@itowns/geographic 2.46.1-next.6 → 2.46.1-next.60

package/src/Ellipsoid.ts

@@ -47,6 +47,7 @@ class Ellipsoid {
      * @param cartesian - The given cartesian coordinate.
      * @param target - An object to store this vector to. If this is not
      * specified, a new vector will be created.
+     * @returns
      */
     geodeticSurfaceNormal(
         cartesian: Coordinates,
@@ -62,6 +63,7 @@ class Ellipsoid {
      * @param coordCarto - The given geographic coordinate.
      * @param target - An object to store this vector to. If this is not
      * specified, a new vector will be created.
+     * @returns
      */
     geodeticSurfaceNormalCartographic(
         coordCarto: Coordinates,
@@ -82,6 +84,7 @@ class Ellipsoid {
      * properties.
      *
      * @param size - The source vector.
+     * @returns
      */
     setSize(size: Vector3Like): this {
         this.size.set(size.x, size.y, size.z);
@@ -146,7 +149,7 @@ class Ellipsoid {
 
         const phi = Math.atan(
             (position.z * (1 - f) + e * a * sinu * sinu * sinu) /
-                ((1 - f) * (rsqXY - e * a * cosu * cosu * cosu)));
+            ((1 - f) * (rsqXY - e * a * cosu * cosu * cosu)));
 
         const h = (rsqXY * Math.cos(phi)) +
             position.z * Math.sin(phi) -
@@ -202,7 +205,7 @@ class Ellipsoid {
             return false;
         }
 
-        let t = 0;
+        let t;
         if (t1 <= EPSILON) { t = t2; } else
             if (t2 <= EPSILON) { t = t1; } else { t = (t1 < t2) ? t1 : t2; }
 
@@ -236,7 +239,7 @@ class Ellipsoid {
 
         const distRad = Math.acos(
             Math.sin(latitude1) * Math.sin(latitude2) +
-                Math.cos(latitude1) * Math.cos(latitude2) * Math.cos(longitude2 - longitude1));
+            Math.cos(latitude1) * Math.cos(latitude2) * Math.cos(longitude2 - longitude1));
 
         const e = this.eccentricity;
         const latMoy = (latitude1 + latitude2) * 0.5;

package/src/Extent.ts

@@ -16,8 +16,6 @@ const cNorthEast =  /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0, 0);
 const southWest = /* @__PURE__ */ new Vector3();
 const northEast = /* @__PURE__ */ new Vector3();
 
-let _extent: Extent;
-
 const cardinals = [
     /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0, 0),
     /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0, 0),
@@ -100,6 +98,7 @@ class Extent {
 
     /**
      * Returns a new extent with the same bounds and crs as this one.
+     * @returns
      */
     clone() {
         return new Extent(this.crs, this.west, this.east, this.south, this.north);
@@ -111,6 +110,7 @@ class Extent {
      * @param crs - target's projection.
      * @param target - The target to store the projected extent. If this not
      * provided a new extent will be created.
+     * @returns
      */
     as(crs: string, target: Extent = new Extent('EPSG:4326')) {
         CRS.isValid(crs);
@@ -155,6 +155,7 @@ class Extent {
      *
      * @param target - The target to store the center coordinate. If this not
      * provided a new coordinate will be created.
+     * @returns
      */
     center(target = new Coordinates(this.crs)) {
         this.planarDimensions(_dim);
@@ -172,6 +173,7 @@ class Extent {
      * 2D Cartesian coordinate system.
      *
      * @param target - optional target
+     * @returns
      */
     planarDimensions(target = new Vector2()) {
         // Calculte the dimensions for x and y
@@ -185,6 +187,7 @@ class Extent {
      * across the curved surface of the ellipsoid.
      *
      * @param target - optional target
+     * @returns
      */
     geodeticDimensions(target = new Vector2()) {
         // set 3 corners extent
@@ -209,6 +212,7 @@ class Extent {
      *  Spatial euclidean distance chord is calculated in an ellispoid space.
      *
      * @param target - optional target
+     * @returns
      */
     spatialEuclideanDimensions(target = new Vector2()) {
         // set 3 corners extent
@@ -233,6 +237,7 @@ class Extent {
      * @param coord - the given coordinates.
      * @param epsilon - error margin when comparing to the coordinates.
      * Default is 0.
+     * @returns
      */
     isPointInside(coord: Coordinates, epsilon = 0) {
         if (this.crs == coord.crs) {
@@ -243,9 +248,9 @@ class Extent {
 
         // TODO this ignores altitude
         return _c.x <= this.east + epsilon &&
-               _c.x >= this.west - epsilon &&
-               _c.y <= this.north + epsilon &&
-               _c.y >= this.south - epsilon;
+            _c.x >= this.west - epsilon &&
+            _c.y <= this.north + epsilon &&
+            _c.y >= this.south - epsilon;
     }
 
     /**
@@ -253,13 +258,14 @@ class Extent {
      *
      * @param extent - the extent to check
      * @param epsilon - error margin when comparing the extent bounds.
+     * @returns
      */
     isInside(extent: 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;
+            _extent.west - this.west <= epsilon &&
+            this.north - _extent.north <= epsilon &&
+            _extent.south - this.south <= epsilon;
     }
 
     /**
@@ -294,13 +300,27 @@ class Extent {
      * Checks wheter this bounding box intersects with the given extent
      * parameter.
      * @param extent - the provided extent
+     * @returns
      */
     intersectsExtent(extent: Extent) {
         return Extent.intersectsExtent(this, extent);
     }
 
+    /**
+     * Tests whether two extents intersect.
+     *
+     * This method checks if the geographic extents `extentA` and `extentB`
+     * overlap. If their coordinate reference systems (CRS) differ, `extentB`
+     * is reprojected into the CRS of `extentA` before performing the test.
+     *
+     * Extents that touch at an edge or a corner aren't treated as intersecting.
+     *
+     * @param extentA - The reference extent.
+     * @param extentB - The extent to test against.
+     *
+     * @returns `true` if the extents intersect, `false` otherwise.
+     */
     static intersectsExtent(extentA: Extent, extentB: Extent) {
-        // TODO don't work when is on limit
         const other = extentB.crs == extentA.crs ? extentB : extentB.as(extentA.crs, _extent);
         return !(extentA.west >= other.east ||
             extentA.east <= other.west ||
@@ -310,16 +330,29 @@ class Extent {
 
     /**
      * Returns the intersection of this extent with another one.
-     * @param extent - extent to intersect
+     *
+     * This method computes the overlapping region between this extent and
+     * another extent. If their coordinate reference systems (CRS) differ,
+     * the other extent is reprojected into the CRS of this extent before
+     * performing the intersection.
+     *
+     *
+     * @param extent - The extent to intersect with this one.
+     * @param target - The target extent to store the result. If not provided,
+     * a new extent will be created.
+     *
+     * @returns The intersection extent
+     * (may be empty if extents do not intersect).
      */
-    intersect(extent: Extent) {
+    intersect(extent: Extent, target = new Extent(this.crs)) {
         if (!this.intersectsExtent(extent)) {
-            return new Extent(this.crs);
+            return target;
         }
         if (extent.crs != this.crs) {
             extent = extent.as(this.crs, _extent);
         }
-        return new Extent(this.crs,
+
+        return target.set(
             Math.max(this.west, extent.west),
             Math.min(this.east, extent.east),
             Math.max(this.south, extent.south),
@@ -333,6 +366,7 @@ class Extent {
      * @param v1 - the `east` value of this extent. Default is 0.
      * @param v2 - the `south` value of this extent. Default is 0.
      * @param v3 - the `north` value of this extent. Default is 0.
+     * @returns
      */
     set(v0: number, v1: number, v2: number, v3: number): this {
         if (v0 == undefined) {
@@ -370,8 +404,9 @@ class Extent {
      * `north` property to `array[offset + 3]`.
      * @param array - the source array
      * @param offset - offset into the array. Default is 0.
+     * @returns
      */
-    setFromArray(array: ArrayLike<number>, offset: number = 0): this {
+    setFromArray(array: ArrayLike<number>, offset = 0): this {
         this.west = array[offset];
         this.east = array[offset + 1];
         this.south = array[offset + 2];
@@ -383,6 +418,7 @@ class Extent {
      * Sets this extent `west`, `east`, `south` and `north` properties from an
      * `extent` bounds.
      * @param extent - the source extent
+     * @returns
      */
     setFromExtent(extent: ExtentLike): this {
         this.west = extent.west;
@@ -395,6 +431,7 @@ class Extent {
     /**
      * Copies the passed extent to this extent.
      * @param extent - extent to copy.
+     * @returns
      */
     copy(extent: Extent): this {
         this.crs = extent.crs;
@@ -404,6 +441,7 @@ class Extent {
     /**
      * Union this extent with the input extent.
      * @param extent - the extent to union.
+     * @returns
      */
     union(extent: Extent) {
         if (extent.crs != this.crs) {
@@ -432,6 +470,8 @@ class Extent {
                 this.north = north;
             }
         }
+
+        return this;
     }
 
     /**
@@ -445,12 +485,11 @@ class Extent {
     }
 
     /**
-    * expandByValuesCoordinates perfoms the minimal extension
-    * for the coordinates values to belong to this Extent object
-    * @param we - The coordinate on west-east
-    * @param sn - The coordinate on south-north
-    *
-    */
+     * expandByValuesCoordinates perfoms the minimal extension
+     * for the coordinates values to belong to this Extent object
+     * @param we - The coordinate on west-east
+     * @param sn - The coordinate on south-north
+     */
     expandByValuesCoordinates(we: number, sn: number) {
         if (we < this.west) {
             this.west = we;
@@ -475,6 +514,7 @@ class Extent {
      *
      * @param crs - Projection of extent to instancied.
      * @param box - Bounding-box
+     * @returns
      */
     static fromBox3(crs: ProjectionLike, box: Box3) {
         if (CRS.isGeocentric(crs)) {
@@ -499,6 +539,7 @@ class Extent {
     /**
      * Return values of extent in string, separated by the separator input.
      * @param sep - string separator
+     * @returns
      */
     toString(sep = '') {
         return `${this.east}${sep}${this.north}${sep}${this.west}${sep}${this.south}`;
@@ -603,6 +644,6 @@ class Extent {
     }
 }
 
-_extent = /* @__PURE__ */ new Extent('EPSG:4326');
+const _extent = /* @__PURE__ */ new Extent('EPSG:4326');
 
 export default Extent;

package/src/OrientationUtils.ts

@@ -32,9 +32,10 @@ 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 };
+interface LCCProjection { long0: number; lat0: number }
+interface TMercProjection { a: number; b: number; e?: number; long0: number }
 
 /**
  * The transform from the platform frame to the local East, North, Up (ENU)
@@ -366,6 +367,7 @@ export function quaternionUnimplemented(
  * identity (0,0,0,1).
  *
  * @param proj - the unimplemented projection (may be parsed using proj4)
+ * @param proj.projName - the name of the projection
  * @param coordinates - the origin of the local East North Up (ENU) frame
  * @param target - output Quaternion
  * @returns The target quaternion if coordinates is defined, otherwise, a
@@ -416,6 +418,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 +456,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 +486,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 +496,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];
 }