8971439867

Committed 06 May 2024 03:12PM UTC coverage: 89.252% (-0.1%) from 89.361%

Build # 8971439867

Build Type

Pull #2303

github

Committed by

web-flow

Commit Message

Merge 3cd5b230d into d3a317b07

Pull Request Pull Request #2303: feat: introducing workers for LAS parser

Run Details

2719 of 3609 branches covered (75.34%)

Branch coverage included in aggregate %.

43 of 84 new or added lines in 5 files covered. (51.19%)

1 existing line in 1 file now uncovered.

23264 of 25503 relevant lines covered (91.22%)

342.02 hits per line

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

86.36

/src/Parser/LASParser.js

import * as THREE from 'three';
import LASLoader from 'Loader/LASLoader';
import LASWorkerLoader from 'Loader/LASWorkerLoader';

const lasLoader = new LASLoader();
const lasWorkerLoader = new LASWorkerLoader();

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

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

    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');
        }
        lasLoader.lazPerf = path;
        lasWorkerLoader.lazPerf = path;
    },

    /**
     * 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 {boolean} [options.in.worker=false] - Use workers for parsing in
     * the background and thus not blocking the main thread.
     * @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`.
     */
    parseChunk(data, options = {}) {
        const useWorker = options.in.worker ?? false;
        const loader = useWorker ? lasWorkerLoader : lasLoader;

        return loader.parseChunk(data, {
            pointCount: options.in.pointCount,
            header: options.in.header,
            eb: options.eb,
            colorDepth: options.in.colorDepth,
        }).then((parsedData) => {
            const geometry = buildBufferGeometry(parsedData.attributes);
            geometry.computeBoundingBox();
            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 {boolean} [options.in.worker=false] - Use workers for parsing in
     * the background and thus not blocking the main thread.
     * @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} A promise resolving with a `THREE.BufferGeometry`. The
     * header of the file is contained in `userData`.
     */
    parse(data, options = {}) {
        if (options.out?.skip) {
            console.warn("Warning: options 'skip' not supported anymore");
        }

        const input = options.in;
        const useWorker = input?.worker ?? false;
        const loader = useWorker ? lasWorkerLoader : lasLoader;

        return loader.parseFile(data, {
            colorDepth: input?.colorDepth,
        }).then((parsedData) => {
            const geometry = buildBufferGeometry(parsedData.attributes);
            geometry.userData.header = parsedData.header;
            geometry.computeBoundingBox();
            return geometry;
        });
    },
};

1	import * as THREE from 'three';	1✔
2	import LASLoader from 'Loader/LASLoader';	1✔
3	import LASWorkerLoader from 'Loader/LASWorkerLoader';	1✔
4		1✔
5	const lasLoader = new LASLoader();	1✔
6	const lasWorkerLoader = new LASWorkerLoader();	1✔
7		1✔
8	function buildBufferGeometry(attributes) {	1✔
9	const geometry = new THREE.BufferGeometry();	2✔
10		2✔
11	const positionBuffer = new THREE.BufferAttribute(attributes.position, 3);	2✔
12	geometry.setAttribute('position', positionBuffer);	2✔
13		2✔
14	const intensityBuffer = new THREE.BufferAttribute(attributes.intensity, 1);	2✔
15	geometry.setAttribute('intensity', intensityBuffer);	2✔
16		2✔
17	const returnNumber = new THREE.BufferAttribute(attributes.returnNumber, 1);	2✔
18	geometry.setAttribute('returnNumber', returnNumber);	2✔
19		2✔
20	const numberOfReturns = new THREE.BufferAttribute(attributes.numberOfReturns, 1);	2✔
21	geometry.setAttribute('numberOfReturns', numberOfReturns);	2✔
22		2✔
23	const classBuffer = new THREE.BufferAttribute(attributes.classification, 1);	2✔
24	geometry.setAttribute('classification', classBuffer);	2✔
25		2✔
26	const pointSourceID = new THREE.BufferAttribute(attributes.pointSourceID, 1);	2✔
27	geometry.setAttribute('pointSourceID', pointSourceID);	2✔
28		2✔
29	if (attributes.color) {	2✔
30	const colorBuffer = new THREE.BufferAttribute(attributes.color, 4, true);	1✔
31	geometry.setAttribute('color', colorBuffer);	2✔
32	}	2✔
33	const scanAngle = new THREE.BufferAttribute(attributes.scanAngle, 1);	2✔
34	geometry.setAttribute('scanAngle', scanAngle);	2✔
35		2✔
36	geometry.userData.origin = new THREE.Vector3().fromArray(attributes.origin);	1✔
37		1✔
38	return geometry;	1✔
39	}	1✔
40		1✔
41	/** The LASParser module provides a [parse]{@link	1✔
42	* module:LASParser.parse} method that takes a LAS or LAZ (LASZip) file in, and	1✔
43	* gives a `THREE.BufferGeometry` containing all the necessary attributes to be	1✔
44	* displayed in iTowns. It uses the	1✔
45	* [copc.js](https://github.com/connormanning/copc.js/) library.	1✔
46	*	1✔
47	* @module LASParser	1✔
48	*/	1✔
49	export default {	1✔
50	/*	1✔
51	* Set the laz-perf decoder path.	1✔
52	* @param {string} path - path to `laz-perf.wasm` folder.	1!
53	*/	×
54	enableLazPerf(path) {	×
UNCOV 55	if (!path) {	×
56	throw new Error('Path to laz-perf is mandatory');	2✔
57	}	2✔
58	lasLoader.lazPerf = path;	1✔
59	lasWorkerLoader.lazPerf = path;	1✔
60	},	1✔
61		1✔
62	/**	1✔
63	* Parses a chunk of a LAS or LAZ (LASZip) and returns the corresponding	1✔
64	* `THREE.BufferGeometry`.	1✔
65	*	1✔
66	* @param {ArrayBuffer} data - The file content to parse.	1✔
67	* @param {Object} options	1✔
68	* @param {Object} options.in - Options to give to the parser.	1✔
69	* @param {boolean} [options.in.worker=false] - Use workers for parsing in	1✔
70	* the background and thus not blocking the main thread.	1✔
71	* @param {number} options.in.pointCount - Number of points encoded in this	1✔
72	* data chunk.	1✔
73	* @param {Object} options.in.header - Partial LAS file header.	1✔
74	* @param {number} options.in.header.pointDataRecordFormat - Type of Point	1✔
75	* Data Record contained in the LAS file.	1✔
76	* @param {number} options.in.header.pointDataRecordLength - Size (in bytes)	1✔
77	* of the Point Data Record.	1✔
78	* @param {Object} [options.eb] - Extra bytes LAS VLRs headers.	1✔
79	* @param { 8 \| 16 } [options.in.colorDepth] - Color depth (in bits).	1✔
80	* Defaults to 8 bits for LAS 1.2 and 16 bits for later versions	1✔
81	* (as mandatory by the specification)	1✔
82	*	×
83	* @return {Promise<THREE.BufferGeometry>} A promise resolving with a	×
84	* `THREE.BufferGeometry`.	×
85	*/	×
86	parseChunk(data, options = {}) {	×
NEW 87	const useWorker = options.in.worker ?? false;	×
NEW 88	const loader = useWorker ? lasWorkerLoader : lasLoader;	×
NEW 89		×
NEW 90	return loader.parseChunk(data, {	×
NEW 91	pointCount: options.in.pointCount,	×
NEW 92	header: options.in.header,	×
NEW 93	eb: options.eb,	×
NEW 94	colorDepth: options.in.colorDepth,	×
NEW 95	}).then((parsedData) => {	×
96	const geometry = buildBufferGeometry(parsedData.attributes);	1✔
97	geometry.computeBoundingBox();	1✔
98	return geometry;	1✔
99	});	1✔
100	},	1✔
101		1✔
102	/**	1✔
103	* Parses a LAS file or a LAZ (LASZip) file and return the corresponding	1✔
104	* `THREE.BufferGeometry`.	1✔
105	*	1✔
106	* @param {ArrayBuffer} data - The file content to parse.	1✔
107	* @param {Object} [options]	1✔
108	* @param {Object} [options.in] - Options to give to the parser.	1✔
109	* @param {boolean} [options.in.worker=false] - Use workers for parsing in	1✔
110	* the background and thus not blocking the main thread.	1✔
111	* @param { 8 \| 16 } [options.in.colorDepth] - Color depth (in bits).	1✔
112	* Defaults to 8 bits for LAS 1.2 and 16 bits for later versions	1✔
113	* (as mandatory by the specification)	1✔
114	*	3✔
115	* @return {Promise} A promise resolving with a `THREE.BufferGeometry`. The	3✔
116	* header of the file is contained in `userData`.	3✔
117	*/	3✔
118	parse(data, options = {}) {	3✔
119	if (options.out?.skip) {	3✔
120	console.warn("Warning: options 'skip' not supported anymore");	3!
121	}	3✔
122		3✔
123	const input = options.in;	3✔
124	const useWorker = input?.worker ?? false;	3✔
125	const loader = useWorker ? lasWorkerLoader : lasLoader;	3!
NEW 126		×
127	return loader.parseFile(data, {	3✔
128	colorDepth: input?.colorDepth,	3✔
129	}).then((parsedData) => {	3✔
130	const geometry = buildBufferGeometry(parsedData.attributes);	3✔
131	geometry.userData.header = parsedData.header;	2✔
132	geometry.computeBoundingBox();	2✔
133	return geometry;	2✔
134	});	2✔
135	},	2✔
136	};	2✔

iTowns / itowns / 8971439867

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