@loaders.gl/potree 3.1.0-alpha.4 → 3.1.0-beta.3

package/dist/bundle.d.ts

@@ -0,0 +1,2 @@
+declare const moduleExports: any;
+//# sourceMappingURL=bundle.d.ts.map

package/dist/bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../src/bundle.ts"],"names":[],"mappings":"AACA,QAAA,MAAM,aAAa,KAAqB,CAAC"}

package/dist/bundle.js

@@ -0,0 +1,182 @@
+(() => {
+  var __defProp = Object.defineProperty;
+  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __esm = (fn, res) => function __init() {
+    return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
+  };
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    __markAsModule(target);
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+
+  // src/potree-loader.ts
+  var VERSION, PotreeLoader;
+  var init_potree_loader = __esm({
+    "src/potree-loader.ts"() {
+      VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      PotreeLoader = {
+        name: "potree",
+        id: "potree",
+        module: "potree",
+        version: VERSION,
+        extensions: ["json"],
+        mimeTypes: ["application/json"],
+        testText: (text) => text.indexOf("octreeDir") >= 0,
+        parseTextSync: (text) => JSON.parse(text),
+        options: {
+          potree: {}
+        }
+      };
+    }
+  });
+
+  // src/parsers/parse-potree-hierarchy-chunk.ts
+  function parsePotreeHierarchyChunk(arrayBuffer) {
+    const tileHeaders = parseBinaryChunk(arrayBuffer);
+    return buildHierarchy(tileHeaders);
+  }
+  function parseBinaryChunk(arrayBuffer, byteOffset = 0) {
+    const dataView = new DataView(arrayBuffer);
+    const stack = [];
+    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;
+  }
+  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;
+      }
+      nodes[name] = tileHeader;
+    }
+    return topNode;
+  }
+  var init_parse_potree_hierarchy_chunk = __esm({
+    "src/parsers/parse-potree-hierarchy-chunk.ts"() {
+    }
+  });
+
+  // src/potree-hierarchy-chunk-loader.ts
+  function parseSync(arrayBuffer) {
+    return parsePotreeHierarchyChunk(arrayBuffer);
+  }
+  var PotreeHierarchyChunkLoader;
+  var init_potree_hierarchy_chunk_loader = __esm({
+    "src/potree-hierarchy-chunk-loader.ts"() {
+      init_parse_potree_hierarchy_chunk();
+      PotreeHierarchyChunkLoader = {
+        id: "potree",
+        name: "potree Hierarchy Chunk",
+        extensions: ["hrc"],
+        mimeTypes: ["application/octet-stream"],
+        parse: async (arrayBuffer, options) => await parseSync(arrayBuffer),
+        parseSync,
+        binary: true
+      };
+    }
+  });
+
+  // src/parsers/parse-potree-bin.ts
+  function parsePotreeBin(arrayBuffer, byteOffset, options, index) {
+    return null;
+  }
+  var init_parse_potree_bin = __esm({
+    "src/parsers/parse-potree-bin.ts"() {
+    }
+  });
+
+  // src/potree-bin-loader.ts
+  function parseSync2(arrayBuffer, options) {
+    const index = {};
+    const byteOffset = 0;
+    parsePotreeBin(arrayBuffer, byteOffset, options, index);
+    return index;
+  }
+  var PotreeBinLoader;
+  var init_potree_bin_loader = __esm({
+    "src/potree-bin-loader.ts"() {
+      init_parse_potree_bin();
+      PotreeBinLoader = {
+        name: "potree Binary Point Attributes",
+        id: "potree",
+        extensions: ["bin"],
+        mimeTypes: ["application/octet-stream"],
+        parseSync: parseSync2,
+        binary: true
+      };
+    }
+  });
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    PotreeBinLoader: () => PotreeBinLoader,
+    PotreeHierarchyChunkLoader: () => PotreeHierarchyChunkLoader,
+    PotreeLoader: () => PotreeLoader
+  });
+  var init_src = __esm({
+    "src/index.ts"() {
+      init_potree_loader();
+      init_potree_hierarchy_chunk_loader();
+      init_potree_bin_loader();
+    }
+  });
+
+  // src/bundle.ts
+  var require_bundle = __commonJS({
+    "src/bundle.ts"(exports, module) {
+      var moduleExports = (init_src(), src_exports);
+      globalThis.loaders = globalThis.loaders || {};
+      module.exports = Object.assign(globalThis.loaders, moduleExports);
+    }
+  });
+  require_bundle();
+})();

package/dist/es5/bundle.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var moduleExports = require('./index');
+const moduleExports = require('./index');
 
 globalThis.loaders = globalThis.loaders || {};
 module.exports = Object.assign(globalThis.loaders, moduleExports);

package/dist/es5/bundle.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":";;AACA,IAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}
+{"version":3,"sources":["../../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":";;AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}

package/dist/es5/index.js

@@ -5,19 +5,19 @@ Object.defineProperty(exports, "__esModule", {
 });
 Object.defineProperty(exports, "PotreeLoader", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _potreeLoader.PotreeLoader;
   }
 });
 Object.defineProperty(exports, "PotreeHierarchyChunkLoader", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _potreeHierarchyChunkLoader.PotreeHierarchyChunkLoader;
   }
 });
 Object.defineProperty(exports, "PotreeBinLoader", {
   enumerable: true,
-  get: function get() {
+  get: function () {
     return _potreeBinLoader.PotreeBinLoader;
   }
 });

package/dist/es5/lib/octree.js

@@ -1,34 +1,29 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.PointCloudOctant = exports.PointCloudOctree = void 0;
 
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+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;
+  }
 
-var PointCloudOctree = function PointCloudOctree() {
-  (0, _classCallCheck2.default)(this, PointCloudOctree);
-  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;
-};
+}
 
 exports.PointCloudOctree = PointCloudOctree;
 
-var PointCloudOctant = function () {
-  function PointCloudOctant(name, octree, boundingBox) {
-    (0, _classCallCheck2.default)(this, PointCloudOctant);
+class PointCloudOctant {
+  constructor(name, octree, boundingBox) {
     this.octree = this.id = PointCloudOctreeGeometryNode.IDCount++;
     this.name = name;
     this.index = parseInt(name.charAt(name.length - 1));
@@ -43,217 +38,202 @@ var PointCloudOctant = function () {
     this.oneTimeDisposeHandlers = [];
   }
 
-  (0, _createClass2.default)(PointCloudOctant, [{
-    key: "isGeometryNode",
-    value: function isGeometryNode() {
-      return true;
-    }
-  }, {
-    key: "getLevel",
-    value: function getLevel() {
-      return this.level;
-    }
-  }, {
-    key: "isTreeNode",
-    value: function isTreeNode() {
-      return false;
-    }
-  }, {
-    key: "isLoaded",
-    value: function isLoaded() {
-      return this.loaded;
-    }
-  }, {
-    key: "getBoundingSphere",
-    value: function getBoundingSphere() {
-      return this.boundingSphere;
-    }
-  }, {
-    key: "getBoundingBox",
-    value: function getBoundingBox() {
-      return this.boundingBox;
-    }
-  }, {
-    key: "getChildren",
-    value: function getChildren() {
-      return this.children.filter(Boolean);
-    }
-  }, {
-    key: "getURL",
-    value: function getURL() {
-      var version = this.octree.version;
-      var hierarchyPath = version >= 1.5 ? "".concat(this.getHierarchyPath(), "/") : '';
-      return "".concat(this.octree.octreeDir, "/").concat(hierarchyPath).concat(this.name);
-    }
-  }, {
-    key: "getHierarchyPath",
-    value: function getHierarchyPath() {
-      var path = 'r/';
-      var hierarchyStepSize = this.octree.hierarchyStepSize;
-      var indices = this.name.substr(1);
-      var numParts = Math.floor(indices.length / hierarchyStepSize);
-
-      for (var i = 0; i < numParts; i++) {
-        path += indices.substr(i * hierarchyStepSize, hierarchyStepSize) + '/';
-      }
+  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);
 
-      path = path.slice(0, -1);
-      return path;
+    for (let i = 0; i < numParts; i++) {
+      path += indices.substr(i * hierarchyStepSize, hierarchyStepSize) + '/';
     }
-  }, {
-    key: "addChild",
-    value: function addChild(child) {
-      this.children[child.index] = child;
-      child.parent = this;
+
+    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;
     }
-  }, {
-    key: "load",
-    value: function load() {
-      if (this.loading === true || this.loaded === true || Potree.numNodesLoading >= Potree.maxNodesLoading) {
-        return;
-      }
 
-      this.loading = true;
-      Potree.numNodesLoading++;
+    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();
-        }
+    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();
     }
-  }, {
-    key: "loadPoints",
-    value: function loadPoints() {
-      this.octree.loader.load(this);
-    }
-  }, {
-    key: "loadHierachyThenPoints",
-    value: function loadHierachyThenPoints() {
-      var node = this;
-
-      var callback = function callback(node, hbuffer) {
-        var view = new DataView(hbuffer);
-        var stack = [];
-        var children = view.getUint8(0);
-        var numPoints = view.getUint32(1, true);
-        node.numPoints = numPoints;
-        stack.push({
-          children: children,
-          numPoints: numPoints,
-          name: node.name
-        });
-        var decoded = [];
-        var offset = 5;
-
-        while (stack.length > 0) {
-          var snode = stack.shift();
-          var mask = 1;
-
-          for (var i = 0; i < 8; i++) {
-            if ((snode.children & mask) !== 0) {
-              var childName = snode.name + i;
-              var childChildren = view.getUint8(offset);
-              var 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;
+  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;
         }
 
-        var nodes = {};
-        nodes[node.name] = node;
-        var pco = node.pcoGeometry;
-
-        for (var _i = 0; _i < decoded.length; _i++) {
-          var name = decoded[_i].name;
-          var decodedNumPoints = decoded[_i].numPoints;
-          var index = parseInt(name.charAt(name.length - 1));
-          var parentName = name.substring(0, name.length - 1);
-          var parentNode = nodes[parentName];
-          var level = name.length - 1;
-          var boundingBox = Utils.createChildAABB(parentNode.boundingBox, index);
-          var 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;
+        if (offset === hbuffer.byteLength) {
+          break;
         }
+      }
 
-        node.loadPoints();
-      };
+      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;
+      }
 
-      if (node.level % node.pcoGeometry.hierarchyStepSize === 0) {
-        var hurl = node.pcoGeometry.octreeDir + '/' + node.getHierarchyPath() + '/' + node.name + '.hrc';
-        var xhr = XHRFactory.createXMLHttpRequest();
-        xhr.open('GET', hurl, true);
-        xhr.responseType = 'arraybuffer';
-        xhr.overrideMimeType('text/plain; charset=x-user-defined');
-
-        xhr.onreadystatechange = function () {
-          if (xhr.readyState === 4) {
-            if (xhr.status === 200 || xhr.status === 0) {
-              var hbuffer = xhr.response;
-              callback(node, hbuffer);
-            } else {
-              console.log('Failed to load file! HTTP status: ' + xhr.status + ', file: ' + hurl);
-              Potree.numNodesLoading--;
-            }
+      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--;
           }
-        };
-
-        try {
-          xhr.send(null);
-        } catch (e) {
-          console.log('fehler beim laden der punktwolke: ' + e);
         }
+      };
+
+      try {
+        xhr.send(null);
+      } catch (e) {
+        console.log('fehler beim laden der punktwolke: ' + e);
       }
     }
-  }, {
-    key: "getNumPoints",
-    value: function getNumPoints() {
-      return this.numPoints;
-    }
-  }, {
-    key: "dispose",
-    value: function dispose() {
-      if (this.geometry && this.parent != null) {
-        this.geometry.dispose();
-        this.geometry = null;
-        this.loaded = false;
-
-        for (var i = 0; i < this.oneTimeDisposeHandlers.length; i++) {
-          var handler = this.oneTimeDisposeHandlers[i];
-          handler();
-        }
+  }
+
+  getNumPoints() {
+    return this.numPoints;
+  }
+
+  dispose() {
+    if (this.geometry && this.parent != null) {
+      this.geometry.dispose();
+      this.geometry = null;
+      this.loaded = false;
 
-        this.oneTimeDisposeHandlers = [];
+      for (let i = 0; i < this.oneTimeDisposeHandlers.length; i++) {
+        let handler = this.oneTimeDisposeHandlers[i];
+        handler();
       }
+
+      this.oneTimeDisposeHandlers = [];
     }
-  }]);
-  return PointCloudOctant;
-}();
+  }
+
+}
 
 exports.PointCloudOctant = PointCloudOctant;
 PointCloudOctreeGeometryNode.IDCount = 0;