@math.gl/geospatial 5.0.0-alpha.2 → 5.0.0-alpha.20

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

@@ -0,0 +1,133 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {
+  GeographicBounds,
+  ProjectionImplementation,
+  ProjectionRenderingProfile
+} from '../types';
+import type {AngularRanges} from './geographic-bounds';
+import {
+  clampGeographicPoint,
+  getAngularRanges,
+  getLongitudeSpan,
+  getGeographicBounds,
+  intersectGeographicBounds,
+  normalizeLongitude
+} from './geographic-bounds';
+import {combineRenderingProfiles} from './rendering-profile';
+
+export type ResolveRenderingBounds = (
+  parameters: AngularRanges
+) => ProjectionRenderingProfile['bounds'];
+
+/** Clamp Greenwich longitude/latitude in degrees to one rendering rectangle. */
+export function normalizeCoverage(
+  point: {x: number; y: number},
+  coverage: GeographicBounds,
+  center = 0,
+  over = false
+): void {
+  const span = getLongitudeSpan(coverage);
+  const west =
+    span === 360
+      ? center - 180
+      : coverage[0] + Math.round((center - coverage[0] - span / 2) / 360) * 360;
+  const east = west + span;
+  // Keep geographic values in degrees: a covered seam endpoint must not be
+  // perturbed by a radians round trip onto the opposite projection branch.
+  if (over) {
+    point.x = Math.max(west, Math.min(east, point.x));
+    point.y = Math.max(coverage[1], Math.min(coverage[3], point.y));
+    return;
+  }
+  const best = clampGeographicPoint(coverage, [point.x, point.y]);
+  let longitude = best[0];
+  if (best[0] === normalizeLongitude(point.x) && point.x >= west && point.x <= east)
+    longitude = point.x;
+  else if (longitude < west || longitude > east)
+    longitude += Math.round(((west + east) / 2 - longitude) / 360) * 360;
+  const offset = longitude - center;
+  point.x = Math.abs(offset) <= 180 ? longitude : center + normalizeLongitude(offset);
+  point.y = best[1];
+}
+
+/** Geographic coverage with a projection-owned analytical envelope. */
+export function createRectangleRenderingProfile(
+  resolveBounds: ResolveRenderingBounds,
+  coverage: GeographicBounds,
+  origin = 0,
+  primeMeridian = 0,
+  over = false
+): ProjectionRenderingProfile {
+  const center = ((origin + primeMeridian) * 180) / Math.PI;
+  return {
+    get bounds() {
+      return resolveBounds(getAngularRanges(coverage, primeMeridian, origin));
+    },
+    normalize(point) {
+      normalizeCoverage(point, coverage, center, over);
+    }
+  };
+}
+
+function createRegionsRenderingProfile(
+  resolveBounds: ResolveRenderingBounds,
+  regions: readonly GeographicBounds[],
+  origin: number,
+  primeMeridian: number,
+  over: boolean
+): ProjectionRenderingProfile {
+  const profile = combineRenderingProfiles(regions, region =>
+    createRectangleRenderingProfile(resolveBounds, region, origin, primeMeridian, over)
+  );
+  if (!profile) throw new Error('CRS coverage does not intersect the rendering target');
+  return profile;
+}
+
+/** Algorithms opt into rectangular coverage and clipping to their own default target. */
+export function withRectangleRenderingProfile(
+  implementation: ProjectionImplementation,
+  parameters: AngularRanges,
+  resolveBounds: ResolveRenderingBounds,
+  primeMeridian = 0,
+  over = false
+): ProjectionImplementation {
+  const origin = (parameters[0][0] + parameters[1][0]) / 2;
+  const defaults = getGeographicBounds(parameters, primeMeridian);
+  const center = ((origin + primeMeridian) * 180) / Math.PI;
+  return {
+    ...implementation,
+    longitudeOrigin: origin,
+    getRenderingProfile(coverage) {
+      if (!coverage)
+        return {
+          bounds: resolveBounds(parameters),
+          normalize(point) {
+            normalizeCoverage(point, defaults, center, over);
+          }
+        };
+      try {
+        const profile = createRectangleRenderingProfile(
+          resolveBounds,
+          coverage,
+          origin,
+          primeMeridian,
+          over
+        );
+        const bounds = profile.bounds;
+        return {bounds, normalize: profile.normalize};
+      } catch {
+        // Singular coverage is clipped to this algorithm's chosen finite target.
+        return createRegionsRenderingProfile(
+          resolveBounds,
+          intersectGeographicBounds(coverage, defaults),
+          origin,
+          primeMeridian,
+          over
+        );
+      }
+    }
+  };
+}

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;
+    }
+  };
+}