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

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

@@ -0,0 +1,117 @@
+import Location from '../../geom/Location'
+import hasInterface from '../../../../../hasInterface'
+import Coordinate from '../../geom/Coordinate'
+import AxisPlaneCoordinateSequence from './AxisPlaneCoordinateSequence'
+import Vector3D from '../../math/Vector3D'
+import CoordinateSequence from '../../geom/CoordinateSequence'
+import Plane3D from '../../math/Plane3D'
+import RayCrossingCounter from '../../algorithm/RayCrossingCounter'
+
+export default class PlanarPolygon3D {
+  constructor () {
+    this._plane = null
+    this._poly = null
+    this._facingPlane = -1
+    const poly = arguments[0]
+    this._poly = poly
+    this._plane = this.findBestFitPlane(poly)
+    this._facingPlane = this._plane.closestAxisPlane()
+  }
+  intersects () {
+    if (arguments.length === 1) {
+      const intPt = arguments[0]
+      if (Location.EXTERIOR === this.locate(intPt, this._poly.getExteriorRing())) return false
+      for (let i = 0; i < this._poly.getNumInteriorRing(); i++) {
+        if (Location.INTERIOR === this.locate(intPt, this._poly.getInteriorRingN(i))) return false
+      }
+      return true
+    } else if (arguments.length === 2) {
+      const pt = arguments[0]
+      const ring = arguments[1]
+      const seq = ring.getCoordinateSequence()
+      const seqProj = PlanarPolygon3D.project(seq, this._facingPlane)
+      const ptProj = PlanarPolygon3D.project(pt, this._facingPlane)
+      return Location.EXTERIOR !== RayCrossingCounter.locatePointInRing(ptProj, seqProj)
+    }
+  }
+  averagePoint (seq) {
+    const a = new Coordinate(0, 0, 0)
+    const n = seq.size()
+    for (let i = 0; i < n; i++) {
+      a.x += seq.getOrdinate(i, CoordinateSequence.X)
+      a.y += seq.getOrdinate(i, CoordinateSequence.Y)
+      a.z += seq.getOrdinate(i, CoordinateSequence.Z)
+    }
+    a.x /= n
+    a.y /= n
+    a.z /= n
+    return a
+  }
+  getPolygon () {
+    return this._poly
+  }
+  getPlane () {
+    return this._plane
+  }
+  findBestFitPlane (poly) {
+    const seq = poly.getExteriorRing().getCoordinateSequence()
+    const basePt = this.averagePoint(seq)
+    const normal = this.averageNormal(seq)
+    return new Plane3D(normal, basePt)
+  }
+  averageNormal (seq) {
+    const n = seq.size()
+    const sum = new Coordinate(0, 0, 0)
+    const p1 = new Coordinate(0, 0, 0)
+    const p2 = new Coordinate(0, 0, 0)
+    for (let i = 0; i < n - 1; i++) {
+      seq.getCoordinate(i, p1)
+      seq.getCoordinate(i + 1, p2)
+      sum.x += (p1.y - p2.y) * (p1.z + p2.z)
+      sum.y += (p1.z - p2.z) * (p1.x + p2.x)
+      sum.z += (p1.x - p2.x) * (p1.y + p2.y)
+    }
+    sum.x /= n
+    sum.y /= n
+    sum.z /= n
+    const norm = Vector3D.create(sum).normalize()
+    return norm
+  }
+  locate (pt, ring) {
+    const seq = ring.getCoordinateSequence()
+    const seqProj = PlanarPolygon3D.project(seq, this._facingPlane)
+    const ptProj = PlanarPolygon3D.project(pt, this._facingPlane)
+    return RayCrossingCounter.locatePointInRing(ptProj, seqProj)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return PlanarPolygon3D
+  }
+  static project () {
+    if (hasInterface(arguments[0], CoordinateSequence) && Number.isInteger(arguments[1])) {
+      const seq = arguments[0]
+      const facingPlane = arguments[1]
+      switch (facingPlane) {
+        case Plane3D.XY_PLANE:
+          return AxisPlaneCoordinateSequence.projectToXY(seq)
+        case Plane3D.XZ_PLANE:
+          return AxisPlaneCoordinateSequence.projectToXZ(seq)
+        default:
+          return AxisPlaneCoordinateSequence.projectToYZ(seq)
+      }
+    } else if (arguments[0] instanceof Coordinate && Number.isInteger(arguments[1])) {
+      const p = arguments[0]
+      const facingPlane = arguments[1]
+      switch (facingPlane) {
+        case Plane3D.XY_PLANE:
+          return new Coordinate(p.x, p.y)
+        case Plane3D.XZ_PLANE:
+          return new Coordinate(p.x, p.z)
+        default:
+          return new Coordinate(p.y, p.z)
+      }
+    }
+  }
+}

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

@@ -0,0 +1,4 @@
+// operation.distance3d
+export { default as AxisPlaneCoordinateSequence } from './distance3d/AxisPlaneCoordinateSequence'
+export { default as Distance3DOp } from './distance3d/Distance3DOp'
+export { default as PlanarPolygon3D } from './distance3d/PlanarPolygon3D'

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

@@ -0,0 +1,46 @@
+import BoundaryNodeRule from '../../algorithm/BoundaryNodeRule'
+import GeometryGraph from '../../geomgraph/GeometryGraph'
+import RobustLineIntersector from '../../algorithm/RobustLineIntersector'
+
+export default class GeometryGraphOp {
+  constructor () {
+    this._li = new RobustLineIntersector()
+    this._resultPrecisionModel = null
+    this._arg = null
+    if (arguments.length === 1) {
+      const g0 = arguments[0]
+      this.setComputationPrecision(g0.getPrecisionModel())
+      this._arg = new Array(1).fill(null)
+      this._arg[0] = new GeometryGraph(0, g0)
+    } else if (arguments.length === 2) {
+      const g0 = arguments[0]
+      const g1 = arguments[1]
+      const boundaryNodeRule = BoundaryNodeRule.OGC_SFS_BOUNDARY_RULE
+      if (g0.getPrecisionModel().compareTo(g1.getPrecisionModel()) >= 0) this.setComputationPrecision(g0.getPrecisionModel()); else this.setComputationPrecision(g1.getPrecisionModel())
+      this._arg = new Array(2).fill(null)
+      this._arg[0] = new GeometryGraph(0, g0, boundaryNodeRule)
+      this._arg[1] = new GeometryGraph(1, g1, boundaryNodeRule)
+    } else if (arguments.length === 3) {
+      const g0 = arguments[0]
+      const g1 = arguments[1]
+      const boundaryNodeRule = arguments[2]
+      if (g0.getPrecisionModel().compareTo(g1.getPrecisionModel()) >= 0) this.setComputationPrecision(g0.getPrecisionModel()); else this.setComputationPrecision(g1.getPrecisionModel())
+      this._arg = new Array(2).fill(null)
+      this._arg[0] = new GeometryGraph(0, g0, boundaryNodeRule)
+      this._arg[1] = new GeometryGraph(1, g1, boundaryNodeRule)
+    }
+  }
+  getArgGeometry (i) {
+    return this._arg[i].getGeometry()
+  }
+  setComputationPrecision (pm) {
+    this._resultPrecisionModel = pm
+    this._li.setPrecisionModel(this._resultPrecisionModel)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return GeometryGraphOp
+  }
+}

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

@@ -0,0 +1,2 @@
+// operation.geometrygraph
+export { default as GeometryGraphOp } from './geometrygraph/GeometryGraphOp'

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

@@ -0,0 +1,164 @@
+import TreeSet from '../../../../../java/util/TreeSet'
+import LineString from '../../geom/LineString'
+import hasInterface from '../../../../../hasInterface'
+import MultiPoint from '../../geom/MultiPoint'
+import GeometryGraph from '../../geomgraph/GeometryGraph'
+import GeometryCollection from '../../geom/GeometryCollection'
+import Polygonal from '../../geom/Polygonal'
+import RobustLineIntersector from '../../algorithm/RobustLineIntersector'
+import LinearComponentExtracter from '../../geom/util/LinearComponentExtracter'
+import TreeMap from '../../../../../java/util/TreeMap'
+import MultiLineString from '../../geom/MultiLineString'
+
+export default class IsSimpleOp {
+  constructor () {
+    this._inputGeom = null
+    this._isClosedEndpointsInInterior = true
+    this._nonSimpleLocation = null
+    if (arguments.length === 1) {
+      const geom = arguments[0]
+      this._inputGeom = geom
+    } else if (arguments.length === 2) {
+      const geom = arguments[0]
+      const boundaryNodeRule = arguments[1]
+      this._inputGeom = geom
+      this._isClosedEndpointsInInterior = !boundaryNodeRule.isInBoundary(2)
+    }
+  }
+  isSimpleMultiPoint (mp) {
+    if (mp.isEmpty()) return true
+    const points = new TreeSet()
+    for (let i = 0; i < mp.getNumGeometries(); i++) {
+      const pt = mp.getGeometryN(i)
+      const p = pt.getCoordinate()
+      if (points.contains(p)) {
+        this._nonSimpleLocation = p
+        return false
+      }
+      points.add(p)
+    }
+    return true
+  }
+  isSimplePolygonal (geom) {
+    const rings = LinearComponentExtracter.getLines(geom)
+    for (const i = rings.iterator(); i.hasNext();) {
+      const ring = i.next()
+      if (!this.isSimpleLinearGeometry(ring)) return false
+    }
+    return true
+  }
+  hasClosedEndpointIntersection (graph) {
+    const endPoints = new TreeMap()
+    for (const i = graph.getEdgeIterator(); i.hasNext();) {
+      const e = i.next()
+      // const maxSegmentIndex = e.getMaximumSegmentIndex()
+      const isClosed = e.isClosed()
+      const p0 = e.getCoordinate(0)
+      this.addEndpoint(endPoints, p0, isClosed)
+      const p1 = e.getCoordinate(e.getNumPoints() - 1)
+      this.addEndpoint(endPoints, p1, isClosed)
+    }
+    for (const i = endPoints.values().iterator(); i.hasNext();) {
+      const eiInfo = i.next()
+      if (eiInfo.isClosed && eiInfo.degree !== 2) {
+        this._nonSimpleLocation = eiInfo.getCoordinate()
+        return true
+      }
+    }
+    return false
+  }
+  getNonSimpleLocation () {
+    return this._nonSimpleLocation
+  }
+  isSimpleLinearGeometry (geom) {
+    if (geom.isEmpty()) return true
+    const graph = new GeometryGraph(0, geom)
+    const li = new RobustLineIntersector()
+    const si = graph.computeSelfNodes(li, true)
+    if (!si.hasIntersection()) return true
+    if (si.hasProperIntersection()) {
+      this._nonSimpleLocation = si.getProperIntersectionPoint()
+      return false
+    }
+    if (this.hasNonEndpointIntersection(graph)) return false
+    if (this._isClosedEndpointsInInterior) {
+      if (this.hasClosedEndpointIntersection(graph)) return false
+    }
+    return true
+  }
+  hasNonEndpointIntersection (graph) {
+    for (const i = graph.getEdgeIterator(); i.hasNext();) {
+      const e = i.next()
+      const maxSegmentIndex = e.getMaximumSegmentIndex()
+      for (const eiIt = e.getEdgeIntersectionList().iterator(); eiIt.hasNext();) {
+        const ei = eiIt.next()
+        if (!ei.isEndPoint(maxSegmentIndex)) {
+          this._nonSimpleLocation = ei.getCoordinate()
+          return true
+        }
+      }
+    }
+    return false
+  }
+  addEndpoint (endPoints, p, isClosed) {
+    let eiInfo = endPoints.get(p)
+    if (eiInfo === null) {
+      eiInfo = new EndpointInfo(p)
+      endPoints.put(p, eiInfo)
+    }
+    eiInfo.addEndpoint(isClosed)
+  }
+  computeSimple (geom) {
+    this._nonSimpleLocation = null
+    if (geom.isEmpty()) return true
+    if (geom instanceof LineString) return this.isSimpleLinearGeometry(geom)
+    if (geom instanceof MultiLineString) return this.isSimpleLinearGeometry(geom)
+    if (geom instanceof MultiPoint) return this.isSimpleMultiPoint(geom)
+    if (hasInterface(geom, Polygonal)) return this.isSimplePolygonal(geom)
+    if (geom instanceof GeometryCollection) return this.isSimpleGeometryCollection(geom)
+    return true
+  }
+  isSimple () {
+    this._nonSimpleLocation = null
+    return this.computeSimple(this._inputGeom)
+  }
+  isSimpleGeometryCollection (geom) {
+    for (let i = 0; i < geom.getNumGeometries(); i++) {
+      const comp = geom.getGeometryN(i)
+      if (!this.computeSimple(comp)) return false
+    }
+    return true
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return IsSimpleOp
+  }
+  static get EndpointInfo () { return EndpointInfo }
+}
+
+class EndpointInfo {
+  constructor () {
+    this.pt = null
+    this.isClosed = null
+    this.degree = null
+    const pt = arguments[0]
+    this.pt = pt
+    this.isClosed = false
+    this.degree = 0
+  }
+  addEndpoint (isClosed) {
+    this.degree++
+    this.isClosed |= isClosed
+  }
+  getCoordinate () {
+    return this.pt
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return EndpointInfo
+  }
+}

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

@@ -0,0 +1,2 @@
+// operation.issimple
+export { default as IsSimpleOp } from './issimple/IsSimpleOp'

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

@@ -0,0 +1,46 @@
+import CoordinateList from '../../geom/CoordinateList'
+import CoordinateArrays from '../../geom/CoordinateArrays'
+import ArrayList from '../../../../../java/util/ArrayList'
+
+export default class EdgeString {
+  constructor () {
+    this._factory = null
+    this._directedEdges = new ArrayList()
+    this._coordinates = null
+    let factory = arguments[0]
+    this._factory = factory
+  }
+  getCoordinates () {
+    if (this._coordinates === null) {
+      let forwardDirectedEdges = 0
+      let reverseDirectedEdges = 0
+      const coordinateList = new CoordinateList()
+      for (const i = this._directedEdges.iterator(); i.hasNext();) {
+        const directedEdge = i.next()
+        if (directedEdge.getEdgeDirection()) {
+          forwardDirectedEdges++
+        } else {
+          reverseDirectedEdges++
+        }
+        coordinateList.add(directedEdge.getEdge().getLine().getCoordinates(), false, directedEdge.getEdgeDirection())
+      }
+      this._coordinates = coordinateList.toCoordinateArray()
+      if (reverseDirectedEdges > forwardDirectedEdges) {
+        CoordinateArrays.reverse(this._coordinates)
+      }
+    }
+    return this._coordinates
+  }
+  toLineString () {
+    return this._factory.createLineString(this.getCoordinates())
+  }
+  add (directedEdge) {
+    this._directedEdges.add(directedEdge)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return EdgeString
+  }
+}

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

@@ -0,0 +1,28 @@
+import DirectedEdge from '../../planargraph/DirectedEdge'
+import Assert from '../../util/Assert'
+
+export default class LineMergeDirectedEdge extends DirectedEdge {
+  constructor () {
+    const from = arguments[0]
+    const to = arguments[1]
+    const directionPt = arguments[2]
+    const edgeDirection = arguments[3]
+    super(from, to, directionPt, edgeDirection)
+  }
+  getNext () {
+    if (this.getToNode().getDegree() !== 2) {
+      return null
+    }
+    if (this.getToNode().getOutEdges().getEdges().get(0) === this.getSym()) {
+      return this.getToNode().getOutEdges().getEdges().get(1)
+    }
+    Assert.isTrue(this.getToNode().getOutEdges().getEdges().get(1) === this.getSym())
+    return this.getToNode().getOutEdges().getEdges().get(0)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return LineMergeDirectedEdge
+  }
+}

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

@@ -0,0 +1,17 @@
+import Edge from '../../planargraph/Edge'
+
+export default class LineMergeEdge extends Edge {
+  constructor () {
+    super()
+    this._line = arguments[0] || null
+  }
+  getLine () {
+    return this._line
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return LineMergeEdge
+  }
+}

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

@@ -0,0 +1,38 @@
+import LineMergeDirectedEdge from './LineMergeDirectedEdge'
+import Node from '../../planargraph/Node'
+import CoordinateArrays from '../../geom/CoordinateArrays'
+import LineMergeEdge from './LineMergeEdge'
+import PlanarGraph from '../../planargraph/PlanarGraph'
+
+export default class LineMergeGraph extends PlanarGraph {
+  addEdge (lineString) {
+    if (lineString.isEmpty()) {
+      return null
+    }
+    const coordinates = CoordinateArrays.removeRepeatedPoints(lineString.getCoordinates())
+    if (coordinates.length <= 1) return null
+    const startCoordinate = coordinates[0]
+    const endCoordinate = coordinates[coordinates.length - 1]
+    const startNode = this.getNode(startCoordinate)
+    const endNode = this.getNode(endCoordinate)
+    const directedEdge0 = new LineMergeDirectedEdge(startNode, endNode, coordinates[1], true)
+    const directedEdge1 = new LineMergeDirectedEdge(endNode, startNode, coordinates[coordinates.length - 2], false)
+    const edge = new LineMergeEdge(lineString)
+    edge.setDirectedEdges(directedEdge0, directedEdge1)
+    this.add(edge)
+  }
+  getNode (coordinate) {
+    let node = this.findNode(coordinate)
+    if (node === null) {
+      node = new Node(coordinate)
+      this.add(node)
+    }
+    return node
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return LineMergeGraph
+  }
+}

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

@@ -0,0 +1,116 @@
+import LineString from '../../geom/LineString'
+import Geometry from '../../geom/Geometry'
+import hasInterface from '../../../../../hasInterface'
+import Collection from '../../../../../java/util/Collection'
+import EdgeString from './EdgeString'
+import LineMergeGraph from './LineMergeGraph'
+import GeometryComponentFilter from '../../geom/GeometryComponentFilter'
+import ArrayList from '../../../../../java/util/ArrayList'
+import Assert from '../../util/Assert'
+import GraphComponent from '../../planargraph/GraphComponent'
+
+export default class LineMerger {
+  constructor () {
+    this._graph = new LineMergeGraph()
+    this._mergedLineStrings = null
+    this._factory = null
+    this._edgeStrings = null
+  }
+  buildEdgeStringsForUnprocessedNodes () {
+    for (const i = this._graph.getNodes().iterator(); i.hasNext();) {
+      const node = i.next()
+      if (!node.isMarked()) {
+        Assert.isTrue(node.getDegree() === 2)
+        this.buildEdgeStringsStartingAt(node)
+        node.setMarked(true)
+      }
+    }
+  }
+  buildEdgeStringsForNonDegree2Nodes () {
+    for (const i = this._graph.getNodes().iterator(); i.hasNext();) {
+      const node = i.next()
+      if (node.getDegree() !== 2) {
+        this.buildEdgeStringsStartingAt(node)
+        node.setMarked(true)
+      }
+    }
+  }
+  buildEdgeStringsForObviousStartNodes () {
+    this.buildEdgeStringsForNonDegree2Nodes()
+  }
+  getMergedLineStrings () {
+    this.merge()
+    return this._mergedLineStrings
+  }
+  buildEdgeStringsStartingAt (node) {
+    for (const i = node.getOutEdges().iterator(); i.hasNext();) {
+      const directedEdge = i.next()
+      if (directedEdge.getEdge().isMarked()) {
+        continue
+      }
+      this._edgeStrings.add(this.buildEdgeStringStartingWith(directedEdge))
+    }
+  }
+  merge () {
+    if (this._mergedLineStrings !== null) {
+      return null
+    }
+    GraphComponent.setMarked(this._graph.nodeIterator(), false)
+    GraphComponent.setMarked(this._graph.edgeIterator(), false)
+    this._edgeStrings = new ArrayList()
+    this.buildEdgeStringsForObviousStartNodes()
+    this.buildEdgeStringsForIsolatedLoops()
+    this._mergedLineStrings = new ArrayList()
+    for (const i = this._edgeStrings.iterator(); i.hasNext();) {
+      const edgeString = i.next()
+      this._mergedLineStrings.add(edgeString.toLineString())
+    }
+  }
+  buildEdgeStringStartingWith (start) {
+    const edgeString = new EdgeString(this._factory)
+    let current = start
+    do {
+      edgeString.add(current)
+      current.getEdge().setMarked(true)
+      current = current.getNext()
+    } while (current !== null && current !== start)
+    return edgeString
+  }
+  add () {
+    if (arguments[0] instanceof Geometry) {
+      let geometry = arguments[0]
+      geometry.appy({
+        interfaces_: function () {
+          return [GeometryComponentFilter]
+        },
+        filter: function (component) {
+          if (component instanceof LineString) {
+            this.add(component)
+          }
+        }
+      })
+    } else if (hasInterface(arguments[0], Collection)) {
+      let geometries = arguments[0]
+      this._mergedLineStrings = null
+      for (const i = geometries.iterator(); i.hasNext();) {
+        const geometry = i.next()
+        this.add(geometry)
+      }
+    } else if (arguments[0] instanceof LineString) {
+      let lineString = arguments[0]
+      if (this._factory === null) {
+        this._factory = lineString.getFactory()
+      }
+      this._graph.addEdge(lineString)
+    }
+  }
+  buildEdgeStringsForIsolatedLoops () {
+    this.buildEdgeStringsForUnprocessedNodes()
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return LineMerger
+  }
+}