@itowns/geographic 2.46.1-next.44 → 2.46.1-next.46

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/Coordinates.d.ts

@@ -0,0 +1,196 @@
+import { Vector3, type Vector3Like, type Matrix4 } 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: 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(): 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?: Vector3): 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: 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/Crs.d.ts

@@ -0,0 +1,108 @@
+import type { Converter } from 'proj4';
+import type { ProjectionDefinition } from 'proj4/dist/lib/defs';
+/**
+ * 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 ProjectionLike = string;
+export declare function transform(crsIn: ProjectionLike, crsOut: ProjectionLike): Converter;
+/**
+ * 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: ProjectionLike): 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: ProjectionLike): 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: ProjectionLike): 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: ProjectionLike): 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: ProjectionLike): 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: ProjectionLike): 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: ProjectionLike): 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: ProjectionLike): string | undefined;
+/**
+ * Defines a proj4 projection as a named alias.
+ * This function is an alias for the
+ * [`proj4.defs`](https://github.com/proj4js/proj4js#named-projections) function.
+ */
+export declare const defs: typeof import("proj4/dist/lib/defs").default;
+/**
+ * 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.
+ *
+ * @example
+ * // Register EPSG:2154 (RGF93 / Lambert-93)
+ * await CRS.fromEPSG('EPSG:2154');
+ *
+ * // Register EPSG:4269 (NAD83)
+ * await CRS.fromEPSG('EPSG:4269');
+ */
+export declare function fromEPSG(crs: string): Promise<ProjectionDefinition>;
+export declare function defsFromWkt(wkt: string): string;

package/lib/Ellipsoid.d.ts

@@ -0,0 +1,74 @@
+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.
+     */
+    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.
+     */
+    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.
+     */
+    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/Extent.d.ts

@@ -0,0 +1,246 @@
+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.
+     */
+    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?: 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
+     */
+    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
+     */
+    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.
+     */
+    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?: Vector4): 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: ProjectionLike, box: 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?: 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;

package/lib/OrientationUtils.d.ts

@@ -0,0 +1,105 @@
+import { Quaternion } from 'three';
+import { type ProjectionDefinition } from 'proj4';
+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: string, crsOut: string): QuaternionFunction;
+export declare function quaternionFromCRSToCRS(crsIn: string, crsOut: string, coords: Coordinates, target?: Quaternion): Quaternion;
+export {};

package/lib/index.d.ts

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

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@itowns/geographic",
-  "version": "2.46.1-next.44",
+  "version": "2.46.1-next.46",
   "description": "Proj4-based three.js geodesy toolkit",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
-    "types": "./src/index.ts",
+    "types": "./lib/index.d.ts",
     "default": "./lib/index.js"
   },
-  "types": "./src/index.ts",
+  "types": "./lib/index.d.ts",
   "scripts": {
     "build": "",
     "lint": "eslint \"src/**/*.{js,ts,tsx}\" \"test/**/*.js\"",