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

package/node_modules/turf-jsts/src/org/locationtech/jts/operation/relate/RelateOp.js

@@ -0,0 +1,109 @@
+import Geometry from '../../geom/Geometry'
+import hasInterface from '../../../../../hasInterface'
+import RelateComputer from './RelateComputer'
+import BoundaryNodeRule from '../../algorithm/BoundaryNodeRule'
+import { GeometryGraphOp } from '../geometrygraph'
+import RectangleContains from '../predicate/RectangleContains'
+import RectangleIntersects from '../predicate/RectangleIntersects'
+
+export default class RelateOp extends GeometryGraphOp {
+  constructor () {
+    if (arguments.length === 2) {
+      const g0 = arguments[0]
+      const g1 = arguments[1]
+      super(g0, g1)
+      this._relate = new RelateComputer(this._arg)
+    } else if (arguments.length === 3) {
+      const g0 = arguments[0]
+      const g1 = arguments[1]
+      const boundaryNodeRule = arguments[2]
+      super(g0, g1, boundaryNodeRule)
+      this._relate = new RelateComputer(this._arg)
+    } else {
+      super()
+      this._relate = null
+    }
+  }
+  getIntersectionMatrix () {
+    return this._relate.computeIM()
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return RelateOp
+  }
+  static covers (g1, g2) {
+    if (!g1.getEnvelopeInternal().covers(g2.getEnvelopeInternal())) return false
+    if (g1.isRectangle()) {
+      return true
+    }
+    return RelateOp.relate(g1, g2).isCovers()
+  }
+  static intersects (g1, g2) {
+    if (!g1.getEnvelopeInternal().intersects(g2.getEnvelopeInternal())) return false
+    if (g1.isRectangle()) {
+      return RectangleIntersects.intersects(g1, g2)
+    }
+    if (g2.isRectangle()) {
+      return RectangleIntersects.intersects(g2, g1)
+    }
+    return RelateOp.relate(g1, g2).isIntersects()
+  }
+  static touches (g1, g2) {
+    if (!g1.getEnvelopeInternal().intersects(g2.getEnvelopeInternal())) return false
+    return RelateOp.relate(g1, g2).isTouches(g1.getDimension(), g2.getDimension())
+  }
+  static within (g1, g2) {
+    return g2.contains(g1)
+  }
+  static coveredBy (g1, g2) {
+    return RelateOp.covers(g2, g1)
+  }
+  static relate () {
+    if (arguments.length === 2) {
+      const a = arguments[0]
+      const b = arguments[1]
+      const relOp = new RelateOp(a, b)
+      const im = relOp.getIntersectionMatrix()
+      return im
+    } else if (arguments.length === 3) {
+      if (typeof arguments[2] === 'string' && (arguments[0] instanceof Geometry && arguments[1] instanceof Geometry)) {
+        const g1 = arguments[0]
+        const g2 = arguments[1]
+        const intersectionPattern = arguments[2]
+        return RelateOp.relateWithCheck(g1, g2).matches(intersectionPattern)
+      } else if (hasInterface(arguments[2], BoundaryNodeRule) && (arguments[0] instanceof Geometry && arguments[1] instanceof Geometry)) {
+        const a = arguments[0]
+        const b = arguments[1]
+        const boundaryNodeRule = arguments[2]
+        const relOp = new RelateOp(a, b, boundaryNodeRule)
+        const im = relOp.getIntersectionMatrix()
+        return im
+      }
+    }
+  }
+  static overlaps (g1, g2) {
+    if (!g1.getEnvelopeInternal().intersects(g2.getEnvelopeInternal())) return false
+    return RelateOp.relate(g1, g2).isOverlaps(g1.getDimension(), g2.getDimension())
+  }
+  static disjoint (g1, g2) {
+    return !g1.intersects(g2)
+  }
+  static relateWithCheck (g1, g2) {
+    g1.checkNotGeometryCollection(g1)
+    g1.checkNotGeometryCollection(g2)
+    return RelateOp.relate(g1, g2)
+  }
+  static crosses (g1, g2) {
+    if (!g1.getEnvelopeInternal().intersects(g2.getEnvelopeInternal())) return false
+    return RelateOp.relate(g1, g2).isCrosses(g1.getDimension(), g2.getDimension())
+  }
+  static contains (g1, g2) {
+    if (!g1.getEnvelopeInternal().contains(g2.getEnvelopeInternal())) return false
+    if (g1.isRectangle()) {
+      return RectangleContains.contains(g1, g2)
+    }
+    return RelateOp.relate(g1, g2).isContains()
+  }
+}

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

@@ -0,0 +1,9 @@
+// operation.relate
+export { default as EdgeEndBuilder } from './relate/EdgeEndBuilder'
+export { default as EdgeEndBundle } from './relate/EdgeEndBundle'
+export { default as EdgeEndBundleStar } from './relate/EdgeEndBundleStar'
+export { default as RelateComputer } from './relate/RelateComputer'
+export { default as RelateNode } from './relate/RelateNode'
+export { default as RelateNodeFactory } from './relate/RelateNodeFactory'
+export { default as RelateNodeGraph } from './relate/RelateNodeGraph'
+export { default as RelateOp } from './relate/RelateOp'

package/node_modules/turf-jsts/src/org/locationtech/jts/operation/union/CascadedPolygonUnion.js

@@ -0,0 +1,157 @@
+import PolygonExtracter from '../../geom/util/PolygonExtracter'
+import STRtree from '../../index/strtree/STRtree'
+import Geometry from '../../geom/Geometry'
+import hasInterface from '../../../../../hasInterface'
+import GeometryFactory from '../../geom/GeometryFactory'
+import GeometryCombiner from '../../geom/util/GeometryCombiner'
+import Polygonal from '../../geom/Polygonal'
+import ArrayList from '../../../../../java/util/ArrayList'
+import List from '../../../../../java/util/List'
+
+export default class CascadedPolygonUnion {
+  constructor () {
+    this._inputPolys = null
+    this._geomFactory = null
+    const polys = arguments[0]
+    this._inputPolys = polys
+    if (this._inputPolys === null) this._inputPolys = new ArrayList()
+  }
+  reduceToGeometries (geomTree) {
+    const geoms = new ArrayList()
+    for (let i = geomTree.iterator(); i.hasNext();) {
+      const o = i.next()
+      let geom = null
+      if (hasInterface(o, List)) {
+        geom = this.unionTree(o)
+      } else if (o instanceof Geometry) {
+        geom = o
+      }
+      geoms.add(geom)
+    }
+    return geoms
+  }
+  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 disjointGeoms.add(elem)
+    }
+    return this._geomFactory.buildGeometry(intersectingGeoms)
+  }
+  unionOptimized (g0, g1) {
+    const g0Env = g0.getEnvelopeInternal()
+    const g1Env = g1.getEnvelopeInternal()
+    if (!g0Env.intersects(g1Env)) {
+      const combo = GeometryCombiner.combine(g0, g1)
+      return combo
+    }
+    if (g0.getNumGeometries() <= 1 && g1.getNumGeometries() <= 1) return this.unionActual(g0, g1)
+    const commonEnv = g0Env.intersection(g1Env)
+    return this.unionUsingEnvelopeIntersection(g0, g1, commonEnv)
+  }
+  union () {
+    if (this._inputPolys === null) throw new Error('union() method cannot be called twice')
+    if (this._inputPolys.isEmpty()) return null
+    this._geomFactory = this._inputPolys.iterator().next().getFactory()
+    const index = new STRtree(CascadedPolygonUnion.STRTREE_NODE_CAPACITY)
+    for (let i = this._inputPolys.iterator(); i.hasNext();) {
+      const item = i.next()
+      index.insert(item.getEnvelopeInternal(), item)
+    }
+    this._inputPolys = null
+    const itemTree = index.itemsTree()
+    const unionAll = this.unionTree(itemTree)
+    return unionAll
+  }
+  binaryUnion () {
+    if (arguments.length === 1) {
+      const geoms = arguments[0]
+      return this.binaryUnion(geoms, 0, geoms.size())
+    } else if (arguments.length === 3) {
+      const geoms = arguments[0]
+      const start = arguments[1]
+      const end = arguments[2]
+      if (end - start <= 1) {
+        const g0 = CascadedPolygonUnion.getGeometry(geoms, start)
+        return this.unionSafe(g0, null)
+      } else if (end - start === 2) {
+        return this.unionSafe(CascadedPolygonUnion.getGeometry(geoms, start), CascadedPolygonUnion.getGeometry(geoms, start + 1))
+      } else {
+        const mid = Math.trunc((end + start) / 2)
+        const g0 = this.binaryUnion(geoms, start, mid)
+        const g1 = this.binaryUnion(geoms, mid, end)
+        return this.unionSafe(g0, g1)
+      }
+    }
+  }
+  repeatedUnion (geoms) {
+    let union = null
+    for (let i = geoms.iterator(); i.hasNext();) {
+      const g = i.next()
+      if (union === null) union = g.copy(); else union = union.union(g)
+    }
+    return union
+  }
+  unionSafe (g0, g1) {
+    if (g0 === null && g1 === null) return null
+    if (g0 === null) return g1.copy()
+    if (g1 === null) return g0.copy()
+    return this.unionOptimized(g0, g1)
+  }
+  unionActual (g0, g1) {
+    return CascadedPolygonUnion.restrictToPolygons(g0.union(g1))
+  }
+  unionTree (geomTree) {
+    const geoms = this.reduceToGeometries(geomTree)
+    const union = this.binaryUnion(geoms)
+    return union
+  }
+  unionUsingEnvelopeIntersection (g0, g1, common) {
+    const disjointPolys = new ArrayList()
+    const g0Int = this.extractByEnvelope(common, g0, disjointPolys)
+    const g1Int = this.extractByEnvelope(common, g1, disjointPolys)
+    const union = this.unionActual(g0Int, g1Int)
+    disjointPolys.add(union)
+    const overallUnion = GeometryCombiner.combine(disjointPolys)
+    return overallUnion
+  }
+  bufferUnion () {
+    if (arguments.length === 1) {
+      const geoms = arguments[0]
+      const factory = geoms.get(0).getFactory()
+      const gColl = factory.buildGeometry(geoms)
+      const unionAll = gColl.buffer(0.0)
+      return unionAll
+    } else if (arguments.length === 2) {
+      const g0 = arguments[0]
+      const g1 = arguments[1]
+      const factory = g0.getFactory()
+      const gColl = factory.createGeometryCollection([g0, g1])
+      const unionAll = gColl.buffer(0.0)
+      return unionAll
+    }
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return CascadedPolygonUnion
+  }
+  static restrictToPolygons (g) {
+    if (hasInterface(g, Polygonal)) {
+      return g
+    }
+    const polygons = PolygonExtracter.getPolygons(g)
+    if (polygons.size() === 1) return polygons.get(0)
+    return g.getFactory().createMultiPolygon(GeometryFactory.toPolygonArray(polygons))
+  }
+  static getGeometry (list, index) {
+    if (index >= list.size()) return null
+    return list.get(index)
+  }
+  static union (polys) {
+    const op = new CascadedPolygonUnion(polys)
+    return op.union()
+  }
+  static get STRTREE_NODE_CAPACITY () { return 4 }
+}

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

@@ -0,0 +1,47 @@
+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 () {
+    this._pointGeom = null
+    this._otherGeom = null
+    this._geomFact = null
+    const pointGeom = arguments[0]
+    const otherGeom = arguments[1]
+    this._pointGeom = pointGeom
+    this._otherGeom = otherGeom
+    this._geomFact = otherGeom.getFactory()
+  }
+  union () {
+    var locater = new PointLocator()
+    var exteriorCoords = new TreeSet()
+    for (var i = 0; i < this._pointGeom.getNumGeometries(); i++) {
+      var point = this._pointGeom.getGeometryN(i)
+      var coord = point.getCoordinate()
+      var loc = locater.locate(coord, this._otherGeom)
+      if (loc === Location.EXTERIOR) exteriorCoords.add(coord)
+    }
+    if (exteriorCoords.size() === 0) return this._otherGeom
+    var ptComp = null
+    var 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)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return PointGeometryUnion
+  }
+  static union (pointGeom, otherGeom) {
+    var unioner = new PointGeometryUnion(pointGeom, otherGeom)
+    return unioner.union()
+  }
+}

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

@@ -0,0 +1,105 @@
+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 ArrayList from '../../../../../java/util/ArrayList'
+import GeometryExtracter from '../../geom/util/GeometryExtracter'
+import OverlayOp from '../overlay/OverlayOp'
+import CascadedPolygonUnion from './CascadedPolygonUnion'
+
+export default class UnaryUnionOp {
+  constructor () {
+    this._polygons = new ArrayList()
+    this._lines = new ArrayList()
+    this._points = new ArrayList()
+    this._geomFact = 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]
+      const geomFact = arguments[1]
+      this._geomFact = geomFact
+      this.extract(geoms)
+    }
+  }
+  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]
+      for (const i = geoms.iterator(); i.hasNext();) {
+        const geom = i.next()
+        this.extract(geom)
+      }
+    } else if (arguments[0] instanceof Geometry) {
+      const geom = arguments[0]
+      if (this._geomFact === null) this._geomFact = geom.getFactory()
+      GeometryExtracter.extract(geom, Geometry.SORTINDEX_POLYGON, this._polygons)
+      GeometryExtracter.extract(geom, Geometry.SORTINDEX_LINESTRING, this._lines)
+      GeometryExtracter.extract(geom, Geometry.SORTINDEX_POINT, this._points)
+    }
+  }
+  union () {
+    if (this._geomFact === null) {
+      return null
+    }
+    let unionPoints = null
+    if (this._points.size() > 0) {
+      const ptGeom = this._geomFact.buildGeometry(this._points)
+      unionPoints = this.unionNoOpt(ptGeom)
+    }
+    let unionLines = null
+    if (this._lines.size() > 0) {
+      const lineGeom = this._geomFact.buildGeometry(this._lines)
+      unionLines = this.unionNoOpt(lineGeom)
+    }
+    let unionPolygons = null
+    if (this._polygons.size() > 0) {
+      unionPolygons = CascadedPolygonUnion.union(this._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
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return UnaryUnionOp
+  }
+  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]
+      const geomFact = arguments[1]
+      const op = new UnaryUnionOp(geoms, geomFact)
+      return op.union()
+    }
+  }
+}

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

@@ -0,0 +1,75 @@
+import GeometryCombiner from '../../geom/util/GeometryCombiner'
+import System from '../../../../../java/lang/System'
+import ArrayList from '../../../../../java/util/ArrayList'
+
+export default class UnionInteracting {
+  constructor () {
+    this._geomFactory = null
+    this._g0 = null
+    this._g1 = null
+    this._interacts0 = null
+    this._interacts1 = null
+    const g0 = arguments[0]
+    const 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)
+  }
+  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) {
+      let 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
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return UnionInteracting
+  }
+  static union (g0, g1) {
+    const uue = new UnionInteracting(g0, g1)
+    return uue.union()
+  }
+}

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

@@ -0,0 +1,21 @@
+import SnapIfNeededOverlayOp from '../overlay/snap/SnapIfNeededOverlayOp'
+import OverlayOp from '../overlay/OverlayOp'
+
+export default class UnionOp {
+  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/turf-jsts/src/org/locationtech/jts/operation/union.js

@@ -0,0 +1,6 @@
+// operation.union
+export { default as CascadedPolygonUnion } from './union/CascadedPolygonUnion'
+export { default as PointGeometryUnion } from './union/PointGeometryUnion'
+export { default as UnaryUnionOp } from './union/UnaryUnionOp'
+export { default as UnionInteracting } from './union/UnionInteracting'
+export { default as UnionOp } from './union/UnionOp'

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

@@ -0,0 +1,121 @@
+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 () {
+    this._geometryFactory = new GeometryFactory()
+    this._geomGraph = null
+    this._disconnectedRingcoord = null
+    let geomGraph = arguments[0]
+    this._geomGraph = geomGraph
+  }
+  visitInteriorRing (ring, graph) {
+    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 (const 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 (const 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)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return ConnectedInteriorTester
+  }
+  static findDifferentPoint (coord, pt) {
+    for (let i = 0; i < coord.length; i++) {
+      if (!coord[i].equals(pt)) return coord[i]
+    }
+    return null
+  }
+}