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

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

@@ -0,0 +1,148 @@
+import type {Subtree, ExplicitBitstream} from '../../../types';
+import type {LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';
+
+const SUBTREE_FILE_MAGIC = 0x74627573;
+const SUBTREE_FILE_VERSION = 1;
+
+/**
+ * Parse subtree file
+ * Spec - https://github.com/CesiumGS/3d-tiles/tree/main/extensions/3DTILES_implicit_tiling#subtree-file-format
+ * @param data
+ * @returns
+ */
+// eslint-disable-next-line max-statements
+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) {
+    throw new Error('Wrong subtree file magic number');
+  }
+
+  const version = new Uint32Array(data.slice(4, 8));
+
+  if (version[0] !== SUBTREE_FILE_VERSION) {
+    throw new Error('Wrong subtree file verson, must be 1');
+  }
+
+  const jsonByteLength = parseUint64Value(data.slice(8, 16));
+  const stringAttribute = new Uint8Array(data, 24, jsonByteLength);
+
+  const textDecoder = new TextDecoder('utf8');
+  const string = textDecoder.decode(stringAttribute);
+  const subtree = JSON.parse(string);
+
+  const binaryByteLength = parseUint64Value(data.slice(16, 24));
+  let internalBinaryBuffer = new ArrayBuffer(0);
+
+  if (binaryByteLength) {
+    internalBinaryBuffer = data.slice(24 + jsonByteLength);
+  }
+
+  if ('bufferView' in subtree.tileAvailability) {
+    subtree.tileAvailability.explicitBitstream = await getExplicitBitstream(
+      subtree,
+      'tileAvailability',
+      internalBinaryBuffer,
+      context
+    );
+  }
+
+  if ('bufferView' in subtree.contentAvailability) {
+    subtree.contentAvailability.explicitBitstream = await getExplicitBitstream(
+      subtree,
+      'contentAvailability',
+      internalBinaryBuffer,
+      context
+    );
+  }
+
+  if ('bufferView' in subtree.childSubtreeAvailability) {
+    subtree.childSubtreeAvailability.explicitBitstream = await getExplicitBitstream(
+      subtree,
+      'childSubtreeAvailability',
+      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
+ * @param name
+ * @param internalBinaryBuffer
+ */
+async function getExplicitBitstream(
+  subtree: Subtree,
+  name: string,
+  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 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);
+  }
+  // Return view of bitstream.
+  return new Uint8Array(internalBinaryBuffer, bufferView.byteOffset, bufferView.byteLength);
+}
+
+/**
+ * Parse buffer to return uint64 value
+ * @param buffer
+ * @returns 64-bit value until precision is lost after Number.MAX_SAFE_INTEGER
+ */
+function parseUint64Value(buffer: ArrayBuffer): number {
+  const dataView = new DataView(buffer);
+  const left = dataView.getUint32(0, true);
+  const right = dataView.getUint32(4, true);
+  // combine the two 32-bit values
+  return left + 2 ** 32 * right;
+}

package/src/lib/parsers/helpers/{parse-3d-tile-tables.js → parse-3d-tile-tables.ts}

@@ -4,7 +4,7 @@
 import {getStringFromArrayBuffer} from './parse-utils';
 
 const SIZEOF_UINT32 = 4;
-const DEPRECATION_WARNING = `b3dm tile in legacy format.`;
+const DEPRECATION_WARNING = 'b3dm tile in legacy format.';
 
 // eslint-disable-next-line max-statements
 export function parse3DTileTablesHeaderSync(tile, arrayBuffer, byteOffset) {

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

@@ -0,0 +1,16 @@
+import {GLTFLoader} from '@loaders.gl/gltf';
+
+export async function parseGltf3DTile(tile, arrayBuffer, options, context) {
+  // Set flags
+  // glTF models need to be rotated from Y to Z up
+  // https://github.com/AnalyticalGraphicsInc/3d-tiles/tree/master/specification#y-up-to-z-up
+  tile.rotateYtoZ = true;
+  // Save gltf up axis
+  tile.gltfUpAxis =
+    options['3d-tiles'] && options['3d-tiles'].assetGltfUpAxis
+      ? options['3d-tiles'].assetGltfUpAxis
+      : 'Y';
+
+  const {parse} = context;
+  tile.gltf = await parse(arrayBuffer, GLTFLoader, options, context);
+}

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

@@ -0,0 +1,220 @@
+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, 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) {
+    return TILE_TYPE.EMPTY;
+  }
+
+  const contentUrl = tile.contentUrl;
+  const fileExtension = contentUrl.split('.').pop();
+  switch (fileExtension) {
+    case 'pnts':
+      return TILE_TYPE.POINTCLOUD;
+    case 'i3dm':
+    case 'b3dm':
+    case 'glb':
+    case 'gltf':
+      return TILE_TYPE.SCENEGRAPH;
+    default:
+      return fileExtension;
+  }
+}
+
+function getRefine(refine) {
+  switch (refine) {
+    case 'REPLACE':
+    case 'replace':
+      return TILE_REFINEMENT.REPLACE;
+    case 'ADD':
+    case 'add':
+      return TILE_REFINEMENT.ADD;
+    default:
+      return 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 = resolveUri(contentUri, options.basePath);
+  }
+  tile.id = tile.contentUrl;
+  tile.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
+  tile.lodMetricValue = tile.geometricError;
+  tile.transformMatrix = tile.transform;
+  tile.type = getTileType(tile);
+  tile.refine = getRefine(tile.refine);
+
+  return tile;
+}
+
+// normalize tile headers
+export async function normalizeTileHeaders(
+  tileset: Tileset3D,
+  options: LoaderOptions
+): Promise<Tileset3D> {
+  const basePath = tileset.basePath;
+  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);
+
+  while (stack.length > 0) {
+    const tile = stack.pop() || {};
+    const children = tile.children || [];
+    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);
+    }
+  }
+
+  return root;
+}
+
+/**
+ * Do normalisation of implicit tile headers
+ * TODO Check if Tile3D class can be a return type here.
+ * @param tileset
+ */
+export async function normalizeImplicitTileHeaders(
+  tile: Tile3D,
+  tileset: Tileset3D,
+  implicitTilingExtension: ImplicitTilingExtension,
+  options: LoaderOptions
+) {
+  const basePath = tileset.basePath;
+  const {
+    subdivisionScheme,
+    maximumLevel,
+    subtreeLevels,
+    subtrees: {uri: subtreesUriTemplate}
+  } = implicitTilingExtension;
+  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 = 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 implicitOptions = {
+    contentUrlTemplate,
+    subtreesUriTemplate,
+    subdivisionScheme,
+    subtreeLevels,
+    maximumLevel,
+    refine,
+    basePath,
+    lodMetricType: LOD_METRIC_TYPE.GEOMETRIC_ERROR,
+    rootLodMetricValue,
+    rootBoundingVolume,
+    getTileType,
+    getRefine
+  };
+
+  return await normalizeImplicitTileData(tile, subtree, implicitOptions);
+}
+
+/**
+ * Do implicit data normalisation to create hierarchical tile structure
+ * @param tile
+ * @param rootSubtree
+ * @param options
+ * @returns
+ */
+export async function normalizeImplicitTileData(tile, rootSubtree: Subtree, options: any) {
+  if (!tile) {
+    return null;
+  }
+
+  tile.lodMetricType = LOD_METRIC_TYPE.GEOMETRIC_ERROR;
+  tile.lodMetricValue = tile.geometricError;
+  tile.transformMatrix = tile.transform;
+
+  const {children, contentUrl} = await parseImplicitTiles({
+    subtree: rootSubtree,
+    options,
+    s2VolumeBox: tile
+  });
+
+  if (contentUrl) {
+    tile.contentUrl = contentUrl;
+    tile.content = {uri: contentUrl.replace(`${options.basePath}/`, '')};
+  }
+
+  tile.refine = getRefine(tile.refine);
+  tile.type = getTileType(tile);
+  tile.children = children;
+  tile.id = tile.contentUrl;
+
+  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/parsers/{parse-3d-tile-instanced-model.js → parse-3d-tile-instanced-model.ts}

@@ -146,6 +146,7 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
     }
 
     instancePosition.copy(position);
+    // @ts-expect-error
     instanceTranslationRotationScale.translation = instancePosition;
 
     // Get the instance rotation
@@ -203,6 +204,7 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
     }
 
     instanceQuaternion.fromMatrix3(instanceRotation);
+    // @ts-expect-error
     instanceTranslationRotationScale.rotation = instanceQuaternion;
 
     // Get the instance scale
@@ -216,6 +218,7 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
       instanceScale.scale(nonUniformScale);
     }
 
+    // @ts-expect-error
     instanceTranslationRotationScale.scale = instanceScale;
 
     // Get the batchId
@@ -225,12 +228,15 @@ function extractInstancedAttributes(tile, featureTable, batchTable, instancesLen
       batchId = i;
     }
 
+    // @ts-expect-error
     const rotationMatrix = new Matrix4().fromQuaternion(instanceTranslationRotationScale.rotation);
 
     // Create the model matrix and the instance
     instanceTransform.identity();
+    // @ts-expect-error
     instanceTransform.translate(instanceTranslationRotationScale.translation);
     instanceTransform.multiplyRight(rotationMatrix);
+    // @ts-expect-error
     instanceTransform.scale(instanceTranslationRotationScale.scale);
 
     const modelMatrix = instanceTransform.clone();

package/src/lib/parsers/{parse-3d-tile-point-cloud.js → parse-3d-tile-point-cloud.ts}

@@ -137,7 +137,7 @@ function parseNormals(tile, featureTable) {
 }
 
 function parseBatchIds(tile, featureTable) {
-  let batchTable = null;
+  let batchTable: Tile3DBatchTable | null = null;
   if (!tile.batchIds && featureTable.hasProperty('BATCH_ID')) {
     tile.batchIds = featureTable.getPropertyArray('BATCH_ID', GL.UNSIGNED_SHORT, 1);
 
@@ -250,7 +250,7 @@ export async function loadDraco(tile, dracoData, options, context) {
 
   tile.attributes = {
     positions: decodedPositions,
-    colors: normalize3DTileColorAttribute(tile, decodedColors),
+    colors: normalize3DTileColorAttribute(tile, decodedColors, undefined),
     normals: decodedNormals,
     batchIds: decodedBatchIds,
     ...batchTableAttributes

package/src/lib/parsers/{parse-3d-tile.js → parse-3d-tile.ts}

@@ -8,12 +8,16 @@ import {parsePointCloud3DTile} from './parse-3d-tile-point-cloud';
 import {parseBatchedModel3DTile} from './parse-3d-tile-batched-model';
 import {parseInstancedModel3DTile} from './parse-3d-tile-instanced-model';
 import {parseComposite3DTile} from './parse-3d-tile-composite';
+import {parseGltf3DTile} from './parse-3d-tile-gltf';
 
 // Extracts
 export async function parse3DTile(arrayBuffer, byteOffset = 0, options, context, tile = {}) {
+  // @ts-expect-error
   tile.byteOffset = byteOffset;
+  // @ts-expect-error
   tile.type = getMagicString(arrayBuffer, byteOffset);
 
+  // @ts-expect-error
   switch (tile.type) {
     case TILE3D_TYPE.COMPOSITE:
       // Note: We pass this function as argument so that embedded tiles can be parsed recursively
@@ -29,6 +33,9 @@ export async function parse3DTile(arrayBuffer, byteOffset = 0, options, context,
     case TILE3D_TYPE.BATCHED_3D_MODEL:
       return await parseBatchedModel3DTile(tile, arrayBuffer, byteOffset, options, context);
 
+    case TILE3D_TYPE.GLTF:
+      return await parseGltf3DTile(tile, arrayBuffer, options, context);
+
     case TILE3D_TYPE.INSTANCED_3D_MODEL:
       return await parseInstancedModel3DTile(tile, arrayBuffer, byteOffset, options, context);
 
@@ -36,6 +43,7 @@ export async function parse3DTile(arrayBuffer, byteOffset = 0, options, context,
       return await parsePointCloud3DTile(tile, arrayBuffer, byteOffset, options, context);
 
     default:
+      // @ts-expect-error
       throw new Error(`3DTileLoader: unknown type ${tile.type}`); // eslint-disable-line
   }
 }

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;
+}

package/src/lib/utils/s2/converters/s2-to-boundary.ts

@@ -0,0 +1,67 @@
+import type {S2Cell} from '../s2geometry/s2-geometry';
+import {IJToST, STToUV, FaceUVToXYZ, XYZToLngLat} from '../s2geometry/s2-geometry';
+
+const MAX_RESOLUTION = 100;
+
+/**
+ * Get a polygon with corner coordinates for an S2 cell
+ * @param s2cell {S2Cell} S2 cell
+ * @return {Float64Array} - a simple polygon in flat array format: [lng0, lat0, lng1, lat1, ...]
+ *   - the polygon is closed, i.e. last coordinate is a copy of the first coordinate
+ */
+// eslint-disable-next-line max-statements
+export function getS2BoundaryFlatFromS2Cell(s2cell: S2Cell): Float64Array {
+  const {face, ij, level} = s2cell;
+  const offsets = [
+    [0, 0],
+    [0, 1],
+    [1, 1],
+    [1, 0],
+    [0, 0]
+  ];
+
+  // The S2 cell edge is curved: http://s2geometry.io/
+  // This is more prominent at lower levels
+  // resolution is the number of segments to generate per edge.
+  // We exponentially reduce resolution as level increases so it doesn't affect perf
+  // when there are a large number of cells
+  const resolution = Math.max(1, Math.ceil(MAX_RESOLUTION * Math.pow(2, -level)));
+  const result = new Float64Array(4 * resolution * 2 + 2);
+  let ptIndex = 0;
+  let prevLng = 0;
+
+  for (let i = 0; i < 4; i++) {
+    const offset = offsets[i].slice(0) as [number, number];
+    const nextOffset = offsets[i + 1];
+    const stepI = (nextOffset[0] - offset[0]) / resolution;
+    const stepJ = (nextOffset[1] - offset[1]) / resolution;
+
+    for (let j = 0; j < resolution; j++) {
+      offset[0] += stepI;
+      offset[1] += stepJ;
+      // Cell can be represented by coordinates IJ, ST, UV, XYZ
+      // http://s2geometry.io/devguide/s2cell_hierarchy#coordinate-systems
+      const st = IJToST(ij, level, offset);
+      const uv = STToUV(st);
+      const xyz = FaceUVToXYZ(face, uv);
+      const lngLat = XYZToLngLat(xyz);
+
+      // Adjust longitude for Web Mercator projection
+
+      if (Math.abs(lngLat[1]) > 89.999) {
+        lngLat[0] = prevLng;
+      }
+
+      const deltaLng = lngLat[0] - prevLng;
+      lngLat[0] += deltaLng > 180 ? -360 : deltaLng < -180 ? 360 : 0;
+
+      result[ptIndex++] = lngLat[0];
+      result[ptIndex++] = lngLat[1];
+      prevLng = lngLat[0];
+    }
+  }
+  // close the loop
+  result[ptIndex++] = result[0];
+  result[ptIndex++] = result[1];
+  return result;
+}

package/src/lib/utils/s2/converters/s2-to-obb-points.ts

@@ -0,0 +1,46 @@
+import {getS2Cell} from '../s2geometry/s2-cell-utils';
+import {getS2Region} from './s2-to-region';
+import {Vector3} from '@math.gl/core';
+
+export type S2HeightInfo = {
+  minimumHeight: number;
+  maximumHeight: number;
+};
+
+/**
+ * Converts S2HeightInfo to corner points of an oriented bounding box
+ * Can be used to constuct an OrientedBoundingBox instance
+ * @param tokenOrKey {string} A string that is the cell's hex token or the Hilbert quad key (containing /)
+ * @param heightInfo {S2HeightInfo} min and max height of the box
+ * @returns corner points of the oriented bounding box
+ */
+export function getS2OrientedBoundingBoxCornerPoints(
+  tokenOrKey: string, // This can be an S2 key or token
+  heightInfo?: S2HeightInfo
+): Vector3[] {
+  const min: number = heightInfo?.minimumHeight || 0;
+  const max: number = heightInfo?.maximumHeight || 0;
+
+  const s2cell = getS2Cell(tokenOrKey);
+  const region = getS2Region(s2cell);
+
+  // region lng/lat are in degrees
+  const W = region.west;
+  const S = region.south;
+  const E = region.east;
+  const N = region.north;
+
+  const points: Vector3[] = [];
+
+  points.push(new Vector3(W, N, min));
+  points.push(new Vector3(E, N, min));
+  points.push(new Vector3(E, S, min));
+  points.push(new Vector3(W, S, min));
+
+  points.push(new Vector3(W, N, max));
+  points.push(new Vector3(E, N, max));
+  points.push(new Vector3(E, S, max));
+  points.push(new Vector3(W, S, max));
+
+  return points;
+}