@itowns/geographic 2.45.0 → 2.45.1-next.1

package/lib/CoordStars.d.ts

@@ -0,0 +1,13 @@
+declare const CoordStars: {
+    getSunPosition(): (date: Date | number, lat: number, lon: number) => {
+        EclipticLongitude: number;
+        declinaison: number;
+        ascension: number;
+        H: number;
+        SiderealTime: number;
+        altitude: number;
+        azimuth: number;
+    };
+    getSunPositionInScene(date: Date | number, lat: number, lon: number): import("three").Vector3;
+};
+export default CoordStars;

package/lib/CoordStars.js

@@ -0,0 +1,89 @@
+/**
+ * Generated On: 2016-02-25
+ * Class: CoordStars
+ * Description: get coord of stars like earth...
+ */
+import Coordinates from "./Coordinates.js";
+const CoordStars = {
+  getSunPosition() {
+    const m = Math;
+    const PI = m.PI;
+    const sin = m.sin;
+    const cos = m.cos;
+    const tan = m.tan;
+    const asin = m.asin;
+    const atan = m.atan2;
+    const rad = PI / 180;
+    const dayMs = 1000 * 60 * 60 * 24;
+    const J1970 = 2440588;
+    const J2000 = 2451545;
+    const e = rad * 23.4397; // obliquity of the Earth
+
+    function toJulian(date) {
+      return date.valueOf() / dayMs - 0.5 + J1970;
+    }
+    function toDays(date) {
+      return toJulian(date) - J2000;
+    }
+    function getRightAscension(l, b) {
+      return atan(sin(l) * cos(e) - tan(b) * sin(e), cos(l));
+    }
+    function getDeclination(l, b) {
+      return asin(sin(b) * cos(e) + cos(b) * sin(e) * sin(l));
+    }
+    function getAzimuth(H, phi, dec) {
+      return atan(sin(H), cos(H) * sin(phi) - tan(dec) * cos(phi));
+    }
+    function getAltitude(H, phi, dec) {
+      return asin(sin(phi) * sin(dec) + cos(phi) * cos(dec) * cos(H));
+    }
+    function getSiderealTime(d, lw) {
+      return rad * (280.16 + 360.9856235 * d) - lw;
+    }
+    function getSolarMeanAnomaly(d) {
+      return rad * (357.5291 + 0.98560028 * d);
+    }
+    function getEquationOfCenter(M) {
+      return rad * (1.9148 * sin(M) + 0.0200 * sin(2 * M) + 0.0003 * sin(3 * M));
+    }
+    function getEclipticLongitude(M, C) {
+      const P = rad * 102.9372; // perihelion of the Earth
+      return M + C + P + PI;
+    }
+    return function getSunPosition(date, lat, lon) {
+      const lw = rad * -lon;
+      const phi = rad * lat;
+      const d = toDays(date);
+      const M = getSolarMeanAnomaly(d);
+      const C = getEquationOfCenter(M);
+      const L = getEclipticLongitude(M, C);
+      const D = getDeclination(L, 0);
+      const A = getRightAscension(L, 0);
+      const t = getSiderealTime(d, lw);
+      const H = t - A;
+      return {
+        EclipticLongitude: L,
+        declinaison: D,
+        ascension: A,
+        H,
+        SiderealTime: t,
+        altitude: getAltitude(H, phi, D),
+        azimuth: getAzimuth(H, phi, D) + PI / 2 // + PI// - PI/2
+        // origin: north !!! not like original Mourner code but more
+        // classical ref
+      };
+    };
+  },
+  // Return scene coordinate ({x,y,z}) of sun
+  getSunPositionInScene(date, lat, lon) {
+    if (typeof date !== 'number') {
+      date = date.valueOf();
+    }
+    const sun = CoordStars.getSunPosition()(date, lat, lon);
+    const dayMilliSec = 24 * 3600000;
+    const longitude = sun.ascension + date % dayMilliSec / dayMilliSec * -360 + 180; // cause midday
+    const coSunCarto = new Coordinates('EPSG:4326', longitude, lat, 50000000).as('EPSG:4978').toVector3();
+    return coSunCarto;
+  }
+};
+export default CoordStars;

package/lib/Coordinates.d.ts

@@ -0,0 +1,196 @@
+import * as THREE from 'three';
+import type { ProjectionLike } from './Crs';
+export interface CoordinatesLike {
+    readonly crs: string;
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+}
+/**
+ * A class representing a geographic or geocentric coordinate.
+ *
+ * A coordinate is defined by a [CRS](http://inspire.ec.europa.eu/theme/rs)
+ * (Coordinate Reference System) and a 3-dimensional vector `(x, y, z)`.
+ * For geocentric projections, it is recommended to use the `latitude`,
+ * `longitude` and `altitude` aliases to refer to vector components.
+ *
+ * To change a value, prefer the use of the `set*` methods.
+ *
+ * By default, the `EPSG:4978` and `EPSG:4326` projections are supported. To use
+ * a different projection, it must have been declared previously with `proj4`.
+ * A comprehensive list of projections and their corresponding proj4 string can
+ * be found at [epsg.io](https://epsg.io/).
+ *
+ * @example Geocentric coordinates
+ * ```js
+ * new Coordinates('EPSG:4978', 20885167, 849862, 23385912);
+ * ```
+ *
+ * @example Geographic coordinates
+ * ```js
+ * new Coordinates('EPSG:4326', 2.33, 48.24, 24999549);
+ * ```
+ *
+ * @example Defining the EPSG:2154 projection with proj4
+ * ```js
+ * proj4.defs('EPSG:2154', `+proj=lcc +lat_0=46.5 +lon_0=3 +lat_1=49 +lat_2=44
+ * +x_0=700000 +y_0=6600000 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m
+ * +no_defs +type=crs`);
+ * ```
+ */
+declare class Coordinates {
+    /**
+     * Read-only flag to check if a given object is of type `Coordinates`.
+     */
+    readonly isCoordinates: boolean;
+    /**
+     * A default or user-defined CRS (see {@link ProjectionLike}).
+     */
+    crs: ProjectionLike;
+    /** The x value (or longitude) of this coordinate. */
+    x: number;
+    /** The y value (or latitude) of this coordinate. */
+    y: number;
+    /** The z value (or altitude) of this coordinate. */
+    z: number;
+    private _normal;
+    private _normalNeedsUpdate;
+    /**
+     * @param crs - A default or user-defined CRS (see {@link ProjectionLike}).
+     * @param x - x or longitude value.
+     * @param y - y or latitude value.
+     * @param z - z or altitude value.
+     */
+    constructor(crs: ProjectionLike, x?: number, y?: number, z?: number);
+    /**
+     * Sets the Coordinate Reference System.
+     * @param crs - Coordinate Reference System (e.g. 'EPSG:4978')
+     */
+    setCrs(crs: ProjectionLike): this;
+    /**
+     * Sets the x, y and z components of this coordinate.
+     *
+     * @param x - x or longitude value.
+     * @param y - y or latitude value.
+     * @param z - z or altitude value.
+     */
+    setFromValues(x?: number, y?: number, z?: number): this;
+    /**
+     * Sets the coordinates's {@link Coordinates#x | x} component to
+     * `array[offset + 0]`, {@link Coordinates#y | y} component to
+     * `array[offset + 1]` and {@link Coordinates#z | z} component to
+     * `array[offset + 2]`.
+     *
+     * @param array - The source array.
+     * @param offset - Optional offset into the array. Default is 0.
+     */
+    setFromArray(array: number[], offset?: number): this;
+    /**
+     * Sets the `(x, y, z)` vector of this coordinate from a 3-dimensional
+     * vector-like object. This object shall have both `x`, `y` and `z`
+     * properties.
+     *
+     * @param v - The source object.
+     */
+    setFromVector3(v: THREE.Vector3Like): this;
+    /**
+     * Returns a new coordinate with the same `(x, y, z)` vector and crs as this
+     * one.
+     */
+    clone(): Coordinates;
+    /**
+     * Copies the `(x, y, z)` vector components and crs of the passed coordinate
+     * to this coordinate.
+     *
+     * @param src - The source coordinate to copy from.
+     */
+    copy(src: CoordinatesLike): this;
+    get longitude(): number;
+    get latitude(): number;
+    get altitude(): number;
+    set altitude(value: number);
+    /**
+     * The geodesic normal of the coordinate.
+     */
+    get geodesicNormal(): THREE.Vector3;
+    /**
+     * Copies the `x`, `y` and `z` components into the provided `THREE.Vector3`.
+     *
+     * @param target - An object to store this vector to. If this is not
+     * specified, a new vector will be created.
+     *
+     * @returns A vector `(x, y, z)`, or copies x, y and z into the provided
+     * vector.
+     */
+    toVector3(target?: THREE.Vector3): THREE.Vector3;
+    /**
+     * Copies the `x`, `y` and `z` components into the provided array.
+     *
+     * @param array - An array to store this vector to. If this is not
+     * provided a new array will be created.
+     * @param offset - An optional offset into the array.
+     *
+     * @returns An array [x, y, z], or copies x, y and z into the provided
+     * array.
+     */
+    toArray(array?: number[], offset?: number): ArrayLike<number>;
+    /**
+     * Computes the planar distance from this coordinates to `coord`.
+     * **Planar distance** is the straight-line euclidean distance calculated in
+     * a 2D cartesian coordinate system.
+     */
+    planarDistanceTo(coord: Coordinates): number;
+    /**
+     * Computes the geodetic distance from this coordinates to `coord`.
+     * **Geodetic distance** is calculated in an ellipsoid space as the shortest
+     * distance across the curved surface of the ellipsoid.
+     */
+    geodeticDistanceTo(coord: Coordinates): number;
+    /**
+     * Computes the euclidean distance from this coordinates to `coord` in a
+     * WGS84 projection.
+     *
+     * @param coord - The coordinate
+     * @returns earth euclidean distance
+     */
+    spatialEuclideanDistanceTo(coord: Coordinates): number;
+    /**
+     * Multiplies this coordinate (with an implicit 1 in the 4th dimension)
+     * by `mat`, and divides by perspective.
+     *
+     * @param mat - The matrix.
+     */
+    applyMatrix4(mat: THREE.Matrix4): this;
+    /**
+     * Projects this coordinate to the specified
+     * [CRS](http://inspire.ec.europa.eu/theme/rs).
+     *
+     * @param crs - The target CRS to which the coordinate will be converted.
+     * @param target - The target to store the projected coordinate. If this not
+     * provided a new coordinate will be created.
+     *
+     * @returns The coordinate projected into the specified CRS.
+     *
+     * @example Conversion from a geographic to a geocentric reference system
+     * ```js
+     * const geographicCoords = new Coordinates('EPSG:4326',
+     *     2.33,        // longitude
+     *     48.24,       // latitude
+     *     24999549,    // altitude
+     * );
+     * const geocentricCoords = geographicCoords.as('EPSG:4978');
+     * ```
+     *
+     * @example Conversion from a geocentric to a geographic reference system
+     * ```js
+     * const geocentricCoords = new Coordinates('EPSG:4978',
+     *     20885167,    // x
+     *     849862,      // y
+     *     23385912,    // z
+     * );
+     * const geographicCoords = geocentricCoords.as('EPSG:4326');
+     * ```
+     */
+    as(crs: ProjectionLike, target?: Coordinates): Coordinates;
+}
+export default Coordinates;

package/lib/Coordinates.js

@@ -0,0 +1,331 @@
+import * as THREE from 'three';
+import proj4 from 'proj4';
+import Ellipsoid from "./Ellipsoid.js";
+import * as CRS from "./Crs.js";
+const ellipsoid = new Ellipsoid();
+const projectionCache = {};
+const v0 = new THREE.Vector3();
+const v1 = new THREE.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.
+ *
+ * A coordinate is defined by a [CRS](http://inspire.ec.europa.eu/theme/rs)
+ * (Coordinate Reference System) and a 3-dimensional vector `(x, y, z)`.
+ * For geocentric projections, it is recommended to use the `latitude`,
+ * `longitude` and `altitude` aliases to refer to vector components.
+ *
+ * To change a value, prefer the use of the `set*` methods.
+ *
+ * By default, the `EPSG:4978` and `EPSG:4326` projections are supported. To use
+ * a different projection, it must have been declared previously with `proj4`.
+ * A comprehensive list of projections and their corresponding proj4 string can
+ * be found at [epsg.io](https://epsg.io/).
+ *
+ * @example Geocentric coordinates
+ * ```js
+ * new Coordinates('EPSG:4978', 20885167, 849862, 23385912);
+ * ```
+ *
+ * @example Geographic coordinates
+ * ```js
+ * new Coordinates('EPSG:4326', 2.33, 48.24, 24999549);
+ * ```
+ *
+ * @example Defining the EPSG:2154 projection with proj4
+ * ```js
+ * proj4.defs('EPSG:2154', `+proj=lcc +lat_0=46.5 +lon_0=3 +lat_1=49 +lat_2=44
+ * +x_0=700000 +y_0=6600000 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m
+ * +no_defs +type=crs`);
+ * ```
+ */
+class Coordinates {
+  /**
+   * Read-only flag to check if a given object is of type `Coordinates`.
+   */
+
+  /**
+   * A default or user-defined CRS (see {@link ProjectionLike}).
+   */
+
+  /** The x value (or longitude) of this coordinate. */
+
+  /** The y value (or latitude) of this coordinate. */
+
+  /** The z value (or altitude) of this coordinate. */
+
+  /**
+   * @param crs - A default or user-defined CRS (see {@link ProjectionLike}).
+   * @param x - x or longitude value.
+   * @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;
+    this.isCoordinates = true;
+    CRS.isValid(crs);
+    this.crs = crs;
+
+    // Storing the coordinates as is, not in arrays, as it is
+    // slower (see https://jsbench.me/40jumfag6g/1)
+    this.x = 0;
+    this.y = 0;
+    this.z = 0;
+
+    // Normal
+    this._normal = new THREE.Vector3();
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (x.length > 0) {
+      // deepscan-disable-line
+      console.warn('Deprecated Coordinates#constructor(string, number[]),', 'use `new Coordinates(string).setFromArray(number[])` instead.');
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      this.setFromArray(x);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } else if (x.isVector3 || x.isCoordinates) {
+      console.warn('Deprecated Coordinates#constructor(string, Vector3),', 'use `new Coordinates(string).setFromVector3(Vector3)` instead.');
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      this.setFromVector3(x);
+    } else {
+      this.setFromValues(x, y, z);
+    }
+    this._normalNeedsUpdate = true;
+  }
+
+  /**
+   * Sets the Coordinate Reference System.
+   * @param crs - Coordinate Reference System (e.g. 'EPSG:4978')
+   */
+  setCrs(crs) {
+    CRS.isValid(crs);
+    this.crs = crs;
+    return this;
+  }
+
+  /**
+   * Sets the x, y and z components of this coordinate.
+   *
+   * @param x - x or longitude value.
+   * @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;
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this._normalNeedsUpdate = true;
+    return this;
+  }
+
+  /**
+   * Sets the coordinates's {@link Coordinates#x | x} component to
+   * `array[offset + 0]`, {@link Coordinates#y | y} component to
+   * `array[offset + 1]` and {@link Coordinates#z | z} component to
+   * `array[offset + 2]`.
+   *
+   * @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;
+    return this.setFromValues(array[offset], array[offset + 1], array[offset + 2]);
+  }
+
+  /**
+   * Sets the `(x, y, z)` vector of this coordinate from a 3-dimensional
+   * vector-like object. This object shall have both `x`, `y` and `z`
+   * properties.
+   *
+   * @param v - The source object.
+   */
+  setFromVector3(v) {
+    return this.setFromValues(v.x, v.y, v.z);
+  }
+
+  /**
+   * Returns a new coordinate with the same `(x, y, z)` vector and crs as this
+   * one.
+   */
+  clone() {
+    return new Coordinates(this.crs, this.x, this.y, this.z);
+  }
+
+  /**
+   * Copies the `(x, y, z)` vector components and crs of the passed coordinate
+   * to this coordinate.
+   *
+   * @param src - The source coordinate to copy from.
+   */
+  copy(src) {
+    this.crs = src.crs;
+    return this.setFromVector3(src);
+  }
+  get longitude() {
+    return this.x;
+  }
+  get latitude() {
+    return this.y;
+  }
+  get altitude() {
+    return this.z;
+  }
+  set altitude(value) {
+    this.z = value;
+  }
+
+  /**
+   * The geodesic normal of the coordinate.
+   */
+  get geodesicNormal() {
+    if (this._normalNeedsUpdate) {
+      this._normalNeedsUpdate = false;
+      if (CRS.is4326(this.crs)) {
+        ellipsoid.geodeticSurfaceNormalCartographic(this, this._normal);
+      } else if (this.crs == 'EPSG:4978') {
+        ellipsoid.geodeticSurfaceNormal(this, this._normal);
+      } else {
+        this._normal.set(0, 0, 1);
+      }
+    }
+    return this._normal;
+  }
+
+  /**
+   * Copies the `x`, `y` and `z` components into the provided `THREE.Vector3`.
+   *
+   * @param target - An object to store this vector to. If this is not
+   * specified, a new vector will be created.
+   *
+   * @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 THREE.Vector3();
+    return target.copy(this);
+  }
+
+  /**
+   * Copies the `x`, `y` and `z` components into the provided array.
+   *
+   * @param array - An array to store this vector to. If this is not
+   * provided a new array will be created.
+   * @param offset - An optional offset into the array.
+   *
+   * @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;
+    return THREE.Vector3.prototype.toArray.call(this, array, offset);
+  }
+
+  /**
+   * Computes the planar distance from this coordinates to `coord`.
+   * **Planar distance** is the straight-line euclidean distance calculated in
+   * a 2D cartesian coordinate system.
+   */
+  planarDistanceTo(coord) {
+    this.toVector3(v0).setZ(0);
+    coord.toVector3(v1).setZ(0);
+    return v0.distanceTo(v1);
+  }
+
+  /**
+   * Computes the geodetic distance from this coordinates to `coord`.
+   * **Geodetic distance** is calculated in an ellipsoid space as the shortest
+   * distance across the curved surface of the ellipsoid.
+   */
+  geodeticDistanceTo(coord) {
+    this.as('EPSG:4326', coord0);
+    coord.as('EPSG:4326', coord1);
+    return ellipsoid.geodesicDistance(coord0, coord1);
+  }
+
+  /**
+   * Computes the euclidean distance from this coordinates to `coord` in a
+   * WGS84 projection.
+   *
+   * @param coord - The coordinate
+   * @returns earth euclidean distance
+   */
+  spatialEuclideanDistanceTo(coord) {
+    this.as('EPSG:4978', coord0).toVector3(v0);
+    coord.as('EPSG:4978', coord1).toVector3(v1);
+    return v0.distanceTo(v1);
+  }
+
+  /**
+   * Multiplies this coordinate (with an implicit 1 in the 4th dimension)
+   * by `mat`, and divides by perspective.
+   *
+   * @param mat - The matrix.
+   */
+  applyMatrix4(mat) {
+    THREE.Vector3.prototype.applyMatrix4.call(this, mat);
+    return this;
+  }
+
+  /**
+   * Projects this coordinate to the specified
+   * [CRS](http://inspire.ec.europa.eu/theme/rs).
+   *
+   * @param crs - The target CRS to which the coordinate will be converted.
+   * @param target - The target to store the projected coordinate. If this not
+   * provided a new coordinate will be created.
+   *
+   * @returns The coordinate projected into the specified CRS.
+   *
+   * @example Conversion from a geographic to a geocentric reference system
+   * ```js
+   * const geographicCoords = new Coordinates('EPSG:4326',
+   *     2.33,        // longitude
+   *     48.24,       // latitude
+   *     24999549,    // altitude
+   * );
+   * const geocentricCoords = geographicCoords.as('EPSG:4978');
+   * ```
+   *
+   * @example Conversion from a geocentric to a geographic reference system
+   * ```js
+   * const geocentricCoords = new Coordinates('EPSG:4978',
+   *     20885167,    // x
+   *     849862,      // y
+   *     23385912,    // z
+   * );
+   * const geographicCoords = geocentricCoords.as('EPSG:4326');
+   * ```
+   */
+  as(crs) {
+    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Coordinates(crs);
+    if (this.crs == crs) {
+      target.copy(this);
+    } else {
+      if (CRS.is4326(this.crs) && crs == 'EPSG:3857') {
+        this.y = THREE.MathUtils.clamp(this.y, -89.999999, 89.999999);
+      }
+      target.setFromArray(proj4cache(this.crs, crs).forward([this.x, this.y, this.z]));
+    }
+    target.crs = crs;
+    return target;
+  }
+}
+coord0 = new Coordinates('EPSG:4326', 0, 0, 0);
+coord1 = new Coordinates('EPSG:4326', 0, 0, 0);
+export default Coordinates;