@wemap/routers 12.0.0 → 12.2.0

package/index.ts

@@ -23,8 +23,6 @@ export { default as NoRouteFoundError } from './src/graph/NoRouteFoundError.js';
 
 /* Wemap Router */
 export { default as OsmGraphUtils } from './src/wemap-osm/OsmGraphUtils.js';
-export { type OsmRouterOptions } from './src/wemap-osm/OsmRouterOptions.js';
-
 export { default as WemapMultiRouter } from './src/wemap-multi/WemapMultiRouter.js';
 export { default as CustomNetworkMap } from './src/wemap-multi/CustomNetworkMap.js';
 

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/routers"
     },
     "name": "@wemap/routers",
-    "version": "12.0.0",
+    "version": "12.2.0",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -52,5 +52,5 @@
         },
         "./helpers/*": "./helpers/*"
     },
-    "gitHead": "90961b51b2bbbb32c4e7b64ddf19097e1d44a1df"
+    "gitHead": "6dda458e79cb7bc9bb63de3db2d000823672c3ca"
 }

package/src/graph/Edge.ts

@@ -3,7 +3,10 @@ import { Level, type Level_t } from '@wemap/geo';
 import Vertex from './Vertex.js';
 
 export type EdgeProperties = {
+    
     name?: string;
+    externalId?: string | number;
+
     isOneway?: boolean;
     areStairs?: boolean;
     isElevator?: boolean;

package/src/graph/Graph.ts

@@ -135,6 +135,7 @@ class Graph {
     toCompressedJson(): GeoGraphJson {
         return {
             vertices: this.vertices.map(vertex => vertex.toJson()),
+            verticesIds: this.vertices.map(vertex => vertex.id),
             edges: this.edges.map(edge => {
                 const vertex1Idx = this.vertices.indexOf(edge.vertex1);
                 const vertex2Idx = this.vertices.indexOf(edge.vertex2);
@@ -155,8 +156,7 @@ class Graph {
             vertices[jsonEdge[0]],
             vertices[jsonEdge[1]],
             jsonEdge.length > 2 ? jsonEdge[2] : {}
-        )
-        );
+        ));
 
         return new Graph(vertices, edges);
     }

package/src/graph/GraphRouter.ts

@@ -107,12 +107,14 @@ class GraphRouter extends GraphRouterEngine {
             if (projection.nearestElement instanceof Edge) {
                 const edge = projection.nearestElement;
                 const newVertex = new Vertex(projection.coords, {
-                    name: `proj on ${edge.properties.name || null} (tmp)`
+                    name: `proj on ${edge.properties.name || null} (tmp)`,
+                    ...(typeof edge.properties.externalId !== 'undefined' && { externalId: edge.properties.externalId })
                 });
                 newVertex.id = this.graph.vertices.length + createdVertices.size;
                 const newEdgesOptions: EdgeProperties = {
                     ...edge.properties,
                     name: `splitted ${edge.properties.name || null} (tmp)`,
+                    ...(typeof edge.properties.externalId !== 'undefined' && { externalId: edge.properties.externalId })
                 };
                 const newEdge1 = new Edge(edge.vertex1, newVertex, newEdgesOptions);
                 const newEdge2 = new Edge(newVertex, edge.vertex2, newEdgesOptions);

package/src/graph/GraphRouterEngine.ts

@@ -149,39 +149,7 @@ export default class GraphRouterEngine {
                 }
             }
 
-            // edges.forEach(edge => {
-            //     // if (edge.properties.isOneway) {
-            //     //     console.log("isOneway")
-            //     //     return edge.vertex1 == u
-            //     // } else {
-            //     //     console.log(`${edge.id} => keep: ${cond} - ${JSON.stringify(edge.properties)} [f: ${firstPart}, s: ${secondPart}]`);
-            //     // }
-            //     // return edge.vertex1 == u || edge.vertex2 == u
-            //     const firstPart = edge.vertex1 == u;
-            //     const secondPart = !edge.properties.isOneway && edge.vertex2 == u;
-            //     const cond = edge.vertex1 == u || !edge.properties.isOneway && edge.vertex2 == u
-            //     console.log(`${edge.id} => keep: ${cond} - ${JSON.stringify(edge.properties)} [f: ${firstPart}, s: ${secondPart}]`);
-            // })
-
-            // const mEdges = edges
-            //     .filter(edge => edge.vertex1 == u || !edge.properties.isOneway && edge.vertex2 == u)
-            //     .map(edge => `${edge.id} - ${edge.properties.name}`)
-            // console.log('_-------_')
-            // console.log(`Processing vertex ${u.id} (${u.properties.name})`);
-            // console.log(`Calc for edges: ${mEdges}`);
-
-            // if (u.properties.name === 'p11') {
-            //     console.log(u);
-            // }
-
-
             edges
-                // .filter(edge => {
-                //     if (edge.properties.isOneway) {
-                //         return edge.vertex1 == u
-                //     }
-                //     return edge.vertex1 == u || edge.vertex2 == u
-                // })
                 .filter(edge => edge.vertex1 == u || !edge.properties.isOneway && edge.vertex2 == u)
                 .forEach(edge => {
                     const v = u === edge.vertex1 ? edge.vertex2 : edge.vertex1;
@@ -206,4 +174,43 @@ export default class GraphRouterEngine {
     ): GraphRouterEngineResults {
         return this.calculateShortestPathToMultipleDestinationsByVertex(source, [target], options, inputVertices, inputEdges);
     }
+
+    // https://en.wikipedia.org/wiki/Component_(graph_theory)
+    calculateComponents() {
+
+        function shiftSet<T>(set: Set<T>): T {
+            const firstValue = set.values().next().value as T;
+            set.delete(firstValue);
+            return firstValue;
+        }
+
+        const verticesToTest = new Set<Vertex>(this.graph.vertices);
+        let components: Vertex[][] = [];
+
+        while (verticesToTest.size > 0) {
+            const vertexToTest = shiftSet(verticesToTest);
+            const otherVertices = this.graph.vertices.filter(v => v.id !== vertexToTest.id);
+            const result = this.calculateShortestPathToMultipleDestinationsByVertex(vertexToTest, otherVertices);
+            const reachedVertices = otherVertices.filter(ov => result.weightedDistance(ov) !== null);
+
+            components.push([vertexToTest, ...reachedVertices]);
+            reachedVertices.forEach(rv => verticesToTest.delete(rv));
+        }
+
+        // As graph is ordered, fuse components with same vertices
+        for (let i = 0; i < components.length - 1; i++) {
+            const component1 = components[i];
+            for (let j = i + 1; j < components.length; j++) {
+                const component2 = components[j];
+                const componentsIntersect = component2.some(v => component1.includes(v));
+                if (componentsIntersect) {
+                    component1.push(...component2);
+                    components = components.filter(component => component !== component2);
+                }
+            }
+        }
+
+        return components.map(c => [... new Set(c)]);
+    }
+
 }

package/src/graph/Vertex.ts

@@ -5,6 +5,7 @@ import { GraphVertexJson } from '../types.js';
 export type VertexProperties = {
 
     name?: string;
+    externalId?: string | number;
 
     isGate?: boolean;
     isSubwayEntrance?: boolean;

package/src/model/Itinerary.ts

@@ -301,34 +301,38 @@ export default class Itinerary {
     }
 
     toGeoJson(): FeatureCollection {
-        const transformToPoint = (point: Coordinates, name?: string): Feature<Point> => ({
+        const transformToPoint = (point: Coordinates, name?: string, type?: string): Feature<Point> => ({
             type: "Feature",
-            properties: { name, level: point.level },
+            properties: { name, level: point.level, ...(type && { type }) },
             geometry: {
                 type: 'Point',
                 coordinates: [point.lng, point.lat]
             }
         });
-        const transformToMultiLineStrings = (segments: Coordinates[][], level: Level_t): Feature<MultiLineString> => {
-            return {
-                type: "Feature",
-                properties: { level, name: level?.toString() },
-                geometry: {
-                    type: 'MultiLineString',
-                    coordinates: segments.map(s => s.map(({ lat, lng }) => [lng, lat]))
-                }
+        const transformToMultiLineStrings = (segments: Coordinates[][], level: Level_t): Feature<MultiLineString> => ({
+            type: "Feature",
+            properties: { level, name: level?.toString() },
+            geometry: {
+                type: 'MultiLineString',
+                coordinates: segments.map(s => s.map(({ lat, lng }) => [lng, lat]))
             }
-        }
+        });
 
         const levelsOfItinerary = [...new Set(this.coords.map(c => Level.toString(c.level)))].map(Level.fromString);
         const segmentsSplitted: [Level_t, Coordinates[][]][] = levelsOfItinerary.map(loi => [loi, GeoUtils.createSegmentsAtLevel(this.coords, loi, true)]);
         const multiLineStrings = segmentsSplitted.map(([loi, segments]) => transformToMultiLineStrings(segments, loi))
+        const legsStarts = this.legs.map((leg, idx) => transformToPoint(leg.start.coords, `Leg ${idx} start`, 'leg-start'));
+        const legsEnds = this.legs.map((leg, idx) => transformToPoint(leg.end.coords, `Leg ${idx} end`, 'leg-end'));
+        const steps = this.steps.map(step => transformToPoint(step.coords, `Step ${step.number}`, 'step'))
         return {
             type: "FeatureCollection",
             features: [
-                transformToPoint(this.origin, 'origin'),
-                transformToPoint(this.destination, 'destination'),
-                ...multiLineStrings
+                transformToPoint(this.origin, 'origin', 'origin'),
+                transformToPoint(this.destination, 'destination', 'destination'),
+                ...multiLineStrings,
+                ...legsStarts,
+                ...legsEnds,
+                ...steps
             ]
         };
     }

package/src/types.ts

@@ -5,6 +5,7 @@ export type GraphVertexJson = CoordinatesCompressedJson;
 
 export type GeoGraphJson = {
     vertices: GraphVertexJson[],
+    verticesIds: (string | number)[], 
     edges: (
         [number, number] |
         [number, number, EdgeProperties]

package/src/wemap-multi/CustomNetworkMap.ts

@@ -190,17 +190,6 @@ class CustomNetworkMap {
         return this.router.calculateShortestPathToMultipleDestinations(start, ends, options);
     }
 
-    get disabledEdges() { return this.router.disabledEdges }
-
-    enableEdge(edgeId: number) {
-        const edge = this.graph.edges.find(e => e.id === edgeId);
-        return Boolean(edge && this.router.disabledEdges.delete(edge));
-    }
-
-    disableEdge(edgeId: number) {
-        const edge = this.graph.edges.find(e => e.id === edgeId);
-        return Boolean(edge && this.router.disabledEdges.add(edge));
-    }
 }
 
 export default CustomNetworkMap;

package/src/wemap-osm/OsmGraphUtils.ts

@@ -24,6 +24,7 @@ export default class OsmGraphUtils {
     static parseNodeProperties(osmNode: OsmNode): VertexProperties {
         return {
             ...(osmNode.name && { name: osmNode.name }),
+            ...(osmNode.id && { externalId: osmNode.id }),
             ...(osmNode.isGate && { isGate: osmNode.isGate }),
             ...(osmNode.isSubwayEntrance && { isSubwayEntrance: osmNode.isSubwayEntrance }),
             ...(osmNode.subwayEntranceRef && { subwayEntrsanceRef: osmNode.subwayEntranceRef })
@@ -33,6 +34,7 @@ export default class OsmGraphUtils {
     static parseWayProperties(osmWay: OsmWay): EdgeProperties {
         return {
             ...(osmWay.name && { name: osmWay.name }),
+            ...(osmWay.id && { externalId: osmWay.id }),
             ...(osmWay.isOneway && { isOneway: osmWay.isOneway }),
             ...(osmWay.areStairs && { areStairs: osmWay.areStairs }),
             ...(osmWay.isElevator && { isElevator: osmWay.isElevator }),
@@ -143,14 +145,14 @@ export default class OsmGraphUtils {
 
                 entryVertices.forEach(entryVertex => {
                     const vertexCenter = getOrCreateVertex(elevatorCenterFakeOsmNode, entryVertex.coords.level);
-                    edges.push(new Edge(vertexCenter, entryVertex));
+                    edges.push(new Edge(vertexCenter, entryVertex, { externalId: way.id }));
                 })
             });
 
 
         // 4. Link elevators vertices
-        elevatorVertices.forEach(([, name, verticesOfEachLevel]) => {
-            const elevatorEdgeProps = { name, isElevator: true };
+        elevatorVertices.forEach(([id, name, verticesOfEachLevel]) => {
+            const elevatorEdgeProps = { name, isElevator: true, externalId: id };
             // Link vertices of each level together
             for (let i = 0; i < verticesOfEachLevel.length; i++) {
                 for (let j = i + 1; j < verticesOfEachLevel.length; j++) {

package/src/wemap-osm/OsmRouter.spec.ts

@@ -265,3 +265,28 @@ describe('OsmRouter - getTrip', () => {
         expect(router.getShortestTrip([p1, p2, p3, p4, p5, p6])).is.empty;
     });
 });
+
+
+describe('OsmRouter - create graph components', () => {
+
+    const networkModel = loadGraph('components.osm');
+    const router = new GraphRouter(networkModel);
+
+    const arraysEqual = <T>(a: T[], b: T[]) => JSON.stringify(a.sort()) === JSON.stringify(b.sort());
+    const findComponent = (components: Vertex[][], vertexNames: string[]) =>
+        components.find(c => arraysEqual(c.map(v => v.properties.name), vertexNames))
+
+    it('createComponents()', () => {
+        const components = router.calculateComponents();
+
+        // console.log(JSON.stringify(components.map(c => c.map(v => v.properties.name)), null, 4));
+        expect(components.length).equal(6);
+        expect(findComponent(components, ['p1', 'p2', 'p3', 'p4'])).to.be.not.undefined;
+        expect(findComponent(components, ['p11', 'p12', 'p13'])).to.be.not.undefined;
+        expect(findComponent(components, ['p13', 'p14'])).to.be.not.undefined;
+        expect(findComponent(components, ['p21', 'p22'])).to.be.not.undefined;
+        expect(findComponent(components, ['p31', 'p32', 'p32', 'p33', 'p34'])).to.be.not.undefined;
+        expect(findComponent(components, ['p41', 'p42', 'p43', 'p44', 'p45', 'p46', 'p47', 'p48'])).to.be.not.undefined;
+    });
+
+});

package/src/wemap-osm/OsmRouterOptions.ts

@@ -1,13 +0,0 @@
-// TODO: remove
-export type OsmRouterOptions = {
-
-    useStairs?: boolean;
-
-    useEscalators?: boolean;
-
-    useElevators?: boolean;
-
-    isTrip?: boolean;
-
-    tspTempCoeff?: number;
-}