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

package/lib/Core/CopcNode.js

@@ -0,0 +1,174 @@
+import * as THREE from 'three';
+import { Hierarchy } from 'copc';
+import PointCloudNode from "./PointCloudNode.js";
+const size = new THREE.Vector3();
+const position = new THREE.Vector3();
+const translation = new THREE.Vector3();
+function buildId(depth, x, y, z) {
+  return `${depth}-${x}-${y}-${z}`;
+}
+class CopcNode extends PointCloudNode {
+  /**
+   * Constructs a new instance of a COPC Octree node
+   *
+   * @param {number} depth - Depth within the octree
+   * @param {number} x - X position within the octree
+   * @param {number} y - Y position within the octree
+   * @param {number} z - Z position with the octree
+   * @param {number} entryOffset - Offset from the beginning of the file of
+   * the node entry
+   * @param {number} entryLength - Size of the node entry
+   * @param {CopcLayer} layer - Parent COPC layer
+   * @param {number} [numPoints=0] - Number of points given by this entry
+   */
+  constructor(depth, x, y, z, entryOffset, entryLength, layer) {
+    let numPoints = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : 0;
+    super(numPoints, layer);
+    this.isCopcNode = true;
+    this.entryOffset = entryOffset;
+    this.entryLength = entryLength;
+    this.layer = layer;
+    this.depth = depth;
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  get id() {
+    return buildId(this.depth, this.x, this.y, this.z);
+  }
+  get octreeIsLoaded() {
+    return this.numPoints >= 0;
+  }
+
+  /**
+   * @param {number} offset
+   * @param {number} size
+   */
+  async _fetch(offset, size) {
+    return this.layer.source.fetcher(this.layer.source.url, {
+      ...this.layer.source.networkOptions,
+      headers: {
+        ...this.layer.source.networkOptions.headers,
+        range: `bytes=${offset}-${offset + size - 1}`
+      }
+    });
+  }
+
+  /**
+   * Create an (A)xis (A)ligned (B)ounding (B)ox for the given node given
+   * `this` is its parent.
+   * @param {CopcNode} node - The child node
+   */
+  createChildAABB(node) {
+    // factor to apply, based on the depth difference (can be > 1)
+    const f = 2 ** (node.depth - this.depth);
+
+    // size of the child node bbox (Vector3), based on the size of the
+    // parent node, and divided by the factor
+    this.bbox.getSize(size).divideScalar(f);
+
+    // initialize the child node bbox at the location of the parent node bbox
+    node.bbox.min.copy(this.bbox.min);
+
+    // position of the parent node, if it was at the same depth as the
+    // child, found by multiplying the tree position by the factor
+    position.copy(this).multiplyScalar(f);
+
+    // difference in position between the two nodes, at child depth, and
+    // scale it using the size
+    translation.subVectors(node, position).multiply(size);
+
+    // apply the translation to the child node bbox
+    node.bbox.min.add(translation);
+
+    // use the size computed above to set the max
+    node.bbox.max.copy(node.bbox.min).add(size);
+  }
+
+  /**
+   * Create a CopcNode from the provided subtree and add it as child
+   * of the current node.
+   * @param {number} depth - Child node depth in the octree
+   * @param {number} x - Child node x position in the octree
+   * @param {number} y - Child node y position in the octree
+   * @param {number} z - Child node z position in the octree
+   * @param {Hierarchy.Subtree} hierarchy - Octree's subtree
+   * @param {CopcNode[]} stack - Stack of node candidates for traversal
+   */
+  findAndCreateChild(depth, x, y, z, hierarchy, stack) {
+    const id = buildId(depth, x, y, z);
+    let pointCount;
+    let offset;
+    let byteSize;
+    const node = hierarchy.nodes[id];
+    if (node) {
+      pointCount = node.pointCount;
+      offset = node.pointDataOffset;
+      byteSize = node.pointDataLength;
+    } else {
+      const page = hierarchy.pages[id];
+      if (!page) {
+        return;
+      }
+      pointCount = -1;
+      offset = page.pageOffset;
+      byteSize = page.pageLength;
+    }
+    const child = new CopcNode(depth, x, y, z, offset, byteSize, this.layer, pointCount);
+    this.add(child);
+    stack.push(child);
+  }
+  async loadOctree() {
+    // Load hierarchy
+    const buffer = await this._fetch(this.entryOffset, this.entryLength);
+    const hierarchy = await Hierarchy.parse(new Uint8Array(buffer));
+
+    // Update current node entry from loaded subtree
+    const node = hierarchy.nodes[this.id];
+    if (!node) {
+      return Promise.reject('[CopcNode]: Ill-formed data, entry not found in hierarchy.');
+    }
+    this.numPoints = node.pointCount;
+    this.entryOffset = node.pointDataOffset;
+    this.entryLength = node.pointDataLength;
+
+    // Load subtree entries
+    const stack = [];
+    stack.push(this);
+    while (stack.length) {
+      const node = stack.shift();
+      const depth = node.depth + 1;
+      const x = node.x * 2;
+      const y = node.y * 2;
+      const z = node.z * 2;
+      node.findAndCreateChild(depth, x, y, z, hierarchy, stack);
+      node.findAndCreateChild(depth, x + 1, y, z, hierarchy, stack);
+      node.findAndCreateChild(depth, x, y + 1, z, hierarchy, stack);
+      node.findAndCreateChild(depth, x + 1, y + 1, z, hierarchy, stack);
+      node.findAndCreateChild(depth, x, y, z + 1, hierarchy, stack);
+      node.findAndCreateChild(depth, x + 1, y, z + 1, hierarchy, stack);
+      node.findAndCreateChild(depth, x, y + 1, z + 1, hierarchy, stack);
+      node.findAndCreateChild(depth, x + 1, y + 1, z + 1, hierarchy, stack);
+    }
+  }
+
+  /**
+   * Load the COPC Buffer geometry for this node.
+   * @returns {Promise<THREE.BufferGeometry>}
+   */
+  async load() {
+    if (!this.octreeIsLoaded) {
+      await this.loadOctree();
+    }
+    const buffer = await this._fetch(this.entryOffset, this.entryLength);
+    const geometry = await this.layer.source.parser(buffer, {
+      in: {
+        ...this.layer.source,
+        pointCount: this.numPoints
+      },
+      out: this.layer
+    });
+    return geometry;
+  }
+}
+export default CopcNode;

package/lib/Core/Deprecated/Undeprecator.js

@@ -0,0 +1,74 @@
+import { colorLayerEffects } from "../../Renderer/LayeredMaterial.js";
+export const deprecatedColorLayerOptions = options => {
+  if (options.fx) {
+    console.warn('ColorLayer fx is deprecated, use ColorLayer.effect_type and ColorLayer.effect_parameter instead.');
+    if (options.fx > 2.0) {
+      options.effect_parameter = options.fx;
+      options.effect_type = colorLayerEffects.removeLightColor;
+    } else if (options.fx > 0.0) {
+      options.effect_parameter = options.fx;
+      options.effect_type = colorLayerEffects.removeWhiteColor;
+    }
+  }
+  return options;
+};
+export const deprecatedParsingOptionsToNewOne = options => {
+  if (options.crsOut || options.crsIn) {
+    console.warn('Parsing options with crsIn and crsOut are deprecated, use { in, out } structure.');
+    const newOptions = {
+      in: {},
+      out: {}
+    };
+    newOptions.in.crs = options.crsIn;
+    newOptions.in.isInverted = options.isInverted;
+    newOptions.in.styles = options.styles;
+    newOptions.in.layers = options.layers;
+    newOptions.in.filter = options.filter;
+    newOptions.out.crs = options.crsOut;
+    newOptions.out.mergeFeatures = options.mergeFeatures;
+    if (options.withAltitude && options.withNormal) {
+      console.warn('Parsing options withAltitude and withNormal is deprecated, use out.structure: 2d or 3d.');
+      newOptions.out.structure = '3d';
+    } else {
+      newOptions.out.structure = '2d';
+    }
+    newOptions.out.filteringExtent = options.filteringExtent;
+    newOptions.out.style = options.style;
+    if (options.crsOut.overrideAltitudeInToZero !== undefined) {
+      console.error('Parsing options out.overrideAltitudeInToZero is removed, use Style.xxx.base_altitude instead');
+    }
+    newOptions.out.filter = options.filter;
+    return newOptions;
+  }
+  if (options.out) {
+    if (options.out.withAltitude !== undefined || options.out.withNormal !== undefined) {
+      console.warn('Parsing options out.withAltitude and out.withNormal is deprecated, use out.structure: 2d or 3d.');
+      if (options.out.withAltitude && options.out.withNormal) {
+        options.out.structure = '3d';
+      } else {
+        options.out.structure = '2d';
+      }
+    }
+    if (options.out.overrideAltitudeInToZero !== undefined) {
+      console.error('Parsing options out.overrideAltitudeInToZero is removed, use Style.xxx.base_altitude instead');
+    }
+  }
+  return options;
+};
+export const deprecatedFeature2MeshOptions = options => {
+  if (options.color) {
+    console.error('Color convert option is removed, use Style.xxx.color');
+  }
+  if (options.extrude) {
+    console.error('extrude convert option is removed, use Style.fill.extrusion_height instead');
+  }
+  if (options.altitude) {
+    console.error('altitude convert option is removed, use Style.xxx.base_altitude instead');
+  }
+};
+export const deprecatedC3DEngineWebGLOptions = options => {
+  if (options.isWebGL2 === false) {
+    console.error('WebGL1 support ended in 2.43.0. Falling-back to the WebGL2 renderer.');
+  }
+};
+export default {};

package/lib/Core/EntwinePointTileNode.js

@@ -0,0 +1,126 @@
+import * as THREE from 'three';
+import Fetcher from "../Provider/Fetcher.js";
+import PointCloudNode from "./PointCloudNode.js";
+const size = new THREE.Vector3();
+const position = new THREE.Vector3();
+const translation = new THREE.Vector3();
+function buildId(depth, x, y, z) {
+  return `${depth}-${x}-${y}-${z}`;
+}
+
+/**
+ * @extends PointCloudNode
+ *
+ * @property {boolean} isEntwinePointTileNode - Used to checkout whether this
+ * node is a EntwinePointTileNode. Default is `true`. You should not change
+ * this, as it is used internally for optimisation.
+ * @property {number} depth - The depth of the node in the tree - see the
+ * [Entwine
+ * documentation](https://entwine.io/entwine-point-tile.html#ept-data)
+ * @property {number} x - The x coordinate of the node in the tree - see the
+ * [Entwine
+ * documentation](https://entwine.io/entwine-point-tile.html#ept-data)
+ * @property {number} y - The x coordinate of the node in the tree - see the
+ * [Entwine
+ * documentation](https://entwine.io/entwine-point-tile.html#ept-data)
+ * @property {number} z - The x coordinate of the node in the tree - see the
+ * [Entwine
+ * documentation](https://entwine.io/entwine-point-tile.html#ept-data)
+ * @property {string} id - The id of the node, constituted of the four
+ * components: `depth-x-y-z`.
+ */
+class EntwinePointTileNode extends PointCloudNode {
+  /**
+   * Constructs a new instance of EntwinePointTileNode.
+   *
+   * @constructor
+   *
+   * @param {number} depth - The depth of the node in the tree - see the
+   * [Entwine
+   * documentation](https://entwine.io/entwine-point-tile.html#ept-data)
+   * @param {number} x - The x coordinate of the node in the tree - see the
+   * [Entwine
+   * documentation](https://entwine.io/entwine-point-tile.html#ept-data)
+   * @param {number} y - The x coordinate of the node in the tree - see the
+   * [Entwine
+   * documentation](https://entwine.io/entwine-point-tile.html#ept-data)
+   * @param {number} z - The x coordinate of the node in the tree - see the
+   * [Entwine
+   * documentation](https://entwine.io/entwine-point-tile.html#ept-data)
+   * @param {EntwinePointTileLayer} layer - The layer the node is attached to.
+   * @param {number} [numPoints=0] - The number of points in this node. If
+   * `-1`, it means that the octree hierarchy associated to this node needs to
+   * be loaded.
+   */
+  constructor(depth, x, y, z, layer) {
+    let numPoints = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
+    super(numPoints, layer);
+    this.isEntwinePointTileNode = true;
+    this.depth = depth;
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.id = buildId(depth, x, y, z);
+    this.url = `${this.layer.source.url}/ept-data/${this.id}.${this.layer.source.extension}`;
+  }
+  createChildAABB(node) {
+    // factor to apply, based on the depth difference (can be > 1)
+    const f = 2 ** (node.depth - this.depth);
+
+    // size of the child node bbox (Vector3), based on the size of the
+    // parent node, and divided by the factor
+    this.bbox.getSize(size).divideScalar(f);
+
+    // initialize the child node bbox at the location of the parent node bbox
+    node.bbox.min.copy(this.bbox.min);
+
+    // position of the parent node, if it was at the same depth than the
+    // child, found by multiplying the tree position by the factor
+    position.copy(this).multiplyScalar(f);
+
+    // difference in position between the two nodes, at child depth, and
+    // scale it using the size
+    translation.subVectors(node, position).multiply(size);
+
+    // apply the translation to the child node bbox
+    node.bbox.min.add(translation);
+
+    // use the size computed above to set the max
+    node.bbox.max.copy(node.bbox.min).add(size);
+  }
+  get octreeIsLoaded() {
+    return this.numPoints >= 0;
+  }
+  loadOctree() {
+    return Fetcher.json(`${this.layer.source.url}/ept-hierarchy/${this.id}.json`, this.layer.source.networkOptions).then(hierarchy => {
+      this.numPoints = hierarchy[this.id];
+      const stack = [];
+      stack.push(this);
+      while (stack.length) {
+        const node = stack.shift();
+        const depth = node.depth + 1;
+        const x = node.x * 2;
+        const y = node.y * 2;
+        const z = node.z * 2;
+        node.findAndCreateChild(depth, x, y, z, hierarchy, stack);
+        node.findAndCreateChild(depth, x + 1, y, z, hierarchy, stack);
+        node.findAndCreateChild(depth, x, y + 1, z, hierarchy, stack);
+        node.findAndCreateChild(depth, x + 1, y + 1, z, hierarchy, stack);
+        node.findAndCreateChild(depth, x, y, z + 1, hierarchy, stack);
+        node.findAndCreateChild(depth, x + 1, y, z + 1, hierarchy, stack);
+        node.findAndCreateChild(depth, x, y + 1, z + 1, hierarchy, stack);
+        node.findAndCreateChild(depth, x + 1, y + 1, z + 1, hierarchy, stack);
+      }
+    });
+  }
+  findAndCreateChild(depth, x, y, z, hierarchy, stack) {
+    const id = buildId(depth, x, y, z);
+    const numPoints = hierarchy[id];
+    if (typeof numPoints == 'number') {
+      const child = new EntwinePointTileNode(depth, x, y, z, this.layer, numPoints);
+      this.add(child);
+      stack.push(child);
+    }
+  }
+}
+export default EntwinePointTileNode;