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

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

@@ -0,0 +1,247 @@
+import CoordinateList from './CoordinateList'
+import Coordinate from './Coordinate'
+import MathUtil from '../math/MathUtil'
+import System from '../../../../java/lang/System'
+import Comparator from '../../../../java/util/Comparator'
+import Envelope from './Envelope'
+
+export default class CoordinateArrays {
+  static get ForwardComparator () { return ForwardComparator }
+  static get BidirectionalComparator () { return BidirectionalComparator }
+  static get coordArrayType () { return new Array(0).fill(null) }
+
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return CoordinateArrays
+  }
+  static isRing (pts) {
+    if (pts.length < 4) return false
+    if (!pts[0].equals2D(pts[pts.length - 1])) return false
+    return true
+  }
+  static ptNotInList (testPts, pts) {
+    for (var i = 0; i < testPts.length; i++) {
+      var testPt = testPts[i]
+      if (CoordinateArrays.indexOf(testPt, pts) < 0) return testPt
+    }
+    return null
+  }
+  static scroll (coordinates, firstCoordinate) {
+    var i = CoordinateArrays.indexOf(firstCoordinate, coordinates)
+    if (i < 0) return null
+    var newCoordinates = new Array(coordinates.length).fill(null)
+    System.arraycopy(coordinates, i, newCoordinates, 0, coordinates.length - i)
+    System.arraycopy(coordinates, 0, newCoordinates, coordinates.length - i, i)
+    System.arraycopy(newCoordinates, 0, coordinates, 0, coordinates.length)
+  }
+  static equals () {
+    if (arguments.length === 2) {
+      const coord1 = arguments[0]
+      const coord2 = arguments[1]
+      if (coord1 === coord2) return true
+      if (coord1 === null || coord2 === null) return false
+      if (coord1.length !== coord2.length) return false
+      for (var i = 0; i < coord1.length; i++) {
+        if (!coord1[i].equals(coord2[i])) return false
+      }
+      return true
+    } else if (arguments.length === 3) {
+      const coord1 = arguments[0]
+      const coord2 = arguments[1]
+      const coordinateComparator = arguments[2]
+      if (coord1 === coord2) return true
+      if (coord1 === null || coord2 === null) return false
+      if (coord1.length !== coord2.length) return false
+      for (let i = 0; i < coord1.length; i++) {
+        if (coordinateComparator.compare(coord1[i], coord2[i]) !== 0) return false
+      }
+      return true
+    }
+  }
+  static intersection (coordinates, env) {
+    var coordList = new CoordinateList()
+    for (var i = 0; i < coordinates.length; i++) {
+      if (env.intersects(coordinates[i])) coordList.add(coordinates[i], true)
+    }
+    return coordList.toCoordinateArray()
+  }
+  static hasRepeatedPoints (coord) {
+    for (var i = 1; i < coord.length; i++) {
+      if (coord[i - 1].equals(coord[i])) {
+        return true
+      }
+    }
+    return false
+  }
+  static removeRepeatedPoints (coord) {
+    if (!CoordinateArrays.hasRepeatedPoints(coord)) return coord
+    var coordList = new CoordinateList(coord, false)
+    return coordList.toCoordinateArray()
+  }
+  static reverse (coord) {
+    var last = coord.length - 1
+    var mid = Math.trunc(last / 2)
+    for (var i = 0; i <= mid; i++) {
+      var tmp = coord[i]
+      coord[i] = coord[last - i]
+      coord[last - i] = tmp
+    }
+  }
+  static removeNull (coord) {
+    let nonNull = 0
+    for (let i = 0; i < coord.length; i++) {
+      if (coord[i] !== null) nonNull++
+    }
+    const newCoord = new Array(nonNull).fill(null)
+    if (nonNull === 0) return newCoord
+    let j = 0
+    for (let i = 0; i < coord.length; i++) {
+      if (coord[i] !== null) newCoord[j++] = coord[i]
+    }
+    return newCoord
+  }
+  static copyDeep () {
+    if (arguments.length === 1) {
+      const coordinates = arguments[0]
+      const copy = new Array(coordinates.length).fill(null)
+      for (let i = 0; i < coordinates.length; i++) {
+        copy[i] = new Coordinate(coordinates[i])
+      }
+      return copy
+    } else if (arguments.length === 5) {
+      const src = arguments[0]
+      const srcStart = arguments[1]
+      const dest = arguments[2]
+      const destStart = arguments[3]
+      const length = arguments[4]
+      for (let i = 0; i < length; i++) {
+        dest[destStart + i] = new Coordinate(src[srcStart + i])
+      }
+    }
+  }
+  static isEqualReversed (pts1, pts2) {
+    for (let i = 0; i < pts1.length; i++) {
+      const p1 = pts1[i]
+      const p2 = pts2[pts1.length - i - 1]
+      if (p1.compareTo(p2) !== 0) return false
+    }
+    return true
+  }
+  static envelope (coordinates) {
+    var env = new Envelope()
+    for (let i = 0; i < coordinates.length; i++) {
+      env.expandToInclude(coordinates[i])
+    }
+    return env
+  }
+  static toCoordinateArray (coordList) {
+    return coordList.toArray(CoordinateArrays.coordArrayType)
+  }
+  static atLeastNCoordinatesOrNothing (n, c) {
+    return c.length >= n ? c : []
+  }
+  static indexOf (coordinate, coordinates) {
+    for (var i = 0; i < coordinates.length; i++) {
+      if (coordinate.equals(coordinates[i])) {
+        return i
+      }
+    }
+    return -1
+  }
+  static increasingDirection (pts) {
+    for (var i = 0; i < Math.trunc(pts.length / 2); i++) {
+      var j = pts.length - 1 - i
+      var comp = pts[i].compareTo(pts[j])
+      if (comp !== 0) return comp
+    }
+    return 1
+  }
+  static compare (pts1, pts2) {
+    var i = 0
+    while (i < pts1.length && i < pts2.length) {
+      var compare = pts1[i].compareTo(pts2[i])
+      if (compare !== 0) return compare
+      i++
+    }
+    if (i < pts2.length) return -1
+    if (i < pts1.length) return 1
+    return 0
+  }
+  static minCoordinate (coordinates) {
+    var minCoord = null
+    for (var i = 0; i < coordinates.length; i++) {
+      if (minCoord === null || minCoord.compareTo(coordinates[i]) > 0) {
+        minCoord = coordinates[i]
+      }
+    }
+    return minCoord
+  }
+  static extract (pts, start, end) {
+    start = MathUtil.clamp(start, 0, pts.length)
+    end = MathUtil.clamp(end, -1, pts.length)
+    var npts = end - start + 1
+    if (end < 0) npts = 0
+    if (start >= pts.length) npts = 0
+    if (end < start) npts = 0
+    var extractPts = new Array(npts).fill(null)
+    if (npts === 0) return extractPts
+    var iPts = 0
+    for (var i = start; i <= end; i++) {
+      extractPts[iPts++] = pts[i]
+    }
+    return extractPts
+  }
+}
+class ForwardComparator {
+  compare (o1, o2) {
+    var pts1 = o1
+    var pts2 = o2
+    return CoordinateArrays.compare(pts1, pts2)
+  }
+  interfaces_ () {
+    return [Comparator]
+  }
+  getClass () {
+    return ForwardComparator
+  }
+}
+
+class BidirectionalComparator {
+  compare (o1, o2) {
+    var pts1 = o1
+    var pts2 = o2
+    if (pts1.length < pts2.length) return -1
+    if (pts1.length > pts2.length) return 1
+    if (pts1.length === 0) return 0
+    var forwardComp = CoordinateArrays.compare(pts1, pts2)
+    var isEqualRev = CoordinateArrays.isEqualReversed(pts1, pts2)
+    if (isEqualRev) return 0
+    return forwardComp
+  }
+  OLDcompare (o1, o2) {
+    var pts1 = o1
+    var pts2 = o2
+    if (pts1.length < pts2.length) return -1
+    if (pts1.length > pts2.length) return 1
+    if (pts1.length === 0) return 0
+    var dir1 = CoordinateArrays.increasingDirection(pts1)
+    var dir2 = CoordinateArrays.increasingDirection(pts2)
+    var i1 = dir1 > 0 ? 0 : pts1.length - 1
+    var i2 = dir2 > 0 ? 0 : pts1.length - 1
+    for (var i = 0; i < pts1.length; i++) {
+      var comparePt = pts1[i1].compareTo(pts2[i2])
+      if (comparePt !== 0) return comparePt
+      i1 += dir1
+      i2 += dir2
+    }
+    return 0
+  }
+  interfaces_ () {
+    return [Comparator]
+  }
+  getClass () {
+    return BidirectionalComparator
+  }
+}

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

@@ -0,0 +1,9 @@
+export default class CoordinateFilter {
+  filter (coord) {}
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return CoordinateFilter
+  }
+}

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

@@ -0,0 +1,127 @@
+import Coordinate from './Coordinate'
+import ArrayList from '../../../../java/util/ArrayList'
+
+export default class CoordinateList extends ArrayList {
+  constructor () {
+    super()
+    if (arguments.length === 0) {
+    } else if (arguments.length === 1) {
+      let coord = arguments[0]
+      this.ensureCapacity(coord.length)
+      this.add(coord, true)
+    } else if (arguments.length === 2) {
+      const coord = arguments[0]
+      const allowRepeated = arguments[1]
+      this.ensureCapacity(coord.length)
+      this.add(coord, allowRepeated)
+    }
+  }
+  static get coordArrayType () { return new Array(0).fill(null) }
+  getCoordinate (i) {
+    return this.get(i)
+  }
+  addAll () {
+    if (arguments.length === 2) {
+      const coll = arguments[0]
+      const allowRepeated = arguments[1]
+      let isChanged = false
+      for (let i = coll.iterator(); i.hasNext();) {
+        this.add(i.next(), allowRepeated)
+        isChanged = true
+      }
+      return isChanged
+    } else return ArrayList.prototype.addAll.apply(this, arguments)
+  }
+  clone () {
+    var clone = ArrayList.prototype.clone.call(this)
+    for (var i = 0; i < this.size(); i++) {
+      clone.add(i, this.get(i).copy())
+    }
+    return clone
+  }
+  toCoordinateArray () {
+    return this.toArray(CoordinateList.coordArrayType)
+  }
+  add () {
+    if (arguments.length === 1) {
+      const coord = arguments[0]
+      ArrayList.prototype.add.call(this, coord)
+    } else if (arguments.length === 2) {
+      if (arguments[0] instanceof Array && typeof arguments[1] === 'boolean') {
+        const coord = arguments[0]
+        const allowRepeated = arguments[1]
+        this.add(coord, allowRepeated, true)
+        return true
+      } else if (arguments[0] instanceof Coordinate && typeof arguments[1] === 'boolean') {
+        const coord = arguments[0]
+        const allowRepeated = arguments[1]
+        if (!allowRepeated) {
+          if (this.size() >= 1) {
+            var last = this.get(this.size() - 1)
+            if (last.equals2D(coord)) return null
+          }
+        }
+        ArrayList.prototype.add.call(this, coord)
+      } else if (arguments[0] instanceof Object && typeof arguments[1] === 'boolean') {
+        const obj = arguments[0]
+        const allowRepeated = arguments[1]
+        this.add(obj, allowRepeated)
+        return true
+      }
+    } else if (arguments.length === 3) {
+      if (typeof arguments[2] === 'boolean' && (arguments[0] instanceof Array && typeof arguments[1] === 'boolean')) {
+        const coord = arguments[0]
+        const allowRepeated = arguments[1]
+        const direction = arguments[2]
+        if (direction) {
+          for (let i = 0; i < coord.length; i++) {
+            this.add(coord[i], allowRepeated)
+          }
+        } else {
+          for (let i = coord.length - 1; i >= 0; i--) {
+            this.add(coord[i], allowRepeated)
+          }
+        }
+        return true
+      } else if (typeof arguments[2] === 'boolean' && (Number.isInteger(arguments[0]) && arguments[1] instanceof Coordinate)) {
+        const i = arguments[0]
+        const coord = arguments[1]
+        const allowRepeated = arguments[2]
+        if (!allowRepeated) {
+          const size = this.size()
+          if (size > 0) {
+            if (i > 0) {
+              const prev = this.get(i - 1)
+              if (prev.equals2D(coord)) return null
+            }
+            if (i < size) {
+              const next = this.get(i)
+              if (next.equals2D(coord)) return null
+            }
+          }
+        }
+        ArrayList.prototype.add.call(this, i, coord)
+      }
+    } else if (arguments.length === 4) {
+      const coord = arguments[0]
+      const allowRepeated = arguments[1]
+      const start = arguments[2]
+      const end = arguments[3]
+      var inc = 1
+      if (start > end) inc = -1
+      for (var i = start; i !== end; i += inc) {
+        this.add(coord[i], allowRepeated)
+      }
+      return true
+    }
+  }
+  closeRing () {
+    if (this.size() > 0) this.add(new Coordinate(this.get(0)), false)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return CoordinateList
+  }
+}

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

@@ -0,0 +1,26 @@
+import Cloneable from '../../../../java/lang/Cloneable'
+
+export default class CoordinateSequence {
+  static get X () { return 0 }
+  static get Y () { return 1 }
+  static get Z () { return 2 }
+  static get M () { return 3 }
+  setOrdinate (index, ordinateIndex, value) {}
+  size () {}
+  getOrdinate (index, ordinateIndex) {}
+  getCoordinate () {}
+  getCoordinateCopy (i) {}
+  getDimension () {}
+  getX (index) {}
+  clone () {}
+  expandEnvelope (env) {}
+  copy () {}
+  getY (index) {}
+  toCoordinateArray () {}
+  interfaces_ () {
+    return [Cloneable]
+  }
+  getClass () {
+    return CoordinateSequence
+  }
+}

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

@@ -0,0 +1,67 @@
+import Double from '../../../../java/lang/Double'
+import Integer from '../../../../java/lang/Integer'
+import Comparator from '../../../../java/util/Comparator'
+
+export default class CoordinateSequenceComparator {
+  constructor () {
+    this._dimensionLimit = null
+    if (arguments.length === 0) {
+      this._dimensionLimit = Integer.MAX_VALUE
+    } else if (arguments.length === 1) {
+      this._dimensionLimit = arguments[0]
+    }
+  }
+  compare (o1, o2) {
+    var s1 = o1
+    var s2 = o2
+    var size1 = s1.size()
+    var size2 = s2.size()
+    var dim1 = s1.getDimension()
+    var dim2 = s2.getDimension()
+    var minDim = dim1
+    if (dim2 < minDim) minDim = dim2
+    var dimLimited = false
+    if (this._dimensionLimit <= minDim) {
+      minDim = this._dimensionLimit
+      dimLimited = true
+    }
+    if (!dimLimited) {
+      if (dim1 < dim2) return -1
+      if (dim1 > dim2) return 1
+    }
+    var i = 0
+    while (i < size1 && i < size2) {
+      var ptComp = this.compareCoordinate(s1, s2, i, minDim)
+      if (ptComp !== 0) return ptComp
+      i++
+    }
+    if (i < size1) return 1
+    if (i < size2) return -1
+    return 0
+  }
+  compareCoordinate (s1, s2, i, dimension) {
+    for (var d = 0; d < dimension; d++) {
+      var ord1 = s1.getOrdinate(i, d)
+      var ord2 = s2.getOrdinate(i, d)
+      var comp = CoordinateSequenceComparator.compare(ord1, ord2)
+      if (comp !== 0) return comp
+    }
+    return 0
+  }
+  interfaces_ () {
+    return [Comparator]
+  }
+  getClass () {
+    return CoordinateSequenceComparator
+  }
+  static compare (a, b) {
+    if (a < b) return -1
+    if (a > b) return 1
+    if (Double.isNaN(a)) {
+      if (Double.isNaN(b)) return 0
+      return -1
+    }
+    if (Double.isNaN(b)) return 1
+    return 0
+  }
+}

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

@@ -0,0 +1,23 @@
+// import hasInterface from '../../../../hasInterface'
+// import CoordinateSequence from './CoordinateSequence'
+
+export default class CoordinateSequenceFactory {
+  create () {
+    // if (arguments.length === 1) {
+    //   if (arguments[0] instanceof Array) {
+    //     let coordinates = arguments[0]
+    //   } else if (hasInterface(arguments[0], CoordinateSequence)) {
+    //     let coordSeq = arguments[0]
+    //   }
+    // } else if (arguments.length === 2) {
+    //   let size = arguments[0]
+    //   let dimension = arguments[1]
+    // }
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return CoordinateSequenceFactory
+  }
+}

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

@@ -0,0 +1,11 @@
+export default class CoordinateSequenceFilter {
+  filter (seq, i) {}
+  isDone () {}
+  isGeometryChanged () {}
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return CoordinateSequenceFilter
+  }
+}

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

@@ -0,0 +1,104 @@
+import StringBuffer from '../../../../java/lang/StringBuffer'
+import StringUtil from '../util/StringUtil'
+import Double from '../../../../java/lang/Double'
+import CoordinateSequence from './CoordinateSequence'
+
+export default class CoordinateSequences {
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return CoordinateSequences
+  }
+  static copyCoord (src, srcPos, dest, destPos) {
+    var minDim = Math.min(src.getDimension(), dest.getDimension())
+    for (var dim = 0; dim < minDim; dim++) {
+      dest.setOrdinate(destPos, dim, src.getOrdinate(srcPos, dim))
+    }
+  }
+  static isRing (seq) {
+    var n = seq.size()
+    if (n === 0) return true
+    if (n <= 3) return false
+    return seq.getOrdinate(0, CoordinateSequence.X) === seq.getOrdinate(n - 1, CoordinateSequence.X) && seq.getOrdinate(0, CoordinateSequence.Y) === seq.getOrdinate(n - 1, CoordinateSequence.Y)
+  }
+  static isEqual (cs1, cs2) {
+    var cs1Size = cs1.size()
+    var cs2Size = cs2.size()
+    if (cs1Size !== cs2Size) return false
+    var dim = Math.min(cs1.getDimension(), cs2.getDimension())
+    for (var i = 0; i < cs1Size; i++) {
+      for (var d = 0; d < dim; d++) {
+        var v1 = cs1.getOrdinate(i, d)
+        var v2 = cs2.getOrdinate(i, d)
+        if (cs1.getOrdinate(i, d) === cs2.getOrdinate(i, d)) continue
+        if (Double.isNaN(v1) && Double.isNaN(v2)) continue
+        return false
+      }
+    }
+    return true
+  }
+  static extend (fact, seq, size) {
+    var newseq = fact.create(size, seq.getDimension())
+    var n = seq.size()
+    CoordinateSequences.copy(seq, 0, newseq, 0, n)
+    if (n > 0) {
+      for (var i = n; i < size; i++) CoordinateSequences.copy(seq, n - 1, newseq, i, 1)
+    }
+    return newseq
+  }
+  static reverse (seq) {
+    var last = seq.size() - 1
+    var mid = Math.trunc(last / 2)
+    for (var i = 0; i <= mid; i++) {
+      CoordinateSequences.swap(seq, i, last - i)
+    }
+  }
+  static swap (seq, i, j) {
+    if (i === j) return null
+    for (var dim = 0; dim < seq.getDimension(); dim++) {
+      var tmp = seq.getOrdinate(i, dim)
+      seq.setOrdinate(i, dim, seq.getOrdinate(j, dim))
+      seq.setOrdinate(j, dim, tmp)
+    }
+  }
+  static copy (src, srcPos, dest, destPos, length) {
+    for (var i = 0; i < length; i++) {
+      CoordinateSequences.copyCoord(src, srcPos + i, dest, destPos + i)
+    }
+  }
+  static toString () {
+    if (arguments.length === 1) {
+      let cs = arguments[0]
+      var size = cs.size()
+      if (size === 0) return '()'
+      var dim = cs.getDimension()
+      var buf = new StringBuffer()
+      buf.append('(')
+      for (var i = 0; i < size; i++) {
+        if (i > 0) buf.append(' ')
+        for (var d = 0; d < dim; d++) {
+          if (d > 0) buf.append(',')
+          buf.append(StringUtil.toString(cs.getOrdinate(i, d)))
+        }
+      }
+      buf.append(')')
+      return buf.toString()
+    }
+  }
+  static ensureValidRing (fact, seq) {
+    var n = seq.size()
+    if (n === 0) return seq
+    if (n <= 3) return CoordinateSequences.createClosedRing(fact, seq, 4)
+    var isClosed = seq.getOrdinate(0, CoordinateSequence.X) === seq.getOrdinate(n - 1, CoordinateSequence.X) && seq.getOrdinate(0, CoordinateSequence.Y) === seq.getOrdinate(n - 1, CoordinateSequence.Y)
+    if (isClosed) return seq
+    return CoordinateSequences.createClosedRing(fact, seq, n + 1)
+  }
+  static createClosedRing (fact, seq, size) {
+    var newseq = fact.create(size, seq.getDimension())
+    var n = seq.size()
+    CoordinateSequences.copy(seq, 0, newseq, 0, n)
+    for (var i = n; i < size; i++) CoordinateSequences.copy(seq, 0, newseq, i, 1)
+    return newseq
+  }
+}

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

@@ -0,0 +1,60 @@
+import IllegalArgumentException from '../../../../java/lang/IllegalArgumentException'
+import Character from '../../../../java/lang/Character'
+
+export default class Dimension {
+  static get P () { return 0 }
+  static get L () { return 1 }
+  static get A () { return 2 }
+  static get FALSE () { return -1 }
+  static get TRUE () { return -2 }
+  static get DONTCARE () { return -3 }
+  static get SYM_FALSE () { return 'F' }
+  static get SYM_TRUE () { return 'T' }
+  static get SYM_DONTCARE () { return '*' }
+  static get SYM_P () { return '0' }
+  static get SYM_L () { return '1' }
+  static get SYM_A () { return '2' }
+
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return Dimension
+  }
+  static toDimensionSymbol (dimensionValue) {
+    switch (dimensionValue) {
+      case Dimension.FALSE:
+        return Dimension.SYM_FALSE
+      case Dimension.TRUE:
+        return Dimension.SYM_TRUE
+      case Dimension.DONTCARE:
+        return Dimension.SYM_DONTCARE
+      case Dimension.P:
+        return Dimension.SYM_P
+      case Dimension.L:
+        return Dimension.SYM_L
+      case Dimension.A:
+        return Dimension.SYM_A
+      default:
+    }
+    throw new IllegalArgumentException('Unknown dimension value: ' + dimensionValue)
+  }
+  static toDimensionValue (dimensionSymbol) {
+    switch (Character.toUpperCase(dimensionSymbol)) {
+      case Dimension.SYM_FALSE:
+        return Dimension.FALSE
+      case Dimension.SYM_TRUE:
+        return Dimension.TRUE
+      case Dimension.SYM_DONTCARE:
+        return Dimension.DONTCARE
+      case Dimension.SYM_P:
+        return Dimension.P
+      case Dimension.SYM_L:
+        return Dimension.L
+      case Dimension.SYM_A:
+        return Dimension.A
+      default:
+    }
+    throw new IllegalArgumentException('Unknown dimension symbol: ' + dimensionSymbol)
+  }
+}