@math.gl/projection 0.0.0-stage → 5.0.0-alpha.12

package/src/experimental/projection-scratch.ts

@@ -0,0 +1,19 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original per-instance coordinate scratch lease; recursive hooks receive independent storage.
+import type {ProjectionPoint} from './types';
+
+/** Reuse one point for ordinary scalar/bulk calls without exposing shared scratch to recursive hooks. */
+export class ProjectionScratch {
+  readonly point: ProjectionPoint = {x: 0, y: 0, z: 0};
+  private busy = false;
+  acquire(): ProjectionPoint {
+    if (this.busy) return {x: 0, y: 0, z: 0};
+    this.busy = true;
+    return this.point;
+  }
+  release(point: ProjectionPoint): void {
+    if (point === this.point) this.busy = false;
+  }
+}

package/src/experimental/projections/aea.ts

@@ -0,0 +1,19 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {createFlatProjection} from '../flat-projection';
+import type {ProjectionPlugin} from '../types';
+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);
+    return bindKernel('aea', createState(base), forward, inverse, createFlatProjection);
+  }
+};

package/src/experimental/projections/aeqd.ts

@@ -0,0 +1,18 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+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);
+
+    return guardAzimuthalDomain(base, bindKernel('aeqd', createState(base), forward, inverse));
+  }
+};

package/src/experimental/projections/bonne.ts

@@ -0,0 +1,23 @@
+// 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 type {ProjectionPlugin} from '../types';
+import {catalogueParameters, 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);
+    return bindCatalogueKernel('bonne', context, state, forward, inverse);
+  }
+};

package/src/experimental/projections/cass.ts

@@ -0,0 +1,19 @@
+// 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 type {ProjectionPlugin} from '../types';
+import {catalogueParameters, 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);
+    return bindCatalogueKernel('cass', context, state, forward, inverse);
+  }
+};

package/src/experimental/projections/cea.ts

@@ -0,0 +1,20 @@
+// 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 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);
+    return bindCatalogueKernel('cea', context, state, forward, inverse);
+  }
+};

package/src/experimental/projections/eck6.ts

@@ -0,0 +1,19 @@
+// 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 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);
+    return bindCatalogueKernel('eck6', context, state, forward, inverse);
+  }
+};

package/src/experimental/projections/eqdc.ts

@@ -0,0 +1,19 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {createFlatProjection} from '../flat-projection';
+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);
+    return bindKernel('eqdc', createState(base), forward, inverse, createFlatProjection);
+  }
+};

package/src/experimental/projections/eqearth.ts

@@ -0,0 +1,19 @@
+// 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 type {ProjectionPlugin} from '../types';
+import {catalogueParameters, bindCatalogueKernel} from '../catalogue-kernel';
+import {createState, forward, inverse} from '../kernels/eqearth';
+
+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 state = createState(base);
+    return bindCatalogueKernel('eqearth', context, state, forward, inverse);
+  }
+};

package/src/experimental/projections/equi.ts

@@ -0,0 +1,20 @@
+// 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 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);
+    return bindCatalogueKernel('equi', context, state, forward, inverse);
+  }
+};

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

@@ -0,0 +1,35 @@
+// 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';
+
+/** 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}) {
+    const wrap = Object.prototype.hasOwnProperty.call(parameters, 'over')
+      ? (value: number) => value
+      : wrapLongitude;
+    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);
+    return createProjection(
+      point => {
+        point.x = x0 + a * parallelScale * wrap(point.x - longitudeOrigin);
+        point.y = y0 + a * (point.y - latitudeOrigin);
+      },
+      point => {
+        point.x = wrap(longitudeOrigin + (point.x - x0) / (a * parallelScale));
+        point.y = latitudeOrigin + (point.y - y0) / a;
+      }
+    );
+  }
+};

package/src/experimental/projections/geocentric.ts

@@ -0,0 +1,34 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import type {ProjectionPlugin} from '../types';
+import {
+  geodeticToGeocentric,
+  geocentricToGeodetic,
+  geodeticToGeocentricInPlace,
+  geocentricToGeodeticInPlace
+} from '../datum';
+export const geocentric: ProjectionPlugin = {
+  name: 'geocent',
+  aliases: ['Geocentric', 'geocentric', 'Geocent'],
+  parameters: [],
+  create({semiMajorAxis, semiMinorAxis, eccentricitySquared}) {
+    const ellipsoid = {
+      semiMajorAxis,
+      eccentricitySquared,
+      semiMinorAxis: semiMinorAxis ?? semiMajorAxis * Math.sqrt(1 - eccentricitySquared)
+    };
+    return {
+      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/experimental/projections/geos.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 type {ProjectionPlugin} from '../types';
+import {catalogueParameters, 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});
+    return bindCatalogueKernel(
+      'geos',
+      context,
+      state,
+      forward,
+      inverse,
+      base.sphere ? horizonGuard({...base, lat0: 0}, 1 / (1 + h / base.a), true) : undefined
+    );
+  }
+};

package/src/experimental/projections/gnom.ts

@@ -0,0 +1,19 @@
+// 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 type {ProjectionPlugin} from '../types';
+import {catalogueParameters, 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);
+    return bindCatalogueKernel('gnom', context, state, forward, inverse, horizonGuard(base));
+  }
+};

package/src/experimental/projections/gstmerc.ts

@@ -0,0 +1,19 @@
+// 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 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);
+    return bindCatalogueKernel('gstmerc', context, state, forward, inverse);
+  }
+};

package/src/experimental/projections/krovak.ts

@@ -0,0 +1,41 @@
+// 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 type {ProjectionPlugin} from '../types';
+import {catalogueParameters, bindCatalogueKernel} from '../catalogue-kernel';
+import {createState, forward, inverse} from '../kernels/krovak';
+import {numberParameter} from '../parameters';
+import {flagParameter, angleParameter} from '../kernel';
+
+export const krovak: ProjectionPlugin = {
+  name: 'krovak',
+  aliases: [
+    'Krovak',
+    'Krovak Modified',
+    'Krovak (North Orientated)',
+    'Krovak Modified (North Orientated)'
+  ],
+  parameters: ['lon_0', 'x_0', 'y_0', 'lat_0', 'k', 'k_0', 'czech', 'alpha', 'lat_ts'],
+  flags: ['czech'],
+  create(context) {
+    // The upstream kernel fixes these angles. Accept the two published azimuth
+    // spellings (legacy PROJ and EPSG), but never silently ignore custom angles.
+    const alpha = numberParameter(context.parameters, 'alpha', 30.28813972222222);
+    const parallel = numberParameter(context.parameters, 'lat_ts', 78.5);
+    if (![30.28813972222222, 30.28813975277778].some(value => Math.abs(alpha - value) <= 1e-10))
+      throw new Error('Krovak requires its fixed cone-axis co-latitude');
+    if (Math.abs(parallel - 78.5) > 1e-10)
+      throw new Error('Krovak requires its fixed 78.5 degree pseudo standard parallel');
+    const base = catalogueParameters(context);
+    base.lat0 = angleParameter(context.parameters, 'lat_0', 49.5);
+    base.long0 = angleParameter(context.parameters, 'lon_0', 24.83333333333333);
+    base.k0 = numberParameter(
+      context.parameters,
+      'k_0',
+      numberParameter(context.parameters, 'k', 0.9999)
+    );
+    const state = createState(base, {czech: flagParameter(context.parameters, 'czech')});
+    return bindCatalogueKernel('krovak', context, state, forward, inverse);
+  }
+};

package/src/experimental/projections/laea.ts

@@ -0,0 +1,18 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ProjectionPlugin} from '../types';
+import {bindKernel, guardAzimuthalDomain, kernelParameters, ORIGIN_PARAMETERS} from '../kernel';
+import {createState, forward, inverse} from '../kernels/laea';
+
+export const lambertAzimuthalEqualArea: ProjectionPlugin = {
+  name: 'laea',
+  aliases: ['Lambert Azimuthal Equal Area', 'Lambert_Azimuthal_Equal_Area'],
+  parameters: ORIGIN_PARAMETERS,
+  create(context) {
+    const base = kernelParameters(context);
+
+    return guardAzimuthalDomain(base, bindKernel('laea', createState(base), forward, inverse));
+  }
+};

package/src/experimental/projections/lcc.ts

@@ -0,0 +1,40 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ProjectionPlugin} from '../types';
+import {createFlatProjection as createProjection} from '../flat-projection';
+import {
+  bindKernel,
+  kernelParameters,
+  ORIGIN_PARAMETERS,
+  SCALE_PARAMETERS,
+  validateConic
+} from '../kernel';
+import {createState, forward, inverse} from '../kernels/lcc';
+
+export const lambertConformalConic: ProjectionPlugin = {
+  name: 'lcc',
+  aliases: [
+    'Lambert Tangential Conformal Conic Projection',
+    'Lambert_Conformal_Conic',
+    'Lambert_Conformal_Conic_1SP',
+    'Lambert_Conformal_Conic_2SP',
+    'Lambert Conic Conformal (1SP)',
+    'Lambert Conic Conformal (2SP)'
+  ],
+  parameters: [...ORIGIN_PARAMETERS, ...SCALE_PARAMETERS, 'lat_1', 'lat_2'],
+  create(context) {
+    const base = kernelParameters(context);
+    validateConic(base, context.parameters);
+    const state = createState(base);
+    const implementation = bindKernel('lcc', state, forward, inverse);
+    return createProjection(point => {
+      const latitude = point.y;
+      if (Math.abs(latitude) === Math.PI / 2 && latitude * state.ns < 0) {
+        throw new Error('Lambert conformal conic is undefined at the opposite pole');
+      }
+      implementation.forwardInPlace!(point);
+    }, implementation.inverseInPlace!);
+  }
+};

package/src/experimental/projections/mercator.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 {createFlatProjection as createProjection} from '../flat-projection';
+import {DEGREES_TO_RADIANS, latitudeParameter, numberParameter, wrapLongitude} from '../parameters';
+import type {ProjectionPlugin} from '../types';
+
+/** Spherical and ellipsoidal Mercator, using the PROJ Mercator equations. */
+export const mercator: ProjectionPlugin = {
+  name: 'merc',
+  aliases: [
+    'Mercator',
+    'Popular Visualisation Pseudo Mercator',
+    'Mercator_1SP',
+    'Mercator_Auxiliary_Sphere',
+    'Mercator_Variant_A'
+  ],
+  parameters: ['lon_0', 'lat_ts', 'k', 'k_0', 'x_0', 'y_0'],
+  create({semiMajorAxis: a, eccentricitySquared: es, parameters}) {
+    const e = Math.sqrt(es);
+    const wrap = Object.prototype.hasOwnProperty.call(parameters, 'over')
+      ? (value: number) => value
+      : wrapLongitude;
+    const longitudeOrigin = numberParameter(parameters, 'lon_0', 0) * DEGREES_TO_RADIANS;
+    const x0 = numberParameter(parameters, 'x_0', 0);
+    const y0 = numberParameter(parameters, 'y_0', 0);
+    let scale = numberParameter(parameters, 'k_0', numberParameter(parameters, 'k', 1));
+    if (Object.prototype.hasOwnProperty.call(parameters, 'lat_ts')) {
+      const latitude = latitudeParameter(parameters, 'lat_ts');
+      scale = Math.cos(latitude) / Math.sqrt(1 - es * Math.sin(latitude) ** 2);
+    }
+    if (scale <= 0) throw new Error('Mercator scale must be positive');
+    const radius = a * scale;
+    return createProjection(
+      point => {
+        const longitude = point.x,
+          latitude = point.y;
+        if (Math.abs(latitude) >= Math.PI / 2) {
+          throw new Error('Mercator is undefined at the poles');
+        }
+        const isometricLatitude = Math.asinh(Math.tan(latitude));
+        point.x = x0 + radius * wrap(longitude - longitudeOrigin);
+        // Spherical Mercator has no ellipsoidal correction. Normalize signed zero.
+        point.y =
+          y0 +
+          radius *
+            (e === 0
+              ? isometricLatitude + 0
+              : isometricLatitude - e * Math.atanh(e * Math.sin(latitude)));
+      },
+      point => {
+        const x = point.x,
+          y = point.y;
+        const isometricLatitude = (y - y0) / radius;
+        let latitude = Math.atan(Math.sinh(isometricLatitude));
+        // The spherical inverse is already exact; no iteration is needed.
+        if (e === 0) {
+          point.x = wrap(longitudeOrigin + (x - x0) / radius);
+          point.y = latitude + 0;
+          return;
+        }
+        for (let iteration = 0; iteration < 30; iteration++) {
+          const next = Math.atan(
+            Math.sinh(isometricLatitude + e * Math.atanh(e * Math.sin(latitude)))
+          );
+          if (Math.abs(next - latitude) < 1e-13) {
+            point.x = wrap(longitudeOrigin + (x - x0) / radius);
+            point.y = next;
+            return;
+          }
+          latitude = next;
+        }
+        throw new Error('Mercator inverse did not converge');
+      }
+    );
+  }
+};

package/src/experimental/projections/mill.ts

@@ -0,0 +1,19 @@
+// 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 type {ProjectionPlugin} from '../types';
+import {catalogueParameters, bindCatalogueKernel} from '../catalogue-kernel';
+import {createState, forward, inverse} from '../kernels/mill';
+
+export const millerCylindrical: ProjectionPlugin = {
+  name: 'mill',
+  aliases: ['Miller_Cylindrical'],
+  parameters: ['lon_0', 'x_0', 'y_0'],
+  create(context) {
+    const base = catalogueParameters(context);
+
+    const state = createState(base);
+    return bindCatalogueKernel('mill', context, state, forward, inverse);
+  }
+};

package/src/experimental/projections/moll.ts

@@ -0,0 +1,19 @@
+// 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 type {ProjectionPlugin} from '../types';
+import {catalogueParameters, bindCatalogueKernel} from '../catalogue-kernel';
+import {createState, forward, inverse} from '../kernels/moll';
+
+export const mollweide: ProjectionPlugin = {
+  name: 'moll',
+  aliases: ['Mollweide'],
+  parameters: ['lon_0', 'x_0', 'y_0'],
+  create(context) {
+    const base = catalogueParameters(context);
+
+    const state = createState(base);
+    return bindCatalogueKernel('moll', context, state, forward, inverse);
+  }
+};

package/src/experimental/projections/nzmg.ts

@@ -0,0 +1,27 @@
+// 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 type {ProjectionPlugin} from '../types';
+import {catalogueParameters, bindCatalogueKernel} from '../catalogue-kernel';
+import {createState, forward, inverse} from '../kernels/nzmg';
+import {numberParameter} from '../parameters';
+
+export const newZealandMapGrid: ProjectionPlugin = {
+  name: 'nzmg',
+  aliases: ['New_Zealand_Map_Grid'],
+  parameters: ['lon_0', 'x_0', 'y_0', 'lat_0', 'iterations'],
+  create(context) {
+    const base = catalogueParameters(context);
+    const iterations = numberParameter(context.parameters, 'iterations', 1);
+    if (!Number.isInteger(iterations) || iterations < 0 || iterations > 10)
+      throw new Error('NZMG iterations must be an integer from 0 to 10');
+    if (
+      !Object.prototype.hasOwnProperty.call(context.parameters, 'lat_0') ||
+      !Object.prototype.hasOwnProperty.call(context.parameters, 'lon_0')
+    )
+      throw new Error('NZMG requires lat_0 and lon_0');
+    const state = createState(base, {iterations});
+    return bindCatalogueKernel('nzmg', context, state, forward, inverse);
+  }
+};