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

package/lib/Core/Tile/Tile.js

@@ -0,0 +1,205 @@
+import * as THREE from 'three';
+import { Coordinates, CRS, Extent } from '@itowns/geographic';
+import { getInfoTms, getCountTiles } from "./TileGrid.js";
+const _tmsCoord = new THREE.Vector2();
+const _dimensionTile = new THREE.Vector2();
+const r = {
+  row: 0,
+  col: 0,
+  invDiff: 0
+};
+function _rowColfromParent(tile, zoom) {
+  const diffLevel = tile.zoom - zoom;
+  const diff = 2 ** diffLevel;
+  r.invDiff = 1 / diff;
+  r.row = (tile.row - tile.row % diff) * r.invDiff;
+  r.col = (tile.col - tile.col % diff) * r.invDiff;
+  return r;
+}
+const _extent = new Extent('EPSG:4326');
+const _extent2 = new Extent('EPSG:4326');
+const _c = new Coordinates('EPSG:4326', 0, 0);
+class Tile {
+  /**
+   * A tile is a geographical bounding rectangle uniquely defined by its zoom,
+   * row and column.
+   *
+   * @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;
+    let row = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    let col = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+    this.isTile = true;
+    this.crs = crs;
+    this.zoom = zoom;
+    this.row = row;
+    this.col = col;
+  }
+
+  /**
+   * 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);
+  }
+
+  /**
+   * 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) {
+    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Extent('EPSG:4326');
+    CRS.isValid(crs);
+    const {
+      epsg,
+      globalExtent,
+      globalDimension
+    } = getInfoTms(this.crs);
+    const countTiles = getCountTiles(this.crs, this.zoom);
+    _dimensionTile.set(1, 1).divide(countTiles).multiply(globalDimension);
+    target.west = globalExtent.west + (globalDimension.x - _dimensionTile.x * (countTiles.x - this.col));
+    target.east = target.west + _dimensionTile.x;
+    target.south = globalExtent.south + _dimensionTile.y * (countTiles.y - this.row - 1);
+    target.north = target.south + _dimensionTile.y;
+    target.crs = epsg;
+    return crs == epsg ? target : target.as(crs, target);
+  }
+
+  /**
+   * Checks whether another tile is inside this tile.
+   *
+   * @param extent - the tile to check.
+   */
+  isInside(tile) {
+    if (this.zoom == tile.zoom) {
+      return this.row == tile.row && this.col == tile.col;
+    } else if (this.zoom < tile.zoom) {
+      return false;
+    } else {
+      const r = _rowColfromParent(this, tile.zoom);
+      return r.row == tile.row && r.col == tile.col;
+    }
+  }
+
+  /**
+   * Returns the translation and scale to transform this tile to the input
+   * tile.
+   *
+   * @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');
+    }
+    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);
+  }
+
+  /**
+   * Returns the parent tile at the given level.
+   *
+   * @param levelParent - the level of the parent tile.
+   */
+  tiledExtentParent(levelParent) {
+    if (levelParent && levelParent < this.zoom) {
+      const r = _rowColfromParent(this, levelParent);
+      return new Tile(this.crs, levelParent, r.row, r.col);
+    } else {
+      return this;
+    }
+  }
+
+  /**
+   * Sets zoom, row and column values.
+   *
+   * @param zoom - zoom value.
+   * @param row - row value.
+   * @param col - column value.
+   */
+  set() {
+    let zoom = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+    let row = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    let col = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    this.zoom = zoom;
+    this.row = row;
+    this.col = col;
+    return this;
+  }
+
+  /**
+   * Copies the passed tile to this tile.
+   * @param tile - tile to copy.
+   */
+  copy(tile) {
+    this.crs = tile.crs;
+    return this.set(tile.zoom, tile.row, tile.col);
+  }
+
+  /**
+   * Return values of tile in string, separated by the separator input.
+   * @param separator - string separator
+   */
+  toString() {
+    let separator = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+    return `${this.zoom}${separator}${this.row}${separator}${this.col}`;
+  }
+}
+export function tiledCovering(e, tms) {
+  if (e.crs == 'EPSG:4326' && tms == 'EPSG:3857') {
+    const WMTS_PM = [];
+    const extent = _extent.copy(e).as(tms, _extent2);
+    const {
+      globalExtent,
+      globalDimension,
+      sTs
+    } = getInfoTms(tms);
+    extent.clampByExtent(globalExtent);
+    extent.planarDimensions(_dimensionTile);
+    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;
+    _tmsCoord.y = globalExtent.north - extent.north;
+    _tmsCoord.divide(globalDimension).multiply(countTiles).floor();
+
+    // ]N; N+1] => N
+    const maxRow = Math.ceil((globalExtent.north - extent.south) / globalDimension.x * countTiles.y) - 1;
+    for (let r = maxRow; r >= _tmsCoord.y; r--) {
+      WMTS_PM.push(new Tile(tms, zoom, r, _tmsCoord.x));
+    }
+    return WMTS_PM;
+  } else {
+    const target = new Tile(tms, 0, 0, 0);
+    const {
+      globalExtent,
+      globalDimension,
+      sTs,
+      isInverted
+    } = getInfoTms(e.crs);
+    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
+    // ... 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)
+    _tmsCoord.x = center.x - globalExtent.west;
+    _tmsCoord.y = isInverted ? globalExtent.north - center.y : center.y - globalExtent.south;
+    _tmsCoord.divide(globalDimension).multiply(countTiles).floor();
+    target.set(zoom, _tmsCoord.y, _tmsCoord.x);
+    return [target];
+  }
+}
+export default Tile;

package/lib/Core/Tile/TileGrid.js

@@ -0,0 +1,49 @@
+import * as THREE from 'three';
+import { Extent } from '@itowns/geographic';
+const _countTiles = new THREE.Vector2();
+const _dim = new THREE.Vector2();
+export const globalExtentTMS = new Map();
+export const schemeTiles = new Map();
+const extent4326 = new Extent('EPSG:4326', -180, 180, -90, 90);
+globalExtentTMS.set('EPSG:4326', extent4326);
+
+// Compute global extent of TMS in EPSG:3857
+// It's square whose a side is between -180° to 180°.
+// So, west extent, it's 180 convert in EPSG:3857
+const extent3857 = extent4326.as('EPSG:3857');
+extent3857.clampSouthNorth(extent3857.west, extent3857.east);
+globalExtentTMS.set('EPSG:3857', extent3857);
+const defaultScheme = new THREE.Vector2(1, 1);
+schemeTiles.set('EPSG:3857', defaultScheme);
+schemeTiles.set('EPSG:4326', new THREE.Vector2(2, 1));
+
+// 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) ?? 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.
+  // See link below for more information
+  // https://alastaira.wordpress.com/2011/07/06/converting-tms-tile-coordinates-to-googlebingosm-tile-coordinates/
+  // in crs includes ':NI' => tms isn't inverted (NOT INVERTED)
+  const isInverted = !crs.includes(':NI');
+  return {
+    epsg: crs,
+    globalExtent,
+    globalDimension,
+    sTs,
+    isInverted
+  };
+}
+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/Core/TileGeometry.js

@@ -0,0 +1,124 @@
+import * as THREE from 'three';
+import { computeBuffers, getBufferIndexSize } from "./Prefab/computeBufferTileGeometry.js";
+import { Coordinates } from '@itowns/geographic';
+function defaultBuffers(builder, params) {
+  const fullParams = {
+    disableSkirt: false,
+    hideSkirt: false,
+    buildIndexAndUv_0: true,
+    segments: 16,
+    coordinates: new Coordinates(builder.crs),
+    center: builder.center(params.extent).clone(),
+    ...params
+  };
+  const buffers = computeBuffers(builder, fullParams);
+  const bufferAttributes = {
+    index: buffers.index ? new THREE.BufferAttribute(buffers.index, 1) : null,
+    uvs: [...(buffers.uvs[0] ? [new THREE.BufferAttribute(buffers.uvs[0], 2)] : []), ...(buffers.uvs[1] ? [new THREE.BufferAttribute(buffers.uvs[1], 1)] : [])],
+    position: new THREE.BufferAttribute(buffers.position, 3),
+    normal: new THREE.BufferAttribute(buffers.normal, 3)
+  };
+  return bufferAttributes;
+}
+export class TileGeometry extends THREE.BufferGeometry {
+  /** Oriented Bounding Box of the tile geometry. */
+
+  /** Ground area covered by this tile geometry. */
+
+  /** Resolution of the tile geometry in segments per side. */
+
+  /**
+   * [TileGeometry] instances are shared between tiles. Since a geometry
+   * handles its own GPU resource, it needs a reference counter to dispose of
+   * that resource only when it is discarded by every single owner of a
+   * reference to the geometry.
+   */
+  // https://github.com/iTowns/itowns/pull/2440#discussion_r1860743294
+  // TODO: Remove nullability by reworking OBB:setFromExtent
+
+  constructor(builder, params) {
+    let bufferAttributes = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultBuffers(builder, params);
+    super();
+    this.extent = params.extent;
+    this.segments = params.segments;
+    this.setIndex(bufferAttributes.index);
+    this.setAttribute('position', bufferAttributes.position);
+    this.setAttribute('normal', bufferAttributes.normal);
+    this.setAttribute('uv', bufferAttributes.uvs[0]);
+    for (let i = 1; i < bufferAttributes.uvs.length; i++) {
+      this.setAttribute(`uv_${i}`, bufferAttributes.uvs[i]);
+    }
+    this.computeBoundingBox();
+    this.OBB = null;
+    if (params.hideSkirt) {
+      this.hideSkirt = params.hideSkirt;
+    }
+    this._refCount = null;
+  }
+
+  /**
+   * Enables or disables skirt rendering.
+   *
+   * @param toggle - Whether to hide the skirt; true hides, false shows.
+   */
+  set hideSkirt(toggle) {
+    this.setDrawRange(0, getBufferIndexSize(this.segments, toggle));
+  }
+
+  /**
+   * Initialize reference count for this geometry if it is currently null.
+   *
+   * @param cacheTile - The [Cache] used to store this geometry.
+   * @param keys - The [south, level, epsg] key of this geometry.
+   */
+  initRefCount(cacheTile, key) {
+    if (this._refCount !== null) {
+      return;
+    }
+    this._refCount = {
+      count: 0,
+      fn: () => {
+        this._refCount.count--;
+        if (this._refCount.count <= 0) {
+          // To avoid remove index buffer and attribute buffer uv
+          //  error un-bound buffer in webgl with VAO rendering.
+          // Could be removed if the attribute buffer deleting is
+          //  taken into account in the buffer binding state
+          //  (in THREE.WebGLBindingStates code).
+          this.index = null;
+          delete this.attributes.uv;
+          cacheTile.delete(key);
+          super.dispose();
+          // THREE.BufferGeometry.prototype.dispose.call(this);
+        }
+      }
+    };
+  }
+
+  /**
+   * Increase reference count.
+   *
+   * @throws If reference count has not been initialized.
+   */
+  increaseRefCount() {
+    if (this._refCount === null) {
+      throw new Error('[TileGeometry::increaseRefCount] ' + 'Tried to increment an unitialized reference count.');
+    }
+    this._refCount.count++;
+  }
+
+  /**
+   * The current reference count of this [TileGeometry] if it has been
+   * initialized.
+   */
+  get refCount() {
+    return this._refCount?.count;
+  }
+  dispose() {
+    if (this._refCount == null) {
+      super.dispose();
+    } else {
+      this._refCount.fn();
+    }
+  }
+}

package/lib/Core/TileMesh.js

@@ -0,0 +1,108 @@
+import * as THREE from 'three';
+import { geoidLayerIsVisible } from "../Layer/GeoidLayer.js";
+import { tiledCovering } from "./Tile/Tile.js";
+
+/**
+ * A TileMesh is a THREE.Mesh with a geometricError and an OBB
+ * The objectId property of the material is the with the id of the TileMesh
+ * @param {TileGeometry} geometry - the tile geometry
+ * @param {THREE.Material} material - a THREE.Material compatible with THREE.Mesh
+ * @param {Layer} layer - the layer the tile is added to
+ * @param {Extent} extent - the tile extent
+ * @param {?number} level - the tile level (default = 0)
+ */
+class TileMesh extends THREE.Mesh {
+  #_tms = (() => new Map())();
+  #visible = true;
+  constructor(geometry, material, layer, extent) {
+    let level = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
+    super(geometry, material);
+    if (!extent) {
+      throw new Error('extent is mandatory to build a TileMesh');
+    }
+    this.layer = layer;
+    this.extent = extent;
+    this.extent.zoom = level;
+    this.level = level;
+    this.material.objectId = this.id;
+    this.obb = this.geometry.OBB.clone();
+    this.boundingSphere = new THREE.Sphere();
+    this.obb.box3D.getBoundingSphere(this.boundingSphere);
+    for (const tms of layer.tileMatrixSets) {
+      this.#_tms.set(tms, tiledCovering(this.extent, tms));
+    }
+    this.frustumCulled = false;
+    this.matrixAutoUpdate = false;
+    this.rotationAutoUpdate = false;
+    this.layerUpdateState = {};
+    this.isTileMesh = true;
+    this.geoidHeight = 0;
+    this.link = {};
+    Object.defineProperty(this, 'visible', {
+      get() {
+        return this.#visible;
+      },
+      set(v) {
+        if (this.#visible != v) {
+          this.#visible = v;
+          this.dispatchEvent({
+            type: v ? 'shown' : 'hidden'
+          });
+        }
+      }
+    });
+  }
+  /**
+   * If specified, update the min and max elevation of the OBB
+   * and updates accordingly the bounding sphere and the geometric error
+   *
+   * @param {Object}  elevation
+   * @param {number}  [elevation.min]
+   * @param {number}  [elevation.max]
+   * @param {number}  [elevation.scale]
+   */
+  setBBoxZ(elevation) {
+    elevation.geoidHeight = geoidLayerIsVisible(this.layer) ? this.geoidHeight : 0;
+    this.obb.updateZ(elevation);
+    if (this.horizonCullingPointElevationScaled) {
+      this.horizonCullingPointElevationScaled.setLength(this.obb.z.delta + this.horizonCullingPoint.length());
+    }
+    this.obb.box3D.getBoundingSphere(this.boundingSphere);
+  }
+  getExtentsByProjection(crs) {
+    return this.#_tms.get(crs);
+  }
+
+  /**
+   * Search for a common ancestor between this tile and another one. It goes
+   * through parents on each side until one is found.
+   *
+   * @param {TileMesh} tile
+   *
+   * @return {TileMesh} the resulting common ancestor
+   */
+  findCommonAncestor(tile) {
+    if (!tile) {
+      return undefined;
+    }
+    if (tile.level == this.level) {
+      if (tile.id == this.id) {
+        return tile;
+      } else if (tile.level != 0) {
+        return this.parent.findCommonAncestor(tile.parent);
+      } else {
+        return undefined;
+      }
+    } else if (tile.level < this.level) {
+      return this.parent.findCommonAncestor(tile);
+    } else {
+      return this.findCommonAncestor(tile.parent);
+    }
+  }
+  onBeforeRender() {
+    if (this.material.layersNeedUpdate) {
+      this.material.updateLayersUniforms();
+    }
+  }
+}
+export default TileMesh;