itowns 2.43.2-next.0 → 2.43.2-next.10

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

@@ -338,10 +338,9 @@ export class FeatureCollection extends THREE.Object3D {
    * @param      {FeatureBuildingOptions|Layer}  options  The building options .
    */
   constructor(options) {
-    var _options$source;
     super();
     this.isFeatureCollection = true;
-    this.crs = CRS.formatToEPSG(options.accurate || !((_options$source = options.source) !== null && _options$source !== void 0 && _options$source.crs) ? options.crs : options.source.crs);
+    this.crs = CRS.formatToEPSG(options.accurate || !options.source?.crs ? options.crs : options.source.crs);
     this.features = [];
     this.mergeFeatures = options.mergeFeatures === undefined ? true : options.mergeFeatures;
     this.size = options.structure == '3d' ? 3 : 2;

package/lib/Core/Geographic/CoordStars.js

@@ -68,7 +68,6 @@ const CoordStars = {
       };
     };
   },
-
   // Return scene coordinate ({x,y,z}) of sun
   getSunPositionInScene(date, lat, lon) {
     const sun = CoordStars.getSunPosition()(date, lat, lon);

package/lib/Core/Label.js

@@ -71,7 +71,6 @@ class Label extends THREE.Object3D {
           // TODO: add smooth transition for fade in/out
         }
       },
-
       get() {
         return _visible;
       }

package/lib/Core/MainLoop.js

@@ -88,7 +88,6 @@ class MainLoop extends EventDispatcher {
     this.scheduler = scheduler;
     this.gfxEngine = engine; // TODO: remove me
   }
-
   scheduleViewUpdate(view, forceRedraw) {
     this.#needsRedraw |= forceRedraw;
     if (this.renderingState !== RENDERING_SCHEDULED) {

package/lib/Core/Prefab/Globe/Atmosphere.js

@@ -72,7 +72,6 @@ class Atmosphere extends GeometryLayer {
           value: new THREE.Vector2(window.innerWidth, window.innerHeight)
         } // Should be updated on screen resize...
       },
-
       vertexShader: GlowVS,
       fragmentShader: GlowFS,
       side: THREE.BackSide,
@@ -100,7 +99,6 @@ class Atmosphere extends GeometryLayer {
           value: new THREE.Vector2(window.innerWidth, window.innerHeight)
         } // Should be updated on screen resize...
       },
-
       vertexShader: GlowVS,
       fragmentShader: GlowFS,
       side: THREE.FrontSide,
@@ -135,7 +133,6 @@ class Atmosphere extends GeometryLayer {
       scaleDepth: 0.25
       // mieScaleDepth: 0.1,
     };
-
     this.object3d.updateMatrixWorld();
   }
   update(context, layer, node) {
@@ -288,7 +285,6 @@ class Atmosphere extends GeometryLayer {
     skyDome.material.uniforms.mieDirectionalG.value = effectController.mieDirectionalG;
     skyDome.material.uniforms.up.value = new THREE.Vector3(); // no more necessary, estimate normal from cam..
   }
-
   setRealisticOn(bool) {
     if (bool) {
       if (!this.realisticAtmosphere.children.length) {

package/lib/Core/Prefab/Globe/GlobeLayer.js

@@ -3,7 +3,6 @@ import TiledGeometryLayer from "../../../Layer/TiledGeometryLayer.js";
 import { ellipsoidSizes } from "../../Math/Ellipsoid.js";
 import { globalExtentTMS, schemeTiles } from "../../Geographic/Extent.js";
 import BuilderEllipsoidTile from "./BuilderEllipsoidTile.js";
-import { SIZE_DIAGONAL_TEXTURE } from "../../../Process/LayeredMaterialNodeProcessing.js";
 import CRS from "../../Geographic/Crs.js";
 
 // matrix to convert sphere to ellipsoid
@@ -129,7 +128,7 @@ class GlobeLayer extends TiledGeometryLayer {
     return isOccluded;
   }
   computeTileZoomFromDistanceCamera(distance, camera) {
-    const preSinus = SIZE_DIAGONAL_TEXTURE * (this.sseSubdivisionThreshold * 0.5) / camera._preSSE / ellipsoidSizes.x;
+    const preSinus = this.sizeDiagonalTexture * (this.sseSubdivisionThreshold * 0.5) / camera._preSSE / ellipsoidSizes.x;
     let sinus = distance * preSinus;
     let zoom = Math.log(Math.PI / (2.0 * Math.asin(sinus))) / Math.log(2);
     const delta = Math.PI / 2 ** zoom;
@@ -143,7 +142,8 @@ class GlobeLayer extends TiledGeometryLayer {
     const delta = Math.PI / 2 ** zoom;
     const circleChord = 2.0 * ellipsoidSizes.x * Math.sin(delta * 0.5);
     const radius = circleChord * 0.5;
-    return camera._preSSE * (radius / SIZE_DIAGONAL_TEXTURE) / (this.sseSubdivisionThreshold * 0.5) + radius;
+    const error = radius / this.sizeDiagonalTexture;
+    return camera._preSSE * error / (this.sseSubdivisionThreshold * 0.5) + radius;
   }
 }
 export default GlobeLayer;

package/lib/Core/Style.js

@@ -12,8 +12,7 @@ const matrix = document.createElementNS('http://www.w3.org/2000/svg', 'svg').cre
 const canvas = document.createElement('canvas');
 const inv255 = 1 / 255;
 function baseAltitudeDefault(properties, ctx) {
-  var _ctx$coordinates;
-  return (ctx === null || ctx === void 0 ? void 0 : (_ctx$coordinates = ctx.coordinates) === null || _ctx$coordinates === void 0 ? void 0 : _ctx$coordinates.z) || 0;
+  return ctx?.coordinates?.z || 0;
 }
 export function readExpression(property, ctx) {
   if (property != undefined) {
@@ -154,7 +153,6 @@ function defineStyleProperty(style, category, parameter, userValue, defaultValue
   Object.defineProperty(style[category], parameter, {
     enumerable: true,
     get: () => {
-      var _style$context$featur, _style$context$featur2;
       // != to check for 'undefined' and 'null' value)
       if (property != undefined) {
         return property;
@@ -162,7 +160,7 @@ function defineStyleProperty(style, category, parameter, userValue, defaultValue
       if (userValue != undefined) {
         return readExpression(userValue, style.context);
       }
-      const dataValue = (_style$context$featur = style.context.featureStyle) === null || _style$context$featur === void 0 ? void 0 : (_style$context$featur2 = _style$context$featur[category]) === null || _style$context$featur2 === void 0 ? void 0 : _style$context$featur2[parameter];
+      const dataValue = style.context.featureStyle?.[category]?.[parameter];
       if (dataValue != undefined) {
         return readExpression(dataValue, style.context);
       }

package/lib/Core/View.js

@@ -232,8 +232,7 @@ class View extends THREE.EventDispatcher {
    * @returns {THREE.WebGLRenderer} the WebGLRenderer used to render this view.
    */
   get renderer() {
-    var _this$mainLoop, _this$mainLoop$gfxEng;
-    return (_this$mainLoop = this.mainLoop) === null || _this$mainLoop === void 0 ? void 0 : (_this$mainLoop$gfxEng = _this$mainLoop.gfxEngine) === null || _this$mainLoop$gfxEng === void 0 ? void 0 : _this$mainLoop$gfxEng.getRenderer();
+    return this.mainLoop?.gfxEngine?.getRenderer();
   }
 
   /**
@@ -241,8 +240,7 @@ class View extends THREE.EventDispatcher {
    * @returns {THREE.Camera} the threejs camera of this view
    */
   get camera3D() {
-    var _this$camera;
-    return (_this$camera = this.camera) === null || _this$camera === void 0 ? void 0 : _this$camera.camera3D;
+    return this.camera?.camera3D;
   }
 
   /**

package/lib/Layer/C3DTilesLayer.js

@@ -92,7 +92,9 @@ class C3DTilesLayer extends GeometryLayer {
    * @param {Number} [config.cleanupDelay=1000] The time (in ms) after which a tile content (and its children) are
    * removed from the scene.
    * @param {C3DTExtensions} [config.registeredExtensions] 3D Tiles extensions managers registered for this tileset.
-   * @param {String} [config.pntsMode= PNTS_MODE.COLOR] {@link PointsMaterials} Point cloud coloring mode. Only 'COLOR' or 'CLASSIFICATION' are possible. COLOR uses RGB colors of the points, CLASSIFICATION uses a classification property of the batch table to color points.
+   * @param {String} [config.pntsMode= PNTS_MODE.COLOR] {@link PointsMaterials} Point cloud coloring mode.
+   *      Only 'COLOR' or 'CLASSIFICATION' are possible. COLOR uses RGB colors of the points,
+   *      CLASSIFICATION uses a classification property of the batch table to color points.
    * @param {String} [config.pntsShape= PNTS_SHAPE.CIRCLE] Point cloud point shape. Only 'CIRCLE' or 'SQUARE' are possible.
    * @param {String} [config.pntsSizeMode= PNTS_SIZE_MODE.VALUE] {@link PointsMaterials} Point cloud size mode. Only 'VALUE' or 'ATTENUATED' are possible. VALUE use constant size, ATTENUATED compute size depending on distance from point to camera.
    * @param {Number} [config.pntsMinAttenuatedSize=3] Minimum scale used by 'ATTENUATED' size mode

package/lib/Layer/CopcLayer.js

@@ -0,0 +1,59 @@
+import * as THREE from 'three';
+import CopcNode from "../Core/CopcNode.js";
+import PointCloudLayer from "./PointCloudLayer.js";
+
+/**
+ * @classdesc
+ * A layer for [Cloud Optimised Point Cloud](https://copc.io) (COPC) datasets.
+ * See {@link PointCloudLayer} class for documentation on base properties.
+ *
+ * @extends {PointCloudLayer}
+ *
+ * @example
+ * // Create a new COPC layer
+ * const copcSource = new CopcSource({
+ *     url: 'https://s3.amazonaws.com/hobu-lidar/autzen-classified.copc.laz',
+ *     crs: 'EPSG:4978',
+ *     colorDepth: 16, // bit-depth of 'color' attribute (either 8 or 16 bits)
+ * });
+ *
+ * const copcLayer = new CopcLayer('COPC', {
+ *     source: copcSource,
+ * });
+ *
+ * View.prototype.addLayer.call(view, copcLayer);
+ */
+class CopcLayer extends PointCloudLayer {
+  /**
+   * @param {string} id - Unique id of the layer.
+   * @param {Object} config - See {@link PointCloudLayer} for base pointcloud
+   * options.
+   */
+  constructor(id, config) {
+    super(id, config);
+    this.isCopcLayer = true;
+    const resolve = () => this;
+    this.whenReady = this.source.whenReady.then(( /** @type {CopcSource} */source) => {
+      const {
+        cube,
+        rootHierarchyPage
+      } = source.info;
+      const {
+        pageOffset,
+        pageLength
+      } = rootHierarchyPage;
+      this.root = new CopcNode(0, 0, 0, 0, pageOffset, pageLength, this, -1);
+      this.root.bbox.min.fromArray(cube, 0);
+      this.root.bbox.max.fromArray(cube, 3);
+      this.minElevationRange = source.header.min[2];
+      this.maxElevationRange = source.header.max[2];
+      this.scale = new THREE.Vector3(1.0, 1.0, 1.0);
+      this.offset = new THREE.Vector3(0.0, 0.0, 0.0);
+      return this.root.loadOctree().then(resolve);
+    });
+  }
+  get spacing() {
+    return this.source.info.spacing;
+  }
+}
+export default CopcLayer;

package/lib/Layer/ElevationLayer.js

@@ -60,14 +60,13 @@ class ElevationLayer extends RasterLayer {
    * view.addLayer(elevation);
    */
   constructor(id) {
-    var _config$clampValues, _config$clampValues2;
     let config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     super(id, config);
     if (config.zmin || config.zmax) {
       console.warn('Config using zmin and zmax are deprecated, use {clampValues: {min, max}} structure.');
     }
-    this.zmin = ((_config$clampValues = config.clampValues) === null || _config$clampValues === void 0 ? void 0 : _config$clampValues.min) ?? config.zmin;
-    this.zmax = ((_config$clampValues2 = config.clampValues) === null || _config$clampValues2 === void 0 ? void 0 : _config$clampValues2.max) ?? config.zmax;
+    this.zmin = config.clampValues?.min ?? config.zmin;
+    this.zmax = config.clampValues?.max ?? config.zmax;
     this.isElevationLayer = true;
     this.defineLayerProperty('scale', this.scale || 1.0);
   }

package/lib/Layer/GeoidLayer.js

@@ -1,8 +1,7 @@
 import Layer from "./Layer.js";
 import LayerUpdateState from "./LayerUpdateState.js";
 export function geoidLayerIsVisible(tilelayer) {
-  var _tilelayer$attachedLa;
-  return tilelayer === null || tilelayer === void 0 ? void 0 : (_tilelayer$attachedLa = tilelayer.attachedLayers.filter(l => l.isGeoidLayer)[0]) === null || _tilelayer$attachedLa === void 0 ? void 0 : _tilelayer$attachedLa.visible;
+  return tilelayer?.attachedLayers.filter(l => l.isGeoidLayer)[0]?.visible;
 }
 
 /**

package/lib/Layer/LabelLayer.js

@@ -195,11 +195,9 @@ class LabelLayer extends GeometryLayer {
   set visible(value) {
     super.visible = value;
     if (value) {
-      var _this$domElement;
-      (_this$domElement = this.domElement) === null || _this$domElement === void 0 ? void 0 : _this$domElement.show();
+      this.domElement?.show();
     } else {
-      var _this$domElement2;
-      (_this$domElement2 = this.domElement) === null || _this$domElement2 === void 0 ? void 0 : _this$domElement2.hide();
+      this.domElement?.hide();
     }
   }
   get submittedLabelNodes() {
@@ -231,16 +229,15 @@ class LabelLayer extends GeometryLayer {
     coord.crs = data.crs;
     context.setZoom(extent.zoom);
     data.features.forEach(f => {
-      var _f$style, _f$style$text, _f$style2, _f$style2$point;
       // TODO: add support for LINE and POLYGON
       if (f.type !== FEATURE_TYPES.POINT) {
         return;
       }
       context.setFeature(f);
-      const featureField = (_f$style = f.style) === null || _f$style === void 0 ? void 0 : (_f$style$text = _f$style.text) === null || _f$style$text === void 0 ? void 0 : _f$style$text.field;
+      const featureField = f.style?.text?.field;
 
       // determine if altitude style is specified by the user
-      const altitudeStyle = (_f$style2 = f.style) === null || _f$style2 === void 0 ? void 0 : (_f$style2$point = _f$style2.point) === null || _f$style2$point === void 0 ? void 0 : _f$style2$point.base_altitude;
+      const altitudeStyle = f.style?.point?.base_altitude;
       const isDefaultElevationStyle = altitudeStyle instanceof Function && altitudeStyle.name == 'baseAltitudeDefault';
 
       // determine if the altitude needs update with ElevationLayer
@@ -292,19 +289,14 @@ class LabelLayer extends GeometryLayer {
     this.toHide.add(labelsNode);
   }
   #findClosestDomElement(node) {
-    var _node$parent;
-    if ((_node$parent = node.parent) !== null && _node$parent !== void 0 && _node$parent.isTileMesh) {
-      var _node$parent$link$thi;
-      return ((_node$parent$link$thi = node.parent.link[this.id]) === null || _node$parent$link$thi === void 0 ? void 0 : _node$parent$link$thi.domElements) || this.#findClosestDomElement(node.parent);
+    if (node.parent?.isTileMesh) {
+      return node.parent.link[this.id]?.domElements || this.#findClosestDomElement(node.parent);
     } else {
       return this.domElement;
     }
   }
   #hasLabelChildren(object) {
-    return object.children.every(c => {
-      var _c$layerUpdateState$t;
-      return c.layerUpdateState && ((_c$layerUpdateState$t = c.layerUpdateState[this.id]) === null || _c$layerUpdateState$t === void 0 ? void 0 : _c$layerUpdateState$t.hasFinished());
-    });
+    return object.children.every(c => c.layerUpdateState && c.layerUpdateState[this.id]?.hasFinished());
   }
 
   // Remove all labels invisible with pre-culling with screen grid
@@ -439,8 +431,7 @@ class LabelLayer extends GeometryLayer {
     this.removeNodeDomElement(node);
   }
   removeNodeDomElement(node) {
-    var _node$link$this$id;
-    if ((_node$link$this$id = node.link[this.id]) !== null && _node$link$this$id !== void 0 && _node$link$this$id.domElements) {
+    if (node.link[this.id]?.domElements) {
       const child = node.link[this.id].domElements.dom;
       child.parentElement.removeChild(child);
       delete node.link[this.id].domElements;

package/lib/Layer/Layer.js

@@ -66,6 +66,7 @@ class Layer extends THREE.EventDispatcher {
    * @param {boolean} [config.addLabelLayer.performance=false] - In case label layer adding, so remove labels that have no chance of being visible.
    * Indeed, even in the best case, labels will never be displayed. By example, if there's many labels.
    * @param {boolean} [config.addLabelLayer.forceClampToTerrain=false] - use elevation layer to clamp label on terrain.
+   * @param {number} [config.subdivisionThreshold=256] - set the texture size and, if applied to the globe, affects the tile subdivision.
    *
    * @example
    * // Add and create a new Layer
@@ -100,8 +101,7 @@ class Layer extends THREE.EventDispatcher {
     super();
     this.isLayer = true;
     if (config.style && !(config.style instanceof Style)) {
-      var _config$style$fill;
-      if (typeof ((_config$style$fill = config.style.fill) === null || _config$style$fill === void 0 ? void 0 : _config$style$fill.pattern) === 'string') {
+      if (typeof config.style.fill?.pattern === 'string') {
         console.warn('Using style.fill.pattern = { source: Img|url } is adviced');
         config.style.fill.pattern = {
           source: config.style.fill.pattern
@@ -110,6 +110,8 @@ class Layer extends THREE.EventDispatcher {
       config.style = new Style(config.style);
     }
     this.style = config.style || new Style();
+    this.subdivisionThreshold = config.subdivisionThreshold || 256;
+    this.sizeDiagonalTexture = (2 * (this.subdivisionThreshold * this.subdivisionThreshold)) ** 0.5;
     Object.assign(this, config);
     Object.defineProperty(this, 'id', {
       value: id,

package/lib/Layer/PointCloudLayer.js

@@ -73,16 +73,13 @@ function markForDeletion(elt) {
   }
 }
 function changeIntensityRange(layer) {
-  var _layer$material$inten;
-  (_layer$material$inten = layer.material.intensityRange) === null || _layer$material$inten === void 0 ? void 0 : _layer$material$inten.set(layer.minIntensityRange, layer.maxIntensityRange);
+  layer.material.intensityRange?.set(layer.minIntensityRange, layer.maxIntensityRange);
 }
 function changeElevationRange(layer) {
-  var _layer$material$eleva;
-  (_layer$material$eleva = layer.material.elevationRange) === null || _layer$material$eleva === void 0 ? void 0 : _layer$material$eleva.set(layer.minElevationRange, layer.maxElevationRange);
+  layer.material.elevationRange?.set(layer.minElevationRange, layer.maxElevationRange);
 }
 function changeAngleRange(layer) {
-  var _layer$material$angle;
-  (_layer$material$angle = layer.material.angleRange) === null || _layer$material$angle === void 0 ? void 0 : _layer$material$angle.set(layer.minAngleRange, layer.maxAngleRange);
+  layer.material.angleRange?.set(layer.minAngleRange, layer.maxAngleRange);
 }
 
 /**
@@ -176,7 +173,7 @@ class PointCloudLayer extends GeometryLayer {
     if (this.material) {
       this.material.visible = this.visible;
       this.material.opacity = this.opacity;
-      this.material.transparent = this.opacity < 1;
+      this.material.transparent = this.opacity < 1 || this.material.userData.needTransparency[this.material.mode];
       this.material.size = this.pointSize;
       this.material.scale = context.camera.preSSE;
       if (this.material.updateUniforms) {

package/lib/Layer/ReferencingLayerProperties.js

@@ -1,6 +1,5 @@
 // next step is move these properties to Style class
 // and hide transparent mechanism
-
 function ReferLayerProperties(material, layer) {
   if (layer && layer.isGeometryLayer) {
     let transparent = material.transparent;
@@ -44,9 +43,10 @@ function ReferLayerProperties(material, layer) {
     });
     Object.defineProperty(material, 'transparent', {
       get: () => {
-        if (transparent != material.layer.opacity < 1.0) {
+        const needTransparency = material.userData.needTransparency?.[material.mode] || material.layer.opacity < 1.0;
+        if (transparent != needTransparency) {
           material.needsUpdate = true;
-          transparent = material.layer.opacity < 1.0;
+          transparent = needTransparency;
         }
         return transparent;
       }

package/lib/Layer/TiledGeometryLayer.js

@@ -4,7 +4,6 @@ import { InfoTiledGeometryLayer } from "./InfoLayer.js";
 import Picking from "../Core/Picking.js";
 import convertToTile from "../Converter/convertToTile.js";
 import ObjectRemovalHelper from "../Process/ObjectRemovalHelper.js";
-import { SIZE_DIAGONAL_TEXTURE } from "../Process/LayeredMaterialNodeProcessing.js";
 import { ImageryLayers } from "./Layer.js";
 import { CACHE_POLICIES } from "../Core/Scheduler/Cache.js";
 const subdivisionVector = new THREE.Vector3();
@@ -89,7 +88,7 @@ class TiledGeometryLayer extends GeometryLayer {
       this.object3d.add(...level0s);
       this.object3d.updateMatrixWorld();
     }));
-    this.maxScreenSizeNode = this.sseSubdivisionThreshold * (SIZE_DIAGONAL_TEXTURE * 2);
+    this.maxScreenSizeNode = this.sseSubdivisionThreshold * (this.sizeDiagonalTexture * 2);
   }
   get hideSkirt() {
     return this._hideSkirt;
@@ -408,7 +407,7 @@ class TiledGeometryLayer extends GeometryLayer {
 
     // The screen space error is calculated to have a correct texture display.
     // For the projection of a texture's texel to be less than or equal to one pixel
-    const sse = node.screenSize / (SIZE_DIAGONAL_TEXTURE * 2);
+    const sse = node.screenSize / (this.sizeDiagonalTexture * 2);
     return this.sseSubdivisionThreshold < sse;
   }
 }

package/lib/Main.js

@@ -60,6 +60,7 @@ export { default as GlobeLayer } from "./Core/Prefab/Globe/GlobeLayer.js";
 export { default as PlanarLayer } from "./Core/Prefab/Planar/PlanarLayer.js";
 export { default as LabelLayer } from "./Layer/LabelLayer.js";
 export { default as EntwinePointTileLayer } from "./Layer/EntwinePointTileLayer.js";
+export { default as CopcLayer } from "./Layer/CopcLayer.js";
 export { default as GeoidLayer } from "./Layer/GeoidLayer.js";
 
 // Sources provided by default in iTowns
@@ -78,6 +79,7 @@ export { default as C3DTilesSource } from "./Source/C3DTilesSource.js";
 export { default as C3DTilesIonSource } from "./Source/C3DTilesIonSource.js";
 export { default as C3DTilesGoogleSource } from "./Source/C3DTilesGoogleSource.js";
 export { default as EntwinePointTileSource } from "./Source/EntwinePointTileSource.js";
+export { default as CopcSource } from "./Source/CopcSource.js";
 
 // Parsers provided by default in iTowns
 // Custom parser can be implemented as wanted, as long as the main function

package/lib/Parser/GeoJsonParser.js

@@ -132,8 +132,7 @@ function toFeatureType(jsonType) {
 const keyProperties = ['type', 'geometry', 'properties'];
 const firstCoordinates = a => a === undefined || Array.isArray(a) && !isNaN(a[0]) ? a : firstCoordinates(a[0]);
 function jsonFeatureToFeature(crsIn, json, collection) {
-  var _json$geometry, _firstCoordinates;
-  if (!((_json$geometry = json.geometry) !== null && _json$geometry !== void 0 && _json$geometry.type)) {
+  if (!json.geometry?.type) {
     console.warn('No geometry provided');
     return null;
   }
@@ -142,7 +141,7 @@ function jsonFeatureToFeature(crsIn, json, collection) {
   const feature = collection.requestFeatureByType(featureType);
   const coordinates = jsonType != 'point' ? json.geometry.coordinates : [json.geometry.coordinates];
   const properties = json.properties || {};
-  feature.hasRawElevationData = ((_firstCoordinates = firstCoordinates(coordinates)) === null || _firstCoordinates === void 0 ? void 0 : _firstCoordinates.length) === 3;
+  feature.hasRawElevationData = firstCoordinates(coordinates)?.length === 3;
 
   // copy other properties
   for (const key of Object.keys(json)) {