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

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

@@ -0,0 +1,71 @@
+import Double from '../../../../java/lang/Double'
+
+export default class MathUtil {
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return MathUtil
+  }
+  static log10 (x) {
+    var ln = Math.log(x)
+    if (Double.isInfinite(ln)) return ln
+    if (Double.isNaN(ln)) return ln
+    return ln / MathUtil.LOG_10
+  }
+  static min (v1, v2, v3, v4) {
+    var min = v1
+    if (v2 < min) min = v2
+    if (v3 < min) min = v3
+    if (v4 < min) min = v4
+    return min
+  }
+  static clamp () {
+    if (typeof arguments[2] === 'number' && (typeof arguments[0] === 'number' && typeof arguments[1] === 'number')) {
+      const x = arguments[0]
+      const min = arguments[1]
+      const max = arguments[2]
+      if (x < min) return min
+      if (x > max) return max
+      return x
+    } else if (Number.isInteger(arguments[2]) && (Number.isInteger(arguments[0]) && Number.isInteger(arguments[1]))) {
+      const x = arguments[0]
+      const min = arguments[1]
+      const max = arguments[2]
+      if (x < min) return min
+      if (x > max) return max
+      return x
+    }
+  }
+  static wrap (index, max) {
+    if (index < 0) {
+      return max - -index % max
+    }
+    return index % max
+  }
+  static max () {
+    if (arguments.length === 3) {
+      const v1 = arguments[0]
+      const v2 = arguments[1]
+      const v3 = arguments[2]
+      let max = v1
+      if (v2 > max) max = v2
+      if (v3 > max) max = v3
+      return max
+    } else if (arguments.length === 4) {
+      const v1 = arguments[0]
+      const v2 = arguments[1]
+      const v3 = arguments[2]
+      const v4 = arguments[3]
+      let max = v1
+      if (v2 > max) max = v2
+      if (v3 > max) max = v3
+      if (v4 > max) max = v4
+      return max
+    }
+  }
+  static average (x1, x2) {
+    return (x1 + x2) / 2.0
+  }
+  static get LOG_10 () { return Math.log(10) }
+}

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

@@ -0,0 +1,54 @@
+import IllegalArgumentException from '../../../../java/lang/IllegalArgumentException'
+
+export default class Matrix {
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return Matrix
+  }
+  static solve (a, b) {
+    const n = b.length
+    if (a.length !== n || a[0].length !== n) throw new IllegalArgumentException('Matrix A is incorrectly sized')
+    for (let i = 0; i < n; i++) {
+      let maxElementRow = i
+      for (let j = i + 1; j < n; j++) if (Math.abs(a[j][i]) > Math.abs(a[maxElementRow][i])) maxElementRow = j
+      if (a[maxElementRow][i] === 0.0) return null
+      Matrix.swapRows(a, i, maxElementRow)
+      Matrix.swapRows(b, i, maxElementRow)
+      for (let j = i + 1; j < n; j++) {
+        const rowFactor = a[j][i] / a[i][i]
+        for (let k = n - 1; k >= i; k--) a[j][k] -= a[i][k] * rowFactor
+        b[j] -= b[i] * rowFactor
+      }
+    }
+    const solution = new Array(n).fill(null)
+    for (let j = n - 1; j >= 0; j--) {
+      let t = 0.0
+      for (let k = j + 1; k < n; k++) t += a[j][k] * solution[k]
+      solution[j] = (b[j] - t) / a[j][j]
+    }
+    return solution
+  }
+  static swapRows () {
+    if (Number.isInteger(arguments[2]) && (arguments[0] instanceof Array && Number.isInteger(arguments[1]))) {
+      const m = arguments[0]
+      const i = arguments[1]
+      const j = arguments[2]
+      if (i === j) return null
+      for (let col = 0; col < m[0].length; col++) {
+        const temp = m[i][col]
+        m[i][col] = m[j][col]
+        m[j][col] = temp
+      }
+    } else if (Number.isInteger(arguments[2]) && (arguments[0] instanceof Array && Number.isInteger(arguments[1]))) {
+      const m = arguments[0]
+      const i = arguments[1]
+      const j = arguments[2]
+      if (i === j) return null
+      const temp = m[i]
+      m[i] = m[j]
+      m[j] = temp
+    }
+  }
+}

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

@@ -0,0 +1,41 @@
+import IllegalArgumentException from '../../../../java/lang/IllegalArgumentException'
+import Double from '../../../../java/lang/Double'
+import Vector3D from './Vector3D'
+
+export default class Plane3D {
+  contructor () {
+    this._normal = null
+    this._basePt = null
+    const normal = arguments[0]
+    const basePt = arguments[1]
+    this._normal = normal
+    this._basePt = basePt
+  }
+  closestAxisPlane () {
+    const xmag = Math.abs(this._normal.getX())
+    const ymag = Math.abs(this._normal.getY())
+    const zmag = Math.abs(this._normal.getZ())
+    if (xmag > ymag) {
+      if (xmag > zmag) return Plane3D.YZ_PLANE; else return Plane3D.XY_PLANE
+    } else if (zmag > ymag) {
+      return Plane3D.XY_PLANE
+    }
+    return Plane3D.XZ_PLANE
+  }
+  orientedDistance (p) {
+    const pb = new Vector3D(p, this._basePt)
+    const pbdDotNormal = pb.dot(this._normal)
+    if (Double.isNaN(pbdDotNormal)) throw new IllegalArgumentException('3D Coordinate has NaN ordinate')
+    const d = pbdDotNormal / this._normal.length()
+    return d
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return Plane3D
+  }
+  static get XY_PLANE () { return 1 }
+  static get YZ_PLANE () { return 2 }
+  static get XZ_PLANE () { return 3 }
+}

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

@@ -0,0 +1,180 @@
+import Coordinate from '../geom/Coordinate'
+import Angle from '../algorithm/Angle'
+import RobustDeterminant from '../algorithm/RobustDeterminant'
+import Assert from '../util/Assert'
+
+export default class Vector2D {
+  constructor () {
+    this._x = null
+    this._y = null
+    if (arguments.length === 0) {
+      Vector2D.call(this, 0.0, 0.0)
+    } else if (arguments.length === 1) {
+      if (arguments[0] instanceof Vector2D) {
+        let v = arguments[0]
+        this._x = v._x
+        this._y = v._y
+      } else if (arguments[0] instanceof Coordinate) {
+        let v = arguments[0]
+        this._x = v.x
+        this._y = v.y
+      }
+    } else if (arguments.length === 2) {
+      if (typeof arguments[0] === 'number' && typeof arguments[1] === 'number') {
+        const x = arguments[0]
+        const y = arguments[1]
+        this._x = x
+        this._y = y
+      } else if (arguments[0] instanceof Coordinate && arguments[1] instanceof Coordinate) {
+        const from = arguments[0]
+        const to = arguments[1]
+        this._x = to.x - from.x
+        this._y = to.y - from.y
+      }
+    }
+  }
+  dot (v) {
+    return this._x * v._x + this._y * v._y
+  }
+  isParallel (v) {
+    return RobustDeterminant.signOfDet2x2(this._x, this._y, v._x, v._y) === 0.0
+  }
+  getComponent (index) {
+    if (index === 0) return this._x
+    return this._y
+  }
+  subtract (v) {
+    return Vector2D.create(this._x - v._x, this._y - v._y)
+  }
+  equals (o) {
+    if (!(o instanceof Vector2D)) {
+      return false
+    }
+    var v = o
+    return this._x === v._x && this._y === v._y
+  }
+  normalize () {
+    var length = this.length()
+    if (length > 0.0) return this.divide(length)
+    return Vector2D.create(0.0, 0.0)
+  }
+  angle () {
+    if (arguments.length === 0) {
+      return Math.atan2(this._y, this._x)
+    } else if (arguments.length === 1) {
+      let v = arguments[0]
+      return Angle.diff(v.angle(), this.angle())
+    }
+  }
+  weightedSum (v, frac) {
+    return Vector2D.create(frac * this._x + (1.0 - frac) * v._x, frac * this._y + (1.0 - frac) * v._y)
+  }
+  divide (d) {
+    return Vector2D.create(this._x / d, this._y / d)
+  }
+  rotateByQuarterCircle (numQuarters) {
+    var nQuad = numQuarters % 4
+    if (numQuarters < 0 && nQuad !== 0) {
+      nQuad = nQuad + 4
+    }
+    switch (nQuad) {
+      case 0:
+        return Vector2D.create(this._x, this._y)
+      case 1:
+        return Vector2D.create(-this._y, this._x)
+      case 2:
+        return Vector2D.create(-this._x, -this._y)
+      case 3:
+        return Vector2D.create(this._y, -this._x)
+    }
+    Assert.shouldNeverReachHere()
+    return null
+  }
+  rotate (angle) {
+    var cos = Math.cos(angle)
+    var sin = Math.sin(angle)
+    return Vector2D.create(this._x * cos - this._y * sin, this._x * sin + this._y * cos)
+  }
+  angleTo (v) {
+    var a1 = this.angle()
+    var a2 = v.angle()
+    var angDel = a2 - a1
+    if (angDel <= -Math.PI) return angDel + Angle.PI_TIMES_2
+    if (angDel > Math.PI) return angDel - Angle.PI_TIMES_2
+    return angDel
+  }
+  getX () {
+    return this._x
+  }
+  lengthSquared () {
+    return this._x * this._x + this._y * this._y
+  }
+  negate () {
+    return Vector2D.create(-this._x, -this._y)
+  }
+  clone () {
+    return new Vector2D(this)
+  }
+  toCoordinate () {
+    return new Coordinate(this._x, this._y)
+  }
+  translate (coord) {
+    return new Coordinate(this._x + coord.x, this._y + coord.y)
+  }
+  multiply (d) {
+    return Vector2D.create(this._x * d, this._y * d)
+  }
+  toString () {
+    return '[' + this._x + ', ' + this._y + ']'
+  }
+  length () {
+    return Math.sqrt(this._x * this._x + this._y * this._y)
+  }
+  average (v) {
+    return this.weightedSum(v, 0.5)
+  }
+  getY () {
+    return this._y
+  }
+  add (v) {
+    return Vector2D.create(this._x + v._x, this._y + v._y)
+  }
+  distance (v) {
+    var delx = v._x - this._x
+    var dely = v._y - this._y
+    return Math.sqrt(delx * delx + dely * dely)
+  }
+  hashCode () {
+    var result = 17
+    result = 37 * result + Coordinate.hashCode(this._x)
+    result = 37 * result + Coordinate.hashCode(this._y)
+    return result
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return Vector2D
+  }
+  static create () {
+    if (arguments.length === 1) {
+      if (arguments[0] instanceof Vector2D) {
+        const v = arguments[0]
+        return new Vector2D(v)
+      } else if (arguments[0] instanceof Coordinate) {
+        const coord = arguments[0]
+        return new Vector2D(coord)
+      }
+    } else if (arguments.length === 2) {
+      if (typeof arguments[0] === 'number' && typeof arguments[1] === 'number') {
+        const x = arguments[0]
+        const y = arguments[1]
+        return new Vector2D(x, y)
+      } else if (arguments[0] instanceof Coordinate && arguments[1] instanceof Coordinate) {
+        const from = arguments[0]
+        const to = arguments[1]
+        return new Vector2D(from, to)
+      }
+    }
+  }
+}

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

@@ -0,0 +1,97 @@
+import Coordinate from '../geom/Coordinate'
+
+export default class Vector3D {
+  constructor () {
+    this._x = null
+    this._y = null
+    this._z = null
+    if (arguments.length === 1) {
+      const v = arguments[0]
+      this._x = v.x
+      this._y = v.y
+      this._z = v.z
+    } else if (arguments.length === 2) {
+      const from = arguments[0]
+      const to = arguments[1]
+      this._x = to.x - from.x
+      this._y = to.y - from.y
+      this._z = to.z - from.z
+    } else if (arguments.length === 3) {
+      const x = arguments[0]
+      const y = arguments[1]
+      const z = arguments[2]
+      this._x = x
+      this._y = y
+      this._z = z
+    }
+  }
+  dot (v) {
+    return this._x * v._x + this._y * v._y + this._z * v._z
+  }
+  getZ () {
+    return this._z
+  }
+  normalize () {
+    const length = this.length()
+    if (length > 0.0) return this.divide(this.length())
+    return Vector3D.create(0.0, 0.0, 0.0)
+  }
+  divide (d) {
+    return Vector3D.create(this._x / d, this._y / d, this._z / d)
+  }
+  getX () {
+    return this._x
+  }
+  toString () {
+    return '[' + this._x + ', ' + this._y + ', ' + this._z + ']'
+  }
+  length () {
+    return Math.sqrt(this._x * this._x + this._y * this._y + this._z * this._z)
+  }
+  getY () {
+    return this._y
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return Vector3D
+  }
+  static length (v) {
+    return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z)
+  }
+  static dot () {
+    if (arguments.length === 2) {
+      const v1 = arguments[0]
+      const v2 = arguments[1]
+      return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z
+    } else if (arguments.length === 4) {
+      const A = arguments[0]
+      const B = arguments[1]
+      const C = arguments[2]
+      const D = arguments[3]
+      const ABx = B.x - A.x
+      const ABy = B.y - A.y
+      const ABz = B.z - A.z
+      const CDx = D.x - C.x
+      const CDy = D.y - C.y
+      const CDz = D.z - C.z
+      return ABx * CDx + ABy * CDy + ABz * CDz
+    }
+  }
+  static normalize (v) {
+    const len = Vector3D.length(v)
+    return new Coordinate(v.x / len, v.y / len, v.z / len)
+  }
+  static create () {
+    if (arguments.length === 1) {
+      const coord = arguments[0]
+      return new Vector3D(coord)
+    } else if (arguments.length === 3) {
+      const x = arguments[0]
+      const y = arguments[1]
+      const z = arguments[2]
+      return new Vector3D(x, y, z)
+    }
+  }
+}

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

@@ -0,0 +1,167 @@
+import WKTWriter from './io/WKTWriter'
+import GeometryCollectionMapper from './geom/util/GeometryCollectionMapper'
+import IsValidOp from './operation/valid/IsValidOp'
+import InteriorPointArea from './algorithm/InteriorPointArea'
+import UnaryUnionOp from './operation/union/UnaryUnionOp'
+import UnionOp from './operation/union/UnionOp'
+import SnapIfNeededOverlayOp from './operation/overlay/snap/SnapIfNeededOverlayOp'
+import InteriorPointLine from './algorithm/InteriorPointLine'
+import IsSimpleOp from './operation/issimple/IsSimpleOp'
+import BufferOp from './operation/buffer/BufferOp'
+import ConvexHull from './algorithm/ConvexHull'
+import Centroid from './algorithm/Centroid'
+import RelateOp from './operation/relate/RelateOp'
+import InteriorPointPoint from './algorithm/InteriorPointPoint'
+import DistanceOp from './operation/distance/DistanceOp'
+import OverlayOp from './operation/overlay/OverlayOp'
+import Geometry from './geom/Geometry'
+import GeometryMapper from './geom/util/GeometryMapper'
+
+import extend from '../../../extend'
+
+extend(Geometry.prototype, {
+  equalsTopo: function (g) {
+    if (!this.getEnvelopeInternal().equals(g.getEnvelopeInternal())) return false
+    return RelateOp.relate(this, g).isEquals(this.getDimension(), g.getDimension())
+  },
+  union: function () {
+    if (arguments.length === 0) {
+      return UnaryUnionOp.union(this)
+    } else if (arguments.length === 1) {
+      const other = arguments[0]
+      return UnionOp.union(this, other)
+    }
+  },
+  isValid: function () {
+    return IsValidOp.isValid(this)
+  },
+  intersection: function (other) {
+    if (this.isEmpty() || other.isEmpty()) return OverlayOp.createEmptyResult(OverlayOp.INTERSECTION, this, other, this.factory)
+    if (this.isGeometryCollection()) {
+      const g2 = other
+      return GeometryCollectionMapper.map(this, {
+        interfaces_: function () {
+          return [GeometryMapper.MapOp]
+        },
+        map: function (g) {
+          return g.intersection(g2)
+        }
+      })
+    }
+    this.checkNotGeometryCollection(this)
+    this.checkNotGeometryCollection(other)
+    return SnapIfNeededOverlayOp.overlayOp(this, other, OverlayOp.INTERSECTION)
+  },
+  covers: function (g) {
+    return RelateOp.covers(this, g)
+  },
+  coveredBy: function (g) {
+    return RelateOp.coveredBy(this, g)
+  },
+  touches: function (g) {
+    return RelateOp.touches(this, g)
+  },
+  intersects: function (g) {
+    return RelateOp.intersects(this, g)
+  },
+  within: function (g) {
+    return RelateOp.within(this, g)
+  },
+  overlaps: function (g) {
+    return RelateOp.overlaps(this, g)
+  },
+  disjoint: function (g) {
+    return RelateOp.disjoint(this, g)
+  },
+  crosses: function (g) {
+    return RelateOp.crosses(this, g)
+  },
+  buffer: function () {
+    if (arguments.length === 1) {
+      const distance = arguments[0]
+      return BufferOp.bufferOp(this, distance)
+    } else if (arguments.length === 2) {
+      const distance = arguments[0]
+      const quadrantSegments = arguments[1]
+      return BufferOp.bufferOp(this, distance, quadrantSegments)
+    } else if (arguments.length === 3) {
+      const distance = arguments[0]
+      const quadrantSegments = arguments[1]
+      const endCapStyle = arguments[2]
+      return BufferOp.bufferOp(this, distance, quadrantSegments, endCapStyle)
+    }
+  },
+  convexHull: function () {
+    return new ConvexHull(this).getConvexHull()
+  },
+  relate: function (...args) {
+    return RelateOp.relate(this, ...args)
+  },
+  getCentroid: function () {
+    if (this.isEmpty()) return this._factory.createPoint()
+    const centPt = Centroid.getCentroid(this)
+    return this.createPointFromInternalCoord(centPt, this)
+  },
+  getInteriorPoint: function () {
+    if (this.isEmpty()) return this._factory.createPoint()
+    let interiorPt = null
+    const dim = this.getDimension()
+    if (dim === 0) {
+      const intPt = new InteriorPointPoint(this)
+      interiorPt = intPt.getInteriorPoint()
+    } else if (dim === 1) {
+      const intPt = new InteriorPointLine(this)
+      interiorPt = intPt.getInteriorPoint()
+    } else {
+      const intPt = new InteriorPointArea(this)
+      interiorPt = intPt.getInteriorPoint()
+    }
+    return this.createPointFromInternalCoord(interiorPt, this)
+  },
+  symDifference: function (other) {
+    if (this.isEmpty() || other.isEmpty()) {
+      if (this.isEmpty() && other.isEmpty()) return OverlayOp.createEmptyResult(OverlayOp.SYMDIFFERENCE, this, other, this.factory)
+      if (this.isEmpty()) return other.copy()
+      if (other.isEmpty()) return this.copy()
+    }
+    this.checkNotGeometryCollection(this)
+    this.checkNotGeometryCollection(other)
+    return SnapIfNeededOverlayOp.overlayOp(this, other, OverlayOp.SYMDIFFERENCE)
+  },
+  createPointFromInternalCoord: function (coord, exemplar) {
+    exemplar.getPrecisionModel().makePrecise(coord)
+    return exemplar.getFactory().createPoint(coord)
+  },
+  toText: function () {
+    const writer = new WKTWriter()
+    return writer.write(this)
+  },
+  toString: function () {
+    this.toText()
+  },
+  contains: function (g) {
+    return RelateOp.contains(this, g)
+  },
+  difference: function (other) {
+    if (this.isEmpty()) return OverlayOp.createEmptyResult(OverlayOp.DIFFERENCE, this, other, this.factory)
+    if (other.isEmpty()) return this.copy()
+    this.checkNotGeometryCollection(this)
+    this.checkNotGeometryCollection(other)
+    return SnapIfNeededOverlayOp.overlayOp(this, other, OverlayOp.DIFFERENCE)
+  },
+  isSimple: function () {
+    const op = new IsSimpleOp(this)
+    return op.isSimple()
+  },
+  isWithinDistance: function (geom, distance) {
+    const envDist = this.getEnvelopeInternal().distance(geom.getEnvelopeInternal())
+    if (envDist > distance) return false
+    return DistanceOp.isWithinDistance(this, geom, distance)
+  },
+  distance: function (g) {
+    return DistanceOp.distance(this, g)
+  },
+  isEquivalentClass: function (other) {
+    return this.getClass() === other.getClass()
+  }
+})

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

@@ -0,0 +1,46 @@
+import WKTWriter from '../io/WKTWriter'
+import CoordinateArraySequence from '../geom/impl/CoordinateArraySequence'
+import Octant from './Octant'
+import SegmentString from './SegmentString'
+
+export default class BasicSegmentString {
+  constructor () {
+    this._pts = null
+    this._data = null
+    const pts = arguments[0]
+    const data = arguments[1]
+    this._pts = pts
+    this._data = data
+  }
+  getCoordinates () {
+    return this._pts
+  }
+  size () {
+    return this._pts.length
+  }
+  getCoordinate (i) {
+    return this._pts[i]
+  }
+  isClosed () {
+    return this._pts[0].equals(this._pts[this._pts.length - 1])
+  }
+  getSegmentOctant (index) {
+    if (index === this._pts.length - 1) return -1
+    return Octant.octant(this.getCoordinate(index), this.getCoordinate(index + 1))
+  }
+  setData (data) {
+    this._data = data
+  }
+  getData () {
+    return this._data
+  }
+  toString () {
+    return WKTWriter.toLineString(new CoordinateArraySequence(this._pts))
+  }
+  interfaces_ () {
+    return [SegmentString]
+  }
+  getClass () {
+    return BasicSegmentString
+  }
+}