@wemap/geo 4.0.14 → 5.0.0

package/index.js

@@ -13,16 +13,23 @@ export { default as UserPosition } from './src/coordinates/UserPosition.js';
 export { default as Attitude } from './src/rotations/Attitude.js';
 export { default as AbsoluteHeading } from './src/rotations/AbsoluteHeading.js';
 
-/** Router */
-export { default as Edge } from './src/graph/Edge.js';
-export { default as GraphRouter } from './src/graph/GraphRouter.js';
-export { default as Itinerary } from './src/graph/Itinerary.js';
-export { default as ItineraryInfo } from './src/graph/ItineraryInfo.js';
-export { default as LevelChange } from './src/graph/LevelChange.js';
+/** Graph */
+export { default as GraphEdge } from './src/graph/GraphEdge.js';
 export { default as Network } from './src/graph/Network.js';
-export { default as Node } from './src/graph/Node.js';
+export { default as GraphNode } from './src/graph/GraphNode.js';
 export { default as MapMatching } from './src/graph/MapMatching.js';
-export { default as Projection } from './src/graph/Projection.js';
-export { default as Step } from './src/graph/Step.js';
-export * as GraphUtils from './src/graph/Utils.js';
-export { default as NoRouteFoundError } from './src/graph/NoRouteFoundError.js';
+export { default as GraphProjection } from './src/graph/GraphProjection.js';
+export * as GraphUtils from './src/graph/GraphUtils.js';
+
+/** Router */
+export { default as GraphItinerary } from './src/router/GraphItinerary.js';
+export { default as GraphRouter } from './src/router/GraphRouter.js';
+export { default as GraphRouterOptions } from './src/router/GraphRouterOptions.js';
+export { default as NoRouteFoundError } from './src/router/NoRouteFoundError.js';
+
+// /** Itinerary */
+// export { default as Itinerary } from '@wemap/osm/src/routers/Itinerary';
+// export { default as ItineraryInfo } from './src/itinerary/ItineraryInfo.js';
+// export { default as Leg } from './src/itinerary/Leg.js';
+// export { default as LevelChange } from './src/itinerary/LevelChange.js';
+// export { default as Step } from './src/itinerary/Step.js';

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "4.0.14",
+    "version": "5.0.0",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -27,8 +27,8 @@
     ],
     "license": "ISC",
     "dependencies": {
-        "@wemap/logger": "^4.0.0",
-        "@wemap/maths": "^4.0.3"
+        "@wemap/logger": "^5.0.0",
+        "@wemap/maths": "^5.0.0"
     },
-    "gitHead": "0b7188383438fcb1dd498dd117799076115dfee6"
+    "gitHead": "73607e294f29d3f9a41673bfc25ad9489a1da7f4"
 }

package/src/Utils.spec.js

@@ -124,6 +124,44 @@ describe('Geo Utils', () => {
         expect(routeSimplified).to.include(route[4]);
 
 
+        route = [
+            new Coordinates(48.75627274161895, 2.054974197053283),
+            new Coordinates(48.756269751891594, 2.0549905921869933),
+            new Coordinates(48.756274912970845, 2.054992757591672),
+            new Coordinates(48.75628117553095, 2.0549584148199345),
+            new Coordinates(48.756276014452325, 2.054956249415256),
+            new Coordinates(48.75627274161895, 2.054974197053283)
+        ];
+
+        routeSimplified = simplifyRoute(route);
+        expect(routeSimplified.length).equal(5);
+        expect(routeSimplified).to.not.include(route[0]);
+        expect(routeSimplified).to.not.include(route[5]);
+
+    });
+
+
+    it('geolocationPositionToUserPosition', () => {
+
+        let route, routeSimplified;
+
+        route = [
+            new Coordinates(48.756308386983484, 2.0549525696601694),
+            new Coordinates(48.75630194782273, 2.054987452552288),
+            new Coordinates(48.756294588780854, 2.055026521391461),
+            new Coordinates(48.7563159759933, 2.0550474511267316),
+            new Coordinates(48.756350241508265, 2.0550837293345348)
+        ];
+
+        routeSimplified = simplifyRoute(route);
+        expect(routeSimplified.length).equal(3);
+        expect(routeSimplified).to.include(route[0]);
+        expect(routeSimplified).to.not.include(route[1]);
+        expect(routeSimplified).to.include(route[2]);
+        expect(routeSimplified).to.not.include(route[3]);
+        expect(routeSimplified).to.include(route[4]);
+
+
         route = [
             new Coordinates(48.75627274161895, 2.054974197053283),
             new Coordinates(48.756269751891594, 2.0549905921869933),

package/src/graph/{Edge.js → GraphEdge.js}

@@ -1,17 +1,19 @@
 import Level from '../coordinates/Level.js';
-import Node from './Node.js';
+import GraphNode from './GraphNode.js';
 
 /**
+ * @template T
+ *
  * An Edge is a segment composed of two Node
  * An edge is mostly issued from an OsmWay, but this is not always the case.
  * For example, edges created by mapmatching.
  */
-class Edge {
+class GraphEdge {
 
-    /** @type {Node} */
+    /** @type {GraphNode<T>} */
     _node1 = null;
 
-    /** @type {Node} */
+    /** @type {GraphNode<T>} */
     _node2 = null;
 
     /** @type {?Level} */
@@ -24,49 +26,38 @@ class Edge {
     _length;
 
     /** @type {boolean} */
-    _computedSizeAndBearing;
+    _computedSizeAndBearing = false;
 
-    /** @type {boolean} */
-    isStairs = false;
-
-    /** @type {boolean} */
-    isElevator = false;
+    /** @type {?T} */
+    builtFrom = null;
 
     /** @type {boolean} */
     isOneway = false;
 
-    /** @type {boolean} */
-    isConveying = false;
-
-    /** @type {string} */
-    name = null;
-
     /**
-     * @param {!Node} node1
-     * @param {!Node} node2
+     * @param {!GraphNode} node1
+     * @param {!GraphNode} node2
      * @param {?Level} level
+     * @param {?T} builtFrom
      * @param {?string} name
      */
-    constructor(node1, node2, level, name = null) {
-
+    constructor(node1, node2, level = null, builtFrom = null) {
         this.node1 = node1;
         this.node2 = node2;
         this.level = level;
-        this.name = name || null;
-
-        this._computedSizeAndBearing = false;
+        this.builtFrom = builtFrom;
     }
 
-    /** @type {!Node} */
+    /** @type {!GraphNode<T>} */
     get node1() {
         return this._node1;
     }
 
-    /** @type {!Node} */
+    /** @type {!GraphNode<T>} */
     set node1(node) {
 
-        if (!(node instanceof Node)) {
-            throw new TypeError('node1 is not a Node');
+        if (!(node instanceof GraphNode)) {
+            throw new TypeError('node1 is not a GraphNode');
         }
 
         if (this._node1 !== null && this._node2 !== this._node1) {
@@ -79,16 +70,16 @@ class Edge {
         this._computedSizeAndBearing = false;
     }
 
-    /** @type {!Node} */
+    /** @type {!GraphNode<T>} */
     get node2() {
         return this._node2;
     }
 
-    /** @type {!Node} */
+    /** @type {!GraphNode<T>} */
     set node2(node) {
 
-        if (!(node instanceof Node)) {
-            throw new TypeError('node2 is not a Node');
+        if (!(node instanceof GraphNode)) {
+            throw new TypeError('node2 is not a GraphNode');
         }
 
         if (this._node2 !== null && this._node2 !== this._node1) {
@@ -147,89 +138,37 @@ class Edge {
     }
 
     /**
-     * @param {Edge} other
+     * @param {GraphEdge<T>} other
      * @returns {boolean}
      */
     equalsTo(other) {
 
-        if (!(other instanceof Edge)) {
+        if (this === other) {
+            return true;
+        }
+
+        if (!(other instanceof GraphEdge)) {
             return false;
         }
 
         return other.node1.equalsTo(this.node1)
             && other.node2.equalsTo(this.node2)
             && Level.equalsTo(other.level, this.level)
-            && other.name === this.name
-            && other.isConveying === this.isConveying
-            && other.isElevator === this.isElevator
             && other.isOneway === this.isOneway
-            && other.isStairs === this.isStairs;
+            && other.builtFrom === this.builtFrom;
     }
 
     /**
-     * @returns {Edge}
+     * @returns {GraphEdge<T>}
      */
     clone() {
-        const edge = new Edge(this.node1, this.node2);
-        edge.name = this.name;
+        const edge = new GraphEdge(this.node1, this.node2);
         edge.level = this.level;
-        edge.isConveying = this.isConveying;
-        edge.isElevator = this.isElevator;
         edge.isOneway = this.isOneway;
-        edge.isStairs = this.isStairs;
+        edge.builtFrom = this.builtFrom;
         return edge;
     }
 
-    /**
-     * @returns {object}
-     */
-    extractProperties() {
-        const output = {};
-        if (this.level !== null) {
-            output.level = this.level.toString();
-        }
-        if (this.name !== null) {
-            output.name = this.name;
-        }
-        if (this.isConveying) {
-            output.isConveying = true;
-        }
-        if (this.isElevator) {
-            output.isElevator = true;
-        }
-        if (this.isOneway) {
-            output.isOneway = true;
-        }
-        if (this.isStairs) {
-            output.isStairs = true;
-        }
-        return output;
-    }
-
-    /**
-     * @param {object} properties
-     */
-    applyProperties(properties) {
-        if (properties.level) {
-            this.level = Level.fromString(properties.level);
-        }
-        if (properties.name) {
-            this.name = properties.name;
-        }
-        if (properties.isConveying) {
-            this.isConveying = true;
-        }
-        if (properties.isElevator) {
-            this.isElevator = true;
-        }
-        if (properties.isOneway) {
-            this.isOneway = true;
-        }
-        if (properties.isStairs) {
-            this.isStairs = true;
-        }
-        return this;
-    }
 }
 
-export default Edge;
+export default GraphEdge;

package/src/graph/GraphEdge.spec.js

@@ -0,0 +1,91 @@
+import chai from 'chai';
+
+import Logger from '@wemap/logger';
+
+import Coordinates from '../coordinates/Coordinates.js';
+import Level from '../coordinates/Level.js';
+import GraphNode from './GraphNode.js';
+import GraphEdge from './GraphEdge.js';
+
+const { expect } = chai;
+
+Logger.enable(false);
+
+describe('GraphEdge', () => {
+
+    const node1 = new GraphNode(new Coordinates(45, 5), 'n1');
+    const node2 = new GraphNode(new Coordinates(46, 5), 'n2');
+
+    const edge = new GraphEdge(node1, node2);
+
+    const fullEdge = new GraphEdge(node1, node2);
+    fullEdge.level = new Level(1);
+    fullEdge.isOneway = true;
+    fullEdge.builtFrom = 'w1';
+
+
+    it('creation', () => {
+
+        expect(() => new GraphEdge()).throw(Error);
+        expect(() => new GraphEdge(
+            {
+                lat: 45,
+                lng: 5
+            }, node2)).throw(Error);
+        expect(() => new GraphEdge(node1,
+            {
+                lat: 45,
+                lng: 5
+            })).throw(Error);
+        expect(() => new GraphEdge(node1, node2)).not.throw(Error);
+        expect(() => new GraphEdge(node1, node2, null)).not.throw(Error);
+        expect(() => new GraphEdge(node1, node2, 1)).throw(Error);
+        expect(() => new GraphEdge(node1, node2, true)).throw(Error);
+        expect(() => new GraphEdge(node1, node2, false)).throw(Error);
+        expect(() => new GraphEdge(node1, node2, new Level(1))).not.throw(Error);
+        expect(() => new GraphEdge(node1, node2, new Level(1), 'foo')).not.throw(Error);
+
+    });
+
+
+    it('distanceTo / bearingTo', () => {
+        let newEdge = new GraphEdge(node1, node2);
+        expect(newEdge.length).equals(node1.distanceTo(node2));
+        expect(newEdge.bearing).equals(node1.bearingTo(node2));
+
+        newEdge = new GraphEdge(node1, node2);
+        expect(newEdge.bearing).equals(node1.bearingTo(node2));
+        expect(newEdge.length).equals(node1.distanceTo(node2));
+    });
+
+    it('equalsTo', () => {
+
+        const testedEdge = new GraphEdge(node1, node2);
+
+        expect(edge.equalsTo({})).false;
+
+        expect(edge.equalsTo(testedEdge)).true;
+        expect(fullEdge.equalsTo(testedEdge)).false;
+
+        testedEdge.level = new Level(1);
+        expect(edge.equalsTo(testedEdge)).false;
+        expect(fullEdge.equalsTo(testedEdge)).false;
+
+        testedEdge.isOneway = true;
+        expect(edge.equalsTo(testedEdge)).false;
+        expect(fullEdge.equalsTo(testedEdge)).false;
+
+        testedEdge.builtFrom = 'w1';
+        expect(edge.equalsTo(testedEdge)).false;
+        expect(fullEdge.equalsTo(testedEdge)).true;
+
+    });
+
+    it('clone', () => {
+        let edgeBis = edge.clone();
+        expect(edgeBis.equalsTo(edge)).true;
+
+        edgeBis = fullEdge.clone();
+        expect(edgeBis.equalsTo(fullEdge)).true;
+    });
+});

package/src/graph/{Node.js → GraphNode.js}

@@ -3,32 +3,30 @@ import Logger from '@wemap/logger';
 import Coordinates from '../coordinates/Coordinates.js';
 import Level from '../coordinates/Level.js';
 
-import Edge from './Edge.js';
+import Edge from './GraphEdge.js';
 
-class Node {
+/**
+ * @template T
+ */
+class GraphNode {
 
     /** @type {Coordinates} */
     _coords;
 
-    /** @type {string} */
-    name = null;
-
-    /** @type {boolean} */
-    subwayEntrance = false;
-
-    /** @type {string} */
-    subwayEntranceRef = null;
-
-    /** @type {Edge[]} */
+    /** @type {Edge<T>[]} */
     edges = [];
 
+    /** @type {?T} */
+    builtFrom = null;
+
     /**
      * @param {Coordinates} coords
+     * @param {T} builtFrom
      */
-    constructor(coords, name = null) {
+    constructor(coords, builtFrom = null) {
         this.coords = coords;
+        this.builtFrom = builtFrom;
         this.edges = [];
-        this.name = name || null;
     }
 
     /** @type {!Coordinates} */
@@ -45,7 +43,7 @@ class Node {
     }
 
     /**
-     * @param {Node} other
+     * @param {GraphNode} other
      * @returns {number}
      */
     distanceTo(other) {
@@ -53,7 +51,7 @@ class Node {
     }
 
     /**
-     * @param {Node} other
+     * @param {GraphNode} other
      * @returns {number}
      */
     bearingTo(other) {
@@ -61,40 +59,38 @@ class Node {
     }
 
     /**
-     * @param {Node} other
+     * @param {GraphNode} other
      * @returns {boolean}
      */
     equalsTo(other) {
         return this.coords.equalsTo(other.coords)
-            && this.name === other.name;
+            && this.builtFrom === other.builtFrom;
     }
 
     /**
-     * @returns {Node}
+     * @returns {GraphNode}
      */
     clone() {
-        const node = new Node(this.coords.clone());
-        node.name = this.name;
+        const node = new GraphNode(this.coords);
+        node.edges = this.edges.slice(0);
+        node.builtFrom = this.builtFrom;
         return node;
     }
 
     /**
+     * Does not include "edges" and "builtFrom" properties
      * @returns {object}
      */
     toJson() {
-        return Object.assign(
-            { coords: this.coords.toCompressedJson() },
-            this.extractProperties()
-        );
+        return this.coords.toCompressedJson();
     }
 
     /**
-     * @returns {Node}
+     * @template T
+     * @returns {GraphNode<T>}
      */
     static fromJson(json) {
-        const node = new Node(Coordinates.fromCompressedJson(json.coords));
-        node.applyProperties(json);
-        return node;
+        return new GraphNode(Coordinates.fromCompressedJson(json));
     }
 
     generateLevelFromEdges() {
@@ -137,8 +133,8 @@ class Node {
         /**
          * This method looks for single level nodes recursively from a multi-level node
          * The result of this method is an union of all single level nodes found.
-         * @param {Node} node node to explore
-         * @param {Node[]} visitedNodes list of visited nodes
+         * @param {GraphNode} node node to explore
+         * @param {GraphNode[]} visitedNodes list of visited nodes
          */
         const lookForLevel = (node, visitedNodes) => {
 
@@ -201,7 +197,7 @@ class Node {
     }
 
     /**
-     * @param {Node[]} nodes
+     * @param {GraphNode[]} nodes
      */
     static generateNodesLevels(nodes) {
         const success = nodes.reduce((acc, node) => acc && node.generateLevelFromEdges(), true);
@@ -217,40 +213,6 @@ class Node {
             && node.inferNodeLevelByRecursion()
         , true);
     }
-
-
-    /**
-     * @returns {object}
-     */
-    extractProperties() {
-        const output = {};
-        if (this.name !== null) {
-            output.name = this.name;
-        }
-        if (this.subwayEntrance !== null) {
-            output.subwayEntrance = this.subwayEntrance;
-        }
-        if (this.subwayEntranceRef !== null) {
-            output.subwayEntranceRef = this.subwayEntranceRef;
-        }
-        return output;
-    }
-
-    /**
-     * @param {object} properties
-     */
-    applyProperties(properties) {
-        if (properties.name) {
-            this.name = properties.name;
-        }
-        if (properties.subwayEntrance) {
-            this.subwayEntrance = properties.subwayEntrance;
-        }
-        if (properties.subwayEntranceRef) {
-            this.subwayEntranceRef = properties.subwayEntranceRef;
-        }
-        return this;
-    }
 }
 
-export default Node;
+export default GraphNode;