itowns 2.44.3-next.32 → 2.44.3-next.34

package/lib/Core/Prefab/computeBufferTileGeometry.js

@@ -16,14 +16,17 @@ function getUintArrayConstructor(highestValue) {
   }
   return picked;
 }
-function allocateIndexBuffer(nVertex, nSeg, params) {
-  if (!params.buildIndexAndUv_0) {
-    return undefined;
-  }
+function allocateIndexBuffer(nVertex, nSeg, params, cache) {
   const indexBufferSize = getBufferIndexSize(nSeg, params.disableSkirt);
   const indexConstructor = getUintArrayConstructor(nVertex);
   const tileLen = indexBufferSize;
   const skirtLen = 4 * nSeg;
+  if (cache !== undefined) {
+    return {
+      index: cache,
+      skirt: cache.subarray(tileLen, tileLen + skirtLen)
+    };
+  }
   const indexBuffer = new ArrayBuffer((
   // Tile
   tileLen
@@ -36,11 +39,11 @@ function allocateIndexBuffer(nVertex, nSeg, params) {
     skirt
   };
 }
-function allocateBuffers(nVertex, nSeg, builder, params) {
+function allocateBuffers(nVertex, nSeg, builder, params, cache) {
   const {
     index,
     skirt
-  } = allocateIndexBuffer(nVertex, nSeg, params) ?? {};
+  } = allocateIndexBuffer(nVertex, nSeg, params, cache?.index);
   return {
     index,
     skirt,
@@ -62,7 +65,7 @@ function allocateBuffers(nVertex, nSeg, builder, params) {
     //      +-------------------------+
     //        * u = wgs84.u
     //        * v = textureid + v in builder texture
-    uvs: [params.buildIndexAndUv_0 ? new Float32Array(nVertex * 2) : undefined, builder.computeExtraOffset !== undefined ? new Float32Array(nVertex) : undefined]
+    uvs: [cache?.uv ?? new Float32Array(nVertex * 2), builder.computeExtraOffset !== undefined ? new Float32Array(nVertex) : undefined]
   };
 }
 function computeUv0(uv, id, u, v) {
@@ -76,7 +79,7 @@ function initComputeUv1(value) {
 }
 /** Compute buffers describing a tile according to a builder and its params. */
 // TODO: Split this even further into subfunctions
-export function computeBuffers(builder, params) {
+export function computeBuffers(builder, params, cache) {
   //     n seg, n+1 vert    + <- skirt, n verts per side
   //    <---------------> / |
   //    +---+---+---+---+   |
@@ -98,8 +101,8 @@ export function computeBuffers(builder, params) {
   if (nTotalVertex > 2 ** 32) {
     throw new Error('Tile segments count is too big');
   }
-  const outBuffers = allocateBuffers(nTotalVertex, nSeg, builder, params);
-  const computeUvs = [params.buildIndexAndUv_0 ? computeUv0 : () => {}];
+  const outBuffers = allocateBuffers(nTotalVertex, nSeg, builder, params, cache);
+  const computeUvs = [cache === undefined ? computeUv0 : () => {}];
   params = builder.prepare(params);
   for (let y = 0; y <= nSeg; y++) {
     const v = y / nSeg;
@@ -135,7 +138,7 @@ export function computeBuffers(builder, params) {
   }
 
   // Fill skirt index buffer
-  if (params.buildIndexAndUv_0 && !params.disableSkirt) {
+  if (cache === undefined && !params.disableSkirt) {
     for (let x = 0; x < nVertex; x++) {
       //   -------->
       //   0---1---2
@@ -174,7 +177,7 @@ export function computeBuffers(builder, params) {
     outBuffers.index[id + 1] = vb;
     outBuffers.index[id + 2] = vc;
   }
-  if (params.buildIndexAndUv_0) {
+  if (cache === undefined) {
     for (let y = 0; y < nSeg; y++) {
       for (let x = 0; x < nSeg; x++) {
         const v1 = y * nVertex + (x + 1);
@@ -192,11 +195,11 @@ export function computeBuffers(builder, params) {
   // INFO: The size of the skirt is now a ratio of the size of the tile.
   // To be perfect it should depend on the real elevation delta but too heavy
   // to compute
-  if (params.buildIndexAndUv_0 && !params.disableSkirt) {
+  if (!params.disableSkirt) {
     // We compute the actual size of tile segment to use later for
     // the skirt.
     const segmentSize = new THREE.Vector3().fromArray(outBuffers.position).distanceTo(new THREE.Vector3().fromArray(outBuffers.position, 3));
-    const buildSkirt = {
+    const buildSkirt = cache === undefined ? {
       index: (id, v1, v2, v3, v4) => {
         bufferizeTri(id, v1, v2, v3);
         bufferizeTri(id + 3, v1, v3, v4);
@@ -206,6 +209,9 @@ export function computeBuffers(builder, params) {
         buf[idTo * 2 + 0] = buf[idFrom * 2 + 0];
         buf[idTo * 2 + 1] = buf[idFrom * 2 + 1];
       }
+    } : {
+      index: () => {},
+      uv: () => {}
     };
 
     // Alias for readability

package/lib/Core/Tile/Tile.js

@@ -10,7 +10,7 @@ const r = {
   col: 0,
   invDiff: 0
 };
-function _rowColfromParent(/** @type {Tile} */tile, /** @type {number} */zoom) {
+function _rowColfromParent(tile, zoom) {
   const diffLevel = tile.zoom - zoom;
   const diff = 2 ** diffLevel;
   r.invDiff = 1 / diff;
@@ -18,17 +18,18 @@ function _rowColfromParent(/** @type {Tile} */tile, /** @type {number} */zoom) {
   r.col = (tile.col - tile.col % diff) * r.invDiff;
   return r;
 }
-const _extent = new Extent('EPSG:4326', [0, 0, 0, 0]);
-const _extent2 = new Extent('EPSG:4326', [0, 0, 0, 0]);
+const _extent = new Extent('EPSG:4326');
+const _extent2 = new Extent('EPSG:4326');
 const _c = new Coordinates('EPSG:4326', 0, 0);
 class Tile {
   /**
-   * Tile is a geographical bounding rectangle defined by zoom, row and column.
+   * A tile is a geographical bounding rectangle uniquely defined by its zoom,
+   * row and column.
    *
-   * @param {String} crs projection of limit values.
-   * @param {number} [zoom=0] zoom value
-   * @param {number} [row=0] row value
-   * @param {number} [col=0] column value
+   * @param crs - projection of limit values.
+   * @param zoom - `zoom` value. Default is 0.
+   * @param row - `row` value. Default is 0.
+   * @param col - `column` value. Default is 0.
    */
   constructor(crs) {
     let zoom = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
@@ -42,22 +43,21 @@ class Tile {
   }
 
   /**
-   * Clone this tile
-   * @return {Tile} cloned tile
+   * Returns a new tile with the same bounds and crs as this one.
    */
   clone() {
     return new Tile(this.crs, this.zoom, this.row, this.col);
   }
 
   /**
-   * Convert tile to the specified extent.
-   * @param {string} crs the projection of destination.
-   * @param {Extent} target copy the destination to target.
-   * @return {Extent}
+   * Converts this tile to the specified extent.
+   * @param crs - target's projection.
+   * @param target - The target to store the projected extent. If this not
+   * provided a new extent will be created.
    */
-  toExtent(crs, target) {
+  toExtent(crs) {
+    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Extent('EPSG:4326');
     CRS.isValid(crs);
-    target = target || new Extent('EPSG:4326', [0, 0, 0, 0]);
     const {
       epsg,
       globalExtent,
@@ -70,16 +70,13 @@ class Tile {
     target.south = globalExtent.south + _dimensionTile.y * (countTiles.y - this.row - 1);
     target.north = target.south + _dimensionTile.y;
     target.crs = epsg;
-    target.zoom = this.zoom;
     return crs == epsg ? target : target.as(crs, target);
   }
 
   /**
-   * Return true if `tile` is inside this tile.
+   * Checks whether another tile is inside this tile.
    *
-   * @param {Tile} tile the tile to check
-   *
-   * @return {boolean}
+   * @param extent - the tile to check.
    */
   isInside(tile) {
     if (this.zoom == tile.zoom) {
@@ -87,36 +84,35 @@ class Tile {
     } else if (this.zoom < tile.zoom) {
       return false;
     } else {
-      _rowColfromParent(this, tile.zoom);
+      const r = _rowColfromParent(this, tile.zoom);
       return r.row == tile.row && r.col == tile.col;
     }
   }
 
   /**
-   * Return the translation and scale to transform this tile to input tile.
+   * Returns the translation and scale to transform this tile to the input
+   * tile.
    *
-   * @param {Tile} tile input tile
-   * @param {THREE.Vector4} target copy the result to target.
-   * @return {THREE.Vector4} {x: translation on west-east, y: translation on south-north, z: scale on west-east, w: scale on south-north}
+   * @param tile - the input tile.
+   * @param target - copy the result to target.
    */
   offsetToParent(tile) {
     let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new THREE.Vector4();
     if (this.crs != tile.crs) {
       throw new Error('unsupported mix');
     }
-    _rowColfromParent(this, tile.zoom);
+    const r = _rowColfromParent(this, tile.zoom);
     return target.set(this.col * r.invDiff - r.col, this.row * r.invDiff - r.row, r.invDiff, r.invDiff);
   }
 
   /**
-   * Return parent tile with input level
+   * Returns the parent tile at the given level.
    *
-   * @param {number} levelParent level of parent.
-   * @return {Tile}
+   * @param levelParent - the level of the parent tile.
    */
   tiledExtentParent(levelParent) {
     if (levelParent && levelParent < this.zoom) {
-      _rowColfromParent(this, levelParent);
+      const r = _rowColfromParent(this, levelParent);
       return new Tile(this.crs, levelParent, r.row, r.col);
     } else {
       return this;
@@ -124,13 +120,11 @@ class Tile {
   }
 
   /**
-   * Set zoom, row and column values
-   *
-   * @param {number} [zoom=0] zoom value
-   * @param {number} [row=0] row value
-   * @param {number} [col=0] column value
+   * Sets zoom, row and column values.
    *
-   * @return {Tile}
+   * @param zoom - zoom value.
+   * @param row - row value.
+   * @param col - column value.
    */
   set() {
     let zoom = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
@@ -143,9 +137,8 @@ class Tile {
   }
 
   /**
-   * Copy to this tile to input tile.
-   * @param {Tile} tile
-   * @return {Tile} copied extent
+   * Copies the passed tile to this tile.
+   * @param tile - tile to copy.
    */
   copy(tile) {
     this.crs = tile.crs;
@@ -154,20 +147,13 @@ class Tile {
 
   /**
    * Return values of tile in string, separated by the separator input.
-   * @param {string} separator
-   * @return {string}
+   * @param separator - string separator
    */
   toString() {
     let separator = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
     return `${this.zoom}${separator}${this.row}${separator}${this.col}`;
   }
 }
-
-/**
- * @param {Extent} e
- * @param {string} tms
- * @returns {Tile[]}
- */
 export function tiledCovering(e, tms) {
   if (e.crs == 'EPSG:4326' && tms == 'EPSG:3857') {
     const WMTS_PM = [];
@@ -179,7 +165,7 @@ export function tiledCovering(e, tms) {
     } = getInfoTms(tms);
     extent.clampByExtent(globalExtent);
     extent.planarDimensions(_dimensionTile);
-    const zoom = e.zoom + 1 || Math.floor(Math.log2(Math.round(globalDimension.x / (_dimensionTile.x * sTs.x))));
+    const zoom = Math.floor(Math.log2(Math.round(globalDimension.x / (_dimensionTile.x * sTs.x))));
     const countTiles = getCountTiles(tms, zoom);
     const center = extent.center(_c);
     _tmsCoord.x = center.x - globalExtent.west;
@@ -203,12 +189,14 @@ export function tiledCovering(e, tms) {
     const center = e.center(_c);
     e.planarDimensions(_dimensionTile);
     // Each level has 2^n * 2^n tiles...
-    // ... so we count how many tiles of the same width as tile we can fit in the layer
+    // ... so we count how many tiles of the same width as tile we can fit
+    // in the layer
     // ... 2^zoom = tilecount => zoom = log2(tilecount)
     const zoom = Math.floor(Math.log2(Math.round(globalDimension.x / (_dimensionTile.x * sTs.x))));
     const countTiles = getCountTiles(tms, zoom);
 
-    // Now that we have computed zoom, we can deduce x and y (or row / column)
+    // Now that we have computed zoom, we can deduce x and y (or row /
+    // column)
     _tmsCoord.x = center.x - globalExtent.west;
     _tmsCoord.y = isInverted ? globalExtent.north - center.y : center.y - globalExtent.south;
     _tmsCoord.divide(globalDimension).multiply(countTiles).floor();

package/lib/Core/Tile/TileGrid.js

@@ -13,13 +13,19 @@ globalExtentTMS.set('EPSG:4326', extent4326);
 const extent3857 = extent4326.as('EPSG:3857');
 extent3857.clampSouthNorth(extent3857.west, extent3857.east);
 globalExtentTMS.set('EPSG:3857', extent3857);
-schemeTiles.set('default', new THREE.Vector2(1, 1));
-schemeTiles.set('EPSG:3857', schemeTiles.get('default'));
+const defaultScheme = new THREE.Vector2(1, 1);
+schemeTiles.set('EPSG:3857', defaultScheme);
 schemeTiles.set('EPSG:4326', new THREE.Vector2(2, 1));
-export function getInfoTms(/** @type {string} */crs) {
+
+// TODO: For now we can only have a single TMS grid per proj4 identifier.
+// This causes TMS identifier to be proj4 identifier.
+export function getInfoTms(crs) {
   const globalExtent = globalExtentTMS.get(crs);
+  if (!globalExtent) {
+    throw new Error(`The tile matrix set ${crs} is not defined.`);
+  }
   const globalDimension = globalExtent.planarDimensions(_dim);
-  const sTs = schemeTiles.get(crs) || schemeTiles.get('default');
+  const sTs = schemeTiles.get(crs) ?? defaultScheme;
   // The isInverted parameter is to be set to the correct value, true or false
   // (default being false) if the computation of the coordinates needs to be
   // inverted to match the same scheme as OSM, Google Maps or other system.
@@ -35,8 +41,8 @@ export function getInfoTms(/** @type {string} */crs) {
     isInverted
   };
 }
-export function getCountTiles(/** @type {string} */crs, /** @type {number} */zoom) {
-  const sTs = schemeTiles.get(crs) || schemeTiles.get('default');
+export function getCountTiles(crs, zoom) {
+  const sTs = schemeTiles.get(crs) || defaultScheme;
   const count = 2 ** zoom;
   _countTiles.set(count, count).multiply(sTs);
   return _countTiles;

package/lib/Layer/OGC3DTilesLayer.js

@@ -141,24 +141,39 @@ class OGC3DTilesLayer extends GeometryLayer {
    * @param {String} id - unique layer id.
    * @param {Object} config - layer specific configuration
    * @param {OGC3DTilesSource} config.source - data source configuration
-   * @param {String} [config.pntsMode= PNTS_MODE.COLOR] Point cloud coloring mode (passed to {@link PointsMaterial}).
+   * @param {String} [config.pntsMode = PNTS_MODE.COLOR] Point cloud coloring mode (passed to {@link PointsMaterial}).
    *      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 {ClassificationScheme}  [config.classificationScheme]  {@link PointsMaterial} classification scheme
-   * @param {String} [config.pntsShape= PNTS_SHAPE.CIRCLE] Point cloud point shape. Only 'CIRCLE' or 'SQUARE' are possible.
+   * @param {ClassificationScheme}  [config.classificationScheme = ClassificationScheme.DEFAULT]  {@link PointsMaterial} classification scheme
+   * @param {String} [config.pntsShape = PNTS_SHAPE.CIRCLE] Point cloud point shape. Only 'CIRCLE' or 'SQUARE' are possible.
    * (passed to {@link PointsMaterial}).
-   * @param {String} [config.pntsSizeMode= PNTS_SIZE_MODE.VALUE] {@link PointsMaterial} Point cloud size mode (passed to {@link PointsMaterial}).
+   * @param {String} [config.pntsSizeMode = PNTS_SIZE_MODE.VALUE] {@link PointsMaterial} Point cloud size mode (passed to {@link PointsMaterial}).
    * 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.
-   * @param {Number} [config.pntsMaxAttenuatedSize=10] Maximum scale used by 'ATTENUATED' size mode.
+   * @param {Number} [config.pntsMinAttenuatedSize = 3] Minimum scale used by 'ATTENUATED' size mode.
+   * @param {Number} [config.pntsMaxAttenuatedSize = 10] Maximum scale used by 'ATTENUATED' size mode.
    */
   constructor(id, config) {
-    super(id, new THREE.Group(), {
-      source: config.source
-    });
+    const {
+      pntsMode = PNTS_MODE.COLOR,
+      pntsShape = PNTS_SHAPE.CIRCLE,
+      classification = ClassificationScheme.DEFAULT,
+      pntsSizeMode = PNTS_SIZE_MODE.VALUE,
+      pntsMinAttenuatedSize = 3,
+      pntsMaxAttenuatedSize = 10,
+      ...geometryLayerConfig
+    } = config;
+    super(id, new THREE.Group(), geometryLayerConfig);
     this.isOGC3DTilesLayer = true;
-    this._handlePointsMaterialConfig(config);
+    // Store points material config so they can be used later to substitute points tiles material
+    // by our own PointsMaterial. These properties should eventually be managed through the Style API
+    // (see https://github.com/iTowns/itowns/issues/2336)
+    this.pntsMode = pntsMode;
+    this.pntsShape = pntsShape;
+    this.classification = classification;
+    this.pntsSizeMode = pntsSizeMode;
+    this.pntsMinAttenuatedSize = pntsMinAttenuatedSize;
+    this.pntsMaxAttenuatedSize = pntsMaxAttenuatedSize;
     this.tilesRenderer = new TilesRenderer(this.source.url);
     if (config.source.isOGC3DTilesIonSource) {
       this.tilesRenderer.registerPlugin(new CesiumIonAuthPlugin({
@@ -197,21 +212,6 @@ class OGC3DTilesLayer extends GeometryLayer {
     }
   }
 
-  /**
-   * Store points material config so they can be used later to substitute points tiles material by our own PointsMaterial
-   * These properties should eventually be managed through the Style API (see https://github.com/iTowns/itowns/issues/2336)
-   * @param {Object} config - points material configuration as passed to the layer constructor.
-   * @private
-   */
-  _handlePointsMaterialConfig(config) {
-    this.pntsMode = config.pntsMode ?? PNTS_MODE.COLOR;
-    this.pntsShape = config.pntsShape ?? PNTS_SHAPE.CIRCLE;
-    this.classification = config.classification ?? ClassificationScheme.DEFAULT;
-    this.pntsSizeMode = config.pntsSizeMode ?? PNTS_SIZE_MODE.VALUE;
-    this.pntsMinAttenuatedSize = config.pntsMinAttenuatedSize || 3;
-    this.pntsMaxAttenuatedSize = config.pntsMaxAttenuatedSize || 10;
-  }
-
   /**
    * Sets the lruCache and download and parse queues so they are shared amongst
    * all tilesets from a same {@link View} view.

package/lib/Source/Source.js

@@ -121,7 +121,7 @@ class Source extends InformationsData {
     this.whenReady = Promise.resolve();
     this._featuresCaches = {};
     if (source.extent && !source.extent.isExtent) {
-      this.extent = new Extent(this.crs, source.extent);
+      this.extent = new Extent(this.crs).setFromExtent(source.extent);
     } else {
       this.extent = source.extent;
     }

package/lib/Source/WFSSource.js

@@ -1,7 +1,7 @@
 import Source from "./Source.js";
 import URLBuilder from "../Provider/URLBuilder.js";
 import Extent from "../Core/Geographic/Extent.js";
-const _extent = new Extent('EPSG:4326', [0, 0, 0, 0]);
+const _extent = new Extent('EPSG:4326');
 
 /**
  * An object defining the source of resources to get from a

package/lib/Source/WMSSource.js

@@ -2,7 +2,7 @@ import Source from "./Source.js";
 import URLBuilder from "../Provider/URLBuilder.js";
 import Extent from "../Core/Geographic/Extent.js";
 import * as CRS from "../Core/Geographic/Crs.js";
-const _extent = new Extent('EPSG:4326', [0, 0, 0, 0]);
+const _extent = new Extent('EPSG:4326');
 
 /**
  * Proj provides an optional param to define axis order and orientation for a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "itowns",
-  "version": "2.44.3-next.32",
+  "version": "2.44.3-next.34",
   "description": "A JS/WebGL framework for 3D geospatial data visualization",
   "type": "module",
   "main": "lib/Main.js",