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

package/node_modules/jsts/org/locationtech/jts/operation/union/OverlapUnion.js

@@ -1,146 +0,0 @@
-import HashSet from '../../../../../java/util/HashSet'
-import TopologyException from '../../geom/TopologyException'
-import GeometryCombiner from '../../geom/util/GeometryCombiner'
-import LineSegment from '../../geom/LineSegment'
-import ArrayList from '../../../../../java/util/ArrayList'
-import CoordinateSequenceFilter from '../../geom/CoordinateSequenceFilter'
-export default class OverlapUnion {
-  constructor() {
-    OverlapUnion.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._geomFactory = null
-    this._g0 = null
-    this._g1 = null
-    this._isUnionSafe = null
-    const g0 = arguments[0], g1 = arguments[1]
-    this._g0 = g0
-    this._g1 = g1
-    this._geomFactory = g0.getFactory()
-  }
-  static containsProperly() {
-    if (arguments.length === 2) {
-      const env = arguments[0], p = arguments[1]
-      if (env.isNull()) return false
-      return p.getX() > env.getMinX() && p.getX() < env.getMaxX() && p.getY() > env.getMinY() && p.getY() < env.getMaxY()
-    } else if (arguments.length === 3) {
-      const env = arguments[0], p0 = arguments[1], p1 = arguments[2]
-      return OverlapUnion.containsProperly(env, p0) && OverlapUnion.containsProperly(env, p1)
-    }
-  }
-  static union(g0, g1) {
-    const union = new OverlapUnion(g0, g1)
-    return union.union()
-  }
-  static intersects(env, p0, p1) {
-    return env.intersects(p0) || env.intersects(p1)
-  }
-  static overlapEnvelope(g0, g1) {
-    const g0Env = g0.getEnvelopeInternal()
-    const g1Env = g1.getEnvelopeInternal()
-    const overlapEnv = g0Env.intersection(g1Env)
-    return overlapEnv
-  }
-  static extractBorderSegments(geom, env, segs) {
-    geom.apply(new (class {
-      get interfaces_() {
-        return [CoordinateSequenceFilter]
-      }
-      filter(seq, i) {
-        if (i <= 0) return null
-        const p0 = seq.getCoordinate(i - 1)
-        const p1 = seq.getCoordinate(i)
-        const isBorder = OverlapUnion.intersects(env, p0, p1) && !OverlapUnion.containsProperly(env, p0, p1)
-        if (isBorder) {
-          const seg = new LineSegment(p0, p1)
-          segs.add(seg)
-        }
-      }
-      isDone() {
-        return false
-      }
-      isGeometryChanged() {
-        return false
-      }
-    })())
-  }
-  static unionBuffer(g0, g1) {
-    const factory = g0.getFactory()
-    const gColl = factory.createGeometryCollection([g0, g1])
-    const union = gColl.buffer(0.0)
-    return union
-  }
-  isBorderSegmentsSame(result, env) {
-    const segsBefore = this.extractBorderSegments(this._g0, this._g1, env)
-    const segsAfter = new ArrayList()
-    OverlapUnion.extractBorderSegments(result, env, segsAfter)
-    return this.isEqual(segsBefore, segsAfter)
-  }
-  extractByEnvelope(env, geom, disjointGeoms) {
-    const intersectingGeoms = new ArrayList()
-    for (let i = 0; i < geom.getNumGeometries(); i++) {
-      const elem = geom.getGeometryN(i)
-      if (elem.getEnvelopeInternal().intersects(env)) {
-        intersectingGeoms.add(elem)
-      } else {
-        const copy = elem.copy()
-        disjointGeoms.add(copy)
-      }
-    }
-    return this._geomFactory.buildGeometry(intersectingGeoms)
-  }
-  isEqual(segs0, segs1) {
-    if (segs0.size() !== segs1.size()) return false
-    const segIndex = new HashSet(segs0)
-    for (const seg of segs1) 
-      if (!segIndex.contains(seg)) 
-        return false
-      
-    
-    return true
-  }
-  union() {
-    const overlapEnv = OverlapUnion.overlapEnvelope(this._g0, this._g1)
-    if (overlapEnv.isNull()) {
-      const g0Copy = this._g0.copy()
-      const g1Copy = this._g1.copy()
-      return GeometryCombiner.combine(g0Copy, g1Copy)
-    }
-    const disjointPolys = new ArrayList()
-    const g0Overlap = this.extractByEnvelope(overlapEnv, this._g0, disjointPolys)
-    const g1Overlap = this.extractByEnvelope(overlapEnv, this._g1, disjointPolys)
-    const unionGeom = this.unionFull(g0Overlap, g1Overlap)
-    let result = null
-    this._isUnionSafe = this.isBorderSegmentsSame(unionGeom, overlapEnv)
-    if (!this._isUnionSafe) 
-      result = this.unionFull(this._g0, this._g1)
-    else 
-      result = this.combine(unionGeom, disjointPolys)
-    
-    return result
-  }
-  combine(unionGeom, disjointPolys) {
-    if (disjointPolys.size() <= 0) return unionGeom
-    disjointPolys.add(unionGeom)
-    const result = GeometryCombiner.combine(disjointPolys)
-    return result
-  }
-  unionFull(geom0, geom1) {
-    try {
-      return geom0.union(geom1)
-    } catch (ex) {
-      if (ex instanceof TopologyException) 
-        return OverlapUnion.unionBuffer(geom0, geom1)
-      else throw ex
-    } finally {}
-  }
-  extractBorderSegments(geom0, geom1, env) {
-    const segs = new ArrayList()
-    OverlapUnion.extractBorderSegments(geom0, env, segs)
-    if (geom1 !== null) OverlapUnion.extractBorderSegments(geom1, env, segs)
-    return segs
-  }
-  isUnionOptimized() {
-    return this._isUnionSafe
-  }
-}

package/node_modules/jsts/org/locationtech/jts/operation/union/PointGeometryUnion.js

@@ -1,42 +0,0 @@
-import PointLocator from '../../algorithm/PointLocator'
-import Location from '../../geom/Location'
-import TreeSet from '../../../../../java/util/TreeSet'
-import GeometryCombiner from '../../geom/util/GeometryCombiner'
-import CoordinateArrays from '../../geom/CoordinateArrays'
-export default class PointGeometryUnion {
-  constructor() {
-    PointGeometryUnion.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._pointGeom = null
-    this._otherGeom = null
-    this._geomFact = null
-    const pointGeom = arguments[0], otherGeom = arguments[1]
-    this._pointGeom = pointGeom
-    this._otherGeom = otherGeom
-    this._geomFact = otherGeom.getFactory()
-  }
-  static union(pointGeom, otherGeom) {
-    const unioner = new PointGeometryUnion(pointGeom, otherGeom)
-    return unioner.union()
-  }
-  union() {
-    const locater = new PointLocator()
-    const exteriorCoords = new TreeSet()
-    for (let i = 0; i < this._pointGeom.getNumGeometries(); i++) {
-      const point = this._pointGeom.getGeometryN(i)
-      const coord = point.getCoordinate()
-      const loc = locater.locate(coord, this._otherGeom)
-      if (loc === Location.EXTERIOR) exteriorCoords.add(coord)
-    }
-    if (exteriorCoords.size() === 0) return this._otherGeom
-    let ptComp = null
-    const coords = CoordinateArrays.toCoordinateArray(exteriorCoords)
-    if (coords.length === 1) 
-      ptComp = this._geomFact.createPoint(coords[0])
-    else 
-      ptComp = this._geomFact.createMultiPointFromCoords(coords)
-    
-    return GeometryCombiner.combine(ptComp, this._otherGeom)
-  }
-}

package/node_modules/jsts/org/locationtech/jts/operation/union/UnaryUnionOp.js

@@ -1,97 +0,0 @@
-import Geometry from '../../geom/Geometry'
-import PointGeometryUnion from './PointGeometryUnion'
-import hasInterface from '../../../../../hasInterface'
-import Collection from '../../../../../java/util/Collection'
-import SnapIfNeededOverlayOp from '../overlay/snap/SnapIfNeededOverlayOp'
-import InputExtracter from './InputExtracter'
-import OverlayOp from '../overlay/OverlayOp'
-import CascadedPolygonUnion from './CascadedPolygonUnion'
-export default class UnaryUnionOp {
-  constructor() {
-    UnaryUnionOp.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._geomFact = null
-    this._extracter = null
-    if (arguments.length === 1) {
-      if (hasInterface(arguments[0], Collection)) {
-        const geoms = arguments[0]
-        this.extract(geoms)
-      } else if (arguments[0] instanceof Geometry) {
-        const geom = arguments[0]
-        this.extract(geom)
-      }
-    } else if (arguments.length === 2) {
-      const geoms = arguments[0], geomFact = arguments[1]
-      this._geomFact = geomFact
-      this.extract(geoms)
-    }
-  }
-  static union() {
-    if (arguments.length === 1) {
-      if (hasInterface(arguments[0], Collection)) {
-        const geoms = arguments[0]
-        const op = new UnaryUnionOp(geoms)
-        return op.union()
-      } else if (arguments[0] instanceof Geometry) {
-        const geom = arguments[0]
-        const op = new UnaryUnionOp(geom)
-        return op.union()
-      }
-    } else if (arguments.length === 2) {
-      const geoms = arguments[0], geomFact = arguments[1]
-      const op = new UnaryUnionOp(geoms, geomFact)
-      return op.union()
-    }
-  }
-  unionNoOpt(g0) {
-    const empty = this._geomFact.createPoint()
-    return SnapIfNeededOverlayOp.overlayOp(g0, empty, OverlayOp.UNION)
-  }
-  unionWithNull(g0, g1) {
-    if (g0 === null && g1 === null) return null
-    if (g1 === null) return g0
-    if (g0 === null) return g1
-    return g0.union(g1)
-  }
-  extract() {
-    if (hasInterface(arguments[0], Collection)) {
-      const geoms = arguments[0]
-      this._extracter = InputExtracter.extract(geoms)
-    } else if (arguments[0] instanceof Geometry) {
-      const geom = arguments[0]
-      this._extracter = InputExtracter.extract(geom)
-    }
-  }
-  union() {
-    if (this._geomFact === null) this._geomFact = this._extracter.getFactory()
-    if (this._geomFact === null) 
-      return null
-    
-    if (this._extracter.isEmpty()) 
-      return this._geomFact.createEmpty(this._extracter.getDimension())
-    
-    const points = this._extracter.getExtract(0)
-    const lines = this._extracter.getExtract(1)
-    const polygons = this._extracter.getExtract(2)
-    let unionPoints = null
-    if (points.size() > 0) {
-      const ptGeom = this._geomFact.buildGeometry(points)
-      unionPoints = this.unionNoOpt(ptGeom)
-    }
-    let unionLines = null
-    if (lines.size() > 0) {
-      const lineGeom = this._geomFact.buildGeometry(lines)
-      unionLines = this.unionNoOpt(lineGeom)
-    }
-    let unionPolygons = null
-    if (polygons.size() > 0) 
-      unionPolygons = CascadedPolygonUnion.union(polygons)
-    
-    const unionLA = this.unionWithNull(unionLines, unionPolygons)
-    let union = null
-    if (unionPoints === null) union = unionLA; else if (unionLA === null) union = unionPoints; else union = PointGeometryUnion.union(unionPoints, unionLA)
-    if (union === null) return this._geomFact.createGeometryCollection()
-    return union
-  }
-}

package/node_modules/jsts/org/locationtech/jts/operation/union/UnionInteracting.js

@@ -1,70 +0,0 @@
-import GeometryCombiner from '../../geom/util/GeometryCombiner'
-import System from '../../../../../java/lang/System'
-import ArrayList from '../../../../../java/util/ArrayList'
-export default class UnionInteracting {
-  constructor() {
-    UnionInteracting.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._geomFactory = null
-    this._g0 = null
-    this._g1 = null
-    this._interacts0 = null
-    this._interacts1 = null
-    const g0 = arguments[0], g1 = arguments[1]
-    this._g0 = g0
-    this._g1 = g1
-    this._geomFactory = g0.getFactory()
-    this._interacts0 = new Array(g0.getNumGeometries()).fill(null)
-    this._interacts1 = new Array(g1.getNumGeometries()).fill(null)
-  }
-  static union(g0, g1) {
-    const uue = new UnionInteracting(g0, g1)
-    return uue.union()
-  }
-  extractElements(geom, interacts, isInteracting) {
-    const extractedGeoms = new ArrayList()
-    for (let i = 0; i < geom.getNumGeometries(); i++) {
-      const elem = geom.getGeometryN(i)
-      if (interacts[i] === isInteracting) extractedGeoms.add(elem)
-    }
-    return this._geomFactory.buildGeometry(extractedGeoms)
-  }
-  computeInteracting() {
-    if (arguments.length === 0) {
-      for (let i = 0; i < this._g0.getNumGeometries(); i++) {
-        const elem = this._g0.getGeometryN(i)
-        this._interacts0[i] = this.computeInteracting(elem)
-      }
-    } else if (arguments.length === 1) {
-      const elem0 = arguments[0]
-      let interactsWithAny = false
-      for (let i = 0; i < this._g1.getNumGeometries(); i++) {
-        const elem1 = this._g1.getGeometryN(i)
-        const interacts = elem1.getEnvelopeInternal().intersects(elem0.getEnvelopeInternal())
-        if (interacts) this._interacts1[i] = true
-        if (interacts) interactsWithAny = true
-      }
-      return interactsWithAny
-    }
-  }
-  union() {
-    this.computeInteracting()
-    const int0 = this.extractElements(this._g0, this._interacts0, true)
-    const int1 = this.extractElements(this._g1, this._interacts1, true)
-    if (int0.isEmpty() || int1.isEmpty()) 
-      System.out.println('found empty!')
-    
-    const union = int0.union(int1)
-    const disjoint0 = this.extractElements(this._g0, this._interacts0, false)
-    const disjoint1 = this.extractElements(this._g1, this._interacts1, false)
-    const overallUnion = GeometryCombiner.combine(union, disjoint0, disjoint1)
-    return overallUnion
-  }
-  bufferUnion(g0, g1) {
-    const factory = g0.getFactory()
-    const gColl = factory.createGeometryCollection([g0, g1])
-    const unionAll = gColl.buffer(0.0)
-    return unionAll
-  }
-}

package/node_modules/jsts/org/locationtech/jts/operation/union/UnionOp.js

@@ -1,22 +0,0 @@
-import SnapIfNeededOverlayOp from '../overlay/snap/SnapIfNeededOverlayOp'
-import OverlayOp from '../overlay/OverlayOp'
-export default class UnionOp {
-  get interfaces_() {
-    return []
-  }
-
-  getClass() {
-    return UnionOp
-  }
-
-  static union(g, other) {
-    if (g.isEmpty() || other.isEmpty()) {
-      if (g.isEmpty() && other.isEmpty()) return OverlayOp.createEmptyResult(OverlayOp.UNION, g, other, g.getFactory())
-      if (g.isEmpty()) return other.copy()
-      if (other.isEmpty()) return g.copy()
-    }
-    g.checkNotGeometryCollection(g)
-    g.checkNotGeometryCollection(other)
-    return SnapIfNeededOverlayOp.overlayOp(g, other, OverlayOp.UNION)
-  }
-}

package/node_modules/jsts/org/locationtech/jts/operation/union.js

@@ -1,5 +0,0 @@
-import UnaryUnionOp from './union/UnaryUnionOp'
-
-export {
-  UnaryUnionOp
-}

package/node_modules/jsts/org/locationtech/jts/operation/valid/ConnectedInteriorTester.js

@@ -1,118 +0,0 @@
-import Location from '../../geom/Location'
-import GeometryFactory from '../../geom/GeometryFactory'
-import Position from '../../geomgraph/Position'
-import Polygon from '../../geom/Polygon'
-import MultiPolygon from '../../geom/MultiPolygon'
-import MaximalEdgeRing from '../overlay/MaximalEdgeRing'
-import OverlayNodeFactory from '../overlay/OverlayNodeFactory'
-import ArrayList from '../../../../../java/util/ArrayList'
-import Assert from '../../util/Assert'
-import PlanarGraph from '../../geomgraph/PlanarGraph'
-export default class ConnectedInteriorTester {
-  constructor() {
-    ConnectedInteriorTester.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._geometryFactory = new GeometryFactory()
-    this._geomGraph = null
-    this._disconnectedRingcoord = null
-    const geomGraph = arguments[0]
-    this._geomGraph = geomGraph
-  }
-  static findDifferentPoint(coord, pt) {
-    for (let i = 0; i < coord.length; i++) 
-      if (!coord[i].equals(pt)) return coord[i]
-    
-    return null
-  }
-  visitInteriorRing(ring, graph) {
-    if (ring.isEmpty()) return null
-    const pts = ring.getCoordinates()
-    const pt0 = pts[0]
-    const pt1 = ConnectedInteriorTester.findDifferentPoint(pts, pt0)
-    const e = graph.findEdgeInSameDirection(pt0, pt1)
-    const de = graph.findEdgeEnd(e)
-    let intDe = null
-    if (de.getLabel().getLocation(0, Position.RIGHT) === Location.INTERIOR) 
-      intDe = de
-    else if (de.getSym().getLabel().getLocation(0, Position.RIGHT) === Location.INTERIOR) 
-      intDe = de.getSym()
-    
-    Assert.isTrue(intDe !== null, 'unable to find dirEdge with Interior on RHS')
-    this.visitLinkedDirectedEdges(intDe)
-  }
-  visitShellInteriors(g, graph) {
-    if (g instanceof Polygon) {
-      const p = g
-      this.visitInteriorRing(p.getExteriorRing(), graph)
-    }
-    if (g instanceof MultiPolygon) {
-      const mp = g
-      for (let i = 0; i < mp.getNumGeometries(); i++) {
-        const p = mp.getGeometryN(i)
-        this.visitInteriorRing(p.getExteriorRing(), graph)
-      }
-    }
-  }
-  getCoordinate() {
-    return this._disconnectedRingcoord
-  }
-  setInteriorEdgesInResult(graph) {
-    for (let it = graph.getEdgeEnds().iterator(); it.hasNext(); ) {
-      const de = it.next()
-      if (de.getLabel().getLocation(0, Position.RIGHT) === Location.INTERIOR) 
-        de.setInResult(true)
-      
-    }
-  }
-  visitLinkedDirectedEdges(start) {
-    const startDe = start
-    let de = start
-    do {
-      Assert.isTrue(de !== null, 'found null Directed Edge')
-      de.setVisited(true)
-      de = de.getNext()
-    } while (de !== startDe)
-  }
-  buildEdgeRings(dirEdges) {
-    const edgeRings = new ArrayList()
-    for (let it = dirEdges.iterator(); it.hasNext(); ) {
-      const de = it.next()
-      if (de.isInResult() && de.getEdgeRing() === null) {
-        const er = new MaximalEdgeRing(de, this._geometryFactory)
-        er.linkDirectedEdgesForMinimalEdgeRings()
-        const minEdgeRings = er.buildMinimalRings()
-        edgeRings.addAll(minEdgeRings)
-      }
-    }
-    return edgeRings
-  }
-  hasUnvisitedShellEdge(edgeRings) {
-    for (let i = 0; i < edgeRings.size(); i++) {
-      const er = edgeRings.get(i)
-      if (er.isHole()) continue
-      const edges = er.getEdges()
-      let de = edges.get(0)
-      if (de.getLabel().getLocation(0, Position.RIGHT) !== Location.INTERIOR) continue
-      for (let j = 0; j < edges.size(); j++) {
-        de = edges.get(j)
-        if (!de.isVisited()) {
-          this._disconnectedRingcoord = de.getCoordinate()
-          return true
-        }
-      }
-    }
-    return false
-  }
-  isInteriorsConnected() {
-    const splitEdges = new ArrayList()
-    this._geomGraph.computeSplitEdges(splitEdges)
-    const graph = new PlanarGraph(new OverlayNodeFactory())
-    graph.addEdges(splitEdges)
-    this.setInteriorEdgesInResult(graph)
-    graph.linkResultDirectedEdges()
-    const edgeRings = this.buildEdgeRings(graph.getEdgeEnds())
-    this.visitShellInteriors(this._geomGraph.getGeometry(), graph)
-    return !this.hasUnvisitedShellEdge(edgeRings)
-  }
-}

package/node_modules/jsts/org/locationtech/jts/operation/valid/ConsistentAreaTester.js

@@ -1,50 +0,0 @@
-import RelateNodeGraph from '../relate/RelateNodeGraph'
-import RobustLineIntersector from '../../algorithm/RobustLineIntersector'
-export default class ConsistentAreaTester {
-  constructor() {
-    ConsistentAreaTester.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._li = new RobustLineIntersector()
-    this._geomGraph = null
-    this._nodeGraph = new RelateNodeGraph()
-    this._invalidPoint = null
-    const geomGraph = arguments[0]
-    this._geomGraph = geomGraph
-  }
-  isNodeEdgeAreaLabelsConsistent() {
-    for (let nodeIt = this._nodeGraph.getNodeIterator(); nodeIt.hasNext(); ) {
-      const node = nodeIt.next()
-      if (!node.getEdges().isAreaLabelsConsistent(this._geomGraph)) {
-        this._invalidPoint = node.getCoordinate().copy()
-        return false
-      }
-    }
-    return true
-  }
-  getInvalidPoint() {
-    return this._invalidPoint
-  }
-  hasDuplicateRings() {
-    for (let nodeIt = this._nodeGraph.getNodeIterator(); nodeIt.hasNext(); ) {
-      const node = nodeIt.next()
-      for (let i = node.getEdges().iterator(); i.hasNext(); ) {
-        const eeb = i.next()
-        if (eeb.getEdgeEnds().size() > 1) {
-          this._invalidPoint = eeb.getEdge().getCoordinate(0)
-          return true
-        }
-      }
-    }
-    return false
-  }
-  isNodeConsistentArea() {
-    const intersector = this._geomGraph.computeSelfNodes(this._li, true, true)
-    if (intersector.hasProperIntersection()) {
-      this._invalidPoint = intersector.getProperIntersectionPoint()
-      return false
-    }
-    this._nodeGraph.build(this._geomGraph)
-    return this.isNodeEdgeAreaLabelsConsistent()
-  }
-}

package/node_modules/jsts/org/locationtech/jts/operation/valid/IndexedNestedRingTester.js

@@ -1,56 +0,0 @@
-import STRtree from '../../index/strtree/STRtree'
-import IsValidOp from './IsValidOp'
-import PointLocation from '../../algorithm/PointLocation'
-import ArrayList from '../../../../../java/util/ArrayList'
-import Envelope from '../../geom/Envelope'
-export default class IndexedNestedRingTester {
-  constructor() {
-    IndexedNestedRingTester.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._graph = null
-    this._rings = new ArrayList()
-    this._totalEnv = new Envelope()
-    this._index = null
-    this._nestedPt = null
-    const graph = arguments[0]
-    this._graph = graph
-  }
-  buildIndex() {
-    this._index = new STRtree()
-    for (let i = 0; i < this._rings.size(); i++) {
-      const ring = this._rings.get(i)
-      const env = ring.getEnvelopeInternal()
-      this._index.insert(env, ring)
-    }
-  }
-  getNestedPoint() {
-    return this._nestedPt
-  }
-  isNonNested() {
-    this.buildIndex()
-    for (let i = 0; i < this._rings.size(); i++) {
-      const innerRing = this._rings.get(i)
-      const innerRingPts = innerRing.getCoordinates()
-      const results = this._index.query(innerRing.getEnvelopeInternal())
-      for (let j = 0; j < results.size(); j++) {
-        const searchRing = results.get(j)
-        const searchRingPts = searchRing.getCoordinates()
-        if (innerRing === searchRing) continue
-        if (!innerRing.getEnvelopeInternal().intersects(searchRing.getEnvelopeInternal())) continue
-        const innerRingPt = IsValidOp.findPtNotNode(innerRingPts, searchRing, this._graph)
-        if (innerRingPt === null) continue
-        const isInside = PointLocation.isInRing(innerRingPt, searchRingPts)
-        if (isInside) {
-          this._nestedPt = innerRingPt
-          return false
-        }
-      }
-    }
-    return true
-  }
-  add(ring) {
-    this._rings.add(ring)
-    this._totalEnv.expandToInclude(ring.getEnvelopeInternal())
-  }
-}