node-red-contrib-tak-registration 0.2.1 → 0.3.1

package/node_modules/geojson-equality/test/test.js

@@ -0,0 +1,364 @@
+var expect = require('chai').expect,
+  Equality = require('../');
+describe('geojson-equality for Points', function() {
+  var g1 = { "type": "Point", "coordinates": [30, 10] },
+    g2 = { "type": "Point", "coordinates": [30, 10] },
+    g3 = { "type": "Point", "coordinates": [30, 11] },
+    g4 = { "type": "Point", "coordinates": [30, 10, 5]},
+    g5 = { "type": "Point", "coordinates": [30, 10, 5]},
+    eq = new Equality();
+  it('are equal', function() {
+    expect(eq.compare(g1,g2)).to.be.true;
+  });
+  it('are not equal', function() {
+    expect(eq.compare(g1,g3)).to.be.false;
+  });
+  it('are not equal with different point dimensions', function() {
+    expect(eq.compare(g1,g4)).to.be.false;
+  });
+  it('are equal with 3d points', function() {
+    expect(eq.compare(g4,g5)).to.be.true;
+  });
+});
+describe('geojson-equality for LineStrings', function() {
+  var g1 = { "type": "LineString", "coordinates":
+    [ [30, 10], [10, 30], [40, 40] ] },
+    g2 = { "type": "LineString", "coordinates":
+      [ [30, 10], [10, 30], [40, 40] ] };
+  it('are equal', function() {
+    var eq = new Equality();
+    expect(eq.compare(g1,g2)).to.be.true;
+  });
+  var g3 = { "type": "LineString", "coordinates":
+    [ [31, 10], [10, 30], [40, 40] ] };
+  it('are not equal', function() {
+    var eq = new Equality();
+    expect(eq.compare(g1,g3)).to.be.false;
+  });
+  var g4 = { "type": "LineString", "coordinates":
+    [ [40, 40], [10, 30], [30, 10]] };
+  it('reverse direction, direction is not matched, so both are equal', function() {
+    var eq = new Equality();
+    expect(eq.compare(g1,g4)).to.be.true;
+  });
+  it('reverse direction, direction is matched, so both are not equal', function() {
+    var eq = new Equality({direction: true});
+    expect(eq.compare(g1,g4)).to.be.false;
+  });
+});
+describe('geojson-equality for Polygons', function() {
+  var g1 = { "type": "Polygon", "coordinates": [
+    [[30, 10], [40, 40], [20, 40], [10, 20], [30, 10]]
+  ]};
+  var g2 = { "type": "Polygon", "coordinates": [
+    [[30, 10], [40, 40], [20, 40], [10, 20], [30, 10]]
+  ]};
+  it('are equal', function() {
+    var eq = new Equality();
+    expect(eq.compare(g1,g2)).to.be.true;
+  });
+  var g3 = { "type": "Polygon", "coordinates": [
+    [[30, 10], [41, 40], [20, 40], [10, 20], [30, 10]]
+  ]};
+  it('are not equal', function() {
+    var eq = new Equality();
+    expect(eq.compare(g1,g3)).to.be.false;
+  });
+  var g4 = { "type": "Polygon", "coordinates": [
+    [[30,10], [10,20], [20,40], [40,40], [30,10]]
+  ]};
+  it('reverse direction, direction is not matched, so both are equal', function() {
+    var eq = new Equality();
+    expect(eq.compare(g1,g4)).to.be.true;
+  });
+  it('reverse direction, direction is matched, so both are not equal', function() {
+    var eq = new Equality({direction: true});
+    expect(eq.compare(g1,g4)).to.be.false;
+  });
+  var g5 = { "type": "Polygon", "coordinates": [
+    [[10,20], [20,40], [40,40], [30,10], [10,20]]
+  ]};
+  it('reverse direction, diff start index, direction is not matched, so both are equal',
+  function() {
+    var eq = new Equality();
+    expect(eq.compare(g1,g5)).to.be.true;
+  });
+  it('reverse direction, diff start index, direction is matched, so both are not equal',
+  function() {
+    var eq = new Equality({direction: true});
+    expect(eq.compare(g1,g5)).to.be.false;
+  });
+  var gh1 = { "type": "Polygon", "coordinates": [
+    [[45, 45], [15, 40], [10, 20], [35, 10],[45, 45]],
+    [[20, 30], [35, 35], [30, 20], [20, 30]]
+  ]};
+  var gh2 = { "type": "Polygon", "coordinates": [
+    [[35, 10], [45, 45], [15, 40], [10, 20], [35, 10]],
+    [[20, 30], [35, 35], [30, 20], [20, 30]]
+  ]};
+  it('have holes too and diff start ind, direction is not matched, both are equal',
+  function() {
+    var eq = new Equality({direction: false});
+    expect(eq.compare(gh1,gh2)).to.be.true;
+  });
+  it('have holes too and diff start ind, direction is matched, so both are not equal',
+  function() {
+    var eq = new Equality({direction: true});
+    expect(eq.compare(gh1,gh2)).to.be.true;
+  });
+  var gprecision1 = { "type": "Polygon", "coordinates": [
+    [[30, 10], [40.12345, 40.12345], [20, 40], [10, 20], [30, 10]]
+  ]};
+  var gprecision2 = { "type": "Polygon", "coordinates": [
+    [[30, 10], [40.123389, 40.123378], [20, 40], [10, 20], [30, 10]]
+  ]};
+  it('after limiting precision, are equal', function() {
+    var eq = new Equality({precision: 3});
+    expect(eq.compare(gprecision1,gprecision2)).to.be.true;
+  });
+  it('with high precision, are not equal', function() {
+    var eq = new Equality({precision: 10});
+    expect(eq.compare(gprecision1,gprecision2)).to.be.false;
+  });
+
+});
+
+describe ('geojson-equality for Feature', function() {
+  it ('will not be equal with changed id', function() {
+    var f1 = {"type": "Feature", "id": "id1"};
+    var f2 = {"type": "Feature", "id": "id2"};
+    var eq = new Equality();
+    expect(eq.compare(f1, f2)).to.be.false;
+  });
+  it ('will not be equal with different count of properties', function() {
+    var f1 = {"type": "Feature", "id": "id1", "properties": {"foo": "bar"}};
+    var f2 = {"type": "Feature", "id": "id1", "properties": {"foo1": "bar", "foo2": "bar"}};
+    var eq = new Equality();
+    expect(eq.compare(f1, f2)).to.be.false;
+  });
+  it ('will not be equal with different keys in properties', function() {
+    var f1 = {"type": "Feature", "id": "id1", "properties": {"foo1": "bar"}};
+    var f2 = {"type": "Feature", "id": "id1", "properties": {"foo2": "bar"}};
+    var eq = new Equality();
+    expect(eq.compare(f1, f2)).to.be.false;
+  });
+  it ('will not be equal with different properties', function() {
+    var f1 = {"type": "Feature", "id": "id1", "properties": {"foo": "bar1"}};
+    var f2 = {"type": "Feature", "id": "id1", "properties": {"foo": "bar2"}};
+    var eq = new Equality();
+    expect(eq.compare(f1, f2)).to.be.false;
+  });
+  it ('will not be equal with different geometry', function() {
+    var f1 = {
+      "type": "Feature",
+      "id": "id1",
+      "properties": {"foo": "bar1"},
+      "geometry": { "type": "Polygon", "coordinates": [
+        [[30, 10], [41, 40], [20, 40], [10, 20], [30, 10]]
+      ]}
+    };
+    var f2 = {
+      "type": "Feature",
+      "id": "id1",
+      "properties": {"foo": "bar1"},
+      "geometry": { "type": "Polygon", "coordinates": [
+        [[40, 20], [31, 10], [30, 20], [30, 10], [10, 40]]
+      ]}
+    };
+    var eq = new Equality();
+    expect(eq.compare(f1, f2)).to.be.false;
+  });
+  it ('will be equal with nested properties', function() {
+    var f1 = {"type": "Feature", "id": "id1", "properties": {"foo": {"bar": "baz"}},
+      "geometry": {"type": "Point", "coordinates": [0, 1]}
+    };
+    var f2 = {"type": "Feature", "id": "id1", "properties": {"foo": {"bar": "baz"}},
+      "geometry": {"type": "Point", "coordinates": [0, 1]}
+    };
+    var eq = new Equality();
+    expect(eq.compare(f1, f2)).to.be.true;
+  });
+  it ('will not be equal with different nested properties', function() {
+    var f1 = {"type": "Feature", "id": "id1", "properties": {"foo": {"bar": "baz"}},
+      "geometry": {"type": "Point", "coordinates": [0, 1]}
+    };
+    var f2 = {"type": "Feature", "id": "id1", "properties": {"foo": {"bar": "baz2"}},
+      "geometry": {"type": "Point", "coordinates": [0, 1]}
+    };
+    var eq = new Equality();
+    expect(eq.compare(f1, f2)).to.be.false;
+  });
+  it ('will use a custom comparator if provided', function() {
+    var f1 = {
+      "type": "Feature",
+      "id": "id1",
+      "properties": {"foo_123": "bar"},
+      "geometry": { "type": "Polygon", "coordinates": [
+        [[40, 20], [31, 10], [30, 20], [30, 10], [10, 40]]
+      ]}
+    };
+    var f2 = {
+      "type": "Feature",
+      "id": "id1",
+      "properties": {"foo_456": "bar"},
+      "geometry": { "type": "Polygon", "coordinates": [
+        [[40, 20], [31, 10], [30, 20], [30, 10], [10, 40]]
+      ]}
+    };
+    var eq = new Equality({objectComparator: function(obj1, obj2) {
+      return ('foo_123' in obj1 && 'foo_456' in obj2);
+    }});
+    expect(eq.compare(f1, f2)).to.be.true;
+  });
+  it ('will not be equal if one has bbox and other not', function() {
+    var f1 = {"type": "Feature", "id": "id1", "bbox": [1, 2, 3, 4]},
+      f2 = {"type": "Feature", "id": "id1"},
+      eq = new Equality();
+    expect(eq.compare(f1, f2)).to.be.false;
+  });
+  it ('will not be equal if bboxes are not equal', function() {
+    var f1 = {"type": "Feature", "id": "id1", "bbox": [1, 2, 3, 4]},
+      f2 = {"type": "Feature", "id": "id1", "bbox": [1, 2, 3, 5]},
+      eq = new Equality();
+    expect(eq.compare(f1, f2)).to.be.false;
+  });
+  it ('equal features with bboxes', function() {
+    var f1 = {
+      "type": "Feature",
+      "id": "id1",
+      "properties": {"foo": "bar1"},
+      "geometry": { "type": "Polygon", "coordinates": [
+        [[30, 10], [41, 40], [20, 40], [10, 20], [30, 10]]
+      ]},
+      "bbox": [10, 10, 41, 40]
+    };
+    var f2 = {
+      "type": "Feature",
+      "id": "id1",
+      "properties": {"foo": "bar1"},
+      "geometry": { "type": "Polygon", "coordinates": [
+        [[30, 10], [41, 40], [20, 40], [10, 20], [30, 10]]
+      ]},
+      "bbox": [10, 10, 41, 40]
+    };
+    var eq = new Equality();
+    expect(eq.compare(f1, f2)).to.be.true;
+  });
+  it ('not equal features with equal bboxes', function() {
+    var f1 = {
+      "type": "Feature",
+      "id": "id1",
+      "properties": {"foo": "bar1"},
+      "geometry": { "type": "Polygon", "coordinates": [
+        [[30, 10], [41, 40], [20, 40], [10, 20], [30, 10]]
+      ]},
+      "bbox": [10, 10, 41, 40]
+    };
+    var f2 = {
+      "type": "Feature",
+      "id": "id1",
+      "properties": {"foo": "bar1"},
+      "geometry": { "type": "Polygon", "coordinates": [
+        [[30, 10], [41, 40], [20, 40], [10, 20], [30, 1]]
+      ]},
+      "bbox": [10, 10, 41, 40]
+    };
+    var eq = new Equality();
+    expect(eq.compare(f1, f2)).to.be.false;
+  });
+});
+
+describe('geojson-equality for MultiPoints', function() {
+  var g1 = { "type": "MultiPoint", "coordinates": [
+    [0, 40], [40, 30], [20, 20], [30, 10]
+  ]};
+  var g2 = { "type": "MultiPoint", "coordinates": [
+    [0, 40], [20, 20], [40, 30], [30, 10]
+  ]};
+  it('are equal', function() {
+    var eq = new Equality();
+    expect(eq.compare(g1,g2)).to.be.true;
+  });
+  var g3 = { "type": "MultiPoint", "coordinates": [
+    [10, 40], [20, 20], [40, 30], [30, 10]
+  ]};
+  it('are not equal', function() {
+    var eq = new Equality();
+    expect(eq.compare(g1,g3)).to.be.false;
+  });
+});
+
+describe('geojson-equality for MultiLineString', function() {
+  var g1 = { "type": "MultiLineString", "coordinates": [
+    [[30, 10], [10, 30], [40, 40]],
+    [[0, 10], [10, 0], [40, 40]]
+  ]};
+  var g2 = { "type": "MultiLineString", "coordinates": [
+    [[40, 40],[10, 30], [30, 10]],
+    [[0, 10], [10, 0], [40, 40]]
+  ]};
+  it('reverse direction, direction is not matched, so both are equal',
+    function() {
+      var eq = new Equality();
+      expect(eq.compare(g1,g2)).to.be.true;
+    }
+  );
+  it('reverse direction, direction is matched, so both are not equal',
+    function() {
+      var eq = new Equality({direction: true});
+      expect(eq.compare(g1,g2)).to.be.false;
+    }
+  );
+  var g3 = { "type": "MultiLineString", "coordinates": [
+    [[10, 10], [20, 20], [10, 40]],
+    [[40, 40], [30, 30], [40, 20], [30, 10]] ] };
+  it('both are not equal',
+    function() {
+      var eq = new Equality();
+      expect(eq.compare(g1,g3)).to.be.false;
+    }
+  );
+});
+describe('geojson-equality for MultiPolygon', function() {
+  var g1 = { "type": "MultiPolygon", "coordinates": [
+    [[[30, 20], [45, 40], [10, 40], [30, 20]]],
+    [[[15, 5], [40, 10], [10, 20], [5, 10], [15, 5]]]
+  ]};
+  var g2 = { "type": "MultiPolygon", "coordinates": [
+    [[[30, 20], [45, 40], [10, 40], [30, 20]]],
+    [[[15, 5], [40, 10], [10, 20], [5, 10], [15, 5]]]
+  ]};
+  it('both are equal', function() {
+    var eq = new Equality();
+    expect(eq.compare(g1,g2)).to.be.true;
+  });
+  var g3 = { "type": "MultiPolygon", "coordinates": [
+    [[[30, 20], [45, 40], [10, 40], [30, 20]]],
+    [[[15, 5], [400, 10], [10, 20], [5, 10], [15, 5]]]
+  ]};
+  it('both are not equal', function() {
+    var eq = new Equality();
+    expect(eq.compare(g1,g3)).to.be.false;
+  });
+  var gh1 = { "type": "MultiPolygon", "coordinates": [
+    [[[40, 40], [20, 45], [45, 30], [40, 40]]],
+    [
+      [[20, 35], [10, 30], [10, 10], [30, 5], [45, 20], [20, 35]],
+      [[30, 20], [20, 15], [20, 25], [30, 20]],
+      [[20, 10], [30, 10], [30, 15], [20, 10]]
+    ]
+  ]};
+  var gh2 = { "type": "MultiPolygon", "coordinates": [
+    [
+      [[20, 35], [10, 30], [10, 10], [30, 5], [45, 20], [20, 35]],
+      [[20, 10], [30, 10], [30, 15], [20, 10]],
+      [[30, 20], [20, 15], [20, 25], [30, 20]]
+    ],
+    [[[40, 40], [20, 45], [45, 30], [40, 40]]]
+  ]};
+  it('having holes, both are equal', function() {
+    var eq = new Equality();
+    expect(eq.compare(gh1,gh2)).to.be.true;
+  });
+});
+

package/node_modules/geojson-rbush/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Denis Carriere
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/node_modules/geojson-rbush/README.md

@@ -0,0 +1,213 @@
+# GeoJSON RBush
+
+[![Build Status](https://travis-ci.org/DenisCarriere/geojson-rbush.svg?branch=master)](https://travis-ci.org/DenisCarriere/geojson-rbush)
+[![npm version](https://badge.fury.io/js/geojson-rbush.svg)](https://badge.fury.io/js/geojson-rbush)
+[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/DenisCarriere/geojson-rbush/master/LICENSE)
+
+GeoJSON implementation of [RBush](https://github.com/mourner/rbush) — a high-performance JavaScript R-tree-based 2D spatial index for points and rectangles.
+
+## Install
+
+**npm**
+
+```bash
+$ npm install --save geojson-rbush
+```
+
+## API
+
+<!-- Generated by documentation.js. Update this documentation by updating the source code. -->
+
+#### Table of Contents
+
+-   [rbush](#rbush)
+-   [insert](#insert)
+-   [load](#load)
+-   [remove](#remove)
+-   [clear](#clear)
+-   [search](#search)
+-   [collides](#collides)
+-   [all](#all)
+-   [toJSON](#tojson)
+-   [fromJSON](#fromjson)
+
+### rbush
+
+GeoJSON implementation of [RBush](https://github.com/mourner/rbush#rbush) spatial index.
+
+**Parameters**
+
+-   `maxEntries` **[number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)** defines the maximum number of entries in a tree node. 9 (used by default) is a
+    reasonable choice for most applications. Higher value means faster insertion and slower search, and vice versa. (optional, default `9`)
+
+**Examples**
+
+```javascript
+var geojsonRbush = require('geojson-rbush').default;
+var tree = geojsonRbush();
+```
+
+Returns **RBush** GeoJSON RBush
+
+### insert
+
+[insert](https://github.com/mourner/rbush#data-format)
+
+**Parameters**
+
+-   `feature` **Feature** insert single GeoJSON Feature
+
+**Examples**
+
+```javascript
+var poly = turf.polygon([[[-78, 41], [-67, 41], [-67, 48], [-78, 48], [-78, 41]]]);
+tree.insert(poly)
+```
+
+Returns **RBush** GeoJSON RBush
+
+### load
+
+[load](https://github.com/mourner/rbush#bulk-inserting-data)
+
+**Parameters**
+
+-   `features` **(FeatureCollection | [Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)&lt;Feature>)** load entire GeoJSON FeatureCollection
+
+**Examples**
+
+```javascript
+var polys = turf.polygons([
+    [[[-78, 41], [-67, 41], [-67, 48], [-78, 48], [-78, 41]]],
+    [[[-93, 32], [-83, 32], [-83, 39], [-93, 39], [-93, 32]]]
+]);
+tree.load(polys);
+```
+
+Returns **RBush** GeoJSON RBush
+
+### remove
+
+[remove](https://github.com/mourner/rbush#removing-data)
+
+**Parameters**
+
+-   `feature` **Feature** remove single GeoJSON Feature
+-   `equals` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)** Pass a custom equals function to compare by value for removal.
+
+**Examples**
+
+```javascript
+var poly = turf.polygon([[[-78, 41], [-67, 41], [-67, 48], [-78, 48], [-78, 41]]]);
+
+tree.remove(poly);
+```
+
+Returns **RBush** GeoJSON RBush
+
+### clear
+
+[clear](https://github.com/mourner/rbush#removing-data)
+
+**Examples**
+
+```javascript
+tree.clear()
+```
+
+Returns **RBush** GeoJSON Rbush
+
+### search
+
+[search](https://github.com/mourner/rbush#search)
+
+**Parameters**
+
+-   `geojson` **(BBox | FeatureCollection | Feature)** search with GeoJSON
+
+**Examples**
+
+```javascript
+var poly = turf.polygon([[[-78, 41], [-67, 41], [-67, 48], [-78, 48], [-78, 41]]]);
+
+tree.search(poly);
+```
+
+Returns **FeatureCollection** all features that intersects with the given GeoJSON.
+
+### collides
+
+[collides](https://github.com/mourner/rbush#collisions)
+
+**Parameters**
+
+-   `geojson` **(BBox | FeatureCollection | Feature)** collides with GeoJSON
+
+**Examples**
+
+```javascript
+var poly = turf.polygon([[[-78, 41], [-67, 41], [-67, 48], [-78, 48], [-78, 41]]]);
+
+tree.collides(poly);
+```
+
+Returns **[boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** true if there are any items intersecting the given GeoJSON, otherwise false.
+
+### all
+
+[all](https://github.com/mourner/rbush#search)
+
+**Examples**
+
+```javascript
+tree.all()
+```
+
+Returns **FeatureCollection** all the features in RBush
+
+### toJSON
+
+[toJSON](https://github.com/mourner/rbush#export-and-import)
+
+**Examples**
+
+```javascript
+var exported = tree.toJSON()
+```
+
+Returns **any** export data as JSON object
+
+### fromJSON
+
+[fromJSON](https://github.com/mourner/rbush#export-and-import)
+
+**Parameters**
+
+-   `json` **any** import previously exported data
+
+**Examples**
+
+```javascript
+var exported = {
+  "children": [
+    {
+      "type": "Feature",
+      "geometry": {
+        "type": "Point",
+        "coordinates": [110, 50]
+      },
+      "properties": {},
+      "bbox": [110, 50, 110, 50]
+    }
+  ],
+  "height": 1,
+  "leaf": true,
+  "minX": 110,
+  "minY": 50,
+  "maxX": 110,
+  "maxY": 50
+}
+tree.fromJSON(exported)
+```
+
+Returns **RBush** GeoJSON RBush

package/node_modules/geojson-rbush/index.d.ts

@@ -0,0 +1,19 @@
+import { BBox, Feature, FeatureCollection, Geometry, GeoJsonProperties } from 'geojson'
+
+declare class RBush<G extends Geometry, P extends GeoJsonProperties> {
+    insert(feature: Feature<G, P>): RBush<G, P>;
+    load(features: FeatureCollection<G, P> | Feature<G, P>[]): RBush<G, P>;
+    remove(feature: Feature<G, P>, equals?: (a: Feature<G, P>, b: Feature<G, P>) => boolean): RBush<G, P>;
+    clear(): RBush<G, P>;
+    search(geojson: Feature<G, P> | FeatureCollection<G, P> | BBox): FeatureCollection<G, P>;
+    all(): FeatureCollection<any>;
+    collides(geosjon: Feature<G, P> | FeatureCollection<G, P> | BBox): boolean;
+    toJSON(): any;
+    fromJSON(data: any): RBush<G, P>;
+}
+
+/**
+ * https://github.com/mourner/rbush
+ */
+export default function rbush<G extends Geometry = Geometry, P = GeoJsonProperties>(maxEntries?: number): RBush<G, P>;
+