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

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

@@ -0,0 +1,252 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {KernelParameters} from '../kernel';
+import type {ProjectionImplementation} from '../types';
+import {createAngularRanges} from './geographic-bounds';
+import type {AngularRanges} from './geographic-bounds';
+import type {State as BonneState} from '../kernels/bonne';
+import type {State as SwissState} from '../kernels/somerc';
+import type {State as HotineState} from '../kernels/omerc';
+import type {State as KrovakState} from '../kernels/krovak';
+import type {State as NZMGState} from '../kernels/nzmg';
+import {sphericalRange} from './spherical-rendering-domain';
+import {
+  add,
+  scale,
+  multiply,
+  ordered,
+  sine,
+  cosine,
+  maxAbs,
+  envelope,
+  longitudeRange
+} from './rendering-bounds';
+import type {Range} from './rendering-bounds';
+import tsfnz from '../common/tsfnz';
+import {SEC_TO_RAD} from '../common/constants';
+
+/** |sin(t)| <= |t| and |1-cos(t)| <= min(2, |t|) bound Bonne's polar terms,
+ * including the removable rho=0 limit, without searching its curved meridians.
+ */
+export function bonneBounds(
+  state: BonneState,
+  project: ProjectionImplementation['forward'],
+  region: AngularRanges
+) {
+  const d = maxAbs(longitudeRange(region, state.long0, state.over));
+  const n = state.a / Math.sqrt(1 - state.es);
+  const meridian = ordered(
+    project(state.long0, region[0][1])[1],
+    project(state.long0, region[1][1])[1]
+  );
+  const radius = Math.max(
+    Math.abs(state.a * (state.es ? state.am1 : state.cphi1) + state.y0 - meridian[0]),
+    Math.abs(state.a * (state.es ? state.am1 : state.cphi1) + state.y0 - meridian[1])
+  );
+  const width = Math.min(radius, n * d);
+  const correction = Math.min(2 * radius, n * d);
+  return envelope(
+    [state.x0 - width, state.x0 + width],
+    [meridian[0] - correction, meridian[1] + correction]
+  );
+}
+
+/** Cancel the apparent polar cotangent singularity before bounding the polynomial terms. */
+export function polyconicBounds(
+  base: KernelParameters,
+  project: ProjectionImplementation['forward'],
+  region: AngularRanges
+) {
+  const d = maxAbs(longitudeRange(region, base.long0, base.over));
+  const n = base.a / Math.sqrt(1 - base.es);
+  const correction = (n * d * d) / 4; // |sin(phi) cos(phi)| <= 1/2
+  let meridian = ordered(
+    project(base.long0, region[0][1])[1],
+    project(base.long0, region[1][1])[1]
+  );
+  if (
+    base.sphere &&
+    (region[0][1] - base.lat0 < -Math.PI / 2 || region[1][1] - base.lat0 > Math.PI / 2)
+  )
+    meridian = [base.y0 - (base.a * Math.PI) / 2, base.y0 + (base.a * Math.PI) / 2];
+  return envelope(
+    [base.x0 - n * d, base.x0 + n * d],
+    [meridian[0] - correction, meridian[1] + correction]
+  );
+}
+
+/** Bounds of the explicit Cassini series, regrouped into bounded sin/cos factors. */
+export function cassiniBounds(
+  base: KernelParameters,
+  project: ProjectionImplementation['forward'],
+  region: AngularRanges
+) {
+  const d = maxAbs(longitudeRange(region, base.long0, base.over));
+  // Beyond the front hemisphere, atan2 northing crosses a branch cut that
+  // the meridian correction below does not bound. Use the regional fallback.
+  if (base.sphere && d > Math.PI / 2) throw new Error('Unsupported Cassini rendering coverage');
+  const n = base.a / Math.sqrt(1 - base.es),
+    c = base.es / (1 - base.es);
+  const width = base.sphere
+    ? base.a * Math.asin(Math.min(1, Math.sin(Math.min(d, Math.PI / 2))))
+    : n * (d + d ** 3 / 6 + ((9 + 8 * c) * d ** 5) / 120);
+  const correction = base.sphere ? base.a * d : n * ((d * d) / 4 + ((6 + 6 * c) * d ** 4) / 24);
+  const meridian = ordered(
+    project(base.long0, region[0][1])[1],
+    project(base.long0, region[1][1])[1]
+  );
+  return envelope(
+    [base.x0 - width, base.x0 + width],
+    [meridian[0] - correction, meridian[1] + correction]
+  );
+}
+
+function ratioRange(numerator: Range, denominator: Range): [number, number] {
+  if (denominator[0] <= 0 && denominator[1] >= 0) return [-Infinity, Infinity];
+  return multiply(numerator, ordered(1 / denominator[0], 1 / denominator[1]));
+}
+
+/** Swiss rotation on its conformal sphere, followed by monotone atan/atanh. */
+export function swissBounds(state: SwissState, region: AngularRanges) {
+  const latitude = (phi: number) => {
+    const s =
+      state.alpha * (Math.asinh(Math.tan(phi)) - state.e * Math.atanh(state.e * Math.sin(phi))) +
+      state.K;
+    return Math.asin(Math.tanh(s));
+  };
+  const rotated: AngularRanges = createAngularRanges(
+    (region[0][0] - state.long0) * state.alpha,
+    latitude(region[0][1]),
+    (region[1][0] - state.long0) * state.alpha,
+    latitude(region[1][1])
+  );
+  const north = sphericalRange([-Math.sin(state.b0), 0, Math.cos(state.b0)], rotated);
+  if (maxAbs(north) >= 1 - 1e-14)
+    throw new Error('Swiss oblique Mercator coverage reaches a rotated pole');
+  const east = sphericalRange([0, 1, 0], rotated);
+  const forward = sphericalRange([Math.cos(state.b0), 0, Math.sin(state.b0)], rotated);
+  const x = ratioRange(east, forward).map(Math.atan) as [number, number];
+  const y = north.map(value =>
+    Math.atanh(Math.max(-1 + Number.EPSILON, Math.min(1 - Number.EPSILON, value)))
+  ) as [number, number];
+  return envelope(
+    add([state.x0, state.x0], scale(x, state.R)),
+    add([state.y0, state.y0], scale(y, state.R))
+  );
+}
+
+/** Hotine's U is a linear form on the conformal sphere. Rotating its bounded
+ * longitude/isometric-latitude ranges gives a guaranteed regional envelope.
+ */
+export function hotineBounds(state: HotineState, region: AngularRanges) {
+  const logW = (phi: number) =>
+    Math.log(state.E) - state.B * Math.log(tsfnz(state.e, phi, Math.sin(phi)));
+  const w = ordered(logW(region[0][1]), logW(region[1][1]));
+  const longitude = scale([region[0][0] - state.lam0, region[1][0] - state.lam0], state.B);
+  const sphere: AngularRanges = createAngularRanges(
+    longitude[0],
+    Math.asin(Math.tanh(w[0])),
+    longitude[1],
+    Math.asin(Math.tanh(w[1]))
+  );
+  const U = sphericalRange([0, -state.cosgam, state.singam], sphere);
+  const v = scale(ordered(-Math.atanh(U[0]), -Math.atanh(U[1])), state.ArB);
+  const numerator = add(
+    scale([Math.sinh(w[0]), Math.sinh(w[1])], state.cosgam),
+    scale(sine(longitude), state.singam)
+  );
+  const denominator = cosine(longitude);
+  const angle =
+    denominator[0] > 0
+      ? (ratioRange(numerator, denominator).map(Math.atan) as [number, number])
+      : ([-Math.PI, Math.PI] as const);
+  let u: Range = scale(angle, state.ArB);
+  let x: Range, y: Range;
+  if (state.no_rot) {
+    x = u;
+    y = v;
+  } else {
+    u = add(u, [-state.u_0, -state.u_0]);
+    x = add(scale(v, state.cosrot), scale(u, state.sinrot));
+    y = add(scale(u, state.cosrot), scale(v, -state.sinrot));
+  }
+  return envelope(
+    add([state.x0, state.x0], scale(x, state.a)),
+    add([state.y0, state.y0], scale(y, state.a))
+  );
+}
+
+/** Krovak's auxiliary-sphere rotation followed by its monotone cone radius. */
+export function krovakBounds(state: KrovakState, region: AngularRanges) {
+  const latitude = (phi: number) =>
+    2 *
+    (Math.atan(
+      (state.k * Math.pow(Math.tan(phi / 2 + state.s45), state.alfa)) /
+        Math.pow(
+          (1 + state.e * Math.sin(phi)) / (1 - state.e * Math.sin(phi)),
+          (state.alfa * state.e) / 2
+        )
+    ) -
+      state.s45);
+  const longitude = scale(longitudeRange(region, state.long0, state.over), -state.alfa);
+  const sphere: AngularRanges = createAngularRanges(
+    longitude[0],
+    latitude(region[0][1]),
+    longitude[1],
+    latitude(region[1][1])
+  );
+  const s = sphericalRange([Math.sin(state.ad), 0, Math.cos(state.ad)], sphere);
+  const cosS: Range = [
+    Math.sqrt(Math.max(Number.EPSILON, 1 - maxAbs(s) ** 2)),
+    1 // cos(s) never exceeds one; a conservative upper endpoint avoids underbounding.
+  ];
+  const numerator = sphericalRange([0, 1, 0], sphere);
+  // Both denominator endpoints matter when the numerator has one sign.
+  const quotient = ratioRange(numerator, cosS);
+  const d = scale(
+    quotient.map(value => Math.asin(Math.max(-1, Math.min(1, value)))) as [number, number],
+    state.n
+  );
+  const radius = (sin: number) =>
+    state.ro0 *
+    Math.pow(
+      Math.tan(state.s0 / 2 + state.s45) / Math.tan(Math.asin(sin) / 2 + state.s45),
+      state.n
+    );
+  const radii = ordered(radius(s[0]), radius(s[1]));
+  const sign = state.czech ? 1 : -1;
+  return envelope(
+    add([state.x0, state.x0], scale(multiply(radii, sine(d)), sign)),
+    add([state.y0, state.y0], scale(multiply(radii, cosine(d)), sign))
+  );
+}
+
+/** Interval Horner evaluation of NZMG's published real/complex polynomials.
+ * The coefficient envelope is rigorous over the entire declared rectangle.
+ */
+export function nzmgBounds(state: NZMGState, region: AngularRanges) {
+  const phi = scale([region[0][1] - state.lat0, region[1][1] - state.lat0], 1e-5 / SEC_TO_RAD);
+  // Normalization selects the origin-relative branch unless +over is active.
+  // Enclose both sides when coverage crosses that cut: the polynomial is not periodic.
+  const lambda = longitudeRange(region, state.long0, state.over);
+  let psi: Range = [0, 0];
+  for (let index = 10; index >= 1; index--)
+    psi = add([state.A[index], state.A[index]], multiply(psi, phi));
+  psi = multiply(psi, phi);
+  let real: Range = [0, 0],
+    imaginary: Range = [0, 0];
+  for (let index = 6; index >= 1; index--) {
+    const nextReal = add(multiply(real, psi), scale(multiply(imaginary, lambda), -1));
+    const nextImaginary = add(multiply(real, lambda), multiply(imaginary, psi));
+    real = add(nextReal, [state.B_re[index], state.B_re[index]]);
+    imaginary = add(nextImaginary, [state.B_im[index], state.B_im[index]]);
+  }
+  const finalReal = add(multiply(real, psi), scale(multiply(imaginary, lambda), -1));
+  const finalImaginary = add(multiply(real, lambda), multiply(imaginary, psi));
+  return envelope(
+    add([state.x0, state.x0], scale(finalImaginary, state.a)),
+    add([state.y0, state.y0], scale(finalReal, state.a))
+  );
+}

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

@@ -0,0 +1,163 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {ProjectionImplementation, ProjectionRenderingProfile} from '../types';
+import type {AngularRanges} from './geographic-bounds';
+import {wrapLongitude} from '../parameters';
+
+export type Range = readonly [number, number];
+export const ordered = (a: number, b: number): [number, number] => [Math.min(a, b), Math.max(a, b)];
+export const add = (a: Range, b: Range): [number, number] => [a[0] + b[0], a[1] + b[1]];
+export const scale = (a: Range, value: number): [number, number] =>
+  ordered(a[0] * value, a[1] * value);
+export function multiply(a: Range, b: Range): [number, number] {
+  const values = [a[0] * b[0], a[0] * b[1], a[1] * b[0], a[1] * b[1]];
+  return [Math.min(...values), Math.max(...values)];
+}
+export function sine([low, high]: Range): [number, number] {
+  const values = [Math.sin(low), Math.sin(high)];
+  for (const [phase, value] of [
+    [Math.PI / 2, 1],
+    [-Math.PI / 2, -1]
+  ]) {
+    if (Math.ceil((low - phase) / (2 * Math.PI)) <= Math.floor((high - phase) / (2 * Math.PI)))
+      values.push(value);
+  }
+  return [Math.min(...values), Math.max(...values)];
+}
+export const cosine = (a: Range): [number, number] =>
+  sine([a[0] + Math.PI / 2, a[1] + Math.PI / 2]);
+export const maxAbs = (a: Range): number => Math.max(Math.abs(a[0]), Math.abs(a[1]));
+export function envelope(x: Range, y: Range): ProjectionRenderingProfile['bounds'] {
+  const padding = (range: Range) => Math.max(1, maxAbs(range)) * 1e-12;
+  if (![...x, ...y].every(Number.isFinite))
+    throw new Error('Projection rendering bounds are not finite');
+  return [
+    [x[0] - padding(x), y[0] - padding(y), 0],
+    [x[1] + padding(x), y[1] + padding(y), 0]
+  ];
+}
+
+/** Include both sides of the projection seam; a continuous geographic bbox can cross it. */
+export function longitudeRange(
+  parameters: AngularRanges,
+  origin: number,
+  over = false
+): [number, number] {
+  const low = parameters[0][0] - origin,
+    high = parameters[1][0] - origin;
+  if (over) return [low, high];
+  // AngularRanges already stores a continuous eastward interval in radians.
+  const span = high - low;
+  if (span >= 2 * Math.PI - 1e-12) return [-Math.PI, Math.PI];
+  let west = wrapLongitude(low);
+  // An eastward interval starting at the cut belongs to its negative side.
+  // Ending at the cut stays on the positive side; touching alone is not crossing.
+  if (span > 0 && Math.abs(west - Math.PI) < 1e-12) west = -Math.PI;
+  const east = west + span;
+  return east > Math.PI + 1e-12 ? [-Math.PI, Math.PI] : [west, Math.min(east, Math.PI)];
+}
+
+/** Cylindrical x is linear in longitude; width is monotone on each side of the equator.
+ * Latitude endpoints and the equator therefore contain all coordinate extrema.
+ */
+export function cylindricalBounds(
+  project: ProjectionImplementation['forward'],
+  parameters: AngularRanges,
+  origin: number,
+  over = false
+): ProjectionRenderingProfile['bounds'] {
+  const longitude = longitudeRange(parameters, origin, over);
+  const latitudes = [
+    parameters[0][1],
+    parameters[1][1],
+    Math.max(parameters[0][1], Math.min(parameters[1][1], 0))
+  ];
+  const points = longitude.flatMap(x => latitudes.map(y => project(origin + x, y)));
+  return envelope(
+    [Math.min(...points.map(p => p[0])), Math.max(...points.map(p => p[0]))],
+    [Math.min(...points.map(p => p[1])), Math.max(...points.map(p => p[1]))]
+  );
+}
+
+/** Transverse meridian strips are monotone away from their auxiliary equator
+ * and central meridian. Both are extrema candidates in addition to strip corners.
+ */
+export function transverseBounds(
+  project: ProjectionImplementation['forward'],
+  parameters: AngularRanges,
+  origin: number,
+  over = false,
+  equator = 0
+): ProjectionRenderingProfile['bounds'] {
+  const longitude = longitudeRange(parameters, origin, over);
+  // This endpoint argument applies to the regional strip, not the kernels'
+  // backside branches or the approximate series far from its central meridian.
+  // Let the profile clip unsupported coverage to its default rendering target.
+  if (maxAbs(longitude) > Math.PI / 6 + 1e-12)
+    throw new Error('Unsupported transverse rendering coverage');
+  const longitudes = [
+    longitude[0],
+    longitude[1],
+    Math.max(longitude[0], Math.min(longitude[1], 0))
+  ];
+  const latitudes = [
+    parameters[0][1],
+    parameters[1][1],
+    Math.max(parameters[0][1], Math.min(parameters[1][1], equator))
+  ];
+  const points = longitudes.flatMap(x => latitudes.map(y => project(origin + x, y)));
+  return envelope(
+    [Math.min(...points.map(p => p[0])), Math.max(...points.map(p => p[0]))],
+    [Math.min(...points.map(p => p[1])), Math.max(...points.map(p => p[1]))]
+  );
+}
+
+/** Van der Grinten is symmetric about the equator and central meridian;
+ * each quadrant's coordinate extrema lie on those axes or the parameters corners.
+ */
+export function vanDerGrintenBounds(
+  project: ProjectionImplementation['forward'],
+  parameters: AngularRanges,
+  origin: number,
+  over = false
+): ProjectionRenderingProfile['bounds'] {
+  const longitude = longitudeRange(parameters, origin, over);
+  const longitudes = [
+    longitude[0],
+    longitude[1],
+    Math.max(longitude[0], Math.min(longitude[1], 0))
+  ];
+  const latitudes = [
+    parameters[0][1],
+    parameters[1][1],
+    Math.max(parameters[0][1], Math.min(parameters[1][1], 0))
+  ];
+  const points = longitudes.flatMap(x => latitudes.map(y => project(origin + x, y)));
+  return envelope(
+    [Math.min(...points.map(p => p[0])), Math.max(...points.map(p => p[0]))],
+    [Math.min(...points.map(p => p[1])), Math.max(...points.map(p => p[1]))]
+  );
+}
+
+/** Conic radius is monotone in latitude and independent of longitude. */
+export function conicBounds(
+  project: ProjectionImplementation['forward'],
+  parameters: AngularRanges,
+  origin: number,
+  cone: number,
+  x0: number,
+  centerY: number,
+  over = false
+): ProjectionRenderingProfile['bounds'] {
+  const angles = scale(longitudeRange(parameters, origin, over), cone);
+  const radii = ordered(
+    centerY - project(origin, parameters[0][1])[1],
+    centerY - project(origin, parameters[1][1])[1]
+  );
+  return envelope(
+    add([x0, x0], multiply(radii, sine(angles))),
+    add([centerY, centerY], scale(multiply(radii, cosine(angles)), -1))
+  );
+}

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

@@ -0,0 +1,96 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {
+  GeographicBounds,
+  ProjectionImplementation,
+  ProjectionRenderingProfile
+} from '../types';
+import {unionRenderingBounds} from './geographic-bounds';
+
+/** Algorithms own extent policy; descriptor assembly only selects a resolved profile. */
+export function resolveRenderingProfile(
+  getRenderingProfile: NonNullable<ProjectionImplementation['getRenderingProfile']>,
+  coverage?: GeographicBounds
+): ProjectionRenderingProfile {
+  if (coverage) {
+    try {
+      const profile = getRenderingProfile(coverage);
+      // Bounds may be lazy. Resolve them here so failures retry the default profile.
+      return resolveBounds(profile);
+    } catch {
+      // Declared metadata remains intact even when its rendering profile falls back.
+    }
+  }
+  const profile = getRenderingProfile();
+  return resolveBounds(profile);
+}
+
+/** Validate the finite-envelope contract without choosing an extent for an algorithm. */
+function resolveBounds(profile: ProjectionRenderingProfile): ProjectionRenderingProfile {
+  const bounds = profile.bounds;
+  if (bounds.some(corner => corner.some(value => !Number.isFinite(value))))
+    throw new Error('Projection rendering bounds must be finite');
+  return {bounds, normalize: profile.normalize?.bind(profile)};
+}
+
+/** Adapt a curved-domain operation to Greenwich degrees, retaining unchanged inputs exactly. */
+export function createAngularNormalization(
+  normalize: NonNullable<ProjectionRenderingProfile['normalize']>,
+  primeMeridian = 0
+): NonNullable<ProjectionRenderingProfile['normalize']> {
+  return point => {
+    const x = (point.x * Math.PI) / 180 - primeMeridian;
+    const y = (point.y * Math.PI) / 180;
+    const native = {x, y, z: point.z};
+    normalize(native);
+    // Interior points need no conversion back: even an identity radians round
+    // trip can change a covered degree coordinate at a projection seam.
+    if (native.x !== x) point.x = ((native.x + primeMeridian) * 180) / Math.PI;
+    if (native.y !== y) point.y = (native.y * 180) / Math.PI;
+  };
+}
+
+/** Combine projection-owned profiles for disconnected geographic coverage.
+ * A null result explicitly marks an empty piece. Unexpected callback/bounds
+ * errors propagate; only an entirely empty collection returns null.
+ */
+export function combineRenderingProfiles(
+  regions: readonly GeographicBounds[],
+  getProfile: (region: GeographicBounds) => ProjectionRenderingProfile | null
+): ProjectionRenderingProfile | null {
+  const profiles: ProjectionRenderingProfile[] = [];
+  for (const region of regions) {
+    const profile = getProfile(region);
+    if (profile !== null) profiles.push(resolveBounds(profile));
+  }
+  if (!profiles.length) return null;
+  if (profiles.length === 1) return profiles[0];
+  return {
+    bounds: unionRenderingBounds(profiles.map(profile => profile.bounds)),
+    normalize(point) {
+      let bestX = point.x,
+        bestY = point.y,
+        best = Infinity;
+      for (const profile of profiles) {
+        const candidate = {x: point.x, y: point.y, z: point.z};
+        profile.normalize?.(candidate);
+        // Compare the actual normalized positions, rather than rectangular
+        // envelopes that may include points outside a curved rendering target.
+        const distance =
+          Math.sin(((candidate.y - point.y) * Math.PI) / 360) ** 2 +
+          Math.cos((point.y * Math.PI) / 180) *
+            Math.cos((candidate.y * Math.PI) / 180) *
+            Math.sin(((candidate.x - point.x) * Math.PI) / 360) ** 2;
+        if (distance < best) {
+          best = distance;
+          bestX = candidate.x;
+          bestY = candidate.y;
+        }
+      }
+      point.x = bestX;
+      point.y = bestY;
+    }
+  };
+}

package/src/projection/experimental/rendering-profile/spherical-rendering-domain.ts

@@ -0,0 +1,175 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {AngularRanges} from './geographic-bounds';
+import {wrapLongitude} from '../parameters';
+
+export type Vector = readonly [number, number, number];
+export type AngularDomain = {latitude: number; distance: number};
+export function geographicVector(longitude: number, latitude: number): Vector {
+  return [
+    Math.cos(latitude) * Math.cos(longitude),
+    Math.cos(latitude) * Math.sin(longitude),
+    Math.sin(latitude)
+  ];
+}
+const dot = (a: Vector, b: Vector) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+
+/** Solve A cos(t) + B sin(t) = C; retain roots in the specified interval. */
+export function trigonometricRoots(
+  a: number,
+  b: number,
+  c: number,
+  low: number,
+  high: number
+): number[] {
+  const radius = Math.hypot(a, b);
+  if (!radius || Math.abs(c) > radius + 1e-14) return [];
+  const angle = Math.atan2(b, a);
+  const offset = Math.acos(Math.max(-1, Math.min(1, c / radius)));
+  const roots: number[] = [];
+  for (const phase of [angle - offset, angle + offset]) {
+    for (
+      let k = Math.ceil((low - phase) / (2 * Math.PI));
+      k <= Math.floor((high - phase) / (2 * Math.PI));
+      k++
+    ) {
+      roots.push(phase + k * 2 * Math.PI);
+    }
+  }
+  return roots;
+}
+
+/** Extremize a linear form on a geographic rectangle intersected with a spherical cap.
+ * Candidates are stationary points, edge intersections and cap tangent points;
+ * no tessellation or curve sampling is needed.
+ */
+export function sphericalExtremum(
+  vector: Vector,
+  parameters: AngularRanges,
+  domain?: AngularDomain,
+  maximize = true
+): {value: number; point: [number, number]} {
+  const [[west, south], [east, north]] = parameters;
+  const center = (west + east) / 2;
+  const axis: Vector = domain
+    ? [Math.cos(domain.latitude), 0, Math.sin(domain.latitude)]
+    : [1, 0, 0];
+  const limit = domain ? Math.cos(domain.distance) : -1;
+  let best = maximize ? -Infinity : Infinity;
+  let point: [number, number] = [NaN, NaN];
+  const consider = (longitude: number, latitude: number) => {
+    longitude = center + wrapLongitude(longitude - center);
+    if (
+      longitude < west - 1e-12 ||
+      longitude > east + 1e-12 ||
+      latitude < south - 1e-12 ||
+      latitude > north + 1e-12
+    )
+      return;
+    const position = geographicVector(longitude, latitude);
+    if (domain && dot(axis, position) < limit - 1e-13) return;
+    const value = dot(vector, position);
+    if (maximize ? value > best : value < best) {
+      best = value;
+      point = [longitude, latitude];
+    }
+  };
+  // Rectangle corners and stationary points of each longitude/latitude edge.
+  const longitudes = [west, east, ...trigonometricRoots(-vector[1], vector[0], 0, west, east)];
+  for (const longitude of longitudes) {
+    const coefficient = vector[0] * Math.cos(longitude) + vector[1] * Math.sin(longitude);
+    for (const latitude of [
+      south,
+      north,
+      ...trigonometricRoots(vector[2], -coefficient, 0, south, north)
+    ])
+      consider(longitude, latitude);
+  }
+  if (domain) {
+    const [a, , c] = axis;
+    // Intersections of the cap circle with the four geographic edges.
+    for (const latitude of [south, north]) {
+      for (const longitude of trigonometricRoots(
+        a * Math.cos(latitude),
+        0,
+        limit - c * Math.sin(latitude),
+        west,
+        east
+      ))
+        consider(longitude, latitude);
+    }
+    for (const longitude of [west, east]) {
+      for (const latitude of trigonometricRoots(a * Math.cos(longitude), c, limit, south, north))
+        consider(longitude, latitude);
+    }
+    // Extrema of the linear form on the cap circle: its two tangency points.
+    const parallel = dot(vector, axis);
+    let tangent = vector.map((value, index) => value - parallel * axis[index]);
+    let length = Math.hypot(...tangent);
+    if (length <= 1e-14) {
+      // Parallel forms are constant on the cap circle; choose its meridian tangency.
+      tangent = [-axis[2], 0, axis[0]];
+      length = 1;
+    }
+    if (length > 1e-14) {
+      for (const sign of [-1, 1]) {
+        const position = axis.map(
+          (value, index) =>
+            value * limit + (sign * tangent[index] * Math.sin(domain.distance)) / length
+        );
+        consider(
+          Math.atan2(position[1], position[0]),
+          Math.atan2(position[2], Math.hypot(position[0], position[1]))
+        );
+      }
+    }
+  }
+  if (!Number.isFinite(best))
+    throw new Error('CRS coverage does not intersect the rendering domain');
+  return {value: best, point};
+}
+
+export function sphericalRange(
+  vector: Vector,
+  parameters: AngularRanges,
+  domain?: AngularDomain
+): [number, number] {
+  return [
+    sphericalExtremum(vector, parameters, domain, false).value,
+    sphericalExtremum(vector, parameters, domain).value
+  ];
+}
+
+/** Extremize a linear-fractional projection by solving its support equation.
+ * A positive denominator makes max(N-qD)=0 monotone in q, so bisection
+ * brackets the true extremum instead of searching sampled boundary points.
+ */
+export function sphericalRatioRange(
+  numerator: Vector,
+  denominator: Vector,
+  constant: number,
+  parameters: AngularRanges,
+  domain?: AngularDomain
+): [number, number] {
+  const n = sphericalRange(numerator, parameters, domain);
+  const d = sphericalRange(denominator, parameters, domain).map(value => value + constant);
+  if (d[0] <= 0) throw new Error('Projection rendering denominator is not positive');
+  const quotients = n.flatMap(value => d.map(divisor => value / divisor));
+  return [false, true].map(maximize => {
+    let low = Math.min(...quotients),
+      high = Math.max(...quotients);
+    for (let iteration = 0; iteration < 60; iteration++) {
+      const middle = (low + high) / 2;
+      const vector = numerator.map(
+        (value, index) => value - middle * denominator[index]
+      ) as unknown as Vector;
+      const residual =
+        sphericalExtremum(vector, parameters, domain, maximize).value - middle * constant;
+      if (residual > 0) low = middle;
+      else high = middle;
+    }
+    return maximize ? high : low;
+  }) as [number, number];
+}