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

package/node_modules/turf-jsts/src/org/locationtech/jts/geomgraph/NodeFactory.js

@@ -0,0 +1,13 @@
+import Node from './Node'
+
+export default class NodeFactory {
+  createNode (coord) {
+    return new Node(coord, null)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return NodeFactory
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/geomgraph/NodeMap.js

@@ -0,0 +1,68 @@
+import Location from '../geom/Location'
+import Coordinate from '../geom/Coordinate'
+import Node from './Node'
+import ArrayList from '../../../../java/util/ArrayList'
+import TreeMap from '../../../../java/util/TreeMap'
+
+export default class NodeMap {
+  constructor () {
+    this.nodeMap = new TreeMap()
+    this.nodeFact = null
+    const nodeFact = arguments[0]
+    this.nodeFact = nodeFact
+  }
+  find (coord) {
+    return this.nodeMap.get(coord)
+  }
+  addNode () {
+    if (arguments[0] instanceof Coordinate) {
+      const coord = arguments[0]
+      let node = this.nodeMap.get(coord)
+      if (node === null) {
+        node = this.nodeFact.createNode(coord)
+        this.nodeMap.put(coord, node)
+      }
+      return node
+    } else if (arguments[0] instanceof Node) {
+      const n = arguments[0]
+      const node = this.nodeMap.get(n.getCoordinate())
+      if (node === null) {
+        this.nodeMap.put(n.getCoordinate(), n)
+        return n
+      }
+      node.mergeLabel(n)
+      return node
+    }
+  }
+  print (out) {
+    for (const it = this.iterator(); it.hasNext();) {
+      const n = it.next()
+      n.print(out)
+    }
+  }
+  iterator () {
+    return this.nodeMap.values().iterator()
+  }
+  values () {
+    return this.nodeMap.values()
+  }
+  getBoundaryNodes (geomIndex) {
+    const bdyNodes = new ArrayList()
+    for (const i = this.iterator(); i.hasNext();) {
+      const node = i.next()
+      if (node.getLabel().getLocation(geomIndex) === Location.BOUNDARY) bdyNodes.add(node)
+    }
+    return bdyNodes
+  }
+  add (e) {
+    const p = e.getCoordinate()
+    const n = this.addNode(p)
+    n.add(e)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return NodeMap
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/geomgraph/PlanarGraph.js

@@ -0,0 +1,142 @@
+import Location from '../geom/Location'
+import CGAlgorithms from '../algorithm/CGAlgorithms'
+import Coordinate from '../geom/Coordinate'
+import Node from './Node'
+import NodeMap from './NodeMap'
+import DirectedEdge from './DirectedEdge'
+import System from '../../../../java/lang/System'
+import ArrayList from '../../../../java/util/ArrayList'
+import Quadrant from './Quadrant'
+import NodeFactory from './NodeFactory'
+
+export default class PlanarGraph {
+  constructor () {
+    this._edges = new ArrayList()
+    this._nodes = null
+    this._edgeEndList = new ArrayList()
+    if (arguments.length === 0) {
+      this._nodes = new NodeMap(new NodeFactory())
+    } else if (arguments.length === 1) {
+      const nodeFact = arguments[0]
+      this._nodes = new NodeMap(nodeFact)
+    }
+  }
+  printEdges (out) {
+    out.println('Edges:')
+    for (let i = 0; i < this._edges.size(); i++) {
+      out.println('edge ' + i + ':')
+      const e = this._edges.get(i)
+      e.print(out)
+      e.eiList.print(out)
+    }
+  }
+  find (coord) {
+    return this._nodes.find(coord)
+  }
+  addNode () {
+    if (arguments[0] instanceof Node) {
+      const node = arguments[0]
+      return this._nodes.addNode(node)
+    } else if (arguments[0] instanceof Coordinate) {
+      const coord = arguments[0]
+      return this._nodes.addNode(coord)
+    }
+  }
+  getNodeIterator () {
+    return this._nodes.iterator()
+  }
+  linkResultDirectedEdges () {
+    for (const nodeit = this._nodes.iterator(); nodeit.hasNext();) {
+      const node = nodeit.next()
+      node.getEdges().linkResultDirectedEdges()
+    }
+  }
+  debugPrintln (o) {
+    System.out.println(o)
+  }
+  isBoundaryNode (geomIndex, coord) {
+    const node = this._nodes.find(coord)
+    if (node === null) return false
+    const label = node.getLabel()
+    if (label !== null && label.getLocation(geomIndex) === Location.BOUNDARY) return true
+    return false
+  }
+  linkAllDirectedEdges () {
+    for (const nodeit = this._nodes.iterator(); nodeit.hasNext();) {
+      const node = nodeit.next()
+      node.getEdges().linkAllDirectedEdges()
+    }
+  }
+  matchInSameDirection (p0, p1, ep0, ep1) {
+    if (!p0.equals(ep0)) return false
+    if (CGAlgorithms.computeOrientation(p0, p1, ep1) === CGAlgorithms.COLLINEAR && Quadrant.quadrant(p0, p1) === Quadrant.quadrant(ep0, ep1)) return true
+    return false
+  }
+  getEdgeEnds () {
+    return this._edgeEndList
+  }
+  debugPrint (o) {
+    System.out.print(o)
+  }
+  getEdgeIterator () {
+    return this._edges.iterator()
+  }
+  findEdgeInSameDirection (p0, p1) {
+    for (let i = 0; i < this._edges.size(); i++) {
+      const e = this._edges.get(i)
+      const eCoord = e.getCoordinates()
+      if (this.matchInSameDirection(p0, p1, eCoord[0], eCoord[1])) return e
+      if (this.matchInSameDirection(p0, p1, eCoord[eCoord.length - 1], eCoord[eCoord.length - 2])) return e
+    }
+    return null
+  }
+  insertEdge (e) {
+    this._edges.add(e)
+  }
+  findEdgeEnd (e) {
+    for (let i = this.getEdgeEnds().iterator(); i.hasNext();) {
+      const ee = i.next()
+      if (ee.getEdge() === e) return ee
+    }
+    return null
+  }
+  addEdges (edgesToAdd) {
+    for (const it = edgesToAdd.iterator(); it.hasNext();) {
+      const e = it.next()
+      this._edges.add(e)
+      const de1 = new DirectedEdge(e, true)
+      const de2 = new DirectedEdge(e, false)
+      de1.setSym(de2)
+      de2.setSym(de1)
+      this.add(de1)
+      this.add(de2)
+    }
+  }
+  add (e) {
+    this._nodes.add(e)
+    this._edgeEndList.add(e)
+  }
+  getNodes () {
+    return this._nodes.values()
+  }
+  findEdge (p0, p1) {
+    for (let i = 0; i < this._edges.size(); i++) {
+      const e = this._edges.get(i)
+      const eCoord = e.getCoordinates()
+      if (p0.equals(eCoord[0]) && p1.equals(eCoord[1])) return e
+    }
+    return null
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return PlanarGraph
+  }
+  static linkResultDirectedEdges (nodes) {
+    for (const nodeit = nodes.iterator(); nodeit.hasNext();) {
+      const node = nodeit.next()
+      node.getEdges().linkResultDirectedEdges()
+    }
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/geomgraph/Position.js

@@ -0,0 +1,16 @@
+export default class Position {
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return Position
+  }
+  static opposite (position) {
+    if (position === Position.LEFT) return Position.RIGHT
+    if (position === Position.RIGHT) return Position.LEFT
+    return position
+  }
+  static get ON () { return 0 }
+  static get LEFT () { return 1 }
+  static get RIGHT () { return 2 }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/geomgraph/Quadrant.js

@@ -0,0 +1,60 @@
+import Coordinate from '../geom/Coordinate'
+import IllegalArgumentException from '../../../../java/lang/IllegalArgumentException'
+
+export default class Quadrant {
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return Quadrant
+  }
+  static isNorthern (quad) {
+    return quad === Quadrant.NE || quad === Quadrant.NW
+  }
+  static isOpposite (quad1, quad2) {
+    if (quad1 === quad2) return false
+    const diff = (quad1 - quad2 + 4) % 4
+    if (diff === 2) return true
+    return false
+  }
+  static commonHalfPlane (quad1, quad2) {
+    if (quad1 === quad2) return quad1
+    const diff = (quad1 - quad2 + 4) % 4
+    if (diff === 2) return -1
+    const min = quad1 < quad2 ? quad1 : quad2
+    const max = quad1 > quad2 ? quad1 : quad2
+    if (min === 0 && max === 3) return 3
+    return min
+  }
+  static isInHalfPlane (quad, halfPlane) {
+    if (halfPlane === Quadrant.SE) {
+      return quad === Quadrant.SE || quad === Quadrant.SW
+    }
+    return quad === halfPlane || quad === halfPlane + 1
+  }
+  static quadrant () {
+    if (typeof arguments[0] === 'number' && typeof arguments[1] === 'number') {
+      const dx = arguments[0]
+      const dy = arguments[1]
+      if (dx === 0.0 && dy === 0.0) throw new IllegalArgumentException('Cannot compute the quadrant for point ( ' + dx + ', ' + dy + ' )')
+      if (dx >= 0.0) {
+        if (dy >= 0.0) return Quadrant.NE; else return Quadrant.SE
+      } else {
+        if (dy >= 0.0) return Quadrant.NW; else return Quadrant.SW
+      }
+    } else if (arguments[0] instanceof Coordinate && arguments[1] instanceof Coordinate) {
+      const p0 = arguments[0]
+      const p1 = arguments[1]
+      if (p1.x === p0.x && p1.y === p0.y) throw new IllegalArgumentException('Cannot compute the quadrant for two identical points ' + p0)
+      if (p1.x >= p0.x) {
+        if (p1.y >= p0.y) return Quadrant.NE; else return Quadrant.SE
+      } else {
+        if (p1.y >= p0.y) return Quadrant.NW; else return Quadrant.SW
+      }
+    }
+  }
+  static get NE () { return 0 }
+  static get NW () { return 1 }
+  static get SW () { return 2 }
+  static get SE () { return 3 }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/geomgraph/TopologyLocation.js

@@ -0,0 +1,129 @@
+import StringBuffer from '../../../../java/lang/StringBuffer'
+import Location from '../geom/Location'
+import Position from './Position'
+
+export default class TopologyLocation {
+  constructor () {
+    this.location = null
+    if (arguments.length === 1) {
+      if (arguments[0] instanceof Array) {
+        const location = arguments[0]
+        this.init(location.length)
+      } else if (Number.isInteger(arguments[0])) {
+        const on = arguments[0]
+        this.init(1)
+        this.location[Position.ON] = on
+      } else if (arguments[0] instanceof TopologyLocation) {
+        const gl = arguments[0]
+        this.init(gl.location.length)
+        if (gl !== null) {
+          for (let i = 0; i < this.location.length; i++) {
+            this.location[i] = gl.location[i]
+          }
+        }
+      }
+    } else if (arguments.length === 3) {
+      const on = arguments[0]
+      const left = arguments[1]
+      const right = arguments[2]
+      this.init(3)
+      this.location[Position.ON] = on
+      this.location[Position.LEFT] = left
+      this.location[Position.RIGHT] = right
+    }
+  }
+  setAllLocations (locValue) {
+    for (let i = 0; i < this.location.length; i++) {
+      this.location[i] = locValue
+    }
+  }
+  isNull () {
+    for (let i = 0; i < this.location.length; i++) {
+      if (this.location[i] !== Location.NONE) return false
+    }
+    return true
+  }
+  setAllLocationsIfNull (locValue) {
+    for (let i = 0; i < this.location.length; i++) {
+      if (this.location[i] === Location.NONE) this.location[i] = locValue
+    }
+  }
+  isLine () {
+    return this.location.length === 1
+  }
+  merge (gl) {
+    if (gl.location.length > this.location.length) {
+      const newLoc = new Array(3).fill(null)
+      newLoc[Position.ON] = this.location[Position.ON]
+      newLoc[Position.LEFT] = Location.NONE
+      newLoc[Position.RIGHT] = Location.NONE
+      this.location = newLoc
+    }
+    for (let i = 0; i < this.location.length; i++) {
+      if (this.location[i] === Location.NONE && i < gl.location.length) this.location[i] = gl.location[i]
+    }
+  }
+  getLocations () {
+    return this.location
+  }
+  flip () {
+    if (this.location.length <= 1) return null
+    const temp = this.location[Position.LEFT]
+    this.location[Position.LEFT] = this.location[Position.RIGHT]
+    this.location[Position.RIGHT] = temp
+  }
+  toString () {
+    const buf = new StringBuffer()
+    if (this.location.length > 1) buf.append(Location.toLocationSymbol(this.location[Position.LEFT]))
+    buf.append(Location.toLocationSymbol(this.location[Position.ON]))
+    if (this.location.length > 1) buf.append(Location.toLocationSymbol(this.location[Position.RIGHT]))
+    return buf.toString()
+  }
+  setLocations (on, left, right) {
+    this.location[Position.ON] = on
+    this.location[Position.LEFT] = left
+    this.location[Position.RIGHT] = right
+  }
+  get (posIndex) {
+    if (posIndex < this.location.length) return this.location[posIndex]
+    return Location.NONE
+  }
+  isArea () {
+    return this.location.length > 1
+  }
+  isAnyNull () {
+    for (let i = 0; i < this.location.length; i++) {
+      if (this.location[i] === Location.NONE) return true
+    }
+    return false
+  }
+  setLocation () {
+    if (arguments.length === 1) {
+      const locValue = arguments[0]
+      this.setLocation(Position.ON, locValue)
+    } else if (arguments.length === 2) {
+      const locIndex = arguments[0]
+      const locValue = arguments[1]
+      this.location[locIndex] = locValue
+    }
+  }
+  init (size) {
+    this.location = new Array(size).fill(null)
+    this.setAllLocations(Location.NONE)
+  }
+  isEqualOnSide (le, locIndex) {
+    return this.location[locIndex] === le.location[locIndex]
+  }
+  allPositionsEqual (loc) {
+    for (let i = 0; i < this.location.length; i++) {
+      if (this.location[i] !== loc) return false
+    }
+    return true
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return TopologyLocation
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/geomgraph/index/EdgeSetIntersector.js

@@ -0,0 +1,8 @@
+export default class EdgeSetIntersector {
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return EdgeSetIntersector
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/geomgraph/index/MonotoneChain.js

@@ -0,0 +1,19 @@
+export default class MonotoneChain {
+  constructor () {
+    this.mce = null
+    this.chainIndex = null
+    const mce = arguments[0]
+    const chainIndex = arguments[1]
+    this.mce = mce
+    this.chainIndex = chainIndex
+  }
+  computeIntersections (mc, si) {
+    this.mce.computeIntersectsForChain(this.chainIndex, mc.mce, mc.chainIndex, si)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return MonotoneChain
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/geomgraph/index/MonotoneChainEdge.js

@@ -0,0 +1,83 @@
+import MonotoneChainIndexer from './MonotoneChainIndexer'
+import Envelope from '../../geom/Envelope'
+
+export default class MonotoneChainEdge {
+  constructor () {
+    this.e = null
+    this.pts = null
+    this.startIndex = null
+    this.env1 = new Envelope()
+    this.env2 = new Envelope()
+    const e = arguments[0]
+    this.e = e
+    this.pts = e.getCoordinates()
+    const mcb = new MonotoneChainIndexer()
+    this.startIndex = mcb.getChainStartIndices(this.pts)
+  }
+  getCoordinates () {
+    return this.pts
+  }
+  getMaxX (chainIndex) {
+    const x1 = this.pts[this.startIndex[chainIndex]].x
+    const x2 = this.pts[this.startIndex[chainIndex + 1]].x
+    return x1 > x2 ? x1 : x2
+  }
+  getMinX (chainIndex) {
+    const x1 = this.pts[this.startIndex[chainIndex]].x
+    const x2 = this.pts[this.startIndex[chainIndex + 1]].x
+    return x1 < x2 ? x1 : x2
+  }
+  computeIntersectsForChain () {
+    if (arguments.length === 4) {
+      const chainIndex0 = arguments[0]
+      const mce = arguments[1]
+      const chainIndex1 = arguments[2]
+      const si = arguments[3]
+      this.computeIntersectsForChain(this.startIndex[chainIndex0], this.startIndex[chainIndex0 + 1], mce, mce.startIndex[chainIndex1], mce.startIndex[chainIndex1 + 1], si)
+    } else if (arguments.length === 6) {
+      const start0 = arguments[0]
+      const end0 = arguments[1]
+      const mce = arguments[2]
+      const start1 = arguments[3]
+      const end1 = arguments[4]
+      const ei = arguments[5]
+      const p00 = this.pts[start0]
+      const p01 = this.pts[end0]
+      const p10 = mce.pts[start1]
+      const p11 = mce.pts[end1]
+      if (end0 - start0 === 1 && end1 - start1 === 1) {
+        ei.addIntersections(this.e, start0, mce.e, start1)
+        return null
+      }
+      this.env1.init(p00, p01)
+      this.env2.init(p10, p11)
+      if (!this.env1.intersects(this.env2)) return null
+      const mid0 = Math.trunc((start0 + end0) / 2)
+      const mid1 = Math.trunc((start1 + end1) / 2)
+      if (start0 < mid0) {
+        if (start1 < mid1) this.computeIntersectsForChain(start0, mid0, mce, start1, mid1, ei)
+        if (mid1 < end1) this.computeIntersectsForChain(start0, mid0, mce, mid1, end1, ei)
+      }
+      if (mid0 < end0) {
+        if (start1 < mid1) this.computeIntersectsForChain(mid0, end0, mce, start1, mid1, ei)
+        if (mid1 < end1) this.computeIntersectsForChain(mid0, end0, mce, mid1, end1, ei)
+      }
+    }
+  }
+  getStartIndexes () {
+    return this.startIndex
+  }
+  computeIntersects (mce, si) {
+    for (let i = 0; i < this.startIndex.length - 1; i++) {
+      for (let j = 0; j < mce.startIndex.length - 1; j++) {
+        this.computeIntersectsForChain(i, mce, j, si)
+      }
+    }
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return MonotoneChainEdge
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/geomgraph/index/MonotoneChainIndexer.js

@@ -0,0 +1,41 @@
+import Integer from '../../../../../java/lang/Integer'
+import ArrayList from '../../../../../java/util/ArrayList'
+import Quadrant from '../Quadrant'
+
+export default class MonotoneChainIndexer {
+  getChainStartIndices (pts) {
+    let start = 0
+    const startIndexList = new ArrayList()
+    startIndexList.add(new Integer(start))
+    do {
+      const last = this.findChainEnd(pts, start)
+      startIndexList.add(new Integer(last))
+      start = last
+    } while (start < pts.length - 1)
+    const startIndex = MonotoneChainIndexer.toIntArray(startIndexList)
+    return startIndex
+  }
+  findChainEnd (pts, start) {
+    const chainQuad = Quadrant.quadrant(pts[start], pts[start + 1])
+    let last = start + 1
+    while (last < pts.length) {
+      const quad = Quadrant.quadrant(pts[last - 1], pts[last])
+      if (quad !== chainQuad) break
+      last++
+    }
+    return last - 1
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return MonotoneChainIndexer
+  }
+  static toIntArray (list) {
+    const array = new Array(list.size()).fill(null)
+    for (let i = 0; i < array.length; i++) {
+      array[i] = list.get(i).intValue()
+    }
+    return array
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/geomgraph/index/SegmentIntersector.js

@@ -0,0 +1,115 @@
+export default class SegmentIntersector {
+  constructor () {
+    this._hasIntersection = false
+    this._hasProper = false
+    this._hasProperInterior = false
+    this._properIntersectionPoint = null
+    this._li = null
+    this._includeProper = null
+    this._recordIsolated = null
+    this._isSelfIntersection = null
+    this._numIntersections = 0
+    this.numTests = 0
+    this._bdyNodes = null
+    this._isDone = false
+    this._isDoneWhenProperInt = false
+    const li = arguments[0]
+    const includeProper = arguments[1]
+    const recordIsolated = arguments[2]
+    this._li = li
+    this._includeProper = includeProper
+    this._recordIsolated = recordIsolated
+  }
+  isTrivialIntersection (e0, segIndex0, e1, segIndex1) {
+    if (e0 === e1) {
+      if (this._li.getIntersectionNum() === 1) {
+        if (SegmentIntersector.isAdjacentSegments(segIndex0, segIndex1)) return true
+        if (e0.isClosed()) {
+          var maxSegIndex = e0.getNumPoints() - 1
+          if ((segIndex0 === 0 && segIndex1 === maxSegIndex) ||
+              (segIndex1 === 0 && segIndex0 === maxSegIndex)) {
+            return true
+          }
+        }
+      }
+    }
+    return false
+  }
+  getProperIntersectionPoint () {
+    return this._properIntersectionPoint
+  }
+  setIsDoneIfProperInt (isDoneWhenProperInt) {
+    this._isDoneWhenProperInt = isDoneWhenProperInt
+  }
+  hasProperInteriorIntersection () {
+    return this._hasProperInterior
+  }
+  isBoundaryPointInternal (li, bdyNodes) {
+    for (var i = bdyNodes.iterator(); i.hasNext();) {
+      var node = i.next()
+      var pt = node.getCoordinate()
+      if (li.isIntersection(pt)) return true
+    }
+    return false
+  }
+  hasProperIntersection () {
+    return this._hasProper
+  }
+  hasIntersection () {
+    return this._hasIntersection
+  }
+  isDone () {
+    return this._isDone
+  }
+  isBoundaryPoint (li, bdyNodes) {
+    if (bdyNodes === null) return false
+    if (this.isBoundaryPointInternal(li, bdyNodes[0])) return true
+    if (this.isBoundaryPointInternal(li, bdyNodes[1])) return true
+    return false
+  }
+  setBoundaryNodes (bdyNodes0, bdyNodes1) {
+    this._bdyNodes = new Array(2).fill(null)
+    this._bdyNodes[0] = bdyNodes0
+    this._bdyNodes[1] = bdyNodes1
+  }
+  addIntersections (e0, segIndex0, e1, segIndex1) {
+    if (e0 === e1 && segIndex0 === segIndex1) return null
+    this.numTests++
+    var p00 = e0.getCoordinates()[segIndex0]
+    var p01 = e0.getCoordinates()[segIndex0 + 1]
+    var p10 = e1.getCoordinates()[segIndex1]
+    var p11 = e1.getCoordinates()[segIndex1 + 1]
+    this._li.computeIntersection(p00, p01, p10, p11)
+    if (this._li.hasIntersection()) {
+      if (this._recordIsolated) {
+        e0.setIsolated(false)
+        e1.setIsolated(false)
+      }
+      this._numIntersections++
+      if (!this.isTrivialIntersection(e0, segIndex0, e1, segIndex1)) {
+        this._hasIntersection = true
+        if (this._includeProper || !this._li.isProper()) {
+          e0.addIntersections(this._li, segIndex0, 0)
+          e1.addIntersections(this._li, segIndex1, 1)
+        }
+        if (this._li.isProper()) {
+          this._properIntersectionPoint = this._li.getIntersection(0).copy()
+          this._hasProper = true
+          if (this._isDoneWhenProperInt) {
+            this._isDone = true
+          }
+          if (!this.isBoundaryPoint(this._li, this._bdyNodes)) this._hasProperInterior = true
+        }
+      }
+    }
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return SegmentIntersector
+  }
+  static isAdjacentSegments (i1, i2) {
+    return Math.abs(i1 - i2) === 1
+  }
+}