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

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

@@ -0,0 +1,73 @@
+// geom
+export { default as Coordinate } from './geom/Coordinate'
+export { default as CoordinateArrays } from './geom/CoordinateArrays'
+export { default as CoordinateFilter } from './geom/CoordinateFilter'
+export { default as CoordinateList } from './geom/CoordinateList'
+export { default as CoordinateSequence } from './geom/CoordinateSequence'
+export { default as CoordinateSequenceComparator } from './geom/CoordinateSequenceComparator'
+export { default as CoordinateSequenceFactory } from './geom/CoordinateSequenceFactory'
+export { default as CoordinateSequenceFilter } from './geom/CoordinateSequenceFilter'
+export { default as CoordinateSequences } from './geom/CoordinateSequences'
+export { default as Dimension } from './geom/Dimension'
+export { default as Envelope } from './geom/Envelope'
+export { default as Geometry } from './geom/Geometry'
+export { default as GeometryCollection } from './geom/GeometryCollection'
+export { default as GeometryCollectionIterator } from './geom/GeometryCollectionIterator'
+export { default as GeometryComponentFilter } from './geom/GeometryComponentFilter'
+export { default as GeometryFactory } from './geom/GeometryFactory'
+export { default as GeometryFilter } from './geom/GeometryFilter'
+export { default as IntersectionMatrix } from './geom/IntersectionMatrix'
+export { default as LineSegment } from './geom/LineSegment'
+export { default as LineString } from './geom/LineString'
+export { default as Lineal } from './geom/Lineal'
+export { default as LinearRing } from './geom/LinearRing'
+export { default as Location } from './geom/Location'
+export { default as MultiLineString } from './geom/MultiLineString'
+export { default as MultiPoint } from './geom/MultiPoint'
+export { default as MultiPolygon } from './geom/MultiPolygon'
+export { default as OctagonalEnvelope } from './geom/OctagonalEnvelope'
+export { default as Point } from './geom/Point'
+export { default as Polygon } from './geom/Polygon'
+export { default as Polygonal } from './geom/Polygonal'
+export { default as PrecisionModel } from './geom/PrecisionModel'
+export { default as Puntal } from './geom/Puntal'
+export { default as TopologyException } from './geom/TopologyException'
+export { default as Triangle } from './geom/Triangle'
+
+// geom.impl
+export { default as CoordinateArraySequence } from './geom/impl/CoordinateArraySequence'
+export { default as CoordinateArraySequenceFactory } from './geom/impl/CoordinateArraySequenceFactory'
+
+// geom.prep
+export { default as AbstractPreparedPolygonContains } from './geom/prep/AbstractPreparedPolygonContains'
+export { default as BasicPreparedGeometry } from './geom/prep/BasicPreparedGeometry'
+export { default as PreparedGeometry } from './geom/prep/PreparedGeometry'
+export { default as PreparedGeometryFactory } from './geom/prep/PreparedGeometryFactory'
+export { default as PreparedLineString } from './geom/prep/PreparedLineString'
+export { default as PreparedLineStringIntersects } from './geom/prep/PreparedLineStringIntersects'
+export { default as PreparedPoint } from './geom/prep/PreparedPoint'
+export { default as PreparedPolygon } from './geom/prep/PreparedPolygon'
+export { default as PreparedPolygonContains } from './geom/prep/PreparedPolygonContains'
+export { default as PreparedPolygonContainsProperly } from './geom/prep/PreparedPolygonContainsProperly'
+export { default as PreparedPolygonCovers } from './geom/prep/PreparedPolygonCovers'
+export { default as PreparedPolygonIntersects } from './geom/prep/PreparedPolygonIntersects'
+export { default as PreparedPolygonPredicate } from './geom/prep/PreparedPolygonPredicate'
+
+// geom.util
+export { default as AffineTransformation } from './geom/util/AffineTransformation'
+export { default as AffineTransformationBuilder } from './geom/util/AffineTransformationBuilder'
+export { default as AffineTransformationFactory } from './geom/util/AffineTransformationFactory'
+export { default as ComponentCoordinateExtracter } from './geom/util/ComponentCoordinateExtracter'
+export { default as GeometryCollectionMapper } from './geom/util/GeometryCollectionMapper'
+export { default as GeometryCombiner } from './geom/util/GeometryCombiner'
+export { default as GeometryEditor } from './geom/util/GeometryEditor'
+export { default as GeometryExtracter } from './geom/util/GeometryExtracter'
+export { default as GeometryMapper } from './geom/util/GeometryMapper'
+export { default as GeometryTransformer } from './geom/util/GeometryTransformer'
+export { default as LineStringExtracter } from './geom/util/LineStringExtracter'
+export { default as LinearComponentExtracter } from './geom/util/LinearComponentExtracter'
+export { default as NoninvertibleTransformationException } from './geom/util/NoninvertibleTransformationException'
+export { default as PointExtracter } from './geom/util/PointExtracter'
+export { default as PolygonExtracter } from './geom/util/PolygonExtracter'
+export { default as ShortCircuitedGeometryVisitor } from './geom/util/ShortCircuitedGeometryVisitor'
+export { default as SineStarFactory } from './geom/util/SineStarFactory'

package/node_modules/turf-jsts/src/org/locationtech/jts/geomgraph/Depth.js

@@ -0,0 +1,92 @@
+import Location from '../geom/Location'
+import Position from './Position'
+
+export default class Depth {
+  constructor () {
+    this._depth = Array(2).fill().map(() => Array(3))
+    for (let i = 0; i < 2; i++) {
+      for (let j = 0; j < 3; j++) {
+        this._depth[i][j] = Depth.NULL_VALUE
+      }
+    }
+  }
+  getDepth (geomIndex, posIndex) {
+    return this._depth[geomIndex][posIndex]
+  }
+  setDepth (geomIndex, posIndex, depthValue) {
+    this._depth[geomIndex][posIndex] = depthValue
+  }
+  isNull () {
+    if (arguments.length === 0) {
+      for (let i = 0; i < 2; i++) {
+        for (let j = 0; j < 3; j++) {
+          if (this._depth[i][j] !== Depth.NULL_VALUE) return false
+        }
+      }
+      return true
+    } else if (arguments.length === 1) {
+      const geomIndex = arguments[0]
+      return this._depth[geomIndex][1] === Depth.NULL_VALUE
+    } else if (arguments.length === 2) {
+      const geomIndex = arguments[0]
+      const posIndex = arguments[1]
+      return this._depth[geomIndex][posIndex] === Depth.NULL_VALUE
+    }
+  }
+  normalize () {
+    for (let i = 0; i < 2; i++) {
+      if (!this.isNull(i)) {
+        let minDepth = this._depth[i][1]
+        if (this._depth[i][2] < minDepth) minDepth = this._depth[i][2]
+        if (minDepth < 0) minDepth = 0
+        for (let j = 1; j < 3; j++) {
+          let newValue = 0
+          if (this._depth[i][j] > minDepth) newValue = 1
+          this._depth[i][j] = newValue
+        }
+      }
+    }
+  }
+  getDelta (geomIndex) {
+    return this._depth[geomIndex][Position.RIGHT] - this._depth[geomIndex][Position.LEFT]
+  }
+  getLocation (geomIndex, posIndex) {
+    if (this._depth[geomIndex][posIndex] <= 0) return Location.EXTERIOR
+    return Location.INTERIOR
+  }
+  toString () {
+    return 'A: ' + this._depth[0][1] + ',' + this._depth[0][2] + ' B: ' + this._depth[1][1] + ',' + this._depth[1][2]
+  }
+  add () {
+    if (arguments.length === 1) {
+      const lbl = arguments[0]
+      for (let i = 0; i < 2; i++) {
+        for (let j = 1; j < 3; j++) {
+          const loc = lbl.getLocation(i, j)
+          if (loc === Location.EXTERIOR || loc === Location.INTERIOR) {
+            if (this.isNull(i, j)) {
+              this._depth[i][j] = Depth.depthAtLocation(loc)
+            } else this._depth[i][j] += Depth.depthAtLocation(loc)
+          }
+        }
+      }
+    } else if (arguments.length === 3) {
+      const geomIndex = arguments[0]
+      const posIndex = arguments[1]
+      const location = arguments[2]
+      if (location === Location.INTERIOR) this._depth[geomIndex][posIndex]++
+    }
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return Depth
+  }
+  static depthAtLocation (location) {
+    if (location === Location.EXTERIOR) return 0
+    if (location === Location.INTERIOR) return 1
+    return Depth.NULL_VALUE
+  }
+  static get NULL_VALUE () { return -1 }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/geomgraph/DirectedEdge.js

@@ -0,0 +1,147 @@
+import Location from '../geom/Location'
+import EdgeEnd from './EdgeEnd'
+import Position from './Position'
+import TopologyException from '../geom/TopologyException'
+import Label from './Label'
+
+export default class DirectedEdge extends EdgeEnd {
+  constructor () {
+    const edge = arguments[0]
+    const isForward = arguments[1]
+    super(edge)
+    this._isForward = null
+    this._isInResult = false
+    this._isVisited = false
+    this._sym = null
+    this._next = null
+    this._nextMin = null
+    this._edgeRing = null
+    this._minEdgeRing = null
+    this._depth = [0, -999, -999]
+    this._isForward = isForward
+    if (isForward) {
+      this.init(edge.getCoordinate(0), edge.getCoordinate(1))
+    } else {
+      const n = edge.getNumPoints() - 1
+      this.init(edge.getCoordinate(n), edge.getCoordinate(n - 1))
+    }
+    this.computeDirectedLabel()
+  }
+  getNextMin () {
+    return this._nextMin
+  }
+  getDepth (position) {
+    return this._depth[position]
+  }
+  setVisited (isVisited) {
+    this._isVisited = isVisited
+  }
+  computeDirectedLabel () {
+    this._label = new Label(this._edge.getLabel())
+    if (!this._isForward) this._label.flip()
+  }
+  getNext () {
+    return this._next
+  }
+  setDepth (position, depthVal) {
+    if (this._depth[position] !== -999) {
+      if (this._depth[position] !== depthVal) throw new TopologyException('assigned depths do not match', this.getCoordinate())
+    }
+    this._depth[position] = depthVal
+  }
+  isInteriorAreaEdge () {
+    let isInteriorAreaEdge = true
+    for (let i = 0; i < 2; i++) {
+      if (!(this._label.isArea(i) && this._label.getLocation(i, Position.LEFT) === Location.INTERIOR && this._label.getLocation(i, Position.RIGHT) === Location.INTERIOR)) {
+        isInteriorAreaEdge = false
+      }
+    }
+    return isInteriorAreaEdge
+  }
+  setNextMin (nextMin) {
+    this._nextMin = nextMin
+  }
+  print (out) {
+    EdgeEnd.prototype.print.call(this, out)
+    out.print(' ' + this._depth[Position.LEFT] + '/' + this._depth[Position.RIGHT])
+    out.print(' (' + this.getDepthDelta() + ')')
+    if (this._isInResult) out.print(' inResult')
+  }
+  setMinEdgeRing (minEdgeRing) {
+    this._minEdgeRing = minEdgeRing
+  }
+  isLineEdge () {
+    const isLine = this._label.isLine(0) || this._label.isLine(1)
+    const isExteriorIfArea0 = !this._label.isArea(0) || this._label.allPositionsEqual(0, Location.EXTERIOR)
+    const isExteriorIfArea1 = !this._label.isArea(1) || this._label.allPositionsEqual(1, Location.EXTERIOR)
+    return isLine && isExteriorIfArea0 && isExteriorIfArea1
+  }
+  setEdgeRing (edgeRing) {
+    this._edgeRing = edgeRing
+  }
+  getMinEdgeRing () {
+    return this._minEdgeRing
+  }
+  getDepthDelta () {
+    let depthDelta = this._edge.getDepthDelta()
+    if (!this._isForward) depthDelta = -depthDelta
+    return depthDelta
+  }
+  setInResult (isInResult) {
+    this._isInResult = isInResult
+  }
+  getSym () {
+    return this._sym
+  }
+  isForward () {
+    return this._isForward
+  }
+  getEdge () {
+    return this._edge
+  }
+  printEdge (out) {
+    this.print(out)
+    out.print(' ')
+    if (this._isForward) this._edge.print(out); else this._edge.printReverse(out)
+  }
+  setSym (de) {
+    this._sym = de
+  }
+  setVisitedEdge (isVisited) {
+    this.setVisited(isVisited)
+    this._sym.setVisited(isVisited)
+  }
+  setEdgeDepths (position, depth) {
+    let depthDelta = this.getEdge().getDepthDelta()
+    if (!this._isForward) depthDelta = -depthDelta
+    let directionFactor = 1
+    if (position === Position.LEFT) directionFactor = -1
+    const oppositePos = Position.opposite(position)
+    const delta = depthDelta * directionFactor
+    const oppositeDepth = depth + delta
+    this.setDepth(position, depth)
+    this.setDepth(oppositePos, oppositeDepth)
+  }
+  getEdgeRing () {
+    return this._edgeRing
+  }
+  isInResult () {
+    return this._isInResult
+  }
+  setNext (next) {
+    this._next = next
+  }
+  isVisited () {
+    return this._isVisited
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return DirectedEdge
+  }
+  static depthFactor (currLocation, nextLocation) {
+    if (currLocation === Location.EXTERIOR && nextLocation === Location.INTERIOR) return 1; else if (currLocation === Location.INTERIOR && nextLocation === Location.EXTERIOR) return -1
+    return 0
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/geomgraph/DirectedEdgeStar.js

@@ -0,0 +1,239 @@
+import Location from '../geom/Location'
+import Position from './Position'
+import TopologyException from '../geom/TopologyException'
+import EdgeEndStar from './EdgeEndStar'
+import System from '../../../../java/lang/System'
+import Label from './Label'
+import ArrayList from '../../../../java/util/ArrayList'
+import Quadrant from './Quadrant'
+import Assert from '../util/Assert'
+
+export default class DirectedEdgeStar extends EdgeEndStar {
+  constructor () {
+    super()
+    this._resultAreaEdgeList = null
+    this._label = null
+    this._SCANNING_FOR_INCOMING = 1
+    this._LINKING_TO_OUTGOING = 2
+  }
+  linkResultDirectedEdges () {
+    this.getResultAreaEdges()
+    let firstOut = null
+    let incoming = null
+    let state = this._SCANNING_FOR_INCOMING
+    for (let i = 0; i < this._resultAreaEdgeList.size(); i++) {
+      const nextOut = this._resultAreaEdgeList.get(i)
+      const nextIn = nextOut.getSym()
+      if (!nextOut.getLabel().isArea()) continue
+      if (firstOut === null && nextOut.isInResult()) firstOut = nextOut
+      switch (state) {
+        case this._SCANNING_FOR_INCOMING:
+          if (!nextIn.isInResult()) continue
+          incoming = nextIn
+          state = this._LINKING_TO_OUTGOING
+          break
+        case this._LINKING_TO_OUTGOING:
+          if (!nextOut.isInResult()) continue
+          incoming.setNext(nextOut)
+          state = this._SCANNING_FOR_INCOMING
+          break
+        default:
+      }
+    }
+    if (state === this._LINKING_TO_OUTGOING) {
+      if (firstOut === null) throw new TopologyException('no outgoing dirEdge found', this.getCoordinate())
+      Assert.isTrue(firstOut.isInResult(), 'unable to link last incoming dirEdge')
+      incoming.setNext(firstOut)
+    }
+  }
+  insert (ee) {
+    const de = ee
+    this.insertEdgeEnd(de, de)
+  }
+  getRightmostEdge () {
+    const edges = this.getEdges()
+    const size = edges.size()
+    if (size < 1) return null
+    const de0 = edges.get(0)
+    if (size === 1) return de0
+    const deLast = edges.get(size - 1)
+    const quad0 = de0.getQuadrant()
+    const quad1 = deLast.getQuadrant()
+    if (Quadrant.isNorthern(quad0) && Quadrant.isNorthern(quad1)) return de0; else if (!Quadrant.isNorthern(quad0) && !Quadrant.isNorthern(quad1)) return deLast; else {
+      // const nonHorizontalEdge = null
+      if (de0.getDy() !== 0) return de0; else if (deLast.getDy() !== 0) return deLast
+    }
+    Assert.shouldNeverReachHere('found two horizontal edges incident on node')
+    return null
+  }
+  print (out) {
+    System.out.println('DirectedEdgeStar: ' + this.getCoordinate())
+    for (const it = this.iterator(); it.hasNext();) {
+      const de = it.next()
+      out.print('out ')
+      de.print(out)
+      out.println()
+      out.print('in ')
+      de.getSym().print(out)
+      out.println()
+    }
+  }
+  getResultAreaEdges () {
+    if (this._resultAreaEdgeList !== null) return this._resultAreaEdgeList
+    this._resultAreaEdgeList = new ArrayList()
+    for (const it = this.iterator(); it.hasNext();) {
+      const de = it.next()
+      if (de.isInResult() || de.getSym().isInResult()) this._resultAreaEdgeList.add(de)
+    }
+    return this._resultAreaEdgeList
+  }
+  updateLabelling (nodeLabel) {
+    for (const it = this.iterator(); it.hasNext();) {
+      const de = it.next()
+      const label = de.getLabel()
+      label.setAllLocationsIfNull(0, nodeLabel.getLocation(0))
+      label.setAllLocationsIfNull(1, nodeLabel.getLocation(1))
+    }
+  }
+  linkAllDirectedEdges () {
+    this.getEdges()
+    let prevOut = null
+    let firstIn = null
+    for (let i = this._edgeList.size() - 1; i >= 0; i--) {
+      const nextOut = this._edgeList.get(i)
+      const nextIn = nextOut.getSym()
+      if (firstIn === null) firstIn = nextIn
+      if (prevOut !== null) nextIn.setNext(prevOut)
+      prevOut = nextOut
+    }
+    firstIn.setNext(prevOut)
+  }
+  computeDepths () {
+    if (arguments.length === 1) {
+      let de = arguments[0]
+      const edgeIndex = this.findIndex(de)
+      // const label = de.getLabel()
+      const startDepth = de.getDepth(Position.LEFT)
+      const targetLastDepth = de.getDepth(Position.RIGHT)
+      const nextDepth = this.computeDepths(edgeIndex + 1, this._edgeList.size(), startDepth)
+      const lastDepth = this.computeDepths(0, edgeIndex, nextDepth)
+      if (lastDepth !== targetLastDepth) throw new TopologyException('depth mismatch at ' + de.getCoordinate())
+    } else if (arguments.length === 3) {
+      const startIndex = arguments[0]
+      const endIndex = arguments[1]
+      const startDepth = arguments[2]
+      let currDepth = startDepth
+      for (let i = startIndex; i < endIndex; i++) {
+        const nextDe = this._edgeList.get(i)
+        // const label = nextDe.getLabel()
+        nextDe.setEdgeDepths(Position.RIGHT, currDepth)
+        currDepth = nextDe.getDepth(Position.LEFT)
+      }
+      return currDepth
+    }
+  }
+  mergeSymLabels () {
+    for (const it = this.iterator(); it.hasNext();) {
+      const de = it.next()
+      const label = de.getLabel()
+      label.merge(de.getSym().getLabel())
+    }
+  }
+  linkMinimalDirectedEdges (er) {
+    let firstOut = null
+    let incoming = null
+    let state = this._SCANNING_FOR_INCOMING
+    for (let i = this._resultAreaEdgeList.size() - 1; i >= 0; i--) {
+      const nextOut = this._resultAreaEdgeList.get(i)
+      const nextIn = nextOut.getSym()
+      if (firstOut === null && nextOut.getEdgeRing() === er) firstOut = nextOut
+      switch (state) {
+        case this._SCANNING_FOR_INCOMING:
+          if (nextIn.getEdgeRing() !== er) continue
+          incoming = nextIn
+          state = this._LINKING_TO_OUTGOING
+          break
+        case this._LINKING_TO_OUTGOING:
+          if (nextOut.getEdgeRing() !== er) continue
+          incoming.setNextMin(nextOut)
+          state = this._SCANNING_FOR_INCOMING
+          break
+        default:
+      }
+    }
+    if (state === this._LINKING_TO_OUTGOING) {
+      Assert.isTrue(firstOut !== null, 'found null for first outgoing dirEdge')
+      Assert.isTrue(firstOut.getEdgeRing() === er, 'unable to link last incoming dirEdge')
+      incoming.setNextMin(firstOut)
+    }
+  }
+  getOutgoingDegree () {
+    if (arguments.length === 0) {
+      let degree = 0
+      for (const it = this.iterator(); it.hasNext();) {
+        const de = it.next()
+        if (de.isInResult()) degree++
+      }
+      return degree
+    } else if (arguments.length === 1) {
+      let er = arguments[0]
+      let degree = 0
+      for (const it = this.iterator(); it.hasNext();) {
+        const de = it.next()
+        if (de.getEdgeRing() === er) degree++
+      }
+      return degree
+    }
+  }
+  getLabel () {
+    return this._label
+  }
+  findCoveredLineEdges () {
+    let startLoc = Location.NONE
+    for (const it = this.iterator(); it.hasNext();) {
+      const nextOut = it.next()
+      const nextIn = nextOut.getSym()
+      if (!nextOut.isLineEdge()) {
+        if (nextOut.isInResult()) {
+          startLoc = Location.INTERIOR
+          break
+        }
+        if (nextIn.isInResult()) {
+          startLoc = Location.EXTERIOR
+          break
+        }
+      }
+    }
+    if (startLoc === Location.NONE) return null
+    let currLoc = startLoc
+    for (const it = this.iterator(); it.hasNext();) {
+      const nextOut = it.next()
+      const nextIn = nextOut.getSym()
+      if (nextOut.isLineEdge()) {
+        nextOut.getEdge().setCovered(currLoc === Location.INTERIOR)
+      } else {
+        if (nextOut.isInResult()) currLoc = Location.EXTERIOR
+        if (nextIn.isInResult()) currLoc = Location.INTERIOR
+      }
+    }
+  }
+  computeLabelling (geom) {
+    EdgeEndStar.prototype.computeLabelling.call(this, geom)
+    this._label = new Label(Location.NONE)
+    for (const it = this.iterator(); it.hasNext();) {
+      const ee = it.next()
+      const e = ee.getEdge()
+      const eLabel = e.getLabel()
+      for (let i = 0; i < 2; i++) {
+        const eLoc = eLabel.getLocation(i)
+        if (eLoc === Location.INTERIOR || eLoc === Location.BOUNDARY) this._label.setLocation(i, Location.INTERIOR)
+      }
+    }
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return DirectedEdgeStar
+  }
+}