9991651740

Committed 18 Jul 2024 12:38PM UTC coverage: 89.728% (-0.04%) from 89.764%

Build # 9991651740

Build Type

Pull #2272

github

Committed by

web-flow

Commit Message

Merge 70d5619b4 into 982b908a4

Pull Request Pull Request #2272: Entwine a la volee

Run Details

2873 of 3767 branches covered (76.27%)

Branch coverage included in aggregate %.

448 of 546 new or added lines in 14 files covered. (82.05%)

26 existing lines in 5 files now uncovered.

25070 of 27375 relevant lines covered (91.58%)

906.77 hits per line

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

89.12

/src/Parser/LASParser.js

import * as THREE from 'three';
import { spawn, Thread, Transfer } from 'threads';
import proj4 from 'proj4';

let _lazPerf;
let _thread;

function workerInstance() {
    return new Worker(
        /* webpackChunkName: "itowns_lasparser" */
        new URL('../Worker/LASLoaderWorker.js', import.meta.url),
        { type: 'module' },
    );
}

async function loader() {
    if (_thread) { return _thread; }
    _thread = await spawn(workerInstance());
    if (_lazPerf) { _thread.lazPerf(_lazPerf); }
    return _thread;
}

function buildBufferGeometry(attributes) {
    const geometry = new THREE.BufferGeometry();

    const positionBuffer = new THREE.BufferAttribute(attributes.position, 3);
    geometry.setAttribute('position', positionBuffer);
    const elevationBuffer = new THREE.BufferAttribute(attributes.elevation, 1);
    geometry.setAttribute('elevation', elevationBuffer);

    const intensityBuffer = new THREE.BufferAttribute(attributes.intensity, 1);
    geometry.setAttribute('intensity', intensityBuffer);

    const returnNumber = new THREE.BufferAttribute(attributes.returnNumber, 1);
    geometry.setAttribute('returnNumber', returnNumber);

    const numberOfReturns = new THREE.BufferAttribute(attributes.numberOfReturns, 1);
    geometry.setAttribute('numberOfReturns', numberOfReturns);

    const classBuffer = new THREE.BufferAttribute(attributes.classification, 1);
    geometry.setAttribute('classification', classBuffer);

    const pointSourceID = new THREE.BufferAttribute(attributes.pointSourceID, 1);
    geometry.setAttribute('pointSourceID', pointSourceID);

    if (attributes.color) {
        const colorBuffer = new THREE.BufferAttribute(attributes.color, 4, true);
        geometry.setAttribute('color', colorBuffer);
    }
    const scanAngle = new THREE.BufferAttribute(attributes.scanAngle, 1);
    geometry.setAttribute('scanAngle', scanAngle);

    geometry.userData.origin = new THREE.Vector3().fromArray(attributes.origin);

    return geometry;
}

/** The LASParser module provides a [parse]{@link
 * module:LASParser.parse} method that takes a LAS or LAZ (LASZip) file in, and
 * gives a `THREE.BufferGeometry` containing all the necessary attributes to be
 * displayed in iTowns. It uses the
 * [copc.js](https://github.com/connormanning/copc.js/) library.
 *
 * @module LASParser
 */
export default {
    /*
     * Set the laz-perf decoder path.
     * @param {string} path - path to `laz-perf.wasm` folder.
     */
    enableLazPerf(path) {
        if (!path) {
            throw new Error('Path to laz-perf is mandatory');
        }
        _lazPerf = path;
    },

    /**
     * Terminate all worker instances.
     * @returns {Promise<void>}
     */
    terminate() {
        const currentThread = _thread;
        _thread = undefined;
        return Thread.terminate(currentThread);
    },

    /**
     * Parses a chunk of a LAS or LAZ (LASZip) and returns the corresponding
     * `THREE.BufferGeometry`.
     *
     * @param {ArrayBuffer} data - The file content to parse.
     * @param {Object} options
     * @param {Object} options.in - Options to give to the parser.
     * @param {number} options.in.pointCount - Number of points encoded in this
     * data chunk.
     * @param {Object} options.in.header - Partial LAS file header.
     * @param {number} options.in.header.pointDataRecordFormat - Type of Point
     * Data Record contained in the LAS file.
     * @param {number} options.in.header.pointDataRecordLength - Size (in bytes)
     * of the Point Data Record.
     * @param {Object} [options.eb] - Extra bytes LAS VLRs headers.
     * @param { 8 | 16 } [options.in.colorDepth] - Color depth (in bits).
     * Defaults to 8 bits for LAS 1.2 and 16 bits for later versions
     * (as mandatory by the specification)
     *
     * @return {Promise<THREE.BufferGeometry>} A promise resolving with a
     * `THREE.BufferGeometry`.
     */
    async parseChunk(data, options = {}) {
        const crsIn = options.in?.crs || 'EPSG:3857';
        const crsOut = options.out?.crs || crsIn;

        const lasLoader = await loader();
        const parsedData = await lasLoader.parseChunk(Transfer(data), {
            pointCount: options.in.pointCount,
            header: options.in.header,
            eb: options.eb,
            colorDepth: options.in.colorDepth,
            crsIn,
            crsOut,
            projDefs: {
                [crsIn]: proj4.defs(crsIn),
                [crsOut]: proj4.defs(crsOut),
            },
        });

        const geometry = buildBufferGeometry(parsedData.attributes);
        return geometry;
    },

    /**
     * Parses a LAS file or a LAZ (LASZip) file and return the corresponding
     * `THREE.BufferGeometry`.
     *
     * @param {ArrayBuffer} data - The file content to parse.
     * @param {Object} [options]
     * @param {Object} [options.in] - Options to give to the parser.
     * @param { 8 | 16 } [options.in.colorDepth] - Color depth (in bits).
     * Defaults to 8 bits for LAS 1.2 and 16 bits for later versions
     * (as mandatory by the specification)
     * @param {String} [options.in.crs = 'EPSG:3857'] - Crs of the source if any.
     * @param {String} [options.out.crs = options.in.crs] - Crs of the view if any.
     *
     * @return {Promise} A promise resolving with a `THREE.BufferGeometry`. The
     * header of the file is contained in `userData`.
     */
    async parse(data, options = {}) {
        if (options.out?.skip) {
            console.warn("Warning: options 'skip' not supported anymore");
        }

        const crsIn = options.in?.crs || 'EPSG:3857';
        const crsOut = options.out?.crs || crsIn;

        const lasLoader = await loader();
        const parsedData = await lasLoader.parseFile(Transfer(data), {
            colorDepth: options.in?.colorDepth,
            crsIn,
            crsOut,
            projDefs: {
                [crsIn]: proj4.defs(crsIn),
                [crsOut]: proj4.defs(crsOut),
            },
        });

        const geometry = buildBufferGeometry(parsedData.attributes);
        geometry.userData.header = parsedData.header;
        return geometry;
    },
};

1	import * as THREE from 'three';	1✔
2	import { spawn, Thread, Transfer } from 'threads';	1✔
3	import proj4 from 'proj4';	1✔
4		1✔
5	let _lazPerf;	1✔
6	let _thread;	1✔
7		3✔
8	function workerInstance() {	3✔
9	return new Worker(	3✔
10	/* webpackChunkName: "itowns_lasparser" */	3✔
11	new URL('../Worker/LASLoaderWorker.js', import.meta.url),	3✔
12	{ type: 'module' },	1✔
13	);	4✔
14	}	4✔
15		4✔
16	async function loader() {	4✔
17	if (_thread) { return _thread; }	4✔
18	_thread = await spawn(workerInstance());	3✔
19	if (_lazPerf) { _thread.lazPerf(_lazPerf); }	1✔
20	return _thread;	2✔
21	}	2✔
22		2✔
23	function buildBufferGeometry(attributes) {	2✔
24	const geometry = new THREE.BufferGeometry();	2✔
25		2✔
26	const positionBuffer = new THREE.BufferAttribute(attributes.position, 3);	2✔
27	geometry.setAttribute('position', positionBuffer);	2✔
28	const elevationBuffer = new THREE.BufferAttribute(attributes.elevation, 1);	2✔
29	geometry.setAttribute('elevation', elevationBuffer);	2✔
30		2✔
31	const intensityBuffer = new THREE.BufferAttribute(attributes.intensity, 1);	2✔
32	geometry.setAttribute('intensity', intensityBuffer);	2✔
33		2✔
34	const returnNumber = new THREE.BufferAttribute(attributes.returnNumber, 1);	2✔
35	geometry.setAttribute('returnNumber', returnNumber);	2✔
36		2✔
37	const numberOfReturns = new THREE.BufferAttribute(attributes.numberOfReturns, 1);	2✔
38	geometry.setAttribute('numberOfReturns', numberOfReturns);	2✔
39		2✔
40	const classBuffer = new THREE.BufferAttribute(attributes.classification, 1);	2✔
41	geometry.setAttribute('classification', classBuffer);	2✔
42		2✔
43	const pointSourceID = new THREE.BufferAttribute(attributes.pointSourceID, 1);	2✔
44	geometry.setAttribute('pointSourceID', pointSourceID);	2✔
45		1✔
46	if (attributes.color) {	1✔
47	const colorBuffer = new THREE.BufferAttribute(attributes.color, 4, true);	2✔
48	geometry.setAttribute('color', colorBuffer);	2✔
49	}	2✔
50	const scanAngle = new THREE.BufferAttribute(attributes.scanAngle, 1);	2✔
51	geometry.setAttribute('scanAngle', scanAngle);	2✔
52		2✔
53	geometry.userData.origin = new THREE.Vector3().fromArray(attributes.origin);	1✔
54		1✔
55	return geometry;	1✔
56	}	1✔
57		1✔
58	/** The LASParser module provides a [parse]{@link	1✔
59	* module:LASParser.parse} method that takes a LAS or LAZ (LASZip) file in, and	1✔
60	* gives a `THREE.BufferGeometry` containing all the necessary attributes to be	1✔
61	* displayed in iTowns. It uses the	1✔
62	* [copc.js](https://github.com/connormanning/copc.js/) library.	1✔
63	*	1✔
64	* @module LASParser	1✔
65	*/	1✔
66	export default {	1✔
67	/*	1✔
68	* Set the laz-perf decoder path.	1✔
69	* @param {string} path - path to `laz-perf.wasm` folder.	3!
70	*/	×
71	enableLazPerf(path) {	3✔
72	if (!path) {	1✔
73	throw new Error('Path to laz-perf is mandatory');	1✔
74	}	1✔
75	_lazPerf = path;	3✔
76	},	3✔
77		3✔
78	/**	3✔
79	* Terminate all worker instances.	3✔
80	* @returns {Promise<void>}	3✔
81	*/	3✔
82	terminate() {	1✔
83	const currentThread = _thread;	1✔
84	_thread = undefined;	1✔
85	return Thread.terminate(currentThread);	1✔
86	},	1✔
87		1✔
88	/**	1✔
89	* Parses a chunk of a LAS or LAZ (LASZip) and returns the corresponding	1✔
90	* `THREE.BufferGeometry`.	1✔
91	*	1✔
92	* @param {ArrayBuffer} data - The file content to parse.	1✔
93	* @param {Object} options	1✔
94	* @param {Object} options.in - Options to give to the parser.	1✔
95	* @param {number} options.in.pointCount - Number of points encoded in this	1✔
96	* data chunk.	1✔
97	* @param {Object} options.in.header - Partial LAS file header.	1✔
98	* @param {number} options.in.header.pointDataRecordFormat - Type of Point	1✔
99	* Data Record contained in the LAS file.	1✔
100	* @param {number} options.in.header.pointDataRecordLength - Size (in bytes)	1✔
101	* of the Point Data Record.	1✔
102	* @param {Object} [options.eb] - Extra bytes LAS VLRs headers.	1✔
103	* @param { 8 \| 16 } [options.in.colorDepth] - Color depth (in bits).	1✔
104	* Defaults to 8 bits for LAS 1.2 and 16 bits for later versions	1✔
105	* (as mandatory by the specification)	×
106	*	×
107	* @return {Promise<THREE.BufferGeometry>} A promise resolving with a	×
108	* `THREE.BufferGeometry`.	×
109	*/	×
110	async parseChunk(data, options = {}) {	×
NEW 111	const crsIn = options.in?.crs \|\| 'EPSG:3857';	×
NEW 112	const crsOut = options.out?.crs \|\| crsIn;	×
NEW 113		×
114	const lasLoader = await loader();	×
115	const parsedData = await lasLoader.parseChunk(Transfer(data), {	×
116	pointCount: options.in.pointCount,	×
117	header: options.in.header,	×
118	eb: options.eb,	×
UNCOV 119	colorDepth: options.in.colorDepth,	×
NEW 120	crsIn,	×
NEW 121	crsOut,	×
NEW 122	projDefs: {	×
123	[crsIn]: proj4.defs(crsIn),	1✔
124	[crsOut]: proj4.defs(crsOut),	1✔
125	},	1✔
126	});	1✔
127		1✔
128	const geometry = buildBufferGeometry(parsedData.attributes);	1✔
129	return geometry;	1✔
130	},	1✔
131		1✔
132	/**	1✔
133	* Parses a LAS file or a LAZ (LASZip) file and return the corresponding	1✔
134	* `THREE.BufferGeometry`.	1✔
135	*	1✔
136	* @param {ArrayBuffer} data - The file content to parse.	1✔
137	* @param {Object} [options]	1✔
138	* @param {Object} [options.in] - Options to give to the parser.	1✔
139	* @param { 8 \| 16 } [options.in.colorDepth] - Color depth (in bits).	1✔
140	* Defaults to 8 bits for LAS 1.2 and 16 bits for later versions	1✔
141	* (as mandatory by the specification)	1✔
142	* @param {String} [options.in.crs = 'EPSG:3857'] - Crs of the source if any.	1✔
143	* @param {String} [options.out.crs = options.in.crs] - Crs of the view if any.	4✔
144	*	2✔
145	* @return {Promise} A promise resolving with a `THREE.BufferGeometry`. The	4!
146	* header of the file is contained in `userData`.	4✔
147	*/	4✔
148	async parse(data, options = {}) {	4✔
149	if (options.out?.skip) {	4✔
150	console.warn("Warning: options 'skip' not supported anymore");	4✔
151	}	4✔
152		4✔
153	const crsIn = options.in?.crs \|\| 'EPSG:3857';	4✔
154	const crsOut = options.out?.crs \|\| crsIn;	4✔
155		4✔
156	const lasLoader = await loader();	4✔
157	const parsedData = await lasLoader.parseFile(Transfer(data), {	4✔
158	colorDepth: options.in?.colorDepth,	2✔
159	crsIn,	2✔
160	crsOut,	2✔
161	projDefs: {	2✔
162	[crsIn]: proj4.defs(crsIn),	1✔
163	[crsOut]: proj4.defs(crsOut),	1✔
164	},	1✔
165	});	1✔
166		1✔
167	const geometry = buildBufferGeometry(parsedData.attributes);	1✔
168	geometry.userData.header = parsedData.header;	1✔
169	return geometry;	1✔
170	},	1✔
171	};	1✔

iTowns / itowns / 9991651740

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