11954088408

Committed 21 Nov 2024 01:20PM UTC coverage: 86.786% (-0.04%) from 86.829%

Build # 11954088408

Build Type

Pull #2444

github

Committed by

web-flow

Commit Message

Merge dd973a3fa into 822c63b2a

Pull Request Pull Request #2444: refactor: migrate Extent to typescript

Run Details

2787 of 3702 branches covered (75.28%)

Branch coverage included in aggregate %.

975 of 1017 new or added lines in 25 files covered. (95.87%)

54 existing lines in 10 files now uncovered.

24417 of 27644 relevant lines covered (88.33%)

1017.78 hits per line

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

73.33

/src/Renderer/RasterTile.js

import * as THREE from 'three';
import { ELEVATION_MODES } from 'Renderer/LayeredMaterial';
import { checkNodeElevationTextureValidity, insertSignificantValuesFromParent, computeMinMaxElevation } from 'Parser/XbilParser';

export const EMPTY_TEXTURE_ZOOM = -1;

const pitch = new THREE.Vector4();

function getIndiceWithPitch(i, pitch, w) {
    // Return corresponding indice in parent tile using pitch
    const currentX = (i % w) / w;  // normalized
    const currentY = Math.floor(i / w) / w; // normalized
    const newX = pitch.x + currentX * pitch.z;
    const newY = pitch.y + currentY * pitch.w;
    const newIndice = Math.floor(newY * w) * w + Math.floor(newX * w);
    return newIndice;
}

/**
 * A `RasterTile` is part of raster {@link Layer} data.
 * This part is a spatial subdivision of the extent of a layer.
 * In the `RasterTile`, The data are converted on three.js textures.
 * This `RasterTile` textures are assigned to a `LayeredMaterial`.
 * This material is applied on terrain (TileMesh).
 * The color textures are mapped to color the terrain.
 * The elevation textures are used to displace vertex terrain.
 *
 * @class RasterTile
 */
class RasterTile extends THREE.EventDispatcher {
    constructor(material, layer) {
        super();
        this.layer = layer;
        this.crs = layer.parent.tileMatrixSets.indexOf(layer.crs);
        if (this.crs == -1) {
            console.error('Unknown crs:', layer.crs);
        }

        this.textures = [];
        this.offsetScales = [];
        this.level = EMPTY_TEXTURE_ZOOM;
        this.material = material;

        this._handlerCBEvent = () => { this.material.layersNeedUpdate = true; };
        layer.addEventListener('visible-property-changed', this._handlerCBEvent);
        layer.addEventListener('opacity-property-changed', this._handlerCBEvent);
    }

    get id() {
        return this.layer.id;
    }

    get opacity() {
        return this.layer.opacity;
    }

    get visible() {
        return this.layer.visible;
    }

    initFromParent(parent, extents) {
        if (parent && parent.level > this.level) {
            let index = 0;
            for (const c of extents) {
                for (const texture of parent.textures) {
                    if (c.isInside(texture.extent)) {
                        this.setTexture(index++, texture, c.offsetToParent(texture.extent));
                        break;
                    }
                }
            }

            if (__DEBUG__) {
                if (index != extents.length) {
                    console.error(`non-coherent result ${index} vs ${extents.length}.`, extents);
                }
            }
        }
    }

    dispose(removeEvent = true) {
        if (removeEvent) {
            this.layer.removeEventListener('visible-property-changed', this._handlerCBEvent);
            this.layer.removeEventListener('opacity-property-changed', this._handlerCBEvent);
            // dispose all events
            this._listeners = {};
        }
        // TODO: WARNING  verify if textures to dispose aren't attached with ancestor
        for (const texture of this.textures) {
            if (texture.isTexture) {
                texture.dispose();
            }
        }
        this.level = EMPTY_TEXTURE_ZOOM;
        this.textures = [];
        this.offsetScales = [];
        this.material.layersNeedUpdate = true;
    }

    setTexture(index, texture, offsetScale) {
        this.level = (texture && texture.extent && (index == 0)) ? texture.extent.zoom : this.level;
        this.textures[index] = texture || null;
        this.offsetScales[index] = offsetScale;
        this.material.layersNeedUpdate = true;
    }

    setTextures(textures, pitchs) {
        this.dispose(false);
        for (let i = 0, il = textures.length; i < il; ++i) {
            this.setTexture(i, textures[i], pitchs[i]);
        }
    }
}

export default RasterTile;

export class RasterColorTile extends RasterTile {
    get effect_type() {
        return this.layer.effect_type;
    }
    get effect_parameter() {
        return this.layer.effect_parameter;
    }
    get transparent() {
        return this.layer.transparent;
    }
}

export class RasterElevationTile extends RasterTile {
    constructor(material, layer) {
        super(material, layer);
        const defaultEle = {
            bias: 0,
            mode: ELEVATION_MODES.DATA,
            zmin: -Infinity,
            zmax: Infinity,
        };

        this.scaleFactor = 1.0;

        // Define elevation properties
        if (layer.useRgbaTextureElevation) {
            defaultEle.mode = ELEVATION_MODES.RGBA;
            defaultEle.zmax = 5000;
            throw new Error('Restore this feature');
        } else if (layer.useColorTextureElevation) {
            this.scaleFactor = layer.colorTextureElevationMaxZ - layer.colorTextureElevationMinZ;
            defaultEle.mode = ELEVATION_MODES.COLOR;
            defaultEle.bias = layer.colorTextureElevationMinZ;
            this.min = this.layer.colorTextureElevationMinZ;
            this.max = this.layer.colorTextureElevationMaxZ;
        } else {
            this.min = 0;
            this.max = 0;
        }
        this.bias = layer.bias ?? defaultEle.bias;
        this.mode = layer.mode ?? defaultEle.mode;
        this.zmin = layer.zmin ?? defaultEle.zmin;
        this.zmax = layer.zmax ?? defaultEle.zmax;

        layer.addEventListener('scale-property-changed', this._handlerCBEvent);
    }

    get scale() {
        return this.layer.scale * this.scaleFactor;
    }

    dispose(removeEvent) {
        super.dispose(removeEvent);
        if (removeEvent) {
            this.layer.removeEventListener('scale-property-changed', this._handlerCBEvent);
        }
    }

    initFromParent(parent, extents) {
        const currentLevel = this.level;
        super.initFromParent(parent, extents);
        this.updateMinMaxElevation();
        if (currentLevel !== this.level) {
            this.dispatchEvent({ type: 'rasterElevationLevelChanged', node: this });
        }
    }

    setTextures(textures, offsetScales) {
        const currentLevel = this.level;
        this.replaceNoDataValueFromTexture(textures[0]);
        super.setTextures(textures, offsetScales);
        this.updateMinMaxElevation();
        if (currentLevel !== this.level) {
            this.dispatchEvent({ type: 'rasterElevationLevelChanged', node: this });
        }
    }

    updateMinMaxElevation() {
        if (this.textures[0] && !this.layer.useColorTextureElevation) {
            const { min, max } = computeMinMaxElevation(
                this.textures[0],
                this.offsetScales[0],
                {
                    noDataValue: this.layer.noDataValue,
                    zmin: this.layer.zmin,
                    zmax: this.layer.zmax,
                });
            if (this.min != min || this.max != max) {
                this.min = min;
                this.max = max;
            }
        }
    }

    replaceNoDataValueFromTexture(texture) {
        const nodatavalue = this.layer.noDataValue;
        if (nodatavalue == undefined) {
            return;
        }
        // replace no data value with parent texture value or 0 (if no significant value found).
        const parentTexture = this.textures[0];
        const parentDataElevation = parentTexture && parentTexture.image && parentTexture.image.data;
        const dataElevation = texture.image && texture.image.data;

        if (dataElevation && !checkNodeElevationTextureValidity(dataElevation, nodatavalue)) {
            insertSignificantValuesFromParent(dataElevation, parentDataElevation && dataParent(texture, parentTexture, parentDataElevation, pitch), nodatavalue);
        }
    }
}

function dataParent(texture, parentTexture, parentDataElevation, pitch) {
    texture.extent.offsetToParent(parentTexture.extent, pitch);
    return i => parentDataElevation[getIndiceWithPitch(i, pitch, 256)];
}

1	import * as THREE from 'three';	1✔
2	import { ELEVATION_MODES } from 'Renderer/LayeredMaterial';	1✔
3	import { checkNodeElevationTextureValidity, insertSignificantValuesFromParent, computeMinMaxElevation } from 'Parser/XbilParser';	1✔
4		1✔
5	export const EMPTY_TEXTURE_ZOOM = -1;	1✔
6		1✔
7	const pitch = new THREE.Vector4();	1✔
8		1✔
UNCOV 9	function getIndiceWithPitch(i, pitch, w) {	×
10	// Return corresponding indice in parent tile using pitch	×
11	const currentX = (i % w) / w; // normalized	×
12	const currentY = Math.floor(i / w) / w; // normalized	×
13	const newX = pitch.x + currentX * pitch.z;	×
14	const newY = pitch.y + currentY * pitch.w;	×
15	const newIndice = Math.floor(newY * w) * w + Math.floor(newX * w);	×
16	return newIndice;	×
17	}	×
18		1✔
19	/**	1✔
20	* A `RasterTile` is part of raster {@link Layer} data.	1✔
21	* This part is a spatial subdivision of the extent of a layer.	1✔
22	* In the `RasterTile`, The data are converted on three.js textures.	1✔
23	* This `RasterTile` textures are assigned to a `LayeredMaterial`.	1✔
24	* This material is applied on terrain (TileMesh).	1✔
25	* The color textures are mapped to color the terrain.	1✔
26	* The elevation textures are used to displace vertex terrain.	1✔
27	*	1✔
28	* @class RasterTile	1✔
29	*/	1✔
30	class RasterTile extends THREE.EventDispatcher {	1✔
31	constructor(material, layer) {	1✔
32	super();	11✔
33	this.layer = layer;	11✔
34	this.crs = layer.parent.tileMatrixSets.indexOf(layer.crs);	11✔
35	if (this.crs == -1) {	11!
UNCOV 36	console.error('Unknown crs:', layer.crs);	×
37	}	×
38		11✔
39	this.textures = [];	11✔
40	this.offsetScales = [];	11✔
41	this.level = EMPTY_TEXTURE_ZOOM;	11✔
42	this.material = material;	11✔
43		11✔
44	this._handlerCBEvent = () => { this.material.layersNeedUpdate = true; };	11✔
45	layer.addEventListener('visible-property-changed', this._handlerCBEvent);	11✔
46	layer.addEventListener('opacity-property-changed', this._handlerCBEvent);	11✔
47	}	11✔
48		1✔
49	get id() {	1✔
50	return this.layer.id;	21✔
51	}	21✔
52		1✔
53	get opacity() {	1✔
54	return this.layer.opacity;	5✔
55	}	5✔
56		1✔
57	get visible() {	1✔
58	return this.layer.visible;	5✔
59	}	5✔
60		1✔
61	initFromParent(parent, extents) {	1✔
62	if (parent && parent.level > this.level) {	3!
UNCOV 63	let index = 0;	×
64	for (const c of extents) {	×
65	for (const texture of parent.textures) {	×
66	if (c.isInside(texture.extent)) {	×
67	this.setTexture(index++, texture, c.offsetToParent(texture.extent));	×
68	break;	×
69	}	×
70	}	×
71	}	×
72		×
73	if (__DEBUG__) {	×
74	if (index != extents.length) {	×
75	console.error(`non-coherent result ${index} vs ${extents.length}.`, extents);	×
76	}	×
77	}	×
78	}	×
79	}	3✔
80		1✔
81	dispose(removeEvent = true) {	1!
82	if (removeEvent) {	3!
UNCOV 83	this.layer.removeEventListener('visible-property-changed', this._handlerCBEvent);	×
84	this.layer.removeEventListener('opacity-property-changed', this._handlerCBEvent);	×
85	// dispose all events	×
86	this._listeners = {};	×
87	}	×
88	// TODO: WARNING verify if textures to dispose aren't attached with ancestor	3✔
89	for (const texture of this.textures) {	3!
UNCOV 90	if (texture.isTexture) {	×
91	texture.dispose();	×
92	}	×
93	}	×
94	this.level = EMPTY_TEXTURE_ZOOM;	3✔
95	this.textures = [];	3✔
96	this.offsetScales = [];	3✔
97	this.material.layersNeedUpdate = true;	3✔
98	}	3✔
99		1✔
100	setTexture(index, texture, offsetScale) {	1✔
101	this.level = (texture && texture.extent && (index == 0)) ? texture.extent.zoom : this.level;	3!
102	this.textures[index] = texture \|\| null;	3!
103	this.offsetScales[index] = offsetScale;	3✔
104	this.material.layersNeedUpdate = true;	3✔
105	}	3✔
106		1✔
107	setTextures(textures, pitchs) {	1✔
108	this.dispose(false);	3✔
109	for (let i = 0, il = textures.length; i < il; ++i) {	3✔
110	this.setTexture(i, textures[i], pitchs[i]);	3✔
111	}	3✔
112	}	3✔
113	}	1✔
114		1✔
115	export default RasterTile;	1✔
116		1✔
117	export class RasterColorTile extends RasterTile {	1✔
118	get effect_type() {	1✔
UNCOV 119	return this.layer.effect_type;	×
120	}	×
121	get effect_parameter() {	1✔
UNCOV 122	return this.layer.effect_parameter;	×
123	}	×
124	get transparent() {	1✔
UNCOV 125	return this.layer.transparent;	×
126	}	×
127	}	1✔
128		1✔
129	export class RasterElevationTile extends RasterTile {	1✔
130	constructor(material, layer) {	1✔
131	super(material, layer);	6✔
132	const defaultEle = {	6✔
133	bias: 0,	6✔
134	mode: ELEVATION_MODES.DATA,	6✔
135	zmin: -Infinity,	6✔
136	zmax: Infinity,	6✔
137	};	6✔
138		6✔
139	this.scaleFactor = 1.0;	6✔
140		6✔
141	// Define elevation properties	6✔
142	if (layer.useRgbaTextureElevation) {	6✔
143	defaultEle.mode = ELEVATION_MODES.RGBA;	1✔
144	defaultEle.zmax = 5000;	1✔
145	throw new Error('Restore this feature');	1✔
146	} else if (layer.useColorTextureElevation) {	6✔
147	this.scaleFactor = layer.colorTextureElevationMaxZ - layer.colorTextureElevationMinZ;	1✔
148	defaultEle.mode = ELEVATION_MODES.COLOR;	1✔
149	defaultEle.bias = layer.colorTextureElevationMinZ;	1✔
150	this.min = this.layer.colorTextureElevationMinZ;	1✔
151	this.max = this.layer.colorTextureElevationMaxZ;	1✔
152	} else {	5✔
153	this.min = 0;	4✔
154	this.max = 0;	4✔
155	}	4✔
156	this.bias = layer.bias ?? defaultEle.bias;	6✔
157	this.mode = layer.mode ?? defaultEle.mode;	6✔
158	this.zmin = layer.zmin ?? defaultEle.zmin;	6✔
159	this.zmax = layer.zmax ?? defaultEle.zmax;	6✔
160		6✔
161	layer.addEventListener('scale-property-changed', this._handlerCBEvent);	6✔
162	}	6✔
163		1✔
164	get scale() {	1✔
UNCOV 165	return this.layer.scale * this.scaleFactor;	×
166	}	×
167		1✔
168	dispose(removeEvent) {	1✔
169	super.dispose(removeEvent);	2✔
170	if (removeEvent) {	2!
UNCOV 171	this.layer.removeEventListener('scale-property-changed', this._handlerCBEvent);	×
172	}	×
173	}	2✔
174		1✔
175	initFromParent(parent, extents) {	1✔
176	const currentLevel = this.level;	1✔
177	super.initFromParent(parent, extents);	1✔
178	this.updateMinMaxElevation();	1✔
179	if (currentLevel !== this.level) {	1!
UNCOV 180	this.dispatchEvent({ type: 'rasterElevationLevelChanged', node: this });	×
181	}	×
182	}	1✔
183		1✔
184	setTextures(textures, offsetScales) {	1✔
185	const currentLevel = this.level;	2✔
186	this.replaceNoDataValueFromTexture(textures[0]);	2✔
187	super.setTextures(textures, offsetScales);	2✔
188	this.updateMinMaxElevation();	2✔
189	if (currentLevel !== this.level) {	2✔
190	this.dispatchEvent({ type: 'rasterElevationLevelChanged', node: this });	2✔
191	}	2✔
192	}	2✔
193		1✔
194	updateMinMaxElevation() {	1✔
195	if (this.textures[0] && !this.layer.useColorTextureElevation) {	3✔
196	const { min, max } = computeMinMaxElevation(	2✔
197	this.textures[0],	2✔
198	this.offsetScales[0],	2✔
199	{	2✔
200	noDataValue: this.layer.noDataValue,	2✔
201	zmin: this.layer.zmin,	2✔
202	zmax: this.layer.zmax,	2✔
203	});	2✔
204	if (this.min != min \|\| this.max != max) {	2!
205	this.min = min;	2✔
206	this.max = max;	2✔
207	}	2✔
208	}	2✔
209	}	3✔
210		1✔
211	replaceNoDataValueFromTexture(texture) {	1✔
212	const nodatavalue = this.layer.noDataValue;	2✔
213	if (nodatavalue == undefined) {	2✔
214	return;	2✔
215	}	2!
UNCOV 216	// replace no data value with parent texture value or 0 (if no significant value found).	×
217	const parentTexture = this.textures[0];	×
218	const parentDataElevation = parentTexture && parentTexture.image && parentTexture.image.data;	2!
219	const dataElevation = texture.image && texture.image.data;	2!
220		2✔
221	if (dataElevation && !checkNodeElevationTextureValidity(dataElevation, nodatavalue)) {	2!
UNCOV 222	insertSignificantValuesFromParent(dataElevation, parentDataElevation && dataParent(texture, parentTexture, parentDataElevation, pitch), nodatavalue);	×
223	}	×
224	}	2✔
225	}	1✔
226		1✔
UNCOV 227	function dataParent(texture, parentTexture, parentDataElevation, pitch) {	×
228	texture.extent.offsetToParent(parentTexture.extent, pitch);	×
229	return i => parentDataElevation[getIndiceWithPitch(i, pitch, 256)];	×
230	}	×

iTowns / itowns / 11954088408

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