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

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

@@ -0,0 +1,26 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original per-instance scratch pool; recursive hooks receive reusable independent leases.
+import type {ProjectionPoint} from './types';
+
+function createPoint(): ProjectionPoint {
+  return {x: 0, y: 0, z: 0};
+}
+/** Allocate once per observed call depth, rather than once per recursive call. */
+export class ProjectionScratch {
+  readonly point: ProjectionPoint = createPoint();
+  private readonly points: ProjectionPoint[] = [this.point];
+  private active = 0;
+  get depth(): number {
+    return this.active;
+  }
+  acquire(): ProjectionPoint {
+    const index = this.active++;
+    this.points[index] ||= createPoint();
+    return this.points[index];
+  }
+  release(point: ProjectionPoint): void {
+    if (this.active > 0 && this.points[this.active - 1] === point) this.active--;
+  }
+}

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

@@ -0,0 +1,41 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {createFlatProjection} from '../flat-projection';
+import type {ProjectionPlugin} from '../types';
+import {conicBounds} from '../rendering-profile/rendering-bounds';
+import {createAngularRanges} from '../rendering-profile/geographic-bounds';
+import {withRectangleRenderingProfile} from '../rendering-profile/rectangular-rendering-profile';
+import {bindKernel, kernelParameters, ORIGIN_PARAMETERS, validateConic} from '../kernel';
+import {createState, forward, inverse} from '../kernels/aea';
+
+export const albersEqualArea: ProjectionPlugin = {
+  name: 'aea',
+  aliases: ['Albers_Conic_Equal_Area', 'Albers_Equal_Area', 'Albers'],
+  parameters: [...ORIGIN_PARAMETERS, 'lat_1', 'lat_2'],
+  create(context) {
+    const base = kernelParameters(context);
+    validateConic(base, context.parameters);
+    const state = createState(base);
+    const projection = {
+      ...bindKernel('aea', state, forward, inverse, createFlatProjection)
+    };
+    return withRectangleRenderingProfile(
+      projection,
+      createAngularRanges(base.long0 - Math.PI, -Math.PI / 2, base.long0 + Math.PI, Math.PI / 2),
+      ranges =>
+        conicBounds(
+          projection.forward,
+          ranges,
+          base.long0,
+          state.ns0,
+          state.x0,
+          state.y0 + state.rh,
+          base.over
+        ),
+      base.primeMeridian,
+      base.over
+    );
+  }
+};

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

@@ -0,0 +1,27 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {withAngularRenderingProfile} from '../rendering-profile/angular-rendering-profile';
+import {equidistantAzimuthalBounds} from '../rendering-profile/azimuthal-rendering-bounds';
+import type {ProjectionPlugin} from '../types';
+import {bindKernel, guardAzimuthalDomain, kernelParameters, ORIGIN_PARAMETERS} from '../kernel';
+import {createState, forward, inverse} from '../kernels/aeqd';
+
+export const azimuthalEquidistant: ProjectionPlugin = {
+  name: 'aeqd',
+  aliases: ['Azimuthal_Equidistant'],
+  parameters: ORIGIN_PARAMETERS,
+  create(context) {
+    const base = kernelParameters(context);
+
+    const state = createState(base);
+    // Keep the rendering boundary finite without restricting raw conversion.
+    return withAngularRenderingProfile(
+      guardAzimuthalDomain(base, bindKernel('aeqd', state, forward, inverse)),
+      base,
+      (Math.PI * 179) / 180,
+      (region, domain) => equidistantAzimuthalBounds(base, region, domain)
+    );
+  }
+};

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

@@ -0,0 +1,38 @@
+// 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.
+import {bonneBounds} from '../rendering-profile/regional-rendering-bounds';
+import {createAngularRanges} from '../rendering-profile/geographic-bounds';
+import {withRectangleRenderingProfile} from '../rendering-profile/rectangular-rendering-profile';
+import type {ProjectionPlugin} from '../types';
+import {
+  catalogueParameters,
+  catalogueBoundsParameters,
+  bindCatalogueKernel
+} from '../catalogue-kernel';
+import {createState, forward, inverse} from '../kernels/bonne';
+
+export const bonne: ProjectionPlugin = {
+  name: 'bonne',
+  aliases: ['Bonne (Werner lat_1=90)'],
+  parameters: ['lon_0', 'x_0', 'y_0', 'lat_1'],
+  create(context) {
+    const base = catalogueParameters(context);
+    if (
+      !Object.prototype.hasOwnProperty.call(context.parameters, 'lat_1') ||
+      Math.abs(base.lat1) < 1e-10
+    )
+      throw new Error('Bonne requires a nonzero lat_1');
+    const state = createState(base);
+    // The finite world is the rendering target, including both polar limits.
+    const projection = bindCatalogueKernel('bonne', context, state, forward, inverse);
+    return withRectangleRenderingProfile(
+      projection,
+      createAngularRanges(base.long0 - Math.PI, -Math.PI / 2, base.long0 + Math.PI, Math.PI / 2),
+      ranges => bonneBounds(catalogueBoundsParameters(state, context), projection.forward, ranges),
+      base.primeMeridian,
+      base.over
+    );
+  }
+};

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

@@ -0,0 +1,39 @@
+// 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.
+import {cassiniBounds} from '../rendering-profile/regional-rendering-bounds';
+import {createAngularRanges} from '../rendering-profile/geographic-bounds';
+import {withRectangleRenderingProfile} from '../rendering-profile/rectangular-rendering-profile';
+import type {ProjectionPlugin} from '../types';
+import {
+  catalogueParameters,
+  catalogueBoundsParameters,
+  bindCatalogueKernel
+} from '../catalogue-kernel';
+import {createState, forward, inverse} from '../kernels/cass';
+
+export const cassiniSoldner: ProjectionPlugin = {
+  name: 'cass',
+  aliases: ['Cassini', 'Cassini_Soldner'],
+  parameters: ['lon_0', 'x_0', 'y_0', 'lat_0'],
+  create(context) {
+    const base = catalogueParameters(context);
+
+    const state = createState(base);
+    // Use a regional meridian strip; the series is not a global map.
+    const projection = bindCatalogueKernel('cass', context, state, forward, inverse);
+    return withRectangleRenderingProfile(
+      projection,
+      createAngularRanges(
+        base.long0 - Math.PI / 6,
+        -Math.PI / 2 + 1e-8,
+        base.long0 + Math.PI / 6,
+        Math.PI / 2 - 1e-8
+      ),
+      ranges => cassiniBounds(catalogueBoundsParameters(base, context), projection.forward, ranges),
+      base.primeMeridian,
+      base.over
+    );
+  }
+};

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

@@ -0,0 +1,31 @@
+// 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.
+import {cylindricalBounds} from '../rendering-profile/rendering-bounds';
+import {createAngularRanges} from '../rendering-profile/geographic-bounds';
+import {withRectangleRenderingProfile} from '../rendering-profile/rectangular-rendering-profile';
+import type {ProjectionPlugin} from '../types';
+import {catalogueParameters, bindCatalogueKernel} from '../catalogue-kernel';
+import {createState, forward, inverse} from '../kernels/cea';
+
+export const cylindricalEqualArea: ProjectionPlugin = {
+  name: 'cea',
+  aliases: [],
+  parameters: ['lon_0', 'x_0', 'y_0', 'lat_ts'],
+  create(context) {
+    const base = catalogueParameters(context);
+    if (Math.abs(base.lat_ts) >= Math.PI / 2)
+      throw new Error('CEA standard parallel must be away from the poles');
+    const state = createState(base);
+    // The rendering target covers one world; +over still permits conversion beyond it.
+    const projection = bindCatalogueKernel('cea', context, state, forward, inverse);
+    return withRectangleRenderingProfile(
+      projection,
+      createAngularRanges(base.long0 - Math.PI, -Math.PI / 2, base.long0 + Math.PI, Math.PI / 2),
+      ranges => cylindricalBounds(projection.forward, ranges, base.long0, base.over),
+      base.primeMeridian,
+      base.over
+    );
+  }
+};

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

@@ -0,0 +1,30 @@
+// 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.
+import {cylindricalBounds} from '../rendering-profile/rendering-bounds';
+import {createAngularRanges} from '../rendering-profile/geographic-bounds';
+import {withRectangleRenderingProfile} from '../rendering-profile/rectangular-rendering-profile';
+import type {ProjectionPlugin} from '../types';
+import {catalogueParameters, bindCatalogueKernel} from '../catalogue-kernel';
+import {createState, forward, inverse} from '../kernels/eck6';
+
+export const eckertVI: ProjectionPlugin = {
+  name: 'eck6',
+  aliases: ['Eckert_VI'],
+  parameters: ['lon_0', 'x_0', 'y_0'],
+  create(context) {
+    const base = catalogueParameters(context);
+
+    const state = createState(base);
+    // The rendering target covers one world; +over still permits conversion beyond it.
+    const projection = bindCatalogueKernel('eck6', context, state, forward, inverse);
+    return withRectangleRenderingProfile(
+      projection,
+      createAngularRanges(base.long0 - Math.PI, -Math.PI / 2, base.long0 + Math.PI, Math.PI / 2),
+      ranges => cylindricalBounds(projection.forward, ranges, base.long0, base.over),
+      base.primeMeridian,
+      base.over
+    );
+  }
+};

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

@@ -0,0 +1,40 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {createFlatProjection} from '../flat-projection';
+import {conicBounds} from '../rendering-profile/rendering-bounds';
+import {createAngularRanges} from '../rendering-profile/geographic-bounds';
+import {withRectangleRenderingProfile} from '../rendering-profile/rectangular-rendering-profile';
+import type {ProjectionPlugin} from '../types';
+import {bindKernel, kernelParameters, ORIGIN_PARAMETERS, validateConic} from '../kernel';
+import {createState, forward, inverse} from '../kernels/eqdc';
+
+export const equidistantConic: ProjectionPlugin = {
+  name: 'eqdc',
+  aliases: ['Equidistant_Conic'],
+  parameters: [...ORIGIN_PARAMETERS, 'lat_1', 'lat_2'],
+  create(context) {
+    const base = kernelParameters(context);
+    validateConic(base, context.parameters);
+    const state = createState(base);
+    // The rendering target covers one world; +over still permits conversion beyond it.
+    const projection = bindKernel('eqdc', state, forward, inverse, createFlatProjection);
+    return withRectangleRenderingProfile(
+      projection,
+      createAngularRanges(base.long0 - Math.PI, -Math.PI / 2, base.long0 + Math.PI, Math.PI / 2),
+      ranges =>
+        conicBounds(
+          projection.forward,
+          ranges,
+          base.long0,
+          state.ns,
+          state.x0,
+          state.y0 + state.rh,
+          base.over
+        ),
+      base.primeMeridian,
+      base.over
+    );
+  }
+};

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

@@ -0,0 +1,72 @@
+// 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.
+import {numberParameter} from '../parameters';
+import type {ProjectionPlugin} from '../types';
+import {catalogueParameters, bindCatalogueKernel} from '../catalogue-kernel';
+import {createState, forward, inverse} from '../kernels/eqearth';
+import {createAngularRanges, getGeographicBounds} from '../rendering-profile/geographic-bounds';
+import {createRectangleRenderingProfile} from '../rendering-profile/rectangular-rendering-profile';
+import {cylindricalBounds} from '../rendering-profile/rendering-bounds';
+
+export const equalEarth: ProjectionPlugin = {
+  name: 'eqearth',
+  aliases: ['Equal Earth', 'Equal_Earth'],
+  parameters: ['lon_0', 'x_0', 'y_0'],
+  create(context) {
+    const base = catalogueParameters(context);
+    const primeMeridian = context.primeMeridian ?? 0;
+
+    const state = createState(base);
+    const projection = bindCatalogueKernel('eqearth', context, state, forward, inverse);
+    // The kernel's authalic radius and polynomial determine the global extrema:
+    // maximum width at the equatorial seam and maximum height at the poles.
+    const e = Math.sqrt(context.eccentricitySquared);
+    const radius =
+      context.semiMajorAxis * (e ? Math.sqrt((1 + ((1 - e * e) * Math.atanh(e)) / e) / 2) : 1);
+    const theta = Math.PI / 3,
+      t2 = theta * theta,
+      t6 = t2 ** 3;
+    const width = (radius * Math.PI) / ((Math.sqrt(3) / 2) * 1.340264);
+    const x0 = numberParameter(context.parameters, 'x_0', 0);
+    const y0 = numberParameter(context.parameters, 'y_0', 0);
+    const height = radius * theta * (1.340264 - 0.081106 * t2 + t6 * (0.000893 + 0.003796 * t2));
+    return {
+      ...projection,
+      longitudeOrigin: base.long0,
+      getRenderingProfile(coverage) {
+        if (coverage)
+          return createRectangleRenderingProfile(
+            region => cylindricalBounds(projection.forward, region, base.long0, base.over),
+            coverage,
+            base.long0,
+            primeMeridian,
+            base.over
+          );
+        const defaultBounds = [
+          [x0 - width, y0 - height, 0],
+          [x0 + width, y0 + height, 0]
+        ] as const;
+        return {
+          bounds: defaultBounds,
+          normalize: createRectangleRenderingProfile(
+            () => defaultBounds,
+            getGeographicBounds(
+              createAngularRanges(
+                base.long0 - Math.PI,
+                -(Math.PI / 2),
+                base.long0 + Math.PI,
+                Math.PI / 2
+              ),
+              primeMeridian
+            ),
+            base.long0,
+            primeMeridian,
+            base.over
+          ).normalize
+        };
+      }
+    };
+  }
+};

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

@@ -0,0 +1,31 @@
+// 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.
+import {cylindricalBounds} from '../rendering-profile/rendering-bounds';
+import {createAngularRanges} from '../rendering-profile/geographic-bounds';
+import {withRectangleRenderingProfile} from '../rendering-profile/rectangular-rendering-profile';
+import type {ProjectionPlugin} from '../types';
+import {catalogueParameters, bindCatalogueKernel} from '../catalogue-kernel';
+import {createState, forward, inverse} from '../kernels/equi';
+
+export const equirectangular: ProjectionPlugin = {
+  name: 'equi',
+  aliases: [],
+  parameters: ['lon_0', 'x_0', 'y_0', 'lat_0'],
+  create(context) {
+    const base = catalogueParameters(context);
+    if (Math.abs(base.lat0) >= Math.PI / 2)
+      throw new Error('Equirectangular standard parallel must be away from the poles');
+    const state = createState(base);
+    // The rendering target covers one world; +over still permits conversion beyond it.
+    const projection = bindCatalogueKernel('equi', context, state, forward, inverse);
+    return withRectangleRenderingProfile(
+      projection,
+      createAngularRanges(base.long0 - Math.PI, -Math.PI / 2, base.long0 + Math.PI, Math.PI / 2),
+      ranges => cylindricalBounds(projection.forward, ranges, base.long0, base.over),
+      base.primeMeridian,
+      base.over
+    );
+  }
+};

package/src/projection/experimental/projections/equidistant-cylindrical.ts

@@ -0,0 +1,79 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original implementation of projection equations; compatibility informed by proj4js 2.22.0.
+
+import {createProjection} from '../mutable-projection';
+import {DEGREES_TO_RADIANS, latitudeParameter, numberParameter, wrapLongitude} from '../parameters';
+import type {ProjectionPlugin} from '../types';
+import {createAngularRanges, getGeographicBounds} from '../rendering-profile/geographic-bounds';
+import {createRectangleRenderingProfile} from '../rendering-profile/rectangular-rendering-profile';
+import {longitudeRange, envelope, scale, add} from '../rendering-profile/rendering-bounds';
+
+/** Spherical equidistant cylindrical (the eqc formulation used by proj4js). */
+export const equidistantCylindrical: ProjectionPlugin = {
+  name: 'eqc',
+  aliases: ['Equirectangular', 'Equidistant_Cylindrical', 'Equidistant_Cylindrical_Spherical'],
+  parameters: ['lon_0', 'lat_0', 'lat_ts', 'x_0', 'y_0'],
+  create({semiMajorAxis: a, parameters, primeMeridian = 0}) {
+    const over = Object.prototype.hasOwnProperty.call(parameters, 'over');
+    const longitudeOrigin = numberParameter(parameters, 'lon_0', 0) * DEGREES_TO_RADIANS;
+    const latitudeOrigin = latitudeParameter(parameters, 'lat_0');
+    const parallelScale = Math.cos(latitudeParameter(parameters, 'lat_ts'));
+    const x0 = numberParameter(parameters, 'x_0', 0);
+    const y0 = numberParameter(parameters, 'y_0', 0);
+    const width = a * Math.abs(parallelScale) * Math.PI;
+    return {
+      longitudeOrigin,
+      getRenderingProfile(coverage) {
+        if (coverage)
+          return createRectangleRenderingProfile(
+            region =>
+              envelope(
+                add(
+                  [x0, x0],
+                  scale(longitudeRange(region, longitudeOrigin, over), a * parallelScale)
+                ),
+                [y0 + a * (region[0][1] - latitudeOrigin), y0 + a * (region[1][1] - latitudeOrigin)]
+              ),
+            coverage,
+            longitudeOrigin,
+            primeMeridian,
+            over
+          );
+        const defaultBounds = [
+          [x0 - width, y0 + a * (-Math.PI / 2 - latitudeOrigin), 0],
+          [x0 + width, y0 + a * (Math.PI / 2 - latitudeOrigin), 0]
+        ] as const;
+        return {
+          bounds: defaultBounds,
+          normalize: createRectangleRenderingProfile(
+            () => defaultBounds,
+            getGeographicBounds(
+              createAngularRanges(
+                longitudeOrigin - Math.PI,
+                -(Math.PI / 2),
+                longitudeOrigin + Math.PI,
+                Math.PI / 2
+              ),
+              primeMeridian
+            ),
+            longitudeOrigin,
+            primeMeridian,
+            over
+          ).normalize
+        };
+      },
+      ...createProjection(
+        point => {
+          point.x = x0 + a * parallelScale * wrapLongitude(point.x - longitudeOrigin, over);
+          point.y = y0 + a * (point.y - latitudeOrigin);
+        },
+        point => {
+          point.x = wrapLongitude(longitudeOrigin + (point.x - x0) / (a * parallelScale), over);
+          point.y = latitudeOrigin + (point.y - y0) / a;
+        }
+      )
+    };
+  }
+};

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

@@ -0,0 +1,42 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import type {ProjectionPlugin} from '../types';
+import {createGeographicProfile} from '../rendering-profile/geographic-rendering-profile';
+import {
+  geodeticToGeocentric,
+  geocentricToGeodetic,
+  geodeticToGeocentricInPlace,
+  geocentricToGeodeticInPlace
+} from '../datum';
+export const geocentric: ProjectionPlugin = {
+  name: 'geocent',
+  aliases: ['Geocentric', 'geocentric', 'Geocent'],
+  parameters: [],
+  create({semiMajorAxis, semiMinorAxis, eccentricitySquared, primeMeridian = 0}) {
+    const ellipsoid = {
+      semiMajorAxis,
+      eccentricitySquared,
+      semiMinorAxis: semiMinorAxis ?? semiMajorAxis * Math.sqrt(1 - eccentricitySquared)
+    };
+    return {
+      getRenderingProfile: () => ({
+        bounds: [
+          [-semiMajorAxis, -semiMajorAxis, -ellipsoid.semiMinorAxis],
+          [semiMajorAxis, semiMajorAxis, ellipsoid.semiMinorAxis]
+        ],
+        normalize: createGeographicProfile({}, primeMeridian)().normalize
+      }),
+      forward() {
+        throw new Error('Geocentric projection requires the 3D pipeline');
+      },
+      inverse() {
+        throw new Error('Geocentric projection requires the 3D pipeline');
+      },
+      forwardInPlace: point => geodeticToGeocentricInPlace(point, ellipsoid),
+      inverseInPlace: point => geocentricToGeodeticInPlace(point, ellipsoid),
+      forward3D: point => geodeticToGeocentric(point, ellipsoid),
+      inverse3D: point => geocentricToGeodetic(point, ellipsoid)
+    };
+  }
+};

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

@@ -0,0 +1,46 @@
+// 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.
+import {createGeostationaryProfile} from '../rendering-profile/geostationary-rendering-profile';
+import type {ProjectionPlugin} from '../types';
+import {
+  catalogueParameters,
+  catalogueBoundsParameters,
+  bindCatalogueKernel,
+  horizonGuard
+} from '../catalogue-kernel';
+import {createState, forward, inverse} from '../kernels/geos';
+import {numberParameter} from '../parameters';
+
+export const geostationary: ProjectionPlugin = {
+  name: 'geos',
+  aliases: ['Geostationary Satellite View', 'Geostationary_Satellite'],
+  parameters: ['lon_0', 'x_0', 'y_0', 'h', 'sweep'],
+  create(context) {
+    const base = catalogueParameters(context);
+    const h = numberParameter(context.parameters, 'h', NaN);
+    if (!Number.isFinite(h) || h <= 0)
+      throw new Error('Geostationary projection requires positive h');
+    const sweep = context.parameters['sweep'] || 'y';
+    if (!['x', 'y'].includes(sweep)) throw new Error('Geostationary sweep must be x or y');
+    const state = createState(base, {h, sweep});
+    const projection = bindCatalogueKernel(
+      'geos',
+      context,
+      state,
+      forward,
+      inverse,
+      base.sphere ? horizonGuard({...base, lat0: 0}, 1 / (1 + h / base.a), true) : undefined
+    );
+    return {
+      ...projection,
+      longitudeOrigin: base.long0,
+      getRenderingProfile: createGeostationaryProfile(
+        catalogueBoundsParameters(base, context),
+        h,
+        sweep === 'x'
+      )
+    };
+  }
+};

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

@@ -0,0 +1,51 @@
+// 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.
+import {withAngularRenderingProfile} from '../rendering-profile/angular-rendering-profile';
+import {
+  sphericalAzimuthalBounds,
+  ellipsoidalGnomonicBounds
+} from '../rendering-profile/azimuthal-rendering-bounds';
+import type {ProjectionPlugin} from '../types';
+import {
+  catalogueParameters,
+  catalogueBoundsParameters,
+  bindCatalogueKernel,
+  horizonGuard
+} from '../catalogue-kernel';
+import {createState, forward, inverse} from '../kernels/gnom';
+
+export const gnomonic: ProjectionPlugin = {
+  name: 'gnom',
+  aliases: [],
+  parameters: ['lon_0', 'x_0', 'y_0', 'lat_0'],
+  create(context) {
+    const base = catalogueParameters(context);
+
+    const state = createState(base);
+    // Keep the rendering boundary finite without restricting raw conversion.
+    return withAngularRenderingProfile(
+      bindCatalogueKernel(
+        'gnom',
+        context,
+        state,
+        forward,
+        inverse,
+        base.sphere ? horizonGuard(base) : undefined
+      ),
+      base,
+      Math.min((Math.PI * 80) / 180, (1 - base.es) * Math.PI * 0.45),
+      (region, domain) =>
+        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/gstmerc.ts

@@ -0,0 +1,43 @@
+// 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.
+import {transverseBounds} from '../rendering-profile/rendering-bounds';
+import invlatiso from '../common/invlatiso';
+import {createAngularRanges} from '../rendering-profile/geographic-bounds';
+import {withRectangleRenderingProfile} from '../rendering-profile/rectangular-rendering-profile';
+import type {ProjectionPlugin} from '../types';
+import {catalogueParameters, bindCatalogueKernel} from '../catalogue-kernel';
+import {createState, forward, inverse} from '../kernels/gstmerc';
+
+export const gaussSchreiberTransverseMercator: ProjectionPlugin = {
+  name: 'gstmerc',
+  aliases: ['gstmerg'],
+  parameters: ['lon_0', 'x_0', 'y_0', 'lat_0', 'k', 'k_0'],
+  create(context) {
+    const base = catalogueParameters(context);
+
+    const state = createState(base);
+    // Avoid the transverse Mercator singularity in the rendering domain.
+    const projection = bindCatalogueKernel('gstmerc', context, state, forward, inverse);
+    return withRectangleRenderingProfile(
+      projection,
+      createAngularRanges(
+        base.long0 - Math.PI / 6,
+        -Math.PI / 3,
+        base.long0 + Math.PI / 6,
+        Math.PI / 3
+      ),
+      ranges =>
+        transverseBounds(
+          projection.forward,
+          ranges,
+          base.long0,
+          base.over,
+          invlatiso(state.e, -state.cp / state.rs)
+        ),
+      base.primeMeridian,
+      base.over
+    );
+  }
+};