@loaders.gl/3d-tiles 4.0.0-alpha.23 → 4.0.0-alpha.25

package/dist/lib/parsers/parse-3d-tile-point-cloud.js

@@ -1,441 +0,0 @@
-"use strict";
-// 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
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadDraco = exports.parsePointCloud3DTile = void 0;
-const draco_1 = require("@loaders.gl/draco");
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const math_1 = require("@loaders.gl/math");
-const core_1 = require("@math.gl/core");
-const tile_3d_feature_table_1 = __importDefault(require("../classes/tile-3d-feature-table"));
-const tile_3d_batch_table_1 = __importDefault(require("../classes/tile-3d-batch-table"));
-const parse_3d_tile_header_1 = require("./helpers/parse-3d-tile-header");
-const parse_3d_tile_tables_1 = require("./helpers/parse-3d-tile-tables");
-const normalize_3d_tile_colors_1 = require("./helpers/normalize-3d-tile-colors");
-const normalize_3d_tile_normals_1 = require("./helpers/normalize-3d-tile-normals");
-const normalize_3d_tile_positions_1 = require("./helpers/normalize-3d-tile-positions");
-async function parsePointCloud3DTile(tile, arrayBuffer, byteOffset, options, context) {
-    byteOffset = (0, parse_3d_tile_header_1.parse3DTileHeaderSync)(tile, arrayBuffer, byteOffset);
-    byteOffset = (0, parse_3d_tile_tables_1.parse3DTileTablesHeaderSync)(tile, arrayBuffer, byteOffset);
-    byteOffset = (0, parse_3d_tile_tables_1.parse3DTileTablesSync)(tile, arrayBuffer, byteOffset, options);
-    initializeTile(tile);
-    const { featureTable, batchTable } = parsePointCloudTables(tile);
-    await parseDraco(tile, featureTable, batchTable, options, context);
-    parsePositions(tile, featureTable, options);
-    // @ts-expect-error TODO - do we need to assert on the batch table?
-    parseColors(tile, featureTable, batchTable);
-    parseNormals(tile, featureTable);
-    return byteOffset;
-}
-exports.parsePointCloud3DTile = parsePointCloud3DTile;
-function initializeTile(tile) {
-    // Initialize point cloud tile defaults
-    tile.attributes = {
-        positions: null,
-        colors: null,
-        normals: null,
-        batchIds: null
-    };
-    tile.isQuantized = false;
-    tile.isTranslucent = false;
-    tile.isRGB565 = false;
-    tile.isOctEncoded16P = false;
-}
-function parsePointCloudTables(tile) {
-    const featureTable = new tile_3d_feature_table_1.default(tile.featureTableJson, tile.featureTableBinary);
-    const pointsLength = featureTable.getGlobalProperty('POINTS_LENGTH');
-    if (!Number.isFinite(pointsLength)) {
-        throw new Error('POINTS_LENGTH must be defined');
-    }
-    featureTable.featuresLength = pointsLength;
-    tile.featuresLength = pointsLength;
-    tile.pointsLength = pointsLength;
-    tile.pointCount = pointsLength;
-    tile.rtcCenter = featureTable.getGlobalProperty('RTC_CENTER', math_1.GL.FLOAT, 3);
-    const batchTable = parseBatchIds(tile, featureTable);
-    return { featureTable, batchTable };
-}
-function parsePositions(tile, featureTable, options) {
-    tile.attributes = tile.attributes || {
-        positions: null,
-        colors: null,
-        normals: null,
-        batchIds: null
-    };
-    if (!tile.attributes.positions) {
-        if (featureTable.hasProperty('POSITION')) {
-            tile.attributes.positions = featureTable.getPropertyArray('POSITION', math_1.GL.FLOAT, 3);
-        }
-        else if (featureTable.hasProperty('POSITION_QUANTIZED')) {
-            const positions = featureTable.getPropertyArray('POSITION_QUANTIZED', math_1.GL.UNSIGNED_SHORT, 3);
-            tile.isQuantized = true;
-            tile.quantizedRange = (1 << 16) - 1;
-            tile.quantizedVolumeScale = featureTable.getGlobalProperty('QUANTIZED_VOLUME_SCALE', math_1.GL.FLOAT, 3);
-            if (!tile.quantizedVolumeScale) {
-                throw new Error('QUANTIZED_VOLUME_SCALE must be defined for quantized positions.');
-            }
-            tile.quantizedVolumeOffset = featureTable.getGlobalProperty('QUANTIZED_VOLUME_OFFSET', math_1.GL.FLOAT, 3);
-            if (!tile.quantizedVolumeOffset) {
-                throw new Error('QUANTIZED_VOLUME_OFFSET must be defined for quantized positions.');
-            }
-            tile.attributes.positions = (0, normalize_3d_tile_positions_1.normalize3DTilePositionAttribute)(tile, positions, options);
-        }
-    }
-    if (!tile.attributes.positions) {
-        throw new Error('Either POSITION or POSITION_QUANTIZED must be defined.');
-    }
-}
-function parseColors(tile, featureTable, batchTable) {
-    tile.attributes = tile.attributes || {
-        positions: null,
-        colors: null,
-        normals: null,
-        batchIds: null
-    };
-    if (!tile.attributes.colors) {
-        let colors = null;
-        if (featureTable.hasProperty('RGBA')) {
-            colors = featureTable.getPropertyArray('RGBA', math_1.GL.UNSIGNED_BYTE, 4);
-            tile.isTranslucent = true;
-        }
-        else if (featureTable.hasProperty('RGB')) {
-            colors = featureTable.getPropertyArray('RGB', math_1.GL.UNSIGNED_BYTE, 3);
-        }
-        else if (featureTable.hasProperty('RGB565')) {
-            colors = featureTable.getPropertyArray('RGB565', math_1.GL.UNSIGNED_SHORT, 1);
-            tile.isRGB565 = true;
-        }
-        tile.attributes.colors = (0, normalize_3d_tile_colors_1.normalize3DTileColorAttribute)(tile, colors, batchTable);
-    }
-    if (featureTable.hasProperty('CONSTANT_RGBA')) {
-        tile.constantRGBA = featureTable.getGlobalProperty('CONSTANT_RGBA', math_1.GL.UNSIGNED_BYTE, 4);
-    }
-}
-function parseNormals(tile, featureTable) {
-    tile.attributes = tile.attributes || {
-        positions: null,
-        colors: null,
-        normals: null,
-        batchIds: null
-    };
-    if (!tile.attributes.normals) {
-        let normals = null;
-        if (featureTable.hasProperty('NORMAL')) {
-            normals = featureTable.getPropertyArray('NORMAL', math_1.GL.FLOAT, 3);
-        }
-        else if (featureTable.hasProperty('NORMAL_OCT16P')) {
-            normals = featureTable.getPropertyArray('NORMAL_OCT16P', math_1.GL.UNSIGNED_BYTE, 2);
-            tile.isOctEncoded16P = true;
-        }
-        tile.attributes.normals = (0, normalize_3d_tile_normals_1.normalize3DTileNormalAttribute)(tile, normals);
-    }
-}
-function parseBatchIds(tile, featureTable) {
-    let batchTable = null;
-    if (!tile.batchIds && featureTable.hasProperty('BATCH_ID')) {
-        tile.batchIds = featureTable.getPropertyArray('BATCH_ID', math_1.GL.UNSIGNED_SHORT, 1);
-        if (tile.batchIds) {
-            const batchFeatureLength = featureTable.getGlobalProperty('BATCH_LENGTH');
-            if (!batchFeatureLength) {
-                throw new Error('Global property: BATCH_LENGTH must be defined when BATCH_ID is defined.');
-            }
-            const { batchTableJson, batchTableBinary } = tile;
-            batchTable = new tile_3d_batch_table_1.default(batchTableJson, batchTableBinary, batchFeatureLength);
-        }
-    }
-    return batchTable;
-}
-// eslint-disable-next-line complexity
-async function parseDraco(tile, featureTable, batchTable, options, context) {
-    let dracoBuffer;
-    let dracoFeatureTableProperties;
-    let dracoBatchTableProperties;
-    const batchTableDraco = tile.batchTableJson &&
-        tile.batchTableJson.extensions &&
-        tile.batchTableJson.extensions['3DTILES_draco_point_compression'];
-    if (batchTableDraco) {
-        dracoBatchTableProperties = batchTableDraco.properties;
-    }
-    const featureTableDraco = featureTable.getExtension('3DTILES_draco_point_compression');
-    if (featureTableDraco) {
-        dracoFeatureTableProperties = featureTableDraco.properties;
-        const dracoByteOffset = featureTableDraco.byteOffset;
-        const dracoByteLength = featureTableDraco.byteLength;
-        if (!dracoFeatureTableProperties || !Number.isFinite(dracoByteOffset) || !dracoByteLength) {
-            throw new Error('Draco properties, byteOffset, and byteLength must be defined');
-        }
-        dracoBuffer = (tile.featureTableBinary || []).slice(dracoByteOffset, dracoByteOffset + dracoByteLength);
-        tile.hasPositions = Number.isFinite(dracoFeatureTableProperties.POSITION);
-        tile.hasColors =
-            Number.isFinite(dracoFeatureTableProperties.RGB) ||
-                Number.isFinite(dracoFeatureTableProperties.RGBA);
-        tile.hasNormals = Number.isFinite(dracoFeatureTableProperties.NORMAL);
-        tile.hasBatchIds = Number.isFinite(dracoFeatureTableProperties.BATCH_ID);
-        tile.isTranslucent = Number.isFinite(dracoFeatureTableProperties.RGBA);
-    }
-    if (!dracoBuffer) {
-        return true;
-    }
-    const dracoData = {
-        buffer: dracoBuffer,
-        properties: { ...dracoFeatureTableProperties, ...dracoBatchTableProperties },
-        featureTableProperties: dracoFeatureTableProperties,
-        batchTableProperties: dracoBatchTableProperties,
-        dequantizeInShader: false
-    };
-    return await loadDraco(tile, dracoData, options, context);
-}
-// eslint-disable-next-line complexity, max-statements
-async function loadDraco(tile, dracoData, options, context) {
-    if (!context) {
-        return;
-    }
-    const dracoOptions = {
-        ...options,
-        draco: {
-            ...options?.draco,
-            extraAttributes: dracoData.batchTableProperties || {}
-        }
-    };
-    // The entire tileset might be included, too expensive to serialize
-    delete dracoOptions['3d-tiles'];
-    const data = await (0, loader_utils_1.parseFromContext)(dracoData.buffer, draco_1.DracoLoader, dracoOptions, context);
-    const decodedPositions = data.attributes.POSITION && data.attributes.POSITION.value;
-    const decodedColors = data.attributes.COLOR_0 && data.attributes.COLOR_0.value;
-    const decodedNormals = data.attributes.NORMAL && data.attributes.NORMAL.value;
-    const decodedBatchIds = data.attributes.BATCH_ID && data.attributes.BATCH_ID.value;
-    // @ts-expect-error
-    const isQuantizedDraco = decodedPositions && data.attributes.POSITION.value.quantization;
-    // @ts-expect-error
-    const isOctEncodedDraco = decodedNormals && data.attributes.NORMAL.value.quantization;
-    if (isQuantizedDraco) {
-        // Draco quantization range == quantized volume scale - size in meters of the quantized volume
-        // Internal quantized range is the range of values of the quantized data, e.g. 255 for 8-bit, 1023 for 10-bit, etc
-        // @ts-expect-error This doesn't look right
-        const quantization = data.POSITION.data.quantization;
-        const range = quantization.range;
-        tile.quantizedVolumeScale = new core_1.Vector3(range, range, range);
-        tile.quantizedVolumeOffset = new core_1.Vector3(quantization.minValues);
-        tile.quantizedRange = (1 << quantization.quantizationBits) - 1.0;
-        tile.isQuantizedDraco = true;
-    }
-    if (isOctEncodedDraco) {
-        // @ts-expect-error This doesn't look right
-        tile.octEncodedRange = (1 << data.NORMAL.data.quantization.quantizationBits) - 1.0;
-        tile.isOctEncodedDraco = true;
-    }
-    // Extra batch table attributes
-    const batchTableAttributes = {};
-    if (dracoData.batchTableProperties) {
-        for (const attributeName of Object.keys(dracoData.batchTableProperties)) {
-            if (data.attributes[attributeName] && data.attributes[attributeName].value) {
-                batchTableAttributes[attributeName.toLowerCase()] = data.attributes[attributeName].value;
-            }
-        }
-    }
-    tile.attributes = {
-        // @ts-expect-error
-        positions: decodedPositions,
-        // @ts-expect-error
-        colors: (0, normalize_3d_tile_colors_1.normalize3DTileColorAttribute)(tile, decodedColors, undefined),
-        // @ts-expect-error
-        normals: decodedNormals,
-        // @ts-expect-error
-        batchIds: decodedBatchIds,
-        ...batchTableAttributes
-    };
-}
-exports.loadDraco = loadDraco;
-// TODO - this is the remaining code from Cesium's parser
-/*
-  const batchTable = new Tile3DBatchTable(tile);
-
-  // parseDracoBuffer(tile, featureTable, batchTable);
-
-  if (!tile.attributes.positions) {
-    throw new Error('Either POSITION or POSITION_QUANTIZED must be defined.');
-  }
-}
-/*
-
-  if (!tile.attributes.positions) {
-    if (featureTable.hasProperty('POSITION')) {
-      tile.attributes.positions = featureTable.getPropertyArray('POSITION', GL.FLOAT, 3);
-    } else if (featureTable.hasProperty('POSITION_QUANTIZED')) {
-      tile.attributes.positions = featureTable.getPropertyArray('POSITION_QUANTIZED', GL.UNSIGNED_SHORT, 3);
-
-
-  if (!tile.colors) {
-    if (featureTable.hasProperty('RGBA')) {
-      tile.colors = featureTable.getPropertyArray('RGBA', GL.UNSIGNED_BYTE, 4);
-      tile.isTranslucent = true;
-    } else if (featureTable.hasProperty('RGB')) {
-      tile.colors = featureTable.getPropertyArray('RGB', GL.UNSIGNED_BYTE, 3);
-    } else if (featureTable.hasPropertry('RGB565')) {
-      tile.colors = featureTable.getPropertyArray('RGB565', GL.UNSIGNED_SHORT, 1);
-      tile.isRGB565 = true;
-    }
-  }
-
-  if (!tile.attributes.normals) {
-    if (featureTable.getPropertry('NORMAL')) {
-      tile.attributes.normals = featureTable.getPropertyArray('NORMAL', GL.FLOAT, 3);
-    } else if (featureTable.getProperty('NORMAL_OCT16P')) {
-      tile.attributes.normals = featureTable.getPropertyArray('NORMAL_OCT16P', GL.UNSIGNED_BYTE, 2);
-      tile.isOctEncoded16P = true;
-    }
-  }
-
-  if (!tile.batchIds) {
-    if (featureTable.hasProperty('BATCH_ID')) {
-      tile.batchIds = featureTable.getPropertyArray('BATCH_ID', GL.UNSIGNED_SHORT, 1);
-    }
-  }
-
-  if (!tile.attributes.positions) {
-    throw new Error('Either POSITION or POSITION_QUANTIZED must be defined.');
-  }
-
-  if (featureTable.getPropertry('CONSTANT_RGBA')) {
-    tile.constantRGBA = featureTable.getGlobalProperty('CONSTANT_RGBA', GL.UNSIGNED_BYTE, 4);
-  }
-
-  if (tile.batchIds) {
-    const batchLength = featureTable.getGlobalProperty('BATCH_LENGTH');
-    if (!defined(batchLength)) {
-      throw new Error('Global property: BATCH_LENGTH must be defined when BATCH_ID is defined.');
-    }
-
-    if (defined(batchTableBinary)) {
-      // Copy the batchTableBinary section and let the underlying ArrayBuffer be freed
-      batchTableBinary = new Uint8Array(batchTableBinary);
-    }
-
-    if (defined(pointCloud._batchTableLoaded)) {
-      pointCloud._batchTableLoaded(batchLength, batchTableJson, batchTableBinary);
-    }
-  }
-
-  // If points are not batched and there are per-point properties, use these properties for styling purposes
-  var styleableProperties;
-  if (!hasBatchIds && defined(batchTableBinary)) {
-    tile.styleableProperties = Cesium3DTileBatchTable.getBinaryProperties(
-      pointsLength,
-      batchTableJson,
-      batchTableBinary
-    );
-  }
-
-  tile.draco = draco;
-}
-
-// Separate parsing and decoding of Draco
-export function parseDracoBuffer(tile, featureTable, batchTable) {
-  let dracoBuffer;
-  let dracoFeatureTableProperties;
-  let dracoBatchTableProperties;
-
-  const batchTableDraco = batchTable.getExtension('3DTILES_draco_point_compression');
-  if (batchTableDraco) {
-    dracoBatchTableProperties = batchTableDraco.properties;
-  }
-
-  const featureTableDraco = featureTable.getExtension('3DTILES_draco_point_compression');
-  if (featureTableDraco) {
-    dracoFeatureTableProperties = featureTableDraco.properties;
-    const dracoByteOffset = featureTableDraco.byteOffset;
-    const dracoByteLength = featureTableDraco.byteLength;
-    if (!dracoFeatureTableProperties || !dracoByteOffset || !dracoByteLength) {
-      throw new Error('Draco properties, byteOffset, and byteLength must be defined');
-    }
-
-    dracoBuffer = arraySlice(
-      featureTableBinary,
-      dracoByteOffset,
-      dracoByteOffset + dracoByteLength
-    );
-    tile.hasPositions = dracoFeatureTableProperties.POSITION;
-    tile.hasColors = dracoFeatureTableProperties.RGB || dracoFeatureTableProperties.RGBA;
-    tile.hasNormals = dracoFeatureTableProperties.NORMAL;
-    tile.hasBatchIds = dracoFeatureTableProperties.BATCH_ID;
-    tile.isTranslucent = dracoFeatureTableProperties.RGBA;
-  }
-
-  if (dracoBuffer) {
-    tile.draco = {
-      buffer: dracoBuffer,
-      properties: {...dracoFeatureTableProperties, ...dracoBatchTableProperties},
-      featureTableProperties: dracoFeatureTableProperties,
-      batchTableProperties: dracoBatchTableProperties,
-      dequantizeInShader: false
-    };
-
-    tile.decodingState = DECODING_STATE.NEEDS_DECODE;
-  }
-}
-
-/*
-function decodeDraco(tile, context) {
-  if (tile.decodingState === DECODING_STATE.READY) {
-    return false;
-  }
-  if (tile.decodingState === DECODING_STATE.NEEDS_DECODE) {
-    var parsedContent = tile._parsedContent;
-    var draco = parsedContent.draco;
-    var decodePromise = DracoLoader.decodePointCloud(draco, context);
-    if (defined(decodePromise)) {
-      tile.decodingState = DECODING_STATE.DECODING;
-      decodePromise.then(function(result) {
-        tile.decodingState = DECODING_STATE.READY;
-        var decodedPositions = defined(result.POSITION) ? result.POSITION.array : undefined;
-        var decodedRgb = defined(result.RGB) ? result.RGB.array : undefined;
-        var decodedRgba = defined(result.RGBA) ? result.RGBA.array : undefined;
-        var decodedNormals = defined(result.NORMAL) ? result.NORMAL.array : undefined;
-        var decodedBatchIds = defined(result.BATCH_ID) ? result.BATCH_ID.array : undefined;
-        var isQuantizedDraco = defined(decodedPositions) && defined(result.POSITION.data.quantization);
-        var isOctEncodedDraco = defined(decodedNormals) && defined(result.NORMAL.data.quantization);
-        if (isQuantizedDraco) {
-          // Draco quantization range == quantized volume scale - size in meters of the quantized volume
-          // Internal quantized range is the range of values of the quantized data, e.g. 255 for 8-bit, 1023 for 10-bit, etc
-          var quantization = result.POSITION.data.quantization;
-          var range = quantization.range;
-          tile._quantizedVolumeScale = Cartesian3.fromElements(range, range, range);
-          tile._quantizedVolumeOffset = Cartesian3.unpack(quantization.minValues);
-          tile._quantizedRange = (1 << quantization.quantizationBits) - 1.0;
-          tile._isQuantizedDraco = true;
-        }
-        if (isOctEncodedDraco) {
-          tile._octEncodedRange = (1 << result.NORMAL.data.quantization.quantizationBits) - 1.0;
-          tile._isOctEncodedDraco = true;
-        }
-        var styleableProperties = parsedContent.styleableProperties;
-        var batchTableProperties = draco.batchTableProperties;
-        for (var name in batchTableProperties) {
-          if (batchTableProperties.hasOwnProperty(name)) {
-            var property = result[name];
-            if (!defined(styleableProperties)) {
-              styleableProperties = {};
-            }
-            styleableProperties[name] = {
-              typedArray : property.array,
-              componentCount : property.data.componentsPerAttribute
-            };
-          }
-        }
-        parsedContent.positions = defaultValue(decodedPositions, parsedContent.positions);
-        parsedContent.colors = defaultValue(defaultValue(decodedRgba, decodedRgb), parsedContent.colors);
-        parsedContent.normals = defaultValue(decodedNormals, parsedContent.normals);
-        parsedContent.batchIds = defaultValue(decodedBatchIds, parsedContent.batchIds);
-        parsedContent.styleableProperties = styleableProperties;
-      }).otherwise(function(error) {
-        tile.decodingState = DECODING_STATE.FAILED;
-        tile._readyPromise.reject(error);
-      });
-    }
-  }
-  return true;
-}
-*/

package/dist/lib/parsers/parse-3d-tile.js

@@ -1,33 +0,0 @@
-"use strict";
-// 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
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parse3DTile = void 0;
-const constants_1 = require("../constants");
-const parse_utils_1 = require("./helpers/parse-utils");
-const parse_3d_tile_point_cloud_1 = require("./parse-3d-tile-point-cloud");
-const parse_3d_tile_batched_model_1 = require("./parse-3d-tile-batched-model");
-const parse_3d_tile_instanced_model_1 = require("./parse-3d-tile-instanced-model");
-const parse_3d_tile_composite_1 = require("./parse-3d-tile-composite");
-const parse_3d_tile_gltf_1 = require("./parse-3d-tile-gltf");
-// Extracts
-async function parse3DTile(arrayBuffer, byteOffset = 0, options, context, tile = { shape: 'tile3d' }) {
-    tile.byteOffset = byteOffset;
-    tile.type = (0, parse_utils_1.getMagicString)(arrayBuffer, byteOffset);
-    switch (tile.type) {
-        case constants_1.TILE3D_TYPE.COMPOSITE:
-            // Note: We pass this function as argument so that embedded tiles can be parsed recursively
-            return await (0, parse_3d_tile_composite_1.parseComposite3DTile)(tile, arrayBuffer, byteOffset, options, context, parse3DTile);
-        case constants_1.TILE3D_TYPE.BATCHED_3D_MODEL:
-            return await (0, parse_3d_tile_batched_model_1.parseBatchedModel3DTile)(tile, arrayBuffer, byteOffset, options, context);
-        case constants_1.TILE3D_TYPE.GLTF:
-            return await (0, parse_3d_tile_gltf_1.parseGltf3DTile)(tile, arrayBuffer, options, context);
-        case constants_1.TILE3D_TYPE.INSTANCED_3D_MODEL:
-            return await (0, parse_3d_tile_instanced_model_1.parseInstancedModel3DTile)(tile, arrayBuffer, byteOffset, options, context);
-        case constants_1.TILE3D_TYPE.POINT_CLOUD:
-            return await (0, parse_3d_tile_point_cloud_1.parsePointCloud3DTile)(tile, arrayBuffer, byteOffset, options, context);
-        default:
-            throw new Error(`3DTileLoader: unknown type ${tile.type}`); // eslint-disable-line
-    }
-}
-exports.parse3DTile = parse3DTile;

package/dist/lib/utils/obb/s2-corners-to-obb.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertS2BoundingVolumetoOBB = void 0;
-const core_1 = require("@math.gl/core");
-const culling_1 = require("@math.gl/culling");
-const index_1 = require("../../utils/s2/index");
-const index_2 = require("../../utils/s2/index");
-const geospatial_1 = require("@math.gl/geospatial");
-/**
- * Converts S2VolumeInfo to OrientedBoundingBox
- * @param {S2VolumeInfo} s2VolumeInfo - s2 volume to convert
- * @returns Oriented Bounding Box of type Box
- */
-function convertS2BoundingVolumetoOBB(s2VolumeInfo) {
-    const token = s2VolumeInfo.token;
-    const heightInfo = {
-        minimumHeight: s2VolumeInfo.minimumHeight,
-        maximumHeight: s2VolumeInfo.maximumHeight
-    };
-    const corners = (0, index_1.getS2OrientedBoundingBoxCornerPoints)(token, heightInfo);
-    // Add a point that doesn't allow the box dive under the Earth
-    const center = (0, index_2.getS2LngLat)(token);
-    const centerLng = center[0];
-    const centerLat = center[1];
-    const point = geospatial_1.Ellipsoid.WGS84.cartographicToCartesian([
-        centerLng,
-        centerLat,
-        heightInfo.maximumHeight
-    ]);
-    const centerPointAdditional = new core_1.Vector3(point[0], point[1], point[2]);
-    corners.push(centerPointAdditional);
-    // corners should be an array of Vector3 (XYZ)
-    const obb = (0, culling_1.makeOrientedBoundingBoxFromPoints)(corners);
-    const box = [...obb.center, ...obb.halfAxes];
-    return box;
-}
-exports.convertS2BoundingVolumetoOBB = convertS2BoundingVolumetoOBB;

package/dist/lib/utils/s2/converters/s2-to-boundary.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getS2BoundaryFlatFromS2Cell = void 0;
-const s2_geometry_1 = require("../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
-function getS2BoundaryFlatFromS2Cell(s2cell) {
-    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);
-        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 = (0, s2_geometry_1.IJToST)(ij, level, offset);
-            const uv = (0, s2_geometry_1.STToUV)(st);
-            const xyz = (0, s2_geometry_1.FaceUVToXYZ)(face, uv);
-            const lngLat = (0, s2_geometry_1.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;
-}
-exports.getS2BoundaryFlatFromS2Cell = getS2BoundaryFlatFromS2Cell;

package/dist/lib/utils/s2/converters/s2-to-obb-points.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getS2OrientedBoundingBoxCornerPoints = void 0;
-const s2_cell_utils_1 = require("../s2geometry/s2-cell-utils");
-const s2_to_region_1 = require("./s2-to-region");
-const core_1 = require("@math.gl/core");
-/**
- * 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
- */
-function getS2OrientedBoundingBoxCornerPoints(tokenOrKey, // This can be an S2 key or token
-heightInfo) {
-    const min = heightInfo?.minimumHeight || 0;
-    const max = heightInfo?.maximumHeight || 0;
-    const s2cell = (0, s2_cell_utils_1.getS2Cell)(tokenOrKey);
-    const region = (0, s2_to_region_1.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 = [];
-    points.push(new core_1.Vector3(W, N, min));
-    points.push(new core_1.Vector3(E, N, min));
-    points.push(new core_1.Vector3(E, S, min));
-    points.push(new core_1.Vector3(W, S, min));
-    points.push(new core_1.Vector3(W, N, max));
-    points.push(new core_1.Vector3(E, N, max));
-    points.push(new core_1.Vector3(E, S, max));
-    points.push(new core_1.Vector3(W, S, max));
-    return points;
-}
-exports.getS2OrientedBoundingBoxCornerPoints = getS2OrientedBoundingBoxCornerPoints;

package/dist/lib/utils/s2/converters/s2-to-region.js

@@ -1,59 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getS2Region = void 0;
-const s2_to_boundary_1 = require("./s2-to-boundary");
-const s2_cell_utils_1 = require("../s2geometry/s2-cell-utils");
-/**
- * Converts S2 cell to the 2D region
- * @param s2cell {S2Cell} S2 cell to convert to 2D region
- * @returns 2D region as an object containing: west, north, east, south in degrees
- */
-function getS2Region(s2cell) {
-    let region;
-    if (s2cell.face === 2 || s2cell.face === 5) {
-        //    let corners: Float64Array;
-        let corners = null;
-        let len = 0;
-        for (let i = 0; i < 4; i++) {
-            const key = `${s2cell.face}/${i}`;
-            const cell = (0, s2_cell_utils_1.getS2Cell)(key);
-            const corns = (0, s2_to_boundary_1.getS2BoundaryFlatFromS2Cell)(cell);
-            if (typeof corners === 'undefined' || corners === null)
-                corners = new Float64Array(4 * corns.length);
-            corners.set(corns, len);
-            len += corns.length;
-        }
-        region = get2DRegionFromS2Corners(corners);
-    }
-    else {
-        const corners = (0, s2_to_boundary_1.getS2BoundaryFlatFromS2Cell)(s2cell);
-        region = get2DRegionFromS2Corners(corners);
-    }
-    return region;
-}
-exports.getS2Region = getS2Region;
-/**
- * Converts the S2 cell defined by its corners to the 2D region
- * @param corners {Float64Array} - a simple polygon in flat array format: [lng0, lat0, lng1, lat1, ...]
- * @returns 2D region as an object containing: west, north, east, south in degrees
- */
-function get2DRegionFromS2Corners(corners) {
-    if (corners.length % 2 !== 0) {
-        throw new Error('Invalid corners');
-    }
-    const longitudes = [];
-    const latitudes = [];
-    for (let i = 0; i < corners.length; i += 2) {
-        longitudes.push(corners[i]);
-        latitudes.push(corners[i + 1]);
-    }
-    longitudes.sort((a, b) => a - b);
-    latitudes.sort((a, b) => a - b);
-    // Return the region in degrees
-    return {
-        west: longitudes[0],
-        east: longitudes[longitudes.length - 1],
-        north: latitudes[latitudes.length - 1],
-        south: latitudes[0]
-    };
-}