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

package/src/projection/experimental/projections/ob-tran.ts

@@ -0,0 +1,279 @@
+// math.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2014 Mike Adair, Richard Greenwood, Didier Richard, Stephen Irons, Olivier Terral and Calvin Metcalf (proj4js)
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+// SPDX-FileComment: Rotation equations directly ported from proj4js 2.22.0 lib/projections/ob_tran.js. See ../../../PROJ4-LICENSE.md. Modified to use an explicitly supplied plugin instead of proj4js's global registry.
+import type {
+  ProjectionPlugin,
+  ProjectionParameters,
+  ProjectionPoint,
+  ProjectionRenderingProfile
+} from '../types';
+import {createProjection, projectionOperation} from '../mutable-projection';
+import {createGeographicProfile} from '../rendering-profile/geographic-rendering-profile';
+import {numberParameter, wrapLongitude} from '../parameters';
+import {createAngularNormalization} from '../rendering-profile/rendering-profile';
+import {TypeScriptCRSError} from '../crs/types';
+import {createRectangleRenderingProfile} from '../rendering-profile/rectangular-rendering-profile';
+import type {GeographicBounds} from '../types';
+import {
+  createAngularRanges,
+  getAngularRanges,
+  getGeographicBounds
+} from '../rendering-profile/geographic-bounds';
+import {sphericalRange, sphericalRatioRange} from '../rendering-profile/spherical-rendering-domain';
+
+const rotationParameters = [
+  'o_proj',
+  'o_alpha',
+  'o_lon_c',
+  'o_lat_c',
+  'o_lon_p',
+  'o_lat_p',
+  'o_lon_1',
+  'o_lat_1',
+  'o_lon_2',
+  'o_lat_2'
+];
+const normalizedName = (name: string): string => name.toLowerCase().replace(/[ _-]/g, '');
+const has = (parameters: ProjectionParameters, name: string): boolean =>
+  Object.prototype.hasOwnProperty.call(parameters, name);
+const radians = (parameters: ProjectionParameters, name: string): number =>
+  (numberParameter(parameters, name, 0) * Math.PI) / 180;
+function rotation(parameters: ProjectionParameters): {lamp: number; phip: number} {
+  const sets = [
+    ['o_alpha', 'o_lon_c', 'o_lat_c'],
+    ['o_lat_p', 'o_lon_p'],
+    ['o_lon_1', 'o_lat_1', 'o_lon_2', 'o_lat_2']
+  ];
+  const selected = sets.find(set => set.some(name => has(parameters, name)));
+  if (!selected) throw new Error('Oblique transformation requires a rotation parameter set');
+  for (const name of selected) {
+    if (!has(parameters, name)) throw new Error('Oblique transformation requires ' + name);
+    if (name.includes('lat') && Math.abs(radians(parameters, name)) > Math.PI / 2)
+      throw new Error('Invalid rotation latitude: ' + name);
+  }
+  if (selected === sets[0]) {
+    const alpha = radians(parameters, 'o_alpha'),
+      lamc = radians(parameters, 'o_lon_c'),
+      phic = radians(parameters, 'o_lat_c');
+    if (Math.abs(phic) >= Math.PI / 2 - 1e-10)
+      throw new Error('Rotation center must be away from the poles');
+    return {
+      lamp: lamc + Math.atan2(-Math.cos(alpha), -Math.sin(alpha) * Math.sin(phic)),
+      phip: Math.asin(Math.cos(phic) * Math.sin(alpha))
+    };
+  }
+  if (selected === sets[1])
+    return {lamp: radians(parameters, 'o_lon_p'), phip: radians(parameters, 'o_lat_p')};
+  const lam1 = radians(parameters, 'o_lon_1'),
+    phi1 = radians(parameters, 'o_lat_1'),
+    lam2 = radians(parameters, 'o_lon_2'),
+    phi2 = radians(parameters, 'o_lat_2');
+  if (
+    Math.abs(phi1) >= Math.PI / 2 - 1e-10 ||
+    Math.abs(phi2) >= Math.PI / 2 - 1e-10 ||
+    Math.abs(phi1) < 1e-10 ||
+    Math.abs(phi1 - phi2) < 1e-10
+  )
+    throw new Error('Invalid new-equator reference points');
+  const lamp = Math.atan2(
+    Math.cos(phi1) * Math.sin(phi2) * Math.cos(lam1) -
+      Math.sin(phi1) * Math.cos(phi2) * Math.cos(lam2),
+    Math.sin(phi1) * Math.cos(phi2) * Math.sin(lam2) -
+      Math.cos(phi1) * Math.sin(phi2) * Math.sin(lam1)
+  );
+  return {lamp, phip: Math.atan(-Math.cos(lamp - lam1) / Math.tan(phi1))};
+}
+/** Explicit dependency: register obliqueTransformation(mollweide), or use 'longlat' for rotated degrees. */
+export function obliqueTransformation(wrapped: ProjectionPlugin | 'longlat'): ProjectionPlugin {
+  const geographic = wrapped === 'longlat';
+  if (!geographic && ['obtran', 'geocent'].includes(normalizedName(wrapped.name)))
+    throw new Error('Cannot wrap a composite or geocentric projection');
+  return {
+    name: 'ob_tran',
+    aliases: ['General Oblique Transformation', 'General_Oblique_Transformation'],
+    parameters: [...rotationParameters, 'lon_0', ...(geographic ? [] : wrapped.parameters)],
+    flags: geographic ? [] : wrapped.flags,
+    create(context) {
+      const {parameters} = context;
+      const requested = parameters['o_proj'];
+      const accepted = geographic
+        ? ['longlat', 'latlong', 'lonlat', 'latlon', 'identity']
+        : [wrapped.name, ...(wrapped.aliases || [])];
+      if (requested && !accepted.map(normalizedName).includes(normalizedName(requested)))
+        throw new TypeScriptCRSError(
+          'missing-plugin',
+          'Oblique transformation dependency does not match +o_proj=' + requested
+        );
+      const {lamp, phip} = rotation(parameters);
+      const cphip = Math.cos(phip),
+        sphip = Math.sin(phip),
+        oblique = Math.abs(phip) > 1e-10;
+      const longitudeOrigin = radians(parameters, 'lon_0');
+      const over = has(parameters, 'over');
+      const innerParameters: Record<string, string | undefined> = {
+        ...parameters,
+        proj: geographic ? 'longlat' : requested || wrapped.name,
+        lon_0: '0'
+      };
+      for (const name of rotationParameters) delete innerParameters[name];
+      const inner = geographic
+        ? createProjection(
+            point => {
+              point.x *= 180 / Math.PI;
+              point.y *= 180 / Math.PI;
+            },
+            point => {
+              point.x *= Math.PI / 180;
+              point.y *= Math.PI / 180;
+            }
+          )
+        : wrapped.create({
+            ...context,
+            parameters: Object.freeze(innerParameters),
+            primeMeridian: 0
+          });
+      const forward = projectionOperation(inner, false),
+        inverse = projectionOperation(inner, true);
+      const asin = (value: number): number => Math.asin(Math.max(-1, Math.min(1, value)));
+      const rotate = (point: ProjectionPoint) => {
+        const longitude = point.x,
+          latitude = point.y;
+        const lam = wrapLongitude(longitude - longitudeOrigin, over);
+        const coslam = Math.cos(lam),
+          sinphi = Math.sin(latitude),
+          cosphi = Math.cos(latitude);
+        const lon = wrapLongitude(
+          Math.atan2(
+            cosphi * Math.sin(lam),
+            oblique ? sphip * cosphi * coslam + cphip * sinphi : sinphi
+          ) + lamp
+        );
+        const lat = asin(oblique ? sphip * sinphi - cphip * cosphi * coslam : -cosphi * coslam);
+        point.x = lon;
+        point.y = lat;
+      };
+      const unrotate = (point: ProjectionPoint) => {
+        const innerLongitude = point.x,
+          latitude = point.y;
+        const lam = innerLongitude - lamp,
+          coslam = Math.cos(lam),
+          sinphi = Math.sin(latitude),
+          cosphi = Math.cos(latitude);
+        const lon = Math.atan2(
+          cosphi * Math.sin(lam),
+          oblique ? sphip * cosphi * coslam - cphip * sinphi : -sinphi
+        );
+        const lat = asin(oblique ? sphip * sinphi + cphip * cosphi * coslam : cosphi * coslam);
+        point.x = wrapLongitude(lon + longitudeOrigin);
+        point.y = lat;
+      };
+      const implementation = createProjection(
+        point => {
+          rotate(point);
+          forward(point);
+        },
+        point => {
+          inverse(point);
+          unrotate(point);
+        }
+      );
+      const getChildProfile = geographic
+        ? createGeographicProfile(innerParameters)
+        : inner.getRenderingProfile?.bind(inner);
+      if (!getChildProfile) return implementation;
+      const wrapProfile = (
+        child: ProjectionRenderingProfile,
+        coverage?: GeographicBounds
+      ): ProjectionRenderingProfile => {
+        const source =
+          coverage &&
+          createRectangleRenderingProfile(
+            () => child.bounds,
+            coverage,
+            longitudeOrigin,
+            context.primeMeridian ?? 0,
+            over
+          );
+        const normalizeRotated = createAngularNormalization(point => {
+          const longitude = point.x,
+            latitude = point.y;
+          rotate(point);
+          const x = (point.x * 180) / Math.PI,
+            y = (point.y * 180) / Math.PI;
+          const rotated = {x, y, z: point.z};
+          child.normalize?.(rotated);
+          if (rotated.x === x && rotated.y === y) {
+            // An unchanged child coordinate needs no inverse rotation or degree round trip.
+            point.x = longitude;
+            point.y = latitude;
+            return;
+          }
+          point.x = (rotated.x * Math.PI) / 180;
+          point.y = (rotated.y * Math.PI) / 180;
+          unrotate(point);
+          if (over) point.x += Math.round((longitude - point.x) / (2 * Math.PI)) * 2 * Math.PI;
+        }, context.primeMeridian ?? 0);
+        return {
+          get bounds() {
+            const bounds = child.bounds;
+            // The longlat child stores degrees; other children store native linear units.
+            const degrees = (
+              corner: readonly [number, number, number]
+            ): [number, number, number] => [
+              (corner[0] * 180) / Math.PI,
+              (corner[1] * 180) / Math.PI,
+              corner[2]
+            ];
+            return geographic ? ([degrees(bounds[0]), degrees(bounds[1])] as const) : bounds;
+          },
+          normalize(point) {
+            source?.normalize!(point);
+            normalizeRotated(point);
+          }
+        };
+      };
+      return {
+        ...implementation,
+        longitudeOrigin,
+        getRenderingProfile(coverage) {
+          if (!coverage) return wrapProfile(getChildProfile());
+          const parameters = getAngularRanges(
+            coverage,
+            context.primeMeridian ?? 0,
+            longitudeOrigin
+          );
+          const local = createAngularRanges(
+            parameters[0][0] - longitudeOrigin,
+            parameters[0][1],
+            parameters[1][0] - longitudeOrigin,
+            parameters[1][1]
+          );
+          const z = sphericalRange(oblique ? [-cphip, 0, sphip] : [-1, 0, 0], local);
+          const xAxis = oblique ? ([sphip, 0, cphip] as const) : ([0, 0, 1] as const);
+          const x = sphericalRange(xAxis, local);
+          // A rotation is linear on the sphere. Latitude extrema follow z;
+          // longitude is a linear-fractional form unless the rotated seam is crossed.
+          const longitude =
+            x[0] > 0
+              ? sphericalRatioRange([0, 1, 0], xAxis, 0, local).map(Math.atan)
+              : [-Math.PI, Math.PI];
+          return wrapProfile(
+            getChildProfile(
+              getGeographicBounds(
+                createAngularRanges(
+                  longitude[0] + lamp,
+                  asin(z[0]),
+                  longitude[1] + lamp,
+                  asin(z[1])
+                )
+              )
+            ),
+            coverage
+          );
+        }
+      };
+    }
+  };
+}

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

@@ -0,0 +1,86 @@
+// 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 {hotineBounds} from '../rendering-profile/regional-rendering-bounds';
+import {createAngularRanges} from '../rendering-profile/geographic-bounds';
+import {withRectangleRenderingProfile} from '../rendering-profile/rectangular-rendering-profile';
+import type {ProjectionPlugin} from '../types';
+import {
+  catalogueParameters,
+  catalogueBoundsParameters,
+  bindCatalogueKernel
+} from '../catalogue-kernel';
+import {createState, forward, inverse} from '../kernels/omerc';
+import {numberParameter} from '../parameters';
+import {flagParameter} from '../kernel';
+
+export const obliqueMercator: ProjectionPlugin = {
+  name: 'omerc',
+  aliases: [
+    'Hotine_Oblique_Mercator',
+    'Hotine Oblique Mercator',
+    'Hotine_Oblique_Mercator_variant_A',
+    'Hotine_Oblique_Mercator_Variant_B',
+    'Hotine_Oblique_Mercator_Azimuth_Natural_Origin',
+    'Hotine_Oblique_Mercator_Two_Point_Natural_Origin',
+    'Hotine_Oblique_Mercator_Azimuth_Center',
+    'Oblique_Mercator'
+  ],
+  parameters: [
+    'lon_0',
+    'x_0',
+    'y_0',
+    'lat_0',
+    'k',
+    'k_0',
+    'alpha',
+    'gamma',
+    'lonc',
+    'lon_1',
+    'lon_2',
+    'lat_1',
+    'lat_2',
+    'no_off',
+    'no_uoff',
+    'no_rot'
+  ],
+  flags: ['no_off', 'no_uoff', 'no_rot'],
+  create(context) {
+    const base = catalogueParameters(context);
+    if (Math.abs(base.lat0) >= Math.PI / 2)
+      throw new Error('Oblique Mercator origin must be away from the poles');
+    const hasAzimuth =
+      Object.prototype.hasOwnProperty.call(context.parameters, 'alpha') ||
+      Object.prototype.hasOwnProperty.call(context.parameters, 'gamma');
+    const required = hasAzimuth ? ['lonc'] : ['lon_1', 'lat_1', 'lon_2', 'lat_2'];
+    for (const name of required)
+      if (!Object.prototype.hasOwnProperty.call(context.parameters, name))
+        throw new Error('Oblique Mercator requires ' + name);
+    const state = createState(base, {
+      projName: context.parameters['proj'] || 'omerc',
+      alpha: (numberParameter(context.parameters, 'alpha', NaN) * Math.PI) / 180,
+      rectified_grid_angle: (numberParameter(context.parameters, 'gamma', NaN) * Math.PI) / 180,
+      longc: (numberParameter(context.parameters, 'lonc', 0) * Math.PI) / 180,
+      long1: (numberParameter(context.parameters, 'lon_1', 0) * Math.PI) / 180,
+      long2: (numberParameter(context.parameters, 'lon_2', 0) * Math.PI) / 180,
+      no_off: flagParameter(context.parameters, 'no_off'),
+      no_uoff: flagParameter(context.parameters, 'no_uoff'),
+      no_rot: flagParameter(context.parameters, 'no_rot')
+    });
+    // Use a regional extent around the effective oblique central meridian.
+    const projection = bindCatalogueKernel('omerc', context, state, forward, inverse);
+    return withRectangleRenderingProfile(
+      projection,
+      createAngularRanges(
+        state.lam0 - Math.PI / 18,
+        Math.max(-Math.PI / 2 + 1e-8, base.lat0 - Math.PI / 18),
+        state.lam0 + Math.PI / 18,
+        Math.min(Math.PI / 2 - 1e-8, base.lat0 + Math.PI / 18)
+      ),
+      ranges => hotineBounds(catalogueBoundsParameters(state, context), ranges),
+      base.primeMeridian,
+      base.over
+    );
+  }
+};

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

@@ -0,0 +1,34 @@
+// 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 {sphericalAzimuthalBounds} 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/ortho';
+
+export const orthographic: ProjectionPlugin = {
+  name: 'ortho',
+  aliases: [],
+  parameters: ['lon_0', 'x_0', 'y_0', 'lat_0'],
+  create(context) {
+    const base = catalogueParameters(context);
+
+    const state = createState(base);
+    // Keep the rendering boundary finite without restricting raw conversion.
+    return withAngularRenderingProfile(
+      bindCatalogueKernel('ortho', context, state, forward, inverse, horizonGuard(base, 0, true)),
+      base,
+      Math.PI / 2,
+      (region, domain) =>
+        sphericalAzimuthalBounds(catalogueBoundsParameters(base, context), region, domain, 'ortho'),
+      Math.PI / 2
+    );
+  }
+};

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

@@ -0,0 +1,40 @@
+// 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 {polyconicBounds} from '../rendering-profile/regional-rendering-bounds';
+import {createAngularRanges} from '../rendering-profile/geographic-bounds';
+import {withRectangleRenderingProfile} from '../rendering-profile/rectangular-rendering-profile';
+import type {ProjectionPlugin} from '../types';
+import {
+  catalogueParameters,
+  catalogueBoundsParameters,
+  bindCatalogueKernel
+} from '../catalogue-kernel';
+import {createState, forward, inverse} from '../kernels/poly';
+
+export const polyconic: ProjectionPlugin = {
+  name: 'poly',
+  aliases: ['Polyconic', 'American_Polyconic'],
+  parameters: ['lon_0', 'x_0', 'y_0', 'lat_0'],
+  create(context) {
+    const base = catalogueParameters(context);
+
+    const state = createState(base);
+    // Use a regional meridian strip for polyconic rendering.
+    const projection = bindCatalogueKernel('poly', context, state, forward, inverse);
+    return withRectangleRenderingProfile(
+      projection,
+      createAngularRanges(
+        base.long0 - Math.PI / 6,
+        Math.max(-Math.PI / 2 + 1e-8, base.lat0 - Math.PI / 2 + 1e-8),
+        base.long0 + Math.PI / 6,
+        Math.min(Math.PI / 2 - 1e-8, base.lat0 + Math.PI / 2 - 1e-8)
+      ),
+      ranges =>
+        polyconicBounds(catalogueBoundsParameters(base, context), projection.forward, ranges),
+      base.primeMeridian,
+      base.over
+    );
+  }
+};

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

@@ -0,0 +1,84 @@
+// 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 type {ProjectionPlugin} from '../types';
+import {createAngularNormalization} from '../rendering-profile/rendering-profile';
+import {createGeographicProfile} from '../rendering-profile/geographic-rendering-profile';
+import {catalogueParameters, bindCatalogueKernel} from '../catalogue-kernel';
+import {numberParameter} from '../parameters';
+import {createState, forward, inverse} from '../kernels/qsc';
+import {createAngularRanges} from '../rendering-profile/geographic-bounds';
+import {createRectangleRenderingProfile} from '../rendering-profile/rectangular-rendering-profile';
+import {sphericalRange} from '../rendering-profile/spherical-rendering-domain';
+import {envelope} from '../rendering-profile/rendering-bounds';
+
+export const quadrilateralizedSphericalCube: ProjectionPlugin = {
+  name: 'qsc',
+  aliases: ['Quadrilateralized Spherical Cube', 'Quadrilateralized_Spherical_Cube'],
+  parameters: ['lon_0', 'x_0', 'y_0', 'lat_0'],
+  create(context) {
+    const base = catalogueParameters(context);
+    const primeMeridian = context.primeMeridian ?? 0;
+
+    const state = createState(base);
+    const implementation = bindCatalogueKernel('qsc', context, state, forward, inverse);
+    const x0 = numberParameter(context.parameters, 'x_0', 0);
+    const y0 = numberParameter(context.parameters, 'y_0', 0);
+    // A QSC rendering target is one cube face, including its square corners.
+    return {
+      ...implementation,
+      longitudeOrigin: base.long0,
+      getRenderingProfile(coverage) {
+        if (coverage)
+          return createRectangleRenderingProfile(
+            region => {
+              const latitude = (phi: number) =>
+                base.es ? Math.atan((1 - base.es) * Math.tan(phi)) : phi;
+              const local = createAngularRanges(
+                region[0][0] - base.long0,
+                latitude(region[0][1]),
+                region[1][0] - base.long0,
+                latitude(region[1][1])
+              );
+              const axis =
+                state.face === 5
+                  ? ([0, 0, 1] as const)
+                  : state.face === 6
+                    ? ([0, 0, -1] as const)
+                    : ([1, 0, 0] as const);
+              const cosine = sphericalRange(axis, local)[0];
+              // QSC's reduced sector has |mu|, |theta| <= pi/4. Bound its
+              // denominator away from zero over the whole sector analytically.
+              const radius = base.a * Math.sqrt((1 - cosine) / (0.5 * (1 - Math.SQRT1_2)));
+              return envelope([x0 - radius, x0 + radius], [y0 - radius, y0 + radius]);
+            },
+            coverage,
+            base.long0,
+            primeMeridian
+          );
+        const defaultBounds = [
+          [x0 - base.a, y0 - base.a, 0],
+          [x0 + base.a, y0 + base.a, 0]
+        ] as const;
+        const normalizeGeographic = createGeographicProfile(context.parameters, primeMeridian)()
+          .normalize!;
+        const normalizeFace = createAngularNormalization(point => {
+          const [x, y] = implementation.forward(point.x, point.y);
+          if (Math.abs(x - x0) <= base.a && Math.abs(y - y0) <= base.a) return;
+          [point.x, point.y] = implementation.inverse(
+            x0 + Math.max(-base.a, Math.min(base.a, x - x0)),
+            y0 + Math.max(-base.a, Math.min(base.a, y - y0))
+          );
+        }, primeMeridian);
+        return {
+          bounds: defaultBounds,
+          normalize(point) {
+            normalizeGeographic(point);
+            normalizeFace(point);
+          }
+        };
+      }
+    };
+  }
+};

package/src/projection/experimental/projections/robin.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 {cylindricalBounds} 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/robin';
+
+export const robinson: ProjectionPlugin = {
+  name: 'robin',
+  aliases: ['Robinson'],
+  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('robin', context, state, forward, inverse);
+    return withRectangleRenderingProfile(
+      projection,
+      createAngularRanges(base.long0 - Math.PI, -Math.PI / 2, base.long0 + Math.PI, Math.PI / 2),
+      ranges => cylindricalBounds(projection.forward, ranges, base.long0, base.over),
+      base.primeMeridian,
+      base.over
+    );
+  }
+};

package/src/projection/experimental/projections/sinu.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 {cylindricalBounds} 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/sinu';
+
+export const sinusoidal: ProjectionPlugin = {
+  name: 'sinu',
+  aliases: ['Sinusoidal'],
+  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('sinu', context, state, forward, inverse);
+    return withRectangleRenderingProfile(
+      projection,
+      createAngularRanges(base.long0 - Math.PI, -Math.PI / 2, base.long0 + Math.PI, Math.PI / 2),
+      ranges => cylindricalBounds(projection.forward, ranges, base.long0, base.over),
+      base.primeMeridian,
+      base.over
+    );
+  }
+};

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

@@ -0,0 +1,39 @@
+// 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 {swissBounds} from '../rendering-profile/regional-rendering-bounds';
+import {createAngularRanges} from '../rendering-profile/geographic-bounds';
+import {withRectangleRenderingProfile} from '../rendering-profile/rectangular-rendering-profile';
+import type {ProjectionPlugin} from '../types';
+import {
+  catalogueParameters,
+  catalogueBoundsParameters,
+  bindCatalogueKernel
+} from '../catalogue-kernel';
+import {createState, forward, inverse} from '../kernels/somerc';
+
+export const swissObliqueMercator: ProjectionPlugin = {
+  name: 'somerc',
+  aliases: [],
+  parameters: ['lon_0', 'x_0', 'y_0', 'lat_0', 'k', 'k_0'],
+  create(context) {
+    const base = catalogueParameters(context);
+
+    const state = createState(base, {rf: base.a === base.b ? Infinity : 1 / (1 - base.b / base.a)});
+    // Swiss oblique Mercator has a regional, center-relative rendering target.
+    const projection = bindCatalogueKernel('somerc', context, state, forward, inverse);
+    return withRectangleRenderingProfile(
+      projection,
+      createAngularRanges(
+        base.long0 - Math.PI / 18,
+        Math.max(-Math.PI / 2 + 1e-8, base.lat0 - Math.PI / 18),
+        base.long0 + Math.PI / 18,
+        Math.min(Math.PI / 2 - 1e-8, base.lat0 + Math.PI / 18)
+      ),
+      ranges => swissBounds(catalogueBoundsParameters(state, context), ranges),
+      base.primeMeridian,
+      base.over
+    );
+  }
+};