@wemap/geo 3.1.15 → 3.1.19

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "3.1.15",
+    "version": "3.1.19",
     "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": "4a4167fd2159c856b90e6a566595ae5945f92d2e"
 }

package/src/Utils.js

@@ -1,3 +1,4 @@
+/* eslint-disable max-statements */
 import Coordinates from './coordinates/Coordinates';
 
 class Utils {
@@ -8,39 +9,63 @@ 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;
     }
+
 }
 
 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,39 @@ 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);
-        expect(samples.length).equals(216);
-    });
+        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);
+
+    });
 });