chore(pointcloud): Add adaptive size mode

ketourneau · ketourneau · commit 40b5fb7184ea · 2026-03-10T10:36:23.000+01:00
diff --git a/packages/Debug/src/PointCloudDebug.js b/packages/Debug/src/PointCloudDebug.js
@@ -276,7 +276,7 @@ export default {
         styleUI.add(layer, 'opacity', 0, 1).name('Layer opacity').onChange(update);
         styleUI.add(layer, 'pointSize', 0, 15).name('Point size').onChange(update);
         if (layer.material.sizeMode != undefined && view.camera.camera3D.isPerspectiveCamera) {
-            styleUI.add(layer.material, 'sizeAttenuation').name('Size attenuation')
+            styleUI.add(layer.material, 'sizeMode', PNTS_SIZE_MODE).name('Size mode')
                 .onChange(update);
             styleUI.add(layer.material, 'minAttenuatedSize', 0, 15).name('Min size')
                 .onChange((value) => {
diff --git a/packages/Main/src/Layer/PointCloudLayer.ts b/packages/Main/src/Layer/PointCloudLayer.ts
@@ -1,6 +1,6 @@
 import * as THREE from 'three';
 import GeometryLayer from 'Layer/GeometryLayer';
-import PointsMaterial, { PNTS_MODE } from 'Renderer/PointsMaterial';
+import PointsMaterial, { PNTS_MODE, PNTS_SIZE_MODE } from 'Renderer/PointsMaterial';
 import Picking from 'Core/Picking';
 
 import type PointCloudNode from 'Core/PointCloudNode';
@@ -506,6 +506,37 @@ abstract class PointCloudLayer<S extends PointCloudSource = PointCloudSource>
                 this.dispatchEvent({ type: 'dispose-model', scene: obj, tile: obj.userData.node });
             }
         }
+
+        // @ts-expect-error PointsMaterial is not typed yet
+        if (this.material.sizeMode === PNTS_SIZE_MODE.ADAPTIVE) {
+            const visibilityTextureData = this.computeVisibilityTextureData(this.group.children);
+
+            // @ts-expect-error PointsMaterial is not typed yet
+            const vnt = this.material.visibleNodes;
+            const data = vnt.image.data;
+            data.set(visibilityTextureData.data);
+            vnt.needsUpdate = true;
+
+            const octreeSize = this.root!.voxelOBB.box3D.getSize(new THREE.Vector3()).x;
+
+            for (const pts of this.group.children) {
+                const node = pts.userData.node;
+                const depth = node.depth;
+                const nodeStartOffset = visibilityTextureData.offsets.get(node);
+                const octreeSpacing = node.source.spacing;
+
+                pts.onBeforeRender = (_renderer, _scene, _camera, _geometry, material) => {
+                    // @ts-expect-error Material is not typed yet
+                    material.uniforms.nodeStartOffset.value = nodeStartOffset;
+                    // @ts-expect-error Material is not typed yet
+                    material.uniforms.octreeSize.value = octreeSize;
+                    // @ts-expect-error Material is not typed yet
+                    material.uniforms.octreeSpacing.value = octreeSpacing;
+                    // @ts-expect-error Material is not typed yet
+                    material.uniforms.nodeDepth.value = depth;
+                };
+            }
+        }
     }
 
     // @ts-expect-error Layer and Picking are not typed yet
@@ -529,6 +560,77 @@ abstract class PointCloudLayer<S extends PointCloudSource = PointCloudSource>
             }
         }
     }
+
+    // Encoding the octree hierarchy in bread-first order
+    // into a texture for adaptive point size rendering
+    // Explanation p36: https://www.cg.tuwien.ac.at/research/publications/2016/SCHUETZ-2016-POT/SCHUETZ-2016-POT-thesis.pdf
+    computeVisibilityTextureData(children: THREE.Object3D[]) {
+        // copy array
+        const orderedChildren = children.slice();
+
+        // Helper function to get octree child index from node
+        const getChildIndex = (node: PointCloudNode): number => {
+            if (!node.parent) {
+                return 0;
+            }
+            const parent = node.parent;
+            // @ts-expect-error PointCloudNode has x properties
+            const dx = node.x - parent.x * 2;
+            // @ts-expect-error PointCloudNode has y properties
+            const dy = node.y - parent.y * 2;
+            // @ts-expect-error PointCloudNode has z properties
+            const dz = node.z - parent.z * 2;
+            // Octree child index (Potree convention): 4*x + 2*y + z
+            return 4 * dx + 2 * dy + dz;
+        };
+
+        // sort by level and hierarchy order
+        const sort = function sortNodes(a: THREE.Object3D, b: THREE.Object3D) {
+            const na = a.userData.node;
+            const nb = b.userData.node;
+            if (na.depth !== nb.depth) { return na.depth - nb.depth; }
+            if (na.z !== nb.z) { return na.z - nb.z; }
+            if (na.y !== nb.y) { return na.y - nb.y; }
+            return na.x - nb.x;
+        };
+        orderedChildren.sort(sort);
+
+        const data = new Uint8Array(orderedChildren.length * 4);
+        const visibleNodeTextureOffsets = new Map();
+        const offsetsToChild: number[] = new Array(orderedChildren.length).fill(Infinity);
+
+        for (let nodeIndex = 0; nodeIndex < orderedChildren.length; nodeIndex++) {
+            const node = orderedChildren[nodeIndex].userData.node;
+            visibleNodeTextureOffsets.set(node, nodeIndex);
+
+            if (node.parent) {
+                const childIndex = getChildIndex(node);
+                const parentIndex = visibleNodeTextureOffsets.get(node.parent);
+
+                const parentOffsetToChild = nodeIndex - parentIndex;
+                const offsetToFirstChild =
+                    Math.min(offsetsToChild[parentIndex], parentOffsetToChild);
+                offsetsToChild[parentIndex] = offsetToFirstChild;
+
+                // The 8 bits of the red value indicate
+                // which of the children are visible
+                data[parentIndex * 4] = data[parentIndex * 4] | (1 << childIndex);
+                // Offset to child is stored on 2 bytes,
+                // so it can support up to 65536 nodes per subtree.
+                // The green channel contains the relative offset
+                // to the node’s first child (8 most significant bits)
+                data[parentIndex * 4 + 1] = offsetToFirstChild >> 8;
+                // The blue channel contains the relative offset
+                // to the node’s first child (8 least significant bits)
+                data[parentIndex * 4 + 2] = offsetToFirstChild % 256;
+            }
+        }
+
+        return {
+            data,
+            offsets: visibleNodeTextureOffsets,
+        };
+    }
 }
 
 export default PointCloudLayer;
diff --git a/packages/Main/src/Renderer/PointsMaterial.js b/packages/Main/src/Renderer/PointsMaterial.js
@@ -25,6 +25,7 @@ export const PNTS_SHAPE = {
 export const PNTS_SIZE_MODE = {
     VALUE: 0,
     ATTENUATED: 1,
+    ADAPTIVE: 2,
 };
 
 const white = new THREE.Color(1.0,  1.0,  1.0);
@@ -245,6 +246,12 @@ class PointsMaterial extends THREE.ShaderMaterial {
         CommonMaterial.setUniformProperty(this, 'gamma', gamma);
         CommonMaterial.setUniformProperty(this, 'ambientBoost', ambientBoost);
 
+        // Adaptive point size uniforms
+        CommonMaterial.setUniformProperty(this, 'octreeSpacing', 1.0);
+        CommonMaterial.setUniformProperty(this, 'octreeSize', 1.0);
+        CommonMaterial.setUniformProperty(this, 'nodeDepth', 0.0);
+        CommonMaterial.setUniformProperty(this, 'nodeStartOffset', 0.0);
+
         // add classification texture to apply classification lut.
         const data = new Uint8Array(256 * 4);
         const texture = new THREE.DataTexture(data, 256, 1, THREE.RGBAFormat);
@@ -262,11 +269,16 @@ class PointsMaterial extends THREE.ShaderMaterial {
         // add texture to apply visibility.
         const dataVisi = new Uint8Array(256 * 1);
         const textureVisi = new THREE.DataTexture(dataVisi, 256, 1, THREE.RedFormat);
-
         textureVisi.needsUpdate = true;
         textureVisi.magFilter = THREE.NearestFilter;
         CommonMaterial.setUniformProperty(this, 'visibilityTexture', textureVisi);
 
+        const dataNodes = new Uint8Array(2048 * 4);
+        const visibleNodesTexture = new THREE.DataTexture(dataNodes, 2048, 1, THREE.RGBAFormat);
+        visibleNodesTexture.needsUpdate = true;
+        visibleNodesTexture.magFilter = THREE.NearestFilter;
+        CommonMaterial.setUniformProperty(this, 'visibleNodes', visibleNodesTexture);
+
         // Classification and other discrete values scheme
         this.classificationScheme = classificationScheme;
         this.discreteScheme = discreteScheme;
@@ -395,6 +407,48 @@ class PointsMaterial extends THREE.ShaderMaterial {
         this.uniforms.ambientBoost.value = ambientBoost;
     }
 
+    // Adaptive point size properties
+
+    /** @returns {number} */
+    get octreeSpacing() {
+        return this.uniforms.octreeSpacing.value;
+    }
+
+    /** @param {number} octreeSpacing */
+    set octreeSpacing(octreeSpacing) {
+        this.uniforms.octreeSpacing.value = octreeSpacing;
+    }
+
+    /** @returns {number} */
+    get octreeSize() {
+        return this.uniforms.octreeSize.value;
+    }
+
+    /** @param {number} octreeSize */
+    set octreeSize(octreeSize) {
+        this.uniforms.octreeSize.value = octreeSize;
+    }
+
+    /** @returns {number} */
+    get nodeDepth() {
+        return this.uniforms.nodeDepth.value;
+    }
+
+    /** @param {number} depth */
+    set nodeDepth(depth) {
+        this.uniforms.nodeDepth.value = depth;
+    }
+
+    /** @returns {number} */
+    get nodeStartOffset() {
+        return this.uniforms.nodeStartOffset.value;
+    }
+
+    /** @param {number} offset */
+    set nodeStartOffset(offset) {
+        this.uniforms.nodeStartOffset.value = offset;
+    }
+
     recomputeClassification() {
         recomputeTexture(this.classificationScheme, this.classificationTexture, 256);
         this.dispatchEvent({
diff --git a/packages/Main/src/Renderer/Shader/PointsVS.glsl b/packages/Main/src/Renderer/Shader/PointsVS.glsl
@@ -31,6 +31,13 @@ uniform int sizeMode;
 uniform float minAttenuatedSize;
 uniform float maxAttenuatedSize;
 
+// Adaptive point size uniforms
+uniform sampler2D visibleNodes;
+uniform float octreeSpacing;
+uniform float octreeSize;
+uniform float nodeDepth;
+uniform float nodeStartOffset;
+
 attribute vec4 unique_id;
 attribute float intensity;
 attribute float classification;
@@ -40,6 +47,58 @@ attribute float returnNumber;
 attribute float numberOfReturns;
 attribute float scanAngle;
 
+// Adaptive point size calculation functions (from Potree)
+/**
+ * number of 1-bits up to inclusive index position
+ * number is treated as if it were an integer in the range 0-255
+ *
+ */
+int numberOfOnes(int number, int index) {
+    int numOnes = 0;
+    int tmp = 128;
+    for (int i = 7; i >= 0; i--) {
+        if (number >= tmp) {
+            number = number - tmp;
+            if (i <= index) {
+                numOnes++;
+            }
+        }
+        tmp = tmp / 2;
+    }
+    return numOnes;
+}
+
+float getLOD() {
+    vec3 offset = vec3(0.0, 0.0, 0.0);
+    int iOffset = int(nodeStartOffset);
+    float depth = nodeDepth;
+    for (float i = 0.0; i <= 30.0; i++) {
+        float nodeSizeAtLevel = octreeSize / pow(2.0, i + nodeDepth);
+
+        vec3 index3d = (position - offset) / nodeSizeAtLevel;
+        index3d = floor(index3d + 0.5);
+        int index = int(round(4.0 * index3d.x + 2.0 * index3d.y + index3d.z));
+
+        vec4 value = texture2D(visibleNodes, vec2(float(iOffset) / 2048.0, 0.0));
+        int mask = int(round(value.r * 255.0));
+        bool childNodeExist = bool(((mask >> index) & 1) != 0);
+
+        if (childNodeExist) {
+            int greenChannelOffset = int(round(value.g * 255.0)) * 256;
+            int blueChannelOffset = int(round(value.b * 255.0));
+            int childIndexOffset = numberOfOnes(mask, index - 1);
+            int totalOffset = greenChannelOffset + blueChannelOffset + childIndexOffset;
+            iOffset = iOffset + totalOffset;
+            depth++;
+        } else {
+            // no more visible child nodes at this position
+            return depth;
+        }
+        offset = offset + (vec3(1.0, 1.0, 1.0) * nodeSizeAtLevel * 0.5) * index3d;
+    }
+    return depth;
+}
+
 void main() {
     vec2 uv = vec2(classification/255., 0.5);
 
@@ -117,13 +176,17 @@ void main() {
 
     gl_PointSize = size;
 
-    if (sizeMode == PNTS_SIZE_MODE_ATTENUATED) {
-        bool isPerspective = isPerspectiveMatrix(projectionMatrix);
-
-        if (isPerspective) {
-            gl_PointSize *= scale / -mvPosition.z;
-            gl_PointSize = clamp(gl_PointSize, minAttenuatedSize, maxAttenuatedSize);
-        }
+    bool isPerspective = isPerspectiveMatrix(projectionMatrix);
+
+    if (isPerspective && (sizeMode == PNTS_SIZE_MODE_ATTENUATED)) {
+        gl_PointSize *= scale / -mvPosition.z;
+        gl_PointSize = clamp(gl_PointSize, minAttenuatedSize, maxAttenuatedSize);
+    } else if (isPerspective && (sizeMode == PNTS_SIZE_MODE_ADAPTIVE)) {
+        float r = octreeSpacing * 1.7;
+        float pointSizeAttenuation = pow(2.0, getLOD());
+        float worldSpaceSize = size * r / pointSizeAttenuation;
+        float projFactor = scale / -mvPosition.z;
+        gl_PointSize = worldSpaceSize * projFactor;
     }
 
 #include <logdepthbuf_vertex>
