ol 10.2.2-dev.1730888074380 → 10.2.2-dev.1730916385053

package/proj/utm.js

@@ -0,0 +1,292 @@
+/**
+ * @module ol/proj/utm
+ */
+
+/**
+ * Adapted from https://github.com/Turbo87/utm
+ * Copyright (c) 2012-2017 Tobias Bieniek
+ *
+ * The functions here provide approximate transforms to and from UTM.
+ * They are not appropriate for use beyond the validity extend of a UTM
+ * zone, and the accuracy of the transform decreases toward the zone
+ * edges.
+ */
+
+import Projection from './Projection.js';
+import {toDegrees, toRadians, wrap} from '../math.js';
+
+/**
+ * @typedef {Object} UTMZone
+ * @property {number} number The zone number (1 - 60).
+ * @property {boolean} north The northern hemisphere.
+ */
+
+const K0 = 0.9996;
+
+const E = 0.00669438;
+const E2 = E * E;
+const E3 = E2 * E;
+const E_P2 = E / (1 - E);
+
+const SQRT_E = Math.sqrt(1 - E);
+const _E = (1 - SQRT_E) / (1 + SQRT_E);
+const _E2 = _E * _E;
+const _E3 = _E2 * _E;
+const _E4 = _E3 * _E;
+const _E5 = _E4 * _E;
+
+const M1 = 1 - E / 4 - (3 * E2) / 64 - (5 * E3) / 256;
+const M2 = (3 * E) / 8 + (3 * E2) / 32 + (45 * E3) / 1024;
+const M3 = (15 * E2) / 256 + (45 * E3) / 1024;
+const M4 = (35 * E3) / 3072;
+
+const P2 = (3 / 2) * _E - (27 / 32) * _E3 + (269 / 512) * _E5;
+const P3 = (21 / 16) * _E2 - (55 / 32) * _E4;
+const P4 = (151 / 96) * _E3 - (417 / 128) * _E5;
+const P5 = (1097 / 512) * _E4;
+
+const R = 6378137;
+
+/**
+ * @param {number} easting Easting value of coordinate.
+ * @param {number} northing Northing value of coordinate.
+ * @param {UTMZone} zone The UTM zone.
+ * @return {import("../coordinate.js").Coordinate} The transformed coordinate.
+ */
+function toLonLat(easting, northing, zone) {
+  const x = easting - 500000;
+  const y = zone.north ? northing : northing - 10000000;
+
+  const m = y / K0;
+  const mu = m / (R * M1);
+
+  const pRad =
+    mu +
+    P2 * Math.sin(2 * mu) +
+    P3 * Math.sin(4 * mu) +
+    P4 * Math.sin(6 * mu) +
+    P5 * Math.sin(8 * mu);
+
+  const pSin = Math.sin(pRad);
+  const pSin2 = pSin * pSin;
+
+  const pCos = Math.cos(pRad);
+
+  const pTan = pSin / pCos;
+  const pTan2 = pTan * pTan;
+  const pTan4 = pTan2 * pTan2;
+
+  const epSin = 1 - E * pSin2;
+  const epSinSqrt = Math.sqrt(1 - E * pSin2);
+
+  const n = R / epSinSqrt;
+  const r = (1 - E) / epSin;
+
+  const c = E_P2 * pCos ** 2;
+  const c2 = c * c;
+
+  const d = x / (n * K0);
+  const d2 = d * d;
+  const d3 = d2 * d;
+  const d4 = d3 * d;
+  const d5 = d4 * d;
+  const d6 = d5 * d;
+
+  const latitude =
+    pRad -
+    (pTan / r) *
+      (d2 / 2 - (d4 / 24) * (5 + 3 * pTan2 + 10 * c - 4 * c2 - 9 * E_P2)) +
+    (d6 / 720) * (61 + 90 * pTan2 + 298 * c + 45 * pTan4 - 252 * E_P2 - 3 * c2);
+
+  let longitude =
+    (d -
+      (d3 / 6) * (1 + 2 * pTan2 + c) +
+      (d5 / 120) * (5 - 2 * c + 28 * pTan2 - 3 * c2 + 8 * E_P2 + 24 * pTan4)) /
+    pCos;
+
+  longitude = wrap(
+    longitude + toRadians(zoneToCentralLongitude(zone.number)),
+    -Math.PI,
+    Math.PI,
+  );
+
+  return [toDegrees(longitude), toDegrees(latitude)];
+}
+
+const MIN_LATITUDE = -80;
+const MAX_LATITUDE = 84;
+const MIN_LONGITUDE = -180;
+const MAX_LONGITUDE = 180;
+
+/**
+ * @param {number} longitude The longitude.
+ * @param {number} latitude The latitude.
+ * @param {UTMZone} zone The UTM zone.
+ * @return {import('../coordinate.js').Coordinate} The UTM coordinate.
+ */
+function fromLonLat(longitude, latitude, zone) {
+  longitude = wrap(longitude, MIN_LONGITUDE, MAX_LONGITUDE);
+
+  if (latitude < MIN_LATITUDE) {
+    latitude = MIN_LATITUDE;
+  } else if (latitude > MAX_LATITUDE) {
+    latitude = MAX_LATITUDE;
+  }
+
+  const latRad = toRadians(latitude);
+  const latSin = Math.sin(latRad);
+  const latCos = Math.cos(latRad);
+
+  const latTan = latSin / latCos;
+  const latTan2 = latTan * latTan;
+  const latTan4 = latTan2 * latTan2;
+
+  const lonRad = toRadians(longitude);
+  const centralLon = zoneToCentralLongitude(zone.number);
+  const centralLonRad = toRadians(centralLon);
+
+  const n = R / Math.sqrt(1 - E * latSin ** 2);
+  const c = E_P2 * latCos ** 2;
+
+  const a = latCos * wrap(lonRad - centralLonRad, -Math.PI, Math.PI);
+  const a2 = a * a;
+  const a3 = a2 * a;
+  const a4 = a3 * a;
+  const a5 = a4 * a;
+  const a6 = a5 * a;
+
+  const m =
+    R *
+    (M1 * latRad -
+      M2 * Math.sin(2 * latRad) +
+      M3 * Math.sin(4 * latRad) -
+      M4 * Math.sin(6 * latRad));
+
+  const easting =
+    K0 *
+      n *
+      (a +
+        (a3 / 6) * (1 - latTan2 + c) +
+        (a5 / 120) * (5 - 18 * latTan2 + latTan4 + 72 * c - 58 * E_P2)) +
+    500000;
+
+  let northing =
+    K0 *
+    (m +
+      n *
+        latTan *
+        (a2 / 2 +
+          (a4 / 24) * (5 - latTan2 + 9 * c + 4 * c ** 2) +
+          (a6 / 720) * (61 - 58 * latTan2 + latTan4 + 600 * c - 330 * E_P2)));
+
+  if (!zone.north) {
+    northing += 10000000;
+  }
+
+  return [easting, northing];
+}
+
+/**
+ * @param {number} zone The zone number.
+ * @return {number} The central longitude in degrees.
+ */
+function zoneToCentralLongitude(zone) {
+  return (zone - 1) * 6 - 180 + 3;
+}
+
+/**
+ * @type {Array<RegExp>}
+ */
+const epsgRegExes = [
+  /^EPSG:(\d+)$/,
+  /^urn:ogc:def:crs:EPSG::(\d+)$/,
+  /^http:\/\/www\.opengis\.net\/def\/crs\/EPSG\/0\/(\d+)$/,
+];
+
+/**
+ * @param {string} code The projection code.
+ * @return {UTMZone|null} The UTM zone info (or null if not UTM).
+ */
+export function zoneFromCode(code) {
+  let epsgId = 0;
+  for (const re of epsgRegExes) {
+    const match = code.match(re);
+    if (match) {
+      epsgId = parseInt(match[1]);
+      break;
+    }
+  }
+  if (!epsgId) {
+    return null;
+  }
+
+  let number = 0;
+  let north = false;
+  if (epsgId > 32700 && epsgId < 32761) {
+    number = epsgId - 32700;
+  } else if (epsgId > 32600 && epsgId < 32661) {
+    north = true;
+    number = epsgId - 32600;
+  }
+  if (!number) {
+    return null;
+  }
+
+  return {number, north};
+}
+
+/**
+ * @param {function(number, number, UTMZone): import('../coordinate.js').Coordinate} transformer The transformer.
+ * @param {UTMZone} zone The UTM zone.
+ * @return {import('../proj.js').TransformFunction} The transform function.
+ */
+function makeTransformFunction(transformer, zone) {
+  return function (input, output, dimension, stride) {
+    const length = input.length;
+    dimension = dimension > 1 ? dimension : 2;
+    stride = stride ?? dimension;
+    if (!output) {
+      if (dimension > 2) {
+        output = input.slice();
+      } else {
+        output = new Array(length);
+      }
+    }
+    for (let i = 0; i < length; i += stride) {
+      const x = input[i];
+      const y = input[i + 1];
+      const coord = transformer(x, y, zone);
+      output[i] = coord[0];
+      output[i + 1] = coord[1];
+    }
+    return output;
+  };
+}
+
+/**
+ * @param {string} code The projection code.
+ * @return {import('./Projection.js').default|null} A projection or null if unable to create one.
+ */
+export function makeProjection(code) {
+  const zone = zoneFromCode(code);
+  if (!zone) {
+    return null;
+  }
+  return new Projection({code, units: 'm'});
+}
+
+/**
+ * @param {import('./Projection.js').default} projection The projection.
+ * @return {import('../proj.js').Transforms|null} The transforms lookup or null if unable to handle projection.
+ */
+export function makeTransforms(projection) {
+  const zone = zoneFromCode(projection.getCode());
+  if (!zone) {
+    return null;
+  }
+
+  return {
+    forward: makeTransformFunction(fromLonLat, zone),
+    inverse: makeTransformFunction(toLonLat, zone),
+  };
+}

package/proj.d.ts

@@ -156,12 +156,12 @@ export function equivalent(projection1: Projection, projection2: Projection): bo
  * Searches in the list of transform functions for the function for converting
  * coordinates from the source projection to the destination projection.
  *
- * @param {Projection} sourceProjection Source Projection object.
- * @param {Projection} destinationProjection Destination Projection
+ * @param {Projection} source Source Projection object.
+ * @param {Projection} destination Destination Projection
  *     object.
- * @return {TransformFunction} Transform function.
+ * @return {TransformFunction|null} Transform function.
  */
-export function getTransformFromProjections(sourceProjection: Projection, destinationProjection: Projection): TransformFunction;
+export function getTransformFromProjections(source: Projection, destination: Projection): TransformFunction | null;
 /**
  * Given the projection-like objects, searches for a transformation
  * function to convert a coordinates array from the source projection to the
@@ -175,7 +175,9 @@ export function getTransformFromProjections(sourceProjection: Projection, destin
 export function getTransform(source: ProjectionLike, destination: ProjectionLike): TransformFunction;
 /**
  * Transforms a coordinate from source projection to destination projection.
- * This returns a new coordinate (and does not modify the original).
+ * This returns a new coordinate (and does not modify the original). If there
+ * is no available transform between the two projection, the function will throw
+ * an error.
  *
  * See {@link module:ol/proj.transformExtent} for extent transformation.
  * See the transform method of {@link module:ol/geom/Geometry~Geometry} and its
@@ -308,6 +310,16 @@ export function addCommon(): void;
  * string or undefined.
  */
 export type ProjectionLike = Projection | string | undefined;
+export type Transforms = {
+    /**
+     * The forward transform (from geographic).
+     */
+    forward: TransformFunction;
+    /**
+     * The inverse transform (to geographic).
+     */
+    inverse: TransformFunction;
+};
 /**
  * A transform function accepts an array of input coordinate values, an optional
  * output array, and an optional dimension (default should be 2).  The function

package/proj.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proj.d.ts","sourceRoot":"","sources":["proj.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"proj.d.ts","sourceRoot":"","sources":["proj.js"],"names":[],"mappings":"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"}

package/proj.js

@@ -75,6 +75,10 @@ import {applyTransform, getWidth} from './extent.js';
 import {clamp, modulo} from './math.js';
 import {equals, getWorldsAway} from './coordinate.js';
 import {getDistance} from './sphere.js';
+import {
+  makeProjection as makeUTMProjection,
+  makeTransforms as makeUTMTransforms,
+} from './proj/utm.js';
 import {warn} from './console.js';
 
 /**
@@ -84,6 +88,22 @@ import {warn} from './console.js';
  * @api
  */
 
+/**
+ * @typedef {Object} Transforms
+ * @property {TransformFunction} forward The forward transform (from geographic).
+ * @property {TransformFunction} inverse The inverse transform (to geographic).
+ */
+
+/**
+ * @type {Array<function(Projection): Transforms|null>}
+ */
+const transformFactories = [makeUTMTransforms];
+
+/**
+ * @type {Array<function(string): Projection|null>}
+ */
+const projectionFactories = [makeUTMProjection];
+
 /**
  * A transform function accepts an array of input coordinate values, an optional
  * output array, and an optional dimension (default should be 2).  The function
@@ -176,9 +196,20 @@ export function addProjections(projections) {
  * @api
  */
 export function get(projectionLike) {
-  return typeof projectionLike === 'string'
-    ? getProj(/** @type {string} */ (projectionLike))
-    : /** @type {Projection} */ (projectionLike) || null;
+  if (!(typeof projectionLike === 'string')) {
+    return projectionLike;
+  }
+  const projection = getProj(projectionLike);
+  if (projection) {
+    return projection;
+  }
+  for (const makeProjection of projectionFactories) {
+    const projection = makeProjection(projectionLike);
+    if (projection) {
+      return projection;
+    }
+  }
+  return null;
 }
 
 /**
@@ -226,7 +257,7 @@ export function getPointResolution(projection, resolution, point, units) {
         projection,
         get('EPSG:4326'),
       );
-      if (toEPSG4326 === identityTransform && projUnits !== 'degrees') {
+      if (!toEPSG4326 && projUnits !== 'degrees') {
         // no transform is available
         pointResolution = resolution * projection.getMetersPerUnit();
       } else {
@@ -460,24 +491,88 @@ export function equivalent(projection1, projection2) {
  * Searches in the list of transform functions for the function for converting
  * coordinates from the source projection to the destination projection.
  *
- * @param {Projection} sourceProjection Source Projection object.
- * @param {Projection} destinationProjection Destination Projection
+ * @param {Projection} source Source Projection object.
+ * @param {Projection} destination Destination Projection
  *     object.
- * @return {TransformFunction} Transform function.
+ * @return {TransformFunction|null} Transform function.
  */
-export function getTransformFromProjections(
-  sourceProjection,
-  destinationProjection,
-) {
-  const sourceCode = sourceProjection.getCode();
-  const destinationCode = destinationProjection.getCode();
+export function getTransformFromProjections(source, destination) {
+  const sourceCode = source.getCode();
+  const destinationCode = destination.getCode();
   let transformFunc = getTransformFunc(sourceCode, destinationCode);
-  if (!transformFunc) {
-    transformFunc = identityTransform;
+  if (transformFunc) {
+    return transformFunc;
+  }
+
+  /**
+   * @type {Transforms|null}
+   */
+  let sourceTransforms = null;
+
+  /**
+   * @type {Transforms|null}
+   */
+  let destinationTransforms = null;
+
+  // lazily add projections if we have supported transforms
+  for (const makeTransforms of transformFactories) {
+    if (!sourceTransforms) {
+      sourceTransforms = makeTransforms(source);
+    }
+    if (!destinationTransforms) {
+      destinationTransforms = makeTransforms(destination);
+    }
+  }
+
+  if (!sourceTransforms && !destinationTransforms) {
+    return null;
+  }
+
+  const intermediateCode = 'EPSG:4326';
+  if (!destinationTransforms) {
+    const toDestination = getTransformFunc(intermediateCode, destinationCode);
+    if (toDestination) {
+      transformFunc = composeTransformFuncs(
+        sourceTransforms.inverse,
+        toDestination,
+      );
+    }
+  } else if (!sourceTransforms) {
+    const fromSource = getTransformFunc(sourceCode, intermediateCode);
+    if (fromSource) {
+      transformFunc = composeTransformFuncs(
+        fromSource,
+        destinationTransforms.forward,
+      );
+    }
+  } else {
+    transformFunc = composeTransformFuncs(
+      sourceTransforms.inverse,
+      destinationTransforms.forward,
+    );
+  }
+
+  if (transformFunc) {
+    addProjection(source);
+    addProjection(destination);
+    addTransformFunc(source, destination, transformFunc);
   }
+
   return transformFunc;
 }
 
+/**
+ * @param {TransformFunction} t1 The first transform function.
+ * @param {TransformFunction} t2 The second transform function.
+ * @return {TransformFunction} The composed transform function.
+ */
+function composeTransformFuncs(t1, t2) {
+  return function (input, output, dimensions, stride) {
+    output = t1(input, output, dimensions, stride);
+    return t2(output, output, dimensions, stride);
+  };
+}
+
 /**
  * Given the projection-like objects, searches for a transformation
  * function to convert a coordinates array from the source projection to the
@@ -496,7 +591,9 @@ export function getTransform(source, destination) {
 
 /**
  * Transforms a coordinate from source projection to destination projection.
- * This returns a new coordinate (and does not modify the original).
+ * This returns a new coordinate (and does not modify the original). If there
+ * is no available transform between the two projection, the function will throw
+ * an error.
  *
  * See {@link module:ol/proj.transformExtent} for extent transformation.
  * See the transform method of {@link module:ol/geom/Geometry~Geometry} and its
@@ -510,6 +607,13 @@ export function getTransform(source, destination) {
  */
 export function transform(coordinate, source, destination) {
   const transformFunc = getTransform(source, destination);
+  if (!transformFunc) {
+    const sourceCode = get(source).getCode();
+    const destinationCode = get(destination).getCode();
+    throw new Error(
+      `No transform available between ${sourceCode} and ${destinationCode}`,
+    );
+  }
   return transformFunc(coordinate, undefined, coordinate.length);
 }
 

package/util.js

@@ -33,4 +33,4 @@ export function getUid(obj) {
  * OpenLayers version.
  * @type {string}
  */
-export const VERSION = '10.2.2-dev.1730888074380';
+export const VERSION = '10.2.2-dev.1730916385053';