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

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

@@ -0,0 +1,105 @@
+import GeometryFactory from '../geom/GeometryFactory'
+import RobustLineIntersector from '../algorithm/RobustLineIntersector'
+import RuntimeException from '../../../../java/lang/RuntimeException'
+
+export default class NodingValidator {
+  constructor () {
+    this._li = new RobustLineIntersector()
+    this._segStrings = null
+    const segStrings = arguments[0]
+    this._segStrings = segStrings
+  }
+  checkEndPtVertexIntersections () {
+    if (arguments.length === 0) {
+      for (const i = this._segStrings.iterator(); i.hasNext();) {
+        const ss = i.next()
+        const pts = ss.getCoordinates()
+        this.checkEndPtVertexIntersections(pts[0], this._segStrings)
+        this.checkEndPtVertexIntersections(pts[pts.length - 1], this._segStrings)
+      }
+    } else if (arguments.length === 2) {
+      const testPt = arguments[0]
+      const segStrings = arguments[1]
+      for (const i = segStrings.iterator(); i.hasNext();) {
+        const ss = i.next()
+        const pts = ss.getCoordinates()
+        for (let j = 1; j < pts.length - 1; j++) {
+          if (pts[j].equals(testPt)) throw new RuntimeException('found endpt/interior pt intersection at index ' + j + ' :pt ' + testPt)
+        }
+      }
+    }
+  }
+  checkInteriorIntersections () {
+    if (arguments.length === 0) {
+      for (const i = this._segStrings.iterator(); i.hasNext();) {
+        const ss0 = i.next()
+        for (const j = this._segStrings.iterator(); j.hasNext();) {
+          const ss1 = j.next()
+          this.checkInteriorIntersections(ss0, ss1)
+        }
+      }
+    } else if (arguments.length === 2) {
+      const ss0 = arguments[0]
+      const ss1 = arguments[1]
+      const pts0 = ss0.getCoordinates()
+      const pts1 = ss1.getCoordinates()
+      for (let i0 = 0; i0 < pts0.length - 1; i0++) {
+        for (let i1 = 0; i1 < pts1.length - 1; i1++) {
+          this.checkInteriorIntersections(ss0, i0, ss1, i1)
+        }
+      }
+    } else if (arguments.length === 4) {
+      const e0 = arguments[0]
+      const segIndex0 = arguments[1]
+      const e1 = arguments[2]
+      const segIndex1 = arguments[3]
+      if (e0 === e1 && segIndex0 === segIndex1) return null
+      const p00 = e0.getCoordinates()[segIndex0]
+      const p01 = e0.getCoordinates()[segIndex0 + 1]
+      const p10 = e1.getCoordinates()[segIndex1]
+      const p11 = e1.getCoordinates()[segIndex1 + 1]
+      this._li.computeIntersection(p00, p01, p10, p11)
+      if (this._li.hasIntersection()) {
+        if (this._li.isProper() || this.hasInteriorIntersection(this._li, p00, p01) || this.hasInteriorIntersection(this._li, p10, p11)) {
+          throw new RuntimeException('found non-noded intersection at ' + p00 + '-' + p01 + ' and ' + p10 + '-' + p11)
+        }
+      }
+    }
+  }
+  checkValid () {
+    this.checkEndPtVertexIntersections()
+    this.checkInteriorIntersections()
+    this.checkCollapses()
+  }
+  checkCollapses () {
+    if (arguments.length === 0) {
+      for (const i = this._segStrings.iterator(); i.hasNext();) {
+        const ss = i.next()
+        this.checkCollapses(ss)
+      }
+    } else if (arguments.length === 1) {
+      const ss = arguments[0]
+      const pts = ss.getCoordinates()
+      for (let i = 0; i < pts.length - 2; i++) {
+        this.checkCollapse(pts[i], pts[i + 1], pts[i + 2])
+      }
+    }
+  }
+  hasInteriorIntersection (li, p0, p1) {
+    for (let i = 0; i < li.getIntersectionNum(); i++) {
+      const intPt = li.getIntersection(i)
+      if (!(intPt.equals(p0) || intPt.equals(p1))) return true
+    }
+    return false
+  }
+  checkCollapse (p0, p1, p2) {
+    if (p0.equals(p2)) throw new RuntimeException('found non-noded collapse at ' + NodingValidator.fact.createLineString([p0, p1, p2]))
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return NodingValidator
+  }
+  static get fact () { return new GeometryFactory() }
+}

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

@@ -0,0 +1,40 @@
+import Coordinate from '../geom/Coordinate'
+import IllegalArgumentException from '../../../../java/lang/IllegalArgumentException'
+
+export default class Octant {
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return Octant
+  }
+  static octant () {
+    if (typeof arguments[0] === 'number' && typeof arguments[1] === 'number') {
+      const dx = arguments[0]
+      const dy = arguments[1]
+      if (dx === 0.0 && dy === 0.0) throw new IllegalArgumentException('Cannot compute the octant for point ( ' + dx + ', ' + dy + ' )')
+      const adx = Math.abs(dx)
+      const ady = Math.abs(dy)
+      if (dx >= 0) {
+        if (dy >= 0) {
+          if (adx >= ady) return 0; else return 1
+        } else {
+          if (adx >= ady) return 7; else return 6
+        }
+      } else {
+        if (dy >= 0) {
+          if (adx >= ady) return 3; else return 2
+        } else {
+          if (adx >= ady) return 4; else return 5
+        }
+      }
+    } else if (arguments[0] instanceof Coordinate && arguments[1] instanceof Coordinate) {
+      const p0 = arguments[0]
+      const p1 = arguments[1]
+      const dx = p1.x - p0.x
+      const dy = p1.y - p0.y
+      if (dx === 0.0 && dy === 0.0) throw new IllegalArgumentException('Cannot compute the octant for two identical points ' + p0)
+      return Octant.octant(dx, dy)
+    }
+  }
+}

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

@@ -0,0 +1,46 @@
+import Comparable from '../../../../java/lang/Comparable'
+import CoordinateArrays from '../geom/CoordinateArrays'
+
+export default class OrientedCoordinateArray {
+  constructor () {
+    this._pts = null
+    this._orientation = null
+    const pts = arguments[0]
+    this._pts = pts
+    this._orientation = OrientedCoordinateArray.orientation(pts)
+  }
+  compareTo (o1) {
+    const oca = o1
+    const comp = OrientedCoordinateArray.compareOriented(this._pts, this._orientation, oca._pts, oca._orientation)
+    return comp
+  }
+  interfaces_ () {
+    return [Comparable]
+  }
+  getClass () {
+    return OrientedCoordinateArray
+  }
+  static orientation (pts) {
+    return CoordinateArrays.increasingDirection(pts) === 1
+  }
+  static compareOriented (pts1, orientation1, pts2, orientation2) {
+    const dir1 = orientation1 ? 1 : -1
+    const dir2 = orientation2 ? 1 : -1
+    const limit1 = orientation1 ? pts1.length : -1
+    const limit2 = orientation2 ? pts2.length : -1
+    let i1 = orientation1 ? 0 : pts1.length - 1
+    let i2 = orientation2 ? 0 : pts2.length - 1
+    // const comp = 0
+    while (true) {
+      const compPt = pts1[i1].compareTo(pts2[i2])
+      if (compPt !== 0) return compPt
+      i1 += dir1
+      i2 += dir2
+      const done1 = i1 === limit1
+      const done2 = i2 === limit2
+      if (done1 && !done2) return -1
+      if (!done1 && done2) return 1
+      if (done1 && done2) return 0
+    }
+  }
+}

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

@@ -0,0 +1,99 @@
+import hasInterface from '../../../../hasInterface'
+import Collection from '../../../../java/util/Collection'
+import Noder from './Noder'
+import Coordinate from '../geom/Coordinate'
+import NodedSegmentString from './NodedSegmentString'
+import System from '../../../../java/lang/System'
+import CoordinateArrays from '../geom/CoordinateArrays'
+import ArrayList from '../../../../java/util/ArrayList'
+
+export default class ScaledNoder {
+  constructor () {
+    this._noder = null
+    this._scaleFactor = null
+    this._offsetX = null
+    this._offsetY = null
+    this._isScaled = false
+    if (arguments.length === 2) {
+      const noder = arguments[0]
+      const scaleFactor = arguments[1]
+      this._noder = noder
+      this._scaleFactor = scaleFactor
+      this._offsetX = 0.0
+      this._offsetY = 0.0
+      this._isScaled = !this.isIntegerPrecision()
+    } else if (arguments.length === 4) {
+      const noder = arguments[0]
+      const scaleFactor = arguments[1]
+      const offsetX = arguments[2]
+      const offsetY = arguments[3]
+      this._noder = noder
+      this._scaleFactor = scaleFactor
+      this._offsetX = offsetX
+      this._offsetY = offsetY
+      this._isScaled = !this.isIntegerPrecision()
+    }
+  }
+  rescale () {
+    if (hasInterface(arguments[0], Collection)) {
+      const segStrings = arguments[0]
+      for (const i = segStrings.iterator(); i.hasNext();) {
+        const ss = i.next()
+        this.rescale(ss.getCoordinates())
+      }
+    } else if (arguments[0] instanceof Array) {
+      const pts = arguments[0]
+      // let p0 = null
+      // let p1 = null
+      // if (pts.length === 2) {
+      //   p0 = new Coordinate(pts[0])
+      //   p1 = new Coordinate(pts[1])
+      // }
+      for (let i = 0; i < pts.length; i++) {
+        pts[i].x = pts[i].x / this._scaleFactor + this._offsetX
+        pts[i].y = pts[i].y / this._scaleFactor + this._offsetY
+      }
+      if (pts.length === 2 && pts[0].equals2D(pts[1])) {
+        System.out.println(pts)
+      }
+    }
+  }
+  scale () {
+    if (hasInterface(arguments[0], Collection)) {
+      const segStrings = arguments[0]
+      const nodedSegmentStrings = new ArrayList()
+      for (const i = segStrings.iterator(); i.hasNext();) {
+        const ss = i.next()
+        nodedSegmentStrings.add(new NodedSegmentString(this.scale(ss.getCoordinates()), ss.getData()))
+      }
+      return nodedSegmentStrings
+    } else if (arguments[0] instanceof Array) {
+      const pts = arguments[0]
+      const roundPts = new Array(pts.length).fill(null)
+      for (let i = 0; i < pts.length; i++) {
+        roundPts[i] = new Coordinate(Math.round((pts[i].x - this._offsetX) * this._scaleFactor), Math.round((pts[i].y - this._offsetY) * this._scaleFactor), pts[i].z)
+      }
+      const roundPtsNoDup = CoordinateArrays.removeRepeatedPoints(roundPts)
+      return roundPtsNoDup
+    }
+  }
+  isIntegerPrecision () {
+    return this._scaleFactor === 1.0
+  }
+  getNodedSubstrings () {
+    const splitSS = this._noder.getNodedSubstrings()
+    if (this._isScaled) this.rescale(splitSS)
+    return splitSS
+  }
+  computeNodes (inputSegStrings) {
+    let intSegStrings = inputSegStrings
+    if (this._isScaled) intSegStrings = this.scale(inputSegStrings)
+    this._noder.computeNodes(intSegStrings)
+  }
+  interfaces_ () {
+    return [Noder]
+  }
+  getClass () {
+    return ScaledNoder
+  }
+}

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

@@ -0,0 +1,81 @@
+import SegmentIntersector from './SegmentIntersector'
+import RobustLineIntersector from '../algorithm/RobustLineIntersector'
+
+export default class SegmentIntersectionDetector {
+  constructor () {
+    this._li = null
+    this._findProper = false
+    this._findAllTypes = false
+    this._hasIntersection = false
+    this._hasProperIntersection = false
+    this._hasNonProperIntersection = false
+    this._intPt = null
+    this._intSegments = null
+    if (arguments.length === 0) {
+      SegmentIntersectionDetector.call(this, new RobustLineIntersector())
+    } else if (arguments.length === 1) {
+      const li = arguments[0]
+      this._li = li
+    }
+  }
+  getIntersectionSegments () {
+    return this._intSegments
+  }
+  setFindAllIntersectionTypes (findAllTypes) {
+    this._findAllTypes = findAllTypes
+  }
+  hasProperIntersection () {
+    return this._hasProperIntersection
+  }
+  getIntersection () {
+    return this._intPt
+  }
+  processIntersections (e0, segIndex0, e1, segIndex1) {
+    if (e0 === e1 && segIndex0 === segIndex1) return null
+    const p00 = e0.getCoordinates()[segIndex0]
+    const p01 = e0.getCoordinates()[segIndex0 + 1]
+    const p10 = e1.getCoordinates()[segIndex1]
+    const p11 = e1.getCoordinates()[segIndex1 + 1]
+    this._li.computeIntersection(p00, p01, p10, p11)
+    if (this._li.hasIntersection()) {
+      this._hasIntersection = true
+      const isProper = this._li.isProper()
+      if (isProper) this._hasProperIntersection = true
+      if (!isProper) this._hasNonProperIntersection = true
+      let saveLocation = true
+      if (this._findProper && !isProper) saveLocation = false
+      if (this._intPt === null || saveLocation) {
+        this._intPt = this._li.getIntersection(0)
+        this._intSegments = new Array(4).fill(null)
+        this._intSegments[0] = p00
+        this._intSegments[1] = p01
+        this._intSegments[2] = p10
+        this._intSegments[3] = p11
+      }
+    }
+  }
+  hasIntersection () {
+    return this._hasIntersection
+  }
+  isDone () {
+    if (this._findAllTypes) {
+      return this._hasProperIntersection && this._hasNonProperIntersection
+    }
+    if (this._findProper) {
+      return this._hasProperIntersection
+    }
+    return this._hasIntersection
+  }
+  hasNonProperIntersection () {
+    return this._hasNonProperIntersection
+  }
+  setFindProper (findProper) {
+    this._findProper = findProper
+  }
+  interfaces_ () {
+    return [SegmentIntersector]
+  }
+  getClass () {
+    return SegmentIntersectionDetector
+  }
+}

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

@@ -0,0 +1,10 @@
+export default class SegmentIntersector {
+  processIntersections (e0, segIndex0, e1, segIndex1) {}
+  isDone () {}
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return SegmentIntersector
+  }
+}

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

@@ -0,0 +1,50 @@
+import Coordinate from '../geom/Coordinate'
+import SegmentPointComparator from './SegmentPointComparator'
+import Comparable from '../../../../java/lang/Comparable'
+
+export default class SegmentNode {
+  constructor () {
+    this._segString = null
+    this.coord = null
+    this.segmentIndex = null
+    this._segmentOctant = null
+    this._isInterior = null
+    const segString = arguments[0]
+    const coord = arguments[1]
+    const segmentIndex = arguments[2]
+    const segmentOctant = arguments[3]
+    this._segString = segString
+    this.coord = new Coordinate(coord)
+    this.segmentIndex = segmentIndex
+    this._segmentOctant = segmentOctant
+    this._isInterior = !coord.equals2D(segString.getCoordinate(segmentIndex))
+  }
+  getCoordinate () {
+    return this.coord
+  }
+  print (out) {
+    out.print(this.coord)
+    out.print(' seg # = ' + this.segmentIndex)
+  }
+  compareTo (obj) {
+    const other = obj
+    if (this.segmentIndex < other.segmentIndex) return -1
+    if (this.segmentIndex > other.segmentIndex) return 1
+    if (this.coord.equals2D(other.coord)) return 0
+    return SegmentPointComparator.compare(this._segmentOctant, this.coord, other.coord)
+  }
+  isEndPoint (maxSegmentIndex) {
+    if (this.segmentIndex === 0 && !this._isInterior) return true
+    if (this.segmentIndex === maxSegmentIndex) return true
+    return false
+  }
+  isInterior () {
+    return this._isInterior
+  }
+  interfaces_ () {
+    return [Comparable]
+  }
+  getClass () {
+    return SegmentNode
+  }
+}

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

@@ -0,0 +1,210 @@
+import CoordinateList from '../geom/CoordinateList'
+import SegmentNode from './SegmentNode'
+// import Iterator from '../../../../java/util/Iterator'
+import Coordinate from '../geom/Coordinate'
+import NodedSegmentString from './NodedSegmentString'
+import Integer from '../../../../java/lang/Integer'
+import ArrayList from '../../../../java/util/ArrayList'
+import RuntimeException from '../../../../java/lang/RuntimeException'
+import Assert from '../util/Assert'
+import TreeMap from '../../../../java/util/TreeMap'
+
+export default class SegmentNodeList {
+  constructor () {
+    this._nodeMap = new TreeMap()
+    this._edge = null
+    let edge = arguments[0]
+    this._edge = edge
+  }
+  getSplitCoordinates () {
+    const coordList = new CoordinateList()
+    this.addEndpoints()
+    const it = this.iterator()
+    let eiPrev = it.next()
+    while (it.hasNext()) {
+      const ei = it.next()
+      this.addEdgeCoordinates(eiPrev, ei, coordList)
+      eiPrev = ei
+    }
+    return coordList.toCoordinateArray()
+  }
+  addCollapsedNodes () {
+    const collapsedVertexIndexes = new ArrayList()
+    this.findCollapsesFromInsertedNodes(collapsedVertexIndexes)
+    this.findCollapsesFromExistingVertices(collapsedVertexIndexes)
+    for (const it = collapsedVertexIndexes.iterator(); it.hasNext();) {
+      const vertexIndex = it.next().intValue()
+      this.add(this._edge.getCoordinate(vertexIndex), vertexIndex)
+    }
+  }
+  print (out) {
+    out.println('Intersections:')
+    for (const it = this.iterator(); it.hasNext();) {
+      const ei = it.next()
+      ei.print(out)
+    }
+  }
+  findCollapsesFromExistingVertices (collapsedVertexIndexes) {
+    for (let i = 0; i < this._edge.size() - 2; i++) {
+      const p0 = this._edge.getCoordinate(i)
+      // const p1 = this._edge.getCoordinate(i + 1)
+      const p2 = this._edge.getCoordinate(i + 2)
+      if (p0.equals2D(p2)) {
+        collapsedVertexIndexes.add(new Integer(i + 1))
+      }
+    }
+  }
+  addEdgeCoordinates (ei0, ei1, coordList) {
+    // let npts = ei1.segmentIndex - ei0.segmentIndex + 2
+    const lastSegStartPt = this._edge.getCoordinate(ei1.segmentIndex)
+    const useIntPt1 = ei1.isInterior() || !ei1.coord.equals2D(lastSegStartPt)
+    // if (!useIntPt1) {
+    //   npts--
+    // }
+    // const ipt = 0
+    coordList.add(new Coordinate(ei0.coord), false)
+    for (let i = ei0.segmentIndex + 1; i <= ei1.segmentIndex; i++) {
+      coordList.add(this._edge.getCoordinate(i))
+    }
+    if (useIntPt1) {
+      coordList.add(new Coordinate(ei1.coord))
+    }
+  }
+  iterator () {
+    return this._nodeMap.values().iterator()
+  }
+  addSplitEdges (edgeList) {
+    this.addEndpoints()
+    this.addCollapsedNodes()
+    const it = this.iterator()
+    let eiPrev = it.next()
+    while (it.hasNext()) {
+      const ei = it.next()
+      const newEdge = this.createSplitEdge(eiPrev, ei)
+      edgeList.add(newEdge)
+      eiPrev = ei
+    }
+  }
+  findCollapseIndex (ei0, ei1, collapsedVertexIndex) {
+    if (!ei0.coord.equals2D(ei1.coord)) return false
+    let numVerticesBetween = ei1.segmentIndex - ei0.segmentIndex
+    if (!ei1.isInterior()) {
+      numVerticesBetween--
+    }
+    if (numVerticesBetween === 1) {
+      collapsedVertexIndex[0] = ei0.segmentIndex + 1
+      return true
+    }
+    return false
+  }
+  findCollapsesFromInsertedNodes (collapsedVertexIndexes) {
+    const collapsedVertexIndex = new Array(1).fill(null)
+    const it = this.iterator()
+    let eiPrev = it.next()
+    while (it.hasNext()) {
+      const ei = it.next()
+      const isCollapsed = this.findCollapseIndex(eiPrev, ei, collapsedVertexIndex)
+      if (isCollapsed) collapsedVertexIndexes.add(new Integer(collapsedVertexIndex[0]))
+      eiPrev = ei
+    }
+  }
+  getEdge () {
+    return this._edge
+  }
+  addEndpoints () {
+    const maxSegIndex = this._edge.size() - 1
+    this.add(this._edge.getCoordinate(0), 0)
+    this.add(this._edge.getCoordinate(maxSegIndex), maxSegIndex)
+  }
+  createSplitEdge (ei0, ei1) {
+    let npts = ei1.segmentIndex - ei0.segmentIndex + 2
+    const lastSegStartPt = this._edge.getCoordinate(ei1.segmentIndex)
+    const useIntPt1 = ei1.isInterior() || !ei1.coord.equals2D(lastSegStartPt)
+    if (!useIntPt1) {
+      npts--
+    }
+    const pts = new Array(npts).fill(null)
+    let ipt = 0
+    pts[ipt++] = new Coordinate(ei0.coord)
+    for (let i = ei0.segmentIndex + 1; i <= ei1.segmentIndex; i++) {
+      pts[ipt++] = this._edge.getCoordinate(i)
+    }
+    if (useIntPt1) pts[ipt] = new Coordinate(ei1.coord)
+    return new NodedSegmentString(pts, this._edge.getData())
+  }
+  add (intPt, segmentIndex) {
+    const eiNew = new SegmentNode(this._edge, intPt, segmentIndex, this._edge.getSegmentOctant(segmentIndex))
+    const ei = this._nodeMap.get(eiNew)
+    if (ei !== null) {
+      Assert.isTrue(ei.coord.equals2D(intPt), 'Found equal nodes with different coordinates')
+      return ei
+    }
+    this._nodeMap.put(eiNew, eiNew)
+    return eiNew
+  }
+  checkSplitEdgesCorrectness (splitEdges) {
+    const edgePts = this._edge.getCoordinates()
+    const split0 = splitEdges.get(0)
+    const pt0 = split0.getCoordinate(0)
+    if (!pt0.equals2D(edgePts[0])) throw new RuntimeException('bad split edge start point at ' + pt0)
+    const splitn = splitEdges.get(splitEdges.size() - 1)
+    const splitnPts = splitn.getCoordinates()
+    const ptn = splitnPts[splitnPts.length - 1]
+    if (!ptn.equals2D(edgePts[edgePts.length - 1])) throw new RuntimeException('bad split edge end point at ' + ptn)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return SegmentNodeList
+  }
+}
+
+// class NodeVertexIterator {
+//   constructor () {
+//     this._nodeList = null
+//     this._edge = null
+//     this._nodeIt = null
+//     this._currNode = null
+//     this._nextNode = null
+//     this._currSegIndex = 0
+//     let nodeList = arguments[0]
+//     this._nodeList = nodeList
+//     this._edge = nodeList.getEdge()
+//     this._nodeIt = nodeList.iterator()
+//     this.readNextNode()
+//   }
+//   next () {
+//     if (this._currNode === null) {
+//       this._currNode = this._nextNode
+//       this._currSegIndex = this._currNode.segmentIndex
+//       this.readNextNode()
+//       return this._currNode
+//     }
+//     if (this._nextNode === null) return null
+//     if (this._nextNode.segmentIndex === this._currNode.segmentIndex) {
+//       this._currNode = this._nextNode
+//       this._currSegIndex = this._currNode.segmentIndex
+//       this.readNextNode()
+//       return this._currNode
+//     }
+//     if (this._nextNode.segmentIndex > this._currNode.segmentIndex) {}
+//     return null
+//   }
+//   remove () {
+//     // throw new UnsupportedOperationException(this.getClass().getName())
+//   }
+//   hasNext () {
+//     if (this._nextNode === null) return false
+//     return true
+//   }
+//   readNextNode () {
+//     if (this._nodeIt.hasNext()) this._nextNode = this._nodeIt.next(); else this._nextNode = null
+//   }
+//   interfaces_ () {
+//     return [Iterator]
+//   }
+//   getClass () {
+//     return NodeVertexIterator
+//   }
+// }

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

@@ -0,0 +1,48 @@
+import Assert from '../util/Assert'
+
+export default class SegmentPointComparator {
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return SegmentPointComparator
+  }
+  static relativeSign (x0, x1) {
+    if (x0 < x1) return -1
+    if (x0 > x1) return 1
+    return 0
+  }
+  static compare (octant, p0, p1) {
+    if (p0.equals2D(p1)) return 0
+    var xSign = SegmentPointComparator.relativeSign(p0.x, p1.x)
+    var ySign = SegmentPointComparator.relativeSign(p0.y, p1.y)
+    switch (octant) {
+      case 0:
+        return SegmentPointComparator.compareValue(xSign, ySign)
+      case 1:
+        return SegmentPointComparator.compareValue(ySign, xSign)
+      case 2:
+        return SegmentPointComparator.compareValue(ySign, -xSign)
+      case 3:
+        return SegmentPointComparator.compareValue(-xSign, ySign)
+      case 4:
+        return SegmentPointComparator.compareValue(-xSign, -ySign)
+      case 5:
+        return SegmentPointComparator.compareValue(-ySign, -xSign)
+      case 6:
+        return SegmentPointComparator.compareValue(-ySign, xSign)
+      case 7:
+        return SegmentPointComparator.compareValue(xSign, -ySign)
+      default:
+    }
+    Assert.shouldNeverReachHere('invalid octant value')
+    return 0
+  }
+  static compareValue (compareSign0, compareSign1) {
+    if (compareSign0 < 0) return -1
+    if (compareSign0 > 0) return 1
+    if (compareSign1 < 0) return -1
+    if (compareSign1 > 0) return 1
+    return 0
+  }
+}