11952113077

Committed 21 Nov 2024 11:16AM UTC coverage: 86.975% (+0.1%) from 86.829%

Build # 11952113077

Build Type

Pull #2368

github

Committed by

web-flow

Commit Message

Merge 1fe883eaa into 822c63b2a

Pull Request Pull Request #2368: Remove assignement of all config properties in base Layer class

Run Details

2781 of 3690 branches covered (75.37%)

Branch coverage included in aggregate %.

479 of 481 new or added lines in 18 files covered. (99.58%)

7 existing lines in 4 files now uncovered.

24671 of 27873 relevant lines covered (88.51%)

1011.09 hits per line

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

70.83

/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.
 *
 * @extends GeometryLayer
 */
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`.
     *
     * @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.
     * @param {Source} config.source - Description and options of the source.
     */
    constructor(id, config = {}) {
        const {
            object3d = new THREE.Group(),
            group = new THREE.Group(),
            bboxes = new THREE.Group(),
            octreeDepthLimit = -1,
            pointBudget = 2000000,
            pointSize = 2,
            sseThreshold = 2,
            minIntensityRange = 1,
            maxIntensityRange = 65536,
            minElevationRange = 0,
            maxElevationRange = 1000,
            minAngleRange = -90,
            maxAngleRange = 90,
            material = {},
            mode = PNTS_MODE.COLOR,
            ...geometryLayerConfig
        } = config;

        super(id, object3d, geometryLayerConfig);

        /**
         * @type {boolean}
         * @readonly
         */
        this.isPointCloudLayer = true;
        this.protocol = 'pointcloud';

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

        // default config
        /**
         * @type {number}
         */
        this.octreeDepthLimit = octreeDepthLimit;

        /**
         * @type {number}
         */
        this.pointBudget = pointBudget;

        /**
         * @type {number}
         */
        this.pointSize = pointSize;

        /**
         * @type {number}
         */
        this.sseThreshold = sseThreshold;

        this.defineLayerProperty('minIntensityRange', minIntensityRange, changeIntensityRange);
        this.defineLayerProperty('maxIntensityRange', maxIntensityRange, changeIntensityRange);
        this.defineLayerProperty('minElevationRange', minElevationRange, changeElevationRange);
        this.defineLayerProperty('maxElevationRange', maxElevationRange, changeElevationRange);
        this.defineLayerProperty('minAngleRange', minAngleRange, changeAngleRange);
        this.defineLayerProperty('maxAngleRange', maxAngleRange, changeAngleRange);

        /**
         * @type {THREE.Material}
         */
        this.material = material;
        if (!this.material.isMaterial) {
            this.material.intensityRange = new THREE.Vector2(this.minIntensityRange, this.maxIntensityRange);
            this.material.elevationRange = new THREE.Vector2(this.minElevationRange, this.maxElevationRange);
            this.material.angleRange = new THREE.Vector2(this.minAngleRange, this.maxAngleRange);
            this.material = new PointsMaterial(this.material);
        }

        this.mode = mode || PNTS_MODE.COLOR;

        /**
         * @type {PointCloudNode | undefined}
         */
        this.root = undefined;
    }

    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.getWorldPosition(new THREE.Vector3()));
        point.applyQuaternion(this.object3d.getWorldQuaternion(new THREE.Quaternion()).invert());

        // 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) {	×
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();	×
27	}	×
28		1✔
29	function computeSSEPerspective(context, pointSize, spacing, elt, distance) {	6✔
30	if (distance <= 0) {	6!
31	return Infinity;	×
32	}	×
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);	6✔
41	}	6✔
42		1✔
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);	×
55		×
56	return Math.max(0.0, distance - pointSize);	×
57	}	×
58		1✔
59	function computeScreenSpaceError(context, pointSize, spacing, elt, distance) {	6✔
60	if (context.camera.camera3D.isOrthographicCamera) {	6!
61	return computeSSEOrthographic(context, pointSize, spacing, elt);	×
62	}	×
63		6✔
64	return computeSSEPerspective(context, pointSize, spacing, elt, distance);	6✔
65	}	6✔
66		1✔
67	function markForDeletion(elt) {	189✔
68	if (elt.obj) {	189!
69	elt.obj.visible = false;	×
70	if (__DEBUG__) {	×
71	if (elt.obj.boxHelper) {	×
72	elt.obj.boxHelper.visible = false;	×
73	}	×
74	}	×
75	}	×
76		189✔
77	if (!elt.notVisibleSince) {	189✔
78	elt.notVisibleSince = Date.now();	178✔
79	// Set .sse to an invalid value	178✔
80	elt.sse = -1;	178✔
81	}	178✔
82	for (const child of elt.children) {	189✔
83	markForDeletion(child);	178✔
84	}	178✔
85	}	189✔
86		1✔
87	function changeIntensityRange(layer) {	×
88	layer.material.intensityRange?.set(layer.minIntensityRange, layer.maxIntensityRange);	×
89	}	×
90		1✔
91	function changeElevationRange(layer) {	2✔
92	layer.material.elevationRange?.set(layer.minElevationRange, layer.maxElevationRange);	2✔
93	}	2✔
94		1✔
95	function changeAngleRange(layer) {	×
96	layer.material.angleRange?.set(layer.minAngleRange, layer.maxAngleRange);	×
97	}	×
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	* @extends GeometryLayer	1✔
132	*/	1✔
133	class PointCloudLayer extends GeometryLayer {	1✔
134	/**	1✔
135	* Constructs a new instance of point cloud layer.	1✔
136	* Constructs a new instance of a Point Cloud Layer. This should not be used	1✔
137	* directly, but rather implemented using `extends`.	1✔
138	*	1✔
139	* @param {string} id - The id of the layer, that should be unique. It is	1✔
140	* not mandatory, but an error will be emitted if this layer is added a	1✔
141	* {@link View} that already has a layer going by that id.	1✔
142	* @param {Object} [config] - Optional configuration, all elements in it	1✔
143	* will be merged as is in the layer. For example, if the configuration	1✔
144	* contains three elements `name, protocol, extent`, these elements will be	1✔
145	* available using `layer.name` or something else depending on the property	1✔
146	* name. See the list of properties to know which one can be specified.	1✔
147	* @param {Source} config.source - Description and options of the source.	1✔
148	*/	1✔
149	constructor(id, config = {}) {	1!
150	const {	11✔
151	object3d = new THREE.Group(),	11✔
152	group = new THREE.Group(),	11✔
153	bboxes = new THREE.Group(),	11✔
154	octreeDepthLimit = -1,	11✔
155	pointBudget = 2000000,	11✔
156	pointSize = 2,	11✔
157	sseThreshold = 2,	11✔
158	minIntensityRange = 1,	11✔
159	maxIntensityRange = 65536,	11✔
160	minElevationRange = 0,	11✔
161	maxElevationRange = 1000,	11✔
162	minAngleRange = -90,	11✔
163	maxAngleRange = 90,	11✔
164	material = {},	11✔
165	mode = PNTS_MODE.COLOR,	11✔
166	...geometryLayerConfig	11✔
167	} = config;	11✔
168		11✔
169	super(id, object3d, geometryLayerConfig);	11✔
170		11✔
171	/**	11✔
172	* @type {boolean}	11✔
173	* @readonly	11✔
174	*/	11✔
175	this.isPointCloudLayer = true;	11✔
176	this.protocol = 'pointcloud';	11✔
177		11✔
178	this.group = group;	11✔
179	this.object3d.add(this.group);	11✔
180	this.bboxes = bboxes \|\| new THREE.Group();	11!
181	this.bboxes.visible = false;	11✔
182	this.object3d.add(this.bboxes);	11✔
183	this.group.updateMatrixWorld();	11✔
184		11✔
185	// default config	11✔
186	/**	11✔
187	* @type {number}	11✔
188	*/	11✔
189	this.octreeDepthLimit = octreeDepthLimit;	11✔
190		11✔
191	/**	11✔
192	* @type {number}	11✔
193	*/	11✔
194	this.pointBudget = pointBudget;	11✔
195		11✔
196	/**	11✔
197	* @type {number}	11✔
198	*/	11✔
199	this.pointSize = pointSize;	11✔
200		11✔
201	/**	11✔
202	* @type {number}	11✔
203	*/	11✔
204	this.sseThreshold = sseThreshold;	11✔
205		11✔
206	this.defineLayerProperty('minIntensityRange', minIntensityRange, changeIntensityRange);	11✔
207	this.defineLayerProperty('maxIntensityRange', maxIntensityRange, changeIntensityRange);	11✔
208	this.defineLayerProperty('minElevationRange', minElevationRange, changeElevationRange);	11✔
209	this.defineLayerProperty('maxElevationRange', maxElevationRange, changeElevationRange);	11✔
210	this.defineLayerProperty('minAngleRange', minAngleRange, changeAngleRange);	11✔
211	this.defineLayerProperty('maxAngleRange', maxAngleRange, changeAngleRange);	11✔
212		11✔
213	/**	11✔
214	* @type {THREE.Material}	11✔
215	*/	11✔
216	this.material = material;	11✔
217	if (!this.material.isMaterial) {	11✔
218	this.material.intensityRange = new THREE.Vector2(this.minIntensityRange, this.maxIntensityRange);	11✔
219	this.material.elevationRange = new THREE.Vector2(this.minElevationRange, this.maxElevationRange);	11✔
220	this.material.angleRange = new THREE.Vector2(this.minAngleRange, this.maxAngleRange);	11✔
221	this.material = new PointsMaterial(this.material);	11✔
222	}	11✔
223		11✔
224	this.mode = mode \|\| PNTS_MODE.COLOR;	11✔
225		11✔
226	/**	11✔
227	* @type {PointCloudNode \| undefined}	11✔
228	*/	11✔
229	this.root = undefined;	11✔
230	}	11✔
231		1✔
232	preUpdate(context, changeSources) {	1✔
233	// See https://cesiumjs.org/hosted-apps/massiveworlds/downloads/Ring/WorldScaleTerrainRendering.pptx	11✔
234	// slide 17	11✔
235	context.camera.preSSE =	11✔
236	context.camera.height /	11✔
237	(2 * Math.tan(THREE.MathUtils.degToRad(context.camera.camera3D.fov) * 0.5));	11✔
238		11✔
239	if (this.material) {	11✔
240	this.material.visible = this.visible;	3✔
241	this.material.opacity = this.opacity;	3✔
242	this.material.transparent = this.opacity < 1 \|\| this.material.userData.needTransparency[this.material.mode];	3✔
243	this.material.size = this.pointSize;	3✔
244	this.material.scale = context.camera.preSSE;	3✔
245	if (this.material.updateUniforms) {	3!
246	this.material.updateUniforms();	×
247	}	×
248	}	3✔
249		11✔
250	// lookup lowest common ancestor of changeSources	11✔
251	let commonAncestor;	11✔
252	for (const source of changeSources.values()) {	11✔
253	if (source.isCamera \|\| source == this) {	19✔
254	// if the change is caused by a camera move, no need to bother	3✔
255	// to find common ancestor: we need to update the whole tree:	3✔
256	// some invisible tiles may now be visible	3✔
257	return [this.root];	3✔
258	}	3✔
259	if (source.obj === undefined) {	19!
260	continue;	×
261	}	✔
262	// filter sources that belong to our layer	16✔
263	if (source.obj.isPoints && source.obj.layer == this) {	19✔
264	if (!commonAncestor) {	14✔
265	commonAncestor = source;	6✔
266	} else {	14✔
267	commonAncestor = source.findCommonAncestor(commonAncestor);	8✔
268		8✔
269	if (!commonAncestor) {	8!
270	return [this.root];	×
271	}	×
272	}	8✔
273	}	14✔
274	}	19✔
275		8✔
276	if (commonAncestor) {	11✔
277	return [commonAncestor];	6✔
278	}	6✔
279		2✔
280	// Start updating from hierarchy root	2✔
281	return [this.root];	2✔
282	}	2✔
283		1✔
284	update(context, layer, elt) {	1✔
285	elt.visible = false;	4✔
286		4✔
287	if (this.octreeDepthLimit >= 0 && this.octreeDepthLimit < elt.depth) {	4!
288	markForDeletion(elt);	×
289	return;	×
290	}	×
291		4✔
292	// pick the best bounding box	4✔
293	const bbox = (elt.tightbbox ? elt.tightbbox : elt.bbox);	4!
294	elt.visible = context.camera.isBox3Visible(bbox, this.object3d.matrixWorld);	4✔
295	if (!elt.visible) {	4✔
296	markForDeletion(elt);	1✔
297	return;	1✔
298	}	1✔
299		3✔
300	elt.notVisibleSince = undefined;	3✔
301	point.copy(context.camera.camera3D.position).sub(this.object3d.getWorldPosition(new THREE.Vector3()));	3✔
302	point.applyQuaternion(this.object3d.getWorldQuaternion(new THREE.Quaternion()).invert());	3✔
303		3✔
304	// only load geometry if this elements has points	3✔
305	if (elt.numPoints !== 0) {	3✔
306	if (elt.obj) {	3!
307	elt.obj.visible = true;	×
308		×
309	if (__DEBUG__) {	×
310	if (this.bboxes.visible) {	×
311	if (!elt.obj.boxHelper) {	×
312	initBoundingBox(elt, layer);	×
313	}	×
314	elt.obj.boxHelper.visible = true;	×
315	elt.obj.boxHelper.material.color.r = 1 - elt.sse;	×
316	elt.obj.boxHelper.material.color.g = elt.sse;	×
317	}	×
318	}	×
319	} else if (!elt.promise) {	3✔
320	const distance = Math.max(0.001, bbox.distanceToPoint(point));	3✔
321	// Increase priority of nearest node	3✔
322	const priority = computeScreenSpaceError(context, layer.pointSize, layer.spacing, elt, distance) / distance;	3✔
323	elt.promise = context.scheduler.execute({	3✔
324	layer,	3✔
325	requester: elt,	3✔
326	view: context.view,	3✔
327	priority,	3✔
328	redraw: true,	3✔
329	earlyDropFunction: cmd => !cmd.requester.visible \|\| !this.visible,	3✔
330	}).then((pts) => {	3✔
331	if (this.onPointsCreated) {	2!
UNCOV 332	this.onPointsCreated(layer, pts);	×
UNCOV 333	}	×
334		2✔
335	elt.obj = pts;	2✔
336	// store tightbbox to avoid ping-pong (bbox = larger => visible, tight => invisible)	2✔
337	elt.tightbbox = pts.tightbbox;	2✔
338		2✔
339	// make sure to add it here, otherwise it might never	2✔
340	// be added nor cleaned	2✔
341	this.group.add(elt.obj);	2✔
342	elt.obj.updateMatrixWorld(true);	2✔
343		2✔
344	elt.promise = null;	2✔
345	}, (err) => {	3✔
346	if (err.isCancelledCommandException) {	1!
347	elt.promise = null;	×
348	}	×
349	});	3✔
350	}	3✔
351	}	3✔
352		3✔
353	if (elt.children && elt.children.length) {	4✔
354	const distance = bbox.distanceToPoint(point);	3✔
355	elt.sse = computeScreenSpaceError(context, layer.pointSize, layer.spacing, elt, distance) / this.sseThreshold;	3✔
356	if (elt.sse >= 1) {	3✔
357	return elt.children;	1✔
358	} else {	3✔
359	for (const child of elt.children) {	2✔
360	markForDeletion(child);	10✔
361	}	10✔
362	}	2✔
363	}	3✔
364	}	4✔
365		1✔
366	postUpdate() {	1✔
367	this.displayedCount = 0;	3✔
368	for (const pts of this.group.children) {	3✔
369	if (pts.visible) {	2✔
370	const count = pts.geometry.attributes.position.count;	2✔
371	pts.geometry.setDrawRange(0, count);	2✔
372	this.displayedCount += count;	2✔
373	}	2✔
374	}	2✔
375		3✔
376	if (this.displayedCount > this.pointBudget) {	3!
377	// 2 different point count limit implementation, depending on the potree source	×
378	if (this.supportsProgressiveDisplay) {	×
379	// In this format, points are evenly distributed within a node,	×
380	// so we can draw a percentage of each node and still get a correct	×
381	// representation	×
382	const reduction = this.pointBudget / this.displayedCount;	×
383	for (const pts of this.group.children) {	×
384	if (pts.visible) {	×
385	const count = Math.floor(pts.geometry.drawRange.count * reduction);	×
386	if (count > 0) {	×
387	pts.geometry.setDrawRange(0, count);	×
388	} else {	×
389	pts.visible = false;	×
390	}	×
391	}	×
392	}	×
393	this.displayedCount *= reduction;	×
394	} else {	×
395	// This format doesn't require points to be evenly distributed, so	×
396	// we're going to sort the nodes by "importance" (= on screen size)	×
397	// and display only the first N nodes	×
398	this.group.children.sort((p1, p2) => p2.userData.node.sse - p1.userData.node.sse);	×
399		×
400	let limitHit = false;	×
401	this.displayedCount = 0;	×
402	for (const pts of this.group.children) {	×
403	const count = pts.geometry.attributes.position.count;	×
404	if (limitHit \|\| (this.displayedCount + count) > this.pointBudget) {	×
405	pts.visible = false;	×
406	limitHit = true;	×
407	} else {	×
408	this.displayedCount += count;	×
409	}	×
410	}	×
411	}	×
412	}	×
413		3✔
414	const now = Date.now();	3✔
415	for (let i = this.group.children.length - 1; i >= 0; i--) {	3✔
416	const obj = this.group.children[i];	2✔
417	if (!obj.visible && (now - obj.userData.node.notVisibleSince) > 10000) {	2!
418	// remove from group	×
419	this.group.children.splice(i, 1);	×
420		×
421	// no need to dispose obj.material, as it is shared by all objects of this layer	×
422	obj.geometry.dispose();	×
423	obj.material = null;	×
424	obj.geometry = null;	×
425	obj.userData.node.obj = null;	×
426		×
427	if (__DEBUG__) {	×
428	if (obj.boxHelper) {	×
429	obj.boxHelper.removeMe = true;	×
430	if (Array.isArray(obj.boxHelper.material)) {	×
431	for (const material of obj.boxHelper.material) {	×
432	material.dispose();	×
433	}	×
434	} else {	×
435	obj.boxHelper.material.dispose();	×
436	}	×
437	obj.boxHelper.geometry.dispose();	×
438	}	×
439	}	×
440	}	×
441	}	2✔
442		3✔
443	if (__DEBUG__) {	3✔
444	this.bboxes.children = this.bboxes.children.filter(b => !b.removeMe);	3✔
445	}	3✔
446	}	3✔
447		1✔
448	pickObjectsAt(view, mouse, radius, target = []) {	1✔
449	return Picking.pickPointsAt(view, mouse, radius, this, target);	×
450	}	×
451		1✔
452	getObjectToUpdateForAttachedLayers(meta) {	1✔
453	if (meta.obj) {	4✔
454	const p = meta.parent;	4✔
455	if (p && p.obj) {	4✔
456	return {	2✔
457	element: meta.obj,	2✔
458	parent: p.obj,	2✔
459	};	2✔
460	} else {	2✔
461	return {	2✔
462	element: meta.obj,	2✔
463	};	2✔
464	}	2✔
465	}	4✔
466	}	4✔
467	}	1✔
468		1✔
469	export default PointCloudLayer;	1✔

iTowns / itowns / 11952113077

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