@loaders.gl/tiles 5.0.0-alpha.12 → 5.0.0-alpha.13

package/src/tileset-3d/format-i3s/i3s-tileset-traverser.ts

@@ -1,102 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {TilesetTraverser} from '../common/tileset-traverser';
-
-import {getLodStatus} from '../helpers/i3s-lod';
-import {Tile3D} from '../common/tile-3d';
-import {I3STileManager} from './i3s-tile-manager';
-import {FrameState} from '../helpers/frame-state';
-
-export class I3STilesetTraverser extends TilesetTraverser {
-  private _tileManager: I3STileManager;
-
-  constructor(options) {
-    super(options);
-    this._tileManager = new I3STileManager();
-  }
-
-  /**
-   * Check if there are no penging tile header requests,
-   * that means the traversal is finished and we can call
-   * following-up callbacks.
-   */
-  traversalFinished(frameState: FrameState): boolean {
-    return !this._tileManager.hasPendingTiles(frameState.viewport.id, this._frameNumber || 0);
-  }
-
-  shouldRefine(tile, frameState: FrameState) {
-    tile._lodJudge = getLodStatus(tile, frameState);
-    return tile._lodJudge === 'DIG';
-  }
-
-  updateChildTiles(tile, frameState: FrameState): boolean {
-    const children = tile.header.children || [];
-    // children which are already fetched and constructed as Tile3D instances
-    const childTiles = tile.children;
-    for (const child of children) {
-      const extendedId = `${child.id}-${frameState.viewport.id}`;
-      // if child tile is not fetched
-      const childTile =
-        childTiles && childTiles.find(t => t.id === extendedId || t.header?.id === child.id);
-      if (!childTile) {
-        const request = () => this._loadTile(tile, child.id, frameState);
-        const cachedRequest = this._tileManager.find(extendedId);
-        if (!cachedRequest) {
-          this._tileManager.add(
-            request,
-            extendedId,
-            header => this._onTileLoad(header, tile, extendedId),
-            frameState
-          );
-        } else {
-          // update frameNumber since it is still needed in current frame
-          this._tileManager.update(extendedId, frameState);
-        }
-      } else if (childTile) {
-        // if child tile is fetched and available
-        this.updateTile(childTile, frameState);
-      }
-    }
-    return false;
-  }
-
-  async _loadTile(tile, nodeId, frameState) {
-    if (!tile.tileset.source.loadChildTileHeader) {
-      throw new Error('I3S source does not support child tile header loading');
-    }
-
-    return await tile.tileset.source.loadChildTileHeader(tile, nodeId, frameState);
-  }
-
-  /**
-   * The callback to init Tile3D instance after loading the tile JSON
-   * @param {Object} header - the tile JSON from a dataset
-   * @param {Tile3D} tile - the parent Tile3D instance
-   * @param {string} extendedId - optional ID to separate copies of a tile for different viewports.
-   *                              const extendedId = `${tile.id}-${frameState.viewport.id}`;
-   * @return {void}
-   */
-  _onTileLoad(header, tile, extendedId) {
-    if (header instanceof Error) {
-      tile.tileset._onSourceError(header, tile);
-      return;
-    }
-
-    // after child tile is fetched
-    const childTile = new Tile3D(tile.tileset, header, tile, extendedId);
-    tile.children.push(childTile);
-    const frameState = this._tileManager.find(childTile.id).frameState;
-    this.updateTile(childTile, frameState);
-
-    // after tile fetched, resume traversal if still in current update/traversal frame
-    if (
-      this._frameNumber === frameState.frameNumber &&
-      (this.traversalFinished(frameState) ||
-        new Date().getTime() - this.lastUpdate > this.updateDebounceTime)
-    ) {
-      this.executeTraversal(childTile, frameState);
-    }
-  }
-}

package/src/tileset-3d/helpers/3d-tiles-options.ts

@@ -1,11 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import type {Tileset3D} from '../common/tileset-3d';
-
-export function get3dTilesOptions(tileset: Tileset3D): {assetGltfUpAxis: 'X' | 'Y' | 'Z'} {
-  return {
-    assetGltfUpAxis: (tileset.asset && tileset.asset.gltfUpAxis) || 'Y'
-  };
-}

package/src/tileset-3d/helpers/bounding-volume.ts

@@ -1,281 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-
-// This file is derived from the Cesium code base under Apache 2 license
-// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
-
-/* eslint-disable */
-import {Quaternion, Vector3, Matrix3, Matrix4, degrees} from '@math.gl/core';
-import {BoundingSphere, OrientedBoundingBox} from '@math.gl/culling';
-import {Ellipsoid, makeOBBFromRegion} from '@math.gl/geospatial';
-import {assert} from '@loaders.gl/loader-utils';
-
-// const scratchProjectedBoundingSphere = new BoundingSphere();
-
-function defined(x) {
-  return x !== undefined && x !== null;
-}
-
-// const scratchMatrix = new Matrix3();
-const scratchPoint = new Vector3();
-const scratchScale = new Vector3();
-const identityTransform = new Matrix4();
-// const scratchRectangle = new Rectangle();
-// const scratchOrientedBoundingBox = new OrientedBoundingBox();
-// const scratchTransform = new Matrix4();
-
-/**
- * Create a bounding volume from the tile's bounding volume header.
- * @param {Object} boundingVolumeHeader The tile's bounding volume header.
- * @param {Matrix4} transform The current computed tile transform, including application transforms.
- * @param [result] The object onto which to store the result.
- * @param initialTransform The accumulated JSON tile transform, excluded from region transforms.
- * Defaults to transform so callers without application transforms keep geospatial regions fixed.
- * @returns The modified result parameter or a new TileBoundingVolume instance if none was provided.
- */
-export function createBoundingVolume(
-  boundingVolumeHeader,
-  transform: Matrix4,
-  result?,
-  initialTransform: Matrix4 = transform
-) {
-  assert(boundingVolumeHeader, '3D Tile: boundingVolume must be defined');
-
-  // boundingVolume schema:
-  // https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/schema/boundingVolume.schema.json
-  if (boundingVolumeHeader.box) {
-    // S2 cells and regions are geospatially anchored. Their conservative ECEF boxes are already
-    // world-space volumes and must not receive the tile/node transform a second time.
-    const boxTransform = boundingVolumeHeader.s2VolumeInfo ? identityTransform : transform;
-    return createBox(boundingVolumeHeader.box, boxTransform, result);
-  }
-  if (boundingVolumeHeader.region) {
-    const boundingVolume = makeOBBFromRegion(boundingVolumeHeader.region);
-    // Regions are already in world coordinates. Apply only the change from the JSON transform.
-    const regionTransform = transform.equals(initialTransform)
-      ? identityTransform
-      : transform.clone().multiplyRight(initialTransform.clone().invert());
-    return createBox(
-      [...boundingVolume.center, ...boundingVolume.halfAxes],
-      regionTransform,
-      result
-    );
-  }
-
-  if (boundingVolumeHeader.sphere) {
-    return createSphere(boundingVolumeHeader.sphere, transform, result);
-  }
-
-  throw new Error('3D Tile: boundingVolume must contain a sphere, region, or box');
-}
-
-/** [min, max] each in [longitude, latitude, altitude] */
-export type CartographicBounds = [min: number[], max: number[]];
-
-/**
- * Calculate the cartographic bounding box the tile's bounding volume.
- * @param {Object} boundingVolumeHeader The tile's bounding volume header.
- * @param {BoundingVolume} boundingVolume The bounding volume.
- * @param isRegionTransformed Whether application transforms moved the region from its JSON bounds.
- * @returns {CartographicBounds}
- */
-export function getCartographicBounds(
-  boundingVolumeHeader,
-  boundingVolume: OrientedBoundingBox | BoundingSphere,
-  isRegionTransformed = false
-): CartographicBounds {
-  // boundingVolume schema:
-  // https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/schema/boundingVolume.schema.json
-  if (boundingVolumeHeader.box || (boundingVolumeHeader.region && isRegionTransformed)) {
-    return orientedBoundingBoxToCartographicBounds(boundingVolume as OrientedBoundingBox);
-  }
-  if (boundingVolumeHeader.region) {
-    // [west, south, east, north, minimum height, maximum height]
-    // Latitudes and longitudes are in the WGS 84 datum as defined in EPSG 4979 and are in radians.
-    // Heights are in meters above (or below) the WGS 84 ellipsoid.
-    const [west, south, east, north, minHeight, maxHeight] = boundingVolumeHeader.region;
-
-    return [
-      [degrees(west), degrees(south), minHeight],
-      [degrees(east), degrees(north), maxHeight]
-    ];
-  }
-
-  if (boundingVolumeHeader.sphere) {
-    return boundingSphereToCartographicBounds(boundingVolume as BoundingSphere);
-  }
-
-  throw new Error('Unkown boundingVolume type');
-}
-
-function createBox(box, transform, result?) {
-  // https://math.gl/modules/culling/docs/api-reference/oriented-bounding-box
-  // 1. A half-axes based representation.
-  // box: An array of 12 numbers that define an oriented bounding box.
-  // The first three elements define the x, y, and z values for the center of the box.
-  // The next three elements (with indices 3, 4, and 5) define the x axis direction and half-length.
-  // The next three elements (indices 6, 7, and 8) define the y axis direction and half-length.
-  // The last three elements (indices 9, 10, and 11) define the z axis direction and half-length.
-  // 2. A half-size-quaternion based representation.
-  // box: An array of 10 numbers that define an oriented bounding box.
-  // The first three elements define the x, y, and z values for the center of the box in a right-handed 3-axis (x, y, z) Cartesian coordinate system where the z-axis is up.
-  // The next three elements (with indices 3, 4, and 5) define the halfSize.
-  // The last four elements (indices 6, 7, 8 and 10) define the quaternion.
-  const center = new Vector3(box[0], box[1], box[2]);
-  transform.transform(center, center);
-  let origin: number[] = [];
-  if (box.length === 10) {
-    const halfSize = box.slice(3, 6);
-    const quaternion = new Quaternion();
-    quaternion.fromArray(box, 6);
-    const x = new Vector3([1, 0, 0]);
-    const y = new Vector3([0, 1, 0]);
-    const z = new Vector3([0, 0, 1]);
-    x.transformByQuaternion(quaternion);
-    x.scale(halfSize[0]);
-    y.transformByQuaternion(quaternion);
-    y.scale(halfSize[1]);
-    z.transformByQuaternion(quaternion);
-    z.scale(halfSize[2]);
-    origin = [...x.toArray(), ...y.toArray(), ...z.toArray()];
-  } else {
-    origin = [...box.slice(3, 6), ...box.slice(6, 9), ...box.slice(9, 12)];
-  }
-  const xAxis = transform.transformAsVector(origin.slice(0, 3));
-  const yAxis = transform.transformAsVector(origin.slice(3, 6));
-  const zAxis = transform.transformAsVector(origin.slice(6, 9));
-  const halfAxes = new Matrix3([
-    xAxis[0],
-    xAxis[1],
-    xAxis[2],
-    yAxis[0],
-    yAxis[1],
-    yAxis[2],
-    zAxis[0],
-    zAxis[1],
-    zAxis[2]
-  ]);
-
-  if (defined(result)) {
-    result.center = center;
-    result.halfAxes = halfAxes;
-    return result;
-  }
-
-  return new OrientedBoundingBox(center, halfAxes);
-}
-
-function createSphere(sphere, transform, result?) {
-  // Find the transformed center
-  const center = new Vector3(sphere[0], sphere[1], sphere[2]);
-  transform.transform(center, center);
-  const scale = transform.getScale(scratchScale);
-
-  const uniformScale = Math.max(Math.max(scale[0], scale[1]), scale[2]);
-  const radius = sphere[3] * uniformScale;
-
-  if (defined(result)) {
-    result.center = center;
-    result.radius = radius;
-    return result;
-  }
-
-  return new BoundingSphere(center, radius);
-}
-
-/**
- * Convert a bounding volume defined by OrientedBoundingBox to cartographic bounds
- * @returns {CartographicBounds}
- */
-function orientedBoundingBoxToCartographicBounds(
-  boundingVolume: OrientedBoundingBox
-): CartographicBounds {
-  const result = emptyCartographicBounds();
-
-  const {halfAxes} = boundingVolume as OrientedBoundingBox;
-  const xAxis = new Vector3(halfAxes.getColumn(0));
-  const yAxis = new Vector3(halfAxes.getColumn(1));
-  const zAxis = new Vector3(halfAxes.getColumn(2));
-
-  // Test all 8 corners of the box
-  for (let x = 0; x < 2; x++) {
-    for (let y = 0; y < 2; y++) {
-      for (let z = 0; z < 2; z++) {
-        scratchPoint.copy(boundingVolume.center);
-        scratchPoint.add(xAxis);
-        scratchPoint.add(yAxis);
-        scratchPoint.add(zAxis);
-
-        addToCartographicBounds(result, scratchPoint);
-        zAxis.negate();
-      }
-      yAxis.negate();
-    }
-    xAxis.negate();
-  }
-  return result;
-}
-
-/**
- * Convert a bounding volume defined by BoundingSphere to cartographic bounds
- * @returns {CartographicBounds}
- */
-function boundingSphereToCartographicBounds(boundingVolume: BoundingSphere): CartographicBounds {
-  const result = emptyCartographicBounds();
-
-  const {center, radius} = boundingVolume as BoundingSphere;
-  const point = Ellipsoid.WGS84.scaleToGeodeticSurface(center, scratchPoint);
-
-  let zAxis: Vector3;
-  if (point) {
-    zAxis = Ellipsoid.WGS84.geodeticSurfaceNormal(point) as Vector3;
-  } else {
-    zAxis = new Vector3(0, 0, 1);
-  }
-  let xAxis = new Vector3(zAxis[2], -zAxis[1], 0);
-  if (xAxis.len() > 0) {
-    xAxis.normalize();
-  } else {
-    xAxis = new Vector3(0, 1, 0);
-  }
-  const yAxis = xAxis.clone().cross(zAxis);
-
-  // Test 6 end points of the 3 axes
-  for (const axis of [xAxis, yAxis, zAxis]) {
-    scratchScale.copy(axis).scale(radius);
-    for (let dir = 0; dir < 2; dir++) {
-      scratchPoint.copy(center);
-      scratchPoint.add(scratchScale);
-      addToCartographicBounds(result, scratchPoint);
-      // Flip the axis
-      scratchScale.negate();
-    }
-  }
-  return result;
-}
-
-/**
- * Create a new cartographic bounds that contains no points
- * @returns {CartographicBounds}
- */
-function emptyCartographicBounds(): CartographicBounds {
-  return [
-    [Infinity, Infinity, Infinity],
-    [-Infinity, -Infinity, -Infinity]
-  ];
-}
-
-/**
- * Add a point to the target cartographic bounds
- * @param {CartographicBounds} target
- * @param {Vector3} cartesian coordinates of the point to add
- */
-function addToCartographicBounds(target: CartographicBounds, cartesian: Readonly<Vector3>) {
-  Ellipsoid.WGS84.cartesianToCartographic(cartesian, scratchPoint);
-  target[0][0] = Math.min(target[0][0], scratchPoint[0]);
-  target[0][1] = Math.min(target[0][1], scratchPoint[1]);
-  target[0][2] = Math.min(target[0][2], scratchPoint[2]);
-
-  target[1][0] = Math.max(target[1][0], scratchPoint[0]);
-  target[1][1] = Math.max(target[1][1], scratchPoint[1]);
-  target[1][2] = Math.max(target[1][2], scratchPoint[2]);
-}