9762270010

Committed 02 Jul 2024 01:52PM UTC coverage: 89.747% (+0.4%) from 89.361%

Build # 9762270010

Build Type

Pull #2325

github

Committed by

web-flow

Commit Message

Merge 3e70e9d5c into 624880d50

Pull Request Pull Request #2325: fix(PointCloud): use preSSE for C3DTilesLayer

Run Details

2823 of 3721 branches covered (75.87%)

Branch coverage included in aggregate %.

10 of 13 new or added lines in 4 files covered. (76.92%)

291 existing lines in 23 files now uncovered.

24617 of 26854 relevant lines covered (91.67%)

904.57 hits per line

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

73.26

/src/Provider/3dTilesProvider.js

import * as THREE from 'three';
import B3dmParser from 'Parser/B3dmParser';
import PntsParser from 'Parser/PntsParser';
import GLTFParser from 'Parser/GLTFParser';
import Fetcher from 'Provider/Fetcher';
import ReferLayerProperties from 'Layer/ReferencingLayerProperties';
import PointsMaterial from 'Renderer/PointsMaterial';

const utf8Decoder = new TextDecoder();

function b3dmToMesh(data, layer, url) {
    const urlBase = THREE.LoaderUtils.extractUrlBase(url);
    const options = {
        gltfUpAxis: layer.tileset.asset.gltfUpAxis,
        urlBase,
        overrideMaterials: layer.overrideMaterials,
        doNotPatchMaterial: layer.doNotPatchMaterial,
        registeredExtensions: layer.registeredExtensions,
        layer,
    };
    return B3dmParser.parse(data, options).then((result) => {
        const batchTable = result.batchTable;
        // object3d is actually a THREE.Scene
        const object3d = result.gltf.scene;
        return { batchTable, object3d };
    });
}

function gltfToMesh(data, layer, url) {
    const urlBase = THREE.LoaderUtils.extractUrlBase(url);
    return GLTFParser.parse(data, urlBase).then(result => ({ object3d: result.scene }));
}

function pntsParse(data, layer) {
    return PntsParser.parse(data, layer.registeredExtensions).then((result) => {
        const material = layer.material ?
            layer.material.clone() :
            new PointsMaterial({
                size: 1,
                mode: layer.pntsMode,
                shape: layer.pntsShape,
                classification: layer.classification,
                sizeMode: layer.pntsSizeMode,
                minAttenuatedSize: layer.pntsMinAttenuatedSize,
                maxAttenuatedSize: layer.pntsMaxAttenuatedSize,
            });

        // refer material properties in the layer so when layers opacity and visibility is updated, the material is
        // automatically updated
        ReferLayerProperties(material, layer);

        // creation points with geometry and material
        const points = new THREE.Points(result.point.geometry, material);

        if (result.point.offset) {
            points.position.copy(result.point.offset);
        }

        return { object3d: points,
            batchTable: result.batchTable,
        };
    });
}

export function configureTile(tile, layer, metadata, parent) {
    tile.frustumCulled = false;
    tile.layer = layer;

    // parse metadata
    if (metadata.transform) {
        tile.applyMatrix4(metadata.transform);
    }
    tile.geometricError = metadata.geometricError;
    tile.tileId = metadata.tileId;
    if (metadata.refine) {
        tile.additiveRefinement = (metadata.refine.toUpperCase() === 'ADD');
    } else {
        tile.additiveRefinement = parent ? (parent.additiveRefinement) : false;
    }
    tile.viewerRequestVolume = metadata.viewerRequestVolume;
    tile.boundingVolume = metadata.boundingVolume;
    tile.updateMatrixWorld();
}

function executeCommand(command) {
    const layer = command.layer;
    const metadata = command.metadata;
    const tile = new THREE.Object3D();
    configureTile(tile, layer, metadata, command.requester);
    // Patch for supporting 3D Tiles pre 1.0 (metadata.content.url) and 1.0
    // (metadata.content.uri)
    const path = metadata.content && (metadata.content.url || metadata.content.uri);

    const setLayer = (obj) => {
        obj.userData.metadata = metadata;
        obj.layer = layer;
    };
    if (path) {
        // Check if we have relative or absolute url (with tileset's lopocs for example)
        let url = path.startsWith('http') ? path : metadata.baseURL + path;
        if (layer.source.isC3DTilesGoogleSource) {
            url = layer.source.getTileUrl(url);
        }
        const supportedFormats = {
            b3dm: b3dmToMesh,
            pnts: pntsParse,
            gltf: gltfToMesh,
        };
        return Fetcher.arrayBuffer(url, layer.source.networkOptions).then((result) => {
            if (result !== undefined) {
                let func;
                const magic = utf8Decoder.decode(new Uint8Array(result, 0, 4));
                if (magic[0] === '{') {
                    result = JSON.parse(utf8Decoder.decode(new Uint8Array(result)));
                    // Another specifics of 3D tiles from Google: tilesets in tilesets are required from the root base
                    // url and not from their parent base url
                    const newPrefix = layer.source.isC3DTilesGoogleSource ? layer.source.baseUrl : url.slice(0, url.lastIndexOf('/') + 1);
                    layer.tileset.extendTileset(result, metadata.tileId, newPrefix, layer.registeredExtensions);
                } else if (magic == 'b3dm') {
                    func = supportedFormats.b3dm;
                } else if (magic == 'pnts') {
                    layer.hasPnts = true;
                    func = supportedFormats.pnts;
                } else if (magic == 'glTF') {
                    func = supportedFormats.gltf;
                } else {
                    return Promise.reject(`Unsupported magic code ${magic}`);
                }
                if (func) {
                    // TODO: request should be delayed if there is a viewerRequestVolume
                    return func(result, layer, url).then((content) => {
                        tile.content = content.object3d;
                        if (content.batchTable) {
                            tile.batchTable = content.batchTable;
                        }
                        tile.add(content.object3d);
                        tile.traverse(setLayer);
                        return tile;
                    });
                }
            }
            tile.traverse(setLayer);
            return tile;
        });
    } else {
        tile.traverse(setLayer);
        return Promise.resolve(tile);
    }
}

export default {
    executeCommand,
};

1	import * as THREE from 'three';	1✔
2	import B3dmParser from 'Parser/B3dmParser';	1✔
3	import PntsParser from 'Parser/PntsParser';	1✔
4	import GLTFParser from 'Parser/GLTFParser';	1✔
5	import Fetcher from 'Provider/Fetcher';	1✔
6	import ReferLayerProperties from 'Layer/ReferencingLayerProperties';	1✔
7	import PointsMaterial from 'Renderer/PointsMaterial';	1✔
8		1✔
9	const utf8Decoder = new TextDecoder();	1✔
10		1✔
11	function b3dmToMesh(data, layer, url) {	1✔
12	const urlBase = THREE.LoaderUtils.extractUrlBase(url);	3✔
13	const options = {	3✔
14	gltfUpAxis: layer.tileset.asset.gltfUpAxis,	3✔
15	urlBase,	3✔
16	overrideMaterials: layer.overrideMaterials,	3✔
17	doNotPatchMaterial: layer.doNotPatchMaterial,	3✔
18	registeredExtensions: layer.registeredExtensions,	3✔
19	layer,	3✔
20	};	3✔
21	return B3dmParser.parse(data, options).then((result) => {	3✔
22	const batchTable = result.batchTable;	3✔
23	// object3d is actually a THREE.Scene	3✔
24	const object3d = result.gltf.scene;	3✔
25	return { batchTable, object3d };	1✔
26	});	×
27	}	×
28		×
29	function gltfToMesh(data, layer, url) {	×
30	const urlBase = THREE.LoaderUtils.extractUrlBase(url);	×
31	return GLTFParser.parse(data, urlBase).then(result => ({ object3d: result.scene }));	1✔
32	}	×
33		×
34	function pntsParse(data, layer) {	×
35	return PntsParser.parse(data, layer.registeredExtensions).then((result) => {	×
36	const material = layer.material ?	×
37	layer.material.clone() :	×
38	new PointsMaterial({	×
NEW 39	size: 1,	×
40	mode: layer.pntsMode,	×
41	shape: layer.pntsShape,	×
42	classification: layer.classification,	×
43	sizeMode: layer.pntsSizeMode,	×
44	minAttenuatedSize: layer.pntsMinAttenuatedSize,	×
45	maxAttenuatedSize: layer.pntsMaxAttenuatedSize,	×
46	});	×
47		×
48	// refer material properties in the layer so when layers opacity and visibility is updated, the material is	×
49	// automatically updated	×
50	ReferLayerProperties(material, layer);	×
51		×
52	// creation points with geometry and material	×
53	const points = new THREE.Points(result.point.geometry, material);	×
54		×
55	if (result.point.offset) {	1✔
56	points.position.copy(result.point.offset);	1✔
57	}	9✔
58		9✔
59	return { object3d: points,	9✔
60	batchTable: result.batchTable,	9✔
61	};	9✔
62	});	9✔
63	}	5✔
64		5✔
65	export function configureTile(tile, layer, metadata, parent) {	9✔
66	tile.frustumCulled = false;	9✔
67	tile.layer = layer;	9✔
68		9✔
69	// parse metadata	9✔
70	if (metadata.transform) {	9✔
71	tile.applyMatrix4(metadata.transform);	2✔
72	}	9✔
73	tile.geometricError = metadata.geometricError;	7✔
74	tile.tileId = metadata.tileId;	9✔
75	if (metadata.refine) {	9✔
76	tile.additiveRefinement = (metadata.refine.toUpperCase() === 'ADD');	9✔
77	} else {	9✔
78	tile.additiveRefinement = parent ? (parent.additiveRefinement) : false;	1✔
79	}	3✔
80	tile.viewerRequestVolume = metadata.viewerRequestVolume;	3✔
81	tile.boundingVolume = metadata.boundingVolume;	3✔
82	tile.updateMatrixWorld();	3✔
83	}	3✔
84		3✔
85	function executeCommand(command) {	3✔
86	const layer = command.layer;	3✔
87	const metadata = command.metadata;	3✔
88	const tile = new THREE.Object3D();	3✔
89	configureTile(tile, layer, metadata, command.requester);	3✔
90	// Patch for supporting 3D Tiles pre 1.0 (metadata.content.url) and 1.0	3✔
91	// (metadata.content.uri)	3✔
92	const path = metadata.content && (metadata.content.url \|\| metadata.content.uri);	3✔
93		3✔
94	const setLayer = (obj) => {	3!
95	obj.userData.metadata = metadata;	3✔
96	obj.layer = layer;	3!
97	};	×
98	if (path) {	×
99	// Check if we have relative or absolute url (with tileset's lopocs for example)	3✔
100	let url = path.startsWith('http') ? path : metadata.baseURL + path;	3✔
101	if (layer.source.isC3DTilesGoogleSource) {	3✔
102	url = layer.source.getTileUrl(url);	3✔
103	}	3✔
104	const supportedFormats = {	3✔
105	b3dm: b3dmToMesh,	3✔
106	pnts: pntsParse,	3!
107	gltf: gltfToMesh,	×
108	};	×
109	return Fetcher.arrayBuffer(url, layer.source.networkOptions).then((result) => {	×
110	if (result !== undefined) {	×
111	let func;	×
112	const magic = utf8Decoder.decode(new Uint8Array(result, 0, 4));	×
113	if (magic[0] === '{') {	×
114	result = JSON.parse(utf8Decoder.decode(new Uint8Array(result)));	×
115	// Another specifics of 3D tiles from Google: tilesets in tilesets are required from the root base	3✔
116	// url and not from their parent base url	3!
117	const newPrefix = layer.source.isC3DTilesGoogleSource ? layer.source.baseUrl : url.slice(0, url.lastIndexOf('/') + 1);	×
118	layer.tileset.extendTileset(result, metadata.tileId, newPrefix, layer.registeredExtensions);	3✔
119	} else if (magic == 'b3dm') {	3✔
120	func = supportedFormats.b3dm;	3✔
121	} else if (magic == 'pnts') {	3✔
122	layer.hasPnts = true;	3✔
123	func = supportedFormats.pnts;	3✔
124	} else if (magic == 'glTF') {	3✔
125	func = supportedFormats.gltf;	3✔
126	} else {	3✔
127	return Promise.reject(`Unsupported magic code ${magic}`);	3!
128	}	×
129	if (func) {	3✔
130	// TODO: request should be delayed if there is a viewerRequestVolume	1!
131	return func(result, layer, url).then((content) => {	1✔
132	tile.content = content.object3d;	1✔
133	if (content.batchTable) {	1✔
134	tile.batchTable = content.batchTable;	1✔
135	}	1✔
136	tile.add(content.object3d);	1✔
137	tile.traverse(setLayer);	1✔
138	return tile;	1✔
139	});	1✔
140	}	1✔
141	}	1✔
142	tile.traverse(setLayer);	1✔
143	return tile;	1✔
144	});	1✔
145	} else {	1✔
146	tile.traverse(setLayer);	1✔
147	return Promise.resolve(tile);	1✔
148	}	1✔
149	}	1✔
150		1✔
151	export default {	1✔
152	executeCommand,	1✔
153	};	1✔

iTowns / itowns / 9762270010

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