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

package/src/projection/analysis.ts

@@ -0,0 +1,284 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original domain enforcement, numerical differentiation and cartographic factors.
+import {NumericalDerivative} from './numerical-derivative';
+import type {
+  ProjectionContext,
+  ProjectionImplementation,
+  ProjectionPlugin,
+  ProjectionPoint
+} from './experimental/types';
+
+/** Closed geographic rectangle in radians, without antimeridian wrapping. */
+export type ProjectionDomain = {
+  readonly west: number;
+  readonly east: number;
+  readonly south: number;
+  readonly north: number;
+};
+/** Physical projected-axis units per input radian. No datum or CRS axis/unit stages. */
+export type ProjectionJacobian = {
+  dxDLongitude: number;
+  dxDLatitude: number;
+  dyDLongitude: number;
+  dyDLatitude: number;
+};
+export type ProjectionFactors = ProjectionJacobian & {
+  meridionalScale: number;
+  parallelScale: number;
+  arealScale: number;
+  meridianConvergence: number;
+  meridianParallelAngle: number;
+  angularDistortion: number;
+  maximumScale: number;
+  minimumScale: number;
+};
+export type ProjectionAnalysisOptions = {
+  projection: ProjectionPlugin;
+  context: ProjectionContext;
+  /** Ellipsoid used to measure ground distances, independently of the projection kernel.
+   * Axes are in the kernel's physical output units. Defaults to context geometry.
+   * Changes factors only; projected coordinates and raw Jacobians are unchanged.
+   */
+  groundEllipsoid?: Pick<ProjectionContext, 'semiMajorAxis' | 'eccentricitySquared'>;
+  /** Application-qualified region, not a promise of a globally valid algorithm. */
+  domain: ProjectionDomain;
+  /** Central difference step in radians. Default 1e-4; stencil uses +/-2 steps. */
+  step?: number;
+  /** Agreement required between fourth-order stencils at step and half-step. */
+  derivativeTolerance?: number;
+};
+export function createProjectionJacobian(): ProjectionJacobian {
+  return {dxDLongitude: 0, dxDLatitude: 0, dyDLongitude: 0, dyDLatitude: 0};
+}
+export function createProjectionFactors(): ProjectionFactors {
+  return {
+    ...createProjectionJacobian(),
+    meridionalScale: 0,
+    parallelScale: 0,
+    arealScale: 0,
+    meridianConvergence: 0,
+    meridianParallelAngle: 0,
+    angularDistortion: 0,
+    maximumScale: 0,
+    minimumScale: 0
+  };
+}
+
+/** Optional single-projection analysis. Allocate scratch once; reuse all method outputs.
+ * false leaves outputs untouched. Plugin errors, nonfinite values, domain edges,
+ * singularities and unresolved derivatives are observable failures. Recursive plugin
+ * calls fail while scratch is in use; output setters can safely reenter afterwards.
+ */
+export class ProjectionAnalysis {
+  readonly domain: ProjectionDomain;
+  private readonly implementation: ProjectionImplementation;
+  private readonly a: number;
+  private readonly groundSemiMajorAxis: number;
+  private readonly groundEs: number;
+  private readonly step: number;
+  private readonly tolerance: number;
+  private readonly point: ProjectionPoint = {x: 0, y: 0, z: 0};
+  // Internal row-major Jacobian scratch; public outputs retain named fields.
+  private readonly derivative = [0, 0, 0, 0];
+  private busy = false;
+  private longitude = 0;
+  private latitude = 0;
+  private axis = 0;
+  private readonly numerical = new NumericalDerivative((offset, output) => {
+    if (
+      !this.sample(
+        this.longitude + (this.axis === 0 ? offset : 0),
+        this.latitude + (this.axis === 1 ? offset : 0)
+      )
+    )
+      return false;
+    output[0] = this.point.x;
+    output[1] = this.point.y;
+    output[2] = 0;
+    return true;
+  });
+  constructor(options: ProjectionAnalysisOptions) {
+    const {semiMajorAxis: a} = options.context;
+    const ground = options.groundEllipsoid ?? options.context;
+    const {west, east, south, north} = options.domain;
+    const step = options.step ?? 1e-4,
+      tolerance = options.derivativeTolerance ?? 1e-6;
+    if (
+      !(
+        [options.context, ground].every(
+          ({semiMajorAxis, eccentricitySquared}) =>
+            Number.isFinite(semiMajorAxis) &&
+            semiMajorAxis > 0 &&
+            Number.isFinite(eccentricitySquared) &&
+            eccentricitySquared >= 0 &&
+            eccentricitySquared < 1
+        ) &&
+        Number.isFinite(west) &&
+        Number.isFinite(east) &&
+        west < east &&
+        west >= -Math.PI &&
+        east <= Math.PI &&
+        Number.isFinite(south) &&
+        Number.isFinite(north) &&
+        south < north &&
+        south >= -Math.PI / 2 &&
+        north <= Math.PI / 2 &&
+        Number.isFinite(step) &&
+        step > 0 &&
+        step < 0.1 &&
+        Number.isFinite(tolerance) &&
+        tolerance > 0 &&
+        tolerance < 1
+      )
+    ) {
+      throw new Error('Invalid projection analysis geometry, domain or derivative options');
+    }
+    this.domain = Object.freeze({west, east, south, north});
+    this.implementation = options.projection.create(options.context);
+    if (!this.implementation.forwardInPlace || !this.implementation.inverseInPlace) {
+      throw new Error('Projection analysis requires mutable horizontal projection hooks');
+    }
+    this.a = a;
+    this.groundSemiMajorAxis = ground.semiMajorAxis;
+    this.groundEs = ground.eccentricitySquared;
+    this.step = step;
+    this.tolerance = tolerance;
+  }
+  contains(longitude: number, latitude: number): boolean {
+    const {west, east, south, north} = this.domain;
+    return (
+      Number.isFinite(longitude) &&
+      Number.isFinite(latitude) &&
+      longitude >= west &&
+      longitude <= east &&
+      latitude >= south &&
+      latitude <= north
+    );
+  }
+  projectTo(longitude: number, latitude: number, result: ProjectionPoint): boolean {
+    if (this.busy || !this.contains(longitude, latitude)) return false;
+    this.busy = true;
+    let x: number, y: number;
+    try {
+      if (!this.sample(longitude, latitude)) return false;
+      x = this.point.x;
+      y = this.point.y;
+    } finally {
+      this.busy = false;
+    }
+    result.x = x;
+    result.y = y;
+    return true;
+  }
+  unprojectTo(x: number, y: number, result: ProjectionPoint): boolean {
+    if (this.busy || !Number.isFinite(x) || !Number.isFinite(y)) return false;
+    this.busy = true;
+    let longitude: number, latitude: number;
+    try {
+      this.point.x = x;
+      this.point.y = y;
+      this.point.z = 0;
+      try {
+        this.implementation.inverseInPlace!(this.point);
+      } catch {
+        return false;
+      }
+      longitude = this.point.x;
+      latitude = this.point.y;
+      if (!this.contains(longitude, latitude)) return false;
+    } finally {
+      this.busy = false;
+    }
+    result.x = longitude;
+    result.y = latitude;
+    return true;
+  }
+  jacobian(longitude: number, latitude: number, result: ProjectionJacobian): boolean {
+    if (!this.calculate(longitude, latitude)) return false;
+    // Snapshot before writing caller-owned outputs, whose setters can reenter.
+    const [xx, xy, yx, yy] = this.derivative;
+    result.dxDLongitude = xx;
+    result.dxDLatitude = xy;
+    result.dyDLongitude = yx;
+    result.dyDLatitude = yy;
+    return true;
+  }
+  factors(longitude: number, latitude: number, result: ProjectionFactors): boolean {
+    if (!this.calculate(longitude, latitude)) return false;
+    // Snapshot before writing caller-owned outputs, whose setters can reenter.
+    const [xx, xy, yx, yy] = this.derivative;
+    const a = this.groundSemiMajorAxis;
+    const es = this.groundEs;
+    const d = 1 - es * Math.sin(latitude) ** 2;
+    const parallelRadius = (a * Math.cos(latitude)) / Math.sqrt(d);
+    const meridionalRadius = (a * (1 - es)) / (d * Math.sqrt(d));
+    const ex = xx / parallelRadius,
+      ey = yx / parallelRadius;
+    const nx = xy / meridionalRadius,
+      ny = yy / meridionalRadius;
+    const k = Math.hypot(ex, ey),
+      h = Math.hypot(nx, ny),
+      area = ex * ny - ey * nx;
+    // Singular values of the local east/north map; retain a signed area determinant.
+    const sum = Math.hypot(ex + ny, ey - nx),
+      difference = Math.hypot(ex - ny, ey + nx);
+    const maximum = (sum + difference) / 2;
+    const minimum = maximum > 0 ? Math.min(maximum, Math.abs(area) / maximum) : 0;
+    if (
+      !(
+        Number.isFinite(maximum) &&
+        minimum > maximum * 1e-12 &&
+        Number.isFinite(h) &&
+        Number.isFinite(k)
+      )
+    )
+      return false;
+    const angle = Math.atan2(Math.abs(area), Math.abs(ex * nx + ey * ny));
+    const convergence = -Math.atan2(xy, yy);
+    const distortion = 2 * Math.asin(Math.min(1, (maximum - minimum) / (maximum + minimum)));
+    result.dxDLongitude = xx;
+    result.dxDLatitude = xy;
+    result.dyDLongitude = yx;
+    result.dyDLatitude = yy;
+    result.meridionalScale = h;
+    result.parallelScale = k;
+    result.arealScale = area;
+    result.meridianConvergence = convergence;
+    result.meridianParallelAngle = angle;
+    result.angularDistortion = distortion;
+    result.maximumScale = maximum;
+    result.minimumScale = minimum;
+    return true;
+  }
+  private sample(longitude: number, latitude: number): boolean {
+    if (!this.contains(longitude, latitude)) return false;
+    this.point.x = longitude;
+    this.point.y = latitude;
+    this.point.z = 0;
+    try {
+      this.implementation.forwardInPlace!(this.point);
+    } catch {
+      return false;
+    }
+    return Number.isFinite(this.point.x) && Number.isFinite(this.point.y);
+  }
+  private calculate(longitude: number, latitude: number): boolean {
+    if (this.busy) return false;
+    this.busy = true;
+    try {
+      this.longitude = longitude;
+      this.latitude = latitude;
+      for (let axis = 0; axis < 2; axis++) {
+        this.axis = axis;
+        if (!this.numerical.evaluate(this.step, this.a, this.tolerance)) return false;
+        this.derivative[axis] = this.numerical.result[0];
+        this.derivative[axis + 2] = this.numerical.result[1];
+      }
+      return true;
+    } finally {
+      this.busy = false;
+    }
+  }
+}

package/src/projection/bulk.ts

@@ -0,0 +1,343 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original reusable interleaved/column buffer transforms with explicit storage contracts.
+import type {ProjectionCoordinate, ProjectionOutput} from './experimental/scalar-output';
+import type {ProjectionArray} from './experimental/typescript-projection';
+import type {PipelineEpochs} from './experimental/projection-pipeline';
+
+/** ProjectionTransform, Projection or ProjectionPipeline with synchronous reusable outputs.
+ * Lazy projections must have been preloaded. Epochs are interpreted by the supplied transform.
+ */
+export type BulkProjection = {
+  projectToSync<T extends ProjectionOutput>(
+    coordinate: ProjectionCoordinate,
+    result: T,
+    epoch?: number
+  ): T;
+  unprojectToSync<T extends ProjectionOutput>(
+    coordinate: ProjectionCoordinate,
+    result: T,
+    epoch?: number
+  ): T;
+};
+export type ProjectionBufferOptions = {
+  projection: BulkProjection;
+  dimension?: number;
+  /** Element offsets relative to the supplied typed-array views. Default zero. */
+  inputOffset?: number;
+  outputOffset?: number;
+  /** Elements per record; defaults to dimension for interleaved, one for columns. */
+  inputStride?: number;
+  outputStride?: number;
+};
+type Scratch = {input: Float64Array; output: Float64Array};
+function createScratch(dimension: number): Scratch {
+  return {input: new Float64Array(dimension), output: new Float64Array(dimension)};
+}
+function isBuffer(value: unknown): value is ProjectionArray {
+  return value instanceof Float32Array || value instanceof Float64Array;
+}
+function shared(buffer: ArrayBufferLike): boolean {
+  return typeof SharedArrayBuffer !== 'undefined' && buffer instanceof SharedArrayBuffer;
+}
+function overlap(
+  a: ProjectionArray,
+  aStart: number,
+  aEnd: number,
+  b: ProjectionArray,
+  bStart: number,
+  bEnd: number
+): boolean {
+  return (
+    (a.buffer === b.buffer || (shared(a.buffer) && shared(b.buffer))) &&
+    aStart < bEnd &&
+    bStart < aEnd
+  );
+}
+function capacity(length: number, offset: number, stride: number, width: number): number {
+  return length < offset + width ? 0 : Math.floor((length - offset - width) / stride) + 1;
+}
+
+/** Capture a layout once, reuse scratch and output buffers for each batch/chunk.
+ * Validation errors write nothing. Coordinate failures preserve the failed record and
+ * commit preceding records. Input/output storage must be disjoint or exactly mapped
+ * in place; shifted overlap is rejected before transformation. All offsets/counts
+ * refer to records/elements of the supplied views, never to the backing buffer.
+ */
+export class ProjectionBuffer {
+  readonly dimension: number;
+  private readonly projection: BulkProjection;
+  private readonly inputOffset: number;
+  private readonly outputOffset: number;
+  private readonly inputStride?: number;
+  private readonly outputStride?: number;
+  private readonly scratch: Scratch[];
+  private depth = 0;
+  constructor(options: ProjectionBufferOptions) {
+    const dimension = options.dimension ?? 2;
+    const inputOffset = options.inputOffset ?? 0,
+      outputOffset = options.outputOffset ?? 0;
+    if (
+      !Number.isSafeInteger(dimension) ||
+      dimension < 2 ||
+      !Number.isSafeInteger(inputOffset) ||
+      inputOffset < 0 ||
+      !Number.isSafeInteger(outputOffset) ||
+      outputOffset < 0 ||
+      (options.inputStride !== undefined &&
+        (!Number.isSafeInteger(options.inputStride) || options.inputStride < 1)) ||
+      (options.outputStride !== undefined &&
+        (!Number.isSafeInteger(options.outputStride) || options.outputStride < 1)) ||
+      typeof options.projection?.projectToSync !== 'function' ||
+      typeof options.projection?.unprojectToSync !== 'function'
+    ) {
+      throw new Error('Invalid projection buffer transform or layout');
+    }
+    this.dimension = dimension;
+    this.projection = options.projection;
+    this.inputOffset = inputOffset;
+    this.outputOffset = outputOffset;
+    this.inputStride = options.inputStride;
+    this.outputStride = options.outputStride;
+    this.scratch = [createScratch(dimension)];
+  }
+  projectFlatTo<T extends ProjectionArray>(
+    input: ProjectionArray,
+    output: T,
+    count?: number,
+    start = 0,
+    epochs?: PipelineEpochs
+  ): T {
+    return this.flat(input, output, count, start, false, epochs);
+  }
+  unprojectFlatTo<T extends ProjectionArray>(
+    input: ProjectionArray,
+    output: T,
+    count?: number,
+    start = 0,
+    epochs?: PipelineEpochs
+  ): T {
+    return this.flat(input, output, count, start, true, epochs);
+  }
+  projectColumnsTo<T extends readonly ProjectionArray[]>(
+    input: readonly ProjectionArray[],
+    output: T,
+    count?: number,
+    start = 0,
+    epochs?: PipelineEpochs
+  ): T {
+    return this.columns(input, output, count, start, false, epochs);
+  }
+  unprojectColumnsTo<T extends readonly ProjectionArray[]>(
+    input: readonly ProjectionArray[],
+    output: T,
+    count?: number,
+    start = 0,
+    epochs?: PipelineEpochs
+  ): T {
+    return this.columns(input, output, count, start, true, epochs);
+  }
+  private range(available: number, count: number | undefined, start: number): number {
+    const records = count ?? Math.max(0, available - start);
+    if (
+      !Number.isSafeInteger(start) ||
+      start < 0 ||
+      !Number.isSafeInteger(records) ||
+      records < 0 ||
+      !Number.isSafeInteger(start + records) ||
+      start + records > available
+    )
+      throw new Error('Invalid projection buffer record range');
+    return records;
+  }
+  private epochStorage(epochs: PipelineEpochs | undefined, start: number, count: number): void {
+    if (epochs === undefined) return;
+    if (typeof epochs === 'number') {
+      if (!Number.isFinite(epochs)) throw new Error('Coordinate epoch must be finite');
+    } else if (!isBuffer(epochs) || epochs.length < start + count)
+      throw new Error('Epoch buffer requires one value per addressed record');
+  }
+  private aliases(
+    input: ProjectionArray,
+    output: ProjectionArray,
+    start: number,
+    count: number,
+    inputStride: number,
+    outputStride: number,
+    width: number
+  ): void {
+    if (!count) return;
+    const ia =
+      input.byteOffset + (this.inputOffset + start * inputStride) * input.BYTES_PER_ELEMENT;
+    const ib = ia + ((count - 1) * inputStride + width) * input.BYTES_PER_ELEMENT;
+    const oa =
+      output.byteOffset + (this.outputOffset + start * outputStride) * output.BYTES_PER_ELEMENT;
+    const ob = oa + ((count - 1) * outputStride + width) * output.BYTES_PER_ELEMENT;
+    const exact =
+      input.buffer === output.buffer &&
+      input.constructor === output.constructor &&
+      ia === oa &&
+      inputStride === outputStride;
+    if (overlap(input, ia, ib, output, oa, ob) && !exact)
+      throw new Error('Projection input/output ranges overlap without an exact in-place mapping');
+  }
+  private epochAlias(
+    epochs: PipelineEpochs | undefined,
+    output: ProjectionArray,
+    start: number,
+    count: number,
+    stride: number,
+    width: number
+  ): void {
+    if (typeof epochs !== 'object' || !epochs || !count) return;
+    const a = epochs.byteOffset + start * epochs.BYTES_PER_ELEMENT;
+    const b = a + count * epochs.BYTES_PER_ELEMENT;
+    const c = output.byteOffset + (this.outputOffset + start * stride) * output.BYTES_PER_ELEMENT;
+    const d = c + ((count - 1) * stride + width) * output.BYTES_PER_ELEMENT;
+    if (overlap(epochs, a, b, output, c, d))
+      throw new Error('Epoch and output buffers must not overlap');
+  }
+  private acquire(): Scratch {
+    const depth = this.depth++;
+    this.scratch[depth] ||= createScratch(this.dimension);
+    return this.scratch[depth];
+  }
+  private transform(scratch: Scratch, inverse: boolean, epoch: number | undefined): void {
+    if (epoch !== undefined && !Number.isFinite(epoch))
+      throw new Error('Coordinate epoch must be finite');
+    if (inverse) this.projection.unprojectToSync(scratch.input, scratch.output, epoch);
+    else this.projection.projectToSync(scratch.input, scratch.output, epoch);
+  }
+  private floatRange(result: Float64Array, float32: boolean): void {
+    // Nonfinite M/payload is allowed, but finite values must fit the output type.
+    for (let i = 0; i < this.dimension; i++) {
+      const value = result[i];
+      if (
+        (i < 3 && !Number.isFinite(value)) ||
+        (float32 && Number.isFinite(value) && Math.abs(value) > 3.4028234663852886e38)
+      )
+        throw new Error('Projection output is nonfinite or exceeds Float32 range');
+    }
+  }
+  private flat<T extends ProjectionArray>(
+    input: ProjectionArray,
+    output: T,
+    count: number | undefined,
+    start: number,
+    inverse: boolean,
+    epochs?: PipelineEpochs
+  ): T {
+    if (!isBuffer(input) || !isBuffer(output))
+      throw new Error('Projection buffers require Float32Array or Float64Array');
+    const inputStride = this.inputStride ?? this.dimension,
+      outputStride = this.outputStride ?? this.dimension;
+    if (inputStride < this.dimension || outputStride < this.dimension)
+      throw new Error('Interleaved stride must contain every ordinate');
+    const records = this.range(
+      capacity(input.length, this.inputOffset, inputStride, this.dimension),
+      count,
+      start
+    );
+    if (start + records > capacity(output.length, this.outputOffset, outputStride, this.dimension))
+      throw new Error('Projection output buffer is too short');
+    this.epochStorage(epochs, start, records);
+    this.aliases(input, output, start, records, inputStride, outputStride, this.dimension);
+    this.epochAlias(epochs, output, start, records, outputStride, this.dimension);
+    const scratch = this.acquire();
+    try {
+      const epochBuffer = typeof epochs === 'number' ? undefined : epochs;
+      const float32 = output instanceof Float32Array;
+      for (let record = start; record < start + records; record++) {
+        const source = this.inputOffset + record * inputStride,
+          target = this.outputOffset + record * outputStride;
+        for (let i = 0; i < this.dimension; i++) scratch.input[i] = input[source + i];
+        this.transform(
+          scratch,
+          inverse,
+          epochBuffer ? epochBuffer[record] : (epochs as number | undefined)
+        );
+        this.floatRange(scratch.output, float32);
+        for (let i = 0; i < this.dimension; i++) output[target + i] = scratch.output[i];
+      }
+      return output;
+    } finally {
+      this.depth--;
+    }
+  }
+  private columns<T extends readonly ProjectionArray[]>(
+    input: readonly ProjectionArray[],
+    output: T,
+    count: number | undefined,
+    start: number,
+    inverse: boolean,
+    epochs?: PipelineEpochs
+  ): T {
+    if (input.length !== this.dimension || output.length !== this.dimension)
+      throw new Error('Projection columns must match dimension');
+    const inputStride = this.inputStride ?? 1,
+      outputStride = this.outputStride ?? 1;
+    let available = Number.MAX_SAFE_INTEGER;
+    for (let i = 0; i < this.dimension; i++) {
+      if (!isBuffer(input[i]) || !isBuffer(output[i]))
+        throw new Error('Projection columns require floating typed arrays');
+      available = Math.min(available, capacity(input[i].length, this.inputOffset, inputStride, 1));
+    }
+    const records = this.range(available, count, start);
+    this.epochStorage(epochs, start, records);
+    for (let i = 0; i < this.dimension; i++) {
+      if (start + records > capacity(output[i].length, this.outputOffset, outputStride, 1))
+        throw new Error('Projection output column is too short');
+      this.epochAlias(epochs, output[i], start, records, outputStride, 1);
+      for (let j = 0; j < this.dimension; j++)
+        this.aliases(input[i], output[j], start, records, inputStride, outputStride, 1);
+      for (let j = 0; j < i && records; j++) {
+        const a =
+          output[i].byteOffset +
+          (this.outputOffset + start * outputStride) * output[i].BYTES_PER_ELEMENT;
+        const b =
+          output[j].byteOffset +
+          (this.outputOffset + start * outputStride) * output[j].BYTES_PER_ELEMENT;
+        if (
+          overlap(
+            output[i],
+            a,
+            a + ((records - 1) * outputStride + 1) * output[i].BYTES_PER_ELEMENT,
+            output[j],
+            b,
+            b + ((records - 1) * outputStride + 1) * output[j].BYTES_PER_ELEMENT
+          )
+        )
+          throw new Error('Projection output columns overlap');
+      }
+    }
+    const scratch = this.acquire();
+    try {
+      const epochBuffer = typeof epochs === 'number' ? undefined : epochs;
+      for (let record = start; record < start + records; record++) {
+        const source = this.inputOffset + record * inputStride,
+          target = this.outputOffset + record * outputStride;
+        for (let i = 0; i < this.dimension; i++) scratch.input[i] = input[i][source];
+        this.transform(
+          scratch,
+          inverse,
+          epochBuffer ? epochBuffer[record] : (epochs as number | undefined)
+        );
+        for (let i = 0; i < this.dimension; i++) {
+          const value = scratch.output[i];
+          if (
+            (i < 3 && !Number.isFinite(value)) ||
+            (output[i] instanceof Float32Array &&
+              Number.isFinite(value) &&
+              Math.abs(value) > 3.4028234663852886e38)
+          )
+            throw new Error('Projection output is nonfinite or exceeds Float32 range');
+        }
+        for (let i = 0; i < this.dimension; i++) output[i][target] = scratch.output[i];
+      }
+      return output;
+    } finally {
+      this.depth--;
+    }
+  }
+}

package/src/projection/datums.ts

@@ -0,0 +1,13 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+import datums from './experimental/crs/datum-table';
+import type {DatumCatalogPlugin} from './experimental/crs/types';
+
+/** Complete regional datum catalogue. WGS84 and NAD83 are provided by the engine. */
+export const datumCatalog: DatumCatalogPlugin = Object.freeze({
+  name: 'regional-datums',
+  datums: Object.freeze(datums)
+});
+
+export type {DatumDefinition, DatumCatalogPlugin} from './experimental/crs/types';

package/src/projection/deformation.ts

@@ -0,0 +1,5 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+export {createDeformationModel} from './experimental/deformation';
+export type {DeformationModel, DeformationModelOptions} from './experimental/deformation';