9649841056

Committed 24 Jun 2024 05:33PM UTC coverage: 89.754% (+0.1%) from 89.614%

Build # 9649841056

Build Type

Pull #2137

github

Committed by

web-flow

Commit Message

Merge 71a1097ac into 58fc8bb38

Pull Request Pull Request #2137: feature: Add potree 2.0 parser

Run Details

2822 of 3719 branches covered (75.88%)

Branch coverage included in aggregate %.

1319 of 1413 new or added lines in 11 files covered. (93.35%)

1 existing line in 1 file now uncovered.

24613 of 26848 relevant lines covered (91.68%)

904.74 hits per line

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

98.32

/src/Parser/Potree2BinParser.js

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

let _thread;

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

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

function decoder(w, metadata) {
    return metadata.encoding === 'BROTLI' ? w.parseBrotli : w.parse;
}

export default {
    /**
     * @return {Promise<void>}
     */
    terminate() {
        const currentThread = _thread;
        _thread = undefined;
        return Thread.terminate(currentThread);
    },

    /** @module Potree2BinParser */
    /** Parse .bin PotreeConverter 2.0 format and convert to a THREE.BufferGeometry
     * @function parse
     * @param {ArrayBuffer} buffer - the bin buffer.
     * @param {Object} options
     * @param {string[]} options.in.pointAttributes - the point attributes information contained in metadata.js
     * @return {Promise} - a promise that resolves with a THREE.BufferGeometry.
     *
     */
    parse: async function parse(buffer, options) {
        const metadata = options.in.source.metadata;
        const layer = options.out;

        const pointAttributes = layer.pointAttributes;
        const scale = metadata.scale;
        const box = options.in.bbox;
        const min = box.min;
        const size = box.max.clone().sub(box.min);
        const max = box.max;
        const offset = metadata.offset;
        const numPoints = options.in.numPoints;

        const potreeLoader = await loader();
        const decode = decoder(potreeLoader, metadata);
        const data = await decode(Transfer(buffer), {
            pointAttributes,
            scale,
            min,
            max,
            size,
            offset,
            numPoints,
        });

        const buffers = data.attributeBuffers;
        const geometry = new THREE.BufferGeometry();
        Object.keys(buffers).forEach((property) => {
            const buffer = buffers[property].buffer;

            if (property === 'position') {
                geometry.setAttribute('position', new THREE.BufferAttribute(new Float32Array(buffer), 3));
            } else if (property === 'rgba') {
                geometry.setAttribute('color', new THREE.BufferAttribute(new Uint8Array(buffer), 4, true));
            } else if (property === 'NORMAL') {
                geometry.setAttribute('normal', new THREE.BufferAttribute(new Float32Array(buffer), 3));
            } else if (property === 'INDICES') {
                const bufferAttribute = new THREE.BufferAttribute(new Uint8Array(buffer), 4);
                bufferAttribute.normalized = true;
                geometry.setAttribute('indices', bufferAttribute);
            } else {
                const bufferAttribute = new THREE.BufferAttribute(new Float32Array(buffer), 1);

                const batchAttribute = buffers[property].attribute;
                bufferAttribute.potree = {
                    offset: buffers[property].offset,
                    scale: buffers[property].scale,
                    preciseBuffer: buffers[property].preciseBuffer,
                    range: batchAttribute.range,
                };

                geometry.setAttribute(property, bufferAttribute);
            }
        });

        geometry.computeBoundingBox();

        return { geometry, density: data.density };
    },
};

1	import * as THREE from 'three';	1✔
2	import { spawn, Thread, Transfer } from 'threads';	1✔
3		1✔
4	let _thread;	1✔
5		2✔
6	function workerInstance() {	2✔
7	return new Worker(	2✔
8	/* webpackChunkName: "itowns_potree2worker" */	2✔
9	new URL('../Worker/Potree2Worker.js', import.meta.url),	2✔
10	{ type: 'module' },	1✔
11	);	4✔
12	}	4✔
13		4✔
14	async function loader() {	4✔
15	if (_thread) { return _thread; }	2✔
16	_thread = await spawn(workerInstance());	1✔
17	return _thread;	4✔
18	}	4✔
19		4✔
20	function decoder(w, metadata) {	4✔
21	return metadata.encoding === 'BROTLI' ? w.parseBrotli : w.parse;	1✔
22	}	1✔
23		1✔
24	export default {	1✔
25	/**	1✔
26	* @return {Promise<void>}	1✔
27	*/	2✔
28	terminate() {	2✔
29	const currentThread = _thread;	2✔
30	_thread = undefined;	2✔
31	return Thread.terminate(currentThread);	1✔
32	},	1✔
33		1✔
34	/** @module Potree2BinParser */	1✔
35	/** Parse .bin PotreeConverter 2.0 format and convert to a THREE.BufferGeometry	1✔
36	* @function parse	1✔
37	* @param {ArrayBuffer} buffer - the bin buffer.	1✔
38	* @param {Object} options	1✔
39	* @param {string[]} options.in.pointAttributes - the point attributes information contained in metadata.js	1✔
40	* @return {Promise} - a promise that resolves with a THREE.BufferGeometry.	1✔
41	*	4✔
42	*/	4✔
43	parse: async function parse(buffer, options) {	4✔
44	const metadata = options.in.source.metadata;	4✔
45	const layer = options.out;	4✔
46		4✔
47	const pointAttributes = layer.pointAttributes;	4✔
48	const scale = metadata.scale;	4✔
49	const box = options.in.bbox;	4✔
50	const min = box.min;	4✔
51	const size = box.max.clone().sub(box.min);	4✔
52	const max = box.max;	4✔
53	const offset = metadata.offset;	4✔
54	const numPoints = options.in.numPoints;	4✔
55		4✔
56	const potreeLoader = await loader();	4✔
57	const decode = decoder(potreeLoader, metadata);	4✔
58	const data = await decode(Transfer(buffer), {	4✔
59	pointAttributes,	4✔
60	scale,	4✔
61	min,	4✔
62	max,	4✔
63	size,	4✔
64	offset,	29✔
65	numPoints,	29✔
66	});	29✔
67		29✔
68	const buffers = data.attributeBuffers;	29✔
69	const geometry = new THREE.BufferGeometry();	4✔
70	Object.keys(buffers).forEach((property) => {	29✔
71	const buffer = buffers[property].buffer;	25✔
72		3✔
73	if (property === 'position') {	3✔
74	geometry.setAttribute('position', new THREE.BufferAttribute(new Float32Array(buffer), 3));	25!
NEW 75	} else if (property === 'rgba') {	×
76	geometry.setAttribute('color', new THREE.BufferAttribute(new Uint8Array(buffer), 4, true));	22✔
77	} else if (property === 'NORMAL') {	4✔
78	geometry.setAttribute('normal', new THREE.BufferAttribute(new Float32Array(buffer), 3));	22✔
79	} else if (property === 'INDICES') {	18✔
80	const bufferAttribute = new THREE.BufferAttribute(new Uint8Array(buffer), 4);	18✔
81	bufferAttribute.normalized = true;	18✔
82	geometry.setAttribute('indices', bufferAttribute);	18✔
83	} else {	18✔
84	const bufferAttribute = new THREE.BufferAttribute(new Float32Array(buffer), 1);	18✔
85		18✔
86	const batchAttribute = buffers[property].attribute;	29✔
87	bufferAttribute.potree = {	4✔
88	offset: buffers[property].offset,	4✔
89	scale: buffers[property].scale,	1✔
90	preciseBuffer: buffers[property].preciseBuffer,	1✔
91	range: batchAttribute.range,	1✔
92	};	1✔
93		1✔
94	geometry.setAttribute(property, bufferAttribute);	1✔
95	}	1✔
96	});	1✔
97		1✔
98	geometry.computeBoundingBox();	1✔
99		1✔
100	return { geometry, density: data.density };	1✔
101	},	1✔
102	};	1✔

iTowns / itowns / 9649841056

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