@turf/line-arc: always reach bearing2 (fix dropped final vertex) (#3078)

The arc was generated with `while (alpha <= arcEndDegree)`, advancing
`alpha = arcStartDegree + i * arcStep`. For some bearing/step
combinations this accumulated angle overshoots `arcEndDegree` by a
floating-point epsilon on the final iteration (e.g. `0 + 7 * (29 / 7)`
=== `29.000000000000004`), so the loop exits one step early.

The result was an arc with `steps` vertices instead of the documented
`steps + 1`, ending a full `arcStep` short of `bearing2`
(e.g. `lineArc(center, 5, 0, 29, { steps: 7 })` stopped at ~24.857°
instead of 29°).

Iterate a fixed `steps + 1` times and pin the last vertex to
`arcEndDegree` so the arc always ends exactly on `bearing2`. Behaviour is
unchanged for inputs that did not trigger the rounding overshoot.

Co-authored-by: mfedderly <24275386+mfedderly@users.noreply.github.com>

Author: chatman-media

packages/turf-line-arc/index.ts

@@ -57,19 +57,21 @@ function lineArc(
   const arcStartDegree = angle1;
   const arcEndDegree = angle1 < angle2 ? angle2 : angle2 + 360;
 
-  let alpha = arcStartDegree;
   const coordinates = [];
-  let i = 0;
   // How many degrees we'll swing around between each step.
   const arcStep = (arcEndDegree - arcStartDegree) / steps;
-  // Add coords to the list, increasing the angle from our start bearing
-  // (alpha) by arcStep degrees until we reach the end bearing.
-  while (alpha <= arcEndDegree) {
+  // Add coords to the list, increasing the angle from our start bearing by
+  // arcStep degrees until we reach the end bearing. Iterate a fixed number of
+  // times (steps + 1 vertices) rather than comparing an accumulated angle
+  // against arcEndDegree: floating-point drift in arcStartDegree + i * arcStep
+  // could make the final value exceed arcEndDegree (e.g. 29.000000000000004),
+  // dropping the last vertex so the arc never reached bearing2. Pin the last
+  // vertex to arcEndDegree so the arc always ends exactly on bearing2.
+  for (let i = 0; i <= steps; i++) {
+    const alpha = i === steps ? arcEndDegree : arcStartDegree + i * arcStep;
     coordinates.push(
       destination(center, radius, alpha, options).geometry.coordinates
     );
-    i++;
-    alpha = arcStartDegree + i * arcStep;
   }
   return lineString(coordinates, properties);
 }

packages/turf-line-arc/package.json

@@ -3,6 +3,9 @@
   "version": "7.3.5",
   "description": "Creates a circular arc, of a circle of the given radius and center point, between two bearings.",
   "author": "Turf Authors",
+  "contributors": [
+    "Alexander Kireev <@chatman-media>"
+  ],
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/Turfjs/turf/issues"

packages/turf-line-arc/test.ts

@@ -5,6 +5,7 @@ import { fileURLToPath } from "url";
 import { loadJsonFileSync } from "load-json-file";
 import { writeJsonFileSync } from "write-json-file";
 import { truncate } from "@turf/truncate";
+import { destination } from "@turf/destination";
 import { featureCollection, point } from "@turf/helpers";
 import { lineArc } from "./index.js";
 
@@ -79,3 +80,27 @@ test("turf-line-arc #2446", (t) => {
 
   t.end();
 });
+
+test("turf-line-arc -- reaches bearing2 despite floating-point drift", (t) => {
+  // For some bearing/step combinations arcStartDegree + steps * arcStep
+  // overshoots arcEndDegree by a rounding epsilon (e.g. 0 + 7 * (29 / 7) ===
+  // 29.000000000000004 > 29). The old `while (alpha <= arcEndDegree)` loop then
+  // dropped the final vertex, returning `steps` points instead of `steps + 1`
+  // and ending the arc a full step short of bearing2.
+  const center = point([-75, 40]);
+  const arc = lineArc(center, 5, 0, 29, { steps: 7 });
+  const coords = arc.geometry.coordinates;
+
+  t.equals(coords.length, 7 + 1, "arc has steps + 1 vertices");
+
+  // The final vertex must sit on bearing2 (29°). destination(center, r, 29)
+  // gives the reference coordinate; the old code stopped at bearing ~24.857°.
+  const expectedLast = destination(center, 5, 29).geometry.coordinates;
+  t.deepEquals(
+    truncate(point(coords[coords.length - 1])).geometry.coordinates,
+    truncate(point(expectedLast)).geometry.coordinates,
+    "last vertex lies on bearing2"
+  );
+
+  t.end();
+});