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

package/dist/tileset/helpers/bounding-volume.d.ts

@@ -0,0 +1,19 @@
+import { BoundingSphere, OrientedBoundingBox } from '@math.gl/culling';
+/**
+ * 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 [result] The object onto which to store the result.
+ * @returns The modified result parameter or a new TileBoundingVolume instance if none was provided.
+ */
+export declare function createBoundingVolume(boundingVolumeHeader: any, transform: any, result: any): any;
+/** [min, max] each in [longitude, latitude, altitude] */
+export type CartographicBounds = [min: number[], max: number[]];
+/**
+ * Calculate the cartographic bounding box the tile's bounding volume.
+ * @param {Object} boundingVolumeHeader The tile's bounding volume header.
+ * @param {BoundingVolume} boundingVolume The bounding volume.
+ * @returns {CartographicBounds}
+ */
+export declare function getCartographicBounds(boundingVolumeHeader: any, boundingVolume: OrientedBoundingBox | BoundingSphere): CartographicBounds;
+//# sourceMappingURL=bounding-volume.d.ts.map

package/dist/tileset/helpers/bounding-volume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounding-volume.d.ts","sourceRoot":"","sources":["../../../src/tileset/helpers/bounding-volume.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,cAAc,EAAE,mBAAmB,EAAC,MAAM,kBAAkB,CAAC;AAmBrE;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,oBAAoB,KAAA,EAAE,SAAS,KAAA,EAAE,MAAM,KAAA,OAsC3E;AAED,yDAAyD;AACzD,MAAM,MAAM,kBAAkB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC;AAEhE;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,oBAAoB,KAAA,EACpB,cAAc,EAAE,mBAAmB,GAAG,cAAc,GACnD,kBAAkB,CAuBpB"}

package/dist/tileset/helpers/bounding-volume.js

@@ -1,88 +1,293 @@
-import { Quaternion, Vector3, Matrix3, Matrix4, degrees } from '@math.gl/core';
-import { BoundingSphere, OrientedBoundingBox } from '@math.gl/culling';
-import { Ellipsoid } from '@math.gl/geospatial';
-import { assert } from '@loaders.gl/loader-utils';
-
+"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.getCartographicBounds = exports.createBoundingVolume = void 0;
+/* eslint-disable */
+const core_1 = require("@math.gl/core");
+const culling_1 = require("@math.gl/culling");
+const geospatial_1 = require("@math.gl/geospatial");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+// const scratchProjectedBoundingSphere = new BoundingSphere();
 function defined(x) {
-  return x !== undefined && x !== null;
+    return x !== undefined && x !== null;
 }
+// const scratchMatrix = new Matrix3();
+const scratchPoint = new core_1.Vector3();
+const scratchScale = new core_1.Vector3();
+const scratchNorthWest = new core_1.Vector3();
+const scratchSouthEast = new core_1.Vector3();
+// const scratchRectangle = new Rectangle();
+// const scratchOrientedBoundingBox = new OrientedBoundingBox();
+// const scratchTransform = new Matrix4();
+/**
+ * Create a bounding volume from the tile's bounding volume header.
+ * @param {Object} boundingVolumeHeader The tile's bounding volume header.
+ * @param {Matrix4} transform The transform to apply to the bounding volume.
+ * @param [result] The object onto which to store the result.
+ * @returns The modified result parameter or a new TileBoundingVolume instance if none was provided.
+ */
+function createBoundingVolume(boundingVolumeHeader, transform, result) {
+    (0, loader_utils_1.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);
+    }
+    if (boundingVolumeHeader.region) {
+        // [west, south, east, north, minimum height, maximum height]
+        // Latitudes and longitudes are in the WGS 84 datum as defined in EPSG 4979 and are in radians.
+        // Heights are in meters above (or below) the WGS 84 ellipsoid.
+        const [west, south, east, north, minHeight, maxHeight] = boundingVolumeHeader.region;
+        const northWest = geospatial_1.Ellipsoid.WGS84.cartographicToCartesian([(0, core_1.degrees)(west), (0, core_1.degrees)(north), minHeight], scratchNorthWest);
+        const southEast = geospatial_1.Ellipsoid.WGS84.cartographicToCartesian([(0, core_1.degrees)(east), (0, core_1.degrees)(south), maxHeight], scratchSouthEast);
+        const centerInCartesian = new core_1.Vector3().addVectors(northWest, southEast).multiplyScalar(0.5);
+        const radius = new core_1.Vector3().subVectors(northWest, southEast).len() / 2.0;
+        // TODO improve region boundingVolume
+        // for now, create a sphere as the boundingVolume instead of box
+        return createSphere([centerInCartesian[0], centerInCartesian[1], centerInCartesian[2], radius], new core_1.Matrix4());
+    }
+    if (boundingVolumeHeader.sphere) {
+        return createSphere(boundingVolumeHeader.sphere, transform, result);
+    }
+    throw new Error('3D Tile: boundingVolume must contain a sphere, region, or box');
+}
+exports.createBoundingVolume = createBoundingVolume;
+/**
+ * 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.
+ * @returns {CartographicBounds}
+ */
+function getCartographicBounds(boundingVolumeHeader, boundingVolume) {
+    // boundingVolume schema:
+    // https://github.com/AnalyticalGraphicsInc/3d-tiles/blob/master/specification/schema/boundingVolume.schema.json
+    if (boundingVolumeHeader.box) {
+        return orientedBoundingBoxToCartographicBounds(boundingVolume);
+    }
+    if (boundingVolumeHeader.region) {
+        // [west, south, east, north, minimum height, maximum height]
+        // Latitudes and longitudes are in the WGS 84 datum as defined in EPSG 4979 and are in radians.
+        // Heights are in meters above (or below) the WGS 84 ellipsoid.
+        const [west, south, east, north, minHeight, maxHeight] = boundingVolumeHeader.region;
+        return [
+            [(0, core_1.degrees)(west), (0, core_1.degrees)(south), minHeight],
+            [(0, core_1.degrees)(east), (0, core_1.degrees)(north), maxHeight]
+        ];
+    }
+    if (boundingVolumeHeader.sphere) {
+        return boundingSphereToCartographicBounds(boundingVolume);
+    }
+    throw new Error('Unkown boundingVolume type');
+}
+exports.getCartographicBounds = getCartographicBounds;
+function createBox(box, transform, result) {
+    // https://math.gl/modules/culling/docs/api-reference/oriented-bounding-box
+    // 1. A half-axes based representation.
+    // box: An array of 12 numbers that define an oriented bounding box.
+    // The first three elements define the x, y, and z values for the center of the box.
+    // The next three elements (with indices 3, 4, and 5) define the x axis direction and half-length.
+    // The next three elements (indices 6, 7, and 8) define the y axis direction and half-length.
+    // The last three elements (indices 9, 10, and 11) define the z axis direction and half-length.
+    // 2. A half-size-quaternion based representation.
+    // box: An array of 10 numbers that define an oriented bounding box.
+    // The first three elements define the x, y, and z values for the center of the box in a right-handed 3-axis (x, y, z) Cartesian coordinate system where the z-axis is up.
+    // The next three elements (with indices 3, 4, and 5) define the halfSize.
+    // The last four elements (indices 6, 7, 8 and 10) define the quaternion.
+    const center = new core_1.Vector3(box[0], box[1], box[2]);
+    transform.transform(center, center);
+    let origin = [];
+    if (box.length === 10) {
+        const halfSize = box.slice(3, 6);
+        const quaternion = new core_1.Quaternion();
+        quaternion.fromArray(box, 6);
+        const x = new core_1.Vector3([1, 0, 0]);
+        const y = new core_1.Vector3([0, 1, 0]);
+        const z = new core_1.Vector3([0, 0, 1]);
+        x.transformByQuaternion(quaternion);
+        x.scale(halfSize[0]);
+        y.transformByQuaternion(quaternion);
+        y.scale(halfSize[1]);
+        z.transformByQuaternion(quaternion);
+        z.scale(halfSize[2]);
+        origin = [...x.toArray(), ...y.toArray(), ...z.toArray()];
+    }
+    else {
+        origin = [...box.slice(3, 6), ...box.slice(6, 9), ...box.slice(9, 12)];
+    }
+    const xAxis = transform.transformAsVector(origin.slice(0, 3));
+    const yAxis = transform.transformAsVector(origin.slice(3, 6));
+    const zAxis = transform.transformAsVector(origin.slice(6, 9));
+    const halfAxes = new core_1.Matrix3([
+        xAxis[0],
+        xAxis[1],
+        xAxis[2],
+        yAxis[0],
+        yAxis[1],
+        yAxis[2],
+        zAxis[0],
+        zAxis[1],
+        zAxis[2]
+    ]);
+    if (defined(result)) {
+        result.center = center;
+        result.halfAxes = halfAxes;
+        return result;
+    }
+    return new culling_1.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 scratchScale = new Vector3();
-const scratchNorthWest = new Vector3();
-const scratchSouthEast = new Vector3();
-export function createBoundingVolume(boundingVolumeHeader, transform, result) {
-  assert(boundingVolumeHeader, '3D Tile: boundingVolume must be defined');
-
-  if (boundingVolumeHeader.box) {
-    return createBox(boundingVolumeHeader.box, transform, result);
-  }
+  const orientedBoundingBox = OrientedBoundingBox.fromRectangle(
+    rectangle,
+    minimumHeight,
+    maximumHeight,
+    Ellipsoid.WGS84,
+    scratchOrientedBoundingBox
+  );
+  const center = orientedBoundingBox.center;
+  const halfAxes = orientedBoundingBox.halfAxes;
 
-  if (boundingVolumeHeader.region) {
-    const [west, south, east, north, minHeight, maxHeight] = boundingVolumeHeader.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).multiplyScalar(0.5);
-    const radius = new Vector3().subVectors(northWest, southEast).len() / 2.0;
-    return createSphere([centerInCartesian[0], centerInCartesian[1], centerInCartesian[2], radius], new Matrix4());
-  }
+  // 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 (boundingVolumeHeader.sphere) {
-    return createSphere(boundingVolumeHeader.sphere, transform, result);
+  if (defined(result) && result instanceof TileOrientedBoundingBox) {
+    result.update(center, halfAxes);
+    return result;
   }
 
-  throw new Error('3D Tile: boundingVolume must contain a sphere, region, or box');
+  return new TileOrientedBoundingBox(center, halfAxes);
 }
 
-function createBox(box, transform, result) {
-  const center = new Vector3(box[0], box[1], box[2]);
-  transform.transform(center, center);
-  let origin = [];
-
-  if (box.length === 10) {
-    const halfSize = box.slice(3, 6);
-    const quaternion = new Quaternion();
-    quaternion.fromArray(box, 6);
-    const x = new Vector3([1, 0, 0]);
-    const y = new Vector3([0, 1, 0]);
-    const z = new Vector3([0, 0, 1]);
-    x.transformByQuaternion(quaternion);
-    x.scale(halfSize[0]);
-    y.transformByQuaternion(quaternion);
-    y.scale(halfSize[1]);
-    z.transformByQuaternion(quaternion);
-    z.scale(halfSize[2]);
-    origin = [...x.toArray(), ...y.toArray(), ...z.toArray()];
-  } else {
-    origin = [...box.slice(3, 6), ...box.slice(6, 9), ...box.slice(9, 12)];
+function createRegion(region, transform, initialTransform, result) {
+  if (!Matrix4.equalsEpsilon(transform, initialTransform, CesiumMath.EPSILON8)) {
+    return createBoxFromTransformedRegion(region, transform, initialTransform, result);
   }
 
-  const xAxis = transform.transformAsVector(origin.slice(0, 3));
-  const yAxis = transform.transformAsVector(origin.slice(3, 6));
-  const zAxis = transform.transformAsVector(origin.slice(6, 9));
-  const halfAxes = new Matrix3([xAxis[0], xAxis[1], xAxis[2], yAxis[0], yAxis[1], yAxis[2], zAxis[0], zAxis[1], zAxis[2]]);
-
   if (defined(result)) {
-    result.center = center;
-    result.halfAxes = halfAxes;
     return result;
   }
 
-  return new OrientedBoundingBox(center, halfAxes);
-}
+  const rectangleRegion = Rectangle.unpack(region, 0, scratchRectangle);
 
+  return new TileBoundingRegion({
+    rectangle: rectangleRegion,
+    minimumHeight: region[4],
+    maximumHeight: region[5]
+  });
+}
+*/
 function createSphere(sphere, transform, result) {
-  const center = new Vector3(sphere[0], sphere[1], sphere[2]);
-  transform.transform(center, center);
-  const scale = transform.getScale(scratchScale);
-  const uniformScale = Math.max(Math.max(scale[0], scale[1]), scale[2]);
-  const radius = sphere[3] * uniformScale;
-
-  if (defined(result)) {
-    result.center = center;
-    result.radius = radius;
+    // Find the transformed center
+    const center = new core_1.Vector3(sphere[0], sphere[1], sphere[2]);
+    transform.transform(center, center);
+    const scale = transform.getScale(scratchScale);
+    const uniformScale = Math.max(Math.max(scale[0], scale[1]), scale[2]);
+    const radius = sphere[3] * uniformScale;
+    if (defined(result)) {
+        result.center = center;
+        result.radius = radius;
+        return result;
+    }
+    return new culling_1.BoundingSphere(center, radius);
+}
+/**
+ * Convert a bounding volume defined by OrientedBoundingBox to cartographic bounds
+ * @returns {CartographicBounds}
+ */
+function orientedBoundingBoxToCartographicBounds(boundingVolume) {
+    const result = emptyCartographicBounds();
+    const { halfAxes } = boundingVolume;
+    const xAxis = new core_1.Vector3(halfAxes.getColumn(0));
+    const yAxis = new core_1.Vector3(halfAxes.getColumn(1));
+    const zAxis = new core_1.Vector3(halfAxes.getColumn(2));
+    // Test all 8 corners of the box
+    for (let x = 0; x < 2; x++) {
+        for (let y = 0; y < 2; y++) {
+            for (let z = 0; z < 2; z++) {
+                scratchPoint.copy(boundingVolume.center);
+                scratchPoint.add(xAxis);
+                scratchPoint.add(yAxis);
+                scratchPoint.add(zAxis);
+                addToCartographicBounds(result, scratchPoint);
+                zAxis.negate();
+            }
+            yAxis.negate();
+        }
+        xAxis.negate();
+    }
     return result;
-  }
-
-  return new BoundingSphere(center, radius);
 }
-//# sourceMappingURL=bounding-volume.js.map
+/**
+ * Convert a bounding volume defined by BoundingSphere to cartographic bounds
+ * @returns {CartographicBounds}
+ */
+function boundingSphereToCartographicBounds(boundingVolume) {
+    const result = emptyCartographicBounds();
+    const { center, radius } = boundingVolume;
+    const point = geospatial_1.Ellipsoid.WGS84.scaleToGeodeticSurface(center, scratchPoint);
+    let zAxis;
+    if (point) {
+        zAxis = geospatial_1.Ellipsoid.WGS84.geodeticSurfaceNormal(point);
+    }
+    else {
+        zAxis = new core_1.Vector3(0, 0, 1);
+    }
+    let xAxis = new core_1.Vector3(zAxis[2], -zAxis[1], 0);
+    if (xAxis.len() > 0) {
+        xAxis.normalize();
+    }
+    else {
+        xAxis = new core_1.Vector3(0, 1, 0);
+    }
+    const yAxis = xAxis.clone().cross(zAxis);
+    // Test 6 end points of the 3 axes
+    for (const axis of [xAxis, yAxis, zAxis]) {
+        scratchScale.copy(axis).scale(radius);
+        for (let dir = 0; dir < 2; dir++) {
+            scratchPoint.copy(center);
+            scratchPoint.add(scratchScale);
+            addToCartographicBounds(result, scratchPoint);
+            // Flip the axis
+            scratchScale.negate();
+        }
+    }
+    return result;
+}
+/**
+ * Create a new cartographic bounds that contains no points
+ * @returns {CartographicBounds}
+ */
+function emptyCartographicBounds() {
+    return [
+        [Infinity, Infinity, Infinity],
+        [-Infinity, -Infinity, -Infinity]
+    ];
+}
+/**
+ * Add a point to the target cartographic bounds
+ * @param {CartographicBounds} target
+ * @param {Vector3} cartesian coordinates of the point to add
+ */
+function addToCartographicBounds(target, cartesian) {
+    geospatial_1.Ellipsoid.WGS84.cartesianToCartographic(cartesian, scratchPoint);
+    target[0][0] = Math.min(target[0][0], scratchPoint[0]);
+    target[0][1] = Math.min(target[0][1], scratchPoint[1]);
+    target[0][2] = Math.min(target[0][2], scratchPoint[2]);
+    target[1][0] = Math.max(target[1][0], scratchPoint[0]);
+    target[1][1] = Math.max(target[1][1], scratchPoint[1]);
+    target[1][2] = Math.max(target[1][2], scratchPoint[2]);
+}

package/dist/tileset/helpers/frame-state.d.ts

@@ -0,0 +1,28 @@
+import { Tile3D } from '@loaders.gl/tiles';
+import { CullingVolume } from '@math.gl/culling';
+import { GeospatialViewport } from '../../types';
+export type FrameState = {
+    camera: {
+        position: number[];
+        direction: number[];
+        up: number[];
+    };
+    viewport: GeospatialViewport;
+    topDownViewport: GeospatialViewport;
+    height: number;
+    cullingVolume: CullingVolume;
+    frameNumber: number;
+    sseDenominator: number;
+};
+export declare function getFrameState(viewport: GeospatialViewport, frameNumber: number): FrameState;
+/**
+ * Limit `tiles` array length with `maximumTilesSelected` number.
+ * The criteria for this filtering is distance of a tile center
+ * to the `frameState.viewport`'s longitude and latitude
+ * @param tiles - tiles array to filter
+ * @param frameState - frameState to calculate distances
+ * @param maximumTilesSelected - maximal amount of tiles in the output array
+ * @returns new tiles array
+ */
+export declare function limitSelectedTiles(tiles: Tile3D[], frameState: FrameState, maximumTilesSelected: number): [Tile3D[], Tile3D[]];
+//# sourceMappingURL=frame-state.d.ts.map

package/dist/tileset/helpers/frame-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame-state.d.ts","sourceRoot":"","sources":["../../../src/tileset/helpers/frame-state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAC,MAAM,mBAAmB,CAAC;AAEzC,OAAO,EAAC,aAAa,EAAQ,MAAM,kBAAkB,CAAC;AAEtD,OAAO,EAAC,kBAAkB,EAAW,MAAM,aAAa,CAAC;AAEzD,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE;QACN,QAAQ,EAAE,MAAM,EAAE,CAAC;QACnB,SAAS,EAAE,MAAM,EAAE,CAAC;QACpB,EAAE,EAAE,MAAM,EAAE,CAAC;KACd,CAAC;IACF,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,eAAe,EAAE,kBAAkB,CAAC;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,aAAa,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAeF,wBAAgB,aAAa,CAAC,QAAQ,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,GAAG,UAAU,CAwD3F;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EAAE,EACf,UAAU,EAAE,UAAU,EACtB,oBAAoB,EAAE,MAAM,GAC3B,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,CAAC,CAyBtB"}

package/dist/tileset/helpers/frame-state.js

@@ -1,51 +1,133 @@
-import { Vector3 } from '@math.gl/core';
-import { CullingVolume, Plane } from '@math.gl/culling';
-import { Ellipsoid } from '@math.gl/geospatial';
-const scratchVector = new Vector3();
-const scratchPosition = new Vector3();
-const cullingVolume = new CullingVolume([new Plane(), new Plane(), new Plane(), new Plane(), new Plane(), new Plane()]);
-export function getFrameState(viewport, frameNumber) {
-  const {
-    cameraDirection,
-    cameraUp,
-    height
-  } = viewport;
-  const {
-    metersPerUnit
-  } = viewport.distanceScales;
-  const viewportCenterCartographic = [viewport.longitude, viewport.latitude, 0];
-  const viewportCenterCartesian = Ellipsoid.WGS84.cartographicToCartesian(viewportCenterCartographic, new Vector3());
-  const enuToFixedTransform = Ellipsoid.WGS84.eastNorthUpToFixedFrame(viewportCenterCartesian);
-  const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);
-  const cameraPositionCartesian = Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, new Vector3());
-  const cameraDirectionCartesian = new Vector3(enuToFixedTransform.transformAsVector(new Vector3(cameraDirection).scale(metersPerUnit))).normalize();
-  const cameraUpCartesian = new Vector3(enuToFixedTransform.transformAsVector(new Vector3(cameraUp).scale(metersPerUnit))).normalize();
-  commonSpacePlanesToWGS84(viewport, viewportCenterCartesian);
-  return {
-    camera: {
-      position: cameraPositionCartesian,
-      direction: cameraDirectionCartesian,
-      up: cameraUpCartesian
-    },
-    viewport,
-    height,
-    cullingVolume,
-    frameNumber,
-    sseDenominator: 1.15
-  };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.limitSelectedTiles = exports.getFrameState = void 0;
+const core_1 = require("@math.gl/core");
+const culling_1 = require("@math.gl/culling");
+const geospatial_1 = require("@math.gl/geospatial");
+const scratchVector = new core_1.Vector3();
+const scratchPosition = new core_1.Vector3();
+const cullingVolume = new culling_1.CullingVolume([
+    new culling_1.Plane(),
+    new culling_1.Plane(),
+    new culling_1.Plane(),
+    new culling_1.Plane(),
+    new culling_1.Plane(),
+    new culling_1.Plane()
+]);
+// Extracts a frame state appropriate for tile culling from a deck.gl viewport
+// TODO - this could likely be generalized and merged back into deck.gl for other culling scenarios
+function getFrameState(viewport, frameNumber) {
+    // Traverse and and request. Update _selectedTiles so that we know what to render.
+    // Traverse and and request. Update _selectedTiles so that we know what to render.
+    const { cameraDirection, cameraUp, height } = viewport;
+    const { metersPerUnit } = viewport.distanceScales;
+    // TODO - Ellipsoid.eastNorthUpToFixedFrame() breaks on raw array, create a Vector.
+    // TODO - Ellipsoid.eastNorthUpToFixedFrame() takes a cartesian, is that intuitive?
+    const viewportCenterCartesian = worldToCartesian(viewport, viewport.center);
+    const enuToFixedTransform = geospatial_1.Ellipsoid.WGS84.eastNorthUpToFixedFrame(viewportCenterCartesian);
+    const cameraPositionCartographic = viewport.unprojectPosition(viewport.cameraPosition);
+    const cameraPositionCartesian = geospatial_1.Ellipsoid.WGS84.cartographicToCartesian(cameraPositionCartographic, new core_1.Vector3());
+    // These should still be normalized as the transform has scale 1 (goes from meters to meters)
+    const cameraDirectionCartesian = new core_1.Vector3(
+    // @ts-ignore
+    enuToFixedTransform.transformAsVector(new core_1.Vector3(cameraDirection).scale(metersPerUnit))).normalize();
+    const cameraUpCartesian = new core_1.Vector3(
+    // @ts-ignore
+    enuToFixedTransform.transformAsVector(new core_1.Vector3(cameraUp).scale(metersPerUnit))).normalize();
+    commonSpacePlanesToWGS84(viewport);
+    const ViewportClass = viewport.constructor;
+    const { longitude, latitude, width, bearing, zoom } = viewport;
+    // @ts-ignore
+    const topDownViewport = new ViewportClass({
+        longitude,
+        latitude,
+        height,
+        width,
+        bearing,
+        zoom,
+        pitch: 0
+    });
+    // TODO: make a file/class for frameState and document what needs to be attached to this so that traversal can function
+    return {
+        camera: {
+            position: cameraPositionCartesian,
+            direction: cameraDirectionCartesian,
+            up: cameraUpCartesian
+        },
+        viewport,
+        topDownViewport,
+        height,
+        cullingVolume,
+        frameNumber,
+        sseDenominator: 1.15 // Assumes fovy = 60 degrees
+    };
 }
-
-function commonSpacePlanesToWGS84(viewport, viewportCenterCartesian) {
-  const frustumPlanes = viewport.getFrustumPlanes();
-  let i = 0;
-
-  for (const dir in frustumPlanes) {
-    const plane = frustumPlanes[dir];
-    const distanceToCenter = plane.normal.dot(viewport.center);
-    scratchPosition.copy(plane.normal).scale(plane.distance - distanceToCenter).add(viewport.center);
-    const cartographicPos = viewport.unprojectPosition(scratchPosition);
-    const cartesianPos = Ellipsoid.WGS84.cartographicToCartesian(cartographicPos, new Vector3());
-    cullingVolume.planes[i++].fromPointNormal(cartesianPos, scratchVector.copy(viewportCenterCartesian).subtract(cartesianPos));
-  }
+exports.getFrameState = getFrameState;
+/**
+ * Limit `tiles` array length with `maximumTilesSelected` number.
+ * The criteria for this filtering is distance of a tile center
+ * to the `frameState.viewport`'s longitude and latitude
+ * @param tiles - tiles array to filter
+ * @param frameState - frameState to calculate distances
+ * @param maximumTilesSelected - maximal amount of tiles in the output array
+ * @returns new tiles array
+ */
+function limitSelectedTiles(tiles, frameState, maximumTilesSelected) {
+    if (maximumTilesSelected === 0 || tiles.length <= maximumTilesSelected) {
+        return [tiles, []];
+    }
+    // Accumulate distances in couples array: [tileIndex: number, distanceToViewport: number]
+    const tuples = [];
+    const { longitude: viewportLongitude, latitude: viewportLatitude } = frameState.viewport;
+    for (const [index, tile] of tiles.entries()) {
+        const [longitude, latitude] = tile.header.mbs;
+        const deltaLon = Math.abs(viewportLongitude - longitude);
+        const deltaLat = Math.abs(viewportLatitude - latitude);
+        const distance = Math.sqrt(deltaLat * deltaLat + deltaLon * deltaLon);
+        tuples.push([index, distance]);
+    }
+    const tuplesSorted = tuples.sort((a, b) => a[1] - b[1]);
+    const selectedTiles = [];
+    for (let i = 0; i < maximumTilesSelected; i++) {
+        selectedTiles.push(tiles[tuplesSorted[i][0]]);
+    }
+    const unselectedTiles = [];
+    for (let i = maximumTilesSelected; i < tuplesSorted.length; i++) {
+        unselectedTiles.push(tiles[tuplesSorted[i][0]]);
+    }
+    return [selectedTiles, unselectedTiles];
+}
+exports.limitSelectedTiles = limitSelectedTiles;
+function commonSpacePlanesToWGS84(viewport) {
+    // Extract frustum planes based on current view.
+    const frustumPlanes = viewport.getFrustumPlanes();
+    // Get the near/far plane centers
+    const nearCenterCommon = closestPointOnPlane(frustumPlanes.near, viewport.cameraPosition);
+    const nearCenterCartesian = worldToCartesian(viewport, nearCenterCommon);
+    const cameraCartesian = worldToCartesian(viewport, viewport.cameraPosition, scratchPosition);
+    let i = 0;
+    cullingVolume.planes[i++].fromPointNormal(nearCenterCartesian, scratchVector.copy(nearCenterCartesian).subtract(cameraCartesian));
+    for (const dir in frustumPlanes) {
+        if (dir === 'near') {
+            continue; // eslint-disable-line no-continue
+        }
+        const plane = frustumPlanes[dir];
+        const posCommon = closestPointOnPlane(plane, nearCenterCommon, scratchPosition);
+        const cartesianPos = worldToCartesian(viewport, posCommon, scratchPosition);
+        cullingVolume.planes[i++].fromPointNormal(cartesianPos, 
+        // Want the normal to point into the frustum since that's what culling expects
+        scratchVector.copy(nearCenterCartesian).subtract(cartesianPos));
+    }
+}
+function closestPointOnPlane(plane, refPoint, out = new core_1.Vector3()) {
+    const distanceToRef = plane.normal.dot(refPoint);
+    out
+        .copy(plane.normal)
+        .scale(plane.distance - distanceToRef)
+        .add(refPoint);
+    return out;
+}
+function worldToCartesian(viewport, point, out = new core_1.Vector3()) {
+    const cartographicPos = viewport.unprojectPosition(point);
+    return geospatial_1.Ellipsoid.WGS84.cartographicToCartesian(cartographicPos, out);
 }
-//# sourceMappingURL=frame-state.js.map

package/dist/tileset/helpers/i3s-lod.d.ts

@@ -0,0 +1,20 @@
+import { Tile3D } from '../tile-3d';
+import { FrameState } from './frame-state';
+/**
+ * For the maxScreenThreshold error metric, maxError means that you should replace the node with it's children
+   as soon as the nodes bounding sphere has a screen radius larger than maxError pixels.
+   In this sense a value of 0 means you should always load it's children,
+   or if it's a leaf node, you should always display it.
+ * @param tile
+ * @param frameState
+ * @returns
+ */
+export declare function getLodStatus(tile: Tile3D, frameState: FrameState): 'DIG' | 'OUT' | 'DRAW';
+/**
+ * Calculate size of MBS radius projected on the screen plane
+ * @param tile
+ * @param frameState
+ * @returns
+ */
+export declare function getProjectedRadius(tile: Tile3D, frameState: FrameState): number;
+//# sourceMappingURL=i3s-lod.d.ts.map

package/dist/tileset/helpers/i3s-lod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"i3s-lod.d.ts","sourceRoot":"","sources":["../../../src/tileset/helpers/i3s-lod.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,MAAM,EAAC,MAAM,YAAY,CAAC;AAClC,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAUzC;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,CAczF;AAED;;;;;GAKG;AAEH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,GAAG,MAAM,CA6C/E"}