@wemap/routers 12.10.8 → 12.10.9

package/src/graph/Graph.ts

@@ -1,272 +0,0 @@
-import { diffAngleLines } from '@wemap/maths';
-import { BoundingBox, Coordinates, Level, UserPosition, Level_t, Constants as GeoConstants } from '@wemap/geo';
-
-import Edge from './Edge.js';
-import GraphProjection from './GraphProjection.js';
-import Vertex from './Vertex.js';
-import { type CompressedGeoGraphJson, type GeoGraphJson } from '../types.js';
-import { type GraphProjectionOptions } from './GraphProjectionOptions.js';
-
-
-class Graph {
-
-    /**
-     * exitVertices are vertices that have at least one indoor edge and one outdoor edge
-     * They are stored because the Level model cannot handle an indoor and outdoor state like [null, 1] or [null, [1,2]]
-     * This vertices are used to cover the projection case:
-     * - if projection origin is null, an exit vertex can be used
-     * - if projection origin is not null, the intersection level with an exit vertex can be used
-     */
-    public readonly exitVertices: Set<Vertex>;
-
-    constructor(public readonly vertices: Vertex[], public readonly edges: Edge[]) {
-        const nullVertices = edges.filter(e => e.level === null).map(e => [e.vertex1, e.vertex2]).flat();
-        const levelVertices = edges.filter(e => e.level !== null).map(e => [e.vertex1, e.vertex2]).flat();
-        this.exitVertices = new Set(nullVertices.filter(v1 => levelVertices.includes(v1)));
-    }
-
-    getEdgeByVertices(vertex1: Vertex, vertex2: Vertex) {
-        return Edge.getEdgeByVertices(this.edges, vertex1, vertex2);
-    }
-
-    getVertexByCoords(coords: Coordinates) {
-        return Graph.getVertexByCoords(this.vertices, coords);
-    }
-
-    static getVertexByCoords(vertices: Vertex[], coords: Coordinates) {
-        return vertices.find(vertex => vertex.coords.equals(coords));
-    }
-
-    getVertexByName(name: string) {
-        return this.vertices.find(vertex => vertex.properties.name === name);
-    }
-
-    getEdgeByName(name: string) {
-        return this.edges.find(edge => edge.properties.name === name);
-    }
-
-    getBoundingBox(extendedMeasure?: number) {
-        if (!this.vertices.length) {
-            return null;
-        }
-        const boundingBox = BoundingBox.fromCoordinates(this.vertices.map(vertex => vertex.coords)) as BoundingBox;
-        if (extendedMeasure) {
-            boundingBox.extendsWithMeasure(extendedMeasure);
-        }
-        return boundingBox;
-    }
-
-    getProjection<U extends (Coordinates | UserPosition)>(
-        origin: U,
-        options: GraphProjectionOptions = {}
-    ): GraphProjection<U> | null {
-
-        const useMaxDistance = 'maxDistance' in options;
-        const maxDistance = options.maxDistance!
-
-        const useMaxBearingAngle = 'maxBearingAngle' in options;
-        if (useMaxBearingAngle && (!(origin instanceof UserPosition) || origin.bearing === null)) return null;
-        const maxBearingAngle = options.maxBearingAngle!;
-
-        const useAcceptEdgeFn = 'acceptEdgeFn' in options;
-
-        const useMultiLevelSegments = !('useMultiLevelSegments' in options) || options.useMultiLevelSegments;
-
-        let bestProjection: GraphProjection<U> | null = null;
-
-        // (for as any) See. https://www.totaltypescript.com/any-considered-harmful#returning-conditional-types-from-generic-functions
-        const adaptProjectionCoords = (projCoords: Coordinates): U => {
-            if (!(origin instanceof UserPosition)) return projCoords as any;
-            const p = origin.clone();
-            p.lat = projCoords.lat;
-            p.lng = projCoords.lng;
-            p.level = projCoords.level;
-            p.alt = projCoords.alt;
-            p.heightFromFloor = projCoords.heightFromFloor;
-            p.heightFromGround = projCoords.heightFromGround;
-            return p as any;
-        }
-
-        this.edges.forEach(edge => {
-
-            if (useAcceptEdgeFn && !options.acceptEdgeFn!(edge)) return;
-            if (!useMultiLevelSegments && Level.isRange(edge.level)) return;
-            if (!Level.intersect(edge.level, origin.level)) return;
-
-            if (useMaxBearingAngle) {
-                // Do not try to project if angle is greater than the threshold
-                if (diffAngleLines(edge.bearing, (origin as UserPosition).bearing!) > maxBearingAngle) return;
-            }
-
-            const segmentProjection = origin.getSegmentProjection(edge.vertex1.coords, edge.vertex2.coords);
-            if (!segmentProjection) return;
-            const distanceToSegment = segmentProjection.distanceTo(origin);
-
-            if (useMaxDistance && distanceToSegment > maxDistance) return;
-
-            if (distanceToSegment < (bestProjection?.distanceFromNearestElement ?? Number.MAX_VALUE)) {
-                bestProjection = new GraphProjection(origin, distanceToSegment, adaptProjectionCoords(segmentProjection), edge);
-            }
-        });
-
-        // if mapmatching bearing is enabled do not use vertices matching
-        if (useMaxBearingAngle) {
-            return bestProjection;
-        }
-
-        this.vertices.forEach(vertex => {
-            let vertexCoords = vertex.coords;
-
-            // Specific case of io nodes that have a non-null level but can be matched to a null origin level
-            if (this.exitVertices.has(vertex) && origin.level === null) {
-                vertexCoords = vertex.coords.clone();
-                vertexCoords.level = null;
-            }
-
-            if (!useMultiLevelSegments && Level.isRange(vertexCoords.level)) return;
-            if (!Level.intersect(vertexCoords.level, origin.level)) return;
-
-            const distanceToVertex = vertexCoords.distanceTo(origin);
-
-            // If distance below epsilon consider it as best projection
-            if (distanceToVertex < GeoConstants.EPS_MM) {
-                bestProjection = new GraphProjection(origin, 0, adaptProjectionCoords(vertexCoords), vertex);
-                return;
-            }
-
-            if (useMaxDistance && distanceToVertex > maxDistance) return;
-
-            if (distanceToVertex < (bestProjection?.distanceFromNearestElement ?? Number.MAX_VALUE)) {
-                bestProjection = new GraphProjection(origin, distanceToVertex, adaptProjectionCoords(vertexCoords), vertex);
-            }
-        });
-
-        return bestProjection;
-    }
-
-
-    toJson(): GeoGraphJson {
-        return {
-            vertices: this.vertices.map(vertex => vertex.toJson()),
-            edges: this.edges.map(edge => ({
-                id: edge.id,
-                vertex1Idx: this.vertices.indexOf(edge.vertex1),
-                vertex2Idx: this.vertices.indexOf(edge.vertex2),
-                ...(Object.keys(edge.properties).length > 0 && { properties: edge.properties })
-            }))
-        };
-    }
-
-    static fromJson(json: GeoGraphJson) {
-
-        const vertices = json.vertices.map(vertex => Vertex.fromJson(vertex));
-        const edges = json.edges.map(jsonEdge => new Edge(
-            vertices[jsonEdge.vertex1Idx],
-            vertices[jsonEdge.vertex2Idx],
-            jsonEdge.properties,
-            jsonEdge.id
-        ));
-
-        return new Graph(vertices, edges);
-    }
-
-    /** @deprecated */
-    toCompressedJson(): CompressedGeoGraphJson {
-        return {
-            vertices: this.vertices.map(vertex => vertex.coords.toCompressedJson()),
-            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);
-                const edgeExtras = edge.properties;
-                if (Object.keys(edgeExtras).length > 0) {
-                    return [vertex1Idx, vertex2Idx, edgeExtras];
-                }
-                return [vertex1Idx, vertex2Idx];
-            })
-        };
-    }
-
-    /** @deprecated */
-    static fromCompressedJson(json: CompressedGeoGraphJson) {
-        const vertices = json.vertices.map(vertex => new Vertex(Coordinates.fromCompressedJson(vertex)));
-        const edges = json.edges.map(jsonEdge => new Edge(
-            vertices[jsonEdge[0]],
-            vertices[jsonEdge[1]],
-            jsonEdge.length > 2 ? jsonEdge[2] : {}
-        ));
-
-        return new Graph(vertices, edges);
-    }
-
-
-    static fromCoordinatesSegments(segments: Coordinates[][]) {
-
-        const vertices: Vertex[] = [];
-        const edges: Edge[] = [];
-
-        const getOrCreateVertex = (coords: Coordinates) => {
-            const vertex = vertices.find(otherVertex => otherVertex.coords.equals(coords));
-            if (vertex) {
-                return vertex;
-            }
-            const newVertex = new Vertex(coords);
-            vertices.push(newVertex);
-            return newVertex;
-        };
-
-        for (const segment of segments) {
-
-            let previousVertex = null;
-            for (const coords of segment) {
-                const currentVertex = getOrCreateVertex(coords);
-
-                if (previousVertex) {
-                    edges.push(new Edge(currentVertex, previousVertex));
-                }
-
-                previousVertex = currentVertex;
-            }
-        }
-
-        return new Graph(vertices, edges);
-    }
-
-    /**
-     * Create edges From MultiLevel Itinerary for a given level
-     * @param useMultiLevelEdges use segments which intersect both levels (stairs, elevators...)
-     */
-    getEdgesAtLevel(targetLevel: Level_t, useMultiLevelEdges = true) {
-        return this.edges.filter(
-            ({ level }) => useMultiLevelEdges
-                ? Level.intersect(targetLevel, level)
-                : Level.contains(targetLevel, level)
-        );
-    }
-
-
-    toDetailedString() {
-        let output
-            = '--- Network ---\n'
-            + `Vertices: ${this.vertices.length}\n`
-            + `Edges: ${this.edges.length}\n`
-            + '---\n'
-            + 'Vertices\n';
-        this.vertices.forEach(vertex => {
-            output += vertex.id;
-            const vertexProps = vertex.properties;
-            if (Object.keys(vertexProps).length !== 0) { output += ` ${vertexProps}` }
-        });
-        output += '---\n'
-            + 'Edges\n';
-        this.edges.forEach(edge => {
-            output += `${edge.id} - [v1: ${edge.vertex1.id}, v2: ${edge.vertex2.id}]`;
-            const edgeProps = edge.properties;
-            if (Object.keys(edgeProps).length !== 0) { output += ` ${edgeProps}` }
-        });
-        output += '---';
-        return output;
-    }
-}
-
-export default Graph;

package/src/graph/GraphProjection.ts

@@ -1,15 +0,0 @@
-import { Coordinates, UserPosition } from '@wemap/geo';
-
-import Edge from './Edge.js';
-import Vertex from './Vertex.js';
-
-class GraphProjection<U extends Coordinates | UserPosition = Coordinates> {
-    constructor(
-        public readonly origin: U,
-        public readonly distanceFromNearestElement: number,
-        public readonly coords: U,
-        public readonly nearestElement: Vertex | Edge
-    ) { }
-}
-
-export default GraphProjection;

package/src/graph/GraphProjectionOptions.ts

@@ -1,8 +0,0 @@
-import Edge from './Edge.js'
-
-export type GraphProjectionOptions = {
-    maxDistance?: number,
-    maxBearingAngle?: number,
-    useMultiLevelSegments?: boolean,
-    acceptEdgeFn?: (edge: Edge) => boolean
-}

package/src/graph/GraphRoute.spec.ts

@@ -1,15 +0,0 @@
-import chai from 'chai';
-
-import GraphRoute from './GraphRoute.js';
-
-const { expect } = chai;
-
-export function isReadable(itinerary: GraphRoute) {
-    for (let i = 0; i < itinerary.vertices.length; i++) {
-        const vertex = itinerary.vertices[i];
-        if (i !== itinerary.vertices.length - 1) {
-            expect(itinerary.edges[i].vertex1).equal(vertex);
-            expect(itinerary.edges[i].vertex2).equal(itinerary.vertices[i + 1]);
-        }
-    }
-}

package/src/graph/GraphRoute.ts

@@ -1,43 +0,0 @@
-import { Coordinates } from '@wemap/geo';
-
-import Graph from "./Graph.js";
-import Edge from './Edge.js';
-import Vertex from './Vertex.js';
-import { getDurationFromLength } from '../Utils.js';
-
-
-/**
- * GraphRoute is an oriented graph
- */
-class GraphRoute extends Graph {
-    constructor(
-        public start: Coordinates,
-        public end: Coordinates,
-        public vertices: Vertex[],
-        public edges: Edge[],
-        public edgesWeights: number[]
-    ) {
-        super(vertices, edges);
-    }
-
-    // /!\ Does not clone vertices
-    // /!\ Create new Edges but does not deep clone properties
-    // /!\ Does not revert edge oneway property
-    reverse() {
-        const vertices = this.vertices.slice().reverse();
-        const edges = this.edges.slice().reverse();
-        const edgesWeights = this.edgesWeights.slice().reverse();
-        edges.map(oldEdge => new Edge(oldEdge.vertex2, oldEdge.vertex1, oldEdge.properties));
-        return new GraphRoute(this.start, this.end, vertices, edges, edgesWeights);
-    }
-
-    static fromCoordinates(start: Coordinates, end: Coordinates, coordinates: Coordinates[]) {
-        const graph = Graph.fromCoordinatesSegments([coordinates]);
-        const edgesWeights = graph.edges.map(e => getDurationFromLength(e.length));
-        return new GraphRoute(start, end, graph.vertices, graph.edges, edgesWeights);
-    }
-
-    get hasRoute() { return Boolean(this.vertices.length) }
-}
-
-export default GraphRoute;

package/src/graph/GraphRouter.spec.ts

@@ -1,317 +0,0 @@
-import chai from 'chai';
-import chaiAlmost from 'chai-almost';
-
-import { Coordinates, type Level_t } from '@wemap/geo';
-
-import Graph from './Graph.js';
-import Vertex from './Vertex.js';
-import Edge from './Edge.js';
-
-import GraphRouter from './GraphRouter.js';
-import GraphRoute from './GraphRoute.js';
-import { type GraphRouterOptions } from './GraphRouterOptions.js';
-import GraphRouterOptionsBuilder from './GraphRouterOptionsBuilder.js';
-
-const { expect } = chai;
-chai.use(chaiAlmost(1e-3));
-
-const networkDidNotChange = (
-    networkAfter: Graph,
-    verticesBefore: Vertex[],
-    edgesBefore: Edge[]
-) => {
-
-    const isEdgeInArray = (edgeArray: Edge[], edge: Edge) => edgeArray.find(_edge =>
-        edge.vertex1 === _edge.vertex1
-        && edge.vertex2 === _edge.vertex2
-        && edge.level === _edge.level
-    );
-    const areEdgeArrayEquals = (edgeArray1: Edge[], edgeArray2: Edge[]) => {
-        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(networkAfter.vertices.length).equals(verticesBefore.length);
-    for (let i = 0; i < verticesBefore.length; i++) {
-        const vertex = networkAfter.vertices[i];
-        const vertexBefore = verticesBefore[i];
-        expect(vertexBefore).equals(vertex);
-    }
-
-    expect(areEdgeArrayEquals(networkAfter.edges, edgesBefore)).true;
-};
-
-const getShortestRoutesByVertex = (
-    _router: GraphRouter,
-    _start: Vertex,
-    _end: Vertex,
-    _options?: GraphRouterOptions
-) => {
-    const { graph } = _router;
-    const verticesBefore = graph.vertices.slice(0);
-    const edgesBefore = graph.edges.slice(0);
-    const output = _router.calculateShortestPathByVertex(_start, _end, _options);
-    networkDidNotChange(graph, verticesBefore, edgesBefore);
-    return output.routeVertices();
-};
-
-const getShortestRoute = (
-    _router: GraphRouter,
-    _start: Coordinates,
-    _end: Coordinates,
-    _options?: GraphRouterOptions
-) => {
-    const { graph } = _router;
-    const verticesBefore = graph.vertices.slice(0);
-    const edgesBefore = graph.edges.slice(0);
-    const output = _router.calculateShortestPath(_start, _end, _options);
-    networkDidNotChange(graph, verticesBefore, edgesBefore);
-    return output.route();
-};
-
-class GraphEdgeWithExtra extends Edge {
-    mood?: boolean;
-    stairs?: boolean;
-}
-
-const createModel = (
-    verticesLevel: [Level_t, Level_t, Level_t, Level_t] = [null, null, null, null]
-) => {
-
-    const vertices = [
-        new Vertex(new Coordinates(43.6091194, 3.884099, null, verticesLevel[0]), { name: 'p0' }),
-        new Vertex(new Coordinates(43.6093629, 3.8842777, null, verticesLevel[1]), { name: 'p1' }),
-        new Vertex(new Coordinates(43.6092785, 3.8845052, null, verticesLevel[2]), { name: 'p2' }),
-        new Vertex(new Coordinates(43.6094902, 3.8843416, null, verticesLevel[3]), { name: 'p3' })
-    ];
-
-    const edges = [
-        new GraphEdgeWithExtra(vertices[0], vertices[1], { name: 'e0' }),
-        new GraphEdgeWithExtra(vertices[2], vertices[1], { name: 'e1' }),
-        new GraphEdgeWithExtra(vertices[1], vertices[3], { name: 'e2' }),
-        new GraphEdgeWithExtra(vertices[2], vertices[3], { name: 'e3' })
-    ];
-
-    const graph = new Graph(vertices, edges);
-
-    const start = new Coordinates(43.6091367, 3.8839298);
-    const end = new Coordinates(43.6093154, 3.8846326);
-
-    return {
-        edges,
-        end,
-        vertices,
-        graph,
-        start
-    };
-};
-
-
-const getVerticesNamesOfPath = (path: Vertex[]) => path.map(vertex => vertex.properties.name);
-const getVerticesNames = (_route: GraphRoute) => _route.vertices.map(vertex => vertex.properties.name);
-
-
-describe('GraphRouter', () => {
-
-    const { graph, start, end, vertices } = createModel();
-
-    const router = new GraphRouter(graph);
-
-    it('returns shortest path - use vertices', () => {
-        const path = getShortestRoutesByVertex(router, vertices[0], vertices[2]);
-        expect(getVerticesNamesOfPath(path)).deep.equals(['p0', 'p1', 'p2']);
-    });
-
-    it('returns shortest path - use coords', () => {
-        const route = getShortestRoute(router, start, end);
-        expect(getVerticesNames(route)).deep.equals(['p0', 'p1', 'p2']);
-    });
-
-    it('returns shortest path - use vertices coords', () => {
-        const route = getShortestRoute(router, vertices[0].coords, vertices[2].coords);
-        expect(getVerticesNames(route)).deep.equals(['p0', 'p1', 'p2']);
-    });
-
-    it('use same vertex', () => {
-        let route = getShortestRoute(router, start, vertices[0].coords);
-        expect(getVerticesNames(route)).deep.equals(['p0']);
-
-        route = getShortestRoute(router, vertices[0].coords, start);
-        expect(getVerticesNames(route)).deep.equals(['p0']);
-    });
-
-    // it('errors', () => {
-
-    //     expect(() => getShortestRoute(router, new Coordinates(0, 0), end)).throw(NoRouteFoundError);
-    //     expect(() => getShortestRoute(router, start, new Coordinates(0, 0))).throw(NoRouteFoundError);
-
-    // });
-});
-
-describe('GraphRouter - with level', () => {
-
-    const {
-        graph, start, end
-    } = createModel([1, [1, 2], [1, 2], 2]);
-
-    start.level = 1;
-    end.level = 2;
-
-    it('router returns shortest path', () => {
-
-        const router = new GraphRouter(graph);
-        const route = getShortestRoute(router, start, end);
-        expect(getVerticesNames(route)).deep.equals(['p0', 'p1', 'p3']);
-
-    });
-});
-
-
-describe('GraphRouter - Route without stairs', () => {
-
-    const { graph, edges, start, end } = createModel();
-    edges[1].stairs = true;
-
-    it('no stairs found', () => {
-
-        const router = new GraphRouter(graph);
-        const route = getShortestRoute(router, start, end, GraphRouterOptionsBuilder.WITHOUT_STAIRS);
-
-        expect(route.hasRoute).is.true;
-        route.edges.forEach((edge: Edge) => expect(edge.properties.areStairs).not.true);
-    });
-});
-
-
-describe('GraphRouter - Route one way', () => {
-
-
-    it('do not use oneway segments', () => {
-
-        const { edges, graph, start, end } = createModel();
-        edges[1].properties.isOneway = true;
-
-        const router = new GraphRouter(graph);
-
-        let route = getShortestRoute(router, start, end);
-        expect(route.hasRoute).is.true;
-        expect(getVerticesNames(route)).deep.equals(['p0', 'p1', 'p3', 'p2']);
-
-        // route other way
-        route = getShortestRoute(router, end, start);
-        expect(route.hasRoute).is.true;
-        expect(getVerticesNames(route)).deep.equals(['p2', 'p1', 'p0']);
-    });
-
-
-    it('do not use oneway segments (2)', () => {
-
-        const vertices = [
-            new Vertex(new Coordinates(0, 0), { name: 'p0' }),
-            new Vertex(new Coordinates(1, 0), { name: 'p1' }),
-            new Vertex(new Coordinates(2, 0), { name: 'p2' })
-        ];
-
-        const edges = [
-            new Edge(vertices[0], vertices[1], { name: 'e0', isOneway: true }),
-            new Edge(vertices[1], vertices[2], { name: 'e1', isOneway: true })
-        ];
-
-        const network = new Graph(vertices, edges);
-
-        const start = new Coordinates(0.5, 0);
-        const end = new Coordinates(1.5, 0);
-
-        const router = new GraphRouter(network);
-
-        const route = getShortestRoute(router, start, end);
-        expect(route.hasRoute).is.true;
-        expect(route.vertices[1].properties.name).equals('p1');
-
-        // Route other way
-        expect(getShortestRoute(router, end, start).hasRoute).is.false;
-    });
-});
-
-
-describe('GraphRouter - Route with weight', () => {
-
-    const { edges, graph, start, end } = createModel();
-    edges[1].mood = true;
-
-    it('Verify weight', () => {
-
-        const router = new GraphRouter(graph);
-
-        const route = getShortestRoute(router, start, end);
-        expect(route.hasRoute).is.true;
-        expect(getVerticesNames(route)).deep.equals(['p0', 'p1', 'p2']);
-        expect(route.edges.length).equals(2);
-        expect(route.edgesWeights).deep.almost([27.62, 18.54], 1e-2);
-    });
-
-
-    it('take shortest path', () => {
-
-        const router = new GraphRouter(graph);
-        const options = new GraphRouterOptionsBuilder().build();
-        options.weightEdgeFn = (edge: GraphEdgeWithExtra) => {
-            let duration = edge.length;
-            if (edge.mood) {
-                duration *= 10;
-            }
-            return duration;
-        };
-
-        const route = getShortestRoute(router, start, end, options);
-
-        expect(route.hasRoute).is.true;
-        expect(getVerticesNames(route)).deep.equals(['p0', 'p1', 'p3', 'p2']);
-        expect(route.edgesWeights).deep.almost([30.696, 15.078, 27.005], 1e-2);
-
-    });
-});
-
-
-describe('GraphRouter - Start and End projection on the same edge', () => {
-
-    const vertices = [
-        new Vertex(new Coordinates(0, 0), { name: 'p0' }),
-        new Vertex(new Coordinates(0, 3), { name: 'p1' })
-    ];
-
-    const edges = [
-        new Edge(vertices[0], vertices[1], { name: 'e0', isOneway: true }),
-    ];
-
-    const graph = new Graph(vertices, edges);
-
-    const start = new Coordinates(0.1, 1);
-    const end = new Coordinates(0.1, 2);
-
-    it('take shortest path', () => {
-        const router = new GraphRouter(graph);
-        const route = getShortestRoute(router, start, end);
-        expect(route.hasRoute).is.true;
-        expect(route.edges.length).equals(1)
-    });
-
-    it('take shortest path oneway reverse', () => {
-        const router = new GraphRouter(graph);
-        const route = getShortestRoute(router, end, start);
-        expect(route.hasRoute).is.false;
-        expect(route.edges.length).equals(0)
-    });
-});