10177211096

Committed 31 Jul 2024 08:59AM UTC coverage: 89.789% (+0.02%) from 89.766%

Build # 10177211096

Build Type

Pull #2374

github

Committed by

web-flow

Commit Message

Merge 136f7878a into d09120714

Pull Request Pull Request #2374: Filtre point

Run Details

2847 of 3739 branches covered (76.14%)

Branch coverage included in aggregate %.

46 of 46 new or added lines in 2 files covered. (100.0%)

16 existing lines in 2 files now uncovered.

24747 of 26993 relevant lines covered (91.68%)

900.05 hits per line

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

78.57

/src/Layer/PointCloudLayer.js

import * as THREE from 'three';
import GeometryLayer from 'Layer/GeometryLayer';
import PointsMaterial, { PNTS_MODE } from 'Renderer/PointsMaterial';
import Picking from 'Core/Picking';

const point = new THREE.Vector3();
const bboxMesh = new THREE.Mesh();
const box3 = new THREE.Box3();
bboxMesh.geometry.boundingBox = box3;

function initBoundingBox(elt, layer) {
    elt.tightbbox.getSize(box3.max);
    box3.max.multiplyScalar(0.5);
    box3.min.copy(box3.max).negate();
    elt.obj.boxHelper = new THREE.BoxHelper(bboxMesh);
    elt.obj.boxHelper.geometry = elt.obj.boxHelper.geometry.toNonIndexed();
    elt.obj.boxHelper.computeLineDistances();
    elt.obj.boxHelper.material = elt.childrenBitField ? new THREE.LineDashedMaterial({ dashSize: 0.25, gapSize: 0.25 }) : new THREE.LineBasicMaterial();
    elt.obj.boxHelper.material.color.setHex(0);
    elt.obj.boxHelper.material.linewidth = 2;
    elt.obj.boxHelper.frustumCulled = false;
    elt.obj.boxHelper.position.copy(elt.tightbbox.min).add(box3.max);
    elt.obj.boxHelper.autoUpdateMatrix = false;
    layer.bboxes.add(elt.obj.boxHelper);
    elt.obj.boxHelper.updateMatrix();
    elt.obj.boxHelper.updateMatrixWorld();
}

function computeSSEPerspective(context, pointSize, spacing, elt, distance) {
    if (distance <= 0) {
        return Infinity;
    }
    const pointSpacing = spacing / 2 ** elt.depth;
    // Estimate the onscreen distance between 2 points
    const onScreenSpacing = context.camera.preSSE * pointSpacing / distance;
    // [  P1  ]--------------[   P2   ]
    //     <--------------------->      = pointsSpacing (in world coordinates)
    //                                  ~ onScreenSpacing (in pixels)
    // <------>                         = pointSize (in pixels)
    return Math.max(0.0, onScreenSpacing - pointSize);
}

function computeSSEOrthographic(context, pointSize, spacing, elt) {
    const pointSpacing = spacing / 2 ** elt.depth;

    // Given an identity view matrix, project pointSpacing from world space to
    // clip space. v' = vVP = vP
    const v = new THREE.Vector4(pointSpacing);
    v.applyMatrix4(context.camera.camera3D.projectionMatrix);

    // We map v' to the screen space and calculate the distance to the origin.
    const dx = v.x * 0.5 * context.camera.width;
    const dy = v.y * 0.5 * context.camera.height;
    const distance = Math.sqrt(dx * dx + dy * dy);

    return Math.max(0.0, distance - pointSize);
}

function computeScreenSpaceError(context, pointSize, spacing, elt, distance) {
    if (context.camera.camera3D.isOrthographicCamera) {
        return computeSSEOrthographic(context, pointSize, spacing, elt);
    }

    return computeSSEPerspective(context, pointSize, spacing, elt, distance);
}

function markForDeletion(elt) {
    if (elt.obj) {
        elt.obj.visible = false;
        if (__DEBUG__) {
            if (elt.obj.boxHelper) {
                elt.obj.boxHelper.visible = false;
            }
        }
    }

    if (!elt.notVisibleSince) {
        elt.notVisibleSince = Date.now();
        // Set .sse to an invalid value
        elt.sse = -1;
    }
    for (const child of elt.children) {
        markForDeletion(child);
    }
}

function changeIntensityRange(layer) {
    layer.material.intensityRange?.set(layer.minIntensityRange, layer.maxIntensityRange);
}

function changeElevationRange(layer) {
    layer.material.elevationRange?.set(layer.minElevationRange, layer.maxElevationRange);
}

function changeAngleRange(layer) {
    layer.material.angleRange?.set(layer.minAngleRange, layer.maxAngleRange);
}

/**
 * The basis for all point clouds related layers.
 *
 * @property {boolean} isPointCloudLayer - Used to checkout whether this layer
 * is a PointCloudLayer. Default is `true`. You should not change this, as it is
 * used internally for optimisation.
 * @property {THREE.Group|THREE.Object3D} group - Contains the created
 * `THREE.Points` meshes, usually with an instance of a `THREE.Points` per node.
 * @property {THREE.Group|THREE.Object3D} bboxes - Contains the bounding boxes
 * (`THREE.Box3`) of the tree, usually one per node.
 * @property {number} octreeDepthLimit - The depth limit at which to stop
 * browsing the octree. Can be used to limit the browsing, without having to
 * edit manually the source of the point cloud. No limit by default (`-1`).
 * @property {number} [pointBudget=2000000] - Maximum number of points to
 * display at the same time. This influences the performance of rendering.
 * Default to two millions points.
 * @property {number} [sseThreshold=2] - Threshold of the **S**creen **S**pace
 * **E**rror. Default to `2`.
 * @property {number} [pointSize=4] - The size (in pixels) of the points.
 * Default to `4`.
 * @property {THREE.Material|PointsMaterial} [material=new PointsMaterial] - The
 * material to use to display the points of the cloud. Be default it is a new
 * `PointsMaterial`.
 * @property {number} [mode=PNTS_MODE.COLOR] - The displaying mode of the points.
 * Values are specified in `PointsMaterial`.
 * @property {number} [minIntensityRange=0] - The minimal intensity of the
 * layer. Changing this value will affect the material, if it has the
 * corresponding uniform. The value is normalized between 0 and 1.
 * @property {number} [maxIntensityRange=1] - The maximal intensity of the
 * layer. Changing this value will affect the material, if it has the
 * corresponding uniform. The value is normalized between 0 and 1.
 */
class PointCloudLayer extends GeometryLayer {
    /**
     * Constructs a new instance of point cloud layer.
     * Constructs a new instance of a Point Cloud Layer. This should not be used
     * directly, but rather implemented using `extends`.
     *
     * @constructor
     * @extends GeometryLayer
     *
     * @param {string} id - The id of the layer, that should be unique. It is
     * not mandatory, but an error will be emitted if this layer is added a
     * {@link View} that already has a layer going by that id.
     * @param {Object} [config] - Optional configuration, all elements in it
     * will be merged as is in the layer. For example, if the configuration
     * contains three elements `name, protocol, extent`, these elements will be
     * available using `layer.name` or something else depending on the property
     * name. See the list of properties to know which one can be specified.
     */
    constructor(id, config = {}) {
        super(id, config.object3d || new THREE.Group(), config);
        this.isPointCloudLayer = true;
        this.protocol = 'pointcloud';

        this.group = config.group || new THREE.Group();
        this.object3d.add(this.group);
        this.bboxes = config.bboxes || new THREE.Group();
        this.bboxes.visible = false;
        this.object3d.add(this.bboxes);
        this.group.updateMatrixWorld();

        // default config
        this.octreeDepthLimit = config.octreeDepthLimit || -1;
        this.pointBudget = config.pointBudget || 2000000;
        this.pointSize = config.pointSize === 0 || !isNaN(config.pointSize) ? config.pointSize : 4;
        this.sseThreshold = config.sseThreshold || 2;

        this.defineLayerProperty('minIntensityRange', config.minIntensityRange || 1, changeIntensityRange);
        this.defineLayerProperty('maxIntensityRange', config.maxIntensityRange || 65536, changeIntensityRange);
        this.defineLayerProperty('minElevationRange', config.minElevationRange || 0, changeElevationRange);
        this.defineLayerProperty('maxElevationRange', config.maxElevationRange || 1000, changeElevationRange);
        this.defineLayerProperty('minAngleRange', config.minAngleRange || -90, changeAngleRange);
        this.defineLayerProperty('maxAngleRange', config.maxAngleRange || 90, changeAngleRange);

        this.material = config.material || {};
        if (!this.material.isMaterial) {
            config.material = config.material || {};
            config.material.intensityRange = new THREE.Vector2(this.minIntensityRange, this.maxIntensityRange);
            config.material.elevationRange = new THREE.Vector2(this.minElevationRange, this.maxElevationRange);
            config.material.angleRange = new THREE.Vector2(this.minAngleRange, this.maxAngleRange);
            this.material = new PointsMaterial(config.material);
        }
        this.material.defines = this.material.defines || {};

        this.mode = config.mode || PNTS_MODE.COLOR;
    }

    preUpdate(context, changeSources) {
        // See https://cesiumjs.org/hosted-apps/massiveworlds/downloads/Ring/WorldScaleTerrainRendering.pptx
        // slide 17
        context.camera.preSSE =
            context.camera.height /
                (2 * Math.tan(THREE.MathUtils.degToRad(context.camera.camera3D.fov) * 0.5));

        if (this.material) {
            this.material.visible = this.visible;
            this.material.opacity = this.opacity;
            this.material.transparent = this.opacity < 1 || this.material.userData.needTransparency[this.material.mode];
            this.material.size = this.pointSize;
            this.material.scale = context.camera.preSSE;
            if (this.material.updateUniforms) {
                this.material.updateUniforms();
            }
        }

        // lookup lowest common ancestor of changeSources
        let commonAncestor;
        for (const source of changeSources.values()) {
            if (source.isCamera || source == this) {
                // if the change is caused by a camera move, no need to bother
                // to find common ancestor: we need to update the whole tree:
                // some invisible tiles may now be visible
                return [this.root];
            }
            if (source.obj === undefined) {
                continue;
            }
            // filter sources that belong to our layer
            if (source.obj.isPoints && source.obj.layer == this) {
                if (!commonAncestor) {
                    commonAncestor = source;
                } else {
                    commonAncestor = source.findCommonAncestor(commonAncestor);

                    if (!commonAncestor) {
                        return [this.root];
                    }
                }
            }
        }

        if (commonAncestor) {
            return [commonAncestor];
        }

        // Start updating from hierarchy root
        return [this.root];
    }

    update(context, layer, elt) {
        elt.visible = false;

        if (this.octreeDepthLimit >= 0 && this.octreeDepthLimit < elt.depth) {
            markForDeletion(elt);
            return;
        }

        // pick the best bounding box
        const bbox = (elt.tightbbox ? elt.tightbbox : elt.bbox);
        elt.visible = context.camera.isBox3Visible(bbox, this.object3d.matrixWorld);
        if (!elt.visible) {
            markForDeletion(elt);
            return;
        }

        elt.notVisibleSince = undefined;
        point.copy(context.camera.camera3D.position).sub(this.object3d.position);

        // only load geometry if this elements has points
        if (elt.numPoints !== 0) {
            if (elt.obj) {
                elt.obj.visible = true;

                if (__DEBUG__) {
                    if (this.bboxes.visible) {
                        if (!elt.obj.boxHelper) {
                            initBoundingBox(elt, layer);
                        }
                        elt.obj.boxHelper.visible = true;
                        elt.obj.boxHelper.material.color.r = 1 - elt.sse;
                        elt.obj.boxHelper.material.color.g = elt.sse;
                    }
                }
            } else if (!elt.promise) {
                const distance = Math.max(0.001, bbox.distanceToPoint(point));
                // Increase priority of nearest node
                const priority = computeScreenSpaceError(context, layer.pointSize, layer.spacing, elt, distance) / distance;
                elt.promise = context.scheduler.execute({
                    layer,
                    requester: elt,
                    view: context.view,
                    priority,
                    redraw: true,
                    earlyDropFunction: cmd => !cmd.requester.visible || !this.visible,
                }).then((pts) => {
                    if (this.onPointsCreated) {
                        this.onPointsCreated(layer, pts);
                    }

                    elt.obj = pts;
                    // store tightbbox to avoid ping-pong (bbox = larger => visible, tight => invisible)
                    elt.tightbbox = pts.tightbbox;

                    // make sure to add it here, otherwise it might never
                    // be added nor cleaned
                    this.group.add(elt.obj);
                    elt.obj.updateMatrixWorld(true);

                    elt.promise = null;
                }, (err) => {
                    if (err.isCancelledCommandException) {
                        elt.promise = null;
                    }
                });
            }
        }

        if (elt.children && elt.children.length) {
            const distance = bbox.distanceToPoint(point);
            elt.sse = computeScreenSpaceError(context, layer.pointSize, layer.spacing, elt, distance) / this.sseThreshold;
            if (elt.sse >= 1) {
                return elt.children;
            } else {
                for (const child of elt.children) {
                    markForDeletion(child);
                }
            }
        }
    }

    postUpdate() {
        this.displayedCount = 0;
        for (const pts of this.group.children) {
            if (pts.visible) {
                const count = pts.geometry.attributes.position.count;
                pts.geometry.setDrawRange(0, count);
                this.displayedCount += count;
            }
        }

        if (this.displayedCount > this.pointBudget) {
            // 2 different point count limit implementation, depending on the potree source
            if (this.supportsProgressiveDisplay) {
                // In this format, points are evenly distributed within a node,
                // so we can draw a percentage of each node and still get a correct
                // representation
                const reduction = this.pointBudget / this.displayedCount;
                for (const pts of this.group.children) {
                    if (pts.visible) {
                        const count = Math.floor(pts.geometry.drawRange.count * reduction);
                        if (count > 0) {
                            pts.geometry.setDrawRange(0, count);
                        } else {
                            pts.visible = false;
                        }
                    }
                }
                this.displayedCount *= reduction;
            } else {
                // This format doesn't require points to be evenly distributed, so
                // we're going to sort the nodes by "importance" (= on screen size)
                // and display only the first N nodes
                this.group.children.sort((p1, p2) => p2.userData.node.sse - p1.userData.node.sse);

                let limitHit = false;
                this.displayedCount = 0;
                for (const pts of this.group.children) {
                    const count = pts.geometry.attributes.position.count;
                    if (limitHit || (this.displayedCount + count) > this.pointBudget) {
                        pts.visible = false;
                        limitHit = true;
                    } else {
                        this.displayedCount += count;
                    }
                }
            }
        }

        const now = Date.now();
        for (let i = this.group.children.length - 1; i >= 0; i--) {
            const obj = this.group.children[i];
            if (!obj.visible && (now - obj.userData.node.notVisibleSince) > 10000) {
                // remove from group
                this.group.children.splice(i, 1);

                // no need to dispose obj.material, as it is shared by all objects of this layer
                obj.geometry.dispose();
                obj.material = null;
                obj.geometry = null;
                obj.userData.node.obj = null;

                if (__DEBUG__) {
                    if (obj.boxHelper) {
                        obj.boxHelper.removeMe = true;
                        if (Array.isArray(obj.boxHelper.material)) {
                            for (const material of obj.boxHelper.material) {
                                material.dispose();
                            }
                        } else {
                            obj.boxHelper.material.dispose();
                        }
                        obj.boxHelper.geometry.dispose();
                    }
                }
            }
        }

        if (__DEBUG__) {
            this.bboxes.children = this.bboxes.children.filter(b => !b.removeMe);
        }
    }

    pickObjectsAt(view, mouse, radius, target = []) {
        return Picking.pickPointsAt(view, mouse, radius, this, target);
    }

    getObjectToUpdateForAttachedLayers(meta) {
        if (meta.obj) {
            const p = meta.parent;
            if (p && p.obj) {
                return {
                    element: meta.obj,
                    parent: p.obj,
                };
            } else {
                return {
                    element: meta.obj,
                };
            }
        }
    }
}

export default PointCloudLayer;

1	import * as THREE from 'three';	1✔
2	import GeometryLayer from 'Layer/GeometryLayer';	1✔
3	import PointsMaterial, { PNTS_MODE } from 'Renderer/PointsMaterial';	1✔
4	import Picking from 'Core/Picking';	1✔
5		1✔
6	const point = new THREE.Vector3();	1✔
7	const bboxMesh = new THREE.Mesh();	1✔
8	const box3 = new THREE.Box3();	1✔
9	bboxMesh.geometry.boundingBox = box3;	1✔
10		1✔
11	function initBoundingBox(elt, layer) {	1✔
12	elt.tightbbox.getSize(box3.max);	×
13	box3.max.multiplyScalar(0.5);	×
14	box3.min.copy(box3.max).negate();	×
15	elt.obj.boxHelper = new THREE.BoxHelper(bboxMesh);	×
16	elt.obj.boxHelper.geometry = elt.obj.boxHelper.geometry.toNonIndexed();	×
17	elt.obj.boxHelper.computeLineDistances();	×
18	elt.obj.boxHelper.material = elt.childrenBitField ? new THREE.LineDashedMaterial({ dashSize: 0.25, gapSize: 0.25 }) : new THREE.LineBasicMaterial();	×
19	elt.obj.boxHelper.material.color.setHex(0);	×
20	elt.obj.boxHelper.material.linewidth = 2;	×
21	elt.obj.boxHelper.frustumCulled = false;	×
22	elt.obj.boxHelper.position.copy(elt.tightbbox.min).add(box3.max);	×
23	elt.obj.boxHelper.autoUpdateMatrix = false;	×
24	layer.bboxes.add(elt.obj.boxHelper);	×
25	elt.obj.boxHelper.updateMatrix();	×
26	elt.obj.boxHelper.updateMatrixWorld();	1✔
27	}	6✔
28		6✔
29	function computeSSEPerspective(context, pointSize, spacing, elt, distance) {	6✔
30	if (distance <= 0) {	6!
31	return Infinity;	6✔
32	}	6✔
33	const pointSpacing = spacing / 2 ** elt.depth;	6✔
34	// Estimate the onscreen distance between 2 points	6✔
35	const onScreenSpacing = context.camera.preSSE * pointSpacing / distance;	6✔
36	// [ P1 ]--------------[ P2 ]	6✔
37	// <---------------------> = pointsSpacing (in world coordinates)	6✔
38	// ~ onScreenSpacing (in pixels)	6✔
39	// <------> = pointSize (in pixels)	6✔
40	return Math.max(0.0, onScreenSpacing - pointSize);	1✔
41	}	×
42		×
43	function computeSSEOrthographic(context, pointSize, spacing, elt) {	×
44	const pointSpacing = spacing / 2 ** elt.depth;	×
45		×
46	// Given an identity view matrix, project pointSpacing from world space to	×
47	// clip space. v' = vVP = vP	×
48	const v = new THREE.Vector4(pointSpacing);	×
49	v.applyMatrix4(context.camera.camera3D.projectionMatrix);	×
50		×
51	// We map v' to the screen space and calculate the distance to the origin.	×
52	const dx = v.x * 0.5 * context.camera.width;	×
53	const dy = v.y * 0.5 * context.camera.height;	×
54	const distance = Math.sqrt(dx * dx + dy * dy);	1✔
55		6✔
56	return Math.max(0.0, distance - pointSize);	6✔
57	}	6✔
58		6✔
59	function computeScreenSpaceError(context, pointSize, spacing, elt, distance) {	6!
60	if (context.camera.camera3D.isOrthographicCamera) {	×
61	return computeSSEOrthographic(context, pointSize, spacing, elt);	6✔
62	}	6✔
63		6✔
64	return computeSSEPerspective(context, pointSize, spacing, elt, distance);	1!
65	}	×
66		×
67	function markForDeletion(elt) {	189✔
68	if (elt.obj) {	189✔
69	elt.obj.visible = false;	178✔
70	if (__DEBUG__) {	178✔
71	if (elt.obj.boxHelper) {	189✔
72	elt.obj.boxHelper.visible = false;	189✔
73	}	1✔
74	}	×
75	}	×
76		×
77	if (!elt.notVisibleSince) {	×
78	elt.notVisibleSince = Date.now();	×
79	// Set .sse to an invalid value	1✔
80	elt.sse = -1;	2✔
81	}	2✔
82	for (const child of elt.children) {	2✔
83	markForDeletion(child);	2✔
84	}	2✔
85	}	2✔
86		2✔
87	function changeIntensityRange(layer) {	1✔
88	layer.material.intensityRange?.set(layer.minIntensityRange, layer.maxIntensityRange);	×
89	}	1✔
90		1✔
91	function changeElevationRange(layer) {	1✔
92	layer.material.elevationRange?.set(layer.minElevationRange, layer.maxElevationRange);	1✔
93	}	1✔
94		1✔
95	function changeAngleRange(layer) {	1✔
96	layer.material.angleRange?.set(layer.minAngleRange, layer.maxAngleRange);	1✔
97	}	1✔
98		1✔
99	/**	1✔
100	* The basis for all point clouds related layers.	1✔
101	*	1✔
102	* @property {boolean} isPointCloudLayer - Used to checkout whether this layer	1✔
103	* is a PointCloudLayer. Default is `true`. You should not change this, as it is	1✔
104	* used internally for optimisation.	1✔
105	* @property {THREE.Group\|THREE.Object3D} group - Contains the created	1✔
106	* `THREE.Points` meshes, usually with an instance of a `THREE.Points` per node.	1✔
107	* @property {THREE.Group\|THREE.Object3D} bboxes - Contains the bounding boxes	1✔
108	* (`THREE.Box3`) of the tree, usually one per node.	1✔
109	* @property {number} octreeDepthLimit - The depth limit at which to stop	1✔
110	* browsing the octree. Can be used to limit the browsing, without having to	1✔
111	* edit manually the source of the point cloud. No limit by default (`-1`).	1✔
112	* @property {number} [pointBudget=2000000] - Maximum number of points to	1✔
113	* display at the same time. This influences the performance of rendering.	1✔
114	* Default to two millions points.	1✔
115	* @property {number} [sseThreshold=2] - Threshold of the Screen Space	1✔
116	* Error. Default to `2`.	1✔
117	* @property {number} [pointSize=4] - The size (in pixels) of the points.	1✔
118	* Default to `4`.	1✔
119	* @property {THREE.Material\|PointsMaterial} [material=new PointsMaterial] - The	1✔
120	* material to use to display the points of the cloud. Be default it is a new	1✔
121	* `PointsMaterial`.	1✔
122	* @property {number} [mode=PNTS_MODE.COLOR] - The displaying mode of the points.	1✔
123	* Values are specified in `PointsMaterial`.	1✔
124	* @property {number} [minIntensityRange=0] - The minimal intensity of the	1✔
125	* layer. Changing this value will affect the material, if it has the	1✔
126	* corresponding uniform. The value is normalized between 0 and 1.	1✔
127	* @property {number} [maxIntensityRange=1] - The maximal intensity of the	1✔
128	* layer. Changing this value will affect the material, if it has the	1✔
129	* corresponding uniform. The value is normalized between 0 and 1.	1✔
130	*/	1✔
131	class PointCloudLayer extends GeometryLayer {	1✔
132	/**	1✔
133	* Constructs a new instance of point cloud layer.	1✔
134	* Constructs a new instance of a Point Cloud Layer. This should not be used	1✔
135	* directly, but rather implemented using `extends`.	1✔
136	*	1✔
137	* @constructor	1✔
138	* @extends GeometryLayer	1✔
139	*	1✔
140	* @param {string} id - The id of the layer, that should be unique. It is	1✔
141	* not mandatory, but an error will be emitted if this layer is added a	1✔
142	* {@link View} that already has a layer going by that id.	1✔
143	* @param {Object} [config] - Optional configuration, all elements in it	1✔
144	* will be merged as is in the layer. For example, if the configuration	1✔
145	* contains three elements `name, protocol, extent`, these elements will be	11!
146	* available using `layer.name` or something else depending on the property	11✔
147	* name. See the list of properties to know which one can be specified.	11✔
148	*/	11✔
149	constructor(id, config = {}) {	11✔
150	super(id, config.object3d \|\| new THREE.Group(), config);	11✔
151	this.isPointCloudLayer = true;	11✔
152	this.protocol = 'pointcloud';	11✔
153		11✔
154	this.group = config.group \|\| new THREE.Group();	11✔
155	this.object3d.add(this.group);	11✔
156	this.bboxes = config.bboxes \|\| new THREE.Group();	11✔
157	this.bboxes.visible = false;	11✔
158	this.object3d.add(this.bboxes);	11✔
159	this.group.updateMatrixWorld();	11!
160		11✔
161	// default config	11✔
162	this.octreeDepthLimit = config.octreeDepthLimit \|\| -1;	11✔
163	this.pointBudget = config.pointBudget \|\| 2000000;	11✔
164	this.pointSize = config.pointSize === 0 \|\| !isNaN(config.pointSize) ? config.pointSize : 4;	11✔
165	this.sseThreshold = config.sseThreshold \|\| 2;	11✔
166		11✔
167	this.defineLayerProperty('minIntensityRange', config.minIntensityRange \|\| 1, changeIntensityRange);	11✔
168	this.defineLayerProperty('maxIntensityRange', config.maxIntensityRange \|\| 65536, changeIntensityRange);	11✔
169	this.defineLayerProperty('minElevationRange', config.minElevationRange \|\| 0, changeElevationRange);	11✔
170	this.defineLayerProperty('maxElevationRange', config.maxElevationRange \|\| 1000, changeElevationRange);	11✔
171	this.defineLayerProperty('minAngleRange', config.minAngleRange \|\| -90, changeAngleRange);	11✔
172	this.defineLayerProperty('maxAngleRange', config.maxAngleRange \|\| 90, changeAngleRange);	11✔
173		11✔
174	this.material = config.material \|\| {};	11✔
175	if (!this.material.isMaterial) {	11✔
176	config.material = config.material \|\| {};	11✔
177	config.material.intensityRange = new THREE.Vector2(this.minIntensityRange, this.maxIntensityRange);	11✔
178	config.material.elevationRange = new THREE.Vector2(this.minElevationRange, this.maxElevationRange);	1!
179	config.material.angleRange = new THREE.Vector2(this.minAngleRange, this.maxAngleRange);	11✔
180	this.material = new PointsMaterial(config.material);	11✔
181	}	11✔
182	this.material.defines = this.material.defines \|\| {};	11✔
183		11✔
184	this.mode = config.mode \|\| PNTS_MODE.COLOR;	11✔
185	}	3✔
186		3✔
187	preUpdate(context, changeSources) {	3✔
188	// See https://cesiumjs.org/hosted-apps/massiveworlds/downloads/Ring/WorldScaleTerrainRendering.pptx	3✔
189	// slide 17	3✔
190	context.camera.preSSE =	3✔
191	context.camera.height /	3✔
192	(2 * Math.tan(THREE.MathUtils.degToRad(context.camera.camera3D.fov) * 0.5));	3!
193		×
194	if (this.material) {	11✔
195	this.material.visible = this.visible;	11✔
196	this.material.opacity = this.opacity;	11✔
197	this.material.transparent = this.opacity < 1 \|\| this.material.userData.needTransparency[this.material.mode];	11✔
198	this.material.size = this.pointSize;	3✔
199	this.material.scale = context.camera.preSSE;	3✔
200	if (this.material.updateUniforms) {	3✔
201	this.material.updateUniforms();	19✔
202	}	16✔
203	}	19!
UNCOV 204		×
205	// lookup lowest common ancestor of changeSources	19✔
206	let commonAncestor;	16✔
207	for (const source of changeSources.values()) {	19✔
208	if (source.isCamera \|\| source == this) {	14✔
209	// if the change is caused by a camera move, no need to bother	14✔
210	// to find common ancestor: we need to update the whole tree:	8!
211	// some invisible tiles may now be visible	11✔
212	return [this.root];	6✔
213	}	2✔
214	if (source.obj === undefined) {	2✔
215	continue;	1✔
216	}	4✔
217	// filter sources that belong to our layer	4✔
218	if (source.obj.isPoints && source.obj.layer == this) {	4!
219	if (!commonAncestor) {	4✔
220	commonAncestor = source;	4✔
221	} else {	4!
222	commonAncestor = source.findCommonAncestor(commonAncestor);	4✔
223		4✔
224	if (!commonAncestor) {	4✔
225	return [this.root];	1✔
226	}	4✔
227	}	3✔
228	}	3✔
229	}	3✔
230		3✔
231	if (commonAncestor) {	3✔
232	return [commonAncestor];	3✔
233	}	3✔
234		3✔
235	// Start updating from hierarchy root	3✔
236	return [this.root];	3✔
237	}	3✔
UNCOV 238		×
UNCOV 239	update(context, layer, elt) {	×
240	elt.visible = false;	3✔
241		3✔
242	if (this.octreeDepthLimit >= 0 && this.octreeDepthLimit < elt.depth) {	3✔
243	markForDeletion(elt);	3✔
244	return;	3✔
245	}	3✔
246		3✔
247	// pick the best bounding box	3✔
248	const bbox = (elt.tightbbox ? elt.tightbbox : elt.bbox);	3✔
249	elt.visible = context.camera.isBox3Visible(bbox, this.object3d.matrixWorld);	3✔
250	if (!elt.visible) {	3✔
251	markForDeletion(elt);	3✔
252	return;	3✔
253	}	3✔
254		3✔
255	elt.notVisibleSince = undefined;	3✔
256	point.copy(context.camera.camera3D.position).sub(this.object3d.position);	3✔
257		2✔
258	// only load geometry if this elements has points	2✔
259	if (elt.numPoints !== 0) {	2✔
260	if (elt.obj) {	2✔
261	elt.obj.visible = true;	2✔
262		2✔
263	if (__DEBUG__) {	2✔
264	if (this.bboxes.visible) {	2✔
265	if (!elt.obj.boxHelper) {	2✔
266	initBoundingBox(elt, layer);	2✔
267	}	2✔
268	elt.obj.boxHelper.visible = true;	3✔
269	elt.obj.boxHelper.material.color.r = 1 - elt.sse;	1!
270	elt.obj.boxHelper.material.color.g = elt.sse;	3✔
271	}	3✔
272	}	4✔
273	} else if (!elt.promise) {	3✔
274	const distance = Math.max(0.001, bbox.distanceToPoint(point));	3✔
275	// Increase priority of nearest node	3✔
276	const priority = computeScreenSpaceError(context, layer.pointSize, layer.spacing, elt, distance) / distance;	3✔
277	elt.promise = context.scheduler.execute({	1✔
278	layer,	3✔
279	requester: elt,	3✔
280	view: context.view,	3✔
281	priority,	2✔
282	redraw: true,	2✔
283	earlyDropFunction: cmd => !cmd.requester.visible \|\| !this.visible,	3✔
284	}).then((pts) => {	3✔
285	if (this.onPointsCreated) {	3!
UNCOV 286	this.onPointsCreated(layer, pts);	×
UNCOV 287	}	×
288		×
289	elt.obj = pts;	×
290	// store tightbbox to avoid ping-pong (bbox = larger => visible, tight => invisible)	×
291	elt.tightbbox = pts.tightbbox;	×
292		×
293	// make sure to add it here, otherwise it might never	×
294	// be added nor cleaned	×
295	this.group.add(elt.obj);	×
296	elt.obj.updateMatrixWorld(true);	×
297		×
298	elt.promise = null;	×
299	}, (err) => {	×
300	if (err.isCancelledCommandException) {	×
301	elt.promise = null;	×
302	}	×
303	});	×
304	}	×
305	}	×
306		×
307	if (elt.children && elt.children.length) {	×
308	const distance = bbox.distanceToPoint(point);	×
309	elt.sse = computeScreenSpaceError(context, layer.pointSize, layer.spacing, elt, distance) / this.sseThreshold;	×
310	if (elt.sse >= 1) {	×
311	return elt.children;	×
312	} else {	×
313	for (const child of elt.children) {	×
314	markForDeletion(child);	×
315	}	×
316	}	×
317	}	×
318	}	×
319		×
320	postUpdate() {	×
321	this.displayedCount = 0;	×
322	for (const pts of this.group.children) {	×
323	if (pts.visible) {	×
324	const count = pts.geometry.attributes.position.count;	×
325	pts.geometry.setDrawRange(0, count);	3✔
326	this.displayedCount += count;	3✔
327	}	3✔
328	}	3✔
329		2✔
330	if (this.displayedCount > this.pointBudget) {	2✔
331	// 2 different point count limit implementation, depending on the potree source	2!
UNCOV 332	if (this.supportsProgressiveDisplay) {	×
UNCOV 333	// In this format, points are evenly distributed within a node,	×
334	// so we can draw a percentage of each node and still get a correct	×
335	// representation	×
336	const reduction = this.pointBudget / this.displayedCount;	1✔
337	for (const pts of this.group.children) {	×
UNCOV 338	if (pts.visible) {	×
339	const count = Math.floor(pts.geometry.drawRange.count * reduction);	1✔
340	if (count > 0) {	4✔
341	pts.geometry.setDrawRange(0, count);	4✔
342	} else {	2✔
343	pts.visible = false;	2✔
344	}	2✔
345	}	2✔
346	}	1✔
347	this.displayedCount *= reduction;	1✔
348	} else {	1✔
349	// This format doesn't require points to be evenly distributed, so	1✔
350	// we're going to sort the nodes by "importance" (= on screen size)	1✔
351	// and display only the first N nodes	1✔
352	this.group.children.sort((p1, p2) => p2.userData.node.sse - p1.userData.node.sse);	1✔
353		1✔
354	let limitHit = false;	1✔
355	this.displayedCount = 0;	1✔
356	for (const pts of this.group.children) {	1✔
357	const count = pts.geometry.attributes.position.count;	1✔
358	if (limitHit \|\| (this.displayedCount + count) > this.pointBudget) {	1✔
359	pts.visible = false;	1✔
360	limitHit = true;	1✔
361	} else {	1✔
362	this.displayedCount += count;	1✔
363	}	1✔
364	}	1✔
365	}	1✔
366	}	1✔
367		1✔
368	const now = Date.now();	1✔
369	for (let i = this.group.children.length - 1; i >= 0; i--) {	1✔
370	const obj = this.group.children[i];	1✔
371	if (!obj.visible && (now - obj.userData.node.notVisibleSince) > 10000) {	1✔
372	// remove from group	1✔
373	this.group.children.splice(i, 1);	1✔
374		1✔
375	// no need to dispose obj.material, as it is shared by all objects of this layer	1✔
376	obj.geometry.dispose();	1✔
377	obj.material = null;	1✔
378	obj.geometry = null;	1✔
379	obj.userData.node.obj = null;	1✔
380		1✔
381	if (__DEBUG__) {	1✔
382	if (obj.boxHelper) {	1✔
383	obj.boxHelper.removeMe = true;	1✔
384	if (Array.isArray(obj.boxHelper.material)) {	1✔
385	for (const material of obj.boxHelper.material) {	1✔
386	material.dispose();	1✔
387	}	1✔
388	} else {	1✔
389	obj.boxHelper.material.dispose();	1✔
390	}	1✔
391	obj.boxHelper.geometry.dispose();	1✔
392	}	1✔
393	}	1✔
394	}	1✔
395	}	1✔
396		1✔
397	if (__DEBUG__) {	1✔
398	this.bboxes.children = this.bboxes.children.filter(b => !b.removeMe);	1✔
399	}	1✔
400	}	1✔
401		1✔
402	pickObjectsAt(view, mouse, radius, target = []) {	1✔
403	return Picking.pickPointsAt(view, mouse, radius, this, target);	1✔
404	}	1✔
405		1✔
406	getObjectToUpdateForAttachedLayers(meta) {	1✔
407	if (meta.obj) {	1✔
408	const p = meta.parent;	1✔
409	if (p && p.obj) {	1✔
410	return {	1✔
411	element: meta.obj,	1✔
412	parent: p.obj,	1✔
413	};	1✔
414	} else {	1✔
415	return {	1✔
416	element: meta.obj,	1✔
417	};	1✔
418	}	1✔
419	}	1✔
420	}	1✔
421	}	1✔
422		1✔
423	export default PointCloudLayer;	1✔

iTowns / itowns / 10177211096

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