@wemap/geo 1.0.1 → 1.0.2

package/index.js

@@ -2,12 +2,14 @@ import Constants from './src/Constants';
 
 import Attitude from './src/rotations/Attitude';
 
+import BoundingBox from './src/coordinates/BoundingBox';
 import Level from './src/coordinates/Level';
 import WGS84 from './src/coordinates/WGS84';
 import WGS84UserPosition from './src/coordinates/WGS84UserPosition';
 
 export {
     Attitude,
+    BoundingBox,
     Constants,
     Level,
     WGS84,

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "1.0.1",
+    "version": "1.0.2",
     "bugs": {
         "url": "https://github.com/wemap/wemap-utils-js/issues"
     },
@@ -28,8 +28,9 @@
     "license": "ISC",
     "dependencies": {
         "@wemap/maths": "^0.2.1",
+        "lodash.isfinite": "^3.3.2",
         "lodash.isnumber": "^3.0.3",
         "lodash.isstring": "^4.0.1"
     },
-    "gitHead": "f4d8fe98fff281533d884e0479894662c4dec9fe"
+    "gitHead": "ba6b8ab6550b6b3bf87eddff821865e3147cfc96"
 }

package/src/coordinates/BoundingBox.js

@@ -0,0 +1,186 @@
+import WGS84 from './WGS84';
+import isNumber from 'lodash.isnumber';
+import isFinite from 'lodash.isfinite';
+
+class BoundingBox {
+
+    northEast;
+    southWest;
+
+    constructor(northEast, southWest) {
+        this.southWest = southWest || null;
+        this.northEast = northEast || null;
+
+        if (this.southWest && this.northEast
+            && (
+                this.southWest.lat > this.northEast.lat
+                || this.southWest.lng > this.northEast.lng)
+        ) {
+            throw new Error('Incorrect bounding box');
+        }
+    }
+
+    /**
+     * Returns the geographical coordinate equidistant from the bounding box's corners.
+     *
+     * @returns {WGS84} The bounding box's center.
+     */
+    get center() {
+        const latCenter = (this.southWest.lat + this.northEast.lat) / 2;
+        const lngCenter = (this.northEast.lng + this.southWest.lng) / 2;
+        return new WGS84(latCenter, lngCenter);
+    }
+
+    /**
+     * Check if a point is contained in the bounding box.
+     *
+     * @returns {WGS84} The point to analyze.
+     */
+    contains(point) {
+        return point.lat <= this.northEast.lat
+            && point.lat >= this.southWest.lat
+            && point.lng <= this.northEast.lng
+            && point.lng >= this.southWest.lng;
+    }
+
+    /**
+     * Extend the bounds to include a given LngLat or LngLatBounds.
+     *
+     * @param {WGS84|BoundingBox} obj object to extend to
+     * @returns {BoundingBox} `this`
+     */
+    extend(obj) {
+        const sw = this.southWest,
+            ne = this.northEast;
+        let sw2, ne2;
+
+        if (obj instanceof WGS84) {
+            sw2 = obj;
+            ne2 = obj;
+
+        } else if (obj instanceof BoundingBox) {
+            sw2 = obj.southWest;
+            ne2 = obj.northEast;
+
+            if (!sw2 || !ne2) {
+                return this;
+            }
+        } else {
+            throw new Error('Unknown parameter');
+        }
+
+        if (!sw && !ne) {
+            this.southWest = new WGS84(sw2.lat, sw2.lng);
+            this.northEast = new WGS84(ne2.lat, ne2.lng);
+
+        } else {
+            sw.lat = Math.min(sw2.lat, sw.lat);
+            sw.lng = Math.min(sw2.lng, sw.lng);
+            ne.lat = Math.max(ne2.lat, ne.lat);
+            ne.lng = Math.max(ne2.lng, ne.lng);
+        }
+
+        return this;
+    }
+
+    /**
+     * This method extends the bounding box with a value in meters
+     * /*\ This method is not precise as distance differs in function of latitude
+     * @param {Number} measure in meters
+     */
+    extendsWithMeasure(measure) {
+
+        if (!isNumber(measure) || !isFinite(measure)) {
+            throw new Error('measure is not a number');
+        }
+
+        this.northEast = this.northEast
+            .destinationPoint(measure, 0)
+            .move(measure, Math.PI / 2);
+
+        this.southWest = this.southWest.clone()
+            .destinationPoint(measure, -Math.PI / 2)
+            .destinationPoint(measure, Math.PI);
+
+        return this;
+    }
+
+    /**
+     * Returns the southwest corner of the bounding box.
+     *
+     * @returns {WGS84} The southwest corner of the bounding box.
+     */
+    getSouthWest() {
+        return this.southWest;
+    }
+
+    /**
+    * Returns the northeast corner of the bounding box.
+    *
+    * @returns {WGS84} The northeast corner of the bounding box.
+     */
+    getNorthEast() {
+        return this.northEast;
+    }
+
+    /**
+    * Returns the northwest corner of the bounding box.
+    *
+    * @returns {WGS84} The northwest corner of the bounding box.
+     */
+    getNorthWest() {
+        return new WGS84(this.getNorth(), this.getWest());
+    }
+
+    /**
+    * Returns the southeast corner of the bounding box.
+    *
+    * @returns {LngLat} The southeast corner of the bounding box.
+     */
+    getSouthEast() {
+        return new WGS84(this.getSouth(), this.getEast());
+    }
+
+    /**
+    * Returns the west edge of the bounding box.
+    *
+    * @returns {number} The west edge of the bounding box.
+     */
+    getWest() {
+        return this.southWest.lng;
+    }
+
+    /**
+    * Returns the south edge of the bounding box.
+    *
+    * @returns {number} The south edge of the bounding box.
+     */
+    getSouth() {
+        return this.southWest.lat;
+    }
+
+    /**
+    * Returns the east edge of the bounding box.
+    *
+    * @returns {number} The east edge of the bounding box.
+     */
+    getEast() {
+        return this.northEast.lng;
+    }
+
+    /**
+    * Returns the north edge of the bounding box.
+    *
+    * @returns {number} The north edge of the bounding box.
+     */
+    getNorth() {
+        return this.northEast.lat;
+    }
+
+    equalsTo(other) {
+        return WGS84.equalsTo(this.northEast, other.northEast)
+            && WGS84.equalsTo(this.southWest, other.southWest);
+    }
+}
+
+export default BoundingBox;

package/src/coordinates/BoundingBox.spec.js

@@ -0,0 +1,128 @@
+/* eslint-disable max-nested-callbacks */
+import chai from 'chai';
+import chaiAlmost from 'chai-almost';
+
+import BoundingBox from './BoundingBox';
+import Logger from '@wemap/logger';
+import WGS84 from './WGS84';
+
+const expect = chai.expect;
+chai.use(chaiAlmost());
+Logger.enable(false);
+
+let boundingBox;
+const northEast = new WGS84(10, 40);
+const southWest = new WGS84(-5, -20);
+
+const checkBounds = (bb, [north, east, south, west]) => {
+    return north === bb.northEast.lat
+        && east === bb.northEast.lng
+        && south === bb.southWest.lat
+        && west === bb.southWest.lng;
+};
+
+describe('Bounding Box', () => {
+
+    it('creation', () => {
+        boundingBox = new BoundingBox();
+        expect(boundingBox.northEast).is.null;
+        expect(boundingBox.southWest).is.null;
+
+        expect(() => new BoundingBox(new WGS84(10, -20), new WGS84(-5, 40))).is.throw(Error);
+
+        boundingBox = new BoundingBox(northEast, southWest);
+        expect(boundingBox.northEast).equals(northEast);
+        expect(boundingBox.southWest).equals(southWest);
+    });
+
+
+    it('center', () => {
+        boundingBox = new BoundingBox();
+        expect(() => boundingBox.center).is.throw(Error);
+
+        boundingBox = new BoundingBox(northEast, southWest);
+        const center = boundingBox.center;
+        expect(center.lat).equals(2.5);
+        expect(center.lng).equals(10);
+    });
+
+
+    it('contains', () => {
+        boundingBox = new BoundingBox();
+        expect(() => boundingBox.contains(new WGS84(0, 0))).is.throw(Error);
+
+        boundingBox = new BoundingBox(northEast, southWest);
+        expect(() => boundingBox.contains(null)).is.throw(Error);
+        expect(boundingBox.contains(new WGS84(0, 0))).true;
+        expect(boundingBox.contains(new WGS84(10, 0))).true;
+        expect(boundingBox.contains(new WGS84(0, 10))).true;
+        expect(boundingBox.contains(new WGS84(-10, 0))).false;
+        expect(boundingBox.contains(new WGS84(0, -10))).true;
+        expect(boundingBox.contains(new WGS84(50, 50))).false;
+        expect(boundingBox.contains(new WGS84(-50, 50))).false;
+        expect(boundingBox.contains(new WGS84(50, -50))).false;
+        expect(boundingBox.contains(new WGS84(-50, -50))).false;
+    });
+
+    it('extend', () => {
+        boundingBox = new BoundingBox();
+        expect(() => boundingBox.extend(new WGS84(0, 0))).is.throw;
+
+        boundingBox = new BoundingBox(northEast, southWest);
+        expect(() => boundingBox.extend(null)).is.throw(Error);
+        expect(checkBounds(
+            boundingBox.extend(new WGS84(0, 0)),
+            [10, 40, -5, -20]
+        )).true;
+        expect(checkBounds(
+            boundingBox.extend(new WGS84(20, 0)),
+            [20, 40, -5, -20]
+        )).true;
+        expect(checkBounds(
+            boundingBox.extend(new WGS84(20, 40)),
+            [20, 40, -5, -20]
+        )).true;
+        expect(checkBounds(
+            boundingBox.extend(new WGS84(30, 40)),
+            [30, 40, -5, -20]
+        )).true;
+    });
+
+
+    it('extend with measure', () => {
+        let measure, extended;
+
+        boundingBox = new BoundingBox();
+        expect(() => boundingBox.extendsWithMeasure(100)).is.throw(Error);
+
+        boundingBox = new BoundingBox(northEast, southWest);
+        expect(() => boundingBox.extendsWithMeasure(null)).is.throw(Error);
+
+        boundingBox = new BoundingBox(northEast, southWest);
+        measure = 50000;
+        extended = boundingBox.extendsWithMeasure(measure);
+        expect(new WGS84(extended.northEast.lat, northEast.lng).distanceTo(northEast))
+            .be.closeTo(measure, 0.05 * measure);
+        expect(new WGS84(northEast.lat, extended.northEast.lng).distanceTo(northEast))
+            .be.closeTo(measure, 0.05 * measure);
+        expect(new WGS84(extended.southWest.lat, southWest.lng).distanceTo(southWest))
+            .be.closeTo(measure, 0.05 * measure);
+        expect(new WGS84(southWest.lat, extended.southWest.lng).distanceTo(southWest))
+            .be.closeTo(measure, 0.05 * measure);
+
+
+        boundingBox = new BoundingBox(northEast, southWest);
+        measure = 50;
+        extended = boundingBox.extendsWithMeasure(measure);
+        expect(new WGS84(extended.northEast.lat, northEast.lng).distanceTo(northEast))
+            .be.closeTo(measure, 0.05 * measure);
+        expect(new WGS84(northEast.lat, extended.northEast.lng).distanceTo(northEast))
+            .be.closeTo(measure, 0.05 * measure);
+        expect(new WGS84(extended.southWest.lat, southWest.lng).distanceTo(southWest))
+            .be.closeTo(measure, 0.05 * measure);
+        expect(new WGS84(southWest.lat, extended.southWest.lng).distanceTo(southWest))
+            .be.closeTo(measure, 0.05 * measure);
+    });
+
+
+});

package/src/coordinates/Level.js

@@ -1,5 +1,5 @@
 import Logger from '@wemap/logger';
-import isNumber from 'lodash.isnumber';
+import isFinite from 'lodash.isfinite';
 import isString from 'lodash.isstring';
 
 /**
@@ -17,10 +17,10 @@ class Level {
      * @param {Number} arg2 (optional) up value
      */
     constructor(arg1, arg2) {
-        if (!isNumber(arg1)) {
+        if (!isFinite(arg1)) {
             throw new Error('first argument is mandatory');
         }
-        if (isNumber(arg2)) {
+        if (isFinite(arg2)) {
             if (arg1 === arg2) {
                 this.isRange = false;
                 this.val = arg1;
@@ -29,9 +29,11 @@ class Level {
                 this.low = Math.min(arg1, arg2);
                 this.up = Math.max(arg1, arg2);
             }
-        } else {
+        } else if (typeof arg2 === 'undefined'){
             this.isRange = false;
             this.val = arg1;
+        } else {
+            throw new Error('second argument is not a number');
         }
     }
 

package/src/coordinates/Level.spec.js

@@ -31,7 +31,7 @@ describe('Level', () => {
 
         listOfLevels.forEach(value1 => {
             if (listOfInvalidLevel.includes(value1)) {
-                expect(() => new Level(value1)).is.throw;
+                expect(() => new Level(value1)).is.throw(Error);
             } else {
                 checkSingle(new Level(value1), value1);
             }
@@ -39,8 +39,8 @@ describe('Level', () => {
             listOfLevels.forEach(value2 => {
                 if (listOfInvalidLevel.includes(value1)
                     || listOfInvalidLevel.includes(value2)) {
-                    expect(() => new Level(value1, value2)).is.throw;
-                    expect(() => new Level(value2, value1)).is.throw;
+                    expect(() => new Level(value1, value2)).is.throw(Error);
+                    expect(() => new Level(value2, value1)).is.throw(Error);
                 } else if (value1 === value2) {
                     checkSingle(new Level(value1), value1);
                 } else {

package/src/coordinates/WGS84.js

@@ -65,13 +65,17 @@ class WGS84 {
         return output;
     }
 
-    equalsTo(other) {
-
-        if (!(other instanceof WGS84)) {
+    static equalsTo(pos1, pos2) {
+        if (!(pos1 instanceof WGS84) || !(pos2 instanceof WGS84)) {
             return false;
         }
+        return pos2.lat === pos1.lat
+            && pos2.lng === pos1.lng
+            && Level.equalsTo(pos2.level, pos1.level);
+    }
 
-        return other.lat === this.lat && other.lng === this.lng && Level.equalsTo(other.level, this.level);
+    equalsTo(other) {
+        return WGS84.equalsTo(this, other);
     }
 
     toString() {
@@ -109,6 +113,8 @@ class WGS84 {
         this.lat = Utils.rad2deg(φ2);
         this.lng = Utils.rad2deg(λ2);
         this.alt = altitude;
+
+        return this;
     }
 
     /**