@loaders.gl/tiles 5.0.0-alpha.1 → 5.0.0-alpha.11

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

@@ -5,13 +5,15 @@
 import {path} from '@loaders.gl/loader-utils';
 import {Ellipsoid} from '@math.gl/geospatial';
 import {Vector3} from '@math.gl/core';
-import type {CoreAPI, LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';
+import type {CoreAPI, Loader, LoaderOptions} from '@loaders.gl/loader-utils';
 import type {Tile3D} from '../common/tile-3d';
 import {Tile3D as Tile3DNode} from '../common/tile-3d';
+import type {Tile3DContent} from '../common/tile-3d-contracts';
 import {I3STilesetTraverser} from './i3s-tileset-traverser';
 import type {Tileset3D} from '../common/tileset-3d';
 import type {FrameState} from '../helpers/frame-state';
 import type {
+  TileChildrenLoadResult,
   TileContentLoadResult,
   TilesetContentFormats,
   TilesetJSON,
@@ -25,6 +27,8 @@ import type {
 import {getZoomFromExtent, getZoomFromFullExtent} from '../helpers/zoom';
 import {TILESET_TYPE} from '../../constants';
 import type {TilesetTraverser, TilesetTraverserProps} from '../common/tileset-traverser';
+import {getI3SSpatialReference} from '../../spatial/format-spatial-reference';
+import {I3SSpatialTransformer} from '../../spatial/i3s-spatial-transformer';
 
 const EMPTY_CONTENT_FORMATS: TilesetContentFormats = {
   draco: false,
@@ -39,8 +43,10 @@ const EMPTY_CONTENT_FORMATS: TilesetContentFormats = {
 export class I3SSource implements Tileset3DSource {
   /** I3S format discriminator. */
   readonly type = TILESET_TYPE.I3S;
-  /** Loader used for tile metadata and content requests. */
-  readonly loader: LoaderWithParser;
+  /** Primary I3S loader used for root and child metadata requests. */
+  readonly loader: Loader;
+  /** Worker-capable loader used for binary tile content when supplied by the format loader. */
+  readonly contentLoader: Loader;
   /** Root I3S layer URL. */
   readonly url: string;
   /** Base path used for relative tile resource resolution. */
@@ -63,6 +69,10 @@ export class I3SSource implements Tileset3DSource {
   private readonly queryParams: Record<string, string> = {};
   private readonly resolver?: TilesetSourceResolver;
   private rootTileset: TilesetJSON;
+  /** Spatial adapter created lazily after Tileset3D applies target options. */
+  private spatialTransformer?: I3SSpatialTransformer;
+  /** Root header prepared after asynchronous elevation sampling. */
+  private preparedRootHeader?: any;
 
   /**
    * Creates an I3S source.
@@ -74,11 +84,13 @@ export class I3SSource implements Tileset3DSource {
     this.rootTileset = isTilesetRequest(input) ? null : input;
     this.tileset = this.rootTileset;
     this.loader = request.loader;
+    this.contentLoader = getI3SContentLoader(request.loader);
     this.url = request.url;
     this.basePath = request.basePath || path.dirname(request.url);
     this.resolver = request.resolver;
     this.coreApi = request.coreApi;
     this.loadOptions = loadOptions;
+    this.initializeQueryParams(loadOptions);
   }
 
   /**
@@ -86,7 +98,10 @@ export class I3SSource implements Tileset3DSource {
    */
   async initialize(): Promise<void> {
     if (!this.rootTileset) {
-      this.rootTileset = await this.loadRootData(this.url, this.loadOptions);
+      this.rootTileset = await this.loadRootData(this.getTileUrl(this.url), {
+        ...this.loadOptions,
+        i3s: {...(this.loadOptions.i3s as Record<string, unknown>), isTileset: true}
+      });
     }
     this.tileset = this.rootTileset;
 
@@ -94,14 +109,6 @@ export class I3SSource implements Tileset3DSource {
       this.rootTileset.root = await this.rootTileset.root;
     }
 
-    const i3sOptions = this.loadOptions.i3s;
-    if (i3sOptions && typeof i3sOptions === 'object' && 'token' in i3sOptions) {
-      const token = (i3sOptions as Record<string, unknown>).token;
-      if (typeof token === 'string') {
-        this.queryParams.token = token;
-      }
-    }
-
     this.metadata = {
       type: this.type,
       loader: this.loader,
@@ -110,7 +117,8 @@ export class I3SSource implements Tileset3DSource {
       tileset: this.rootTileset,
       lodMetricType: this.rootTileset.lodMetricType,
       lodMetricValue: this.rootTileset.lodMetricValue,
-      refine: this.rootTileset.root?.refine
+      refine: this.rootTileset.root?.refine,
+      spatialReference: getI3SSpatialReference(this.rootTileset)
     };
   }
 
@@ -131,6 +139,26 @@ export class I3SSource implements Tileset3DSource {
     return this.getMetadata().tileset;
   }
 
+  /** Prepare option-dependent spatial state and the asynchronously placed root bound. */
+  async prepareTileset(tileset: Tileset3D): Promise<void> {
+    const spatialReference = tileset.spatialReference;
+    if (spatialReference.status === 'unresolved') {
+      throw new Error(
+        spatialReference.warnings[0] ||
+          'I3S spatial operations cannot be resolved from the supplied metadata and options'
+      );
+    }
+    if (spatialReference.status !== 'transformable' && spatialReference.status !== 'transformed') {
+      return;
+    }
+    this.spatialTransformer ||= new I3SSpatialTransformer(
+      spatialReference,
+      tileset.options.spatial
+    );
+    tileset.spatialReference = this.spatialTransformer.spatialReference;
+    this.preparedRootHeader = await this.transformTileHeader(this.getMetadata().tileset.root);
+  }
+
   /**
    * Creates the runtime root tile for an I3S subtree.
    */
@@ -139,7 +167,11 @@ export class I3SSource implements Tileset3DSource {
     tilesetJson: TilesetJSON,
     parentTile?: Tile3D | null
   ): Tile3D {
-    const rootTile = new Tile3DNode(tileset, tilesetJson.root, parentTile || undefined);
+    const rootHeader = parentTile ? tilesetJson.root : this.preparedRootHeader || tilesetJson.root;
+    if (this.spatialTransformer && !this.preparedRootHeader) {
+      throw new Error('I3S spatial root header was not prepared before tile initialization');
+    }
+    const rootTile = new Tile3DNode(tileset, rootHeader, parentTile || undefined);
     if (parentTile) {
       parentTile.children.push(rootTile);
       rootTile.depth = parentTile.depth + 1;
@@ -170,23 +202,39 @@ export class I3SSource implements Tileset3DSource {
         _tileOptions: {
           attributeUrls: tile.header.attributeUrls,
           textureUrl: tile.header.textureUrl,
+          textureUrls: tile.header.textureUrls,
           textureFormat: tile.header.textureFormat,
           textureLoaderOptions: tile.header.textureLoaderOptions,
           materialDefinition: tile.header.materialDefinition,
+          layerType: tile.header.layerType,
+          pointRenderer: tile.header.pointRenderer,
+          pointSymbol: tile.header.pointSymbol,
           isDracoGeometry: tile.header.isDracoGeometry,
           mbs: tile.header.mbs
         },
         _tilesetOptions: {
           store: metadata.tileset.store,
           attributeStorageInfo: metadata.tileset.attributeStorageInfo,
-          fields: metadata.tileset.fields
+          fields: metadata.tileset.fields,
+          spatialReference: tile.tileset.spatialReference,
+          spatialOptions: tile.tileset.options.spatial
         },
         isTileHeader: false
       }
     };
 
-    tile.content = await this.loadResourceData(contentUrl, options);
-    return {loaded: true};
+    tile.content = await this.loadResourceData(contentUrl, options, this.contentLoader);
+    const contentEntry: Tile3DContent = {
+      index: 0,
+      uri: tile.contentUrl,
+      type: tile.header.layerType,
+      payload: tile.content,
+      metadata: tile.header.metadata || null,
+      boundingVolume: tile.boundingVolume,
+      featureIds: tile.featureIdSets,
+      renderable: Boolean(tile.content)
+    };
+    return {loaded: true, contents: [tile.content], contentEntries: [contentEntry]};
   }
 
   /**
@@ -195,11 +243,12 @@ export class I3SSource implements Tileset3DSource {
   async loadChildTileHeader(
     _parentTile: Tile3D,
     childId: string,
-    _frameState: FrameState
+    _frameState: FrameState | null
   ): Promise<any> {
     const metadata = this.getMetadata();
-    if (metadata.tileset.nodePages) {
-      return await metadata.tileset.nodePagesTile.formTileFromNodePages(childId);
+    if (metadata.tileset.nodePages || metadata.tileset.pointNodePages) {
+      const header = await metadata.tileset.nodePagesTile.formTileFromNodePages(childId);
+      return await this.transformTileHeader(header);
     }
 
     const nodeUrl = this.getTileUrl(`${this.url}/nodes/${childId}`);
@@ -215,7 +264,52 @@ export class I3SSource implements Tileset3DSource {
       }
     };
 
-    return await this.loadResourceData(nodeUrl, options);
+    const header = await this.loadResourceData(nodeUrl, options);
+    return await this.transformTileHeader(header);
+  }
+
+  /** Loads all declared I3S child headers without camera or visibility state. */
+  async loadTileChildrenForTraversal(
+    parentTile: Tile3D,
+    signal?: AbortSignal
+  ): Promise<TileChildrenLoadResult> {
+    const childHeaders = parentTile.header.children || [];
+    let loadedChildren = 0;
+    const orderedChildren: Tile3D[] = [];
+
+    for (const childHeader of childHeaders) {
+      throwIfTraversalAborted(signal);
+      const childId = childHeader.id;
+      if (typeof childId !== 'string' && typeof childId !== 'number') {
+        throw new Error('I3S child header is missing its node ID');
+      }
+      const existingChild = parentTile.children.find(
+        tile => tile.id === String(childId) || tile.header?.id === childId
+      );
+      if (existingChild) {
+        orderedChildren.push(existingChild);
+        continue;
+      }
+
+      const childTileHeader = await this.loadChildTileHeader(parentTile, String(childId), null);
+      throwIfTraversalAborted(signal);
+      const childTile = new Tile3DNode(
+        parentTile.tileset,
+        childTileHeader,
+        parentTile,
+        String(childId)
+      );
+      orderedChildren.push(childTile);
+      loadedChildren++;
+    }
+
+    const orderedChildSet = new Set(orderedChildren);
+    parentTile.children = [
+      ...orderedChildren,
+      ...parentTile.children.filter(childTile => !orderedChildSet.has(childTile))
+    ];
+
+    return {loaded: true, tileCount: loadedChildren, childSubtreeCount: 0};
   }
 
   /**
@@ -230,14 +324,52 @@ export class I3SSource implements Tileset3DSource {
       return tilePath;
     }
 
-    const queryParams = new URLSearchParams(this.queryParams).toString();
-    return `${tilePath}${tilePath.includes('?') ? '&' : '?'}${queryParams}`;
+    const hashIndex = tilePath.indexOf('#');
+    const hash = hashIndex >= 0 ? tilePath.slice(hashIndex) : '';
+    const tilePathWithoutHash = hashIndex >= 0 ? tilePath.slice(0, hashIndex) : tilePath;
+    const queryDelimiterIndex = tilePathWithoutHash.indexOf('?');
+    const path =
+      queryDelimiterIndex === -1
+        ? tilePathWithoutHash
+        : tilePathWithoutHash.slice(0, queryDelimiterIndex);
+    const existingQuery =
+      queryDelimiterIndex === -1 ? '' : tilePathWithoutHash.slice(queryDelimiterIndex + 1);
+    const existingQueryParams = new URLSearchParams(existingQuery);
+    const queryParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(this.queryParams)) {
+      if (!existingQueryParams.has(key)) {
+        queryParams.set(key, value);
+      }
+    }
+
+    const queryString = queryParams.toString();
+    return `${path}${existingQuery ? `?${existingQuery}` : ''}${
+      queryString ? `${existingQuery ? '&' : '?'}${queryString}` : ''
+    }${hash}`;
   }
 
   /**
    * Derives the default view state from full extent or store extent metadata.
    */
-  getViewState(_rootTile: Tile3D | null): TilesetSourceViewState {
+  getViewState(rootTile: Tile3D | null): TilesetSourceViewState {
+    if (this.spatialTransformer && rootTile) {
+      const center = new Vector3(rootTile.boundingVolume.center);
+      const cartographicCenter = new Vector3(rootTile.header.i3sLodMbs.slice(0, 3));
+      if (this.spatialTransformer.targetCoordinateFrame === 'geographic') {
+        return {
+          boundingVolume: rootTile.boundingVolume,
+          cartographicCenter,
+          cartesianCenter: center,
+          zoom: 1
+        };
+      }
+      return {
+        boundingVolume: rootTile.boundingVolume,
+        cartographicCenter,
+        cartesianCenter: center,
+        zoom: 1
+      };
+    }
     const metadata = this.getMetadata();
     const fullExtent = metadata.tileset.fullExtent;
     if (fullExtent) {
@@ -306,12 +438,16 @@ export class I3SSource implements Tileset3DSource {
   /**
    * Loads data through injected core APIs so this module stays independent from `@loaders.gl/core`.
    */
-  private async loadWithCoreApi(url: string, options: LoaderOptions): Promise<any> {
+  private async loadWithCoreApi(
+    url: string,
+    options: LoaderOptions,
+    loader: Loader = this.loader
+  ): Promise<any> {
     if (!this.coreApi) {
       throw new Error('I3SSource requires an injected coreApi to load tileset data');
     }
 
-    return await this.coreApi.load(url, this.loader, options);
+    return await this.coreApi.load(url, loader, options);
   }
 
   /**
@@ -325,18 +461,73 @@ export class I3SSource implements Tileset3DSource {
     return await this.loadWithCoreApi(url, options);
   }
 
+  /**
+   * Initializes query parameters before any URL-backed resource is requested.
+   * @param loadOptions Loader options that may contain an ArcGIS token.
+   */
+  private initializeQueryParams(loadOptions: LoaderOptions): void {
+    for (const [key, value] of Object.entries(loadOptions.searchParams || {})) {
+      this.queryParams[key] = String(value);
+    }
+
+    const i3sOptions = loadOptions.i3s;
+    if (i3sOptions && typeof i3sOptions === 'object' && 'token' in i3sOptions) {
+      const token = (i3sOptions as Record<string, unknown>).token;
+      if (typeof token === 'string') {
+        this.queryParams.token = token;
+      }
+    }
+  }
+
   /**
    * Loads tile metadata or content through an injected resolver when present, otherwise through the injected core API.
    */
-  private async loadResourceData(url: string, options: LoaderOptions): Promise<any> {
+  private async loadResourceData(
+    url: string,
+    options: LoaderOptions,
+    loader: Loader = this.loader
+  ): Promise<any> {
     if (this.resolver) {
-      return await this.resolver.loadResource(url, this.loader, options);
+      return await this.resolver.loadResource(url, loader, options);
     }
 
-    return await this.loadWithCoreApi(url, options);
+    return await this.loadWithCoreApi(url, options, loader);
+  }
+
+  /** Transform one I3S header bound after target options and elevation providers are available. */
+  private async transformTileHeader(header: any): Promise<any> {
+    if (!this.spatialTransformer) {
+      return header;
+    }
+    const sourceBounds = {
+      mbs: header.mbs,
+      obb: header.obb,
+      normalReferenceFrame: this.getMetadata().tileset.store?.normalReferenceFrame
+    };
+    const transformedBounds = await this.spatialTransformer.transformBoundsAsync(sourceBounds);
+    return {
+      ...header,
+      // Tileset3D traversal and culling operate in WGS84 ECEF independently of content output.
+      boundingVolume: transformedBounds.boundingVolume,
+      // Preserve the renderer/output-frame bound for applications and content coordination.
+      spatialBoundingVolume: transformedBounds.spatialBoundingVolume,
+      i3sLodMbs: transformedBounds.i3sLodMbs
+    };
   }
 }
 
+/** Throws a cancellation reason before or after source-managed traversal work. */
+function throwIfTraversalAborted(signal?: AbortSignal): void {
+  if (signal?.aborted) {
+    throw signal.reason ?? new DOMException('The operation was aborted', 'AbortError');
+  }
+}
+
+/** Returns the format-provided binary content loader, falling back for custom legacy loaders. */
+function getI3SContentLoader(loader: Loader): Loader {
+  return (loader as Loader & {contentLoader?: Loader}).contentLoader || loader;
+}
+
 function isTilesetRequest(input: TilesetSourceInput): input is TilesetSourceRequest {
   return Boolean(
     input && typeof input === 'object' && 'url' in input && 'loader' in input && !('type' in input)

package/src/tileset-3d/format-i3s/i3s-tile-manager.ts

@@ -1,3 +1,7 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import {FrameState} from '../helpers/frame-state';
 import {I3SPendingTilesRegister} from './i3s-pending-tiles-register';
 

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

@@ -1,3 +1,7 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import {TilesetTraverser} from '../common/tileset-traverser';
 
 import {getLodStatus} from '../helpers/i3s-lod';
@@ -34,7 +38,8 @@ export class I3STilesetTraverser extends TilesetTraverser {
     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);
+      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);

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

@@ -1,3 +1,7 @@
+// 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'} {

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

@@ -1,10 +1,12 @@
+// 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} from '@math.gl/geospatial';
+import {Ellipsoid, makeOBBFromRegion} from '@math.gl/geospatial';
 import {assert} from '@loaders.gl/loader-utils';
 
 // const scratchProjectedBoundingSphere = new BoundingSphere();
@@ -16,12 +18,7 @@ function defined(x) {
 // const scratchMatrix = new Matrix3();
 const scratchPoint = new Vector3();
 const scratchScale = new Vector3();
-const scratchNorthWest = new Vector3();
-const scratchSouthEast = new Vector3();
-const scratchCenter = new Vector3();
-const scratchXAxis = new Vector3();
-const scratchYAxis = new Vector3();
-const scratchZAxis = new Vector3();
+const identityTransform = new Matrix4();
 // const scratchRectangle = new Rectangle();
 // const scratchOrientedBoundingBox = new OrientedBoundingBox();
 // const scratchTransform = new Matrix4();
@@ -29,20 +26,39 @@ const scratchZAxis = new Vector3();
 /**
  * Create a bounding volume from the tile's bounding volume header.
  * @param {Object} boundingVolumeHeader The tile's bounding volume header.
- * @param {Matrix4} transform The transform to apply to the bounding volume.
+ * @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, result?) {
+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) {
-    return createBox(boundingVolumeHeader.box, transform, result);
+    // 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) {
-    return createObbFromRegion(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) {
@@ -59,15 +75,17 @@ 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
+  boundingVolume: OrientedBoundingBox | BoundingSphere,
+  isRegionTransformed = false
 ): CartographicBounds {
   // boundingVolume schema:
   // https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/schema/boundingVolume.schema.json
-  if (boundingVolumeHeader.box) {
+  if (boundingVolumeHeader.box || (boundingVolumeHeader.region && isRegionTransformed)) {
     return orientedBoundingBoxToCartographicBounds(boundingVolume as OrientedBoundingBox);
   }
   if (boundingVolumeHeader.region) {
@@ -146,61 +164,6 @@ function createBox(box, transform, result?) {
   return new OrientedBoundingBox(center, halfAxes);
 }
 
-/*
-function createBoxFromTransformedRegion(region, transform, initialTransform, result) {
-  const rectangle = Rectangle.unpack(region, 0, scratchRectangle);
-  const minimumHeight = region[4];
-  const maximumHeight = region[5];
-
-  const orientedBoundingBox = OrientedBoundingBox.fromRectangle(
-    rectangle,
-    minimumHeight,
-    maximumHeight,
-    Ellipsoid.WGS84,
-    scratchOrientedBoundingBox
-  );
-  const center = orientedBoundingBox.center;
-  const halfAxes = orientedBoundingBox.halfAxes;
-
-  // A region bounding volume is not transformed by the transform in the tileset JSON,
-  // but may be transformed by additional transforms applied in Cesium.
-  // This is why the transform is calculated as the difference between the initial transform and the current transform.
-  transform = Matrix4.multiplyTransformation(
-    transform,
-    Matrix4.inverseTransformation(initialTransform, scratchTransform),
-    scratchTransform
-  );
-  center = Matrix4.multiplyByPoint(transform, center, center);
-  const rotationScale = Matrix4.getRotation(transform, scratchMatrix);
-  halfAxes = Matrix3.multiply(rotationScale, halfAxes, halfAxes);
-
-  if (defined(result) && result instanceof TileOrientedBoundingBox) {
-    result.update(center, halfAxes);
-    return result;
-  }
-
-  return new TileOrientedBoundingBox(center, halfAxes);
-}
-
-function createRegion(region, transform, initialTransform, result) {
-  if (!Matrix4.equalsEpsilon(transform, initialTransform, CesiumMath.EPSILON8)) {
-    return createBoxFromTransformedRegion(region, transform, initialTransform, result);
-  }
-
-  if (defined(result)) {
-    return result;
-  }
-
-  const rectangleRegion = Rectangle.unpack(region, 0, scratchRectangle);
-
-  return new TileBoundingRegion({
-    rectangle: rectangleRegion,
-    minimumHeight: region[4],
-    maximumHeight: region[5]
-  });
-}
-*/
-
 function createSphere(sphere, transform, result?) {
   // Find the transformed center
   const center = new Vector3(sphere[0], sphere[1], sphere[2]);
@@ -219,52 +182,6 @@ function createSphere(sphere, transform, result?) {
   return new BoundingSphere(center, radius);
 }
 
-/**
- * Create OrientedBoundingBox instance from region 3D tiles bounding volume
- * @param region - region 3D tiles bounding volume
- * @returns OrientedBoundingBox instance
- */
-function createObbFromRegion(region: number[]): OrientedBoundingBox {
-  // [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] = region;
-
-  const northWest = Ellipsoid.WGS84.cartographicToCartesian(
-    [degrees(west), degrees(north), minHeight],
-    scratchNorthWest
-  );
-  const southEast = Ellipsoid.WGS84.cartographicToCartesian(
-    [degrees(east), degrees(south), maxHeight],
-    scratchSouthEast
-  );
-  const centerInCartesian = new Vector3().addVectors(northWest, southEast).multiplyByScalar(0.5);
-  Ellipsoid.WGS84.cartesianToCartographic(centerInCartesian, scratchCenter);
-
-  Ellipsoid.WGS84.cartographicToCartesian(
-    [degrees(east), scratchCenter[1], scratchCenter[2]],
-    scratchXAxis
-  );
-  Ellipsoid.WGS84.cartographicToCartesian(
-    [scratchCenter[0], degrees(north), scratchCenter[2]],
-    scratchYAxis
-  );
-  Ellipsoid.WGS84.cartographicToCartesian(
-    [scratchCenter[0], scratchCenter[1], maxHeight],
-    scratchZAxis
-  );
-
-  return createBox(
-    [
-      ...centerInCartesian,
-      ...scratchXAxis.subtract(centerInCartesian),
-      ...scratchYAxis.subtract(centerInCartesian),
-      ...scratchZAxis.subtract(centerInCartesian)
-    ],
-    new Matrix4()
-  );
-}
-
 /**
  * Convert a bounding volume defined by OrientedBoundingBox to cartographic bounds
  * @returns {CartographicBounds}