@wemap/routers 12.10.8 → 12.10.9

package/src/graph/GraphRouter.ts

@@ -1,229 +0,0 @@
-import salesman from '@wemap/salesman.js';
-
-import { Coordinates } from '@wemap/geo';
-
-import Vertex from './Vertex.js';
-import Edge, { EdgeProperties } from './Edge.js';
-import GraphRoute from './GraphRoute.js';
-import GraphRouterEngine, { GraphRouterEngineResults } from './GraphRouterEngine.js';
-import { type GraphRouterOptions } from './GraphRouterOptions.js';
-import GraphRouterOptionsBuilder from './GraphRouterOptionsBuilder.js';
-
-export class GraphRouterResults extends GraphRouterEngineResults {
-
-    constructor(
-        engineResults: GraphRouterEngineResults,
-        public sourceProjection: [Coordinates, Vertex | null],
-        public targetsProjections: [Coordinates, Vertex | null][]
-
-    ) {
-        super(engineResults.prev, engineResults.dist, engineResults.source, engineResults.targets, engineResults.edges);
-    }
-
-    static createEmpty(source: Coordinates, targets: Coordinates[]) {
-        const length = targets.length;
-        const engineResults = new GraphRouterEngineResults(
-            new Array(length).fill(null),
-            new Array(length).fill(Number.MAX_VALUE),
-            new Vertex(source),
-            targets.map(target => new Vertex(target)),
-            []
-        );
-        const sourceProjection: [Coordinates, null] = [source, null];
-        const targetsProjections: [Coordinates, null][] = targets.map(target => [target, null]);
-        return new GraphRouterResults(engineResults, sourceProjection, targetsProjections);
-    }
-
-    routeVertices(to: Coordinates | Vertex = this.targetsProjections[0][0]): Vertex[] {
-
-        if (to instanceof Vertex) {
-            return super.routeVertices(to);
-        }
-
-        const sourceVertex = this.sourceProjection[1];
-        if (!sourceVertex) return [];
-
-        const toVertex = this.targetsProjections.find(([coord]) => coord === to)?.[1];
-        if (!toVertex) return [];
-
-        return super.routeVertices(toVertex);
-    }
-
-    weightedDistance(to: Coordinates | Vertex = this.targetsProjections[0][0]) {
-
-        if (to instanceof Vertex) {
-            return super.weightedDistance(to);
-        }
-
-        const sourceVertex = this.sourceProjection[1];
-        if (!sourceVertex) return null;
-
-        const toVertex = this.targetsProjections.find(([coord]) => coord === to)?.[1];
-        if (!toVertex) return null;
-
-        return super.weightedDistance(toVertex);
-    }
-
-    route(to: Coordinates | Vertex = this.targetsProjections[0][0]) {
-
-        if (to instanceof Vertex) {
-            return super.route(to);
-        }
-
-        const toVertex = this.targetsProjections.find(([coord]) => coord === to)?.[1];
-        if (!toVertex) return new GraphRoute(this.sourceProjection[0], to, [], [], []);
-
-        const route = super.route(toVertex);
-        route.start = this.sourceProjection[0];
-        route.end = to;
-        return route;
-    }
-}
-
-
-class GraphRouter extends GraphRouterEngine {
-
-    calculateShortestPathToMultipleDestinations(
-        source: Coordinates,
-        targets: Coordinates[],
-        options: GraphRouterOptions = GraphRouterOptionsBuilder.DEFAULT,
-    ): GraphRouterResults {
-
-        const createdVertices = new Set<Vertex>();
-        const createdEdges = new Set<Edge>();
-        const createdVerticesByOriginalEdges: [Edge, Vertex[]][] = []
-
-        const projectionsOptions = {
-            maxDistance: options.projectionMaxDistance,
-            acceptEdgeFn: options.acceptEdgeFn,
-            useMultiLevelSegments: options.useMultiLevelSegments,
-        };
-
-        const getOrCreateVertex = (coords: Coordinates): Vertex | null => {
-            const projection = this.graph.getProjection(coords, projectionsOptions);
-            if (projection === null) return null;
-            if (projection.nearestElement instanceof Vertex) {
-                return projection.nearestElement;
-            }
-            if (projection.nearestElement instanceof Edge) {
-                const edge = projection.nearestElement;
-                const newVertex = new Vertex(projection.coords, {
-                    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,
-                    ...(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);
-
-                createdVertices.add(newVertex);
-                createdEdges.add(newEdge1);
-                createdEdges.add(newEdge2);
-
-                const createdVerticesByOriginalEdge = createdVerticesByOriginalEdges.find(p => p[0] === edge)
-                if (!createdVerticesByOriginalEdge) {
-                    createdVerticesByOriginalEdges.push([edge, [newVertex]])
-                } else {
-                    createdVerticesByOriginalEdge[1].push(newVertex);
-                }
-                return newVertex;
-            }
-
-            return null; // Should never happens
-        }
-
-        const sourceVertex = getOrCreateVertex(source);
-        if (!sourceVertex) return GraphRouterResults.createEmpty(source, targets);
-
-        const targetsProjections: [Coordinates, Vertex | null][] = targets.map(target => [target, getOrCreateVertex(target)]);
-        const targetsVertices = targetsProjections.map(([, vertex]) => vertex).filter(p => p !== null) as Vertex[];
-
-        // In some specific cases, more than one vertex is created from an original edge.
-        // And this vertices need to be connected together.
-        createdVerticesByOriginalEdges.filter(pair => pair[1].length >= 2);
-        createdVerticesByOriginalEdges.forEach(([edge, vertices]) => {
-            const newEdgesOptions: EdgeProperties = {
-                ...edge.properties,
-                name: `splitted ${edge.properties.name || null} (tmp)`,
-            };
-            for (let i = 0; i < vertices.length; i++) {
-                const vertexA = vertices[i];
-                const distVertexAVertex1 = vertexA.distanceTo(edge.vertex1)
-                for (let j = i + 1; j < vertices.length; j++) {
-                    const vertexB = vertices[j];
-                    const distVertexBVertex1 = vertexB.distanceTo(edge.vertex1)
-                    const reverse = distVertexBVertex1 < distVertexAVertex1;
-                    const newEdge = !reverse
-                        ? new Edge(vertexA, vertexB, newEdgesOptions)
-                        : new Edge(vertexB, vertexA, newEdgesOptions);
-                    createdEdges.add(newEdge);
-                }
-            }
-        })
-
-
-        const engineResults = this.calculateShortestPathToMultipleDestinationsByVertex(
-            sourceVertex, targetsVertices, options,
-            [...this.graph.vertices, ...createdVertices],
-            [...this.graph.edges, ...createdEdges],
-        );
-
-        return new GraphRouterResults(engineResults, [source, sourceVertex], targetsProjections);
-    }
-
-    calculateShortestPath(
-        source: Coordinates,
-        target: Coordinates,
-        options: GraphRouterOptions = GraphRouterOptionsBuilder.DEFAULT,
-    ): GraphRouterResults {
-        return this.calculateShortestPathToMultipleDestinations(source, [target], options);
-    }
-
-
-    // TODO: Verify if it works well with oneway edges
-    getShortestTrip(waypoints: Coordinates[], options?: GraphRouterOptions, tspTempCoeff = 0.99) {
-        type CustomPoint = salesman.Point & { coords: Coordinates };
-
-        const points = waypoints.map(waypoint => {
-            const point = new salesman.Point(0, 0) as CustomPoint;
-            point.coords = waypoint;
-            return point;
-        });
-        const graphRoutesCache: GraphRoute[] = [];
-        const solution = salesman.solve(points, tspTempCoeff, undefined, (p: salesman.Point, q: salesman.Point) => {
-            const route = this.calculateShortestPath(
-                (p as CustomPoint).coords,
-                (q as CustomPoint).coords,
-                options
-            ).route();
-            graphRoutesCache.push(route);
-            if (!route.hasRoute) { return Number.MAX_VALUE }
-            return route.edgesWeights.reduce((acc, weight) => acc + weight, 0);
-        });
-
-        const orderedPoints = solution.map(i => points[i]);
-        const orderedRoutes = [];
-        for (let i = 0; i < orderedPoints.length; i++) {
-            const p = orderedPoints[i] as CustomPoint;
-            const q = orderedPoints[(i + 1) % orderedPoints.length] as CustomPoint;
-            let cachedRoute = graphRoutesCache.find(route => route.start === p.coords && route.end === q.coords || route.end === p.coords && route.start === q.coords);
-            if (cachedRoute?.end === p.coords) {
-                // Need to revert route due to salesman bijectivity
-                cachedRoute = cachedRoute.reverse();
-            }
-            if (cachedRoute) {
-                orderedRoutes.push(cachedRoute);
-            }
-        }
-
-        if (orderedRoutes.some(route => !route.hasRoute)) return [];
-
-        return orderedRoutes;
-    }
-
-
-}
-export default GraphRouter;

package/src/graph/GraphRouterEngine.ts

@@ -1,248 +0,0 @@
-
-import { ColorUtils } from '@wemap/utils';
-import Edge from './Edge.js';
-import Graph from './Graph.js';
-import GraphRoute from './GraphRoute.js';
-import { type GraphRouterOptions } from './GraphRouterOptions.js';
-import GraphRouterOptionsBuilder from './GraphRouterOptionsBuilder.js';
-import Vertex from './Vertex.js';
-
-export class GraphRouterEngineResults {
-    constructor(
-        public prev: Array<Vertex | null>,
-        public dist: number[],
-        public source: Vertex,
-        public targets: Vertex[],
-        public edges: Edge[]
-    ) { }
-
-    routeVertices(to = this.targets[0], list: Vertex[] = []): Vertex[] {
-        const last = this.prev[to.id];
-        if (last === null) return this.source === to ? [...list, to] : [];
-        return [...this.routeVertices(last, list), to];
-    }
-
-    weightedDistance(to = this.targets[0]) {
-        const distance = this.dist[to.id];
-        return distance === Number.MAX_VALUE ? null : distance;
-    }
-
-    route(to = this.targets[0]) {
-
-        const path = this.routeVertices(to);
-
-        const edges = [];
-        const edgesWeights = [];
-        for (let i = 1; i < path.length; i++) {
-            const v1 = path[i - 1];
-            const v2 = path[i];
-            const graphEdge = Edge.getEdgeByVertices(this.edges, v1, v2)!;
-            const clonedEdge = new Edge(v1, v2, Object.assign({}, graphEdge.properties));
-            const isReversed = graphEdge.vertex1 === clonedEdge.vertex2;
-            if (isReversed) {
-                clonedEdge.reverseProperties();
-            }
-            edges.push(clonedEdge);
-            edgesWeights.push(this.dist[v2.id] - this.dist[v1.id]);
-        }
-        return new GraphRoute(this.source.coords, to.coords, path, edges, edgesWeights);
-    }
-
-    toGeoJson(graph: Graph) {
-        return {
-            type: "FeatureCollection",
-            features: [
-                ...graph.vertices.map(v => {
-                    const prev = this.prev[v.id];
-                    const dist = this.dist[v.id];
-                    const isSource = v === this.source;
-                    const isTarget = this.targets.includes(v);
-                    const level = v.coords.level;
-                    return {
-                        type: "Feature",
-                        properties: {
-                            id: v.id,
-                            ...(prev && { prev: prev.id }),
-                            dist: dist === Number.MAX_VALUE ? 'infinity' : dist,
-                            ...(isSource && { name: 'source' }),
-                            ...(isTarget && { name: 'target' }),
-                            ...(level !== null && { level }),
-                            ...v.properties
-                        },
-                        geometry: {
-                            type: 'Point',
-                            coordinates: [v.coords.lng, v.coords.lat]
-                        }
-                    }
-                }),
-                ...graph.edges.map(e => {
-                    const level = e.level;
-                    return {
-                        type: "Feature",
-                        properties: {
-                            id: e.id,
-                            ...(level !== null && { level }),
-                            ...e.properties
-                        },
-                        geometry: {
-                            type: 'LineString',
-                            coordinates: [
-                                [e.vertex1.coords.lng, e.vertex1.coords.lat],
-                                [e.vertex2.coords.lng, e.vertex2.coords.lat]
-                            ]
-                        }
-                    }
-                })
-            ]
-        };
-    }
-}
-
-export default class GraphRouterEngine {
-
-    disabledEdges: Set<Edge> = new Set();
-
-    constructor(public readonly graph: Graph) {
-        let vertexId = 0;
-        graph.vertices.forEach(vertex => vertex.id = vertexId++);
-    }
-
-    calculateShortestPathToMultipleDestinationsByVertex(
-        source: Vertex,
-        targets: Vertex[],
-        options: GraphRouterOptions = GraphRouterOptionsBuilder.DEFAULT,
-        inputVertices = this.graph.vertices,
-        inputEdges = this.graph.edges
-    ): GraphRouterEngineResults {
-
-        const q = new Set(inputVertices);
-        const dist = Array(q.size).fill(Number.MAX_VALUE);
-        const prev = new Array<Vertex | null>(q.size).fill(null);
-        const edges = inputEdges.filter(e => (options.acceptEdgeFn?.(e) ?? true) && !this.disabledEdges.has(e));
-        const weightEdgeFn = options.weightEdgeFn || ((edge: Edge) => edge.length);
-
-        const getVertexWithMinDistance = (vertices: Set<Vertex>): Vertex | null => {
-            let minDistance = Number.MAX_VALUE;
-            let vertex: Vertex | null = null;
-            vertices.forEach(_vertex => {
-                const distance = dist[_vertex.id];
-                if (distance <= minDistance) {
-                    minDistance = distance;
-                    vertex = _vertex;
-                }
-            });
-            return vertex;
-        }
-
-
-        const remainingNodesToFind = new Set(targets);
-
-        dist[source.id] = 0;
-
-        while (q.size > 0) {
-            const u = getVertexWithMinDistance(q)!;
-            q.delete(u);
-
-            if (targets.includes(u)) {
-                remainingNodesToFind.delete(u);
-                if (remainingNodesToFind.size === 0) {
-                    break;
-                }
-            }
-
-            edges
-                .filter(edge => edge.vertex1 == u || !edge.properties.isOneway && edge.vertex2 == u)
-                .forEach(edge => {
-                    const v = u === edge.vertex1 ? edge.vertex2 : edge.vertex1;
-                    const distance = weightEdgeFn(edge);
-                    const alt = dist[u.id] + distance;
-                    if (alt < dist[v.id]) {
-                        dist[v.id] = alt;
-                        prev[v.id] = u
-                    }
-                });
-        }
-
-        return new GraphRouterEngineResults(prev, dist, source, targets, edges);
-    }
-
-    calculateShortestPathByVertex(
-        source: Vertex,
-        target: Vertex,
-        options: GraphRouterOptions = GraphRouterOptionsBuilder.DEFAULT,
-        inputVertices = this.graph.vertices,
-        inputEdges = this.graph.edges
-    ): 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
-        let hasChanged;
-        do {
-            hasChanged = false;
-            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);
-                        hasChanged = true;
-                    }
-                }
-            }
-        } while (hasChanged)
-
-        return components.map(c => [... new Set(c)]);
-    }
-
-    toGeoJson() {
-        const components = this.calculateComponents();
-        const features = components.map((component, i) => {
-            const edges = this.graph.edges.filter(edge => component.includes(edge.vertex1) && component.includes(edge.vertex2));
-            return {
-                "type": "Feature",
-                "geometry": {
-                    "type": "MultiLineString",
-                    "coordinates":
-                        edges.map(e => [
-                            [e.vertex1.coords.lng, e.vertex1.coords.lat],
-                            [e.vertex2.coords.lng, e.vertex2.coords.lat],
-                        ])
-                },
-                "properties": {
-                    "stroke": '#' + ColorUtils.getQualitativeColor(i).toString(16)
-                }
-            }
-        });
-
-        return {
-            "type": "FeatureCollection",
-            "features": features
-        };
-    }
-
-}

package/src/graph/GraphRouterOptionsBuilder.ts

@@ -1,98 +0,0 @@
-import Edge from './Edge.js';
-import { getDurationFromLength } from '../Utils.js';
-import { GraphRouterOptionsJson, type GraphRouterOptions } from './GraphRouterOptions.js';
-
-export default class GraphRouterOptionsBuilder {
-
-    public avoidStairs = false;
-    public avoidEscalators = false;
-    public avoidElevators = false;
-    public avoidMovingWalkways = false;
-    public avoidTicketRestrictedAreas = false;
-    public useMultiLevelSegments = false;
-    public projectionMaxDistance?: number;
-
-    static DEFAULT = new GraphRouterOptionsBuilder().build();
-    static WITHOUT_STAIRS = new GraphRouterOptionsBuilder().setAvoidStairs(true).build();
-
-    setAvoidStairs(avoidStairs: boolean) {
-        this.avoidStairs = avoidStairs;
-        return this;
-    }
-
-    setAvoidEscalators(avoidEscalators: boolean) {
-        this.avoidEscalators = avoidEscalators;
-        return this;
-    }
-
-    setAvoidElevators(avoidElevators: boolean) {
-        this.avoidElevators = avoidElevators;
-        return this;
-    }
-
-    setAvoidMovingWalkways(avoidMovingWalkways: boolean) {
-        this.avoidMovingWalkways = avoidMovingWalkways;
-        return this;
-    }
-
-    setAvoidTicketRestrictedAreas(avoidTicketRestrictedAreas: boolean) {
-        this.avoidTicketRestrictedAreas = avoidTicketRestrictedAreas;
-        return this;
-    }
-
-    setUseMultiLevelSegments(useMultiLevelSegments: boolean) {
-        this.useMultiLevelSegments = useMultiLevelSegments;
-        return this;
-    }
-
-    static fromJson(options: GraphRouterOptionsJson) {
-        const builder = new GraphRouterOptionsBuilder();
-        Object.assign(builder, options);
-        return builder.build();
-    }
-
-    build(): GraphRouterOptions {
-
-        const weightEdgeFn = (edge: Edge) => {
-            if (edge.properties.isElevator) {
-                return 90;
-            }
-            let duration = getDurationFromLength(edge.length, 4);
-            if (edge.properties.areStairs) {
-                duration *= 3;
-            } else if (edge.properties.areEscalators) {
-                duration *= 1.5;
-            } else if (edge.properties.isMovingWalkway) {
-                duration *= 0.8;
-            }
-            return duration;
-        }
-
-        const acceptEdgeFn = (edge: Edge) => {
-
-            if (this.avoidStairs && edge.properties.areStairs) return false;
-            if (this.avoidEscalators && edge.properties.areEscalators) return false;
-            if (this.avoidElevators && edge.properties.isElevator) return false;
-            if (this.avoidMovingWalkways && edge.properties.isMovingWalkway) return false;
-            if (this.avoidTicketRestrictedAreas && edge.properties.needTicket) return false;
-
-            return true;
-        };
-
-        return {
-            input: {
-                avoidStairs: this.avoidStairs,
-                avoidEscalators: this.avoidEscalators,
-                avoidElevators: this.avoidElevators,
-                avoidMovingWalkways: this.avoidMovingWalkways,
-                avoidTicketRestrictedAreas: this.avoidTicketRestrictedAreas,
-                projectionMaxDistance: this.projectionMaxDistance
-            },
-            weightEdgeFn,
-            acceptEdgeFn,
-            projectionMaxDistance: this.projectionMaxDistance,
-            useMultiLevelSegments: this.useMultiLevelSegments
-        };
-    }
-
-}

package/src/graph/NoRouteFoundError.ts

@@ -1,39 +0,0 @@
-import { Coordinates } from '@wemap/geo';
-
-import Vertex from './Vertex.js';
-
-class NoRouteFoundError extends Error {
-
-    constructor(
-        public start: Vertex | Coordinates,
-        public end: Vertex | Coordinates | (Coordinates | Vertex)[],
-        public details: string | null = null
-    ) { super(); }
-
-    get startStr() {
-        if (this.start instanceof Vertex) {
-            return `Vertex ${this.start.coords.toString()}`;
-        }
-        return this.start.toString();
-    }
-
-    get endStr() {
-        if (this.end instanceof Vertex) {
-            return `Vertex ${this.end.coords.toString()}`;
-        }
-        if (Array.isArray(this.end)) {
-            return this.end.map(p => p instanceof Vertex ? p.coords.toString() : p.toString()).join(',');
-        }
-        return this.end.toString();
-    }
-
-    get message() {
-        let message = `No route found from ${this.startStr} to ${this.endStr}.`;
-        if (this.details) {
-            message += ` Details: ${this.details}`;
-        }
-        return message;
-    }
-}
-
-export default NoRouteFoundError;

package/src/graph/Vertex.spec.ts

@@ -1,42 +0,0 @@
-import chai from 'chai';
-
-import { Coordinates } from '@wemap/geo';
-
-import Vertex from './Vertex.js';
-
-const { expect } = chai;
-
-describe('Vertex', () => {
-
-    it('creation', () => {
-
-        expect(() => new Vertex(new Coordinates(0, 0))).not.throw(Error);
-
-    });
-
-
-    const pos1 = new Coordinates(45, 5);
-    const pos2 = new Coordinates(46, 5);
-    const vertex1 = new Vertex(pos1);
-    const vertex2 = new Vertex(pos2);
-
-    it('distanceTo', () => {
-        expect(vertex1.distanceTo(vertex2)).equals(pos1.distanceTo(pos2));
-    });
-
-    it('bearingTo', () => {
-        expect(vertex1.bearingTo(vertex2)).equals(pos1.bearingTo(pos2));
-    });
-
-    it('toJson / fromJson', () => {
-
-        const vertex = new Vertex(pos1);
-
-        const jsonVertex = vertex.toJson();
-        expect(jsonVertex).deep.equals({ id: -1, coords: [45, 5] });
-
-        const vertexBis = Vertex.fromJson(jsonVertex);
-        expect(vertexBis.coords.equals(vertex.coords)).true;
-        expect(vertexBis.id).equals(vertex.id);
-    });
-});