@wemap/geo 3.2.6 → 3.2.16

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "3.2.6",
+    "version": "3.2.16",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -27,7 +27,7 @@
     "license": "ISC",
     "dependencies": {
         "@wemap/logger": "^3.2.3",
-        "@wemap/maths": "^3.2.3"
+        "@wemap/maths": "^3.2.15"
     },
-    "gitHead": "0b4bcb307a86aa10d123603698961463baf931fd"
+    "gitHead": "01e6c2ed3b4f24b230cb6a774fe159e7b20b810a"
 }

package/src/Utils.js

@@ -1,4 +1,10 @@
 /* eslint-disable max-statements */
+
+import {
+    deg2rad, positiveMod
+} from '@wemap/maths';
+
+import Constants from './Constants.js';
 import Coordinates from './coordinates/Coordinates.js';
 
 class Utils {
@@ -106,7 +112,8 @@ class Utils {
         while (currentPointIndex < route.length) {
             const currentPoint = route[currentPointIndex];
             const dist = previousPoint.distanceTo(currentPoint);
-            if (cumulativeDistance + dist >= length) {
+            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);
@@ -121,6 +128,39 @@ class Utils {
 
         return newRoute;
     }
+
+    /**
+     * @param {Coordinates[]} coords
+     * @param {number} precision
+     * @returns {Coordinates[]}
+     */
+    static 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;
+    }
 }
 
 export default Utils;

package/src/Utils.spec.js

@@ -102,4 +102,41 @@ describe('Geo Utils', () => {
         expect(newRoute[1].equalsTo(p2)).true;
         expect(newRoute[2].equalsTo(p3)).true;
     });
+
+    it('simplifyRoute', () => {
+
+        let route, routeSimplified;
+
+        route = [
+            new Coordinates(48.756308386983484, 2.0549525696601694),
+            new Coordinates(48.75630194782273, 2.054987452552288),
+            new Coordinates(48.756294588780854, 2.055026521391461),
+            new Coordinates(48.7563159759933, 2.0550474511267316),
+            new Coordinates(48.756350241508265, 2.0550837293345348)
+        ];
+
+        routeSimplified = Utils.simplifyRoute(route);
+        expect(routeSimplified.length).equal(3);
+        expect(routeSimplified).to.include(route[0]);
+        expect(routeSimplified).to.not.include(route[1]);
+        expect(routeSimplified).to.include(route[2]);
+        expect(routeSimplified).to.not.include(route[3]);
+        expect(routeSimplified).to.include(route[4]);
+
+
+        route = [
+            new Coordinates(48.75627274161895, 2.054974197053283),
+            new Coordinates(48.756269751891594, 2.0549905921869933),
+            new Coordinates(48.756274912970845, 2.054992757591672),
+            new Coordinates(48.75628117553095, 2.0549584148199345),
+            new Coordinates(48.756276014452325, 2.054956249415256),
+            new Coordinates(48.75627274161895, 2.054974197053283)
+        ];
+
+        routeSimplified = Utils.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.js

@@ -6,10 +6,10 @@ class BoundingBox {
     southWest;
 
     constructor(northEast, southWest) {
-        this.southWest = southWest || null;
         this.northEast = northEast || null;
+        this.southWest = southWest || null;
 
-        if (this.southWest && this.northEast && this.getNorth() < this.getSouth()) {
+        if (this.northEast && this.southWest && this.getNorth() < this.getSouth()) {
             throw new Error('Incorrect bounding box');
         }
     }

package/src/coordinates/Coordinates.js

@@ -18,6 +18,8 @@ import Level from './Level.js';
  */
 class Coordinates {
 
+    autoWrap = true;
+
     constructor(lat, lng, alt, level) {
         this.lat = lat;
         this.lng = lng;
@@ -66,13 +68,8 @@ class Coordinates {
     set lng(lng) {
         if (typeof lng === 'number') {
             this._lng = lng;
-            if (Math.abs(lng) >= 180) {
-                // from https://stackoverflow.com/a/2323034/2239938
-                this._lng = this._lng % 360;
-                this._lng = (this._lng + 360) % 360;
-                if (this._lng > 180) {
-                    this._lng -= 360;
-                }
+            if (this.autoWrap) {
+                this.wrap();
             }
         } else {
             throw new Error('lng argument is not a number');
@@ -111,6 +108,12 @@ class Coordinates {
         return output;
     }
 
+    wrap() {
+        if (this._lng <= -180 || this._lng > 180) {
+            this._lng = Utils.wrap(this._lng, -180, 180);
+        }
+    }
+
     /**
      * Compares two Coordinates
      * @param {Coordinates} pos1 position 1
@@ -316,7 +319,7 @@ class Coordinates {
         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))) > 1e-6) {
+        if (Math.abs((p1.distanceTo(p2) - p1.distanceTo(projection) - p2.distanceTo(projection))) > Constants.EPS_MM) {
             return null;
         }