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

package/src/projection/experimental/crs/wkt.ts

@@ -0,0 +1,201 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Original adapter; named-axis fallback inspired by proj4js 2.22.0 / wkt-parser (MIT). See ../../../PROJ4-LICENSE.md for upstream attribution.
+import {inferCRSRepresentation} from '../../../crs/spatial-reference';
+import {parseWKTCRS} from '../../../crs/wkt-crs';
+import type {WKTCRSNode} from '../../../crs/index';
+import type {CRSParser} from './types';
+import {unsupportedStage} from './types';
+import {readStructuredCRS} from './structured';
+import type {RecordValue} from './structured';
+
+function children(node: WKTCRSNode, ...names: string[]): WKTCRSNode[] {
+  return node.values.filter(
+    (value): value is WKTCRSNode =>
+      value.type === 'node' && names.includes(value.keyword.toUpperCase())
+  );
+}
+function child(node: WKTCRSNode, ...names: string[]): WKTCRSNode | undefined {
+  return children(node, ...names)[0];
+}
+function value(node: WKTCRSNode, index = 0): string | number | undefined {
+  const item = node.values[index];
+  return item && item.type !== 'node' ? item.value : undefined;
+}
+function units(node?: WKTCRSNode): unknown {
+  return node ? {name: value(node), conversion_factor: value(node, 1)} : undefined;
+}
+// Original WKT adapters. UNKNOWN is only recoverable from an explicit grid-axis name.
+function legacyAxisDirection(axis: WKTCRSNode, projected: boolean): string | number | undefined {
+  const direction = value(axis, 1);
+  if (projected && String(direction).toLowerCase() === 'unknown') {
+    const name = String(value(axis)).toLowerCase();
+    const match = /^(easting|northing|westing|southing)(?:\s*\([a-z]\))?$/.exec(name);
+    if (match)
+      return {easting: 'east', northing: 'north', westing: 'west', southing: 'south'}[match[1]];
+  }
+  return direction;
+}
+function axisMeridian(axis: WKTCRSNode): RecordValue | undefined {
+  const meridian = child(axis, 'MERIDIAN');
+  if (!meridian) return undefined;
+  return {longitude: {value: value(meridian), unit: units(child(meridian, 'ANGLEUNIT'))}};
+}
+function operation(node: WKTCRSNode): RecordValue {
+  const method = child(node, 'METHOD', 'PROJECTION');
+  if (!method) throw new Error('WKT conversion requires a METHOD or PROJECTION');
+  if (child(node, 'PARAMETERFILE')) unsupportedStage('Grid-based WKT operation is not implemented');
+  return {
+    method: {name: value(method)},
+    parameters: children(node, 'PARAMETER').map(parameter => ({
+      name: value(parameter),
+      value: value(parameter, 1),
+      unit: units(child(parameter, 'ANGLEUNIT', 'LENGTHUNIT', 'SCALEUNIT'))
+    }))
+  };
+}
+function readWKT(node: WKTCRSNode): RecordValue {
+  const keyword = node.keyword.toUpperCase();
+  if (keyword === 'COMPD_CS' || keyword === 'COMPOUNDCRS') {
+    return {
+      type: 'CompoundCRS',
+      components: children(
+        node,
+        'PROJCS',
+        'PROJCRS',
+        'GEOGCS',
+        'GEOGCRS',
+        'GEODCRS',
+        'BOUNDCRS',
+        'VERT_CS',
+        'VERTCRS'
+      ).map(readWKT)
+    };
+  }
+  if (keyword === 'BOUNDCRS') {
+    const source = child(node, 'SOURCECRS'),
+      target = child(node, 'TARGETCRS'),
+      transform = child(node, 'ABRIDGEDTRANSFORMATION');
+    if (!source || !target || !transform) throw new Error('Incomplete WKT BoundCRS');
+    const root = (wrapper: WKTCRSNode): WKTCRSNode => {
+      const entry = wrapper.values.find((value): value is WKTCRSNode => value.type === 'node');
+      if (!entry) throw new Error('Missing bound CRS component');
+      return entry;
+    };
+    // Abridged transformations express scale as a multiplier; PROJJSON uses ppm.
+    const op = operation(transform);
+    const parameters = op['parameters'] as RecordValue[];
+    for (const parameter of parameters) {
+      if (
+        String(parameter['name']).toLowerCase() === 'scale difference' &&
+        parameter['unit'] === undefined
+      )
+        parameter['value'] = (Number(parameter['value']) - 1) * 1e6;
+    }
+    return {
+      type: 'BoundCRS',
+      source_crs: readWKT(root(source)),
+      target_crs: readWKT(root(target)),
+      transformation: op
+    };
+  }
+  if (['VERT_CS', 'VERTCRS'].includes(keyword)) return {type: 'VerticalCRS'};
+  const projected = ['PROJCS', 'PROJCRS', 'PROJECTEDCRS'].includes(keyword);
+  const geographic = [
+    'GEOGCS',
+    'GEOGCRS',
+    'GEODCRS',
+    'GEODETICCRS',
+    'GEOGRAPHICCRS',
+    'BASEGEOGCRS',
+    'BASEGEODCRS',
+    'GEOCCS'
+  ].includes(keyword);
+  if (!projected && !geographic) unsupportedStage('Unsupported WKT CRS: ' + keyword);
+  if (child(node, 'DYNAMIC', 'DERIVINGCONVERSION', 'VELOCITYGRID', 'EXTENSION'))
+    unsupportedStage('Unsupported WKT dynamic/extension operation');
+  const cs = child(node, 'CS');
+  const geocentric =
+    keyword === 'GEOCCS' || (String(value(cs || node)).toLowerCase() === 'cartesian' && !projected);
+  const localUnit = child(node, projected || geocentric ? 'LENGTHUNIT' : 'ANGLEUNIT', 'UNIT');
+  const axes = children(node, 'AXIS')
+    .sort((a, b) => Number(value(child(a, 'ORDER') || a)) - Number(value(child(b, 'ORDER') || b)))
+    .map((axis, index) => ({
+      name: value(axis),
+      direction:
+        keyword === 'GEOCCS'
+          ? ['geocentricX', 'geocentricY', 'geocentricZ'][index]
+          : legacyAxisDirection(axis, projected),
+      unit: units(
+        child(axis, 'ANGLEUNIT', 'LENGTHUNIT') ||
+          (!geocentric && !projected && /^(up|down)$/i.test(String(value(axis, 1)))
+            ? undefined
+            : localUnit)
+      ),
+      meridian: axisMeridian(axis)
+    }));
+  if (!axes.length) {
+    for (const direction of geocentric
+      ? ['geocentricX', 'geocentricY', 'geocentricZ']
+      : ['east', 'north'])
+      axes.push({name: direction, direction, unit: units(localUnit), meridian: undefined});
+  }
+  const id = keyword === 'GEOGCS' ? undefined : child(node, 'ID');
+  const result: RecordValue = {
+    type: projected ? 'ProjectedCRS' : geocentric ? 'GeodeticCRS' : 'GeographicCRS',
+    name: value(node),
+    // WKT1 uses datum names; WKT2 base-CRS IDs select the upstream authority table.
+    id: id ? {authority: value(id), code: value(id, 1)} : undefined,
+    coordinate_system: {subtype: projected || geocentric ? 'Cartesian' : 'ellipsoidal', axis: axes}
+  };
+  const usage = child(node, 'USAGE');
+  const bbox = child(usage || node, 'BBOX');
+  if (bbox)
+    result['bbox'] = {
+      south_latitude: value(bbox, 0),
+      west_longitude: value(bbox, 1),
+      north_latitude: value(bbox, 2),
+      east_longitude: value(bbox, 3)
+    };
+  if (projected) {
+    const base = child(node, 'GEOGCS', 'BASEGEOGCRS', 'BASEGEODCRS', 'GEODCRS', 'GEOGCRS');
+    if (!base) throw new Error('Projected WKT requires a base geographic CRS');
+    result['base_crs'] = readWKT(base);
+    result['conversion'] = operation(child(node, 'CONVERSION') || node);
+  } else {
+    const datum = child(node, 'DATUM', 'GEODETICDATUM', 'ENSEMBLE');
+    if (!datum) throw new Error('WKT requires a geodetic datum');
+    if (child(datum, 'EXTENSION', 'DYNAMIC')) unsupportedStage('Unsupported datum extension');
+    const ellipsoid = child(datum, 'SPHEROID', 'ELLIPSOID');
+    if (!ellipsoid) throw new Error('WKT datum requires an ellipsoid');
+    const shift = child(datum, 'TOWGS84');
+    result['datum'] = {
+      name: value(datum),
+      ellipsoid: {
+        name: value(ellipsoid),
+        semi_major_axis: value(ellipsoid, 1),
+        inverse_flattening: value(ellipsoid, 2),
+        unit: units(child(ellipsoid, 'LENGTHUNIT'))
+      },
+      towgs84: shift?.values.map((_, index) => value(shift, index))
+    };
+    const pm = child(node, 'PRIMEM');
+    if (pm)
+      result['prime_meridian'] = {
+        name: value(pm),
+        longitude: value(pm, 1),
+        unit: units(child(pm, 'ANGLEUNIT') || (geocentric ? undefined : localUnit))
+      };
+    result['angular_unit'] = geocentric ? undefined : units(localUnit);
+  }
+  return result;
+}
+export const wktCRSParser: CRSParser = {
+  name: 'wkt',
+  canParse: definition => inferCRSRepresentation(definition) === 'wkt',
+  parse(definition, options) {
+    if (typeof definition !== 'string') throw new Error('Expected serialized WKT');
+    return readStructuredCRS(readWKT(parseWKTCRS(definition).root), options);
+  }
+};

package/src/projection/experimental/crs-descriptor.ts

@@ -0,0 +1,250 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {CRSMetadata, CRSUnit} from '../../crs/index';
+import {normalizeCRS} from './crs/normalize';
+import {createRenderingScale} from './crs-rendering-scale';
+import {validateScalarOutput, writeScalarOutput} from './scalar-output';
+import type {ProjectionTransform} from './typescript-projection';
+import {getCRSSignature, linearUnits} from '../../crs/crs-metadata';
+import type {TypeScriptCRSInput} from './crs/spatial-reference';
+import type {CRSNormalizationOptions, NormalizedCRS} from './crs/types';
+import type {
+  CRSBounds,
+  CRSConversion,
+  CRSConverter,
+  CRSDescriptor,
+  GetCRSOptions,
+  ProjectionRenderingProfile
+} from './types';
+import type {
+  CreateProjectionOptions,
+  PreparedProjection,
+  ProjectionCoordinate,
+  ProjectionOutput
+} from '../types';
+
+const ANGULAR_UNITS: Readonly<Record<string, number>> = {
+  degrees: Math.PI / 180,
+  radians: 1,
+  gradians: Math.PI / 200
+};
+
+const LINEAR_UNITS: Readonly<Record<string, number>> = {
+  ...Object.fromEntries(Object.values(linearUnits).map(unit => [unit.name, unit.metersPerUnit]))
+};
+
+/** Shared descriptor assembly; algorithms stay in the supplied engine's registrations. */
+export async function resolveCRSDescriptor(
+  engine: {createProjectionAsync(options: CreateProjectionOptions): Promise<ProjectionTransform>},
+  definition: TypeScriptCRSInput,
+  normalization: CRSNormalizationOptions & Pick<CreateProjectionOptions, 'enforceAxis'>,
+  options: GetCRSOptions = {},
+  useDefinitionSignature = false
+): Promise<CRSDescriptor> {
+  // Lazy imports yield control. Capture caller-owned JSON metadata before loading so
+  // descriptor metadata and compiled conversions describe the same definition.
+  const input: TypeScriptCRSInput =
+    typeof definition === 'string' ? definition : JSON.parse(JSON.stringify(definition));
+  const conventions = {
+    enforceAxis: normalization.enforceAxis,
+    mode: normalization.mode,
+    ...options,
+    converters: options.converters && [...options.converters]
+  };
+  const crs = normalizeCRS(input, {...normalization, ...conventions});
+  const projection = await engine.createProjectionAsync({
+    ...conventions,
+    from: 'WGS84',
+    to: input
+  });
+  const axis = crs.storedAxis || (conventions.enforceAxis ? crs.axis : 'enu');
+  const horizontalUnit = getUnit(
+    crs.kind === 'geographic' ? crs.angularUnit : crs.toMeter,
+    crs.kind === 'geographic'
+  );
+  const heightUnit = getUnit(crs.verticalUnit, false);
+  // Component names describe storage, not east/north/up. Axis enforcement can put
+  // height first; geocentric XYZ always share the same linear coordinate unit.
+  const units = [...axis].map(direction =>
+    crs.kind !== 'geocentric' && /[ud]/.test(direction) ? heightUnit : horizontalUnit
+  );
+  const profile = projection.targetProfile;
+  if (!profile) throw new Error('Projection must define a rendering profile for CRS retrieval');
+  // Derivative seam checks follow the algorithm's central meridian, independently of rendering coverage.
+  const center = ((projection.targetLongitudeOrigin + crs.primeMeridian) * 180) / Math.PI;
+  const bounds = adaptBounds(profile, crs, axis);
+  const normalizeWGS84 = createNormalization(profile.normalize);
+  const renderingScale = createRenderingScale(crs, projection, axis, center);
+  const sources = [...new Set(['WGS84', ...(conventions.converters || [])])];
+  if (sources.some(source => typeof source !== 'string' || !source.trim()))
+    throw new Error('Converter source CRS must be a nonempty string');
+  const entries = await Promise.all(
+    sources.map(async source => {
+      if (source === 'WGS84') return [source, createConverter(projection, normalizeWGS84)] as const;
+      // Direct CRS-pair conversions retain each source's datum and axis conventions.
+      const [pair, geographic] = await Promise.all([
+        engine.createProjectionAsync({...conventions, from: source, to: input}),
+        engine.createProjectionAsync({...conventions, from: 'WGS84', to: source})
+      ]);
+      return [
+        source,
+        createConverter(pair, createSourceNormalization(geographic, normalizeWGS84))
+      ] as const;
+    })
+  );
+  const converter = Object.assign(Object.create(null), Object.fromEntries(entries));
+  const metadata: CRSMetadata = {
+    coordinateFrame: crs.kind,
+    projection: crs.projection,
+    parameters: crs.parameters,
+    ellipsoid: {
+      semiMajorAxis: crs.ellipsoid.semiMajorAxis,
+      semiMinorAxis: crs.ellipsoid.semiMinorAxis
+    },
+    axis,
+    xUnit: units[0],
+    yUnit: units[1],
+    zUnit: units[2],
+    areaOfUse: crs.areaOfUse,
+    lossy: crs.lossy
+  };
+  return {
+    ...metadata,
+    // Exact caller identity is sufficient under default execution conventions.
+    // Additional source converters do not change the target CRS.
+    signature:
+      useDefinitionSignature && typeof input === 'string' && !conventions.enforceAxis && !crs.lossy
+        ? input
+        : getCRSSignature(metadata),
+    renderingBounds: bounds,
+    renderingScale,
+    getRenderingScale: coordinate =>
+      typeof renderingScale === 'function' ? renderingScale(coordinate) : renderingScale,
+    converter
+  };
+}
+
+function createConverter(projection: PreparedProjection, normalize: CRSConversion): CRSConverter {
+  return {
+    from: createConversion(
+      projection.project.bind(projection),
+      projection.projectTo.bind(projection)
+    ),
+    to: createConversion(
+      projection.unproject.bind(projection),
+      projection.unprojectTo.bind(projection)
+    ),
+    normalize
+  };
+}
+
+/** Express destination-specific geographic normalization back in the source CRS. */
+function createSourceNormalization(
+  geographic: PreparedProjection,
+  normalizeWGS84: CRSConversion
+): CRSConversion {
+  function normalize(coordinate: ProjectionCoordinate): number[];
+  function normalize<T extends ProjectionOutput>(coordinate: ProjectionCoordinate, output: T): T;
+  function normalize(
+    coordinate: ProjectionCoordinate,
+    output?: ProjectionOutput
+  ): ProjectionOutput {
+    if (output !== undefined) validateScalarOutput(coordinate, output, coordinate.length);
+    const wgs84 = geographic.unproject(Array.from(coordinate));
+    const [longitude, latitude, altitude] = wgs84;
+    normalizeWGS84(wgs84, wgs84);
+    if (wgs84[0] === longitude && wgs84[1] === latitude && wgs84[2] === altitude) {
+      // Source -> WGS84 is needed to evaluate the target's rendering policy.
+      // An unchanged point needs no reverse projection, which could perturb it.
+      return output === undefined
+        ? Array.from(coordinate)
+        : writeScalarOutput(
+            coordinate,
+            output,
+            {x: coordinate[0], y: coordinate[1], z: coordinate[2] ?? 0},
+            coordinate.length
+          );
+    }
+    return output === undefined ? geographic.project(wgs84) : geographic.projectTo(wgs84, output);
+  }
+  return normalize;
+}
+
+/** Keep the engine's output sizing and validation while supporting both storage conventions. */
+function createConversion(
+  allocate: PreparedProjection['project'],
+  write: PreparedProjection['projectTo']
+): CRSConversion {
+  function convert(coordinate: ProjectionCoordinate): number[];
+  function convert<T extends ProjectionOutput>(coordinate: ProjectionCoordinate, output: T): T;
+  function convert(coordinate: ProjectionCoordinate, output?: ProjectionOutput): ProjectionOutput {
+    return output === undefined
+      ? allocate(Array.isArray(coordinate) ? coordinate : Array.from(coordinate))
+      : write(coordinate, output);
+  }
+  return convert;
+}
+
+function createNormalization(
+  normalizeDomain?: ProjectionRenderingProfile['normalize']
+): CRSConversion {
+  function normalize(coordinate: ProjectionCoordinate): number[];
+  function normalize<T extends ProjectionOutput>(coordinate: ProjectionCoordinate, output: T): T;
+  function normalize(
+    coordinate: ProjectionCoordinate,
+    output?: ProjectionOutput
+  ): ProjectionOutput {
+    const result = output ?? new Array<number>(coordinate.length);
+    validateScalarOutput(coordinate, result, coordinate.length);
+    const longitude = coordinate[0],
+      latitude = coordinate[1],
+      altitude = coordinate[2] ?? 0;
+    if (
+      coordinate.length < 2 ||
+      !Number.isFinite(longitude) ||
+      !Number.isFinite(latitude) ||
+      !Number.isFinite(altitude)
+    )
+      throw new Error('Normalization requires finite longitude, latitude and altitude');
+    const point = {x: longitude, y: latitude, z: altitude};
+    normalizeDomain?.(point);
+    return writeScalarOutput(coordinate, result, point, coordinate.length);
+  }
+  return normalize;
+}
+
+/** Convert projection-owned native envelopes into the CRS's stored units and axis order. */
+function adaptBounds(
+  profile: ProjectionRenderingProfile,
+  crs: NormalizedCRS,
+  axis: string
+): CRSBounds {
+  const horizontalUnit = crs.kind === 'geographic' ? crs.angularUnit : crs.toMeter;
+  const units = [
+    horizontalUnit,
+    horizontalUnit,
+    crs.kind === 'geocentric' ? crs.toMeter : crs.verticalUnit
+  ];
+  const bounds = profile.bounds;
+  const limits = [...axis].map(direction => {
+    const index = /[ew]/.test(direction) ? 0 : /[ns]/.test(direction) ? 1 : 2;
+    const minimum = bounds[0][index] / units[index];
+    const maximum = bounds[1][index] / units[index];
+    return /[wsd]/.test(direction) ? [-maximum, -minimum] : [minimum, maximum];
+  });
+  return [
+    [limits[0][0], limits[1][0], limits[2][0]] as readonly [number, number, number],
+    [limits[0][1], limits[1][1], limits[2][1]] as readonly [number, number, number]
+  ];
+}
+
+/** Canonical labels and conversion factors describe the effective coordinate units. */
+function getUnit(factor: number, angular: boolean): CRSUnit {
+  const units = angular ? ANGULAR_UNITS : LINEAR_UNITS;
+  const name = Object.keys(units).find(candidate => units[candidate] === factor) || 'custom';
+  return angular
+    ? {name, degreesPerUnit: factor / ANGULAR_UNITS['degrees']}
+    : {name, metersPerUnit: factor};
+}

package/src/projection/experimental/crs-rendering-scale.ts

@@ -0,0 +1,115 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {NumericalDerivative} from '../numerical-derivative';
+import {normalizeCRS} from './crs/normalize';
+import type {NormalizedCRS} from './crs/types';
+import type {CRSRenderingScale} from './types';
+import type {PreparedProjection, ProjectionCoordinate} from '../types';
+
+const RADIANS = Math.PI / 180;
+// Samples are returned by the WGS84 converter, regardless of the target ellipsoid.
+const WGS84 = normalizeCRS('WGS84').ellipsoid;
+
+function validateScale(scale: CRSRenderingScale): CRSRenderingScale {
+  if (scale.length !== 3 || scale.some(value => !Number.isFinite(value) || value <= 0))
+    throw new Error('Invalid CRS rendering scale');
+  return scale;
+}
+
+export function createRenderingScale(
+  crs: NormalizedCRS,
+  projection: PreparedProjection,
+  axis: string,
+  center: number
+): CRSRenderingScale | ((coordinate: ProjectionCoordinate) => CRSRenderingScale | null) {
+  if (crs.kind === 'geocentric') return validateScale([crs.toMeter, crs.toMeter, crs.toMeter]);
+  if (crs.kind === 'identity') {
+    return validateScale(
+      [...axis].map(direction => (/[ud]/.test(direction) ? crs.verticalUnit : crs.toMeter)) as [
+        number,
+        number,
+        number
+      ]
+    );
+  }
+  const anchor = [0, 0, 0],
+    input = [0, 0, 0],
+    geographic = [0, 0, 0],
+    sample = [0, 0, 0];
+  const derivatives = Array.from({length: 3}, () => [0, 0, 0]);
+  let component = 0,
+    longitudeMeters = 0,
+    latitudeMeters = 0,
+    busy = false;
+  const numerical = new NumericalDerivative((offset, output) => {
+    for (let i = 0; i < 3; i++) input[i] = anchor[i];
+    input[component] += offset;
+    projection.unprojectTo(input, sample);
+    // WGS84 can wrap at Greenwich ±180 even when the target is continuous there.
+    // Target branch cuts are checked against its central meridian below.
+    const rawDelta = sample[0] - geographic[0];
+    const delta =
+      Math.abs(rawDelta) <= 180 ? rawDelta : ((((rawDelta + 180) % 360) + 360) % 360) - 180;
+    if (Math.abs(sample[1]) >= 90) return false;
+    output[0] = delta * longitudeMeters;
+    output[1] = (sample[1] - geographic[1]) * latitudeMeters;
+    output[2] = sample[2] - geographic[2];
+    return output.every(Number.isFinite);
+  });
+  return (coordinate: ProjectionCoordinate): CRSRenderingScale | null => {
+    if (busy || coordinate.length < 2) return null;
+    busy = true;
+    let scale: [number, number, number];
+    try {
+      anchor[0] = coordinate[0];
+      anchor[1] = coordinate[1];
+      anchor[2] = coordinate[2] ?? 0;
+      if (!anchor.every(Number.isFinite)) return null;
+      projection.unprojectTo(anchor, geographic);
+      const latitude = geographic[1] * RADIANS;
+      const a = WGS84.semiMajorAxis,
+        es = WGS84.eccentricitySquared;
+      const denominator = 1 - es * Math.sin(latitude) ** 2;
+      longitudeMeters = ((a * Math.cos(latitude)) / Math.sqrt(denominator)) * RADIANS;
+      latitudeMeters = ((a * (1 - es)) / denominator ** 1.5) * RADIANS;
+      if (!(longitudeMeters > a * RADIANS * 1e-8) || !(latitudeMeters > 0)) return null;
+      const offset = ((((geographic[0] - center + 180) % 360) + 360) % 360) - 180;
+      const hasLongitudeSeam =
+        crs.kind === 'geographic'
+          ? crs.longitudeWrap !== undefined
+          : !Object.prototype.hasOwnProperty.call(crs.parameters, 'over');
+      if (
+        (hasLongitudeSeam && Math.abs(offset) + 2 / longitudeMeters >= 180) ||
+        Math.abs(geographic[1]) + 2 / latitudeMeters >= 90
+      )
+        return null;
+      for (component = 0; component < 3; component++) {
+        const direction = axis[component];
+        const nominalMeters = /[ud]/.test(direction)
+          ? crs.verticalUnit
+          : crs.kind === 'geographic'
+            ? ((/[ew]/.test(direction) ? longitudeMeters : latitudeMeters) * crs.angularUnit) /
+              RADIANS
+            : crs.toMeter;
+        if (!numerical.evaluate(1 / nominalMeters, nominalMeters)) return null;
+        for (let i = 0; i < 3; i++) derivatives[component][i] = numerical.result[i];
+      }
+      scale = derivatives.map(derivative => Math.hypot(...derivative)) as [number, number, number];
+      if (crs.kind === 'projected') {
+        const east = derivatives[axis.search(/[ew]/)];
+        const north = derivatives[axis.search(/[ns]/)];
+        // Retain rotation/shear in the determinant. This is rendering sizing,
+        // not the physical height conversion performed by the converter.
+        const inverseArea = Math.abs(east[0] * north[1] - east[1] * north[0]) / crs.toMeter ** 2;
+        scale[axis.search(/[ud]/)] = crs.verticalUnit * Math.sqrt(inverseArea);
+      }
+    } catch {
+      return null;
+    } finally {
+      busy = false;
+    }
+    return validateScale(scale);
+  };
+}