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

package/node_modules/turf-jsts/src/org/locationtech/jts/operation/predicate/RectangleIntersects.js

@@ -0,0 +1,158 @@
+import Coordinate from '../../geom/Coordinate'
+import Polygon from '../../geom/Polygon'
+import RectangleLineIntersector from '../../algorithm/RectangleLineIntersector'
+import ShortCircuitedGeometryVisitor from '../../geom/util/ShortCircuitedGeometryVisitor'
+import SimplePointInAreaLocator from '../../algorithm/locate/SimplePointInAreaLocator'
+import LinearComponentExtracter from '../../geom/util/LinearComponentExtracter'
+
+export default class RectangleIntersects {
+  constructor (rectangle) {
+    this._rectangle = null
+    this._rectEnv = null
+    this._rectangle = rectangle
+    this._rectEnv = rectangle.getEnvelopeInternal()
+  }
+  intersects (geom) {
+    if (!this._rectEnv.intersects(geom.getEnvelopeInternal())) return false
+    var visitor = new EnvelopeIntersectsVisitor(this._rectEnv)
+    visitor.applyTo(geom)
+    if (visitor.intersects()) return true
+    var ecpVisitor = new GeometryContainsPointVisitor(this._rectangle)
+    ecpVisitor.applyTo(geom)
+    if (ecpVisitor.containsPoint()) return true
+    var riVisitor = new RectangleIntersectsSegmentVisitor(this._rectangle)
+    riVisitor.applyTo(geom)
+    if (riVisitor.intersects()) return true
+    return false
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return RectangleIntersects
+  }
+  static intersects (rectangle, b) {
+    var rp = new RectangleIntersects(rectangle)
+    return rp.intersects(b)
+  }
+}
+
+class EnvelopeIntersectsVisitor extends ShortCircuitedGeometryVisitor {
+  constructor (rectEnv) {
+    super()
+    this._rectEnv = null
+    this._intersects = false
+    this._rectEnv = rectEnv
+  }
+  isDone () {
+    return this._intersects === true
+  }
+  visit (element) {
+    var elementEnv = element.getEnvelopeInternal()
+    if (!this._rectEnv.intersects(elementEnv)) {
+      return null
+    }
+    if (this._rectEnv.contains(elementEnv)) {
+      this._intersects = true
+      return null
+    }
+    if (elementEnv.getMinX() >= this._rectEnv.getMinX() && elementEnv.getMaxX() <= this._rectEnv.getMaxX()) {
+      this._intersects = true
+      return null
+    }
+    if (elementEnv.getMinY() >= this._rectEnv.getMinY() && elementEnv.getMaxY() <= this._rectEnv.getMaxY()) {
+      this._intersects = true
+      return null
+    }
+  }
+  intersects () {
+    return this._intersects
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return EnvelopeIntersectsVisitor
+  }
+}
+
+class GeometryContainsPointVisitor extends ShortCircuitedGeometryVisitor {
+  constructor (rectangle) {
+    super()
+    this._containsPoint = false
+    this._rectSeq = rectangle.getExteriorRing().getCoordinateSequence() || null
+    this._rectEnv = rectangle.getEnvelopeInternal() || null
+  }
+  isDone () {
+    return this._containsPoint === true
+  }
+  visit (geom) {
+    if (!(geom instanceof Polygon)) return null
+    var elementEnv = geom.getEnvelopeInternal()
+    if (!this._rectEnv.intersects(elementEnv)) return null
+    var rectPt = new Coordinate()
+    for (var i = 0; i < 4; i++) {
+      this._rectSeq.getCoordinate(i, rectPt)
+      if (!elementEnv.contains(rectPt)) continue
+      if (SimplePointInAreaLocator.containsPointInPolygon(rectPt, geom)) {
+        this._containsPoint = true
+        return null
+      }
+    }
+  }
+  containsPoint () {
+    return this._containsPoint
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return GeometryContainsPointVisitor
+  }
+}
+
+class RectangleIntersectsSegmentVisitor extends ShortCircuitedGeometryVisitor {
+  constructor (rectangle) {
+    super()
+    this._p0 = new Coordinate()
+    this._p1 = new Coordinate()
+    this._rectEnv = rectangle.getEnvelopeInternal() || null
+    this._rectIntersector = new RectangleLineIntersector(this._rectEnv) || false
+  }
+  intersects () {
+    return this._hasIntersection
+  }
+  isDone () {
+    return this._hasIntersection === true
+  }
+  visit (geom) {
+    var elementEnv = geom.getEnvelopeInternal()
+    if (!this._rectEnv.intersects(elementEnv)) return null
+    var lines = LinearComponentExtracter.getLines(geom)
+    this.checkIntersectionWithLineStrings(lines)
+  }
+  checkIntersectionWithLineStrings (lines) {
+    for (var i = lines.iterator(); i.hasNext();) {
+      var testLine = i.next()
+      this.checkIntersectionWithSegments(testLine)
+      if (this._hasIntersection) return null
+    }
+  }
+  checkIntersectionWithSegments (testLine) {
+    var seq1 = testLine.getCoordinateSequence()
+    for (var j = 1; j < seq1.size(); j++) {
+      seq1.getCoordinate(j - 1, this._p0)
+      seq1.getCoordinate(j, this._p1)
+      if (this._rectIntersector.intersects(this._p0, this._p1)) {
+        this._hasIntersection = true
+        return null
+      }
+    }
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return RectangleIntersectsSegmentVisitor
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/operation/predicate.js

@@ -0,0 +1,3 @@
+// operation.predicate
+export { default as RectangleContains } from './predicate/RectangleContains'
+export { default as RectangleIntersects } from './predicate/RectangleIntersects'

package/node_modules/turf-jsts/src/org/locationtech/jts/operation/relate/EdgeEndBuilder.js

@@ -0,0 +1,64 @@
+import EdgeEnd from '../../geomgraph/EdgeEnd'
+import Label from '../../geomgraph/Label'
+import ArrayList from '../../../../../java/util/ArrayList'
+
+export default class EdgeEndBuilder {
+  createEdgeEndForNext (edge, l, eiCurr, eiNext) {
+    const iNext = eiCurr.segmentIndex + 1
+    if (iNext >= edge.getNumPoints() && eiNext === null) return null
+    let pNext = edge.getCoordinate(iNext)
+    if (eiNext !== null && eiNext.segmentIndex === eiCurr.segmentIndex) pNext = eiNext.coord
+    const e = new EdgeEnd(edge, eiCurr.coord, pNext, new Label(edge.getLabel()))
+    l.add(e)
+  }
+  createEdgeEndForPrev (edge, l, eiCurr, eiPrev) {
+    let iPrev = eiCurr.segmentIndex
+    if (eiCurr.dist === 0.0) {
+      if (iPrev === 0) return null
+      iPrev--
+    }
+    let pPrev = edge.getCoordinate(iPrev)
+    if (eiPrev !== null && eiPrev.segmentIndex >= iPrev) pPrev = eiPrev.coord
+    const label = new Label(edge.getLabel())
+    label.flip()
+    const e = new EdgeEnd(edge, eiCurr.coord, pPrev, label)
+    l.add(e)
+  }
+  computeEdgeEnds () {
+    if (arguments.length === 1) {
+      let edges = arguments[0]
+      const l = new ArrayList()
+      for (const i = edges; i.hasNext();) {
+        const e = i.next()
+        this.computeEdgeEnds(e, l)
+      }
+      return l
+    } else if (arguments.length === 2) {
+      const edge = arguments[0]
+      const l = arguments[1]
+      const eiList = edge.getEdgeIntersectionList()
+      eiList.addEndpoints()
+      const it = eiList.iterator()
+      let eiPrev = null
+      let eiCurr = null
+      if (!it.hasNext()) return null
+      let eiNext = it.next()
+      do {
+        eiPrev = eiCurr
+        eiCurr = eiNext
+        eiNext = null
+        if (it.hasNext()) eiNext = it.next()
+        if (eiCurr !== null) {
+          this.createEdgeEndForPrev(edge, l, eiCurr, eiPrev)
+          this.createEdgeEndForNext(edge, l, eiCurr, eiNext)
+        }
+      } while (eiCurr !== null)
+    }
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return EdgeEndBuilder
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/operation/relate/EdgeEndBundle.js

@@ -0,0 +1,96 @@
+import Location from '../../geom/Location'
+import EdgeEnd from '../../geomgraph/EdgeEnd'
+import Position from '../../geomgraph/Position'
+import GeometryGraph from '../../geomgraph/GeometryGraph'
+import Label from '../../geomgraph/Label'
+import ArrayList from '../../../../../java/util/ArrayList'
+import Edge from '../../geomgraph/Edge'
+
+export default class EdgeEndBundle extends EdgeEnd {
+  constructor () {
+    let e
+    // let boundaryNodeRule = null
+    if (arguments.length === 1) {
+      e = arguments[0]
+    } else if (arguments.length === 2) {
+      // boundaryNodeRule = arguments[0]
+      e = arguments[1]
+    }
+    super(e.getEdge(), e.getCoordinate(), e.getDirectedCoordinate(), new Label(e.getLabel()))
+    this._edgeEnds = new ArrayList()
+    this.insert(e)
+  }
+  insert (e) {
+    this._edgeEnds.add(e)
+  }
+  print (out) {
+    out.println('EdgeEndBundle--> Label: ' + this._label)
+    for (const it = this.iterator(); it.hasNext();) {
+      const ee = it.next()
+      ee.print(out)
+      out.println()
+    }
+  }
+  iterator () {
+    return this._edgeEnds.iterator()
+  }
+  getEdgeEnds () {
+    return this._edgeEnds
+  }
+  computeLabelOn (geomIndex, boundaryNodeRule) {
+    let boundaryCount = 0
+    let foundInterior = false
+    for (const it = this.iterator(); it.hasNext();) {
+      const e = it.next()
+      const loc = e.getLabel().getLocation(geomIndex)
+      if (loc === Location.BOUNDARY) boundaryCount++
+      if (loc === Location.INTERIOR) foundInterior = true
+    }
+    let loc = Location.NONE
+    if (foundInterior) loc = Location.INTERIOR
+    if (boundaryCount > 0) {
+      loc = GeometryGraph.determineBoundary(boundaryNodeRule, boundaryCount)
+    }
+    this._label.setLocation(geomIndex, loc)
+  }
+  computeLabelSide (geomIndex, side) {
+    for (const it = this.iterator(); it.hasNext();) {
+      const e = it.next()
+      if (e.getLabel().isArea()) {
+        const loc = e.getLabel().getLocation(geomIndex, side)
+        if (loc === Location.INTERIOR) {
+          this._label.setLocation(geomIndex, side, Location.INTERIOR)
+          return null
+        } else if (loc === Location.EXTERIOR) this._label.setLocation(geomIndex, side, Location.EXTERIOR)
+      }
+    }
+  }
+  getLabel () {
+    return this._label
+  }
+  computeLabelSides (geomIndex) {
+    this.computeLabelSide(geomIndex, Position.LEFT)
+    this.computeLabelSide(geomIndex, Position.RIGHT)
+  }
+  updateIM (im) {
+    Edge.updateIM(this._label, im)
+  }
+  computeLabel (boundaryNodeRule) {
+    let isArea = false
+    for (const it = this.iterator(); it.hasNext();) {
+      const e = it.next()
+      if (e.getLabel().isArea()) isArea = true
+    }
+    if (isArea) this._label = new Label(Location.NONE, Location.NONE, Location.NONE); else this._label = new Label(Location.NONE)
+    for (let i = 0; i < 2; i++) {
+      this.computeLabelOn(i, boundaryNodeRule)
+      if (isArea) this.computeLabelSides(i)
+    }
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return EdgeEndBundle
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/operation/relate/EdgeEndBundleStar.js

@@ -0,0 +1,26 @@
+import EdgeEndStar from '../../geomgraph/EdgeEndStar'
+import EdgeEndBundle from './EdgeEndBundle'
+
+export default class EdgeEndBundleStar extends EdgeEndStar {
+  updateIM (im) {
+    for (const it = this.iterator(); it.hasNext();) {
+      const esb = it.next()
+      esb.updateIM(im)
+    }
+  }
+  insert (e) {
+    let eb = this._edgeMap.get(e)
+    if (eb === null) {
+      eb = new EdgeEndBundle(e)
+      this.insertEdgeEnd(e, eb)
+    } else {
+      eb.insert(e)
+    }
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return EdgeEndBundleStar
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/operation/relate/RelateComputer.js

@@ -0,0 +1,172 @@
+import PointLocator from '../../algorithm/PointLocator'
+import Location from '../../geom/Location'
+import IntersectionMatrix from '../../geom/IntersectionMatrix'
+import EdgeEndBuilder from './EdgeEndBuilder'
+import NodeMap from '../../geomgraph/NodeMap'
+import RelateNodeFactory from './RelateNodeFactory'
+import ArrayList from '../../../../../java/util/ArrayList'
+import RobustLineIntersector from '../../algorithm/RobustLineIntersector'
+import Assert from '../../util/Assert'
+
+export default class RelateComputer {
+  constructor () {
+    this._li = new RobustLineIntersector()
+    this._ptLocator = new PointLocator()
+    this._arg = null
+    this._nodes = new NodeMap(new RelateNodeFactory())
+    this._im = null
+    this._isolatedEdges = new ArrayList()
+    this._invalidPoint = null
+    let arg = arguments[0]
+    this._arg = arg
+  }
+  insertEdgeEnds (ee) {
+    for (const i = ee.iterator(); i.hasNext();) {
+      const e = i.next()
+      this._nodes.add(e)
+    }
+  }
+  computeProperIntersectionIM (intersector, im) {
+    const dimA = this._arg[0].getGeometry().getDimension()
+    const dimB = this._arg[1].getGeometry().getDimension()
+    const hasProper = intersector.hasProperIntersection()
+    const hasProperInterior = intersector.hasProperInteriorIntersection()
+    if (dimA === 2 && dimB === 2) {
+      if (hasProper) im.setAtLeast('212101212')
+    } else if (dimA === 2 && dimB === 1) {
+      if (hasProper) im.setAtLeast('FFF0FFFF2')
+      if (hasProperInterior) im.setAtLeast('1FFFFF1FF')
+    } else if (dimA === 1 && dimB === 2) {
+      if (hasProper) im.setAtLeast('F0FFFFFF2')
+      if (hasProperInterior) im.setAtLeast('1F1FFFFFF')
+    } else if (dimA === 1 && dimB === 1) {
+      if (hasProperInterior) im.setAtLeast('0FFFFFFFF')
+    }
+  }
+  labelIsolatedEdges (thisIndex, targetIndex) {
+    for (const ei = this._arg[thisIndex].getEdgeIterator(); ei.hasNext();) {
+      const e = ei.next()
+      if (e.isIsolated()) {
+        this.labelIsolatedEdge(e, targetIndex, this._arg[targetIndex].getGeometry())
+        this._isolatedEdges.add(e)
+      }
+    }
+  }
+  labelIsolatedEdge (e, targetIndex, target) {
+    if (target.getDimension() > 0) {
+      const loc = this._ptLocator.locate(e.getCoordinate(), target)
+      e.getLabel().setAllLocations(targetIndex, loc)
+    } else {
+      e.getLabel().setAllLocations(targetIndex, Location.EXTERIOR)
+    }
+  }
+  computeIM () {
+    const im = new IntersectionMatrix()
+    im.set(Location.EXTERIOR, Location.EXTERIOR, 2)
+    if (!this._arg[0].getGeometry().getEnvelopeInternal().intersects(this._arg[1].getGeometry().getEnvelopeInternal())) {
+      this.computeDisjointIM(im)
+      return im
+    }
+    this._arg[0].computeSelfNodes(this._li, false)
+    this._arg[1].computeSelfNodes(this._li, false)
+    const intersector = this._arg[0].computeEdgeIntersections(this._arg[1], this._li, false)
+    this.computeIntersectionNodes(0)
+    this.computeIntersectionNodes(1)
+    this.copyNodesAndLabels(0)
+    this.copyNodesAndLabels(1)
+    this.labelIsolatedNodes()
+    this.computeProperIntersectionIM(intersector, im)
+    const eeBuilder = new EdgeEndBuilder()
+    const ee0 = eeBuilder.computeEdgeEnds(this._arg[0].getEdgeIterator())
+    this.insertEdgeEnds(ee0)
+    const ee1 = eeBuilder.computeEdgeEnds(this._arg[1].getEdgeIterator())
+    this.insertEdgeEnds(ee1)
+    this.labelNodeEdges()
+    this.labelIsolatedEdges(0, 1)
+    this.labelIsolatedEdges(1, 0)
+    this.updateIM(im)
+    return im
+  }
+  labelNodeEdges () {
+    for (const ni = this._nodes.iterator(); ni.hasNext();) {
+      const node = ni.next()
+      node.getEdges().computeLabelling(this._arg)
+    }
+  }
+  copyNodesAndLabels (argIndex) {
+    for (const i = this._arg[argIndex].getNodeIterator(); i.hasNext();) {
+      const graphNode = i.next()
+      const newNode = this._nodes.addNode(graphNode.getCoordinate())
+      newNode.setLabel(argIndex, graphNode.getLabel().getLocation(argIndex))
+    }
+  }
+  labelIntersectionNodes (argIndex) {
+    for (const i = this._arg[argIndex].getEdgeIterator(); i.hasNext();) {
+      const e = i.next()
+      const eLoc = e.getLabel().getLocation(argIndex)
+      for (const eiIt = e.getEdgeIntersectionList().iterator(); eiIt.hasNext();) {
+        const ei = eiIt.next()
+        const n = this._nodes.find(ei.coord)
+        if (n.getLabel().isNull(argIndex)) {
+          if (eLoc === Location.BOUNDARY) n.setLabelBoundary(argIndex); else n.setLabel(argIndex, Location.INTERIOR)
+        }
+      }
+    }
+  }
+  labelIsolatedNode (n, targetIndex) {
+    const loc = this._ptLocator.locate(n.getCoordinate(), this._arg[targetIndex].getGeometry())
+    n.getLabel().setAllLocations(targetIndex, loc)
+  }
+  computeIntersectionNodes (argIndex) {
+    for (const i = this._arg[argIndex].getEdgeIterator(); i.hasNext();) {
+      const e = i.next()
+      const eLoc = e.getLabel().getLocation(argIndex)
+      for (const eiIt = e.getEdgeIntersectionList().iterator(); eiIt.hasNext();) {
+        const ei = eiIt.next()
+        const n = this._nodes.addNode(ei.coord)
+        if (eLoc === Location.BOUNDARY) n.setLabelBoundary(argIndex); else {
+          if (n.getLabel().isNull(argIndex)) n.setLabel(argIndex, Location.INTERIOR)
+        }
+      }
+    }
+  }
+  labelIsolatedNodes () {
+    for (const ni = this._nodes.iterator(); ni.hasNext();) {
+      const n = ni.next()
+      const label = n.getLabel()
+      Assert.isTrue(label.getGeometryCount() > 0, 'node with empty label found')
+      if (n.isIsolated()) {
+        if (label.isNull(0)) this.labelIsolatedNode(n, 0); else this.labelIsolatedNode(n, 1)
+      }
+    }
+  }
+  updateIM (im) {
+    for (const ei = this._isolatedEdges.iterator(); ei.hasNext();) {
+      const e = ei.next()
+      e.updateIM(im)
+    }
+    for (const ni = this._nodes.iterator(); ni.hasNext();) {
+      const node = ni.next()
+      node.updateIM(im)
+      node.updateIMFromEdges(im)
+    }
+  }
+  computeDisjointIM (im) {
+    const ga = this._arg[0].getGeometry()
+    if (!ga.isEmpty()) {
+      im.set(Location.INTERIOR, Location.EXTERIOR, ga.getDimension())
+      im.set(Location.BOUNDARY, Location.EXTERIOR, ga.getBoundaryDimension())
+    }
+    const gb = this._arg[1].getGeometry()
+    if (!gb.isEmpty()) {
+      im.set(Location.EXTERIOR, Location.INTERIOR, gb.getDimension())
+      im.set(Location.EXTERIOR, Location.BOUNDARY, gb.getBoundaryDimension())
+    }
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return RelateComputer
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/operation/relate/RelateNode.js

@@ -0,0 +1,21 @@
+import Node from '../../geomgraph/Node'
+
+export default class RelateNode extends Node {
+  constructor () {
+    const coord = arguments[0]
+    const edges = arguments[1]
+    super(coord, edges)
+  }
+  updateIMFromEdges (im) {
+    this._edges.updateIM(im)
+  }
+  computeIM (im) {
+    im.setAtLeastIfValid(this._label.getLocation(0), this._label.getLocation(1), 0)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return RelateNode
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/operation/relate/RelateNodeFactory.js

@@ -0,0 +1,15 @@
+import EdgeEndBundleStar from './EdgeEndBundleStar'
+import RelateNode from './RelateNode'
+import NodeFactory from '../../geomgraph/NodeFactory'
+
+export default class RelateNodeFactory extends NodeFactory {
+  createNode (coord) {
+    return new RelateNode(coord, new EdgeEndBundleStar())
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return RelateNodeFactory
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/operation/relate/RelateNodeGraph.js

@@ -0,0 +1,52 @@
+import Location from '../../geom/Location'
+import EdgeEndBuilder from './EdgeEndBuilder'
+import NodeMap from '../../geomgraph/NodeMap'
+import RelateNodeFactory from './RelateNodeFactory'
+
+export default class RelateNodeGraph {
+  constructor () {
+    this._nodes = new NodeMap(new RelateNodeFactory())
+  }
+  insertEdgeEnds (ee) {
+    for (var i = ee.iterator(); i.hasNext();) {
+      var e = i.next()
+      this._nodes.add(e)
+    }
+  }
+  getNodeIterator () {
+    return this._nodes.iterator()
+  }
+  copyNodesAndLabels (geomGraph, argIndex) {
+    for (var nodeIt = geomGraph.getNodeIterator(); nodeIt.hasNext();) {
+      var graphNode = nodeIt.next()
+      var newNode = this._nodes.addNode(graphNode.getCoordinate())
+      newNode.setLabel(argIndex, graphNode.getLabel().getLocation(argIndex))
+    }
+  }
+  build (geomGraph) {
+    this.computeIntersectionNodes(geomGraph, 0)
+    this.copyNodesAndLabels(geomGraph, 0)
+    var eeBuilder = new EdgeEndBuilder()
+    var eeList = eeBuilder.computeEdgeEnds(geomGraph.getEdgeIterator())
+    this.insertEdgeEnds(eeList)
+  }
+  computeIntersectionNodes (geomGraph, argIndex) {
+    for (var edgeIt = geomGraph.getEdgeIterator(); edgeIt.hasNext();) {
+      var e = edgeIt.next()
+      var eLoc = e.getLabel().getLocation(argIndex)
+      for (var eiIt = e.getEdgeIntersectionList().iterator(); eiIt.hasNext();) {
+        var ei = eiIt.next()
+        var n = this._nodes.addNode(ei.coord)
+        if (eLoc === Location.BOUNDARY) n.setLabelBoundary(argIndex); else {
+          if (n.getLabel().isNull(argIndex)) n.setLabel(argIndex, Location.INTERIOR)
+        }
+      }
+    }
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return RelateNodeGraph
+  }
+}