node-red-contrib-tak-registration 0.16.3 → 0.16.5

package/node_modules/jsts/org/locationtech/jts/shape/fractal/MortonCode.js

@@ -1,49 +0,0 @@
-import Coordinate from '../../geom/Coordinate'
-import IllegalArgumentException from '../../../../../java/lang/IllegalArgumentException'
-export default class MortonCode {
-  static deinterleave(x) {
-    x = x & 0x55555555
-    x = (x | x >> 1) & 0x33333333
-    x = (x | x >> 2) & 0x0F0F0F0F
-    x = (x | x >> 4) & 0x00FF00FF
-    x = (x | x >> 8) & 0x0000FFFF
-    return x
-  }
-  static encode(x, y) {
-    return (MortonCode.interleave(y) << 1) + MortonCode.interleave(x)
-  }
-  static checkLevel(level) {
-    if (level > MortonCode.MAX_LEVEL) 
-      throw new IllegalArgumentException('Level must be in range 0 to ' + MortonCode.MAX_LEVEL)
-    
-  }
-  static size(level) {
-    MortonCode.checkLevel(level)
-    return Math.trunc(Math.pow(2, 2 * level))
-  }
-  static maxOrdinate(level) {
-    MortonCode.checkLevel(level)
-    return Math.trunc(Math.pow(2, level)) - 1
-  }
-  static interleave(x) {
-    x &= 0x0000ffff
-    x = (x ^ x << 8) & 0x00ff00ff
-    x = (x ^ x << 4) & 0x0f0f0f0f
-    x = (x ^ x << 2) & 0x33333333
-    x = (x ^ x << 1) & 0x55555555
-    return x
-  }
-  static decode(index) {
-    const x = MortonCode.deinterleave(index)
-    const y = MortonCode.deinterleave(index >> 1)
-    return new Coordinate(x, y)
-  }
-  static level(numPoints) {
-    const pow2 = Math.trunc(Math.log(numPoints) / Math.log(2))
-    let level = Math.trunc(pow2 / 2)
-    const size = MortonCode.size(level)
-    if (size < numPoints) level += 1
-    return level
-  }
-}
-MortonCode.MAX_LEVEL = 16

package/node_modules/jsts/org/locationtech/jts/shape/fractal/MortonCurveBuilder.js

@@ -1,43 +0,0 @@
-import Coordinate from '../../geom/Coordinate'
-import MortonCode from './MortonCode'
-import GeometricShapeBuilder from '../GeometricShapeBuilder'
-export default class MortonCurveBuilder extends GeometricShapeBuilder {
-  constructor() {
-    super()
-    MortonCurveBuilder.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    const geomFactory = arguments[0]
-    GeometricShapeBuilder.constructor_.call(this, geomFactory)
-    this._extent = null
-  }
-  static transform(val, scale, offset) {
-    return val * scale + offset
-  }
-  getGeometry() {
-    const level = MortonCode.level(this._numPts)
-    const nPts = MortonCode.size(level)
-    let scale = 1
-    let baseX = 0
-    let baseY = 0
-    if (this._extent !== null) {
-      const baseLine = this.getSquareBaseLine()
-      baseX = baseLine.minX()
-      baseY = baseLine.minY()
-      const width = baseLine.getLength()
-      const maxOrdinate = MortonCode.maxOrdinate(level)
-      scale = width / maxOrdinate
-    }
-    const pts = new Array(nPts).fill(null)
-    for (let i = 0; i < nPts; i++) {
-      const pt = MortonCode.decode(i)
-      const x = MortonCurveBuilder.transform(pt.getX(), scale, baseX)
-      const y = MortonCurveBuilder.transform(pt.getY(), scale, baseY)
-      pts[i] = new Coordinate(x, y)
-    }
-    return this._geomFactory.createLineString(pts)
-  }
-  setLevel(level) {
-    this._numPts = MortonCode.size(level)
-  }
-}

package/node_modules/jsts/org/locationtech/jts/shape/fractal/SierpinskiCarpetBuilder.js

@@ -1,52 +0,0 @@
-import CoordinateList from '../../geom/CoordinateList'
-import GeometryFactory from '../../geom/GeometryFactory'
-import Coordinate from '../../geom/Coordinate'
-import ArrayList from '../../../../../java/util/ArrayList'
-import GeometricShapeBuilder from '../GeometricShapeBuilder'
-export default class SierpinskiCarpetBuilder extends GeometricShapeBuilder {
-  constructor() {
-    super()
-    SierpinskiCarpetBuilder.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._coordList = new CoordinateList()
-    const geomFactory = arguments[0]
-    GeometricShapeBuilder.constructor_.call(this, geomFactory)
-  }
-  static recursionLevelForSize(numPts) {
-    const pow4 = Math.trunc(numPts / 3)
-    const exp = Math.log(pow4) / Math.log(4)
-    return Math.trunc(exp)
-  }
-  addHoles(n, originX, originY, width, holeList) {
-    if (n < 0) return null
-    const n2 = n - 1
-    const widthThird = width / 3.0
-    this.addHoles(n2, originX, originY, widthThird, holeList)
-    this.addHoles(n2, originX + widthThird, originY, widthThird, holeList)
-    this.addHoles(n2, originX + 2 * widthThird, originY, widthThird, holeList)
-    this.addHoles(n2, originX, originY + widthThird, widthThird, holeList)
-    this.addHoles(n2, originX + 2 * widthThird, originY + widthThird, widthThird, holeList)
-    this.addHoles(n2, originX, originY + 2 * widthThird, widthThird, holeList)
-    this.addHoles(n2, originX + widthThird, originY + 2 * widthThird, widthThird, holeList)
-    this.addHoles(n2, originX + 2 * widthThird, originY + 2 * widthThird, widthThird, holeList)
-    holeList.add(this.createSquareHole(originX + widthThird, originY + widthThird, widthThird))
-  }
-  getHoles(n, originX, originY, width) {
-    const holeList = new ArrayList()
-    this.addHoles(n, originX, originY, width, holeList)
-    return GeometryFactory.toLinearRingArray(holeList)
-  }
-  createSquareHole(x, y, width) {
-    const pts = [new Coordinate(x, y), new Coordinate(x + width, y), new Coordinate(x + width, y + width), new Coordinate(x, y + width), new Coordinate(x, y)]
-    return this._geomFactory.createLinearRing(pts)
-  }
-  getGeometry() {
-    const level = SierpinskiCarpetBuilder.recursionLevelForSize(this._numPts)
-    const baseLine = this.getSquareBaseLine()
-    const origin = baseLine.getCoordinate(0)
-    const holes = this.getHoles(level, origin.x, origin.y, this.getDiameter())
-    const shell = this._geomFactory.toGeometry(this.getSquareExtent()).getExteriorRing()
-    return this._geomFactory.createPolygon(shell, holes)
-  }
-}

package/node_modules/jsts/org/locationtech/jts/shape/random/RandomPointsBuilder.js

@@ -1,60 +0,0 @@
-import Location from '../../geom/Location'
-import Geometry from '../../geom/Geometry'
-import hasInterface from '../../../../../hasInterface'
-import GeometryFactory from '../../geom/GeometryFactory'
-import Coordinate from '../../geom/Coordinate'
-import IllegalArgumentException from '../../../../../java/lang/IllegalArgumentException'
-import Polygonal from '../../geom/Polygonal'
-import IndexedPointInAreaLocator from '../../algorithm/locate/IndexedPointInAreaLocator'
-import GeometricShapeBuilder from '../GeometricShapeBuilder'
-export default class RandomPointsBuilder extends GeometricShapeBuilder {
-  constructor() {
-    super()
-    RandomPointsBuilder.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._maskPoly = null
-    this._extentLocator = null
-    if (arguments.length === 0) {
-      GeometricShapeBuilder.constructor_.call(this, new GeometryFactory())
-    } else if (arguments.length === 1) {
-      const geomFact = arguments[0]
-      GeometricShapeBuilder.constructor_.call(this, geomFact)
-    }
-  }
-  getGeometry() {
-    const pts = new Array(this._numPts).fill(null)
-    let i = 0
-    while (i < this._numPts) {
-      const p = this.createRandomCoord(this.getExtent())
-      if (this._extentLocator !== null && !this.isInExtent(p)) continue
-      pts[i++] = p
-    }
-    return this._geomFactory.createMultiPointFromCoords(pts)
-  }
-  createRandomCoord(env) {
-    const x = env.getMinX() + env.getWidth() * Math.random()
-    const y = env.getMinY() + env.getHeight() * Math.random()
-    return this.createCoord(x, y)
-  }
-  isInExtent(p) {
-    if (this._extentLocator !== null) return this._extentLocator.locate(p) !== Location.EXTERIOR
-    return this.getExtent().contains(p)
-  }
-  setExtent() {
-    if (arguments.length === 1 && arguments[0] instanceof Geometry) {
-      const mask = arguments[0]
-      if (!hasInterface(mask, Polygonal)) throw new IllegalArgumentException('Only polygonal extents are supported')
-      this._maskPoly = mask
-      this.setExtent(mask.getEnvelopeInternal())
-      this._extentLocator = new IndexedPointInAreaLocator(mask)
-    } else {
-      return super.setExtent.apply(this, arguments)
-    }
-  }
-  createCoord(x, y) {
-    const pt = new Coordinate(x, y)
-    this._geomFactory.getPrecisionModel().makePrecise(pt)
-    return pt
-  }
-}

package/node_modules/jsts/org/locationtech/jts/shape/random/RandomPointsInGridBuilder.js

@@ -1,71 +0,0 @@
-import GeometryFactory from '../../geom/GeometryFactory'
-import Coordinate from '../../geom/Coordinate'
-import MathUtil from '../../math/MathUtil'
-import GeometricShapeBuilder from '../GeometricShapeBuilder'
-export default class RandomPointsInGridBuilder extends GeometricShapeBuilder {
-  constructor() {
-    super()
-    RandomPointsInGridBuilder.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._isConstrainedToCircle = false
-    this._gutterFraction = 0
-    if (arguments.length === 0) {
-      GeometricShapeBuilder.constructor_.call(this, new GeometryFactory())
-    } else if (arguments.length === 1) {
-      const geomFact = arguments[0]
-      GeometricShapeBuilder.constructor_.call(this, geomFact)
-    }
-  }
-  static randomPointInCircle(orgX, orgY, width, height) {
-    const centreX = orgX + width / 2
-    const centreY = orgY + height / 2
-    const rndAng = 2 * Math.PI * Math.random()
-    const rndRadius = Math.random()
-    const rndRadius2 = Math.sqrt(rndRadius)
-    const rndX = width / 2 * rndRadius2 * Math.cos(rndAng)
-    const rndY = height / 2 * rndRadius2 * Math.sin(rndAng)
-    const x0 = centreX + rndX
-    const y0 = centreY + rndY
-    return new Coordinate(x0, y0)
-  }
-  randomPointInCell(orgX, orgY, xLen, yLen) {
-    if (this._isConstrainedToCircle) 
-      return RandomPointsInGridBuilder.randomPointInCircle(orgX, orgY, xLen, yLen)
-    
-    return this.randomPointInGridCell(orgX, orgY, xLen, yLen)
-  }
-  getGeometry() {
-    let nCells = Math.trunc(Math.sqrt(this._numPts))
-    if (nCells * nCells < this._numPts) nCells += 1
-    const gridDX = this.getExtent().getWidth() / nCells
-    const gridDY = this.getExtent().getHeight() / nCells
-    const gutterFrac = MathUtil.clamp(this._gutterFraction, 0.0, 1.0)
-    const gutterOffsetX = gridDX * gutterFrac / 2
-    const gutterOffsetY = gridDY * gutterFrac / 2
-    const cellFrac = 1.0 - gutterFrac
-    const cellDX = cellFrac * gridDX
-    const cellDY = cellFrac * gridDY
-    const pts = new Array(nCells * nCells).fill(null)
-    let index = 0
-    for (let i = 0; i < nCells; i++) 
-      for (let j = 0; j < nCells; j++) {
-        const orgX = this.getExtent().getMinX() + i * gridDX + gutterOffsetX
-        const orgY = this.getExtent().getMinY() + j * gridDY + gutterOffsetY
-        pts[index++] = this.randomPointInCell(orgX, orgY, cellDX, cellDY)
-      }
-    
-    return this._geomFactory.createMultiPointFromCoords(pts)
-  }
-  setConstrainedToCircle(isConstrainedToCircle) {
-    this._isConstrainedToCircle = isConstrainedToCircle
-  }
-  setGutterFraction(gutterFraction) {
-    this._gutterFraction = gutterFraction
-  }
-  randomPointInGridCell(orgX, orgY, xLen, yLen) {
-    const x = orgX + xLen * Math.random()
-    const y = orgY + yLen * Math.random()
-    return this.createCoord(x, y)
-  }
-}

package/node_modules/jsts/org/locationtech/jts/simplify/DouglasPeuckerLineSimplifier.js

@@ -1,60 +0,0 @@
-import CoordinateList from '../geom/CoordinateList'
-import Coordinate from '../geom/Coordinate'
-import LineSegment from '../geom/LineSegment'
-export default class DouglasPeuckerLineSimplifier {
-  constructor() {
-    DouglasPeuckerLineSimplifier.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._pts = null
-    this._usePt = null
-    this._distanceTolerance = null
-    this._seg = new LineSegment()
-    const pts = arguments[0]
-    this._pts = pts
-  }
-  static simplify(pts, distanceTolerance) {
-    const simp = new DouglasPeuckerLineSimplifier(pts)
-    simp.setDistanceTolerance(distanceTolerance)
-    return simp.simplify()
-  }
-  simplifySection(i, j) {
-    if (i + 1 === j) 
-      return null
-    
-    this._seg.p0 = this._pts[i]
-    this._seg.p1 = this._pts[j]
-    let maxDistance = -1.0
-    let maxIndex = i
-    for (let k = i + 1; k < j; k++) {
-      const distance = this._seg.distance(this._pts[k])
-      if (distance > maxDistance) {
-        maxDistance = distance
-        maxIndex = k
-      }
-    }
-    if (maxDistance <= this._distanceTolerance) {
-      for (let k = i + 1; k < j; k++) 
-        this._usePt[k] = false
-      
-    } else {
-      this.simplifySection(i, maxIndex)
-      this.simplifySection(maxIndex, j)
-    }
-  }
-  setDistanceTolerance(distanceTolerance) {
-    this._distanceTolerance = distanceTolerance
-  }
-  simplify() {
-    this._usePt = new Array(this._pts.length).fill(null)
-    for (let i = 0; i < this._pts.length; i++) 
-      this._usePt[i] = true
-    
-    this.simplifySection(0, this._pts.length - 1)
-    const coordList = new CoordinateList()
-    for (let i = 0; i < this._pts.length; i++) 
-      if (this._usePt[i]) coordList.add(new Coordinate(this._pts[i]))
-    
-    return coordList.toCoordinateArray()
-  }
-}

package/node_modules/jsts/org/locationtech/jts/simplify/DouglasPeuckerSimplifier.js

@@ -1,81 +0,0 @@
-import DouglasPeuckerLineSimplifier from './DouglasPeuckerLineSimplifier'
-import GeometryTransformer from '../geom/util/GeometryTransformer'
-import IllegalArgumentException from '../../../../java/lang/IllegalArgumentException'
-import Polygon from '../geom/Polygon'
-import LinearRing from '../geom/LinearRing'
-import MultiPolygon from '../geom/MultiPolygon'
-export default class DouglasPeuckerSimplifier {
-  constructor() {
-    DouglasPeuckerSimplifier.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._inputGeom = null
-    this._distanceTolerance = null
-    this._isEnsureValidTopology = true
-    const inputGeom = arguments[0]
-    this._inputGeom = inputGeom
-  }
-  static simplify(geom, distanceTolerance) {
-    const tss = new DouglasPeuckerSimplifier(geom)
-    tss.setDistanceTolerance(distanceTolerance)
-    return tss.getResultGeometry()
-  }
-  setEnsureValid(isEnsureValidTopology) {
-    this._isEnsureValidTopology = isEnsureValidTopology
-  }
-  getResultGeometry() {
-    if (this._inputGeom.isEmpty()) return this._inputGeom.copy()
-    return new DPTransformer(this._isEnsureValidTopology, this._distanceTolerance).transform(this._inputGeom)
-  }
-  setDistanceTolerance(distanceTolerance) {
-    if (distanceTolerance < 0.0) throw new IllegalArgumentException('Tolerance must be non-negative')
-    this._distanceTolerance = distanceTolerance
-  }
-}
-class DPTransformer extends GeometryTransformer {
-  constructor() {
-    super()
-    DPTransformer.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._isEnsureValidTopology = true
-    this._distanceTolerance = null
-    const isEnsureValidTopology = arguments[0], distanceTolerance = arguments[1]
-    this._isEnsureValidTopology = isEnsureValidTopology
-    this._distanceTolerance = distanceTolerance
-  }
-  transformPolygon(geom, parent) {
-    if (geom.isEmpty()) return null
-    const rawGeom = super.transformPolygon.call(this, geom, parent)
-    if (parent instanceof MultiPolygon) 
-      return rawGeom
-    
-    return this.createValidArea(rawGeom)
-  }
-  createValidArea(rawAreaGeom) {
-    if (this._isEnsureValidTopology) return rawAreaGeom.buffer(0.0)
-    return rawAreaGeom
-  }
-  transformCoordinates(coords, parent) {
-    const inputPts = coords.toCoordinateArray()
-    let newPts = null
-    if (inputPts.length === 0) 
-      newPts = new Array(0).fill(null)
-    else 
-      newPts = DouglasPeuckerLineSimplifier.simplify(inputPts, this._distanceTolerance)
-    
-    return this._factory.getCoordinateSequenceFactory().create(newPts)
-  }
-  transformMultiPolygon(geom, parent) {
-    const rawGeom = super.transformMultiPolygon.call(this, geom, parent)
-    return this.createValidArea(rawGeom)
-  }
-  transformLinearRing(geom, parent) {
-    const removeDegenerateRings = parent instanceof Polygon
-    const simpResult = super.transformLinearRing.call(this, geom, parent)
-    if (removeDegenerateRings && !(simpResult instanceof LinearRing)) return null
-    
-    return simpResult
-  }
-}
-DouglasPeuckerSimplifier.DPTransformer = DPTransformer

package/node_modules/jsts/org/locationtech/jts/simplify/LineSegmentIndex.js

@@ -1,58 +0,0 @@
-import Quadtree from '../index/quadtree/Quadtree'
-import ItemVisitor from '../index/ItemVisitor'
-import LineSegment from '../geom/LineSegment'
-import ArrayList from '../../../../java/util/ArrayList'
-import Envelope from '../geom/Envelope'
-import TaggedLineString from './TaggedLineString'
-export default class LineSegmentIndex {
-  constructor() {
-    LineSegmentIndex.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._index = new Quadtree()
-  }
-  remove(seg) {
-    this._index.remove(new Envelope(seg.p0, seg.p1), seg)
-  }
-  add() {
-    if (arguments[0] instanceof TaggedLineString) {
-      const line = arguments[0]
-      const segs = line.getSegments()
-      for (let i = 0; i < segs.length; i++) {
-        const seg = segs[i]
-        this.add(seg)
-      }
-    } else if (arguments[0] instanceof LineSegment) {
-      const seg = arguments[0]
-      this._index.insert(new Envelope(seg.p0, seg.p1), seg)
-    }
-  }
-  query(querySeg) {
-    const env = new Envelope(querySeg.p0, querySeg.p1)
-    const visitor = new LineSegmentVisitor(querySeg)
-    this._index.query(env, visitor)
-    const itemsFound = visitor.getItems()
-    return itemsFound
-  }
-}
-class LineSegmentVisitor {
-  constructor() {
-    LineSegmentVisitor.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._querySeg = null
-    this._items = new ArrayList()
-    const querySeg = arguments[0]
-    this._querySeg = querySeg
-  }
-  visitItem(item) {
-    const seg = item
-    if (Envelope.intersects(seg.p0, seg.p1, this._querySeg.p0, this._querySeg.p1)) this._items.add(item)
-  }
-  getItems() {
-    return this._items
-  }
-  get interfaces_() {
-    return [ItemVisitor]
-  }
-}

package/node_modules/jsts/org/locationtech/jts/simplify/TaggedLineSegment.js

@@ -1,26 +0,0 @@
-import LineSegment from '../geom/LineSegment'
-export default class TaggedLineSegment extends LineSegment {
-  constructor() {
-    super()
-    TaggedLineSegment.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._parent = null
-    this._index = null
-    if (arguments.length === 2) {
-      const p0 = arguments[0], p1 = arguments[1]
-      TaggedLineSegment.constructor_.call(this, p0, p1, null, -1)
-    } else if (arguments.length === 4) {
-      const p0 = arguments[0], p1 = arguments[1], parent = arguments[2], index = arguments[3]
-      LineSegment.constructor_.call(this, p0, p1)
-      this._parent = parent
-      this._index = index
-    }
-  }
-  getIndex() {
-    return this._index
-  }
-  getParent() {
-    return this._parent
-  }
-}

package/node_modules/jsts/org/locationtech/jts/simplify/TaggedLineString.js

@@ -1,71 +0,0 @@
-import TaggedLineSegment from './TaggedLineSegment'
-import ArrayList from '../../../../java/util/ArrayList'
-export default class TaggedLineString {
-  constructor() {
-    TaggedLineString.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._parentLine = null
-    this._segs = null
-    this._resultSegs = new ArrayList()
-    this._minimumSize = null
-    if (arguments.length === 1) {
-      const parentLine = arguments[0]
-      TaggedLineString.constructor_.call(this, parentLine, 2)
-    } else if (arguments.length === 2) {
-      const parentLine = arguments[0], minimumSize = arguments[1]
-      this._parentLine = parentLine
-      this._minimumSize = minimumSize
-      this.init()
-    }
-  }
-  static extractCoordinates(segs) {
-    const pts = new Array(segs.size() + 1).fill(null)
-    let seg = null
-    for (let i = 0; i < segs.size(); i++) {
-      seg = segs.get(i)
-      pts[i] = seg.p0
-    }
-    pts[pts.length - 1] = seg.p1
-    return pts
-  }
-  addToResult(seg) {
-    this._resultSegs.add(seg)
-  }
-  asLineString() {
-    return this._parentLine.getFactory().createLineString(TaggedLineString.extractCoordinates(this._resultSegs))
-  }
-  getResultSize() {
-    const resultSegsSize = this._resultSegs.size()
-    return resultSegsSize === 0 ? 0 : resultSegsSize + 1
-  }
-  getParent() {
-    return this._parentLine
-  }
-  getSegment(i) {
-    return this._segs[i]
-  }
-  getParentCoordinates() {
-    return this._parentLine.getCoordinates()
-  }
-  getMinimumSize() {
-    return this._minimumSize
-  }
-  asLinearRing() {
-    return this._parentLine.getFactory().createLinearRing(TaggedLineString.extractCoordinates(this._resultSegs))
-  }
-  getSegments() {
-    return this._segs
-  }
-  init() {
-    const pts = this._parentLine.getCoordinates()
-    this._segs = new Array(pts.length - 1).fill(null)
-    for (let i = 0; i < pts.length - 1; i++) {
-      const seg = new TaggedLineSegment(pts[i], pts[i + 1], this._parentLine, i)
-      this._segs[i] = seg
-    }
-  }
-  getResultCoordinates() {
-    return TaggedLineString.extractCoordinates(this._resultSegs)
-  }
-}