@openglobus/og 0.17.2 → 0.18.1

package/lib/js/astro/jd.js

@@ -0,0 +1,416 @@
+import { binarySearch } from "../utils/shared";
+/**
+ * Seconds in millisecond.
+ * @const
+ */
+export const SECONDS_PER_MILLISECOND = 0.001;
+/**
+ * Milliseconds in second.
+ * @const
+ */
+export const MILLISECONDS_PER_SECOND = 1000.0;
+/**
+ * Seconds in minute.
+ * @const
+ */
+export const SECONDS_PER_MINUTE = 60.0;
+/**
+ * One by seconds in minute.
+ * @const
+ */
+export const ONE_BY_SECONDS_PER_MINUTE = 1.0 / SECONDS_PER_MINUTE;
+/**
+ * Minutes in hour.
+ * @const
+ */
+export const MINUTES_PER_HOUR = 60.0;
+/**
+ * Hours in day.
+ * @const
+ */
+export const HOURS_PER_DAY = 24.0;
+/**
+ * One by hours in day.
+ * @const
+ */
+export const ONE_BY_HOURS_PER_DAY = 1.0 / HOURS_PER_DAY;
+/**
+ * Seconds in hour.
+ * @const
+ */
+export const SECONDS_PER_HOUR = 3600.0;
+/**
+ * One by seconds in hour.
+ * @const
+ */
+export const ONE_BY_SECONDS_PER_HOUR = 1.0 / SECONDS_PER_HOUR;
+/**
+ * Seconds in 12 hours.
+ * @const
+ */
+export const SECONDS_PER_12_HOURS = 12.0 * SECONDS_PER_HOUR;
+/**
+ * Minutes in day.
+ * @const
+ */
+export const MINUTES_PER_DAY = 1440.0;
+/**
+ * One by minutes in day.
+ * @const
+ */
+export const ONE_BY_MINUTES_PER_DAY = 1.0 / MINUTES_PER_DAY;
+/**
+ * Seconds in day.
+ * @const
+ */
+export const SECONDS_PER_DAY = 86400.0;
+/**
+ * Milliseconds in day.
+ * @const
+ */
+export const MILLISECONDS_PER_DAY = 86400000.0;
+/**
+ * One by milliseconds in day.
+ * @const
+ */
+export const ONE_BY_MILLISECONDS_PER_DAY = 1.0 / MILLISECONDS_PER_DAY;
+/**
+ * One by seconds in day.
+ * @const
+ */
+export const ONE_BY_SECONDS_PER_DAY = 1.0 / SECONDS_PER_DAY;
+/**
+ * Days in julian century.
+ * @const
+ */
+export const DAYS_PER_JULIAN_CENTURY = 36525.0;
+/**
+ * Days in julian year.
+ * @const
+ */
+export const DAYS_PER_JULIAN_YEAR = 365.25;
+/**
+ * Seconds in picoseconds.
+ * @const
+ */
+export const PICOSECOND = 0.000000001;
+/**
+ * Modified julian date difference.
+ * @const
+ */
+export const MODIFIED_JULIAN_DATE_DIFFERENCE = 2400000.5;
+/**
+ * Julian date of 2000 year. Epoch.
+ * @const
+ */
+export const J2000 = 2451545.0;
+/**
+ * Returns julian days from Epoch.
+ * @param {JulianDate} jd - Julian date.
+ * @returns {number} Days from epoch
+ */
+export function T(jd) {
+    return (jd - J2000) / DAYS_PER_JULIAN_CENTURY;
+}
+/**
+ * Gets the date's julian day.
+ * @param {number} year - Year.
+ * @param {number} month - Month.
+ * @param {number} day - Day.
+ * @returns {number} Day number
+ */
+export function getDayNumber(year, month, day) {
+    let a = ((month - 14) / 12) | 0;
+    let b = year + 4800 + a;
+    return ((((1461 * b) / 4) | 0) +
+        (((367 * (month - 2 - 12 * a)) / 12) | 0) -
+        (((3 * (((b + 100) / 100) | 0)) / 4) | 0) +
+        day -
+        32075);
+}
+/**
+ * Converts javascript date to the universal(UTC) julian date.
+ * @param {Date} date - Date.
+ * @returns {JulianDate} UTC julian date
+ */
+export function DateToUTC(date) {
+    let dayNumber = getDayNumber(date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate());
+    let hour = date.getUTCHours() - 12;
+    if (hour < 0) {
+        hour += 24;
+    }
+    let secondsOfDay = date.getUTCSeconds() +
+        hour * SECONDS_PER_HOUR +
+        date.getUTCMinutes() * SECONDS_PER_MINUTE +
+        date.getUTCMilliseconds() * SECONDS_PER_MILLISECOND;
+    if (secondsOfDay >= SECONDS_PER_12_HOURS) {
+        dayNumber--;
+    }
+    let extraDays = (secondsOfDay * ONE_BY_SECONDS_PER_DAY) | 0;
+    dayNumber += extraDays;
+    secondsOfDay -= SECONDS_PER_DAY * extraDays;
+    if (secondsOfDay < 0) {
+        dayNumber--;
+        secondsOfDay += SECONDS_PER_DAY;
+    }
+    return dayNumber + secondsOfDay * ONE_BY_SECONDS_PER_DAY;
+}
+/**
+ * Converts javascript date to the atomic(TAI) julian date.
+ * @param {Date} date - Date.
+ * @returns {JulianDate} TAI julian date
+ */
+export function DateToTAI(date) {
+    return UTCtoTAI(DateToUTC(date));
+}
+/**
+ * Converts coordinated universal(UTC) julian date to atomic(TAI) julian date.
+ * @param {JulianDate} jd - UTC julian date.
+ * @returns {JulianDate} TAI julian date
+ */
+export function UTCtoTAI(jd) {
+    let leapSeconds = leapSecondsTable;
+    let index = binarySearch(leapSeconds, jd, function (a, b) {
+        return a - b.jd;
+    });
+    if (index < 0) {
+        index = ~index;
+    }
+    if (index >= leapSeconds.length) {
+        index = leapSeconds.length - 1;
+    }
+    let offset = leapSeconds[index].leapSeconds;
+    if (index !== 0) {
+        if ((leapSeconds[index].jd - jd) * SECONDS_PER_DAY > offset) {
+            offset = leapSeconds[index - 1].leapSeconds;
+        }
+    }
+    return jd + offset * ONE_BY_SECONDS_PER_DAY;
+}
+/**
+ * Converts atomic julian date(TAI) to the coordinated universal(UTC) julian date.
+ * @param {JulianDate} tai - TAI julian date.
+ * @returns {JulianDate | undefined} UTC julian date
+ */
+export function TAItoUTC(tai) {
+    let leapSeconds = leapSecondsTable;
+    let index = binarySearch(leapSeconds, tai, function (a, b) {
+        return a - b.jd;
+    });
+    if (index < 0) {
+        index = ~index;
+    }
+    if (index >= leapSeconds.length) {
+        return tai - leapSeconds[index - 1].leapSeconds * ONE_BY_SECONDS_PER_DAY;
+    }
+    if (index === 0) {
+        return tai - leapSeconds[0].leapSeconds * ONE_BY_SECONDS_PER_DAY;
+    }
+    let diff = (leapSeconds[index].jd - tai) * SECONDS_PER_DAY;
+    if (diff === 0) {
+        return tai - leapSeconds[index].leapSeconds * ONE_BY_SECONDS_PER_DAY;
+    }
+    if (diff <= 1.0) {
+        return;
+    }
+    return tai - leapSeconds[index - 1].leapSeconds * ONE_BY_SECONDS_PER_DAY;
+}
+/**
+ * Converts UTC julian date to the javascript date object.
+ * @param {JulianDate} utc - UTC julian date.
+ * @returns {Date} JavaScript Date object
+ */
+export function UTCtoDate(utc) {
+    let julianDayNumber = utc | 0;
+    let secondsOfDay = (utc - julianDayNumber) * SECONDS_PER_DAY;
+    if (secondsOfDay >= SECONDS_PER_12_HOURS) {
+        julianDayNumber++;
+    }
+    let L = (julianDayNumber + 68569) | 0;
+    let N = ((4 * L) / 146097) | 0;
+    L = (L - (((146097 * N + 3) / 4) | 0)) | 0;
+    let I = ((4000 * (L + 1)) / 1461001) | 0;
+    L = (L - (((1461 * I) / 4) | 0) + 31) | 0;
+    let J = ((80 * L) / 2447) | 0;
+    let day = (L - (((2447 * J) / 80) | 0)) | 0;
+    L = (J / 11) | 0;
+    let month = (J + 2 - 12 * L) | 0;
+    let year = (100 * (N - 49) + I + L) | 0;
+    let hour = (secondsOfDay * ONE_BY_SECONDS_PER_HOUR) | 0;
+    let remainingSeconds = secondsOfDay - hour * SECONDS_PER_HOUR;
+    let minute = (remainingSeconds * ONE_BY_SECONDS_PER_MINUTE) | 0;
+    remainingSeconds = remainingSeconds - minute * SECONDS_PER_MINUTE;
+    let second = remainingSeconds | 0;
+    let millisecond = ((remainingSeconds - second) * MILLISECONDS_PER_SECOND) | 0;
+    hour += 12;
+    if (hour > 23) {
+        hour -= 24;
+    }
+    return new Date(Date.UTC(year, month - 1, day, hour, minute, second, millisecond));
+}
+/**
+ * Converts TAI julian date to the javascript date object.
+ * @param {JulianDate} tai - TAI julian date.
+ * @returns {Date} JavaScript Date object
+ */
+export function TAItoDate(tai) {
+    let utc = TAItoUTC(tai);
+    if (!utc) {
+        utc = TAItoUTC(addSeconds(tai, -1));
+        console.trace(`TAItoDate - can't convert ${tai.toString()} to utc.`);
+    }
+    return UTCtoDate(utc);
+}
+/**
+ * Adds milliseconds to the julian date.
+ * @param {JulianDate} jd - Julian date.
+ * @param {number} milliseconds - Milliseconds to add.
+ * @returns {JulianDate} Julian date
+ */
+export function addMilliseconds(jd, milliseconds) {
+    return jd + milliseconds * ONE_BY_MILLISECONDS_PER_DAY;
+}
+/**
+ * Adds seconds to the julian date.
+ * @param {JulianDate} jd - Julian date.
+ * @param {number} seconds - Seconds to add.
+ * @returns {JulianDate} Julian date
+ */
+export function addSeconds(jd, seconds) {
+    return jd + seconds * ONE_BY_SECONDS_PER_DAY;
+}
+/**
+ * Adds hours to the julian date.
+ * @param {JulianDate} jd - Julian date.
+ * @param {number} hours - Hours to add.
+ * @returns {JulianDate} Julian date
+ */
+export function addHours(jd, hours) {
+    return jd + hours * ONE_BY_HOURS_PER_DAY;
+}
+/**
+ * Adds minutes to the julian date.
+ * @param {JulianDate} jd - Julian date.
+ * @param {number} minutes - Minutes to add.
+ * @returns {JulianDate} Julian date
+ */
+export function addMinutes(jd, minutes) {
+    return jd + minutes * MINUTES_PER_DAY;
+}
+/**
+ * Adds days to the julian date.
+ * @param {JulianDate} jd - Julian date.
+ * @param {number} days - Days to add.
+ * @returns {JulianDate} Julian date
+ */
+export function addDays(jd, days) {
+    return jd + days;
+}
+/**
+ * Gets milliseconds of a julian date.
+ * @param {JulianDate} jd - julian date.
+ * @returns {number} Milliseconds
+ */
+export function getMilliseconds(jd) {
+    let s = jd - (jd | 0);
+    s *= SECONDS_PER_DAY;
+    return ((s - (s | 0)) * MILLISECONDS_PER_SECOND) | 0;
+}
+/**
+ * Gets seconds of a julian date.
+ * @param {JulianDate} jd - julian date.
+ * @returns {number} Seconds
+ */
+export function getSeconds(jd) {
+    let s = jd - (jd | 0);
+    return s * SECONDS_PER_DAY;
+}
+/**
+ * Gets hours of a julian date.
+ * @param {JulianDate} jd - julian date.
+ * @returns {number} Hours
+ */
+export function getHours(jd) {
+    let julianDayNumber = jd | 0;
+    let secondsOfDay = (jd - julianDayNumber) * SECONDS_PER_DAY;
+    let hour = (secondsOfDay * ONE_BY_SECONDS_PER_HOUR) | 0;
+    let remainingSeconds = secondsOfDay - hour * SECONDS_PER_HOUR;
+    let minute = (remainingSeconds * ONE_BY_SECONDS_PER_MINUTE) | 0;
+    remainingSeconds = remainingSeconds - minute * SECONDS_PER_MINUTE;
+    let second = remainingSeconds | 0;
+    let millisecond = ((remainingSeconds - second) * MILLISECONDS_PER_SECOND) | 0;
+    hour += 12 + minute / 60 + second / 3600 + millisecond / 1000;
+    if (hour > 23) {
+        hour -= 24;
+    }
+    return hour;
+}
+/**
+ * Gets minutes of a julian date.
+ * @param {JulianDate} jd - julian date.
+ * @returns {number} Minutes
+ */
+export function getMinutes(jd) {
+    let s = jd - (jd | 0);
+    return (s * MINUTES_PER_DAY) | 0;
+}
+/**
+ * Gets days of a julian date.
+ * @param {JulianDate} jd - julian date.
+ * @returns {number} Days
+ */
+export function getDays(jd) {
+    return jd | 0;
+}
+/**
+ * Returns days in seconds.
+ * @param {number} s - Seconds.
+ * @returns {number} Days
+ */
+export function secondsToDays(s) {
+    return s * ONE_BY_SECONDS_PER_DAY;
+}
+/**
+ * Returns seconds in days.
+ * @param {number} d - Days.
+ * @returns {number} Seconds
+ */
+export function daysToSeconds(d) {
+    return d * SECONDS_PER_DAY;
+}
+function __ls(jd, leapSeconds) {
+    return {
+        jd: jd,
+        leapSeconds: leapSeconds
+    };
+}
+const leapSecondsTable = [
+    __ls(2441317.5, 10.0),
+    __ls(2441499.5, 11.0),
+    __ls(2441683.5, 12.0),
+    __ls(2442048.5, 13.0),
+    __ls(2442413.5, 14.0),
+    __ls(2442778.5, 15.0),
+    __ls(2443144.5, 16.0),
+    __ls(2443509.5, 17.0),
+    __ls(2443874.5, 18.0),
+    __ls(2444239.5, 19.0),
+    __ls(2444786.5, 20.0),
+    __ls(2445151.5, 21.0),
+    __ls(2445516.5, 22.0),
+    __ls(2446247.5, 23.0),
+    __ls(2447161.5, 24.0),
+    __ls(2447892.5, 25.0),
+    __ls(2448257.5, 26.0),
+    __ls(2448804.5, 27.0),
+    __ls(2449169.5, 28.0),
+    __ls(2449534.5, 29.0),
+    __ls(2450083.5, 30.0),
+    __ls(2450630.5, 31.0),
+    __ls(2451179.5, 32.0),
+    __ls(2453736.5, 33.0),
+    __ls(2454832.5, 34.0),
+    __ls(2456109.5, 35.0),
+    __ls(2457204.5, 36.0) // 2015-07-01T00:00:00.000Z
+];
+export const J2000TAI = UTCtoTAI(J2000);

package/lib/js/astro/orbit.d.ts

@@ -0,0 +1,5 @@
+import { Mat3 } from "../math/Mat3";
+export declare function getEccentricAnomaly(M: number, ecc: number): number;
+export declare function getEllipticalEccentricAnomaly(meanAnomaly: number, eccentricity: number): number;
+export declare function getTrueAnomaly(eccentricAnomaly: number, eccentricity: number): number;
+export declare function getPerifocalToCartesianMatrix(argumentOfPeriapsis: number, inclination: number, rightAscension: number): Mat3;

package/lib/js/astro/orbit.js

@@ -0,0 +1,104 @@
+import * as math from "../math";
+import { Mat3 } from "../math/Mat3";
+export function getEccentricAnomaly(M, ecc) {
+    if (ecc === 0.0) {
+        // Circular orbit
+        return M;
+    }
+    else if (ecc < 0.2) {
+        // Low eccentricity, so use the standard iteration technique
+        return math.solve_iteration_fixed(solveKeplerFunc1(ecc, M), M, 5);
+    }
+    else if (ecc < 0.9) {
+        // Higher eccentricity elliptical orbit; use a more complex but
+        // much faster converging iteration.
+        return math.solve_iteration_fixed(solveKeplerFunc2(ecc, M), M, 6);
+    }
+    else if (ecc < 1.0) {
+        // Extremely stable Laguerre-Conway method for solving Kepler's
+        // equation.  Only use this for high-eccentricity orbits, as it
+        // requires more calculation.
+        let E = M + 0.85 * ecc * Math.sign(Math.sin(M));
+        return math.solve_iteration_fixed(solveKeplerLaguerreConway(ecc, M), E, 8);
+    }
+    else if (ecc === 1.0) {
+        // TODO: Parabolic orbit
+        return M;
+    }
+    else {
+        // Laguerre-Conway method for hyperbolic (ecc > 1) orbits.
+        let E = Math.log((2 * M) / ecc + 1.85);
+        return math.solve_iteration_fixed(solveKeplerLaguerreConwayHyp(ecc, M), E, 30);
+    }
+}
+// Standard iteration for solving Kepler's Equation
+function solveKeplerFunc1(ecc, M) {
+    return function (x) {
+        return M + ecc * Math.sin(x);
+    };
+}
+// Faster converging iteration for Kepler's Equation; more efficient
+// than above for orbits with eccentricities greater than 0.3.  This
+// is from Jean Meeus's _Astronomical Algorithms_ (2nd ed), p. 199
+function solveKeplerFunc2(ecc, M) {
+    return function (x) {
+        return x + (M + ecc * Math.sin(x) - x) / (1 - ecc * Math.cos(x));
+    };
+}
+function solveKeplerLaguerreConway(ecc, M) {
+    return function (x) {
+        const s = ecc * Math.sin(x);
+        const c = ecc * Math.cos(x);
+        const f = x - s - M;
+        const f1 = 1 - c;
+        x += (-5 * f) / (f1 + Math.sign(f1) * Math.sqrt(Math.abs(16 * f1 * f1 - 20 * f * s)));
+        return x;
+    };
+}
+function solveKeplerLaguerreConwayHyp(ecc, M) {
+    return function (x) {
+        const s = ecc * Math.sinh(x);
+        const c = ecc * Math.cosh(x);
+        const f = s - x - M;
+        const f1 = c - 1;
+        x += (-5 * f) / (f1 + Math.sign(f1) * Math.sqrt(Math.abs(16 * f1 * f1 - 20 * f * s)));
+        return x;
+    };
+}
+export function getEllipticalEccentricAnomaly(meanAnomaly, eccentricity) {
+    const tol = 0.00000001745;
+    let iterations = 20;
+    let e = meanAnomaly - 2.0 * Math.PI * ((meanAnomaly / (2.0 * Math.PI)) | 0);
+    let err = 1;
+    while (Math.abs(err) > tol && iterations > 0) {
+        err = e - eccentricity * Math.sin(e) - meanAnomaly;
+        let delta = err / (1 - eccentricity * Math.cos(e));
+        e -= delta;
+        iterations--;
+    }
+    return e;
+}
+export function getTrueAnomaly(eccentricAnomaly, eccentricity) {
+    const revs = Math.floor(eccentricAnomaly / math.TWO_PI);
+    eccentricAnomaly -= revs * math.TWO_PI;
+    let trueAnomaly = Math.atan2(Math.sin(eccentricAnomaly) * Math.sqrt(1 - eccentricity * eccentricity), Math.cos(eccentricAnomaly) - eccentricity);
+    trueAnomaly = math.zeroTwoPI(trueAnomaly);
+    if (eccentricAnomaly < 0) {
+        trueAnomaly -= math.TWO_PI;
+    }
+    return trueAnomaly + revs * math.TWO_PI;
+}
+export function getPerifocalToCartesianMatrix(argumentOfPeriapsis, inclination, rightAscension) {
+    let res = new Mat3();
+    let cosap = Math.cos(argumentOfPeriapsis), sinap = Math.sin(argumentOfPeriapsis), cosi = Math.cos(inclination), sini = Math.sin(inclination), cosraan = Math.cos(rightAscension), sinraan = Math.sin(rightAscension);
+    res._m[0] = cosraan * cosap - sinraan * sinap * cosi;
+    res._m[1] = sinraan * cosap + cosraan * sinap * cosi;
+    res._m[2] = sinap * sini;
+    res._m[3] = -cosraan * sinap - sinraan * cosap * cosi;
+    res._m[4] = -sinraan * sinap + cosraan * cosap * cosi;
+    res._m[5] = cosap * sini;
+    res._m[6] = sinraan * sini;
+    res._m[7] = -cosraan * sini;
+    res._m[8] = cosi;
+    return res;
+}

package/lib/js/astro/rotation.d.ts

@@ -0,0 +1,2 @@
+import { Mat3 } from "../math/Mat3";
+export declare function getRotationMatrix(rightAscension: number, declination: number, res?: Mat3): Mat3;

package/lib/js/astro/rotation.js

@@ -0,0 +1,25 @@
+import { PI_TWO } from "../math";
+import { Mat3 } from "../math/Mat3";
+import { Vec3 } from "../math/Vec3";
+export function getRotationMatrix(rightAscension, declination, res) {
+    let xAxis = new Vec3(), zAxis = new Vec3();
+    res = res || new Mat3();
+    xAxis.x = Math.cos(rightAscension + PI_TWO);
+    xAxis.y = Math.sin(rightAscension + PI_TWO);
+    xAxis.z = 0.0;
+    let cosDec = Math.cos(declination);
+    zAxis.x = cosDec * Math.cos(rightAscension);
+    zAxis.y = cosDec * Math.sin(rightAscension);
+    zAxis.z = Math.sin(declination);
+    let yAxis = zAxis.cross(xAxis);
+    res._m[0] = xAxis.x;
+    res._m[1] = yAxis.x;
+    res._m[2] = zAxis.x;
+    res._m[3] = xAxis.y;
+    res._m[4] = yAxis.y;
+    res._m[5] = zAxis.y;
+    res._m[6] = xAxis.z;
+    res._m[7] = yAxis.z;
+    res._m[8] = zAxis.z;
+    return res;
+}

package/lib/js/bv/Box.d.ts

@@ -0,0 +1,32 @@
+import { Vec3 } from "../math/Vec3";
+import { NumberArray6 } from "./Sphere";
+import { Ellipsoid } from "../ellipsoid/Ellipsoid";
+import { Extent } from "../Extent";
+type Vec3Array8 = [Vec3, Vec3, Vec3, Vec3, Vec3, Vec3, Vec3, Vec3];
+/**
+ * Bounding box class.
+ * @class
+ * @param {NumberArray6} [boundsArr]
+ */
+declare class Box {
+    /**
+     * Vertices array.
+     * @public
+     * @type{Array.<Vec3>}
+     */
+    vertices: Vec3Array8;
+    constructor(boundsArr?: NumberArray6);
+    copy(bbox: Box): void;
+    /**
+     * Sets bounding box coordinates by the bounds array.
+     * @param {NumberArray6} bounds - Bounds is an array where [minX, minY, minZ, maxX, maxY, maxZ]
+     */
+    setFromBoundsArr(bounds: NumberArray6): void;
+    /**
+     * Sets bounding box coordinates by ellipsoid geodetic extend.
+     * @param {Ellipsoid} ellipsoid - Ellipsoid.
+     * @param {Extent} extent - Geodetic extent.
+     */
+    setFromExtent(ellipsoid: Ellipsoid, extent: Extent): void;
+}
+export { Box };

package/lib/js/bv/Box.js

@@ -0,0 +1,53 @@
+import { Vec3 } from "../math/Vec3";
+/**
+ * Bounding box class.
+ * @class
+ * @param {NumberArray6} [boundsArr]
+ */
+class Box {
+    constructor(boundsArr) {
+        this.vertices = [
+            new Vec3(),
+            new Vec3(),
+            new Vec3(),
+            new Vec3(),
+            new Vec3(),
+            new Vec3(),
+            new Vec3(),
+            new Vec3()
+        ];
+        if (boundsArr) {
+            this.setFromBoundsArr(boundsArr);
+        }
+    }
+    copy(bbox) {
+        for (let i = 0, len = this.vertices.length; i < len; i++) {
+            this.vertices[i].copy(bbox.vertices[i]);
+        }
+    }
+    /**
+     * Sets bounding box coordinates by the bounds array.
+     * @param {NumberArray6} bounds - Bounds is an array where [minX, minY, minZ, maxX, maxY, maxZ]
+     */
+    setFromBoundsArr(bounds) {
+        let xmin = bounds[0], xmax = bounds[3], ymin = bounds[1], ymax = bounds[4], zmin = bounds[2], zmax = bounds[5];
+        let v = this.vertices;
+        v[0].set(xmin, ymin, zmin);
+        v[1].set(xmax, ymin, zmin);
+        v[2].set(xmax, ymin, zmax);
+        v[3].set(xmin, ymin, zmax);
+        v[4].set(xmin, ymax, zmin);
+        v[5].set(xmax, ymax, zmin);
+        v[6].set(xmax, ymax, zmax);
+        v[7].set(xmin, ymax, zmax);
+    }
+    /**
+     * Sets bounding box coordinates by ellipsoid geodetic extend.
+     * @param {Ellipsoid} ellipsoid - Ellipsoid.
+     * @param {Extent} extent - Geodetic extent.
+     */
+    setFromExtent(ellipsoid, extent) {
+        this.setFromBoundsArr(extent.getCartesianBounds(ellipsoid));
+    }
+}
+export { Box };

package/lib/js/bv/Sphere.d.ts

@@ -0,0 +1,37 @@
+import { Vec3 } from "../math/Vec3";
+import { Ellipsoid } from "../ellipsoid/Ellipsoid";
+import { Extent } from "../Extent";
+export type NumberArray6 = [number, number, number, number, number, number];
+/**
+ * Bounding sphere class.
+ * @class
+ * @param {Number} [radius] - Bounding sphere radius.
+ * @param {Vec3} [center] - Bounding sphere coordinates.
+ */
+declare class Sphere {
+    /**
+     * Sphere radius.
+     * @public
+     * @type {Number}
+     */
+    radius: number;
+    /**
+     * Sphere coordinates.
+     * @public
+     * @type {Vec3}
+     */
+    center: Vec3;
+    constructor(radius?: number, center?: Vec3);
+    /**
+     * Sets bounding sphere coordinates by the bounds array.
+     * @param {Array.<number>} bounds - Bounds is an array where [minX, minY, minZ, maxX, maxY, maxZ]
+     */
+    setFromBounds(bounds: NumberArray6): void;
+    /**
+     * Sets bounding sphere coordinates by ellipsoid geodetic extend.
+     * @param {Ellipsoid} ellipsoid - Ellipsoid.
+     * @param {Extent} extent - Geodetic extent.
+     */
+    setFromExtent(ellipsoid: Ellipsoid, extent: Extent): void;
+}
+export { Sphere };