Merge pull request #10 from khubo/between-circles

Add method to generate point between circles

Author: sagi

.circleci/config.yml

@@ -41,8 +41,12 @@ jobs:
           name: prettier
           command: yarn prettier:ci
       - run:
-          name: test & coveralls
-          command: yarn test --coverageReporters=text-lcov | yarn coveralls
+          name: jest
+          command: yarn test
+      - run:
+          name: codecov
+          command: yarn codecov
+
       - persist_to_workspace:
           root: ~/repo
           paths:

README.md

@@ -6,7 +6,7 @@ We use it to stress test our [geohash](https://en.wikipedia.org/wiki/Geohash) ba
 It works anywhere JavaScript runs.
 
 [![Build](https://circleci.com/gh/rmrs/random-location.svg?style=svg)](https://circleci.com/gh/rmrs/random-location)
-[![Coverage](https://coveralls.io/repos/github/rmrs/random-location/badge.svg?branch=modernize_js_repo)](https://coveralls.io/github/rmrs/random-location?branch=modernize_js_repo)
+[![Coverage](https://codecov.io/gh/rmrs/random-location/branch/master/graph/badge.svg)](https://codecov.io/gh/rmrs/random-location)
 [![Version](https://img.shields.io/npm/v/random-location.svg?style=flat-square)](http://npm.im/random-location)
 [![MIT License](https://img.shields.io/npm/l/random-location.svg?style=flat-square)](http://opensource.org/licenses/MIT)
 [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)
@@ -74,6 +74,24 @@ Where:
 - **`radius`** *required* The distance (meters) from `centerPoint`.
 - **`randomFn`** *optional* A random function. Output is >=0 and <=1. Allows usage of seeded random number generators (see [`seedrandom`](https://www.npmjs.com/package/seedrandom)) - more predictability when testing.
 
+### `randomLocation.randomAnnulusPoint(...)`
+
+Outputs a Point ( `{ latitude: ..., longitude: ... }`) of random coordinates in a region bounded by two concentric circles (annulus).
+
+Function definition:
+
+```js
+const randomCircumferencePoint= (centerPoint, radius, randomFn = Math.random) => { ... }
+```
+
+Where:
+
+- **`centerPoint`** *required* An object with a `latitude` and `longitude` fields.
+- **`innerRadius`** *required* The readius of the smaller circle.
+- **`outerRadius`** *required* The readius of the larger circle.
+- **`randomFn`** *optional* A random function. Output is >=0 and <=1. Allows usage of seeded random number generators (see [`seedrandom`](https://www.npmjs.com/package/seedrandom)) - more predictability when testing.
+
+
 
 ## Usage
 

index.d.ts

@@ -1,9 +1,23 @@
-declare module "random-location" {
-    interface Point {
-        latitude: number,
-        longitude: number
-    }
+declare module 'random-location' {
+  interface Point {
+    latitude: number;
+    longitude: number;
+  }
 
-    function randomCirclePoint(centerPoint: Point, radius: number, randomFn?: (...args: any[]) => number): Point;
-    function randomCircumferencePoint(centerPoint: Point, radius: number, randomFn?: (...args: any[]) => number): Point;
+  function randomCirclePoint (
+    centerPoint: Point,
+    radius: number,
+    randomFn?: (...args: any[]) => number
+  ): Point;
+  function randomCircumferencePoint (
+    centerPoint: Point,
+    radius: number,
+    randomFn?: (...args: any[]) => number
+  ): Point;
+  function randomAnnulusPoint (
+    centerPoint: PointerEvent,
+    innerRadius: number,
+    outerRadius: number,
+    randomFn?: (...args: any[]) => number
+  ): PointerEvent;
 }

package.json

@@ -12,30 +12,30 @@
     "build": "npm-run-all --parallel build:*",
     "build:babel": "babel --ignore '**/*.test.js' src -d dist --verbose",
     "build:webpack": "webpack --display-modules ./src -o dist/randomLocation.umd.js",
-    "prettier:ci": "prettier --list-different \"src/**/*.js\"",
+    "prettier:ci": "prettier --check \"src/**/*.js\"",
     "semantic-release": "yarn build && semantic-release"
   },
   "devDependencies": {
-    "@babel/cli": "^7.6.2",
-    "@babel/core": "^7.6.2",
-    "@babel/preset-env": "^7.6.2",
-    "@commitlint/cli": "^8.2.0",
-    "@commitlint/config-conventional": "^8.2.0",
-    "babel-eslint": "^10.0.3",
-    "coveralls": "^3.0.6",
-    "eslint": "^6.4.0",
-    "eslint-config-prettier": "^6.3.0",
-    "eslint-plugin-jest": "^22.17.0",
-    "eslint-plugin-prettier": "^3.1.1",
-    "husky": "^3.0.7",
-    "jest": "^24.9.0",
+    "@babel/cli": "^7.8.4",
+    "@babel/core": "^7.9.0",
+    "@babel/preset-env": "^7.9.5",
+    "@commitlint/cli": "^8.3.5",
+    "@commitlint/config-conventional": "^8.3.4",
+    "babel-eslint": "^10.1.0",
+    "codecov": "^3.6.5",
+    "eslint": "^6.8.0",
+    "eslint-config-prettier": "^6.11.0",
+    "eslint-plugin-jest": "^23.8.2",
+    "eslint-plugin-prettier": "^3.1.3",
+    "husky": "^4.2.5",
+    "jest": "^25.4.0",
     "npm-run-all": "4.1.5",
-    "prettier": "^1.18.2",
-    "rimraf": "3.0.0",
+    "prettier": "^2.0.5",
+    "rimraf": "3.0.2",
     "seedrandom": "^3.0.5",
-    "semantic-release": "^15.13.24",
-    "webpack": "4.41.0",
-    "webpack-cli": "^3.3.9"
+    "semantic-release": "^17.0.7",
+    "webpack": "4.43.0",
+    "webpack-cli": "^3.3.11"
   },
   "husky": {
     "hooks": {

src/index.js

@@ -3,8 +3,8 @@ const DEG_TO_RAD = Math.PI / 180.0;
 const THREE_PI = Math.PI * 3;
 const TWO_PI = Math.PI * 2;
 
-const toRadians = deg => deg * DEG_TO_RAD;
-const toDegrees = rad => rad / DEG_TO_RAD;
+const toRadians = (deg) => deg * DEG_TO_RAD;
+const toDegrees = (rad) => rad / DEG_TO_RAD;
 
 /*
 Given a centerPoint C and a radius R, returns a random point that is on the
@@ -69,6 +69,38 @@ const randomCirclePoint = (centerPoint, radius, randomFn = Math.random) => {
   );
 };
 
+/**
+ * Returns a random point in a region bounded by two concentric circles (annulus).
+ *
+ * centerPoint - the center point of both circles.
+ * innerRadius - the radius of the smaller circle.
+ * outerRadius - the radius of the larger circle
+ * randomFn -  *optional* A random function. Output is >=0 and <=1. Allows
+ * usage of seeded random number generators - i.e. allows us to predict
+ * generated random coordiantes. default is Math.random()
+ *
+ */
+const randomAnnulusPoint = (
+  centerPoint,
+  innerRadius,
+  outerRadius,
+  randomFn = Math.random
+) => {
+  if (innerRadius >= outerRadius) {
+    throw new Error(
+      `innerRadius (${innerRadius}) should be smaller than outerRadius (${outerRadius})`
+    );
+  }
+
+  const deltaRadius = outerRadius - innerRadius;
+
+  return randomCircumferencePoint(
+    centerPoint,
+    innerRadius + Math.sqrt(randomFn()) * deltaRadius,
+    randomFn
+  );
+};
+
 /*
 Returns the distance in meters between two points P1 and P2.
 
@@ -109,4 +141,5 @@ module.exports = {
   haversine,
   randomCircumferencePoint,
   randomCirclePoint,
+  randomAnnulusPoint,
 };

src/index.test.js

@@ -108,4 +108,65 @@ describe('random-location', () => {
       }
     });
   });
+
+  describe('random generation of random annulus points', () => {
+    test('innerRadius is larger than outerRadius', () => {
+      // Eiffel Tower
+      const P1 = {
+        latitude: 48.8583736,
+        longitude: 2.2922926,
+      };
+      const innerRadius = 1000; // meters
+      const outerRadius = 123;
+      expect(() =>
+        randomLocation.randomAnnulusPoint(P1, innerRadius, outerRadius)
+      ).toThrow(
+        `innerRadius (${innerRadius}) should be smaller than outerRadius (${outerRadius})`
+      );
+    });
+
+    test('on an annulus of two concentric circles', () => {
+      // Eiffel Tower
+      const P1 = {
+        latitude: 48.8583736,
+        longitude: 2.2922926,
+      };
+      const innerRadius = 1000; // meters
+      const outerRadius = 2000;
+
+      for (let i = 0; i < 100; i++) {
+        const randomPoint = randomLocation.randomAnnulusPoint(
+          P1,
+          innerRadius,
+          outerRadius
+        );
+        const distance = Math.floor(randomLocation.distance(P1, randomPoint));
+        expect(distance).toBeLessThanOrEqual(outerRadius);
+        expect(distance).toBeGreaterThanOrEqual(innerRadius);
+      }
+    });
+    test('on an annulus of two concentric circles; using seedrandom', () => {
+      // Eiffel Tower
+      const P1 = {
+        latitude: 48.8583736,
+        longitude: 2.2922926,
+      };
+      const innerRadius = 1000; // meters
+      const outerRadius = 2000;
+      const seed = 'this is another seed';
+      const randomFn = seedrandom(seed);
+
+      for (let i = 0; i < 100; i++) {
+        const randomPoint = randomLocation.randomAnnulusPoint(
+          P1,
+          innerRadius,
+          outerRadius,
+          randomFn
+        );
+        const distance = Math.floor(randomLocation.distance(P1, randomPoint));
+        expect(distance).toBeLessThanOrEqual(outerRadius);
+        expect(distance).toBeGreaterThanOrEqual(innerRadius);
+      }
+    });
+  });
 });