@wemap/routers 12.10.8 → 12.10.9

package/helpers/InstructionManagerV1.ts

@@ -1,95 +0,0 @@
-import { Coordinates } from '@wemap/geo';
-import ItineraryInfoManager from '../src/ItineraryInfoManager.js';
-import { Step } from '../src/model/Step.js';
-import OsrmRemoteRouter from '../src/remote/osrm/OsrmRemoteRouter.js';
-
-export default class InstructionManagerV1 {
-
-    // eslint-disable-next-line max-statements, complexity
-    static getInstructionFromStep(step: Step) {
-
-        const modifier = OsrmRemoteRouter.getModifierFromAngle(step.angle);
-        let direction, directionExtra;
-        if (modifier.includes('left')) {
-            direction = 'left';
-        } else if (modifier.includes('right')) {
-            direction = 'right';
-        }
-        if (modifier.includes('slight')) {
-            directionExtra = 'slight';
-        }
-        const isTurn = modifier !== 'straight';
-
-        if (step.lastStep) {
-            if (isTurn && direction === 'left') {
-                return 'Your destination is on your left';
-            } else if (isTurn && direction === 'right') {
-                return 'Your destination is on your right';
-            }
-        }
-
-        const suffix = step.name ? ` on ${step.name}` : '';
-
-        if (step.levelChange) {
-            if (step.levelChange.direction === 'up') {
-                if (step.levelChange.type === 'escalator') {
-                    return 'Go up the escalator';
-                }
-                if (step.levelChange.type === 'stairs') {
-                    return 'Go up the stairs';
-                }
-                return 'Go up' + suffix;
-            }
-            if (step.levelChange.direction === 'down') {
-                if (step.levelChange.type === 'escalator') {
-                    return 'Go down the escalator';
-                }
-                if (step.levelChange.type === 'stairs') {
-                    return 'Go down the stairs';
-                }
-                return 'Go down' + suffix;
-            }
-            if (step.extras?.subwayEntrance) {
-                return `Take exit ${step.extras.subwayEntranceRef}`;
-            }
-        }
-
-        if (isTurn) {
-            if (direction === 'left') {
-                if (directionExtra === 'slight') {
-                    return 'Turn slightly left' + suffix;
-                }
-                return 'Turn left' + suffix;
-            }
-            if (direction === 'right') {
-                if (directionExtra === 'slight') {
-                    return 'Turn slightly right' + suffix;
-                }
-                return 'Turn right' + suffix;
-            }
-        }
-
-
-        return '';
-    }
-
-    static getInstructionFromPosition(itineraryInfoManager: ItineraryInfoManager, position: Coordinates) {
-        const itineraryInfo = itineraryInfoManager.getInfo(position);
-        if (!itineraryInfo) {
-            return null;
-        }
-
-        const { nextStep } = itineraryInfo;
-        if (!nextStep) {
-            return null;
-        }
-
-        const distNextStep = position.distanceTo(nextStep.coords);
-        const nextStep2 = itineraryInfoManager._steps.find(step => step.number > nextStep.number);
-        if (distNextStep < 3 && nextStep2) {
-            return InstructionManagerV1.getInstructionFromStep(nextStep2);
-        }
-
-        return InstructionManagerV1.getInstructionFromStep(nextStep);
-    }
-}

package/src/ItineraryInfoManager.spec.ts

@@ -1,183 +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, Utils as GeoUtils } from '@wemap/geo';
-import { OsmParser } from '@wemap/osm';
-
-import ItineraryInfoManager, { ItineraryInfo } from './ItineraryInfoManager.js';
-import OtpRemoteRouter from './remote/otp/OtpRemoteRouter.js';
-import OsmGraphUtils from './wemap-osm/OsmGraphUtils.js';
-import GraphRouter from './graph/GraphRouter.js';
-import Itinerary from './model/Itinerary.js';
-import Vertex from './graph/Vertex.js';
-import Edge from './graph/Edge.js';
-
-
-const { expect } = chai;
-chai.use(chaiAlmost(0.1));
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-const load = (fileName: string) => {
-    const filePath = path.resolve(__dirname, '../assets/' + fileName);
-    const osmXmlString = fs.readFileSync(filePath, 'utf8');
-    const model = OsmParser.parseOsmXmlString(osmXmlString);
-    const graph = OsmGraphUtils.createGraphFromOsmModel(model);
-    const osmRouter = new GraphRouter(graph);
-
-    const from = model.getNodeByName('origin')?.coords as Coordinates;
-    const to = model.getNodeByName('destination')?.coords as Coordinates;
-
-    const itinerary = Itinerary.fromGraphRoute(osmRouter.calculateShortestPath(from, to).route());
-    const iim = new ItineraryInfoManager();
-    iim.itinerary = itinerary;
-
-    return { model, graph, iim, from, to, itinerary };
-};
-
-let resItineraryInfo: ItineraryInfo | null;
-let itineraryInfo: ItineraryInfo;
-
-describe('ItineraryInfoManager', () => {
-
-    it('Itinerary 2 points', () => {
-
-        const { from, to, iim, model, itinerary } = load('itinerary-info-two-points.osm');
-
-        // Projection on origin
-        const position1 = model.getNodeByName('position 1')?.coords as Coordinates;
-        resItineraryInfo = iim.getInfo(position1);
-        expect(resItineraryInfo).is.not.null;
-        itineraryInfo = resItineraryInfo as ItineraryInfo;
-        expect(itineraryInfo.projection.nearestElement).instanceOf(Vertex);
-        expect(itineraryInfo.projection.coords.equals(from)).is.true;
-        expect(itineraryInfo.previousStep).is.null;
-        expect(itineraryInfo.nextStep?.number).equals(1);
-        expect(itineraryInfo.remainingDistance).closeTo(8.29, 0.1);
-        expect(itineraryInfo.remainingPercentage).almost.equals(1);
-        expect(itineraryInfo.traveledDistance).almost.equals(0);
-        expect(itineraryInfo.traveledPercentage).almost.equals(0);
-        expect(itineraryInfo.leg).almost.equals(itinerary.legs[0]);
-
-        // Projection on middle
-        const position2 = model.getNodeByName('position 2')?.coords as Coordinates;
-        resItineraryInfo = iim.getInfo(position2);
-        expect(resItineraryInfo).is.not.null;
-        itineraryInfo = resItineraryInfo as ItineraryInfo;
-        expect(itineraryInfo.projection.nearestElement).instanceOf(Edge);
-        expect(itineraryInfo.previousStep?.number).equals(1);
-        expect(itineraryInfo.nextStep).is.null;
-        expect(itineraryInfo.remainingDistance).closeTo(4.3, 0.1);
-        expect(itineraryInfo.remainingPercentage).closeTo(0.59, 0.01);
-        expect(itineraryInfo.traveledDistance).closeTo(3, 0.1);
-        expect(itineraryInfo.traveledPercentage).closeTo(0.41, 0.01);
-        expect(itineraryInfo.leg).almost.equals(itinerary.legs[0]);
-
-        // Projection on destination
-        const position3 = model.getNodeByName('position 3')?.coords as Coordinates;
-        resItineraryInfo = iim.getInfo(position3);
-        expect(resItineraryInfo).is.not.null;
-        itineraryInfo = resItineraryInfo as ItineraryInfo;
-        expect(itineraryInfo.projection.nearestElement).instanceOf(Vertex);
-        expect(itineraryInfo.projection.coords.equals(to)).is.true;
-        expect(itineraryInfo.previousStep?.number).equals(1);
-        expect(itineraryInfo.nextStep).is.null;
-        expect(itineraryInfo.remainingDistance).closeTo(1.65, 0.1);
-        expect(itineraryInfo.remainingPercentage).closeTo(0.21, 0.01);
-        expect(itineraryInfo.traveledDistance).closeTo(itinerary.distance, 0.1);
-        expect(itineraryInfo.traveledPercentage).closeTo(0.78, 0.01);
-        expect(itineraryInfo.leg).almost.equals(itinerary.legs[0]);
-
-    });
-
-    it('Itinerary 2 points - from & to projection', () => {
-
-        const { iim, model, itinerary, to } = load('itinerary-info-two-points-proj.osm');
-        const porigin = model.getNodeByName('porigin')?.coords as Coordinates;
-        const pdest = model.getNodeByName('pdest')?.coords as Coordinates;
-
-        // Projection on origin
-        const position1 = model.getNodeByName('position 1')?.coords as Coordinates;
-        resItineraryInfo = iim.getInfo(position1);
-        expect(resItineraryInfo).is.not.null;
-        itineraryInfo = resItineraryInfo as ItineraryInfo;
-        expect(itineraryInfo.projection.nearestElement).instanceOf(Vertex);
-        expect(itineraryInfo.previousStep).is.null;
-        expect(itineraryInfo.nextStep?.number).equals(1);
-        expect(itineraryInfo.remainingDistance).almost.equals(GeoUtils.calcDistance([position1, porigin, pdest]));
-        expect(itineraryInfo.remainingPercentage).almost.equals(1);
-        expect(itineraryInfo.traveledDistance).almost.equals(0);
-        expect(itineraryInfo.traveledPercentage).almost.equals(0);
-        expect(itineraryInfo.leg).almost.equals(itinerary.legs[0]);
-
-        // Projection on middle
-        const position2 = model.getNodeByName('position 2')?.coords as Coordinates;
-        const p2 = model.getNodeByName('p2')?.coords as Coordinates;
-        resItineraryInfo = iim.getInfo(position2);
-        expect(resItineraryInfo).is.not.null;
-        itineraryInfo = resItineraryInfo as ItineraryInfo;
-        expect(itineraryInfo.projection.nearestElement).instanceOf(Edge);
-        expect(itineraryInfo.previousStep?.number).equals(1);
-        expect(itineraryInfo.nextStep?.number).equals(2);
-        expect(itineraryInfo.remainingDistance).closeTo(GeoUtils.calcDistance([position2, p2, pdest]), 0.1);
-        expect(itineraryInfo.remainingPercentage).closeTo(3.4 / 4.78, 0.1);
-        expect(itineraryInfo.traveledDistance).closeTo(GeoUtils.calcDistance([porigin, p2]), 0.1);
-        expect(itineraryInfo.traveledPercentage).closeTo(1.38 / 4.78, 0.1);
-        expect(itineraryInfo.leg).almost.equals(itinerary.legs[0]);
-
-        // Projection on end
-        const position3 = model.getNodeByName('position 3')?.coords as Coordinates;
-        resItineraryInfo = iim.getInfo(position3);
-        expect(resItineraryInfo).is.not.null;
-        itineraryInfo = resItineraryInfo as ItineraryInfo;
-        expect(itineraryInfo.projection.nearestElement).instanceOf(Vertex);
-        expect(itineraryInfo.previousStep?.number).equals(1);
-        expect(itineraryInfo.nextStep?.number).equals(2);
-        expect(itineraryInfo.remainingDistance).almost.equals(GeoUtils.calcDistance([position3, pdest]));
-        expect(itineraryInfo.remainingPercentage).closeTo(0.25, 0.01);
-        expect(itineraryInfo.traveledDistance).almost.equals(GeoUtils.calcDistance([porigin, pdest]));
-        expect(itineraryInfo.traveledPercentage).closeTo(0.75, 0.01);
-        expect(itineraryInfo.leg).almost.equals(itinerary.legs[0]);
-
-    });
-
-
-    it('Itinerary OTP', () => {
-
-        let position;
-
-        const filePath = path.resolve(__dirname, '../assets/itinerary-grenoble-otp-1.json');
-        const fileString = fs.readFileSync(filePath, 'utf8');
-        const json = JSON.parse(fileString);
-        const itineraries = OtpRemoteRouter.parseResponse(json);
-
-        const itinerary = itineraries[0];
-        const iim = new ItineraryInfoManager();
-        iim.itinerary = itinerary;
-
-        position = new Coordinates(45.1641153, 5.741293);
-        resItineraryInfo = iim.getInfo(position);
-        expect(resItineraryInfo).is.not.null;
-        itineraryInfo = resItineraryInfo as ItineraryInfo;
-        expect(itineraryInfo.projection.nearestElement).instanceOf(Vertex);
-        expect(itineraryInfo.previousStep?.number).equals(14);
-        expect(itineraryInfo.nextStep?.number).equals(15);
-        expect(itineraryInfo.remainingDistance).closeTo(56.9, 0.1);
-        expect(itineraryInfo.remainingPercentage).closeTo(0.0155, 0.01);
-        expect(itineraryInfo.leg).almost.equals(itinerary.legs[2]);
-
-        position = new Coordinates(45.1641691, 5.7413891);
-        resItineraryInfo = iim.getInfo(position);
-        expect(resItineraryInfo).is.not.null;
-        itineraryInfo = resItineraryInfo as ItineraryInfo;
-        expect(itineraryInfo.projection.nearestElement).instanceOf(Edge);
-        expect(itineraryInfo.nextStep?.number).equals(15);
-        expect(itineraryInfo.previousStep?.number).equals(14);
-        expect(itineraryInfo.remainingDistance).closeTo(66.4, 0.1);
-        expect(itineraryInfo.remainingPercentage).closeTo(0.018, 0.01);
-        expect(itineraryInfo.leg).almost.equals(itinerary.legs[2]);
-    });
-});

package/src/ItineraryInfoManager.ts

@@ -1,181 +0,0 @@
-import { Coordinates } from '@wemap/geo';
-
-import Itinerary from './model/Itinerary.js';
-import Leg from './model/Leg.js';
-import { Step } from './model/Step.js';
-import Graph from './graph/Graph.js';
-import GraphProjection from './graph/GraphProjection.js';
-import Vertex from './graph/Vertex.js';
-import Edge from './graph/Edge.js';
-
-export type ItineraryInfo<U extends Coordinates = Coordinates> = {
-    nextStep: Step | null;
-    previousStep: Step | null;
-    projection: GraphProjection<U>;
-    leg: Leg;
-    traveledDistance: number;
-    remainingDistance: number;
-    traveledPercentage: number;
-    remainingPercentage: number;
-};
-
-class ItineraryInfoManager {
-
-    _itinerary: Itinerary | null = null;
-    _graph: Graph | null = null;
-
-    _steps: Step[] = [];
-    _coordsNextStep: (Step | null)[] = [];
-    _coordsPreviousStep: (Step | null)[] = [];
-    _coordsDistanceTraveled: number[] = [];
-    _coordsLeg: Leg[] = [];
-    _itineraryDistanceWithoutProjections = 0;
-
-    constructor(itinerary: Itinerary | null = null) {
-        this.itinerary = itinerary;
-    }
-
-    get itinerary() {
-        return this._itinerary;
-    }
-
-    set itinerary(itinerary) {
-
-        if (itinerary === null) {
-            this._itinerary = null;
-            return;
-        }
-
-        this._itinerary = itinerary;
-        this._steps = itinerary.steps;
-        this._graph = itinerary.toGraph();
-
-        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);
-        this._itineraryDistanceWithoutProjections = itinerary.distance;
-
-        let stepId = 0;
-        let previousStep: Step | null = null;
-        let nextStep: Step | null = this._steps[0];
-        let distanceTraveled = 0;
-
-        itinerary.coords.forEach((coords, idx, arr) => {
-            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)) as Leg;
-
-            if (stepId < this._steps.length && this._steps[stepId].coords.equals(coords)) {
-                previousStep = this._steps[stepId];
-                nextStep = stepId === this._steps.length - 1 ? null : this._steps[stepId + 1];
-                stepId++;
-            }
-        });
-    }
-
-    getInfo<U extends Coordinates = Coordinates>(position: U) {
-
-        if (!this._itinerary || !this._graph) {
-            return null;
-        }
-
-        const projection = this._graph.getProjection(position);
-        if (!projection) {
-            return null;
-        }
-
-        let itineraryInfo: ItineraryInfo<U> | null = null;
-
-        if (projection.nearestElement instanceof Vertex) {
-            const idx = this._itinerary.coords.findIndex(
-                coords => (projection.nearestElement as Vertex).coords === coords
-            );
-            if (idx === -1) {
-                throw new Error('ItineraryInfoManager: could not find projection in itinerary (Node)');
-            }
-
-            const traveledDistanceOnItinerary = this._coordsDistanceTraveled[idx];
-
-            // Traveled distance takes into account:
-            // - projection of the origin
-            const traveledDistance = traveledDistanceOnItinerary;
-
-            // Remaining distance takes into account:
-            // - projection of the current position
-            // - distance remaining on the itinerary
-            const remainingDistanceOnItinerary = this._itineraryDistanceWithoutProjections - traveledDistanceOnItinerary;
-            const remainingDistance = projection.distanceFromNearestElement + remainingDistanceOnItinerary;
-
-            const distanceForPercentage = traveledDistance + remainingDistance
-            const traveledPercentage = traveledDistance / distanceForPercentage;
-            const remainingPercentage = 1 - traveledPercentage;
-
-            itineraryInfo = {
-                nextStep: this._coordsNextStep[idx],
-                previousStep: this._coordsPreviousStep[idx],
-                projection: projection,
-                leg: this._coordsLeg[idx],
-                traveledDistance: traveledDistanceOnItinerary,
-                remainingDistance,
-                traveledPercentage,
-                remainingPercentage
-            };
-
-        } else if (projection.nearestElement instanceof Edge) {
-
-            let firstNode = projection.nearestElement.vertex1.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.vertex2.coords
-            ) {
-                firstNode = projection.nearestElement.vertex2.coords;
-                idx--;
-            }
-
-            const traveledDistanceOnItinerary = this._coordsDistanceTraveled[idx] 
-                + projection.coords.distanceTo(firstNode);
-            
-            // Traveled distance takes into account:
-            // - distance traveled on the itinerary
-            const traveledDistance = traveledDistanceOnItinerary;
-
-            // Remaining distance takes into account:
-            // - projection of the current position
-            // - distance remaining on the itinerary
-            const remainingDistanceOnItinerary = this._itineraryDistanceWithoutProjections - traveledDistanceOnItinerary;
-            const remainingDistance = projection.distanceFromNearestElement + remainingDistanceOnItinerary 
-
-            const distanceForPercentage = traveledDistance + remainingDistance
-            const traveledPercentage = traveledDistance / distanceForPercentage;
-            const remainingPercentage = 1 - traveledPercentage;
-
-            itineraryInfo = {
-                nextStep: this._coordsNextStep[idx + 1],
-                previousStep: this._coordsPreviousStep[idx + 1],
-                projection: projection,
-                leg: this._coordsLeg[idx + 1],
-                traveledDistance,
-                remainingDistance,
-                traveledPercentage,
-                remainingPercentage
-            };
-
-        }
-
-        return itineraryInfo;
-    }
-
-}
-
-export default ItineraryInfoManager;

package/src/RoutingError.ts

@@ -1,60 +0,0 @@
-// Based on GRPC status code
-
-import { StatusCode } from "./StatusCode";
-import { TravelMode } from "./model/TravelMode";
-
-
-export class RoutingError extends Error {
-
-    public customMapName?: string | null;
-
-    constructor(public code = StatusCode.UNKNOWN, message?: string) {
-        super(message)
-    }
-
-    static notFound(details?: string) {
-        return new RoutingError(StatusCode.NOT_FOUND, `Cannot found an itinerary. Details: ${details}`)
-    }
-}
-
-
-export class WemapMultiRoutingError extends RoutingError {
-    
-    constructor(public code = StatusCode.UNKNOWN, public mapName: string | null, message?: string) {
-        super(code, message);
-        this.mapName = mapName;
-    }
-
-    static notFound(mapName: string, details?: string) {
-        return new WemapMultiRoutingError(StatusCode.NOT_FOUND, mapName, `Cannot found an itinerary in map ${mapName}. Details: ${details || 'No details'}`)
-    }
-
-}
-
-export class RemoteRoutingError extends RoutingError {
-    
-    constructor(public code = StatusCode.UNKNOWN, public routerName: string, message?: string) {
-        super(code, message);
-        this.routerName = routerName;
-    }
-
-    static notFound(routerName: string, details?: string) {
-        return new RemoteRoutingError(StatusCode.NOT_FOUND, routerName, `Cannot found an itinerary with ${routerName}. Details: ${details || 'No details'}`)
-    }
-
-    static missingApiKey(routerName: string, details?: string) {
-        return new RemoteRoutingError(StatusCode.UNAUTHENTICATED, routerName, `API key is missing for ${routerName}. Details: ${details}`)
-    }
-
-    static unreachableServer(routerName: string, url: string) {
-        return new RemoteRoutingError(StatusCode.NOT_FOUND, routerName, `Remote router server ${routerName} is unreachable. URL: ${url}`)
-    }
-
-    static responseNotParsing(routerName: string, url: string) {
-        return new RemoteRoutingError(StatusCode.NOT_FOUND, routerName, `Remote router server response ${routerName} cannot be parsed. URL: ${url}`)
-    }
-
-    static travelModeUnimplemented(routerName: string, travelMode: TravelMode) {
-        return new RemoteRoutingError(StatusCode.UNIMPLEMENTED, routerName, `Travel mode "${travelMode}" is not implemented for ${routerName}`)
-    }
-}

package/src/Utils.ts

@@ -1,8 +0,0 @@
-/**
- * Get route duration
- * @param {Number} speed in km/h
- * @returns {Number} duration in seconds
- */
-export function getDurationFromLength(length: number, speed = 5) {
-    return length / (speed * 1000 / 3600);
-}

package/src/graph/Edge.spec.ts

@@ -1,32 +0,0 @@
-import chai from 'chai';
-
-import { Coordinates } from '@wemap/geo';
-
-import Vertex from './Vertex.js';
-import Edge from './Edge.js';
-
-const { expect } = chai;
-
-describe('Edge', () => {
-
-    const vertex1 = new Vertex(new Coordinates(45, 5));
-    const vertex2 = new Vertex(new Coordinates(46, 5));
-
-    it('creation', () => {
-
-        expect(() => new Edge(vertex1, vertex2)).not.throw(Error);
-
-    });
-
-
-    it('distanceTo / bearingTo', () => {
-        let newEdge = new Edge(vertex1, vertex2);
-        expect(newEdge.length).equals(vertex1.distanceTo(vertex2));
-        expect(newEdge.bearing).equals(vertex1.bearingTo(vertex2));
-
-        newEdge = new Edge(vertex1, vertex2);
-        expect(newEdge.bearing).equals(vertex1.bearingTo(vertex2));
-        expect(newEdge.length).equals(vertex1.distanceTo(vertex2));
-    });
-
-});

package/src/graph/Edge.ts

@@ -1,64 +0,0 @@
-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;
-    areEscalators?: boolean;
-    isMovingWalkway?: boolean;
-    needTicket?: boolean;
-    incline?: 'up' | 'down';
-}
-
-/**
- * An Edge is a segment composed of two Vertex
- * An edge is mostly issued from an OsmWay, but this is not always the case.
- * For example, edges created by mapmatching.
- */
-export default class Edge {
-
-    static currentUniqueId = 0;
-
-    public readonly level: Level_t;
-
-    /** Edge bearing from vertex1 to vertex2 */
-    public readonly bearing: number;
-    public readonly length: number;
-
-    constructor(
-        public vertex1: Vertex,
-        public vertex2: Vertex,
-        public properties: EdgeProperties = {},
-        public readonly id: number = Edge.currentUniqueId++
-    ) {
-        this.level = Level.union(vertex1.coords.level, vertex2.coords.level)
-        this.length = this.vertex1.distanceTo(this.vertex2);
-        this.bearing = this.vertex1.bearingTo(this.vertex2);
-    }
-
-    static getEdgeByVertices(
-        edges: Edge[],
-        vertex1: Vertex,
-        vertex2: Vertex
-    ) {
-        return edges.find(edge => vertex1 === edge.vertex1 && vertex2 === edge.vertex2
-            || vertex2 === edge.vertex1 && vertex1 === edge.vertex2
-        );
-    }
-
-    reverseProperties() {
-        const { properties } = this;
-        if (properties.incline) {
-            properties.incline = properties.incline === 'up' ? 'down' : 'up';
-        }
-        if (properties.isOneway) {
-            properties.isOneway = false;
-        }
-    }
-}