itowns 2.45.1 → 2.45.2-next.0

package/lib/Core/3DTiles/C3DTExtensions.d.ts

@@ -0,0 +1,75 @@
+export default C3DTExtensions;
+/**
+ * Class for managing
+ * [3D Tiles extensions](https://github.com/AnalyticalGraphicsInc/3d-tiles/tree/master/extensions).
+ * Extensions used in a 3D Tiles tileset must be registered in the iTowns' layer
+ * holding the tileset by the user with the {@link registerExtension}
+ * method. The extension must be registered together with a class holding the
+ * code to interpret the extension.
+ * An example of extension class is {@link C3DTBatchTableHierarchyExtension}.
+ * This extension has only one part situated in the batch table (but other
+ * extensions can have multiple parts, stored in different 3D Tiles classes
+ * such as tileset or bounding volume).
+ * @example
+ * // Create a C3DTExtensions object
+ * const extensions = new itowns.C3DTExtensions();
+ * // Register an extension to it named "3DTILES_batch_table_hierarchy" and
+ * // a class itowns.C3DTBatchTableHierarchyExtension to the batch table part
+ * // (with [itowns.C3DTilesTypes.batchtable]). see {@link C3DTilesTypes}
+ * extensions.registerExtension("3DTILES_batch_table_hierarchy",
+ * { [itowns.C3DTilesTypes.batchtable]: itowns.C3DTBatchTableHierarchyExtension });
+ *
+ * // Create a 3D Tiles layer with registered extensions
+ * var $3dTilesLayerBTHierarchy = new itowns.C3DTilesLayer('3d-tiles-bt-hierarchy', {
+ *      name: 'BTHierarchy',
+ *      source: new itowns.C3DTilesSource({
+ *          url: 'https://raw.githubusercontent.com/AnalyticalGraphicsInc/cesium/master/Apps/SampleData/Cesium3DTiles/Hierarchy/BatchTableHierarchy/tileset.json',
+ *          }),
+ *          registeredExtensions: extensions,
+ *      },
+ * view);
+ */
+declare class C3DTExtensions {
+    /**
+     * Register a 3D Tiles extension: Maps an extension name to the
+     * extensionsManagers (i.e. one class per 3D Tiles class (e.g.
+     * batch table or bounding volume).
+     * @param {string} extensionName - Name of the extension
+     * @param {object} extensionManagers - An object mapping 3D Tiles
+     * classes names (see @link{C3DTilesTypes} to the extension managers
+     * corresponding to this class. These extension managers should be able
+     * to parse the extension fragment (done in the constructor) and should
+     * have a getInfoById method if they are related to the batch table class.
+     * See {@link C3DTBatchTableHierarchyExtension} for an example of
+     * extension class.
+     */
+    registerExtension(extensionName: string, extensionManagers: object): void;
+    /**
+     * Get an extension manager from its name and C3DTilesType
+     * @param {string} extensionName - name of the extension.
+     * @param {C3DTilesTypes} type - type of 3DTiles class (e.g. batch
+     * table, bounding volume, tileset, etc.)
+     * @returns {object} - the extension manager corresponding to the
+     * extensioNname and type.
+     */
+    getExtension(extensionName: string, type: C3DTilesTypes): object;
+    /**
+     * Test if an extension is registered
+     * @param {string} extensionName - Name of the extension
+     * @returns {boolean} - true if the extension is registered and false
+     * otherwise.
+     */
+    isExtensionRegistered(extensionName: string): boolean;
+    /**
+     * Parses the extensions from a given JSON (extensionsJSON) by
+     * instanciating the right class from the registered extensions.
+     * @param {object} extensionsJSON - the JSON to parse extensions from.
+     * @param {C3DTilesTypes} type - type of class asking for extensions parsing
+     * has been called. For instance, if {@link C3DTBatchTable} needs to
+     * parse its extensions, it will call parseExtension with the JSON to
+     * parse and C3DTilesTypes.batchtable as type.
+     * @returns {object} - An object with keys being the names of the
+     * extensions and values the instances of the extensions managers.
+     */
+    parseExtensions(extensionsJSON: object, type: C3DTilesTypes): object;
+}

package/lib/Core/3DTiles/C3DTFeature.d.ts

@@ -0,0 +1,47 @@
+export default C3DTFeature;
+/**
+ * C3DTFeature is a feature of a 3DTiles
+ *
+ * @class      C3DTFeature
+ * @param {number} tileId - tileId
+ * @param {number} batchId - batch id
+ * @param {Array<{start:number,count:number}>} groups - groups in geometry.attributes matching batchId
+ * @param {object} [userData] - some userData
+ * @param {Object3D} object3d - object3d in which feature is present
+ * @property {number} tileId - tile id
+ * @property {Object3D} object3d - object3d in which feature is present
+ * @property {number} batchId - batch id
+ * @property {Array<{start:number,count:number}>} groups - groups in geometry.attributes matching batchId
+ * @property {object} [userData] - some userData
+ */
+declare class C3DTFeature {
+    constructor(tileId: any, batchId: any, groups: any, userData: any, object3d: any);
+    /** @type {Object3D} */
+    object3d: Object3D;
+    /** @type {number} */
+    batchId: number;
+    /** @type {Array<{start:number,count:number}>} */
+    groups: Array<{
+        start: number;
+        count: number;
+    }>;
+    /** @type {object} */
+    userData: object;
+    /** @type {number} */
+    tileId: number;
+    /**
+     * Compute world box3 of this
+     *
+     * @param {Box3} target - target of the result
+     * @returns {Box3}
+     */
+    computeWorldBox3(target?: Box3): Box3;
+    /**
+     * Gets the information from the tile batch table for this C3DTFeature batch id.
+     * @returns {object} - batchTable info
+     */
+    getInfo(): object;
+    #private;
+}
+import { Object3D } from 'three';
+import { Box3 } from 'three';

package/lib/Core/3DTiles/C3DTilesEnums.d.ts

@@ -0,0 +1,14 @@
+/**
+ * C3DTilesTypes
+ */
+export type C3DTilesTypes = Object;
+export namespace C3DTilesTypes {
+    let tileset: string;
+    let batchtable: string;
+    let boundingVolume: string;
+}
+export namespace C3DTilesBoundingVolumeTypes {
+    let region: string;
+    let box: string;
+    let sphere: string;
+}

package/lib/Core/3DTiles/C3DTileset.d.ts

@@ -0,0 +1,46 @@
+export default C3DTileset;
+/**
+ * A 3D Tiles
+ *  [Tileset](https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/schema/tileset.schema.json).
+ * @property {C3DTilesTypes} type - Used by 3D Tiles extensions
+ * (e.g. {@link C3DTBatchTableHierarchyExtension}) to know in which context
+ * (i.e. for which 3D Tiles class) the parsing of the extension should be done.
+ *  @property {object} asset - Generic information about the tileset, see
+ *  [asset specification]https://github.com/CesiumGS/3d-tiles/blob/master/specification/schema/asset.schema.json
+ *  @property {object} properties - Properties associated with the tileset, see
+ *  [tileset specification](https://github.com/CesiumGS/3d-tiles/blob/master/specification/schema/tileset.schema.json#L11)
+ *  @property {number} geometricError - see [tileset
+ *  specification](https://github.com/CesiumGS/3d-tiles/blob/master/specification/schema/tileset.schema.json#L18)
+ *  @property {string[]} extensionsUsed - see [tileset
+ *  specification](https://github.com/CesiumGS/3d-tiles/blob/master/specification/schema/tileset.schema.json#L27)
+ *  @property {array} extensionsRequired - see [tileset specification](https://github.com/CesiumGS/3d-tiles/blob/master/specification/schema/tileset.schema.json#L36)
+ *  @property {object[]} tiles - an array holding all the
+ *  [tiles](https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/schema/tile.schema.json)
+ *  (not their content which is stored in the attribute object3d of the
+ *  layer). This list represents a flattened tileset.
+ *  @property {object} extensions - Extensions of the tileset in the form:
+ * {extensioName1: extensionObject1, extensioName2: extensionObject2, ...}
+ */
+declare class C3DTileset {
+    constructor(json: any, baseURL: any, registeredExtensions: any);
+    type: string;
+    asset: any;
+    properties: any;
+    geometricError: any;
+    extensionsUsed: any;
+    extensionsRequired: any;
+    tiles: any[];
+    extensions: any;
+    /**
+     * Recursion on the 3DTiles tileset (which is a tree) to parse the tiles
+     * (nodes of the tree).
+     * @param {object} tile - current tile
+     * @param {string} baseURL - url of the source tileset and tiles
+     * @param {object} parent - parent tile (used for computing the transform
+     * matrix from local to global coordinates)
+     * @param {object} registeredExtensions - 3D Tiles extensions registered
+     * in the C3DTilesLayer (see {@link C3DTExtensions}
+     */
+    parseTiles(tile: object, baseURL: string, parent: object, registeredExtensions: object): void;
+    extendTileset(tileset: any, nodeId: any, baseURL: any, registeredExtensions: any): void;
+}

package/lib/Core/3DTiles/utils/BinaryPropertyAccessor.d.ts

@@ -0,0 +1,14 @@
+export default binaryPropertyAccessor;
+/**
+ * Parses a 3D Tiles binary property. Used for batch table and feature table parsing. See the 3D Tiles spec for more
+ * information on how these values are encoded:
+ * [3D Tiles spec](https://github.com/CesiumGS/3d-tiles/blob/main/specification/TileFormats/BatchTable/README.md#binary-body))
+ * @param {ArrayBuffer} buffer The buffer to parse values from.
+ * @param {Number} batchLength number of objects in the batch (= number of elements to parse).
+ * @param {Number} byteOffset the offset in bytes into the buffer.
+ * @param {String} componentType the type of component to parse (one of componentTypeBytesSize keys)
+ * @param {String} type the type of element to parse (one of typeComponentsNumber keys)
+ * @returns {Array} an array of values parsed from the buffer. An array of componentType if type is SCALAR. An array
+ * of Threejs Vector2, Vector3 or Vector4 if type is VEC2, VEC3 or VEC4 respectively.
+ */
+declare function binaryPropertyAccessor(buffer: ArrayBuffer, batchLength: number, byteOffset: number, componentType: string, type: string): any[];

package/lib/Core/AnimationPlayer.d.ts

@@ -0,0 +1,53 @@
+export default AnimationPlayer;
+/**
+ * It can play, pause or stop Animation or AnimationExpression (See below).
+ * AnimationPlayer is needed to use Animation or AnimationExpression
+ * AnimationPlayer emits events :
+ *       - for each animation's frame;
+ *       - when Animation is stopped
+ *       - when Animation is ending
+ */
+declare class AnimationPlayer extends THREE.EventDispatcher<any> {
+    constructor();
+    id: NodeJS.Timer | null;
+    keyframe: number;
+    duration: number;
+    state: number;
+    waitTimer: number | null;
+    callback: () => void;
+    isPlaying(): boolean;
+    isStopped(): boolean;
+    isEnded(): boolean;
+    /**
+     * Set the Player `callback` property. This callback is executed at each animation frame.
+     *
+     * @param {function} callback - The callback to execute at each animation frame.
+     */
+    setCallback(callback: Function): void;
+    /**
+     * Play one animation.
+     * If another animation is playing, it's stopped and the new animation is played.
+     *
+     * @param {number} duration - The duration to play
+     */
+    play(duration: number): void;
+    /**
+     * Play an animation after a number of frames.
+     *
+     * @param      {number}  duration    The duration to play
+     * @param      {number}  waitingFrame    The waiting time before start animation (time in frame)
+     */
+    playLater(duration: number, waitingFrame: number): void;
+    /**
+     * Stop the current animation.
+     *
+     */
+    stop(): void;
+    /**
+     * Executed for each frame.
+     *
+     * @private
+     */
+    private frame;
+}
+import * as THREE from 'three';

package/lib/Core/CopcNode.d.ts

@@ -0,0 +1,67 @@
+export default CopcNode;
+/**
+ * @extends PointCloudNode
+ *
+ * @property {boolean} isCopcNode - Used to checkout whether this
+ * node is a CopcNode. Default is `true`. You should not change
+ * this, as it is used internally for optimisation.
+ * @property {number} entryOffset - Offset from the beginning of the file of
+ * the node entry
+ * @property {number} entryLength - Size of the node entry
+ * @property {CopcLayer} layer - COPC layer the node belongs to.
+ * @property {number} depth - Depth within the octree
+ * @property {number} x - X position within the octree
+ * @property {number} y - Y position within the octree
+ * @property {number} z - Z position within the octree
+ * @property {string} id - The id of the node, constituted of the four
+ * components: `depth-x-y-z`.
+ */
+declare 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 to
+     * 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: number, x: number, y: number, z: number, entryOffset: number, entryLength: number, layer: CopcLayer, numPoints?: number);
+    isCopcNode: boolean;
+    entryOffset: number;
+    entryLength: number;
+    depth: number;
+    x: number;
+    y: number;
+    z: number;
+    id: string;
+    get octreeIsLoaded(): boolean;
+    /**
+     * @param {number} offset
+     * @param {number} size
+     */
+    _fetch(offset: number, size: number): Promise<any>;
+    loadOctree(): Promise<undefined>;
+    /**
+     * 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: number, x: number, y: number, z: number, hierarchy: Hierarchy.Subtree, stack: CopcNode[]): void;
+    /**
+     * Load the COPC Buffer geometry for this node.
+     * @returns {Promise<THREE.BufferGeometry>}
+     */
+    load(): Promise<THREE.BufferGeometry>;
+}
+import PointCloudNode from '../Core/PointCloudNode';
+import { Hierarchy } from 'copc';

package/lib/Core/CopcNode.js

@@ -1,12 +1,26 @@
-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}`;
 }
+
+/**
+ * @extends PointCloudNode
+ *
+ * @property {boolean} isCopcNode - Used to checkout whether this
+ * node is a CopcNode. Default is `true`. You should not change
+ * this, as it is used internally for optimisation.
+ * @property {number} entryOffset - Offset from the beginning of the file of
+ * the node entry
+ * @property {number} entryLength - Size of the node entry
+ * @property {CopcLayer} layer - COPC layer the node belongs to.
+ * @property {number} depth - Depth within the octree
+ * @property {number} x - X position within the octree
+ * @property {number} y - Y position within the octree
+ * @property {number} z - Z position within the octree
+ * @property {string} id - The id of the node, constituted of the four
+ * components: `depth-x-y-z`.
+ */
 class CopcNode extends PointCloudNode {
   /**
    * Constructs a new instance of a COPC Octree node
@@ -15,7 +29,7 @@ class CopcNode extends PointCloudNode {
    * @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
+   * @param {number} entryOffset - Offset from the beginning of the file to
    * the node entry
    * @param {number} entryLength - Size of the node entry
    * @param {CopcLayer} layer - Parent COPC layer
@@ -32,9 +46,7 @@ class CopcNode extends PointCloudNode {
     this.x = x;
     this.y = y;
     this.z = z;
-  }
-  get id() {
-    return buildId(this.depth, this.x, this.y, this.z);
+    this.id = buildId(depth, x, y, z);
   }
   get octreeIsLoaded() {
     return this.numPoints >= 0;
@@ -53,36 +65,38 @@ class CopcNode extends PointCloudNode {
       }
     });
   }
+  async loadOctree() {
+    // Load hierarchy
+    const buffer = await this._fetch(this.entryOffset, this.entryLength);
+    const hierarchy = await Hierarchy.parse(new Uint8Array(buffer));
 
-  /**
-   * 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);
+    // 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;
 
-    // use the size computed above to set the max
-    node.bbox.max.copy(node.bbox.min).add(size);
+    // 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);
+    }
   }
 
   /**
@@ -118,39 +132,6 @@ class CopcNode extends PointCloudNode {
     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.

package/lib/Core/Deprecated/Undeprecator.d.ts

@@ -0,0 +1,6 @@
+export function deprecatedColorLayerOptions(options: any): any;
+export function deprecatedParsingOptionsToNewOne(options: any): any;
+export function deprecatedFeature2MeshOptions(options: any): void;
+export function deprecatedC3DEngineWebGLOptions(options: any): void;
+declare const _default: {};
+export default _default;

package/lib/Core/EntwinePointTileNode.d.ts

@@ -0,0 +1,58 @@
+export default EntwinePointTileNode;
+/**
+ * @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 y coordinate of the node in the tree - see the
+ * [Entwine
+ * documentation](https://entwine.io/entwine-point-tile.html#ept-data)
+ * @property {number} z - The z 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`.
+ */
+declare 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 y coordinate of the node in the tree - see the
+     * [Entwine
+     * documentation](https://entwine.io/entwine-point-tile.html#ept-data)
+     * @param {number} z - The z 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: number, x: number, y: number, z: number, layer: EntwinePointTileLayer, numPoints?: number);
+    isEntwinePointTileNode: boolean;
+    depth: number;
+    x: number;
+    y: number;
+    z: number;
+    id: string;
+    url: string;
+    get octreeIsLoaded(): boolean;
+    loadOctree(): Promise<void>;
+    findAndCreateChild(depth: any, x: any, y: any, z: any, hierarchy: any, stack: any): void;
+}
+import PointCloudNode from '../Core/PointCloudNode';

package/lib/Core/EntwinePointTileNode.js

@@ -1,9 +1,5 @@
-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}`;
 }
@@ -20,10 +16,10 @@ function buildId(depth, x, y, z) {
  * @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
+ * @property {number} y - The y 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
+ * @property {number} z - The z 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
@@ -41,10 +37,10 @@ class EntwinePointTileNode extends PointCloudNode {
    * @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
+   * @param {number} y - The y 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
+   * @param {number} z - The z 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.
@@ -63,36 +59,12 @@ class EntwinePointTileNode extends PointCloudNode {
     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 => {
+    const hierarchyUrl = `${this.layer.source.url}/ept-hierarchy/${this.id}.json`;
+    return Fetcher.json(hierarchyUrl, this.layer.source.networkOptions).then(hierarchy => {
       this.numPoints = hierarchy[this.id];
       const stack = [];
       stack.push(this);