@wemap/geo 3.1.15 → 3.1.20

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "3.1.15",
+    "version": "3.1.20",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -33,5 +33,5 @@
         "lodash.isnumber": "^3.0.3",
         "lodash.isstring": "^4.0.1"
     },
-    "gitHead": "44d9ad40afa3e6522a01bc86891082a753199f9a"
+    "gitHead": "f7c26f0b16ec1d0d3ec5ca7efe6440424e18d3fb"
 }

package/src/Constants.js

@@ -10,7 +10,7 @@ const Constants = {
     EPS_DEG_MM: 1e-8,
 
     /**
-     * epsilon in meters which corresponds to q millimeter
+     * epsilon in meters which corresponds to 1 millimeter
      */
     EPS_MM: 1e-3
 };

package/src/Utils.js

@@ -1,3 +1,4 @@
+/* eslint-disable max-statements */
 import Coordinates from './coordinates/Coordinates';
 
 class Utils {
@@ -8,39 +9,118 @@ class Utils {
      * @param {*} stepSize step size to sample
      * @param {*} maxLength max route length to sample
      */
-    static sampleRoute(route, stepSize = 0.7, maxLength = Number.MAX_VALUE) {
+    static sampleRoute(route, stepSize = 0.7, startSampling = 0, length = Number.MAX_VALUE) {
 
-        let p1, p2 = null;
-        let bearing, distance;
+        const endSampling = startSampling + length;
 
         const sampledRoute = [];
-        let reportedDistance = 0;
-        let totalDistance = 0;
 
-        for (let i = 0; i < route.length - 1; i++) {
+        let lastSample = null;
 
-            p1 = route[i];
-            p2 = route[i + 1];
+        let totalDistanceTraveled = 0;
+        let distanceToNextSample;
+        let startFound = false;
 
-            bearing = p1.bearingTo(p2);
-            distance = p1.distanceTo(p2);
+        for (let segmentIndex = 0; segmentIndex < route.length - 1; segmentIndex++) {
 
-            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;
+            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;
                 }
-                reportedDistance = (ratio - 1) * distance;
             }
+
+            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;
         }
-        sampledRoute.push(p2);
 
         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
+     */
+    static 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 (startPosition.equalsTo(p1)) {
+                newRoute.push(p1);
+                previousPoint = p1;
+                break;
+            }
+
+            const proj = startPosition.getSegmentProjection(p1, p2);
+            if (proj && proj.equalsTo(startPosition) && !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) {
+                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;
+    }
 }
 
 export default Utils;

package/src/Utils.spec.js

@@ -1,8 +1,12 @@
-import { expect } from 'chai';
+/* eslint-disable max-statements */
+import chai from 'chai';
+import chaiAlmost from 'chai-almost';
 
 import Utils from './Utils';
 import Coordinates from './coordinates/Coordinates';
 
+const expect = chai.expect;
+chai.use(chaiAlmost(1e-3));
 
 describe('Geo Utils', () => {
 
@@ -10,30 +14,92 @@ describe('Geo Utils', () => {
 
         let samples;
 
-        const route = [
-            new Coordinates(45.0, 5.0),
-            new Coordinates(45.000735, 5.0007303),
-            new Coordinates(45.000735, 5.0007303),
-            new Coordinates(45.0003702, 5.0011008)
-        ];
+        const p1 = new Coordinates(45.0, 5.0);
+        const p2 = p1.destinationPoint(100, Math.PI / 4);
+        const p3 = p2.destinationPoint(49.9, Math.PI / 2);
+        const route = [p1, p2, p3];
 
-        samples = Utils.sampleRoute(route, 10);
-        expect(samples.length).equals(16);
-
-        // Do not consider the last point
-        for (let i = 0; i < samples.length - 2; i++) {
-            // Do not consider the turn, only straight lines
-            if (i === 9) {
+        samples = Utils.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
+            if (i === Math.floor(100 / 0.7)) {
                 i++;
             }
-            expect(10 - samples[i].distanceTo(samples[i + 1])).is.below(1e-8);
+            expect(samples[i].distanceTo(samples[i + 1])).to.almost.equal(0.7);
         }
 
-        samples = Utils.sampleRoute(route, 10, 100);
-        expect(samples.length).equals(11);
+        samples = Utils.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);
+        expect(samples.length).equals(10);
+
+
+        samples = Utils.sampleRoute(route, 10, 50, 12);
+        expect(samples.length).equals(2);
+
+        samples = Utils.sampleRoute(route, 10, 50, 100);
+        expect(samples.length).equals(10);
+
+        samples = Utils.sampleRoute(route, 10, 110, 12);
+        expect(samples.length).equals(2);
 
-        samples = Utils.sampleRoute(route);
-        expect(samples.length).equals(216);
     });
 
+    it('trimRoute', () => {
+
+        let newRoute;
+
+        const p1 = new Coordinates(45.0, 5.0);
+        const p2 = p1.destinationPoint(100, Math.PI / 4);
+        const p3 = p2.destinationPoint(49.9, Math.PI / 2);
+        const route = [p1, p2, p3];
+
+        expect(() => Utils.trimRoute(route, new Coordinates(0, 0))).throw(Error);
+
+        newRoute = Utils.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);
+        expect(newRoute.length).equals(2);
+        expect(newRoute[0].equalsTo(p1)).true;
+        expect(newRoute[1].equalsTo(p2)).true;
+
+        newRoute = Utils.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);
+        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);
+        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);
+        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);
+        expect(newRoute.length).equals(3);
+        expect(newRoute[0].equalsTo(p4)).true;
+        expect(newRoute[1].equalsTo(p2)).true;
+        expect(newRoute[2].equalsTo(p3)).true;
+    });
 });