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

package/src/projection/experimental/grids/velocity-geotiff.ts

@@ -0,0 +1,82 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original adapter inspired by PROJ's Geodetic TIFF Grid specification, not a fork. Caller-owned TIFF decoding; no proj4js, PROJ or TIFF decoder code is copied here.
+import {prepareScalarGeoTIFFGrids} from './scalar-geotiff';
+import {velocityGridFromComponents} from './velocity';
+import type {VelocityGrid} from './velocity';
+import type {
+  VerticalGridGeoTIFF,
+  VerticalGridGeoTIFFData,
+  VerticalGridGeoTIFFImage
+} from './vertical-geotiff';
+export type VelocityGridGeoTIFF = VerticalGridGeoTIFF;
+export type VelocityGridGeoTIFFImage = VerticalGridGeoTIFFImage;
+export type VelocityGridGeoTIFFData = VerticalGridGeoTIFFData;
+
+/** Prepare geographic, north-up GTG VELOCITY images with explicit first-three ENU
+ * bands in millimetres per year. Accuracy bands are ignored. No model/frame/epoch
+ * inference. Decoded loaders.gl rasters and structural geotiff.js objects are accepted.
+ */
+export async function loadVelocityGeoTIFFGrid(
+  tiff: VelocityGridGeoTIFF | VelocityGridGeoTIFFData
+): Promise<VelocityGrid> {
+  const count = 'images' in tiff ? tiff.images.length : await tiff.getImageCount();
+  if (!Number.isSafeInteger(count) || count < 1)
+    throw new Error('Velocity GeoTIFF requires images');
+  const images: VerticalGridGeoTIFFImage[][] = [[], [], []];
+  const names = ['east_velocity', 'north_velocity', 'up_velocity'];
+  for (let index = 0; index < count; index++) {
+    const raster = 'images' in tiff ? tiff.images[index] : undefined;
+    const image = raster ? undefined : await (tiff as VelocityGridGeoTIFF).getImage(index);
+    const metadata = raster ? raster.metadata : await image.getGDALMetadata();
+    if (metadata?.['TYPE'] !== 'VELOCITY')
+      throw new Error('Velocity GeoTIFF requires TYPE=VELOCITY');
+    for (let component = 0; component < 3; component++) {
+      const band = raster?.bands.find(b => b.index === component);
+      if (raster && !band) throw new Error('Velocity GeoTIFF requires original ENU bands 0, 1, 2');
+      const bandMetadata = raster ? band.metadata : await image.getGDALMetadata(component);
+      if (
+        bandMetadata?.['DESCRIPTION'] !== names[component] ||
+        !['millimetres per year', 'mm/year'].includes(bandMetadata?.['UNITTYPE'] as string)
+      )
+        throw new Error(
+          'Velocity GeoTIFF requires explicit ENU descriptions and millimetres per year'
+        );
+      // Reuse scalar geometry, scale/offset, nodata, ownership and hierarchy checks.
+      // This internal view presents native millimetres as generic scalar values;
+      // conversion to metres/year occurs only after all three components are sampled.
+      images[component].push({
+        getWidth: () => (raster ? raster.width : image.getWidth()),
+        getHeight: () => (raster ? raster.height : image.getHeight()),
+        getGeoKeys: () => (raster ? raster.geoKeys : image.getGeoKeys()),
+        getGDALMetadata: sample =>
+          sample === 0
+            ? {...bandMetadata, DESCRIPTION: 'geoid_undulation', UNITTYPE: 'metre'}
+            : {...metadata, TYPE: 'VERTICAL_OFFSET_GEOGRAPHIC_TO_VERTICAL'},
+        getGDALNoData: () => (raster ? raster.noData : (image.getGDALNoData?.() ?? null)),
+        fileDirectory: raster ? raster.fileDirectory : image.fileDirectory,
+        readRasters: async () =>
+          raster ? [band.data] : image.readRasters({samples: [component], interleave: false})
+      });
+    }
+  }
+  const bands = await Promise.all(
+    images.map(list =>
+      prepareScalarGeoTIFFGrids({
+        getImageCount: async () => list.length,
+        getImage: async index => list[index]
+      })
+    )
+  );
+  const grids = bands[0].map((east, index) =>
+    velocityGridFromComponents(east, bands[1][index], bands[2][index], 0.001)
+  );
+  return Object.freeze({
+    sample(longitude, latitude, output): boolean {
+      for (let i = grids.length - 1; i >= 0; i--)
+        if (grids[i].sample(longitude, latitude, output)) return true;
+      return false;
+    }
+  });
+}

package/src/projection/experimental/grids/velocity.ts

@@ -0,0 +1,58 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original ENU grid preparation inspired by PROJ's velocity grid conventions. Bilinear interpolation reuses original math.gl vertical grids; no upstream fork.
+import {createVerticalGrid} from './vertical';
+import type {VerticalGridOptions} from './vertical';
+import type {ProjectionPoint} from '../types';
+import type {VerticalGrid} from './types';
+
+/** Prepared velocities in metres per decimal year at Greenwich lon/lat radians.
+ * sample writes ENU into output.x/y/z only on success. False means no coverage.
+ */
+export type VelocityGrid = {
+  sample(longitude: number, latitude: number, output: ProjectionPoint): boolean;
+};
+export type VelocityGridOptions = Omit<VerticalGridOptions, 'offsets'> & {
+  readonly units: 'm/year' | 'mm/year';
+  /** Owned snapshots, row-major south-to-north and west-to-east. */
+  readonly east: ArrayLike<number>;
+  readonly north: ArrayLike<number>;
+  readonly up: ArrayLike<number>;
+};
+/** Internal atomic three-band sampler: never mix components from different images. */
+export function velocityGridFromComponents(
+  east: VerticalGrid,
+  north: VerticalGrid,
+  up: VerticalGrid,
+  scale: number
+): VelocityGrid {
+  return Object.freeze({
+    sample(longitude: number, latitude: number, output: ProjectionPoint): boolean {
+      const e = east.getOffset(longitude, latitude),
+        n = north.getOffset(longitude, latitude),
+        u = up.getOffset(longitude, latitude);
+      if (e === undefined || n === undefined || u === undefined) return false;
+      const x = e * scale,
+        y = n * scale,
+        z = u * scale;
+      if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
+        throw new Error('Non-finite velocity interpolation');
+      output.x = x;
+      output.y = y;
+      output.z = z;
+      return true;
+    }
+  });
+}
+/** No extrapolation; nodata in any contributing component makes the sample unavailable. */
+export function createVelocityGrid(options: VelocityGridOptions): VelocityGrid {
+  if (!['m/year', 'mm/year'].includes(options.units))
+    throw new Error('Explicit velocity units required');
+  return velocityGridFromComponents(
+    createVerticalGrid({...options, offsets: options.east}),
+    createVerticalGrid({...options, offsets: options.north}),
+    createVerticalGrid({...options, offsets: options.up}),
+    options.units === 'mm/year' ? 0.001 : 1
+  );
+}

package/src/projection/experimental/grids/vertical-geotiff.ts

@@ -0,0 +1,28 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original adapter for PROJ's GTG conventions; no upstream decoder code is copied.
+import {prepareScalarGeoTIFFGrids} from './scalar-geotiff';
+import type {VerticalGrid} from './types';
+import type {VerticalGridGeoTIFF, VerticalGridGeoTIFFData} from './scalar-geotiff';
+export type {
+  VerticalGridGeoTIFF,
+  VerticalGridGeoTIFFImage,
+  VerticalGridGeoTIFFData
+} from './scalar-geotiff';
+
+/** Prepare owned geoid grids; later nested images take precedence with nodata fallback. */
+export async function loadVerticalGeoTIFFGrid(
+  tiff: VerticalGridGeoTIFF | VerticalGridGeoTIFFData
+): Promise<VerticalGrid> {
+  const grids = await prepareScalarGeoTIFFGrids(tiff);
+  return Object.freeze({
+    getOffset(longitude: number, latitude: number): number | undefined {
+      for (let i = grids.length - 1; i >= 0; i--) {
+        const value = grids[i].getOffset(longitude, latitude);
+        if (value !== undefined) return value;
+      }
+      return undefined;
+    }
+  });
+}

package/src/projection/experimental/grids/vertical.ts

@@ -0,0 +1,99 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original bilinear vertical grid and structural math.gl/geoid adapter. PROJ supplies independent numeric references; no upstream code is copied.
+import type {VerticalGrid} from './types';
+export type {VerticalGrid, VerticalGridCollection} from './types';
+
+export type VerticalGridOptions = {
+  /** Southwest node, [longitude, latitude] in degrees. */
+  origin: readonly [number, number];
+  /** Positive [longitude, latitude] node spacing in degrees. */
+  step: readonly [number, number];
+  size: readonly [number, number];
+  /** Row-major south-to-north, west-to-east geoid undulations in metres. Copied. */
+  offsets: ArrayLike<number>;
+  /** Non-finite values are also treated as nodata. */
+  noData?: number;
+};
+
+/** Prepare an owned, synchronous grid with inclusive edges and no extrapolation. */
+export function createVerticalGrid(options: VerticalGridOptions): VerticalGrid {
+  const [west, south] = options.origin;
+  const [dx, dy] = options.step;
+  const [width, height] = options.size;
+  const east = west + (width - 1) * dx;
+  const north = south + (height - 1) * dy;
+  if (
+    ![west, south, dx, dy, east, north].every(Number.isFinite) ||
+    ![width, height].every(n => Number.isSafeInteger(n) && n >= 2) ||
+    !(dx > 0 && dy > 0) ||
+    east - west > 360 ||
+    south < -90 ||
+    north > 90 ||
+    width * height !== options.offsets.length
+  )
+    throw new Error('Invalid vertical grid geometry or node count');
+  const noData = options.noData;
+  const values = Float64Array.from(options.offsets, value =>
+    value === noData || !Number.isFinite(value) ? NaN : value
+  );
+  return Object.freeze({
+    getOffset(longitude: number, latitude: number): number | undefined {
+      if (!Number.isFinite(longitude) || !Number.isFinite(latitude))
+        throw new Error('Vertical grid coordinates must be finite');
+      // Choose the equivalent longitude nearest the grid's centre, including
+      // grids expressed in 0..360 degrees or crossing the antimeridian.
+      let x = longitude * (180 / Math.PI);
+      const epsilon = 1e-10;
+      // Preserve either explicit edge of a grid with duplicate seam nodes.
+      if (x < west - epsilon * dx || x > east + epsilon * dx)
+        x += 360 * Math.round(((west + east) / 2 - x) / 360);
+      let col = (x - west) / dx;
+      let row = (latitude * (180 / Math.PI) - south) / dy;
+      if (
+        !Number.isFinite(col) ||
+        !Number.isFinite(row) ||
+        col < -epsilon ||
+        row < -epsilon ||
+        col > width - 1 + epsilon ||
+        row > height - 1 + epsilon
+      )
+        return undefined;
+      col = Math.max(0, Math.min(width - 1, col));
+      row = Math.max(0, Math.min(height - 1, row));
+      const i = Math.min(width - 2, Math.floor(col));
+      const j = Math.min(height - 2, Math.floor(row));
+      const u = col - i,
+        v = row - j;
+      let offset = 0;
+      for (let n = 0; n < 4; n++) {
+        const right = n % 2,
+          upper = n > 1;
+        const weight = (right ? u : 1 - u) * (upper ? v : 1 - v);
+        if (!weight) continue;
+        const value = values[(j + (upper ? 1 : 0)) * width + i + right];
+        if (!Number.isFinite(value)) return undefined;
+        offset += weight * value;
+      }
+      return offset;
+    }
+  });
+}
+
+/** Adapt an already loaded @math.gl/earth/geoid Geoid without importing its implementation.
+ * The supplied model owns its data and interpolation choice; do not mutate it while in use.
+ */
+export function createGeoidGrid(geoid: {
+  getHeight(latitude: number, longitude: number): number;
+}): VerticalGrid {
+  if (!geoid || typeof geoid.getHeight !== 'function') throw new Error('Invalid geoid model');
+  return Object.freeze({
+    getOffset(longitude: number, latitude: number): number | undefined {
+      if (!Number.isFinite(longitude) || !Number.isFinite(latitude))
+        throw new Error('Vertical grid coordinates must be finite');
+      const offset = geoid.getHeight(latitude * (180 / Math.PI), longitude * (180 / Math.PI));
+      return Number.isFinite(offset) ? offset : undefined;
+    }
+  });
+}

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

@@ -0,0 +1,76 @@
+// 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) 2016, Thomas Knudsen / SDFE (PROJ)
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original whole-buffer dispatch. Small-angle equations follow the proj4js adaptation in datum.ts; see ../../PROJ4-LICENSE.md. Exact equations follow exact-helmert.ts, adapted from PROJ 9.5.1 helmert.cpp; see ../../PROJ-LICENSE.txt. Consume its prepared matrix without recomputing rotations.
+import type {NumericFlatOperation} from './numeric-flat';
+
+/** Setup-owned coefficients: small-angle rx/ry/rz or row-major exact matrix, then dx/dy/dz/scale. */
+export function createHelmertFlat(
+  coefficients: readonly number[],
+  inverse: boolean,
+  exact: boolean
+): NumericFlatOperation {
+  const dx = coefficients[9],
+    dy = coefficients[10],
+    dz = coefficients[11],
+    scale = coefficients[12];
+  const a = coefficients[0],
+    b = coefficients[1],
+    c = coefficients[2],
+    d = coefficients[3],
+    e = coefficients[4],
+    f = coefficients[5],
+    g = coefficients[6],
+    h = coefficients[7],
+    j = coefficients[8];
+  return (coordinates, dimension, epochs) => {
+    const float32 = coordinates instanceof Float32Array;
+    const epochBuffer = typeof epochs === 'number' ? undefined : epochs;
+    for (let offset = 0, record = 0; offset < coordinates.length; offset += dimension, record++) {
+      let x = coordinates[offset],
+        y = coordinates[offset + 1],
+        z = coordinates[offset + 2];
+      if (epochBuffer && !Number.isFinite(epochBuffer[record]))
+        throw new Error('Coordinate epoch must be a finite decimal year');
+      if (!Number.isFinite(x) || !Number.isFinite(y) || !Number.isFinite(z))
+        throw new Error('Pipeline coordinate must be finite');
+      if (inverse) {
+        x = (x - dx) / scale;
+        y = (y - dy) / scale;
+        z = (z - dz) / scale;
+      }
+      let outX: number, outY: number, outZ: number;
+      if (exact) {
+        if (inverse) {
+          outX = a * x + d * y + g * z;
+          outY = b * x + e * y + h * z;
+          outZ = c * x + f * y + j * z;
+        } else {
+          outX = scale * (a * x + b * y + c * z) + dx;
+          outY = scale * (d * x + e * y + f * z) + dy;
+          outZ = scale * (g * x + h * y + j * z) + dz;
+        }
+      } else if (inverse) {
+        outX = x + c * y - b * z;
+        outY = -c * x + y + a * z;
+        outZ = b * x - a * y + z;
+      } else {
+        outX = scale * (x - c * y + b * z) + dx;
+        outY = scale * (c * x + y - a * z) + dy;
+        outZ = scale * (-b * x + a * y + z) + dz;
+      }
+      if (!Number.isFinite(outX) || !Number.isFinite(outY) || !Number.isFinite(outZ))
+        throw new Error('Pipeline coordinate must be finite');
+      if (
+        float32 &&
+        Math.max(Math.abs(outX), Math.abs(outY), Math.abs(outZ)) > 3.4028234663852886e38
+      )
+        throw new Error('Pipeline output exceeds Float32 range');
+      coordinates[offset] = outX;
+      coordinates[offset + 1] = outY;
+      coordinates[offset + 2] = outZ;
+    }
+  };
+}

package/src/projection/experimental/index.ts

@@ -0,0 +1,59 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+export * from './core';
+export {mercator} from './projections/mercator';
+export {equidistantCylindrical} from './projections/equidistant-cylindrical';
+export {lambertConformalConic} from './projections/lcc';
+export {albersEqualArea} from './projections/aea';
+export {equidistantConic} from './projections/eqdc';
+export {lambertAzimuthalEqualArea} from './projections/laea';
+export {stereographic} from './projections/stere';
+export {obliqueStereographic} from './projections/sterea';
+export {azimuthalEquidistant} from './projections/aeqd';
+export {transverseMercator, extendedTransverseMercator} from './projections/transverse-mercator';
+export {universalTransverseMercator} from './projections/utm';
+export {geocentric} from './projections/geocentric';
+export {bonne} from './projections/bonne';
+export {cassiniSoldner} from './projections/cass';
+export {cylindricalEqualArea} from './projections/cea';
+export {eckertVI} from './projections/eck6';
+export {equalEarth} from './projections/eqearth';
+export {equirectangular} from './projections/equi';
+export {geostationary} from './projections/geos';
+export {gnomonic} from './projections/gnom';
+export {gaussSchreiberTransverseMercator} from './projections/gstmerc';
+export {krovak} from './projections/krovak';
+export {millerCylindrical} from './projections/mill';
+export {mollweide} from './projections/moll';
+export {newZealandMapGrid} from './projections/nzmg';
+export {obliqueMercator} from './projections/omerc';
+export {orthographic} from './projections/ortho';
+export {polyconic} from './projections/poly';
+export {quadrilateralizedSphericalCube} from './projections/qsc';
+export {robinson} from './projections/robin';
+export {sinusoidal} from './projections/sinu';
+export {swissObliqueMercator} from './projections/somerc';
+export {tiltedPerspective} from './projections/tpers';
+export {vanDerGrinten} from './projections/vandg';
+export {obliqueTransformation} from './projections/ob-tran';
+export {wktCRSParser} from './crs/wkt';
+export {projJSONCRSParser} from './crs/projjson';
+export {parseNTv2Grid} from './grids/ntv2';
+export type {NTv2GridOptions} from './grids/ntv2';
+export {loadGeoTIFFGrid} from './grids/geotiff';
+export type {DatumGridGeoTIFF, DatumGridGeoTIFFImage} from './grids/geotiff';
+
+export {parseGTXGrid} from './grids/gtx';
+export {createVerticalGrid, createGeoidGrid} from './grids/vertical';
+export type {VerticalGridOptions} from './grids/vertical';
+
+export {loadVerticalGeoTIFFGrid} from './grids/vertical-geotiff';
+export type {
+  VerticalGridGeoTIFF,
+  VerticalGridGeoTIFFImage,
+  VerticalGridGeoTIFFData
+} from './grids/vertical-geotiff';
+
+export * from './projection-pipeline';

package/src/projection/experimental/kernel.ts

@@ -0,0 +1,142 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {createProjection, projectionOperation} from './mutable-projection';
+import {DEGREES_TO_RADIANS, numberParameter} from './parameters';
+import type {ProjectionContext, ProjectionImplementation, ProjectionParameters} from './types';
+
+export type Point = {x: number; y: number};
+
+/** Fully initialized inputs to numerical kernels. Angles are radians, lengths meters. */
+export type KernelParameters = {
+  primeMeridian: number;
+  a: number;
+  b: number;
+  e: number;
+  es: number;
+  ep2: number;
+  sphere: boolean;
+  over: boolean;
+  long0: number;
+  lat0: number;
+  lat1: number;
+  lat2: number;
+  /** NaN means a latitude of true scale was not supplied. */
+  lat_ts: number;
+  x0: number;
+  y0: number;
+  k0: number;
+};
+
+export const ORIGIN_PARAMETERS = ['lon_0', 'lat_0', 'x_0', 'y_0'] as const;
+export const SCALE_PARAMETERS = ['k', 'k_0'] as const;
+
+export function angleParameter(
+  parameters: ProjectionParameters,
+  name: string,
+  fallback = 0
+): number {
+  const degrees = numberParameter(parameters, name, fallback);
+  if (name !== 'lon_0' && Math.abs(degrees) > 90) {
+    throw new Error('Latitude parameter must be between -90 and 90 degrees: +' + name);
+  }
+  return degrees * DEGREES_TO_RADIANS;
+}
+
+export function flagParameter(parameters: ProjectionParameters, name: string): boolean {
+  const present = Object.prototype.hasOwnProperty.call(parameters, name);
+  if (present && parameters[name] !== undefined)
+    throw new Error('Expected a flag without a value: +' + name);
+  return present;
+}
+
+export function kernelParameters({
+  semiMajorAxis: a,
+  eccentricitySquared: es,
+  parameters,
+  primeMeridian = 0
+}: ProjectionContext): KernelParameters {
+  const k0 = numberParameter(parameters, 'k_0', numberParameter(parameters, 'k', 1));
+  if (k0 <= 0) throw new Error('Projection scale must be positive');
+  return {
+    primeMeridian,
+    a,
+    b: a * Math.sqrt(1 - es),
+    es,
+    e: Math.sqrt(es),
+    ep2: es / (1 - es),
+    sphere: es === 0,
+    over: flagParameter(parameters, 'over'),
+    long0: angleParameter(parameters, 'lon_0'),
+    lat0: angleParameter(parameters, 'lat_0'),
+    lat1: angleParameter(parameters, 'lat_1'),
+    lat2: angleParameter(parameters, 'lat_2', numberParameter(parameters, 'lat_1', 0)),
+    lat_ts: angleParameter(parameters, 'lat_ts', NaN),
+    x0: numberParameter(parameters, 'x_0', 0),
+    y0: numberParameter(parameters, 'y_0', 0),
+    k0
+  };
+}
+
+export function validateConic(base: KernelParameters, parameters: ProjectionParameters): void {
+  if (!Object.prototype.hasOwnProperty.call(parameters, 'lat_1')) {
+    throw new Error('Conic projections require +lat_1');
+  }
+  if (
+    Math.abs(base.lat1 + base.lat2) < 1e-10 ||
+    Math.abs(base.lat1) >= Math.PI / 2 ||
+    Math.abs(base.lat2) >= Math.PI / 2
+  ) {
+    throw new Error('Conic standard parallels must not be opposite or at a pole');
+  }
+}
+
+/** Adapt kernels with explicit state into the allocation-isolated public plugin contract. */
+export function bindKernel<State>(
+  name: string,
+  state: State,
+  forward: (state: State, point: Point) => Point | null | undefined | number,
+  inverse: (state: State, point: Point) => Point | null | undefined | number,
+  adapt = createProjection
+): ProjectionImplementation {
+  const run = (operation: typeof forward, point: Point): void => {
+    const result = operation(state, point);
+    if (
+      !result ||
+      typeof result !== 'object' ||
+      !Number.isFinite(result.x) ||
+      !Number.isFinite(result.y)
+    )
+      throw new Error(name + ': coordinate outside projection domain or inverse did not converge');
+    point.x = result.x;
+    point.y = result.y;
+  };
+  return adapt(
+    point => run(forward, point),
+    point => run(inverse, point)
+  );
+}
+
+/** Azimuthal antipodes have no unique azimuth; reject even when roundoff is finite. */
+export function guardAzimuthalDomain(
+  base: KernelParameters,
+  implementation: ProjectionImplementation
+): ProjectionImplementation {
+  const forward = projectionOperation(implementation, false);
+  return createProjection(
+    point => {
+      const longitude = point.x,
+        latitude = point.y;
+      const delta = Math.atan2(Math.sin(longitude - base.long0), Math.cos(longitude - base.long0));
+      const polar = Math.abs(Math.abs(base.lat0) - Math.PI / 2) < 1e-10;
+      if (
+        Math.abs(latitude + base.lat0) < 1e-10 &&
+        (polar || Math.abs(Math.abs(delta) - Math.PI) < 1e-10)
+      )
+        throw new Error('Azimuthal projection is undefined at the antipode');
+      forward(point);
+    },
+    projectionOperation(implementation, true)
+  );
+}