@wemap/geo 2.7.8 → 3.0.0

package/src/coordinates/UserPosition.spec.js

@@ -0,0 +1,220 @@
+/* eslint-disable max-statements */
+import chai from 'chai';
+import chaiAlmost from 'chai-almost';
+
+import UserPosition from './UserPosition';
+import Level from './Level';
+import Coordinates from './Coordinates';
+
+const expect = chai.expect;
+chai.use(chaiAlmost());
+
+describe('UserPosition', () => {
+
+    it('creation', () => {
+
+        expect(() => new UserPosition()).throw(Error);
+
+        expect(() => new UserPosition(45)).throw(Error);
+        expect(() => new UserPosition(45, 5)).not.throw(Error);
+        expect(() => new UserPosition(45, 5, null)).not.throw(Error);
+        expect(() => new UserPosition(45, 5, null, null)).not.throw(Error);
+
+        expect(() => new UserPosition(45, 5, null, null, null)).not.throw(Error);
+        expect(() => new UserPosition(45, 5, null, null, 0)).not.throw(Error);
+        expect(() => new UserPosition(45, 5, null, null, 10)).not.throw(Error);
+        expect(() => new UserPosition(45, 5, null, null, -10)).not.throw(Error);
+        expect(() => new UserPosition(45, 5, null, null, Number.POSITIVE_INFINITY)).throw(Error);
+
+        expect(() => new UserPosition(45, 5, null, null, null, null)).not.throw(Error);
+        expect(() => new UserPosition(45, 5, null, null, null, 0)).not.throw(Error);
+        expect(() => new UserPosition(45, 5, null, null, null, 10)).not.throw(Error);
+        expect(() => new UserPosition(45, 5, null, null, null, -10)).throw(Error);
+        expect(() => new UserPosition(45, 5, null, null, null, Number.POSITIVE_INFINITY)).throw(Error);
+
+        expect(() => new UserPosition(45, 5, null, null, null,
+            null, null)).not.throw(Error);
+        expect(() => new UserPosition(45, 5, null, null, null,
+            null, 0)).not.throw(Error);
+        expect(() => new UserPosition(45, 5, null, null, null,
+            null, 10)).not.throw(Error);
+        expect(() => new UserPosition(45, 5, null, null, null,
+            null, -10)).not.throw(Error);
+        expect(() => new UserPosition(45, 5, null, null, null,
+            null, Number.POSITIVE_INFINITY)).throw(Error);
+
+        const position = new UserPosition(45, 5, 0, new Level(2), 123456, 10, Math.PI, 'foo');
+        expect(position.lat).equals(45);
+        expect(position.lng).equals(5);
+        expect(position.alt).equals(0);
+        expect(Level.equalsTo(position.level, new Level(2))).true;
+        expect(position.time).equals(123456);
+        expect(position.accuracy).equals(10);
+        expect(position.bearing).equals(Math.PI);
+
+    });
+
+    it('update', () => {
+        const position = new UserPosition(0, 0);
+        position.lat = 45;
+        position.lng = 5;
+        position.alt = 0;
+        position.level = new Level(2);
+        position.time = 123456;
+        position.accuracy = 10;
+        position.bearing = Math.PI;
+        expect(position.lat).equals(45);
+        expect(position.lng).equals(5);
+        expect(position.alt).equals(0);
+        expect(Level.equalsTo(position.level, new Level(2))).true;
+        expect(position.time).equals(123456);
+        expect(position.accuracy).equals(10);
+        expect(position.bearing).equals(Math.PI);
+
+    });
+
+    it('fromCoordinates', () => {
+        const level = new Level(2);
+        const coordinates = new Coordinates(45, 5, 0, level, 123456);
+        const position = UserPosition.fromCoordinates(coordinates);
+        expect(position).instanceOf(UserPosition);
+        expect(position.lat).equals(45);
+        expect(position.lng).equals(5);
+        expect(position.alt).equals(0);
+        expect(Level.equalsTo(position.level, level)).true;
+        expect(position.time).is.null;
+        expect(position.accuracy).is.null;
+        expect(position.bearing).is.null;
+    });
+
+
+    it('clone', () => {
+        const level = new Level(2);
+        const position = new UserPosition(45, 5, 0, level, 123456, 10, Math.PI);
+        const clonePosition = position.clone();
+
+        expect(clonePosition.lat).equals(45);
+        expect(clonePosition.lng).equals(5);
+        expect(clonePosition.alt).equals(0);
+        expect(Level.equalsTo(clonePosition.level, level)).true;
+        expect(clonePosition.level).not.equals(level);
+        expect(clonePosition.time).equals(123456);
+        expect(clonePosition.accuracy).equals(10);
+        expect(clonePosition.bearing).equals(Math.PI);
+    });
+
+
+    it('equalsTo', () => {
+        let position, position2;
+
+        expect(UserPosition.equalsTo(null, null)).true;
+
+        position = new UserPosition(0, 0);
+        expect(UserPosition.equalsTo(position, new UserPosition(0, 0))).true;
+        expect(UserPosition.equalsTo(position, new Coordinates(0, 0))).false;
+
+        position = new UserPosition(45, 5, 0, new Level(2), 123456, 10, Math.PI);
+        expect(UserPosition.equalsTo(position,
+            new UserPosition(45, 5, 0, new Level(2), 123456, 10, Math.PI)
+        )).true;
+
+        position2 = position.clone();
+        position2.lat = 0;
+        expect(UserPosition.equalsTo(position, position2)).false;
+
+        position2 = position.clone();
+        position2.lng = 0;
+        expect(UserPosition.equalsTo(position, position2)).false;
+
+        position2 = position.clone();
+        position2.alt = 10;
+        expect(UserPosition.equalsTo(position, position2)).false;
+
+        position2 = position.clone();
+        position2.level = null;
+        expect(UserPosition.equalsTo(position, position2)).false;
+
+        position2 = position.clone();
+        position2.time = 0;
+        expect(UserPosition.equalsTo(position, position2)).false;
+
+        position2 = position.clone();
+        position2.accuracy = 0;
+        expect(UserPosition.equalsTo(position, position2)).false;
+
+        position2 = position.clone();
+        position2.bearing = 0;
+        expect(UserPosition.equalsTo(position, position2)).false;
+
+        expect(position.equalsTo(
+            new UserPosition(45, 5, 0, new Level(2), 123456, 10, Math.PI)
+        )).true;
+        expect(position.equalsTo(
+            new UserPosition(45, 5, 0, new Level(2), 123456, 0, Math.PI)
+        )).false;
+    });
+
+    it('json', () => {
+        let position;
+
+        position = new UserPosition(5, -10);
+        expect(position.toJson()).to.deep.equal({
+            lat: 5,
+            lng: -10
+        });
+
+        position = new UserPosition(5, -10);
+        position.alt = 2;
+        expect(position.toJson()).to.deep.equal({
+            lat: 5,
+            lng: -10,
+            alt: 2
+        });
+
+        position = new UserPosition(5, -10);
+        position.level = new Level(2);
+        expect(position.toJson()).to.deep.equal({
+            lat: 5,
+            lng: -10,
+            level: '2'
+        });
+
+        position = new UserPosition(5, -10);
+        position.time = 10;
+        expect(position.toJson()).to.deep.equal({
+            lat: 5,
+            lng: -10,
+            time: 10
+        });
+
+        position = new UserPosition(5, -10);
+        position.accuracy = 10;
+        expect(position.toJson()).to.deep.equal({
+            lat: 5,
+            lng: -10,
+            accuracy: 10
+        });
+
+        position = new UserPosition(5, -10);
+        position.bearing = Math.PI;
+        expect(position.toJson()).to.deep.equal({
+            lat: 5,
+            lng: -10,
+            bearing: Math.PI
+        });
+
+        position = new UserPosition(5, -10);
+        expect(UserPosition.equalsTo(
+            UserPosition.fromJson(position.toJson()),
+            position)
+        ).true;
+
+        position = new UserPosition(45, 5, 0, new Level(2), 123456, 10, Math.PI);
+        expect(UserPosition.equalsTo(
+            UserPosition.fromJson(position.toJson()),
+            position)
+        ).true;
+
+    });
+
+});

package/src/rotations/AbsoluteHeading.js

@@ -0,0 +1,138 @@
+import isNumber from 'lodash.isnumber';
+import isFinite from 'lodash.isfinite';
+
+import { Quaternion } from '@wemap/maths';
+import Attitude from './Attitude';
+
+class AbsoluteHeading {
+
+    _heading = null;
+    _time = null;
+    _accuracy = null;
+
+    /**
+     *
+     * @param {Number} heading
+     * @param {Number} time
+     * @param {Number} accuracy
+     */
+    constructor(heading, time, accuracy) {
+        this.heading = heading;
+        this.time = time;
+        this.accuracy = accuracy;
+    }
+
+    /**
+     * @returns {Number}
+     */
+    get heading() {
+        return this._heading;
+    }
+
+    /**
+     * @param {Number} heading
+     */
+    set heading(heading) {
+        if (isNumber(heading) && isFinite(heading)) {
+            this._heading = heading;
+        } else {
+            throw new Error('heading argument is not a number');
+        }
+    }
+
+    /**
+     * @returns {Number}
+     */
+    get time() {
+        return this._time;
+    }
+
+    /**
+     * @param {Number} time
+     */
+    set time(time) {
+        if (isNumber(time) && isFinite(time)) {
+            this._time = time;
+        } else {
+            if (typeof time !== 'undefined' && time !== null) {
+                throw new Error('time argument is not a number');
+            }
+            this._time = null;
+        }
+    }
+
+    /**
+     * @returns {Number}
+     */
+    get accuracy() {
+        return this._accuracy;
+    }
+
+    /**
+     * @param {Number} accuracy
+     */
+    set accuracy(accuracy) {
+        if (isNumber(accuracy) && accuracy >= 0 && accuracy <= Math.PI) {
+            this._accuracy = accuracy;
+        } else {
+            if (typeof accuracy !== 'undefined' && accuracy !== null) {
+                throw new Error('accuracy argument (' + accuracy + ') is not in range [0; PI]');
+            }
+            this._accuracy = null;
+        }
+    }
+
+    /**
+     * @returns {Attitude}
+     */
+    toAttitude() {
+        /**
+         * Heading is given around z-axis in NED frame and our attitude in ENU frame, that is why
+         *  -1* is applied to heading.
+         */
+        return new Attitude(
+            Quaternion.fromAxisAngle([0, 0, 1], -this.heading),
+            this.time,
+            this.accuracy
+        );
+    }
+
+
+    /**
+     * Compares two AbsoluteHeading
+     * @param {AbsoluteHeading} heading1 heading 1
+     * @param {AbsoluteHeading} heading2 heading 2
+     */
+    static equalsTo(heading1, heading2) {
+
+        // Handle null comparison
+        if (heading1 === null && heading1 === heading2) {
+            return true;
+        }
+
+        if (!(heading1 instanceof AbsoluteHeading) || !(heading2 instanceof AbsoluteHeading)) {
+            return false;
+        }
+
+        return Math.abs(heading1.heading, heading2.heading) < 1e-8;
+    }
+
+    equalsTo(other) {
+        return AbsoluteHeading.equalsTo(this, other);
+    }
+
+    toJson() {
+        return {
+            accuracy: this.accuracy,
+            heading: this.heading,
+            time: this.time
+        };
+    }
+
+    static fromJson(json) {
+        return new AbsoluteHeading(json);
+    }
+
+}
+
+export default AbsoluteHeading;

package/src/rotations/Attitude.js

@@ -1,3 +1,6 @@
+import isNumber from 'lodash.isnumber';
+import isFinite from 'lodash.isfinite';
+
 import {
     Rotations, Quaternion, rad2deg, deg2rad
 } from '@wemap/maths';
@@ -7,19 +10,35 @@ class Attitude {
     _quaternion = [1, 0, 0, 0];
     _heading = null;
     _eulerAngles = null;
+    _time = null;
+    _accuracy = null;
 
-    constructor(quaternion) {
+    /**
+     *
+     * @param {Number[]} quaternion
+     * @param {Number} time
+     * @param {Number} accuracy
+     */
+    constructor(quaternion, time, accuracy) {
         this.quaternion = quaternion;
+        this.time = time;
+        this.accuracy = accuracy;
     }
 
     static unitary() {
         return new Attitude([1, 0, 0, 0]);
     }
 
+    /**
+     * @returns {Number[]}
+     */
     get quaternion() {
         return this._quaternion;
     }
 
+    /**
+     * @param {Number[]} quaternion
+     */
     set quaternion(quaternion) {
         if (!Array.isArray(quaternion)
             || quaternion.length !== 4
@@ -27,6 +46,50 @@ class Attitude {
             throw new Error('quaternion is not a unit quaternion');
         }
         this._quaternion = quaternion;
+        this._heading = null;
+        this._eulerAngles = null;
+    }
+
+    /**
+     * @returns {Number}
+     */
+    get time() {
+        return this._time;
+    }
+
+    /**
+     * @param {Number} time
+     */
+    set time(time) {
+        if (isNumber(time) && isFinite(time)) {
+            this._time = time;
+        } else {
+            if (typeof time !== 'undefined' && time !== null) {
+                throw new Error('time argument is not a number');
+            }
+            this._time = null;
+        }
+    }
+
+    /**
+     * @returns {Number}
+     */
+    get accuracy() {
+        return this._accuracy;
+    }
+
+    /**
+     * @param {Number} accuracy
+     */
+    set accuracy(accuracy) {
+        if (isNumber(accuracy) && accuracy >= 0 && accuracy <= Math.PI) {
+            this._accuracy = accuracy;
+        } else {
+            if (typeof accuracy !== 'undefined' && accuracy !== null) {
+                throw new Error('accuracy argument (' + accuracy + ') is not in range [0; PI]');
+            }
+            this._accuracy = null;
+        }
     }
 
     get eulerAngles() {

package/src/rotations/Attitude.spec.js

@@ -1,7 +1,9 @@
+/* eslint-disable max-statements */
 import chai from 'chai';
 import chaiAlmost from 'chai-almost';
 
 import Attitude from './Attitude';
+import { deg2rad } from '@wemap/maths';
 
 const expect = chai.expect;
 chai.use(chaiAlmost());
@@ -20,6 +22,42 @@ describe('Attitude', () => {
         expect(() => new Attitude([0.5, 0.5, 0.5, 0.5])).not.throw(Error);
         expect(() => new Attitude([Math.sqrt(2) / 2, Math.sqrt(2) / 2, 0, 0])).not.throw(Error);
         expect(Attitude.unitary().quaternion).deep.equals([1, 0, 0, 0]);
+
+        expect(() => new Attitude([1, 0, 0, 0])).not.throw(Error);
+
+        expect(() => new Attitude([1, 0, 0, 0], 10)).not.throw(Error);
+        expect(() => new Attitude([1, 0, 0, 0], -1)).not.throw(Error);
+        expect(() => new Attitude([1, 0, 0, 0], false)).throw(Error);
+        expect(() => new Attitude([1, 0, 0, 0], true)).throw(Error);
+        expect(() => new Attitude([1, 0, 0, 0], null)).not.throw(Error);
+        expect(() => new Attitude([1, 0, 0, 0], Number.POSITIVE_INFINITY)).throw(Error);
+
+        expect(() => new Attitude([1, 0, 0, 0], 10, deg2rad(10))).not.throw(Error);
+        expect(() => new Attitude([1, 0, 0, 0], 10, -1)).throw(Error);
+        expect(() => new Attitude([1, 0, 0, 0], 10, 0)).not.throw(Error);
+        expect(() => new Attitude([1, 0, 0, 0], 10, 10)).throw(Error);
+        expect(() => new Attitude([1, 0, 0, 0], 10, Math.PI)).not.throw(Error);
+        expect(() => new Attitude([1, 0, 0, 0], 10, true)).throw(Error);
+        expect(() => new Attitude([1, 0, 0, 0], 10, false)).throw(Error);
+        expect(() => new Attitude([1, 0, 0, 0], 10, null)).not.throw(Error);
+
+
+        const attitude = new Attitude([1, 0, 0, 0], 10, deg2rad(10), 'foo');
+        expect(attitude.quaternion).deep.equals([1, 0, 0, 0]);
+        expect(attitude.time).equals(10);
+        expect(attitude.accuracy).equals(deg2rad(10));
+    });
+
+
+    it('update', () => {
+        const attitude = new Attitude([1, 0, 0, 0]);
+        attitude.quaternion = [0, 1, 0, 0];
+        attitude.time = 123456;
+        attitude.accuracy = 2;
+        expect(attitude.quaternion).deep.equals([0, 1, 0, 0]);
+        expect(attitude.time).equals(123456);
+        expect(attitude.accuracy).equals(2);
+
     });
 
     it('eulerAngles', () => {