@loaders.gl/3d-tiles 4.0.0-alpha.5 → 4.0.0-alpha.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/3d-tiles",
-  "version": "4.0.0-alpha.5",
+  "version": "4.0.0-alpha.6",
   "description": "3D Tiles, an open standard for streaming massive heterogeneous 3D geospatial datasets.",
   "license": "MIT",
   "publishConfig": {
@@ -21,8 +21,8 @@
     "pointcloud"
   ],
   "types": "dist/index.d.ts",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
+  "main": "dist/es5/index.js",
+  "module": "dist/esm/index.js",
   "sideEffects": false,
   "files": [
     "src",
@@ -34,16 +34,17 @@
     "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/dist.min.js"
   },
   "dependencies": {
-    "@loaders.gl/draco": "4.0.0-alpha.5",
-    "@loaders.gl/gltf": "4.0.0-alpha.5",
-    "@loaders.gl/loader-utils": "4.0.0-alpha.5",
-    "@loaders.gl/math": "4.0.0-alpha.5",
-    "@loaders.gl/tiles": "4.0.0-alpha.5",
+    "@loaders.gl/draco": "4.0.0-alpha.6",
+    "@loaders.gl/gltf": "4.0.0-alpha.6",
+    "@loaders.gl/loader-utils": "4.0.0-alpha.6",
+    "@loaders.gl/math": "4.0.0-alpha.6",
+    "@loaders.gl/tiles": "4.0.0-alpha.6",
     "@math.gl/core": "^3.5.1",
-    "@math.gl/geospatial": "^3.5.1"
+    "@math.gl/geospatial": "^3.5.1",
+    "long": "^5.2.1"
   },
   "peerDependencies": {
-    "@loaders.gl/core": "4.0.0-alpha.4"
+    "@loaders.gl/core": "4.0.0-alpha.5"
   },
-  "gitHead": "7a71a54bdf1ddf985cc3af3db90b82e7fa97d025"
+  "gitHead": "acc1985050dfaa0f1f0c066f8da5bce7454a046c"
 }

package/src/cesium-ion-loader.ts

@@ -33,6 +33,7 @@ export const CesiumIonLoader: LoaderWithParser = {
   },
   options: {
     'cesium-ion': {
+      // @ts-expect-error
       ...Tiles3DLoader.options['3d-tiles'],
       accessToken: null
     }

package/src/index.ts

@@ -13,4 +13,4 @@ export {default as Tile3DBatchTable} from './lib/classes/tile-3d-batch-table';
 // EXPERIMENTAL
 export {TILE3D_TYPE} from './lib/constants';
 export {getIonTilesetMetadata as _getIonTilesetMetadata} from './lib/ion/ion';
-export type {BatchTableJson, B3DMContent, Node3D} from './types';
+export type {FeatureTableJson, B3DMContent, Node3D, ImplicitTilingExtension} from './types';

package/src/lib/parsers/helpers/parse-3d-implicit-tiles.ts

@@ -2,6 +2,11 @@ import type {Availability, BoundingVolume, Subtree} from '../../../types';
 import {Tile3DSubtreeLoader} from '../../../tile-3d-subtree-loader';
 import {load} from '@loaders.gl/core';
 
+import {getS2CellIdFromToken, getS2ChildCellId, getS2TokenFromCellId} from '../../utils/s2/index';
+import type {S2VolumeInfo} from '../../utils/obb/s2-corners-to-obb';
+import {convertS2BoundingVolumetoOBB} from '../../utils/obb/s2-corners-to-obb';
+import Long from 'long';
+
 const QUADTREE_DEVISION_COUNT = 4;
 const OCTREE_DEVISION_COUNT = 8;
 
@@ -10,6 +15,59 @@ const SUBDIVISION_COUNT_MAP = {
   OCTREE: OCTREE_DEVISION_COUNT
 };
 
+/**
+ *  S2VolumeBox is an extention of BoundingVolume of type "box"
+ */
+export type S2VolumeBox = {
+  /** BoundingVolume of type "box" has the "box" field. S2VolumeBox contains it as well. */
+  box: number[];
+  /** s2VolumeInfo provides additional info about the box - specifically the token, min and max height */
+  s2VolumeInfo: S2VolumeInfo;
+};
+
+function getChildS2VolumeBox(
+  s2VolumeBox: S2VolumeBox | undefined,
+  index: number,
+  subdivisionScheme: string
+): S2VolumeBox | undefined {
+  if (s2VolumeBox?.box) {
+    // Check if the BoundingVolume is of type "box"
+    const cellId: Long = getS2CellIdFromToken(s2VolumeBox.s2VolumeInfo.token);
+    const childCellId = getS2ChildCellId(cellId, index);
+    const childToken = getS2TokenFromCellId(childCellId);
+
+    // Clone object. Note, s2VolumeInfo is a plain object that doesn't contain any nested object.
+    // So, we can use the Spread Operator to make a shallow copy of the object.
+    const s2ChildVolumeInfo: S2VolumeInfo = {...s2VolumeBox.s2VolumeInfo};
+    s2ChildVolumeInfo.token = childToken; // replace the token with the child's one
+
+    // In case of QUADTREE the sizeZ should NOT be changed!
+    // https://portal.ogc.org/files/102132
+    // A quadtree divides space only on the x and y dimensions.
+    // It divides each tile into 4 smaller tiles where the x and y dimensions are halved.
+    // The quadtree z minimum and maximum remain unchanged.
+    switch (subdivisionScheme) {
+      case 'OCTREE':
+        const s2VolumeInfo: S2VolumeInfo = s2VolumeBox.s2VolumeInfo;
+        const delta = s2VolumeInfo.maximumHeight - s2VolumeInfo.minimumHeight;
+        const sizeZ: number = delta / 2.0; // It's a next level (a child)
+        const midZ: number = s2VolumeInfo.minimumHeight + delta / 2.0;
+        s2VolumeInfo.minimumHeight = midZ - sizeZ;
+        s2VolumeInfo.maximumHeight = midZ + sizeZ;
+        break;
+      default:
+        break;
+    }
+    const box = convertS2BoundingVolumetoOBB(s2ChildVolumeInfo);
+    const childS2VolumeBox: S2VolumeBox = {
+      box,
+      s2VolumeInfo: s2ChildVolumeInfo
+    };
+    return childS2VolumeBox;
+  }
+  return undefined;
+}
+
 /**
  * Recursively parse implicit tiles tree
  * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling
@@ -30,6 +88,7 @@ export async function parseImplicitTiles(params: {
   childIndex?: number;
   level?: number;
   globalData?: {level: number; mortonIndex: number; x: number; y: number; z: number};
+  s2VolumeBox?: S2VolumeBox;
 }) {
   const {
     options,
@@ -46,7 +105,8 @@ export async function parseImplicitTiles(params: {
       x: 0,
       y: 0,
       z: 0
-    }
+    },
+    s2VolumeBox
   } = params;
   let {subtree, level = 0} = params;
   const {
@@ -75,15 +135,6 @@ export async function parseImplicitTiles(params: {
   let childTileY = concatBits(parentData.y, childY);
   let childTileZ = concatBits(parentData.z, childZ);
 
-  // TODO Remove after real implicit tileset will be tested.
-  // Degug data
-  // tile.level = level + globalData.level;
-  // tile.x = concatBits(globalData.x, childTileX);
-  // tile.y = concatBits(globalData.y, childTileY);
-  // tile.z = concatBits(globalData.z, childTileZ);
-  // tile.mortonIndex = childTileMortonIndex;
-  // End of debug data
-
   let isChildSubtreeAvailable = false;
 
   if (level + 1 > subtreeLevels) {
@@ -138,19 +189,33 @@ export async function parseImplicitTiles(params: {
   const pData = {mortonIndex: childTileMortonIndex, x: childTileX, y: childTileY, z: childTileZ};
 
   for (let index = 0; index < childrenPerTile; index++) {
-    const currentTile = await parseImplicitTiles({
+    const childS2VolumeBox: S2VolumeBox | undefined = getChildS2VolumeBox(
+      s2VolumeBox,
+      index,
+      subdivisionScheme
+    );
+
+    // Recursive calling...
+    const childTileParsed = await parseImplicitTiles({
       subtree,
       options,
       parentData: pData,
       childIndex: index,
       level: childTileLevel,
-      globalData
+      globalData,
+      s2VolumeBox: childS2VolumeBox
     });
 
-    if (currentTile.contentUrl || currentTile.children.length) {
+    if (childTileParsed.contentUrl || childTileParsed.children.length) {
       const globalLevel = lev + 1;
       const childCoordinates = {childTileX, childTileY, childTileZ};
-      const formattedTile = formatTileData(currentTile, globalLevel, childCoordinates, options);
+      const formattedTile = formatTileData(
+        childTileParsed,
+        globalLevel,
+        childCoordinates,
+        options,
+        s2VolumeBox
+      );
       // @ts-ignore
       tile.children.push(formattedTile);
     }
@@ -183,7 +248,8 @@ function formatTileData(
   tile,
   level: number,
   childCoordinates: {childTileX: number; childTileY: number; childTileZ: number},
-  options: any
+  options: any,
+  s2VolumeBox?: S2VolumeBox
 ) {
   const {
     basePath,
@@ -196,9 +262,14 @@ function formatTileData(
   } = options;
   const uri = tile.contentUrl && tile.contentUrl.replace(`${basePath}/`, '');
   const lodMetricValue = rootLodMetricValue / 2 ** level;
-  const boundingVolume = calculateBoundingVolumeForChildTile(
+
+  const boundingVolume: BoundingVolume = s2VolumeBox?.box
+    ? {box: s2VolumeBox.box}
+    : rootBoundingVolume;
+
+  const boundingVolumeForChildTile = calculateBoundingVolumeForChildTile(
     level,
-    rootBoundingVolume,
+    boundingVolume,
     childCoordinates
   );
 
@@ -211,12 +282,9 @@ function formatTileData(
     type: getTileType(tile),
     lodMetricType,
     lodMetricValue,
-    boundingVolume
-    // Temp debug values. Remove when real implicit tileset will be tested.
-    // x: tile.x,
-    // y: tile.y,
-    // z: tile.z,
-    // level: tile.level
+    geometricError: lodMetricValue,
+    transform: tile.transform,
+    boundingVolume: boundingVolumeForChildTile
   };
 }
 
@@ -231,7 +299,7 @@ function calculateBoundingVolumeForChildTile(
   level: number,
   rootBoundingVolume: BoundingVolume,
   childCoordinates: {childTileX: number; childTileY: number; childTileZ: number}
-): BoundingVolume | null {
+): BoundingVolume {
   if (rootBoundingVolume.region) {
     const {childTileX, childTileY, childTileZ} = childCoordinates;
     const [west, south, east, north, minimumHeight, maximumHeight] = rootBoundingVolume.region;
@@ -239,6 +307,13 @@ function calculateBoundingVolumeForChildTile(
 
     const sizeX = (east - west) / boundingVolumesCount;
     const sizeY = (north - south) / boundingVolumesCount;
+
+    // TODO : Why is the subdivisionScheme not being checked here?
+
+    // In case of QUADTREE the sizeZ should NOT be changed!
+    // https://portal.ogc.org/files/102132
+    // A quadtree divides space only on the x and y dimensions. It divides each tile into 4 smaller tiles where the x and y dimensions are halved. The quadtree z minimum and maximum remain unchanged.
+
     const sizeZ = (maximumHeight - minimumHeight) / boundingVolumesCount;
 
     const [childWest, childEast] = [west + sizeX * childTileX, west + sizeX * (childTileX + 1)];
@@ -253,9 +328,11 @@ function calculateBoundingVolumeForChildTile(
     };
   }
 
-  // eslint-disable-next-line no-console
-  console.warn('Unsupported bounding volume type: ', rootBoundingVolume);
-  return null;
+  if (rootBoundingVolume.box) {
+    return rootBoundingVolume;
+  }
+
+  throw new Error(`Unsupported bounding volume type ${rootBoundingVolume}`);
 }
 
 /**

package/src/lib/parsers/helpers/parse-3d-tile-subtree.ts

@@ -1,5 +1,5 @@
 import type {Subtree, ExplicitBitstream} from '../../../types';
-import {fetchFile} from '@loaders.gl/core';
+import type {LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';
 
 const SUBTREE_FILE_MAGIC = 0x74627573;
 const SUBTREE_FILE_VERSION = 1;
@@ -11,7 +11,11 @@ const SUBTREE_FILE_VERSION = 1;
  * @returns
  */
 // eslint-disable-next-line max-statements
-export default async function parse3DTilesSubtree(data: ArrayBuffer): Promise<Subtree> {
+export default async function parse3DTilesSubtree(
+  data: ArrayBuffer,
+  options: LoaderOptions | undefined,
+  context: LoaderContext | undefined
+): Promise<Subtree> {
   const magic = new Uint32Array(data.slice(0, 4));
 
   if (magic[0] !== SUBTREE_FILE_MAGIC) {
@@ -42,7 +46,8 @@ export default async function parse3DTilesSubtree(data: ArrayBuffer): Promise<Su
     subtree.tileAvailability.explicitBitstream = await getExplicitBitstream(
       subtree,
       'tileAvailability',
-      internalBinaryBuffer
+      internalBinaryBuffer,
+      context
     );
   }
 
@@ -50,7 +55,8 @@ export default async function parse3DTilesSubtree(data: ArrayBuffer): Promise<Su
     subtree.contentAvailability.explicitBitstream = await getExplicitBitstream(
       subtree,
       'contentAvailability',
-      internalBinaryBuffer
+      internalBinaryBuffer,
+      context
     );
   }
 
@@ -58,13 +64,40 @@ export default async function parse3DTilesSubtree(data: ArrayBuffer): Promise<Su
     subtree.childSubtreeAvailability.explicitBitstream = await getExplicitBitstream(
       subtree,
       'childSubtreeAvailability',
-      internalBinaryBuffer
+      internalBinaryBuffer,
+      context
     );
   }
 
   return subtree;
 }
 
+/**
+ * Get url for bitstream downloading
+ * @param bitstreamRelativeUri
+ * @param baseUri
+ * @returns
+ */
+function resolveBufferUri(bitstreamRelativeUri: string, basePath: string): string {
+  const hasProtocol = basePath.startsWith('http');
+
+  if (hasProtocol) {
+    const resolvedUri = new URL(bitstreamRelativeUri, basePath);
+    return decodeURI(resolvedUri.toString());
+  }
+
+  /**
+   * Adding http protocol only for new URL constructor usage.
+   * It allows to resolve relative paths like ../../example with basePath.
+   */
+  const basePathWithProtocol = `http://${basePath}`;
+  const resolvedUri = new URL(bitstreamRelativeUri, basePathWithProtocol);
+  /**
+   * Drop protocol and use just relative path.
+   */
+  return `/${resolvedUri.host}${resolvedUri.pathname}`;
+}
+
 /**
  * Get explicit bitstream for subtree availability data.
  * @param subtree
@@ -74,15 +107,25 @@ export default async function parse3DTilesSubtree(data: ArrayBuffer): Promise<Su
 async function getExplicitBitstream(
   subtree: Subtree,
   name: string,
-  internalBinaryBuffer: ArrayBuffer
+  internalBinaryBuffer: ArrayBuffer,
+  context: LoaderContext | undefined
 ): Promise<ExplicitBitstream> {
   const bufferViewIndex = subtree[name].bufferView;
   const bufferView = subtree.bufferViews[bufferViewIndex];
   const buffer = subtree.buffers[bufferView.buffer];
 
+  if (!context?.url || !context.fetch) {
+    throw new Error('Url is not provided');
+  }
+
+  if (!context.fetch) {
+    throw new Error('fetch is not provided');
+  }
+
   // External bitstream loading
   if (buffer.uri) {
-    const response = await fetchFile(buffer.uri);
+    const bufferUri = resolveBufferUri(buffer.uri, context?.url);
+    const response = await context.fetch(bufferUri);
     const data = await response.arrayBuffer();
     // Return view of bitstream.
     return new Uint8Array(data, bufferView.byteOffset, bufferView.byteLength);

package/src/lib/parsers/parse-3d-tile-header.ts

@@ -1,8 +1,12 @@
+import type {LoaderOptions} from '@loaders.gl/loader-utils';
 import {Tile3DSubtreeLoader} from '../../tile-3d-subtree-loader';
 import {load} from '@loaders.gl/core';
-import {Tileset3D, LOD_METRIC_TYPE, TILE_REFINEMENT, TILE_TYPE} from '@loaders.gl/tiles';
-import {Subtree} from '../../types';
+import {Tileset3D, LOD_METRIC_TYPE, TILE_REFINEMENT, TILE_TYPE, Tile3D} from '@loaders.gl/tiles';
+import {ImplicitTilingExtension, Subtree} from '../../types';
+import type {S2VolumeBox} from './helpers/parse-3d-implicit-tiles';
 import {parseImplicitTiles, replaceContentUrlTemplate} from './helpers/parse-3d-implicit-tiles';
+import type {S2VolumeInfo} from '../utils/obb/s2-corners-to-obb';
+import {convertS2BoundingVolumetoOBB} from '../utils/obb/s2-corners-to-obb';
 
 function getTileType(tile) {
   if (!tile.contentUrl) {
@@ -37,13 +41,27 @@ function getRefine(refine) {
   }
 }
 
+function resolveUri(uri, basePath) {
+  // url scheme per RFC3986
+  const urlSchemeRegex = /^[a-z][0-9a-z+.-]*:/i;
+
+  if (urlSchemeRegex.test(basePath)) {
+    const url = new URL(uri, `${basePath}/`);
+    return decodeURI(url.toString());
+  } else if (uri.startsWith('/')) {
+    return uri;
+  }
+
+  return `${basePath}/${uri}`;
+}
+
 export function normalizeTileData(tile, options) {
   if (!tile) {
     return null;
   }
   if (tile.content) {
     const contentUri = tile.content.uri || tile.content.url;
-    tile.contentUrl = `${options.basePath}/${contentUri}`;
+    tile.contentUrl = resolveUri(contentUri, options.basePath);
   }
   tile.id = tile.contentUrl;
   tile.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
@@ -56,9 +74,24 @@ export function normalizeTileData(tile, options) {
 }
 
 // normalize tile headers
-export function normalizeTileHeaders(tileset) {
+export async function normalizeTileHeaders(
+  tileset: Tileset3D,
+  options: LoaderOptions
+): Promise<Tileset3D> {
   const basePath = tileset.basePath;
-  const root = normalizeTileData(tileset.root, tileset);
+  let root: Tileset3D;
+
+  const rootImplicitTilingExtension = getImplicitTilingExtensionData(tileset?.root);
+  if (rootImplicitTilingExtension && tileset.root) {
+    root = await normalizeImplicitTileHeaders(
+      tileset.root,
+      tileset,
+      rootImplicitTilingExtension,
+      options
+    );
+  } else {
+    root = normalizeTileData(tileset.root, tileset);
+  }
 
   const stack: any[] = [];
   stack.push(root);
@@ -66,8 +99,19 @@ export function normalizeTileHeaders(tileset) {
   while (stack.length > 0) {
     const tile = stack.pop() || {};
     const children = tile.children || [];
-    for (const childHeader of children) {
-      normalizeTileData(childHeader, {basePath});
+    for (let childHeader of children) {
+      const childImplicitTilingExtension = getImplicitTilingExtensionData(childHeader);
+      if (childImplicitTilingExtension) {
+        childHeader = await normalizeImplicitTileHeaders(
+          childHeader,
+          tileset,
+          childImplicitTilingExtension,
+          options
+        );
+      } else {
+        normalizeTileData(childHeader, {basePath});
+      }
+
       stack.push(childHeader);
     }
   }
@@ -80,29 +124,38 @@ export function normalizeTileHeaders(tileset) {
  * TODO Check if Tile3D class can be a return type here.
  * @param tileset
  */
-export async function normalizeImplicitTileHeaders(tileset: Tileset3D) {
-  if (!tileset.root) {
-    return null;
-  }
-
+export async function normalizeImplicitTileHeaders(
+  tile: Tile3D,
+  tileset: Tileset3D,
+  implicitTilingExtension: ImplicitTilingExtension,
+  options: LoaderOptions
+) {
   const basePath = tileset.basePath;
-  const implicitTilingExtension = tileset.root.extensions['3DTILES_implicit_tiling'];
   const {
     subdivisionScheme,
     maximumLevel,
     subtreeLevels,
     subtrees: {uri: subtreesUriTemplate}
   } = implicitTilingExtension;
-  const subtreeUrl = replaceContentUrlTemplate(subtreesUriTemplate, 0, 0, 0, 0);
-  const rootSubtreeUrl = `${basePath}/${subtreeUrl}`;
-  const rootSubtree = await load(rootSubtreeUrl, Tile3DSubtreeLoader);
-  const contentUrlTemplate = `${basePath}/${tileset.root.content.uri}`;
-  const refine = tileset.root.refine;
+  const replacedUrlTemplate = replaceContentUrlTemplate(subtreesUriTemplate, 0, 0, 0, 0);
+  const subtreeUrl = resolveUri(replacedUrlTemplate, basePath);
+  const subtree = await load(subtreeUrl, Tile3DSubtreeLoader, options);
+  const contentUrlTemplate = resolveUri(tile.content.uri, basePath);
+  const refine = tileset?.root?.refine;
   // @ts-ignore
-  const rootLodMetricValue = tileset.root.geometricError;
-  const rootBoundingVolume = tileset.root.boundingVolume;
+  const rootLodMetricValue = tile.geometricError;
+
+  // Replace tile.boundingVolume with the the bounding volume specified by the extensions['3DTILES_bounding_volume_S2']
+  const s2VolumeInfo: S2VolumeInfo = tile.boundingVolume.extensions?.['3DTILES_bounding_volume_S2'];
+  if (s2VolumeInfo) {
+    const box = convertS2BoundingVolumetoOBB(s2VolumeInfo);
+    const s2VolumeBox: S2VolumeBox = {box, s2VolumeInfo};
+    tile.boundingVolume = s2VolumeBox;
+  }
+
+  const rootBoundingVolume = tile.boundingVolume;
 
-  const options = {
+  const implicitOptions = {
     contentUrlTemplate,
     subtreesUriTemplate,
     subdivisionScheme,
@@ -117,7 +170,7 @@ export async function normalizeImplicitTileHeaders(tileset: Tileset3D) {
     getRefine
   };
 
-  return await normalizeImplicitTileData(tileset.root, rootSubtree, options);
+  return await normalizeImplicitTileData(tile, subtree, implicitOptions);
 }
 
 /**
@@ -136,7 +189,11 @@ export async function normalizeImplicitTileData(tile, rootSubtree: Subtree, opti
   tile.lodMetricValue = tile.geometricError;
   tile.transformMatrix = tile.transform;
 
-  const {children, contentUrl} = await parseImplicitTiles({subtree: rootSubtree, options});
+  const {children, contentUrl} = await parseImplicitTiles({
+    subtree: rootSubtree,
+    options,
+    s2VolumeBox: tile
+  });
 
   if (contentUrl) {
     tile.contentUrl = contentUrl;
@@ -150,3 +207,14 @@ export async function normalizeImplicitTileData(tile, rootSubtree: Subtree, opti
 
   return tile;
 }
+
+/**
+ * Implicit Tiling data can be in 3DTILES_implicit_tiling for 3DTiles v.Next or directly in implicitTiling object for 3DTiles v1.1.
+ * Spec 3DTiles v.Next - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling
+ * Spec 3DTiles v.1.1 - https://github.com/CesiumGS/3d-tiles/tree/draft-1.1/specification/ImplicitTiling
+ * @param tile
+ * @returns
+ */
+function getImplicitTilingExtensionData(tile: Tile3D | null): ImplicitTilingExtension {
+  return tile?.extensions?.['3DTILES_implicit_tiling'] || tile?.implicitTiling;
+}

package/src/lib/utils/obb/s2-corners-to-obb.ts

@@ -0,0 +1,51 @@
+import {Vector3} from '@math.gl/core';
+import {OrientedBoundingBox, makeOrientedBoundingBoxFromPoints} from '@math.gl/culling';
+
+import type {S2HeightInfo} from '../../utils/s2/index';
+import {getS2OrientedBoundingBoxCornerPoints} from '../../utils/s2/index';
+
+import {getS2LngLat} from '../../utils/s2/index';
+import {Ellipsoid} from '@math.gl/geospatial';
+
+export type S2VolumeInfo = {
+  /** S2 key or token */
+  token: string;
+  /** minimum height in meters */
+  minimumHeight: number;
+  /** maximum height in meters */
+  maximumHeight: number;
+};
+
+/**
+ * Converts S2VolumeInfo to OrientedBoundingBox
+ * @param {S2VolumeInfo} s2VolumeInfo - s2 volume to convert
+ * @returns Oriented Bounding Box of type Box
+ */
+export function convertS2BoundingVolumetoOBB(s2VolumeInfo: S2VolumeInfo): number[] {
+  const token: string = s2VolumeInfo.token;
+  const heightInfo: S2HeightInfo = {
+    minimumHeight: s2VolumeInfo.minimumHeight,
+    maximumHeight: s2VolumeInfo.maximumHeight
+  };
+
+  const corners: Vector3[] = getS2OrientedBoundingBoxCornerPoints(token, heightInfo);
+
+  // Add a point that doesn't allow the box dive under the Earth
+
+  const center = getS2LngLat(token);
+  const centerLng: number = center[0];
+  const centerLat: number = center[1];
+  const point = Ellipsoid.WGS84.cartographicToCartesian([
+    centerLng,
+    centerLat,
+    heightInfo.maximumHeight
+  ]);
+  const centerPointAdditional = new Vector3(point[0], point[1], point[2]);
+  corners.push(centerPointAdditional);
+
+  // corners should be an array of Vector3 (XYZ)
+  const obb: OrientedBoundingBox = makeOrientedBoundingBoxFromPoints(corners);
+  const box: number[] = [...obb.center, ...obb.halfAxes];
+
+  return box;
+}