@wemap/geo 3.0.0 → 3.1.6

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "3.0.0",
+    "version": "3.1.6",
     "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": "2bbb4840a99b90eaae989291cb728ac87cebade8"
+    "gitHead": "f7967fd5b465e1e2be1c575ef0f2150adde4825f"
 }

package/src/Constants.js

@@ -24,5 +24,6 @@ Constants.R_MAJOR_4 = Constants.R_MAJOR_2 * Constants.R_MAJOR_2;
 Constants.R_MINOR_2 = Constants.R_MINOR * Constants.R_MINOR;
 Constants.R_MINOR_4 = Constants.R_MINOR_2 * Constants.R_MINOR_2;
 Constants.ECCENTRICITY_2 = Constants.ECCENTRICITY * Constants.ECCENTRICITY;
+Constants.CIRCUMFERENCE = Constants.R_MAJOR * 2 * Math.PI;
 
 export default Constants;

package/src/coordinates/BoundingBox.js

@@ -109,6 +109,26 @@ class BoundingBox {
         return this;
     }
 
+    /**
+     * Returns bounds created by extending or retracting the current bounds by a given ratio in each direction.
+     * For example, a ratio of 0.5 extends the bounds by 50% in each direction.
+     * Negative values will retract the bounds.
+     * @param {Number} bufferRatio
+     * @returns {BoundingBox} `this`
+     */
+    pad(bufferRatio) {
+        const sw = this.southWest;
+        const ne = this.northEast;
+
+        const heightBuffer = Math.abs(sw.lat - ne.lat) * bufferRatio;
+        const widthBuffer = Math.abs(sw.lng - ne.lng) * bufferRatio;
+
+        this.southWest = new Coordinates(sw.lat - heightBuffer, sw.lng - widthBuffer);
+        this.northEast = new Coordinates(ne.lat + heightBuffer, ne.lng + widthBuffer);
+
+        return this;
+    }
+
     /**
      * Returns the southwest corner of the bounding box.
      *

package/src/coordinates/Level.js

@@ -72,11 +72,46 @@ class Level {
     }
 
     /**
-     * Is the given number inside the current level
-     * @param {Number} val the given number
+     * Returns if the level is inside the given level
+     * @param {Level} level the container level
      */
-    isInside(val) {
-        return this.isRange ? val >= this.low && val <= this.up : val === this.val;
+    isInside(level) {
+        return Level.contains(level, this);
+    }
+
+    /**
+     * Returns if the level is inside the given level
+     * @param {Level} level the container level
+     */
+    contains(level) {
+        return Level.contains(this, level);
+    }
+
+
+    /**
+     * Returns if a level is contained in another
+     * @param {Level} container The container level
+     * @param {Level} targeted The targeted level
+     */
+    static contains(container, targeted) {
+
+        if (container === targeted) {
+            return true;
+        }
+
+        if (!container || !targeted) {
+            return false;
+        }
+
+        if (!container.isRange) {
+            if (targeted.isRange) {
+                return false;
+            }
+            return container.val === targeted.val;
+        }
+
+        return container.up >= (targeted.isRange ? targeted.up : targeted.val)
+            && container.low <= (targeted.isRange ? targeted.low : targeted.val);
     }
 
     /**
@@ -110,13 +145,13 @@ class Level {
         }
 
         if (first.isRange && !second.isRange) {
-            if (first.isInside(second.val)) {
+            if (first.contains(second)) {
                 return second.clone();
             }
             return null;
         }
         if (!first.isRange && second.isRange) {
-            if (second.isInside(first.val)) {
+            if (second.contains(first)) {
                 return first.clone();
             }
             return null;

package/src/coordinates/Level.spec.js

@@ -120,20 +120,38 @@ describe('Level', () => {
         expect(Level.equalsTo(new Level(-1.5, 1).clone(), new Level(-1.5, 1))).true;
     });
 
-    it('isInside', () => {
-        expect(new Level(0).isInside(0)).true;
-        expect(new Level(1).isInside(0)).false;
-        expect(new Level(-1).isInside(0)).false;
-        expect(new Level(0).isInside(1)).false;
-        expect(new Level(0).isInside(-1)).false;
-        expect(new Level(0, 2).isInside(0)).true;
-        expect(new Level(0, 2).isInside(1)).true;
-        expect(new Level(0, 2).isInside(-1)).false;
-        expect(new Level(2, 0).isInside(0)).true;
-        expect(new Level(2, 0).isInside(1)).true;
-        expect(new Level(2, 0).isInside(-1)).false;
+    it('contains', () => {
+        expect(Level.contains(null, null)).true;
+        expect(Level.contains(new Level(0), null)).false;
+        expect(Level.contains(null, new Level(0))).false;
+
+        expect(Level.contains(new Level(0), new Level(0))).true;
+        expect(Level.contains(new Level(1), new Level(0))).false;
+        expect(Level.contains(new Level(-1), new Level(0))).false;
+        expect(Level.contains(new Level(0), new Level(1))).false;
+        expect(Level.contains(new Level(0), new Level(-1))).false;
+        expect(Level.contains(new Level(0, 2), new Level(0))).true;
+        expect(Level.contains(new Level(0, 2), new Level(1))).true;
+        expect(Level.contains(new Level(0, 2), new Level(-1))).false;
+        expect(Level.contains(new Level(2, 0), new Level(0))).true;
+        expect(Level.contains(new Level(2, 0), new Level(1))).true;
+        expect(Level.contains(new Level(2, 0), new Level(-1))).false;
+
+        expect(Level.contains(new Level(0), new Level(0, 1))).false;
+        expect(Level.contains(new Level(1), new Level(0, 1))).false;
+        expect(Level.contains(new Level(1), new Level(0, 2))).false;
+
+        expect(Level.contains(new Level(0, 1), new Level(0, 1))).true;
+        expect(Level.contains(new Level(0, 1), new Level(0, 2))).false;
+        expect(Level.contains(new Level(0, 2), new Level(0, 1))).true;
+        expect(Level.contains(new Level(0, 3), new Level(1, 2))).true;
+        expect(Level.contains(new Level(1, 2), new Level(0, 3))).false;
+
+        expect(new Level(0).isInside(new Level(0, 1))).true;
+
     });
 
+
     it('intersect', () => {
         expect(Level.intersect(null, null)).is.null;