@loaders.gl/tiles 4.0.0-alpha.8 → 4.0.0-beta.1

package/dist/tileset/format-3d-tiles/tileset-3d-traverser.js

@@ -1,54 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Tileset3DTraverser = void 0;
-// This file is derived from the Cesium code base under Apache 2 license
-// See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
-const constants_1 = require("../../constants");
-const tileset_traverser_1 = require("../tileset-traverser");
-class Tileset3DTraverser extends tileset_traverser_1.TilesetTraverser {
-    compareDistanceToCamera(a, b) {
-        // Sort by farthest child first since this is going on a stack
-        return b._distanceToCamera === 0 && a._distanceToCamera === 0
-            ? b._centerZDepth - a._centerZDepth
-            : b._distanceToCamera - a._distanceToCamera;
-    }
-    updateTileVisibility(tile, frameState) {
-        super.updateTileVisibility(tile, frameState);
-        //  Optimization - if none of the tile's children are visible then this tile isn't visible
-        if (!tile.isVisibleAndInRequestVolume) {
-            return;
-        }
-        const hasChildren = tile.children.length > 0;
-        if (tile.hasTilesetContent && hasChildren) {
-            // Use the root tile's visibility instead of this tile's visibility.
-            // The root tile may be culled by the children bounds optimization in which
-            // case this tile should also be culled.
-            const firstChild = tile.children[0];
-            this.updateTileVisibility(firstChild, frameState);
-            tile._visible = firstChild._visible;
-            return;
-        }
-        if (this.meetsScreenSpaceErrorEarly(tile, frameState)) {
-            tile._visible = false;
-            return;
-        }
-        const replace = tile.refine === constants_1.TILE_REFINEMENT.REPLACE;
-        const useOptimization = tile._optimChildrenWithinParent === constants_1.TILE3D_OPTIMIZATION_HINT.USE_OPTIMIZATION;
-        if (replace && useOptimization && hasChildren) {
-            if (!this.anyChildrenVisible(tile, frameState)) {
-                tile._visible = false;
-                return;
-            }
-        }
-    }
-    meetsScreenSpaceErrorEarly(tile, frameState) {
-        const { parent } = tile;
-        if (!parent || parent.hasTilesetContent || parent.refine !== constants_1.TILE_REFINEMENT.ADD) {
-            return false;
-        }
-        // Use parent's geometric error with child's box to see if the tile already meet the SSE
-        return !this.shouldRefine(tile, frameState, true);
-    }
-}
-exports.Tileset3DTraverser = Tileset3DTraverser;

package/dist/tileset/format-i3s/i3s-pending-tiles-register.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.I3SPendingTilesRegister = void 0;
-/**
- * Counter to register pending tile headers for the particular frameNumber
- * Until all tiles are loaded we won't call `onTraversalEnd` callback
- */
-class I3SPendingTilesRegister {
-    constructor() {
-        this.frameNumberMap = new Map();
-    }
-    /**
-     * Register a new pending tile header for the particular frameNumber
-     * @param viewportId
-     * @param frameNumber
-     */
-    register(viewportId, frameNumber) {
-        const viewportMap = this.frameNumberMap.get(viewportId) || new Map();
-        const oldCount = viewportMap.get(frameNumber) || 0;
-        viewportMap.set(frameNumber, oldCount + 1);
-        this.frameNumberMap.set(viewportId, viewportMap);
-    }
-    /**
-     * Deregister a pending tile header for the particular frameNumber
-     * @param viewportId
-     * @param frameNumber
-     */
-    deregister(viewportId, frameNumber) {
-        const viewportMap = this.frameNumberMap.get(viewportId);
-        if (!viewportMap) {
-            return;
-        }
-        const oldCount = viewportMap.get(frameNumber) || 1;
-        viewportMap.set(frameNumber, oldCount - 1);
-    }
-    /**
-     * Check is there are no pending tile headers registered for the particular frameNumber
-     * @param viewportId
-     * @param frameNumber
-     * @returns
-     */
-    isZero(viewportId, frameNumber) {
-        const count = this.frameNumberMap.get(viewportId)?.get(frameNumber) || 0;
-        return count === 0;
-    }
-}
-exports.I3SPendingTilesRegister = I3SPendingTilesRegister;

package/dist/tileset/format-i3s/i3s-tile-manager.js

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.I3STileManager = void 0;
-const i3s_pending_tiles_register_1 = require("./i3s-pending-tiles-register");
-const STATUS = {
-    REQUESTED: 'REQUESTED',
-    COMPLETED: 'COMPLETED',
-    ERROR: 'ERROR'
-};
-// A helper class to manage tile metadata fetching
-class I3STileManager {
-    constructor() {
-        this.pendingTilesRegister = new i3s_pending_tiles_register_1.I3SPendingTilesRegister();
-        this._statusMap = {};
-    }
-    /**
-     * Add request to map
-     * @param request - node metadata request
-     * @param key - unique key
-     * @param callback - callback after request completed
-     * @param frameState - frameState data
-     */
-    add(request, key, callback, frameState) {
-        if (!this._statusMap[key]) {
-            const { frameNumber, viewport: { id } } = frameState;
-            this._statusMap[key] = { request, callback, key, frameState, status: STATUS.REQUESTED };
-            // Register pending request for the frameNumber
-            this.pendingTilesRegister.register(id, frameNumber);
-            request()
-                .then((data) => {
-                this._statusMap[key].status = STATUS.COMPLETED;
-                const { frameNumber: actualFrameNumber, viewport: { id } } = this._statusMap[key].frameState;
-                // Deregister pending request for the frameNumber
-                this.pendingTilesRegister.deregister(id, actualFrameNumber);
-                this._statusMap[key].callback(data, frameState);
-            })
-                .catch((error) => {
-                this._statusMap[key].status = STATUS.ERROR;
-                const { frameNumber: actualFrameNumber, viewport: { id } } = this._statusMap[key].frameState;
-                // Deregister pending request for the frameNumber
-                this.pendingTilesRegister.deregister(id, actualFrameNumber);
-                callback(error);
-            });
-        }
-    }
-    /**
-     * Update request if it is still actual for the new frameState
-     * @param key - unique key
-     * @param frameState - frameState data
-     */
-    update(key, frameState) {
-        if (this._statusMap[key]) {
-            // Deregister pending request for the old frameNumber
-            const { frameNumber, viewport: { id } } = this._statusMap[key].frameState;
-            this.pendingTilesRegister.deregister(id, frameNumber);
-            // Register pending request for the new frameNumber
-            const { frameNumber: newFrameNumber, viewport: { id: newViewportId } } = frameState;
-            this.pendingTilesRegister.register(newViewportId, newFrameNumber);
-            this._statusMap[key].frameState = frameState;
-        }
-    }
-    /**
-     * Find request in the map
-     * @param key - unique key
-     * @returns
-     */
-    find(key) {
-        return this._statusMap[key];
-    }
-    /**
-     * Check it there are pending tile headers for the particular frameNumber
-     * @param viewportId
-     * @param frameNumber
-     * @returns
-     */
-    hasPendingTiles(viewportId, frameNumber) {
-        return !this.pendingTilesRegister.isZero(viewportId, frameNumber);
-    }
-}
-exports.I3STileManager = I3STileManager;

package/dist/tileset/format-i3s/i3s-tileset-traverser.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.I3STilesetTraverser = void 0;
-const core_1 = require("@loaders.gl/core");
-const tileset_traverser_1 = require("../tileset-traverser");
-const i3s_lod_1 = require("../helpers/i3s-lod");
-const tile_3d_1 = require("../tile-3d");
-const i3s_tile_manager_1 = require("./i3s-tile-manager");
-class I3STilesetTraverser extends tileset_traverser_1.TilesetTraverser {
-    constructor(options) {
-        super(options);
-        this._tileManager = new i3s_tile_manager_1.I3STileManager();
-    }
-    /**
-     * Check if there are no penging tile header requests,
-     * that means the traversal is finished and we can call
-     * following-up callbacks.
-     */
-    traversalFinished(frameState) {
-        return !this._tileManager.hasPendingTiles(frameState.viewport.id, this._frameNumber || 0);
-    }
-    shouldRefine(tile, frameState) {
-        tile._lodJudge = (0, i3s_lod_1.getLodStatus)(tile, frameState);
-        return tile._lodJudge === 'DIG';
-    }
-    updateChildTiles(tile, frameState) {
-        const children = tile.header.children || [];
-        // children which are already fetched and constructed as Tile3D instances
-        const childTiles = tile.children;
-        const tileset = tile.tileset;
-        for (const child of children) {
-            const extendedId = `${child.id}-${frameState.viewport.id}`;
-            // if child tile is not fetched
-            const childTile = childTiles && childTiles.find((t) => t.id === extendedId);
-            if (!childTile) {
-                let request = () => this._loadTile(child.id, tileset);
-                const cachedRequest = this._tileManager.find(extendedId);
-                if (!cachedRequest) {
-                    // eslint-disable-next-line max-depth
-                    if (tileset.tileset.nodePages) {
-                        request = () => tileset.tileset.nodePagesTile.formTileFromNodePages(child.id);
-                    }
-                    this._tileManager.add(request, extendedId, (header) => this._onTileLoad(header, tile, extendedId), frameState);
-                }
-                else {
-                    // update frameNumber since it is still needed in current frame
-                    this._tileManager.update(extendedId, frameState);
-                }
-            }
-            else if (childTile) {
-                // if child tile is fetched and available
-                this.updateTile(childTile, frameState);
-            }
-        }
-        return false;
-    }
-    async _loadTile(nodeId, tileset) {
-        const { loader } = tileset;
-        const nodeUrl = tileset.getTileUrl(`${tileset.url}/nodes/${nodeId}`);
-        // load metadata
-        const options = {
-            ...tileset.loadOptions,
-            i3s: {
-                ...tileset.loadOptions.i3s,
-                isTileHeader: true
-            }
-        };
-        return await (0, core_1.load)(nodeUrl, loader, options);
-    }
-    /**
-     * The callback to init Tile3D instance after loading the tile JSON
-     * @param {Object} header - the tile JSON from a dataset
-     * @param {Tile3D} tile - the parent Tile3D instance
-     * @param {string} extendedId - optional ID to separate copies of a tile for different viewports.
-     *                              const extendedId = `${tile.id}-${frameState.viewport.id}`;
-     * @return {void}
-     */
-    _onTileLoad(header, tile, extendedId) {
-        // after child tile is fetched
-        const childTile = new tile_3d_1.Tile3D(tile.tileset, header, tile, extendedId);
-        tile.children.push(childTile);
-        const frameState = this._tileManager.find(childTile.id).frameState;
-        this.updateTile(childTile, frameState);
-        // after tile fetched, resume traversal if still in current update/traversal frame
-        if (this._frameNumber === frameState.frameNumber &&
-            (this.traversalFinished(frameState) ||
-                new Date().getTime() - this.lastUpdate > this.updateDebounceTime)) {
-            this.executeTraversal(childTile, frameState);
-        }
-    }
-}
-exports.I3STilesetTraverser = I3STilesetTraverser;

package/dist/tileset/helpers/3d-tiles-options.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.get3dTilesOptions = void 0;
-function get3dTilesOptions(tileset) {
-    return {
-        assetGltfUpAxis: (tileset.asset && tileset.asset.gltfUpAxis) || 'Y'
-    };
-}
-exports.get3dTilesOptions = get3dTilesOptions;

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

@@ -1,293 +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.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;
-}
-// 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 orientedBoundingBox = OrientedBoundingBox.fromRectangle(
-    rectangle,
-    minimumHeight,
-    maximumHeight,
-    Ellipsoid.WGS84,
-    scratchOrientedBoundingBox
-  );
-  const center = orientedBoundingBox.center;
-  const halfAxes = orientedBoundingBox.halfAxes;
-
-  // A region bounding volume is not transformed by the transform in the tileset JSON,
-  // but may be transformed by additional transforms applied in Cesium.
-  // This is why the transform is calculated as the difference between the initial transform and the current transform.
-  transform = Matrix4.multiplyTransformation(
-    transform,
-    Matrix4.inverseTransformation(initialTransform, scratchTransform),
-    scratchTransform
-  );
-  center = Matrix4.multiplyByPoint(transform, center, center);
-  const rotationScale = Matrix4.getRotation(transform, scratchMatrix);
-  halfAxes = Matrix3.multiply(rotationScale, halfAxes, halfAxes);
-
-  if (defined(result) && result instanceof TileOrientedBoundingBox) {
-    result.update(center, halfAxes);
-    return result;
-  }
-
-  return new TileOrientedBoundingBox(center, halfAxes);
-}
-
-function createRegion(region, transform, initialTransform, result) {
-  if (!Matrix4.equalsEpsilon(transform, initialTransform, CesiumMath.EPSILON8)) {
-    return createBoxFromTransformedRegion(region, transform, initialTransform, result);
-  }
-
-  if (defined(result)) {
-    return result;
-  }
-
-  const rectangleRegion = Rectangle.unpack(region, 0, scratchRectangle);
-
-  return new TileBoundingRegion({
-    rectangle: rectangleRegion,
-    minimumHeight: region[4],
-    maximumHeight: region[5]
-  });
-}
-*/
-function createSphere(sphere, transform, result) {
-    // Find the transformed center
-    const center = new 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;
-}
-/**
- * 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]);
-}