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

package/node_modules/jsts/org/locationtech/jts/precision/GeometryPrecisionReducer.js

@@ -1,80 +0,0 @@
-import hasInterface from '../../../../hasInterface'
-import GeometryFactory from '../geom/GeometryFactory'
-import IsValidOp from '../operation/valid/IsValidOp'
-import GeometryEditor from '../geom/util/GeometryEditor'
-import BufferOp from '../operation/buffer/BufferOp'
-import Polygonal from '../geom/Polygonal'
-import PrecisionReducerCoordinateOperation from './PrecisionReducerCoordinateOperation'
-export default class GeometryPrecisionReducer {
-  constructor() {
-    GeometryPrecisionReducer.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._targetPM = null
-    this._removeCollapsed = true
-    this._changePrecisionModel = false
-    this._isPointwise = false
-    const pm = arguments[0]
-    this._targetPM = pm
-  }
-  static reduce(g, precModel) {
-    const reducer = new GeometryPrecisionReducer(precModel)
-    return reducer.reduce(g)
-  }
-  static reducePointwise(g, precModel) {
-    const reducer = new GeometryPrecisionReducer(precModel)
-    reducer.setPointwise(true)
-    return reducer.reduce(g)
-  }
-  fixPolygonalTopology(geom) {
-    let geomToBuffer = geom
-    if (!this._changePrecisionModel) 
-      geomToBuffer = this.changePM(geom, this._targetPM)
-    
-    const bufGeom = BufferOp.bufferOp(geomToBuffer, 0)
-    return bufGeom
-  }
-  reducePointwise(geom) {
-    let geomEdit = null
-    if (this._changePrecisionModel) {
-      const newFactory = this.createFactory(geom.getFactory(), this._targetPM)
-      geomEdit = new GeometryEditor(newFactory)
-    } else {
-      geomEdit = new GeometryEditor()
-    }
-    let finalRemoveCollapsed = this._removeCollapsed
-    if (geom.getDimension() >= 2) finalRemoveCollapsed = true
-    const reduceGeom = geomEdit.edit(geom, new PrecisionReducerCoordinateOperation(this._targetPM, finalRemoveCollapsed))
-    return reduceGeom
-  }
-  changePM(geom, newPM) {
-    const geomEditor = this.createEditor(geom.getFactory(), newPM)
-    return geomEditor.edit(geom, new GeometryEditor.NoOpGeometryOperation())
-  }
-  setRemoveCollapsedComponents(removeCollapsed) {
-    this._removeCollapsed = removeCollapsed
-  }
-  createFactory(inputFactory, pm) {
-    const newFactory = new GeometryFactory(pm, inputFactory.getSRID(), inputFactory.getCoordinateSequenceFactory())
-    return newFactory
-  }
-  setChangePrecisionModel(changePrecisionModel) {
-    this._changePrecisionModel = changePrecisionModel
-  }
-  reduce(geom) {
-    const reducePW = this.reducePointwise(geom)
-    if (this._isPointwise) return reducePW
-    if (!hasInterface(reducePW, Polygonal)) return reducePW
-    if (IsValidOp.isValid(reducePW)) return reducePW
-    return this.fixPolygonalTopology(reducePW)
-  }
-  setPointwise(isPointwise) {
-    this._isPointwise = isPointwise
-  }
-  createEditor(geomFactory, newPM) {
-    if (geomFactory.getPrecisionModel() === newPM) return new GeometryEditor()
-    const newFactory = this.createFactory(geomFactory, newPM)
-    const geomEdit = new GeometryEditor(newFactory)
-    return geomEdit
-  }
-}

package/node_modules/jsts/org/locationtech/jts/precision/MinimumClearance.js

@@ -1,125 +0,0 @@
-import ItemBoundable from '../index/strtree/ItemBoundable'
-import FacetSequence from '../operation/distance/FacetSequence'
-import Coordinate from '../geom/Coordinate'
-import Double from '../../../../java/lang/Double'
-import LineSegment from '../geom/LineSegment'
-import FacetSequenceTreeBuilder from '../operation/distance/FacetSequenceTreeBuilder'
-import Distance from '../algorithm/Distance'
-import ItemDistance from '../index/strtree/ItemDistance'
-export default class MinimumClearance {
-  constructor() {
-    MinimumClearance.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._inputGeom = null
-    this._minClearance = null
-    this._minClearancePts = null
-    const geom = arguments[0]
-    this._inputGeom = geom
-  }
-  static getLine(g) {
-    const rp = new MinimumClearance(g)
-    return rp.getLine()
-  }
-  static getDistance(g) {
-    const rp = new MinimumClearance(g)
-    return rp.getDistance()
-  }
-  getLine() {
-    this.compute()
-    if (this._minClearancePts === null || this._minClearancePts[0] === null) return this._inputGeom.getFactory().createLineString()
-    return this._inputGeom.getFactory().createLineString(this._minClearancePts)
-  }
-  compute() {
-    if (this._minClearancePts !== null) return null
-    this._minClearancePts = new Array(2).fill(null)
-    this._minClearance = Double.MAX_VALUE
-    if (this._inputGeom.isEmpty()) 
-      return null
-    
-    const geomTree = FacetSequenceTreeBuilder.build(this._inputGeom)
-    const nearest = geomTree.nearestNeighbour(new MinClearanceDistance())
-    const mcd = new MinClearanceDistance()
-    this._minClearance = mcd.distance(nearest[0], nearest[1])
-    this._minClearancePts = mcd.getCoordinates()
-  }
-  getDistance() {
-    this.compute()
-    return this._minClearance
-  }
-}
-class MinClearanceDistance {
-  constructor() {
-    MinClearanceDistance.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._minDist = Double.MAX_VALUE
-    this._minPts = new Array(2).fill(null)
-  }
-  vertexDistance(fs1, fs2) {
-    for (let i1 = 0; i1 < fs1.size(); i1++) 
-      for (let i2 = 0; i2 < fs2.size(); i2++) {
-        const p1 = fs1.getCoordinate(i1)
-        const p2 = fs2.getCoordinate(i2)
-        if (!p1.equals2D(p2)) {
-          const d = p1.distance(p2)
-          if (d < this._minDist) {
-            this._minDist = d
-            this._minPts[0] = p1
-            this._minPts[1] = p2
-            if (d === 0.0) return d
-          }
-        }
-      }
-    
-    return this._minDist
-  }
-  getCoordinates() {
-    return this._minPts
-  }
-  segmentDistance(fs1, fs2) {
-    for (let i1 = 0; i1 < fs1.size(); i1++) 
-      for (let i2 = 1; i2 < fs2.size(); i2++) {
-        const p = fs1.getCoordinate(i1)
-        const seg0 = fs2.getCoordinate(i2 - 1)
-        const seg1 = fs2.getCoordinate(i2)
-        if (!(p.equals2D(seg0) || p.equals2D(seg1))) {
-          const d = Distance.pointToSegment(p, seg0, seg1)
-          if (d < this._minDist) {
-            this._minDist = d
-            this.updatePts(p, seg0, seg1)
-            if (d === 0.0) return d
-          }
-        }
-      }
-    
-    return this._minDist
-  }
-  distance() {
-    if (arguments[0] instanceof ItemBoundable && arguments[1] instanceof ItemBoundable) {
-      const b1 = arguments[0], b2 = arguments[1]
-      const fs1 = b1.getItem()
-      const fs2 = b2.getItem()
-      this._minDist = Double.MAX_VALUE
-      return this.distance(fs1, fs2)
-    } else if (arguments[0] instanceof FacetSequence && arguments[1] instanceof FacetSequence) {
-      const fs1 = arguments[0], fs2 = arguments[1]
-      this.vertexDistance(fs1, fs2)
-      if (fs1.size() === 1 && fs2.size() === 1) return this._minDist
-      if (this._minDist <= 0.0) return this._minDist
-      this.segmentDistance(fs1, fs2)
-      if (this._minDist <= 0.0) return this._minDist
-      this.segmentDistance(fs2, fs1)
-      return this._minDist
-    }
-  }
-  updatePts(p, seg0, seg1) {
-    this._minPts[0] = p
-    const seg = new LineSegment(seg0, seg1)
-    this._minPts[1] = new Coordinate(seg.closestPoint(p))
-  }
-  get interfaces_() {
-    return [ItemDistance]
-  }
-}
-MinimumClearance.MinClearanceDistance = MinClearanceDistance

package/node_modules/jsts/org/locationtech/jts/precision/PrecisionReducerCoordinateOperation.js

@@ -1,44 +0,0 @@
-import LineString from '../geom/LineString'
-import CoordinateList from '../geom/CoordinateList'
-import Geometry from '../geom/Geometry'
-import Coordinate from '../geom/Coordinate'
-import GeometryEditor from '../geom/util/GeometryEditor'
-import LinearRing from '../geom/LinearRing'
-export default class PrecisionReducerCoordinateOperation extends GeometryEditor.CoordinateOperation {
-  constructor() {
-    super()
-    PrecisionReducerCoordinateOperation.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._targetPM = null
-    this._removeCollapsed = true
-    const targetPM = arguments[0], removeCollapsed = arguments[1]
-    this._targetPM = targetPM
-    this._removeCollapsed = removeCollapsed
-  }
-  edit() {
-    if (arguments.length === 2 && (arguments[1] instanceof Geometry && arguments[0] instanceof Array)) {
-      const coordinates = arguments[0], geom = arguments[1]
-      if (coordinates.length === 0) return null
-      const reducedCoords = new Array(coordinates.length).fill(null)
-      for (let i = 0; i < coordinates.length; i++) {
-        const coord = new Coordinate(coordinates[i])
-        this._targetPM.makePrecise(coord)
-        reducedCoords[i] = coord
-      }
-      const noRepeatedCoordList = new CoordinateList(reducedCoords, false)
-      const noRepeatedCoords = noRepeatedCoordList.toCoordinateArray()
-      let minLength = 0
-      if (geom instanceof LineString) minLength = 2
-      if (geom instanceof LinearRing) minLength = 4
-      let collapsedCoords = reducedCoords
-      if (this._removeCollapsed) collapsedCoords = null
-      if (noRepeatedCoords.length < minLength) 
-        return collapsedCoords
-      
-      return noRepeatedCoords
-    } else {
-      return super.edit.apply(this, arguments)
-    }
-  }
-}

package/node_modules/jsts/org/locationtech/jts/precision/SimpleMinimumClearance.js

@@ -1,114 +0,0 @@
-import CoordinateFilter from '../geom/CoordinateFilter'
-import Coordinate from '../geom/Coordinate'
-import Double from '../../../../java/lang/Double'
-import LineSegment from '../geom/LineSegment'
-import CoordinateSequenceFilter from '../geom/CoordinateSequenceFilter'
-import Distance from '../algorithm/Distance'
-export default class SimpleMinimumClearance {
-  constructor() {
-    SimpleMinimumClearance.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._inputGeom = null
-    this._minClearance = null
-    this._minClearancePts = null
-    const geom = arguments[0]
-    this._inputGeom = geom
-  }
-  static getLine(g) {
-    const rp = new SimpleMinimumClearance(g)
-    return rp.getLine()
-  }
-  static getDistance(g) {
-    const rp = new SimpleMinimumClearance(g)
-    return rp.getDistance()
-  }
-  getLine() {
-    this.compute()
-    return this._inputGeom.getFactory().createLineString(this._minClearancePts)
-  }
-  updateClearance() {
-    if (arguments.length === 3) {
-      const candidateValue = arguments[0], p0 = arguments[1], p1 = arguments[2]
-      if (candidateValue < this._minClearance) {
-        this._minClearance = candidateValue
-        this._minClearancePts[0] = new Coordinate(p0)
-        this._minClearancePts[1] = new Coordinate(p1)
-      }
-    } else if (arguments.length === 4) {
-      const candidateValue = arguments[0], p = arguments[1], seg0 = arguments[2], seg1 = arguments[3]
-      if (candidateValue < this._minClearance) {
-        this._minClearance = candidateValue
-        this._minClearancePts[0] = new Coordinate(p)
-        const seg = new LineSegment(seg0, seg1)
-        this._minClearancePts[1] = new Coordinate(seg.closestPoint(p))
-      }
-    }
-  }
-  compute() {
-    if (this._minClearancePts !== null) return null
-    this._minClearancePts = new Array(2).fill(null)
-    this._minClearance = Double.MAX_VALUE
-    this._inputGeom.apply(new VertexCoordinateFilter(this))
-  }
-  getDistance() {
-    this.compute()
-    return this._minClearance
-  }
-}
-class VertexCoordinateFilter {
-  constructor() {
-    VertexCoordinateFilter.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this.smc = null
-    const smc = arguments[0]
-    this.smc = smc
-  }
-  filter(coord) {
-    this.smc._inputGeom.apply(new ComputeMCCoordinateSequenceFilter(this.smc, coord))
-  }
-  get interfaces_() {
-    return [CoordinateFilter]
-  }
-}
-class ComputeMCCoordinateSequenceFilter {
-  constructor() {
-    ComputeMCCoordinateSequenceFilter.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this.smc = null
-    this._queryPt = null
-    const smc = arguments[0], queryPt = arguments[1]
-    this.smc = smc
-    this._queryPt = queryPt
-  }
-  isGeometryChanged() {
-    return false
-  }
-  checkVertexDistance(vertex) {
-    const vertexDist = vertex.distance(this._queryPt)
-    if (vertexDist > 0) 
-      this.smc.updateClearance(vertexDist, this._queryPt, vertex)
-    
-  }
-  filter(seq, i) {
-    this.checkVertexDistance(seq.getCoordinate(i))
-    if (i > 0) 
-      this.checkSegmentDistance(seq.getCoordinate(i - 1), seq.getCoordinate(i))
-    
-  }
-  checkSegmentDistance(seg0, seg1) {
-    if (this._queryPt.equals2D(seg0) || this._queryPt.equals2D(seg1)) return null
-    const segDist = Distance.pointToSegment(this._queryPt, seg1, seg0)
-    if (segDist > 0) this.smc.updateClearance(segDist, this._queryPt, seg1, seg0)
-  }
-  isDone() {
-    return false
-  }
-  get interfaces_() {
-    return [CoordinateSequenceFilter]
-  }
-}
-SimpleMinimumClearance.VertexCoordinateFilter = VertexCoordinateFilter
-SimpleMinimumClearance.ComputeMCCoordinateSequenceFilter = ComputeMCCoordinateSequenceFilter

package/node_modules/jsts/org/locationtech/jts/precision.js

@@ -1,17 +0,0 @@
-import CommonBits from './precision/CommonBits'
-import CommonBitsOp from './precision/CommonBitsOp'
-import CommonBitsRemover from './precision/CommonBitsRemover'
-import EnhancedPrecisionOp from './precision/EnhancedPrecisionOp'
-import GeometryPrecisionReducer from './precision/GeometryPrecisionReducer'
-import MinimumClearance from './precision/MinimumClearance'
-import SimpleMinimumClearance from './precision/SimpleMinimumClearance'
-
-export {
-  CommonBits,
-  CommonBitsOp,
-  CommonBitsRemover,
-  EnhancedPrecisionOp,
-  GeometryPrecisionReducer,
-  MinimumClearance,
-  SimpleMinimumClearance
-}

package/node_modules/jsts/org/locationtech/jts/shape/GeometricShapeBuilder.js

@@ -1,50 +0,0 @@
-import Coordinate from '../geom/Coordinate'
-import LineSegment from '../geom/LineSegment'
-import Envelope from '../geom/Envelope'
-export default class GeometricShapeBuilder {
-  constructor() {
-    GeometricShapeBuilder.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._extent = new Envelope(0, 1, 0, 1)
-    this._numPts = 0
-    this._geomFactory = null
-    const geomFactory = arguments[0]
-    this._geomFactory = geomFactory
-  }
-  setNumPoints(numPts) {
-    this._numPts = numPts
-  }
-  getRadius() {
-    return this.getDiameter() / 2
-  }
-  getDiameter() {
-    return Math.min(this._extent.getHeight(), this._extent.getWidth())
-  }
-  getSquareBaseLine() {
-    const radius = this.getRadius()
-    const centre = this.getCentre()
-    const p0 = new Coordinate(centre.x - radius, centre.y - radius)
-    const p1 = new Coordinate(centre.x + radius, centre.y - radius)
-    return new LineSegment(p0, p1)
-  }
-  setExtent(extent) {
-    this._extent = extent
-  }
-  getCentre() {
-    return this._extent.centre()
-  }
-  getExtent() {
-    return this._extent
-  }
-  getSquareExtent() {
-    const radius = this.getRadius()
-    const centre = this.getCentre()
-    return new Envelope(centre.x - radius, centre.x + radius, centre.y - radius, centre.y + radius)
-  }
-  createCoord(x, y) {
-    const pt = new Coordinate(x, y)
-    this._geomFactory.getPrecisionModel().makePrecise(pt)
-    return pt
-  }
-}

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

@@ -1,109 +0,0 @@
-import Coordinate from '../../geom/Coordinate'
-import IllegalArgumentException from '../../../../../java/lang/IllegalArgumentException'
-export default class HilbertCode {
-  static deinterleave(x) {
-    x = x & 0x55555555
-    x = (x | x >> 1) & 0x33333333
-    x = (x | x >> 2) & 0x0F0F0F0F
-    x = (x | x >> 4) & 0x00FF00FF
-    x = (x | x >> 8) & 0x0000FFFF
-    return x
-  }
-  static encode(level, x, y) {
-    const lvl = HilbertCode.levelClamp(level)
-    x = x << 16 - lvl
-    y = y << 16 - lvl
-    let a = x ^ y
-    let b = 0xFFFF ^ a
-    let c = 0xFFFF ^ (x | y)
-    let d = x & (y ^ 0xFFFF)
-    let A = a | b >> 1
-    let B = a >> 1 ^ a
-    let C = c >> 1 ^ b & d >> 1 ^ c
-    let D = a & c >> 1 ^ d >> 1 ^ d
-    a = A
-    b = B
-    c = C
-    d = D
-    A = a & a >> 2 ^ b & b >> 2
-    B = a & b >> 2 ^ b & (a ^ b) >> 2
-    C ^= a & c >> 2 ^ b & d >> 2
-    D ^= b & c >> 2 ^ (a ^ b) & d >> 2
-    a = A
-    b = B
-    c = C
-    d = D
-    A = a & a >> 4 ^ b & b >> 4
-    B = a & b >> 4 ^ b & (a ^ b) >> 4
-    C ^= a & c >> 4 ^ b & d >> 4
-    D ^= b & c >> 4 ^ (a ^ b) & d >> 4
-    a = A
-    b = B
-    c = C
-    d = D
-    C ^= a & c >> 8 ^ b & d >> 8
-    D ^= b & c >> 8 ^ (a ^ b) & d >> 8
-    a = C ^ C >> 1
-    b = D ^ D >> 1
-    let i0 = x ^ y
-    let i1 = b | 0xFFFF ^ (i0 | a)
-    i0 = (i0 | i0 << 8) & 0x00FF00FF
-    i0 = (i0 | i0 << 4) & 0x0F0F0F0F
-    i0 = (i0 | i0 << 2) & 0x33333333
-    i0 = (i0 | i0 << 1) & 0x55555555
-    i1 = (i1 | i1 << 8) & 0x00FF00FF
-    i1 = (i1 | i1 << 4) & 0x0F0F0F0F
-    i1 = (i1 | i1 << 2) & 0x33333333
-    i1 = (i1 | i1 << 1) & 0x55555555
-    const index = (i1 << 1 | i0) >> 32 - 2 * lvl
-    return Math.trunc(index)
-  }
-  static checkLevel(level) {
-    if (level > HilbertCode.MAX_LEVEL) 
-      throw new IllegalArgumentException('Level must be in range 0 to ' + HilbertCode.MAX_LEVEL)
-    
-  }
-  static size(level) {
-    HilbertCode.checkLevel(level)
-    return Math.trunc(Math.pow(2, 2 * level))
-  }
-  static maxOrdinate(level) {
-    HilbertCode.checkLevel(level)
-    return Math.trunc(Math.pow(2, level)) - 1
-  }
-  static prefixScan(x) {
-    x = x >> 8 ^ x
-    x = x >> 4 ^ x
-    x = x >> 2 ^ x
-    x = x >> 1 ^ x
-    return x
-  }
-  static decode(level, index) {
-    HilbertCode.checkLevel(level)
-    const lvl = HilbertCode.levelClamp(level)
-    index = index << 32 - 2 * lvl
-    const i0 = HilbertCode.deinterleave(index)
-    const i1 = HilbertCode.deinterleave(index >> 1)
-    const t0 = (i0 | i1) ^ 0xFFFF
-    const t1 = i0 & i1
-    const prefixT0 = HilbertCode.prefixScan(t0)
-    const prefixT1 = HilbertCode.prefixScan(t1)
-    const a = (i0 ^ 0xFFFF) & prefixT1 | i0 & prefixT0
-    const x = (a ^ i1) >> 16 - lvl
-    const y = (a ^ i0 ^ i1) >> 16 - lvl
-    return new Coordinate(x, y)
-  }
-  static levelClamp(level) {
-    let lvl = level < 1 ? 1 : level
-    lvl = lvl > HilbertCode.MAX_LEVEL ? HilbertCode.MAX_LEVEL : lvl
-    return lvl
-  }
-  static level(numPoints) {
-    const pow2 = Math.trunc(Math.log(numPoints) / Math.log(2))
-    let level = Math.trunc(pow2 / 2)
-    const size = HilbertCode.size(level)
-    if (size < numPoints) level += 1
-    return level
-  }
-}
-HilbertCode.MAX_LEVEL = 16

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

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

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

@@ -1,65 +0,0 @@
-import CoordinateList from '../../geom/CoordinateList'
-import Coordinate from '../../geom/Coordinate'
-import Vector2D from '../../math/Vector2D'
-import GeometricShapeBuilder from '../GeometricShapeBuilder'
-export default class KochSnowflakeBuilder extends GeometricShapeBuilder {
-  constructor() {
-    super()
-    KochSnowflakeBuilder.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._coordList = new CoordinateList()
-    const geomFactory = arguments[0]
-    GeometricShapeBuilder.constructor_.call(this, geomFactory)
-  }
-  static recursionLevelForSize(numPts) {
-    const pow4 = Math.trunc(numPts / 3)
-    const exp = Math.log(pow4) / Math.log(4)
-    return Math.trunc(exp)
-  }
-  getBoundary(level, origin, width) {
-    let y = origin.y
-    if (level > 0) 
-      y += KochSnowflakeBuilder.THIRD_HEIGHT * width
-    
-    const p0 = new Coordinate(origin.x, y)
-    const p1 = new Coordinate(origin.x + width / 2, y + width * KochSnowflakeBuilder.HEIGHT_FACTOR)
-    const p2 = new Coordinate(origin.x + width, y)
-    this.addSide(level, p0, p1)
-    this.addSide(level, p1, p2)
-    this.addSide(level, p2, p0)
-    this._coordList.closeRing()
-    return this._coordList.toCoordinateArray()
-  }
-  getGeometry() {
-    const level = KochSnowflakeBuilder.recursionLevelForSize(this._numPts)
-    const baseLine = this.getSquareBaseLine()
-    const pts = this.getBoundary(level, baseLine.getCoordinate(0), baseLine.getLength())
-    return this._geomFactory.createPolygon(this._geomFactory.createLinearRing(pts), null)
-  }
-  addSegment(p0, p1) {
-    this._coordList.add(p1)
-  }
-  addSide(level, p0, p1) {
-    if (level === 0) {
-      this.addSegment(p0, p1)
-    } else {
-      const base = Vector2D.create(p0, p1)
-      const midPt = base.multiply(0.5).translate(p0)
-      const heightVec = base.multiply(KochSnowflakeBuilder.THIRD_HEIGHT)
-      const offsetVec = heightVec.rotateByQuarterCircle(1)
-      const offsetPt = offsetVec.translate(midPt)
-      const n2 = level - 1
-      const thirdPt = base.multiply(KochSnowflakeBuilder.ONE_THIRD).translate(p0)
-      const twoThirdPt = base.multiply(KochSnowflakeBuilder.TWO_THIRDS).translate(p0)
-      this.addSide(n2, p0, thirdPt)
-      this.addSide(n2, thirdPt, offsetPt)
-      this.addSide(n2, offsetPt, twoThirdPt)
-      this.addSide(n2, twoThirdPt, p1)
-    }
-  }
-}
-KochSnowflakeBuilder.HEIGHT_FACTOR = Math.sin(Math.PI / 3.0)
-KochSnowflakeBuilder.ONE_THIRD = 1.0 / 3.0
-KochSnowflakeBuilder.THIRD_HEIGHT = KochSnowflakeBuilder.HEIGHT_FACTOR / 3.0
-KochSnowflakeBuilder.TWO_THIRDS = 2.0 / 3.0