Function to generate flight trajectory (list of 3D points, lat, lon, alt)

Question

I am looking to generate some 3D trajectory data for an aircraft simulation. The idea is that the aircraft takes off at some location x and continues to ascend at some average ascent velocity a_v and angle a_theta until it reaches a maximum altitude m_a. The aircraft would then continue at its m_a until it reaches a certain distance d_d from its destination, at which point it will begin its descent at some angle d_theta with an average descent velocity of d_v. Finally, the aircraft lands at destination y.

I would like the function to return a list of 3D points.

I am looking to implement this in either Python (preferred) or C#.

For illustration purposes:

Does anyone know how I can achieve this? Is there perhaps some open source project which does this? I have been looking for a while now, but have not found anything.

So where's the problem? For the diagram you've shown, `cos`, `sin`, `sqrt` and `**2` should be all that you need in addition to `+-*/`. Try to solve the problem in 2D first (as shown) and convert the coordinates to spherical. Also, if you only need a trajectory with 3D points, the velocity should be irrelevant. — Eric Duminil, Aug 01 '17 at 12:25
@meowgoesthedog Well, I suppose if I had the altitudes of airport A and B, then yes. It would be nice to take that into consideration. — pookie, Aug 01 '17 at 12:41
And by the way, you can't specify both `d_d` and `d_theta`; either one is enough to calculate the trajectory for a given `m_a`. — meowgoesthedog, Aug 01 '17 at 12:52

Vincent Cantin · Answer 1 · 2017-08-01T12:29:27.240

I recommend you to solve the problem in 2 independent steps so that the airplane does not pass through the ground :

Calculate the path on the surface of a sphere.
Interpolate the height along this path.

For 1. you can use the spherical interpolation techniques on Quaternions.

Quaternion slerp(Quaternion v0, Quaternion v1, double t) {
    // Only unit quaternions are valid rotations.
    // Normalize to avoid undefined behavior.
    v0.normalize();
    v1.normalize();

    // Compute the cosine of the angle between the two vectors.
    double dot = dot_product(v0, v1);

    const double DOT_THRESHOLD = 0.9995;
    if (fabs(dot) > DOT_THRESHOLD) {
        // If the inputs are too close for comfort, linearly interpolate
        // and normalize the result.

        Quaternion result = v0 + t*(v1 – v0);
        result.normalize();
        return result;
    }

    // If the dot product is negative, the quaternions
    // have opposite handed-ness and slerp won't take
    // the shorter path. Fix by reversing one quaternion.
    if (dot < 0.0f) {
        v1 = -v1;
        dot = -dot;
    }  

    Clamp(dot, -1, 1);           // Robustness: Stay within domain of acos()
    double theta_0 = acos(dot);  // theta_0 = angle between input vectors
    double theta = theta_0*t;    // theta = angle between v0 and result 

    Quaternion v2 = v1 – v0*dot;
    v2.normalize();              // { v0, v2 } is now an orthonormal basis

    return v0*cos(theta) + v2*sin(theta);
}

score 0 · Answer 2 · answered Aug 01 '17 at 12:42

You didn't write any code, so I won't write any either. Python with math package is more than enough to solve this problem.

Required steps:

The plane should fly on a great circle. This means you only need one distance to describe X and Y.
You could place the origin at X and specify Y with a latitude.
Calculate the tangent of the Earth at X, and rotate by a_theta. Find the point where it reaches m_a altitude.
Calculate the tangent of the Earth at Y, and rotate by d_theta. Find the point where it reaches m_a altitude.
Draw an arc between the two previous points, with a radius of EarthRadius + m_a
Every coordinate is known in the 2D of the great circle, you just need to rotate them back to 3D coordinates.

For a list of 3D points, you don't need either a_v, d_v or d_d.

Function to generate flight trajectory (list of 3D points, lat, lon, alt)

2 Answers2