node-red-contrib-tak-registration 0.2.0 → 0.3.0

package/node_modules/turf-jsts/src/org/locationtech/jts/index/bintree/Node.js

@@ -0,0 +1,94 @@
+import NodeBase from './NodeBase'
+import Interval from './Interval'
+import Assert from '../../util/Assert'
+import Key from './Key'
+
+export default class Node extends NodeBase {
+  constructor () {
+    super()
+    this._interval = null
+    this._centre = null
+    this._level = null
+    const interval = arguments[0]
+    const level = arguments[1]
+    this._interval = interval
+    this._level = level
+    this._centre = (interval.getMin() + interval.getMax()) / 2
+  }
+  getInterval () {
+    return this._interval
+  }
+  find (searchInterval) {
+    const subnodeIndex = NodeBase.getSubnodeIndex(searchInterval, this._centre)
+    if (subnodeIndex === -1) return this
+    if (this._subnode[subnodeIndex] !== null) {
+      const node = this._subnode[subnodeIndex]
+      return node.find(searchInterval)
+    }
+    return this
+  }
+  insert (node) {
+    Assert.isTrue(this._interval === null || this._interval.contains(node._interval))
+    const index = NodeBase.getSubnodeIndex(node._interval, this._centre)
+    if (node._level === this._level - 1) {
+      this._subnode[index] = node
+    } else {
+      const childNode = this.createSubnode(index)
+      childNode.insert(node)
+      this._subnode[index] = childNode
+    }
+  }
+  isSearchMatch (itemInterval) {
+    return itemInterval.overlaps(this._interval)
+  }
+  getSubnode (index) {
+    if (this._subnode[index] === null) {
+      this._subnode[index] = this.createSubnode(index)
+    }
+    return this._subnode[index]
+  }
+  getNode (searchInterval) {
+    const subnodeIndex = NodeBase.getSubnodeIndex(searchInterval, this._centre)
+    if (subnodeIndex !== -1) {
+      const node = this.getSubnode(subnodeIndex)
+      return node.getNode(searchInterval)
+    } else {
+      return this
+    }
+  }
+  createSubnode (index) {
+    let min = 0.0
+    let max = 0.0
+    switch (index) {
+      case 0:
+        min = this._interval.getMin()
+        max = this._centre
+        break
+      case 1:
+        min = this._centre
+        max = this._interval.getMax()
+        break
+    }
+    const subInt = new Interval(min, max)
+    const node = new Node(subInt, this._level - 1)
+    return node
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return Node
+  }
+  static createNode (itemInterval) {
+    const key = new Key(itemInterval)
+    const node = new Node(key.getInterval(), key.getLevel())
+    return node
+  }
+  static createExpanded (node, addInterval) {
+    const expandInt = new Interval(addInterval)
+    if (node !== null) expandInt.expandToInclude(node._interval)
+    const largerNode = Node.createNode(expandInt)
+    if (node !== null) largerNode.insert(node)
+    return largerNode
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/index/bintree/NodeBase.js

@@ -0,0 +1,97 @@
+import ArrayList from '../../../../../java/util/ArrayList'
+
+export default class NodeBase {
+  constructor () {
+    this._items = new ArrayList()
+    this._subnode = [null, null]
+  }
+  hasChildren () {
+    for (let i = 0; i < 2; i++) {
+      if (this._subnode[i] !== null) return true
+    }
+    return false
+  }
+  isPrunable () {
+    return !(this.hasChildren() || this.hasItems())
+  }
+  addAllItems (items) {
+    items.addAll(this._items)
+    for (let i = 0; i < 2; i++) {
+      if (this._subnode[i] !== null) {
+        this._subnode[i].addAllItems(items)
+      }
+    }
+    return items
+  }
+  size () {
+    let subSize = 0
+    for (let i = 0; i < 2; i++) {
+      if (this._subnode[i] !== null) {
+        subSize += this._subnode[i].size()
+      }
+    }
+    return subSize + this._items.size()
+  }
+  addAllItemsFromOverlapping (interval, resultItems) {
+    if (interval !== null && !this.isSearchMatch(interval)) return null
+    resultItems.addAll(this._items)
+    if (this._subnode[0] !== null) this._subnode[0].addAllItemsFromOverlapping(interval, resultItems)
+    if (this._subnode[1] !== null) this._subnode[1].addAllItemsFromOverlapping(interval, resultItems)
+  }
+  hasItems () {
+    return !this._items.isEmpty()
+  }
+  remove (itemInterval, item) {
+    if (!this.isSearchMatch(itemInterval)) return false
+    let found = false
+    for (let i = 0; i < 2; i++) {
+      if (this._subnode[i] !== null) {
+        found = this._subnode[i].remove(itemInterval, item)
+        if (found) {
+          if (this._subnode[i].isPrunable()) this._subnode[i] = null
+          break
+        }
+      }
+    }
+    if (found) return found
+    found = this._items.remove(item)
+    return found
+  }
+  getItems () {
+    return this._items
+  }
+  depth () {
+    let maxSubDepth = 0
+    for (let i = 0; i < 2; i++) {
+      if (this._subnode[i] !== null) {
+        const sqd = this._subnode[i].depth()
+        if (sqd > maxSubDepth) maxSubDepth = sqd
+      }
+    }
+    return maxSubDepth + 1
+  }
+  nodeSize () {
+    let subSize = 0
+    for (let i = 0; i < 2; i++) {
+      if (this._subnode[i] !== null) {
+        subSize += this._subnode[i].nodeSize()
+      }
+    }
+    return subSize + 1
+  }
+  add (item) {
+    this._items.add(item)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return NodeBase
+  }
+  static getSubnodeIndex (interval, centre) {
+    let subnodeIndex = -1
+    if (interval.min >= centre) subnodeIndex = 1
+    if (interval.max <= centre) subnodeIndex = 0
+    return subnodeIndex
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/index/bintree/Root.js

@@ -0,0 +1,37 @@
+import NodeBase from './NodeBase'
+import Node from './Node'
+import IntervalSize from '../quadtree/IntervalSize'
+import Assert from '../../util/Assert'
+
+export default class Root extends NodeBase {
+  insert (itemInterval, item) {
+    var index = NodeBase.getSubnodeIndex(itemInterval, Root.origin)
+    if (index === -1) {
+      this.add(item)
+      return null
+    }
+    var node = this._subnode[index]
+    if (node === null || !node.getInterval().contains(itemInterval)) {
+      var largerNode = Node.createExpanded(node, itemInterval)
+      this._subnode[index] = largerNode
+    }
+    this.insertContained(this._subnode[index], itemInterval, item)
+  }
+  isSearchMatch (interval) {
+    return true
+  }
+  insertContained (tree, itemInterval, item) {
+    Assert.isTrue(tree.getInterval().contains(itemInterval))
+    var isZeroArea = IntervalSize.isZeroWidth(itemInterval.getMin(), itemInterval.getMax())
+    var node = null
+    if (isZeroArea) node = tree.find(itemInterval); else node = tree.getNode(itemInterval)
+    node.add(item)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return Root
+  }
+  static get origin () { return 0.0 }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/index/chain/MonotoneChain.js

@@ -0,0 +1,107 @@
+import Envelope from '../../geom/Envelope'
+
+export default class MonotoneChain {
+  constructor () {
+    this._pts = null
+    this._start = null
+    this._end = null
+    this._env = null
+    this._context = null
+    this._id = null
+    const pts = arguments[0]
+    const start = arguments[1]
+    const end = arguments[2]
+    const context = arguments[3]
+    this._pts = pts
+    this._start = start
+    this._end = end
+    this._context = context
+  }
+  getLineSegment (index, ls) {
+    ls.p0 = this._pts[index]
+    ls.p1 = this._pts[index + 1]
+  }
+  computeSelect (searchEnv, start0, end0, mcs) {
+    const p0 = this._pts[start0]
+    const p1 = this._pts[end0]
+    mcs.tempEnv1.init(p0, p1)
+    if (end0 - start0 === 1) {
+      mcs.select(this, start0)
+      return null
+    }
+    if (!searchEnv.intersects(mcs.tempEnv1)) return null
+    const mid = Math.trunc((start0 + end0) / 2)
+    if (start0 < mid) {
+      this.computeSelect(searchEnv, start0, mid, mcs)
+    }
+    if (mid < end0) {
+      this.computeSelect(searchEnv, mid, end0, mcs)
+    }
+  }
+  getCoordinates () {
+    const coord = new Array(this._end - this._start + 1).fill(null)
+    let index = 0
+    for (let i = this._start; i <= this._end; i++) {
+      coord[index++] = this._pts[i]
+    }
+    return coord
+  }
+  computeOverlaps (mc, mco) {
+    this.computeOverlapsInternal(this._start, this._end, mc, mc._start, mc._end, mco)
+  }
+  setId (id) {
+    this._id = id
+  }
+  select (searchEnv, mcs) {
+    this.computeSelect(searchEnv, this._start, this._end, mcs)
+  }
+  getEnvelope () {
+    if (this._env === null) {
+      const p0 = this._pts[this._start]
+      const p1 = this._pts[this._end]
+      this._env = new Envelope(p0, p1)
+    }
+    return this._env
+  }
+  getEndIndex () {
+    return this._end
+  }
+  getStartIndex () {
+    return this._start
+  }
+  getContext () {
+    return this._context
+  }
+  getId () {
+    return this._id
+  }
+  computeOverlapsInternal (start0, end0, mc, start1, end1, mco) {
+    const p00 = this._pts[start0]
+    const p01 = this._pts[end0]
+    const p10 = mc._pts[start1]
+    const p11 = mc._pts[end1]
+    if (end0 - start0 === 1 && end1 - start1 === 1) {
+      mco.overlap(this, start0, mc, start1)
+      return null
+    }
+    mco.tempEnv1.init(p00, p01)
+    mco.tempEnv2.init(p10, p11)
+    if (!mco.tempEnv1.intersects(mco.tempEnv2)) return null
+    const mid0 = Math.trunc((start0 + end0) / 2)
+    const mid1 = Math.trunc((start1 + end1) / 2)
+    if (start0 < mid0) {
+      if (start1 < mid1) this.computeOverlapsInternal(start0, mid0, mc, start1, mid1, mco)
+      if (mid1 < end1) this.computeOverlapsInternal(start0, mid0, mc, mid1, end1, mco)
+    }
+    if (mid0 < end0) {
+      if (start1 < mid1) this.computeOverlapsInternal(mid0, end0, mc, start1, mid1, mco)
+      if (mid1 < end1) this.computeOverlapsInternal(mid0, end0, mc, mid1, end1, mco)
+    }
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return MonotoneChain
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/index/chain/MonotoneChainBuilder.js

@@ -0,0 +1,67 @@
+import MonotoneChain from './MonotoneChain'
+import Integer from '../../../../../java/lang/Integer'
+import ArrayList from '../../../../../java/util/ArrayList'
+import Quadrant from '../../geomgraph/Quadrant'
+
+export default class MonotoneChainBuilder {
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return MonotoneChainBuilder
+  }
+  static getChainStartIndices (pts) {
+    let start = 0
+    const startIndexList = new ArrayList()
+    startIndexList.add(new Integer(start))
+    do {
+      const last = MonotoneChainBuilder.findChainEnd(pts, start)
+      startIndexList.add(new Integer(last))
+      start = last
+    } while (start < pts.length - 1)
+    const startIndex = MonotoneChainBuilder.toIntArray(startIndexList)
+    return startIndex
+  }
+  static findChainEnd (pts, start) {
+    let safeStart = start
+    while (safeStart < pts.length - 1 && pts[safeStart].equals2D(pts[safeStart + 1])) {
+      safeStart++
+    }
+    if (safeStart >= pts.length - 1) {
+      return pts.length - 1
+    }
+    const chainQuad = Quadrant.quadrant(pts[safeStart], pts[safeStart + 1])
+    let last = start + 1
+    while (last < pts.length) {
+      if (!pts[last - 1].equals2D(pts[last])) {
+        const quad = Quadrant.quadrant(pts[last - 1], pts[last])
+        if (quad !== chainQuad) break
+      }
+      last++
+    }
+    return last - 1
+  }
+  static getChains () {
+    if (arguments.length === 1) {
+      const pts = arguments[0]
+      return MonotoneChainBuilder.getChains(pts, null)
+    } else if (arguments.length === 2) {
+      const pts = arguments[0]
+      const context = arguments[1]
+      const mcList = new ArrayList()
+      const startIndex = MonotoneChainBuilder.getChainStartIndices(pts)
+      for (let i = 0; i < startIndex.length - 1; i++) {
+        const mc = new MonotoneChain(pts, startIndex[i], startIndex[i + 1], context)
+        mcList.add(mc)
+      }
+      return mcList
+    }
+  }
+  static toIntArray (list) {
+    const array = new Array(list.size()).fill(null)
+    for (let i = 0; i < array.length; i++) {
+      array[i] = list.get(i).intValue()
+    }
+    return array
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/index/chain/MonotoneChainOverlapAction.js

@@ -0,0 +1,31 @@
+import LineSegment from '../../geom/LineSegment'
+import Envelope from '../../geom/Envelope'
+
+export default class MonotoneChainOverlapAction {
+  constructor () {
+    this.tempEnv1 = new Envelope()
+    this.tempEnv2 = new Envelope()
+    this._overlapSeg1 = new LineSegment()
+    this._overlapSeg2 = new LineSegment()
+  }
+  overlap () {
+    if (arguments.length === 2) {
+      // const seg1 = arguments[0]
+      // const seg2 = arguments[1]
+    } else if (arguments.length === 4) {
+      const mc1 = arguments[0]
+      const start1 = arguments[1]
+      const mc2 = arguments[2]
+      const start2 = arguments[3]
+      mc1.getLineSegment(start1, this._overlapSeg1)
+      mc2.getLineSegment(start2, this._overlapSeg2)
+      this.overlap(this._overlapSeg1, this._overlapSeg2)
+    }
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return MonotoneChainOverlapAction
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/index/chain/MonotoneChainSelectAction.js

@@ -0,0 +1,25 @@
+import LineSegment from '../../geom/LineSegment'
+import Envelope from '../../geom/Envelope'
+
+export default class MonotoneChainSelectAction {
+  constructor () {
+    this.tempEnv1 = new Envelope()
+    this.selectedSegment = new LineSegment()
+  }
+  select () {
+    if (arguments.length === 1) {
+      // const seg = arguments[0]
+    } else if (arguments.length === 2) {
+      const mc = arguments[0]
+      const startIndex = arguments[1]
+      mc.getLineSegment(startIndex, this.selectedSegment)
+      this.select(this.selectedSegment)
+    }
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return MonotoneChainSelectAction
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/index/intervalrtree/IntervalRTreeBranchNode.js

@@ -0,0 +1,31 @@
+import IntervalRTreeNode from './IntervalRTreeNode'
+
+export default class IntervalRTreeBranchNode extends IntervalRTreeNode {
+  constructor () {
+    super()
+    this._node1 = null
+    this._node2 = null
+    const n1 = arguments[0]
+    const n2 = arguments[1]
+    this._node1 = n1
+    this._node2 = n2
+    this.buildExtent(this._node1, this._node2)
+  }
+  buildExtent (n1, n2) {
+    this._min = Math.min(n1._min, n2._min)
+    this._max = Math.max(n1._max, n2._max)
+  }
+  query (queryMin, queryMax, visitor) {
+    if (!this.intersects(queryMin, queryMax)) {
+      return null
+    }
+    if (this._node1 !== null) this._node1.query(queryMin, queryMax, visitor)
+    if (this._node2 !== null) this._node2.query(queryMin, queryMax, visitor)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return IntervalRTreeBranchNode
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/index/intervalrtree/IntervalRTreeLeafNode.js

@@ -0,0 +1,24 @@
+import IntervalRTreeNode from './IntervalRTreeNode'
+
+export default class IntervalRTreeLeafNode extends IntervalRTreeNode {
+  constructor () {
+    super()
+    this._item = null
+    const min = arguments[0]
+    const max = arguments[1]
+    const item = arguments[2]
+    this._min = min
+    this._max = max
+    this._item = item
+  }
+  query (queryMin, queryMax, visitor) {
+    if (!this.intersects(queryMin, queryMax)) return null
+    visitor.visitItem(this._item)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return IntervalRTreeLeafNode
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/index/intervalrtree/IntervalRTreeNode.js

@@ -0,0 +1,49 @@
+import WKTWriter from '../../io/WKTWriter'
+import Coordinate from '../../geom/Coordinate'
+import Double from '../../../../../java/lang/Double'
+import Comparator from '../../../../../java/util/Comparator'
+
+export default class IntervalRTreeNode {
+  constructor () {
+    this._min = Double.POSITIVE_INFINITY
+    this._max = Double.NEGATIVE_INFINITY
+  }
+  getMin () {
+    return this._min
+  }
+  intersects (queryMin, queryMax) {
+    if (this._min > queryMax || this._max < queryMin) return false
+    return true
+  }
+  getMax () {
+    return this._max
+  }
+  toString () {
+    return WKTWriter.toLineString(new Coordinate(this._min, 0), new Coordinate(this._max, 0))
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return IntervalRTreeNode
+  }
+  static get NodeComparator () { return NodeComparator }
+}
+
+class NodeComparator {
+  compare (o1, o2) {
+    var n1 = o1
+    var n2 = o2
+    var mid1 = (n1._min + n1._max) / 2
+    var mid2 = (n2._min + n2._max) / 2
+    if (mid1 < mid2) return -1
+    if (mid1 > mid2) return 1
+    return 0
+  }
+  interfaces_ () {
+    return [Comparator]
+  }
+  getClass () {
+    return NodeComparator
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/index/intervalrtree/SortedPackedIntervalRTree.js

@@ -0,0 +1,68 @@
+import WKTWriter from '../../io/WKTWriter'
+import Coordinate from '../../geom/Coordinate'
+import IntervalRTreeLeafNode from './IntervalRTreeLeafNode'
+import Collections from '../../../../../java/util/Collections'
+import System from '../../../../../java/lang/System'
+import ArrayList from '../../../../../java/util/ArrayList'
+import IntervalRTreeBranchNode from './IntervalRTreeBranchNode'
+import IntervalRTreeNode from './IntervalRTreeNode'
+
+export default class SortedPackedIntervalRTree {
+  constructor () {
+    this._leaves = new ArrayList()
+    this._root = null
+    this._level = 0
+  }
+  buildTree () {
+    Collections.sort(this._leaves, new IntervalRTreeNode.NodeComparator())
+    var src = this._leaves
+    var temp = null
+    var dest = new ArrayList()
+    while (true) {
+      this.buildLevel(src, dest)
+      if (dest.size() === 1) return dest.get(0)
+      temp = src
+      src = dest
+      dest = temp
+    }
+  }
+  insert (min, max, item) {
+    if (this._root !== null) throw new Error('Index cannot be added to once it has been queried')
+    this._leaves.add(new IntervalRTreeLeafNode(min, max, item))
+  }
+  query (min, max, visitor) {
+    this.init()
+    this._root.query(min, max, visitor)
+  }
+  buildRoot () {
+    if (this._root !== null) return null
+    this._root = this.buildTree()
+  }
+  printNode (node) {
+    System.out.println(WKTWriter.toLineString(new Coordinate(node._min, this._level), new Coordinate(node._max, this._level)))
+  }
+  init () {
+    if (this._root !== null) return null
+    this.buildRoot()
+  }
+  buildLevel (src, dest) {
+    this._level++
+    dest.clear()
+    for (var i = 0; i < src.size(); i += 2) {
+      var n1 = src.get(i)
+      var n2 = i + 1 < src.size() ? src.get(i) : null
+      if (n2 === null) {
+        dest.add(n1)
+      } else {
+        var node = new IntervalRTreeBranchNode(src.get(i), src.get(i + 1))
+        dest.add(node)
+      }
+    }
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return SortedPackedIntervalRTree
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/index/intervalrtree.js

@@ -0,0 +1,5 @@
+// index.intervalrtree
+export { default as IntervalRTreeBranchNode } from './intervalrtree/IntervalRTreeBranchNode'
+export { default as IntervalRTreeLeafNode } from './intervalrtree/IntervalRTreeLeafNode'
+export { default as IntervalRTreeNode } from './intervalrtree/IntervalRTreeNode'
+export { default as SortedPackedIntervalRTree } from './intervalrtree/SortedPackedIntervalRTree'