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

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

@@ -0,0 +1,67 @@
+import Double from '../../../../java/lang/Double'
+
+export default class CommonBits {
+  constructor () {
+    this._isFirst = true
+    this._commonMantissaBitsCount = 53
+    this._commonBits = 0
+    this._commonSignExp = null
+  }
+  getCommon () {
+    return Double.longBitsToDouble(this._commonBits)
+  }
+  add (num) {
+    const numBits = Double.doubleToLongBits(num)
+    if (this._isFirst) {
+      this._commonBits = numBits
+      this._commonSignExp = CommonBits.signExpBits(this._commonBits)
+      this._isFirst = false
+      return null
+    }
+    const numSignExp = CommonBits.signExpBits(numBits)
+    if (numSignExp !== this._commonSignExp) {
+      this._commonBits = 0
+      return null
+    }
+    this._commonMantissaBitsCount = CommonBits.numCommonMostSigMantissaBits(this._commonBits, numBits)
+    this._commonBits = CommonBits.zeroLowerBits(this._commonBits, 64 - (12 + this._commonMantissaBitsCount))
+  }
+  toString () {
+    if (arguments.length === 1) {
+      let bits = arguments[0]
+      const x = Double.longBitsToDouble(bits)
+      const numStr = Double.toBinaryString(bits)
+      const padStr = '0000000000000000000000000000000000000000000000000000000000000000' + numStr
+      const bitStr = padStr.substring(padStr.length - 64)
+      const str = bitStr.substring(0, 1) + '  ' + bitStr.substring(1, 12) + '(exp) ' + bitStr.substring(12) + ' [ ' + x + ' ]'
+      return str
+    }
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return CommonBits
+  }
+  static getBit (bits, i) {
+    const mask = 1 << i
+    return (bits & mask) !== 0 ? 1 : 0
+  }
+  static signExpBits (num) {
+    return num >> 52
+  }
+  static zeroLowerBits (bits, nBits) {
+    const invMask = (1 << nBits) - 1
+    const mask = ~invMask
+    const zeroed = bits & mask
+    return zeroed
+  }
+  static numCommonMostSigMantissaBits (num1, num2) {
+    let count = 0
+    for (let i = 52; i >= 0; i--) {
+      if (CommonBits.getBit(num1, i) !== CommonBits.getBit(num2, i)) return count
+      count++
+    }
+    return 52
+  }
+}

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

@@ -0,0 +1,63 @@
+import CommonBitsRemover from './CommonBitsRemover'
+
+export default class CommonBitsOp {
+  constructor () {
+    this._returnToOriginalPrecision = true
+    this._cbr = null
+    if (arguments.length === 0) {
+      CommonBitsOp.call(this, true)
+    } else if (arguments.length === 1) {
+      const returnToOriginalPrecision = arguments[0]
+      this._returnToOriginalPrecision = returnToOriginalPrecision
+    }
+  }
+  computeResultPrecision (result) {
+    if (this._returnToOriginalPrecision) this._cbr.addCommonBits(result)
+    return result
+  }
+  union (geom0, geom1) {
+    const geom = this.removeCommonBits(geom0, geom1)
+    return this.computeResultPrecision(geom[0].union(geom[1]))
+  }
+  intersection (geom0, geom1) {
+    const geom = this.removeCommonBits(geom0, geom1)
+    return this.computeResultPrecision(geom[0].intersection(geom[1]))
+  }
+  removeCommonBits () {
+    if (arguments.length === 1) {
+      const geom0 = arguments[0]
+      this._cbr = new CommonBitsRemover()
+      this._cbr.add(geom0)
+      const geom = this._cbr.removeCommonBits(geom0.copy())
+      return geom
+    } else if (arguments.length === 2) {
+      const geom0 = arguments[0]
+      const geom1 = arguments[1]
+      this._cbr = new CommonBitsRemover()
+      this._cbr.add(geom0)
+      this._cbr.add(geom1)
+      const geom = new Array(2).fill(null)
+      geom[0] = this._cbr.removeCommonBits(geom0.copy())
+      geom[1] = this._cbr.removeCommonBits(geom1.copy())
+      return geom
+    }
+  }
+  buffer (geom0, distance) {
+    const geom = this.removeCommonBits(geom0)
+    return this.computeResultPrecision(geom.buffer(distance))
+  }
+  symDifference (geom0, geom1) {
+    const geom = this.removeCommonBits(geom0, geom1)
+    return this.computeResultPrecision(geom[0].symDifference(geom[1]))
+  }
+  difference (geom0, geom1) {
+    const geom = this.removeCommonBits(geom0, geom1)
+    return this.computeResultPrecision(geom[0].difference(geom[1]))
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return CommonBitsOp
+  }
+}

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

@@ -0,0 +1,87 @@
+import CommonBits from './CommonBits'
+import CoordinateFilter from '../geom/CoordinateFilter'
+import Coordinate from '../geom/Coordinate'
+import CoordinateSequenceFilter from '../geom/CoordinateSequenceFilter'
+
+export default class CommonBitsRemover {
+  constructor () {
+    this._commonCoord = null
+    this._ccFilter = new CommonCoordinateFilter()
+  }
+  addCommonBits (geom) {
+    const trans = new Translater(this._commonCoord)
+    geom.apply(trans)
+    geom.geometryChanged()
+  }
+  removeCommonBits (geom) {
+    if (this._commonCoord.x === 0.0 && this._commonCoord.y === 0.0) return geom
+    const invCoord = new Coordinate(this._commonCoord)
+    invCoord.x = -invCoord.x
+    invCoord.y = -invCoord.y
+    const trans = new Translater(invCoord)
+    geom.apply(trans)
+    geom.geometryChanged()
+    return geom
+  }
+  getCommonCoordinate () {
+    return this._commonCoord
+  }
+  add (geom) {
+    geom.apply(this._ccFilter)
+    this._commonCoord = this._ccFilter.getCommonCoordinate()
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return CommonBitsRemover
+  }
+  static get CommonCoordinateFilter () { return CommonCoordinateFilter }
+  static get Translater () { return Translater }
+}
+
+class CommonCoordinateFilter {
+  constructor () {
+    this._commonBitsX = new CommonBits()
+    this._commonBitsY = new CommonBits()
+  }
+  filter (coord) {
+    this._commonBitsX.add(coord.x)
+    this._commonBitsY.add(coord.y)
+  }
+  getCommonCoordinate () {
+    return new Coordinate(this._commonBitsX.getCommon(), this._commonBitsY.getCommon())
+  }
+  interfaces_ () {
+    return [CoordinateFilter]
+  }
+  getClass () {
+    return CommonCoordinateFilter
+  }
+}
+
+class Translater {
+  constructor () {
+    this.trans = null
+    let trans = arguments[0]
+    this.trans = trans
+  }
+  filter (seq, i) {
+    const xp = seq.getOrdinate(i, 0) + this.trans.x
+    const yp = seq.getOrdinate(i, 1) + this.trans.y
+    seq.setOrdinate(i, 0, xp)
+    seq.setOrdinate(i, 1, yp)
+  }
+  isDone () {
+    return false
+  }
+  isGeometryChanged () {
+    return true
+  }
+  interfaces_ () {
+    return [CoordinateSequenceFilter]
+  }
+  getClass () {
+    return Translater
+  }
+}

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

@@ -0,0 +1,25 @@
+import CoordinateSequenceFilter from '../geom/CoordinateSequenceFilter'
+
+export default class CoordinatePrecisionReducerFilter {
+  constructor () {
+    this._precModel = null
+    let precModel = arguments[0]
+    this._precModel = precModel
+  }
+  filter (seq, i) {
+    seq.setOrdinate(i, 0, this._precModel.makePrecise(seq.getOrdinate(i, 0)))
+    seq.setOrdinate(i, 1, this._precModel.makePrecise(seq.getOrdinate(i, 1)))
+  }
+  isDone () {
+    return false
+  }
+  isGeometryChanged () {
+    return true
+  }
+  interfaces_ () {
+    return [CoordinateSequenceFilter]
+  }
+  getClass () {
+    return CoordinatePrecisionReducerFilter
+  }
+}

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

@@ -0,0 +1,116 @@
+import CommonBitsOp from './CommonBitsOp'
+import RuntimeException from '../../../../java/lang/RuntimeException'
+
+export default class EnhancedPrecisionOp {
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return EnhancedPrecisionOp
+  }
+  static union (geom0, geom1) {
+    let originalEx = null
+    try {
+      const result = geom0.union(geom1)
+      return result
+    } catch (ex) {
+      if (ex instanceof RuntimeException) {
+        originalEx = ex
+      } else throw ex
+    } finally {}
+    try {
+      const cbo = new CommonBitsOp(true)
+      const resultEP = cbo.union(geom0, geom1)
+      if (!resultEP.isValid()) throw originalEx
+      return resultEP
+    } catch (ex2) {
+      if (ex2 instanceof RuntimeException) {
+        throw originalEx
+      } else throw ex2
+    } finally {}
+  }
+  static intersection (geom0, geom1) {
+    let originalEx = null
+    try {
+      const result = geom0.intersection(geom1)
+      return result
+    } catch (ex) {
+      if (ex instanceof RuntimeException) {
+        originalEx = ex
+      } else throw ex
+    } finally {}
+    try {
+      const cbo = new CommonBitsOp(true)
+      const resultEP = cbo.intersection(geom0, geom1)
+      if (!resultEP.isValid()) throw originalEx
+      return resultEP
+    } catch (ex2) {
+      if (ex2 instanceof RuntimeException) {
+        throw originalEx
+      } else throw ex2
+    } finally {}
+  }
+  static buffer (geom, distance) {
+    let originalEx = null
+    try {
+      const result = geom.buffer(distance)
+      return result
+    } catch (ex) {
+      if (ex instanceof RuntimeException) {
+        originalEx = ex
+      } else throw ex
+    } finally {}
+    try {
+      const cbo = new CommonBitsOp(true)
+      const resultEP = cbo.buffer(geom, distance)
+      if (!resultEP.isValid()) throw originalEx
+      return resultEP
+    } catch (ex2) {
+      if (ex2 instanceof RuntimeException) {
+        throw originalEx
+      } else throw ex2
+    } finally {}
+  }
+  static symDifference (geom0, geom1) {
+    let originalEx = null
+    try {
+      const result = geom0.symDifference(geom1)
+      return result
+    } catch (ex) {
+      if (ex instanceof RuntimeException) {
+        originalEx = ex
+      } else throw ex
+    } finally {}
+    try {
+      const cbo = new CommonBitsOp(true)
+      const resultEP = cbo.symDifference(geom0, geom1)
+      if (!resultEP.isValid()) throw originalEx
+      return resultEP
+    } catch (ex2) {
+      if (ex2 instanceof RuntimeException) {
+        throw originalEx
+      } else throw ex2
+    } finally {}
+  }
+  static difference (geom0, geom1) {
+    let originalEx = null
+    try {
+      const result = geom0.difference(geom1)
+      return result
+    } catch (ex) {
+      if (ex instanceof RuntimeException) {
+        originalEx = ex
+      } else throw ex
+    } finally {}
+    try {
+      const cbo = new CommonBitsOp(true)
+      const resultEP = cbo.difference(geom0, geom1)
+      if (!resultEP.isValid()) throw originalEx
+      return resultEP
+    } catch (ex2) {
+      if (ex2 instanceof RuntimeException) {
+        throw originalEx
+      } else throw ex2
+    } finally {}
+  }
+}

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

@@ -0,0 +1,82 @@
+import hasInterface from '../../../../hasInterface'
+import GeometryFactory from '../geom/GeometryFactory'
+import GeometryEditor from '../geom/util/GeometryEditor'
+import Polygonal from '../geom/Polygonal'
+import PrecisionReducerCoordinateOperation from './PrecisionReducerCoordinateOperation'
+
+export default class GeometryPrecisionReducer {
+  constructor (pm) {
+    this._removeCollapsed = true
+    this._changePrecisionModel = false
+    this._isPointwise = false
+    this._targetPM = pm || null
+  }
+  fixPolygonalTopology (geom) {
+    let geomToBuffer = geom
+    if (!this._changePrecisionModel) {
+      geomToBuffer = this.changePM(geom, this._targetPM)
+    }
+    const bufGeom = geomToBuffer.buffer(0)
+    let finalGeom = bufGeom
+    if (!this._changePrecisionModel) {
+      finalGeom = this.changePM(bufGeom, geom.getPrecisionModel())
+    }
+    return finalGeom
+  }
+  reducePointwise (geom) {
+    let geomEdit = null
+    if (this._changePrecisionModel) {
+      const newFactory = this.createFactory(geom.getFactory(), this._targetPM)
+      geomEdit = new GeometryEditor(newFactory)
+    } else geomEdit = new GeometryEditor()
+    let finalRemoveCollapsed = this._removeCollapsed
+    if (geom.getDimension() >= 2) finalRemoveCollapsed = true
+    const reduceGeom = geomEdit.edit(geom, new PrecisionReducerCoordinateOperation(this._targetPM, finalRemoveCollapsed))
+    return reduceGeom
+  }
+  changePM (geom, newPM) {
+    const geomEditor = this.createEditor(geom.getFactory(), newPM)
+    return geomEditor.edit(geom, new GeometryEditor.NoOpGeometryOperation())
+  }
+  setRemoveCollapsedComponents (removeCollapsed) {
+    this._removeCollapsed = removeCollapsed
+  }
+  createFactory (inputFactory, pm) {
+    const newFactory = new GeometryFactory(pm, inputFactory.getSRID(), inputFactory.getCoordinateSequenceFactory())
+    return newFactory
+  }
+  setChangePrecisionModel (changePrecisionModel) {
+    this._changePrecisionModel = changePrecisionModel
+  }
+  reduce (geom) {
+    const reducePW = this.reducePointwise(geom)
+    if (this._isPointwise) return reducePW
+    if (!hasInterface(reducePW, Polygonal)) return reducePW
+    if (reducePW.isValid()) return reducePW
+    return this.fixPolygonalTopology(reducePW)
+  }
+  setPointwise (isPointwise) {
+    this._isPointwise = isPointwise
+  }
+  createEditor (geomFactory, newPM) {
+    if (geomFactory.getPrecisionModel() === newPM) return new GeometryEditor()
+    const newFactory = this.createFactory(geomFactory, newPM)
+    const geomEdit = new GeometryEditor(newFactory)
+    return geomEdit
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return GeometryPrecisionReducer
+  }
+  static reduce (g, precModel) {
+    const reducer = new GeometryPrecisionReducer(precModel)
+    return reducer.reduce(g)
+  }
+  static reducePointwise (g, precModel) {
+    const reducer = new GeometryPrecisionReducer(precModel)
+    reducer.setPointwise(true)
+    return reducer.reduce(g)
+  }
+}

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

@@ -0,0 +1,132 @@
+import ItemBoundable from '../index/strtree/ItemBoundable'
+import FacetSequence from '../operation/distance/FacetSequence'
+import CGAlgorithms from '../algorithm/CGAlgorithms'
+import Coordinate from '../geom/Coordinate'
+import Double from '../../../../java/lang/Double'
+import LineSegment from '../geom/LineSegment'
+import FacetSequenceTreeBuilder from '../operation/distance/FacetSequenceTreeBuilder'
+import ItemDistance from '../index/strtree/ItemDistance'
+
+export default class MinimumClearance {
+  constructor () {
+    this._inputGeom = null
+    this._minClearance = null
+    this._minClearancePts = null
+    const geom = arguments[0]
+    this._inputGeom = geom
+  }
+  getLine () {
+    this.compute()
+    if (this._minClearancePts === null || this._minClearancePts[0] === null) return this._inputGeom.getFactory().createLineString(null)
+    return this._inputGeom.getFactory().createLineString(this._minClearancePts)
+  }
+  compute () {
+    if (this._minClearancePts !== null) return null
+    this._minClearancePts = new Array(2).fill(null)
+    this._minClearance = Double.MAX_VALUE
+    if (this._inputGeom.isEmpty()) {
+      return null
+    }
+    const geomTree = FacetSequenceTreeBuilder.build(this._inputGeom)
+    const nearest = geomTree.nearestNeighbour(new MinClearanceDistance())
+    const mcd = new MinClearanceDistance()
+    this._minClearance = mcd.distance(nearest[0], nearest[1])
+    this._minClearancePts = mcd.getCoordinates()
+  }
+  getDistance () {
+    this.compute()
+    return this._minClearance
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return MinimumClearance
+  }
+  static getLine (g) {
+    const rp = new MinimumClearance(g)
+    return rp.getLine()
+  }
+  static getDistance (g) {
+    const rp = new MinimumClearance(g)
+    return rp.getDistance()
+  }
+  static get MinClearanceDistance () { return MinClearanceDistance }
+}
+
+class MinClearanceDistance {
+  constructor () {
+    this._minDist = Double.MAX_VALUE
+    this._minPts = new Array(2).fill(null)
+  }
+  vertexDistance (fs1, fs2) {
+    for (let i1 = 0; i1 < fs1.size(); i1++) {
+      for (let i2 = 0; i2 < fs2.size(); i2++) {
+        const p1 = fs1.getCoordinate(i1)
+        const p2 = fs2.getCoordinate(i2)
+        if (!p1.equals2D(p2)) {
+          const d = p1.distance(p2)
+          if (d < this._minDist) {
+            this._minDist = d
+            this._minPts[0] = p1
+            this._minPts[1] = p2
+            if (d === 0.0) return d
+          }
+        }
+      }
+    }
+    return this._minDist
+  }
+  getCoordinates () {
+    return this._minPts
+  }
+  segmentDistance (fs1, fs2) {
+    for (let i1 = 0; i1 < fs1.size(); i1++) {
+      for (let i2 = 1; i2 < fs2.size(); i2++) {
+        const p = fs1.getCoordinate(i1)
+        const seg0 = fs2.getCoordinate(i2 - 1)
+        const seg1 = fs2.getCoordinate(i2)
+        if (!(p.equals2D(seg0) || p.equals2D(seg1))) {
+          const d = CGAlgorithms.distancePointLine(p, seg0, seg1)
+          if (d < this._minDist) {
+            this._minDist = d
+            this.updatePts(p, seg0, seg1)
+            if (d === 0.0) return d
+          }
+        }
+      }
+    }
+    return this._minDist
+  }
+  distance () {
+    if (arguments[0] instanceof ItemBoundable && arguments[1] instanceof ItemBoundable) {
+      const b1 = arguments[0]
+      const b2 = arguments[1]
+      const fs1 = b1.getItem()
+      const fs2 = b2.getItem()
+      this._minDist = Double.MAX_VALUE
+      return this.distance(fs1, fs2)
+    } else if (arguments[0] instanceof FacetSequence && arguments[1] instanceof FacetSequence) {
+      const fs1 = arguments[0]
+      const fs2 = arguments[1]
+      this.vertexDistance(fs1, fs2)
+      if (fs1.size() === 1 && fs2.size() === 1) return this._minDist
+      if (this._minDist <= 0.0) return this._minDist
+      this.segmentDistance(fs1, fs2)
+      if (this._minDist <= 0.0) return this._minDist
+      this.segmentDistance(fs2, fs1)
+      return this._minDist
+    }
+  }
+  updatePts (p, seg0, seg1) {
+    this._minPts[0] = p
+    const seg = new LineSegment(seg0, seg1)
+    this._minPts[1] = new Coordinate(seg.closestPoint(p))
+  }
+  interfaces_ () {
+    return [ItemDistance]
+  }
+  getClass () {
+    return MinClearanceDistance
+  }
+}

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

@@ -0,0 +1,39 @@
+import LineString from '../geom/LineString'
+import CoordinateList from '../geom/CoordinateList'
+import Coordinate from '../geom/Coordinate'
+import GeometryEditor from '../geom/util/GeometryEditor'
+import LinearRing from '../geom/LinearRing'
+
+export default class PrecisionReducerCoordinateOperation extends GeometryEditor.CoordinateOperation {
+  constructor (targetPM, removeCollapsed) {
+    super()
+    this._targetPM = targetPM || null
+    this._removeCollapsed = (removeCollapsed !== undefined) ? removeCollapsed : true
+  }
+  editCoordinates (coordinates, geom) {
+    if (coordinates.length === 0) return null
+    const reducedCoords = new Array(coordinates.length).fill(null)
+    for (let i = 0; i < coordinates.length; i++) {
+      const coord = new Coordinate(coordinates[i])
+      this._targetPM.makePrecise(coord)
+      reducedCoords[i] = coord
+    }
+    const noRepeatedCoordList = new CoordinateList(reducedCoords, false)
+    const noRepeatedCoords = noRepeatedCoordList.toCoordinateArray()
+    let minLength = 0
+    if (geom instanceof LineString) minLength = 2
+    if (geom instanceof LinearRing) minLength = 4
+    let collapsedCoords = reducedCoords
+    if (this._removeCollapsed) collapsedCoords = null
+    if (noRepeatedCoords.length < minLength) {
+      return collapsedCoords
+    }
+    return noRepeatedCoords
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return PrecisionReducerCoordinateOperation
+  }
+}