@math.gl/geospatial 5.0.0-alpha.19 → 5.0.0-alpha.20

package/src/projection/experimental/kernels/stere.ts

@@ -1,9 +1,12 @@
 // math.gl
 // SPDX-License-Identifier: MIT
 // SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
-// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0. See ../../../PROJ4-LICENSE.md for the upstream license and attribution.
+// SPDX-FileCopyrightText: Copyright (c) PROJ contributors
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original math.gl inverse Cartesian rotation correction. Adapted from proj4js 2.22.0, with polar half-angle equations from PROJ 9.5.1 src/projections/stere.cpp. See ../../../../projection/PROJ-LICENSE.txt. See ../../../../projection/PROJ4-LICENSE.md for the upstream license and attribution.
 
 import type {KernelParameters, Point} from '../kernel';
+import {inverseSphericalLatitude} from '../inverse-spherical-latitude';
 export type State = KernelParameters & {
   coslat0: number;
   sinlat0: number;
@@ -90,6 +93,15 @@ export function forward(state: State, p: Point): Point | null | undefined | numb
     p.y = NaN;
     return p;
   }
+  if (state.sphere && Math.abs(state.coslat0) <= EPSLN) {
+    // PROJ's polar half-angle form avoids subtracting nearly equal values in
+    // 1 +/- sin(latitude) close to the opposite pole.
+    const sign = state.lat0 > 0 ? 1 : -1;
+    const radius = 2 * state.a * state.k0 * Math.tan(Math.PI / 4 - (sign * lat) / 2);
+    p.x = state.x0 + radius * Math.sin(dlon);
+    p.y = state.y0 - sign * radius * Math.cos(dlon);
+    return p;
+  }
   if (state.sphere) {
     // trace('stere:sphere case');
     A = (2 * state.k0) / (1 + state.sinlat0 * sinlat + state.coslat0 * coslat * Math.cos(dlon));
@@ -143,7 +155,15 @@ export function inverse(state: State, p: Point): Point | null | undefined | numb
       p.y = lat;
       return p;
     }
-    lat = Math.asin(Math.cos(c) * state.sinlat0 + (p.y * Math.sin(c) * state.coslat0) / rh);
+    lat = inverseSphericalLatitude(
+      state.sinlat0,
+      state.coslat0,
+      Math.sin(c),
+      Math.cos(c),
+      p.x,
+      p.y,
+      rh
+    );
     if (Math.abs(state.coslat0) < EPSLN) {
       if (state.lat0 > 0) {
         lon = adjust_lon(state.long0 + Math.atan2(p.x, -1 * p.y), state.over);
@@ -184,7 +204,15 @@ export function inverse(state: State, p: Point): Point | null | undefined | numb
       if (rh <= EPSLN) {
         Chi = state.X0;
       } else {
-        Chi = Math.asin(Math.cos(ce) * state.sinX0 + (p.y * Math.sin(ce) * state.cosX0) / rh);
+        Chi = inverseSphericalLatitude(
+          state.sinX0,
+          state.cosX0,
+          Math.sin(ce),
+          Math.cos(ce),
+          p.x,
+          p.y,
+          rh
+        );
         lon = adjust_lon(
           state.long0 +
             Math.atan2(

package/src/projection/experimental/kernels/sterea.ts

@@ -1,9 +1,11 @@
 // math.gl
 // SPDX-License-Identifier: MIT
 // SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
-// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0. See ../../../PROJ4-LICENSE.md for the upstream license and attribution.
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original math.gl inverse Cartesian rotation correction. Direct TypeScript port of proj4js 2.22.0. See ../../../../projection/PROJ4-LICENSE.md for the upstream license and attribution.
 
 import type {KernelParameters, Point} from '../kernel';
+import {inverseSphericalLatitude} from '../inverse-spherical-latitude';
 export type State = GaussState & {
   sinc0: number;
   cosc0: number;
@@ -54,7 +56,7 @@ export function inverse(state: State, p: Point): Point | null | undefined | numb
     var c = 2 * Math.atan2(rho, state.R2);
     sinc = Math.sin(c);
     cosc = Math.cos(c);
-    lat = Math.asin(cosc * state.sinc0 + (p.y * sinc * state.cosc0) / rho);
+    lat = inverseSphericalLatitude(state.sinc0, state.cosc0, sinc, cosc, p.x, p.y, rho);
     lon = Math.atan2(p.x * sinc, rho * state.cosc0 * cosc - p.y * state.sinc0 * sinc);
   } else {
     lat = state.phic0;

package/src/projection/experimental/kernels/tmerc.ts

@@ -1,7 +1,7 @@
 // math.gl
 // SPDX-License-Identifier: MIT
 // SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
-// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0. See ../../../PROJ4-LICENSE.md for the upstream license and attribution.
+// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0. See ../../../../projection/PROJ4-LICENSE.md for the upstream license and attribution.
 
 import type {KernelParameters, Point} from '../kernel';
 export type State = KernelParameters & {

package/src/projection/experimental/kernels/tpers.ts

@@ -1,7 +1,7 @@
 // math.gl
 // SPDX-License-Identifier: MIT
 // SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
-// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0, modified to keep inverse temporary coordinates in local numbers. See ../../../PROJ4-LICENSE.md for the upstream license and attribution.
+// SPDX-FileComment: Direct TypeScript port of proj4js 2.22.0, modified to keep inverse temporary coordinates in local numbers. See ../../../../projection/PROJ4-LICENSE.md for the upstream license and attribution.
 
 import type {KernelParameters, Point} from '../kernel';
 export type State = KernelParameters & {

package/src/projection/experimental/kernels/vandg.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
-// SPDX-FileComment: Cancellation-resistant rationalization of forward/inverse numerators is original math.gl code. Remaining equations ported from of proj4js 2.22.0. See ../../../PROJ4-LICENSE.md for the upstream license and attribution.
+// SPDX-FileComment: Cancellation-resistant rationalization of forward/inverse numerators is original math.gl code. Remaining equations ported from of proj4js 2.22.0. See ../../../../projection/PROJ4-LICENSE.md for the upstream license and attribution.
 
 import type {KernelParameters, Point} from '../kernel';
 export type State = KernelParameters & {

package/src/projection/experimental/kinematic-helmert-flat.ts

@@ -3,7 +3,7 @@
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 // SPDX-FileCopyrightText: Copyright (c) 2016, Thomas Knudsen / SDFE (PROJ)
 // SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
-// SPDX-FileComment: Original numeric-buffer traversal around kinematic-helmert.ts's existing attributed equations and prepared coefficients. Exact matrix application follows the PROJ adaptation; small-angle matrix application follows the proj4js adaptation. See ../../PROJ-LICENSE.txt and ../../PROJ4-LICENSE.md. No model data is included.
+// SPDX-FileComment: Original numeric-buffer traversal around kinematic-helmert.ts's existing attributed equations and prepared coefficients. Exact matrix application follows the PROJ adaptation; small-angle matrix application follows the proj4js adaptation. See ../../../projection/PROJ-LICENSE.txt and ../../../projection/PROJ4-LICENSE.md. No model data is included.
 import type {NumericFlatOperation} from './numeric-flat';
 
 /** Borrow the stage's owned coefficients, with exactly the scalar epoch preparation. */

package/src/projection/experimental/kinematic-helmert.ts

@@ -3,7 +3,7 @@
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 // SPDX-FileCopyrightText: Copyright (c) 2016, Thomas Knudsen / SDFE (PROJ)
 // SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
-// SPDX-FileComment: Original epoch propagation follows PROJ's kinematic Helmert contract. Exact matrix/convention transpose adapted from PROJ 9.5.1 helmert.cpp. See ../../PROJ-LICENSE.txt. Small-angle equations follow the attributed proj4js adaptation in datum.ts. See ../../PROJ4-LICENSE.md for the small-angle adaptation license.
+// SPDX-FileComment: Original epoch propagation follows PROJ's kinematic Helmert contract. Exact matrix/convention transpose adapted from PROJ 9.5.1 helmert.cpp. See ../../../projection/PROJ-LICENSE.txt. Small-angle equations follow the attributed proj4js adaptation in datum.ts. See ../../../projection/PROJ4-LICENSE.md for the small-angle adaptation license.
 import {createKinematicHelmertFlat} from './kinematic-helmert-flat';
 import type {NumericFlatOperation} from './numeric-flat';
 import type {ProjectionPoint} from './types';

package/src/projection/experimental/projection-pipeline.ts

@@ -1,7 +1,7 @@
 // math.gl
 // SPDX-License-Identifier: MIT
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
-// SPDX-FileComment: Original typed orchestration inspired by PROJ's explicit pipeline model. Projection, geocentric and static Helmert equations reuse the proj4js adaptations in this package; see datum.ts and ../../PROJ4-LICENSE.md. The separate exact Helmert matrix is adapted from PROJ; see exact-helmert.ts and ../../PROJ-LICENSE.txt.
+// SPDX-FileComment: Original typed orchestration inspired by PROJ's explicit pipeline model. Projection, geocentric and static Helmert equations reuse the proj4js adaptations in this package; see datum.ts and ../../../projection/PROJ4-LICENSE.md. The separate exact Helmert matrix is adapted from PROJ; see exact-helmert.ts and ../../../projection/PROJ-LICENSE.txt.
 import type {DeformationModel} from './deformation';
 import {CORE_PARAMETERS, normalizeCRS} from './crs/normalize';
 import {unsupportedStage} from './crs/types';

package/src/projection/experimental/projections/gnom.ts

@@ -3,7 +3,10 @@
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 // SPDX-FileComment: Original plugin adapter for the numerical kernel directly ported from proj4js 2.22.0.
 import {withAngularRenderingProfile} from '../rendering-profile/angular-rendering-profile';
-import {sphericalAzimuthalBounds} from '../rendering-profile/azimuthal-rendering-bounds';
+import {
+  sphericalAzimuthalBounds,
+  ellipsoidalGnomonicBounds
+} from '../rendering-profile/azimuthal-rendering-bounds';
 import type {ProjectionPlugin} from '../types';
 import {
   catalogueParameters,
@@ -23,12 +26,26 @@ export const gnomonic: ProjectionPlugin = {
     const state = createState(base);
     // Keep the rendering boundary finite without restricting raw conversion.
     return withAngularRenderingProfile(
-      bindCatalogueKernel('gnom', context, state, forward, inverse, horizonGuard(base)),
+      bindCatalogueKernel(
+        'gnom',
+        context,
+        state,
+        forward,
+        inverse,
+        base.sphere ? horizonGuard(base) : undefined
+      ),
       base,
-      (Math.PI * 80) / 180,
+      Math.min((Math.PI * 80) / 180, (1 - base.es) * Math.PI * 0.45),
       (region, domain) =>
-        sphericalAzimuthalBounds(catalogueBoundsParameters(base, context), region, domain, 'gnom'),
-      Math.PI / 2
+        base.sphere
+          ? sphericalAzimuthalBounds(
+              catalogueBoundsParameters(base, context),
+              region,
+              domain,
+              'gnom'
+            )
+          : ellipsoidalGnomonicBounds(catalogueBoundsParameters(base, context), region, domain),
+      ((1 - base.es) * Math.PI) / 2
     );
   }
 };

package/src/projection/experimental/projections/laea.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
 
-import qsfnz from '../common/qsfnz';
+import {authalicLatitude} from '../authalic-latitude';
 import {withAngularRenderingProfile} from '../rendering-profile/angular-rendering-profile';
 import {equalAreaAzimuthalBounds} from '../rendering-profile/azimuthal-rendering-bounds';
 import type {ProjectionPlugin} from '../types';
@@ -29,10 +29,10 @@ export const lambertAzimuthalEqualArea: ProjectionPlugin = {
           base.sphere ? 1 : state.ymf || Math.sqrt(state.qp / 2),
           region,
           domain,
-          base.sphere ? base.lat0 : Math.asin(qsfnz(base.e, Math.sin(base.lat0)) / state.qp),
+          base.sphere ? base.lat0 : authalicLatitude(base.e, state.qp, base.lat0),
           base.sphere
             ? latitude => latitude
-            : latitude => Math.asin(qsfnz(base.e, Math.sin(latitude)) / state.qp)
+            : latitude => authalicLatitude(base.e, state.qp, latitude)
         )
     );
   }

package/src/projection/experimental/projections/ob-tran.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
-// SPDX-FileComment: Rotation equations directly ported from proj4js 2.22.0 lib/projections/ob_tran.js. See ../../../PROJ4-LICENSE.md. Modified to use an explicitly supplied plugin instead of proj4js's global registry.
+// SPDX-FileComment: Rotation equations directly ported from proj4js 2.22.0 lib/projections/ob_tran.js. See ../../../../projection/PROJ4-LICENSE.md. Modified to use an explicitly supplied plugin instead of proj4js's global registry.
 import type {
   ProjectionPlugin,
   ProjectionParameters,

package/src/projection/experimental/projections/ortho.ts

@@ -1,9 +1,9 @@
 // math.gl
 // SPDX-License-Identifier: MIT
 // SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
-// SPDX-FileComment: Original plugin adapter for the numerical kernel directly ported from proj4js 2.22.0.
+// SPDX-FileComment: Original plugin adapter for the ellipsoidal orthographic kernel.
 import {withAngularRenderingProfile} from '../rendering-profile/angular-rendering-profile';
-import {sphericalAzimuthalBounds} from '../rendering-profile/azimuthal-rendering-bounds';
+import {orthographicBounds} from '../rendering-profile/azimuthal-rendering-bounds';
 import type {ProjectionPlugin} from '../types';
 import {
   catalogueParameters,
@@ -16,7 +16,7 @@ import {createState, forward, inverse} from '../kernels/ortho';
 export const orthographic: ProjectionPlugin = {
   name: 'ortho',
   aliases: [],
-  parameters: ['lon_0', 'x_0', 'y_0', 'lat_0'],
+  parameters: ['lon_0', 'x_0', 'y_0', 'lat_0', 'k', 'k_0'],
   create(context) {
     const base = catalogueParameters(context);
 
@@ -27,7 +27,7 @@ export const orthographic: ProjectionPlugin = {
       base,
       Math.PI / 2,
       (region, domain) =>
-        sphericalAzimuthalBounds(catalogueBoundsParameters(base, context), region, domain, 'ortho'),
+        orthographicBounds(catalogueBoundsParameters(base, context), region, domain),
       Math.PI / 2
     );
   }

package/src/projection/experimental/rendering-profile/azimuthal-rendering-bounds.ts

@@ -6,8 +6,8 @@ import type {KernelParameters} from '../kernel';
 import {createAngularRanges} from './geographic-bounds';
 import type {AngularRanges} from './geographic-bounds';
 import type {Vector, AngularDomain} from './spherical-rendering-domain';
-import {sphericalRange, sphericalRatioRange} from './spherical-rendering-domain';
-import {envelope, scale, add} from './rendering-bounds';
+import {sphericalExtremum, sphericalRange, sphericalRatioRange} from './spherical-rendering-domain';
+import {envelope, scale, add, multiply, ordered} from './rendering-bounds';
 
 /** Exact extrema for spherical orthographic and linear-fractional azimuthal maps. */
 export function sphericalAzimuthalBounds(
@@ -31,6 +31,56 @@ export function sphericalAzimuthalBounds(
   );
 }
 
+/** Enclose ellipsoidal orthographic ECEF components over the visible region. */
+export function orthographicBounds(
+  base: KernelParameters,
+  parameters: AngularRanges,
+  domain?: AngularDomain
+) {
+  const sin0 = Math.sin(base.lat0);
+  const cos0 = Math.cos(base.lat0);
+  const latitudeSin = sphericalRange([0, 0, 1], parameters, domain);
+  if (Math.abs(sin0) < 1e-15 && (!domain || Math.abs(domain.distance - Math.PI / 2) < 1e-15)) {
+    // On an equatorial hemisphere, visibility restricts longitude only. The
+    // parallel radius decreases with |latitude|, so x has the same extremizers
+    // as its spherical counterpart; ellipsoidal northing is monotone in sin(phi).
+    const x = (maximize: boolean) => {
+      const extremum = sphericalExtremum([0, 1, 0], parameters, domain, maximize);
+      return extremum.value / Math.sqrt(1 - base.es * Math.sin(extremum.point[1]) ** 2);
+    };
+    const y = (sin: number) => ((1 - base.es) * sin) / Math.sqrt(1 - base.es * sin * sin);
+    return envelope(
+      add([base.x0, base.x0], scale([x(false), x(true)], base.a * base.k0)),
+      add([base.y0, base.y0], scale([y(latitudeSin[0]), y(latitudeSin[1])], base.a * base.k0))
+    );
+  }
+
+  const squareMin =
+    latitudeSin[0] <= 0 && latitudeSin[1] >= 0
+      ? 0
+      : Math.min(latitudeSin[0] ** 2, latitudeSin[1] ** 2);
+  const squareMax = Math.max(latitudeSin[0] ** 2, latitudeSin[1] ** 2);
+  const nu = ordered(
+    1 / Math.sqrt(1 - base.es * squareMin),
+    1 / Math.sqrt(1 - base.es * squareMax)
+  );
+  const factor = base.a * base.k0;
+  const yShift = (base.es * sin0 * cos0) / Math.sqrt(1 - base.es * sin0 * sin0);
+  return envelope(
+    add(
+      [base.x0, base.x0],
+      scale(multiply(sphericalRange([0, 1, 0], parameters, domain), nu), factor)
+    ),
+    add(
+      [base.y0 + factor * yShift, base.y0 + factor * yShift],
+      scale(
+        multiply(sphericalRange([-sin0, 0, (1 - base.es) * cos0], parameters, domain), nu),
+        factor
+      )
+    )
+  );
+}
+
 /** The ellipsoid's maximum curvature radius bounds the shortest geodesic length. */
 export function equidistantAzimuthalBounds(
   base: KernelParameters,
@@ -179,3 +229,23 @@ export function perspectiveBounds(
     add([base.y0, base.y0], scale(y, base.a * (p - 1)))
   );
 }
+
+/** Gaussian curvature K <= 1/b² gives M >= cos(s/b), while m <= s.
+ * The geodetic spherical path bounds distance by a*angle/sqrt(1-es).
+ * This disk conservatively encloses m/M on the finite rendering cap.
+ */
+export function ellipsoidalGnomonicBounds(
+  base: KernelParameters,
+  region: AngularRanges,
+  domain?: AngularDomain
+) {
+  const dot = sphericalRange([Math.cos(base.lat0), 0, Math.sin(base.lat0)], region, domain)[0];
+  const angle = Math.acos(Math.max(-1, Math.min(1, dot)));
+  const q = 1 - base.es;
+  const distance = (base.a * angle) / Math.sqrt(q);
+  const scale = Math.cos(angle / q);
+  if (!(scale > 0))
+    throw new Error('Gnomonic rendering coverage approaches its ellipsoidal horizon');
+  const radius = distance / scale;
+  return envelope([base.x0 - radius, base.x0 + radius], [base.y0 - radius, base.y0 + radius]);
+}

package/src/rhumb-path.ts

@@ -0,0 +1,128 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original distance-parameterized adapter over the attributed math.gl rhumb solver.
+
+import type {NumericArray} from '@math.gl/core/types';
+import {EllipsoidRhumb, type RhumbLine} from './ellipsoid-rhumb';
+import {validateGeographicPosition} from './geodesic-path';
+import {WGS84_RADIUS_X, WGS84_RADIUS_Z} from './constants';
+
+let wgs84: EllipsoidRhumb | undefined;
+function getDefaultRhumb(): EllipsoidRhumb {
+  if (!wgs84)
+    wgs84 = new EllipsoidRhumb({semiMajorAxis: WGS84_RADIUS_X, semiMinorAxis: WGS84_RADIUS_Z});
+  return wgs84;
+}
+
+export type RhumbPathOptions = {
+  rhumb?: EllipsoidRhumb;
+  /** Preserve the supplied endpoint interval, including complete turns. */
+  longitudeMode?: 'shortest' | 'unrolled';
+  /** Whole turns added to the shortest endpoint longitude difference. */
+  longitudeTurns?: number;
+};
+
+/** Constant-bearing endpoint path, in degrees and solver axis units. Height is
+ * linear in surface-distance fraction and does not contribute to length.
+ * Unlike geodesics, rhumbs reject exact poles. Endpoints/options are snapshots.
+ */
+export class RhumbPath {
+  readonly length: number;
+  readonly size: 2 | 3;
+  private readonly first: readonly number[];
+  private readonly last: readonly number[];
+  private readonly line: RhumbLine;
+
+  constructor(start: ArrayLike<number>, end: ArrayLike<number>, options: RhumbPathOptions = {}) {
+    validateGeographicPosition(start);
+    validateGeographicPosition(end);
+    if (start.length !== end.length) throw new RangeError('Rhumb endpoint dimensions must match');
+    const solver = options.rhumb || getDefaultRhumb();
+    if (
+      (options.longitudeMode !== undefined &&
+        !['shortest', 'unrolled'].includes(options.longitudeMode)) ||
+      (options.longitudeMode === 'unrolled' && options.longitudeTurns !== undefined)
+    )
+      throw new RangeError('Choose explicit turns or unrolled endpoint longitudes');
+    let inverse = solver.inverse(start[1], start[0], end[1], end[0], {
+      longitudeTurns: options.longitudeTurns,
+      unrollLongitude: true
+    });
+    if (options.longitudeMode === 'unrolled') {
+      const turns = Math.round((end[0] - inverse.lon2) / 360);
+      if (turns !== 0)
+        inverse = solver.inverse(start[1], start[0], end[1], end[0], {
+          longitudeTurns: turns,
+          unrollLongitude: true
+        });
+    }
+    if (![inverse.s12, inverse.azi12, inverse.lon2].every(Number.isFinite) || inverse.s12 < 0)
+      throw new RangeError('Unresolved rhumb path');
+    this.size = start.length as 2 | 3;
+    this.length = inverse.s12;
+    this.first = Object.freeze(Array.from(start));
+    const last = Array.from(end);
+    const turns = Math.round((inverse.lon2 - end[0]) / 360);
+    const endpoint = end[0] + 360 * turns;
+    const retainsPhase =
+      Number.isSafeInteger(turns) &&
+      Number.isFinite(endpoint) &&
+      Math.abs(endpoint - inverse.lon2) <=
+        4 * Number.EPSILON * Math.max(360, Math.abs(inverse.lon2));
+    last[0] = inverse.s12 === 0 ? start[0] : retainsPhase ? endpoint : inverse.lon2;
+    if (inverse.s12 === 0) last[1] = start[1];
+    this.last = Object.freeze(last);
+    this.line = solver.line(start[1], start[0], inverse.azi12, {unrollLongitude: true});
+  }
+
+  get start(): number[] {
+    return this.first.slice();
+  }
+  get end(): number[] {
+    return this.last.slice();
+  }
+
+  sample(fraction: number): number[];
+  sample<T extends NumericArray>(fraction: number, result: T): T;
+  sample(fraction: number, result: NumericArray = new Array(this.size)): NumericArray {
+    if (!Number.isFinite(fraction) || fraction < 0 || fraction > 1)
+      throw new RangeError('Rhumb fraction must be in [0, 1]');
+    if (
+      result.length !== this.size ||
+      (ArrayBuffer.isView(result) &&
+        !(result instanceof Float32Array) &&
+        !(result instanceof Float64Array))
+    )
+      throw new RangeError('Expected a floating rhumb output with matching dimensions');
+    let longitude = this.first[0],
+      latitude = this.first[1];
+    if (fraction === 1) {
+      longitude = this.last[0];
+      latitude = this.last[1];
+    } else if (fraction !== 0 && this.length !== 0) {
+      const p = this.line.position(this.length * fraction);
+      longitude = p.lon2;
+      latitude = p.lat2;
+    }
+    const height = this.size === 3 ? this.first[2] * (1 - fraction) + this.last[2] * fraction : 0;
+    const values = [longitude, latitude, height];
+    if (
+      !values.every(Number.isFinite) ||
+      (result instanceof Float32Array && !values.every(x => Number.isFinite(Math.fround(x))))
+    )
+      throw new RangeError('Unrepresentable rhumb sample');
+    result[0] = longitude;
+    result[1] = latitude;
+    if (this.size === 3) result[2] = height;
+    return result;
+  }
+
+  sampleByDistance(distance: number): number[];
+  sampleByDistance<T extends NumericArray>(distance: number, result: T): T;
+  sampleByDistance(distance: number, result: NumericArray = new Array(this.size)): NumericArray {
+    if (!Number.isFinite(distance) || distance < 0 || distance > this.length)
+      throw new RangeError('Distance must be within the rhumb path');
+    return this.sample(this.length === 0 ? 0 : distance / this.length, result);
+  }
+}

package/src/rhumb-polygon.ts

@@ -0,0 +1,24 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original rhumb polygon facade over the original rhumb integrals and separately attributed shared GeographicLib polygon transit/reduction rules.
+import {EllipsoidRhumb, validateRhumbPoint} from './ellipsoid-rhumb';
+import type {GeodesicParameters} from './ellipsoid-geodesic';
+import {SurfacePolygon, type SurfacePointOptions} from './ellipsoid-helpers/surface-polygon';
+export type {
+  SurfacePolygonOptions as RhumbPolygonOptions,
+  SurfacePolygonResult as RhumbPolygonResult,
+  SurfacePointOptions as RhumbPointOptions
+} from './ellipsoid-helpers/surface-polygon';
+/** Streaming rhumb polygon/polyline. Extra inverse turns are explicit per point. */
+export class RhumbPolygon extends SurfacePolygon {
+  constructor(parameters: GeodesicParameters, options: {polyline?: boolean} = {}) {
+    super(new EllipsoidRhumb(parameters), options);
+  }
+  override addPoint(latitude: number, longitude: number, options: SurfacePointOptions = {}): this {
+    validateRhumbPoint(latitude, longitude);
+    if (!Number.isSafeInteger(options.longitudeTurns ?? 0))
+      throw new RangeError('Rhumb longitudeTurns must be a safe integer');
+    return super.addPoint(latitude, longitude, options);
+  }
+}

package/src/subdivide-geodesic-polyline.ts

@@ -0,0 +1,74 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original geodesic edge adapter over the shared adaptive polyline subdivision engine.
+
+import {subdividePolyline} from '@math.gl/geometry/polygon';
+import type {SubdividePolylineOptions, SubdividedPolyline} from '@math.gl/geometry/polygon';
+import {GeodesicPath, validateGeographicPosition, type GeodesicPathOptions} from './geodesic-path';
+
+export type SubdivideGeodesicPolylineOptions = Omit<
+  SubdividePolylineOptions,
+  'createEdgeSampler' | 'maxSegmentLength'
+> &
+  GeodesicPathOptions & {
+    /** Positive maximum surface distance per output edge, in solver axis units.
+     * Height is excluded. Infinity by default; sampled target error is still checked.
+     */
+    maxSurfaceDistance?: number;
+  };
+
+/** Adaptively sample shortest endpoint geodesics through a supplied continuous transform.
+ * Geographic source angles are degrees; heights interpolate by surface-distance fraction.
+ * Output longitudes are unrolled across successive edges. No seam splitting, clipping,
+ * rhumb semantics or universal error bound is implied. Original-edge provenance is retained.
+ */
+export function subdivideGeodesicPolyline(
+  input: ArrayLike<number>,
+  options: SubdivideGeodesicPolylineOptions
+): SubdividedPolyline {
+  const {geodesic, size = 2, maxSurfaceDistance = Infinity, ...subdivision} = options;
+  if (
+    (size !== 2 && size !== 3) ||
+    !Number.isSafeInteger(input.length) ||
+    input.length < 0 ||
+    input.length % size !== 0
+  ) {
+    throw new RangeError('Expected packed longitude/latitude[/height] positions');
+  }
+  // Reject size/vertex-limit violations before constructing potentially many line objects.
+  const maxVertices = subdivision.maxVertices ?? 65536;
+  if (
+    !Number.isSafeInteger(maxVertices) ||
+    maxVertices < 1 ||
+    maxVertices > 0xffffffff ||
+    input.length / size > maxVertices
+  ) {
+    throw new RangeError('Invalid or exceeded maxVertices');
+  }
+  if (
+    !(maxSurfaceDistance > 0) ||
+    (maxSurfaceDistance !== Infinity && !Number.isFinite(maxSurfaceDistance))
+  ) {
+    throw new RangeError('maxSurfaceDistance must be positive');
+  }
+  const positions = Array.from(input);
+  for (let i = 0; i < positions.length; i += size)
+    validateGeographicPosition(positions.slice(i, i + size));
+  const paths: GeodesicPath[] = [];
+  for (let i = size; i < positions.length; i += size) {
+    const path = new GeodesicPath(positions.slice(i - size, i), positions.slice(i, i + size), {
+      geodesic
+    });
+    paths.push(path);
+    const end = path.end;
+    for (let component = 0; component < size; component++)
+      positions[i + component] = end[component];
+  }
+  return subdividePolyline(positions, {
+    ...subdivision,
+    size,
+    maxSegmentLength: maxSurfaceDistance,
+    createEdgeSampler: (_start, _end, index) => paths[index]
+  });
+}