11295619330

Committed 11 Oct 2024 04:06PM UTC coverage: 86.935% (-0.001%) from 86.936%

Build # 11295619330

Build Type

Pull #2436

github

Committed by

web-flow

Commit Message

Merge b6e923f75 into cfb9d0f51

Pull Request Pull Request #2436: refacto: migrate Crs to typescript

Run Details

2804 of 3720 branches covered (75.38%)

Branch coverage included in aggregate %.

182 of 187 new or added lines in 20 files covered. (97.33%)

69 existing lines in 11 files now uncovered.

24377 of 27546 relevant lines covered (88.5%)

1022.7 hits per line

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

93.98

/src/Core/Geographic/Extent.js

import * as THREE from 'three';
import Coordinates from './Coordinates';
import CRS from './Crs';

/**
 * Extent is a SIG-area (so 2D)
 * It can use explicit coordinates (e.g: lon/lat) or implicit (WMTS coordinates)
 */

const _dim = new THREE.Vector2();
const _dim2 = new THREE.Vector2();
const _box = new THREE.Box3();
const defaultScheme = new THREE.Vector2(2, 2);

const cNorthWest =  new Coordinates('EPSG:4326', 0, 0, 0);
const cSouthWest =  new Coordinates('EPSG:4326', 0, 0, 0);
const cNorthEast =  new Coordinates('EPSG:4326', 0, 0, 0);

const southWest = new THREE.Vector3();
const northEast = new THREE.Vector3();

/** @type {Extent} */
let _extent;

const cardinals = new Array(8);
for (let i = cardinals.length - 1; i >= 0; i--) {
    cardinals[i] = new Coordinates('EPSG:4326', 0, 0, 0);
}

const _c = new Coordinates('EPSG:4326', 0, 0);

class Extent {
    /**
     * Extent is geographical bounding rectangle defined by 4 limits: west, east, south and north.
     *
     * Warning, using geocentric projection isn't consistent with geographical extent.
     *
     * @param {String} crs projection of limit values.
     * @param {number|Array.<number>|Coordinates|Object} v0 west value, Array
     * of values [west, east, south and north], Coordinates of west-south
     * corner or object {west, east, south and north}
     * @param {number|Coordinates} [v1] east value or Coordinates of
     * east-north corner
     * @param {number} [v2] south value
     * @param {number} [v3] north value
     */
    constructor(crs, v0, v1, v2, v3) {
        if (CRS.isGeocentric(crs)) {
            throw new Error(`${crs} is a geocentric projection, it doesn't make sense with a geographical extent`);
        }

        if (CRS.isTms(crs)) {
            throw new Error(`${crs} is a tiled projection, use Tile instead`);
        }

        this.isExtent = true;
        this.crs = crs;

        this.west = 0;
        this.east = 0;
        this.south = 0;
        this.north = 0;

        this.set(v0, v1, v2, v3);
    }

    /**
     * Clone this extent
     * @return {Extent} cloned extent
     */
    clone() {
        return new Extent(this.crs, this.west, this.east, this.south, this.north);
    }

    /**
     * Convert Extent to the specified projection.
     * @param {string} crs the projection of destination.
     * @param {Extent} [target] copy the destination to target.
     * @return {Extent}
     */
    as(crs, target) {
        CRS.isValid(crs);
        target = target || new Extent('EPSG:4326', [0, 0, 0, 0]);
        if (this.crs != crs) {
            // Compute min/max in x/y by projecting 8 cardinal points,
            // and then taking the min/max of each coordinates.
            const center = this.center(_c);
            cardinals[0].setFromValues(this.west, this.north);
            cardinals[1].setFromValues(center.x, this.north);
            cardinals[2].setFromValues(this.east, this.north);
            cardinals[3].setFromValues(this.east, center.y);
            cardinals[4].setFromValues(this.east, this.south);
            cardinals[5].setFromValues(center.x, this.south);
            cardinals[6].setFromValues(this.west, this.south);
            cardinals[7].setFromValues(this.west, center.y);

            target.set(Infinity, -Infinity, Infinity, -Infinity);

            // loop over the coordinates
            for (let i = 0; i < cardinals.length; i++) {
                // convert the coordinate.
                cardinals[i].crs = this.crs;
                cardinals[i].as(crs, _c);
                target.north = Math.max(target.north, _c.y);
                target.south = Math.min(target.south, _c.y);
                target.east = Math.max(target.east, _c.x);
                target.west = Math.min(target.west, _c.x);
            }

            target.crs = crs;
            return target;
        }

        target.crs = crs;
        target.set(this.west, this.east, this.south, this.north);

        return target;
    }

    /**
     * Return the center of Extent
     * @param {Coordinates} target copy the center to the target.
     * @return {Coordinates}
     */
    center(target = new Coordinates(this.crs)) {
        this.planarDimensions(_dim);

        target.crs = this.crs;
        target.setFromValues(this.west + _dim.x * 0.5, this.south + _dim.y * 0.5);

        return target;
    }

    /**
    * Returns the dimension of the extent, in a `THREE.Vector2`.
    *
    * @param {THREE.Vector2} [target] - The target to assign the result in.
    *
    * @return {THREE.Vector2}
    */
    dimensions(target = new THREE.Vector2()) {
        console.warn('Extent.dimensions is deprecated, use planarDimensions, geodeticDimensions or spatialEuclideanDimensions');
        target.x = Math.abs(this.east - this.west);
        target.y = Math.abs(this.north - this.south);
        return target;
    }

    /**
     *  Planar dimensions are two planar distances west/east and south/north.
     *  Planar distance straight-line Euclidean distance calculated in a 2D Cartesian coordinate system.
     *
     * @param      {THREE.Vector2}  [target=new THREE.Vector2()]  The target
     * @return     {THREE.Vector2}  Planar dimensions
     */
    planarDimensions(target = new THREE.Vector2()) {
        // Calculte the dimensions for x and y
        return target.set(Math.abs(this.east - this.west), Math.abs(this.north - this.south));
    }

    /**
     *  Geodetic dimensions are two planar distances west/east and south/north.
     *  Geodetic distance is calculated in an ellispoid space as the distance
     *  across the curved surface of the world.
     *
     * @param      {THREE.Vector2}  [target=new THREE.Vector2()]  The target
     * @return     {THREE.Vector2}  geodetic dimensions
     */
    geodeticDimensions(target = new THREE.Vector2()) {
        // set 3 corners extent
        cNorthWest.crs = this.crs;
        cSouthWest.crs = this.crs;
        cNorthEast.crs = this.crs;

        cNorthWest.setFromValues(this.west, this.north, 0);
        cSouthWest.setFromValues(this.west, this.south, 0);
        cNorthEast.setFromValues(this.east, this.north, 0);

        // calcul geodetic distance northWest/northEast and northWest/southWest
        return target.set(cNorthWest.geodeticDistanceTo(cNorthEast), cNorthWest.geodeticDistanceTo(cSouthWest));
    }

    /**
     *  Spatial euclidean dimensions are two spatial euclidean distances between west/east corner and south/north corner.
     *  Spatial euclidean distance chord is calculated in a ellispoid space.
     *
     * @param      {THREE.Vector2}  [target=new THREE.Vector2()]  The target
     * @return     {THREE.Vector2}  spatial euclidean dimensions
     */
    spatialEuclideanDimensions(target = new THREE.Vector2()) {
        // set 3 corners extent
        cNorthWest.crs = this.crs;
        cSouthWest.crs = this.crs;
        cNorthEast.crs = this.crs;

        cNorthWest.setFromValues(this.west, this.north, 0);
        cSouthWest.setFromValues(this.west, this.south, 0);
        cNorthEast.setFromValues(this.east, this.north, 0);

        // calcul chord distance northWest/northEast and northWest/southWest
        return target.set(cNorthWest.spatialEuclideanDistanceTo(cNorthEast), cNorthWest.spatialEuclideanDistanceTo(cSouthWest));
    }

    /**
     * Return true if `coord` is inside the bounding box.
     *
     * @param {Coordinates} coord
     * @param {number} [epsilon=0] - to take into account when comparing to the
     * point.
     *
     * @return {boolean}
     */
    isPointInside(coord, epsilon = 0) {
        if (this.crs == coord.crs) {
            _c.copy(coord);
        } else {
            coord.as(this.crs, _c);
        }

        // TODO this ignores altitude
        return _c.x <= this.east + epsilon &&
               _c.x >= this.west - epsilon &&
               _c.y <= this.north + epsilon &&
               _c.y >= this.south - epsilon;
    }

    /**
     * Return true if `extent` is inside this extent.
     *
     * @param {Extent} extent the extent to check
     * @param {number} epsilon to take into account when comparing to the
     * point.
     *
     * @return {boolean}
     */
    isInside(extent, epsilon) {
        extent.as(this.crs, _extent);
        epsilon = epsilon == undefined ? CRS.reasonnableEpsilon(this.crs) : epsilon;
        return this.east - _extent.east <= epsilon &&
                _extent.west - this.west <= epsilon &&
                this.north - _extent.north <= epsilon &&
                _extent.south - this.south <= epsilon;
    }

    /**
     * Return the translation and scale to transform this extent to input extent.
     *
     * @param {Extent} extent input extent
     * @param {THREE.Vector4} target copy the result to target.
     * @return {THREE.Vector4} {x: translation on west-east, y: translation on south-north, z: scale on west-east, w: scale on south-north}
     */
    offsetToParent(extent, target = new THREE.Vector4()) {
        if (this.crs != extent.crs) {
            throw new Error('unsupported mix');
        }

        extent.planarDimensions(_dim);
        this.planarDimensions(_dim2);

        const originX = (this.west - extent.west) / _dim.x;
        const originY = (extent.north - this.north) / _dim.y;

        const scaleX = _dim2.x / _dim.x;
        const scaleY = _dim2.y / _dim.y;

        return target.set(originX, originY, scaleX, scaleY);
    }

    /**
     * Return true if this bounding box intersect with the bouding box parameter
     * @param {Extent} extent
     * @returns {Boolean}
     */
    intersectsExtent(extent) {
        return Extent.intersectsExtent(this, extent);
    }

    static intersectsExtent(/** @type {Extent} */extentA, /** @type {Extent} */ extentB) {
        // TODO don't work when is on limit
        const other = extentB.crs == extentA.crs ? extentB : extentB.as(extentA.crs, _extent);
        return !(extentA.west >= other.east ||
            extentA.east <= other.west ||
            extentA.south >= other.north ||
            extentA.north <= other.south);
    }

    /**
     * Return the intersection of this extent with another one
     * @param {Extent} extent
     * @returns {Extent}
     */
    intersect(extent) {
        if (!this.intersectsExtent(extent)) {
            return new Extent(this.crs, 0, 0, 0, 0);
        }
        if (extent.crs != this.crs) {
            extent = extent.as(this.crs, _extent);
        }
        return new Extent(this.crs,
            Math.max(this.west, extent.west),
            Math.min(this.east, extent.east),
            Math.max(this.south, extent.south),
            Math.min(this.north, extent.north));
    }

    /**
     * Set west, east, south and north values.
     *
     * @param {number|Array.<number>|Coordinates|Object|Extent} v0 west value,
     * Array of values [west, east, south and north], Extent of same type (tiled
     * or not), Coordinates of west-south corner or object {west, east, south
     * and north}
     * @param {number|Coordinates} [v1] east value, row value or Coordinates of
     * east-north corner
     * @param {number} [v2] south value or column value
     * @param {number} [v3] north value
     *
     * @return {Extent}
     */
    set(v0, v1, v2, v3) {
        if (v0 == undefined) {
            throw new Error('No values to set in the extent');
        }
        if (v0.isExtent) {
            v1 = v0.east;
            v2 = v0.south;
            v3 = v0.north;
            v0 = v0.west;
        }

        if (v0.isCoordinates) {
            // seem never used
            this.west = v0.x;
            this.east = v1.x;
            this.south = v0.y;
            this.north = v1.y;
        } else if (v0.west !== undefined) {
            this.west = v0.west;
            this.east = v0.east;
            this.south = v0.south;
            this.north = v0.north;
        } else if (v0.length == 4) {
            this.west = v0[0];
            this.east = v0[1];
            this.south = v0[2];
            this.north = v0[3];
        } else if (v3 !== undefined) {
            this.west = v0;
            this.east = v1;
            this.south = v2;
            this.north = v3;
        }

        return this;
    }

    /**
     * Copy to this extent to input extent.
     * @param {Extent} extent
     * @return {Extent} copied extent
     */
    copy(extent) {
        this.crs = extent.crs;
        return this.set(extent);
    }

    /**
     * Union this extent with the input extent.
     * @param {Extent} extent the extent to union.
     */
    union(extent) {
        if (extent.crs != this.crs) {
            throw new Error('unsupported union between 2 diff crs');
        }
        if (this.west === Infinity) {
            this.copy(extent);
        } else {
            const west = extent.west;
            if (west < this.west) {
                this.west = west;
            }

            const east = extent.east;
            if (east > this.east) {
                this.east = east;
            }

            const south = extent.south;
            if (south < this.south) {
                this.south = south;
            }

            const north = extent.north;
            if (north > this.north) {
                this.north = north;
            }
        }
    }

    /**
     * expandByCoordinates perfoms the minimal extension
     * for the coordinates to belong to this Extent object
     * @param {Coordinates} coordinates  The coordinates to belong
     */
    expandByCoordinates(coordinates) {
        const coords = coordinates.crs == this.crs ? coordinates : coordinates.as(this.crs, _c);
        this.expandByValuesCoordinates(coords.x, coords.y);
    }

    /**
    * expandByValuesCoordinates perfoms the minimal extension
    * for the coordinates values to belong to this Extent object
    * @param {number} we  The coordinate on west-east
    * @param {number} sn  The coordinate on south-north
    *
    */
    expandByValuesCoordinates(we, sn) {
        if (we < this.west) {
            this.west = we;
        }
        if (we > this.east) {
            this.east = we;
        }
        if (sn < this.south) {
            this.south = sn;
        }
        if (sn > this.north) {
            this.north = sn;
        }
    }

    /**
     * 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 {string} crs Projection of extent to instancied.
     * @param {THREE.Box3} box
     * @return {Extent}
     */
    static fromBox3(crs, box) {
        if (CRS.isGeocentric(crs)) {
            // if geocentric reproject box on 'EPSG:4326'
            crs = 'EPSG:4326';
            box = _box.copy(box);

            cSouthWest.crs = crs;
            cSouthWest.setFromVector3(box.min).as(crs, cSouthWest).toVector3(box.min);
            cNorthEast.crs = crs;
            cNorthEast.setFromVector3(box.max).as(crs, cNorthEast).toVector3(box.max);
        }

        return new Extent(crs, {
            west: box.min.x,
            east: box.max.x,
            south: box.min.y,
            north: box.max.y,
        });
    }

    /**
     * Return values of extent in string, separated by the separator input.
     * @param {string} separator
     * @return {string}
     */
    toString(separator = '') {
        return `${this.east}${separator}${this.north}${separator}${this.west}${separator}${this.south}`;
    }

    /**
     * Subdivide equally an extent from its center to return four extents:
     * north-west, north-east, south-west and south-east.
     *
     * @returns {Extent[]} An array containing the four sections of the extent. The
     * order of the sections is [NW, NE, SW, SE].
     */
    subdivision() {
        return this.subdivisionByScheme();
    }
    /**
     * subdivise extent by scheme.x on west-east and scheme.y on south-north.
     *
     * @param      {THREE.Vector2}  [scheme=Vector2(2,2)]  The scheme to subdivise.
     * @return     {Array<Extent>}   subdivised extents.
     */
    subdivisionByScheme(scheme = defaultScheme) {
        const subdivisedExtents = [];
        const dimSub = this.planarDimensions(_dim).divide(scheme);
        for (let x = scheme.x - 1; x >= 0; x--) {
            for (let y = scheme.y - 1; y >= 0; y--) {
                const west = this.west + x * dimSub.x;
                const south = this.south + y * dimSub.y;
                subdivisedExtents.push(new Extent(this.crs,
                    west,
                    west + dimSub.x,
                    south,
                    south + dimSub.y));
            }
        }
        return subdivisedExtents;
    }

    /**
     * Multiplies all extent `coordinates` (with an implicit 1 in the 4th dimension) and `matrix`.
     *
     * @param      {THREE.Matrix4}  matrix  The matrix
     * @return     {Extent}  return this extent instance.
     */
    applyMatrix4(matrix) {
        southWest.set(this.west, this.south, 0).applyMatrix4(matrix);
        northEast.set(this.east, this.north, 0).applyMatrix4(matrix);
        this.west = southWest.x;
        this.east = northEast.x;
        this.south = southWest.y;
        this.north = northEast.y;
        if (this.west > this.east) {
            const temp = this.west;
            this.west = this.east;
            this.east = temp;
        }
        if (this.south > this.north) {
            const temp = this.south;
            this.south = this.north;
            this.north = temp;
        }
        return this;
    }

    /**
     * clamp south and north values
     *
     * @param      {number}  [south=this.south]  The min south
     * @param      {number}  [north=this.north]  The max north
     * @return     {Extent}  this extent
     */
    clampSouthNorth(south = this.south, north = this.north) {
        this.south = Math.max(this.south, south);
        this.north = Math.min(this.north, north);
        return this;
    }

    /**
     * clamp west and east values
     *
     * @param      {number}  [west=this.west]  The min west
     * @param      {number}  [east=this.east]  The max east
     * @return     {Extent}  this extent
     */
    clampWestEast(west = this.west, east = this.east) {
        this.west = Math.max(this.west, west);
        this.east = Math.min(this.east, east);
        return this;
    }
    /**
     * clamp this extent by passed extent
     *
     * @param      {Extent}  extent  The maximum extent.
     * @return     {Extent}  this extent.
     */
    clampByExtent(extent) {
        this.clampSouthNorth(extent.south, extent.north);
        return this.clampWestEast(extent.west, extent.east);
    }
}

_extent = new Extent('EPSG:4326', [0, 0, 0, 0]);

export default Extent;

1	import * as THREE from 'three';	1✔
2	import Coordinates from './Coordinates';	1✔
3	import CRS from './Crs';	1✔
4		1✔
5	/**	1✔
6	* Extent is a SIG-area (so 2D)	1✔
7	* It can use explicit coordinates (e.g: lon/lat) or implicit (WMTS coordinates)	1✔
8	*/	1✔
9		1✔
10	const _dim = new THREE.Vector2();	1✔
11	const _dim2 = new THREE.Vector2();	1✔
12	const _box = new THREE.Box3();	1✔
13	const defaultScheme = new THREE.Vector2(2, 2);	1✔
14		1✔
15	const cNorthWest = new Coordinates('EPSG:4326', 0, 0, 0);	1✔
16	const cSouthWest = new Coordinates('EPSG:4326', 0, 0, 0);	1✔
17	const cNorthEast = new Coordinates('EPSG:4326', 0, 0, 0);	1✔
18		1✔
19	const southWest = new THREE.Vector3();	1✔
20	const northEast = new THREE.Vector3();	1✔
21		1✔
22	/** @type {Extent} */	1✔
23	let _extent;	1✔
24		1✔
25	const cardinals = new Array(8);	1✔
26	for (let i = cardinals.length - 1; i >= 0; i--) {	1✔
27	cardinals[i] = new Coordinates('EPSG:4326', 0, 0, 0);	8✔
28	}	8✔
29		1✔
30	const _c = new Coordinates('EPSG:4326', 0, 0);	1✔
31		1✔
32	class Extent {	1✔
33	/**	1✔
34	* Extent is geographical bounding rectangle defined by 4 limits: west, east, south and north.	1✔
35	*	1✔
36	* Warning, using geocentric projection isn't consistent with geographical extent.	1✔
37	*	1✔
38	* @param {String} crs projection of limit values.	1✔
39	* @param {number\|Array.<number>\|Coordinates\|Object} v0 west value, Array	1✔
40	* of values [west, east, south and north], Coordinates of west-south	1✔
41	* corner or object {west, east, south and north}	1✔
42	* @param {number\|Coordinates} [v1] east value or Coordinates of	1✔
43	* east-north corner	1✔
44	* @param {number} [v2] south value	1✔
45	* @param {number} [v3] north value	1✔
46	*/	1✔
47	constructor(crs, v0, v1, v2, v3) {	1✔
48	if (CRS.isGeocentric(crs)) {	601✔
49	throw new Error(`${crs} is a geocentric projection, it doesn't make sense with a geographical extent`);	1✔
50	}	1✔
51		600✔
52	if (CRS.isTms(crs)) {	601!
53	throw new Error(`${crs} is a tiled projection, use Tile instead`);	×
UNCOV 54	}	✔
55		600✔
56	this.isExtent = true;	600✔
57	this.crs = crs;	600✔
58		600✔
59	this.west = 0;	600✔
60	this.east = 0;	600✔
61	this.south = 0;	600✔
62	this.north = 0;	600✔
63		600✔
64	this.set(v0, v1, v2, v3);	600✔
65	}	600✔
66		1✔
67	/**	1✔
68	* Clone this extent	1✔
69	* @return {Extent} cloned extent	1✔
70	*/	1✔
71	clone() {	1✔
72	return new Extent(this.crs, this.west, this.east, this.south, this.north);	37✔
73	}	37✔
74		1✔
75	/**	1✔
76	* Convert Extent to the specified projection.	1✔
77	* @param {string} crs the projection of destination.	1✔
78	* @param {Extent} [target] copy the destination to target.	1✔
79	* @return {Extent}	1✔
80	*/	1✔
81	as(crs, target) {	1✔
82	CRS.isValid(crs);	77✔
83	target = target \|\| new Extent('EPSG:4326', [0, 0, 0, 0]);	77✔
84	if (this.crs != crs) {	77✔
85	// Compute min/max in x/y by projecting 8 cardinal points,	63✔
86	// and then taking the min/max of each coordinates.	63✔
87	const center = this.center(_c);	63✔
88	cardinals[0].setFromValues(this.west, this.north);	63✔
89	cardinals[1].setFromValues(center.x, this.north);	63✔
90	cardinals[2].setFromValues(this.east, this.north);	63✔
91	cardinals[3].setFromValues(this.east, center.y);	63✔
92	cardinals[4].setFromValues(this.east, this.south);	63✔
93	cardinals[5].setFromValues(center.x, this.south);	63✔
94	cardinals[6].setFromValues(this.west, this.south);	63✔
95	cardinals[7].setFromValues(this.west, center.y);	63✔
96		63✔
97	target.set(Infinity, -Infinity, Infinity, -Infinity);	63✔
98		63✔
99	// loop over the coordinates	63✔
100	for (let i = 0; i < cardinals.length; i++) {	63✔
101	// convert the coordinate.	504✔
102	cardinals[i].crs = this.crs;	504✔
103	cardinals[i].as(crs, _c);	504✔
104	target.north = Math.max(target.north, _c.y);	504✔
105	target.south = Math.min(target.south, _c.y);	504✔
106	target.east = Math.max(target.east, _c.x);	504✔
107	target.west = Math.min(target.west, _c.x);	504✔
108	}	504✔
109		63✔
110	target.crs = crs;	63✔
111	return target;	63✔
112	}	63✔
113		14✔
114	target.crs = crs;	14✔
115	target.set(this.west, this.east, this.south, this.north);	14✔
116		14✔
117	return target;	14✔
118	}	14✔
119		1✔
120	/**	1✔
121	* Return the center of Extent	1✔
122	* @param {Coordinates} target copy the center to the target.	1✔
123	* @return {Coordinates}	1✔
124	*/	1✔
125	center(target = new Coordinates(this.crs)) {	1✔
126	this.planarDimensions(_dim);	444✔
127		444✔
128	target.crs = this.crs;	444✔
129	target.setFromValues(this.west + _dim.x * 0.5, this.south + _dim.y * 0.5);	444✔
130		444✔
131	return target;	444✔
132	}	444✔
133		1✔
134	/**	1✔
135	* Returns the dimension of the extent, in a `THREE.Vector2`.	1✔
136	*	1✔
137	* @param {THREE.Vector2} [target] - The target to assign the result in.	1✔
138	*	1✔
139	* @return {THREE.Vector2}	1✔
140	*/	1✔
141	dimensions(target = new THREE.Vector2()) {	1!
142	console.warn('Extent.dimensions is deprecated, use planarDimensions, geodeticDimensions or spatialEuclideanDimensions');	1✔
143	target.x = Math.abs(this.east - this.west);	1✔
144	target.y = Math.abs(this.north - this.south);	1✔
145	return target;	1✔
146	}	1✔
147		1✔
148	/**	1✔
149	* Planar dimensions are two planar distances west/east and south/north.	1✔
150	* Planar distance straight-line Euclidean distance calculated in a 2D Cartesian coordinate system.	1✔
151	*	1✔
152	* @param {THREE.Vector2} [target=new THREE.Vector2()] The target	1✔
153	* @return {THREE.Vector2} Planar dimensions	1✔
154	*/	1✔
155	planarDimensions(target = new THREE.Vector2()) {	1✔
156	// Calculte the dimensions for x and y	899✔
157	return target.set(Math.abs(this.east - this.west), Math.abs(this.north - this.south));	899✔
158	}	899✔
159		1✔
160	/**	1✔
161	* Geodetic dimensions are two planar distances west/east and south/north.	1✔
162	* Geodetic distance is calculated in an ellispoid space as the distance	1✔
163	* across the curved surface of the world.	1✔
164	*	1✔
165	* @param {THREE.Vector2} [target=new THREE.Vector2()] The target	1✔
166	* @return {THREE.Vector2} geodetic dimensions	1✔
167	*/	1✔
168	geodeticDimensions(target = new THREE.Vector2()) {	1!
169	// set 3 corners extent	1✔
170	cNorthWest.crs = this.crs;	1✔
171	cSouthWest.crs = this.crs;	1✔
172	cNorthEast.crs = this.crs;	1✔
173		1✔
174	cNorthWest.setFromValues(this.west, this.north, 0);	1✔
175	cSouthWest.setFromValues(this.west, this.south, 0);	1✔
176	cNorthEast.setFromValues(this.east, this.north, 0);	1✔
177		1✔
178	// calcul geodetic distance northWest/northEast and northWest/southWest	1✔
179	return target.set(cNorthWest.geodeticDistanceTo(cNorthEast), cNorthWest.geodeticDistanceTo(cSouthWest));	1✔
180	}	1✔
181		1✔
182	/**	1✔
183	* Spatial euclidean dimensions are two spatial euclidean distances between west/east corner and south/north corner.	1✔
184	* Spatial euclidean distance chord is calculated in a ellispoid space.	1✔
185	*	1✔
186	* @param {THREE.Vector2} [target=new THREE.Vector2()] The target	1✔
187	* @return {THREE.Vector2} spatial euclidean dimensions	1✔
188	*/	1✔
189	spatialEuclideanDimensions(target = new THREE.Vector2()) {	1!
190	// set 3 corners extent	4✔
191	cNorthWest.crs = this.crs;	4✔
192	cSouthWest.crs = this.crs;	4✔
193	cNorthEast.crs = this.crs;	4✔
194		4✔
195	cNorthWest.setFromValues(this.west, this.north, 0);	4✔
196	cSouthWest.setFromValues(this.west, this.south, 0);	4✔
197	cNorthEast.setFromValues(this.east, this.north, 0);	4✔
198		4✔
199	// calcul chord distance northWest/northEast and northWest/southWest	4✔
200	return target.set(cNorthWest.spatialEuclideanDistanceTo(cNorthEast), cNorthWest.spatialEuclideanDistanceTo(cSouthWest));	4✔
201	}	4✔
202		1✔
203	/**	1✔
204	* Return true if `coord` is inside the bounding box.	1✔
205	*	1✔
206	* @param {Coordinates} coord	1✔
207	* @param {number} [epsilon=0] - to take into account when comparing to the	1✔
208	* point.	1✔
209	*	1✔
210	* @return {boolean}	1✔
211	*/	1✔
212	isPointInside(coord, epsilon = 0) {	1✔
213	if (this.crs == coord.crs) {	262✔
214	_c.copy(coord);	262✔
215	} else {	262!
UNCOV 216	coord.as(this.crs, _c);	×
UNCOV 217	}	×
218		262✔
219	// TODO this ignores altitude	262✔
220	return _c.x <= this.east + epsilon &&	262✔
221	_c.x >= this.west - epsilon &&	262✔
222	_c.y <= this.north + epsilon &&	262✔
223	_c.y >= this.south - epsilon;	262✔
224	}	262✔
225		1✔
226	/**	1✔
227	* Return true if `extent` is inside this extent.	1✔
228	*	1✔
229	* @param {Extent} extent the extent to check	1✔
230	* @param {number} epsilon to take into account when comparing to the	1✔
231	* point.	1✔
232	*	1✔
233	* @return {boolean}	1✔
234	*/	1✔
235	isInside(extent, epsilon) {	1✔
236	extent.as(this.crs, _extent);	1✔
237	epsilon = epsilon == undefined ? CRS.reasonnableEpsilon(this.crs) : epsilon;	1!
238	return this.east - _extent.east <= epsilon &&	1✔
239	_extent.west - this.west <= epsilon &&	1✔
240	this.north - _extent.north <= epsilon &&	1✔
241	_extent.south - this.south <= epsilon;	1✔
242	}	1✔
243		1✔
244	/**	1✔
245	* Return the translation and scale to transform this extent to input extent.	1✔
246	*	1✔
247	* @param {Extent} extent input extent	1✔
248	* @param {THREE.Vector4} target copy the result to target.	1✔
249	* @return {THREE.Vector4} {x: translation on west-east, y: translation on south-north, z: scale on west-east, w: scale on south-north}	1✔
250	*/	1✔
251	offsetToParent(extent, target = new THREE.Vector4()) {	1!
252	if (this.crs != extent.crs) {	1!
UNCOV 253	throw new Error('unsupported mix');	×
UNCOV 254	}	×
255		1✔
256	extent.planarDimensions(_dim);	1✔
257	this.planarDimensions(_dim2);	1✔
258		1✔
259	const originX = (this.west - extent.west) / _dim.x;	1✔
260	const originY = (extent.north - this.north) / _dim.y;	1✔
261		1✔
262	const scaleX = _dim2.x / _dim.x;	1✔
263	const scaleY = _dim2.y / _dim.y;	1✔
264		1✔
265	return target.set(originX, originY, scaleX, scaleY);	1✔
266	}	1✔
267		1✔
268	/**	1✔
269	* Return true if this bounding box intersect with the bouding box parameter	1✔
270	* @param {Extent} extent	1✔
271	* @returns {Boolean}	1✔
272	*/	1✔
273	intersectsExtent(extent) {	1✔
274	return Extent.intersectsExtent(this, extent);	22✔
275	}	22✔
276		1✔
277	static intersectsExtent(/** @type {Extent} /extentA, /* @type {Extent} */ extentB) {	1✔
278	// TODO don't work when is on limit	30✔
279	const other = extentB.crs == extentA.crs ? extentB : extentB.as(extentA.crs, _extent);	30!
280	return !(extentA.west >= other.east \|\|	30✔
281	extentA.east <= other.west \|\|	30✔
282	extentA.south >= other.north \|\|	30✔
283	extentA.north <= other.south);	30✔
284	}	30✔
285		1✔
286	/**	1✔
287	* Return the intersection of this extent with another one	1✔
288	* @param {Extent} extent	1✔
289	* @returns {Extent}	1✔
290	*/	1✔
291	intersect(extent) {	1✔
292	if (!this.intersectsExtent(extent)) {	1!
293	return new Extent(this.crs, 0, 0, 0, 0);	×
UNCOV 294	}	×
295	if (extent.crs != this.crs) {	1!
UNCOV 296	extent = extent.as(this.crs, _extent);	×
UNCOV 297	}	×
298	return new Extent(this.crs,	1✔
299	Math.max(this.west, extent.west),	1✔
300	Math.min(this.east, extent.east),	1✔
301	Math.max(this.south, extent.south),	1✔
302	Math.min(this.north, extent.north));	1✔
303	}	1✔
304		1✔
305	/**	1✔
306	* Set west, east, south and north values.	1✔
307	*	1✔
308	* @param {number\|Array.<number>\|Coordinates\|Object\|Extent} v0 west value,	1✔
309	* Array of values [west, east, south and north], Extent of same type (tiled	1✔
310	* or not), Coordinates of west-south corner or object {west, east, south	1✔
311	* and north}	1✔
312	* @param {number\|Coordinates} [v1] east value, row value or Coordinates of	1✔
313	* east-north corner	1✔
314	* @param {number} [v2] south value or column value	1✔
315	* @param {number} [v3] north value	1✔
316	*	1✔
317	* @return {Extent}	1✔
318	*/	1✔
319	set(v0, v1, v2, v3) {	1✔
320	if (v0 == undefined) {	870!
UNCOV 321	throw new Error('No values to set in the extent');	×
UNCOV 322	}	×
323	if (v0.isExtent) {	870✔
324	v1 = v0.east;	189✔
325	v2 = v0.south;	189✔
326	v3 = v0.north;	189✔
327	v0 = v0.west;	189✔
328	}	189✔
329		870✔
330	if (v0.isCoordinates) {	870✔
331	// seem never used	1✔
332	this.west = v0.x;	1✔
333	this.east = v1.x;	1✔
334	this.south = v0.y;	1✔
335	this.north = v1.y;	1✔
336	} else if (v0.west !== undefined) {	870✔
337	this.west = v0.west;	15✔
338	this.east = v0.east;	15✔
339	this.south = v0.south;	15✔
340	this.north = v0.north;	15✔
341	} else if (v0.length == 4) {	869✔
342	this.west = v0[0];	64✔
343	this.east = v0[1];	64✔
344	this.south = v0[2];	64✔
345	this.north = v0[3];	64✔
346	} else if (v3 !== undefined) {	854✔
347	this.west = v0;	790✔
348	this.east = v1;	790✔
349	this.south = v2;	790✔
350	this.north = v3;	790✔
351	}	790✔
352		870✔
353	return this;	870✔
354	}	870✔
355		1✔
356	/**	1✔
357	* Copy to this extent to input extent.	1✔
358	* @param {Extent} extent	1✔
359	* @return {Extent} copied extent	1✔
360	*/	1✔
361	copy(extent) {	1✔
362	this.crs = extent.crs;	189✔
363	return this.set(extent);	189✔
364	}	189✔
365		1✔
366	/**	1✔
367	* Union this extent with the input extent.	1✔
368	* @param {Extent} extent the extent to union.	1✔
369	*/	1✔
370	union(extent) {	1✔
371	if (extent.crs != this.crs) {	191!
UNCOV 372	throw new Error('unsupported union between 2 diff crs');	×
UNCOV 373	}	×
374	if (this.west === Infinity) {	191✔
375	this.copy(extent);	126✔
376	} else {	191✔
377	const west = extent.west;	65✔
378	if (west < this.west) {	65✔
379	this.west = west;	26✔
380	}	26✔
381		65✔
382	const east = extent.east;	65✔
383	if (east > this.east) {	65✔
384	this.east = east;	12✔
385	}	12✔
386		65✔
387	const south = extent.south;	65✔
388	if (south < this.south) {	65✔
389	this.south = south;	7✔
390	}	7✔
391		65✔
392	const north = extent.north;	65✔
393	if (north > this.north) {	65✔
394	this.north = north;	13✔
395	}	13✔
396	}	65✔
397	}	191✔
398		1✔
399	/**	1✔
400	* expandByCoordinates perfoms the minimal extension	1✔
401	* for the coordinates to belong to this Extent object	1✔
402	* @param {Coordinates} coordinates The coordinates to belong	1✔
403	*/	1✔
404	expandByCoordinates(coordinates) {	1✔
405	const coords = coordinates.crs == this.crs ? coordinates : coordinates.as(this.crs, _c);	214!
406	this.expandByValuesCoordinates(coords.x, coords.y);	214✔
407	}	214✔
408		1✔
409	/**	1✔
410	* expandByValuesCoordinates perfoms the minimal extension	1✔
411	* for the coordinates values to belong to this Extent object	1✔
412	* @param {number} we The coordinate on west-east	1✔
413	* @param {number} sn The coordinate on south-north	1✔
414	*	1✔
415	*/	1✔
416	expandByValuesCoordinates(we, sn) {	1✔
417	if (we < this.west) {	245✔
418	this.west = we;	82✔
419	}	82✔
420	if (we > this.east) {	245✔
421	this.east = we;	127✔
422	}	127✔
423	if (sn < this.south) {	245✔
424	this.south = sn;	90✔
425	}	90✔
426	if (sn > this.north) {	245✔
427	this.north = sn;	120✔
428	}	120✔
429	}	245✔
430		1✔
431	/**	1✔
432	* Instance Extent with THREE.Box3.	1✔
433	*	1✔
434	* If crs is a geocentric projection, the `box3.min` and `box3.max`	1✔
435	* should be the geocentric coordinates of `min` and `max` of a `box3`	1✔
436	* in local tangent plane.	1✔
437	*	1✔
438	* @param {string} crs Projection of extent to instancied.	1✔
439	* @param {THREE.Box3} box	1✔
440	* @return {Extent}	1✔
441	*/	1✔
442	static fromBox3(crs, box) {	1✔
443	if (CRS.isGeocentric(crs)) {	14✔
444	// if geocentric reproject box on 'EPSG:4326'	1✔
445	crs = 'EPSG:4326';	1✔
446	box = _box.copy(box);	1✔
447		1✔
448	cSouthWest.crs = crs;	1✔
449	cSouthWest.setFromVector3(box.min).as(crs, cSouthWest).toVector3(box.min);	1✔
450	cNorthEast.crs = crs;	1✔
451	cNorthEast.setFromVector3(box.max).as(crs, cNorthEast).toVector3(box.max);	1✔
452	}	1✔
453		14✔
454	return new Extent(crs, {	14✔
455	west: box.min.x,	14✔
456	east: box.max.x,	14✔
457	south: box.min.y,	14✔
458	north: box.max.y,	14✔
459	});	14✔
460	}	14✔
461		1✔
462	/**	1✔
463	* Return values of extent in string, separated by the separator input.	1✔
464	* @param {string} separator	1✔
465	* @return {string}	1✔
466	*/	1✔
467	toString(separator = '') {	1!
468	return `${this.east}${separator}${this.north}${separator}${this.west}${separator}${this.south}`;	1✔
469	}	1✔
470		1✔
471	/**	1✔
472	* Subdivide equally an extent from its center to return four extents:	1✔
473	* north-west, north-east, south-west and south-east.	1✔
474	*	1✔
475	* @returns {Extent[]} An array containing the four sections of the extent. The	1✔
476	* order of the sections is [NW, NE, SW, SE].	1✔
477	*/	1✔
478	subdivision() {	1✔
479	return this.subdivisionByScheme();	5✔
480	}	5✔
481	/**	1✔
482	* subdivise extent by scheme.x on west-east and scheme.y on south-north.	1✔
483	*	1✔
484	* @param {THREE.Vector2} [scheme=Vector2(2,2)] The scheme to subdivise.	1✔
485	* @return {Array<Extent>} subdivised extents.	1✔
486	*/	1✔
487	subdivisionByScheme(scheme = defaultScheme) {	1✔
488	const subdivisedExtents = [];	26✔
489	const dimSub = this.planarDimensions(_dim).divide(scheme);	26✔
490	for (let x = scheme.x - 1; x >= 0; x--) {	26✔
491	for (let y = scheme.y - 1; y >= 0; y--) {	52✔
492	const west = this.west + x * dimSub.x;	62✔
493	const south = this.south + y * dimSub.y;	62✔
494	subdivisedExtents.push(new Extent(this.crs,	62✔
495	west,	62✔
496	west + dimSub.x,	62✔
497	south,	62✔
498	south + dimSub.y));	62✔
499	}	62✔
500	}	52✔
501	return subdivisedExtents;	26✔
502	}	26✔
503		1✔
504	/**	1✔
505	* Multiplies all extent `coordinates` (with an implicit 1 in the 4th dimension) and `matrix`.	1✔
506	*	1✔
507	* @param {THREE.Matrix4} matrix The matrix	1✔
508	* @return {Extent} return this extent instance.	1✔
509	*/	1✔
510	applyMatrix4(matrix) {	1✔
511	southWest.set(this.west, this.south, 0).applyMatrix4(matrix);	15✔
512	northEast.set(this.east, this.north, 0).applyMatrix4(matrix);	15✔
513	this.west = southWest.x;	15✔
514	this.east = northEast.x;	15✔
515	this.south = southWest.y;	15✔
516	this.north = northEast.y;	15✔
517	if (this.west > this.east) {	15!
UNCOV 518	const temp = this.west;	×
UNCOV 519	this.west = this.east;	×
UNCOV 520	this.east = temp;	×
UNCOV 521	}	×
522	if (this.south > this.north) {	15✔
523	const temp = this.south;	1✔
524	this.south = this.north;	1✔
525	this.north = temp;	1✔
526	}	1✔
527	return this;	15✔
528	}	15✔
529		1✔
530	/**	1✔
531	* clamp south and north values	1✔
532	*	1✔
533	* @param {number} [south=this.south] The min south	1✔
534	* @param {number} [north=this.north] The max north	1✔
535	* @return {Extent} this extent	1✔
536	*/	1✔
537	clampSouthNorth(south = this.south, north = this.north) {	1!
538	this.south = Math.max(this.south, south);	59✔
539	this.north = Math.min(this.north, north);	59✔
540	return this;	59✔
541	}	59✔
542		1✔
543	/**	1✔
544	* clamp west and east values	1✔
545	*	1✔
546	* @param {number} [west=this.west] The min west	1✔
547	* @param {number} [east=this.east] The max east	1✔
548	* @return {Extent} this extent	1✔
549	*/	1✔
550	clampWestEast(west = this.west, east = this.east) {	1!
551	this.west = Math.max(this.west, west);	58✔
552	this.east = Math.min(this.east, east);	58✔
553	return this;	58✔
554	}	58✔
555	/**	1✔
556	* clamp this extent by passed extent	1✔
557	*	1✔
558	* @param {Extent} extent The maximum extent.	1✔
559	* @return {Extent} this extent.	1✔
560	*/	1✔
561	clampByExtent(extent) {	1✔
562	this.clampSouthNorth(extent.south, extent.north);	58✔
563	return this.clampWestEast(extent.west, extent.east);	58✔
564	}	58✔
565	}	1✔
566		1✔
567	_extent = new Extent('EPSG:4326', [0, 0, 0, 0]);	1✔
568		1✔
569	export default Extent;	1✔

iTowns / itowns / 11295619330

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