@wemap/geo 0.1.1

package/index.js

@@ -0,0 +1,17 @@
+import Constants from './src/Constants';
+import Edge from './src/graph/Edge';
+import Itinerary from './src/graph/Itinerary';
+import MapMatching from './src/graph/MapMatching';
+import Network from './src/graph/Network';
+import WGS84 from './src/coordinates/WGS84';
+import WGS84UserPosition from './src/coordinates/WGS84UserPosition';
+
+export {
+    Constants,
+    Edge,
+    Itinerary,
+    MapMatching,
+    Network,
+    WGS84,
+    WGS84UserPosition
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+    "author": "Wemap",
+    "contributors": [
+        {
+            "name": "Thibaud Michel",
+            "email": "thibaud@getwemap.com"
+        },
+        {
+            "name": "Guillaume Pannetier",
+            "email": "guillaume.pannetier@getwemap.com"
+        }
+    ],
+    "description": "A package using different geoloc systems",
+    "dependencies": {
+        "@wemap/maths": "latest"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/wemap/wemap-utils-js.git",
+        "directory": "packages/geo"
+    },
+    "main": "index.js",
+    "name": "@wemap/geo",
+    "version": "0.1.1",
+    "gitHead": "00ed0bae7da0086bb47d6e958343fd2020bac2b1"
+}

package/src/Constants.js

@@ -0,0 +1,18 @@
+const Constants = {
+    R_MAJOR: 6378137.0,
+    R_MINOR: 6356752.3142,
+    EARTH_GRAVITY: 9.80665,
+    EARTH_RADIUS_KM: 6371
+};
+
+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;
+
+export default Constants;

package/src/coordinates/WGS84.js

@@ -0,0 +1,285 @@
+import { Utils, Vector3, Quaternion } from '@wemap/maths';
+import Constants from '../Constants';
+
+
+class WGS84 {
+
+    constructor(lat, lng, alt = 0) {
+        this._lat = lat;
+        this._lng = lng;
+        this._alt = alt;
+        this._ecef = null;
+    }
+
+    get lat() {
+        return this._lat;
+    }
+
+    get lng() {
+        return this._lng;
+    }
+
+    get alt() {
+        return this._alt;
+    }
+
+    set lat(lat) {
+        this._ecef = null;
+        this._lat = lat;
+    }
+
+    set lng(lng) {
+        this._ecef = null;
+        this._lng = lng;
+    }
+
+    set alt(alt) {
+        this._ecef = null;
+        this._alt = alt;
+    }
+
+    clone() {
+        return new WGS84(this.lat, this.lng, this.alt);
+    }
+
+    equalsTo(other) {
+
+        if (!(other instanceof WGS84)) {
+            return false;
+        }
+
+        return other.lat === this.lat && other.lng === this.lng;
+    }
+
+    toString() {
+        let str = '[' + this._lat.toFixed(7) + ', ' + this._lng.toFixed(7);
+        if (this._alt) {
+            str += ', ' + this._alt.toFixed(2);
+        }
+        str += ']';
+        return str;
+    }
+
+    destinationPoint(distance, bearing, elevation = 0) {
+        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 = 0) {
+
+        const d = distance;
+        const R = Constants.R_MAJOR;
+
+        const φ1 = Utils.deg2rad(this.lat);
+        const λ1 = Utils.deg2rad(this.lng);
+
+        const φ2 = Math.asin(Math.sin(φ1) * Math.cos(d / R) + Math.cos(φ1) * Math.sin(d / R) * Math.cos(bearing));
+        const λ2 = λ1 + Math.atan2(Math.sin(bearing) * Math.sin(d / R) * Math.cos(φ1), Math.cos(d / R) - Math.sin(φ1) * Math.sin(φ2));
+
+        const altitude = (this.alt || 0) + elevation;
+
+        this.lat = Utils.rad2deg(φ2);
+        this.lng = Utils.rad2deg(λ2);
+        this.alt = altitude;
+    }
+
+    /**
+     * Returns a distance between two points in meters
+     * @param  {Number} location2 latitude / longitude point2
+     * @return {Number} distance in meters
+     */
+    distanceTo(location2) {
+        var cosn, dist, dlat, dlng, angle, tangy, tangx,
+            dlatsin, dlngsin, lat1cos, lat2cos, lat2rad, lat1rad;
+
+        const lat1 = this.lat;
+        const lng1 = this.lng;
+
+        const lat2 = location2.lat;
+        const lng2 = location2.lng;
+
+        dlat = Utils.deg2rad(lat2 - lat1);
+        dlng = Utils.deg2rad(lng2 - lng1);
+
+        dlngsin = Math.sin(dlng / 2);
+        dlatsin = Math.sin(dlat / 2);
+        lat1rad = Utils.deg2rad(lat1);
+        lat1cos = Math.cos(lat1rad);
+        lat2rad = Utils.deg2rad(lat2);
+        lat2cos = Math.cos(lat2rad);
+        angle = (dlatsin * dlatsin + lat1cos * lat2cos * dlngsin * dlngsin);
+
+        // arctangent
+        tangy = Math.sqrt(angle);
+        tangx = Math.sqrt(1 - angle);
+        cosn = (2 * Math.atan2(tangy, tangx));
+
+        // distance in km
+        dist = (Constants.EARTH_RADIUS_KM * 1000 * cosn);
+        return dist;
+    }
+
+    static distanceBetween(point1, point2) {
+        return point1.distanceTo(point2);
+    }
+
+    bearingTo(location2) {
+        const lat1 = Utils.deg2rad(this.lat);
+        const lat2 = Utils.deg2rad(location2.lat);
+        const diffLng = Utils.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));
+    }
+
+
+    getEnuToEcefRotation() {
+        const rot1 = Quaternion.fromAxisAngle([0, 0, 1], Math.PI / 2 + Utils.deg2rad(this.lng));
+        const rot2 = Quaternion.fromAxisAngle([1, 0, 0], Math.PI / 2 - Utils.deg2rad(this.lat));
+        return Quaternion.multiply(rot1, rot2);
+    }
+
+    getEcefToEnuRotation() {
+        const rot1 = Quaternion.fromAxisAngle([1, 0, 0], Utils.deg2rad(this.lat) - Math.PI / 2);
+        const rot2 = Quaternion.fromAxisAngle([0, 0, 1], -Utils.deg2rad(this.lng) - Math.PI / 2);
+        return Quaternion.multiply(rot1, rot2);
+    }
+
+    getUpVector() {
+        return Vector3.normalize(this.ecef);
+    }
+
+
+    get ecef() {
+
+        if (!this._ecef) {
+            const lat = Utils.deg2rad(this.lat);
+            const lng = Utils.deg2rad(this.lng);
+            const alt = this.alt || 0;
+
+            const N = Constants.R_MAJOR / Math.sqrt(1 - Constants.ECCENTRICITY_2 * Math.pow(Math.sin(lat), 2));
+
+            const x = (N + alt) * Math.cos(lat) * Math.cos(lng);
+            const y = (N + alt) * Math.cos(lat) * Math.sin(lng);
+            const z = ((1 - Constants.ECCENTRICITY_2) * N + 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 b = Math.sqrt(Constants.R_MAJOR_2 * (1 - Constants.ECCENTRICITY_2));
+        const bsq = Math.pow(b, 2);
+        const ep = Math.sqrt((Constants.R_MAJOR_2 - bsq) / bsq);
+        const p = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
+        const th = Math.atan2(Constants.R_MAJOR * z, b * p);
+
+        let lng = Math.atan2(y, x);
+        const lat = Math.atan2((z + Math.pow(ep, 2) * b * Math.pow(Math.sin(th), 3)), (p - Constants.ECCENTRICITY_2 * Constants.R_MAJOR * Math.pow(Math.cos(th), 3)));
+        const N = Constants.R_MAJOR / (Math.sqrt(1 - Constants.ECCENTRICITY_2 * Math.pow(Math.sin(lat), 2)));
+        const alt = p / Math.cos(lat) - N;
+
+        lng = lng % (2 * Math.PI);
+
+        const newPoint = new WGS84(Utils.rad2deg(lat), Utils.rad2deg(lng), Utils.rad2deg(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
+    getProjection(edge) {
+
+        const p1 = edge.node1;
+        const p2 = edge.node2;
+
+        const a = Vector3.normalize(p1.ecef);
+        const b = Vector3.normalize(p2.ecef);
+        const c = Vector3.normalize(this.ecef);
+
+        const G = Vector3.cross(a, b);
+        const F = Vector3.cross(c, G);
+        let t = Vector3.normalize(Vector3.cross(G, F));
+
+        t = Vector3.multiplyScalar(t, this.getEarthRadiusAtPosition());
+
+        const projection = WGS84.fromECEF(t);
+        projection.alt = p1.alt && p2.alt ? (p1.alt + p2.alt) / 2 : 0;
+        if (Math.abs((p1.distanceTo(p2) - p1.distanceTo(projection) - p2.distanceTo(projection))) > 1e-6) {
+            return null;
+        }
+
+        return projection;
+    }
+
+
+    getEarthRadiusAtPosition() {
+        const latR = Utils.deg2rad(this.lat);
+        const cos2 = Math.cos(latR) * Math.cos(latR);
+        const sin2 = Math.sin(latR) * Math.sin(latR);
+        return Math.sqrt((Constants.R_MAJOR_4 * cos2 + Constants.R_MINOR_4 * sin2) / (Constants.R_MAJOR_2 * cos2 + Constants.R_MINOR_2 * sin2));
+    }
+
+    toMessage() {
+        return {
+            lat: this.lat,
+            lng: this.lng,
+            alt: this.alt
+        };
+    }
+
+    static fromMessage(message) {
+        return new WGS84(message.lat, message.lng, message.alt);
+    }
+
+    static fromPinpoint(pinpoint) {
+        return new WGS84(pinpoint.latitude, pinpoint.longitude, pinpoint.altitude);
+    }
+
+    static sampleRoute(route, stepSize = 0.7, maxLength = Number.MAX_VALUE) {
+
+        let p1, p2 = null;
+        let bearing, distance;
+
+        const sampledRoute = [];
+        let reportedDistance = 0;
+        let totalDistance = 0;
+
+        for (let i = 0; i < route.length - 1; i++) {
+
+            p1 = route[i];
+            p2 = route[i + 1];
+
+            bearing = p1.bearingTo(p2);
+            distance = p1.distanceTo(p2);
+
+            if (distance > 0) {
+                let ratio = reportedDistance / distance;
+                while (ratio < 1 && totalDistance <= maxLength) {
+                    const newPoint = p1.destinationPoint(ratio * distance, bearing);
+                    newPoint.bearing = bearing;
+                    sampledRoute.push(newPoint);
+                    ratio += stepSize / distance;
+                    totalDistance += stepSize;
+                }
+                reportedDistance = (ratio - 1) * distance;
+            }
+        }
+        if (p2) {
+            sampledRoute.push(p2);
+        }
+
+        return sampledRoute;
+    }
+}
+
+export default WGS84;

package/src/coordinates/WGS84UserPosition.js

@@ -0,0 +1,52 @@
+import WGS84 from './WGS84';
+
+const MESSAGE_TYPE = 'WGS84UserPosition';
+
+class WGS84UserPosition extends WGS84 {
+
+    constructor(lat, lng, alt = null, time = null,
+        accuracy = null, bearing = null, provider = null) {
+        super(lat, lng, alt);
+        this.bearing = bearing;
+        this.provider = provider;
+        this.time = time;
+        this.accuracy = accuracy;
+    }
+
+    // Create a WGS84UserPosition with lat, lng, alt from WGS84 coordinates and
+    //   other fields from another WGS84UserPosition
+    static fromWGS84(wgs84Coordinates, userPosition) {
+
+        if (userPosition) {
+            return new WGS84UserPosition(wgs84Coordinates.lat, wgs84Coordinates.lng, wgs84Coordinates.alt,
+                userPosition.time, userPosition.accuracy, userPosition.bearing, userPosition.provider);
+        }
+
+        return new WGS84UserPosition(wgs84Coordinates.lat, wgs84Coordinates.lng, wgs84Coordinates.alt);
+    }
+
+    clone() {
+        return new WGS84UserPosition(this.lat, this.lng, this.alt, this.time, this.accuracy, this.bearing, this.provider);
+    }
+
+    static get MESSAGE_TYPE() {
+        return MESSAGE_TYPE;
+    }
+
+    toMessage() {
+        const message = super.toMessage();
+        message.type = MESSAGE_TYPE;
+        message.time = this.time;
+        message.bearing = this.bearing;
+        message.provider = this.provider;
+        message.accuracy = this.accuracy;
+        return message;
+    }
+
+    static fromMessage(message) {
+        return new WGS84UserPosition(message.lat, message.lng, message.alt,
+            message.time, message.accuracy, message.bearing, message.provider);
+    }
+}
+
+export default WGS84UserPosition;

package/src/graph/Edge.js

@@ -0,0 +1,63 @@
+import WGS84 from '../coordinates/WGS84';
+
+class Edge {
+
+    constructor(node1, node2) {
+
+        if (!(node1 instanceof WGS84)) {
+            throw new TypeError('node1 is not an instance of WGS84');
+        }
+
+        if (!(node2 instanceof WGS84)) {
+            throw new TypeError('node2 is not an instance of WGS84');
+        }
+
+        this.node1 = node1;
+        this.node2 = node2;
+        this.computedSizeAndBearing = false;
+    }
+
+    getBearing() {
+        if (!this.computedSizeAndBearing) {
+            this.computeSizeAndBearing();
+        }
+        return this.bearing;
+    }
+
+    getLength() {
+        if (!this.computedSizeAndBearing) {
+            this.computeSizeAndBearing();
+        }
+        return this.length;
+    }
+
+    computeSizeAndBearing() {
+        this.length = this.node1.distanceTo(this.node2);
+        this.bearing = this.node1.bearingTo(this.node2);
+        this.computedSizedAndBearing = true;
+    }
+
+    static pointsToEdges(points, lngLatFormat = true) {
+        let lastPoint = null;
+        const edgesNetwork = [];
+        for (let i = 0; i < points.length; i++) {
+            const currentPoint = new WGS84(points[i][lngLatFormat ? 1 : 0], points[i][lngLatFormat ? 0 : 1]);
+            if (lastPoint) {
+                edgesNetwork.push(new Edge(lastPoint, currentPoint));
+            }
+            lastPoint = currentPoint;
+        }
+        return edgesNetwork;
+    }
+
+    equalsTo(other) {
+
+        if (!(other instanceof Edge)) {
+            return false;
+        }
+
+        return other.node1.equalsTo(this.node1) && other.node2.equalsTo(this.node2);
+    }
+}
+
+export default Edge;

package/src/graph/Itinerary.js

@@ -0,0 +1,36 @@
+import Edge from './Edge';
+import Network from './Network';
+
+// An itinerary is an ordered list of edges where edge(n-1).p2 = edge.(n).p1
+class Itinerary extends Network {
+
+    constructor(edges = []) {
+        super(edges);
+    }
+
+    static fromPoints(points, lngLatFormat = true) {
+        return new Itinerary(Edge.pointsToEdges(points, lngLatFormat));
+    }
+
+    get firstEdge() {
+        if (this.edges.length < 1) {
+            throw new TypeError('first edge of itinerary does not exist');
+        }
+        return this.edges[0];
+    }
+
+    get secondEdge() {
+        if (this.edges.length < 2) {
+            throw new TypeError('second edge of itinerary does not exist');
+        }
+        return this.edges[1];
+    }
+
+    get distance() {
+        let dist = 0;
+        this.edges.forEach(edge => (dist += edge.getLength()));
+        return dist;
+    }
+}
+
+export default Itinerary;

package/src/graph/MapMatching.js

@@ -0,0 +1,118 @@
+/* eslint complexity: ["error", 21]*/
+/* eslint max-statements: ["error", 45]*/
+
+import { Utils as MathUtils} from '@wemap/maths';
+import Network from './Network';
+
+const rad2deg = MathUtils.rad2deg;
+
+class MapMatching {
+
+    _maxDistance = Number.MAX_VALUE;
+
+    /**
+     * Constructor of Map-matching
+     * @param {Network} network List of Edges
+     */
+    constructor(network) {
+        if (network) {
+            this.setNetwork(network);
+        }
+    }
+
+    set maxAngleBearing(maxAngleBearing) {
+        this._maxAngleBearing = maxAngleBearing;
+    }
+
+    set maxDistance(maxDistance) {
+        this._maxDistance = maxDistance;
+    }
+
+    setNetwork(network) {
+        if (!(network instanceof Network)) {
+            throw new Error(network + ' is not an instance of Network');
+        }
+        this.network = network;
+    }
+
+    getProjection(location, useDistance = true, useBearing = true) {
+
+        if (!this.network) {
+            return null;
+        }
+
+        if (useBearing && (!location.bearing || !this._maxAngleBearing)) {
+            return null;
+        }
+
+        if (useDistance && !this._maxDistance) {
+            return null;
+        }
+
+        const projection = {};
+        projection.origin = location;
+        projection.distanceFromNearestElement = Number.MAX_VALUE;
+
+        for (let i = 0; i < this.network.edges.length; i++) {
+            const edge = this.network.edges[i];
+
+            if (useBearing) {
+                const edgeBearing = rad2deg(edge.getBearing());
+                const diffAngle = MapMatching.diffAngle90(edgeBearing, location.bearing);
+                if (diffAngle > this._maxAngleBearing) {
+                    continue;
+                }
+            } else {
+                // Check node 1
+                const distNode1 = location.distanceTo(edge.node1);
+                if (distNode1 < projection.distanceFromNearestElement
+                    && (!useDistance || distNode1 <= this._maxDistance)) {
+                    projection.distanceFromNearestElement = distNode1;
+                    projection.nearestElement = edge.node1;
+                    projection.projection = edge.node1.clone();
+                }
+
+                // Check node 2
+                const distNode2 = location.distanceTo(edge.node2);
+                if (distNode2 < projection.distanceFromNearestElement
+                    && (!useDistance || distNode2 <= this._maxDistance)) {
+                    projection.distanceFromNearestElement = distNode2;
+                    projection.nearestElement = edge.node2;
+                    projection.projection = edge.node2.clone();
+                }
+            }
+
+            // Check edge
+            const segmentProjection = location.getProjection(edge);
+            if (segmentProjection) {
+                const distEdge = location.distanceTo(segmentProjection);
+                if (distEdge < projection.distanceFromNearestElement
+                    && (!useDistance || distEdge <= this._maxDistance)) {
+                    projection.distanceFromNearestElement = distEdge;
+                    projection.nearestElement = edge;
+                    projection.projection = segmentProjection.clone();
+                }
+            }
+        }
+
+        if (!projection.projection) {
+            return null;
+        }
+
+        return projection;
+    }
+
+    static diffAngle90(angle1, angle2) {
+        let diffAngle = Math.abs(angle1 - angle2);
+        if (diffAngle > 180) {
+            diffAngle = 360 - diffAngle;
+        }
+        if (diffAngle > 90) {
+            diffAngle = 180 - diffAngle;
+        }
+        return diffAngle;
+    }
+
+}
+
+export default MapMatching;

package/src/graph/MapMatching.spec.js

@@ -0,0 +1,47 @@
+import chai from 'chai';
+import chaiAlmost from 'chai-almost';
+
+import Edge from './Edge';
+import MapMatching from './MapMatching';
+import Network from './Network';
+import WGS84 from '../coordinates/WGS84';
+import WGS84UserPosition from '../coordinates/WGS84UserPosition';
+
+const expect = chai.expect;
+chai.use(chaiAlmost());
+
+describe('matching', () => {
+    it('Should return the good value', () => {
+
+        const p1 = new WGS84(43.6091883, 3.8841242);
+        const p2 = new WGS84(43.6091709, 3.8842382);
+        const p3 = new WGS84(43.6091288, 3.884226);
+        const p4 = new WGS84(43.6091461, 3.884112);
+        const e1 = new Edge(p1, p2);
+        const e2 = new Edge(p2, p3);
+        const e3 = new Edge(p3, p4);
+        const e4 = new Edge(p4, p1);
+        const network = new Network([e1, e2, e3, e4]);
+
+        const mapMatching = new MapMatching(network);
+        mapMatching.maxAngleBearing = 30;
+
+        const location = new WGS84UserPosition(43.6091762, 3.8841239);
+
+        location.bearing = 101.9;
+        const projection1 = mapMatching.getProjection(location);
+        const result1 = projection1.projection;
+        const expected1 = new WGS84(43.609187832342556, 3.884127262759803);
+        const distance1 = result1.distanceTo(expected1);
+        expect(distance1).to.below(0.01);
+
+
+        location.bearing = 11.9;
+        const projection2 = mapMatching.getProjection(location);
+        const result2 = projection2.projection;
+        const expected2 = new WGS84(43.609176667533255, 3.8841208369745965);
+        const distance2 = result2.distanceTo(expected2);
+        expect(distance2).to.below(0.01);
+
+    });
+});

package/src/graph/Network.js

@@ -0,0 +1,34 @@
+import Edge from './Edge';
+
+class Network {
+
+    constructor(edges = []) {
+        this.addEdges(edges);
+    }
+
+    addEdges(edges) {
+        Network.checkEdgesArray(edges);
+        if (!this.edges) {
+            this.edges = [];
+        }
+        this.edges = this.edges.concat(edges);
+    }
+
+    get length() {
+        return this.edges.length;
+    }
+
+    static checkEdgesArray(edges) {
+        if (!Array.isArray(edges)) {
+            throw new TypeError('Network creation: edges param is not an Array');
+        }
+
+        edges.forEach(edge => {
+            if (!(edge instanceof Edge)) {
+                throw new TypeError('Network creation: ' + edge + ' is not an Edge');
+            }
+        });
+    }
+}
+
+export default Network;