How can I accurately determine the parameters of an ellipse that represents the trajectory of an object in space using initial condition values (r0, v0, deltat, and mu)?

Question

How can I accurately determine the parameters of an ellipse that represents the trajectory of an object in space using initial condition values (r0, v0, deltat, and mu)?

In my current game project, I'm developing a primary user interface that displays the solar system from a top-down perspective (with Earth's north pole as 'up'). One of the challenges I faced was creating a semi-realistic path for an object traveling between planets. To tackle this, I've been using Lambert's problem to calculate the initial velocity vector for the object, and the results have been promising for the game.

After spending a few weeks on this issue, I even turned to ChatGPT-4 for assistance with the complex math involved. While I made progress at times, I struggled to arrive at the correct solution consistently.

One recurring issue I encountered was obtaining negative values for the a parameter (semi-major-axis of the ellipse), which shouldn't be the case.

I suspected one reason for this discrepancy could be the disparity in coordinate systems used in my game (left-handed) versus traditional mathematical calculations (right-handed). In order to address this, I inverted the y-values during vector calculations and ensured proper inversion for screen display. I also experimented with reversing the entire coordinate system, but the outcomes were similar.

Below is the TypeScript implementation of the logic responsible for generating the current elliptical path:

Following multiple iterations of custom Lambert problem solvers and aided by AI, I opted to utilize the lambert-orbit package, which provided the functionality I required along with additional useful features.

Furthermore, here is an excerpt from my vector class implementation:

For instance, when passing the given parameters to the generatePath method, the resulting data includes a velocity vector and various calculated values like the semi-major axis and the second foci point.

A visual representation of the computed ellipse shows discrepancies in intersecting the designated locations correctly, prompting reflections on possible causes and adjustments needed.

The journey to achieving accurate orbital paths continues as ongoing tests and observations shed light on potential solutions to refine the game's trajectory simulation.

typescript vector game-physics space

Answer 1

Answer №1

I have finally discovered the solution that I have been searching for!

While exploring, I stumbled upon a detailed graphic depicting the visualization of an ellipse.

https://i.sstatic.net/LhF7O.png

Using this visualization, I was able to craft a code snippet that helped me determine the two potential locations for the second focus point. This involved creating circles representing 2a - r and 2a - r0 around their respective points and identifying the intersection points as my focal points.

Below is the code snippet:

private static circleCircleIntersection(
    c1: Vector,
    r1: number,
    c2: Vector,
    r2: number
  ): [Vector, Vector] | null {
    const d = c2.subtract(c1).magnitude();
    if (d > r1 + r2 || d < Math.abs(r1 - r2)) {
      return null;
    }

    const a = (r1 * r1 - r2 * r2 + d * d) / (2 * d);
    const h = Math.sqrt(r1 * r1 - a * a);
    const p = c1.add(c2.subtract(c1).normalize().multiply(a));

    const x1 = p.x + (h * (c2.y - c1.y)) / d;
    const y1 = p.y - (h * (c2.x - c1.x)) / d;

    const x2 = p.x - (h * (c2.y - c1.y)) / d;
    const y2 = p.y + (h * (c2.x - c1.x)) / d;

    return [new Vector(x1, y1), new Vector(x2, y2)];
  }

By utilizing this code, I was able to identify the required ellipses accurately. Notably, it aligned perfectly with the initial velocity vector, further solidifying its relevance to my problem at hand.

https://i.sstatic.net/itnhZ.png

Answer 2

I have finally discovered the solution that I have been searching for!

While exploring, I stumbled upon a detailed graphic depicting the visualization of an ellipse.

https://i.sstatic.net/LhF7O.png

Using this visualization, I was able to craft a code snippet that helped me determine the two potential locations for the second focus point. This involved creating circles representing 2a - r and 2a - r0 around their respective points and identifying the intersection points as my focal points.

Below is the code snippet:

private static circleCircleIntersection(
    c1: Vector,
    r1: number,
    c2: Vector,
    r2: number
  ): [Vector, Vector] | null {
    const d = c2.subtract(c1).magnitude();
    if (d > r1 + r2 || d < Math.abs(r1 - r2)) {
      return null;
    }

    const a = (r1 * r1 - r2 * r2 + d * d) / (2 * d);
    const h = Math.sqrt(r1 * r1 - a * a);
    const p = c1.add(c2.subtract(c1).normalize().multiply(a));

    const x1 = p.x + (h * (c2.y - c1.y)) / d;
    const y1 = p.y - (h * (c2.x - c1.x)) / d;

    const x2 = p.x - (h * (c2.y - c1.y)) / d;
    const y2 = p.y + (h * (c2.x - c1.x)) / d;

    return [new Vector(x1, y1), new Vector(x2, y2)];
  }

By utilizing this code, I was able to identify the required ellipses accurately. Notably, it aligned perfectly with the initial velocity vector, further solidifying its relevance to my problem at hand.

https://i.sstatic.net/itnhZ.png

How can I accurately determine the parameters of an ellipse that represents the trajectory of an object in space using initial condition values (r0, v0, deltat, and mu)?

Answer №1

Similar questions

Ways to define a static variable within a function using Typescript

Exploring the Power of DataList in Angular

I have integrated React Hook Form with Typescript, where the input data is not being accepted by the string datatype

Ways to verify if an array contains elements from other arrays in Typescript

Issue with decompressing the identical data using zlib (Z_BUF_ERROR)

Guide on creating an interface for a JSON object with an array of custom functions

The TypeScript compilation is not able to find index.ts at the moment

Is it possible to specify the version of a dependency using Stackblitz?

Navigating images within Typescript - NextJS operations

Generating a new Observable from a callback function

Tips on extracting the value from an observable and storing it in a variable

Tips for Implementing Error Handling in Angular using Sweetalert2

"How can we trigger a re-render of a React component once a promise is fulfilled? Is there a way to prevent rendering until the

Tips for scrolling ion-items vertically to the bottom and top using arrow icons in Ionic 4

What is the correct way to employ async/await in combination with Array.filter within a React application?

The most effective approach to creating linked observable subscriptions

Guide to initializing the state in pinia with Typescript

Angular2 authguards encountering issues when trying to run asynchronous functions

Where can one find Typescript definitions when using typings?

Angular auto-suggest components in material design