@wemap/geo 1.0.5 → 2.7.1

package/src/rotations/Attitude.js

@@ -1,63 +1,89 @@
 import {
-    Rotations, Utils as MathUtils, Quaternion
+    Rotations, Quaternion, rad2deg, deg2rad
 } from '@wemap/maths';
 
-const rotxM90 = Quaternion.fromAxisAngle([1, 0, 0], -Math.PI / 2);
-
 class Attitude {
 
-    quaternion = [1, 0, 0, 0];
-    quaternionThreeJsV = null;
-    headingV = null;
-    headingDegreesV = null;
-    eulerAnglesV = null;
-    eulerAnglesDegreesV = null;
+    _quaternion = [1, 0, 0, 0];
+    _heading = null;
+    _eulerAngles = null;
 
     constructor(quaternion) {
         this.quaternion = quaternion;
     }
 
+    static unitary() {
+        return new Attitude([1, 0, 0, 0]);
+    }
+
+    get quaternion() {
+        return this._quaternion;
+    }
+
+    set quaternion(quaternion) {
+        if (!Array.isArray(quaternion)
+            || quaternion.length !== 4
+            || Math.abs(1 - Quaternion.norm(quaternion)) > 1e-4) {
+            throw new Error('quaternion is not a unit quaternion');
+        }
+        this._quaternion = quaternion;
+    }
+
     get eulerAngles() {
-        if (!this.eulerAnglesV) {
-            this.eulerAnglesV = Rotations.quaternionToEulerZXY(this.quaternion);
+        if (this._eulerAngles === null) {
+            this._eulerAngles = Rotations.quaternionToEulerZXY(this.quaternion);
         }
-        return this.eulerAnglesV;
+        return this._eulerAngles;
     }
 
     get eulerAnglesDegrees() {
-        if (!this.eulerAnglesDegreesV) {
-            this.eulerAnglesDegreesV = Rotations.quaternionToEulerZXYDegrees(this.quaternion);
-        }
-        return this.eulerAnglesDegreesV;
+        return this.eulerAngles.map(x => rad2deg(x));
     }
 
     get heading() {
-        if (!this.headingV) {
-            this.headingV = Rotations.getHeadingFromQuaternion(this.quaternion) + MathUtils.deg2rad(window.orientation || 0);
+        if (this._heading === null) {
+            let offset = 0;
+            if (global.window && global.window.orientation) {
+                offset = deg2rad(global.window.orientation);
+            }
+            this._heading = Rotations.getHeadingFromQuaternion(this.quaternion) + offset;
         }
-        return this.headingV;
+        return this._heading;
     }
 
     get headingDegrees() {
-        if (!this.headingDegreesV) {
-            this.headingDegreesV = MathUtils.rad2deg(Rotations.getHeadingFromQuaternion(this.quaternion)) + (window.orientation || 0);
-        }
-        return this.headingDegreesV;
+        return rad2deg(this.heading);
     }
 
-    get quaternionThreeJs() {
-        if (!this.quaternionThreeJsV) {
-            this.quaternionThreeJsV = Quaternion.wxyz2xyzw(Quaternion.multiply(rotxM90, this.quaternion));
+    /**
+     * Compares two Attitude
+     * @param {Attitude} att1 attitude 1
+     * @param {Attitude} att2 attitude 2
+     */
+    static equalsTo(att1, att2) {
+
+        // Handle null comparison
+        if (att1 === null && att1 === att2) {
+            return true;
+        }
+
+        if (!(att1 instanceof Attitude) || !(att2 instanceof Attitude)) {
+            return false;
         }
-        return this.quaternionThreeJsV;
+
+        return Quaternion.distance(att1.quaternion, att2.quaternion) < 1e-8;
+    }
+
+    equalsTo(other) {
+        return Attitude.equalsTo(this, other);
     }
 
-    toMessage() {
+    toJson() {
         return this.quaternion;
     }
 
-    static fromMessage(message) {
-        return new Attitude(message);
+    static fromJson(json) {
+        return new Attitude(json);
     }
 
 }

package/src/rotations/Attitude.spec.js

@@ -0,0 +1,82 @@
+import chai from 'chai';
+import chaiAlmost from 'chai-almost';
+
+import Attitude from './Attitude';
+
+const expect = chai.expect;
+chai.use(chaiAlmost());
+
+describe('Attitude', () => {
+
+    it('creation', () => {
+        expect(() => new Attitude()).throw(Error);
+        expect(() => new Attitude(true)).throw(Error);
+        expect(() => new Attitude(false)).throw(Error);
+        expect(() => new Attitude([])).throw(Error);
+        expect(() => new Attitude([1])).throw(Error);
+        expect(() => new Attitude([1, 2, 3, 4])).throw(Error);
+        expect(() => new Attitude([1, 1, 1, 1])).throw(Error);
+        expect(() => new Attitude([0, 0, 0, 1])).not.throw(Error);
+        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]);
+    });
+
+    it('eulerAngles', () => {
+
+        const attitude = new Attitude([1, 0, 0, 0]);
+        expect(attitude.eulerAngles).deep.equals([0, 0, 0]);
+        expect(attitude.eulerAngles).deep.equals([0, 0, 0]);
+
+        expect(new Attitude([0, 1, 0, 0]).eulerAngles).deep.equals([Math.PI, 0, Math.PI]);
+        expect(new Attitude([0, 0, 1, 0]).eulerAngles).deep.equals([0, 0, Math.PI]);
+        expect(new Attitude([0, 0, 0, 1]).eulerAngles).deep.equals([Math.PI, 0, 0]);
+
+        expect(new Attitude([1, 0, 0, 0]).eulerAnglesDegrees).deep.equals([0, 0, 0]);
+        expect(new Attitude([0, 0, 1, 0]).eulerAnglesDegrees).deep.equals([0, 0, 180]);
+    });
+
+    it('heading', () => {
+        const attitude = new Attitude([1, 0, 0, 0]);
+        expect(attitude.heading).equals(0);
+        expect(attitude.heading).equals(0);
+
+        expect(new Attitude([Math.sqrt(2) / 2, Math.sqrt(2) / 2, 0, 0]).heading).equals(0);
+        expect(new Attitude([-0.5, 0.5, 0.5, 0.5]).heading).equals(Math.PI / 2);
+
+        const tmpWindow = global.window;
+        global.window = { orientation: 90 };
+        expect(new Attitude([1, 0, 0, 0]).heading).equals(Math.PI / 2);
+        expect(new Attitude([Math.sqrt(2) / 2, Math.sqrt(2) / 2, 0, 0]).heading).equals(Math.PI / 2);
+        expect(new Attitude([-0.5, 0.5, 0.5, 0.5]).heading).equals(Math.PI);
+        global.window = tmpWindow;
+
+        expect(new Attitude([-0.5, 0.5, 0.5, 0.5]).headingDegrees).equals(90);
+    });
+
+    it('equalsTo', () => {
+
+        expect(Attitude.equalsTo(null, null)).true;
+        expect(Attitude.equalsTo(new Attitude([-0.5, 0.5, 0.5, 0.5]), new Attitude([1, 0, 0, 0]))).false;
+        expect(Attitude.equalsTo([-0.5, 0.5, 0.5, 0.5], new Attitude([1, 0, 0, 0]))).false;
+        expect(Attitude.equalsTo(new Attitude([1, 0, 0, 0]), [-0.5, 0.5, 0.5, 0.5])).false;
+        expect(new Attitude([1, 0, 0, 0]).equalsTo(new Attitude([1, 0, 0, 0]))).true;
+        expect(new Attitude([-0.5, 0.5, 0.5, 0.5]).equalsTo(new Attitude([-0.5, 0.5, 0.5, 0.5]))).true;
+
+    });
+
+
+    it('json', () => {
+
+        let attitude;
+
+        attitude = new Attitude([1, 0, 0, 0]);
+        expect(attitude.toJson()).deep.equals([1, 0, 0, 0]);
+        expect(attitude.equalsTo(Attitude.fromJson(attitude.toJson()))).true;
+
+        attitude = new Attitude([-0.5, 0.5, 0.5, 0.5]);
+        expect(attitude.toJson()).deep.equals([-0.5, 0.5, 0.5, 0.5]);
+        expect(attitude.equalsTo(Attitude.fromJson(attitude.toJson()))).true;
+    });
+
+});