@wemap/geo 11.3.3 → 11.7.0

package/package.json

@@ -13,7 +13,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "11.3.3",
+    "version": "11.7.0",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -33,7 +33,7 @@
     "dependencies": {
         "@wemap/logger": "^11.0.1",
         "@wemap/maths": "^11.0.1",
-        "@wemap/utils": "^11.3.3"
+        "@wemap/utils": "^11.5.0"
     },
     "devDependencies": {
         "jsdom-global": "^3.0.2"
@@ -45,5 +45,5 @@
         },
         "./tests/*": "./tests/*"
     },
-    "gitHead": "e53e577cf8a7f4e9bd1e1be6639d2ebc68319bcc"
+    "gitHead": "e06f16f4114b6e8da0c0f6bbda65c1ad1a3f45ce"
 }

package/src/graph/GeoGraph.spec.ts

@@ -21,7 +21,7 @@ describe('GeoGraph', () => {
 
     });
 
-    it('getNodeByCoords', () => {
+    it('getVertexByCoords', () => {
 
         let vertex = graph.getVertexByCoords(vertices[2].coords.clone());
         expect(vertex).not.undefined;
@@ -31,7 +31,7 @@ describe('GeoGraph', () => {
         expect(vertex).is.undefined;
     });
 
-    it('getEdgeByNodes', () => {
+    it('getEdgeByVertices', () => {
 
         let edge = graph.getEdgeByVertices(vertices[1], vertices[2]);
         expect(edge).not.null;
@@ -70,8 +70,8 @@ describe('GeoGraph', () => {
         const networkJson = graph.toCompressedJson();
         const networkBis = GeoGraph.fromCompressedJson(networkJson);
 
-        networkBis.vertices.forEach((node, i) => {
-            expect(node.coords.equals(graph.vertices[i].coords)).is.true;
+        networkBis.vertices.forEach((vertex, i) => {
+            expect(vertex.coords.equals(graph.vertices[i].coords)).is.true;
         });
 
         networkBis.edges.forEach((edge, i) => {
@@ -84,7 +84,7 @@ describe('GeoGraph', () => {
 
     it('getEdgesAtLevel', () => {
 
-        const _nodes = [
+        const _vertices = [
             new GeoGraphVertex(new Coordinates(43.6091194, 3.884099, null, 0), { name: 'p0' }),
             new GeoGraphVertex(new Coordinates(43.6093629, 3.8842777, null, 0), { name: 'p1' }),
             new GeoGraphVertex(new Coordinates(43.6094654, 3.8842167, null, [0, 1]), { name: 'p2' }),
@@ -96,16 +96,16 @@ describe('GeoGraph', () => {
         ];
 
         const _edges = [
-            new GeoGraphEdge(_nodes[0], _nodes[1], { name: 'e0', level: 0 }),
-            new GeoGraphEdge(_nodes[1], _nodes[2], { name: 'e1', level: [0, 1] }),
-            new GeoGraphEdge(_nodes[2], _nodes[3], { name: 'e2', level: [0, 1] }),
-            new GeoGraphEdge(_nodes[3], _nodes[4], { name: 'e3', level: 1 }),
-            new GeoGraphEdge(_nodes[4], _nodes[5], { name: 'e4', level: [1, 2] }),
-            new GeoGraphEdge(_nodes[5], _nodes[6], { name: 'e5', level: [1, 2] }),
-            new GeoGraphEdge(_nodes[6], _nodes[7], { name: 'e6', level: 1 })
+            new GeoGraphEdge(_vertices[0], _vertices[1], { name: 'e0', level: 0 }),
+            new GeoGraphEdge(_vertices[1], _vertices[2], { name: 'e1', level: [0, 1] }),
+            new GeoGraphEdge(_vertices[2], _vertices[3], { name: 'e2', level: [0, 1] }),
+            new GeoGraphEdge(_vertices[3], _vertices[4], { name: 'e3', level: 1 }),
+            new GeoGraphEdge(_vertices[4], _vertices[5], { name: 'e4', level: [1, 2] }),
+            new GeoGraphEdge(_vertices[5], _vertices[6], { name: 'e5', level: [1, 2] }),
+            new GeoGraphEdge(_vertices[6], _vertices[7], { name: 'e6', level: 1 })
         ];
 
-        const _network = new GeoGraph(_nodes, _edges);
+        const _network = new GeoGraph(_vertices, _edges);
 
         const edgesAtLevel0 = _network.getEdgesAtLevel(0, false);
         expect(edgesAtLevel0.length).equals(1);

package/src/graph/GeoGraph.ts

@@ -3,7 +3,7 @@ import { Graph } from '@wemap/utils';
 import BoundingBox from '../coordinates/BoundingBox.js';
 import Coordinates from '../coordinates/Coordinates.js';
 import Level from '../coordinates/Level.js';
-import { Level_t, GeoGraphJson } from '../types.js';
+import { Level_t, GeoGraphJson, GeoGraphEdgeExtras } from '../types.js';
 
 import GeoGraphEdge from './GeoGraphEdge.js';
 import GeoGraphVertex from './GeoGraphVertex.js';
@@ -50,13 +50,21 @@ class GeoGraph<VertexData = unknown, EdgeData = unknown> extends Graph<VertexDat
 
 
     toCompressedJson(): GeoGraphJson {
+
+        const createEdgeExtras = (edge: GeoGraphEdge) => {
+            const extras: GeoGraphEdgeExtras = {};
+            if (edge.isOneway) { extras.oneway = true }
+            return extras;
+        }
+
         return {
             vertices: this.vertices.map(vertex => vertex.toJson()),
             edges: this.edges.map(edge => {
                 const vertex1Idx = this.vertices.indexOf(edge.vertex1);
                 const vertex2Idx = this.vertices.indexOf(edge.vertex2);
-                if (edge.isOneway) {
-                    return [vertex1Idx, vertex2Idx, edge.level, true];
+                const edgeExtras = createEdgeExtras(edge);
+                if (Object.keys(edgeExtras).length > 0) {
+                    return [vertex1Idx, vertex2Idx, edge.level, edgeExtras];
                 }
                 if (edge.level !== null) {
                     return [vertex1Idx, vertex2Idx, edge.level];
@@ -79,8 +87,9 @@ class GeoGraph<VertexData = unknown, EdgeData = unknown> extends Graph<VertexDat
                 geograph.vertices[jsonEdge[1]],
                 { level: jsonEdge.length > 2 ? jsonEdge[2] : null }
             );
-            if (jsonEdge.length > 3 && jsonEdge[3]) {
-                edge.isOneway = true;
+            const extras: GeoGraphEdgeExtras = jsonEdge.length > 3 ? jsonEdge[3]! : {}
+            if (typeof extras.oneway !== 'undefined') { 
+                edge.isOneway = extras.oneway; 
             }
             return edge;
         });

package/src/graph/GeoGraphEdge.spec.ts

@@ -3,7 +3,7 @@ import chai from 'chai';
 import Logger from '@wemap/logger';
 
 import Coordinates from '../coordinates/Coordinates.js';
-import GraphNode from './GeoGraphVertex.js';
+import GeoGraphVertex from './GeoGraphVertex.js';
 import GeoGraphEdge from './GeoGraphEdge.js';
 
 const { expect } = chai;
@@ -18,26 +18,26 @@ describe('GeoGraphEdge', () => {
         Logger.enable(true);
     })
 
-    const node1 = new GraphNode(new Coordinates(45, 5));
-    const node2 = new GraphNode(new Coordinates(46, 5));
+    const vertex1 = new GeoGraphVertex(new Coordinates(45, 5));
+    const vertex2 = new GeoGraphVertex(new Coordinates(46, 5));
 
     it('creation', () => {
 
-        expect(() => new GeoGraphEdge(node1, node2)).not.throw(Error);
-        expect(() => new GeoGraphEdge(node1, node2, {})).not.throw(Error);
-        expect(() => new GeoGraphEdge(node1, node2, { level: 1 })).not.throw(Error);
+        expect(() => new GeoGraphEdge(vertex1, vertex2)).not.throw(Error);
+        expect(() => new GeoGraphEdge(vertex1, vertex2, {})).not.throw(Error);
+        expect(() => new GeoGraphEdge(vertex1, vertex2, { level: 1 })).not.throw(Error);
 
     });
 
 
     it('distanceTo / bearingTo', () => {
-        let newEdge = new GeoGraphEdge(node1, node2);
-        expect(newEdge.length).equals(node1.distanceTo(node2));
-        expect(newEdge.bearing).equals(node1.bearingTo(node2));
+        let newEdge = new GeoGraphEdge(vertex1, vertex2);
+        expect(newEdge.length).equals(vertex1.distanceTo(vertex2));
+        expect(newEdge.bearing).equals(vertex1.bearingTo(vertex2));
 
-        newEdge = new GeoGraphEdge(node1, node2);
-        expect(newEdge.bearing).equals(node1.bearingTo(node2));
-        expect(newEdge.length).equals(node1.distanceTo(node2));
+        newEdge = new GeoGraphEdge(vertex1, vertex2);
+        expect(newEdge.bearing).equals(vertex1.bearingTo(vertex2));
+        expect(newEdge.length).equals(vertex1.distanceTo(vertex2));
     });
 
    

package/src/graph/GeoGraphItinerary.spec.ts

@@ -5,9 +5,9 @@ const { expect } = chai;
 
 export function isReadable(itinerary: GraphItinerary) {
     for (let i = 0; i < itinerary.vertices.length; i++) {
-        const node = itinerary.vertices[i];
+        const vertex = itinerary.vertices[i];
         if (i !== itinerary.vertices.length - 1) {
-            expect(itinerary.edges[i].vertex1).equal(node);
+            expect(itinerary.edges[i].vertex1).equal(vertex);
             expect(itinerary.edges[i].vertex2).equal(itinerary.vertices[i + 1]);
         }
     }

package/src/graph/GeoGraphProjectionHandler.spec.ts

@@ -58,20 +58,20 @@ const expectProjection = (projectionResult: GeoGraphProjection | null, condition
 
 describe('GeoGraphProjectionHandler', () => {
 
-    const nodes = [
+    const vertices = [
         new GeoGraphVertex(new Coordinates(43.6091194, 3.884099), { name: 'p0' }),
         new GeoGraphVertex(new Coordinates(43.6093629, 3.8842777), { name: 'p1' }),
         new GeoGraphVertex(new Coordinates(43.6092785, 3.8845052), { name: 'p2' })
     ];
 
     const edges = [
-        new GeoGraphEdge(nodes[0], nodes[1], { name: 'e0' }),
-        new GeoGraphEdge(nodes[1], nodes[2], { name: 'e1' })
+        new GeoGraphEdge(vertices[0], vertices[1], { name: 'e0' }),
+        new GeoGraphEdge(vertices[1], vertices[2], { name: 'e1' })
     ];
 
     let mapMatching: GeoGraphProjectionHandler;
     it('creation', () => {
-        const owNetwork = new GeoGraph(nodes, edges);
+        const owNetwork = new GeoGraph(vertices, edges);
         expect(() => (mapMatching = new GeoGraphProjectionHandler(owNetwork))).not.throw(Error);
     });
 
@@ -102,12 +102,12 @@ describe('GeoGraphProjectionHandler', () => {
         projection = mapMatching.getProjection(location);
         expectProjection(projection, { name: 'e0', coords: expected, nearestElementType: 'edge' });
 
-        const owNodes = [
+        const owVertices = [
             new GeoGraphVertex(new Coordinates(43.6091194, 3.884099, 5)),
             new GeoGraphVertex(new Coordinates(43.6093629, 3.8842777, 10))
         ];
-        const owNetwork = new GeoGraph(owNodes, [
-            new GeoGraphEdge(owNodes[0], owNodes[1])
+        const owNetwork = new GeoGraph(owVertices, [
+            new GeoGraphEdge(owVertices[0], owVertices[1])
         ]);
         const owGeoGraphProjectionHandler = new GeoGraphProjectionHandler(owNetwork);
         projection = owGeoGraphProjectionHandler.getProjection(new Coordinates(43.6092086, 3.8842598, 10));
@@ -127,19 +127,19 @@ describe('GeoGraphProjectionHandler', () => {
 
         let pointToTest;
 
-        pointToTest = nodes[0].coords.destinationPoint(0.0001, nodes[0].bearingTo(nodes[1]));
+        pointToTest = vertices[0].coords.destinationPoint(0.0001, vertices[0].bearingTo(vertices[1]));
         projection = mapMatching.getProjection(pointToTest);
         expectProjection(projection, { name: 'p0', nearestElementType: 'vertex' });
 
-        pointToTest = nodes[1].coords.destinationPoint(0.0001, nodes[1].bearingTo(nodes[0]));
+        pointToTest = vertices[1].coords.destinationPoint(0.0001, vertices[1].bearingTo(vertices[0]));
         projection = mapMatching.getProjection(pointToTest);
         expectProjection(projection, { name: 'p1', nearestElementType: 'vertex' });
 
-        pointToTest = nodes[0].coords.destinationPoint(0.005, nodes[0].bearingTo(nodes[1]));
+        pointToTest = vertices[0].coords.destinationPoint(0.005, vertices[0].bearingTo(vertices[1]));
         projection = mapMatching.getProjection(pointToTest);
         expectProjection(projection, { name: 'e0', nearestElementType: 'edge', coords: pointToTest });
 
-        pointToTest = nodes[1].coords.destinationPoint(0.005, nodes[1].bearingTo(nodes[0]));
+        pointToTest = vertices[1].coords.destinationPoint(0.005, vertices[1].bearingTo(vertices[0]));
         projection = mapMatching.getProjection(pointToTest);
         expectProjection(projection, { name: 'e0', nearestElementType: 'edge', coords: pointToTest });
     });
@@ -166,7 +166,7 @@ describe('GeoGraphProjectionHandler - multilevels', () => {
         expectProjection(projection, { coords: expected });
     });
 
-    it('matching node levels', () => {
+    it('matching vertex levels', () => {
         let currentPosition;
 
         currentPosition = new Coordinates(43.6091773, 3.8842584, null, -1);
@@ -207,7 +207,7 @@ describe('GeoGraphProjectionHandler - multilevels', () => {
 
     });
 
-    it('matching stairs nodes levels', () => {
+    it('matching stairs vertices levels', () => {
         let currentPosition;
 
         currentPosition = new Coordinates(43.6093691, 3.8842057, null, -1);
@@ -250,7 +250,7 @@ describe('GeoGraphProjectionHandler - multilevels', () => {
     it('useMultiLevelSegments = false', () => {
         let currentPosition;
 
-        // On Nodes
+        // On Vertices
 
         currentPosition = new Coordinates(43.6093381, 3.8841926, null, -1);
         projection = mapMatching.getProjection(currentPosition, true, false, false);
@@ -304,7 +304,7 @@ describe('GeoGraphProjectionHandler - multilevels', () => {
     });
 
 
-    it('matching exact node position with eps', () => {
+    it('matching exact vertex position with eps', () => {
         let currentPosition;
 
         currentPosition = new Coordinates(43.60936289383032, 3.884212691390017, null, -1);

package/src/graph/GeoGraphProjectionHandler.ts

@@ -39,12 +39,12 @@ class GeoGraphProjectionHandler<VertexData = unknown, EdgeData = unknown> {
 
 
     /**
-     * Check if the specified edge and its nodes can be used for projection
+     * Check if the specified edge and its vertices can be used for projection
      * @returns an array of two elements.
      *  First is true if projection will be used on the specified edge, false otherwise.
-     *  Second is true if projection will be used on the nodes of the specified edge, false otherwise.
+     *  Second is true if projection will be used on the vertices of the specified edge, false otherwise.
      */
-    _shouldProjectOnEdgeAndNodes(
+    _shouldProjectOnEdgeAndVertices(
         edge: GeoGraphEdge<VertexData, EdgeData>,
         location: Coordinates | UserPosition,
         useBearing: boolean,
@@ -58,18 +58,18 @@ class GeoGraphProjectionHandler<VertexData = unknown, EdgeData = unknown> {
 
         // First, check if levels intersects
         let checkEdge = Level.intersect(location.level, edge.level);
-        let checkNode1 = Level.intersect(location.level, edge.vertex1.coords.level);
-        let checkNode2 = Level.intersect(location.level, edge.vertex2.coords.level);
+        let checkVertex1 = Level.intersect(location.level, edge.vertex1.coords.level);
+        let checkVertex2 = Level.intersect(location.level, edge.vertex2.coords.level);
 
-        // Second, in case of IO nodes, accept matching if location's level is null
-        checkNode1 = checkNode1 || edge.vertex1.io && location.level === null;
-        checkNode2 = checkNode2 || edge.vertex2.io && location.level === null;
+        // Second, in case of IO vertices, accept matching if location's level is null
+        checkVertex1 = checkVertex1 || edge.vertex1.io && location.level === null;
+        checkVertex2 = checkVertex2 || edge.vertex2.io && location.level === null;
 
         // Third, check if level is a range if useMultiLevelSegments is false
         if (!useMultiLevelSegments) {
             checkEdge = checkEdge && !Level.isRange(edge.level);
-            checkNode1 = checkNode1 && !Level.isRange(edge.vertex1.coords.level);
-            checkNode2 = checkNode2 && !Level.isRange(edge.vertex2.coords.level);
+            checkVertex1 = checkVertex1 && !Level.isRange(edge.vertex1.coords.level);
+            checkVertex2 = checkVertex2 && !Level.isRange(edge.vertex2.coords.level);
         }
 
         // Finally, check edges bearing if option is used
@@ -82,12 +82,12 @@ class GeoGraphProjectionHandler<VertexData = unknown, EdgeData = unknown> {
                     checkEdge = false;
                 }
             }
-            // if mapmatching bearing is enabled do not use nodes matching
-            checkNode1 = false;
-            checkNode2 = false;
+            // if mapmatching bearing is enabled do not use vertices matching
+            checkVertex1 = false;
+            checkVertex2 = false;
         }
 
-        return [checkEdge, checkNode1, checkNode2];
+        return [checkEdge, checkVertex1, checkVertex2];
     }
 
 
@@ -98,12 +98,12 @@ class GeoGraphProjectionHandler<VertexData = unknown, EdgeData = unknown> {
     }
 
     /**
-     * IO Nodes are typical because they have a non-null level but projection car works on them.
-     * This function handles the case where the projection is on an IO node and a location with
+     * IO Vertices are typical because they have a non-null level but projection car works on them.
+     * This function handles the case where the projection is on an IO vertex and a location with
      * a null level is required.
      */
-    static _handleLevelsWithIONodes(projection: Coordinates, location: Coordinates, projectionNode: GeoGraphVertex) {
-        if (location.level === null && projectionNode.io) {
+    static _handleLevelsWithIOVertices(projection: Coordinates, location: Coordinates, projectionVertex: GeoGraphVertex) {
+        if (location.level === null && projectionVertex.io) {
             projection.level = null;
         }
     }
@@ -149,36 +149,36 @@ class GeoGraphProjectionHandler<VertexData = unknown, EdgeData = unknown> {
         //  the current projection is replaced
         for (const edge of this.graph.edges) {
 
-            // Check if the specified edge and its nodes can be used for projection. See the
+            // Check if the specified edge and its vertices can be used for projection. See the
             // documentation of the corresponding function for more information.
-            const [checkEdge, checkNode1, checkNode2] = this._shouldProjectOnEdgeAndNodes(
+            const [checkEdge, checkVertex1, checkVertex2] = this._shouldProjectOnEdgeAndVertices(
                 edge, location, useBearing, useMultiLevelSegments, acceptEdgeFn);
 
-            if (checkNode1) {
+            if (checkVertex1) {
 
-                const distNode1 = location.distanceTo(edge.vertex1.coords);
-                if (isProjectionBetter(distNode1) || distNode1 <= EPS_MM) {
-                    distanceFromNearestElement = distNode1;
+                const distVertex1 = location.distanceTo(edge.vertex1.coords);
+                if (isProjectionBetter(distVertex1) || distVertex1 <= EPS_MM) {
+                    distanceFromNearestElement = distVertex1;
                     nearestElement = edge.vertex1 as typeof this.graph.vertices[0];
                     GeoGraphProjectionHandler._assignLatLngLevel(edge.vertex1.coords, projection as Coordinates);
-                    GeoGraphProjectionHandler._handleLevelsWithIONodes(projection as Coordinates, location, edge.vertex1);
+                    GeoGraphProjectionHandler._handleLevelsWithIOVertices(projection as Coordinates, location, edge.vertex1);
 
-                    if (distNode1 <= EPS_MM) {
+                    if (distVertex1 <= EPS_MM) {
                         break;
                     }
                 }
             }
 
-            if (checkNode2) {
+            if (checkVertex2) {
 
-                const distNode2 = location.distanceTo(edge.vertex2.coords);
-                if (isProjectionBetter(distNode2) || distNode2 <= EPS_MM) {
-                    distanceFromNearestElement = distNode2;
+                const distVertex2 = location.distanceTo(edge.vertex2.coords);
+                if (isProjectionBetter(distVertex2) || distVertex2 <= EPS_MM) {
+                    distanceFromNearestElement = distVertex2;
                     nearestElement = edge.vertex2 as typeof this.graph.vertices[0];
                     GeoGraphProjectionHandler._assignLatLngLevel(edge.vertex2.coords, projection as Coordinates);
-                    GeoGraphProjectionHandler._handleLevelsWithIONodes(projection as Coordinates, location, edge.vertex2);
+                    GeoGraphProjectionHandler._handleLevelsWithIOVertices(projection as Coordinates, location, edge.vertex2);
 
-                    if (distNode2 <= EPS_MM) {
+                    if (distVertex2 <= EPS_MM) {
                         break;
                     }
                 }

package/src/graph/NoRouteFoundError.ts

@@ -11,7 +11,7 @@ class NoRouteFoundError extends Error {
 
     get startStr() {
         if (this.start instanceof GeoGraphVertex) {
-            return `GraphNode ${this.start.coords.toString()}`;
+            return `GeoGraphVertex ${this.start.coords.toString()}`;
         }
 
         // if (this.start instanceof Coordinates) {
@@ -20,7 +20,7 @@ class NoRouteFoundError extends Error {
 
     get endStr() {
         if (this.end instanceof GeoGraphVertex) {
-            return `GraphNode ${this.end.coords.toString()}`;
+            return `GeoGraphVertex ${this.end.coords.toString()}`;
         }
 
         // if (this.end instanceof Coordinates) {

package/src/types.ts

@@ -38,13 +38,14 @@ export type UserPositionJson = CoordinatesJson & {
 };
 
 export type GraphVertexJson = CoordinatesCompressedJson;
+export type GeoGraphEdgeExtras = { oneway?: boolean }
 
 export type GeoGraphJson = {
     vertices: GraphVertexJson[],
     edges: (
         [number, number] |
-        [number, number, number | [number, number]] |
-        [number, number, Level_t, true]
+        [number, number, Level_t] |
+        [number, number, Level_t, GeoGraphEdgeExtras]
     )[]
 };