@wemap/geo 4.0.13 → 5.0.0

package/src/graph/Itinerary.js

@@ -1,529 +0,0 @@
-/* eslint-disable max-statements */
-import Coordinates from '../coordinates/Coordinates.js';
-import Level from '../coordinates/Level.js';
-
-import Edge from './Edge.js';
-import ItineraryInfo from './ItineraryInfo.js';
-import MapMatching from './MapMatching.js';
-import Network from './Network.js';
-import Node from './Node.js';
-import Step from './Step.js';
-import StepsGeneration from './StepsGeneration.js';
-import { getDurationFromLength } from './Utils.js';
-
-/**
- * Main attributes are:
- * nodes: the ordered list of Node
- * edges: the ordered list of Edge
- * start: the start point (Coordinates)
- * end: the end point (Coordinates)
- * length: the route length
- */
-class Itinerary extends Network {
-
-    /** @type {?Coordinates} */
-    start;
-
-    /** @type {?Coordinates} */
-    end;
-
-    /** @type {?Step[]} */
-    _steps;
-
-    /** @type {number} */
-    _length;
-
-    /** @type {boolean[]} */
-    _edgesDirectionReversed;
-
-    /** @type {number[]} */
-    _nextStepsIndexes;
-
-    /** @type {MapMatching} */
-    _mapMatching;
-
-    /**
-     * @param {Node[]} nodes
-     * @param {Edge[]} edges
-     */
-    constructor(nodes, edges) {
-        super(nodes, edges);
-        this.start = null;
-        this.end = null;
-        this._steps = null;
-        this._length = 0;
-
-        // This array is for computational time gain only
-        // It helps to know if this.edges is in the same direction than the current itinerary
-        // true = opposite direction
-        // false = same direction
-        // if this.edgeDirectionReversed[i] is true, this.edges[i].node2 is before
-        //  this.edges[i].node1 following the current itinerary
-        this._edgesDirectionReversed = new Array(edges ? edges.length : 0);
-
-        // This array is for computational time gain only
-        // It helps to find next and previous steps by storing next steps indexes for each node
-        // The size of this array is the same than this.nodes
-        this._nextStepsIndexes = null;
-
-        this._mapMatching = new MapMatching(this);
-    }
-
-    /**
-     * Get route length
-     * @type {number}
-     */
-    get length() {
-        if (!this._length) {
-            this._length = this.edges.reduce((acc, edge) => acc + edge.length, 0);
-        }
-        return this._length;
-    }
-
-    /**
-     * Get route duration with default speed
-     * @type {number}
-     */
-    get duration() {
-        return this.getDuration();
-    }
-
-    /**
-     * Get route duration
-     * @param {number} speed in km/h
-     */
-    getDuration(speed) {
-        return getDurationFromLength(this.length, speed);
-    }
-
-    /** @type {Step[]} */
-    get steps() {
-        if (!this._steps) {
-            const {
-                steps, nextStepsIndexes
-            } = StepsGeneration.fromItinerary(this);
-            this._steps = steps;
-            this._nextStepsIndexes = nextStepsIndexes;
-        }
-        return this._steps;
-    }
-
-    /**
-     * Get edge at given distance
-     * @param {number} distance
-     * @returns {Edge} the edge or null if not exists
-     */
-    getEdgeAt(distance) {
-
-        if (distance === 0 && this.edges.length > 0) {
-            return this.edges[0];
-        }
-
-        let sum = 0;
-        for (let i = 0; i < this.edges.length; i++) {
-            sum += this.edges[i].length;
-            if (distance <= sum) {
-                return this.edges[i];
-            }
-        }
-        return null;
-    }
-
-    /**
-     * @param {Edge|Node} graphElement
-     * @returns {Node}
-     */
-    getNextNode(graphElement) {
-        if (graphElement instanceof Edge) {
-            const indexOfEdge = this.edges.indexOf(graphElement);
-            if (indexOfEdge !== -1) {
-                return this.nodes[indexOfEdge + 1];
-            }
-        }
-
-        if (graphElement instanceof Node) {
-            const indexOfNode = this.nodes.indexOf(graphElement);
-            if (indexOfNode !== -1 && indexOfNode !== this.nodes.length - 1) {
-                return this.nodes[indexOfNode + 1];
-            }
-        }
-        return null;
-    }
-
-    /**
-     * @param {Edge|Node} graphElement
-     * @returns {Edge}
-     */
-    getNextEdge(graphElement) {
-        if (graphElement instanceof Edge) {
-            const indexOfEdge = this.edges.indexOf(graphElement);
-            if (indexOfEdge !== -1 && indexOfEdge !== this.edges.length - 1) {
-                return this.edges[indexOfEdge + 1];
-            }
-        }
-
-        if (graphElement instanceof Node) {
-            const indexOfNode = this.nodes.indexOf(graphElement);
-            if (indexOfNode !== -1 && indexOfNode !== this.edges.length) {
-                return this.edges[indexOfNode];
-            }
-        }
-        return null;
-    }
-
-    /**
-     * @param {Edge|Node} graphElement
-     * @returns {Step}
-     */
-    getNextStep(graphElement) {
-
-        if (graphElement instanceof Edge) {
-            const indexOfEdge = this.edges.indexOf(graphElement);
-            if (indexOfEdge !== -1) {
-                return this._getNextStepFromEdgeId(indexOfEdge);
-            }
-        } else if (graphElement instanceof Node) {
-            const indexOfNode = this.nodes.indexOf(graphElement);
-            if (indexOfNode !== -1) {
-                return this._getNextStepFromNodeId(indexOfNode);
-            }
-        }
-        return null;
-    }
-
-    /**
-     * @param {number} edgeId
-     * @returns {Step}
-     */
-    _getNextStepFromEdgeId(edgeId) {
-        return this.steps[this._nextStepsIndexes[edgeId + 1]];
-    }
-
-    /**
-     * @param {number} nodeId
-     * @returns {Step}
-     */
-    _getNextStepFromNodeId(nodeId) {
-        return this.steps[this._nextStepsIndexes[nodeId]];
-    }
-
-    /**
-     * @param {Edge|Node} graphElement
-     * @returns {Step}
-     */
-    getPreviousStep(graphElement) {
-
-        if (graphElement instanceof Edge) {
-            const indexOfEdge = this.edges.indexOf(graphElement);
-            if (indexOfEdge !== -1) {
-                return this._getPreviousStepFromEdgeId(indexOfEdge);
-            }
-        } else if (graphElement instanceof Node) {
-            const indexOfNode = this.nodes.indexOf(graphElement);
-            if (indexOfNode !== -1) {
-                return this._getPreviousStepFromNodeId(indexOfNode);
-            }
-        }
-        return null;
-    }
-
-    /**
-     * @param {number} edgeId
-     * @returns {Step}
-     */
-    _getPreviousStepFromEdgeId(edgeId) {
-        const previousStepId = this._nextStepsIndexes[edgeId + 1] - 1;
-        return this.steps[previousStepId];
-    }
-
-    /**
-     * @param {number} nodeId
-     * @returns {Step}
-     */
-    _getPreviousStepFromNodeId(nodeId) {
-        const previousStepId = this._nextStepsIndexes[nodeId] - 1;
-        if (previousStepId !== -1) {
-            return this.steps[previousStepId];
-        }
-        return null;
-    }
-
-    /**
-     * @param {Coordinates} position
-     * @returns {ItineraryInfo}
-     */
-    getInfo(position) {
-
-        if (!(position instanceof Coordinates)) {
-            return null;
-        }
-
-        const projection = this._mapMatching.getProjection(position);
-        if (!projection) {
-            return null;
-        }
-
-        const totalDistance = this.length;
-        let traveledDistance = 0;
-        let nextStep, previousStep;
-
-        if (projection.nearestElement instanceof Node) {
-
-            let currentNodeIndex = 0;
-            while (this.nodes[currentNodeIndex] !== projection.nearestElement) {
-                traveledDistance += this.edges[currentNodeIndex].length;
-                currentNodeIndex++;
-            }
-            nextStep = this._getNextStepFromNodeId(currentNodeIndex);
-            previousStep = this._getPreviousStepFromNodeId(currentNodeIndex);
-
-        } else {
-            // if (projection.nearestElement instanceof Edge)
-            let currentEdgeIndex = 0;
-            while (this.edges[currentEdgeIndex] !== projection.nearestElement) {
-                traveledDistance += this.edges[currentEdgeIndex].length;
-                currentEdgeIndex++;
-            }
-            traveledDistance += this.nodes[currentEdgeIndex].coords
-                .distanceTo(projection.projection);
-            nextStep = this._getNextStepFromEdgeId(currentEdgeIndex);
-            previousStep = this._getPreviousStepFromEdgeId(currentEdgeIndex);
-
-        }
-
-        const itineraryInfo = new ItineraryInfo();
-        return Object.assign(itineraryInfo, {
-            nextStep,
-            previousStep,
-            projection,
-            traveledDistance,
-            traveledPercentage: traveledDistance / totalDistance,
-            remainingDistance: totalDistance - traveledDistance,
-            remainingPercentage: 1 - traveledDistance / totalDistance
-        });
-    }
-
-    static fromNetworkNodes(nodes, start, end) {
-
-        /**
-         * Itinerary part of network is cloned and ordered
-         */
-
-        const itinerary = new Itinerary();
-        itinerary._length = 0;
-        itinerary.start = start;
-        itinerary.end = end;
-
-        for (let i = 0; i < nodes.length; i++) {
-
-            const networkNode = nodes[i];
-
-            itinerary.nodes.push(networkNode);
-
-            if (i === nodes.length - 1) {
-                break;
-            }
-
-            const nextNetworkNode = nodes[i + 1];
-            const networkEdge = Network.getEdgeByNodes(networkNode.edges, networkNode, nextNetworkNode);
-            itinerary._edgesDirectionReversed.push(networkNode !== networkEdge.node1);
-
-            itinerary.edges.push(networkEdge);
-            itinerary._length += networkEdge.length;
-        }
-
-        return itinerary;
-    }
-
-    /**
-     * Convert lat/lng/level points to Itinerary
-     * @param {2DArray} points 2D points array of lat/lng/level (level is optional)
-     */
-    static fromOrderedPointsArray(points, start, end) {
-
-        const pointToCoordinates = point => new Coordinates(point[0], point[1], null, point[2]);
-
-        return this.fromOrderedCoordinates(
-            points.map(pointToCoordinates),
-            pointToCoordinates(start),
-            pointToCoordinates(end)
-        );
-    }
-
-    /**
-     * Convert lat/lng/level points to Itinerary
-     * @param {2DArray} points 2D points array of lat/lng/level (level is optional)
-     */
-    static fromOrderedCoordinates(points, start, end) {
-
-        const route = new Itinerary();
-        route._length = 0;
-        route.start = start;
-        route.end = end;
-
-        let lastPoint = null;
-
-        points.forEach(point => {
-            const currentPoint = new Node(point);
-            if (lastPoint) {
-                const edge = new Edge(
-                    lastPoint,
-                    currentPoint,
-                    Level.union(lastPoint.coords.level, currentPoint.coords.level)
-                );
-                route._edgesDirectionReversed.push(false);
-                route.edges.push(edge);
-                route._length += edge.length;
-            }
-
-            route.nodes.push(currentPoint);
-            lastPoint = currentPoint;
-        });
-
-        return route;
-    }
-
-    /**
-     * Create edges From MultiLevel Itinerary for a given level
-     * @param {Level} targetLevel level for selection.
-     * @param {Boolean} useMultiLevelEdges use segments which intersect both levels (stairs, elevators...)
-     * @returns {Array[Edge]} Ordered edges
-     */
-    getEdgesAtLevel(targetLevel, useMultiLevelEdges = true) {
-        return this.edges.filter(
-            ({ level }) => useMultiLevelEdges
-                ? Level.intersect(targetLevel, level) !== null
-                : Level.contains(targetLevel, level)
-        );
-    }
-
-    /**
-     * Append another itinerary
-     * @param {Itinerary} other
-     * @returns {Itinerary} this
-     */
-    append(other) {
-
-        if (!this.end.equalsTo(other.start)) {
-            throw new Error('end of the first itinerary does not equal to the start of the second one');
-        }
-
-        this._steps = null;
-        this._nextStepsIndexes = null;
-        this._length = this.length + other.length;
-
-        const lastNodeOfThis = this.nodes[this.nodes.length - 1];
-        const firstNodeOfOther = other.nodes[0];
-        const firstEdgeOfOther = other.edges[0];
-
-        if (this.end.equalsTo(lastNodeOfThis.coords)
-            && other.start.equalsTo(firstNodeOfOther.coords)) {
-            // first itinerary end node equals to the second itinerary first node
-
-            // Add to nodes other.nodes[1..end]
-            this.nodes = this.nodes.concat(other.nodes.slice(1));
-
-            // Add to edges other.edges[0..end]
-            this.edges = this.edges.concat(other.edges);
-            this._edgesDirectionReversed = this._edgesDirectionReversed.concat(other._edgesDirectionReversed);
-            firstEdgeOfOther.node1 = lastNodeOfThis;
-
-        } else if (this.end.equalsTo(lastNodeOfThis.coords)
-            || other.start.equalsTo(firstNodeOfOther.coords)) {
-            // last node and end of the first itinerary are merged
-            // or
-            // first node and start of the second itinerary are merged
-
-            // Add to nodes other.nodes[0..end]
-            this.nodes = this.nodes.concat(other.nodes);
-
-            // Add to edges [newEdge].concat(other.edges[0..end])
-            const newEdge = new Edge(lastNodeOfThis, firstNodeOfOther,
-                Level.union(lastNodeOfThis.coords.level, firstNodeOfOther.coords.level)
-            );
-            this.edges.push(newEdge);
-            this.edges = this.edges.concat(other.edges);
-            this._edgesDirectionReversed.push(false);
-            this._edgesDirectionReversed = this._edgesDirectionReversed.concat(other._edgesDirectionReversed);
-
-            this._length += newEdge.length;
-
-        } else {
-            // normal case
-
-            // Add to nodes [newNode].concat(other.nodes[0..end])
-            const coords = this.end.clone();
-            coords.level = Level.intersect(this.end.level, other.start.level);
-            const newNode = new Node(this.end);
-            this.nodes.push(newNode);
-            this.nodes = this.nodes.concat(other.nodes);
-
-            // Add to edges [newEdge1, newEdge2].concat(other.edges[0..end])
-            const newEdge1 = new Edge(lastNodeOfThis, newNode,
-                Level.union(lastNodeOfThis.coords.level, coords.level)
-            );
-            const newEdge2 = new Edge(newNode, firstNodeOfOther,
-                Level.union(coords.level, firstNodeOfOther.coords.level)
-            );
-            this.edges.push(newEdge1);
-            this.edges.push(newEdge2);
-            this.edges = this.edges.concat(other.edges);
-            this._edgesDirectionReversed.push(false);
-            this._edgesDirectionReversed.push(false);
-            this._edgesDirectionReversed = this._edgesDirectionReversed.concat(other._edgesDirectionReversed);
-
-            this._length += newEdge1.length + newEdge2.length;
-
-        }
-
-        this.end = other.end;
-
-        return this;
-    }
-
-    toCompressedJson() {
-        return {
-            start: this.start.toCompressedJson(),
-            end: this.end.toCompressedJson(),
-            coords: this.nodes.map(node => node.coords.toCompressedJson()),
-            nodeProperties: this.nodes.reduce((acc, node, idx) => {
-                const properties = node.extractProperties();
-                if (Object.keys(properties).length !== 0) {
-                    acc[idx] = properties;
-                }
-                return acc;
-            }, {}),
-            edgeProperties: this.edges.reduce((acc, edge, idx) => {
-                const properties = edge.extractProperties();
-                if (Object.keys(properties).length !== 0) {
-                    acc[idx] = properties;
-                }
-                return acc;
-            }, {})
-        };
-    }
-
-    static fromCompressedJson(json) {
-        const itinerary = Itinerary.fromOrderedCoordinates(
-            json.coords.map(coords => Coordinates.fromCompressedJson(coords)),
-            Coordinates.fromCompressedJson(json.start),
-            Coordinates.fromCompressedJson(json.end)
-        );
-        if ('nodeProperties' in json) {
-            for (const idx in json.nodeProperties) {
-                if (json.nodeProperties.hasOwnProperty(idx)) {
-                    itinerary.nodes[idx].applyProperties(json.nodeProperties[idx]);
-                }
-            }
-        }
-        if ('edgeProperties' in json) {
-            for (const idx in json.edgeProperties) {
-                if (json.edgeProperties.hasOwnProperty(idx)) {
-                    itinerary.edges[idx].applyProperties(json.edgeProperties[idx]);
-                }
-            }
-        }
-        return itinerary;
-    }
-}
-export default Itinerary;