@itowns/geographic 2.46.1-next.0 → 2.46.1-next.10

package/lib/Crs.d.ts

@@ -1,93 +0,0 @@
-/**
- * A projection as a CRS identifier string. This identifier references a
- * projection definition previously defined with
- * [`proj4.defs`](https://github.com/proj4js/proj4js#named-projections).
- */
-export type ProjectionAlias = string;
-/**
- * System units supported for a coordinate system. See
- * [proj](https://proj4.org/en/9.5/operations/conversions/unitconvert.html#angular-units).
- * Note that only degree and meters units are supported for now.
- */
-export declare const UNIT: {
-    /**
-     * Angular unit in degree.
-     */
-    readonly DEGREE: 1;
-    /**
-     * Distance unit in meter.
-     */
-    readonly METER: 2;
-    /**
-     * Distance unit in foot.
-     */
-    readonly FOOT: 3;
-};
-/**
- * Checks that the CRS is EPSG:4326.
- * @internal
- *
- * @param crs - The CRS to test.
- */
-export declare function is4326(crs: ProjectionAlias): crs is "EPSG:4326";
-/**
- * Returns the horizontal coordinates system units associated with this CRS.
- *
- * @param crs - The CRS to extract the unit from.
- * @returns Either `UNIT.METER`, `UNIT.DEGREE`, `UNIT.FOOT` or `undefined`.
- */
-export declare function getUnit(crs: ProjectionAlias): 1 | 2 | 3 | undefined;
-/**
- * Asserts that the CRS is using metric units.
- *
- * @param crs - The CRS to check.
- * @throws {@link Error} if the CRS is not valid.
- */
-export declare function isMetricUnit(crs: ProjectionAlias): boolean;
-/**
- * Asserts that the CRS is geographic.
- *
- * @param crs - The CRS to check.
- * @throws {@link Error} if the CRS is not valid.
- */
-export declare function isGeographic(crs: ProjectionAlias): boolean;
-/**
- * Asserts that the CRS is geocentric.
- *
- * @param crs - The CRS to test.
- * @returns false if the crs isn't defined.
- */
-export declare function isGeocentric(crs: ProjectionAlias): boolean;
-/**
- * Asserts that the CRS is valid, meaning it has been previously defined and
- * includes an unit.
- *
- * @param crs - The CRS to test.
- * @throws {@link Error} if the crs is not valid.
- */
-export declare function isValid(crs: ProjectionAlias): void;
-/**
- * Gives a reasonable epsilon for this CRS.
- *
- * @param crs - The CRS to use.
- * @returns 0.01 if the CRS is EPSG:4326, 0.001 otherwise.
- */
-export declare function reasonableEpsilon(crs: ProjectionAlias): 0.01 | 0.001;
-/**
- * Returns the axis parameter defined in proj4 for the provided crs.
- * Might be undefined depending on crs definition.
- *
- * @param crs - The CRS to get axis from.
- * @returns the matching proj4 axis string, 'enu' for instance (east, north, up)
- */
-export declare function axisOrder(crs: ProjectionAlias): string | undefined;
-/**
- * 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.
- *
- * @param code - Named alias of the currently defined projection.
- * @param proj4def - Proj4 or WKT string of the defined projection.
- */
-export declare const defs: (code: string, proj4def: string) => void;

package/lib/Ellipsoid.d.ts

@@ -1,74 +0,0 @@
-import * as THREE from 'three';
-import Coordinates from './Coordinates';
-/**
- * Length of the semi-axes of the WGS84 ellipsoid.
- * @internal
- */
-export declare const ellipsoidSizes: THREE.Vector3;
-declare class Ellipsoid {
-    /**
-     * Length of the semi-axes of the ellipsoid.
-     */
-    size: THREE.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?: THREE.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.
-     */
-    geodeticSurfaceNormal(cartesian: Coordinates, target?: THREE.Vector3): THREE.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.
-     */
-    geodeticSurfaceNormalCartographic(coordCarto: Coordinates, target?: THREE.Vector3): THREE.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.
-     */
-    setSize(size: THREE.Vector3Like): this;
-    cartographicToCartesian(coordCarto: Coordinates, target?: THREE.Vector3): THREE.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: THREE.Vector3Like, target?: Coordinates): Coordinates;
-    cartographicToCartesianArray(coordCartoArray: Coordinates[]): THREE.Vector3[];
-    intersection(ray: THREE.Ray): THREE.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/Extent.d.ts

@@ -1,246 +0,0 @@
-import * as THREE from 'three';
-import Coordinates from './Coordinates';
-import type { ProjectionAlias } 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 ProjectionAlias}).
-     */
-    crs: ProjectionAlias;
-    /**
-     * 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 ProjectionAlias}).
-     * @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: ProjectionAlias, west?: number, east?: number, south?: number, north?: number);
-    /**
-     * Returns a new extent with the same bounds and crs as this one.
-     */
-    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.
-     */
-    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.
-     */
-    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
-     */
-    planarDimensions(target?: THREE.Vector2): THREE.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
-     */
-    geodeticDimensions(target?: THREE.Vector2): THREE.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
-     */
-    spatialEuclideanDimensions(target?: THREE.Vector2): THREE.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.
-     */
-    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.
-     */
-    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?: THREE.Vector4): THREE.Vector4;
-    /**
-     * Checks wheter this bounding box intersects with the given extent
-     * parameter.
-     * @param extent - the provided extent
-     */
-    intersectsExtent(extent: Extent): boolean;
-    static intersectsExtent(extentA: Extent, extentB: Extent): boolean;
-    /**
-     * Returns the intersection of this extent with another one.
-     * @param extent - extent to intersect
-     */
-    intersect(extent: 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.
-     */
-    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.
-     */
-    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
-     */
-    setFromExtent(extent: ExtentLike): this;
-    /**
-     * Copies the passed extent to this extent.
-     * @param extent - extent to copy.
-     */
-    copy(extent: Extent): this;
-    /**
-     * Union this extent with the input extent.
-     * @param extent - the extent to union.
-     */
-    union(extent: Extent): void;
-    /**
-     * 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
-     */
-    static fromBox3(crs: ProjectionAlias, box: THREE.Box3): Extent;
-    /**
-     * Return values of extent in string, separated by the separator input.
-     * @param sep - string separator
-     */
-    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?: THREE.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: THREE.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;

package/lib/Main.d.ts

@@ -1,6 +0,0 @@
-export { default as Extent } from './Extent';
-export { default as Coordinates } from './Coordinates';
-export * as CRS from './Crs';
-export { default as CoordStars } from './CoordStars';
-export * as OrientationUtils from './OrientationUtils';
-export { default as Ellipsoid, ellipsoidSizes } from './Ellipsoid';

package/lib/OrientationUtils.d.ts

@@ -1,105 +0,0 @@
-import { Quaternion } from 'three';
-import type { ProjectionDefinition } from 'proj4/dist/lib/defs';
-import Coordinates from './Coordinates';
-interface EulerAngles {
-    /** angle in degrees */
-    roll: number;
-    /** angle in degrees */
-    pitch: number;
-    /** angle in degrees */
-    heading: number;
-}
-interface PhotogrammetryAngles {
-    /** angle in degrees */
-    omega: number;
-    /** angle in degrees */
-    phi: number;
-    /** angle in degrees */
-    kappa: number;
-}
-type Attitude = Partial<EulerAngles> | Partial<PhotogrammetryAngles>;
-type QuaternionFunction = (coords: Coordinates, target?: Quaternion) => Quaternion;
-type ProjectionLike = ProjectionDefinition | string;
-type LCCProjection = {
-    long0: number;
-    lat0: number;
-};
-type TMercProjection = {
-    a: number;
-    b: number;
-    e?: number;
-    long0: number;
-};
-/**
- * The transform from the platform frame to the local East, North, Up (ENU)
- * frame is `RotationZ(heading).RotationX(pitch).RotationY(roll)`.
- *
- * @param roll - angle in degrees. Default is 0.
- * @param pitch - angle in degrees. Default is 0.
- * @param heading - angle in degrees. Default is 0
- * @param target - output Quaternion
- *
- * @returns The target quaternion
- */
-export declare function quaternionFromRollPitchHeading(roll?: number, pitch?: number, heading?: number, target?: Quaternion): Quaternion;
-/**
- * From
- * [DocMicMac](https://github.com/micmacIGN/Documentation/raw/master/DocMicMac.pdf),
- * the transform from the platform frame to the local East, North, Up (ENU)
- * frame is:
- *
- * ```
- * RotationX(omega).RotationY(phi).RotationZ(kappa).RotationX(PI)
- * Converts between the 2 conventions for the camera local frame:
- * RotationX(PI) <=> Quaternion(1,0,0,0)
- * X right, Y bottom, Z front : convention in photogrammetry and computer vision
- * X right, Y top,    Z back  : convention in webGL, threejs
- * ```
- *
- * @param omega - angle in degrees. Default is 0.
- * @param phi - angle in degrees. Default is 0.
- * @param kappa - angle in degrees. Default is 0.
- * @param target - output quaternion
- *
- * @returns The target quaternion
- */
-export declare function quaternionFromOmegaPhiKappa(omega?: number, phi?: number, kappa?: number, target?: Quaternion): Quaternion;
-/**
- * Sets the quaternion according to the rotation from the platform frame to the
- * local frame.
- *
- * @param attitude - either euler angles or photogrammetry angles
- * @param target - output Quaternion
- *
- * @returns The target quaternion
- */
-export declare function quaternionFromAttitude(attitude: Attitude, target?: Quaternion): Quaternion;
-export declare function quaternionFromEnuToGeocent(): QuaternionFunction;
-export declare function quaternionFromEnuToGeocent(coords: Coordinates, target?: Quaternion): Quaternion;
-export declare function quaternionFromGeocentToEnu(): QuaternionFunction;
-export declare function quaternionFromGeocentToEnu(coords: Coordinates, target?: Quaternion): Quaternion;
-export declare function quaternionFromLCCToEnu(proj: LCCProjection): QuaternionFunction;
-export declare function quaternionFromLCCToEnu(proj: LCCProjection, coords: Coordinates, target?: Quaternion): Quaternion;
-export declare function quaternionFromEnuToLCC(proj: LCCProjection): QuaternionFunction;
-export declare function quaternionFromEnuToLCC(proj: LCCProjection, coords: Coordinates, target?: Quaternion): Quaternion;
-export declare function quaternionFromTMercToEnu(proj: TMercProjection): QuaternionFunction;
-export declare function quaternionFromTMercToEnu(proj: TMercProjection, coords: Coordinates, target?: Quaternion): Quaternion;
-export declare function quaternionFromEnuToTMerc(proj: TMercProjection): QuaternionFunction;
-export declare function quaternionFromEnuToTMerc(proj: TMercProjection, coords: Coordinates, target?: Quaternion): Quaternion;
-export declare function quaternionFromLongLatToEnu(): QuaternionFunction;
-export declare function quaternionFromLongLatToEnu(coords: Coordinates, target?: Quaternion): Quaternion;
-export declare function quaternionFromEnuToLongLat(): QuaternionFunction;
-export declare function quaternionFromEnuToLongLat(coords: Coordinates, target?: Quaternion): Quaternion;
-export declare function quaternionUnimplemented(proj: {
-    projName?: string;
-}): QuaternionFunction;
-export declare function quaternionUnimplemented(proj: {
-    projName?: string;
-}, coords: Coordinates, target?: Quaternion): Quaternion;
-export declare function quaternionFromEnuToCRS(proj: ProjectionLike): QuaternionFunction;
-export declare function quaternionFromEnuToCRS(proj: ProjectionLike, coords: Coordinates, target?: Quaternion): Quaternion;
-export declare function quaternionFromCRSToEnu(proj: ProjectionLike): QuaternionFunction;
-export declare function quaternionFromCRSToEnu(proj: ProjectionLike, coords: Coordinates, target?: Quaternion): Quaternion;
-export declare function quaternionFromCRSToCRS(crsIn: ProjectionLike, crsOut: ProjectionLike): QuaternionFunction;
-export declare function quaternionFromCRSToCRS(crsIn: ProjectionLike, crsOut: ProjectionLike, coords: Coordinates, target?: Quaternion): Quaternion;
-export {};