@wemap/osm 5.8.0 → 6.2.2

package/src/routers/custom/OsmRouterOptions.js

@@ -1,33 +0,0 @@
-import { GraphRouterOptions } from '@wemap/geo';
-
-import OsmElement from '../../model/OsmElement.js';
-
-class OsmRouterOptions extends GraphRouterOptions {
-
-    /** @type {OsmRouterOptions} */
-    static DEFAULT = new OsmRouterOptions();
-
-    /**
-     * @returns {OsmRouterOptions}
-     */
-    static get WITHOUT_STAIRS() {
-        const options = new OsmRouterOptions();
-        options.acceptEdgeFn = edge => edge.builtFrom.tags.highway !== 'steps';
-        return options;
-    }
-
-    /**
-     * Get route duration
-     * @param {Number} speed in km/h
-     */
-    static getDurationFromLength(length, speed = 5) {
-        return length / (speed * 1000 / 3600);
-    }
-
-    /** @type {function(GraphEdge<OsmElement>):boolean} */
-    weightEdgeFn = edge => edge.builtFrom.isElevator ? 30 : OsmRouterOptions.getDurationFromLength(edge.length);
-
-
-}
-
-export default OsmRouterOptions;

package/src/routers/custom/OsmRouterUtils.js

@@ -1,46 +0,0 @@
-import { GraphItinerary } from '@wemap/geo';
-
-import OsmElement from '../../model/OsmElement.js';
-import Itinerary from '../Itinerary.js';
-import Leg from '../Leg.js';
-import StepsGeneration from './StepsGeneration.js';
-
-/**
- * @param {GraphItinerary<OsmElement>} graphItinerary
- * @param {string} mode
- * @returns {Leg}
- */
-export function createLegFromGraphItinerary(graphItinerary, mode = 'WALK') {
-
-    const leg = new Leg();
-
-    leg.from = { coords: graphItinerary.start };
-    leg.to = { coords: graphItinerary.end };
-    leg.coords = graphItinerary.nodes.map(node => node.coords);
-    leg.distance = graphItinerary.edges.reduce((acc, edge) => acc + edge.length, 0);
-    leg.duration = graphItinerary.edgesWeights.reduce((acc, weight) => acc + weight, 0);
-    leg.mode = mode;
-    leg.steps = StepsGeneration.fromGraphItinerary(graphItinerary);
-
-    return leg;
-}
-
-/**
- * @param {GraphItinerary<OsmElement>} graphItinerary
- * @param {string} mode
- * @returns {Itinerary}
- */
-export function createItineraryFromGraphItinerary(graphItinerary, mode = 'WALK') {
-
-    const leg = createLegFromGraphItinerary(graphItinerary, mode);
-
-    const itinerary = new Itinerary();
-
-    itinerary.from = graphItinerary.start;
-    itinerary.to = graphItinerary.end;
-    itinerary.distance = leg.distance;
-    itinerary.duration = leg.duration;
-    itinerary.legs.push(leg);
-
-    return itinerary;
-}

package/src/routers/custom/StepsGeneration.js

@@ -1,104 +0,0 @@
-/* eslint-disable complexity */
-/* eslint-disable max-statements */
-import { Coordinates, GraphItinerary } from '@wemap/geo';
-import { diffAngle, deg2rad } from '@wemap/maths';
-
-import OsmElement from '../../model/OsmElement.js';
-import Step from '../Step.js';
-import LevelChange from '../LevelChange.js';
-
-const SKIP_STEP_ANGLE_MAX = deg2rad(20);
-
-class StepsGeneration {
-
-    /**
-     * @param {GraphItinerary<OsmElement>} itinerary
-     * @returns {Step[]}
-     */
-    static fromGraphItinerary(itinerary) {
-
-        const steps = [];
-
-        const { start, end, nodes, edges } = itinerary;
-
-        let currentStep, previousStep;
-        let previousBearing = start.bearingTo(nodes[0].coords);
-
-        for (let i = 0; i < nodes.length - 1; i++) {
-
-            const isFirstStep = !currentStep;
-
-            const node = nodes[i];
-            const nextNode = nodes[i + 1];
-            const edge = edges[i];
-
-            const bearing = edge.bearing;
-            const angle = diffAngle(previousBearing, bearing + Math.PI);
-
-            let splitByAngle = Math.abs(diffAngle(Math.PI, angle)) >= SKIP_STEP_ANGLE_MAX;
-
-            const splitByLevel = edge.level && edge.level.isRange
-                && node.coords.level && !node.coords.level.isRange;
-            splitByAngle = splitByAngle && !(node.coords.level && node.coords.level.isRange);
-
-            const splitStepCondition = splitByAngle || splitByLevel;
-
-            const isSubwayEntrance = node ? node.builtFrom.tags.railway === 'subway_entrance' : false;
-
-            // New step creation
-            if (isFirstStep || splitStepCondition || isSubwayEntrance) {
-
-                previousStep = currentStep;
-
-                currentStep = new Step();
-                currentStep.coords = node.coords;
-                currentStep.number = steps.length + 1;
-                currentStep.angle = angle;
-                currentStep.previousBearing = previousBearing;
-                currentStep.nextBearing = bearing;
-                currentStep.name = edge.builtFrom.tags.name || null;
-                currentStep.distance = 0;
-                currentStep.duration = 0;
-
-                if (isSubwayEntrance) {
-                    currentStep.extras.subwayEntrance = true;
-                    currentStep.name = node.builtFrom.tags.name;
-                    if (node.builtFrom.tags.ref) {
-                        currentStep.extras.subwayEntranceRef = node.builtFrom.tags.ref;
-                    }
-                }
-
-                if (splitByLevel) {
-                    currentStep.levelChange = LevelChange.fromTwoNodes(node, nextNode);
-                }
-
-                steps.push(currentStep);
-
-                if (!previousStep) {
-                    currentStep.firstStep = true;
-                }
-            }
-
-            currentStep.distance += edge.length;
-            currentStep.duration += itinerary.edgesWeights[i];
-            previousBearing = bearing;
-        }
-
-        const lastNode = nodes[nodes.length - 1];
-        const lastStep = new Step();
-        lastStep.coords = lastNode.coords;
-        lastStep.number = steps.length + 1;
-        lastStep.previousBearing = previousBearing;
-        lastStep.distance = lastNode.coords.distanceTo(end);
-        if (!Coordinates.equalsTo(lastNode.coords, end)) {
-            lastStep.nextBearing = lastNode.coords.bearingTo(end);
-            lastStep.angle = diffAngle(lastStep.previousBearing, lastStep.nextBearing + Math.PI);
-        }
-        lastStep.lastStep = true;
-        steps.push(lastStep);
-
-        return steps;
-    }
-
-}
-export default StepsGeneration;

package/src/routers/deutsche-bahn/DeutscheBahnRouterUtils.js

@@ -1,93 +0,0 @@
-/* eslint-disable max-statements */
-
-import { Coordinates, GraphEdge, GraphItinerary, GraphNode, Level } from '@wemap/geo';
-
-import OsmNode from '../../model/OsmNode.js';
-import OsmWay from '../../model/OsmWay.js';
-import Itinerary from '../Itinerary.js';
-import RouterResponse from '../RouterResponse.js';
-import { generateStepsMetadata } from '../Utils.js';
-import OsmElement from '../../model/OsmElement.js';
-import StepsGeneration from '../custom/StepsGeneration.js';
-
-/**
- * Generate multi itineraries from the DB JSON
- * @param {object} json JSON file provided by the DB.
- * @param {Coordinates} from itinerary start
- * @param {Coordinates} to itinerary end
- * @returns {?RouterResponse}
- */
-export function createRouterResponseFromJson(json, from, to) {
-
-    const { segments: jsonSegments } = json;
-
-    if (!jsonSegments) {
-        return null;
-    }
-
-    const routerResponse = new RouterResponse();
-    routerResponse.routerName = 'deutsche-bahn';
-
-    routerResponse.from = from;
-    routerResponse.to = to;
-
-    /** @type {GraphEdge<OsmElement>[]} */
-    const edges = [];
-
-    /** @type {GraphNode<OsmElement>[]} */
-    const nodes = [];
-
-    /** @type {number[]} */
-    const edgesWeights = [];
-
-    let id = 1;
-    for (const jsonSegment of jsonSegments) {
-
-        const level = new Level(jsonSegment.fromLevel, jsonSegment.toLevel);
-        const osmWay = new OsmWay(id++, null, level);
-
-        for (const jsonPoint of jsonSegment.polyline) {
-            const coord = new Coordinates(jsonPoint.lat, jsonPoint.lon, null, level);
-
-            if (nodes.length !== 0
-                && nodes[nodes.length - 1].coords.equalsTo(coord)) {
-                continue;
-            }
-
-            const osmNode = new OsmNode(id++, coord);
-            const node = new GraphNode(osmNode.coords, osmNode);
-
-            if (nodes.length !== 0) {
-                const prevNode = nodes[nodes.length - 1];
-                const edge = new GraphEdge(prevNode, node, level, osmWay);
-                edges.push(edge);
-                edgesWeights.push(prevNode.coords.distanceTo(osmNode));
-            }
-
-            nodes.push(node);
-
-        }
-    }
-
-    /** @type {GraphItinerary<OsmElement>} */
-    const graphItinerary = new GraphItinerary();
-    graphItinerary.nodes = nodes;
-    graphItinerary.edges = edges;
-    graphItinerary.edgesWeights = edgesWeights;
-    graphItinerary.start = nodes[0].coords;
-    graphItinerary.end = nodes[nodes.length - 1].coords;
-
-    const points = nodes.map(node => node.coords);
-    const itinerary = Itinerary.fromOrderedCoordinates(points, from, to);
-    itinerary.legs[0].steps = StepsGeneration.fromGraphItinerary(graphItinerary);
-    itinerary.legs[0].steps.map((step, idx) => (step._idCoordsInLeg = idx));
-
-    // All legs have to be parsed before computing steps metadata
-    generateStepsMetadata(itinerary);
-
-    routerResponse.itineraries.push(itinerary);
-
-    return routerResponse;
-}
-
-

package/src/routers/deutsche-bahn/DeutscheBahnRouterUtils.spec.js

@@ -1,54 +0,0 @@
-/* eslint-disable max-statements */
-import chai from 'chai';
-import chaiAlmost from 'chai-almost';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-import { Coordinates, Level } from '@wemap/geo';
-
-import { createRouterResponseFromJson } from './DeutscheBahnRouterUtils.js';
-
-import { verifyRouterResponseData } from '../RouterResponse.type.spec.js';
-
-
-const { expect } = chai;
-chai.use(chaiAlmost(0.1));
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-describe('OtpUtils - createRouterResponseFromJson', () => {
-
-    it('RouterResponse - 1', () => {
-
-        const filePath = path.resolve(__dirname, '../../../assets/itinerary-deutsche-bahn-1.json');
-        const fileString = fs.readFileSync(filePath, 'utf8');
-        const json = JSON.parse(fileString);
-
-        const from = new Coordinates(52.5258473, 13.3683657, null, new Level(-10));
-        const to = new Coordinates(52.52499085853664, 13.369467296949914, null, new Level(0));
-
-        const routerResponse = createRouterResponseFromJson(json, from, to);
-        verifyRouterResponseData(routerResponse);
-
-        expect(routerResponse.routerName).equal('deutsche-bahn');
-        expect(routerResponse.itineraries.length).equal(1);
-        expect(routerResponse.from.equalsTo(from)).true;
-        expect(routerResponse.to.equalsTo(to)).true;
-
-        const itinerary1 = routerResponse.itineraries[0];
-        expect(itinerary1.coords.length).equal(77);
-        expect(itinerary1.distance).almost.equal(129.673);
-        expect(itinerary1.duration).almost.equal(93.365);
-
-        const itinerary1leg1 = itinerary1.legs[0];
-        expect(itinerary1leg1.distance).almost.equal(129.673);
-        expect(itinerary1leg1.mode).equal('WALK');
-        expect(itinerary1leg1.from.name).is.null;
-        expect(itinerary1leg1.from.coords.equalsTo(from)).true;
-        expect(itinerary1leg1.to.name).is.null;
-        expect(itinerary1leg1.to.coords.equalsTo(to)).true;
-    });
-
-});
-

package/src/routers/info/ItineraryInfo.js

@@ -1,34 +0,0 @@
-import { GraphProjection } from '@wemap/geo';
-
-import Leg from '../Leg.js';
-import Step from '../Step.js';
-
-class ItineraryInfo {
-
-    /** @type {Step} */
-    nextStep;
-
-    /** @type {Step} */
-    previousStep;
-
-    /** @type {GraphProjection} */
-    projection;
-
-    /** @type {Leg} */
-    leg;
-
-    /** @type {number} */
-    traveledDistance;
-
-    /** @type {number} */
-    traveledPercentage;
-
-    /** @type {number} */
-    remainingDistance;
-
-    /** @type {number} */
-    remainingPercentage;
-
-}
-
-export default ItineraryInfo;

package/src/routers/info/ItineraryInfoManager.js

@@ -1,148 +0,0 @@
-/* eslint-disable max-statements */
-import { Coordinates, GraphEdge, GraphNode, MapMatching, Network } from '@wemap/geo';
-
-import Itinerary from '../Itinerary.js';
-import Leg from '../Leg.js';
-import Step from '../Step.js';
-import ItineraryInfo from './ItineraryInfo.js';
-
-class ItineraryInfoManager {
-
-    /** @type {Itinerary} */
-    _itinerary;
-
-    /** @type {Network} */
-    _network;
-
-    /** @type {Network} */
-    _mapMatching;
-
-    /** @type {Step[]} */
-    _steps;
-
-    /** @type {Step[]} */
-    _coordsNextStep;
-
-    /** @type {Step[]} */
-    _coordsPreviousStep;
-
-    /** @type {number[]} */
-    _coordsDistanceTraveled;
-
-    /** @type {Leg[]} */
-    _coordsLeg;
-
-    /** @type {Itinerary} */
-    set itinerary(itinerary) {
-
-        if (itinerary === null) {
-            this._itinerary = null;
-            return;
-        }
-
-        this._itinerary = itinerary;
-        this._steps = itinerary.steps;
-        this._network = itinerary.toNetwork();
-        this._mapMatching = new MapMatching(this._network);
-
-        this._coordsNextStep = new Array(itinerary.coords.length);
-        this._coordsPreviousStep = new Array(itinerary.coords.length);
-        this._coordsDistanceTraveled = new Array(itinerary.coords.length);
-        this._coordsLeg = new Array(itinerary.coords.length);
-
-        let stepId = 0;
-        let previousStep = null;
-        let nextStep = this._steps[0];
-        let distanceTraveled = 0;
-
-        itinerary.coords.forEach((coords, idx, arr) => {
-            if (stepId < this._steps.length && this._steps[stepId].coords.equalsTo(coords)) {
-                previousStep = this._steps[stepId];
-                nextStep = stepId === this._steps.length - 1 ? null : this._steps[stepId + 1];
-                stepId++;
-            }
-            if (idx !== 0) {
-                distanceTraveled += arr[idx - 1].distanceTo(coords);
-            }
-
-            this._coordsNextStep[idx] = nextStep;
-            this._coordsPreviousStep[idx] = previousStep;
-            this._coordsDistanceTraveled[idx] = distanceTraveled;
-            this._coordsLeg[idx] = itinerary.legs.find(leg => leg.coords.includes(coords));
-        });
-    }
-
-    /**
-     * @param {Coordinates} position
-     * @returns {ItineraryInfo}
-     */
-    getInfo(position) {
-
-        if (!this._itinerary) {
-            return null;
-        }
-
-        if (!(position instanceof Coordinates)) {
-            return null;
-        }
-
-        const projection = this._mapMatching.getProjection(position);
-        if (!projection) {
-            return null;
-        }
-
-        let itineraryInfo = null;
-
-        if (projection.nearestElement instanceof GraphNode) {
-            const idx = this._itinerary.coords.findIndex(
-                coords => projection.nearestElement.coords === coords
-            );
-            if (idx === -1) {
-                throw new Error('ItineraryInfoManager: could not find projection in itinerary (Node)');
-            }
-
-            itineraryInfo = new ItineraryInfo();
-            itineraryInfo.nextStep = this._coordsNextStep[idx];
-            itineraryInfo.previousStep = this._coordsPreviousStep[idx];
-            itineraryInfo.projection = projection;
-            itineraryInfo.leg = this._coordsLeg[idx];
-            itineraryInfo.traveledDistance = this._coordsDistanceTraveled[idx];
-            itineraryInfo.remainingDistance = this._itinerary.distance - itineraryInfo.traveledDistance;
-            itineraryInfo.traveledPercentage = itineraryInfo.traveledDistance / this._itinerary.distance;
-            itineraryInfo.remainingPercentage = itineraryInfo.remainingDistance / this._itinerary.distance;
-
-        } else if (projection.nearestElement instanceof GraphEdge) {
-
-            let firstNode = projection.nearestElement.node1.coords;
-            let idx = this._itinerary.coords.findIndex(coords => firstNode === coords);
-            if (idx === -1) {
-                throw new Error('ItineraryInfoManager: could not find projection in itinerary (Edge)');
-            }
-
-            // graphEdge is not necessarly ordered. We have to look for the first point
-            if (idx === this._itinerary.coords.length - 1
-                || this._itinerary.coords[idx + 1] !== projection.nearestElement.node2.coords
-            ) {
-                firstNode = projection.nearestElement.node2.coords;
-                idx--;
-            }
-
-            itineraryInfo = new ItineraryInfo();
-            itineraryInfo.nextStep = this._coordsNextStep[idx];
-            itineraryInfo.previousStep = this._coordsPreviousStep[idx];
-            itineraryInfo.projection = projection;
-            itineraryInfo.leg = this._coordsLeg[idx];
-            itineraryInfo.traveledDistance = this._coordsDistanceTraveled[idx]
-                + projection.projection.distanceTo(firstNode);
-            itineraryInfo.remainingDistance = this._itinerary.distance - itineraryInfo.traveledDistance;
-            itineraryInfo.traveledPercentage = itineraryInfo.traveledDistance / this._itinerary.distance;
-            itineraryInfo.remainingPercentage = itineraryInfo.remainingDistance / this._itinerary.distance;
-
-        }
-
-        return itineraryInfo;
-    }
-
-}
-
-export default ItineraryInfoManager;

package/src/routers/info/ItineraryInfoManager.spec.js

@@ -1,54 +0,0 @@
-import chai from 'chai';
-import chaiAlmost from 'chai-almost';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-import { Coordinates, GraphEdge, GraphNode } from '@wemap/geo';
-
-import { createRouterResponseFromJson } from '../otp/OtpUtils.js';
-import ItineraryInfoManager from './ItineraryInfoManager.js';
-
-
-const { expect } = chai;
-chai.use(chaiAlmost(0.1));
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-
-const filePath = path.resolve(__dirname, '../../../assets/itinerary-grenoble-otp-1.json');
-const fileString = fs.readFileSync(filePath, 'utf8');
-const json = JSON.parse(fileString);
-const routerResponse = createRouterResponseFromJson(json);
-
-let position, itineraryInfo;
-
-describe('ItineraryInfoManager', () => {
-
-    it('verify integrity', () => {
-
-        const itinerary = routerResponse.itineraries[0];
-        const iim = new ItineraryInfoManager();
-        iim.itinerary = itinerary;
-
-        position = new Coordinates(45.1641153, 5.741293);
-        itineraryInfo = iim.getInfo(position);
-        expect(itineraryInfo.projection.nearestElement).instanceOf(GraphNode);
-        expect(itineraryInfo.nextStep).is.null;
-        expect(itineraryInfo.previousStep).equals(itinerary.legs[2].steps[3]);
-        expect(itineraryInfo.remainingDistance).almost.equals(56.095);
-        expect(itineraryInfo.remainingPercentage).almost.equals(0.0155);
-        expect(itineraryInfo.leg).almost.equals(itinerary.legs[2]);
-
-        position = new Coordinates(45.1641691, 5.7413891);
-        itineraryInfo = iim.getInfo(position);
-        expect(itineraryInfo.projection.nearestElement).instanceOf(GraphEdge);
-        expect(itineraryInfo.nextStep).equals(itinerary.legs[2].steps[3]);
-        expect(itineraryInfo.previousStep).equals(itinerary.legs[2].steps[2]);
-        expect(itineraryInfo.remainingDistance).almost.equals(65.671);
-        expect(itineraryInfo.remainingPercentage).almost.equals(0.018);
-        expect(itineraryInfo.leg).almost.equals(itinerary.legs[2]);
-    });
-
-});
-