@wemap/geo 1.0.5 → 2.7.1

package/index.js

@@ -1,4 +1,5 @@
 import Constants from './src/Constants';
+import Utils from './src/Utils';
 
 import Attitude from './src/rotations/Attitude';
 
@@ -12,6 +13,7 @@ export {
     BoundingBox,
     Constants,
     Level,
+    Utils,
     WGS84,
     WGS84UserPosition
 };

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "1.0.5",
+    "version": "2.7.1",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -27,10 +27,11 @@
     ],
     "license": "ISC",
     "dependencies": {
-        "@wemap/maths": "^1.0.1",
+        "@wemap/logger": "^2.7.0",
+        "@wemap/maths": "^2.7.0",
         "lodash.isfinite": "^3.3.2",
         "lodash.isnumber": "^3.0.3",
         "lodash.isstring": "^4.0.1"
     },
-    "gitHead": "1ccef947faf3f37aba592594efe06575b6542170"
+    "gitHead": "3d332f1dce308ba28f2a551c2e709e840c54bd83"
 }

package/src/Constants.js

@@ -2,7 +2,17 @@ const Constants = {
     R_MAJOR: 6378137.0,
     R_MINOR: 6356752.3142,
     EARTH_GRAVITY: 9.80665,
-    EARTH_RADIUS_KM: 6371
+
+    /**
+     * latitude and longitude epsilon in degrees
+     * 1e-8° correspond to ~1mm at latitude = 0
+     */
+    EPS_DEG_MM: 1e-8,
+
+    /**
+     * epsilon in meters which corresponds to q millimeter
+     */
+    EPS_MM: 1e-3
 };
 
 Constants.ELLIPSOID_FLATNESS = (Constants.R_MAJOR - Constants.R_MINOR) / Constants.R_MAJOR;

package/src/Utils.js

@@ -0,0 +1,46 @@
+import WGS84 from './coordinates/WGS84';
+
+class Utils {
+
+    /**
+     * Sample a route of WGS84
+     * @param {Array.<WGS84>} route ordered points
+     * @param {*} stepSize step size to sample
+     * @param {*} maxLength max route length to sample
+     */
+    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;
+            }
+        }
+        sampledRoute.push(p2);
+
+        return sampledRoute;
+    }
+}
+
+export default Utils;

package/src/Utils.spec.js

@@ -0,0 +1,39 @@
+import { expect } from 'chai';
+
+import Utils from './Utils';
+import WGS84 from './coordinates/WGS84';
+
+
+describe('Geo Utils', () => {
+
+    it('sampleRoute', () => {
+
+        let samples;
+
+        const route = [
+            new WGS84(45.0, 5.0),
+            new WGS84(45.000735, 5.0007303),
+            new WGS84(45.000735, 5.0007303),
+            new WGS84(45.0003702, 5.0011008)
+        ];
+
+        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) {
+                i++;
+            }
+            expect(10 - samples[i].distanceTo(samples[i + 1])).is.below(1e-8);
+        }
+
+        samples = Utils.sampleRoute(route, 10, 100);
+        expect(samples.length).equals(11);
+
+        samples = Utils.sampleRoute(route);
+        expect(samples.length).equals(216);
+    });
+
+});

package/src/coordinates/Level.js

@@ -183,6 +183,7 @@ class Level {
         } else {
             this.val *= factor;
         }
+        return this;
     }
 
     toString() {

package/src/coordinates/Level.spec.js

@@ -98,6 +98,7 @@ describe('Level', () => {
     it('equalsTo', () => {
         const level = new Level(1);
         expect(Level.equalsTo(null, null)).true;
+        expect(Level.equalsTo(null, false)).true;
         expect(Level.equalsTo(level, level)).true;
         expect(Level.equalsTo(level, null)).false;
         expect(Level.equalsTo(null, level)).false;
@@ -141,19 +142,25 @@ describe('Level', () => {
         expect(Level.intersect(null, level)).equals(null);
         expect(Level.intersect(level, level)).equals(level);
 
-        expect(Level.equalsTo(Level.intersect(new Level(0, 1), new Level(1)), new Level(1)));
-        expect(Level.equalsTo(Level.intersect(new Level(0, 2), new Level(1)), new Level(1)));
-        expect(Level.equalsTo(Level.intersect(new Level(-1, 2), new Level(1)), new Level(1)));
-        expect(Level.equalsTo(Level.intersect(new Level(1), new Level(0, 1)), new Level(1)));
-        expect(Level.equalsTo(Level.intersect(new Level(1), new Level(0, 2)), new Level(1)));
-        expect(Level.equalsTo(Level.intersect(new Level(1), new Level(-1, 2)), new Level(1)));
-        expect(Level.equalsTo(Level.intersect(new Level(1, 2), new Level(-1, 2)), new Level(1, 2)));
-        expect(Level.equalsTo(Level.intersect(new Level(-3, 1), new Level(-1, 2)), new Level(-1, 1)));
-        expect(Level.equalsTo(Level.intersect(new Level(-3, -1), new Level(-1, 2)), new Level(-1)));
+        expect(Level.equalsTo(Level.intersect(new Level(1), new Level(1)), new Level(1))).true;
+        expect(Level.intersect(new Level(1), new Level(2))).is.null;
+
+        expect(Level.equalsTo(Level.intersect(new Level(0, 1), new Level(1)), new Level(1))).true;
+        expect(Level.equalsTo(Level.intersect(new Level(0, 2), new Level(1)), new Level(1))).true;
+        expect(Level.equalsTo(Level.intersect(new Level(-1, 2), new Level(1)), new Level(1))).true;
+        expect(Level.equalsTo(Level.intersect(new Level(1), new Level(0, 1)), new Level(1))).true;
+        expect(Level.equalsTo(Level.intersect(new Level(1), new Level(0, 2)), new Level(1))).true;
+        expect(Level.equalsTo(Level.intersect(new Level(1), new Level(-1, 2)), new Level(1))).true;
+        expect(Level.equalsTo(Level.intersect(new Level(1, 2), new Level(-1, 2)), new Level(1, 2))).true;
+        expect(Level.equalsTo(Level.intersect(new Level(-3, 1), new Level(-1, 2)), new Level(-1, 1))).true;
+        expect(Level.equalsTo(Level.intersect(new Level(-3, -1), new Level(-1, 2)), new Level(-1))).true;
         expect(Level.intersect(new Level(-3, -2), new Level(-1, 2))).is.null;
         expect(Level.intersect(new Level(-1, 2), new Level(-3, -2))).is.null;
         expect(Level.intersect(new Level(0), new Level(1, 2))).is.null;
         expect(Level.intersect(new Level(1, 2), new Level(0))).is.null;
+
+        expect(new Level(1, 2).intersect(new Level(0))).is.null;
+        expect(Level.equalsTo(new Level(-3, -1).intersect(new Level(-1, 2)), new Level(-1))).true;
     });
 
     it('union', () => {
@@ -164,31 +171,33 @@ describe('Level', () => {
         expect(Level.union(null, level)).equals(level);
         expect(Level.union(level, level)).equals(level);
 
-        expect(Level.equalsTo(Level.union(new Level(0, 1), new Level(1)), new Level(0, 1)));
-        expect(Level.equalsTo(Level.union(new Level(0, 2), new Level(1)), new Level(0, 2)));
-        expect(Level.equalsTo(Level.union(new Level(-1, 2), new Level(1)), new Level(-1, 2)));
-        expect(Level.equalsTo(Level.union(new Level(1), new Level(0, 1)), new Level(0, 1)));
-        expect(Level.equalsTo(Level.union(new Level(1), new Level(0, 2)), new Level(0, 2)));
-        expect(Level.equalsTo(Level.union(new Level(1), new Level(-1, 2)), new Level(-1, 2)));
-        expect(Level.equalsTo(Level.union(new Level(1, 2), new Level(-1, 2)), new Level(-1, 2)));
-        expect(Level.equalsTo(Level.union(new Level(-3, 1), new Level(-1, 2)), new Level(-3, 2)));
-        expect(Level.equalsTo(Level.union(new Level(-3, -1), new Level(-1, 2)), new Level(-3, 2)));
-        expect(Level.equalsTo(Level.union(new Level(-3, -2), new Level(-1, 2)), new Level(-3, 2)));
-        expect(Level.equalsTo(Level.union(new Level(-1, 2), new Level(-3, -2)), new Level(-3, 2)));
-        expect(Level.equalsTo(Level.union(new Level(0), new Level(1, 2)), new Level(0, 2)));
-        expect(Level.equalsTo(Level.union(new Level(1, 2), new Level(0)), new Level(0, 2)));
-
-        expect(Level.equalsTo(new Level(0, 1).union(new Level(1)), new Level(0, 1)));
+        expect(Level.equalsTo(Level.union(new Level(1), new Level(1)), new Level(1))).true;
+        expect(Level.equalsTo(Level.union(new Level(1), new Level(2)), new Level(1, 2))).true;
+        expect(Level.equalsTo(Level.union(new Level(0, 1), new Level(1)), new Level(0, 1))).true;
+        expect(Level.equalsTo(Level.union(new Level(0, 2), new Level(1)), new Level(0, 2))).true;
+        expect(Level.equalsTo(Level.union(new Level(-1, 2), new Level(1)), new Level(-1, 2))).true;
+        expect(Level.equalsTo(Level.union(new Level(1), new Level(0, 1)), new Level(0, 1))).true;
+        expect(Level.equalsTo(Level.union(new Level(1), new Level(0, 2)), new Level(0, 2))).true;
+        expect(Level.equalsTo(Level.union(new Level(1), new Level(-1, 2)), new Level(-1, 2))).true;
+        expect(Level.equalsTo(Level.union(new Level(1, 2), new Level(-1, 2)), new Level(-1, 2))).true;
+        expect(Level.equalsTo(Level.union(new Level(-3, 1), new Level(-1, 2)), new Level(-3, 2))).true;
+        expect(Level.equalsTo(Level.union(new Level(-3, -1), new Level(-1, 2)), new Level(-3, 2))).true;
+        expect(Level.equalsTo(Level.union(new Level(-3, -2), new Level(-1, 2)), new Level(-3, 2))).true;
+        expect(Level.equalsTo(Level.union(new Level(-1, 2), new Level(-3, -2)), new Level(-3, 2))).true;
+        expect(Level.equalsTo(Level.union(new Level(0), new Level(1, 2)), new Level(0, 2))).true;
+        expect(Level.equalsTo(Level.union(new Level(1, 2), new Level(0)), new Level(0, 2))).true;
+
+        expect(Level.equalsTo(new Level(0, 1).union(new Level(1)), new Level(0, 1))).true;
     });
 
 
     it('multiplyBy', () => {
-        expect(Level.equalsTo(new Level(0).multiplyBy(5), new Level(0)));
-        expect(Level.equalsTo(new Level(3).multiplyBy(2), new Level(6)));
-        expect(Level.equalsTo(new Level(-1).multiplyBy(5), new Level(-5)));
-        expect(Level.equalsTo(new Level(0, 1).multiplyBy(5), new Level(0, 5)));
-        expect(Level.equalsTo(new Level(-1, 1).multiplyBy(5), new Level(-5, 5)));
-        expect(Level.equalsTo(new Level(1, -1).multiplyBy(5), new Level(-5, 5)));
+        expect(Level.equalsTo(new Level(0).multiplyBy(5), new Level(0))).true;
+        expect(Level.equalsTo(new Level(3).multiplyBy(2), new Level(6))).true;
+        expect(Level.equalsTo(new Level(-1).multiplyBy(5), new Level(-5))).true;
+        expect(Level.equalsTo(new Level(0, 1).multiplyBy(5), new Level(0, 5))).true;
+        expect(Level.equalsTo(new Level(-1, 1).multiplyBy(5), new Level(-5, 5))).true;
+        expect(Level.equalsTo(new Level(1, -1).multiplyBy(5), new Level(-5, 5))).true;
     });
 
 });