@wemap/geo 0.3.9 → 1.0.0

package/index.js

@@ -6,23 +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,
     WGS84,
     WGS84UserPosition
 };

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "0.3.9",
+    "version": "1.0.0",
     "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": "84a60e64b0968bc45f0f76cc26c08e165dbe6985"
+    "gitHead": "2a8dc4304fae3f175819ed1a1561a818e871cf44"
 }

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,238 +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';
-
-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);
-
-        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) {
-        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;
-                    // 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/GraphRouter.spec.js

@@ -1,72 +0,0 @@
-import { expect } from 'chai';
-
-import GraphRouter from './GraphRouter';
-
-import {
-    network, nodes, itineraryStart, itineraryEnd
-} from '../../tests/CommonTest';
-
-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);
-
-        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]);
-        }
-
-    });
-
-    it('no route found', () => {
-        const itineraryWithoutStairs = router.getShortestPath(itineraryStart, itineraryEnd,
-            edge => !edge.data || !edge.data.hasOwnProperty('stairs') || !edge.data.stairs
-        );
-        expect(itineraryWithoutStairs).is.undefined;
-    });
-});