@wemap/geo 10.0.0-alpha.11 → 10.0.0-alpha.6

package/index.d.ts

@@ -85,7 +85,6 @@ declare module '@wemap/geo' {
         static unitary(): Attitude;
         static equals(attitude1: Attitude, attitude2: Attitude): boolean;
         static fromJson(json: AttitudeJson): Attitude;
-        static diff(attitudeStart: Attitude, attitudeEnd: Attitude): Attitude;
     }
 
     export class GeoRef {

package/package.json

@@ -13,7 +13,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "10.0.0-alpha.11",
+    "version": "10.0.0-alpha.6",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -28,8 +28,8 @@
     ],
     "license": "ISC",
     "dependencies": {
-        "@wemap/logger": "^10.0.0-alpha.8",
-        "@wemap/maths": "^10.0.0-alpha.11"
+        "@wemap/logger": "^9.0.0",
+        "@wemap/maths": "^9.0.0"
     },
-    "gitHead": "51207f18c96fb4693c7719c6dcb0d73642d6ebb2"
+    "gitHead": "a2f0ceaabb22c5a9a7b7642993a55abe25c3efba"
 }

package/src/coordinates/GeoRef.js

@@ -23,7 +23,7 @@ class GeoRef {
         const rotationOffset = Quaternion.fromAxisAngle([0, 0, 1], this.heading);
         const enuToEcefRotationOrigin = Quaternion.multiply(rotationOffset, this.origin.enuToEcefRotation);
         const ecefTranslation = Quaternion.rotate(enuToEcefRotationOrigin, enuTranslationScaled);
-        const ecef = Vector3.sum(this.origin.ecef, ecefTranslation);
+        const ecef = Vector3.add(this.origin.ecef, ecefTranslation);
         return Coordinates.fromECEF(ecef);
     }
 

package/src/graph/Network.js

@@ -161,15 +161,8 @@ class Network {
 
         const network = new Network();
 
-        const getOrCreateNode = coords => {
-            const node = network.nodes.find(otherNode => otherNode.coords.equals(coords));
-            if (node) {
-                return node;
-            }
-            const newNode = new GraphNode(coords);
-            network.nodes.push(newNode);
-            return newNode;
-        };
+        const getOrCreateNode = coords =>
+            network.nodes.find(_coords => _coords.equals(coords)) || new GraphNode(coords);
 
 
         const createEdgeFromNodes = (node1, node2) =>
@@ -186,6 +179,7 @@ class Network {
                     network.edges.push(edge);
                 }
 
+                network.nodes.push(currentNode);
                 previousNode = currentNode;
             }
         }

package/src/rotations/Attitude.js

@@ -187,30 +187,6 @@ class Attitude {
     clone() {
         return new Attitude(this.quaternion.slice(0), this.time, this.accuracy);
     }
-
-    /**
-     * Calculate the relative attitude between two given attitudes
-     * @param {Attitude} attitudeStart
-     * @param {Attitude} attitudeEnd
-     * @returns {Attitude}
-     */
-    static diff(attitudeStart, attitudeEnd) {
-
-        const quaternionDiff = Quaternion.multiply(
-            Quaternion.inverse(attitudeStart.quaternion),
-            attitudeEnd.quaternion
-        );
-
-        const timeDiff = attitudeEnd.time - attitudeStart.time;
-
-        let accuracyDiff = null;
-        if (attitudeStart.accuracy !== null && attitudeEnd.accuracy !== null) {
-            // Approximation
-            accuracyDiff = Math.max(attitudeEnd.accuracy - attitudeStart.accuracy);
-        }
-
-        return new Attitude(quaternionDiff, timeDiff, accuracyDiff);
-    }
 }
 
 export default Attitude;

package/src/rotations/Attitude.spec.js

@@ -230,19 +230,19 @@ describe('Attitude', () => {
         expect(attitude.equals(Attitude.fromJson(attitude.toJson()))).true;
 
         attitude = new Attitude([1, 0, 0, 0], 2);
-        expect(attitude.toJson()).deep.equals({ q: [1, 0, 0, 0], time: 2 });
+        expect(attitude.toJson()).deep.equals({q: [1, 0, 0, 0], time: 2});
         attitudeBis = Attitude.fromJson(attitude.toJson());
         expect(attitude.equals(attitudeBis)).true;
         expect(attitudeBis.time).equals(2);
 
         attitude = new Attitude([1, 0, 0, 0], null, 3);
-        expect(attitude.toJson()).deep.equals({ q: [1, 0, 0, 0], accuracy: 3 });
+        expect(attitude.toJson()).deep.equals({q: [1, 0, 0, 0], accuracy: 3});
         attitudeBis = Attitude.fromJson(attitude.toJson());
         expect(attitude.equals(attitudeBis)).true;
         expect(attitudeBis.accuracy).equals(3);
 
         attitude = new Attitude([1, 0, 0, 0], 2, 3);
-        expect(attitude.toJson()).deep.equals({ q: [1, 0, 0, 0], time: 2, accuracy: 3 });
+        expect(attitude.toJson()).deep.equals({q: [1, 0, 0, 0], time: 2, accuracy: 3});
         attitudeBis = Attitude.fromJson(attitude.toJson());
         expect(attitude.equals(attitudeBis)).true;
         expect(attitudeBis.time).equals(2);
@@ -250,34 +250,4 @@ describe('Attitude', () => {
 
     });
 
-    it('diff', () => {
-
-        let startAttitude, endAttitude, diffAttitude;
-
-        startAttitude = new Attitude(LAYED_PORTRAIT_NORTH, 0, 0);
-        endAttitude = new Attitude(LAYED_PORTRAIT_EAST, 2, Math.PI / 4);
-        diffAttitude = Attitude.diff(startAttitude, endAttitude);
-        checkAngles(diffAttitude.heading, Math.PI / 2);
-        expect(Quaternion.equals(diffAttitude.quaternion, Quaternion.fromAxisAngle([0, 0, 1], -Math.PI / 2))).true;
-        expect(diffAttitude.time).equals(2);
-        expect(diffAttitude.accuracy).equals(Math.PI / 4);
-
-        endAttitude = new Attitude(LAYED_PORTRAIT_SOUTH);
-        diffAttitude = Attitude.diff(startAttitude, endAttitude);
-        checkAngles(diffAttitude.heading, Math.PI);
-        expect(Quaternion.equals(diffAttitude.quaternion, Quaternion.fromAxisAngle([0, 0, 1], Math.PI))).true;
-
-        endAttitude = new Attitude(STAND_PORTRAIT_NORTH);
-        diffAttitude = Attitude.diff(startAttitude, endAttitude);
-        checkAngles(diffAttitude.heading, 0);
-        expect(Quaternion.equals(diffAttitude.quaternion, Quaternion.fromAxisAngle([1, 0, 0], Math.PI / 2))).true;
-
-        startAttitude = new Attitude(STAND_PORTRAIT_SOUTH);
-        endAttitude = new Attitude(STAND_PORTRAIT_EAST);
-        diffAttitude = Attitude.diff(startAttitude, endAttitude);
-        checkAngles(diffAttitude.heading, -Math.PI / 2);
-        expect(Quaternion.equals(diffAttitude.quaternion, Quaternion.fromAxisAngle([0, 1, 0], Math.PI / 2))).true;
-
-    });
-
 });