@wemap/geo 10.0.0-alpha.0 → 10.0.0-alpha.10

package/index.d.ts

@@ -16,9 +16,6 @@ declare module '@wemap/geo' {
         static toString(level: Level_t): string;
         static equals(first: Level_t, second: Level_t): boolean;
         static diff(first: Level_t, second: Level_t): null | number;
-
-        /** @deprecated */
-        static fromLegacy(level: (null | { isRange: boolean, val?: number, low?: number, up?: number })): Level_t;
     }
 
     type CoordinatesCompressedJson = [number, number] |
@@ -65,22 +62,6 @@ declare module '@wemap/geo' {
         toCompressedJson(): CoordinatesCompressedJson;
         static fromJson(json: CoordinatesJson): Coordinates;
         static fromCompressedJson(json: CoordinatesCompressedJson): Coordinates;
-
-        /** @deprecated */
-        toLegacyJson(): any;
-        /** @deprecated */
-        toLegacyCompressedJson():
-            [number, number] |
-            [number, number, number] |
-            [number, number, number, string] |
-            [number, number, null, string];
-        /** @deprecated */
-        static fromLegacyCompressedJson(json:
-            [number, number] |
-            [number, number, number] |
-            [number, number, number, string] |
-            [number, number, null, string]): Coordinates;
-
     }
 
     export type AttitudeJson = Quaternion_t
@@ -104,6 +85,7 @@ 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.0",
+    "version": "10.0.0-alpha.10",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -28,8 +28,8 @@
     ],
     "license": "ISC",
     "dependencies": {
-        "@wemap/logger": "^9.0.0",
-        "@wemap/maths": "^9.0.0"
+        "@wemap/logger": "^10.0.0-alpha.8",
+        "@wemap/maths": "^10.0.0-alpha.10"
     },
-    "gitHead": "d98a62dea33f5bcd93bc0eda133242da9fe441e3"
+    "gitHead": "5970289ef2b1f06f9df382878f72bf48f57c4c00"
 }

package/src/coordinates/Coordinates.js

@@ -1,5 +1,3 @@
-import Logger from '@wemap/logger';
-
 import {
     deg2rad, Vector3, Quaternion, rad2deg, wrap
 } from '@wemap/maths';
@@ -448,32 +446,11 @@ class Coordinates {
         return output;
     }
 
-    /**
-     * @returns {!Object}
-     */
-    toLegacyJson() {
-        const output = {
-            lat: this.lat,
-            lng: this.lng
-        };
-        if (this.alt !== null) {
-            output.alt = this.alt;
-        }
-        if (this.level !== null) {
-            output.level = Level.toString(this.level);
-        }
-        return output;
-    }
-
     /**
      * @param {!Object} json
      * @returns {!Coordinates}
      */
     static fromJson(json) {
-        if (typeof json.level === 'string') {
-            Logger.warn('Still using legacy level format. Please update your project.');
-            return new Coordinates(json.lat, json.lng, json.alt, Level.fromString(json.level));
-        }
         return new Coordinates(json.lat, json.lng, json.alt, json.level);
     }
 
@@ -491,21 +468,6 @@ class Coordinates {
         return output;
     }
 
-    /**
-     * @returns {!Object}
-     * @deprecated
-     */
-    toLegacyCompressedJson() {
-        const output = [this.lat, this.lng];
-        if (this.alt !== null || this.level !== null) {
-            output.push(this.alt);
-        }
-        if (this.level !== null) {
-            output.push(Level.toString(this.level));
-        }
-        return output;
-    }
-
     /**
      * @param {!Object} json
      * @returns {!Coordinates}
@@ -516,27 +478,7 @@ class Coordinates {
             coords.alt = json[2];
         }
         if (json.length > 3) {
-            if (typeof json[3] === 'string') {
-                Logger.warn('Still using legacy level format. Please update your project.');
-                coords.level = Level.fromString(json[3]);
-            } else {
-                coords.level = json[3];
-            }
-        }
-        return coords;
-    }
-
-    /**
-     * @param {!Object} json
-     * @returns {!Coordinates}
-     */
-    static fromLegacyCompressedJson(json) {
-        const coords = new Coordinates(json[0], json[1]);
-        if (json.length > 2) {
-            coords.alt = json[2];
-        }
-        if (json.length > 3) {
-            coords.level = Level.fromString(json[3]);
+            coords.level = json[3];
         }
         return coords;
     }

package/src/coordinates/Coordinates.spec.js

@@ -250,12 +250,6 @@ describe('Coordinates', () => {
             level: [1, 2]
         });
 
-        expect(new Coordinates(5, -10, null, [1, 2]).toLegacyJson()).to.deep.equal({
-            lat: 5,
-            lng: -10,
-            level: '1;2'
-        });
-
         expect(new Coordinates(5, -10, 3, [1, 2]).toJson()).to.deep.equal({
             lat: 5,
             lng: -10,
@@ -263,13 +257,6 @@ describe('Coordinates', () => {
             level: [1, 2]
         });
 
-        expect(new Coordinates(5, -10, 3, [1, 2]).toLegacyJson()).to.deep.equal({
-            lat: 5,
-            lng: -10,
-            alt: 3,
-            level: '1;2'
-        });
-
         let position;
 
         position = new Coordinates(0, 0);
@@ -296,20 +283,10 @@ describe('Coordinates', () => {
         ).true;
 
         expect(Coordinates.equals(
-            Coordinates.fromCompressedJson([5, -10, null, '1']),
-            new Coordinates(5, -10, null, 1))
-        ).true;
-
-        expect(Coordinates.equals(
-            Coordinates.fromCompressedJson([5, -10, null, '1;2']),
+            Coordinates.fromCompressedJson([5, -10, null, [1, 2]]),
             new Coordinates(5, -10, null, [1, 2]))
         ).true;
 
-        expect(Coordinates.equals(
-            Coordinates.fromCompressedJson([5, -10, 10, '2;3']),
-            new Coordinates(5, -10, 10, [2, 3]))
-        ).true;
-
     });
 
 });

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.add(this.origin.ecef, ecefTranslation);
+        const ecef = Vector3.sum(this.origin.ecef, ecefTranslation);
         return Coordinates.fromECEF(ecef);
     }
 

package/src/coordinates/Level.js

@@ -331,20 +331,6 @@ class Level {
 
         return null;
     }
-
-    /**
-     * @param {null|{isRange: boolean, val?: number, low?: number, up?: number}} legacyLevel
-     * @deprecated
-     */
-    static fromLegacy(legacyLevel) {
-        if (legacyLevel === null) {
-            return null;
-        }
-        if (legacyLevel.isRange) {
-            return [legacyLevel.low, legacyLevel.up];
-        }
-        return legacyLevel.val;
-    }
 }
 
 export default Level;

package/src/coordinates/Level.spec.js

@@ -225,15 +225,4 @@ describe('Level', () => {
         expect(Level.diff([0, 1], [0, 1])).equals(0);
         expect(Level.diff([0, 1], [0, 2])).is.null;
     });
-
-
-    it('fromLegacy', () => {
-        expect(Level.fromLegacy(null)).is.null;
-        expect(Level.fromLegacy({ isRange: false, val: 0 })).equals(0);
-        expect(Level.fromLegacy({ isRange: false, val: 6 })).equals(6);
-        expect(Level.fromLegacy({ isRange: false, val: -5 })).equals(-5);
-        expect(Level.fromLegacy({ isRange: true, low: 0, up: 1 })).deep.equals([0, 1]);
-        expect(Level.fromLegacy({ isRange: true, low: -5, up: 5 })).deep.equals([-5, 5]);
-    });
-
 });

package/src/graph/GraphNode.js

@@ -1,5 +1,3 @@
-import Logger from '@wemap/logger';
-
 import Coordinates from '../coordinates/Coordinates.js';
 import Level from '../coordinates/Level.js';
 
@@ -107,14 +105,12 @@ class GraphNode {
                 } else {
                     tmpLevel = Level.intersection(tmpLevel, edge.level);
                     if (tmpLevel === null) {
-                        Logger.error('Error: Something bad happend during parsing: We cannot retrieve node level from adjacent ways: ' + this.coords);
-                        return false;
+                        throw Error('Something bad happend during parsing: We cannot retrieve node level from adjacent ways: ' + this.coords);
                     }
                 }
             }
         }
         this.coords.level = tmpLevel;
-        return true;
     }
 
 
@@ -124,14 +120,14 @@ class GraphNode {
     _inferNodeLevelByRecursion() {
         const { level } = this.coords;
         if (level === null || !Level.isRange(level)) {
-            return true;
+            return;
         }
 
         /**
          * We can infer node level only if this one have one edge attached
          */
         if (this.edges.length > 1) {
-            return true;
+            return;
         }
 
         /**
@@ -169,13 +165,10 @@ class GraphNode {
         if (othersLevels !== null) {
             if (!Level.isRange(othersLevels)) {
                 this.coords.level = othersLevels === level[0] ? level[1] : level[0];
-                return true;
+                return;
             }
-            Logger.warn('Level of: ' + this.coords.toString() + ' cannot be decided');
-            return false;
+            throw Error('Level of: ' + this.coords.toString() + ' cannot be decided');
         }
-
-        return true;
     }
 
     /**
@@ -215,23 +208,17 @@ class GraphNode {
      * @param {GraphNode[]} nodes
      */
     static generateNodesLevels(nodes) {
-        const success = nodes.reduce((acc, node) => acc && node._generateLevelFromEdges(), true);
-        if (!success) {
-            return false;
-        }
+
+        nodes.forEach(node => node._generateLevelFromEdges());
 
         // In some cases, node levels cannot be retrieve just using adjacent edges
         // (e.g stairs without network at one of its bounds)
         // To infer this node level, we use inferNodeLevelByRecursion()
-        const res = nodes.reduce((acc, node) => acc
-            && node._inferNodeLevelByNeighboors()
-            && node._inferNodeLevelByRecursion()
-        , true);
+        nodes.forEach(node => node._inferNodeLevelByNeighboors());
+        nodes.forEach(node => node._inferNodeLevelByRecursion());
 
         // Finally define nodes that are links between indoor and outdoor
         nodes.forEach(node => node._checkIO());
-
-        return res;
     }
 }
 

package/src/graph/GraphNode.spec.js

@@ -86,23 +86,23 @@ describe('GraphNode', () => {
          */
 
         nodes = cleanNodesWithAdjEdges(1, 0);
-        expect(GraphNode.generateNodesLevels(nodes)).false;
+        expect(() => GraphNode.generateNodesLevels(nodes)).throw(Error);
         expect(nodes[0].coords.level).is.null;
 
         nodes = cleanNodesWithAdjEdges(1, 1);
-        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(() => GraphNode.generateNodesLevels(nodes)).not.throw(Error);
         expect(Level.equals(nodes[0].coords.level, 1)).true;
 
         nodes = cleanNodesWithAdjEdges(1, [1, 2]);
-        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(() => GraphNode.generateNodesLevels(nodes)).not.throw(Error);
         expect(Level.equals(nodes[0].coords.level, 1)).true;
 
         nodes = cleanNodesWithAdjEdges([0, 1], [1, 2]);
-        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(() => GraphNode.generateNodesLevels(nodes)).not.throw(Error);
         expect(Level.equals(nodes[0].coords.level, 1)).true;
 
         nodes = cleanNodesWithAdjEdges([0, 1]);
-        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(() => GraphNode.generateNodesLevels(nodes)).not.throw(Error);
         expect(Level.equals(nodes[0].coords.level, [0, 1])).true;
 
         /**
@@ -113,7 +113,7 @@ describe('GraphNode', () => {
         new GraphEdge(nodes[0], nodes[1], 1, 'e0');
         new GraphEdge(nodes[1], nodes[2], [1, 2], 'e1');
         new GraphEdge(nodes[2], nodes[3], [1, 2], 'e2');
-        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(() => GraphNode.generateNodesLevels(nodes)).not.throw(Error);
         expect(Level.equals(nodes[0].coords.level, 1)).true;
         expect(Level.equals(nodes[1].coords.level, 1)).true;
         expect(Level.equals(nodes[2].coords.level, [1, 2])).true;
@@ -125,14 +125,14 @@ describe('GraphNode', () => {
         new GraphEdge(nodes[1], nodes[2], [1, 2], 'e1');
         new GraphEdge(nodes[2], nodes[3], [1, 2], 'e2');
         new GraphEdge(nodes[2], nodes[4], null, 'e3');
-        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(() => GraphNode.generateNodesLevels(nodes)).not.throw(Error);
 
 
         nodes = cleanNodes(4);
         new GraphEdge(nodes[0], nodes[1], 1, 'e0');
         new GraphEdge(nodes[1], nodes[2], [0, 1], 'e1');
         new GraphEdge(nodes[2], nodes[3], [0, 1], 'e2');
-        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(() => GraphNode.generateNodesLevels(nodes)).not.throw(Error);
         expect(Level.equals(nodes[0].coords.level, 1)).true;
         expect(Level.equals(nodes[1].coords.level, 1)).true;
         expect(Level.equals(nodes[2].coords.level, [0, 1])).true;
@@ -144,7 +144,7 @@ describe('GraphNode', () => {
         new GraphEdge(nodes[1], nodes[2], [1, 2], 'e1');
         new GraphEdge(nodes[2], nodes[3], [1, 2], 'e2');
         new GraphEdge(nodes[1], nodes[3], 1, 'e3');
-        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(() => GraphNode.generateNodesLevels(nodes)).not.throw(Error);
         expect(Level.equals(nodes[0].coords.level, 1)).true;
         expect(Level.equals(nodes[1].coords.level, 1)).true;
         expect(Level.equals(nodes[2].coords.level, 2)).true;
@@ -156,7 +156,7 @@ describe('GraphNode', () => {
         new GraphEdge(nodes[1], nodes[2], [0, 1], 'e1');
         new GraphEdge(nodes[2], nodes[3], [0, 1], 'e2');
         new GraphEdge(nodes[1], nodes[3], 1, 'e3');
-        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(() => GraphNode.generateNodesLevels(nodes)).not.throw(Error);
         expect(Level.equals(nodes[0].coords.level, 1)).true;
         expect(Level.equals(nodes[1].coords.level, 1)).true;
         expect(Level.equals(nodes[2].coords.level, 0)).true;
@@ -169,7 +169,7 @@ describe('GraphNode', () => {
         new GraphEdge(nodes[2], nodes[3], [1, 2], 'e2');
         new GraphEdge(nodes[2], nodes[4], [1, 2], 'e3');
         new GraphEdge(nodes[4], nodes[5], 2, 'e4');
-        expect(GraphNode.generateNodesLevels(nodes)).false;
+        expect(() => GraphNode.generateNodesLevels(nodes)).throw(Error);
 
 
         nodes = cleanNodes(5);
@@ -177,7 +177,7 @@ describe('GraphNode', () => {
         new GraphEdge(nodes[1], nodes[2], [1, 2]);
         new GraphEdge(nodes[2], nodes[3], [1, 2]);
         new GraphEdge(nodes[3], nodes[4], 1);
-        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(() => GraphNode.generateNodesLevels(nodes)).not.throw(Error);
         expect(Level.equals(nodes[0].coords.level, 2)).true;
         expect(Level.equals(nodes[1].coords.level, [1, 2])).true;
         expect(Level.equals(nodes[2].coords.level, [1, 2])).true;
@@ -191,7 +191,7 @@ describe('GraphNode', () => {
         new GraphEdge(nodes[2], nodes[3], [0, 1], 'e2');
         new GraphEdge(nodes[3], nodes[4], [0, 1], 'e3');
         new GraphEdge(nodes[4], nodes[5], 1, 'e4');
-        expect(GraphNode.generateNodesLevels(nodes)).true;
+        expect(() => GraphNode.generateNodesLevels(nodes)).not.throw(Error);
         expect(Level.equals(nodes[1].coords.level, 0)).true;
         expect(Level.equals(nodes[1].coords.level, 0)).true;
         expect(Level.equals(nodes[2].coords.level, [0, 1])).true;

package/src/graph/Network.js

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

package/src/rotations/Attitude.js

@@ -187,6 +187,30 @@ 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,4 +250,34 @@ 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;
+
+    });
+
 });