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

package/node_modules/turf-jsts/src/org/locationtech/jts/operation/overlay/snap/LineStringSnapper.js

@@ -0,0 +1,93 @@
+import LineString from '../../../geom/LineString'
+import CoordinateList from '../../../geom/CoordinateList'
+import Coordinate from '../../../geom/Coordinate'
+import Double from '../../../../../../java/lang/Double'
+import LineSegment from '../../../geom/LineSegment'
+
+export default class LineStringSnapper {
+  constructor () {
+    this._snapTolerance = 0.0
+    this._srcPts = null
+    this._seg = new LineSegment()
+    this._allowSnappingToSourceVertices = false
+    this._isClosed = false
+    if (arguments[0] instanceof LineString && typeof arguments[1] === 'number') {
+      const srcLine = arguments[0]
+      const snapTolerance = arguments[1]
+      LineStringSnapper.call(this, srcLine.getCoordinates(), snapTolerance)
+    } else if (arguments[0] instanceof Array && typeof arguments[1] === 'number') {
+      const srcPts = arguments[0]
+      const snapTolerance = arguments[1]
+      this._srcPts = srcPts
+      this._isClosed = LineStringSnapper.isClosed(srcPts)
+      this._snapTolerance = snapTolerance
+    }
+  }
+  snapVertices (srcCoords, snapPts) {
+    var end = this._isClosed ? srcCoords.size() - 1 : srcCoords.size()
+    for (var i = 0; i < end; i++) {
+      var srcPt = srcCoords.get(i)
+      var snapVert = this.findSnapForVertex(srcPt, snapPts)
+      if (snapVert !== null) {
+        srcCoords.set(i, new Coordinate(snapVert))
+        if (i === 0 && this._isClosed) srcCoords.set(srcCoords.size() - 1, new Coordinate(snapVert))
+      }
+    }
+  }
+  findSnapForVertex (pt, snapPts) {
+    for (var i = 0; i < snapPts.length; i++) {
+      if (pt.equals2D(snapPts[i])) return null
+      if (pt.distance(snapPts[i]) < this._snapTolerance) return snapPts[i]
+    }
+    return null
+  }
+  snapTo (snapPts) {
+    var coordList = new CoordinateList(this._srcPts)
+    this.snapVertices(coordList, snapPts)
+    this.snapSegments(coordList, snapPts)
+    var newPts = coordList.toCoordinateArray()
+    return newPts
+  }
+  snapSegments (srcCoords, snapPts) {
+    if (snapPts.length === 0) return null
+    var distinctPtCount = snapPts.length
+    if (snapPts[0].equals2D(snapPts[snapPts.length - 1])) distinctPtCount = snapPts.length - 1
+    for (var i = 0; i < distinctPtCount; i++) {
+      var snapPt = snapPts[i]
+      var index = this.findSegmentIndexToSnap(snapPt, srcCoords)
+      if (index >= 0) {
+        srcCoords.add(index + 1, new Coordinate(snapPt), false)
+      }
+    }
+  }
+  findSegmentIndexToSnap (snapPt, srcCoords) {
+    var minDist = Double.MAX_VALUE
+    var snapIndex = -1
+    for (var i = 0; i < srcCoords.size() - 1; i++) {
+      this._seg.p0 = srcCoords.get(i)
+      this._seg.p1 = srcCoords.get(i + 1)
+      if (this._seg.p0.equals2D(snapPt) || this._seg.p1.equals2D(snapPt)) {
+        if (this._allowSnappingToSourceVertices) continue; else return -1
+      }
+      var dist = this._seg.distance(snapPt)
+      if (dist < this._snapTolerance && dist < minDist) {
+        minDist = dist
+        snapIndex = i
+      }
+    }
+    return snapIndex
+  }
+  setAllowSnappingToSourceVertices (allowSnappingToSourceVertices) {
+    this._allowSnappingToSourceVertices = allowSnappingToSourceVertices
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return LineStringSnapper
+  }
+  static isClosed (pts) {
+    if (pts.length <= 1) return false
+    return pts[0].equals2D(pts[pts.length - 1])
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/operation/overlay/snap/SnapIfNeededOverlayOp.js

@@ -0,0 +1,57 @@
+import SnapOverlayOp from './SnapOverlayOp'
+import RuntimeException from '../../../../../../java/lang/RuntimeException'
+import OverlayOp from '../OverlayOp'
+
+export default class SnapIfNeededOverlayOp {
+  constructor (g1, g2) {
+    this._geom = new Array(2).fill(null)
+    this._geom[0] = g1
+    this._geom[1] = g2
+  }
+  getResultGeometry (opCode) {
+    var result = null
+    var isSuccess = false
+    var savedException = null
+    try {
+      result = OverlayOp.overlayOp(this._geom[0], this._geom[1], opCode)
+      var isValid = true
+      if (isValid) isSuccess = true
+    } catch (ex) {
+      if (ex instanceof RuntimeException) {
+        savedException = ex
+      } else throw ex
+    } finally {}
+    if (!isSuccess) {
+      try {
+        result = SnapOverlayOp.overlayOp(this._geom[0], this._geom[1], opCode)
+      } catch (ex) {
+        if (ex instanceof RuntimeException) {
+          throw savedException
+        } else throw ex
+      } finally {}
+    }
+    return result
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return SnapIfNeededOverlayOp
+  }
+  static overlayOp (g0, g1, opCode) {
+    var op = new SnapIfNeededOverlayOp(g0, g1)
+    return op.getResultGeometry(opCode)
+  }
+  static union (g0, g1) {
+    return SnapIfNeededOverlayOp.overlayOp(g0, g1, OverlayOp.UNION)
+  }
+  static intersection (g0, g1) {
+    return SnapIfNeededOverlayOp.overlayOp(g0, g1, OverlayOp.INTERSECTION)
+  }
+  static symDifference (g0, g1) {
+    return SnapIfNeededOverlayOp.overlayOp(g0, g1, OverlayOp.SYMDIFFERENCE)
+  }
+  static difference (g0, g1) {
+    return SnapIfNeededOverlayOp.overlayOp(g0, g1, OverlayOp.DIFFERENCE)
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/operation/overlay/snap/SnapOverlayOp.js

@@ -0,0 +1,73 @@
+import GeometrySnapper from './GeometrySnapper'
+import System from '../../../../../../java/lang/System'
+import CommonBitsRemover from '../../../precision/CommonBitsRemover'
+import OverlayOp from '../OverlayOp'
+
+export default class SnapOverlayOp {
+  constructor (g1, g2) {
+    this._geom = new Array(2).fill(null)
+    this._snapTolerance = null
+    this._cbr = null
+    this._geom[0] = g1
+    this._geom[1] = g2
+    this.computeSnapTolerance()
+  }
+  selfSnap (geom) {
+    var snapper0 = new GeometrySnapper(geom)
+    var snapGeom = snapper0.snapTo(geom, this._snapTolerance)
+    return snapGeom
+  }
+  removeCommonBits (geom) {
+    this._cbr = new CommonBitsRemover()
+    this._cbr.add(geom[0])
+    this._cbr.add(geom[1])
+    var remGeom = new Array(2).fill(null)
+    remGeom[0] = this._cbr.removeCommonBits(geom[0].copy())
+    remGeom[1] = this._cbr.removeCommonBits(geom[1].copy())
+    return remGeom
+  }
+  prepareResult (geom) {
+    this._cbr.addCommonBits(geom)
+    return geom
+  }
+  getResultGeometry (opCode) {
+    var prepGeom = this.snap(this._geom)
+    var result = OverlayOp.overlayOp(prepGeom[0], prepGeom[1], opCode)
+    return this.prepareResult(result)
+  }
+  checkValid (g) {
+    if (!g.isValid()) {
+      System.out.println('Snapped geometry is invalid')
+    }
+  }
+  computeSnapTolerance () {
+    this._snapTolerance = GeometrySnapper.computeOverlaySnapTolerance(this._geom[0], this._geom[1])
+  }
+  snap (geom) {
+    var remGeom = this.removeCommonBits(geom)
+    var snapGeom = GeometrySnapper.snap(remGeom[0], remGeom[1], this._snapTolerance)
+    return snapGeom
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return SnapOverlayOp
+  }
+  static overlayOp (g0, g1, opCode) {
+    var op = new SnapOverlayOp(g0, g1)
+    return op.getResultGeometry(opCode)
+  }
+  static union (g0, g1) {
+    return SnapOverlayOp.overlayOp(g0, g1, OverlayOp.UNION)
+  }
+  static intersection (g0, g1) {
+    return SnapOverlayOp.overlayOp(g0, g1, OverlayOp.INTERSECTION)
+  }
+  static symDifference (g0, g1) {
+    return SnapOverlayOp.overlayOp(g0, g1, OverlayOp.SYMDIFFERENCE)
+  }
+  static difference (g0, g1) {
+    return SnapOverlayOp.overlayOp(g0, g1, OverlayOp.DIFFERENCE)
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/operation/overlay/validate/FuzzyPointLocator.js

@@ -0,0 +1,77 @@
+import PointLocator from '../../../algorithm/PointLocator'
+import Location from '../../../geom/Location'
+import GeometryFactory from '../../../geom/GeometryFactory'
+import Polygon from '../../../geom/Polygon'
+import LineSegment from '../../../geom/LineSegment'
+import ArrayList from '../../../../../../java/util/ArrayList'
+import GeometryFilter from '../../../geom/GeometryFilter'
+
+export default class FuzzyPointLocator {
+  constructor () {
+    this._g = null
+    this._boundaryDistanceTolerance = null
+    this._linework = null
+    this._ptLocator = new PointLocator()
+    this._seg = new LineSegment()
+    const g = arguments[0]
+    const boundaryDistanceTolerance = arguments[1]
+    this._g = g
+    this._boundaryDistanceTolerance = boundaryDistanceTolerance
+    this._linework = this.extractLinework(g)
+  }
+  isWithinToleranceOfBoundary (pt) {
+    for (let i = 0; i < this._linework.getNumGeometries(); i++) {
+      const line = this._linework.getGeometryN(i)
+      const seq = line.getCoordinateSequence()
+      for (let j = 0; j < seq.size() - 1; j++) {
+        seq.getCoordinate(j, this._seg.p0)
+        seq.getCoordinate(j + 1, this._seg.p1)
+        const dist = this._seg.distance(pt)
+        if (dist <= this._boundaryDistanceTolerance) return true
+      }
+    }
+    return false
+  }
+  getLocation (pt) {
+    if (this.isWithinToleranceOfBoundary(pt)) return Location.BOUNDARY
+    return this._ptLocator.locate(pt, this._g)
+  }
+  extractLinework (g) {
+    const extracter = new PolygonalLineworkExtracter()
+    g.apply(extracter)
+    const linework = extracter.getLinework()
+    const lines = GeometryFactory.toLineStringArray(linework)
+    return g.getFactory().createMultiLineString(lines)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return FuzzyPointLocator
+  }
+}
+
+class PolygonalLineworkExtracter {
+  constructor () {
+    this._linework = null
+    this._linework = new ArrayList()
+  }
+  getLinework () {
+    return this._linework
+  }
+  filter (g) {
+    if (g instanceof Polygon) {
+      const poly = g
+      this._linework.add(poly.getExteriorRing())
+      for (let i = 0; i < poly.getNumInteriorRing(); i++) {
+        this._linework.add(poly.getInteriorRingN(i))
+      }
+    }
+  }
+  interfaces_ () {
+    return [GeometryFilter]
+  }
+  getClass () {
+    return PolygonalLineworkExtracter
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/operation/overlay/validate/OffsetPointGenerator.js

@@ -0,0 +1,55 @@
+import Coordinate from '../../../geom/Coordinate'
+import ArrayList from '../../../../../../java/util/ArrayList'
+import LinearComponentExtracter from '../../../geom/util/LinearComponentExtracter'
+
+export default class OffsetPointGenerator {
+  constructor () {
+    this._g = null
+    this._doLeft = true
+    this._doRight = true
+    let g = arguments[0]
+    this._g = g
+  }
+  extractPoints (line, offsetDistance, offsetPts) {
+    const pts = line.getCoordinates()
+    for (let i = 0; i < pts.length - 1; i++) {
+      this.computeOffsetPoints(pts[i], pts[i + 1], offsetDistance, offsetPts)
+    }
+  }
+  setSidesToGenerate (doLeft, doRight) {
+    this._doLeft = doLeft
+    this._doRight = doRight
+  }
+  getPoints (offsetDistance) {
+    const offsetPts = new ArrayList()
+    const lines = LinearComponentExtracter.getLines(this._g)
+    for (const i = lines.iterator(); i.hasNext();) {
+      const line = i.next()
+      this.extractPoints(line, offsetDistance, offsetPts)
+    }
+    return offsetPts
+  }
+  computeOffsetPoints (p0, p1, offsetDistance, offsetPts) {
+    const dx = p1.x - p0.x
+    const dy = p1.y - p0.y
+    const len = Math.sqrt(dx * dx + dy * dy)
+    const ux = offsetDistance * dx / len
+    const uy = offsetDistance * dy / len
+    const midX = (p1.x + p0.x) / 2
+    const midY = (p1.y + p0.y) / 2
+    if (this._doLeft) {
+      const offsetLeft = new Coordinate(midX - uy, midY + ux)
+      offsetPts.add(offsetLeft)
+    }
+    if (this._doRight) {
+      const offsetRight = new Coordinate(midX + uy, midY - ux)
+      offsetPts.add(offsetRight)
+    }
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return OffsetPointGenerator
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/operation/overlay/validate/OverlayResultValidator.js

@@ -0,0 +1,88 @@
+import GeometrySnapper from '../snap/GeometrySnapper'
+import Location from '../../../geom/Location'
+import FuzzyPointLocator from './FuzzyPointLocator'
+import OffsetPointGenerator from './OffsetPointGenerator'
+import System from '../../../../../../java/lang/System'
+import ArrayList from '../../../../../../java/util/ArrayList'
+import OverlayOp from '../OverlayOp'
+
+export default class OverlayResultValidator {
+  constructor () {
+    this._geom = null
+    this._locFinder = null
+    this._location = new Array(3).fill(null)
+    this._invalidLocation = null
+    this._boundaryDistanceTolerance = OverlayResultValidator.TOLERANCE
+    this._testCoords = new ArrayList()
+    const a = arguments[0]
+    const b = arguments[1]
+    const result = arguments[2]
+    this._boundaryDistanceTolerance = OverlayResultValidator.computeBoundaryDistanceTolerance(a, b)
+    this._geom = [a, b, result]
+    this._locFinder = [new FuzzyPointLocator(this._geom[0], this._boundaryDistanceTolerance), new FuzzyPointLocator(this._geom[1], this._boundaryDistanceTolerance), new FuzzyPointLocator(this._geom[2], this._boundaryDistanceTolerance)]
+  }
+  reportResult (overlayOp, location, expectedInterior) {
+    System.out.println('Overlay result invalid - A:' + Location.toLocationSymbol(location[0]) + ' B:' + Location.toLocationSymbol(location[1]) + ' expected:' + (expectedInterior ? 'i' : 'e') + ' actual:' + Location.toLocationSymbol(location[2]))
+  }
+  isValid (overlayOp) {
+    this.addTestPts(this._geom[0])
+    this.addTestPts(this._geom[1])
+    var isValid = this.checkValid(overlayOp)
+    return isValid
+  }
+  checkValid () {
+    if (arguments.length === 1) {
+      let overlayOp = arguments[0]
+      for (var i = 0; i < this._testCoords.size(); i++) {
+        var pt = this._testCoords.get(i)
+        if (!this.checkValid(overlayOp, pt)) {
+          this._invalidLocation = pt
+          return false
+        }
+      }
+      return true
+    } else if (arguments.length === 2) {
+      const overlayOp = arguments[0]
+      const pt = arguments[1]
+      this._location[0] = this._locFinder[0].getLocation(pt)
+      this._location[1] = this._locFinder[1].getLocation(pt)
+      this._location[2] = this._locFinder[2].getLocation(pt)
+      if (OverlayResultValidator.hasLocation(this._location, Location.BOUNDARY)) return true
+      return this.isValidResult(overlayOp, this._location)
+    }
+  }
+  addTestPts (g) {
+    var ptGen = new OffsetPointGenerator(g)
+    this._testCoords.addAll(ptGen.getPoints(5 * this._boundaryDistanceTolerance))
+  }
+  isValidResult (overlayOp, location) {
+    var expectedInterior = OverlayOp.isResultOfOp(location[0], location[1], overlayOp)
+    var resultInInterior = location[2] === Location.INTERIOR
+    var isValid = !(expectedInterior ^ resultInInterior)
+    if (!isValid) this.reportResult(overlayOp, location, expectedInterior)
+    return isValid
+  }
+  getInvalidLocation () {
+    return this._invalidLocation
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return OverlayResultValidator
+  }
+  static hasLocation (location, loc) {
+    for (var i = 0; i < 3; i++) {
+      if (location[i] === loc) return true
+    }
+    return false
+  }
+  static computeBoundaryDistanceTolerance (g0, g1) {
+    return Math.min(GeometrySnapper.computeSizeBasedSnapTolerance(g0), GeometrySnapper.computeSizeBasedSnapTolerance(g1))
+  }
+  static isValid (a, b, overlayOp, result) {
+    var validator = new OverlayResultValidator(a, b, result)
+    return validator.isValid(overlayOp)
+  }
+  static get TOLERANCE () { return 0.000001 }
+}

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

@@ -0,0 +1,21 @@
+// operation.overlay
+export { default as ConsistentPolygonRingChecker } from './overlay/ConsistentPolygonRingChecker'
+export { default as EdgeSetNoder } from './overlay/EdgeSetNoder'
+export { default as LineBuilder } from './overlay/LineBuilder'
+export { default as MaximalEdgeRing } from './overlay/MaximalEdgeRing'
+export { default as MinimalEdgeRing } from './overlay/MinimalEdgeRing'
+export { default as OverlayNodeFactory } from './overlay/OverlayNodeFactory'
+export { default as OverlayOp } from './overlay/OverlayOp'
+export { default as PointBuilder } from './overlay/PointBuilder'
+export { default as PolygonBuilder } from './overlay/PolygonBuilder'
+
+// operation.overlay.snap
+export { default as GeometrySnapper } from './overlay/snap/GeometrySnapper'
+export { default as LineStringSnapper } from './overlay/snap/LineStringSnapper'
+export { default as SnapIfNeededOverlayOp } from './overlay/snap/SnapIfNeededOverlayOp'
+export { default as SnapOverlayOp } from './overlay/snap/SnapOverlayOp'
+
+// operation.overlay.validate
+export { default as FuzzyPointLocator } from './overlay/validate/FuzzyPointLocator'
+export { default as OffsetPointGenerator } from './overlay/validate/OffsetPointGenerator'
+export { default as OverlayResultValidator } from './overlay/validate/OverlayResultValidator'

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

@@ -0,0 +1,232 @@
+import CGAlgorithms from '../../algorithm/CGAlgorithms'
+import CoordinateList from '../../geom/CoordinateList'
+import WKTWriter from '../../io/WKTWriter'
+import CoordinateArraySequence from '../../geom/impl/CoordinateArraySequence'
+import IsValidOp from '../valid/IsValidOp'
+import LinearRing from '../../geom/LinearRing'
+import Exception from '../../../../../java/lang/Exception'
+import System from '../../../../../java/lang/System'
+import CoordinateArrays from '../../geom/CoordinateArrays'
+import ArrayList from '../../../../../java/util/ArrayList'
+import Comparator from '../../../../../java/util/Comparator'
+import Assert from '../../util/Assert'
+
+export default class EdgeRing {
+  constructor () {
+    this._factory = null
+    this._deList = new ArrayList()
+    this._lowestEdge = null
+    this._ring = null
+    this._ringPts = null
+    this._holes = null
+    this._shell = null
+    this._isHole = null
+    this._isProcessed = false
+    this._isIncludedSet = false
+    this._isIncluded = false
+    let factory = arguments[0]
+    this._factory = factory
+  }
+  isIncluded () {
+    return this._isIncluded
+  }
+  getCoordinates () {
+    if (this._ringPts === null) {
+      const coordList = new CoordinateList()
+      for (let i = this._deList.iterator(); i.hasNext();) {
+        const de = i.next()
+        const edge = de.getEdge()
+        EdgeRing.addEdge(edge.getLine().getCoordinates(), de.getEdgeDirection(), coordList)
+      }
+      this._ringPts = coordList.toCoordinateArray()
+    }
+    return this._ringPts
+  }
+  isIncludedSet () {
+    return this._isIncludedSet
+  }
+  isValid () {
+    this.getCoordinates()
+    if (this._ringPts.length <= 3) return false
+    this.getRing()
+    return IsValidOp.isValid(this._ring)
+  }
+  build (startDE) {
+    let de = startDE
+    do {
+      this.add(de)
+      de.setRing(this)
+      de = de.getNext()
+      Assert.isTrue(de !== null, 'found null DE in ring')
+      Assert.isTrue(de === startDE || !de.isInRing(), 'found DE already in ring')
+    } while (de !== startDE)
+  }
+  isOuterHole () {
+    if (!this._isHole) return false
+    return !this.hasShell()
+  }
+  getPolygon () {
+    let holeLR = null
+    if (this._holes !== null) {
+      holeLR = new Array(this._holes.size()).fill(null)
+      for (let i = 0; i < this._holes.size(); i++) {
+        holeLR[i] = this._holes.get(i)
+      }
+    }
+    const poly = this._factory.createPolygon(this._ring, holeLR)
+    return poly
+  }
+  isHole () {
+    return this._isHole
+  }
+  isProcessed () {
+    return this._isProcessed
+  }
+  addHole () {
+    if (arguments[0] instanceof LinearRing) {
+      let hole = arguments[0]
+      if (this._holes === null) this._holes = new ArrayList()
+      this._holes.add(hole)
+    } else if (arguments[0] instanceof EdgeRing) {
+      let holeER = arguments[0]
+      holeER.setShell(this)
+      const hole = holeER.getRing()
+      if (this._holes === null) this._holes = new ArrayList()
+      this._holes.add(hole)
+    }
+  }
+  setIncluded (isIncluded) {
+    this._isIncluded = isIncluded
+    this._isIncludedSet = true
+  }
+  getOuterHole () {
+    if (this.isHole()) return null
+    for (let i = 0; i < this._deList.size(); i++) {
+      const de = this._deList.get(i)
+      const adjRing = de.getSym().getRing()
+      if (adjRing.isOuterHole()) return adjRing
+    }
+    return null
+  }
+  computeHole () {
+    const ring = this.getRing()
+    this._isHole = CGAlgorithms.isCCW(ring.getCoordinates())
+  }
+  hasShell () {
+    return this._shell !== null
+  }
+  isOuterShell () {
+    return this.getOuterHole() !== null
+  }
+  getLineString () {
+    this.getCoordinates()
+    return this._factory.createLineString(this._ringPts)
+  }
+  toString () {
+    return WKTWriter.toLineString(new CoordinateArraySequence(this.getCoordinates()))
+  }
+  getShell () {
+    if (this.isHole()) return this._shell
+    return this
+  }
+  add (de) {
+    this._deList.add(de)
+  }
+  getRing () {
+    if (this._ring !== null) return this._ring
+    this.getCoordinates()
+    if (this._ringPts.length < 3) System.out.println(this._ringPts)
+    try {
+      this._ring = this._factory.createLinearRing(this._ringPts)
+    } catch (ex) {
+      if (ex instanceof Exception) {
+        System.out.println(this._ringPts)
+      } else throw ex
+    } finally {}
+    return this._ring
+  }
+  updateIncluded () {
+    if (this.isHole()) return null
+    for (let i = 0; i < this._deList.size(); i++) {
+      const de = this._deList.get(i)
+      const adjShell = de.getSym().getRing().getShell()
+      if (adjShell !== null && adjShell.isIncludedSet()) {
+        this.setIncluded(!adjShell.isIncluded())
+        return null
+      }
+    }
+  }
+  setShell (shell) {
+    this._shell = shell
+  }
+  setProcessed (isProcessed) {
+    this._isProcessed = isProcessed
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return EdgeRing
+  }
+  static findDirEdgesInRing (startDE) {
+    let de = startDE
+    const edges = new ArrayList()
+    do {
+      edges.add(de)
+      de = de.getNext()
+      Assert.isTrue(de !== null, 'found null DE in ring')
+      Assert.isTrue(de === startDE || !de.isInRing(), 'found DE already in ring')
+    } while (de !== startDE)
+    return edges
+  }
+  static addEdge (coords, isForward, coordList) {
+    if (isForward) {
+      for (let i = 0; i < coords.length; i++) {
+        coordList.add(coords[i], false)
+      }
+    } else {
+      for (let i = coords.length - 1; i >= 0; i--) {
+        coordList.add(coords[i], false)
+      }
+    }
+  }
+  static findEdgeRingContaining (testEr, shellList) {
+    const testRing = testEr.getRing()
+    const testEnv = testRing.getEnvelopeInternal()
+    let testPt = testRing.getCoordinateN(0)
+    let minShell = null
+    let minShellEnv = null
+    for (const it = shellList.iterator(); it.hasNext();) {
+      const tryShell = it.next()
+      const tryShellRing = tryShell.getRing()
+      const tryShellEnv = tryShellRing.getEnvelopeInternal()
+      if (tryShellEnv.equals(testEnv)) continue
+      if (!tryShellEnv.contains(testEnv)) continue
+      testPt = CoordinateArrays.ptNotInList(testRing.getCoordinates(), tryShellRing.getCoordinates())
+      let isContained = false
+      if (CGAlgorithms.isPointInRing(testPt, tryShellRing.getCoordinates())) isContained = true
+      if (isContained) {
+        if (minShell === null || minShellEnv.contains(tryShellEnv)) {
+          minShell = tryShell
+          minShellEnv = minShell.getRing().getEnvelopeInternal()
+        }
+      }
+    }
+    return minShell
+  }
+  static EnvelopeComparator () { return EnvelopeComparator }
+}
+
+class EnvelopeComparator {
+  compare (obj0, obj1) {
+    const r0 = obj0
+    const r1 = obj1
+    return r0.getRing().getEnvelope().compareTo(r1.getRing().getEnvelope())
+  }
+  interfaces_ () {
+    return [Comparator]
+  }
+  getClass () {
+    return EnvelopeComparator
+  }
+}