@loaders.gl/potree 4.0.0-alpha.5 → 4.0.0-alpha.7

package/dist/lib/octree.js

@@ -1,228 +1,197 @@
-export class PointCloudOctree {
-  constructor() {
-    this.url = null;
-    this.octreeDir = null;
-    this.spacing = 0;
-    this.boundingBox = null;
-    this.root = null;
-    this.nodes = null;
-    this.pointAttributes = null;
-    this.hierarchyStepSize = -1;
-    this.loader = null;
-  }
-
+"use strict";
+/* eslint-disable */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PointCloudOctant = exports.PointCloudOctree = void 0;
+// @ts-nocheck
+class PointCloudOctree {
+    constructor() {
+        this.url = null;
+        this.octreeDir = null;
+        this.spacing = 0;
+        this.boundingBox = null;
+        this.root = null;
+        this.nodes = null;
+        this.pointAttributes = null;
+        this.hierarchyStepSize = -1;
+        this.loader = null;
+    }
 }
-export class PointCloudOctant {
-  constructor(name, octree, boundingBox) {
-    this.octree = this.id = PointCloudOctreeGeometryNode.IDCount++;
-    this.name = name;
-    this.index = parseInt(name.charAt(name.length - 1));
-    this.octree = octree;
-    this.geometry = null;
-    this.boundingBox = boundingBox;
-    this.boundingSphere = boundingBox.getBoundingSphere(new THREE.Sphere());
-    this.children = {};
-    this.numPoints = 0;
-    this.level = null;
-    this.loaded = false;
-    this.oneTimeDisposeHandlers = [];
-  }
-
-  isGeometryNode() {
-    return true;
-  }
-
-  getLevel() {
-    return this.level;
-  }
-
-  isTreeNode() {
-    return false;
-  }
-
-  isLoaded() {
-    return this.loaded;
-  }
-
-  getBoundingSphere() {
-    return this.boundingSphere;
-  }
-
-  getBoundingBox() {
-    return this.boundingBox;
-  }
-
-  getChildren() {
-    return this.children.filter(Boolean);
-  }
-
-  getURL() {
-    const {
-      version
-    } = this.octree;
-    const hierarchyPath = version >= 1.5 ? "".concat(this.getHierarchyPath(), "/") : '';
-    return "".concat(this.octree.octreeDir, "/").concat(hierarchyPath).concat(this.name);
-  }
-
-  getHierarchyPath() {
-    let path = 'r/';
-    let hierarchyStepSize = this.octree.hierarchyStepSize;
-    let indices = this.name.substr(1);
-    let numParts = Math.floor(indices.length / hierarchyStepSize);
-
-    for (let i = 0; i < numParts; i++) {
-      path += indices.substr(i * hierarchyStepSize, hierarchyStepSize) + '/';
-    }
-
-    path = path.slice(0, -1);
-    return path;
-  }
-
-  addChild(child) {
-    this.children[child.index] = child;
-    child.parent = this;
-  }
-
-  load() {
-    if (this.loading === true || this.loaded === true || Potree.numNodesLoading >= Potree.maxNodesLoading) {
-      return;
-    }
-
-    this.loading = true;
-    Potree.numNodesLoading++;
-
-    if (this.octree.loader.version.equalOrHigher('1.5')) {
-      if (this.level % this.octree.hierarchyStepSize === 0 && this.hasChildren) {
-        this.loadHierachyThenPoints();
-      } else {
-        this.loadPoints();
-      }
-    } else {
-      this.loadPoints();
-    }
-  }
-
-  loadPoints() {
-    this.octree.loader.load(this);
-  }
-
-  loadHierachyThenPoints() {
-    let node = this;
-
-    let callback = function (node, hbuffer) {
-      let view = new DataView(hbuffer);
-      let stack = [];
-      let children = view.getUint8(0);
-      let numPoints = view.getUint32(1, true);
-      node.numPoints = numPoints;
-      stack.push({
-        children: children,
-        numPoints: numPoints,
-        name: node.name
-      });
-      let decoded = [];
-      let offset = 5;
-
-      while (stack.length > 0) {
-        let snode = stack.shift();
-        let mask = 1;
-
-        for (let i = 0; i < 8; i++) {
-          if ((snode.children & mask) !== 0) {
-            let childName = snode.name + i;
-            let childChildren = view.getUint8(offset);
-            let childNumPoints = view.getUint32(offset + 1, true);
-            stack.push({
-              children: childChildren,
-              numPoints: childNumPoints,
-              name: childName
-            });
-            decoded.push({
-              children: childChildren,
-              numPoints: childNumPoints,
-              name: childName
-            });
-            offset += 5;
-          }
-
-          mask = mask * 2;
+exports.PointCloudOctree = PointCloudOctree;
+class PointCloudOctant {
+    constructor(name, octree, boundingBox) {
+        this.octree = this.id = PointCloudOctreeGeometryNode.IDCount++;
+        this.name = name;
+        this.index = parseInt(name.charAt(name.length - 1));
+        this.octree = octree;
+        this.geometry = null;
+        this.boundingBox = boundingBox;
+        this.boundingSphere = boundingBox.getBoundingSphere(new THREE.Sphere());
+        this.children = {};
+        this.numPoints = 0;
+        this.level = null;
+        this.loaded = false;
+        this.oneTimeDisposeHandlers = [];
+    }
+    isGeometryNode() {
+        return true;
+    }
+    getLevel() {
+        return this.level;
+    }
+    isTreeNode() {
+        return false;
+    }
+    isLoaded() {
+        return this.loaded;
+    }
+    getBoundingSphere() {
+        return this.boundingSphere;
+    }
+    getBoundingBox() {
+        return this.boundingBox;
+    }
+    getChildren() {
+        // Children is a length 8 array with nulls for "missing" octants
+        return this.children.filter(Boolean);
+    }
+    getURL() {
+        const { version } = this.octree;
+        const hierarchyPath = version >= 1.5 ? `${this.getHierarchyPath()}/` : '';
+        return `${this.octree.octreeDir}/${hierarchyPath}${this.name}`;
+    }
+    getHierarchyPath() {
+        let path = 'r/';
+        let hierarchyStepSize = this.octree.hierarchyStepSize;
+        let indices = this.name.substr(1);
+        let numParts = Math.floor(indices.length / hierarchyStepSize);
+        for (let i = 0; i < numParts; i++) {
+            path += indices.substr(i * hierarchyStepSize, hierarchyStepSize) + '/';
         }
-
-        if (offset === hbuffer.byteLength) {
-          break;
+        path = path.slice(0, -1);
+        return path;
+    }
+    addChild(child) {
+        this.children[child.index] = child;
+        child.parent = this;
+    }
+    load() {
+        if (this.loading === true ||
+            this.loaded === true ||
+            Potree.numNodesLoading >= Potree.maxNodesLoading) {
+            return;
+        }
+        this.loading = true;
+        Potree.numNodesLoading++;
+        if (this.octree.loader.version.equalOrHigher('1.5')) {
+            if (this.level % this.octree.hierarchyStepSize === 0 && this.hasChildren) {
+                this.loadHierachyThenPoints();
+            }
+            else {
+                this.loadPoints();
+            }
+        }
+        else {
+            this.loadPoints();
+        }
+    }
+    loadPoints() {
+        this.octree.loader.load(this);
+    }
+    loadHierachyThenPoints() {
+        let node = this;
+        // load hierarchy
+        let callback = function (node, hbuffer) {
+            let view = new DataView(hbuffer);
+            let stack = [];
+            let children = view.getUint8(0);
+            let numPoints = view.getUint32(1, true);
+            node.numPoints = numPoints;
+            stack.push({ children: children, numPoints: numPoints, name: node.name });
+            let decoded = [];
+            let offset = 5;
+            while (stack.length > 0) {
+                let snode = stack.shift();
+                let mask = 1;
+                for (let i = 0; i < 8; i++) {
+                    if ((snode.children & mask) !== 0) {
+                        let childName = snode.name + i;
+                        let childChildren = view.getUint8(offset);
+                        let childNumPoints = view.getUint32(offset + 1, true);
+                        stack.push({ children: childChildren, numPoints: childNumPoints, name: childName });
+                        decoded.push({ children: childChildren, numPoints: childNumPoints, name: childName });
+                        offset += 5;
+                    }
+                    mask = mask * 2;
+                }
+                if (offset === hbuffer.byteLength) {
+                    break;
+                }
+            }
+            // console.log(decoded);
+            let nodes = {};
+            nodes[node.name] = node;
+            let pco = node.pcoGeometry;
+            for (let i = 0; i < decoded.length; i++) {
+                let name = decoded[i].name;
+                let decodedNumPoints = decoded[i].numPoints;
+                let index = parseInt(name.charAt(name.length - 1));
+                let parentName = name.substring(0, name.length - 1);
+                let parentNode = nodes[parentName];
+                let level = name.length - 1;
+                let boundingBox = Utils.createChildAABB(parentNode.boundingBox, index);
+                let currentNode = new PointCloudOctreeGeometryNode(name, pco, boundingBox);
+                currentNode.level = level;
+                currentNode.numPoints = decodedNumPoints;
+                currentNode.hasChildren = decoded[i].children > 0;
+                currentNode.spacing = pco.spacing / Math.pow(2, level);
+                parentNode.addChild(currentNode);
+                nodes[name] = currentNode;
+            }
+            node.loadPoints();
+        };
+        if (node.level % node.pcoGeometry.hierarchyStepSize === 0) {
+            // let hurl = node.pcoGeometry.octreeDir + "/../hierarchy/" + node.name + ".hrc";
+            let hurl = node.pcoGeometry.octreeDir + '/' + node.getHierarchyPath() + '/' + node.name + '.hrc';
+            let xhr = XHRFactory.createXMLHttpRequest();
+            xhr.open('GET', hurl, true);
+            xhr.responseType = 'arraybuffer';
+            xhr.overrideMimeType('text/plain; charset=x-user-defined');
+            xhr.onreadystatechange = () => {
+                if (xhr.readyState === 4) {
+                    if (xhr.status === 200 || xhr.status === 0) {
+                        let hbuffer = xhr.response;
+                        callback(node, hbuffer);
+                    }
+                    else {
+                        console.log('Failed to load file! HTTP status: ' + xhr.status + ', file: ' + hurl);
+                        Potree.numNodesLoading--;
+                    }
+                }
+            };
+            try {
+                xhr.send(null);
+            }
+            catch (e) {
+                console.log('fehler beim laden der punktwolke: ' + e);
+            }
         }
-      }
-
-      let nodes = {};
-      nodes[node.name] = node;
-      let pco = node.pcoGeometry;
-
-      for (let i = 0; i < decoded.length; i++) {
-        let name = decoded[i].name;
-        let decodedNumPoints = decoded[i].numPoints;
-        let index = parseInt(name.charAt(name.length - 1));
-        let parentName = name.substring(0, name.length - 1);
-        let parentNode = nodes[parentName];
-        let level = name.length - 1;
-        let boundingBox = Utils.createChildAABB(parentNode.boundingBox, index);
-        let currentNode = new PointCloudOctreeGeometryNode(name, pco, boundingBox);
-        currentNode.level = level;
-        currentNode.numPoints = decodedNumPoints;
-        currentNode.hasChildren = decoded[i].children > 0;
-        currentNode.spacing = pco.spacing / Math.pow(2, level);
-        parentNode.addChild(currentNode);
-        nodes[name] = currentNode;
-      }
-
-      node.loadPoints();
-    };
-
-    if (node.level % node.pcoGeometry.hierarchyStepSize === 0) {
-      let hurl = node.pcoGeometry.octreeDir + '/' + node.getHierarchyPath() + '/' + node.name + '.hrc';
-      let xhr = XHRFactory.createXMLHttpRequest();
-      xhr.open('GET', hurl, true);
-      xhr.responseType = 'arraybuffer';
-      xhr.overrideMimeType('text/plain; charset=x-user-defined');
-
-      xhr.onreadystatechange = () => {
-        if (xhr.readyState === 4) {
-          if (xhr.status === 200 || xhr.status === 0) {
-            let hbuffer = xhr.response;
-            callback(node, hbuffer);
-          } else {
-            console.log('Failed to load file! HTTP status: ' + xhr.status + ', file: ' + hurl);
-            Potree.numNodesLoading--;
-          }
+    }
+    getNumPoints() {
+        return this.numPoints;
+    }
+    dispose() {
+        if (this.geometry && this.parent != null) {
+            this.geometry.dispose();
+            this.geometry = null;
+            this.loaded = false;
+            // this.dispatchEvent( { type: 'dispose' } );
+            for (let i = 0; i < this.oneTimeDisposeHandlers.length; i++) {
+                let handler = this.oneTimeDisposeHandlers[i];
+                handler();
+            }
+            this.oneTimeDisposeHandlers = [];
         }
-      };
-
-      try {
-        xhr.send(null);
-      } catch (e) {
-        console.log('fehler beim laden der punktwolke: ' + e);
-      }
-    }
-  }
-
-  getNumPoints() {
-    return this.numPoints;
-  }
-
-  dispose() {
-    if (this.geometry && this.parent != null) {
-      this.geometry.dispose();
-      this.geometry = null;
-      this.loaded = false;
-
-      for (let i = 0; i < this.oneTimeDisposeHandlers.length; i++) {
-        let handler = this.oneTimeDisposeHandlers[i];
-        handler();
-      }
-
-      this.oneTimeDisposeHandlers = [];
-    }
-  }
-
+    }
 }
+exports.PointCloudOctant = PointCloudOctant;
 PointCloudOctreeGeometryNode.IDCount = 0;
-//# sourceMappingURL=octree.js.map

package/dist/parsers/parse-potree-bin.js

@@ -1,4 +1,6 @@
-export default function parsePotreeBin(arrayBuffer, byteOffset, options, index) {
-  return null;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function parsePotreeBin(arrayBuffer, byteOffset, options, index) {
+    return null;
 }
-//# sourceMappingURL=parse-potree-bin.js.map
+exports.default = parsePotreeBin;

package/dist/parsers/parse-potree-hierarchy-chunk.js

@@ -1,83 +1,129 @@
-export default function parsePotreeHierarchyChunk(arrayBuffer) {
-  const tileHeaders = parseBinaryChunk(arrayBuffer);
-  return buildHierarchy(tileHeaders);
-}
+"use strict";
+// This file is derived from the Cesium code base under BSD 2-clause license
+// See LICENSE.md and https://github.com/potree/potree/blob/develop/LICENSE
+Object.defineProperty(exports, "__esModule", { value: true });
+// Potree Hierarchy Chunk file format
+// https://github.com/potree/potree/blob/develop/docs/potree-file-format.md#index-files
+/*
+### Hierarchy Chunk Files
 
-function parseBinaryChunk(arrayBuffer, byteOffset = 0) {
-  const dataView = new DataView(arrayBuffer);
-  const stack = [];
-  const topTileHeader = {};
-  byteOffset = decodeRow(dataView, byteOffset, topTileHeader);
-  stack.push(topTileHeader);
-  const tileHeaders = [];
+As mentioned in the former section, the `.hrc` files contain the index structure
+meaning a list of all the files stored within the directory tree.
 
-  while (stack.length > 0) {
-    const snode = stack.shift();
-    let mask = 1;
+An index file contains a list of tuple values with the first being a `uint8`
+"mask" and the second being `uint32` "number of points" of a hierarchy level
+in a [breadth first level order][breadth-first].
 
-    for (let i = 0; i < 8; i++) {
-      if (snode && (snode.header.childMask & mask) !== 0) {
-        const tileHeader = {};
-        byteOffset = decodeRow(dataView, byteOffset, tileHeader);
-        tileHeader.name = snode.name + i;
-        stack.push(tileHeader);
-        tileHeaders.push(tileHeader);
-        snode.header.childCount++;
-      }
+Per hierarchy level we have 8 possible nodes. To indicate whether a node exists
+a simple binary mask is used:
 
-      mask = mask * 2;
-    }
+| Position | Mask | [Binary][bin] |
+|----------|------|---------------|
+| 0        | 1    | 0b00000001    |
+| 1        | 2    | 0b00000010    |
+| 2        | 4    | 0b00000100    |
+| 3        | 8    | 0b00001000    |
+| 4        | 16   | 0b00010000    |
+| 5        | 32   | 0b00100000    |
+| 6        | 64   | 0b01000000    |
+| 7        | 128  | 0b10000000    |
 
-    if (byteOffset === dataView.byteLength) {
-      break;
-    }
-  }
+So if in a hierarchy the child node 3 and node 7 exist then the hierarchies
+mask has to be `0b00001000 | 0b10000000` → `0b10001000` (=136).
 
-  return tileHeaders;
-}
+_Example:_ A simple, non-realistic tree:
+
+```
+|- r1
+|  |
+|  \- r14 (2 Points)
+|
+\- r3
+   |
+   \- r36 (1 Point)
+```
 
+Would have an index looking like this:
+
+| name | mask               | points |
+|------|--------------------|--------|
+| r    | `0b00001010` (=10) | `3`    |
+| r1   | `0b00010000` (=16) | `2`    |
+| r3   | `0b01000000` (=64) | `1`    |
+| r14  | `0b00000000` (=0)  | `2`    |
+| r36  | `0b00000000` (=0)  | `1`    |
+*/
+// @ts-nocheck
+// load hierarchy
+function parsePotreeHierarchyChunk(arrayBuffer) {
+    const tileHeaders = parseBinaryChunk(arrayBuffer);
+    return buildHierarchy(tileHeaders);
+}
+exports.default = parsePotreeHierarchyChunk;
+// Parses the binary rows
+function parseBinaryChunk(arrayBuffer, byteOffset = 0) {
+    const dataView = new DataView(arrayBuffer);
+    const stack = [];
+    // Get root mask
+    const topTileHeader = {};
+    byteOffset = decodeRow(dataView, byteOffset, topTileHeader);
+    stack.push(topTileHeader);
+    const tileHeaders = [];
+    while (stack.length > 0) {
+        const snode = stack.shift();
+        let mask = 1;
+        for (let i = 0; i < 8; i++) {
+            if (snode && (snode.header.childMask & mask) !== 0) {
+                const tileHeader = {};
+                byteOffset = decodeRow(dataView, byteOffset, tileHeader);
+                tileHeader.name = snode.name + i;
+                stack.push(tileHeader);
+                tileHeaders.push(tileHeader);
+                snode.header.childCount++;
+            }
+            mask = mask * 2;
+        }
+        if (byteOffset === dataView.byteLength) {
+            break;
+        }
+    }
+    return tileHeaders;
+}
 function decodeRow(dataView, byteOffset, tileHeader) {
-  tileHeader.header = tileHeader.header || {};
-  tileHeader.header.childMask = dataView.getUint8(byteOffset);
-  tileHeader.header.childCount = 0;
-  tileHeader.pointCount = dataView.getUint32(byteOffset + 1, true);
-  tileHeader.name = '';
-  byteOffset += 5;
-  return byteOffset;
+    tileHeader.header = tileHeader.header || {};
+    tileHeader.header.childMask = dataView.getUint8(byteOffset);
+    tileHeader.header.childCount = 0;
+    tileHeader.pointCount = dataView.getUint32(byteOffset + 1, true);
+    tileHeader.name = '';
+    byteOffset += 5;
+    return byteOffset;
 }
-
+// Resolves the binary rows into a hierarchy (tree structure)
 function buildHierarchy(tileHeaders, options = {}) {
-  const DEFAULT_OPTIONS = {
-    spacing: 100
-  };
-  options = { ...DEFAULT_OPTIONS,
-    ...options
-  };
-  const topNode = tileHeaders[0];
-  const nodes = {};
-
-  for (const tileHeader of tileHeaders) {
-    const {
-      name
-    } = tileHeader;
-    const index = parseInt(name.charAt(name.length - 1), 10);
-    const parentName = name.substring(0, name.length - 1);
-    const parentNode = nodes[parentName];
-    const level = name.length - 1;
-    tileHeader.level = level;
-    tileHeader.hasChildren = tileHeader.header.childCount;
-    tileHeader.children = [];
-    tileHeader.childrenByIndex = new Array(8).fill(null);
-    tileHeader.spacing = options.spacing / Math.pow(2, level);
-
-    if (parentNode) {
-      parentNode.children.push(tileHeader);
-      parentNode.childrenByIndex[index] = tileHeader;
+    const DEFAULT_OPTIONS = { spacing: 100 }; // TODO assert instead of default?
+    options = { ...DEFAULT_OPTIONS, ...options };
+    const topNode = tileHeaders[0];
+    const nodes = {};
+    for (const tileHeader of tileHeaders) {
+        const { name } = tileHeader;
+        const index = parseInt(name.charAt(name.length - 1), 10);
+        const parentName = name.substring(0, name.length - 1);
+        const parentNode = nodes[parentName];
+        const level = name.length - 1;
+        // assert(parentNode && level >= 0);
+        tileHeader.level = level;
+        tileHeader.hasChildren = tileHeader.header.childCount;
+        tileHeader.children = [];
+        tileHeader.childrenByIndex = new Array(8).fill(null);
+        tileHeader.spacing = options.spacing / Math.pow(2, level);
+        // tileHeader.boundingVolume = Utils.createChildAABB(parentNode.boundingBox, index);
+        if (parentNode) {
+            parentNode.children.push(tileHeader);
+            parentNode.childrenByIndex[index] = tileHeader;
+        }
+        // Add the node to the map
+        nodes[name] = tileHeader;
     }
-
-    nodes[name] = tileHeader;
-  }
-
-  return topNode;
+    // First node is the root
+    return topNode;
 }
-//# sourceMappingURL=parse-potree-hierarchy-chunk.js.map

package/dist/potree-bin-loader.js

@@ -1,17 +1,27 @@
-import { default as parsePotreeBin } from './parsers/parse-potree-bin';
-export const PotreeBinLoader = {
-  name: 'potree Binary Point Attributes',
-  id: 'potree',
-  extensions: ['bin'],
-  mimeTypes: ['application/octet-stream'],
-  parseSync,
-  binary: true
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PotreeBinLoader = void 0;
+const parse_potree_bin_1 = __importDefault(require("./parsers/parse-potree-bin"));
+/**
+ * Loader for potree Binary Point Attributes
+ * */
+// @ts-ignore
+exports.PotreeBinLoader = {
+    name: 'potree Binary Point Attributes',
+    id: 'potree',
+    extensions: ['bin'],
+    mimeTypes: ['application/octet-stream'],
+    // Unfortunately binary potree files have no header bytes, no test possible
+    // test: ['...'],
+    parseSync,
+    binary: true
 };
-
 function parseSync(arrayBuffer, options) {
-  const index = {};
-  const byteOffset = 0;
-  parsePotreeBin(arrayBuffer, byteOffset, options, index);
-  return index;
+    const index = {};
+    const byteOffset = 0;
+    (0, parse_potree_bin_1.default)(arrayBuffer, byteOffset, options, index);
+    return index;
 }
-//# sourceMappingURL=potree-bin-loader.js.map