@wemap/geo 5.1.1 → 5.1.7

package/dist/wemap-geo.es.js

@@ -0,0 +1,2946 @@
+import { wrap, deg2rad, rad2deg, Quaternion, Vector3, positiveMod, Rotations, diffAngleLines } from '@wemap/maths';
+import Logger from '@wemap/logger';
+
+const Constants = {
+    R_MAJOR: 6378137.0,
+    R_MINOR: 6356752.3142,
+    EARTH_GRAVITY: 9.80665,
+
+    /**
+     * latitude and longitude epsilon in degrees
+     * 1e-8° correspond to ~1mm at latitude = 0
+     */
+    EPS_DEG_MM: 1e-8,
+
+    /**
+     * epsilon in meters which corresponds to 1 millimeter
+     */
+    EPS_MM: 1e-3
+};
+
+Constants.ELLIPSOID_FLATNESS = (Constants.R_MAJOR - Constants.R_MINOR) / Constants.R_MAJOR;
+
+Constants.ECCENTRICITY = Math.sqrt(Constants.ELLIPSOID_FLATNESS * (2 - Constants.ELLIPSOID_FLATNESS));
+
+Constants.R_MAJOR_2 = Constants.R_MAJOR * Constants.R_MAJOR;
+Constants.R_MAJOR_4 = Constants.R_MAJOR_2 * Constants.R_MAJOR_2;
+Constants.R_MINOR_2 = Constants.R_MINOR * Constants.R_MINOR;
+Constants.R_MINOR_4 = Constants.R_MINOR_2 * Constants.R_MINOR_2;
+Constants.ECCENTRICITY_2 = Constants.ECCENTRICITY * Constants.ECCENTRICITY;
+Constants.CIRCUMFERENCE = Constants.R_MAJOR * 2 * Math.PI;
+
+/**
+ * A Level is the representation of a building floor number
+ * A level can be a simple number (val) or a range (low, up)
+ * To know if a level is a range or a number, isRange can be used
+ */
+class Level {
+
+    /**
+     * Level constructor
+     *  1 argument: level is not a range and first argument is the level
+     *  2 arguments: level is a range
+     * @param {number} arg1 if arg2: low value, otherwise: level
+     * @param {number} arg2 (optional) up value
+     */
+    constructor(arg1, arg2) {
+        if (typeof arg1 !== 'number' || isNaN(arg1)) {
+            throw new Error('first argument is mandatory');
+        }
+        if (typeof arg2 === 'number' && !isNaN(arg2)) {
+            if (arg1 === arg2) {
+                this.isRange = false;
+                this.val = arg1;
+            } else {
+                this.isRange = true;
+                this.low = Math.min(arg1, arg2);
+                this.up = Math.max(arg1, arg2);
+            }
+        } else if (typeof arg2 === 'undefined') {
+            this.isRange = false;
+            this.val = arg1;
+        } else {
+            throw new Error('second argument is not a number');
+        }
+    }
+
+    clone() {
+        if (this.isRange) {
+            return new Level(this.low, this.up);
+        }
+        return new Level(this.val);
+    }
+
+    /**
+     * Create a level from a string
+     * @param {string} str level in str format (eg. 1, -2, 1;2, -2;3, 2;-1, 0.5;1 ...)
+     */
+    static fromString(str) {
+
+        if (typeof str !== 'string') {
+            return null;
+        }
+
+        if (!isNaN(Number(str))) {
+            return new Level(parseFloat(str));
+        }
+
+        const splited = str.split(';');
+        if (splited.length === 2) {
+            if (!isNaN(Number(splited[0])) && !isNaN(Number(splited[1]))) {
+                return new Level(parseFloat(splited[0]), parseFloat(splited[1]));
+            }
+        }
+
+        Logger.warn('Cannot parse following level: ' + str);
+        return null;
+    }
+
+    /**
+     * Returns if the level is inside the given level
+     * @param {Level} level the container level
+     */
+    isInside(level) {
+        return Level.contains(level, this);
+    }
+
+    /**
+     * Returns if the level is inside the given level
+     * @param {Level} level the container level
+     */
+    contains(level) {
+        return Level.contains(this, level);
+    }
+
+
+    /**
+     * Returns if a level is contained in another
+     * @param {Level} container The container level
+     * @param {Level} targeted The targeted level
+     */
+    static contains(container, targeted) {
+
+        if (container === targeted) {
+            return true;
+        }
+
+        if (!container || !targeted) {
+            return false;
+        }
+
+        if (!container.isRange) {
+            if (targeted.isRange) {
+                return false;
+            }
+            return container.val === targeted.val;
+        }
+
+        return container.up >= (targeted.isRange ? targeted.up : targeted.val)
+            && container.low <= (targeted.isRange ? targeted.low : targeted.val);
+    }
+
+    /**
+     * Retrieve the intersection of two levels
+     * @param {Level} other The other level
+     */
+    intersect(other) {
+        return Level.intersect(this, other);
+    }
+
+    /**
+     * Retrieve the intersection of two levels
+     * @param {Level} first The first level
+     * @param {Level} second The second level
+     */
+    static intersect(first, second) {
+
+        if (first === second) {
+            if (first instanceof Level) {
+                return first.clone();
+            }
+            return null;
+        }
+
+        if (!second) {
+            return null;
+        }
+
+        if (!first) {
+            return null;
+        }
+
+        if (first.isRange && !second.isRange) {
+            if (first.contains(second)) {
+                return second.clone();
+            }
+            return null;
+        }
+        if (!first.isRange && second.isRange) {
+            if (second.contains(first)) {
+                return first.clone();
+            }
+            return null;
+        }
+        if (first.isRange && second.isRange) {
+            const up = Math.min(first.up, second.up);
+            const low = Math.max(first.low, second.low);
+            if (up < low) {
+                return null;
+            }
+            return new Level(low, up);
+        }
+        return first.val === second.val ? first : null;
+    }
+
+    /**
+     * Retrieve the union of two levels
+     * @param {Level} other The other level
+     */
+    union(other) {
+        return Level.union(this, other);
+    }
+
+    /**
+     * Retrieve the union of two levels
+     * @param {Level} other The other level
+     */
+    static union(first, second) {
+
+        if (first === second) {
+            if (first instanceof Level) {
+                return first.clone();
+            }
+            return null;
+        }
+
+        if (!second) {
+            return first.clone();
+        }
+
+        if (!first) {
+            return second.clone();
+        }
+
+        let low, up;
+        if (!first.isRange && !second.isRange) {
+            low = Math.min(first.val, second.val);
+            up = Math.max(first.val, second.val);
+        } else if (first.isRange && !second.isRange) {
+            low = Math.min(first.low, second.val);
+            up = Math.max(first.up, second.val);
+        } else if (!first.isRange && second.isRange) {
+            low = Math.min(second.low, first.val);
+            up = Math.max(second.up, first.val);
+        } else {
+            /* if (first.isRange && second.isRange) */
+            low = Math.min(second.low, first.low);
+            up = Math.max(second.up, first.up);
+        }
+
+        if (low === up) {
+            return new Level(low);
+        }
+        return new Level(low, up);
+    }
+
+    multiplyBy(factor) {
+        if (this.isRange) {
+            this.low *= factor;
+            this.up *= factor;
+        } else {
+            this.val *= factor;
+        }
+        return this;
+    }
+
+    toString() {
+        return this.isRange ? this.low + ';' + this.up : String(this.val);
+    }
+
+    static equalsTo(first, second) {
+
+        if (first === second) {
+            return true;
+        }
+        if (!first && !second) {
+            return true;
+        }
+        if (!first && second) {
+            return false;
+        }
+        if (first && !second) {
+            return false;
+        }
+        if (!first.isRange && second.isRange) {
+            return false;
+        }
+        if (first.isRange && !second.isRange) {
+            return false;
+        }
+        if (first.isRange && second.isRange) {
+            return first.low === second.low && first.up === second.up;
+        }
+        // !first.isRange && !second.isRange
+        return first.val === second.val;
+
+    }
+
+    static diff(first, second) {
+
+        if (first === null || second === null) {
+            return null;
+        }
+
+        if (!first.isRange && !second.isRange) {
+            return second.val - first.val;
+        }
+
+        if (first.isRange && !second.isRange) {
+            if (first.low === second.val) {
+                return second.val - first.up;
+            }
+            if (first.up === second.val) {
+                return second.val - first.low;
+            }
+            return null;
+        }
+
+        if (second.isRange && !first.isRange) {
+            if (first.val === second.low) {
+                return second.up - first.val;
+            }
+            if (first.val === second.up) {
+                return second.low - first.val;
+            }
+            return null;
+        }
+
+        if (Level.equalsTo(first, second)) {
+            return 0;
+        }
+
+        return null;
+    }
+
+}
+
+/**
+ * A Coordinates position using at least latitude (lat) and longitude (lng).
+ * Optionnal fields are: altitude (alt) and level.
+ *
+ * Basic geo methods are directly accessibles from here:
+ * distanceTo, bearingTo, toEcef...
+ *
+ * /!\ This class has been adapted to use earth as a sphere and not as an ellipsoid
+ * /!\ So, this class does not stricly represent WGS84 coordinates anymore
+ * /!\ This modifications have been made for computational improvements.
+ */
+class Coordinates {
+
+    autoWrap = true;
+
+    constructor(lat, lng, alt, level) {
+        this.lat = lat;
+        this.lng = lng;
+        this.alt = alt;
+        this.level = level;
+        this._ecef = null;
+    }
+
+    get lat() {
+        return this._lat;
+    }
+
+    get latitude() {
+        return this._lat;
+    }
+
+    get lng() {
+        return this._lng;
+    }
+
+    get longitude() {
+        return this._lng;
+    }
+
+    /**
+     * alt does not denote the altitude of a point but its height from
+     *  the "level" field (if defined) or from the ground
+     */
+    get alt() {
+        return this._alt;
+    }
+
+    get level() {
+        return this._level;
+    }
+
+    set lat(lat) {
+        if (typeof lat === 'number' && Math.abs(lat) <= 90) {
+            this._lat = lat;
+        } else {
+            throw new Error('lat argument is not in [-90; 90]');
+        }
+        this._ecef = null;
+    }
+
+    set latitude(lat) {
+        throw new Error('Please use Coordinate#lat setter instead of Coordinate#latitude');
+    }
+
+    set lng(lng) {
+        if (typeof lng === 'number') {
+            this._lng = lng;
+            if (this.autoWrap) {
+                this.wrap();
+            }
+        } else {
+            throw new Error('lng argument is not a number');
+        }
+        this._ecef = null;
+    }
+
+    set longitude(lng) {
+        throw new Error('Please use Coordinate#lng setter instead of Coordinate#longitude');
+    }
+
+    set alt(alt) {
+        if (typeof alt === 'number') {
+            this._alt = alt;
+        } else {
+            if (typeof alt !== 'undefined' && alt !== null) {
+                throw new Error('alt argument is not a finite number');
+            }
+            this._alt = null;
+        }
+        this._ecef = null;
+    }
+
+    set level(level) {
+        if (level instanceof Level) {
+            this._level = level;
+        } else {
+            if (typeof level !== 'undefined' && level !== null) {
+                throw new Error('level argument is not a Level object');
+            }
+            this._level = null;
+        }
+    }
+
+    clone() {
+        const output = new Coordinates(this.lat, this.lng, this.alt);
+        if (this.level) {
+            output.level = this.level.clone();
+        }
+        return output;
+    }
+
+    wrap() {
+        if (this._lng <= -180 || this._lng > 180) {
+            this._lng = wrap(this._lng, -180, 180);
+        }
+    }
+
+    /**
+     * Compares two Coordinates
+     * @param {Coordinates} pos1 position 1
+     * @param {Coordinates} pos2 position 2
+     * @param {Number} eps latitude and longitude epsilon in degrees (default: 1e-8 [~1mm at lat=0])
+     * @param {Number} epsAlt altitude epsilon in meters (default: 1e-3 [= 1mm])
+     */
+    static equalsTo(pos1, pos2, eps = Constants.EPS_DEG_MM, epsAlt = Constants.EPS_MM) {
+
+        // Handle null comparison
+        if (pos1 === null && pos1 === pos2) {
+            return true;
+        }
+
+        if (!(pos1 instanceof Coordinates) || !(pos2 instanceof Coordinates)) {
+            return false;
+        }
+
+        return Math.abs(pos2.lat - pos1.lat) < eps
+            && Math.abs(pos2.lng - pos1.lng) < eps
+            && (pos1.alt === pos2.alt
+                || pos1.alt !== null && pos2.alt !== null
+                && Math.abs(pos2.alt - pos1.alt) < epsAlt)
+            && Level.equalsTo(pos1.level, pos2.level);
+    }
+
+    equalsTo(other) {
+        return Coordinates.equalsTo(this, other);
+    }
+
+    destinationPoint(distance, bearing, elevation) {
+        const newPoint = this.clone();
+        newPoint.move(distance, bearing, elevation);
+        return newPoint;
+    }
+
+    // Source: http://www.movable-type.co.uk/scripts/latlong.html#destPoint
+    move(distance, bearing, elevation) {
+
+        const dR = distance / Constants.R_MAJOR;
+        const cosDr = Math.cos(dR);
+        const sinDr = Math.sin(dR);
+
+        const phi1 = deg2rad(this.lat);
+        const lambda1 = deg2rad(this.lng);
+
+        const phi2 = Math.asin(
+            Math.sin(phi1) * cosDr
+            + Math.cos(phi1) * sinDr * Math.cos(bearing)
+        );
+        const lambda2 = lambda1 + Math.atan2(
+            Math.sin(bearing) * sinDr * Math.cos(phi1),
+            cosDr - Math.sin(phi1) * Math.sin(phi2)
+        );
+
+        this.lat = rad2deg(phi2);
+        this.lng = rad2deg(lambda2);
+
+        if (typeof elevation === 'number') {
+            if (this.alt === null) {
+                throw new Error('Point altitude is not defined');
+            }
+            this.alt += elevation;
+        }
+
+
+        return this;
+    }
+
+    /**
+     * Returns a distance between two points in meters
+     * @param  {Coordinates} location2 latitude / longitude point
+     * @return {Number} distance in meters
+     */
+    distanceTo(location2) {
+        const lat1 = this.lat;
+        const lng1 = this.lng;
+
+        const lat2 = location2.lat;
+        const lng2 = location2.lng;
+
+        const dlat = deg2rad(lat2 - lat1);
+        const dlng = deg2rad(lng2 - lng1);
+
+        const dlngsin = Math.sin(dlng / 2);
+        const dlatsin = Math.sin(dlat / 2);
+        const lat1rad = deg2rad(lat1);
+        const lat1cos = Math.cos(lat1rad);
+        const lat2rad = deg2rad(lat2);
+        const lat2cos = Math.cos(lat2rad);
+        const angle = dlatsin * dlatsin + lat1cos * lat2cos * dlngsin * dlngsin;
+
+        // arctangent
+        const tangy = Math.sqrt(angle);
+        const tangx = Math.sqrt(1 - angle);
+        const cosn = 2 * Math.atan2(tangy, tangx);
+
+        return Constants.R_MAJOR * cosn;
+    }
+
+    static distanceBetween(point1, point2) {
+        return point1.distanceTo(point2);
+    }
+
+    bearingTo(location2) {
+        const lat1 = deg2rad(this.lat);
+        const lat2 = deg2rad(location2.lat);
+        const diffLng = deg2rad(location2.lng - this.lng);
+
+        return Math.atan2(Math.sin(diffLng) * Math.cos(lat2),
+            Math.cos(lat1) * Math.sin(lat2) - Math.sin(lat1) * Math.cos(lat2) * Math.cos(diffLng));
+    }
+
+    static bearingTo(point1, point2) {
+        return point1.bearingTo(point2);
+    }
+
+
+    /**
+     * ECEF Transformations
+     * Here we used a light version of ECEF considering earth
+     * as a sphere instead of an ellipse
+     */
+
+    get enuToEcefRotation() {
+        const rot1 = Quaternion.fromAxisAngle([0, 0, 1], Math.PI / 2 + deg2rad(this.lng));
+        const rot2 = Quaternion.fromAxisAngle([1, 0, 0], Math.PI / 2 - deg2rad(this.lat));
+        return Quaternion.multiply(rot1, rot2);
+    }
+
+    get ecefToEnuRotation() {
+        const rot1 = Quaternion.fromAxisAngle([1, 0, 0], deg2rad(this.lat) - Math.PI / 2);
+        const rot2 = Quaternion.fromAxisAngle([0, 0, 1], -deg2rad(this.lng) - Math.PI / 2);
+        return Quaternion.multiply(rot1, rot2);
+    }
+
+    // https://gist.github.com/klucar/1536194
+    // Adapted for spherical formula
+    get ecef() {
+
+        if (!this._ecef) {
+            const lat = deg2rad(this.lat);
+            const lng = deg2rad(this.lng);
+            const alt = this.alt || 0;
+
+            const x = (Constants.R_MAJOR + alt) * Math.cos(lat) * Math.cos(lng);
+            const y = (Constants.R_MAJOR + alt) * Math.cos(lat) * Math.sin(lng);
+            const z = (Constants.R_MAJOR + alt) * Math.sin(lat);
+
+            this._ecef = [x, y, z];
+        }
+
+        return this._ecef;
+    }
+
+    static fromECEF(ecef) {
+
+        const x = ecef[0];
+        const y = ecef[1];
+        const z = ecef[2];
+
+        const p = Math.sqrt(x ** 2 + y ** 2);
+
+        let lng = Math.atan2(y, x);
+        const lat = Math.atan2(z, p);
+        const alt = p / Math.cos(lat) - Constants.R_MAJOR;
+
+        lng = lng % (2 * Math.PI);
+
+        const newPoint = new Coordinates(rad2deg(lat), rad2deg(lng), alt);
+        newPoint._ecef = ecef;
+        return newPoint;
+    }
+
+
+    // https://stackoverflow.com/questions/1299567/how-to-calculate-distance-from-a-point-to-a-line-segment-on-a-sphere
+    // Adapted to ECEF
+    getSegmentProjection(p1, p2) {
+
+        const a = Vector3.normalize(p1.ecef);
+        const b = Vector3.normalize(p2.ecef);
+        const c = Vector3.normalize(this.ecef);
+
+        const G = Vector3.cross(a, b);
+        if (Vector3.norm(G) === 0) {
+            return null;
+        }
+
+        const F = Vector3.cross(c, G);
+        const t = Vector3.normalize(Vector3.cross(G, F));
+
+        const posECEF = Vector3.multiplyScalar(t, Constants.R_MAJOR);
+        const poseCoordinates = Coordinates.fromECEF(posECEF);
+
+        // poseCoordinates.alt is not 0 here due to the ECEF transformation residual.
+        // So if p1.alt and p2.alt are defined we take the middle elevation between p1 and p2.
+        // Otherwise we remove alt from projection because the residual has no sense.
+        let alt;
+        if (p1.alt !== null && p2.alt !== null) {
+            // This formula is maybe not the best one.
+            alt = (p1.alt + p2.alt) / 2;
+        }
+        const projection = new Coordinates(poseCoordinates.lat, poseCoordinates.lng,
+            alt, Level.intersect(p1.level, p2.level));
+
+        if (Math.abs((p1.distanceTo(p2) - p1.distanceTo(projection) - p2.distanceTo(projection))) > Constants.EPS_MM) {
+            return null;
+        }
+
+        return projection;
+    }
+
+    /**
+     * Input / Output
+     */
+
+    toString() {
+        let str = '[' + this._lat.toFixed(7) + ', ' + this._lng.toFixed(7);
+        if (this._alt !== null) {
+            str += ', ' + this._alt.toFixed(2);
+        }
+        if (this._level !== null) {
+            str += ', [' + this._level.toString() + ']';
+        }
+        str += ']';
+        return str;
+    }
+
+    toJson() {
+        const output = {
+            lat: this.lat,
+            lng: this.lng
+        };
+        if (this.alt !== null) {
+            output.alt = this.alt;
+        }
+        if (this.level !== null) {
+            output.level = this.level.toString();
+        }
+        return output;
+    }
+
+    static fromJson(json) {
+        return new Coordinates(json.lat, json.lng, json.alt, Level.fromString(json.level));
+    }
+
+    toCompressedJson() {
+        const output = [this.lat, this.lng];
+        if (this.alt !== null || this.level !== null) {
+            output.push(this.alt);
+        }
+        if (this.level !== null) {
+            output.push(this.level.toString());
+        }
+        return output;
+    }
+
+    static fromCompressedJson(json) {
+        const coords = new Coordinates(json[0], json[1]);
+        if (json.length > 2) {
+            coords.alt = json[2];
+        }
+        if (json.length > 3) {
+            coords.level = Level.fromString(json[3]);
+        }
+        return coords;
+    }
+}
+
+/**
+ * A Coordinates User Position is a Coordinates position with specific data related to user (bearing, time, accuracy)
+ */
+class UserPosition extends Coordinates {
+
+    _time = null;
+    _accuracy = null;
+    _bearing = null;
+
+    constructor(lat, lng, alt, level, time, accuracy, bearing) {
+        super(lat, lng, alt, level);
+        this.time = time;
+        this.accuracy = accuracy;
+        this.bearing = bearing;
+    }
+
+    get time() {
+        return this._time;
+    }
+
+    set time(time) {
+        if (typeof time === 'number') {
+            this._time = time;
+        } else {
+            if (typeof time !== 'undefined' && time !== null) {
+                throw new Error('time argument is not a number');
+            }
+            this._time = null;
+        }
+    }
+
+
+    get accuracy() {
+        return this._accuracy;
+    }
+
+    set accuracy(accuracy) {
+        if (typeof accuracy === 'number' && accuracy >= 0) {
+            this._accuracy = accuracy;
+        } else {
+            if (typeof accuracy !== 'undefined' && accuracy !== null) {
+                throw new Error('accuracy argument is not a positive number');
+            }
+            this._accuracy = null;
+        }
+    }
+
+
+    get bearing() {
+        return this._bearing;
+    }
+
+    set bearing(bearing) {
+        if (typeof bearing === 'number') {
+            this._bearing = bearing % (2 * Math.PI);
+        } else {
+            if (typeof bearing !== 'undefined' && bearing !== null) {
+                throw new Error('bearing argument is not a number');
+            }
+            this._bearing = null;
+        }
+    }
+
+
+    // Create a UserPosition with lat, lng, alt from Coordinates coordinates and
+    //   other fields from another UserPosition
+    static fromCoordinates(coordinates) {
+        return new UserPosition(coordinates.lat, coordinates.lng,
+            coordinates.alt, coordinates.level);
+    }
+
+    clone() {
+        const cloned = UserPosition.fromCoordinates(super.clone());
+        cloned.time = this.time;
+        cloned.accuracy = this.accuracy;
+        cloned.bearing = this.bearing;
+        return cloned;
+    }
+
+
+    /**
+     * Compares two UserPosition
+     * @param {UserPosition} pos1 position 1
+     * @param {UserPosition} pos2 position 2
+     * @param {Number} eps latitude and longitude epsilon in degrees (default: 1e-8 [~1mm at lat=0])
+     * @param {Number} epsAlt altitude epsilon in meters (default: 1e-3 [= 1mm])
+     */
+    static equalsTo(pos1, pos2, eps = Constants.EPS_DEG_MM, epsAlt = Constants.EPS_MM) {
+
+        // Handle null comparison
+        if (pos1 === null && pos1 === pos2) {
+            return true;
+        }
+
+        if (!(pos1 instanceof UserPosition) || !(pos2 instanceof UserPosition)) {
+            return false;
+        }
+
+        if (!super.equalsTo(pos1, pos2, eps, epsAlt)) {
+            return false;
+        }
+
+        return pos1.time === pos2.time
+            && pos1.accuracy === pos2.accuracy
+            && pos1.bearing === pos2.bearing;
+    }
+
+    equalsTo(other) {
+        return UserPosition.equalsTo(this, other);
+    }
+
+
+    toJson() {
+        const output = super.toJson();
+        if (this.time !== null) {
+            output.time = this.time;
+        }
+        if (this.accuracy !== null) {
+            output.accuracy = this.accuracy;
+        }
+        if (this.bearing !== null) {
+            output.bearing = this.bearing;
+        }
+        return output;
+    }
+
+    static fromJson(json) {
+        const position = UserPosition.fromCoordinates(Coordinates.fromJson(json));
+        position.time = json.time;
+        position.accuracy = json.accuracy;
+        position.bearing = json.bearing;
+        return position;
+    }
+}
+
+/* eslint-disable max-statements */
+
+/**
+ * Sample a route of Coordinates
+ * @param {Array.<Coordinates>} route ordered points
+ * @param {*} stepSize step size to sample
+ * @param {*} maxLength max route length to sample
+ */
+function sampleRoute(route, stepSize = 0.7, startSampling = 0, length = Number.MAX_VALUE) {
+
+    const endSampling = startSampling + length;
+
+    const sampledRoute = [];
+
+    let lastSample = null;
+
+    let totalDistanceTraveled = 0;
+    let distanceToNextSample;
+    let startFound = false;
+
+    for (let segmentIndex = 0; segmentIndex < route.length - 1; segmentIndex++) {
+
+        const p1 = route[segmentIndex];
+        const p2 = route[segmentIndex + 1];
+        const segmentSize = p1.distanceTo(p2);
+        const segmentBearing = p1.bearingTo(p2);
+
+        let distanceTraveledOnSegment = 0;
+
+        if (!startFound) {
+            if (startSampling < totalDistanceTraveled + segmentSize) {
+                startFound = true;
+                distanceToNextSample = startSampling - totalDistanceTraveled;
+            } else {
+                totalDistanceTraveled += segmentSize;
+                continue;
+            }
+        }
+
+        lastSample = p1;
+        while (distanceTraveledOnSegment + distanceToNextSample < segmentSize
+            && totalDistanceTraveled + distanceToNextSample <= endSampling) {
+
+            const newPoint = lastSample.destinationPoint(distanceToNextSample, segmentBearing);
+            newPoint.bearing = segmentBearing;
+            sampledRoute.push(newPoint);
+            lastSample = newPoint;
+
+            distanceTraveledOnSegment += distanceToNextSample;
+            totalDistanceTraveled += distanceToNextSample;
+            distanceToNextSample = stepSize;
+        }
+
+        if (totalDistanceTraveled + distanceToNextSample > endSampling) {
+            break;
+        }
+
+        const rest = segmentSize - distanceTraveledOnSegment;
+        totalDistanceTraveled += rest;
+        distanceToNextSample -= rest;
+    }
+
+    return sampledRoute;
+}
+
+/**
+ * Trim a route of Coordinates
+ * @param {Array.<Coordinates>} route ordered points
+ * @param {Coordinates} startPosition position where the trim starts. startPosition has to be on the route.
+ * @param {*} maxLength max route length
+ */
+function trimRoute(route, startPosition = route[0], length = Number.MAX_VALUE) {
+
+    const newRoute = [];
+    let previousPoint;
+
+    let currentPointIndex;
+    let cumulativeDistance = 0;
+
+    for (currentPointIndex = 1; currentPointIndex < route.length; currentPointIndex++) {
+
+        const p1 = route[currentPointIndex - 1];
+        const p2 = route[currentPointIndex];
+
+        if (Coordinates.equalsTo(startPosition, p1)) {
+            newRoute.push(p1);
+            previousPoint = p1;
+            break;
+        }
+
+        const proj = startPosition.getSegmentProjection(p1, p2);
+        if (proj && Coordinates.equalsTo(startPosition, proj) && !proj.equalsTo(p2)) {
+            newRoute.push(proj);
+            previousPoint = proj;
+            break;
+        }
+    }
+
+    if (!newRoute.length) {
+        throw new Error('startPosition is not on the route');
+    }
+
+    while (currentPointIndex < route.length) {
+        const currentPoint = route[currentPointIndex];
+        const dist = previousPoint.distanceTo(currentPoint);
+        if (cumulativeDistance + dist >= length
+            || Math.abs(cumulativeDistance + dist - length) <= Constants.EPS_MM) {
+            const bearing = previousPoint.bearingTo(currentPoint);
+            const remainingLength = length - cumulativeDistance;
+            const end = previousPoint.destinationPoint(remainingLength, bearing);
+            newRoute.push(end);
+            break;
+        }
+        newRoute.push(currentPoint);
+        previousPoint = currentPoint;
+        cumulativeDistance += dist;
+        currentPointIndex++;
+    }
+
+    return newRoute;
+}
+
+/**
+ * @param {Coordinates[]} coords
+ * @param {number} precision
+ * @returns {Coordinates[]}
+ */
+function simplifyRoute(coords, precisionAngle = deg2rad(5)) {
+
+    const isClosed = (coords[0].equalsTo(coords[coords.length - 1]));
+
+    let newRoute = coords.slice(0, coords.length - (isClosed ? 1 : 0));
+
+    const len = newRoute.length;
+    for (let i = isClosed ? 0 : 1; i < len; i++) {
+
+        const p0 = coords[positiveMod(i - 1, len)];
+        const p1 = coords[i];
+        const p2 = coords[positiveMod(i + 1, len)];
+
+        const seg1Dir = p0.bearingTo(p1);
+        const seg2Dir = p1.bearingTo(p2);
+
+        if (Math.abs(seg2Dir - seg1Dir) < precisionAngle) {
+            newRoute = newRoute.filter(coord => coord !== p1);
+        }
+    }
+
+    if (isClosed) {
+        newRoute.push(newRoute[0]);
+    }
+
+    return newRoute;
+}
+
+/**
+ * @param {GeolocationPosition} geolocationPosition
+ * @returns {UserPosition}
+ */
+function geolocationPositionToUserPosition(geolocationPosition) {
+    if (geolocationPosition === null) {
+        return null;
+    }
+
+    const { latitude, longitude, accuracy, heading } = geolocationPosition.coords;
+
+    const userPosition = new UserPosition(latitude, longitude);
+    userPosition.time = geolocationPosition.timestamp;
+    userPosition.accuracy = accuracy;
+    userPosition.bearing = heading ? deg2rad(heading) : null;
+    return userPosition;
+}
+
+var Utils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    sampleRoute: sampleRoute,
+    trimRoute: trimRoute,
+    simplifyRoute: simplifyRoute,
+    geolocationPositionToUserPosition: geolocationPositionToUserPosition
+});
+
+class BoundingBox {
+
+    northEast;
+    southWest;
+
+    constructor(northEast, southWest) {
+        this.northEast = northEast || null;
+        this.southWest = southWest || null;
+
+        if (this.northEast && this.southWest && this.getNorth() < this.getSouth()) {
+            throw new Error('Incorrect bounding box');
+        }
+    }
+
+    /**
+     * Returns the geographical coordinate equidistant from the bounding box's corners.
+     *
+     * @returns {Coordinates} The bounding box's center.
+     */
+    get center() {
+        const latCenter = (this.southWest.lat + this.northEast.lat) / 2;
+        const lngCenter = (this.northEast.lng + this.southWest.lng) / 2;
+        return new Coordinates(latCenter, lngCenter);
+    }
+
+    /**
+     * Check if a point is contained in the bounding box.
+     *
+     * @returns {Coordinates} The point to analyze.
+     */
+    contains(point) {
+        return point.lat <= this.northEast.lat
+            && point.lat >= this.southWest.lat
+            && point.lng <= this.northEast.lng
+            && point.lng >= this.southWest.lng;
+    }
+
+    /**
+     * Extend the bounds to include a given LngLat or LngLatBounds.
+     *
+     * @param {Coordinates|BoundingBox} obj object to extend to
+     * @returns {BoundingBox} `this`
+     */
+    extend(obj) {
+        const sw = this.southWest,
+            ne = this.northEast;
+        let sw2, ne2;
+
+        if (obj instanceof Coordinates) {
+            sw2 = obj;
+            ne2 = obj;
+
+        } else if (obj instanceof BoundingBox) {
+            sw2 = obj.southWest;
+            ne2 = obj.northEast;
+
+            if (!sw2 || !ne2) {
+                return this;
+            }
+        } else {
+            throw new Error('Unknown parameter');
+        }
+
+        if (!sw && !ne) {
+            this.southWest = new Coordinates(sw2.lat, sw2.lng);
+            this.northEast = new Coordinates(ne2.lat, ne2.lng);
+
+        } else {
+            this.southWest = new Coordinates(
+                Math.min(sw2.lat, sw.lat),
+                Math.min(sw2.lng, sw.lng)
+            );
+            this.northEast = new Coordinates(
+                Math.max(ne2.lat, ne.lat),
+                Math.max(ne2.lng, ne.lng)
+            );
+        }
+
+        return this;
+    }
+
+    /**
+     * This method extends the bounding box with a value in meters
+     * /*\ This method is not precise as distance differs in function of latitude
+     * @param {!number} measure in meters
+     */
+    extendsWithMeasure(measure) {
+
+        if (typeof measure !== 'number') {
+            throw new Error('measure is not a number');
+        }
+
+        this.northEast = this.northEast
+            .destinationPoint(measure, 0)
+            .move(measure, Math.PI / 2);
+
+        this.southWest = this.southWest.clone()
+            .destinationPoint(measure, -Math.PI / 2)
+            .destinationPoint(measure, Math.PI);
+
+        return this;
+    }
+
+    /**
+     * Returns bounds created by extending or retracting the current bounds by a given ratio in each direction.
+     * For example, a ratio of 0.5 extends the bounds by 50% in each direction.
+     * Negative values will retract the bounds.
+     * @param {Number} bufferRatio
+     * @returns {BoundingBox} `this`
+     */
+    pad(bufferRatio) {
+        const sw = this.southWest;
+        const ne = this.northEast;
+
+        const heightBuffer = Math.abs(sw.lat - ne.lat) * bufferRatio;
+        const widthBuffer = Math.abs(sw.lng - ne.lng) * bufferRatio;
+
+        this.southWest = new Coordinates(sw.lat - heightBuffer, sw.lng - widthBuffer);
+        this.northEast = new Coordinates(ne.lat + heightBuffer, ne.lng + widthBuffer);
+
+        return this;
+    }
+
+    /**
+     * Returns the southwest corner of the bounding box.
+     *
+     * @returns {Coordinates} The southwest corner of the bounding box.
+     */
+    getSouthWest() {
+        return this.southWest;
+    }
+
+    /**
+    * Returns the northeast corner of the bounding box.
+    *
+    * @returns {Coordinates} The northeast corner of the bounding box.
+     */
+    getNorthEast() {
+        return this.northEast;
+    }
+
+    /**
+    * Returns the northwest corner of the bounding box.
+    *
+    * @returns {Coordinates} The northwest corner of the bounding box.
+     */
+    getNorthWest() {
+        return new Coordinates(this.getNorth(), this.getWest());
+    }
+
+    /**
+    * Returns the southeast corner of the bounding box.
+    *
+    * @returns {LngLat} The southeast corner of the bounding box.
+     */
+    getSouthEast() {
+        return new Coordinates(this.getSouth(), this.getEast());
+    }
+
+    /**
+    * Returns the west edge of the bounding box.
+    *
+    * @returns {number} The west edge of the bounding box.
+     */
+    getWest() {
+        return this.southWest.lng;
+    }
+
+    /**
+    * Returns the south edge of the bounding box.
+    *
+    * @returns {number} The south edge of the bounding box.
+     */
+    getSouth() {
+        return this.southWest.lat;
+    }
+
+    /**
+    * Returns the east edge of the bounding box.
+    *
+    * @returns {number} The east edge of the bounding box.
+     */
+    getEast() {
+        return this.northEast.lng;
+    }
+
+    /**
+    * Returns the north edge of the bounding box.
+    *
+    * @returns {number} The north edge of the bounding box.
+     */
+    getNorth() {
+        return this.northEast.lat;
+    }
+
+    static equalsTo(bb1, bb2) {
+        return Coordinates.equalsTo(bb1.northEast, bb2.northEast)
+            && Coordinates.equalsTo(bb1.southWest, bb2.southWest);
+    }
+
+    equalsTo(other) {
+        return BoundingBox.equalsTo(this, other);
+    }
+
+    /**
+     * Create a BoundingBox from a WSEN array
+     * @param {Number[4]} bounds a WSEN array
+     * @returns {BoundingBox} the corresponding BoundingBox
+     */
+    static fromArray(bounds) {
+        return new BoundingBox(
+            new Coordinates(bounds[3], bounds[2]),
+            new Coordinates(bounds[1], bounds[0])
+        );
+    }
+
+    /**
+     * Returns the WSEN array
+     * @returns {Number[4]} the WSEN array
+     */
+    toArray() {
+        return [this.getWest(), this.getSouth(), this.getEast(), this.getNorth()];
+    }
+}
+
+class RelativePosition {
+
+    _x = 0;
+    _y = 0;
+    _z = 0;
+    _time = null;
+    _accuracy = null;
+    _bearing = null;
+
+    constructor(x, y, z, time, accuracy, bearing) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.time = time;
+        this.accuracy = accuracy;
+        this.bearing = bearing;
+    }
+
+    get x() {
+        return this._x;
+    }
+
+    set x(x) {
+        if (typeof x === 'number') {
+            this._x = x;
+        } else {
+            throw new Error('x argument is not a number');
+        }
+    }
+
+    get y() {
+        return this._y;
+    }
+
+    set y(y) {
+        if (typeof y === 'number') {
+            this._y = y;
+        } else {
+            throw new Error('y argument is not a number');
+        }
+    }
+
+    get z() {
+        return this._z;
+    }
+
+    set z(z) {
+        if (typeof z === 'number') {
+            this._z = z;
+        } else {
+            throw new Error('z argument is not a number');
+        }
+    }
+
+    get time() {
+        return this._time;
+    }
+
+    set time(time) {
+        if (typeof time === 'number') {
+            this._time = time;
+        } else {
+            if (typeof time !== 'undefined' && time !== null) {
+                throw new Error('time argument is not a number');
+            }
+            this._time = null;
+        }
+    }
+
+
+    get accuracy() {
+        return this._accuracy;
+    }
+
+    set accuracy(accuracy) {
+        if (typeof accuracy === 'number' && accuracy >= 0) {
+            this._accuracy = accuracy;
+        } else {
+            if (typeof accuracy !== 'undefined' && accuracy !== null) {
+                throw new Error('accuracy argument is not a positive number');
+            }
+            this._accuracy = null;
+        }
+    }
+
+
+    get bearing() {
+        return this._bearing;
+    }
+
+    set bearing(bearing) {
+        if (typeof bearing === 'number') {
+            this._bearing = bearing % (2 * Math.PI);
+        } else {
+            if (typeof bearing !== 'undefined' && bearing !== null) {
+                throw new Error('bearing argument is not a number');
+            }
+            this._bearing = null;
+        }
+    }
+
+    clone() {
+        return new RelativePosition(this.x, this.y, this.z, this.time, this.accuracy, this.bearing);
+    }
+
+
+    /**
+     * Compares two RelativePosition
+     * @param {RelativePosition} pos1 position 1
+     * @param {RelativePosition} pos2 position 2
+     * @param {Number} eps x, y, z epsilon in meters (default: 1e-3 [= 1mm])
+     */
+    static equalsTo(pos1, pos2, eps = Constants.EPS_MM) {
+
+        // Handle null comparison
+        if (pos1 === null && pos1 === pos2) {
+            return true;
+        }
+
+        if (!(pos1 instanceof RelativePosition) || !(pos2 instanceof RelativePosition)) {
+            return false;
+        }
+
+        return Math.abs(pos2.x - pos1.x) < eps
+            && Math.abs(pos2.y - pos1.y) < eps
+            && Math.abs(pos2.z - pos1.z) < eps
+            && pos1.time === pos2.time
+            && pos1.accuracy === pos2.accuracy
+            && pos1.bearing === pos2.bearing;
+    }
+
+    equalsTo(other) {
+        return RelativePosition.equalsTo(this, other);
+    }
+
+
+    toJson() {
+        const output = {
+            x: this.x,
+            y: this.y,
+            z: this.z
+        };
+
+        if (this.time !== null) {
+            output.time = this.time;
+        }
+        if (this.accuracy !== null) {
+            output.accuracy = this.accuracy;
+        }
+        if (this.bearing !== null) {
+            output.bearing = this.bearing;
+        }
+        return output;
+    }
+
+    static fromJson(json) {
+        return new RelativePosition(json.x, json.y, json.z, json.time, json.accuracy, json.bearing);
+    }
+}
+
+/**
+ * Position is defined in EUS (East-Up-South) frame with: x pointing to East, y pointing to Up, z pointing to South
+ * This frame is close to ThreeJS / OpenGL frame.
+ */
+class GeoRelativePosition extends RelativePosition { }
+
+class Attitude {
+
+    _quaternion = [1, 0, 0, 0];
+    _heading = null;
+    _eulerAngles = null;
+    _time = null;
+    _accuracy = null;
+
+    /**
+     *
+     * @param {number[]} quaternion
+     * @param {number} time
+     * @param {number} accuracy
+     */
+    constructor(quaternion, time, accuracy) {
+        this.quaternion = quaternion;
+        this.time = time;
+        this.accuracy = accuracy;
+    }
+
+    static unitary() {
+        return new Attitude([1, 0, 0, 0]);
+    }
+
+    /**
+     * @returns {number[]}
+     */
+    get quaternion() {
+        return this._quaternion;
+    }
+
+    /**
+     * @param {number[]} quaternion
+     */
+    set quaternion(quaternion) {
+        if (!Array.isArray(quaternion)
+            || quaternion.length !== 4
+            || Math.abs(1 - Quaternion.norm(quaternion)) > 1e-4) {
+            throw new Error('quaternion is not a unit quaternion');
+        }
+        this._quaternion = quaternion;
+        this._heading = null;
+        this._eulerAngles = null;
+    }
+
+    /**
+     * @returns {number}
+     */
+    get time() {
+        return this._time;
+    }
+
+    /**
+     * @param {number} time
+     */
+    set time(time) {
+        if (typeof time === 'number') {
+            this._time = time;
+        } else {
+            if (typeof time !== 'undefined' && time !== null) {
+                throw new Error('time argument is not a number');
+            }
+            this._time = null;
+        }
+    }
+
+    /**
+     * @returns {number}
+     */
+    get accuracy() {
+        return this._accuracy;
+    }
+
+    /**
+     * @param {number} accuracy
+     */
+    set accuracy(accuracy) {
+        if (typeof accuracy === 'number' && accuracy >= 0 && accuracy <= Math.PI) {
+            this._accuracy = accuracy;
+        } else {
+            if (typeof accuracy !== 'undefined' && accuracy !== null) {
+                throw new Error('accuracy argument (' + accuracy + ') is not in range [0; PI]');
+            }
+            this._accuracy = null;
+        }
+    }
+
+    /** @type {number[]} */
+    get eulerAngles() {
+        if (this._eulerAngles === null) {
+            this._eulerAngles = Rotations.quaternionToEulerZXY(this.quaternion);
+        }
+        return this._eulerAngles;
+    }
+
+    /** @type {number[]} */
+    get eulerAnglesDegrees() {
+        return this.eulerAngles.map(x => rad2deg(x));
+    }
+
+    /** @type {number} */
+    get heading() {
+        if (this._heading === null) {
+            let offset = 0;
+            if (typeof (window) !== 'undefined' && window && window.orientation) {
+                offset = deg2rad(window.orientation);
+            }
+            this._heading = Rotations.getHeadingFromQuaternion(this.quaternion) + offset;
+        }
+        return this._heading;
+    }
+
+    /** @type {number} */
+    get headingDegrees() {
+        return rad2deg(this.heading);
+    }
+
+    /**
+     * Compares two Attitude
+     * @param {Attitude} att1 attitude 1
+     * @param {Attitude} att2 attitude 2
+     */
+    static equalsTo(att1, att2) {
+
+        // Handle null comparison
+        if (att1 === null && att1 === att2) {
+            // TODO not sure to return true here.
+            return true;
+        }
+
+        if (!(att1 instanceof Attitude) || !(att2 instanceof Attitude)) {
+            return false;
+        }
+
+        if (att1 === att2) {
+            return true;
+        }
+
+        return Quaternion.equalsTo(att1.quaternion, att2.quaternion);
+    }
+
+    /**
+     * @param {Attitude} other
+     * @returns {boolean}
+     */
+    equalsTo(other) {
+        return Attitude.equalsTo(this, other);
+    }
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        return this.quaternion;
+    }
+
+    /**
+     * @param {object} json
+     * @returns {Attitude}
+     */
+    static fromJson(json) {
+        return new Attitude(json);
+    }
+
+    /**
+     * @returns {Attitude}
+     */
+    clone() {
+        return new Attitude(this.quaternion.slice(0), this.time, this.accuracy);
+    }
+}
+
+class AbsoluteHeading {
+
+    _heading = null;
+    _time = null;
+    _accuracy = null;
+
+    /**
+     *
+     * @param {Number} heading
+     * @param {Number} time
+     * @param {Number} accuracy
+     */
+    constructor(heading, time, accuracy) {
+        this.heading = heading;
+        this.time = time;
+        this.accuracy = accuracy;
+    }
+
+    /**
+     * @returns {Number}
+     */
+    get heading() {
+        return this._heading;
+    }
+
+    /**
+     * @param {Number} heading
+     */
+    set heading(heading) {
+        if (typeof heading === 'number') {
+            this._heading = heading;
+        } else {
+            throw new Error('heading argument is not a number');
+        }
+    }
+
+    /**
+     * @returns {Number}
+     */
+    get time() {
+        return this._time;
+    }
+
+    /**
+     * @param {Number} time
+     */
+    set time(time) {
+        if (typeof time === 'number') {
+            this._time = time;
+        } else {
+            if (typeof time !== 'undefined' && time !== null) {
+                throw new Error('time argument is not a number');
+            }
+            this._time = null;
+        }
+    }
+
+    /**
+     * @returns {Number}
+     */
+    get accuracy() {
+        return this._accuracy;
+    }
+
+    /**
+     * @param {Number} accuracy
+     */
+    set accuracy(accuracy) {
+        if (typeof accuracy === 'number' && accuracy >= 0 && accuracy <= Math.PI) {
+            this._accuracy = accuracy;
+        } else {
+            if (typeof accuracy !== 'undefined' && accuracy !== null) {
+                throw new Error('accuracy argument (' + accuracy + ') is not in range [0; PI]');
+            }
+            this._accuracy = null;
+        }
+    }
+
+    /**
+     * @returns {Attitude}
+     */
+    toAttitude() {
+        /**
+         * Heading is given around z-axis in NED frame and our attitude in ENU frame, that is why
+         *  -1* is applied to heading.
+         */
+        return new Attitude(
+            Quaternion.fromAxisAngle([0, 0, 1], -this.heading),
+            this.time,
+            this.accuracy
+        );
+    }
+
+
+    /**
+     * Compares two AbsoluteHeading
+     * @param {AbsoluteHeading} heading1 heading 1
+     * @param {AbsoluteHeading} heading2 heading 2
+     */
+    static equalsTo(heading1, heading2) {
+
+        // Handle null comparison
+        if (heading1 === null && heading1 === heading2) {
+            return true;
+        }
+
+        if (!(heading1 instanceof AbsoluteHeading) || !(heading2 instanceof AbsoluteHeading)) {
+            return false;
+        }
+
+        return Math.abs(heading1.heading - heading2.heading) < 1e-8;
+    }
+
+    equalsTo(other) {
+        return AbsoluteHeading.equalsTo(this, other);
+    }
+
+    toJson() {
+        const output = { heading: this.heading };
+        if (this.accuracy !== null) {
+            output.accuracy = this.accuracy;
+        }
+        if (this.time !== null) {
+            output.time = this.time;
+        }
+        return output;
+    }
+
+    static fromJson({
+        heading, time, accuracy
+    }) {
+        return new AbsoluteHeading(heading, time, accuracy);
+    }
+
+    clone() {
+        return new AbsoluteHeading(this.heading, this.time, this.accuracy);
+    }
+}
+
+/**
+ * @template T
+ */
+class GraphNode {
+
+    /** @type {Coordinates} */
+    _coords;
+
+    /** @type {Edge<T>[]} */
+    edges = [];
+
+    /** @type {?T} */
+    builtFrom = null;
+
+    /**
+     * @param {Coordinates} coords
+     * @param {T} builtFrom
+     */
+    constructor(coords, builtFrom = null) {
+        this.coords = coords;
+        this.builtFrom = builtFrom;
+        this.edges = [];
+    }
+
+    /** @type {!Coordinates} */
+    get coords() {
+        return this._coords;
+    }
+
+    /** @type {!Coordinates} */
+    set coords(coords) {
+        if (!(coords instanceof Coordinates)) {
+            throw new Error('coords is not a Coordinates');
+        }
+        this._coords = coords;
+    }
+
+    /**
+     * @param {GraphNode} other
+     * @returns {number}
+     */
+    distanceTo(other) {
+        return this.coords.distanceTo(other.coords);
+    }
+
+    /**
+     * @param {GraphNode} other
+     * @returns {number}
+     */
+    bearingTo(other) {
+        return this.coords.bearingTo(other.coords);
+    }
+
+    /**
+     * @param {GraphNode} other
+     * @returns {boolean}
+     */
+    equalsTo(other) {
+        return this.coords.equalsTo(other.coords)
+            && this.builtFrom === other.builtFrom;
+    }
+
+    /**
+     * @returns {GraphNode}
+     */
+    clone() {
+        const node = new GraphNode(this.coords);
+        node.edges = this.edges.slice(0);
+        node.builtFrom = this.builtFrom;
+        return node;
+    }
+
+    /**
+     * Does not include "edges" and "builtFrom" properties
+     * @returns {object}
+     */
+    toJson() {
+        return this.coords.toCompressedJson();
+    }
+
+    /**
+     * @template T
+     * @returns {GraphNode<T>}
+     */
+    static fromJson(json) {
+        return new GraphNode(Coordinates.fromCompressedJson(json));
+    }
+
+    generateLevelFromEdges() {
+        let tmpLevel;
+        for (let i = 0; i < this.edges.length; i++) {
+            const edge = this.edges[i];
+            if (edge.level) {
+                if (!tmpLevel) {
+                    tmpLevel = edge.level.clone();
+                } else {
+                    tmpLevel = tmpLevel.intersect(edge.level);
+                    if (!tmpLevel) {
+                        Logger.error('Error: Something bad happend during parsing: We cannot retrieve node level from adjacent ways: ' + this.coords);
+                        return false;
+                    }
+                }
+            }
+        }
+        this.coords.level = tmpLevel;
+        return true;
+    }
+
+
+    /**
+     * We suppose generateLevelFromEdges() was called before
+     */
+    inferNodeLevelByRecursion() {
+        const { level } = this.coords;
+        if (!level || !level.isRange) {
+            return true;
+        }
+
+        /**
+         * We can infer node level only if this one have one edge attached
+         */
+        if (this.edges.length > 1) {
+            return true;
+        }
+
+        /**
+         * This method looks for single level nodes recursively from a multi-level node
+         * The result of this method is an union of all single level nodes found.
+         * @param {GraphNode} node node to explore
+         * @param {GraphNode[]} visitedNodes list of visited nodes
+         */
+        const lookForLevel = (node, visitedNodes) => {
+
+            visitedNodes.push(node);
+
+            if (!node.coords.level) {
+                return null;
+            }
+
+            if (!node.coords.level.isRange) {
+                return node.coords.level;
+            }
+
+            let tmpLevel = null;
+            for (let i = 0; i < node.edges.length; i++) {
+                const edge = node.edges[i];
+                const otherNode = edge.node1 === node ? edge.node2 : edge.node1;
+                if (!visitedNodes.includes(otherNode)) {
+                    tmpLevel = Level.union(lookForLevel(otherNode, visitedNodes), tmpLevel);
+                }
+            }
+            return tmpLevel;
+        };
+
+        const othersLevels = lookForLevel(this, []);
+
+        if (othersLevels !== null) {
+            if (!othersLevels.isRange) {
+                this.coords.level = new Level(othersLevels.val === level.low ? level.up : level.low);
+                return true;
+            }
+            Logger.warn('Level of: ' + this.coords.toString() + ' cannot be decided');
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * We suppose generateLevelFromEdges() was called before
+     */
+    inferNodeLevelByNeighboors() {
+        const { level } = this.coords;
+        if (!level || !level.isRange) {
+            return true;
+        }
+
+        let tmpLevel = null;
+        for (let i = 0; i < this.edges.length; i++) {
+            const edge = this.edges[i];
+            const otherNode = edge.node1 === this ? edge.node2 : edge.node1;
+            tmpLevel = Level.union(otherNode.coords.level, tmpLevel);
+        }
+
+        if (tmpLevel === null || !tmpLevel.isRange) {
+            this.coords.level = new Level(tmpLevel.val === level.low ? level.up : level.low);
+        }
+
+        return true;
+    }
+
+    /**
+     * @param {GraphNode[]} nodes
+     */
+    static generateNodesLevels(nodes) {
+        const success = nodes.reduce((acc, node) => acc && node.generateLevelFromEdges(), true);
+        if (!success) {
+            return false;
+        }
+
+        // In some cases, node levels cannot be retrieve just using adjacent edges
+        // (e.g stairs without network at one of its bounds)
+        // To infer this node level, we use inferNodeLevelByRecursion()
+        return nodes.reduce((acc, node) => acc
+            && node.inferNodeLevelByNeighboors()
+            && node.inferNodeLevelByRecursion()
+        , true);
+    }
+}
+
+/**
+ * @template T
+ *
+ * An Edge is a segment composed of two Node
+ * An edge is mostly issued from an OsmWay, but this is not always the case.
+ * For example, edges created by mapmatching.
+ */
+class GraphEdge {
+
+    /** @type {GraphNode<T>} */
+    _node1 = null;
+
+    /** @type {GraphNode<T>} */
+    _node2 = null;
+
+    /** @type {?Level} */
+    _level = null;
+
+    /** @type {?number} */
+    _bearing;
+
+    /** @type {?number} */
+    _length;
+
+    /** @type {boolean} */
+    _computedSizeAndBearing = false;
+
+    /** @type {?T} */
+    builtFrom = null;
+
+    /** @type {boolean} */
+    isOneway = false;
+
+    /**
+     * @param {!GraphNode} node1
+     * @param {!GraphNode} node2
+     * @param {?Level} level
+     * @param {?T} builtFrom
+     * @param {?string} name
+     */
+    constructor(node1, node2, level = null, builtFrom = null) {
+        this.node1 = node1;
+        this.node2 = node2;
+        this.level = level;
+        this.builtFrom = builtFrom;
+    }
+
+    /** @type {!GraphNode<T>} */
+    get node1() {
+        return this._node1;
+    }
+
+    /** @type {!GraphNode<T>} */
+    set node1(node) {
+
+        if (!(node instanceof GraphNode)) {
+            throw new TypeError('node1 is not a GraphNode');
+        }
+
+        if (this._node1 !== null && this._node2 !== this._node1) {
+            this._node1.edges = this._node1.edges.filter(edge => edge !== this);
+        }
+
+        node.edges.push(this);
+
+        this._node1 = node;
+        this._computedSizeAndBearing = false;
+    }
+
+    /** @type {!GraphNode<T>} */
+    get node2() {
+        return this._node2;
+    }
+
+    /** @type {!GraphNode<T>} */
+    set node2(node) {
+
+        if (!(node instanceof GraphNode)) {
+            throw new TypeError('node2 is not a GraphNode');
+        }
+
+        if (this._node2 !== null && this._node2 !== this._node1) {
+            this._node2.edges = this._node2.edges.filter(edge => edge !== this);
+        }
+
+        node.edges.push(this);
+
+        this._node2 = node;
+        this._computedSizeAndBearing = false;
+    }
+
+    /** @type {?Level} */
+    get level() {
+        return this._level;
+    }
+
+    /** @type {?Level} */
+    set level(level) {
+        if (level instanceof Level) {
+            this._level = level;
+        } else {
+            if (typeof level !== 'undefined' && level !== null) {
+                throw new Error('level argument is not a Level object');
+            }
+            this._level = null;
+        }
+    }
+
+    /**
+     * Get edge bearing from node1 to node2
+     * @type {number}
+     */
+    get bearing() {
+        if (!this._computedSizeAndBearing) {
+            this._computeSizeAndBearing();
+        }
+        return this._bearing;
+    }
+
+    /**
+     * get edge length
+     * @type {number}
+     */
+    get length() {
+        if (!this._computedSizeAndBearing) {
+            this._computeSizeAndBearing();
+        }
+        return this._length;
+    }
+
+    _computeSizeAndBearing() {
+        this._length = this.node1.distanceTo(this.node2);
+        this._bearing = this.node1.bearingTo(this.node2);
+        this._computedSizeAndBearing = true;
+    }
+
+    /**
+     * @param {GraphEdge<T>} other
+     * @returns {boolean}
+     */
+    equalsTo(other) {
+
+        if (this === other) {
+            return true;
+        }
+
+        if (!(other instanceof GraphEdge)) {
+            return false;
+        }
+
+        return other.node1.equalsTo(this.node1)
+            && other.node2.equalsTo(this.node2)
+            && Level.equalsTo(other.level, this.level)
+            && other.isOneway === this.isOneway
+            && other.builtFrom === this.builtFrom;
+    }
+
+    /**
+     * @returns {GraphEdge<T>}
+     */
+    clone() {
+        const edge = new GraphEdge(this.node1, this.node2);
+        edge.level = this.level;
+        edge.isOneway = this.isOneway;
+        edge.builtFrom = this.builtFrom;
+        return edge;
+    }
+
+}
+
+/**
+ * @template T
+ * @param {GraphEdge<T>[]} edges
+ * @param {GraphNode<T>} node1
+ * @param {GraphNode<T>} node2
+ * @returns {?GraphEdge<T>}
+ */
+function getEdgeByNodes(edges, node1, node2) {
+    return edges.find(edge =>
+        node1 === edge.node1 && node2 === edge.node2
+        || node2 === edge.node1 && node1 === edge.node2
+    );
+}
+
+var GraphUtils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getEdgeByNodes: getEdgeByNodes
+});
+
+/**
+ * @template T
+ *
+ * A typical network with nodes (Node) and edges (Edge)
+ */
+class Network {
+
+    /** @type {GraphNode<T>[]} */
+    nodes;
+
+    /** @type {GraphEdge<T>[]} */
+    edges;
+
+    /**
+     * @template T
+     * @param {GraphNode<T>[]} nodes
+     * @param {GraphEdge<T>[]} edges
+     */
+    constructor(nodes, edges) {
+        this.nodes = Array.isArray(nodes) ? nodes : [];
+        this.edges = Array.isArray(edges) ? edges : [];
+    }
+
+    /**
+     * @template T
+     * @param {Coordinates} coords
+     * @returns {?GraphNode<T>}
+     */
+    getNodeByCoords(coords) {
+        return this.nodes.find(node => node.coords.equalsTo(coords));
+    }
+
+    /**
+     * @template T
+     * @param {GraphNode<T>} node1
+     * @param {GraphNode<T>} node2
+     * @returns {?GraphEdge<T>}
+     */
+    getEdgeByNodes(node1, node2) {
+        return getEdgeByNodes(this.edges, node1, node2);
+    }
+
+
+    /**
+     * @param {?number} extendedMeasure
+     * @returns {BoundingBox}
+     */
+    getBoundingBox(extendedMeasure) {
+        const boundingBox = this.nodes.reduce(
+            (acc, node) => acc.extend(node.coords), new BoundingBox()
+        );
+        if (extendedMeasure) {
+            boundingBox.extendsWithMeasure(extendedMeasure);
+        }
+        return boundingBox;
+    }
+
+    /**
+     * @param {function} _nodeToStringFn
+     * @param {function} _edgeToStringFn
+     * @returns {string}
+     */
+    toDetailedString(_nodeToStringFn, _edgeToStringFn) {
+
+        let nodeToStringFn = _nodeToStringFn;
+        if (!nodeToStringFn) {
+            nodeToStringFn = node => `${node.builtFrom}`;
+        }
+
+        let edgeToStringFn = _edgeToStringFn;
+        if (!_edgeToStringFn) {
+            edgeToStringFn = edge => `${edge.builtFrom}`;
+        }
+
+        let output
+            = '--- Network ---\n'
+            + `Nodes: ${this.nodes.length}\n`
+            + `Edges: ${this.edges.length}\n`
+            + '---\n'
+            + 'Nodes\n';
+        this.nodes.forEach(node => {
+            output += `${nodeToStringFn(node)} [edges: ${node.edges.length}]\n`;
+        });
+        output += '---\n'
+            + 'Edges\n';
+        this.edges.forEach(edge => {
+            output += `${edgeToStringFn(edge)} `;
+            output += `[${nodeToStringFn(edge.node1)} -- ${nodeToStringFn(edge.node2)}]\n`;
+        });
+        output += '---';
+        return output;
+    }
+
+    /**
+     * @returns {object}
+     */
+    toCompressedJson() {
+        return {
+            nodes: this.nodes.map(node => node.toJson()),
+            edges: this.edges.map(edge => {
+                const output = [
+                    this.nodes.indexOf(edge.node1),
+                    this.nodes.indexOf(edge.node2)
+                ];
+                if (edge.level !== null) {
+                    output.push(edge.level.toString());
+                }
+                if (edge.isOneway) {
+                    if (edge.level === null) {
+                        output.push(null);
+                    }
+                    output.push(true);
+                }
+                return output;
+            })
+        };
+    }
+
+    /**
+     * @param {object} json
+     * @returns {Network}
+     */
+    static fromCompressedJson(json) {
+
+        const network = new Network();
+
+        network.nodes = json.nodes.map(GraphNode.fromJson);
+
+        network.edges = json.edges.map(jsonEdge => {
+            const edge = new GraphEdge(
+                network.nodes[jsonEdge[0]],
+                network.nodes[jsonEdge[1]]
+            );
+            if (jsonEdge.length > 2 && jsonEdge[2] !== null) {
+                edge.level = Level.fromString(jsonEdge[2]);
+            }
+            if (jsonEdge.length > 3 && jsonEdge[3]) {
+                edge.isOneway = true;
+            }
+            return edge;
+        });
+
+        return network;
+    }
+
+
+    /**
+     * Convert Array of Coordinates array to a network
+     * @param {Coordinates[][]} segments
+     * @returns {Network}
+     */
+    static fromCoordinates(segments) {
+
+        const network = new Network();
+
+        const getOrCreateNode = coords =>
+            network.nodes.find(_coords => _coords.equalsTo(coords)) || new GraphNode(coords);
+
+        const createEdgeFromCoords = (coords1, coords2) =>
+            new GraphEdge(coords1, coords2, Level.union(coords1.level, coords2.level));
+
+        for (const segment of segments) {
+
+            let previousNode = null;
+            for (const coords of segment) {
+                const currentNode = getOrCreateNode(coords);
+
+                if (previousNode) {
+                    const edge = createEdgeFromCoords(currentNode, previousNode);
+                    network.edges.push(edge);
+                }
+
+                network.nodes.push(currentNode);
+                previousNode = currentNode;
+            }
+        }
+
+        return network;
+    }
+
+    /**
+     * 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 {GraphEdge[]} Ordered edges
+     */
+    getEdgesAtLevel(targetLevel, useMultiLevelEdges = true) {
+        return this.edges.filter(
+            ({ level }) => useMultiLevelEdges
+                ? Level.intersect(targetLevel, level) !== null
+                : Level.contains(targetLevel, level)
+        );
+    }
+
+}
+
+class GraphProjection {
+
+    /** @type {Coordinates} */
+    origin;
+
+    /** @type {number} */
+    distanceFromNearestElement;
+
+    /** @type {Coordinates} */
+    projection;
+
+    /** @type {Node|Edge} */
+    nearestElement;
+
+}
+
+/* eslint-disable complexity */
+
+class MapMatching {
+
+    /** @type {Network} */
+    _network = null;
+
+    /** @type {number} */
+    _maxDistance = Number.MAX_VALUE;
+
+    /** @type {number} */
+    _maxAngleBearing = Math.PI;
+
+    /**
+     * Constructor of Map-matching
+     * @param {?Network} network
+     */
+    constructor(network) {
+        this.network = network;
+    }
+
+    /** @type {!number} */
+    set maxAngleBearing(maxAngleBearing) {
+        this._maxAngleBearing = maxAngleBearing;
+    }
+
+    /** @type {!number} */
+    set maxDistance(maxDistance) {
+        this._maxDistance = maxDistance;
+    }
+
+    /** @type {!number} */
+    get maxAngleBearing() {
+        return this._maxAngleBearing;
+    }
+
+    /** @type {!number} */
+    get maxDistance() {
+        return this._maxDistance;
+    }
+
+    /** @type {?Network} */
+    get network() {
+        return this._network;
+    }
+
+    /** @type {?Network} */
+    set network(network) {
+        if (network instanceof Network) {
+            this._network = network;
+        } else {
+            if (typeof network !== 'undefined' && network !== null) {
+                throw new Error('network argument is not a Network object');
+            }
+            this._network = null;
+        }
+    }
+
+    /**
+     * Check if the specified edge and its nodes can be used for projection
+     * @returns {boolean} an array of two elements.
+     *  First is true if projection will be used on the specified edge, false otherwise.
+     *  Second is true if projection will be used on the nodes of the specified edge, false otherwise.
+     */
+    _shouldProjectOnEdgeAndNodes(edge, location, useBearing, useMultiLevelSegments, acceptEdgeFn) {
+
+        if (!acceptEdgeFn(edge)) {
+            // if edge selection is not verified
+            return [false, false, false];
+        }
+
+        let checkNode1 = true;
+        let checkNode2 = true;
+        let checkEdge = true;
+
+        if (
+            // Verify if edge level only if one of both is defined
+            (location.level || edge.level)
+            && (
+                // if edge level intersect location level
+                !Level.intersect(location.level, edge.level)
+                // ignore MultiLevelSegments if option used
+                || (!useMultiLevelSegments && edge.level && edge.level.isRange)
+            )) {
+            checkEdge = false;
+        }
+
+        if (!Level.equalsTo(location.level, edge.node1.coords.level)) {
+            checkNode1 = false;
+        }
+
+        if (!Level.equalsTo(location.level, edge.node2.coords.level)) {
+            checkNode2 = false;
+        }
+
+        if (useBearing) {
+            // if mapmatching bearing is enabled do not use nodes matching
+            if (checkEdge) {
+                // condition for optimisation
+                const diffAngle = diffAngleLines(edge.bearing, location.bearing);
+                if (diffAngle > this._maxAngleBearing) {
+                    // Do not try to project if angle is greater than the threshold
+                    checkEdge = false;
+                }
+            }
+            checkNode1 = false;
+            checkNode2 = false;
+        }
+
+        return [checkEdge, checkNode1, checkNode2];
+    }
+
+
+    /**
+     * @param {Coordinates} fromCoordinates
+     * @param {Coordinates} toCoordinates
+     */
+    static _assignLatLngLevel(fromCoordinates, toCoordinates) {
+        toCoordinates.lat = fromCoordinates.lat;
+        toCoordinates.lng = fromCoordinates.lng;
+        toCoordinates.level = fromCoordinates.level;
+    }
+
+    /**
+     * @param {Edge} _edge
+     * @param {Coordinates} _projection
+     */
+    static _updateProjectionLevelFromEdge = (_edge, _projection) => {
+        if (_edge.level) {
+            _projection.level = _edge.level.clone();
+        }
+    };
+
+    /**
+     * @param {!Coordinates} location
+     * @param {boolean} useDistance
+     * @param {boolean} useBearing
+     * @param {boolean} useMultiLevelSegments
+     * @param {function} acceptEdgeFn
+     * @returns {GraphProjection}
+     */
+    getProjection(location, useDistance = false, useBearing = false,
+        useMultiLevelSegments = true, acceptEdgeFn = () => true) {
+
+        if (this.network === null) {
+            throw new Error('Network has not been set yet');
+        }
+
+        if (!(location instanceof Coordinates)) {
+            throw new TypeError('location is not an instance of Coordinates');
+        }
+
+        if (useBearing && (!location.bearing || !this._maxAngleBearing)) {
+            return null;
+        }
+
+        const projection = new GraphProjection();
+        projection.origin = location;
+        projection.distanceFromNearestElement = Number.MAX_VALUE;
+        projection.projection = location.clone();
+
+        const isProjectionBetter = (distanceOfNewProjection) => {
+            return distanceOfNewProjection < projection.distanceFromNearestElement
+                && (!useDistance || distanceOfNewProjection <= this._maxDistance);
+        };
+
+        for (let i = 0; i < this.network.edges.length; i++) {
+            const edge = this.network.edges[i];
+
+            const [checkEdge, checkNode1, checkNode2] = this._shouldProjectOnEdgeAndNodes(
+                edge, location, useBearing, useMultiLevelSegments, acceptEdgeFn);
+
+            if (checkNode1) {
+
+                const distNode1 = location.distanceTo(edge.node1.coords);
+                if (isProjectionBetter(distNode1) || distNode1 <= Constants.EPS_MM) {
+                    projection.distanceFromNearestElement = distNode1;
+                    projection.nearestElement = edge.node1;
+                    MapMatching._assignLatLngLevel(edge.node1.coords, projection.projection);
+                    MapMatching._updateProjectionLevelFromEdge(edge, projection.projection);
+
+                    if (distNode1 <= Constants.EPS_MM
+                        && location.level === edge.node1.coords.level) {
+                        break;
+                    }
+                }
+            }
+
+            if (checkNode2) {
+
+                const distNode2 = location.distanceTo(edge.node2.coords);
+                if (isProjectionBetter(distNode2) || distNode2 <= Constants.EPS_MM) {
+
+                    projection.distanceFromNearestElement = distNode2;
+                    projection.nearestElement = edge.node2;
+                    MapMatching._assignLatLngLevel(edge.node2.coords, projection.projection);
+                    MapMatching._updateProjectionLevelFromEdge(edge, projection.projection);
+
+                    if (distNode2 <= Constants.EPS_MM
+                        && location.level === edge.node2.coords.level) {
+                        break;
+                    }
+                }
+            }
+
+            if (checkEdge) {
+                const segmentProjection = location.getSegmentProjection(edge.node1.coords, edge.node2.coords);
+                if (segmentProjection) {
+                    const distEdge = location.distanceTo(segmentProjection);
+                    if (isProjectionBetter(distEdge)) {
+                        projection.distanceFromNearestElement = distEdge;
+                        projection.nearestElement = edge;
+                        MapMatching._assignLatLngLevel(segmentProjection, projection.projection);
+                        MapMatching._updateProjectionLevelFromEdge(edge, projection.projection);
+                    }
+                }
+            }
+        }
+
+
+        if (!projection.nearestElement) {
+            return null;
+        }
+
+        if (projection.projection instanceof UserPosition) {
+            projection.projection.accuracy += projection.distanceFromNearestElement;
+        }
+        return projection;
+    }
+
+}
+
+/**
+ * @template T
+ */
+class GraphItinerary {
+
+    /** @type {Coordinates} */
+    start;
+
+    /** @type {Coordinates} */
+    end;
+
+    /** @type {GraphNode<T>[]} */
+    nodes;
+
+    /** @type {GraphEdge<T>[]} */
+    edges;
+
+    /** @type {number[]} */
+    edgesWeights;
+
+
+    /**
+     * @template T
+     * @param {GraphNode<T>[]} networkNodes
+     * @param {number[]} edgesWeights
+     * @returns {GraphItinerary<T>}
+     */
+    static fromNetworkNodes(networkNodes, edgesWeights) {
+        const itinerary = new GraphItinerary();
+        itinerary.edgesWeights = edgesWeights;
+
+        itinerary.nodes = networkNodes.map(node => {
+            const newNode = node.clone();
+            // Remove node edges, they will be added later.
+            newNode.edges = [];
+            return newNode;
+        });
+
+        itinerary.edges = [];
+        networkNodes.forEach((node, idx, arr) => {
+            if (idx === 0) {
+                return;
+            }
+
+            // Retrieve network edge
+            const prevNode = arr[idx - 1];
+            const edge = getEdgeByNodes(prevNode.edges, prevNode, node);
+
+            // Create itinerary edge
+            const newEdge = new GraphEdge(
+                itinerary.nodes[idx - 1],
+                itinerary.nodes[idx],
+                edge.level,
+                edge.builtFrom
+            );
+            newEdge.isOneway = edge.isOneway;
+            itinerary.edges.push(newEdge);
+        });
+
+        return itinerary;
+
+    }
+}
+
+class NoRouteFoundError extends Error {
+
+    constructor(start, end, details) {
+        super();
+        this.start = start;
+        this.end = end;
+        this.details = details;
+    }
+
+    get startStr() {
+        if (this.start instanceof GraphNode) {
+            return `Node ${this.start.coords.toString()}`;
+        }
+
+        // if (this.start instanceof Coordinates) {
+        return this.start.toString();
+    }
+
+    get endStr() {
+        if (this.end instanceof GraphNode) {
+            return `Node ${this.end.coords.toString()}`;
+        }
+
+        // if (this.end instanceof Coordinates) {
+        return this.end.toString();
+    }
+
+    get message() {
+        let message = `No route found from ${this.startStr} to ${this.endStr}.`;
+        if (this.details) {
+            message += ` Details: ${this.details}`;
+        }
+        return message;
+    }
+}
+
+/**
+ * @template T
+ */
+class GraphRouterOptions {
+
+    /** @type {number} in meters */
+    projectionMaxDistance = 50;
+
+    /** @type {function(GraphEdge<T>):boolean} */
+    weightEdgeFn = edge => edge.length;
+
+    /** @type {function(GraphEdge<T>):boolean} */
+    acceptEdgeFn = () => true;
+
+}
+
+/**
+ * @template T
+ * @abstract
+ */
+class GraphRouter {
+
+    /** @type {!Network<T>} */
+    _network;
+
+    /**
+     * @param {!Network<T>} network
+     */
+    constructor(network) {
+        this._network = network;
+        this._mapMatching = new MapMatching(network);
+    }
+
+    /**
+     * @template T
+     * @param {!GraphNode<T>|!Coordinates} start
+     * @param {!GraphNode<T>|!Coordinates} end
+     * @param {GraphRouterOptions} _options
+     * @returns {GraphItinerary<T>}
+     */
+    getShortestPath(start, end, options = new GraphRouterOptions()) {
+
+        if (!(start instanceof GraphNode) && !(start instanceof Coordinates)) {
+            throw new Error('Unknown start type');
+        }
+
+        if (!(end instanceof GraphNode) && !(end instanceof Coordinates)) {
+            throw new Error('Unknown end type');
+        }
+
+        const { acceptEdgeFn, weightEdgeFn, projectionMaxDistance } = options;
+        this._mapMatching.maxDistance = projectionMaxDistance;
+
+        const createdNodes = [];
+
+        const retrieveOrCreateNearestNode = point => {
+            if (point instanceof GraphNode) {
+                return point;
+            }
+
+            const closeNode = this._network.getNodeByCoords(point);
+            if (closeNode) {
+                return closeNode;
+            }
+
+            const proj = this._mapMatching.getProjection(point, true, false, false, acceptEdgeFn);
+            if (!proj) {
+                throw new NoRouteFoundError(start, end,
+                    `Point ${point.toString()} is too far from the network `
+                    + `> ${this._mapMatching.maxDistance.toFixed(0)} meters`
+                );
+            }
+            if (proj.nearestElement instanceof GraphNode) {
+                return proj.nearestElement;
+            }
+            // if (proj.nearestElement instanceof Edge)
+            const nodeCreated = this.createNodeInsideEdge(
+                proj.nearestElement,
+                proj.projection
+            );
+            createdNodes.push(nodeCreated);
+            return nodeCreated;
+        };
+
+        const removeCreatedNodes = () => {
+            while (createdNodes.length) {
+                this.removeNodeFromPreviouslyCreatedEdge(createdNodes.pop());
+            }
+        };
+
+        const startNode = retrieveOrCreateNearestNode(start);
+        const endNode = retrieveOrCreateNearestNode(end);
+
+        const graphItinerary = this.getShortestPathBetweenGraphNodes(
+            startNode,
+            endNode,
+            acceptEdgeFn,
+            weightEdgeFn
+        );
+        graphItinerary.start = start instanceof GraphNode ? start.coords : start;
+        graphItinerary.end = end instanceof GraphNode ? end.coords : end;
+
+        removeCreatedNodes();
+
+        if (!graphItinerary.nodes.length) {
+            throw new NoRouteFoundError(start, end);
+        }
+
+        return graphItinerary;
+
+    }
+
+    /**
+     * @param {GraphEdge<T>} edge
+     * @param {Coordinates} point
+     */
+    createNodeInsideEdge(edge, point) {
+        const a = edge.node1;
+        const b = edge.node2;
+
+        const m = new GraphNode(point);
+        m.coords.level = edge.level;
+        m.builtFrom = edge.builtFrom;
+
+        const u = edge.clone();
+        u.node1 = a;
+        u.node2 = m;
+
+        const v = edge.clone();
+        v.node1 = m;
+        v.node2 = b;
+
+        a.edges = a.edges.filter(_edge => _edge !== edge);
+        b.edges = b.edges.filter(_edge => _edge !== edge);
+
+        this._network.nodes.push(m);
+        this._network.edges.push(u, v);
+
+        this._network.edges = this._network.edges.filter(
+            _edge => _edge !== edge
+        );
+
+        return m;
+    }
+
+    /**
+     * @param {GraphNode<T>} _node
+     */
+    removeNodeFromPreviouslyCreatedEdge(_node) {
+        const u = _node.edges[0];
+        const v = _node.edges[1];
+
+        u.node1.edges = u.node1.edges.filter(edge => edge !== u);
+        v.node1.edges = v.node1.edges.filter(edge => edge !== v);
+
+        const oldEdge = u.clone();
+        oldEdge.node1 = u.node1;
+        oldEdge.node2 = v.node2;
+        this._network.edges.push(oldEdge);
+
+        this._network.nodes = this._network.nodes.filter(node => node !== _node);
+        this._network.edges = this._network.edges.filter(
+            edge => edge !== u && edge !== v
+        );
+    }
+
+    getShortestPathBetweenGraphNodes(start, end, acceptEdgeFn, weightFn) {
+        const distanceMap = {},
+            vertexList = {},
+            vertexNodes = {},
+            parentVertices = {},
+            path = [];
+        let vertexId = 1;
+
+        // Initially, we assume each vertex is unreachable
+        this._network.nodes.forEach(vertex => {
+
+            // Generate Unique Router Id
+            vertex.uniqueRouterId = vertexId;
+            vertexNodes[vertexId] = vertex;
+
+            distanceMap[vertexId] = Infinity;
+            vertexList[vertexId] = true;
+
+            vertexId++;
+        });
+
+        // The cost from the starting vertex to the starting vertex is 0
+        distanceMap[start.uniqueRouterId] = 0;
+
+        // check each vertex
+        while (Object.keys(vertexList).length > 0) {
+            const current = Number(
+                Object.keys(vertexList).reduce((_checking, vertex) => {
+                    return distanceMap[_checking] > distanceMap[vertex]
+                        ? vertex
+                        : _checking;
+                }, Object.keys(vertexList)[0])
+            );
+
+            // all the vertices accessible from current vertex
+            this._network.edges
+                .filter(edge => {
+
+                    if (!acceptEdgeFn(edge)) {
+                        return false;
+                    }
+
+                    const from = edge.node1.uniqueRouterId,
+                        to = edge.node2.uniqueRouterId;
+                    // are these vertices joined?
+                    return from === current || to === current;
+                })
+                // for each vertex we can reach
+                .forEach(edge => {
+                    let to, from, reversed = false;
+                    // determine the direction of travel
+                    if (edge.node1.uniqueRouterId === current) {
+                        to = edge.node2.uniqueRouterId;
+                        from = edge.node1.uniqueRouterId;
+                    } else {
+                        to = edge.node1.uniqueRouterId;
+                        from = edge.node2.uniqueRouterId;
+                        reversed = true;
+                    }
+
+                    if (edge.isOneway && reversed) {
+                        return;
+                    }
+
+                    // distance is how far we travelled to reach the
+                    // current vertex, plus cost of travel the next(to)
+                    const distance = distanceMap[current] + weightFn(edge);
+
+                    // if we have found a cheaper path
+                    // update the hash of costs
+                    // and record which vertex we came from
+                    if (distanceMap[to] > distance) {
+                        distanceMap[to] = distance;
+                        parentVertices[to] = from;
+                    }
+                });
+
+            // remove vertex so we don't revisit it
+            delete vertexList[current];
+        }
+
+        const edgesWeights = [];
+
+        // now we have the most efficient paths for all vertices
+        // build the path for the user specified vertex(end)
+        let endId = end.uniqueRouterId;
+        while (parentVertices[endId]) {
+            path.unshift(vertexNodes[endId]);
+            edgesWeights.unshift(distanceMap[endId] - distanceMap[parentVertices[endId]]);
+            endId = parentVertices[endId];
+        }
+        if (path.length !== 0) {
+            path.unshift(start);
+        }
+
+        // Remove Unique Router Id
+        this._network.nodes.forEach(vertex => {
+            delete vertex.uniqueRouterId;
+        });
+
+        // This clone the itinerary and temporary nodes
+        return GraphItinerary.fromNetworkNodes(path, edgesWeights);
+    }
+}
+
+export { AbsoluteHeading, Attitude, BoundingBox, Constants, Coordinates, GeoRelativePosition, GraphEdge, GraphItinerary, GraphNode, GraphProjection, GraphRouter, GraphRouterOptions, GraphUtils, Level, MapMatching, Network, NoRouteFoundError, RelativePosition, UserPosition, Utils };
+//# sourceMappingURL=wemap-geo.es.js.map