@wemap/geo 0.1.4 → 0.2.0

package/index.js

@@ -1,19 +1,28 @@
-import Attitude from './src/rotations/Attitude';
 import Constants from './src/Constants';
+
+import Attitude from './src/rotations/Attitude';
+
+import Level from './src/coordinates/Level';
+import WGS84 from './src/coordinates/WGS84';
+import WGS84UserPosition from './src/coordinates/WGS84UserPosition';
+
 import Edge from './src/graph/Edge';
+import GraphRouter from './src/graph/GraphRouter';
 import Itinerary from './src/graph/Itinerary';
-import MapMatching from './src/graph/MapMatching';
 import Network from './src/graph/Network';
-import WGS84 from './src/coordinates/WGS84';
-import WGS84UserPosition from './src/coordinates/WGS84UserPosition';
+import Node from './src/graph/Node';
+import MapMatching from './src/graph/MapMatching';
 
 export {
     Attitude,
     Constants,
     Edge,
+    GraphRouter,
     Itinerary,
+    Level,
     MapMatching,
     Network,
+    Node,
     WGS84,
     WGS84UserPosition
 };

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "0.1.4",
+    "version": "0.2.0",
     "bugs": {
         "url": "https://github.com/wemap/wemap-utils-js/issues"
     },
@@ -26,5 +26,8 @@
         "wemap"
     ],
     "license": "ISC",
-    "gitHead": "991a53f06eed6adb872fad2cbd70a4edf7ee9cf9"
+    "dependencies": {
+        "lodash.isnumber": "^3.0.3"
+    },
+    "gitHead": "6673bc4d0f4b6ff404534e0642122c340fe58483"
 }

package/src/coordinates/Level.js

@@ -0,0 +1,108 @@
+import Logger from '@wemap/logger';
+
+/**
+ * A Level is the representation of a building floor number
+ * A level can be a simple number (val) or a range (low, up)
+ * To know if a level is a range or a number, isRange can be used
+ */
+class Level {
+
+    constructor() {
+        this.val = null;
+        this.isRange = false;
+    }
+
+    clone() {
+        const output = new Level();
+        output.isRange = this.isRange;
+        output.val = this.val;
+        output.up = this.up;
+        output.low = this.low;
+        return output;
+    }
+
+    /**
+     * Create a level from a string
+     * @param {*} str level in str format (eg. 1, -2, 1;2, -2;3, 2;-1, 0.5;1 ...)
+     */
+    static fromString(str) {
+        const level = new Level();
+        const num = Number(str);
+        if (!isNaN(num)) {
+            level.val = num;
+            level.isRange = false;
+            return level;
+        }
+
+        const splited = str.split(';');
+        if (splited.length === 2) {
+            const num1 = Number(splited[0]);
+            const num2 = Number(splited[1]);
+            if (!isNaN(num1) && !isNaN(num2)) {
+                level.up = Math.max(num1, num2);
+                level.low = Math.min(num1, num2);
+                level.isRange = true;
+                return level;
+            }
+        }
+
+        Logger.warn('Cannot parse following level: ' + str);
+        return null;
+    }
+
+    /**
+     * Is the given number inside the current level
+     * @param {Number} val the given number
+     */
+    isInside(val) {
+        return this.isRange ? val >= this.low && val <= this.up : val === this.val;
+    }
+
+    /**
+     * Retrieve the intersection of two levels
+     * @param {Level} other The other level
+     */
+    intersect(other) {
+
+        if (!other) {
+            return null;
+        }
+
+        if (this.isRange && !other.isRange) {
+            if (this.isInside(other.val)) {
+                return other;
+            }
+            return null;
+        }
+        if (!this.isRange && other.isRange) {
+            if (other.isInside(this.val)) {
+                return this;
+            }
+            return null;
+        }
+        if (this.isRange && other.isRange) {
+            const level = new Level();
+            level.low = Math.max(this.low, other.low);
+            level.up = Math.min(this.up, other.up);
+            level.isRange = true;
+            return level;
+        }
+        return this.val === other.val ? this : null;
+    }
+
+    multiplyBy(factor) {
+        if (this.isRange) {
+            this.low *= factor;
+            this.up *= factor;
+        } else {
+            this.val *= factor;
+        }
+    }
+
+    toString() {
+        return this.isRange ? this.low + ';' + this.up : this.val;
+    }
+
+}
+
+export default Level;

package/src/coordinates/WGS84.js

@@ -2,14 +2,30 @@ import {
     Utils, Vector3, Quaternion
 } from '@wemap/maths';
 import Constants from '../Constants';
-
-
+import isNumber from 'lodash/isnumber';
+
+/**
+ * JSON output formats:
+ * - FORMAT_LAT_LNG_ELE (default)
+ * - FORMAT_LNG_LAT_STRLEVEL
+ */
+const FORMAT_LAT_LNG_ELE = 0;
+const FORMAT_LNG_LAT_STRLEVEL = 1;
+
+/**
+ * A WGS84 position using at least latitude (lat) and longitude (lng).
+ * Optionnal fields are: altitude (alt) and level.
+ *
+ * Basic geo methods are directly accessibles from here:
+ * distanceTo, bearingTo, toEcef...
+ */
 class WGS84 {
 
     constructor(lat, lng, alt) {
         this._lat = lat;
         this._lng = lng;
         this._alt = alt;
+        this._level = null;
         this._ecef = null;
     }
 
@@ -25,6 +41,10 @@ class WGS84 {
         return this._alt;
     }
 
+    get level() {
+        return this._level;
+    }
+
     set lat(lat) {
         this._ecef = null;
         this._lat = lat;
@@ -40,8 +60,16 @@ class WGS84 {
         this._alt = alt;
     }
 
+    set level(level) {
+        this._level = level;
+    }
+
     clone() {
-        return new WGS84(this.lat, this.lng, this.alt);
+        const output = new WGS84(this.lat, this.lng, this.alt);
+        if (this.level) {
+            output.level = this.level.clone();
+        }
+        return output;
     }
 
     equalsTo(other) {
@@ -62,6 +90,17 @@ class WGS84 {
         return str;
     }
 
+    toJson(format = FORMAT_LAT_LNG_ELE) {
+        switch (format) {
+        case FORMAT_LNG_LAT_STRLEVEL:
+            return [this.lng, this.lat, this.level ? this.level.toString() : null];
+
+        case FORMAT_LAT_LNG_ELE:
+        default:
+            return [this.lat, this.lng, this.ele];
+        }
+    }
+
     destinationPoint(distance, bearing, elevation = 0) {
         const newPoint = this.clone();
         newPoint.move(distance, bearing, elevation);
@@ -201,8 +240,8 @@ class WGS84 {
     // Adapted to ECEF
     getProjection(edge) {
 
-        const p1 = edge.node1;
-        const p2 = edge.node2;
+        const p1 = edge.node1.coords;
+        const p2 = edge.node2.coords;
 
         const a = Vector3.normalize(p1.ecef);
         const b = Vector3.normalize(p2.ecef);
@@ -219,7 +258,7 @@ class WGS84 {
         // So if p1.alt and p2.alt are defined we take the middle elevation between p1 and p2.
         // Otherwise we remove alt from projection because the residual has no sense.
         let alt;
-        if (typeof p1.alt !== 'undefined' && typeof p2.alt !== 'undefined') {
+        if (isNumber(p1.alt) && isNumber(p2.alt)) {
             alt = (p1.alt + p2.alt) / 2;
         }
         const projection = new WGS84(poseWGS84.lat, poseWGS84.lng, alt);
@@ -290,6 +329,15 @@ class WGS84 {
 
         return sampledRoute;
     }
+
+
+    static get FORMAT_LNG_LAT_STRLEVEL() {
+        return FORMAT_LNG_LAT_STRLEVEL;
+    }
+
+    static get FORMAT_LAT_LNG_ELE() {
+        return FORMAT_LAT_LNG_ELE;
+    }
 }
 
 export default WGS84;

package/src/coordinates/WGS84UserPosition.js

@@ -2,6 +2,9 @@ import WGS84 from './WGS84';
 
 const MESSAGE_TYPE = 'WGS84UserPosition';
 
+/**
+ * A WGS84 User Position is a WGS84 position with specific data related to user (bearing, provider, time, accuracy)
+ */
 class WGS84UserPosition extends WGS84 {
 
     constructor(lat, lng, alt = null, time = null,

package/src/graph/Edge.js

@@ -1,55 +1,56 @@
-import WGS84 from '../coordinates/WGS84';
+import Node from './Node';
 
+/**
+ * An Edge is a segment composed of two Node
+ * An edge is mostly issued from an OsmWay (data attribute), but this is not
+ * always the case. For example, edges created by mapmatching.
+ */
 class Edge {
 
-    constructor(node1, node2) {
+    constructor(node1, node2, data) {
 
-        if (!(node1 instanceof WGS84)) {
-            throw new TypeError('node1 is not an instance of WGS84');
+        if (!(node1 instanceof Node)) {
+            throw new TypeError('node1 is not an instance of Node');
         }
 
-        if (!(node2 instanceof WGS84)) {
-            throw new TypeError('node2 is not an instance of WGS84');
+        if (!(node2 instanceof Node)) {
+            throw new TypeError('node2 is not an instance of Node');
         }
 
         this.node1 = node1;
         this.node2 = node2;
+        this.data = data;
+        this.level = null;
+
         this.computedSizeAndBearing = false;
     }
 
-    getBearing() {
+    /**
+     * Get edge bearing from node1 to node2
+     */
+    get bearing() {
         if (!this.computedSizeAndBearing) {
             this.computeSizeAndBearing();
         }
-        return this.bearing;
+        return this._bearing;
     }
 
-    getLength() {
+    /**
+     * get edge length
+     */
+    get length() {
         if (!this.computedSizeAndBearing) {
             this.computeSizeAndBearing();
         }
-        return this.length;
+        return this._length;
     }
 
     computeSizeAndBearing() {
-        this.length = this.node1.distanceTo(this.node2);
-        this.bearing = this.node1.bearingTo(this.node2);
+        this._length = this.node1.distanceTo(this.node2);
+        this._bearing = this.node1.bearingTo(this.node2);
         this.computedSizedAndBearing = true;
     }
 
-    static pointsToEdges(points, lngLatFormat = true) {
-        let lastPoint = null;
-        const edgesNetwork = [];
-        for (let i = 0; i < points.length; i++) {
-            const currentPoint = new WGS84(points[i][lngLatFormat ? 1 : 0], points[i][lngLatFormat ? 0 : 1]);
-            if (lastPoint) {
-                edgesNetwork.push(new Edge(lastPoint, currentPoint));
-            }
-            lastPoint = currentPoint;
-        }
-        return edgesNetwork;
-    }
-
     equalsTo(other) {
 
         if (!(other instanceof Edge)) {
@@ -58,6 +59,10 @@ class Edge {
 
         return other.node1.equalsTo(this.node1) && other.node2.equalsTo(this.node2);
     }
+
+    clone(node1, node2) {
+        return new Edge(node1, node2, this.data);
+    }
 }
 
 export default Edge;

package/src/graph/GraphRouter.js

@@ -0,0 +1,242 @@
+/* eslint-disable max-statements */
+/* eslint-disable complexity */
+
+import { WGS84 } from '@wemap/geo';
+
+import Edge from './Edge';
+import Itinerary from './Itinerary';
+import Node from './Node';
+import MapMatching from './MapMatching';
+
+class GraphRouter {
+
+    constructor(network) {
+        this.network = network;
+        this.mapMatching = new MapMatching(network);
+        this.mapMatching.maxDistance = 50;
+    }
+
+    getShortestPath(_start, _end, acceptEdgeFn = () => true) {
+        let start;
+        let startNodeCreated;
+
+        if (_start instanceof Node) {
+            start = _start;
+        } else if (_start instanceof WGS84) {
+            const node = this.network.getNodeByCoords(_start);
+            if (node) {
+                start = node;
+            } else {
+                const proj = this.mapMatching.getProjection(_start, true, false, false, acceptEdgeFn);
+                if (proj && proj.nearestElement instanceof Node) {
+                    start = proj.nearestElement;
+                } else if (proj && proj.nearestElement instanceof Edge) {
+                    startNodeCreated = this.createNodeInsideEdge(
+                        proj.nearestElement,
+                        proj.projection
+                    );
+                    start = startNodeCreated;
+                }
+            }
+        }
+
+        if (!start) {
+            throw new Error('Cannot provide path because no starting point has been found');
+        }
+
+        let end;
+        let endNodeCreated;
+
+        if (_end instanceof Node) {
+            end = _end;
+        } else if (_end instanceof WGS84) {
+            const node = this.network.getNodeByCoords(_end);
+            if (node) {
+                end = node;
+            } else {
+                const proj = this.mapMatching.getProjection(_end, true, false, false, acceptEdgeFn);
+                if (proj && proj.nearestElement instanceof Node) {
+                    end = proj.nearestElement;
+                } else if (proj && proj.nearestElement instanceof Edge) {
+                    endNodeCreated = this.createNodeInsideEdge(
+                        proj.nearestElement,
+                        proj.projection
+                    );
+                    end = endNodeCreated;
+                }
+            }
+        }
+
+        if (!end) {
+            if (startNodeCreated) {
+                this.removeNodeFromPreviouslyCreatedEdge(startNodeCreated);
+            }
+            throw new Error('Cannot provide path because no end point has been found');
+        }
+
+        const path = this.getShortestPathInternal(start, end, acceptEdgeFn);
+
+        if (endNodeCreated) {
+            this.removeNodeFromPreviouslyCreatedEdge(endNodeCreated);
+        }
+
+        if (startNodeCreated) {
+            this.removeNodeFromPreviouslyCreatedEdge(startNodeCreated);
+        }
+
+        let route;
+        if (path && path.length !== 0) {
+            route = Itinerary.fromNetworkNodes(path, _start, _end);
+        }
+
+        return route;
+    }
+
+    createNodeInsideEdge(edge, point) {
+        const a = edge.node1;
+        const b = edge.node2;
+
+        const m = new Node(point);
+        m.coords.level = edge.level;
+
+        const u = new Edge(a, m);
+        u.level = edge.level;
+        u.data = edge.data;
+
+        const v = new Edge(b, m);
+        v.level = edge.level;
+        v.data = edge.data;
+
+        m.edges.push(u, v);
+        a.edges.push(u);
+        b.edges.push(v);
+        a.edges = a.edges.filter(_edge => _edge !== edge);
+        b.edges = b.edges.filter(_edge => _edge !== edge);
+
+        this.network.nodes.push(m);
+        this.network.edges.push(u, v);
+
+        this.network.edges = this.network.edges.filter(
+            _edge => _edge !== edge
+        );
+
+        return m;
+    }
+
+    removeNodeFromPreviouslyCreatedEdge(_node) {
+        const u = _node.edges[0];
+        const v = _node.edges[1];
+
+        u.node1.edges = u.node1.edges.filter(edge => edge !== u);
+        v.node1.edges = v.node1.edges.filter(edge => edge !== v);
+
+        const oldEdge = new Edge(u.node1, v.node1);
+        oldEdge.data = u.data;
+        this.network.edges.push(oldEdge);
+        u.node1.edges.push(oldEdge);
+        v.node1.edges.push(oldEdge);
+
+        this.network.nodes = this.network.nodes.filter(node => node !== _node);
+        this.network.edges = this.network.edges.filter(
+            edge => edge !== u && edge !== v
+        );
+    }
+
+    getShortestPathInternal(start, end, acceptEdgeFn) {
+        const distanceMap = {},
+            checking = {},
+            vertexList = {},
+            vertexNodes = {},
+            parentVertices = {},
+            path = [];
+        let vertexId = 0;
+
+        // Initially, we assume each vertex is unreachable
+        this.network.nodes.forEach(vertex => {
+
+            // Generate Unique Router Id
+            vertex.uniqueRouterId = vertexId;
+            vertexNodes[vertexId] = vertex;
+
+            distanceMap[vertexId] = Infinity;
+            checking[vertexId] = null;
+            vertexList[vertexId] = true;
+
+            vertexId++;
+        });
+
+        // The cost from the starting vertex to the starting vertex is 0
+        distanceMap[start.uniqueRouterId] = 0;
+
+        // check each vertex
+        while (Object.keys(vertexList).length > 0) {
+            const current = Number(
+                Object.keys(vertexList).reduce((_checking, vertex) => {
+                    return distanceMap[_checking] > distanceMap[vertex]
+                        ? vertex
+                        : _checking;
+                }, Object.keys(vertexList)[0])
+            );
+
+            // all the vertices accessible from current vertex
+            this.network.edges
+                .filter(edge => {
+
+                    if (!acceptEdgeFn(edge)) {
+                        return false;
+                    }
+
+                    const from = edge.node1.uniqueRouterId,
+                        to = edge.node2.uniqueRouterId;
+                    // are these vertices joined?
+                    return from === current || to === current;
+                })
+                // for each vertex we can reach
+                .forEach(edge => {
+                    let to, from;
+                    // determine the direction of travel
+                    if (edge.node1.uniqueRouterId === current) {
+                        to = edge.node2.uniqueRouterId;
+                        from = edge.node1.uniqueRouterId;
+                    } else {
+                        to = edge.node1.uniqueRouterId;
+                        from = edge.node2.uniqueRouterId;
+                    }
+                    // distance is how far we travelled to reach the
+                    // current vertex, plus cost of travel the next(to)
+                    const distance = distanceMap[current] + edge.length;
+
+                    // if we have found a cheaper path
+                    // update the hash of costs
+                    // and record which vertex we came from
+                    if (distanceMap[to] > distance) {
+                        distanceMap[to] = distance;
+                        checking[to] = current;
+                        parentVertices[to] = from;
+                    }
+                });
+
+            // remove vertex so we don't revisit it
+            delete vertexList[current];
+        }
+
+        // now we have the most efficient paths for all vertices
+        // build the path for the user specified vertex(end)
+        let endId = end.uniqueRouterId;
+        while (parentVertices[endId]) {
+            path.unshift(vertexNodes[endId]);
+            endId = parentVertices[endId];
+        }
+        if (path.length !== 0) {
+            path.unshift(start);
+        }
+
+        // Remove Unique Router Id
+        this.network.nodes.forEach(vertex => {
+            delete vertex.uniqueRouterId;
+        });
+
+        return path;
+    }
+}
+export default GraphRouter;

package/src/graph/Itinerary.js

@@ -1,36 +1,133 @@
-import Edge from './Edge';
+
+import { WGS84 } from '@wemap/geo';
+
 import Network from './Network';
+import Edge from './Edge';
+import Node from './Node';
 
-// An itinerary is an ordered list of edges where edge(n-1).p2 = edge.(n).p1
+/**
+ * Main attributes are:
+ * nodes: the ordered list of Node
+ * edges: the ordered list of Edge
+ * start: the start point (WGS84)
+ * end: the end point (WGS84)
+ * length: the route length
+ */
 class Itinerary extends Network {
 
-    constructor(edges = []) {
-        super(edges);
+    constructor() {
+        super();
+        this.start = null;
+        this.end = null;
+        this.length = -1;
     }
 
-    static fromPoints(points, lngLatFormat = true) {
-        return new Itinerary(Edge.pointsToEdges(points, lngLatFormat));
+    /**
+     * Get route duration
+     * @param {Number} speed in km/h
+     */
+    getDuration(speed = 4) {
+        return (speed * 1000 / 3600) * this.length;
     }
 
-    get firstEdge() {
-        if (this.edges.length < 1) {
-            throw new TypeError('first edge of itinerary does not exist');
+    /**
+     * Get edge at given distance
+     * @param {Number} distance
+     * @returns {Edge} the edge or null if not exists
+     */
+    getEdgeAt(distance) {
+
+        if (distance === 0 && this.edges.length > 0) {
+            return this.edges[0];
+        }
+
+        let sum = 0;
+        for (let i = 0; i <= this.edges.length; i++) {
+            sum += this.edges[i].length;
+            if (distance <= sum) {
+                return this.edges[i];
+            }
         }
-        return this.edges[0];
+        return null;
     }
 
-    get secondEdge() {
-        if (this.edges.length < 2) {
-            throw new TypeError('second edge of itinerary does not exist');
+
+    static fromNetworkNodes(nodes, start, end) {
+
+        /**
+         * Itinerary part of network is cloned and ordered
+         */
+
+        const itinerary = new Itinerary();
+        itinerary.length = 0;
+        itinerary.start = start;
+        itinerary.end = end;
+
+        let nextItineraryNode;
+
+        for (let i = 0; i < nodes.length; i++) {
+
+            const networkNode = nodes[i];
+            const itineraryNode = nextItineraryNode ? nextItineraryNode : networkNode.clone();
+
+            itinerary.nodes.push(itineraryNode);
+
+            if (i === nodes.length - 1) {
+                break;
+            }
+            const nextNetworkNode = nodes[i + 1];
+            nextItineraryNode = nextNetworkNode.clone();
+
+            const networkEdge = Network.getEdgeByNodes(networkNode.edges, networkNode, nextNetworkNode);
+            const itineraryEdge = networkEdge.clone(itineraryNode, nextItineraryNode);
+            itineraryNode.edges.push(itineraryEdge);
+            nextItineraryNode.edges.push(itineraryEdge);
+
+            itinerary.edges.push(itineraryEdge);
+            itinerary.length += itineraryEdge.length;
         }
-        return this.edges[1];
+
+        return itinerary;
     }
 
-    get distance() {
-        let dist = 0;
-        this.edges.forEach(edge => (dist += edge.getLength()));
-        return dist;
+    /**
+     * Convert lng/lat points to Itinerary
+     * @param {2DArray} points 2D points array of lng/lat (or lat/lng see lngLatFormat)
+     * @param {Boolean} lngLatFormat true: lng/lat (default), false: lat/lng
+     */
+    static fromOrderedPointsArray(points, start, end, lngLatFormat) {
+        const route = new Itinerary();
+        route.length = 0;
+        route.start = new WGS84(start[lngLatFormat ? 1 : 0],
+            start[lngLatFormat ? 0 : 1]);
+        route.end = new WGS84(end[lngLatFormat ? 1 : 0],
+            end[lngLatFormat ? 0 : 1]);
+
+        let lastPoint = null;
+
+        for (let i = 0; i < points.length; i++) {
+
+            const currentPoint = new Node(
+                new WGS84(points[i][lngLatFormat ? 1 : 0],
+                    points[i][lngLatFormat ? 0 : 1])
+            );
+
+            if (lastPoint) {
+                const edge = new Edge(lastPoint, currentPoint);
+
+                route.edges.push(edge);
+                route.length += edge.length;
+
+                currentPoint.edges.push(edge);
+                lastPoint.edges.push(edge);
+            }
+
+            route.nodes.push(currentPoint);
+            lastPoint = currentPoint;
+        }
+
+        return route;
     }
-}
 
+}
 export default Itinerary;

package/src/graph/MapMatching.js

@@ -1,10 +1,10 @@
-/* eslint complexity: ["error", 22]*/
-/* eslint max-statements: ["error", 45]*/
+/* eslint-disable max-statements */
+/* eslint-disable complexity */
+import isNumber from 'lodash/isnumber';
 
-import { Utils as MathUtils } from '@wemap/maths';
-import Network from './Network';
+import { rad2deg } from '@wemap/maths';
 
-const rad2deg = MathUtils.rad2deg;
+import Network from './Network';
 
 class MapMatching {
 
@@ -12,7 +12,7 @@ class MapMatching {
 
     /**
      * Constructor of Map-matching
-     * @param {Network} network List of Edges
+     * @param {Network} network
      */
     constructor(network) {
         if (network) {
@@ -35,7 +35,7 @@ class MapMatching {
         this.network = network;
     }
 
-    getProjection(location, useDistance = true, useBearing = true) {
+    getProjection(location, useDistance = true, useBearing = true, useMultiLevelSegments = true, acceptEdgeFn = () => true) {
 
         if (!this.network) {
             return null;
@@ -56,29 +56,42 @@ class MapMatching {
         for (let i = 0; i < this.network.edges.length; i++) {
             const edge = this.network.edges[i];
 
+            if (!acceptEdgeFn(edge)) {
+                continue;
+            }
+
+            if (!useMultiLevelSegments && edge.level && edge.level.isRange) {
+                continue;
+            }
+
+            if (location.level && !location.level.intersect(edge.level)
+                || !location.level && edge.level) {
+                continue;
+            }
+
             if (useBearing) {
-                const edgeBearing = rad2deg(edge.getBearing());
+                const edgeBearing = rad2deg(edge.bearing);
                 const diffAngle = MapMatching.diffAngle90(edgeBearing, location.bearing);
                 if (diffAngle > this._maxAngleBearing) {
                     continue;
                 }
             } else {
                 // Check node 1
-                const distNode1 = location.distanceTo(edge.node1);
+                const distNode1 = location.distanceTo(edge.node1.coords);
                 if (distNode1 < projection.distanceFromNearestElement
                     && (!useDistance || distNode1 <= this._maxDistance)) {
                     projection.distanceFromNearestElement = distNode1;
                     projection.nearestElement = edge.node1;
-                    projection.projection = edge.node1.clone();
+                    projection.projection = edge.node1.coords.clone();
                 }
 
                 // Check node 2
-                const distNode2 = location.distanceTo(edge.node2);
+                const distNode2 = location.distanceTo(edge.node2.coords);
                 if (distNode2 < projection.distanceFromNearestElement
                     && (!useDistance || distNode2 <= this._maxDistance)) {
                     projection.distanceFromNearestElement = distNode2;
                     projection.nearestElement = edge.node2;
-                    projection.projection = edge.node2.clone();
+                    projection.projection = edge.node2.coords.clone();
                 }
             }
 
@@ -97,7 +110,9 @@ class MapMatching {
 
         if (!projection.projection) {
             return null;
-        } else if (typeof projection.projection.alt === 'undefined') {
+        }
+
+        if (!isNumber(projection.projection.alt)) {
             projection.projection.alt = location.alt;
         }
 

package/src/graph/MapMatching.spec.js

@@ -1,27 +1,52 @@
 import chai from 'chai';
 import chaiAlmost from 'chai-almost';
 
+import {
+    WGS84, WGS84UserPosition
+} from '@wemap/geo';
+
 import Edge from './Edge';
-import MapMatching from './MapMatching';
+import Node from './Node';
 import Network from './Network';
-import WGS84 from '../coordinates/WGS84';
-import WGS84UserPosition from '../coordinates/WGS84UserPosition';
+import MapMatching from './MapMatching';
 
 const expect = chai.expect;
 chai.use(chaiAlmost());
 
+
+function edgeFromTwoNodes(node1, node2) {
+    if (!(node1 instanceof Node)) {
+        throw new TypeError('node1 is not an instance of Node');
+    }
+
+    if (!(node2 instanceof Node)) {
+        throw new TypeError('node2 is not an instance of Node');
+    }
+    const edge = new Edge(node1, node2);
+    node1.edges.push(edge);
+    node2.edges.push(edge);
+    return edge;
+}
+
+function createNetworkFromEdgesAndNodes(edges, nodes) {
+    const network = new Network();
+    network.edges = edges;
+    network.nodes = nodes;
+    return network;
+}
+
 describe('matching', () => {
     it('Should return the good value', () => {
 
-        const p1 = new WGS84(43.6091883, 3.8841242);
-        const p2 = new WGS84(43.6091709, 3.8842382);
-        const p3 = new WGS84(43.6091288, 3.884226);
-        const p4 = new WGS84(43.6091461, 3.884112);
-        const e1 = new Edge(p1, p2);
-        const e2 = new Edge(p2, p3);
-        const e3 = new Edge(p3, p4);
-        const e4 = new Edge(p4, p1);
-        const network = new Network([e1, e2, e3, e4]);
+        const n1 = new Node(new WGS84(43.6091883, 3.8841242));
+        const n2 = new Node(new WGS84(43.6091709, 3.8842382));
+        const n3 = new Node(new WGS84(43.6091288, 3.884226));
+        const n4 = new Node(new WGS84(43.6091461, 3.884112));
+        const e1 = edgeFromTwoNodes(n1, n2);
+        const e2 = edgeFromTwoNodes(n2, n3);
+        const e3 = edgeFromTwoNodes(n3, n4);
+        const e4 = edgeFromTwoNodes(n4, n1);
+        const network = createNetworkFromEdgesAndNodes([e1, e2, e3, e4], [n1, n2, n3, n4]);
 
         const mapMatching = new MapMatching(network);
         mapMatching.maxAngleBearing = 30;

package/src/graph/Network.js

@@ -1,33 +1,26 @@
-import Edge from './Edge';
-
+/**
+ * A typical network with nodes (Node) and edges (Edge)
+ */
 class Network {
 
-    constructor(edges = []) {
-        this.addEdges(edges);
+    constructor() {
+        this.nodes = [];
+        this.edges = [];
     }
 
-    addEdges(edges) {
-        Network.checkEdgesArray(edges);
-        if (!this.edges) {
-            this.edges = [];
-        }
-        this.edges = this.edges.concat(edges);
+    getNodeByCoords(coords) {
+        return this.nodes.find(node => node.coords.equalsTo(coords));
     }
 
-    get length() {
-        return this.edges.length;
+    getEdgeByNodes(node1, node2) {
+        return Network.getEdgeByNodes(this.edges, node1, node2);
     }
 
-    static checkEdgesArray(edges) {
-        if (!Array.isArray(edges)) {
-            throw new TypeError('Network creation: edges param is not an Array');
-        }
-
-        edges.forEach(edge => {
-            if (!(edge instanceof Edge)) {
-                throw new TypeError('Network creation: ' + edge + ' is not an Edge');
-            }
-        });
+    static getEdgeByNodes(edges, node1, node2) {
+        return edges.find(edge =>
+            node1 === edge.node1 && node2 === edge.node2
+            || node2 === edge.node1 && node1 === edge.node2
+        );
     }
 }
 

package/src/graph/Node.js

@@ -0,0 +1,26 @@
+class Node {
+
+    constructor(coords, data) {
+        this.coords = coords;
+        this.data = data;
+        this.edges = [];
+    }
+
+    distanceTo(other) {
+        return this.coords.distanceTo(other.coords);
+    }
+
+    bearingTo(other) {
+        return this.coords.bearingTo(other.coords);
+    }
+
+    equalsTo(other) {
+        return this.coords.equalsTo(other.coords);
+    }
+
+    clone() {
+        return new Node(this.coords, this.data);
+    }
+}
+
+export default Node;