@wemap/geo 3.2.16 → 4.0.0

package/index.js

@@ -1,25 +1,25 @@
-import Constants from './src/Constants.js';
-import Utils from './src/Utils.js';
+export { default as Constants } from './src/Constants.js';
+export * as Utils from './src/Utils.js';
 
-import Attitude from './src/rotations/Attitude.js';
-import AbsoluteHeading from './src/rotations/AbsoluteHeading.js';
+/** Coordinates */
+export { default as BoundingBox } from './src/coordinates/BoundingBox.js';
+export { default as GeoRelativePosition } from './src/coordinates/GeoRelativePosition.js';
+export { default as Level } from './src/coordinates/Level.js';
+export { default as RelativePosition } from './src/coordinates/RelativePosition.js';
+export { default as Coordinates } from './src/coordinates/Coordinates.js';
+export { default as UserPosition } from './src/coordinates/UserPosition.js';
 
-import BoundingBox from './src/coordinates/BoundingBox.js';
-import GeoRelativePosition from './src/coordinates/GeoRelativePosition.js';
-import Level from './src/coordinates/Level.js';
-import RelativePosition from './src/coordinates/RelativePosition.js';
-import Coordinates from './src/coordinates/Coordinates.js';
-import UserPosition from './src/coordinates/UserPosition.js';
+/** Rotations */
+export { default as Attitude } from './src/rotations/Attitude.js';
+export { default as AbsoluteHeading } from './src/rotations/AbsoluteHeading.js';
 
-export {
-    AbsoluteHeading,
-    Attitude,
-    BoundingBox,
-    Constants,
-    GeoRelativePosition,
-    Level,
-    RelativePosition,
-    Utils,
-    Coordinates,
-    UserPosition
-};
+/** Router */
+export { default as Edge } from './src/graph/Edge.js';
+export { default as GraphRouter } from './src/graph/GraphRouter.js';
+export { default as Itinerary } from './src/graph/Itinerary.js';
+export { default as Network } from './src/graph/Network.js';
+export { default as Node } from './src/graph/Node.js';
+export { default as MapMatching } from './src/graph/MapMatching.js';
+export { default as Step } from './src/graph/Step.js';
+export * as GraphUtils from './src/graph/Utils.js';
+export { default as NoRouteFoundError } from './src/graph/NoRouteFoundError.js';

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "3.2.16",
+    "version": "4.0.0",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -22,12 +22,13 @@
     "keywords": [
         "utils",
         "geo",
+        "graph",
         "wemap"
     ],
     "license": "ISC",
     "dependencies": {
-        "@wemap/logger": "^3.2.3",
-        "@wemap/maths": "^3.2.15"
+        "@wemap/logger": "^4.0.0",
+        "@wemap/maths": "^4.0.0"
     },
-    "gitHead": "01e6c2ed3b4f24b230cb6a774fe159e7b20b810a"
+    "gitHead": "8b72858590fc2ff33fbea4f090de8cd353a7445f"
 }

package/src/Utils.js

@@ -6,161 +6,175 @@ import {
 
 import Constants from './Constants.js';
 import Coordinates from './coordinates/Coordinates.js';
+import UserPosition from './coordinates/UserPosition.js';
 
-class Utils {
+/**
+ * Sample a route of Coordinates
+ * @param {Array.<Coordinates>} route ordered points
+ * @param {*} stepSize step size to sample
+ * @param {*} maxLength max route length to sample
+ */
+export function sampleRoute(route, stepSize = 0.7, startSampling = 0, length = Number.MAX_VALUE) {
 
-    /**
-     * Sample a route of Coordinates
-     * @param {Array.<Coordinates>} route ordered points
-     * @param {*} stepSize step size to sample
-     * @param {*} maxLength max route length to sample
-     */
-    static sampleRoute(route, stepSize = 0.7, startSampling = 0, length = Number.MAX_VALUE) {
+    const endSampling = startSampling + length;
 
-        const endSampling = startSampling + length;
+    const sampledRoute = [];
 
-        const sampledRoute = [];
+    let lastSample = null;
 
-        let lastSample = null;
+    let totalDistanceTraveled = 0;
+    let distanceToNextSample;
+    let startFound = false;
 
-        let totalDistanceTraveled = 0;
-        let distanceToNextSample;
-        let startFound = false;
+    for (let segmentIndex = 0; segmentIndex < route.length - 1; segmentIndex++) {
 
-        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);
 
-            const p1 = route[segmentIndex];
-            const p2 = route[segmentIndex + 1];
-            const segmentSize = p1.distanceTo(p2);
-            const segmentBearing = p1.bearingTo(p2);
+        let distanceTraveledOnSegment = 0;
 
-            let distanceTraveledOnSegment = 0;
-
-            if (!startFound) {
-                if (startSampling < totalDistanceTraveled + segmentSize) {
-                    startFound = true;
-                    distanceToNextSample = startSampling - totalDistanceTraveled;
-                } else {
-                    totalDistanceTraveled += segmentSize;
-                    continue;
-                }
+        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;
+        lastSample = p1;
+        while (distanceTraveledOnSegment + distanceToNextSample < segmentSize
+            && totalDistanceTraveled + distanceToNextSample <= endSampling) {
 
-                distanceTraveledOnSegment += distanceToNextSample;
-                totalDistanceTraveled += distanceToNextSample;
-                distanceToNextSample = stepSize;
-            }
+            const newPoint = lastSample.destinationPoint(distanceToNextSample, segmentBearing);
+            newPoint.bearing = segmentBearing;
+            sampledRoute.push(newPoint);
+            lastSample = newPoint;
 
-            if (totalDistanceTraveled + distanceToNextSample > endSampling) {
-                break;
-            }
+            distanceTraveledOnSegment += distanceToNextSample;
+            totalDistanceTraveled += distanceToNextSample;
+            distanceToNextSample = stepSize;
+        }
 
-            const rest = segmentSize - distanceTraveledOnSegment;
-            totalDistanceTraveled += rest;
-            distanceToNextSample -= rest;
+        if (totalDistanceTraveled + distanceToNextSample > endSampling) {
+            break;
         }
 
-        return sampledRoute;
+        const rest = segmentSize - distanceTraveledOnSegment;
+        totalDistanceTraveled += rest;
+        distanceToNextSample -= rest;
     }
 
-    /**
-     * 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
-     */
-    static trimRoute(route, startPosition = route[0], length = Number.MAX_VALUE) {
+    return sampledRoute;
+}
 
-        const newRoute = [];
-        let previousPoint;
+/**
+ * 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
+ */
+export function trimRoute(route, startPosition = route[0], length = Number.MAX_VALUE) {
 
-        let currentPointIndex;
-        let cumulativeDistance = 0;
+    const newRoute = [];
+    let previousPoint;
 
-        for (currentPointIndex = 1; currentPointIndex < route.length; currentPointIndex++) {
+    let currentPointIndex;
+    let cumulativeDistance = 0;
 
-            const p1 = route[currentPointIndex - 1];
-            const p2 = route[currentPointIndex];
+    for (currentPointIndex = 1; currentPointIndex < route.length; currentPointIndex++) {
 
-            if (startPosition.equalsTo(p1)) {
-                newRoute.push(p1);
-                previousPoint = p1;
-                break;
-            }
+        const p1 = route[currentPointIndex - 1];
+        const p2 = route[currentPointIndex];
 
-            const proj = startPosition.getSegmentProjection(p1, p2);
-            if (proj && proj.equalsTo(startPosition) && !proj.equalsTo(p2)) {
-                newRoute.push(proj);
-                previousPoint = proj;
-                break;
-            }
+        if (startPosition.equalsTo(p1)) {
+            newRoute.push(p1);
+            previousPoint = p1;
+            break;
         }
 
-        if (!newRoute.length) {
-            throw new Error('startPosition is not on the route');
+        const proj = startPosition.getSegmentProjection(p1, p2);
+        if (proj && proj.equalsTo(startPosition) && !proj.equalsTo(p2)) {
+            newRoute.push(proj);
+            previousPoint = proj;
+            break;
         }
+    }
 
-        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++;
-        }
+    if (!newRoute.length) {
+        throw new Error('startPosition is not on the route');
+    }
 
-        return newRoute;
+    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++;
     }
 
-    /**
-     * @param {Coordinates[]} coords
-     * @param {number} precision
-     * @returns {Coordinates[]}
-     */
-    static simplifyRoute(coords, precisionAngle = deg2rad(5)) {
+    return newRoute;
+}
 
-        const isClosed = (coords[0].equalsTo(coords[coords.length - 1]));
+/**
+ * @param {Coordinates[]} coords
+ * @param {number} precision
+ * @returns {Coordinates[]}
+ */
+export function simplifyRoute(coords, precisionAngle = deg2rad(5)) {
 
-        let newRoute = coords.slice(0, coords.length - (isClosed ? 1 : 0));
+    const isClosed = (coords[0].equalsTo(coords[coords.length - 1]));
 
-        const len = newRoute.length;
-        for (let i = isClosed ? 0 : 1; i < len; i++) {
+    let newRoute = coords.slice(0, coords.length - (isClosed ? 1 : 0));
 
-            const p0 = coords[positiveMod(i - 1, len)];
-            const p1 = coords[i];
-            const p2 = coords[positiveMod(i + 1, len)];
+    const len = newRoute.length;
+    for (let i = isClosed ? 0 : 1; i < len; i++) {
 
-            const seg1Dir = p0.bearingTo(p1);
-            const seg2Dir = p1.bearingTo(p2);
+        const p0 = coords[positiveMod(i - 1, len)];
+        const p1 = coords[i];
+        const p2 = coords[positiveMod(i + 1, len)];
 
-            if (Math.abs(seg2Dir - seg1Dir) < precisionAngle) {
-                newRoute = newRoute.filter(coord => coord !== p1);
-            }
-        }
+        const seg1Dir = p0.bearingTo(p1);
+        const seg2Dir = p1.bearingTo(p2);
 
-        if (isClosed) {
-            newRoute.push(newRoute[0]);
+        if (Math.abs(seg2Dir - seg1Dir) < precisionAngle) {
+            newRoute = newRoute.filter(coord => coord !== p1);
         }
+    }
 
-        return newRoute;
+    if (isClosed) {
+        newRoute.push(newRoute[0]);
     }
+
+    return newRoute;
 }
 
-export default Utils;
+/**
+ * @param {GeolocationPosition} geolocationPosition
+ * @returns {UserPosition}
+ */
+export 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;
+}

package/src/Utils.spec.js

@@ -2,7 +2,7 @@
 import chai from 'chai';
 import chaiAlmost from 'chai-almost';
 
-import Utils from './Utils.js';
+import { sampleRoute, simplifyRoute, trimRoute } from './Utils.js';
 import Coordinates from './coordinates/Coordinates.js';
 
 const expect = chai.expect;
@@ -19,7 +19,7 @@ describe('Geo Utils', () => {
         const p3 = p2.destinationPoint(49.9, Math.PI / 2);
         const route = [p1, p2, p3];
 
-        samples = Utils.sampleRoute(route);
+        samples = sampleRoute(route);
         expect(samples.length).equals(Math.ceil(149.9 / 0.7));
         for (let i = 0; i < samples.length - 1; i++) {
             // Ignore the crow flies for the turn
@@ -29,23 +29,23 @@ describe('Geo Utils', () => {
             expect(samples[i].distanceTo(samples[i + 1])).to.almost.equal(0.7);
         }
 
-        samples = Utils.sampleRoute(route, 10);
+        samples = sampleRoute(route, 10);
         expect(samples.length).equals(15);
         for (let i = 0; i < samples.length - 1; i++) {
             expect(samples[i].distanceTo(samples[i + 1])).to.almost.equal(i === 14 ? 9.9 : 10);
         }
 
-        samples = Utils.sampleRoute(route, 10, 0, 99.9);
+        samples = sampleRoute(route, 10, 0, 99.9);
         expect(samples.length).equals(10);
 
 
-        samples = Utils.sampleRoute(route, 10, 50, 12);
+        samples = sampleRoute(route, 10, 50, 12);
         expect(samples.length).equals(2);
 
-        samples = Utils.sampleRoute(route, 10, 50, 100);
+        samples = sampleRoute(route, 10, 50, 100);
         expect(samples.length).equals(10);
 
-        samples = Utils.sampleRoute(route, 10, 110, 12);
+        samples = sampleRoute(route, 10, 110, 12);
         expect(samples.length).equals(2);
 
     });
@@ -59,44 +59,44 @@ describe('Geo Utils', () => {
         const p3 = p2.destinationPoint(49.9, Math.PI / 2);
         const route = [p1, p2, p3];
 
-        expect(() => Utils.trimRoute(route, new Coordinates(0, 0))).throw(Error);
+        expect(() => trimRoute(route, new Coordinates(0, 0))).throw(Error);
 
-        newRoute = Utils.trimRoute(route);
+        newRoute = trimRoute(route);
         expect(newRoute.length).equals(3);
         for (let i = 0; i < newRoute.length - 1; i++) {
             expect(newRoute[i].equalsTo(route[i])).true;
         }
 
-        newRoute = Utils.trimRoute(route, p1, 100);
+        newRoute = trimRoute(route, p1, 100);
         expect(newRoute.length).equals(2);
         expect(newRoute[0].equalsTo(p1)).true;
         expect(newRoute[1].equalsTo(p2)).true;
 
-        newRoute = Utils.trimRoute(route, p1, 90);
+        newRoute = trimRoute(route, p1, 90);
         expect(newRoute.length).equals(2);
         expect(newRoute[0].equalsTo(p1)).true;
         expect(newRoute[1].equalsTo(p1.destinationPoint(90, Math.PI / 4))).true;
 
-        newRoute = Utils.trimRoute(route, p2, 10);
+        newRoute = trimRoute(route, p2, 10);
         expect(newRoute.length).equals(2);
         expect(newRoute[0].equalsTo(p2)).true;
         expect(newRoute[1].equalsTo(p2.destinationPoint(10, Math.PI / 2))).true;
 
         const p4 = p1.destinationPoint(20, Math.PI / 4);
-        newRoute = Utils.trimRoute(route, p4);
+        newRoute = trimRoute(route, p4);
         expect(newRoute.length).equals(3);
         expect(newRoute[0].equalsTo(p4)).true;
         expect(newRoute[1].equalsTo(p2)).true;
         expect(newRoute[2].equalsTo(p3)).true;
 
         const p5 = p2.destinationPoint(20, Math.PI / 2);
-        newRoute = Utils.trimRoute(route, p4, 100);
+        newRoute = trimRoute(route, p4, 100);
         expect(newRoute.length).equals(3);
         expect(newRoute[0].equalsTo(p4)).true;
         expect(newRoute[1].equalsTo(p2)).true;
         expect(newRoute[2].equalsTo(p5)).true;
 
-        newRoute = Utils.trimRoute(route, p4, 200);
+        newRoute = trimRoute(route, p4, 200);
         expect(newRoute.length).equals(3);
         expect(newRoute[0].equalsTo(p4)).true;
         expect(newRoute[1].equalsTo(p2)).true;
@@ -115,7 +115,7 @@ describe('Geo Utils', () => {
             new Coordinates(48.756350241508265, 2.0550837293345348)
         ];
 
-        routeSimplified = Utils.simplifyRoute(route);
+        routeSimplified = simplifyRoute(route);
         expect(routeSimplified.length).equal(3);
         expect(routeSimplified).to.include(route[0]);
         expect(routeSimplified).to.not.include(route[1]);
@@ -133,7 +133,7 @@ describe('Geo Utils', () => {
             new Coordinates(48.75627274161895, 2.054974197053283)
         ];
 
-        routeSimplified = Utils.simplifyRoute(route);
+        routeSimplified = simplifyRoute(route);
         expect(routeSimplified.length).equal(5);
         expect(routeSimplified).to.not.include(route[0]);
         expect(routeSimplified).to.not.include(route[5]);

package/src/coordinates/BoundingBox.spec.js

@@ -171,6 +171,51 @@ describe('Bounding Box', () => {
             .be.closeTo(measure, 0.05 * measure);
     });
 
+    it('pad', () => {
+
+        let distBefore, distAfter;
+
+        boundingBox = new BoundingBox(northEast, southWest);
+        const bufferRatio = 0.3;
+        const extended = new BoundingBox(northEast, southWest).pad(bufferRatio);
+
+
+        distBefore = new Coordinates(boundingBox.getNorth(), boundingBox.getWest()).distanceTo(
+            new Coordinates(boundingBox.getNorth(), boundingBox.getEast())
+        );
+        distAfter = new Coordinates(extended.getNorth(), extended.getWest()).distanceTo(
+            new Coordinates(extended.getNorth(), extended.getEast())
+        );
+        expect(distAfter).be.closeTo(distBefore * (1 + bufferRatio * 2), distAfter * 0.05);
+
+
+        distBefore = new Coordinates(boundingBox.getSouth(), boundingBox.getWest()).distanceTo(
+            new Coordinates(boundingBox.getSouth(), boundingBox.getEast())
+        );
+        distAfter = new Coordinates(extended.getSouth(), extended.getWest()).distanceTo(
+            new Coordinates(extended.getSouth(), extended.getEast())
+        );
+        expect(distAfter).be.closeTo(distBefore * (1 + bufferRatio * 2), distAfter * 0.05);
+
+
+        distBefore = new Coordinates(boundingBox.getNorth(), boundingBox.getEast()).distanceTo(
+            new Coordinates(boundingBox.getSouth(), boundingBox.getEast())
+        );
+        distAfter = new Coordinates(extended.getNorth(), extended.getEast()).distanceTo(
+            new Coordinates(extended.getSouth(), extended.getEast())
+        );
+        expect(distAfter).be.closeTo(distBefore * (1 + bufferRatio * 2), distAfter * 0.05);
+
+
+        distBefore = new Coordinates(boundingBox.getNorth(), boundingBox.getWest()).distanceTo(
+            new Coordinates(boundingBox.getSouth(), boundingBox.getWest())
+        );
+        distAfter = new Coordinates(extended.getNorth(), extended.getWest()).distanceTo(
+            new Coordinates(extended.getSouth(), extended.getWest())
+        );
+        expect(distAfter).be.closeTo(distBefore * (1 + bufferRatio * 2), distAfter * 0.05);
+    });
+
     it('toArray', () => {
         expect(new BoundingBox(northEast, southWest).toArray()).deep.equals([-20, -5, 40, 10]);
     });