@wemap/routers 12.10.8 → 12.10.9

package/src/remote/wemap-multi/WemapMultiRemoteRouter.spec.ts

@@ -1,103 +0,0 @@
-import chai from 'chai';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import fetchMock from 'fetch-mock';
-
-import { Coordinates } from '@wemap/geo';
-
-import WemapMultiRemoteRouter from './WemapMultiRemoteRouter.js';
-import { verifyStepsCoherence } from '../../model/Itinerary.spec.js';
-import { type RouterRequest } from '../../model/RouterRequest.js';
-
-const { expect } = chai;
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const assetsPath = path.resolve(__dirname, '../../../assets');
-
-
-function mockFetchWithJsonAsset(assetName: string) {
-    fetchMock.restore();
-    fetchMock.mock('*', (() => {
-        const filePath = path.resolve(assetsPath, assetName);
-        const fileString = fs.readFileSync(filePath, 'utf8');
-        return JSON.parse(fileString);
-    })(),)
-}
-
-describe('WemapMultiRemoteRouter', () => {
-    
-    after(() => {
-        fetchMock.restore();
-    });
-
-
-    const endpointUrl = 'http://localhost:3001';
-
-    it('indoor to indoor', async () => {
-        mockFetchWithJsonAsset('rr-wemap-multi-remote-indoor-indoor.json');
-
-        const routerRequest: RouterRequest = {
-            origin: new Coordinates(48.8725992, 2.343431),
-            destination: new Coordinates(48.8725694, 2.3433),
-            travelMode: 'WALK'
-        } 
-        const itineraries = await WemapMultiRemoteRouter.getItineraries(endpointUrl, routerRequest);
-        itineraries.forEach(verifyStepsCoherence);
-        expect(itineraries.length).equals(1);
-        expect(itineraries[0].coords.length).equals(6);
-        expect(itineraries[0].legs).not.empty;
-    });
-
-    it('outdoor to outdoor', async () => {
-        mockFetchWithJsonAsset('rr-wemap-multi-remote-outdoor-outdoor.json');
-        const routerRequest: RouterRequest = {
-            origin: new Coordinates(48.8726513, 2.343449),
-            destination: new Coordinates(48.8726397, 2.3431657),
-            travelMode: 'WALK'
-        } 
-        const itineraries = await WemapMultiRemoteRouter.getItineraries(endpointUrl, routerRequest);
-        itineraries.forEach(verifyStepsCoherence);
-        expect(itineraries[0].coords.length).equals(4);
-    });
-
-    it('outdoor to indoor', async () => {
-        mockFetchWithJsonAsset('rr-wemap-multi-remote-outdoor-indoor.json');
-        const routerRequest: RouterRequest = {
-            origin: new Coordinates(48.8726085, 2.3434289),
-            destination: new Coordinates(48.8725694, 2.3433),
-            travelMode: 'WALK'
-        } 
-        const itineraries = await WemapMultiRemoteRouter.getItineraries(endpointUrl, routerRequest);
-
-        itineraries.forEach(verifyStepsCoherence);
-        expect(itineraries[0].coords.length).equals(6);
-    });
-
-    it('indoor to outdoor', async () => {
-        mockFetchWithJsonAsset('rr-wemap-multi-remote-indoor-outdoor.json');
-        const routerRequest: RouterRequest = {
-            origin: new Coordinates(48.8725992, 2.343431),
-            destination: new Coordinates(48.8726513, 2.343449),
-            travelMode: 'WALK'
-        } 
-        const itineraries = await WemapMultiRemoteRouter.getItineraries(endpointUrl, routerRequest);
-
-        itineraries.forEach(verifyStepsCoherence);
-        expect(itineraries[0].coords.length).equals(6);
-    });
-
-    it('indoor to outdoor to indoor', async () => {
-        mockFetchWithJsonAsset('rr-wemap-multi-remote-indoor-outdoor-indoor.json');
-        const routerRequest: RouterRequest = {
-            origin: new Coordinates(48.8725992, 2.343431),
-            destination: new Coordinates(48.8772962, 2.3584458, null, 0),
-            travelMode: 'WALK'
-        } 
-        const itineraries = await WemapMultiRemoteRouter.getItineraries(endpointUrl, routerRequest);
-
-        itineraries.forEach(verifyStepsCoherence);
-        expect(itineraries[0].coords.length).equals(77);
-    });
-
-});

package/src/remote/wemap-multi/WemapMultiRemoteRouter.ts

@@ -1,56 +0,0 @@
-import { Coordinates } from '@wemap/geo';
-
-import RemoteRouter from '../RemoteRouter.js';
-import { RouterRequest } from '../../model/RouterRequest.js';
-import Itinerary from '../../model/Itinerary.js';
-import { RemoteRoutingError } from '../../RoutingError.js';
-
-
-type WemapRouterRequest = Omit<RouterRequest, 'origin' | 'destination' | 'waypoints'> & {
-    mapId?: number,
-    origin: Coordinates | number | string
-    destination: Coordinates | number | string
-    waypoints?: (Coordinates | number | string)[]
-}
-
-/**
- * Singleton.
- */
-class WemapMultiRemoteRouter extends RemoteRouter {
-
-    get rname() { return 'wemap-multi' as const; }
-
-    async getItineraries(endpointUrl: string, routerRequest: WemapRouterRequest) {
-        const { origin, destination, waypoints } = routerRequest;
-        const payload = {
-            ...routerRequest,
-            origin: origin instanceof Coordinates ? origin.toJson() : origin,
-            destination: destination instanceof Coordinates ? destination.toJson() : destination,
-            ...(waypoints && {waypoints: waypoints.map(w => w instanceof Coordinates ? w.toJson() : w)})
-        };
-
-        const res = await (fetch(endpointUrl, {
-            method: 'POST',
-            headers: {
-                'Accept': 'application/json',
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify(payload)
-        }).catch(() => {
-            throw RemoteRoutingError.unreachableServer(this.rname, endpointUrl);
-        }));
-
-        const jsonResponse = await res.json().catch(() => {
-            throw RemoteRoutingError.responseNotParsing(this.rname, endpointUrl);
-        });
-
-        if (jsonResponse.error) {
-            throw RemoteRoutingError.notFound(this.rname, jsonResponse.error)
-        }
-
-        return (jsonResponse.itineraries || []).map(Itinerary.fromJson) as Itinerary[];
-    }
-
-}
-
-export default new WemapMultiRemoteRouter();

package/src/types.ts

@@ -1,32 +0,0 @@
-import { type CoordinatesCompressedJson } from '@wemap/geo';
-import { type EdgeProperties } from './graph/Edge.js';
-import { VertexProperties } from './graph/Vertex.js';
-
-export type GraphVertexJson = {
-    id: number,
-    coords: CoordinatesCompressedJson
-    properties?: VertexProperties
-}
-
-export type GraphEdgeJson = {
-    id: number,
-    vertex1Idx: number,
-    vertex2Idx: number,
-    properties?: EdgeProperties
-}
-
-export type GeoGraphJson = {
-    vertices: GraphVertexJson[],
-    edges: GraphEdgeJson[]
-};
-
-export type CompressedGraphVertexJson = CoordinatesCompressedJson;
-
-export type CompressedGeoGraphJson = {
-    vertices: CompressedGraphVertexJson[],
-    verticesIds: (string | number)[], 
-    edges: (
-        [number, number] |
-        [number, number, EdgeProperties]
-    )[]
-};

package/src/wemap-multi/CustomGraphMap.spec.ts

@@ -1,40 +0,0 @@
-import chai from 'chai';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-import CustomGraphMap from './CustomGraphMap.js';
-
-const { expect } = chai;
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-function getMapNameAndContents(assetName: string) {
-    const filePath = path.resolve(__dirname, '../../assets/' + assetName);
-    const osmXmlString = fs.readFileSync(filePath, 'utf8');
-    const mapName = path.parse(assetName).name;
-    return [mapName, osmXmlString];
-}
-
-describe('CustomGraphMap', () => {
-
-
-    it('fromOsmXml - biocbon-bergere-rdc-network', async () => {
-
-        const [mapName, mapContents] = getMapNameAndContents('biocbon-bergere-rdc-network.osm');
-        const customGraphMap = CustomGraphMap.fromOsmXml(mapContents, mapName)!;
-        expect(customGraphMap.entryPoints.length).equal(1);
-        expect(customGraphMap.graph.edges).is.not.empty;
-        
-    });
-
-    it('fromOsmXml - gare-de-lest-network-pp-bounds', async () => {
-
-        const [mapName, mapContents] = getMapNameAndContents('gare-de-lest-network-pp-bounds.osm');
-        const customGraphMap = CustomGraphMap.fromOsmXml(mapContents, mapName)!;
-        expect(customGraphMap.entryPoints.length).equal(4);
-        expect(customGraphMap.graph.edges).is.not.empty;
-        
-    });
-
-});

package/src/wemap-multi/CustomGraphMap.ts

@@ -1,213 +0,0 @@
-import pointInPolygon from '@turf/boolean-point-in-polygon';
-import convexHullFn from '@turf/convex';
-import { Position, MultiPolygon } from '@turf/helpers';
-
-import { Coordinates, Level } from '@wemap/geo';
-import { OsmNode, OsmParser } from '@wemap/osm';
-
-import Graph from '../graph/Graph.js';
-import GraphRouter from '../graph/GraphRouter.js';
-import { GraphRouterOptions } from '../graph/GraphRouterOptions.js';
-import Vertex from '../graph/Vertex.js';
-import OsmGraphUtils from '../wemap-osm/OsmGraphUtils.js';
-
-
-export type ParsingErrors = {
-    couldNotParseFile?: string,
-    routingIoNotFound: OsmNode[],
-    routingBoundsNotFound: boolean
-}
-
-export default class CustomGraphMap {
-
-    name: string | null;
-    graph: Graph;
-    router: GraphRouter;
-    bounds: MultiPolygon;
-    entryPoints: Vertex[];
-
-    constructor(
-        graph: Graph,
-        entryPoints: Vertex[],
-        bounds: MultiPolygon | null = null,
-        name: string | null = null) {
-
-        this.name = name;
-        this.graph = graph;
-        this.router = new GraphRouter(graph);
-
-        // Entry points
-        entryPoints.forEach(entryPoint => {
-            if (!graph.vertices.includes(entryPoint)) {
-                throw new Error(`Cannot find entry point ${entryPoint.coords.toString()} in graph "${name}"`);
-            }
-        });
-        this.entryPoints = entryPoints;
-
-        // Bounds
-        if (bounds) {
-            this.bounds = bounds;
-        } else {
-            const polygon = [graph.vertices.map(vertex => [vertex.coords.lng, vertex.coords.lat] as Position)];
-            const convexHull = convexHullFn({ type: 'polygon', coordinates: polygon });
-            if (!convexHull) {
-                throw new Error(`Cannot calculate convexHull of graph "${name}"`);
-            }
-            this.bounds = {
-                type: 'MultiPolygon',
-                coordinates: [convexHull.geometry.coordinates]
-            };
-        }
-    }
-
-    static fromOsmXml(
-        osmXmlString: string,
-        name: string | null = null,
-        callbackErrors?: (errors: ParsingErrors) => void
-    ) {
-        const errors: ParsingErrors = {
-            routingIoNotFound: [],
-            routingBoundsNotFound: false
-        };
-
-        let osmModel;
-        try {
-            osmModel = OsmParser.parseOsmXmlString(osmXmlString);
-        } catch (e) {
-            errors.couldNotParseFile = e instanceof Error ? e.message : "Unknown error";
-            callbackErrors?.(errors);
-            return;
-        }
-        let verticesMapping: [nodeId: number, vertex: Vertex][] = []
-        const graph = OsmGraphUtils.createGraphFromOsmModel(osmModel, OsmGraphUtils.DEFAULT_WAY_SELECTOR, vm => (verticesMapping = vm));
-
-        const entryPointsOsmNodes = osmModel.nodes.filter(node => node.tags['wemap:routing-io']);
-        const entryPointsToCheck = entryPointsOsmNodes.map(node => {
-            const vertex = verticesMapping.find(v => v[0] === node.id)?.[1]
-            if (!vertex) { errors.routingIoNotFound.push(node); }
-            return vertex || null;
-        });
-        const entryPoints = entryPointsToCheck.filter(it => it !== null) as Vertex[];
-        entryPoints.forEach(v => graph.exitVertices.add(v));
-
-        const bounds: MultiPolygon = {
-            type: 'MultiPolygon',
-            coordinates: []
-        };
-        osmModel.ways
-            .filter(({ tags }) => tags['wemap:routing-bounds'])
-            .forEach(way => {
-                bounds.coordinates.push([way.nodes.reduce((acc, node) => {
-                    acc.push([node.coords.lng, node.coords.lat]);
-                    return acc;
-                }, [] as Position[])
-                ]);
-            });
-        osmModel.relations
-            .filter(rel => rel.tags['wemap:routing-bounds'] && rel.isMultipolygon())
-            .forEach(rel => {
-                const polygon = rel.getGeoJsonPolygon();
-                polygon && bounds.coordinates.push(polygon.coordinates);
-            });
-
-        if (!bounds.coordinates.length) {
-            errors.routingBoundsNotFound = true;
-        }
-        callbackErrors?.(errors);
-        return new CustomGraphMap(graph, entryPoints, bounds, name);
-    }
-
-    isPointInside(coordinates: Coordinates) {
-        return pointInPolygon([coordinates.lng, coordinates.lat], this.bounds);
-    }
-
-    /**
-     * Get the list of entry points sorted by the lowest distance between:
-     * start -> entry point -> end
-     * (as the crow flies)
-     *
-     */
-    getOrderedEntryPointsSortedByDistance(start: Coordinates, end: Coordinates) {
-        const entryPointsCopy = [...this.entryPoints];
-        const levelDiffFactor = 50; // in meters
-        return entryPointsCopy.sort((ep1, ep2) => {
-
-            const distance2D = Number(ep1.coords.distanceTo(start)) + ep1.coords.distanceTo(end)
-                - (ep2.coords.distanceTo(start) + ep2.coords.distanceTo(end))
-
-            const levelDiffEp1Start = Math.abs(Level.diff(start.level, ep1.coords.level) || 0);
-            const levelDiffEp1End = Math.abs(Level.diff(end.level, ep1.coords.level) || 0);
-            const levelDiffEp2Start = Math.abs(Level.diff(start.level, ep2.coords.level) || 0);
-            const levelDiffEp2End = Math.abs(Level.diff(end.level, ep2.coords.level) || 0);
-            const levelDiff = levelDiffEp1Start + levelDiffEp1End - (levelDiffEp2Start + levelDiffEp2End);
-
-            return distance2D + levelDiff * levelDiffFactor;
-        });
-    }
-
-    /**
-     * Get the best itinerary from any entry point to an end coordinates.
-     *
-     * The algorithm works as following:
-     * 1 - Entry points are sorted using distance (as the crow flies) between start - entry point - end
-     * 2 - Try to calculate an itinerary from the first entry point to the end coordinates.
-     * 3 - If an itinerary is found, it is returned. Otherwise it tries from the next entry point.
-     *
-     * /!\ start is only used to sort the entry points (step 1).
-     *
-     */
-    getBestRouteFromEntryPointsToDestination(start: Coordinates, end: Coordinates, options: GraphRouterOptions) {
-        // TODO: use multiple-destinations algorithm
-        const sortedEntryPoints = this.getOrderedEntryPointsSortedByDistance(start, end);
-        for (const entryPoint of sortedEntryPoints) {
-            const route = this.router.calculateShortestPath(entryPoint.coords, end, options).route();
-            if (route.hasRoute) {
-                return route;
-            }
-            // no route found
-        }
-        return null;
-    }
-
-
-    /**
-     * Get the best itinerary from start coordinates to any entry point.
-     *
-     * The algorithm works as following:
-     * 1 - Entry points are sorted using distance (as the crow flies) between start - entry point - end
-     * 2 - Try to calculate an itinerary from the start coordinates to the first entry point.
-     * 3 - If an itinerary is found, it is returned. Otherwise it tries to the next entry point.
-     *
-     * /!\ end is only used to sort the entry points (step 1).
-     *
-     */
-    getBestRouteFromOriginToEntryPoints(start: Coordinates, end: Coordinates, options: GraphRouterOptions) {
-        // TODO: use multiple-destinations algorithm
-        const sortedEntryPoints = this.getOrderedEntryPointsSortedByDistance(start, end);
-        for (const entryPoint of sortedEntryPoints) {
-            const route = this.router.calculateShortestPath(start, entryPoint.coords, options).route();
-            if (route.hasRoute) {
-                return route;
-            }
-            // no route found
-        }
-        return null;
-    }
-
-    getRouteInsideMap(start: Coordinates, end: Coordinates, options: GraphRouterOptions) {
-        // Call the Wemap router to get the shortest path
-        const route = this.router.calculateShortestPath(start, end, options).route();
-        return route.hasRoute ? route : null;
-    }
-
-    getTripInsideMap(waypoints: Coordinates[], options: GraphRouterOptions) {
-        // Call the Wemap router to get the shortest trip itinerary
-        return this.router.getShortestTrip(waypoints, options);
-    }
-
-    getRoutesMultipleDestinationsInsideMap(start: Coordinates, ends: Coordinates[], options: GraphRouterOptions) {
-        // Call the Wemap router to get the shortest path for all the input destinations
-        return this.router.calculateShortestPathToMultipleDestinations(start, ends, options);
-    }
-
-}

package/src/wemap-multi/CustomGraphMapTester.spec.ts

@@ -1,48 +0,0 @@
-import chai from 'chai';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-import CustomGraphMapTester from './CustomGraphMapTester.js';
-
-const { expect } = chai;
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-function createReport(fileName: string) {
-    const filePath = path.resolve(__dirname, '../../assets/' + fileName);
-    const osmXmlString = fs.readFileSync(filePath, 'utf8');
-    return CustomGraphMapTester.createReport(osmXmlString);
-}
-
-describe('CustomGraphMapTester', () => {
-
-
-    it('multiple-graph-components', async () => {
-
-        const report = createReport('report-map-1.osm');
-        expect(report.errors.length).equal(1);
-        expect(report.errors[0].type).equal('multiple-graph-components');
-        expect(report.errors[0].data.length).equal(2);
-        
-    });
-
-    it('routing-io-not-on-graph', async () => {
-
-        const report = createReport('report-map-2.osm');
-        expect(report.errors.length).equal(1);
-        expect(report.errors[0].type).equal('routing-io-not-on-graph');
-        expect(report.errors[0].data.length).equal(1);
-        
-    });
-
-    it('routing-bounds-not-found', async () => {
-
-        const report = createReport('report-map-3.osm');
-        expect(report.errors.length).equal(1);
-        expect(report.errors[0].type).equal('routing-bounds-not-found');
-        
-    });
-
-
-});

package/src/wemap-multi/CustomGraphMapTester.ts

@@ -1,90 +0,0 @@
-
-import { OsmNode } from '@wemap/osm';
-
-import CustomGraphMap, { type ParsingErrors } from './CustomGraphMap.js';
-import Vertex from '../graph/Vertex.js';
-
-export type Report = {
-    customGraphMap?: CustomGraphMap,
-    errors: Error[],
-}
-
-export type Error = CouldNotParseFileError
-    | MultipleGraphComponentsError
-    | RoutingBoundsNotFoundError
-    | RoutingIoNotOnGraphError;
-
-export type CouldNotParseFileError = {
-    type: 'could-not-parse-file',
-    details: string | undefined
-}
-
-export type MultipleGraphComponentsError = {
-    type: 'multiple-graph-components',
-    data: Vertex[][]
-}
-
-export type RoutingBoundsNotFoundError = {
-    type: 'routing-bounds-not-found'
-}
-
-export type RoutingIoNotOnGraphError = {
-    type: 'routing-io-not-on-graph',
-    data: OsmNode[]
-}
-
-export default class CustomGraphMapTester {
-
-    static createReport(osmXmlString: string): Report {
-
-        let customGraphMapErrors: ParsingErrors | undefined;
-        const customGraphMap = CustomGraphMap.fromOsmXml(osmXmlString, null, e => (customGraphMapErrors = e));
-        const errors: Error[] = [];
-
-        if (customGraphMapErrors?.couldNotParseFile || !customGraphMap) {
-            errors.push({
-                type: 'could-not-parse-file',
-                details: customGraphMapErrors?.couldNotParseFile
-            });
-            return { errors };
-        }
-
-        const components = customGraphMap.router.calculateComponents();
-        if (components.length > 1) {
-            errors.push({
-                type: 'multiple-graph-components',
-                data: components
-            });
-        }
-        if (customGraphMapErrors?.routingBoundsNotFound) {
-            errors.push({
-                type: 'routing-bounds-not-found'
-            });
-        }
-        if (customGraphMapErrors?.routingIoNotFound?.length) {
-            errors.push({
-                type: 'routing-io-not-on-graph',
-                data: customGraphMapErrors.routingIoNotFound
-            });
-        }
-
-        return { customGraphMap, errors };
-    }
-
-    static reportToJson(report: Report) {
-        return {
-            graph: report.customGraphMap?.graph?.toCompressedJson(),
-            errors: report.errors.map(error => {
-                if (error.type === 'multiple-graph-components') {
-                    return { type: error.type, data: error.data.map(c => c.map(v => v.id)) };
-                }
-                if (error.type === 'routing-io-not-on-graph') {
-                    return { type: error.type, data: error.data.map(v => v.id) };
-                }
-                return { type: error.type };
-            })
-        }
-    }
-
-}
-