@wemap/routers 6.0.0

package/src/cityway/CitywayUtils.js

@@ -0,0 +1,240 @@
+/* eslint-disable max-depth */
+/* eslint-disable max-statements */
+import { Coordinates } from '@wemap/geo';
+import Logger from '@wemap/logger';
+
+import Itinerary from '../model/Itinerary.js';
+import Leg from '../model/Leg.js';
+import RouterResponse from '../model/RouterResponse.js';
+import Step from '../model/Step.js';
+import { generateStepsMetadata } from '../Utils.js';
+
+/**
+ * @param {object} json
+ * @returns {Coordinates}
+ */
+export function jsonToCoordinates(json) {
+    return new Coordinates(json.Lat, json.Long);
+}
+
+/**
+ * @param {string} jsonDate
+ * @returns {number}
+ */
+function jsonDateToTimestamp(jsonDate) {
+    const [dateStr, timeStr] = jsonDate.split(' ');
+    const [dayStr, monthStr, yearStr] = dateStr.split('/');
+    const [hoursStr, minutesStr, secondsStr] = timeStr.split(':');
+    const date = new Date(
+        Number(yearStr), Number(monthStr) - 1, Number(dayStr),
+        Number(hoursStr), Number(minutesStr), Number(secondsStr)
+    );
+    return date.getTime();
+}
+
+/**
+ * @param {string} wktGeometry
+ * @returns {Coordinates[]}
+ */
+function parseWKTGeometry(wktGeometry) {
+    const tmpCoordsStr = wktGeometry.match(/LINESTRING \((.*)\)/i);
+    if (!tmpCoordsStr) {
+        return null;
+    }
+    return tmpCoordsStr[1].split(',').map(str => {
+        const sp = str.trim().split(' ');
+        return new Coordinates(Number(sp[1]), Number(sp[0]));
+    });
+}
+
+/**
+ * @param {string} iso8601Duration
+ * @see https://stackoverflow.com/a/29153059/2239938
+ */
+function parseDuration(iso8601Duration) {
+    const iso8601DurationRegex = /(-)?P(?:([.,\d]+)Y)?(?:([.,\d]+)M)?(?:([.,\d]+)W)?(?:([.,\d]+)D)?T(?:([.,\d]+)H)?(?:([.,\d]+)M)?(?:([.,\d]+)S)?/;
+
+    var matches = iso8601Duration.match(iso8601DurationRegex);
+
+    // const sign = typeof matches[1] === 'undefined' ? '+' : '-',
+    const years = typeof matches[2] === 'undefined' ? 0 : Number(matches[2]);
+    const months = typeof matches[3] === 'undefined' ? 0 : Number(matches[3]);
+    const weeks = typeof matches[4] === 'undefined' ? 0 : Number(matches[4]);
+    const days = typeof matches[5] === 'undefined' ? 0 : Number(matches[5]);
+    const hours = typeof matches[6] === 'undefined' ? 0 : Number(matches[6]);
+    const minutes = typeof matches[7] === 'undefined' ? 0 : Number(matches[7]);
+    const seconds = typeof matches[8] === 'undefined' ? 0 : Number(matches[8]);
+
+    return seconds
+        + minutes * 60
+        + hours * 3600
+        + days * 86400
+        + weeks * (86400 * 7)
+        + months * (86400 * 30)
+        + years * (86400 * 365.25);
+}
+
+/**
+ * Generate multi itineraries from Cityway JSON
+ * @param {object} json JSON file provided by Cityway.
+ * @returns {?RouterResponse}
+ * @example https://preprod.api.lia2.cityway.fr/journeyplanner/api/opt/PlanTrips/json?DepartureLatitude=49.51509388236216&DepartureLongitude=0.09341749619366316&ArrivalLatitude=49.5067090188444&ArrivalLongitude=0.1694842115417831&DepartureType=COORDINATES&ArrivalType=COORDINATES
+ */
+export function createRouterResponseFromJson(json) {
+
+    if (json.StatusCode !== 200 || !json.Data || !json.Data.length) {
+        return null;
+    }
+
+    const routerResponse = new RouterResponse();
+    routerResponse.routerName = 'cityway';
+
+
+    // Do not know if it the best approach, but it works...
+    const allJsonTrips = json.Data.reduce((acc, dataObj) => {
+        acc.push(...dataObj.response.trips.Trip);
+        return acc;
+    }, []);
+
+    for (const trip of allJsonTrips) {
+
+        const itinerary = new Itinerary();
+
+        itinerary.duration = parseDuration(trip.Duration);
+        itinerary.startTime = jsonDateToTimestamp(trip.Departure.Time);
+        itinerary.from = jsonToCoordinates(trip.Departure.Site.Position);
+        itinerary.endTime = jsonDateToTimestamp(trip.Arrival.Time);
+        itinerary.to = jsonToCoordinates(trip.Arrival.Site.Position);
+        routerResponse.itineraries.push(itinerary);
+
+        for (const jsonSection of trip.sections.Section) {
+
+            const jsonLeg = jsonSection.Leg ? jsonSection.Leg : jsonSection.PTRide;
+
+            const leg = new Leg();
+
+            leg.mode = jsonLeg.TransportMode;
+            leg.duration = parseDuration(jsonLeg.Duration);
+            leg.startTime = jsonDateToTimestamp(jsonLeg.Departure.Time);
+            leg.endTime = jsonDateToTimestamp(jsonLeg.Arrival.Time);
+            leg.coords = [];
+
+            if (leg.mode === 'WALK' || leg.mode === 'BICYCLE') {
+
+                leg.from = {
+                    name: jsonLeg.Departure.Site.Name,
+                    coords: jsonToCoordinates(jsonLeg.Departure.Site.Position)
+                };
+                leg.to = {
+                    name: jsonLeg.Arrival.Site.Name,
+                    coords: jsonToCoordinates(jsonLeg.Arrival.Site.Position)
+                };
+
+                leg.steps = [];
+                for (const jsonPathLink of jsonLeg.pathLinks.PathLink) {
+                    const step = new Step();
+                    let stepCoords;
+                    if (jsonPathLink.Geometry) {
+                        stepCoords = parseWKTGeometry(jsonPathLink.Geometry);
+                    } else {
+                        stepCoords = [leg.from.coords, leg.to.coords];
+                    }
+                    step.coords = stepCoords[0];
+                    step._idCoordsInLeg = leg.coords.length;
+                    stepCoords.forEach((coords, idx) => {
+                        if (
+                            idx !== 0
+                            || leg.coords.length === 0
+                            || !leg.coords[leg.coords.length - 1].equalsTo(coords)
+                        ) {
+                            leg.coords.push(coords);
+                        }
+                    });
+
+
+                    step.name = jsonPathLink.Departure.Site.Name;
+                    step.levelChange = null;
+
+                    step.distance = jsonPathLink.Distance;
+
+                    leg.steps.push(step);
+                }
+
+            } else if (leg.mode === 'BUS' || leg.mode === 'TRAMWAY' || leg.mode === 'FUNICULAR') {
+
+                leg.from = {
+                    name: jsonLeg.Departure.StopPlace.Name,
+                    coords: jsonToCoordinates(jsonLeg.Departure.StopPlace.Position)
+                };
+                leg.to = {
+                    name: jsonLeg.Arrival.StopPlace.Name,
+                    coords: jsonToCoordinates(jsonLeg.Arrival.StopPlace.Position)
+                };
+
+                let transportName = jsonLeg.Line.Number;
+                if (leg.mode === 'TRAMWAY') {
+                    leg.mode = 'TRAM';
+                    // In order to remove the "TRAM " prefix.
+                    transportName = transportName.substr(5);
+                }
+
+                leg.transportInfo = {
+                    name: transportName,
+                    routeColor: jsonLeg.Line.Color,
+                    routeTextColor: jsonLeg.Line.TextColor,
+                    directionName: jsonLeg.Destination
+                };
+
+                for (const jsonStep of jsonLeg.steps.Step) {
+                    const stepCoords = parseWKTGeometry(jsonStep.Geometry);
+                    stepCoords.forEach((coords, idx) => {
+                        if (
+                            idx !== 0
+                            || leg.coords.length === 0
+                            || !leg.coords[leg.coords.length - 1].equalsTo(coords)
+                        ) {
+                            leg.coords.push(coords);
+                        }
+                    });
+                }
+
+                const legStep = new Step();
+                legStep.coords = leg.coords[0];
+                legStep._idCoordsInLeg = 0;
+                legStep.name = jsonLeg.Line.Name;
+                legStep.levelChange = null;
+                legStep.distance = jsonLeg.Distance;
+                leg.steps = [legStep];
+            } else {
+                Logger.warn(`[CitywayParser] Unknown leg mode: ${leg.mode}`);
+            }
+
+            leg.distance = leg.coords.reduce((acc, coords, idx, arr) => {
+                if (idx === 0) {
+                    return acc;
+                }
+                return acc + arr[idx - 1].distanceTo(coords);
+            }, 0);
+
+            itinerary.legs.push(leg);
+
+        }
+
+        itinerary.distance = itinerary.coords.reduce((acc, coords, idx, arr) => {
+            if (idx === 0) {
+                return acc;
+            }
+            return acc + arr[idx - 1].distanceTo(coords);
+        }, 0);
+
+        // All legs have to be parsed before computing steps metadata
+        generateStepsMetadata(itinerary);
+    }
+
+    routerResponse.from = routerResponse.itineraries[0].from;
+    routerResponse.to = routerResponse.itineraries[routerResponse.itineraries.length - 1].to;
+
+    return routerResponse;
+}
+
+

package/src/cityway/CitywayUtils.spec.js

@@ -0,0 +1,109 @@
+/* eslint-disable max-statements */
+import chai from 'chai';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { Coordinates } from '@wemap/geo';
+
+import { createRouterResponseFromJson } from './CitywayUtils.js';
+
+import { verifyRouterResponseData } from '../model/RouterResponse.type.spec.js';
+
+
+const { expect } = chai;
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+describe('CitywayUtils - createRouterResponseFromJson', () => {
+
+    it('RouterResponse - 1', () => {
+
+        const filePath = path.resolve(__dirname, '../../assets/itinerary-lehavre-cityway-1.json');
+        const fileString = fs.readFileSync(filePath, 'utf8');
+        const json = JSON.parse(fileString);
+
+        const routerResponse = createRouterResponseFromJson(json);
+        verifyRouterResponseData(routerResponse);
+
+        expect(routerResponse.routerName).equal('cityway');
+        expect(routerResponse.itineraries.length).equal(3);
+        expect(routerResponse.from.equalsTo(new Coordinates(49.515093882362159, 0.093417496193663158))).true;
+        expect(routerResponse.to.equalsTo(new Coordinates(49.5067090188444, 0.16948421154178309))).true;
+
+        const itinerary1 = routerResponse.itineraries[0];
+        expect(itinerary1.distance).to.be.closeTo(6887, 1);
+        expect(itinerary1.duration).equal(2379);
+        // Do not work because of the input time format
+        // expect(itinerary1.startTime).equal(1620659156000);
+        // expect(itinerary1.endTime).equal(1620661535000);
+        expect(itinerary1.legs.length).equal(5);
+
+        const itinerary1leg1 = itinerary1.legs[0];
+        // Do not work because of the input time format
+        // expect(itinerary1leg1.startTime).equal(1620659156000);
+        // expect(itinerary1leg1.endTime).equal(1620659340000);
+        expect(itinerary1leg1.distance).to.be.closeTo(200.14, 0.1);
+        expect(itinerary1leg1.mode).equal('WALK');
+        expect(itinerary1leg1.transportInfo).is.null;
+        expect(itinerary1leg1.from.name).equal('RUE DU QUARTIER NEUF');
+        expect(itinerary1leg1.from.coords.equalsTo(new Coordinates(49.515093882362159, 0.093417496193663158))).true;
+        expect(itinerary1leg1.to.name).equal('T. Gautier');
+        expect(itinerary1leg1.to.coords.equalsTo(new Coordinates(49.5147550229, 0.0911025378))).true;
+
+        const itinerary1leg2 = itinerary1.legs[1];
+        expect(itinerary1leg2.mode).equal('BUS');
+        expect(itinerary1leg2.transportInfo).is.not.null;
+        expect(itinerary1leg2.transportInfo.name).equal('03');
+        expect(itinerary1leg2.transportInfo.routeColor).equal('3FA435');
+        expect(itinerary1leg2.transportInfo.routeTextColor).is.null;
+        expect(itinerary1leg2.transportInfo.directionName).equal('Graville');
+    });
+
+    it('RouterResponse - 2', () => {
+        const filePath = path.resolve(__dirname, '../../assets/itinerary-lehavre-cityway-2.json');
+        const fileString = fs.readFileSync(filePath, 'utf8');
+        const json = JSON.parse(fileString);
+
+        const routerResponse = createRouterResponseFromJson(json);
+        verifyRouterResponseData(routerResponse);
+
+        expect(routerResponse.itineraries.length).equal(1);
+    });
+
+    it('RouterResponse - 3', () => {
+        const filePath = path.resolve(__dirname, '../../assets/itinerary-lehavre-cityway-3.json');
+        const fileString = fs.readFileSync(filePath, 'utf8');
+        const json = JSON.parse(fileString);
+
+        const routerResponse = createRouterResponseFromJson(json);
+        verifyRouterResponseData(routerResponse);
+
+        expect(routerResponse.itineraries[0].legs[1].mode).equal('FUNICULAR');
+    });
+
+    it('RouterResponse - 4', () => {
+        const filePath = path.resolve(__dirname, '../../assets/itinerary-lehavre-cityway-4.json');
+        const fileString = fs.readFileSync(filePath, 'utf8');
+        const json = JSON.parse(fileString);
+
+        const routerResponse = createRouterResponseFromJson(json);
+        verifyRouterResponseData(routerResponse);
+
+        expect(routerResponse.itineraries[0].legs[0].mode).equal('BICYCLE');
+    });
+
+    it('RouterResponse - 5', () => {
+        const filePath = path.resolve(__dirname, '../../assets/itinerary-lehavre-cityway-5.json');
+        const fileString = fs.readFileSync(filePath, 'utf8');
+        const json = JSON.parse(fileString);
+
+        const routerResponse = createRouterResponseFromJson(json);
+        verifyRouterResponseData(routerResponse);
+
+        expect(routerResponse.itineraries[1].legs[1].mode).equal('TRAM');
+        expect(routerResponse.itineraries[1].legs[1].transportInfo.name).equal('B');
+    });
+
+});
+

package/src/deutsche-bahn/DeutscheBahnRouterUtils.js

@@ -0,0 +1,91 @@
+/* eslint-disable max-statements */
+
+import { Coordinates, GraphEdge, GraphItinerary, GraphNode, Level } from '@wemap/geo';
+import { OsmElement, OsmNode, OsmWay } from '@wemap/osm';
+
+import Itinerary from '../model/Itinerary.js';
+import RouterResponse from '../model/RouterResponse.js';
+import { generateStepsMetadata } from '../Utils.js';
+import StepsGeneration from '../wemap/WemapStepsGeneration.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/deutsche-bahn/DeutscheBahnRouterUtils.spec.js

@@ -0,0 +1,54 @@
+/* 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 '../model/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/model/Itinerary.js

@@ -0,0 +1,197 @@
+/* eslint-disable max-statements */
+import { Coordinates, Network } from '@wemap/geo';
+import Leg from './Leg.js';
+import Step from './Step.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 {
+
+    /** @type {!Coordinates} */
+    from;
+
+    /** @type {!Coordinates} */
+    to;
+
+    /** @type {!number} */
+    distance;
+
+    /** @type {!number} */
+    duration;
+
+    /** @type {?number} */
+    startTime = null;
+
+    /** @type {?number} */
+    endTime = null;
+
+    /** @type {!(Leg[])} */
+    legs = [];
+
+    /** @type {?Coordinates[]} */
+    _coords = null;
+
+    set coords(_) {
+        throw new Error('Itinerary.coords cannot be set. They are calculated from Itinerary.legs.');
+    }
+
+    /** @type {!(Coordinates[])} */
+    get coords() {
+        if (!this._coords) {
+            // Returns the coordinates contained in all legs and remove duplicates between array
+            this._coords = this.legs.reduce((acc, val) => {
+                const isDuplicate = acc.length && val.coords.length && acc[acc.length - 1].equalsTo(val.coords[0]);
+                acc.push(...val.coords.slice(isDuplicate ? 1 : 0));
+                return acc;
+            }, []);
+        }
+        return this._coords;
+    }
+
+    set steps(_) {
+        throw new Error('Itinerary.step cannot be set. They are calculated from Itinerary.legs.');
+    }
+
+    /** @type {!(Step[])} */
+    get steps() {
+        return this.legs.map(leg => leg.steps).flat();
+    }
+
+    /**
+     * @returns {Network}
+     */
+    toNetwork() {
+        return Network.fromCoordinates([this.coords]);
+    }
+
+    /**
+     * @param {Itinerary[]} itineraries
+     * @returns {Itinerary}
+     */
+    static fromItineraries(...itineraries) {
+        const itinerary = new Itinerary();
+        itinerary.from = itineraries[0].from;
+        itinerary.to = itineraries[itineraries.length - 1].to;
+        itinerary.distance = 0;
+        itinerary.duration = 0;
+        itinerary.legs = [];
+
+        itineraries.forEach(_itinerary => {
+            itinerary.distance += _itinerary.distance;
+            itinerary.duration += _itinerary.duration;
+            itinerary.legs.push(..._itinerary.legs);
+            itinerary.legs.forEach(leg => {
+                leg.steps[0].firstStep = false;
+                leg.steps[leg.steps.length - 1].lastStep = false;
+            });
+        });
+
+        itinerary.legs[0].steps[0].firstStep = true;
+        const lastLeg = itinerary.legs[itinerary.legs.length - 1];
+        lastLeg.steps[lastLeg.steps.length - 1].lastStep = true;
+
+        return itinerary;
+    }
+
+    /**
+     * Convert lat/lng/level points to Itinerary
+     * @param {number[][]} points 2D points array of lat/lng/level (level is optional)
+     * @param {Coordinates} from
+     * @param {Coordinates} to
+     * @param {string} mode
+     * @returns {Itinerary}
+     */
+    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 ordered Coordinates to Itinerary
+     * @param {Coordinates[]} points
+     * @param {Coordinates} from
+     * @param {Coordinates} to
+     * @param {string} mode
+     * @returns {Itinerary}
+     */
+    static fromOrderedCoordinates(points, from, to, mode = 'WALK') {
+
+        const itinerary = new Itinerary();
+        itinerary.from = from;
+        itinerary.to = to;
+
+        const leg = new Leg();
+        leg.mode = mode;
+        leg.from = { name: null, coords: from };
+        leg.to = { name: null, coords: to };
+
+        leg.coords = points;
+        leg.distance = points.reduce((acc, coords, idx, arr) => {
+            if (idx !== 0) {
+                return acc + arr[idx - 1].distanceTo(coords);
+            }
+            return acc;
+        }, 0);
+        leg.duration = getDurationFromLength(leg.distance);
+        itinerary.legs.push(leg);
+
+        itinerary.distance = leg.distance;
+        itinerary.duration = leg.duration;
+
+        return itinerary;
+    }
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        const output = {
+            from: this.from.toCompressedJson(),
+            to: this.to.toCompressedJson(),
+            distance: this.distance,
+            duration: this.duration,
+            legs: this.legs.map(leg => leg.toJson())
+        };
+        if (this.startTime !== null) {
+            output.startTime = this.startTime;
+        }
+        if (this.endTime !== null) {
+            output.endTime = this.endTime;
+        }
+        return output;
+    }
+
+    /**
+     * @param {object} json
+     * @returns {Itinerary}
+     */
+    static fromJson(json) {
+        const itinerary = new Itinerary();
+        itinerary.from = Coordinates.fromCompressedJson(json.from);
+        itinerary.to = Coordinates.fromCompressedJson(json.to);
+        itinerary.distance = json.distance;
+        itinerary.duration = json.duration;
+        itinerary.legs = json.legs.map(Leg.fromJson);
+        if (json.startTime) {
+            itinerary.startTime = json.startTime;
+        }
+        if (json.endTime) {
+            itinerary.endTime = json.endTime;
+        }
+        return itinerary;
+    }
+}
+export default Itinerary;