Drawing a parabolic arc between two points based on a known projectile angle

Question

I am trying to draw an arc between two points that represents a projectile's path. The angle that the projectile leaves point A at is known, and the X/Y coordinates of both points are known.

I'm trying to figure out the math behind this, and how to draw it up in c#.

Here is my failed attempt, based on some path examples I found

var g = new StreamGeometry();
var xDistance = Math.Abs(pointA.X - pointB.X);
var yDistance = Math.Abs(pointA.Y - pointB.Y);
var angle = 60;
var radiusX = xDistance / angle;
var radiusY = yDistance / angle;

using (var gc = g.Open())
{
    gc.BeginFigure(
        startPoint: pointA,
        isFilled: false,
        isClosed: false);

    gc.ArcTo(
        point: pointB,
        size: new Size(radiusX, radiusY),
        rotationAngle: 0d,
        isLargeArc: false,
        sweepDirection: SweepDirection.Clockwise,
        isStroked: true,
        isSmoothJoin: false);
}

Any help would be greatly appreciated!

Edit #2 (added clarity): For this problem assume that physics play no role (no gravity, velocity, or any outside forces). The projectile is guaranteed to land at point B and move along a parabolic path. The vertex will be halfway between point A and point B on the horizontal axis. The angle that it launches at is the angle up from the ground (horizontal).

So Point A (Ax, Ay) is known. Point B (Bx, By) is known. The angle of departure is known. The X half of the vertex is known (Vx = Abs(Ax - Bx)).

Does this really boil down to needing to figure out the Y coordinate of the vertex?

Answer 1

A body movement subject only to the force of gravity (air resistance is ignored) can be evaluated with the following equations:

DistanceX(t) = dx0 + Vx0·t
DistanceY(t) = dy0 + Vy0·t - g/2·t^2

Where

g      : gravity acceleration (9.8 m/s^2)
dx0    : initial position in the X axis
dy0    : initial position in the Y axis
Vy0    : initial X velocity component (muzzle speed)
Vy0    : initial Y velocity component (muzzle speed)

Well that doesn't seem very helpful, but lets investigate further. Your cannon has a muzzle speed V we can consider constant, so Vx0 and Vy0 can be written as:

Vx0 = V·cos(X)
Vy0 = V·sin(X)

Where X is the angle at which you are shooting. Ok, that seems interesting, we finally have an input that is useful to whoever is shooting the cannon: X. Lets go back to our equations and rewrite them:

DistanceX(t) = dx0 + V·cos(X)·t
DistanceY(t) = dy0 + V·sin(X)·t - g/2·t^2

And now, lets think through what we are trying to do. We want to figure out a way to hit a specific point P. Lets give it coordinates: (A, B). And in order to do that, the projectile has to reach that point in both projections at the same time. We'll call that time T. Ok, lets rewrite our equations again:

A = dx0 + V·cos(X)·T
B = dy0 + V·sin(X)·T - g/2·T^2

Lets get ourselves rid of some unnecessary constants here; if our cannon is located at (0, 0) our equations are now:

A = V·cos(X)·T [1]
B = V·sin(X)·T - g/2·T^2 [2]

From [1] we know that: T = A/(V·cos(X)), so we use that in [2]:

B = V·sin(X)·A/(V·cos(X)) - g/2·A^2/(V^2·cos^2(X))

Or

B = A·tan(X) - g/2·A^2/(V^2*cos^2(X))

And now some trigonometry will tell you that 1/cos^2 = 1 + tan^2 so:

B = A·tan(X) - g/2·A^2/V^2·(1+tan^2(X)) [3]

And now you have quadratic equation in tan(X) you can solve.

DISCLAIMER: typing math is kind of hard, I might have an error in there somewhere, but you should get the idea.

UPDATE The previous approach would allow you to solve the angle X that hits a target P given a muzzle speed V. Based on your comments, the angle X is given, so what you need to figure out is the muzzle speed that will make the projectile hit the target with the specified cannon angle. If it makes you more comfortable, don't think of V as muzzle speed, think of it as a form factor of the parabola you are trying to find.

Solve Vin [3]:

B = A·tan(X) - g/2·A^2/V^2·(1+tan^2(X))

This is a trivial quadratic equation, simply isolate V and take the square root. Obviously the negative root has no physical meaning but it will also do, you can take any of the two solutions. If there is no real number solution for V, it would mean that there is simply no possible shot (or parabola) that reaches P(angle X is too big; imagine you shoot straight up, you'll hit yourself, nothing else).

Now simply eliminate t in the parametrized equations:

x = V·cos(X)·t [4]
y = V·sin(X)·t - g/2·t^2 [5]

From [4] you have t = x/(V·cos(X)). Substitute in [5]:

y = tan(X)·x - g·x^2 /(2·V^2*cos^2(X))

And there is your parabola equation. Draw it and see your shot hit the mark.

I've given it a physical interpretation because I find it easier to follow, but you could change all the names I've written here to purely mathematical terms, it doesn't really matter, at the end of the day its all maths and the parabola is the same, any which way you want to think about it.

Answer 2

Following on from the comments, we need a quadratic Bezier curve. This is defined by 3 points, the start, end, and a control point:

It is defined by the following equation:

We therefore need to find P1 using the given conditions (note that the gravity strength is determined implicitly). For a 2D coordinate we need two constraints / boundary conditions. They are given by:

1. The tangent vector at P0:

   

   We need to match the angle to the horizontal:

   

2. The apex of the curve must be directly below the control point P1:

   

Therefore the vertical coordinate is given by:

[Please let me know if you would like some example code for the above]

---

Now for how to add a quadratic Bezier; thankfully, once you have done the above, it is not too difficult

---

The following method creates the parabolic geometry for the simple symmetric case. The angle is measured in degrees counterclockwise from the horizontal.

public Geometry CreateParabola(double x1, double x2, double y, double angle)
{
    var startPoint = new Point(x1, y);
    var endPoint = new Point(x2, y);

    var controlPoint = new Point(
        0.5 * (x1 + x2),
        y - 0.5 * (x2 - x1) * Math.Tan(angle * Math.PI / 180));

    var geometry = new StreamGeometry();

    using (var context = geometry.Open())
    {
        context.BeginFigure(startPoint, false, false);
        context.QuadraticBezierTo(controlPoint, endPoint, true, false);
    }

    return geometry;
}