@openglobus/og 0.17.1 → 0.18.0

package/src/{og/astro/orbit.js → astro/orbit.ts}

@@ -1,9 +1,9 @@
-"use strict";
+import * as math from "../math";
+import {Mat3} from "../math/Mat3";
 
-import * as math from "../math.js";
-import { Mat3 } from "../math/Mat3.js";
+type Func = (x: number) => number;
 
-export function getEccentricAnomaly(M, ecc) {
+export function getEccentricAnomaly(M: number, ecc: number): number {
     if (ecc == 0.0) {
         // Circular orbit
         return M;
@@ -17,7 +17,7 @@ export function getEccentricAnomaly(M, ecc) {
     } 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.
+        // 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) {
@@ -31,8 +31,8 @@ export function getEccentricAnomaly(M, ecc) {
 }
 
 // Standard iteration for solving Kepler's Equation
-function solveKeplerFunc1(ecc, M) {
-    return function (x) {
+function solveKeplerFunc1(ecc: number, M: number): Func {
+    return function (x: number) {
         return M + ecc * Math.sin(x);
     };
 }
@@ -40,54 +40,52 @@ function solveKeplerFunc1(ecc, M) {
 // 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) {
+function solveKeplerFunc2(ecc: number, M: number): Func {
+    return function (x: number) {
         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)));
+function solveKeplerLaguerreConway(ecc: number, M: number): Func {
+    return function (x: number) {
+        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) {
-        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)));
+function solveKeplerLaguerreConwayHyp(ecc: number, M: number): Func {
+    return function (x: number) {
+        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) {
-    var tol = 0.00000001745;
-    var iterations = 20;
-    var e = meanAnomaly - 2.0 * Math.PI * ((meanAnomaly / (2.0 * Math.PI)) | 0);
-    var err = 1;
+export function getEllipticalEccentricAnomaly(meanAnomaly: number, eccentricity: number): number {
+    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;
-        var delta = err / (1 - eccentricity * Math.cos(e));
+        let 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);
+export function getTrueAnomaly(eccentricAnomaly: number, eccentricity: number): number {
+    const revs = Math.floor(eccentricAnomaly / math.TWO_PI);
     eccentricAnomaly -= revs * math.TWO_PI;
-    var trueAnomaly = Math.atan2(
+    let trueAnomaly = Math.atan2(
         Math.sin(eccentricAnomaly) * Math.sqrt(1 - eccentricity * eccentricity),
         Math.cos(eccentricAnomaly) - eccentricity
     );
@@ -98,9 +96,9 @@ export function getTrueAnomaly(eccentricAnomaly, eccentricity) {
     return trueAnomaly + revs * math.TWO_PI;
 }
 
-export function getPerifocalToCartesianMatrix(argumentOfPeriapsis, inclination, rightAscension) {
-    var res = new Mat3();
-    var cosap = Math.cos(argumentOfPeriapsis),
+export function getPerifocalToCartesianMatrix(argumentOfPeriapsis: number, inclination: number, rightAscension: number): Mat3 {
+    let res = new Mat3();
+    let cosap = Math.cos(argumentOfPeriapsis),
         sinap = Math.sin(argumentOfPeriapsis),
         cosi = Math.cos(inclination),
         sini = Math.sin(inclination),

package/src/{og/astro/rotation.js → astro/rotation.ts}

@@ -1,10 +1,8 @@
-"use strict";
+import { PI_TWO } from "../math";
+import { Mat3 } from "../math/Mat3";
+import { Vec3 } from "../math/Vec3";
 
-import { PI_TWO } from "../math.js";
-import { Mat3 } from "../math/Mat3.js";
-import { Vec3 } from "../math/Vec3.js";
-
-export function getRotationMatrix(rightAscension, declination, res) {
+export function getRotationMatrix(rightAscension: number, declination: number, res?: Mat3): Mat3 {
     let xAxis = new Vec3(),
         zAxis = new Vec3();
 

package/src/{og/bv/Box.js → bv/Box.ts}

@@ -1,22 +1,26 @@
-"use strict";
+import {Vec3} from "../math/Vec3";
+import {NumberArray6} from "./Sphere";
+import {Ellipsoid} from "../ellipsoid/Ellipsoid";
+import {Extent} from "../Extent";
 
-import { Vec3 } from "../math/Vec3.js";
+type Vec3Array8 = [Vec3, Vec3, Vec3, Vec3, Vec3, Vec3, Vec3, Vec3];
 
 /**
  * Bounding box class.
  * @class
+ * @param {NumberArray6} [boundsArr]
  */
 class Box {
+
     /**
-     *
-     * @param {*} boundsArr
+     * Vertices array.
+     * @public
+     * @type{Array.<Vec3>}
      */
-    constructor(boundsArr = [0, 0, 0, 0, 0, 0]) {
-        /**
-         * Vertices array.
-         * @public
-         * @type{Array.<Vec3>}
-         */
+    public vertices: Vec3Array8
+
+    constructor(boundsArr?: NumberArray6) {
+
         this.vertices = [
             new Vec3(),
             new Vec3(),
@@ -33,7 +37,7 @@ class Box {
         }
     }
 
-    copy(bbox) {
+    public copy(bbox: Box) {
         for (let i = 0, len = this.vertices.length; i < len; i++) {
             this.vertices[i].copy(bbox.vertices[i]);
         }
@@ -41,17 +45,17 @@ class Box {
 
     /**
      * Sets bounding box coordinates by the bounds array.
-     * @param {Array.<number>} bounds - Bounds is an array where [minX, minY, minZ, maxX, maxY, maxZ]
+     * @param {NumberArray6} bounds - Bounds is an array where [minX, minY, minZ, maxX, maxY, maxZ]
      */
-    setFromBoundsArr(bounds) {
-        var xmin = bounds[0],
+    public setFromBoundsArr(bounds: NumberArray6) {
+        let xmin = bounds[0],
             xmax = bounds[3],
             ymin = bounds[1],
             ymax = bounds[4],
             zmin = bounds[2],
             zmax = bounds[5];
 
-        var v = this.vertices;
+        let v = this.vertices;
 
         v[0].set(xmin, ymin, zmin);
         v[1].set(xmax, ymin, zmin);
@@ -68,10 +72,10 @@ class Box {
      * @param {Ellipsoid} ellipsoid - Ellipsoid.
      * @param {Extent} extent - Geodetic extent.
      */
-    setFromExtent(ellipsoid, extent) {
+    public setFromExtent(ellipsoid: Ellipsoid, extent: Extent) {
         this.setFromBoundsArr(extent.getCartesianBounds(ellipsoid));
     }
 }
 
-export { Box };
+export {Box};
 

package/src/{og/bv/Sphere.js → bv/Sphere.ts}

@@ -1,6 +1,8 @@
-"use strict";
+import {Vec3} from "../math/Vec3";
+import {Ellipsoid} from "../ellipsoid/Ellipsoid";
+import {Extent} from "../Extent";
 
-import { Vec3 } from "../math/Vec3.js";
+export type NumberArray6 = [number, number, number, number, number, number];
 
 /**
  * Bounding sphere class.
@@ -10,23 +12,23 @@ import { Vec3 } from "../math/Vec3.js";
  */
 class Sphere {
     /**
-     *
-     * @param {number} radius
-     * @param {Vec3} center
+     * Sphere radius.
+     * @public
+     * @type {Number}
      */
-    constructor(radius = 0, center = Vec3.ZERO) {
-        /**
-         * Sphere radius.
-         * @public
-         * @type {Number}
-         */
+    public radius: number;
+
+    /**
+     * Sphere coordinates.
+     * @public
+     * @type {Vec3}
+     */
+    public center: Vec3;
+
+    constructor(radius: number = 0, center?: Vec3) {
+
         this.radius = radius;
 
-        /**
-         * Sphere coordinates.
-         * @public
-         * @type {Vec3}
-         */
         this.center = center ? center.clone() : new Vec3();
     }
 
@@ -34,7 +36,7 @@ class Sphere {
      * 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) {
+    public setFromBounds(bounds: NumberArray6) {
         let m = new Vec3(bounds[0], bounds[1], bounds[2]);
         this.center.set(
             m.x + (bounds[3] - m.x) * 0.5,
@@ -49,9 +51,9 @@ class Sphere {
      * @param {Ellipsoid} ellipsoid - Ellipsoid.
      * @param {Extent} extent - Geodetic extent.
      */
-    setFromExtent(ellipsoid, extent) {
+    public setFromExtent(ellipsoid: Ellipsoid, extent: Extent) {
         this.setFromBounds(extent.getCartesianBounds(ellipsoid));
     }
 }
 
-export { Sphere };
+export {Sphere};

package/src/bv/index.ts

@@ -0,0 +1,4 @@
+import { Box } from './Box';
+import { Sphere } from './Sphere';
+
+export { Box, Sphere };