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

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

@@ -0,0 +1,66 @@
+export default class BoundaryNodeRule {
+  isInBoundary (boundaryCount) {}
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return BoundaryNodeRule
+  }
+  static get Mod2BoundaryNodeRule () { return Mod2BoundaryNodeRule }
+  static get EndPointBoundaryNodeRule () { return EndPointBoundaryNodeRule }
+  static get MultiValentEndPointBoundaryNodeRule () { return MultiValentEndPointBoundaryNodeRule }
+  static get MonoValentEndPointBoundaryNodeRule () { return MonoValentEndPointBoundaryNodeRule }
+  static get MOD2_BOUNDARY_RULE () { return new Mod2BoundaryNodeRule() }
+  static get ENDPOINT_BOUNDARY_RULE () { return new EndPointBoundaryNodeRule() }
+  static get MULTIVALENT_ENDPOINT_BOUNDARY_RULE () { return new MultiValentEndPointBoundaryNodeRule() }
+  static get MONOVALENT_ENDPOINT_BOUNDARY_RULE () { return new MonoValentEndPointBoundaryNodeRule() }
+  static get OGC_SFS_BOUNDARY_RULE () { return BoundaryNodeRule.MOD2_BOUNDARY_RULE }
+}
+
+class Mod2BoundaryNodeRule {
+  isInBoundary (boundaryCount) {
+    return boundaryCount % 2 === 1
+  }
+  interfaces_ () {
+    return [BoundaryNodeRule]
+  }
+  getClass () {
+    return Mod2BoundaryNodeRule
+  }
+}
+
+class EndPointBoundaryNodeRule {
+  isInBoundary (boundaryCount) {
+    return boundaryCount > 0
+  }
+  interfaces_ () {
+    return [BoundaryNodeRule]
+  }
+  getClass () {
+    return EndPointBoundaryNodeRule
+  }
+}
+
+class MultiValentEndPointBoundaryNodeRule {
+  isInBoundary (boundaryCount) {
+    return boundaryCount > 1
+  }
+  interfaces_ () {
+    return [BoundaryNodeRule]
+  }
+  getClass () {
+    return MultiValentEndPointBoundaryNodeRule
+  }
+}
+
+class MonoValentEndPointBoundaryNodeRule {
+  isInBoundary (boundaryCount) {
+    return boundaryCount === 1
+  }
+  interfaces_ () {
+    return [BoundaryNodeRule]
+  }
+  getClass () {
+    return MonoValentEndPointBoundaryNodeRule
+  }
+}

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

@@ -0,0 +1,194 @@
+import Location from '../geom/Location'
+import hasInterface from '../../../../hasInterface'
+import Coordinate from '../geom/Coordinate'
+import IllegalArgumentException from '../../../../java/lang/IllegalArgumentException'
+import MathUtil from '../math/MathUtil'
+import CGAlgorithmsDD from './CGAlgorithmsDD'
+import CoordinateSequence from '../geom/CoordinateSequence'
+import RobustLineIntersector from './RobustLineIntersector'
+import Envelope from '../geom/Envelope'
+import RayCrossingCounter from './RayCrossingCounter'
+
+export default class CGAlgorithms {
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return CGAlgorithms
+  }
+  static orientationIndex (p1, p2, q) {
+    return CGAlgorithmsDD.orientationIndex(p1, p2, q)
+  }
+  static signedArea () {
+    if (arguments[0] instanceof Array) {
+      let ring = arguments[0]
+      if (ring.length < 3) return 0.0
+      let sum = 0.0
+      const x0 = ring[0].x
+      for (let i = 1; i < ring.length - 1; i++) {
+        const x = ring[i].x - x0
+        const y1 = ring[i + 1].y
+        const y2 = ring[i - 1].y
+        sum += x * (y2 - y1)
+      }
+      return sum / 2.0
+    } else if (hasInterface(arguments[0], CoordinateSequence)) {
+      let ring = arguments[0]
+      const n = ring.size()
+      if (n < 3) return 0.0
+      const p0 = new Coordinate()
+      const p1 = new Coordinate()
+      const p2 = new Coordinate()
+      ring.getCoordinate(0, p1)
+      ring.getCoordinate(1, p2)
+      const x0 = p1.x
+      p2.x -= x0
+      let sum = 0.0
+      for (let i = 1; i < n - 1; i++) {
+        p0.y = p1.y
+        p1.x = p2.x
+        p1.y = p2.y
+        ring.getCoordinate(i + 1, p2)
+        p2.x -= x0
+        sum += p1.x * (p0.y - p2.y)
+      }
+      return sum / 2.0
+    }
+  }
+  static distanceLineLine (A, B, C, D) {
+    if (A.equals(B)) return CGAlgorithms.distancePointLine(A, C, D)
+    if (C.equals(D)) return CGAlgorithms.distancePointLine(D, A, B)
+    let noIntersection = false
+    if (!Envelope.intersects(A, B, C, D)) {
+      noIntersection = true
+    } else {
+      const denom = (B.x - A.x) * (D.y - C.y) - (B.y - A.y) * (D.x - C.x)
+      if (denom === 0) {
+        noIntersection = true
+      } else {
+        const rNumb = (A.y - C.y) * (D.x - C.x) - (A.x - C.x) * (D.y - C.y)
+        const sNum = (A.y - C.y) * (B.x - A.x) - (A.x - C.x) * (B.y - A.y)
+        const s = sNum / denom
+        const r = rNumb / denom
+        if (r < 0 || r > 1 || s < 0 || s > 1) {
+          noIntersection = true
+        }
+      }
+    }
+    if (noIntersection) {
+      return MathUtil.min(CGAlgorithms.distancePointLine(A, C, D), CGAlgorithms.distancePointLine(B, C, D), CGAlgorithms.distancePointLine(C, A, B), CGAlgorithms.distancePointLine(D, A, B))
+    }
+    return 0.0
+  }
+  static isPointInRing (p, ring) {
+    return CGAlgorithms.locatePointInRing(p, ring) !== Location.EXTERIOR
+  }
+  static computeLength (pts) {
+    const n = pts.size()
+    if (n <= 1) return 0.0
+    let len = 0.0
+    const p = new Coordinate()
+    pts.getCoordinate(0, p)
+    let x0 = p.x
+    let y0 = p.y
+    for (let i = 1; i < n; i++) {
+      pts.getCoordinate(i, p)
+      const x1 = p.x
+      const y1 = p.y
+      const dx = x1 - x0
+      const dy = y1 - y0
+      len += Math.sqrt(dx * dx + dy * dy)
+      x0 = x1
+      y0 = y1
+    }
+    return len
+  }
+  static isCCW (ring) {
+    const nPts = ring.length - 1
+    if (nPts < 3) throw new IllegalArgumentException('Ring has fewer than 4 points, so orientation cannot be determined')
+    let hiPt = ring[0]
+    let hiIndex = 0
+    for (let i = 1; i <= nPts; i++) {
+      const p = ring[i]
+      if (p.y > hiPt.y) {
+        hiPt = p
+        hiIndex = i
+      }
+    }
+    let iPrev = hiIndex
+    do {
+      iPrev = iPrev - 1
+      if (iPrev < 0) iPrev = nPts
+    } while (ring[iPrev].equals2D(hiPt) && iPrev !== hiIndex)
+    let iNext = hiIndex
+    do {
+      iNext = (iNext + 1) % nPts
+    } while (ring[iNext].equals2D(hiPt) && iNext !== hiIndex)
+    const prev = ring[iPrev]
+    const next = ring[iNext]
+    if (prev.equals2D(hiPt) || next.equals2D(hiPt) || prev.equals2D(next)) return false
+    const disc = CGAlgorithms.computeOrientation(prev, hiPt, next)
+    let isCCW = false
+    if (disc === 0) {
+      isCCW = prev.x > next.x
+    } else {
+      isCCW = disc > 0
+    }
+    return isCCW
+  }
+  static locatePointInRing (p, ring) {
+    return RayCrossingCounter.locatePointInRing(p, ring)
+  }
+  static distancePointLinePerpendicular (p, A, B) {
+    const len2 = (B.x - A.x) * (B.x - A.x) + (B.y - A.y) * (B.y - A.y)
+    const s = ((A.y - p.y) * (B.x - A.x) - (A.x - p.x) * (B.y - A.y)) / len2
+    return Math.abs(s) * Math.sqrt(len2)
+  }
+  static computeOrientation (p1, p2, q) {
+    return CGAlgorithms.orientationIndex(p1, p2, q)
+  }
+  static distancePointLine () {
+    if (arguments.length === 2) {
+      const p = arguments[0]
+      const line = arguments[1]
+      if (line.length === 0) throw new IllegalArgumentException('Line array must contain at least one vertex')
+      let minDistance = p.distance(line[0])
+      for (let i = 0; i < line.length - 1; i++) {
+        const dist = CGAlgorithms.distancePointLine(p, line[i], line[i + 1])
+        if (dist < minDistance) {
+          minDistance = dist
+        }
+      }
+      return minDistance
+    } else if (arguments.length === 3) {
+      const p = arguments[0]
+      const A = arguments[1]
+      const B = arguments[2]
+      if (A.x === B.x && A.y === B.y) return p.distance(A)
+      const len2 = (B.x - A.x) * (B.x - A.x) + (B.y - A.y) * (B.y - A.y)
+      const r = ((p.x - A.x) * (B.x - A.x) + (p.y - A.y) * (B.y - A.y)) / len2
+      if (r <= 0.0) return p.distance(A)
+      if (r >= 1.0) return p.distance(B)
+      const s = ((A.y - p.y) * (B.x - A.x) - (A.x - p.x) * (B.y - A.y)) / len2
+      return Math.abs(s) * Math.sqrt(len2)
+    }
+  }
+  static isOnLine (p, pt) {
+    const lineIntersector = new RobustLineIntersector()
+    for (let i = 1; i < pt.length; i++) {
+      const p0 = pt[i - 1]
+      const p1 = pt[i]
+      lineIntersector.computeIntersection(p, p0, p1)
+      if (lineIntersector.hasIntersection()) {
+        return true
+      }
+    }
+    return false
+  }
+  static get CLOCKWISE () { return -1 }
+  static get RIGHT () { return CGAlgorithms.CLOCKWISE }
+  static get COUNTERCLOCKWISE () { return 1 }
+  static get LEFT () { return CGAlgorithms.COUNTERCLOCKWISE }
+  static get COLLINEAR () { return 0 }
+  static get STRAIGHT () { return CGAlgorithms.COLLINEAR }
+}

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

@@ -0,0 +1,65 @@
+import Coordinate from '../geom/Coordinate'
+import IllegalArgumentException from '../../../../java/lang/IllegalArgumentException'
+import Double from '../../../../java/lang/Double'
+import Vector3D from '../math/Vector3D'
+
+export default class CGAlgorithms3D {
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return CGAlgorithms3D
+  }
+  static distanceSegmentSegment (A, B, C, D) {
+    if (A.equals3D(B)) return CGAlgorithms3D.distancePointSegment(A, C, D)
+    if (C.equals3D(B)) return CGAlgorithms3D.distancePointSegment(C, A, B)
+    var a = Vector3D.dot(A, B, A, B)
+    var b = Vector3D.dot(A, B, C, D)
+    var c = Vector3D.dot(C, D, C, D)
+    var d = Vector3D.dot(A, B, C, A)
+    var e = Vector3D.dot(C, D, C, A)
+    var denom = a * c - b * b
+    if (Double.isNaN(denom)) throw new IllegalArgumentException('Ordinates must not be NaN')
+    var s = null
+    var t = null
+    if (denom <= 0.0) {
+      s = 0
+      if (b > c) t = d / b; else t = e / c
+    } else {
+      s = (b * e - c * d) / denom
+      t = (a * e - b * d) / denom
+    }
+    if (s < 0) return CGAlgorithms3D.distancePointSegment(A, C, D); else if (s > 1) return CGAlgorithms3D.distancePointSegment(B, C, D); else if (t < 0) return CGAlgorithms3D.distancePointSegment(C, A, B); else if (t > 1) {
+      return CGAlgorithms3D.distancePointSegment(D, A, B)
+    }
+    var x1 = A.x + s * (B.x - A.x)
+    var y1 = A.y + s * (B.y - A.y)
+    var z1 = A.z + s * (B.z - A.z)
+    var x2 = C.x + t * (D.x - C.x)
+    var y2 = C.y + t * (D.y - C.y)
+    var z2 = C.z + t * (D.z - C.z)
+    return CGAlgorithms3D.distance(new Coordinate(x1, y1, z1), new Coordinate(x2, y2, z2))
+  }
+  static distance (p0, p1) {
+    if (Double.isNaN(p0.z) || Double.isNaN(p1.z)) return p0.distance(p1)
+    var dx = p0.x - p1.x
+    var dy = p0.y - p1.y
+    var dz = p0.z - p1.z
+    return Math.sqrt(dx * dx + dy * dy + dz * dz)
+  }
+  static distancePointSegment (p, A, B) {
+    if (A.equals3D(B)) return CGAlgorithms3D.distance(p, A)
+    var len2 = (B.x - A.x) * (B.x - A.x) + (B.y - A.y) * (B.y - A.y) + (B.z - A.z) * (B.z - A.z)
+    if (Double.isNaN(len2)) throw new IllegalArgumentException('Ordinates must not be NaN')
+    var r = ((p.x - A.x) * (B.x - A.x) + (p.y - A.y) * (B.y - A.y) + (p.z - A.z) * (B.z - A.z)) / len2
+    if (r <= 0.0) return CGAlgorithms3D.distance(p, A)
+    if (r >= 1.0) return CGAlgorithms3D.distance(p, B)
+    var qx = A.x + r * (B.x - A.x)
+    var qy = A.y + r * (B.y - A.y)
+    var qz = A.z + r * (B.z - A.z)
+    var dx = p.x - qx
+    var dy = p.y - qy
+    var dz = p.z - qz
+    return Math.sqrt(dx * dx + dy * dy + dz * dz)
+  }
+}

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

@@ -0,0 +1,72 @@
+import Coordinate from '../geom/Coordinate'
+import DD from '../math/DD'
+
+export default class CGAlgorithmsDD {
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return CGAlgorithmsDD
+  }
+  static orientationIndex (p1, p2, q) {
+    const index = CGAlgorithmsDD.orientationIndexFilter(p1, p2, q)
+    if (index <= 1) return index
+    const dx1 = DD.valueOf(p2.x).selfAdd(-p1.x)
+    const dy1 = DD.valueOf(p2.y).selfAdd(-p1.y)
+    const dx2 = DD.valueOf(q.x).selfAdd(-p2.x)
+    const dy2 = DD.valueOf(q.y).selfAdd(-p2.y)
+    return dx1.selfMultiply(dy2).selfSubtract(dy1.selfMultiply(dx2)).signum()
+  }
+  static signOfDet2x2 (x1, y1, x2, y2) {
+    const det = x1.multiply(y2).selfSubtract(y1.multiply(x2))
+    return det.signum()
+  }
+  static intersection (p1, p2, q1, q2) {
+    const denom1 = DD.valueOf(q2.y).selfSubtract(q1.y).selfMultiply(DD.valueOf(p2.x).selfSubtract(p1.x))
+    const denom2 = DD.valueOf(q2.x).selfSubtract(q1.x).selfMultiply(DD.valueOf(p2.y).selfSubtract(p1.y))
+    const denom = denom1.subtract(denom2)
+    const numx1 = DD.valueOf(q2.x).selfSubtract(q1.x).selfMultiply(DD.valueOf(p1.y).selfSubtract(q1.y))
+    const numx2 = DD.valueOf(q2.y).selfSubtract(q1.y).selfMultiply(DD.valueOf(p1.x).selfSubtract(q1.x))
+    const numx = numx1.subtract(numx2)
+    const fracP = numx.selfDivide(denom).doubleValue()
+    const x = DD.valueOf(p1.x).selfAdd(DD.valueOf(p2.x).selfSubtract(p1.x).selfMultiply(fracP)).doubleValue()
+    const numy1 = DD.valueOf(p2.x).selfSubtract(p1.x).selfMultiply(DD.valueOf(p1.y).selfSubtract(q1.y))
+    const numy2 = DD.valueOf(p2.y).selfSubtract(p1.y).selfMultiply(DD.valueOf(p1.x).selfSubtract(q1.x))
+    const numy = numy1.subtract(numy2)
+    const fracQ = numy.selfDivide(denom).doubleValue()
+    const y = DD.valueOf(q1.y).selfAdd(DD.valueOf(q2.y).selfSubtract(q1.y).selfMultiply(fracQ)).doubleValue()
+    return new Coordinate(x, y)
+  }
+  static orientationIndexFilter (pa, pb, pc) {
+    let detsum = null
+    const detleft = (pa.x - pc.x) * (pb.y - pc.y)
+    const detright = (pa.y - pc.y) * (pb.x - pc.x)
+    const det = detleft - detright
+    if (detleft > 0.0) {
+      if (detright <= 0.0) {
+        return CGAlgorithmsDD.signum(det)
+      } else {
+        detsum = detleft + detright
+      }
+    } else if (detleft < 0.0) {
+      if (detright >= 0.0) {
+        return CGAlgorithmsDD.signum(det)
+      } else {
+        detsum = -detleft - detright
+      }
+    } else {
+      return CGAlgorithmsDD.signum(det)
+    }
+    const errbound = CGAlgorithmsDD.DP_SAFE_EPSILON * detsum
+    if (det >= errbound || -det >= errbound) {
+      return CGAlgorithmsDD.signum(det)
+    }
+    return 2
+  }
+  static signum (x) {
+    if (x > 0) return 1
+    if (x < 0) return -1
+    return 0
+  }
+  static get DP_SAFE_EPSILON () { return 1e-15 };
+}

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

@@ -0,0 +1,127 @@
+import LineString from '../geom/LineString'
+import CGAlgorithms from './CGAlgorithms'
+import Geometry from '../geom/Geometry'
+import Coordinate from '../geom/Coordinate'
+import Point from '../geom/Point'
+import Polygon from '../geom/Polygon'
+import GeometryCollection from '../geom/GeometryCollection'
+
+export default class Centroid {
+  constructor () {
+    this._areaBasePt = null
+    this._triangleCent3 = new Coordinate()
+    this._areasum2 = 0
+    this._cg3 = new Coordinate()
+    this._lineCentSum = new Coordinate()
+    this._totalLength = 0.0
+    this._ptCount = 0
+    this._ptCentSum = new Coordinate()
+    const geom = arguments[0]
+    this._areaBasePt = null
+    this.add(geom)
+  }
+  addPoint (pt) {
+    this._ptCount += 1
+    this._ptCentSum.x += pt.x
+    this._ptCentSum.y += pt.y
+  }
+  setBasePoint (basePt) {
+    if (this._areaBasePt === null) this._areaBasePt = basePt
+  }
+  addLineSegments (pts) {
+    let lineLen = 0.0
+    for (let i = 0; i < pts.length - 1; i++) {
+      const segmentLen = pts[i].distance(pts[i + 1])
+      if (segmentLen === 0.0) continue
+      lineLen += segmentLen
+      const midx = (pts[i].x + pts[i + 1].x) / 2
+      this._lineCentSum.x += segmentLen * midx
+      const midy = (pts[i].y + pts[i + 1].y) / 2
+      this._lineCentSum.y += segmentLen * midy
+    }
+    this._totalLength += lineLen
+    if (lineLen === 0.0 && pts.length > 0) this.addPoint(pts[0])
+  }
+  addHole (pts) {
+    const isPositiveArea = CGAlgorithms.isCCW(pts)
+    for (let i = 0; i < pts.length - 1; i++) {
+      this.addTriangle(this._areaBasePt, pts[i], pts[i + 1], isPositiveArea)
+    }
+    this.addLineSegments(pts)
+  }
+  getCentroid () {
+    const cent = new Coordinate()
+    if (Math.abs(this._areasum2) > 0.0) {
+      cent.x = this._cg3.x / 3 / this._areasum2
+      cent.y = this._cg3.y / 3 / this._areasum2
+    } else if (this._totalLength > 0.0) {
+      cent.x = this._lineCentSum.x / this._totalLength
+      cent.y = this._lineCentSum.y / this._totalLength
+    } else if (this._ptCount > 0) {
+      cent.x = this._ptCentSum.x / this._ptCount
+      cent.y = this._ptCentSum.y / this._ptCount
+    } else {
+      return null
+    }
+    return cent
+  }
+  addShell (pts) {
+    if (pts.length > 0) this.setBasePoint(pts[0])
+    const isPositiveArea = !CGAlgorithms.isCCW(pts)
+    for (let i = 0; i < pts.length - 1; i++) {
+      this.addTriangle(this._areaBasePt, pts[i], pts[i + 1], isPositiveArea)
+    }
+    this.addLineSegments(pts)
+  }
+  addTriangle (p0, p1, p2, isPositiveArea) {
+    const sign = isPositiveArea ? 1.0 : -1.0
+    Centroid.centroid3(p0, p1, p2, this._triangleCent3)
+    const area2 = Centroid.area2(p0, p1, p2)
+    this._cg3.x += sign * area2 * this._triangleCent3.x
+    this._cg3.y += sign * area2 * this._triangleCent3.y
+    this._areasum2 += sign * area2
+  }
+  add () {
+    if (arguments[0] instanceof Polygon) {
+      let poly = arguments[0]
+      this.addShell(poly.getExteriorRing().getCoordinates())
+      for (let i = 0; i < poly.getNumInteriorRing(); i++) {
+        this.addHole(poly.getInteriorRingN(i).getCoordinates())
+      }
+    } else if (arguments[0] instanceof Geometry) {
+      let geom = arguments[0]
+      if (geom.isEmpty()) return null
+      if (geom instanceof Point) {
+        this.addPoint(geom.getCoordinate())
+      } else if (geom instanceof LineString) {
+        this.addLineSegments(geom.getCoordinates())
+      } else if (geom instanceof Polygon) {
+        const poly = geom
+        this.add(poly)
+      } else if (geom instanceof GeometryCollection) {
+        const gc = geom
+        for (let i = 0; i < gc.getNumGeometries(); i++) {
+          this.add(gc.getGeometryN(i))
+        }
+      }
+    }
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return Centroid
+  }
+  static area2 (p1, p2, p3) {
+    return (p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y)
+  }
+  static centroid3 (p1, p2, p3, c) {
+    c.x = p1.x + p2.x + p3.x
+    c.y = p1.y + p2.y + p3.y
+    return null
+  }
+  static getCentroid (geom) {
+    const cent = new Centroid(geom)
+    return cent.getCentroid()
+  }
+}