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

package/lib/Ellipsoid.d.ts

@@ -0,0 +1,77 @@
+import { Vector3, type Vector3Like, type Ray } from 'three';
+import Coordinates from './Coordinates';
+/**
+ * Length of the semi-axes of the WGS84 ellipsoid.
+ * @internal
+ */
+export declare const ellipsoidSizes: Vector3;
+declare class Ellipsoid {
+    /**
+     * Length of the semi-axes of the ellipsoid.
+     */
+    size: Vector3;
+    /**
+     * Eccentricity of the ellipsoid.
+     */
+    eccentricity: number;
+    private _radiiSquared;
+    private _invRadiiSquared;
+    /**
+     * @param size - Length of the semi-axes of the ellipsoid. Defaults to those
+     * defined by the WGS84 ellipsoid.
+     */
+    constructor(size?: Vector3);
+    /**
+     * Computes the normal vector to an ellipsoid at the given cartesian
+     * coordinate `(x, y, z)`.
+     *
+     * @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, target?: Vector3): Vector3;
+    /**
+     * Computes the normal vector to an ellipsoid at the given geographic
+     * coordinate `(longitude, latitude, altitude)`.
+     *
+     * @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, target?: Vector3): Vector3;
+    /**
+     * Sets the length of the semi-axes of this ellipsoid from a 3-dimensional
+     * vector-like object. The object shall have both `x`, `y` and `z`
+     * properties.
+     *
+     * @param size - The source vector.
+     * @returns
+     */
+    setSize(size: Vector3Like): this;
+    cartographicToCartesian(coordCarto: Coordinates, target?: Vector3): Vector3;
+    /**
+     * Convert cartesian coordinates to geographic according to the current
+     * ellipsoid of revolution.
+     * @param position - The coordinate to convert
+     * @param target - coordinate to copy result
+     * @returns an object describing the coordinates on the reference ellipsoid,
+     * angles are in degree
+     */
+    cartesianToCartographic(position: Vector3Like, target?: Coordinates): Coordinates;
+    cartographicToCartesianArray(coordCartoArray: Coordinates[]): Vector3[];
+    intersection(ray: Ray): Vector3 | false;
+    /**
+     * Calculate the geodesic distance, between coordCarto1 and coordCarto2.
+     * It's most short distance on ellipsoid surface between coordCarto1 and
+     * coordCarto2.
+     * It's called orthodromy.
+     *
+     * @param coordCarto1 - The coordinate carto 1
+     * @param coordCarto2 - The coordinate carto 2
+     * @returns The orthodromic distance between the two given coordinates.
+     */
+    geodesicDistance(coordCarto1: Coordinates, coordCarto2: Coordinates): number;
+}
+export default Ellipsoid;

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();
@@ -37,9 +36,9 @@ 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) {
-    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();
   }
 
@@ -50,9 +49,9 @@ 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) {
-    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);
@@ -65,6 +64,7 @@ class Ellipsoid {
    * properties.
    *
    * @param size - The source vector.
+   * @returns
    */
   setSize(size) {
     this.size.set(size.x, size.y, size.z);
@@ -75,8 +75,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 +92,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?
@@ -139,7 +137,7 @@ class Ellipsoid {
       // both intersections are behind the ray origin
       return false;
     }
-    let t = 0;
+    let t;
     if (t1 <= EPSILON) {
       t = t2;
     } else if (t2 <= EPSILON) {

package/lib/Extent.d.ts

@@ -0,0 +1,287 @@
+import { Vector2, Vector4, Box3, type Matrix4 } from 'three';
+import Coordinates from './Coordinates';
+import type { ProjectionLike } from './Crs';
+export interface ExtentLike {
+    readonly west: number;
+    readonly east: number;
+    readonly south: number;
+    readonly north: number;
+}
+/**
+ * A class representing a geographical extent.
+ *
+ * An extent is a geographical bounding rectangle defined by 4 limits: west,
+ * east, south and north.
+ *
+ * **Warning**: Using a geocentric projection is not suitable for representing a
+ * geographical extent. Please use a geographic projection.
+ */
+declare class Extent {
+    /**
+     * Read-only flag to check if a given object is of type `Extent`.
+     */
+    readonly isExtent: true;
+    /**
+     * A default or user-defined CRS (see {@link ProjectionLike}).
+     */
+    crs: ProjectionLike;
+    /**
+     * West longitude bound of this extent.
+     */
+    west: number;
+    /**
+     * East longitude bound of this extent.
+     */
+    east: number;
+    /**
+     * South latitude bound of this extent.
+     */
+    south: number;
+    /**
+     * North latitude bound of this extent.
+     */
+    north: number;
+    /**
+     * @param crs - A default or user-defined CRS (see {@link ProjectionLike}).
+     * @param west - the `west` value of this extent. Default is 0.
+     * @param east - the `east` value of this extent. Default is 0.
+     * @param south - the `south` value of this extent. Default is 0.
+     * @param north - the `north` value of this extent. Default is 0.
+     */
+    constructor(crs: ProjectionLike, west?: number, east?: number, south?: number, north?: number);
+    /**
+     * Returns a new extent with the same bounds and crs as this one.
+     * @returns
+     */
+    clone(): Extent;
+    /**
+     * Projects this extent to the specified projection.
+     *
+     * @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): Extent;
+    /**
+     * Returns the center of the extent.
+     *
+     * @param target - The target to store the center coordinate. If this not
+     * provided a new coordinate will be created.
+     * @returns
+     */
+    center(target?: Coordinates): Coordinates;
+    /**
+     * Returns the planar dimensions as two-vector planar distances west/east
+     * and south/north.
+     * The planar distance is a straight-line Euclidean distance calculated in a
+     * 2D Cartesian coordinate system.
+     *
+     * @param target - optional target
+     * @returns
+     */
+    planarDimensions(target?: Vector2): Vector2;
+    /**
+     * Returns the geodetic dimensions as two-vector planar distances west/east
+     * and south/north.
+     * Geodetic distance is calculated in an ellispoid space as the distance
+     * across the curved surface of the ellipsoid.
+     *
+     * @param target - optional target
+     * @returns
+     */
+    geodeticDimensions(target?: Vector2): Vector2;
+    /**
+     *  Returns the spatial euclidean dimensions as a two-vector spatial
+     *  euclidean distances between west/east corner and south/north corner.
+     *  Spatial euclidean distance chord is calculated in an ellispoid space.
+     *
+     * @param target - optional target
+     * @returns
+     */
+    spatialEuclideanDimensions(target?: Vector2): Vector2;
+    /**
+     * Checks whether a coordinates is inside the extent.
+     *
+     * @param coord - the given coordinates.
+     * @param epsilon - error margin when comparing to the coordinates.
+     * Default is 0.
+     * @returns
+     */
+    isPointInside(coord: Coordinates, epsilon?: number): boolean;
+    /**
+     * Checks whether another extent is inside the extent.
+     *
+     * @param extent - the extent to check
+     * @param epsilon - error margin when comparing the extent bounds.
+     * @returns
+     */
+    isInside(extent: Extent, epsilon?: number): boolean;
+    /**
+     * Return the translation and scale to transform this extent to the input
+     * extent.
+     *
+     * @param extent - input extent
+     * @param target - copy the result to target.
+     * @returns A {@link THREE.Vector4} where the `x` property encodes the
+     * translation on west-east, the `y` property the translation on
+     * south-north, the `z` property the scale on west-east, the `w` property
+     * the scale on south-north.
+     */
+    offsetToParent(extent: Extent, target?: Vector4): Vector4;
+    /**
+     * Checks wheter this bounding box intersects with the given extent
+     * parameter.
+     * @param extent - the provided extent
+     * @returns
+     */
+    intersectsExtent(extent: Extent): boolean;
+    /**
+     * 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): boolean;
+    /**
+     * Returns the intersection of this extent with another one.
+     *
+     * 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, target?: Extent): Extent;
+    /**
+     * Set west, east, south and north values.
+     *
+     * @param v0 - the `west` value of this extent. Default is 0.
+     * @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;
+    /**
+     * Sets this extent `west` property to `array[offset + 0]`, `east` property
+     * to `array[offset + 1]`, `south` property to `array[offset + 2]` and
+     * `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): this;
+    /**
+     * Sets this extent `west`, `east`, `south` and `north` properties from an
+     * `extent` bounds.
+     * @param extent - the source extent
+     * @returns
+     */
+    setFromExtent(extent: ExtentLike): this;
+    /**
+     * Copies the passed extent to this extent.
+     * @param extent - extent to copy.
+     * @returns
+     */
+    copy(extent: Extent): this;
+    /**
+     * Union this extent with the input extent.
+     * @param extent - the extent to union.
+     * @returns
+     */
+    union(extent: Extent): this;
+    /**
+     * expandByCoordinates perfoms the minimal extension
+     * for the coordinates to belong to this Extent object
+     * @param coordinates - The coordinates to belong
+     */
+    expandByCoordinates(coordinates: Coordinates): void;
+    /**
+     * 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): void;
+    /**
+     * Instance Extent with THREE.Box3.
+     *
+     * If crs is a geocentric projection, the `box3.min` and `box3.max`
+     * should be the geocentric coordinates of `min` and `max` of a `box3`
+     * in local tangent plane.
+     *
+     * @param crs - Projection of extent to instancied.
+     * @param box - Bounding-box
+     * @returns
+     */
+    static fromBox3(crs: ProjectionLike, box: Box3): Extent;
+    /**
+     * Return values of extent in string, separated by the separator input.
+     * @param sep - string separator
+     * @returns
+     */
+    toString(sep?: string): string;
+    /**
+     * Subdivide equally an extent from its center to return four extents:
+     * north-west, north-east, south-west and south-east.
+     *
+     * @returns An array containing the four sections of the extent. The order
+     * of the sections is [NW, NE, SW, SE].
+     */
+    subdivision(): Extent[];
+    /**
+     * subdivise extent by scheme.x on west-east and scheme.y on south-north.
+     *
+     * @param scheme - The scheme to subdivise.
+     * @returns subdivised extents.
+     */
+    subdivisionByScheme(scheme?: Vector2): Extent[];
+    /**
+     * Multiplies all extent `coordinates` (with an implicit 1 in the 4th
+     * dimension) and `matrix`.
+     *
+     * @param matrix - The matrix
+     * @returns return this extent instance.
+     */
+    applyMatrix4(matrix: Matrix4): this;
+    /**
+     * clamp south and north values
+     *
+     * @param south - The min south
+     * @param north - The max north
+     * @returns this extent
+     */
+    clampSouthNorth(south?: number, north?: number): this;
+    /**
+     * clamp west and east values
+     *
+     * @param west - The min west
+     * @param east - The max east
+     * @returns this extent
+     */
+    clampWestEast(west?: number, east?: number): this;
+    /**
+     * clamp this extent by passed extent
+     *
+     * @param extent - The maximum extent.
+     * @returns this extent.
+     */
+    clampByExtent(extent: ExtentLike): this;
+}
+export default Extent;