@openglobus/og 0.16.2 → 0.17.0

package/src/og/astro/orbit.js

@@ -1,123 +1,119 @@
-/**
- * @module og/astro/orbit
- */
-
-"use strict";
-
-import * as math from "../math.js";
-import { Mat3 } from "../math/Mat3.js";
-
-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 calcuation.
-        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) {
-        var s = ecc * Math.sin(x);
-        var c = ecc * Math.cos(x);
-        var f = x - s - M;
-        var f1 = 1 - c;
-        var f2 = s;
-        x += (-5 * f) / (f1 + Math.sign(f1) * Math.sqrt(Math.abs(16 * f1 * f1 - 20 * f * f2)));
-        return x;
-    };
-}
-
-function solveKeplerLaguerreConwayHyp(ecc, M) {
-    return function (x) {
-        var s = ecc * Math.sinh(x);
-        var c = ecc * Math.cosh(x);
-        var f = s - x - M;
-        var f1 = c - 1;
-        var f2 = s;
-        x += (-5 * f) / (f1 + Math.sign(f1) * Math.sqrt(Math.abs(16 * f1 * f1 - 20 * f * f2)));
-        return x;
-    };
-}
-
-export function getEllipticalEccentricAnomaly(meanAnomaly, eccentricity) {
-    var tol = 0.00000001745;
-    var iterations = 20;
-    var e = meanAnomaly - 2.0 * Math.PI * ((meanAnomaly / (2.0 * Math.PI)) | 0);
-    var err = 1;
-    while (Math.abs(err) > tol && iterations > 0) {
-        err = e - eccentricity * Math.sin(e) - meanAnomaly;
-        var delta = err / (1 - eccentricity * Math.cos(e));
-        e -= delta;
-        iterations--;
-    }
-    return e;
-}
-
-export function getTrueAnomaly(eccentricAnomaly, eccentricity) {
-    var revs = Math.floor(eccentricAnomaly / math.TWO_PI);
-    eccentricAnomaly -= revs * math.TWO_PI;
-    var 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) {
-    var res = new Mat3();
-    var 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;
-}
+"use strict";
+
+import * as math from "../math.js";
+import { Mat3 } from "../math/Mat3.js";
+
+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 calcuation.
+        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) {
+        var s = ecc * Math.sin(x);
+        var c = ecc * Math.cos(x);
+        var f = x - s - M;
+        var f1 = 1 - c;
+        var f2 = s;
+        x += (-5 * f) / (f1 + Math.sign(f1) * Math.sqrt(Math.abs(16 * f1 * f1 - 20 * f * f2)));
+        return x;
+    };
+}
+
+function solveKeplerLaguerreConwayHyp(ecc, M) {
+    return function (x) {
+        var s = ecc * Math.sinh(x);
+        var c = ecc * Math.cosh(x);
+        var f = s - x - M;
+        var f1 = c - 1;
+        var f2 = s;
+        x += (-5 * f) / (f1 + Math.sign(f1) * Math.sqrt(Math.abs(16 * f1 * f1 - 20 * f * f2)));
+        return x;
+    };
+}
+
+export function getEllipticalEccentricAnomaly(meanAnomaly, eccentricity) {
+    var tol = 0.00000001745;
+    var iterations = 20;
+    var e = meanAnomaly - 2.0 * Math.PI * ((meanAnomaly / (2.0 * Math.PI)) | 0);
+    var err = 1;
+    while (Math.abs(err) > tol && iterations > 0) {
+        err = e - eccentricity * Math.sin(e) - meanAnomaly;
+        var delta = err / (1 - eccentricity * Math.cos(e));
+        e -= delta;
+        iterations--;
+    }
+    return e;
+}
+
+export function getTrueAnomaly(eccentricAnomaly, eccentricity) {
+    var revs = Math.floor(eccentricAnomaly / math.TWO_PI);
+    eccentricAnomaly -= revs * math.TWO_PI;
+    var 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) {
+    var res = new Mat3();
+    var 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/src/og/astro/rotation.js

@@ -1,40 +1,36 @@
-/**
- * @module og/astro/rotation
- */
-
-"use strict";
-
-import { PI_TWO } from "../math.js";
-import { Mat3 } from "../math/Mat3.js";
-import { Vec3 } from "../math/Vec3.js";
-
-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;
-}
+"use strict";
+
+import { PI_TWO } from "../math.js";
+import { Mat3 } from "../math/Mat3.js";
+import { Vec3 } from "../math/Vec3.js";
+
+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/src/og/bv/Box.js

@@ -1,81 +1,77 @@
-/**
- * @module og/bv/Box
- */
-
-"use strict";
-
-import { Vec3 } from "../math/Vec3.js";
-
-/**
- * Bounding box class.
- * @class
- */
-class Box {
-    /**
-     *
-     * @param {*} boundsArr
-     */
-    constructor(boundsArr = [0, 0, 0, 0, 0, 0]) {
-        /**
-         * Vertices array.
-         * @public
-         * @type{Array.<Vec3>}
-         */
-        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 {Array.<number>} bounds - Bounds is an array where [minX, minY, minZ, maxX, maxY, maxZ]
-     */
-    setFromBoundsArr(bounds) {
-        var xmin = bounds[0],
-            xmax = bounds[3],
-            ymin = bounds[1],
-            ymax = bounds[4],
-            zmin = bounds[2],
-            zmax = bounds[5];
-
-        var 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 coordiantes by ellipsoid geodetic extend.
-     * @param {Ellipsoid} ellipsoid - Ellipsoid.
-     * @param {Extent} extent - Geodetic extent.
-     */
-    setFromExtent(ellipsoid, extent) {
-        this.setFromBoundsArr(extent.getCartesianBounds(ellipsoid));
-    }
-}
-
-export { Box };
-
+"use strict";
+
+import { Vec3 } from "../math/Vec3.js";
+
+/**
+ * Bounding box class.
+ * @class
+ */
+class Box {
+    /**
+     *
+     * @param {*} boundsArr
+     */
+    constructor(boundsArr = [0, 0, 0, 0, 0, 0]) {
+        /**
+         * Vertices array.
+         * @public
+         * @type{Array.<Vec3>}
+         */
+        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 {Array.<number>} bounds - Bounds is an array where [minX, minY, minZ, maxX, maxY, maxZ]
+     */
+    setFromBoundsArr(bounds) {
+        var xmin = bounds[0],
+            xmax = bounds[3],
+            ymin = bounds[1],
+            ymax = bounds[4],
+            zmin = bounds[2],
+            zmax = bounds[5];
+
+        var 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/src/og/bv/Sphere.js

@@ -1,61 +1,57 @@
-/**
- * @module og/bv/Sphere
- */
-
-"use strict";
-
-import { Vec3 } from "../math/Vec3.js";
-
-/**
- * Bounding sphere class.
- * @class
- * @param {Number} [radius] - Bounding sphere radius.
- * @param {Vec3} [center] - Bounding sphere coordiantes.
- */
-class Sphere {
-    /**
-     *
-     * @param {number} radius
-     * @param {Vec3} center
-     */
-    constructor(radius = 0, center = Vec3.ZERO) {
-        /**
-         * Sphere radius.
-         * @public
-         * @type {Number}
-         */
-        this.radius = radius;
-
-        /**
-         * Sphere coordiantes.
-         * @public
-         * @type {Vec3}
-         */
-        this.center = center ? center.clone() : new 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) {
-        let m = new Vec3(bounds[0], bounds[1], bounds[2]);
-        this.center.set(
-            m.x + (bounds[3] - m.x) * 0.5,
-            m.y + (bounds[3] - m.y) * 0.5,
-            m.z + (bounds[5] - m.z) * 0.5
-        );
-        this.radius = this.center.distance(m);
-    }
-
-    /**
-     * Sets bounding sphere coordiantes by ellipsoid geodetic extend.
-     * @param {Ellipsoid} ellipsoid - Ellipsoid.
-     * @param {Extent} extent - Geodetic extent.
-     */
-    setFromExtent(ellipsoid, extent) {
-        this.setFromBounds(extent.getCartesianBounds(ellipsoid));
-    }
-}
-
-export { Sphere };
+"use strict";
+
+import { Vec3 } from "../math/Vec3.js";
+
+/**
+ * Bounding sphere class.
+ * @class
+ * @param {Number} [radius] - Bounding sphere radius.
+ * @param {Vec3} [center] - Bounding sphere coordinates.
+ */
+class Sphere {
+    /**
+     *
+     * @param {number} radius
+     * @param {Vec3} center
+     */
+    constructor(radius = 0, center = Vec3.ZERO) {
+        /**
+         * Sphere radius.
+         * @public
+         * @type {Number}
+         */
+        this.radius = radius;
+
+        /**
+         * Sphere coordinates.
+         * @public
+         * @type {Vec3}
+         */
+        this.center = center ? center.clone() : new 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) {
+        let m = new Vec3(bounds[0], bounds[1], bounds[2]);
+        this.center.set(
+            m.x + (bounds[3] - m.x) * 0.5,
+            m.y + (bounds[3] - m.y) * 0.5,
+            m.z + (bounds[5] - m.z) * 0.5
+        );
+        this.radius = this.center.distance(m);
+    }
+
+    /**
+     * Sets bounding sphere coordinates by ellipsoid geodetic extend.
+     * @param {Ellipsoid} ellipsoid - Ellipsoid.
+     * @param {Extent} extent - Geodetic extent.
+     */
+    setFromExtent(ellipsoid, extent) {
+        this.setFromBounds(extent.getCartesianBounds(ellipsoid));
+    }
+}
+
+export { Sphere };