12046551553

Committed 27 Nov 2024 08:34AM UTC coverage: 86.793% (-0.04%) from 86.829%

Build # 12046551553

Build Type

push

github

Committed by

Desplandis

Commit Message

refacto(Crs): remove tms/epsg family of functions

BREAKING CHANGE: CRS.isEPSG and CRS.isTMS have been removed
BREAKING CHANGE: CRS.formatToESPG and CRS.formatToTMS have been removed

Run Details

2778 of 3696 branches covered (75.16%)

Branch coverage included in aggregate %.

28 of 29 new or added lines in 16 files covered. (96.55%)

6 existing lines in 1 file now uncovered.

24297 of 27499 relevant lines covered (88.36%)

1022.8 hits per line

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

89.01

/src/Core/Prefab/Globe/GlobeLayer.js

import * as THREE from 'three';
import TiledGeometryLayer from 'Layer/TiledGeometryLayer';
import { ellipsoidSizes } from 'Core/Math/Ellipsoid';
import { globalExtentTMS, schemeTiles } from 'Core/Tile/TileGrid';
import BuilderEllipsoidTile from 'Core/Prefab/Globe/BuilderEllipsoidTile';

// matrix to convert sphere to ellipsoid
const worldToScaledEllipsoid = new THREE.Matrix4();
// camera's position in worldToScaledEllipsoid system
const cameraPosition = new THREE.Vector3();
let magnitudeSquared = 0.0;

// vectors for operation purpose
const scaledHorizonCullingPoint = new THREE.Vector3();

/**
 * @property {boolean} isGlobeLayer - Used to checkout whether this layer is a
 * GlobeLayer. Default is true. You should not change this, as it is used
 * internally for optimisation.
 */
class GlobeLayer extends TiledGeometryLayer {
    /**
     * A {@link TiledGeometryLayer} to use with a {@link GlobeView}. It has
     * specific method for updating and subdivising its grid.
     *
     * @extends TiledGeometryLayer
     *
     * @param {string} id - The id of the layer, that should be unique. It is
     * not mandatory, but an error will be emitted if this layer is added a
     * {@link View} that already has a layer going by that id.
     * @param {THREE.Object3d} [object3d=THREE.Group] - The object3d used to
     * contain the geometry of the TiledGeometryLayer. It is usually a
     * `THREE.Group`, but it can be anything inheriting from a `THREE.Object3d`.
     * @param {Object} [config] - Optional configuration, all elements in it
     * will be merged as is in the layer. For example, if the configuration
     * contains three elements `name, protocol, extent`, these elements will be
     * available using `layer.name` or something else depending on the property
     * name.
     * @param {number} [config.minSubdivisionLevel=2] - Minimum subdivision
     * level for this tiled layer.
     * @param {number} [config.maxSubdivisionLevel=18] - Maximum subdivision
     * level for this tiled layer.
     * @param {number} [config.sseSubdivisionThreshold=1] - Threshold level for
     * the SSE.
     *
     * @throws {Error} `object3d` must be a valid `THREE.Object3d`.
     */
    constructor(id, object3d, config = {}) {
        // Configure tiles
        const scheme = schemeTiles.get('EPSG:4326');
        const schemeTile = globalExtentTMS.get('EPSG:4326').subdivisionByScheme(scheme);

        // Supported tile matrix set for color/elevation layer
        config.tileMatrixSets = [
            'EPSG:4326',
            'EPSG:3857',
        ];
        const uvCount = config.tileMatrixSets.length;
        const builder = new BuilderEllipsoidTile({ crs: 'EPSG:4978', uvCount });

        super(id, object3d || new THREE.Group(), schemeTile, builder, config);

        this.isGlobeLayer = true;
        this.options.defaultPickingRadius = 5;
        this.minSubdivisionLevel = this.minSubdivisionLevel == undefined ? 2 : this.minSubdivisionLevel;
        this.maxSubdivisionLevel = this.maxSubdivisionLevel == undefined ? 19 : this.maxSubdivisionLevel;
        this.extent = this.schemeTile[0].clone();

        for (let i = 1; i < this.schemeTile.length; i++) {
            this.extent.union(this.schemeTile[i]);
        }

        // We're going to use the method described here:
        //    https://cesiumjs.org/2013/04/25/Horizon-culling/
        // This method assumes that the globe is a unit sphere at 0,0,0 so
        // we setup a world-to-scaled-ellipsoid matrix4
        worldToScaledEllipsoid.copy(this.object3d.matrixWorld).invert();
        worldToScaledEllipsoid.premultiply(
            new THREE.Matrix4().makeScale(
                1 / ellipsoidSizes.x,
                1 / ellipsoidSizes.y,
                1 / ellipsoidSizes.z));
    }

    preUpdate(context, changeSources) {
        // pre-horizon culling
        cameraPosition.copy(context.camera.camera3D.position).applyMatrix4(worldToScaledEllipsoid);
        magnitudeSquared = cameraPosition.lengthSq() - 1.0;

        return super.preUpdate(context, changeSources);
    }

    countColorLayersTextures(...layers) {
        let occupancy = 0;
        for (const layer of layers) {
            const crs = layer.crs || layer.source.crs;
            // 'EPSG:3857' occupies the maximum 3 textures on tiles
            // 'EPSG:4326' occupies 1 textures on tile
            occupancy += crs == 'EPSG:3857' ? 3 : 1;
        }
        return occupancy;
    }

    subdivision(context, layer, node) {
        if (node.level == 5) {
            const row = node.getExtentsByProjection('EPSG:4326')[0].row;
            if (row == 31 || row == 0) {
                // doesn't subdivise the pole
                return false;
            }
        }
        return super.subdivision(context, layer, node);
    }

    culling(node, camera) {
        if (super.culling(node, camera)) {
            return true;
        }

        if (node.level < this.minSubdivisionLevel) {
            return false;
        }

        return GlobeLayer.horizonCulling(node.horizonCullingPointElevationScaled);
    }

    static horizonCulling(point) {
        // see https://cesiumjs.org/2013/04/25/Horizon-culling/
        scaledHorizonCullingPoint.copy(point).applyMatrix4(worldToScaledEllipsoid);
        scaledHorizonCullingPoint.sub(cameraPosition);

        const vtMagnitudeSquared = scaledHorizonCullingPoint.lengthSq();
        const dot = -scaledHorizonCullingPoint.dot(cameraPosition);
        const isOccluded = magnitudeSquared < 0 ? dot > 0 : magnitudeSquared < dot && magnitudeSquared < ((dot * dot) / vtMagnitudeSquared);

        return isOccluded;
    }

    computeTileZoomFromDistanceCamera(distance, camera) {
        const preSinus =
            this.sizeDiagonalTexture * (this.sseSubdivisionThreshold * 0.5) / camera._preSSE / ellipsoidSizes.x;

        let sinus = distance * preSinus;
        let zoom = Math.log(Math.PI / (2.0 * Math.asin(sinus))) / Math.log(2);

        const delta = Math.PI / 2 ** zoom;
        const circleChord = 2.0 * ellipsoidSizes.x * Math.sin(delta * 0.5);
        const radius = circleChord * 0.5;

        // adjust with bounding sphere rayon
        sinus = (distance - radius) * preSinus;
        zoom = Math.log(Math.PI / (2.0 * Math.asin(sinus))) / Math.log(2);

        return isNaN(zoom) ? 0 : Math.round(zoom);
    }

    computeDistanceCameraFromTileZoom(zoom, camera) {
        const delta = Math.PI / 2 ** zoom;
        const circleChord = 2.0 * ellipsoidSizes.x * Math.sin(delta * 0.5);
        const radius = circleChord * 0.5;
        const error = radius / this.sizeDiagonalTexture;

        return camera._preSSE * error / (this.sseSubdivisionThreshold * 0.5) + radius;
    }
}

export default GlobeLayer;

1	import * as THREE from 'three';	1✔
2	import TiledGeometryLayer from 'Layer/TiledGeometryLayer';	1✔
3	import { ellipsoidSizes } from 'Core/Math/Ellipsoid';	1✔
4	import { globalExtentTMS, schemeTiles } from 'Core/Tile/TileGrid';	1✔
5	import BuilderEllipsoidTile from 'Core/Prefab/Globe/BuilderEllipsoidTile';	1✔
6		1✔
7	// matrix to convert sphere to ellipsoid	1✔
8	const worldToScaledEllipsoid = new THREE.Matrix4();	1✔
9	// camera's position in worldToScaledEllipsoid system	1✔
10	const cameraPosition = new THREE.Vector3();	1✔
11	let magnitudeSquared = 0.0;	1✔
12		1✔
13	// vectors for operation purpose	1✔
14	const scaledHorizonCullingPoint = new THREE.Vector3();	1✔
15		1✔
16	/**	1✔
17	* @property {boolean} isGlobeLayer - Used to checkout whether this layer is a	1✔
18	* GlobeLayer. Default is true. You should not change this, as it is used	1✔
19	* internally for optimisation.	1✔
20	*/	1✔
21	class GlobeLayer extends TiledGeometryLayer {	1✔
22	/**	1✔
23	* A {@link TiledGeometryLayer} to use with a {@link GlobeView}. It has	1✔
24	* specific method for updating and subdivising its grid.	1✔
25	*	1✔
26	* @extends TiledGeometryLayer	1✔
27	*	1✔
28	* @param {string} id - The id of the layer, that should be unique. It is	1✔
29	* not mandatory, but an error will be emitted if this layer is added a	1✔
30	* {@link View} that already has a layer going by that id.	1✔
31	* @param {THREE.Object3d} [object3d=THREE.Group] - The object3d used to	1✔
32	* contain the geometry of the TiledGeometryLayer. It is usually a	1✔
33	* `THREE.Group`, but it can be anything inheriting from a `THREE.Object3d`.	1✔
34	* @param {Object} [config] - Optional configuration, all elements in it	1✔
35	* will be merged as is in the layer. For example, if the configuration	1✔
36	* contains three elements `name, protocol, extent`, these elements will be	1✔
37	* available using `layer.name` or something else depending on the property	1✔
38	* name.	1✔
39	* @param {number} [config.minSubdivisionLevel=2] - Minimum subdivision	1✔
40	* level for this tiled layer.	1✔
41	* @param {number} [config.maxSubdivisionLevel=18] - Maximum subdivision	1✔
42	* level for this tiled layer.	1✔
43	* @param {number} [config.sseSubdivisionThreshold=1] - Threshold level for	1✔
44	* the SSE.	1✔
45	*	1✔
46	* @throws {Error} `object3d` must be a valid `THREE.Object3d`.	1✔
47	*/	1✔
48	constructor(id, object3d, config = {}) {	1✔
49	// Configure tiles	21✔
50	const scheme = schemeTiles.get('EPSG:4326');	21✔
51	const schemeTile = globalExtentTMS.get('EPSG:4326').subdivisionByScheme(scheme);	21✔
52		21✔
53	// Supported tile matrix set for color/elevation layer	21✔
54	config.tileMatrixSets = [	21✔
55	'EPSG:4326',	21✔
56	'EPSG:3857',	21✔
57	];	21✔
58	const uvCount = config.tileMatrixSets.length;	21✔
59	const builder = new BuilderEllipsoidTile({ crs: 'EPSG:4978', uvCount });	21✔
60		21✔
61	super(id, object3d \|\| new THREE.Group(), schemeTile, builder, config);	21✔
62		21✔
63	this.isGlobeLayer = true;	21✔
64	this.options.defaultPickingRadius = 5;	21✔
65	this.minSubdivisionLevel = this.minSubdivisionLevel == undefined ? 2 : this.minSubdivisionLevel;	21!
66	this.maxSubdivisionLevel = this.maxSubdivisionLevel == undefined ? 19 : this.maxSubdivisionLevel;	21!
67	this.extent = this.schemeTile[0].clone();	21✔
68		21✔
69	for (let i = 1; i < this.schemeTile.length; i++) {	21✔
70	this.extent.union(this.schemeTile[i]);	21✔
71	}	21✔
72		21✔
73	// We're going to use the method described here:	21✔
74	// https://cesiumjs.org/2013/04/25/Horizon-culling/	21✔
75	// This method assumes that the globe is a unit sphere at 0,0,0 so	21✔
76	// we setup a world-to-scaled-ellipsoid matrix4	21✔
77	worldToScaledEllipsoid.copy(this.object3d.matrixWorld).invert();	21✔
78	worldToScaledEllipsoid.premultiply(	21✔
79	new THREE.Matrix4().makeScale(	21✔
80	1 / ellipsoidSizes.x,	21✔
81	1 / ellipsoidSizes.y,	21✔
82	1 / ellipsoidSizes.z));	21✔
83	}	21✔
84		1✔
85	preUpdate(context, changeSources) {	1✔
86	// pre-horizon culling	2✔
87	cameraPosition.copy(context.camera.camera3D.position).applyMatrix4(worldToScaledEllipsoid);	2✔
88	magnitudeSquared = cameraPosition.lengthSq() - 1.0;	2✔
89		2✔
90	return super.preUpdate(context, changeSources);	2✔
91	}	2✔
92		1✔
93	countColorLayersTextures(...layers) {	1✔
94	let occupancy = 0;	5✔
95	for (const layer of layers) {	5✔
96	const crs = layer.crs \|\| layer.source.crs;	6!
97	// 'EPSG:3857' occupies the maximum 3 textures on tiles	6✔
98	// 'EPSG:4326' occupies 1 textures on tile	6✔
99	occupancy += crs == 'EPSG:3857' ? 3 : 1;	6!
100	}	6✔
101	return occupancy;	5✔
102	}	5✔
103		1✔
104	subdivision(context, layer, node) {	1✔
105	if (node.level == 5) {	1!
NEW 106	const row = node.getExtentsByProjection('EPSG:4326')[0].row;	×
107	if (row == 31 \|\| row == 0) {	×
108	// doesn't subdivise the pole	×
109	return false;	×
110	}	×
111	}	×
112	return super.subdivision(context, layer, node);	1✔
113	}	1✔
114		1✔
115	culling(node, camera) {	1✔
116	if (super.culling(node, camera)) {	1!
117	return true;	×
118	}	×
119		1✔
120	if (node.level < this.minSubdivisionLevel) {	1✔
121	return false;	1✔
122	}	1!
123		×
124	return GlobeLayer.horizonCulling(node.horizonCullingPointElevationScaled);	×
125	}	×
126		1✔
127	static horizonCulling(point) {	1✔
128	// see https://cesiumjs.org/2013/04/25/Horizon-culling/	1✔
129	scaledHorizonCullingPoint.copy(point).applyMatrix4(worldToScaledEllipsoid);	1✔
130	scaledHorizonCullingPoint.sub(cameraPosition);	1✔
131		1✔
132	const vtMagnitudeSquared = scaledHorizonCullingPoint.lengthSq();	1✔
133	const dot = -scaledHorizonCullingPoint.dot(cameraPosition);	1✔
134	const isOccluded = magnitudeSquared < 0 ? dot > 0 : magnitudeSquared < dot && magnitudeSquared < ((dot * dot) / vtMagnitudeSquared);	1!
135		1✔
136	return isOccluded;	1✔
137	}	1✔
138		1✔
139	computeTileZoomFromDistanceCamera(distance, camera) {	1✔
140	const preSinus =	1✔
141	this.sizeDiagonalTexture * (this.sseSubdivisionThreshold * 0.5) / camera._preSSE / ellipsoidSizes.x;	1✔
142		1✔
143	let sinus = distance * preSinus;	1✔
144	let zoom = Math.log(Math.PI / (2.0 * Math.asin(sinus))) / Math.log(2);	1✔
145		1✔
146	const delta = Math.PI / 2 ** zoom;	1✔
147	const circleChord = 2.0 * ellipsoidSizes.x * Math.sin(delta * 0.5);	1✔
148	const radius = circleChord * 0.5;	1✔
149		1✔
150	// adjust with bounding sphere rayon	1✔
151	sinus = (distance - radius) * preSinus;	1✔
152	zoom = Math.log(Math.PI / (2.0 * Math.asin(sinus))) / Math.log(2);	1✔
153		1✔
154	return isNaN(zoom) ? 0 : Math.round(zoom);	1!
155	}	1✔
156		1✔
157	computeDistanceCameraFromTileZoom(zoom, camera) {	1✔
158	const delta = Math.PI / 2 ** zoom;	2✔
159	const circleChord = 2.0 * ellipsoidSizes.x * Math.sin(delta * 0.5);	2✔
160	const radius = circleChord * 0.5;	2✔
161	const error = radius / this.sizeDiagonalTexture;	2✔
162		2✔
163	return camera._preSSE * error / (this.sseSubdivisionThreshold * 0.5) + radius;	2✔
164	}	2✔
165	}	1✔
166		1✔
167	export default GlobeLayer;	1✔

iTowns / itowns / 12046551553

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