@wemap/geo 0.4.0 → 1.0.1

package/index.js

@@ -1,5 +1,4 @@
 import Constants from './src/Constants';
-import Utils from './src/Utils';
 
 import Attitude from './src/rotations/Attitude';
 
@@ -7,24 +6,10 @@ 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 Network from './src/graph/Network';
-import Node from './src/graph/Node';
-import MapMatching from './src/graph/MapMatching';
-
 export {
     Attitude,
     Constants,
-    Edge,
-    GraphRouter,
-    Itinerary,
     Level,
-    MapMatching,
-    Network,
-    Node,
-    Utils,
     WGS84,
     WGS84UserPosition
 };

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "0.4.0",
+    "version": "1.0.1",
     "bugs": {
         "url": "https://github.com/wemap/wemap-utils-js/issues"
     },
@@ -31,5 +31,5 @@
         "lodash.isnumber": "^3.0.3",
         "lodash.isstring": "^4.0.1"
     },
-    "gitHead": "08d7d843add321d899aef07f9e2ec7739270dc70"
+    "gitHead": "f4d8fe98fff281533d884e0479894662c4dec9fe"
 }

package/src/coordinates/Level.js

@@ -96,11 +96,11 @@ class Level {
         }
 
         if (!second) {
-            return first;
+            return null;
         }
 
         if (!first) {
-            return second;
+            return null;
         }
 
         if (first.isRange && !second.isRange) {

package/src/coordinates/Level.spec.js

@@ -137,8 +137,8 @@ describe('Level', () => {
         expect(Level.intersect(null, null)).is.null;
 
         const level = new Level(1);
-        expect(Level.intersect(level, null)).equals(level);
-        expect(Level.intersect(null, level)).equals(level);
+        expect(Level.intersect(level, null)).equals(null);
+        expect(Level.intersect(null, level)).equals(null);
         expect(Level.intersect(level, level)).equals(level);
 
         expect(Level.equalsTo(Level.intersect(new Level(0, 1), new Level(1)), new Level(1)));

package/src/Utils.js

@@ -1,12 +0,0 @@
-class Utils {
-
-    /**
-     * Get route duration
-     * @param {Number} speed in km/h
-     */
-    static getDurationFromLength(length, speed = 5) {
-        return length / (speed * 1000 / 3600);
-    }
-}
-
-export default Utils;

package/src/graph/Edge.js

@@ -1,73 +0,0 @@
-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, data, level) {
-
-        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');
-        }
-
-        this.node1 = node1;
-        this.node2 = node2;
-        this.data = data;
-        this.level = level;
-
-        this.node1.edges.push(this);
-        this.node2.edges.push(this);
-
-        this.computedSizeAndBearing = false;
-    }
-
-    /**
-     * Get edge bearing from node1 to node2
-     */
-    get bearing() {
-        if (!this.computedSizeAndBearing) {
-            this.computeSizeAndBearing();
-        }
-        return this._bearing;
-    }
-
-    /**
-     * get edge length
-     */
-    get length() {
-        if (!this.computedSizeAndBearing) {
-            this.computeSizeAndBearing();
-        }
-        return this._length;
-    }
-
-    computeSizeAndBearing() {
-        this._length = this.node1.distanceTo(this.node2);
-        this._bearing = this.node1.bearingTo(this.node2);
-        this.computedSizedAndBearing = true;
-    }
-
-    equalsTo(other) {
-
-        if (!(other instanceof Edge)) {
-            return false;
-        }
-
-        return other.node1.equalsTo(this.node1) && other.node2.equalsTo(this.node2);
-    }
-
-    clone(node1, node2) {
-        const edge = new Edge(node1, node2, this.data);
-        edge.level = this.level;
-        return edge;
-    }
-}
-
-export default Edge;

package/src/graph/GraphRouter.js

@@ -1,260 +0,0 @@
-/* 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';
-import Utils from '../Utils';
-
-const DEFAULT_ACCEPT_EDGE_FN = () => true;
-const DEFAULT_ACCEPT_ONEWAY_FN = () => true;
-const DEFAULT_WEIGHT_FN = edge => Utils.getDurationFromLength(edge.length);
-
-class GraphRouter {
-
-    constructor(network, mapMatchingMaxDistance = 50) {
-        this.network = network;
-        this.mapMatching = new MapMatching(network);
-        this.mapMatching.maxDistance = mapMatchingMaxDistance;
-    }
-
-    getShortestPath(
-        _start,
-        _end,
-        _acceptEdgeFn,
-        _weightFn,
-        _acceptOneWayFn) {
-
-        const acceptEdgeFn = _acceptEdgeFn || DEFAULT_ACCEPT_EDGE_FN;
-        const weightFn = _weightFn || DEFAULT_WEIGHT_FN;
-        const acceptOneWayFn = _acceptOneWayFn || DEFAULT_ACCEPT_ONEWAY_FN;
-
-        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, weightFn, acceptOneWayFn);
-
-        let route;
-        if (path && path.length !== 0) {
-            route = Itinerary.fromNetworkNodes(path, _start, _end);
-        }
-
-        if (endNodeCreated) {
-            this.removeNodeFromPreviouslyCreatedEdge(endNodeCreated);
-        }
-
-        if (startNodeCreated) {
-            this.removeNodeFromPreviouslyCreatedEdge(startNodeCreated);
-        }
-
-        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;
-
-        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;
-        oldEdge.level = u.level;
-        this.network.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, weightFn, acceptOneWayFn) {
-        const distanceMap = {},
-            checking = {},
-            vertexList = {},
-            vertexNodes = {},
-            parentVertices = {},
-            path = [];
-        let vertexId = 1;
-
-        // 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, reversed = false;
-                    // 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;
-                        reversed = true;
-                    }
-
-                    if (!acceptOneWayFn(edge, reversed)) {
-                        return;
-                    }
-
-                    // distance is how far we travelled to reach the
-                    // current vertex, plus cost of travel the next(to)
-                    const distance = distanceMap[current] + weightFn(edge);
-
-                    // 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/GraphRouter.spec.js

@@ -1,159 +0,0 @@
-import { expect } from 'chai';
-
-import WGS84 from '../coordinates/WGS84';
-import GraphRouter from './GraphRouter';
-import Node from './Node';
-import Edge from './Edge';
-
-import {
-    network, nodes, itineraryStart, itineraryEnd, routingOptions
-} from '../../tests/CommonTest';
-import Network from './Network';
-
-
-const {
-    acceptEdgeWithoutStairsFn, weightFn, acceptOneWayFn
-} = routingOptions;
-
-describe('GraphRouter', () => {
-
-    const router = new GraphRouter(network);
-    let itinerary;
-
-    it('network did not change', () => {
-        const nodesBefore = network.nodes.slice(0);
-        const edgesBefore = network.edges.slice(0);
-
-        itinerary = router.getShortestPath(itineraryStart, itineraryEnd, null, weightFn);
-
-        const isEdgeInArray = (edgeArray, edge) => edgeArray.find(_edge =>
-            edge.node1 === _edge.node1
-            && edge.node2 === _edge.node2
-            && edge.level === _edge.level
-            && edge.data === _edge.data
-        );
-        const areEdgeArrayEquals = (edgeArray1, edgeArray2) => {
-            if (edgeArray1.length !== edgeArray2.length) {
-                return false;
-            }
-            for (let j = 0; j < edgeArray1.length; j++) {
-                if (!isEdgeInArray(edgeArray2, edgeArray1[j])) {
-                    return false;
-                }
-            }
-            for (let j = 0; j < edgeArray2.length; j++) {
-                if (!isEdgeInArray(edgeArray1, edgeArray2[j])) {
-                    return false;
-                }
-            }
-            return true;
-        };
-
-        expect(network.nodes.length).equals(nodesBefore.length);
-        for (let i = 0; i < nodesBefore.length; i++) {
-            const node = network.nodes[i];
-            const nodeBefore = nodesBefore[i];
-            expect(nodeBefore).equals(node);
-            expect(areEdgeArrayEquals(node.edges, nodeBefore.edges)).true;
-        }
-
-        expect(areEdgeArrayEquals(network.edges, edgesBefore)).true;
-    });
-
-    it('router returns shortest path', () => {
-
-        expect(itinerary.nodes.length).equal(11);
-
-        for (let i = 1; i <= 10; i++) {
-            expect(itinerary.nodes[i]).equal(nodes[i + 6]);
-        }
-
-    });
-});
-
-
-describe('GraphRouter - Itinerary without stairs', () => {
-
-    const router = new GraphRouter(network);
-    const itinerary = router.getShortestPath(
-        itineraryStart,
-        itineraryEnd,
-        acceptEdgeWithoutStairsFn,
-        weightFn
-    );
-    const itineraryWithoutRestriction = router.getShortestPath(
-        itineraryStart,
-        itineraryEnd,
-        null,
-        weightFn
-    );
-
-    it('no stairs found', () => {
-        expect(itinerary).is.not.undefined;
-        expect(itinerary.edges.some(node => node.data && node.data.stairs)).false;
-
-        expect(itineraryWithoutRestriction).is.not.undefined;
-        expect(itineraryWithoutRestriction.edges.some(node => node.data && node.data.stairs)).true;
-    });
-});
-
-
-describe('GraphRouter - Itinerary one way', () => {
-
-    const owNodes = [
-        new Node(new WGS84(43.6094442, 3.8842049), { name: 'p0' }),
-        new Node(new WGS84(43.6094286, 3.8842011), { name: 'p1' }),
-        new Node(new WGS84(43.6094058, 3.8841955), { name: 'p2' }),
-        new Node(new WGS84(43.6093893, 3.8841914), { name: 'p3' }),
-        new Node(new WGS84(43.6094256, 3.8842247), { name: 'p4' }),
-        new Node(new WGS84(43.6094028, 3.8842191), { name: 'p5' })
-    ];
-
-    const owEdges = [
-        new Edge(owNodes[0], owNodes[1], { name: 'e0' }),
-        new Edge(owNodes[1], owNodes[2], { name: 'e1', oneWay: true }),
-        new Edge(owNodes[2], owNodes[3], { name: 'e2' }),
-        new Edge(owNodes[1], owNodes[4], { name: 'e3' }),
-        new Edge(owNodes[4], owNodes[5], { name: 'e4' }),
-        new Edge(owNodes[5], owNodes[2], { name: 'e5' })
-    ];
-    const owNetwork = new Network(owNodes, owEdges);
-    const owRouter = new GraphRouter(owNetwork);
-
-    const start = new WGS84(43.6094542, 3.8842072);
-    const end = new WGS84(43.6093792, 3.8841889);
-
-    const itinerary = owRouter.getShortestPath(
-        start,
-        end,
-        null,
-        weightFn,
-        acceptOneWayFn
-    );
-
-    const itineraryOtherWay = owRouter.getShortestPath(
-        end,
-        start,
-        null,
-        weightFn,
-        acceptOneWayFn
-    );
-
-    it('do not use oneway segments', () => {
-
-        expect(itinerary).is.not.undefined;
-        expect(itinerary.nodes[0]).equals(owNodes[0]);
-        expect(itinerary.nodes[1]).equals(owNodes[1]);
-        expect(itinerary.nodes[2]).equals(owNodes[2]);
-        expect(itinerary.nodes[3]).equals(owNodes[3]);
-
-        expect(itineraryOtherWay).is.not.undefined;
-        expect(itineraryOtherWay.nodes[0]).equals(owNodes[3]);
-        expect(itineraryOtherWay.nodes[1]).equals(owNodes[2]);
-        expect(itineraryOtherWay.nodes[2]).equals(owNodes[5]);
-        expect(itineraryOtherWay.nodes[3]).equals(owNodes[4]);
-        expect(itineraryOtherWay.nodes[4]).equals(owNodes[1]);
-        expect(itineraryOtherWay.nodes[5]).equals(owNodes[0]);
-
-    });
-});