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

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

@@ -0,0 +1,161 @@
+// math.gl
+// 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.
+import type {ProjectionPlugin, ProjectionParameters} from '../types';
+import {createProjection, projectionOperation} from '../mutable-projection';
+import {numberParameter, wrapLongitude} from '../parameters';
+import {TypeScriptCRSError} from '../crs/types';
+
+const rotationParameters = [
+  'o_proj',
+  'o_alpha',
+  'o_lon_c',
+  'o_lat_c',
+  'o_lon_p',
+  'o_lat_p',
+  'o_lon_1',
+  'o_lat_1',
+  'o_lon_2',
+  'o_lat_2'
+];
+const normalizedName = (name: string): string => name.toLowerCase().replace(/[ _-]/g, '');
+const has = (parameters: ProjectionParameters, name: string): boolean =>
+  Object.prototype.hasOwnProperty.call(parameters, name);
+const radians = (parameters: ProjectionParameters, name: string): number =>
+  (numberParameter(parameters, name, 0) * Math.PI) / 180;
+function rotation(parameters: ProjectionParameters): {lamp: number; phip: number} {
+  const sets = [
+    ['o_alpha', 'o_lon_c', 'o_lat_c'],
+    ['o_lat_p', 'o_lon_p'],
+    ['o_lon_1', 'o_lat_1', 'o_lon_2', 'o_lat_2']
+  ];
+  const selected = sets.find(set => set.some(name => has(parameters, name)));
+  if (!selected) throw new Error('Oblique transformation requires a rotation parameter set');
+  for (const name of selected) {
+    if (!has(parameters, name)) throw new Error('Oblique transformation requires ' + name);
+    if (name.includes('lat') && Math.abs(radians(parameters, name)) > Math.PI / 2)
+      throw new Error('Invalid rotation latitude: ' + name);
+  }
+  if (selected === sets[0]) {
+    const alpha = radians(parameters, 'o_alpha'),
+      lamc = radians(parameters, 'o_lon_c'),
+      phic = radians(parameters, 'o_lat_c');
+    if (Math.abs(phic) >= Math.PI / 2 - 1e-10)
+      throw new Error('Rotation center must be away from the poles');
+    return {
+      lamp: lamc + Math.atan2(-Math.cos(alpha), -Math.sin(alpha) * Math.sin(phic)),
+      phip: Math.asin(Math.cos(phic) * Math.sin(alpha))
+    };
+  }
+  if (selected === sets[1])
+    return {lamp: radians(parameters, 'o_lon_p'), phip: radians(parameters, 'o_lat_p')};
+  const lam1 = radians(parameters, 'o_lon_1'),
+    phi1 = radians(parameters, 'o_lat_1'),
+    lam2 = radians(parameters, 'o_lon_2'),
+    phi2 = radians(parameters, 'o_lat_2');
+  if (
+    Math.abs(phi1) >= Math.PI / 2 - 1e-10 ||
+    Math.abs(phi2) >= Math.PI / 2 - 1e-10 ||
+    Math.abs(phi1) < 1e-10 ||
+    Math.abs(phi1 - phi2) < 1e-10
+  )
+    throw new Error('Invalid new-equator reference points');
+  const lamp = Math.atan2(
+    Math.cos(phi1) * Math.sin(phi2) * Math.cos(lam1) -
+      Math.sin(phi1) * Math.cos(phi2) * Math.cos(lam2),
+    Math.sin(phi1) * Math.cos(phi2) * Math.sin(lam2) -
+      Math.cos(phi1) * Math.sin(phi2) * Math.sin(lam1)
+  );
+  return {lamp, phip: Math.atan(-Math.cos(lamp - lam1) / Math.tan(phi1))};
+}
+/** Explicit dependency: register obliqueTransformation(mollweide), or use 'longlat' for rotated degrees. */
+export function obliqueTransformation(wrapped: ProjectionPlugin | 'longlat'): ProjectionPlugin {
+  const geographic = wrapped === 'longlat';
+  if (!geographic && ['obtran', 'geocent'].includes(normalizedName(wrapped.name)))
+    throw new Error('Cannot wrap a composite or geocentric projection');
+  return {
+    name: 'ob_tran',
+    aliases: ['General Oblique Transformation', 'General_Oblique_Transformation'],
+    parameters: [...rotationParameters, 'lon_0', ...(geographic ? [] : wrapped.parameters)],
+    flags: geographic ? [] : wrapped.flags,
+    create(context) {
+      const {parameters} = context;
+      const requested = parameters['o_proj'];
+      const accepted = geographic
+        ? ['longlat', 'latlong', 'lonlat', 'latlon', 'identity']
+        : [wrapped.name, ...(wrapped.aliases || [])];
+      if (requested && !accepted.map(normalizedName).includes(normalizedName(requested)))
+        throw new TypeScriptCRSError(
+          'missing-plugin',
+          'Oblique transformation dependency does not match +o_proj=' + requested
+        );
+      const {lamp, phip} = rotation(parameters);
+      const cphip = Math.cos(phip),
+        sphip = Math.sin(phip),
+        oblique = Math.abs(phip) > 1e-10;
+      const longitudeOrigin = radians(parameters, 'lon_0');
+      const over = has(parameters, 'over');
+      const innerParameters: Record<string, string | undefined> = {
+        ...parameters,
+        proj: geographic ? 'longlat' : requested || wrapped.name,
+        lon_0: '0'
+      };
+      for (const name of rotationParameters) delete innerParameters[name];
+      const inner = geographic
+        ? createProjection(
+            point => {
+              point.x *= 180 / Math.PI;
+              point.y *= 180 / Math.PI;
+            },
+            point => {
+              point.x *= Math.PI / 180;
+              point.y *= Math.PI / 180;
+            }
+          )
+        : wrapped.create({...context, parameters: Object.freeze(innerParameters)});
+      const forward = projectionOperation(inner, false),
+        inverse = projectionOperation(inner, true);
+      const asin = (value: number): number => Math.asin(Math.max(-1, Math.min(1, value)));
+      return createProjection(
+        point => {
+          const longitude = point.x,
+            latitude = point.y;
+          const lam = over
+            ? longitude - longitudeOrigin
+            : wrapLongitude(longitude - longitudeOrigin);
+          const coslam = Math.cos(lam),
+            sinphi = Math.sin(latitude),
+            cosphi = Math.cos(latitude);
+          const lon = wrapLongitude(
+            Math.atan2(
+              cosphi * Math.sin(lam),
+              oblique ? sphip * cosphi * coslam + cphip * sinphi : sinphi
+            ) + lamp
+          );
+          const lat = asin(oblique ? sphip * sinphi - cphip * cosphi * coslam : -cosphi * coslam);
+          point.x = lon;
+          point.y = lat;
+          forward(point);
+        },
+        point => {
+          inverse(point);
+          const innerLongitude = point.x,
+            latitude = point.y;
+          const lam = innerLongitude - lamp,
+            coslam = Math.cos(lam),
+            sinphi = Math.sin(latitude),
+            cosphi = Math.cos(latitude);
+          const lon = Math.atan2(
+            cosphi * Math.sin(lam),
+            oblique ? sphip * cosphi * coslam - cphip * sinphi : -sinphi
+          );
+          const lat = asin(oblique ? sphip * sinphi + cphip * cosphi * coslam : cosphi * coslam);
+          point.x = wrapLongitude(lon + longitudeOrigin);
+          point.y = lat;
+        }
+      );
+    }
+  };
+}

package/src/experimental/projections/omerc.ts

@@ -0,0 +1,66 @@
+// 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/omerc';
+import {numberParameter} from '../parameters';
+import {flagParameter} from '../kernel';
+
+export const obliqueMercator: ProjectionPlugin = {
+  name: 'omerc',
+  aliases: [
+    'Hotine_Oblique_Mercator',
+    'Hotine Oblique Mercator',
+    'Hotine_Oblique_Mercator_variant_A',
+    'Hotine_Oblique_Mercator_Variant_B',
+    'Hotine_Oblique_Mercator_Azimuth_Natural_Origin',
+    'Hotine_Oblique_Mercator_Two_Point_Natural_Origin',
+    'Hotine_Oblique_Mercator_Azimuth_Center',
+    'Oblique_Mercator'
+  ],
+  parameters: [
+    'lon_0',
+    'x_0',
+    'y_0',
+    'lat_0',
+    'k',
+    'k_0',
+    'alpha',
+    'gamma',
+    'lonc',
+    'lon_1',
+    'lon_2',
+    'lat_1',
+    'lat_2',
+    'no_off',
+    'no_uoff',
+    'no_rot'
+  ],
+  flags: ['no_off', 'no_uoff', 'no_rot'],
+  create(context) {
+    const base = catalogueParameters(context);
+    if (Math.abs(base.lat0) >= Math.PI / 2)
+      throw new Error('Oblique Mercator origin must be away from the poles');
+    const hasAzimuth =
+      Object.prototype.hasOwnProperty.call(context.parameters, 'alpha') ||
+      Object.prototype.hasOwnProperty.call(context.parameters, 'gamma');
+    const required = hasAzimuth ? ['lonc'] : ['lon_1', 'lat_1', 'lon_2', 'lat_2'];
+    for (const name of required)
+      if (!Object.prototype.hasOwnProperty.call(context.parameters, name))
+        throw new Error('Oblique Mercator requires ' + name);
+    const state = createState(base, {
+      projName: context.parameters['proj'] || 'omerc',
+      alpha: (numberParameter(context.parameters, 'alpha', NaN) * Math.PI) / 180,
+      rectified_grid_angle: (numberParameter(context.parameters, 'gamma', NaN) * Math.PI) / 180,
+      longc: (numberParameter(context.parameters, 'lonc', 0) * Math.PI) / 180,
+      long1: (numberParameter(context.parameters, 'lon_1', 0) * Math.PI) / 180,
+      long2: (numberParameter(context.parameters, 'lon_2', 0) * Math.PI) / 180,
+      no_off: flagParameter(context.parameters, 'no_off'),
+      no_uoff: flagParameter(context.parameters, 'no_uoff'),
+      no_rot: flagParameter(context.parameters, 'no_rot')
+    });
+    return bindCatalogueKernel('omerc', context, state, forward, inverse);
+  }
+};

package/src/experimental/projections/ortho.ts

@@ -0,0 +1,26 @@
+// 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/ortho';
+
+export const orthographic: ProjectionPlugin = {
+  name: 'ortho',
+  aliases: [],
+  parameters: ['lon_0', 'x_0', 'y_0', 'lat_0'],
+  create(context) {
+    const base = catalogueParameters(context);
+
+    const state = createState(base);
+    return bindCatalogueKernel(
+      'ortho',
+      context,
+      state,
+      forward,
+      inverse,
+      horizonGuard(base, 0, true)
+    );
+  }
+};

package/src/experimental/projections/poly.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/poly';
+
+export const polyconic: ProjectionPlugin = {
+  name: 'poly',
+  aliases: ['Polyconic', 'American_Polyconic'],
+  parameters: ['lon_0', 'x_0', 'y_0', 'lat_0'],
+  create(context) {
+    const base = catalogueParameters(context);
+
+    const state = createState(base);
+    return bindCatalogueKernel('poly', context, state, forward, inverse);
+  }
+};

package/src/experimental/projections/qsc.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/qsc';
+
+export const quadrilateralizedSphericalCube: ProjectionPlugin = {
+  name: 'qsc',
+  aliases: ['Quadrilateralized Spherical Cube', 'Quadrilateralized_Spherical_Cube'],
+  parameters: ['lon_0', 'x_0', 'y_0', 'lat_0'],
+  create(context) {
+    const base = catalogueParameters(context);
+
+    const state = createState(base);
+    return bindCatalogueKernel('qsc', context, state, forward, inverse);
+  }
+};

package/src/experimental/projections/robin.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/robin';
+
+export const robinson: ProjectionPlugin = {
+  name: 'robin',
+  aliases: ['Robinson'],
+  parameters: ['lon_0', 'x_0', 'y_0'],
+  create(context) {
+    const base = catalogueParameters(context);
+
+    const state = createState(base);
+    return bindCatalogueKernel('robin', context, state, forward, inverse);
+  }
+};

package/src/experimental/projections/sinu.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/sinu';
+
+export const sinusoidal: ProjectionPlugin = {
+  name: 'sinu',
+  aliases: ['Sinusoidal'],
+  parameters: ['lon_0', 'x_0', 'y_0'],
+  create(context) {
+    const base = catalogueParameters(context);
+
+    const state = createState(base);
+    return bindCatalogueKernel('sinu', context, state, forward, inverse);
+  }
+};

package/src/experimental/projections/somerc.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/somerc';
+
+export const swissObliqueMercator: ProjectionPlugin = {
+  name: 'somerc',
+  aliases: [],
+  parameters: ['lon_0', 'x_0', 'y_0', 'lat_0', 'k', 'k_0'],
+  create(context) {
+    const base = catalogueParameters(context);
+
+    const state = createState(base, {rf: base.a === base.b ? Infinity : 1 / (1 - base.b / base.a)});
+    return bindCatalogueKernel('somerc', context, state, forward, inverse);
+  }
+};

package/src/experimental/projections/stere.ts

@@ -0,0 +1,29 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ProjectionPlugin} from '../types';
+import {
+  bindKernel,
+  guardAzimuthalDomain,
+  kernelParameters,
+  ORIGIN_PARAMETERS,
+  SCALE_PARAMETERS
+} from '../kernel';
+import {createState, forward, inverse} from '../kernels/stere';
+
+export const stereographic: ProjectionPlugin = {
+  name: 'stere',
+  aliases: [
+    'Stereographic_South_Pole',
+    'Polar_Stereographic_variant_A',
+    'Polar_Stereographic_variant_B',
+    'Polar_Stereographic'
+  ],
+  parameters: [...ORIGIN_PARAMETERS, ...SCALE_PARAMETERS, 'lat_ts'],
+  create(context) {
+    const base = kernelParameters(context);
+
+    return guardAzimuthalDomain(base, bindKernel('stere', createState(base), forward, inverse));
+  }
+};

package/src/experimental/projections/sterea.ts

@@ -0,0 +1,30 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ProjectionPlugin} from '../types';
+import {
+  bindKernel,
+  guardAzimuthalDomain,
+  kernelParameters,
+  ORIGIN_PARAMETERS,
+  SCALE_PARAMETERS
+} from '../kernel';
+import {createState, forward, inverse} from '../kernels/sterea';
+
+export const obliqueStereographic: ProjectionPlugin = {
+  name: 'sterea',
+  aliases: [
+    'Stereographic_North_Pole',
+    'Oblique_Stereographic',
+    'Oblique Stereographic Alternative',
+    'Double_Stereographic'
+  ],
+  parameters: [...ORIGIN_PARAMETERS, ...SCALE_PARAMETERS],
+  create(context) {
+    const base = kernelParameters(context);
+    if (Math.abs(base.lat0) === Math.PI / 2)
+      throw new Error('sterea requires a non-polar origin; use stere at the poles');
+    return guardAzimuthalDomain(base, bindKernel('sterea', createState(base), forward, inverse));
+  }
+};

package/src/experimental/projections/tpers.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/tpers';
+import {numberParameter} from '../parameters';
+
+export const tiltedPerspective: ProjectionPlugin = {
+  name: 'tpers',
+  aliases: ['Tilted_Perspective'],
+  parameters: ['lon_0', 'x_0', 'y_0', 'lat_0', 'h', 'tilt', 'azi'],
+  create(context) {
+    const base = catalogueParameters(context);
+    const h = numberParameter(context.parameters, 'h', 100000);
+    const tilt = (numberParameter(context.parameters, 'tilt', 0) * Math.PI) / 180;
+    const azi = (numberParameter(context.parameters, 'azi', 0) * Math.PI) / 180;
+    if (Math.abs(tilt) >= Math.PI / 2)
+      throw new Error('Perspective tilt must be between -90 and 90 degrees');
+    const state = createState(base, {h, tilt, azi});
+    return bindCatalogueKernel(
+      'tpers',
+      context,
+      state,
+      forward,
+      inverse,
+      horizonGuard(base, 1 / (1 + h / base.a))
+    );
+  }
+};

package/src/experimental/projections/transverse-mercator.ts

@@ -0,0 +1,68 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {createFlatProjection} from '../flat-projection';
+import type {ProjectionContext, ProjectionImplementation, ProjectionPlugin} from '../types';
+import {
+  bindKernel,
+  flagParameter,
+  kernelParameters,
+  ORIGIN_PARAMETERS,
+  SCALE_PARAMETERS
+} from '../kernel';
+import {
+  createState as createExtended,
+  forward as extendedForward,
+  inverse as extendedInverse
+} from '../kernels/etmerc';
+import {
+  createState as createFast,
+  forward as fastForward,
+  inverse as fastInverse
+} from '../kernels/tmerc';
+
+export function createTransverseMercator(context: ProjectionContext): ProjectionImplementation {
+  const base = kernelParameters(context);
+  if (flagParameter(context.parameters, 'approx')) {
+    return bindKernel(
+      'tmerc +approx',
+      createFast(base),
+      fastForward,
+      fastInverse,
+      createFlatProjection
+    );
+  }
+  if (base.sphere) throw new Error('Spherical transverse Mercator requires +approx');
+  return bindKernel(
+    'etmerc',
+    createExtended(base),
+    extendedForward,
+    extendedInverse,
+    createFlatProjection
+  );
+}
+
+/** Matches proj4js: tmerc uses the extended algorithm unless +approx is supplied. */
+export const transverseMercator: ProjectionPlugin = {
+  name: 'tmerc',
+  aliases: [
+    'Fast_Transverse_Mercator',
+    'Fast Transverse Mercator',
+    'Transverse_Mercator',
+    'Transverse Mercator',
+    'Gauss Kruger',
+    'Gauss_Kruger'
+  ],
+  parameters: [...ORIGIN_PARAMETERS, ...SCALE_PARAMETERS, 'approx'],
+  flags: ['approx'],
+  create: createTransverseMercator
+};
+
+export const extendedTransverseMercator: ProjectionPlugin = {
+  name: 'etmerc',
+  aliases: ['Extended_Transverse_Mercator', 'Extended Transverse Mercator'],
+  parameters: [...ORIGIN_PARAMETERS, ...SCALE_PARAMETERS, 'approx'],
+  flags: ['approx'],
+  create: createTransverseMercator
+};

package/src/experimental/projections/utm.ts

@@ -0,0 +1,33 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ProjectionPlugin} from '../types';
+import {numberParameter} from '../parameters';
+import {flagParameter} from '../kernel';
+import {createTransverseMercator} from './transverse-mercator';
+
+export const universalTransverseMercator: ProjectionPlugin = {
+  name: 'utm',
+  aliases: ['Universal Transverse Mercator System'],
+  parameters: ['zone', 'south', 'approx'],
+  flags: ['south', 'approx'],
+  create(context) {
+    const zone = numberParameter(context.parameters, 'zone', NaN);
+    if (!Number.isInteger(zone) || zone < 1 || zone > 60) {
+      throw new Error('UTM requires an integer +zone from 1 to 60');
+    }
+    const south = flagParameter(context.parameters, 'south');
+    return createTransverseMercator({
+      ...context,
+      parameters: {
+        ...context.parameters,
+        lat_0: '0',
+        lon_0: String(6 * zone - 183),
+        x_0: '500000',
+        y_0: south ? '10000000' : '0',
+        k_0: '0.9996'
+      }
+    });
+  }
+};

package/src/experimental/projections/vandg.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/vandg';
+
+export const vanDerGrinten: ProjectionPlugin = {
+  name: 'vandg',
+  aliases: ['Van_der_Grinten_I', 'VanDerGrinten', 'Van_der_Grinten'],
+  parameters: ['lon_0', 'x_0', 'y_0'],
+  create(context) {
+    const base = catalogueParameters(context);
+
+    const state = createState(base);
+    return bindCatalogueKernel('vandg', context, state, forward, inverse);
+  }
+};

package/src/experimental/scalar-output.ts

@@ -0,0 +1,74 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original caller-owned scalar output validation and commit helpers.
+import type {ProjectionPoint} from './types';
+
+export type ProjectionCoordinate = readonly number[] | Float32Array | Float64Array;
+export type ProjectionOutput = number[] | Float32Array | Float64Array;
+const FLOAT32_MAX = 3.4028234663852886e38;
+
+/** Validate storage before executing user hooks; no views or coordinate copies are created. */
+export function validateScalarOutput(
+  coordinate: ProjectionCoordinate,
+  output: ProjectionOutput,
+  length: number
+): void {
+  if (
+    !(
+      Array.isArray(coordinate) ||
+      coordinate instanceof Float32Array ||
+      coordinate instanceof Float64Array
+    )
+  )
+    throw new Error('Scalar input requires a number array, Float32Array or Float64Array');
+  if (
+    !(Array.isArray(output) || output instanceof Float32Array || output instanceof Float64Array) ||
+    output.length < length
+  )
+    throw new Error(
+      'Scalar output requires a preallocated number array, Float32Array or Float64Array with sufficient capacity'
+    );
+  if (coordinate === output || Array.isArray(coordinate) || Array.isArray(output)) return;
+  const input = coordinate as Float32Array | Float64Array;
+  const result = output as Float32Array | Float64Array;
+  const shared =
+    typeof SharedArrayBuffer !== 'undefined' &&
+    input.buffer instanceof SharedArrayBuffer &&
+    result.buffer instanceof SharedArrayBuffer;
+  // Cloned SharedArrayBuffer wrappers can refer to the same storage without === identity.
+  if (
+    (input.buffer === result.buffer || shared) &&
+    input.byteOffset < result.byteOffset + length * result.BYTES_PER_ELEMENT &&
+    result.byteOffset < input.byteOffset + input.byteLength
+  )
+    throw new Error('Scalar input/output views overlap; use the same view for in-place projection');
+}
+
+/** Numerical/storage overflow errors happen before committing any output ordinate. */
+export function writeScalarOutput<T extends ProjectionOutput>(
+  coordinate: ProjectionCoordinate,
+  output: T,
+  point: ProjectionPoint,
+  length: number
+): T {
+  if (output instanceof Float32Array) {
+    if (
+      Math.abs(point.x) > FLOAT32_MAX ||
+      Math.abs(point.y) > FLOAT32_MAX ||
+      (length >= 3 && Math.abs(point.z) > FLOAT32_MAX)
+    )
+      throw new Error('Projected coordinate exceeds Float32 range');
+    for (let i = 3; i < coordinate.length; i++) {
+      const value = coordinate[i];
+      if (Number.isFinite(value) && Math.abs(value) > FLOAT32_MAX)
+        throw new Error('Trailing ordinate exceeds Float32 range');
+    }
+  }
+  // XYZ have already been read into private scratch, so exact input/output identity is safe.
+  for (let i = 3; i < coordinate.length; i++) output[i] = coordinate[i];
+  output[0] = point.x;
+  output[1] = point.y;
+  if (length >= 3) output[2] = point.z;
+  return output;
+}