itowns 2.45.1-next.0 → 2.45.1-next.1

package/lib/Core/PointCloudNode.js

@@ -0,0 +1,42 @@
+import * as THREE from 'three';
+class PointCloudNode extends THREE.EventDispatcher {
+  constructor() {
+    let numPoints = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let layer = arguments.length > 1 ? arguments[1] : undefined;
+    super();
+    this.numPoints = numPoints;
+    this.layer = layer;
+    this.children = [];
+    this.bbox = new THREE.Box3();
+    this.sse = -1;
+  }
+  add(node, indexChild) {
+    this.children.push(node);
+    node.parent = this;
+    this.createChildAABB(node, indexChild);
+  }
+  load() {
+    // Query octree/HRC if we don't have children potreeNode yet.
+    if (!this.octreeIsLoaded) {
+      this.loadOctree();
+    }
+    return this.layer.source.fetcher(this.url, this.layer.source.networkOptions).then(file => this.layer.source.parse(file, {
+      out: this.layer,
+      in: this.layer.source
+    }));
+  }
+  findCommonAncestor(node) {
+    if (node.depth == this.depth) {
+      if (node.id == this.id) {
+        return node;
+      } else if (node.depth != 0) {
+        return this.parent.findCommonAncestor(node.parent);
+      }
+    } else if (node.depth < this.depth) {
+      return this.parent.findCommonAncestor(node);
+    } else {
+      return this.findCommonAncestor(node.parent);
+    }
+  }
+}
+export default PointCloudNode;

package/lib/Core/Potree2Node.js

@@ -0,0 +1,206 @@
+/*
+============
+== POTREE ==
+============
+
+http://potree.org
+
+Copyright (c) 2011-2020, Markus Schütz
+All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    The views and conclusions contained in the software and documentation are those
+of the authors and should not be interpreted as representing official policies,
+    either expressed or implied, of the FreeBSD Project.
+ */
+
+import * as THREE from 'three';
+import PointCloudNode from "./PointCloudNode.js";
+
+// Create an A(xis)A(ligned)B(ounding)B(ox) for the child `childIndex` of one aabb.
+// (PotreeConverter protocol builds implicit octree hierarchy by applying the same
+// subdivision algo recursively)
+const dHalfLength = new THREE.Vector3();
+const NODE_TYPE = {
+  NORMAL: 0,
+  LEAF: 1,
+  PROXY: 2
+};
+class Potree2Node extends PointCloudNode {
+  constructor() {
+    let numPoints = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let childrenBitField = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    let layer = arguments.length > 2 ? arguments[2] : undefined;
+    super(numPoints, layer);
+    this.childrenBitField = childrenBitField;
+    this.id = '';
+    this.depth = 0;
+    this.baseurl = layer.source.baseurl;
+  }
+  add(node, indexChild) {
+    super.add(node, indexChild);
+    node.id = this.id + indexChild;
+    node.depth = this.depth + 1;
+  }
+  createChildAABB(node, childIndex) {
+    // Code inspired from potree
+    node.bbox.copy(this.bbox);
+    this.bbox.getCenter(node.bbox.max);
+    dHalfLength.copy(node.bbox.max).sub(this.bbox.min);
+    if (childIndex === 1) {
+      node.bbox.min.z += dHalfLength.z;
+      node.bbox.max.z += dHalfLength.z;
+    } else if (childIndex === 3) {
+      node.bbox.min.z += dHalfLength.z;
+      node.bbox.max.z += dHalfLength.z;
+      node.bbox.min.y += dHalfLength.y;
+      node.bbox.max.y += dHalfLength.y;
+    } else if (childIndex === 0) {
+      //
+    } else if (childIndex === 2) {
+      node.bbox.min.y += dHalfLength.y;
+      node.bbox.max.y += dHalfLength.y;
+    } else if (childIndex === 5) {
+      node.bbox.min.z += dHalfLength.z;
+      node.bbox.max.z += dHalfLength.z;
+      node.bbox.min.x += dHalfLength.x;
+      node.bbox.max.x += dHalfLength.x;
+    } else if (childIndex === 7) {
+      node.bbox.min.add(dHalfLength);
+      node.bbox.max.add(dHalfLength);
+    } else if (childIndex === 4) {
+      node.bbox.min.x += dHalfLength.x;
+      node.bbox.max.x += dHalfLength.x;
+    } else if (childIndex === 6) {
+      node.bbox.min.y += dHalfLength.y;
+      node.bbox.max.y += dHalfLength.y;
+      node.bbox.min.x += dHalfLength.x;
+      node.bbox.max.x += dHalfLength.x;
+    }
+  }
+  get octreeIsLoaded() {
+    return !(this.childrenBitField && this.children.length === 0);
+  }
+  get url() {
+    return `${this.baseurl}/octree.bin`;
+  }
+  networkOptions(byteOffset, byteSize) {
+    const first = byteOffset;
+    // When we specify 'multipart/byteranges' on headers request it trigger a preflight request
+    // Actually github doesn't support it https://github.com/orgs/community/discussions/24659
+    // But if we omit header parameter, github seems to know it's a 'multipart/byteranges' request (thanks to 'Range' parameter)
+    const networkOptions = {
+      ...this.layer.source.networkOptions,
+      headers: {
+        ...this.layer.source.networkOptions.headers,
+        ...(this.url.startsWith('https://raw.githubusercontent.com') ? {} : {
+          'content-type': 'multipart/byteranges'
+        }),
+        Range: `bytes=${first}-${first + byteSize - 1n}`
+      }
+    };
+    return networkOptions;
+  }
+  async load() {
+    // Query octree if we don't have children potreeNode yet.
+    if (!this.octreeIsLoaded) {
+      await this.loadOctree();
+    }
+    return this.layer.source.fetcher(this.url, this.networkOptions(this.byteOffset, this.byteSize)).then(file => this.layer.source.parser(file, {
+      in: {
+        source: this.layer.source,
+        bbox: this.bbox,
+        numPoints: this.numPoints
+      },
+      out: this.layer
+    })).then(data => {
+      this.loaded = true;
+      this.loading = false;
+      return data.geometry;
+    });
+  }
+  async loadOctree() {
+    if (this.loaded || this.loading) {
+      return;
+    }
+    this.loading = true;
+    return this.nodeType === NODE_TYPE.PROXY ? this.loadHierarchy() : Promise.resolve();
+  }
+  async loadHierarchy() {
+    const hierarchyPath = `${this.baseurl}/hierarchy.bin`;
+    const buffer = await this.layer.source.fetcher(hierarchyPath, this.networkOptions(this.hierarchyByteOffset, this.hierarchyByteSize));
+    this.parseHierarchy(buffer);
+  }
+  parseHierarchy(buffer) {
+    const view = new DataView(buffer);
+    const bytesPerNode = 22;
+    const numNodes = buffer.byteLength / bytesPerNode;
+    const stack = [];
+    stack.push(this);
+    for (let indexNode = 0; indexNode < numNodes; indexNode++) {
+      const current = stack.shift();
+      const offset = indexNode * bytesPerNode;
+      const type = view.getUint8(offset + 0);
+      const childMask = view.getUint8(offset + 1);
+      const numPoints = view.getUint32(offset + 2, true);
+      const byteOffset = view.getBigInt64(offset + 6, true);
+      const byteSize = view.getBigInt64(offset + 14, true);
+      if (current.nodeType === NODE_TYPE.PROXY) {
+        // replace proxy with real node
+        current.byteOffset = byteOffset;
+        current.byteSize = byteSize;
+        current.numPoints = numPoints;
+      } else if (type === NODE_TYPE.PROXY) {
+        // load proxy
+        current.hierarchyByteOffset = byteOffset;
+        current.hierarchyByteSize = byteSize;
+        current.numPoints = numPoints;
+      } else {
+        // load real node
+        current.byteOffset = byteOffset;
+        current.byteSize = byteSize;
+        current.numPoints = numPoints;
+      }
+      if (current.byteSize === 0n) {
+        // workaround for issue potree/potree#1125
+        // some inner nodes erroneously report >0 points even though have 0 points
+        // however, they still report a byteSize of 0, so based on that we now set node.numPoints to 0
+        current.numPoints = 0;
+      }
+      current.nodeType = type;
+      if (current.nodeType === NODE_TYPE.PROXY) {
+        continue;
+      }
+      for (let childIndex = 0; childIndex < 8; childIndex++) {
+        const childExists = (1 << childIndex & childMask) !== 0;
+        if (!childExists) {
+          continue;
+        }
+        const child = new Potree2Node(numPoints, childMask, this.layer);
+        child.spacing = current.spacing / 2;
+        current.add(child, childIndex);
+        stack.push(child);
+      }
+    }
+  }
+}
+export default Potree2Node;

package/lib/Core/Potree2PointAttributes.js

@@ -0,0 +1,139 @@
+/*
+============
+== POTREE ==
+============
+
+http://potree.org
+
+Copyright (c) 2011-2020, Markus Schütz
+All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    The views and conclusions contained in the software and documentation are those
+of the authors and should not be interpreted as representing official policies,
+    either expressed or implied, of the FreeBSD Project.
+ */
+
+/**
+ * Some types of possible point attribute data formats
+ *
+ * @class
+ */
+const PointAttributeTypes = {
+  DATA_TYPE_DOUBLE: {
+    name: 'double',
+    size: 8
+  },
+  DATA_TYPE_FLOAT: {
+    name: 'float',
+    size: 4
+  },
+  DATA_TYPE_INT8: {
+    name: 'int8',
+    size: 1
+  },
+  DATA_TYPE_UINT8: {
+    name: 'uint8',
+    size: 1
+  },
+  DATA_TYPE_INT16: {
+    name: 'int16',
+    size: 2
+  },
+  DATA_TYPE_UINT16: {
+    name: 'uint16',
+    size: 2
+  },
+  DATA_TYPE_INT32: {
+    name: 'int32',
+    size: 4
+  },
+  DATA_TYPE_UINT32: {
+    name: 'uint32',
+    size: 4
+  },
+  DATA_TYPE_INT64: {
+    name: 'int64',
+    size: 8
+  },
+  DATA_TYPE_UINT64: {
+    name: 'uint64',
+    size: 8
+  }
+};
+Object.keys(PointAttributeTypes).forEach((type, index) => {
+  PointAttributeTypes[index] = PointAttributeTypes[type];
+});
+export { PointAttributeTypes };
+class PointAttribute {
+  constructor(name, type, numElements) {
+    this.name = name;
+    this.type = type;
+    this.numElements = numElements;
+    this.byteSize = this.numElements * this.type.size;
+    this.description = '';
+    this.range = [Infinity, -Infinity];
+  }
+}
+PointAttribute.POSITION_CARTESIAN = new PointAttribute('POSITION_CARTESIAN', PointAttributeTypes.DATA_TYPE_FLOAT, 3);
+PointAttribute.RGBA_PACKED = new PointAttribute('COLOR_PACKED', PointAttributeTypes.DATA_TYPE_INT8, 4);
+PointAttribute.COLOR_PACKED = PointAttribute.RGBA_PACKED;
+PointAttribute.RGB_PACKED = new PointAttribute('COLOR_PACKED', PointAttributeTypes.DATA_TYPE_INT8, 3);
+PointAttribute.NORMAL_FLOATS = new PointAttribute('NORMAL_FLOATS', PointAttributeTypes.DATA_TYPE_FLOAT, 3);
+PointAttribute.INTENSITY = new PointAttribute('INTENSITY', PointAttributeTypes.DATA_TYPE_UINT16, 1);
+PointAttribute.CLASSIFICATION = new PointAttribute('CLASSIFICATION', PointAttributeTypes.DATA_TYPE_UINT8, 1);
+PointAttribute.NORMAL_SPHEREMAPPED = new PointAttribute('NORMAL_SPHEREMAPPED', PointAttributeTypes.DATA_TYPE_UINT8, 2);
+PointAttribute.NORMAL_OCT16 = new PointAttribute('NORMAL_OCT16', PointAttributeTypes.DATA_TYPE_UINT8, 2);
+PointAttribute.NORMAL = new PointAttribute('NORMAL', PointAttributeTypes.DATA_TYPE_FLOAT, 3);
+PointAttribute.RETURN_NUMBER = new PointAttribute('RETURN_NUMBER', PointAttributeTypes.DATA_TYPE_UINT8, 1);
+PointAttribute.NUMBER_OF_RETURNS = new PointAttribute('NUMBER_OF_RETURNS', PointAttributeTypes.DATA_TYPE_UINT8, 1);
+PointAttribute.SOURCE_ID = new PointAttribute('SOURCE_ID', PointAttributeTypes.DATA_TYPE_UINT16, 1);
+PointAttribute.INDICES = new PointAttribute('INDICES', PointAttributeTypes.DATA_TYPE_UINT32, 1);
+PointAttribute.SPACING = new PointAttribute('SPACING', PointAttributeTypes.DATA_TYPE_FLOAT, 1);
+PointAttribute.GPS_TIME = new PointAttribute('GPS_TIME', PointAttributeTypes.DATA_TYPE_DOUBLE, 1);
+export { PointAttribute };
+export class Potree2PointAttributes {
+  constructor() {
+    this.attributes = [];
+    this.byteSize = 0;
+    this.size = 0;
+    this.vectors = [];
+  }
+  add(pointAttribute) {
+    this.attributes.push(pointAttribute);
+    this.byteSize += pointAttribute.byteSize;
+    this.size++;
+  }
+  addVector(vector) {
+    this.vectors.push(vector);
+  }
+  hasNormals() {
+    for (let index = 0; index < this.attributes.length; index++) {
+      const name = this.attributes[index];
+      const pointAttribute = this.attributes[name];
+      if (pointAttribute === PointAttribute.NORMAL_SPHEREMAPPED || pointAttribute === PointAttribute.NORMAL_FLOATS || pointAttribute === PointAttribute.NORMAL || pointAttribute === PointAttribute.NORMAL_OCT16) {
+        return true;
+      }
+    }
+    return false;
+  }
+}

package/lib/Core/PotreeNode.js

@@ -0,0 +1,101 @@
+import * as THREE from 'three';
+import PointCloudNode from "./PointCloudNode.js";
+
+// Create an A(xis)A(ligned)B(ounding)B(ox) for the child `childIndex` of one aabb.
+// (PotreeConverter protocol builds implicit octree hierarchy by applying the same
+// subdivision algo recursively)
+const dHalfLength = new THREE.Vector3();
+class PotreeNode extends PointCloudNode {
+  constructor() {
+    let numPoints = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let childrenBitField = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    let layer = arguments.length > 2 ? arguments[2] : undefined;
+    super(numPoints, layer);
+    this.childrenBitField = childrenBitField;
+    this.id = '';
+    this.depth = 0;
+    this.baseurl = layer.source.baseurl;
+  }
+  add(node, indexChild, root) {
+    super.add(node, indexChild);
+    node.id = this.id + indexChild;
+    node.depth = node.id.length;
+    if (node.id.length % this.layer.hierarchyStepSize == 0) {
+      node.baseurl = `${root.baseurl}/${node.id.substr(root.id.length)}`;
+    } else {
+      node.baseurl = root.baseurl;
+    }
+  }
+  createChildAABB(node, childIndex) {
+    // Code inspired from potree
+    node.bbox.copy(this.bbox);
+    this.bbox.getCenter(node.bbox.max);
+    dHalfLength.copy(node.bbox.max).sub(this.bbox.min);
+    if (childIndex === 1) {
+      node.bbox.min.z += dHalfLength.z;
+      node.bbox.max.z += dHalfLength.z;
+    } else if (childIndex === 3) {
+      node.bbox.min.z += dHalfLength.z;
+      node.bbox.max.z += dHalfLength.z;
+      node.bbox.min.y += dHalfLength.y;
+      node.bbox.max.y += dHalfLength.y;
+    } else if (childIndex === 0) {
+      //
+    } else if (childIndex === 2) {
+      node.bbox.min.y += dHalfLength.y;
+      node.bbox.max.y += dHalfLength.y;
+    } else if (childIndex === 5) {
+      node.bbox.min.z += dHalfLength.z;
+      node.bbox.max.z += dHalfLength.z;
+      node.bbox.min.x += dHalfLength.x;
+      node.bbox.max.x += dHalfLength.x;
+    } else if (childIndex === 7) {
+      node.bbox.min.add(dHalfLength);
+      node.bbox.max.add(dHalfLength);
+    } else if (childIndex === 4) {
+      node.bbox.min.x += dHalfLength.x;
+      node.bbox.max.x += dHalfLength.x;
+    } else if (childIndex === 6) {
+      node.bbox.min.y += dHalfLength.y;
+      node.bbox.max.y += dHalfLength.y;
+      node.bbox.min.x += dHalfLength.x;
+      node.bbox.max.x += dHalfLength.x;
+    }
+  }
+  get octreeIsLoaded() {
+    return !(this.childrenBitField && this.children.length === 0);
+  }
+  get url() {
+    return `${this.baseurl}/r${this.id}.${this.layer.source.extension}`;
+  }
+  loadOctree() {
+    const octreeUrl = `${this.baseurl}/r${this.id}.${this.layer.source.extensionOctree}`;
+    return this.layer.source.fetcher(octreeUrl, this.layer.source.networkOptions).then(blob => {
+      const view = new DataView(blob);
+      const stack = [];
+      let offset = 0;
+      this.childrenBitField = view.getUint8(0);
+      offset += 1;
+      this.numPoints = view.getUint32(1, true);
+      offset += 4;
+      stack.push(this);
+      while (stack.length && offset < blob.byteLength) {
+        const snode = stack.shift();
+        // look up 8 children
+        for (let indexChild = 0; indexChild < 8; indexChild++) {
+          // does snode have a #indexChild child ?
+          if (snode.childrenBitField & 1 << indexChild && offset + 5 <= blob.byteLength) {
+            const childrenBitField = view.getUint8(offset);
+            offset += 1;
+            const numPoints = view.getUint32(offset, true) || this.numPoints;
+            offset += 4;
+            const item = new PotreeNode(numPoints, childrenBitField, this.layer);
+            snode.add(item, indexChild, this);
+            stack.push(item);
+          }
+        }
+      }
+    });
+  }
+}
+export default PotreeNode;