Draw an arc of an ellipse

Question

I've been struggling with this for some months: I need to output an array of points for an arc segment for an ellipse, I'm attempting to draw segments of Kepler orbits, i.e. similar to KSP ship maneuvers. I found this paper which describes drawing ellipses with a fixed number of points and also has more points around the ends of the ellipse than the sides which is almost perfect for my needs: https://doi.org/10.1093/comjnl/14.1.81 However I need to:

• Rotate/tilt around a focal point of the ellipse rather than the center, I have solved that elsewhere.
• Draw just an arc segment starting from a given angle and either ending at a given angle or of an arc size.

Here is a link to C# code of the original function from the paper: https://gist.github.com/se5a/1135132f0f2d8d84770ca960405b9e41

I was able to solve the rotation/tilt by doing a matrix move and rotate on the resulting output rather than tilting as the original has it, if there's a more efficient way to do this I'd like to know.

The arc problem has gotten me completely stumped however. I think the number of points given as input should still be the whole ellipse, but I'll likely need to have extra points at the arc start and arc end, which is fine. idealy the arc start and end would be the true anomaly (ie focal point origin angle from the periapsis ) though I should be able to figure out from a center point origin solution.

Apologies if this should have gone on stackoverflow, I always seem to get in trouble because I cant figure out which one it's supposed to go in.

Answer 1

The polar coordinates of an ellipse drawn from one of the focci is

$$ r(\theta) = \frac{a\, (1-\epsilon^2)}{1+\epsilon\,\cos \theta} $$

where $a$ is the semi-major axis, $b$ the semi-minor axus and $\epsilon = \sqrt{1-(b/a)^2}$ is the eccentricity.

To rotate the ellipse, add a phase to the angle $\theta$.

To draw a segment, limit $\theta$ to something less than $\theta = 0 \ldots 2\pi$.

To draw points, just enter the angle values you want points for.

---

I have made an example C# WinForms Gist that uses the built-in System.Numerics.Vector2 objects to define the geometry of objects. File Geometry.cs contains the routines that defined the points on the ellipse. File Gdi.cs contains the extension methods to draw various things on a System.Drawing.Graphics object, but using Vector2 for model-based coordinates instead of PointF pixel-based coordinates. Objects are drawn from the center of the form, and with some specified scale to convert between model coordinates and pixels.

The visual result is:

The code that draws the ellipse, the arrow and the points calls a function GetPointsOnEllipseArc() to produce the points on the ellipse.

Care must be taken because all drawing routines in Gdi.cs accept angles in degrees, and the geometry routines in Geometry.cs accept angles in radians.

Here is the drawing code inside the form

protected override void OnPaint(PaintEventArgs e)
{
    base.OnPaint(e);
e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
e.Graphics.TranslateTransform(ClientSize.Width / 2, ClientSize.Height / 2);
float scale = 20;

Gdi.Stroke.Color = Color.Black;
Gdi.Stroke.DashStyle = DashStyle.Dash;
Vector2 center = Vector2.Zero;
float semiMajor = 5f, semiMinor = 3f;
float tiltAngle = 15;
e.Graphics.DrawEllipse(scale, center, semiMajor, semiMinor, tiltAngle);
Gdi.Stroke.DashStyle = DashStyle.Solid;

Gdi.Stroke.AddEndArrow(4f);
Gdi.Stroke.Color = Color.Red;
float factor = 4 / 3f;
e.Graphics.DrawEllipseArc(scale, center, factor*semiMajor, factor*semiMinor, 0, 20, tiltAngle);
Gdi.Stroke.RemoveEndArrow();

float focusDistance = (float)Math.Sqrt(semiMajor * semiMajor - semiMinor * semiMinor);
Vector2 focus = center + new Vector2(focusDistance * (float)Math.Cos(tiltAngle*Geometry.deg), focusDistance * (float)Math.Sin(tiltAngle*Geometry.deg));
Gdi.Fill.Color = Color.Black;
e.Graphics.FillPoint(scale, focus);
Gdi.Stroke.Color = Color.Purple;
var points = Geometry.GetPointsOnEllipseArc(focus, semiMajor, semiMinor, 24, 0, 180 * Geometry.deg, tiltAngle * Geometry.deg);
foreach (var point in points)
{
    e.Graphics.DrawPoint(scale, point);
}

}

Notice the manual calculation of the focus point, and the calling of Geometry.GetPointsOnEllipseArc() to return the list of points on the ellipse. This uses the polar equation shown above.

/// <summary>
/// Gets points on an ellipse arc (partial ellipse).
/// </summary>
/// <remarks>
/// The points are drawn from the focus of the ellipse and are spaced
/// by equal angles in polar coordinates.
/// </remarks>
/// <param name="focus">The focus point of the ellipse.</param>
/// <param name="semiMajor">The semi-major axis.</param>
/// <param name="semiMinor">The semi-minor axis.</param>
/// <param name="numPoints">The number points.</param>
/// <param name="azimuthOffset">The azimuth offset angle in radians, CCW.</param>
/// <param name="azimuthSweep">The azimuth sweep angle in radians, CCW.</param>
/// <param name="tiltAngle">The tilt angle in radians, CCW from horizontal.</param>
/// <returns>An array of <see cref="Vector2"/> points.</returns>
static public Vector2[] GetPointsOnEllipseArc(Vector2 focus, float semiMajor, float semiMinor, int numPoints, float azimuthOffset, float azimuthSweep, float tiltAngle = 0)
{
    float e = (float)Math.Sqrt(1 - (semiMinor / semiMajor) * (semiMinor / semiMajor));
float Δθ = azimuthSweep / (numPoints - 1);
float ct = (float)Math.Cos(tiltAngle), st = (float)Math.Sin(tiltAngle);

Vector2[] points = new Vector2[numPoints];
for (int i = 0; i &lt; numPoints; i++)
{
    // get azimuth angle along the ellipse
    float θ = azimuthOffset + i * Δθ;
    // get polar coordinate of ellipse r(θ)
    float r = semiMajor * (1 - e * e) /(float)(1 + e * Math.Cos(θ));
    // get axis aligned (x,y) point from foci
    float x = r * (float)Math.Cos(θ), y = r * (float)Math.Sin(θ);
    // get rotated (x,y) point
    Vector2 localPoint = new Vector2(ct * x - st * y, st * x + ct * y);
    points[i] = focus + localPoint;
}

return points;

}