itowns 2.43.2-next.9 → 2.44.1-next.0

package/examples/jsm/.eslintrc.cjs

@@ -0,0 +1,38 @@
+module.exports = {
+    extends: [
+        'eslint-config-airbnb-base',
+        'eslint-config-airbnb-base/rules/strict',
+        '../.eslintrc.cjs',
+    ],
+    parserOptions: {
+        ecmaVersion: 13,
+        sourceType: 'module',
+        ecmaFeatures: {
+            impliedStrict: true,
+        },
+    },
+    env: {
+        browser: true,
+        es6: true,
+        amd: true,
+        commonjs: true,
+    },
+    globals: {
+        itowns: true,
+    },
+    rules: {
+        'prefer-arrow-callback': 'off',
+        'object-shorthand': 'off',
+        'no-param-reassign': ['error', { props: false }],
+        'no-mixed-operators': ['error', { allowSamePrecedence: true }],
+        'prefer-template': 'off',
+        'prefer-rest-params': 'off',
+        'arrow-parens': ['error', 'as-needed', { requireForBlockBody: true }],
+
+        // deactivated rules for `examples/`
+        'no-console': 'off',
+        // TODO reactivate all the following rules
+        'no-underscore-dangle': 'off',
+
+    },
+};

package/examples/jsm/OGC3DTilesHelper.js

@@ -0,0 +1,105 @@
+import { MathUtils, Vector3 } from 'three';
+
+const { Coordinates, Extent, CameraUtils } = itowns;
+
+/**
+ * Function allowing picking on a given 3D tiles layer and filling an html div
+ * with information on the picked feature.
+ * @param {MouseEvent} event
+ * @param {Object} pickingArg
+ * @param {HTMLDivElement} pickingArg.htmlDiv - div element which contains the
+ * picked information
+ * @param {GlobeView} picking.view - iTowns view where the picking must be done
+ * @param {OGC3DTilesLayer} pickingArg.layer - the layer on which the picking
+ * must be done
+ */
+export function fillHTMLWithPickingInfo(event, pickingArg) {
+    const { htmlDiv, view, layer } = pickingArg;
+
+    // Remove content already in html div
+    while (htmlDiv.firstChild) {
+        htmlDiv.removeChild(htmlDiv.firstChild);
+    }
+
+    // Get intersected objects
+    const intersects = view.pickObjectsAt(event, 5, layer);
+
+    // Get information from intersected objects (from the batch table and
+    // eventually the 3D Tiles extensions
+    const closestC3DTileFeature =
+        layer.getC3DTileFeatureFromIntersectsArray(intersects);
+
+    if (closestC3DTileFeature) {
+        // eslint-disable-next-line
+        htmlDiv.appendChild(createHTMLListFromObject(closestC3DTileFeature));
+    }
+}
+
+function zoomToSphere(view, tile, sphere) {
+    const transform = tile.cached.transform;
+
+    const center = new Vector3().fromArray(sphere).applyMatrix4(transform);
+    const radius = sphere[3] * transform.getMaxScaleOnAxis();
+
+    // Get the distance to sphere where the diameter cover the whole screen
+    // This is similar to SSE computation where sse = screen height.
+    const fov = view.camera3D.fov * MathUtils.DEG2RAD;
+    const distance = radius * Math.tan(fov * 2);
+
+    return {
+        coord: new Coordinates('EPSG:4978', center),
+        range: distance + radius,
+    };
+}
+
+function zoomToBox(view, tile, box) {
+    const radius = Math.max(
+        new Vector3().fromArray(box, 3).length(),
+        new Vector3().fromArray(box, 6).length(),
+        new Vector3().fromArray(box, 9).length(),
+    );
+
+    // Approximate zoomToBox with sphere
+    const sphere = [box[0], box[1], box[2], radius];
+    return zoomToSphere(view, tile, sphere);
+}
+
+function zoomToRegion(view, region) {
+    const extent = new Extent('EPSG:4326',
+        region[0] * MathUtils.RAD2DEG, // west
+        region[2] * MathUtils.RAD2DEG, // east
+        region[1] * MathUtils.RAD2DEG, // south
+        region[3] * MathUtils.RAD2DEG, // north
+    );
+
+    return CameraUtils.getCameraTransformOptionsFromExtent(
+        view,
+        view.camera3D,
+        extent,
+    );
+}
+
+function zoomToTile(view, tile) {
+    const { region, box, sphere } = tile.boundingVolume;
+
+    let cameraTransform;
+    if (region) {
+        cameraTransform = zoomToRegion(view, region);
+    } else if (box) {
+        cameraTransform = zoomToBox(view, tile, box);
+    } else {
+        cameraTransform = zoomToSphere(view, tile, sphere);
+    }
+
+    view.controls.lookAtCoordinate({
+        coord: cameraTransform.coord,
+        range: 1.25 * cameraTransform.range, // zoom out a little bit
+        tilt: 60,
+    });
+}
+
+export function zoomToLayer(view, layer) {
+    const root = layer.tilesRenderer.root;
+
+    zoomToTile(view, root);
+}

package/examples/misc_instancing.html

@@ -145,7 +145,8 @@
             });
 
             // Load a glTF resource
-            itowns.glTFLoader.load(
+            var gltfLoader = new itowns.iGLTFLoader();
+            gltfLoader.load(
                 // resource URL
                 "https://raw.githubusercontent.com/iTowns/iTowns2-sample-data/master/models/lampadaire/scene.gltf",
 

package/examples/potree2_25d_map.html

@@ -0,0 +1,127 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>Point Cloud Viewer</title>
+
+        <style type="text/css">
+            #info {
+                color: #7ad7ff;
+                font-family: 'Open Sans', sans-serif;
+                position: absolute;
+                top: 0;
+                left: 0;
+                padding: 0.3rem;
+                background-color: #404040;
+                z-index: 1;
+            }
+            @media (max-width: 600px) {
+                #info,
+                .dg {
+                    display: none;
+                }
+            }
+        </style>
+
+        <meta charset="UTF-8">
+        <link rel="stylesheet" type="text/css" href="css/example.css">
+        <link rel="stylesheet" type="text/css" href="css/LoadingScreen.css">
+
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    </head>
+    <body>
+        <div id="viewerDiv">
+            <div id="info"></div>
+        </div>
+
+        <div>
+            <script src="https://cdnjs.cloudflare.com/ajax/libs/dat-gui/0.7.6/dat.gui.min.js"></script>
+            <script src="../dist/itowns.js"></script>
+            <script src="js/GUI/LoadingScreen.js"></script>
+            <script src="../dist/debug.js"></script>
+            <script type="text/javascript">
+                var potreeLayer;
+                var oldPostUpdate;
+                var viewerDiv;
+                var debugGui;
+                var view;
+                var controls;
+
+                // Define crs projection that we will use (taken from https://epsg.io/3946, Proj4js section)
+                itowns.proj4.defs('EPSG:3946', '+proj=lcc +lat_1=45.25 +lat_2=46.75 +lat_0=46 +lon_0=3 +x_0=1700000 +y_0=5200000 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs');
+
+                viewerDiv = document.getElementById('viewerDiv');
+                viewerDiv.style.display = 'block';
+
+                debugGui = new dat.GUI();
+
+                // TODO: do we really need to disable logarithmicDepthBuffer ?
+                view = new itowns.View('EPSG:3946', viewerDiv);
+                setupLoadingScreen(viewerDiv, view);
+                view.mainLoop.gfxEngine.renderer.setClearColor(0xcccccc);
+
+                // Configure Point Cloud layer
+                potreeLayer = new itowns.Potree2Layer('Lion', {
+                    source: new itowns.Potree2Source({
+                        file: 'metadata.json',
+                        url: 'https://raw.githubusercontent.com/iTowns/iTowns2-sample-data/master/pointclouds/potree2.0/lion',
+                        crs: view.referenceCrs,
+                    }),
+                });
+
+                // point selection on double-click
+                function dblClickHandler(event) {
+                    var pick = view.pickObjectsAt(event, 5, potreeLayer);
+
+                    for (const p of pick) {
+                        console.info('Selected point #' + p.index + ' in position (' +
+                            p.object.position.x + ', ' +
+                            p.object.position.y + ', ' +
+                            p.object.position.z +
+                         ') in Points ' + p.object.layer.id);
+                    }
+                }
+                view.domElement.addEventListener('dblclick', dblClickHandler);
+
+                function placeCamera(position, lookAt) {
+                    view.camera.camera3D.position.copy(position);
+                    view.camera.camera3D.lookAt(lookAt);
+                    // create controls
+                    controls = new itowns.FirstPersonControls(view, { focusOnClick: true });
+                    debugGui.add(controls.options, 'moveSpeed', 1, 100).name('Movement speed');
+
+                    view.notifyChange(view.camera.camera3D);
+                }
+
+                // add potreeLayer to scene
+                function onLayerReady() {
+                    var ratio;
+                    var position;
+                    var lookAt = new itowns.THREE.Vector3();
+                    var size = new itowns.THREE.Vector3();
+
+                    potreeLayer.root.bbox.getSize(size);
+                    potreeLayer.root.bbox.getCenter(lookAt);
+
+                    debug.PointCloudDebug.initTools(view, potreeLayer, debugGui);
+
+                    view.camera.camera3D.far = 2.0 * size.length();
+
+                    ratio = size.x / size.z;
+                    position = potreeLayer.root.bbox.min.clone().add(
+                        size.multiply({ x: 0, y: 0, z: ratio * 0.5 }));
+                    lookAt.z = potreeLayer.root.bbox.min.z;
+                    placeCamera(position, lookAt);
+                    controls.moveSpeed = size.length() / 3;
+
+                    // update stats window
+                    var info = document.getElementById('info');
+                    view.addFrameRequester(itowns.MAIN_LOOP_EVENTS.AFTER_RENDER, () => {
+                        info.textContent = potreeLayer.displayedCount.toLocaleString() + ' points';
+                    });
+                }
+                window.view = view;
+                view.addLayer(potreeLayer).then(onLayerReady);
+            </script>
+    </body>
+</html>
+

package/lib/Core/3DTiles/C3DTFeature.js

@@ -72,12 +72,12 @@ class C3DTFeature {
     target.min.y = Infinity;
     target.min.z = Infinity;
     this.groups.forEach(group => {
-      const positionIndexStart = group.start * 3;
-      const positionIndexCount = (group.start + group.count) * 3;
-      for (let index = positionIndexStart; index < positionIndexCount; index += 3) {
-        const x = this.object3d.geometry.attributes.position.array[index];
-        const y = this.object3d.geometry.attributes.position.array[index + 1];
-        const z = this.object3d.geometry.attributes.position.array[index + 2];
+      const positionIndexStart = group.start * this.object3d.geometry.attributes.position.itemSize;
+      const positionIndexCount = (group.start + group.count) * this.object3d.geometry.attributes.position.itemSize;
+      for (let index = positionIndexStart; index < positionIndexCount; index++) {
+        const x = this.object3d.geometry.attributes.position.getX(index);
+        const y = this.object3d.geometry.attributes.position.getY(index);
+        const z = this.object3d.geometry.attributes.position.getZ(index);
         target.max.x = Math.max(x, target.max.x);
         target.max.y = Math.max(y, target.max.y);
         target.max.z = Math.max(z, target.max.z);

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/Scheduler/Scheduler.js

@@ -140,7 +140,7 @@ Scheduler.prototype.execute = function (command) {
 
   // parse host
   const layer = command.layer;
-  const host = layer.source && layer.source.url ? new URL(URLBuilder.subDomains(layer.source.url), document.location).host : undefined;
+  const host = layer.source && layer.source.url && layer.source.url !== 'none' ? new URL(URLBuilder.subDomains(layer.source.url), document.location).host : undefined;
   command.promise = new Promise((resolve, reject) => {
     command.resolve = resolve;
     command.reject = reject;