@itowns/geographic 2.46.1-next.4 → 2.46.1-next.40

package/lib/Coordinates.js

@@ -1,23 +1,11 @@
 import { Vector3, MathUtils } from 'three';
-import proj4 from 'proj4';
 import Ellipsoid from "./Ellipsoid.js";
 import * as CRS from "./Crs.js";
 const ellipsoid = /* @__PURE__ */new Ellipsoid();
-const projectionCache = {};
 const v0 = /* @__PURE__ */new Vector3();
 const v1 = /* @__PURE__ */new Vector3();
 let coord0;
 let coord1;
-function proj4cache(crsIn, crsOut) {
-  if (!projectionCache[crsIn]) {
-    projectionCache[crsIn] = {};
-  }
-  if (!projectionCache[crsIn][crsOut]) {
-    projectionCache[crsIn][crsOut] = proj4(crsIn, crsOut);
-  }
-  return projectionCache[crsIn][crsOut];
-}
-
 /**
  * A class representing a geographic or geocentric coordinate.
  *
@@ -71,10 +59,7 @@ class Coordinates {
    * @param y - y or latitude value.
    * @param z - z or altitude value.
    */
-  constructor(crs) {
-    let x = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    let y = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-    let z = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  constructor(crs, x = 0, y = 0, z = 0) {
     this.isCoordinates = true;
     CRS.isValid(crs);
     this.crs = crs;
@@ -122,10 +107,7 @@ class Coordinates {
    * @param y - y or latitude value.
    * @param z - z or altitude value.
    */
-  setFromValues() {
-    let x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-    let y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    let z = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  setFromValues(x = 0, y = 0, z = 0) {
     this.x = x;
     this.y = y;
     this.z = z;
@@ -142,8 +124,7 @@ class Coordinates {
    * @param array - The source array.
    * @param offset - Optional offset into the array. Default is 0.
    */
-  setFromArray(array) {
-    let offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  setFromArray(array, offset = 0) {
     return this.setFromValues(array[offset], array[offset + 1], array[offset + 2]);
   }
 
@@ -215,8 +196,7 @@ class Coordinates {
    * @returns A vector `(x, y, z)`, or copies x, y and z into the provided
    * vector.
    */
-  toVector3() {
-    let target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Vector3();
+  toVector3(target = new Vector3()) {
     return target.copy(this);
   }
 
@@ -230,9 +210,7 @@ class Coordinates {
    * @returns An array [x, y, z], or copies x, y and z into the provided
    * array.
    */
-  toArray() {
-    let array = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-    let offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  toArray(array = [], offset = 0) {
     return Vector3.prototype.toArray.call(this, array, offset);
   }
 
@@ -312,15 +290,14 @@ class Coordinates {
    * const geographicCoords = geocentricCoords.as('EPSG:4326');
    * ```
    */
-  as(crs) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Coordinates(crs);
+  as(crs, target = new Coordinates(crs)) {
     if (this.crs == crs) {
       target.copy(this);
     } else {
       if (CRS.is4326(this.crs) && crs == 'EPSG:3857') {
         this.y = MathUtils.clamp(this.y, -89.999999, 89.999999);
       }
-      target.setFromArray(proj4cache(this.crs, crs).forward([this.x, this.y, this.z]));
+      target.setFromArray(CRS.transform(this.crs, crs).forward([this.x, this.y, this.z]));
     }
     target.crs = crs;
     return target;

package/lib/Crs.js

@@ -12,7 +12,18 @@ proj4.defs('WGS84').axis = 'neu';
  * projection definition previously defined with
  * [`proj4.defs`](https://github.com/proj4js/proj4js#named-projections).
  */
+// TODO Unify with OrientationUtils.js
 
+const proj4Cache = {};
+export function transform(crsIn, crsOut) {
+  if (!proj4Cache[crsIn]) {
+    proj4Cache[crsIn] = {};
+  }
+  if (!proj4Cache[crsIn][crsOut]) {
+    proj4Cache[crsIn][crsOut] = proj4(crsIn, crsOut);
+  }
+  return proj4Cache[crsIn][crsOut];
+}
 function isString(s) {
   return typeof s === 'string' || s instanceof String;
 }
@@ -56,7 +67,7 @@ function unitFromProj4Unit(proj) {
     return UNIT.DEGREE;
   } else if (proj.units === 'm' || proj.units === 'meter') {
     return UNIT.METER;
-  } else if (proj.units === 'foot') {
+  } else if (proj.units === 'foot' || proj.units === 'ft') {
     return UNIT.FOOT;
   } else if (proj.units === undefined && proj.to_meter === undefined) {
     // See https://proj.org/en/9.4/usage/projections.html [17/10/2024]
@@ -124,7 +135,7 @@ export function isGeocentric(crs) {
 export function isValid(crs) {
   const proj = proj4.defs(crs);
   if (!proj) {
-    throw new Error(`Undefined crs '${crs}'. Add it with proj4.defs('${crs}', string)`);
+    throw new Error(`Undefined crs '${crs}'. Add it with itowns.CRS.defs('${crs}', wktString)`);
   }
   if (!unitFromProj4Unit(proj)) {
     throw new Error(`No valid unit found for crs '${crs}', found ${proj.units}`);
@@ -160,11 +171,53 @@ export function axisOrder(crs) {
 
 /**
  * Defines a proj4 projection as a named alias.
- * This function is a specialized wrapper over the
- * [`proj4.defs`](https://github.com/proj4js/proj4js#named-projections)
- * function.
+ * This function is an alias for the
+ * [`proj4.defs`](https://github.com/proj4js/proj4js#named-projections) function.
+ */
+export const defs = proj4.defs;
+
+/**
+ * Fetches a CRS definition from epsg.io and registers it with proj4.
+ * If the CRS is already defined, returns the existing definition.
+ *
+ * @param crs - The EPSG code string (e.g. "EPSG:2154").
+ * @returns The proj4 projection definition.
  *
- * @param code - Named alias of the currently defined projection.
- * @param proj4def - Proj4 or WKT string of the defined projection.
+ * @example
+ * // Register EPSG:2154 (RGF93 / Lambert-93)
+ * await CRS.fromEPSG('EPSG:2154');
+ *
+ * // Register EPSG:4269 (NAD83)
+ * await CRS.fromEPSG('EPSG:4269');
  */
-export const defs = (code, proj4def) => proj4.defs(code, proj4def);
+export async function fromEPSG(crs) {
+  const def = proj4.defs(crs);
+  if (def) {
+    return def;
+  }
+  const code = crs.replace(/^EPSG:/i, '');
+  const response = await fetch(`https://epsg.io/${code}.proj4`);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch EPSG:${code} from epsg.io: ${response.status}`);
+  }
+  const proj4def = await response.text();
+  proj4.defs(crs, proj4def);
+  return proj4.defs(crs);
+}
+export function defsFromWkt(wkt) {
+  proj4.defs('unknown', wkt);
+  const proj4Defs = proj4.defs;
+  let projCS;
+  if (proj4Defs('unknown').type === 'COMPD_CS') {
+    console.warn('Compound coordinate system is not yet supported.');
+    projCS = proj4Defs('unknown').PROJCS;
+  } else {
+    projCS = proj4Defs('unknown');
+  }
+  const crsAlias = projCS.title || projCS.name || 'EPSG:XXXX';
+  if (!(crsAlias in proj4.defs)) {
+    proj4.defs(crsAlias, projCS);
+  }
+  delete proj4Defs.unknown;
+  return crsAlias;
+}

package/lib/Ellipsoid.js

@@ -21,8 +21,7 @@ class Ellipsoid {
    * @param size - Length of the semi-axes of the ellipsoid. Defaults to those
    * defined by the WGS84 ellipsoid.
    */
-  constructor() {
-    let size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ellipsoidSizes;
+  constructor(size = ellipsoidSizes) {
     this.size = new Vector3();
     this._radiiSquared = new Vector3();
     this._invRadiiSquared = new Vector3();
@@ -38,8 +37,7 @@ class Ellipsoid {
    * @param target - An object to store this vector to. If this is not
    * specified, a new vector will be created.
    */
-  geodeticSurfaceNormal(cartesian) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Vector3();
+  geodeticSurfaceNormal(cartesian, target = new Vector3()) {
     return cartesian.toVector3(target).multiply(this._invRadiiSquared).normalize();
   }
 
@@ -51,8 +49,7 @@ class Ellipsoid {
    * @param target - An object to store this vector to. If this is not
    * specified, a new vector will be created.
    */
-  geodeticSurfaceNormalCartographic(coordCarto) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Vector3();
+  geodeticSurfaceNormalCartographic(coordCarto, target = new Vector3()) {
     const longitude = MathUtils.degToRad(coordCarto.longitude);
     const latitude = MathUtils.degToRad(coordCarto.latitude);
     const cosLatitude = Math.cos(latitude);
@@ -75,8 +72,7 @@ class Ellipsoid {
     this.eccentricity = Math.sqrt(this._radiiSquared.x - this._radiiSquared.z) / this.size.x;
     return this;
   }
-  cartographicToCartesian(coordCarto) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Vector3();
+  cartographicToCartesian(coordCarto, target = new Vector3()) {
     normal.copy(coordCarto.geodesicNormal);
     target.multiplyVectors(this._radiiSquared, normal);
     const gamma = Math.sqrt(normal.dot(target));
@@ -93,8 +89,7 @@ class Ellipsoid {
    * @returns an object describing the coordinates on the reference ellipsoid,
    * angles are in degree
    */
-  cartesianToCartographic(position) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Coordinates('EPSG:4326', 0, 0, 0);
+  cartesianToCartographic(position, target = new Coordinates('EPSG:4326', 0, 0, 0)) {
     // for details, see for example http://www.linz.govt.nz/data/geodetic-system/coordinate-conversion/geodetic-datum-conversions/equations-used-datum
     // TODO the following is only valable for oblate ellipsoid of
     // revolution. do we want to support triaxial ellipsoid?

package/lib/Extent.js

@@ -54,11 +54,7 @@ class Extent {
    * @param south - the `south` value of this extent. Default is 0.
    * @param north - the `north` value of this extent. Default is 0.
    */
-  constructor(crs) {
-    let west = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    let east = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-    let south = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-    let north = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
+  constructor(crs, west = 0, east = 0, south = 0, north = 0) {
     if (CRS.isGeocentric(crs)) {
       throw new Error(`Non-compatible geocentric projection ${crs} to build a geographical extent`);
     }
@@ -85,8 +81,7 @@ class Extent {
    * @param target - The target to store the projected extent. If this not
    * provided a new extent will be created.
    */
-  as(crs) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Extent('EPSG:4326');
+  as(crs, target = new Extent('EPSG:4326')) {
     CRS.isValid(crs);
     if (this.crs != crs) {
       // Compute min/max in x/y by projecting 8 cardinal points,
@@ -126,8 +121,7 @@ class Extent {
    * @param target - The target to store the center coordinate. If this not
    * provided a new coordinate will be created.
    */
-  center() {
-    let target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Coordinates(this.crs);
+  center(target = new Coordinates(this.crs)) {
     this.planarDimensions(_dim);
     target.crs = this.crs;
     target.setFromValues(this.west + _dim.x * 0.5, this.south + _dim.y * 0.5);
@@ -142,8 +136,7 @@ class Extent {
    *
    * @param target - optional target
    */
-  planarDimensions() {
-    let target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Vector2();
+  planarDimensions(target = new Vector2()) {
     // Calculte the dimensions for x and y
     return target.set(Math.abs(this.east - this.west), Math.abs(this.north - this.south));
   }
@@ -156,8 +149,7 @@ class Extent {
    *
    * @param target - optional target
    */
-  geodeticDimensions() {
-    let target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Vector2();
+  geodeticDimensions(target = new Vector2()) {
     // set 3 corners extent
     cNorthWest.crs = this.crs;
     cSouthWest.crs = this.crs;
@@ -177,8 +169,7 @@ class Extent {
    *
    * @param target - optional target
    */
-  spatialEuclideanDimensions() {
-    let target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Vector2();
+  spatialEuclideanDimensions(target = new Vector2()) {
     // set 3 corners extent
     cNorthWest.crs = this.crs;
     cSouthWest.crs = this.crs;
@@ -198,8 +189,7 @@ class Extent {
    * @param epsilon - error margin when comparing to the coordinates.
    * Default is 0.
    */
-  isPointInside(coord) {
-    let epsilon = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  isPointInside(coord, epsilon = 0) {
     if (this.crs == coord.crs) {
       _c.copy(coord);
     } else {
@@ -216,8 +206,7 @@ class Extent {
    * @param extent - the extent to check
    * @param epsilon - error margin when comparing the extent bounds.
    */
-  isInside(extent) {
-    let epsilon = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : CRS.reasonableEpsilon(this.crs);
+  isInside(extent, epsilon = CRS.reasonableEpsilon(this.crs)) {
     extent.as(this.crs, _extent);
     return this.east - _extent.east <= epsilon && _extent.west - this.west <= epsilon && this.north - _extent.north <= epsilon && _extent.south - this.south <= epsilon;
   }
@@ -233,8 +222,7 @@ class Extent {
    * south-north, the `z` property the scale on west-east, the `w` property
    * the scale on south-north.
    */
-  offsetToParent(extent) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Vector4();
+  offsetToParent(extent, target = new Vector4()) {
     if (this.crs != extent.crs) {
       throw new Error('unsupported mix');
     }
@@ -314,8 +302,7 @@ class Extent {
    * @param array - the source array
    * @param offset - offset into the array. Default is 0.
    */
-  setFromArray(array) {
-    let offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  setFromArray(array, offset = 0) {
     this.west = array[offset];
     this.east = array[offset + 1];
     this.south = array[offset + 2];
@@ -439,8 +426,7 @@ class Extent {
    * Return values of extent in string, separated by the separator input.
    * @param sep - string separator
    */
-  toString() {
-    let sep = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  toString(sep = '') {
     return `${this.east}${sep}${this.north}${sep}${this.west}${sep}${this.south}`;
   }
 
@@ -461,8 +447,7 @@ class Extent {
    * @param scheme - The scheme to subdivise.
    * @returns subdivised extents.
    */
-  subdivisionByScheme() {
-    let scheme = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultScheme;
+  subdivisionByScheme(scheme = defaultScheme) {
     const subdivisedExtents = [];
     const dimSub = this.planarDimensions(_dim).divide(scheme);
     for (let x = scheme.x - 1; x >= 0; x--) {
@@ -509,9 +494,7 @@ class Extent {
    * @param north - The max north
    * @returns this extent
    */
-  clampSouthNorth() {
-    let south = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.south;
-    let north = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.north;
+  clampSouthNorth(south = this.south, north = this.north) {
     this.south = Math.max(this.south, south);
     this.north = Math.min(this.north, north);
     return this;
@@ -524,9 +507,7 @@ class Extent {
    * @param east - The max east
    * @returns this extent
    */
-  clampWestEast() {
-    let west = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.west;
-    let east = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.east;
+  clampWestEast(west = this.west, east = this.east) {
     this.west = Math.max(this.west, west);
     this.east = Math.min(this.east, east);
     return this;

package/lib/OrientationUtils.js

@@ -8,6 +8,9 @@ const axis = /* @__PURE__ */new Vector3().set(0, 0, 1);
 const coord = /* @__PURE__ */new Coordinates('EPSG:4326', 0, 0, 0);
 const euler = /* @__PURE__ */new Euler();
 const quat = /* @__PURE__ */new Quaternion();
+
+// To unify with Crs.js ProjectionLike type ?
+
 /**
  * The transform from the platform frame to the local East, North, Up (ENU)
  * frame is `RotationZ(heading).RotationX(pitch).RotationY(roll)`.
@@ -19,11 +22,7 @@ const quat = /* @__PURE__ */new Quaternion();
  *
  * @returns The target quaternion
  */
-export function quaternionFromRollPitchHeading() {
-  let roll = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-  let pitch = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  let heading = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-  let target = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Quaternion();
+export function quaternionFromRollPitchHeading(roll = 0, pitch = 0, heading = 0, target = new Quaternion()) {
   roll *= MathUtils.DEG2RAD;
   pitch *= MathUtils.DEG2RAD;
   heading *= MathUtils.DEG2RAD;
@@ -53,11 +52,7 @@ export function quaternionFromRollPitchHeading() {
  *
  * @returns The target quaternion
  */
-export function quaternionFromOmegaPhiKappa() {
-  let omega = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-  let phi = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  let kappa = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-  let target = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Quaternion();
+export function quaternionFromOmegaPhiKappa(omega = 0, phi = 0, kappa = 0, target = new Quaternion()) {
   omega *= MathUtils.DEG2RAD;
   phi *= MathUtils.DEG2RAD;
   kappa *= MathUtils.DEG2RAD;
@@ -76,8 +71,7 @@ export function quaternionFromOmegaPhiKappa() {
  *
  * @returns The target quaternion
  */
-export function quaternionFromAttitude(attitude) {
-  let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
+export function quaternionFromAttitude(attitude, target = new Quaternion()) {
   if ('roll' in attitude || 'pitch' in attitude || 'heading' in attitude) {
     return quaternionFromRollPitchHeading(attitude.roll, attitude.pitch, attitude.heading, target);
   }
@@ -97,13 +91,11 @@ export function quaternionFromAttitude(attitude) {
  * @returns The target quaternion if coordinates is defined. Otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromEnuToGeocent(coordinates) {
-  let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
+export function quaternionFromEnuToGeocent(coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromEnuToGeocent()(coordinates, target);
   }
-  return function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
+  return (coordinates, target = new Quaternion()) => {
     const up = coordinates.geodesicNormal;
     if (up.x == 0 && up.y == 0) {
       return target.set(0, 0, 0, 1);
@@ -127,16 +119,12 @@ export function quaternionFromEnuToGeocent(coordinates) {
  * @returns The target quaternion if coordinates is defined. Otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromGeocentToEnu(coordinates) {
-  let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
+export function quaternionFromGeocentToEnu(coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromGeocentToEnu()(coordinates, target);
   }
   const toGeocent = quaternionFromEnuToGeocent();
-  return function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return toGeocent(coordinates, target).conjugate();
-  };
+  return (coordinates, target = new Quaternion()) => toGeocent(coordinates, target).conjugate();
 }
 /**
  * Computes the rotation from a Lambert Conformal Conic (LCC) frame to the local
@@ -152,14 +140,12 @@ export function quaternionFromGeocentToEnu(coordinates) {
  * @returns The target quaternion if coordinates is defined. Otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromLCCToEnu(proj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionFromLCCToEnu(proj, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromLCCToEnu(proj)(coordinates, target);
   }
   const sinlat0 = Math.sin(proj.lat0);
-  return function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
+  return (coordinates, target = new Quaternion()) => {
     const long = coordinates.as(coord.crs, coord).longitude * MathUtils.DEG2RAD;
     return target.setFromAxisAngle(axis, sinlat0 * (proj.long0 - long));
   };
@@ -177,16 +163,12 @@ export function quaternionFromLCCToEnu(proj, coordinates) {
  * @returns The target quaternion if coordinates is defined. Otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromEnuToLCC(proj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionFromEnuToLCC(proj, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromEnuToLCC(proj)(coordinates, target);
   }
   const fromLCC = quaternionFromLCCToEnu(proj);
-  return function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return fromLCC(coordinates, target).conjugate();
-  };
+  return (coordinates, target = new Quaternion()) => fromLCC(coordinates, target).conjugate();
 }
 /**
  * Computes the rotation from a Transverse Mercator frame (TMerc) to the
@@ -201,8 +183,7 @@ export function quaternionFromEnuToLCC(proj, coordinates) {
  * @returns The target quaternion if coordinates is defined. Otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromTMercToEnu(proj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionFromTMercToEnu(proj, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromTMercToEnu(proj)(coordinates, target);
   }
@@ -215,8 +196,7 @@ export function quaternionFromTMercToEnu(proj, coordinates) {
     const e2 = proj.e * proj.e;
     eta0 = e2 / (1 - e2);
   }
-  return function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
+  return (coordinates, target = new Quaternion()) => {
     coordinates.as(coord.crs, coord);
     const long = coord.longitude * MathUtils.DEG2RAD;
     const lat = coord.latitude * MathUtils.DEG2RAD;
@@ -244,16 +224,12 @@ export function quaternionFromTMercToEnu(proj, coordinates) {
  * @returns The target quaternion if coordinates is defined. Otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromEnuToTMerc(proj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionFromEnuToTMerc(proj, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromEnuToTMerc(proj)(coordinates, target);
   }
   const fromTMerc = quaternionFromTMercToEnu(proj);
-  return function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return fromTMerc(coordinates, target).conjugate();
-  };
+  return (coordinates, target = new Quaternion()) => fromTMerc(coordinates, target).conjugate();
 }
 /**
  * Computes the rotation from a LongLat frame to the local East North Up
@@ -266,12 +242,8 @@ export function quaternionFromEnuToTMerc(proj, coordinates) {
  * @returns The target quaternion if coordinates is defined, otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromLongLatToEnu(coordinates) {
-  let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-  return coordinates ? target.set(0, 0, 0, 1) : function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return quaternionFromLongLatToEnu(coordinates, target);
-  };
+export function quaternionFromLongLatToEnu(coordinates, target = new Quaternion()) {
+  return coordinates ? target.set(0, 0, 0, 1) : (coordinates, target = new Quaternion()) => quaternionFromLongLatToEnu(coordinates, target);
 }
 /**
  * Computes the rotation from the local East North Up (ENU) frame to a
@@ -283,12 +255,8 @@ export function quaternionFromLongLatToEnu(coordinates) {
  * @returns The target quaternion if coordinates is defined, otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromEnuToLongLat(coordinates) {
-  let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-  return coordinates ? target.set(0, 0, 0, 1) : function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return quaternionFromEnuToLongLat(coordinates, target);
-  };
+export function quaternionFromEnuToLongLat(coordinates, target = new Quaternion()) {
+  return coordinates ? target.set(0, 0, 0, 1) : (coordinates, target = new Quaternion()) => quaternionFromEnuToLongLat(coordinates, target);
 }
 /**
  * Warns for an unimplemented projection, sets the quaternion to the
@@ -300,13 +268,9 @@ export function quaternionFromEnuToLongLat(coordinates) {
  * @returns The target quaternion if coordinates is defined, otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionUnimplemented(proj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionUnimplemented(proj, coordinates, target = new Quaternion()) {
   console.warn('This quaternion function is not implemented for projections of type', proj.projName);
-  return coordinates ? target.set(0, 0, 0, 1) : function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return quaternionUnimplemented(proj, coordinates, target);
-  };
+  return coordinates ? target.set(0, 0, 0, 1) : (coordinates, target = new Quaternion()) => quaternionUnimplemented(proj, coordinates, target);
 }
 /**
  * Compute the quaternion that models the rotation from the local East North
@@ -319,8 +283,7 @@ export function quaternionUnimplemented(proj, coordinates) {
  * @returns The target quaternion if coordinates is defined, otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromEnuToCRS(crsOrProj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionFromEnuToCRS(crsOrProj, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromEnuToCRS(crsOrProj)(coordinates, target);
   }
@@ -331,6 +294,7 @@ export function quaternionFromEnuToCRS(crsOrProj, coordinates) {
       return quaternionFromEnuToGeocent();
     case 'Lambert Tangential Conformal Conic Projection':
       return quaternionFromEnuToLCC(proj);
+    case 'Universal Transverse Mercator System':
     case 'Fast_Transverse_Mercator':
       return quaternionFromEnuToTMerc(proj);
     case 'longlat':
@@ -350,8 +314,7 @@ export function quaternionFromEnuToCRS(crsOrProj, coordinates) {
  * @returns The target quaternion if coordinates is defined, otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromCRSToEnu(crsOrProj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionFromCRSToEnu(crsOrProj, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromCRSToEnu(crsOrProj)(coordinates, target);
   }
@@ -362,6 +325,7 @@ export function quaternionFromCRSToEnu(crsOrProj, coordinates) {
       return quaternionFromGeocentToEnu();
     case 'Lambert Tangential Conformal Conic Projection':
       return quaternionFromLCCToEnu(proj);
+    case 'Universal Transverse Mercator System':
     case 'Fast_Transverse_Mercator':
       return quaternionFromTMercToEnu(proj);
     case 'longlat':
@@ -370,6 +334,7 @@ export function quaternionFromCRSToEnu(crsOrProj, coordinates) {
       return quaternionUnimplemented(proj);
   }
 }
+const quaternionCrs2CrsCache = {};
 /**
  * Return the function that computes the quaternion that represents a
  * rotation of coordinates between two CRS frames.
@@ -381,23 +346,25 @@ export function quaternionFromCRSToEnu(crsOrProj, coordinates) {
  * @returns The target quaternion if coordinates is defined, otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromCRSToCRS(crsIn, crsOut, coordinates) {
-  let target = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Quaternion();
+export function quaternionFromCRSToCRS(crsIn, crsOut, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromCRSToCRS(crsIn, crsOut)(coordinates, target);
   }
   if (crsIn == crsOut) {
-    return function (origin) {
-      let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-      return target.set(0, 0, 0, 1);
-    };
+    return (origin, target = new Quaternion()) => target.set(0, 0, 0, 1);
+  }
+  if (quaternionCrs2CrsCache[crsIn] && quaternionCrs2CrsCache[crsIn][crsOut]) {
+    return quaternionCrs2CrsCache[crsIn][crsOut];
   }
 
   // get rotations from the local East/North/Up (ENU) frame to both CRS.
   const fromCrs = quaternionFromCRSToEnu(crsIn);
   const toCrs = quaternionFromEnuToCRS(crsOut);
-  return function (origin) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return toCrs(origin, target).multiply(fromCrs(origin, quat));
-  };
+  if (!quaternionCrs2CrsCache[crsIn]) {
+    quaternionCrs2CrsCache[crsIn] = {};
+  }
+  if (!quaternionCrs2CrsCache[crsIn][crsOut]) {
+    quaternionCrs2CrsCache[crsIn][crsOut] = (origin, target = new Quaternion()) => toCrs(origin, target).multiply(fromCrs(origin, quat));
+  }
+  return quaternionCrs2CrsCache[crsIn][crsOut];
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@itowns/geographic",
-  "version": "2.46.1-next.4",
-  "description": "Geodesy",
+  "version": "2.46.1-next.40",
+  "description": "Proj4-based three.js geodesy toolkit",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
@@ -14,7 +14,7 @@
     "lint": "eslint \"src/**/*.{js,ts,tsx}\" \"test/**/*.js\"",
     "transpile": "tsc && cross-env BABEL_DISABLE_CACHE=1 babel src --out-dir lib --extensions .js,.ts",
     "test-unit": "npm run base-test-unit test/unit",
-    "base-test-unit": "cross-env BABEL_DISABLE_CACHE=1 mocha --import=../../config/babel-register/register.mjs",
+    "base-test-unit": "cross-env BABEL_DISABLE_CACHE=1 NODE_OPTIONS=--no-experimental-strip-types mocha --import=../../config/babel-register/register.mjs",
     "test-with-coverage": "c8 -n src -r html cross-env npm run test-unit",
     "test-with-coverage_lcov": "c8 -n src --reporter=lcov cross-env npm run test-unit",
     "watch": "npm run transpile -- --watch",
@@ -35,8 +35,8 @@
     "url": "https://github.com/itowns/itowns/issues"
   },
   "peerDependencies": {
-    "proj4": "^2.19.10",
-    "three": "^0.174.0"
+    "proj4": ">=2.20.0",
+    "three": ">=0.182.0"
   },
   "homepage": "https://itowns.github.io/"
 }

package/src/Coordinates.ts

@@ -1,12 +1,10 @@
 import { Vector3, type Vector3Like, type Matrix4, MathUtils } from 'three';
-import proj4, { type Converter } from 'proj4';
 import Ellipsoid from './Ellipsoid';
 import * as CRS from './Crs';
 
 import type { ProjectionLike } from './Crs';
 
 const ellipsoid = /* @__PURE__ */ new Ellipsoid();
-const projectionCache: Record<string, Record<string, Converter>> = {};
 
 const v0 = /* @__PURE__ */ new Vector3();
 const v1 = /* @__PURE__ */ new Vector3();
@@ -21,18 +19,6 @@ export interface CoordinatesLike {
     readonly z: number;
 }
 
-function proj4cache(crsIn: ProjectionLike, crsOut: ProjectionLike): Converter {
-    if (!projectionCache[crsIn]) {
-        projectionCache[crsIn] = {};
-    }
-
-    if (!projectionCache[crsIn][crsOut]) {
-        projectionCache[crsIn][crsOut] = proj4(crsIn, crsOut);
-    }
-
-    return projectionCache[crsIn][crsOut];
-}
-
 /**
  * A class representing a geographic or geocentric coordinate.
  *
@@ -348,7 +334,7 @@ class Coordinates {
                 this.y = MathUtils.clamp(this.y, -89.999999, 89.999999);
             }
 
-            target.setFromArray(proj4cache(this.crs, crs)
+            target.setFromArray(CRS.transform(this.crs, crs)
                 .forward([this.x, this.y, this.z]));
         }
 

package/src/Crs.ts

@@ -1,7 +1,15 @@
 import proj4 from 'proj4';
-
+import type { Converter } from 'proj4';
 import type { ProjectionDefinition } from 'proj4/dist/lib/defs';
 
+type proj4Def = {
+    type: string,
+    PROJCS: proj4Def,
+    unknown?: string,
+    (alias: string): proj4Def & { name: string },
+    title: string,
+}
+
 proj4.defs('EPSG:4978', '+proj=geocent +datum=WGS84 +units=m +no_defs');
 
 // Redefining proj4 global projections to match epsg.org database axis order.
@@ -15,8 +23,22 @@ proj4.defs('WGS84').axis = 'neu';
  * projection definition previously defined with
  * [`proj4.defs`](https://github.com/proj4js/proj4js#named-projections).
  */
+// TODO Unify with OrientationUtils.js
 export type ProjectionLike = string;
 
+const proj4Cache: Record<string, Record<string, Converter>> = {};
+export function transform(crsIn: ProjectionLike, crsOut: ProjectionLike): Converter {
+    if (!proj4Cache[crsIn]) {
+        proj4Cache[crsIn] = {};
+    }
+
+    if (!proj4Cache[crsIn][crsOut]) {
+        proj4Cache[crsIn][crsOut] = proj4(crsIn, crsOut);
+    }
+
+    return proj4Cache[crsIn][crsOut];
+}
+
 function isString(s: unknown): s is string {
     return typeof s === 'string' || s instanceof String;
 }
@@ -62,7 +84,7 @@ function unitFromProj4Unit(proj: ProjectionDefinition) {
         return UNIT.DEGREE;
     } else if (proj.units === 'm' || proj.units === 'meter') {
         return UNIT.METER;
-    } else if (proj.units === 'foot') {
+    } else if (proj.units === 'foot' || proj.units === 'ft') {
         return UNIT.FOOT;
     } else if (proj.units === undefined && proj.to_meter === undefined) {
         // See https://proj.org/en/9.4/usage/projections.html [17/10/2024]
@@ -130,7 +152,7 @@ export function isGeocentric(crs: ProjectionLike) {
 export function isValid(crs: ProjectionLike) {
     const proj = proj4.defs(crs);
     if (!proj) {
-        throw new Error(`Undefined crs '${crs}'. Add it with proj4.defs('${crs}', string)`);
+        throw new Error(`Undefined crs '${crs}'. Add it with itowns.CRS.defs('${crs}', wktString)`);
     }
     if (!unitFromProj4Unit(proj)) {
         throw new Error(`No valid unit found for crs '${crs}', found ${proj.units}`);
@@ -166,11 +188,56 @@ export function axisOrder(crs: ProjectionLike) {
 
 /**
  * Defines a proj4 projection as a named alias.
- * This function is a specialized wrapper over the
- * [`proj4.defs`](https://github.com/proj4js/proj4js#named-projections)
- * function.
+ * This function is an alias for the
+ * [`proj4.defs`](https://github.com/proj4js/proj4js#named-projections) function.
+ */
+export const defs = proj4.defs;
+
+/**
+ * Fetches a CRS definition from epsg.io and registers it with proj4.
+ * If the CRS is already defined, returns the existing definition.
  *
- * @param code - Named alias of the currently defined projection.
- * @param proj4def - Proj4 or WKT string of the defined projection.
+ * @param crs - The EPSG code string (e.g. "EPSG:2154").
+ * @returns The proj4 projection definition.
+ *
+ * @example
+ * // Register EPSG:2154 (RGF93 / Lambert-93)
+ * await CRS.fromEPSG('EPSG:2154');
+ *
+ * // Register EPSG:4269 (NAD83)
+ * await CRS.fromEPSG('EPSG:4269');
  */
-export const defs = (code: string, proj4def: string) => proj4.defs(code, proj4def);
+export async function fromEPSG(crs: string): Promise<ProjectionDefinition> {
+    const def = proj4.defs(crs);
+    if (def) {
+        return def;
+    }
+
+    const code = crs.replace(/^EPSG:/i, '');
+    const response = await fetch(`https://epsg.io/${code}.proj4`);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch EPSG:${code} from epsg.io: ${response.status}`);
+    }
+
+    const proj4def = await response.text();
+    proj4.defs(crs, proj4def);
+    return proj4.defs(crs);
+}
+
+export function defsFromWkt(wkt: string): string {
+    proj4.defs('unknown', wkt);
+    const proj4Defs = proj4.defs as unknown as proj4Def;
+    let projCS;
+    if (proj4Defs('unknown').type === 'COMPD_CS') {
+        console.warn('Compound coordinate system is not yet supported.');
+        projCS = proj4Defs('unknown').PROJCS;
+    } else {
+        projCS = proj4Defs('unknown');
+    }
+    const crsAlias = (projCS.title || projCS.name || 'EPSG:XXXX');
+    if (!(crsAlias in proj4.defs)) {
+        proj4.defs(crsAlias, projCS);
+    }
+    delete proj4Defs.unknown;
+    return crsAlias;
+}

package/src/OrientationUtils.ts

@@ -32,6 +32,7 @@ type Attitude = Partial<EulerAngles> | Partial<PhotogrammetryAngles>;
 
 type QuaternionFunction = (coords: Coordinates, target?: Quaternion) => Quaternion;
 
+// To unify with Crs.js ProjectionLike type ?
 type ProjectionLike = ProjectionDefinition | string;
 type LCCProjection = { long0: number, lat0: number };
 type TMercProjection = { a: number, b: number, e?: number, long0: number };
@@ -416,6 +417,7 @@ export function quaternionFromEnuToCRS(
         case 'Geocentric': return quaternionFromEnuToGeocent();
         case 'Lambert Tangential Conformal Conic Projection':
             return quaternionFromEnuToLCC(proj as LCCProjection);
+        case 'Universal Transverse Mercator System':
         case 'Fast_Transverse_Mercator': return quaternionFromEnuToTMerc(proj as TMercProjection);
         case 'longlat': return quaternionFromEnuToLongLat();
         default: return quaternionUnimplemented(proj);
@@ -453,19 +455,21 @@ export function quaternionFromCRSToEnu(
         case 'Geocentric': return quaternionFromGeocentToEnu();
         case 'Lambert Tangential Conformal Conic Projection':
             return quaternionFromLCCToEnu(proj as LCCProjection);
+        case 'Universal Transverse Mercator System':
         case 'Fast_Transverse_Mercator': return quaternionFromTMercToEnu(proj as TMercProjection);
         case 'longlat': return quaternionFromLongLatToEnu();
         default: return quaternionUnimplemented(proj);
     }
 }
 
+const quaternionCrs2CrsCache: Record<string, Record<string, QuaternionFunction>> = {};
 export function quaternionFromCRSToCRS(
-    crsIn: ProjectionLike,
-    crsOut: ProjectionLike,
+    crsIn: string,
+    crsOut: string,
 ): QuaternionFunction;
 export function quaternionFromCRSToCRS(
-    crsIn: ProjectionLike,
-    crsOut: ProjectionLike,
+    crsIn: string,
+    crsOut: string,
     coords: Coordinates,
     target?: Quaternion,
 ): Quaternion;
@@ -481,8 +485,8 @@ export function quaternionFromCRSToCRS(
  * function to compute it from coordinates.
  */
 export function quaternionFromCRSToCRS(
-    crsIn: ProjectionLike,
-    crsOut: ProjectionLike,
+    crsIn: string,
+    crsOut: string,
     coordinates?: Coordinates,
     target = new Quaternion(),
 ) {
@@ -491,9 +495,23 @@ export function quaternionFromCRSToCRS(
         return (origin: Coordinates, target = new Quaternion()) => target.set(0, 0, 0, 1);
     }
 
+    if (quaternionCrs2CrsCache[crsIn] && quaternionCrs2CrsCache[crsIn][crsOut]) {
+        return quaternionCrs2CrsCache[crsIn][crsOut];
+    }
+
     // get rotations from the local East/North/Up (ENU) frame to both CRS.
     const fromCrs = quaternionFromCRSToEnu(crsIn);
     const toCrs = quaternionFromEnuToCRS(crsOut);
-    return (origin: Coordinates, target = new Quaternion()) =>
-        toCrs(origin, target).multiply(fromCrs(origin, quat));
+
+    if (!quaternionCrs2CrsCache[crsIn]) {
+        quaternionCrs2CrsCache[crsIn] = {};
+    }
+
+    if (!quaternionCrs2CrsCache[crsIn][crsOut]) {
+        quaternionCrs2CrsCache[crsIn][crsOut] =
+            (origin: Coordinates, target = new Quaternion()) =>
+                toCrs(origin, target).multiply(fromCrs(origin, quat));
+    }
+
+    return quaternionCrs2CrsCache[crsIn][crsOut];
 }