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

package/src/projection/experimental/projections/stere.ts

@@ -0,0 +1,59 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {withAngularRenderingProfile} from '../rendering-profile/angular-rendering-profile';
+import {
+  sphericalAzimuthalBounds,
+  ellipsoidalStereographicBounds
+} from '../rendering-profile/azimuthal-rendering-bounds';
+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);
+
+    const state = createState(base);
+    const projection = guardAzimuthalDomain(base, bindKernel('stere', state, forward, inverse));
+    return withAngularRenderingProfile(projection, base, (150 * Math.PI) / 180, (region, domain) =>
+      state.sphere
+        ? sphericalAzimuthalBounds(state, region, domain, 'stere')
+        : ellipsoidalStereographicBounds(
+            state,
+            latitude =>
+              2 *
+                Math.atan(
+                  Math.tan(Math.PI / 4 + latitude / 2) *
+                    Math.pow(
+                      (1 - state.e * Math.sin(latitude)) / (1 + state.e * Math.sin(latitude)),
+                      state.e / 2
+                    )
+                ) -
+              Math.PI / 2,
+            state.X0,
+            2 *
+              state.a *
+              state.k0 *
+              (Math.abs(state.coslat0) < 1e-10 ? 1 / state.cons : state.ms1 / state.cosX0),
+            region,
+            domain
+          )
+    );
+  }
+};

package/src/projection/experimental/projections/sterea.ts

@@ -0,0 +1,61 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {withAngularRenderingProfile} from '../rendering-profile/angular-rendering-profile';
+import {ellipsoidalStereographicBounds} from '../rendering-profile/azimuthal-rendering-bounds';
+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');
+    const state = createState(base);
+    // Keep the rendering boundary finite without restricting raw conversion.
+    return withAngularRenderingProfile(
+      guardAzimuthalDomain(base, bindKernel('sterea', state, forward, inverse)),
+      base,
+      (Math.PI * 150) / 180,
+      (region, domain) =>
+        ellipsoidalStereographicBounds(
+          base,
+          latitude =>
+            2 *
+              Math.atan(
+                state.K *
+                  Math.pow(Math.tan(Math.PI / 4 + latitude / 2), state.C) *
+                  Math.pow(
+                    (1 - base.e * Math.sin(latitude)) / (1 + base.e * Math.sin(latitude)),
+                    state.ratexp
+                  )
+              ) -
+            Math.PI / 2,
+          state.phic0,
+          base.a * base.k0 * state.R2,
+          region,
+          domain,
+          state.C,
+          Math.abs(Math.log(state.C)) +
+            Math.abs(Math.log(state.K)) +
+            state.C * base.e * Math.atanh(base.e)
+        )
+    );
+  }
+};

package/src/projection/experimental/projections/tpers.ts

@@ -0,0 +1,59 @@
+// 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 {withAngularRenderingProfile} from '../rendering-profile/angular-rendering-profile';
+import {perspectiveBounds} from '../rendering-profile/azimuthal-rendering-bounds';
+import type {ProjectionPlugin} from '../types';
+import {
+  catalogueParameters,
+  catalogueBoundsParameters,
+  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});
+    const radius = 1 + h / base.a;
+    const horizon = Math.acos(1 / radius);
+    // Tilt can make the image plane singular before the geographic horizon.
+    const angle = Math.abs(tilt);
+    const plane =
+      radius * Math.cos(angle) < 1 ? angle - Math.acos(radius * Math.cos(angle)) : horizon;
+    const distance = Math.min(horizon, plane) * (1 - 1e-10);
+    return withAngularRenderingProfile(
+      bindCatalogueKernel(
+        'tpers',
+        context,
+        state,
+        forward,
+        inverse,
+        horizonGuard(base, 1 / (1 + h / base.a))
+      ),
+      base,
+      distance,
+      (region, domain) =>
+        perspectiveBounds(
+          catalogueBoundsParameters(base, context),
+          radius,
+          tilt,
+          azi,
+          region,
+          domain
+        ),
+      horizon
+    );
+  }
+};

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

@@ -0,0 +1,89 @@
+// 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 {transverseBounds} from '../rendering-profile/rendering-bounds';
+import {createAngularRanges} from '../rendering-profile/geographic-bounds';
+import {withRectangleRenderingProfile} from '../rendering-profile/rectangular-rendering-profile';
+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);
+  // A finite regional strip avoids the transverse singularities at +/-90 degrees.
+  const render = (implementation: ProjectionImplementation) =>
+    withRectangleRenderingProfile(
+      implementation,
+      createAngularRanges(
+        base.long0 - Math.PI / 6,
+        -Math.PI / 2,
+        base.long0 + Math.PI / 6,
+        Math.PI / 2
+      ),
+      ranges => transverseBounds(implementation.forward, ranges, base.long0, base.over),
+      base.primeMeridian,
+      base.over
+    );
+  if (flagParameter(context.parameters, 'approx')) {
+    return render({
+      ...bindKernel(
+        'tmerc +approx',
+        createFast(base),
+        fastForward,
+        fastInverse,
+        createFlatProjection
+      )
+    });
+  }
+  if (base.sphere) throw new Error('Spherical transverse Mercator requires +approx');
+  return render({
+    ...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/projection/experimental/projections/utm.ts

@@ -0,0 +1,50 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ProjectionPlugin} from '../types';
+import {transverseBounds} from '../rendering-profile/rendering-bounds';
+import {createAngularRanges} from '../rendering-profile/geographic-bounds';
+import {withRectangleRenderingProfile} from '../rendering-profile/rectangular-rendering-profile';
+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');
+    const implementation = 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'
+      }
+    });
+    const center = ((6 * zone - 183) * Math.PI) / 180;
+    // Standard six-degree UTM zone coverage, independent of conversion validity.
+    return withRectangleRenderingProfile(
+      implementation,
+      createAngularRanges(
+        center - Math.PI / 60,
+        south ? (-80 * Math.PI) / 180 : 0,
+        center + Math.PI / 60,
+        south ? 0 : (84 * Math.PI) / 180
+      ),
+      ranges => transverseBounds(implementation.forward, ranges, center),
+      context.primeMeridian ?? 0,
+      Object.prototype.hasOwnProperty.call(context.parameters, 'over')
+    );
+  }
+};

package/src/projection/experimental/projections/vandg.ts

@@ -0,0 +1,30 @@
+// 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 {vanDerGrintenBounds} from '../rendering-profile/rendering-bounds';
+import {createAngularRanges} from '../rendering-profile/geographic-bounds';
+import {withRectangleRenderingProfile} from '../rendering-profile/rectangular-rendering-profile';
+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);
+    // The rendering target covers one world; +over still permits conversion beyond it.
+    const projection = bindCatalogueKernel('vandg', context, state, forward, inverse);
+    return withRectangleRenderingProfile(
+      projection,
+      createAngularRanges(base.long0 - Math.PI, -Math.PI / 2, base.long0 + Math.PI, Math.PI / 2),
+      ranges => vanDerGrintenBounds(projection.forward, ranges, base.long0, base.over),
+      base.primeMeridian,
+      base.over
+    );
+  }
+};

package/src/projection/experimental/rendering-profile/angular-rendering-profile.ts

@@ -0,0 +1,117 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {KernelParameters} from '../kernel';
+import type {
+  GeographicBounds,
+  ProjectionImplementation,
+  ProjectionRenderingProfile
+} from '../types';
+import {createAngularRanges, getAngularRanges, normalizeLongitude} from './geographic-bounds';
+import type {AngularRanges} from './geographic-bounds';
+import {createRectangleRenderingProfile} from './rectangular-rendering-profile';
+import {geographicVector, sphericalExtremum} from './spherical-rendering-domain';
+import type {AngularDomain} from './spherical-rendering-domain';
+import {wrapLongitude} from '../parameters';
+import {createAngularNormalization} from './rendering-profile';
+
+export type ResolveAngularBounds = (
+  parameters: AngularRanges,
+  domain?: AngularDomain
+) => ProjectionRenderingProfile['bounds'];
+
+/** A spherical cap with projection-owned analytical bounds and exact coverage intersections. */
+export function createAngularRenderingProfile(
+  base: Pick<KernelParameters, 'long0' | 'lat0' | 'primeMeridian'>,
+  maximumDistance: number,
+  resolveBounds: ResolveAngularBounds,
+  horizon = Math.PI
+): NonNullable<ProjectionImplementation['getRenderingProfile']> {
+  const full: GeographicBounds = [-180, -90, 180, 90];
+  const create = (coverage: GeographicBounds, declared: boolean): ProjectionRenderingProfile => {
+    const parameters = getAngularRanges(coverage, base.primeMeridian, base.long0);
+    const local = createAngularRanges(
+      parameters[0][0] - base.long0,
+      parameters[0][1],
+      parameters[1][0] - base.long0,
+      parameters[1][1]
+    );
+    const axis = [Math.cos(base.lat0), 0, Math.sin(base.lat0)] as const;
+    const minimum = declared ? sphericalExtremum(axis, local, undefined, false).value : -1;
+    const clipped = !declared || minimum <= Math.cos(horizon) + 1e-13;
+    const domain = clipped ? {latitude: base.lat0, distance: maximumDistance} : undefined;
+    const rectangle = createRectangleRenderingProfile(
+      () => resolveBounds(local, domain),
+      coverage,
+      base.long0,
+      base.primeMeridian
+    );
+    const polar = Math.abs(Math.cos(base.lat0)) < 1e-12;
+    const polarLatitude = ((Math.PI / 2 - maximumDistance) * 180) / Math.PI;
+    const normalizeCap =
+      domain &&
+      !polar &&
+      createAngularNormalization(point => {
+        const target = geographicVector(point.x - base.long0, point.y);
+        if (
+          target[0] * Math.cos(base.lat0) + target[2] * Math.sin(base.lat0) >=
+          Math.cos(domain.distance) - 1e-14
+        )
+          return;
+        if (Math.hypot(target[0] + axis[0], target[1], target[2] + axis[2]) < 1e-12) {
+          // All cap bearings are equally close to an exact antipode. Prefer
+          // northward to keep normalization stable, provided coverage allows it.
+          const angle = base.lat0 + domain.distance;
+          const center = (local[0][0] + local[1][0]) / 2;
+          const longitude = center + wrapLongitude((Math.cos(angle) < 0 ? Math.PI : 0) - center);
+          const latitude = Math.atan2(Math.sin(angle), Math.abs(Math.cos(angle)));
+          if (
+            longitude >= local[0][0] &&
+            longitude <= local[1][0] &&
+            latitude >= local[0][1] &&
+            latitude <= local[1][1]
+          ) {
+            point.x = longitude + base.long0;
+            point.y = latitude;
+            return;
+          }
+        }
+        const result = sphericalExtremum(target, local, domain);
+        [point.x, point.y] = [result.point[0] + base.long0, result.point[1]];
+      }, base.primeMeridian);
+    return {
+      get bounds() {
+        return resolveBounds(local, domain);
+      },
+      normalize(point) {
+        rectangle.normalize!(point);
+        if (domain && polar) {
+          // A polar cap is a latitude clamp in degrees; retain its input meridian.
+          point.y =
+            base.lat0 > 0 ? Math.max(polarLatitude, point.y) : Math.min(-polarLatitude, point.y);
+        } else normalizeCap?.(point);
+        // Cap extrema use a continuous coverage interval, which may lie on a
+        // different longitude branch than the rectangle's normalized output.
+        const center = ((base.long0 + base.primeMeridian) * 180) / Math.PI;
+        const offset = point.x - center;
+        if (Math.abs(offset) > 180) point.x = center + normalizeLongitude(offset);
+      }
+    };
+  };
+  return coverage => create(coverage ?? full, Boolean(coverage));
+}
+
+export function withAngularRenderingProfile(
+  implementation: ProjectionImplementation,
+  base: Pick<KernelParameters, 'long0' | 'lat0' | 'primeMeridian'>,
+  distance: number,
+  resolveBounds: ResolveAngularBounds,
+  horizon = Math.PI
+): ProjectionImplementation {
+  return {
+    ...implementation,
+    longitudeOrigin: base.long0,
+    getRenderingProfile: createAngularRenderingProfile(base, distance, resolveBounds, horizon)
+  };
+}

package/src/projection/experimental/rendering-profile/azimuthal-rendering-bounds.ts

@@ -0,0 +1,181 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {KernelParameters} from '../kernel';
+import {createAngularRanges} from './geographic-bounds';
+import type {AngularRanges} from './geographic-bounds';
+import type {Vector, AngularDomain} from './spherical-rendering-domain';
+import {sphericalRange, sphericalRatioRange} from './spherical-rendering-domain';
+import {envelope, scale, add} from './rendering-bounds';
+
+/** Exact extrema for spherical orthographic and linear-fractional azimuthal maps. */
+export function sphericalAzimuthalBounds(
+  base: KernelParameters,
+  parameters: AngularRanges,
+  domain: AngularDomain | undefined,
+  kind: 'ortho' | 'gnom' | 'stere'
+) {
+  const north = [-Math.sin(base.lat0), 0, Math.cos(base.lat0)] as const;
+  const center = [Math.cos(base.lat0), 0, Math.sin(base.lat0)] as const;
+  const east = [0, 1, 0] as const;
+  const constant = kind === 'stere' ? 1 : 0;
+  const range = (vector: Vector) =>
+    kind === 'ortho'
+      ? sphericalRange(vector, parameters, domain)
+      : sphericalRatioRange(vector, center, constant, parameters, domain);
+  const factor = base.a * (kind === 'stere' ? 2 * base.k0 : 1);
+  return envelope(
+    add([base.x0, base.x0], scale(range(east), factor)),
+    add([base.y0, base.y0], scale(range(north), factor))
+  );
+}
+
+/** The ellipsoid's maximum curvature radius bounds the shortest geodesic length. */
+export function equidistantAzimuthalBounds(
+  base: KernelParameters,
+  parameters: AngularRanges,
+  domain?: AngularDomain
+) {
+  const minimum = sphericalRange(
+    [Math.cos(base.lat0), 0, Math.sin(base.lat0)],
+    parameters,
+    domain
+  )[0];
+  const radius = (base.a / Math.sqrt(1 - base.es)) * Math.acos(Math.max(-1, Math.min(1, minimum)));
+  return envelope([base.x0 - radius, base.x0 + radius], [base.y0 - radius, base.y0 + radius]);
+}
+
+/** Equal-area azimuthal maps lie in the authalic disk (an ellipse after axis scaling). */
+export function equalAreaAzimuthalBounds(
+  base: KernelParameters,
+  xFactor: number,
+  yFactor: number,
+  parameters: AngularRanges,
+  domain: AngularDomain | undefined,
+  latitude: number,
+  transformLatitude: (latitude: number) => number
+) {
+  // Check the geodetic intersection before changing latitude: an empty target
+  // must trigger default-profile fallback, rather than leave normalization unusable.
+  const latitudes = domain && sphericalRange([0, 0, 1], parameters, domain);
+  const region: AngularRanges = createAngularRanges(
+    parameters[0][0],
+    transformLatitude(latitudes ? Math.asin(Math.max(-1, latitudes[0])) : parameters[0][1]),
+    parameters[1][0],
+    transformLatitude(latitudes ? Math.asin(Math.min(1, latitudes[1])) : parameters[1][1])
+  );
+  // Authalic latitude has meridional metric >= (1-e²)² and longitude metric
+  // >= 1. This lower bound on distance from the antipode encloses the transformed
+  // geodetic cap; the spherical case retains its exact angular boundary.
+  const cap = domain && {
+    latitude,
+    distance: Math.PI - (1 - base.es) ** 2 * (Math.PI - domain.distance)
+  };
+  const center = [Math.cos(latitude), 0, Math.sin(latitude)] as const;
+  const north = [-Math.sin(latitude), 0, Math.cos(latitude)] as const;
+  const d = sphericalRange(center, region, cap);
+  const factor: [number, number] = [
+    Math.sqrt(2 / (1 + Math.min(1, d[1]))),
+    d[0] > -1 + 1e-14 ? Math.sqrt(2 / (1 + d[0])) : Infinity
+  ];
+  const axisBounds = (vector: Vector, unit: number) => {
+    const range = sphericalRange(vector, region, cap);
+    const minimum = range[0] === 0 ? 0 : range[0] * (range[0] < 0 ? factor[1] : factor[0]);
+    const maximum = range[1] === 0 ? 0 : range[1] * (range[1] > 0 ? factor[1] : factor[0]);
+    return scale([Math.max(-2, minimum), Math.min(2, maximum)], base.a * unit);
+  };
+  return envelope(
+    add([base.x0, base.x0], axisBounds([0, 1, 0], xFactor)),
+    add([base.y0, base.y0], axisBounds(north, yFactor))
+  );
+}
+
+/** Conformal latitude is monotone. Its isometric shift is at most e*atanh(e),
+ * which bounds angular displacement on the auxiliary sphere without sampling.
+ */
+export function ellipsoidalStereographicBounds(
+  base: KernelParameters,
+  conformalLatitude: (latitude: number) => number,
+  centerLatitude: number,
+  radius: number,
+  parameters: AngularRanges,
+  domain?: AngularDomain,
+  longitudeScale = 1,
+  latitudeError = base.e * Math.atanh(base.e)
+) {
+  const region: AngularRanges = createAngularRanges(
+    parameters[0][0] * longitudeScale,
+    conformalLatitude(parameters[0][1]),
+    parameters[1][0] * longitudeScale,
+    conformalLatitude(parameters[1][1])
+  );
+  const padding = 2 * latitudeError + Math.PI * Math.abs(longitudeScale - 1);
+  // The conformal-sphere metric has minimum scale 1-e². Applying that
+  // bound to distance from the antipode also handles strongly flattened axes.
+  const capDistance =
+    domain && longitudeScale === 1
+      ? Math.min(domain.distance + padding, Math.PI - (1 - base.es) * (Math.PI - domain.distance))
+      : domain && domain.distance + padding;
+  const cap =
+    capDistance && capDistance < Math.PI
+      ? {latitude: centerLatitude, distance: capDistance}
+      : undefined;
+  const center = [Math.cos(centerLatitude), 0, Math.sin(centerLatitude)] as const;
+  const north = [-Math.sin(centerLatitude), 0, Math.cos(centerLatitude)] as const;
+  const longitudeWidth = region[1][0] - region[0][0];
+  const wrapped =
+    longitudeWidth >= 2 * Math.PI
+      ? createAngularRanges(-Math.PI, region[0][1], Math.PI, region[1][1])
+      : region;
+  const x = sphericalRatioRange([0, 1, 0], center, 1, wrapped, cap);
+  const y = sphericalRatioRange(north, center, 1, wrapped, cap);
+  return envelope(
+    add([base.x0, base.x0], scale(x, radius)),
+    add([base.y0, base.y0], scale(y, radius))
+  );
+}
+
+/** Perspective tilt preserves a linear-fractional form in sphere coordinates. */
+export function perspectiveBounds(
+  base: KernelParameters,
+  p: number,
+  tilt: number,
+  azimuth: number,
+  parameters: AngularRanges,
+  domain?: AngularDomain
+) {
+  const center = [Math.cos(base.lat0), 0, Math.sin(base.lat0)];
+  const north = [-Math.sin(base.lat0), 0, Math.cos(base.lat0)];
+  const east = [0, 1, 0];
+  const cg = Math.cos(azimuth),
+    sg = Math.sin(azimuth),
+    cw = Math.cos(tilt),
+    sw = Math.sin(tilt);
+  const up = north.map((value, index) => cg * value + sg * east[index]);
+  const right = east.map((value, index) => cg * value - sg * north[index]);
+  const denominator = center.map((value, index) => -cw * value + sw * up[index]) as [
+    number,
+    number,
+    number
+  ];
+  const x = sphericalRatioRange(
+    right as [number, number, number],
+    denominator,
+    cw * p,
+    parameters,
+    domain
+  );
+  const y = sphericalRatioRange(
+    up as [number, number, number],
+    denominator,
+    cw * p,
+    parameters,
+    domain
+  );
+  // The existing numerical kernel returns image coordinates without false offsets.
+  return envelope(
+    add([base.x0, base.x0], scale(x, base.a * (p - 1) * cw)),
+    add([base.y0, base.y0], scale(y, base.a * (p - 1)))
+  );
+}