12410088850

Committed 19 Dec 2024 09:40AM UTC coverage: 87.094% (+0.04%) from 87.055%

Build # 12410088850

Build Type

Pull #2437

github

Committed by

web-flow

Commit Message

Merge b622fc74c into 7d67ec41e

Pull Request Pull Request #2437: refactor: migrate Coordinates and Ellipsoid to typescript

Run Details

2785 of 3695 branches covered (75.37%)

Branch coverage included in aggregate %.

607 of 621 new or added lines in 4 files covered. (97.75%)

14 existing lines in 1 file now uncovered.

25119 of 28344 relevant lines covered (88.62%)

987.82 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.67

/src/Core/Geographic/Coordinates.ts

import * as THREE from 'three';
import proj4 from 'proj4';
import * as CRS from 'Core/Geographic/Crs';
import Ellipsoid from 'Core/Math/Ellipsoid';

import type { ProjectionLike } from './Crs';

const ellipsoid = new Ellipsoid();
const projectionCache: Record<string, Record<string, proj4.Converter>> = {};

const v0 = new THREE.Vector3();
const v1 = new THREE.Vector3();

let coord0: Coordinates;
let coord1: Coordinates;

export interface CoordinatesLike {
    readonly crs: string;
    readonly x: number;
    readonly y: number;
    readonly z: number;
}

function proj4cache(crsIn: string, crsOut: string): proj4.Converter {
    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`.
     */
    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: THREE.Vector3;
    private _normalNeedsUpdate: boolean;

    /**
     * @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 = 0, y: number = 0, z: number = 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 as any).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 as any);
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        } else if ((x as any).isVector3 || (x as any).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 as any);
        } 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: ProjectionLike): this {
        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(x: number = 0, y: number = 0, z: number = 0): this {
        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: number[], offset: number = 0): this {
        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: THREE.Vector3Like): this {
        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(): Coordinates {
        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: CoordinatesLike): this {
        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(target: THREE.Vector3 = new THREE.Vector3()): 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(array: number[] = [], offset: number = 0): ArrayLike<number> {
        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: Coordinates): number {
        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: Coordinates): number {
        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: Coordinates): number {
        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.Matrix4): this {
        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: ProjectionLike, target = new Coordinates(crs)): Coordinates {
        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;

1	import * as THREE from 'three';	1✔
2	import proj4 from 'proj4';	1✔
3	import * as CRS from 'Core/Geographic/Crs';	1✔
4	import Ellipsoid from 'Core/Math/Ellipsoid';	1✔
5		1✔
6	import type { ProjectionLike } from './Crs';	1✔
7		1✔
8	const ellipsoid = new Ellipsoid();	1✔
9	const projectionCache: Record<string, Record<string, proj4.Converter>> = {};	1✔
10		1✔
11	const v0 = new THREE.Vector3();	1✔
12	const v1 = new THREE.Vector3();	1✔
13		1✔
14	let coord0: Coordinates;	1✔
15	let coord1: Coordinates;	1✔
16		1✔
17	export interface CoordinatesLike {	1✔
18	readonly crs: string;	1✔
19	readonly x: number;	1✔
20	readonly y: number;	1✔
21	readonly z: number;	1✔
22	}	1✔
23		1✔
24	function proj4cache(crsIn: string, crsOut: string): proj4.Converter {	2,017✔
25	if (!projectionCache[crsIn]) {	2,017✔
26	projectionCache[crsIn] = {};	5✔
27	}	5✔
28		2,017✔
29	if (!projectionCache[crsIn][crsOut]) {	2,017✔
30	projectionCache[crsIn][crsOut] = proj4(crsIn, crsOut);	11✔
31	}	11✔
32		2,017✔
33	return projectionCache[crsIn][crsOut];	2,017✔
34	}	2,017✔
35		1✔
36	/**	1✔
37	* A class representing a geographic or geocentric coordinate.	1✔
38	*	1✔
39	* A coordinate is defined by a [CRS](http://inspire.ec.europa.eu/theme/rs)	1✔
40	* (Coordinate Reference System) and a 3-dimensional vector `(x, y, z)`.	1✔
41	* For geocentric projections, it is recommended to use the `latitude`,	1✔
42	* `longitude` and `altitude` aliases to refer to vector components.	1✔
43	*	1✔
44	* To change a value, prefer the use of the `set*` methods.	1✔
45	*	1✔
46	* By default, the `EPSG:4978` and `EPSG:4326` projections are supported. To use	1✔
47	* a different projection, it must have been declared previously with `proj4`.	1✔
48	* A comprehensive list of projections and their corresponding proj4 string can	1✔
49	* be found at [epsg.io](https://epsg.io/).	1✔
50	*	1✔
51	* @example Geocentric coordinates	1✔
52	* ```js	1✔
53	* new Coordinates('EPSG:4978', 20885167, 849862, 23385912);	1✔
54	* ```	1✔
55	*	1✔
56	* @example Geographic coordinates	1✔
57	* ```js	1✔
58	* new Coordinates('EPSG:4326', 2.33, 48.24, 24999549);	1✔
59	* ```	1✔
60	*	1✔
61	* @example Defining the EPSG:2154 projection with proj4	1✔
62	* ```js	1✔
63	* proj4.defs('EPSG:2154', `+proj=lcc +lat_0=46.5 +lon_0=3 +lat_1=49 +lat_2=44	1✔
64	* +x_0=700000 +y_0=6600000 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m	1✔
65	* +no_defs +type=crs`);	1✔
66	* ```	1✔
67	*/	1✔
68	class Coordinates {	1✔
69	/**	1✔
70	* Read-only flag to check if a given object is of type `Coordinates`.	1✔
71	*/	1✔
72	readonly isCoordinates: boolean;	1✔
73	/**	1✔
74	* A default or user-defined CRS (see {@link ProjectionLike}).	1✔
75	*/	1✔
76	crs: ProjectionLike;	1✔
77		1✔
78	/** The x value (or longitude) of this coordinate. */	1✔
79	x: number;	1✔
80	/** The y value (or latitude) of this coordinate. */	1✔
81	y: number;	1✔
82	/** The z value (or altitude) of this coordinate. */	1✔
83	z: number;	1✔
84		1✔
85	private _normal: THREE.Vector3;	1✔
86	private _normalNeedsUpdate: boolean;	1✔
87		1✔
88	/**	1✔
89	* @param crs - A default or user-defined CRS (see {@link ProjectionLike}).	1✔
90	* @param x - x or longitude value.	1✔
91	* @param y - y or latitude value.	1✔
92	* @param z - z or altitude value.	1✔
93	*/	1✔
94	constructor(crs: ProjectionLike, x: number = 0, y: number = 0, z: number = 0) {	1✔
95	this.isCoordinates = true;	1,154✔
96		1,154✔
97	CRS.isValid(crs);	1,154✔
98	this.crs = crs;	1,154✔
99		1,154✔
100	// Storing the coordinates as is, not in arrays, as it is	1,154✔
101	// slower (see https://jsbench.me/40jumfag6g/1)	1,154✔
102	this.x = 0;	1,154✔
103	this.y = 0;	1,154✔
104	this.z = 0;	1,154✔
105		1,154✔
106	// Normal	1,154✔
107	this._normal = new THREE.Vector3();	1,154✔
108		1,154✔
109	// eslint-disable-next-line @typescript-eslint/no-explicit-any	1,154✔
110	if ((x as any).length > 0) { // deepscan-disable-line	1,154!
NEW 111	console.warn(	×
NEW 112	'Deprecated Coordinates#constructor(string, number[]),',	×
NEW 113	'use `new Coordinates(string).setFromArray(number[])` instead.',	×
NEW 114	);	×
NEW 115	// eslint-disable-next-line @typescript-eslint/no-explicit-any	×
NEW 116	this.setFromArray(x as any);	×
NEW 117	// eslint-disable-next-line @typescript-eslint/no-explicit-any	×
118	} else if ((x as any).isVector3 \|\| (x as any).isCoordinates) {	1,154✔
119	console.warn(	4✔
120	'Deprecated Coordinates#constructor(string, Vector3),',	4✔
121	'use `new Coordinates(string).setFromVector3(Vector3)` instead.',	4✔
122	);	4✔
123	// eslint-disable-next-line @typescript-eslint/no-explicit-any	4✔
124	this.setFromVector3(x as any);	4✔
125	} else {	1,154✔
126	this.setFromValues(x, y, z);	1,150✔
127	}	1,150✔
128		1,154✔
129	this._normalNeedsUpdate = true;	1,154✔
130	}	1,154✔
131		1✔
132	/**	1✔
133	* Sets the Coordinate Reference System.	1✔
134	* @param crs - Coordinate Reference System (e.g. 'EPSG:4978')	1✔
135	*/	1✔
136	setCrs(crs: ProjectionLike): this {	1✔
137	CRS.isValid(crs);	20✔
138	this.crs = crs;	20✔
139	return this;	20✔
140	}	20✔
141		1✔
142	/**	1✔
143	* Sets the x, y and z components of this coordinate.	1✔
144	*	1✔
145	* @param x - x or longitude value.	1✔
146	* @param y - y or latitude value.	1✔
147	* @param z - z or altitude value.	1✔
148	*/	1✔
149	setFromValues(x: number = 0, y: number = 0, z: number = 0): this {	1!
150	this.x = x;	7,134✔
151	this.y = y;	7,134✔
152	this.z = z;	7,134✔
153		7,134✔
154	this._normalNeedsUpdate = true;	7,134✔
155	return this;	7,134✔
156	}	7,134✔
157		1✔
158	/**	1✔
159	* Sets the coordinates's {@link Coordinates#x \| x} component to	1✔
160	* `array[offset + 0]`, {@link Coordinates#y \| y} component to	1✔
161	* `array[offset + 1]` and {@link Coordinates#z \| z} component to	1✔
162	* `array[offset + 2]`.	1✔
163	*	1✔
164	* @param array - The source array.	1✔
165	* @param offset - Optional offset into the array. Default is 0.	1✔
166	*/	1✔
167	setFromArray(array: number[], offset: number = 0): this {	1✔
168	return this.setFromValues(	2,152✔
169	array[offset],	2,152✔
170	array[offset + 1],	2,152✔
171	array[offset + 2],	2,152✔
172	);	2,152✔
173	}	2,152✔
174		1✔
175	/**	1✔
176	* Sets the `(x, y, z)` vector of this coordinate from a 3-dimensional	1✔
177	* vector-like object. This object shall have both `x`, `y` and `z`	1✔
178	* properties.	1✔
179	*	1✔
180	* @param v - The source object.	1✔
181	*/	1✔
182	setFromVector3(v: THREE.Vector3Like): this {	1✔
183	return this.setFromValues(v.x, v.y, v.z);	1,657✔
184	}	1,657✔
185		1✔
186	/**	1✔
187	* Returns a new coordinate with the same `(x, y, z)` vector and crs as this	1✔
188	* one.	1✔
189	*/	1✔
190	clone(): Coordinates {	1✔
191	return new Coordinates(this.crs, this.x, this.y, this.z);	141✔
192	}	141✔
193		1✔
194	/**	1✔
195	* Copies the `(x, y, z)` vector components and crs of the passed coordinate	1✔
196	* to this coordinate.	1✔
197	*	1✔
198	* @param src - The source coordinate to copy from.	1✔
199	*/	1✔
200	copy(src: CoordinatesLike): this {	1✔
201	this.crs = src.crs;	1,321✔
202	return this.setFromVector3(src);	1,321✔
203	}	1,321✔
204		1✔
205	get longitude() {	1✔
206	return this.x;	118✔
207	}	118✔
208		1✔
209	get latitude() {	1✔
210	return this.y;	222✔
211	}	222✔
212		1✔
213	get altitude() {	1✔
214	return this.z;	9✔
215	}	9✔
216		1✔
217	set altitude(value) {	1✔
NEW 218	this.z = value;	×
NEW 219	}	×
220		1✔
221	/**	1✔
222	* The geodesic normal of the coordinate.	1✔
223	*/	1✔
224	get geodesicNormal() {	1✔
225	if (this._normalNeedsUpdate) {	1,146✔
226	this._normalNeedsUpdate = false;	1,117✔
227		1,117✔
228	if (CRS.is4326(this.crs)) {	1,117✔
229	ellipsoid.geodeticSurfaceNormalCartographic(this, this._normal);	73✔
230	} else if (this.crs == 'EPSG:4978') {	1,117✔
231	ellipsoid.geodeticSurfaceNormal(this, this._normal);	930✔
232	} else {	1,044✔
233	this._normal.set(0, 0, 1);	114✔
234	}	114✔
235	}	1,117✔
236		1,146✔
237	return this._normal;	1,146✔
238	}	1,146✔
239		1✔
240	/**	1✔
241	* Copies the `x`, `y` and `z` components into the provided `THREE.Vector3`.	1✔
242	*	1✔
243	* @param target - An object to store this vector to. If this is not	1✔
244	* specified, a new vector will be created.	1✔
245	*	1✔
246	* @returns A vector `(x, y, z)`, or copies x, y and z into the provided	1✔
247	* vector.	1✔
248	*/	1✔
249	toVector3(target: THREE.Vector3 = new THREE.Vector3()): THREE.Vector3 {	1✔
250	return target.copy(this);	2,162✔
251	}	2,162✔
252		1✔
253	/**	1✔
254	* Copies the `x`, `y` and `z` components into the provided array.	1✔
255	*	1✔
256	* @param array - An array to store this vector to. If this is not	1✔
257	* provided a new array will be created.	1✔
258	* @param offset - An optional offset into the array.	1✔
259	*	1✔
260	* @returns An array [x, y, z], or copies x, y and z into the provided	1✔
261	* array.	1✔
262	*/	1✔
263	toArray(array: number[] = [], offset: number = 0): ArrayLike<number> {	1✔
NEW 264	return THREE.Vector3.prototype.toArray.call(this, array, offset);	×
NEW 265	}	×
266		1✔
267	/**	1✔
268	* Computes the planar distance from this coordinates to `coord`.	1✔
269	* Planar distance is the straight-line euclidean distance calculated in	1✔
270	* a 2D cartesian coordinate system.	1✔
271	*/	1✔
272	planarDistanceTo(coord: Coordinates): number {	1✔
273	this.toVector3(v0).setZ(0);	2✔
274	coord.toVector3(v1).setZ(0);	2✔
275	return v0.distanceTo(v1);	2✔
276	}	2✔
277		1✔
278	/**	1✔
279	* Computes the geodetic distance from this coordinates to `coord`.	1✔
280	* Geodetic distance is calculated in an ellipsoid space as the shortest	1✔
281	* distance across the curved surface of the ellipsoid.	1✔
282	*/	1✔
283	geodeticDistanceTo(coord: Coordinates): number {	1✔
284	this.as('EPSG:4326', coord0);	4✔
285	coord.as('EPSG:4326', coord1);	4✔
286	return ellipsoid.geodesicDistance(coord0, coord1);	4✔
287	}	4✔
288		1✔
289	/**	1✔
290	* Computes the euclidean distance from this coordinates to `coord` in a	1✔
291	* WGS84 projection.	1✔
292	*	1✔
293	* @param coord - The coordinate	1✔
294	* @returns earth euclidean distance	1✔
295	*/	1✔
296	spatialEuclideanDistanceTo(coord: Coordinates): number {	1✔
297	this.as('EPSG:4978', coord0).toVector3(v0);	10✔
298	coord.as('EPSG:4978', coord1).toVector3(v1);	10✔
299	return v0.distanceTo(v1);	10✔
300	}	10✔
301		1✔
302	/**	1✔
303	* Multiplies this coordinate (with an implicit 1 in the 4th dimension)	1✔
304	* by `mat`, and divides by perspective.	1✔
305	*	1✔
306	* @param mat - The matrix.	1✔
307	*/	1✔
308	applyMatrix4(mat: THREE.Matrix4): this {	1✔
309	THREE.Vector3.prototype.applyMatrix4.call(this, mat);	495✔
310	return this;	495✔
311	}	495✔
312		1✔
313	/**	1✔
314	* Projects this coordinate to the specified	1✔
315	* [CRS](http://inspire.ec.europa.eu/theme/rs).	1✔
316	*	1✔
317	* @param crs - The target CRS to which the coordinate will be converted.	1✔
318	* @param target - The target to store the projected coordinate. If this not	1✔
319	* provided a new coordinate will be created.	1✔
320	*	1✔
321	* @returns The coordinate projected into the specified CRS.	1✔
322	*	1✔
323	* @example Conversion from a geographic to a geocentric reference system	1✔
324	* ```js	1✔
325	* const geographicCoords = new Coordinates('EPSG:4326',	1✔
326	* 2.33, // longitude	1✔
327	* 48.24, // latitude	1✔
328	* 24999549, // altitude	1✔
329	* );	1✔
330	* const geocentricCoords = geographicCoords.as('EPSG:4978');	1✔
331	* ```	1✔
332	*	1✔
333	* @example Conversion from a geocentric to a geographic reference system	1✔
334	* ```js	1✔
335	* const geocentricCoords = new Coordinates('EPSG:4978',	1✔
336	* 20885167, // x	1✔
337	* 849862, // y	1✔
338	* 23385912, // z	1✔
339	* );	1✔
340	* const geographicCoords = geocentricCoords.as('EPSG:4326');	1✔
341	* ```	1✔
342	*/	1✔
343	as(crs: ProjectionLike, target = new Coordinates(crs)): Coordinates {	1✔
344	if (this.crs == crs) {	2,579✔
345	target.copy(this);	562✔
346	} else {	2,579✔
347	if (CRS.is4326(this.crs) && crs == 'EPSG:3857') {	2,017✔
348	this.y = THREE.MathUtils.clamp(this.y, -89.999999, 89.999999);	482✔
349	}	482✔
350		2,017✔
351	target.setFromArray(proj4cache(this.crs, crs)	2,017✔
352	.forward([this.x, this.y, this.z]));	2,017✔
353	}	2,017✔
354		2,579✔
355	target.crs = crs;	2,579✔
356		2,579✔
357	return target;	2,579✔
358	}	2,579✔
359	}	1✔
360		1✔
361	coord0 = new Coordinates('EPSG:4326', 0, 0, 0);	1✔
362	coord1 = new Coordinates('EPSG:4326', 0, 0, 0);	1✔
363		1✔
364	export default Coordinates;	1✔

iTowns / itowns / 12410088850

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous