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

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

@@ -0,0 +1,3 @@
+// export * from './noding/MCIndexNoder'
+// export * from './noding/ScaledNoder'
+// export * from './noding/SegmentString'

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

@@ -0,0 +1,117 @@
+import LineString from '../../geom/LineString'
+import BoundaryNodeRule from '../../algorithm/BoundaryNodeRule'
+import CoordinateArrays from '../../geom/CoordinateArrays'
+import ArrayList from '../../../../../java/util/ArrayList'
+import TreeMap from '../../../../../java/util/TreeMap'
+import MultiLineString from '../../geom/MultiLineString'
+
+export default class BoundaryOp {
+  constructor () {
+    this._geom = null
+    this._geomFact = null
+    this._bnRule = null
+    this._endpointMap = null
+    if (arguments.length === 1) {
+      const geom = arguments[0]
+      const bnRule = BoundaryNodeRule.MOD2_BOUNDARY_RULE
+      this._geom = geom
+      this._geomFact = geom.getFactory()
+      this._bnRule = bnRule
+    } else if (arguments.length === 2) {
+      const geom = arguments[0]
+      const bnRule = arguments[1]
+      this._geom = geom
+      this._geomFact = geom.getFactory()
+      this._bnRule = bnRule
+    }
+  }
+  boundaryMultiLineString (mLine) {
+    if (this._geom.isEmpty()) {
+      return this.getEmptyMultiPoint()
+    }
+    const bdyPts = this.computeBoundaryCoordinates(mLine)
+    if (bdyPts.length === 1) {
+      return this._geomFact.createPoint(bdyPts[0])
+    }
+    return this._geomFact.createMultiPointFromCoords(bdyPts)
+  }
+  getBoundary () {
+    if (this._geom instanceof LineString) return this.boundaryLineString(this._geom)
+    if (this._geom instanceof MultiLineString) return this.boundaryMultiLineString(this._geom)
+    return this._geom.getBoundary()
+  }
+  boundaryLineString (line) {
+    if (this._geom.isEmpty()) {
+      return this.getEmptyMultiPoint()
+    }
+    if (line.isClosed()) {
+      const closedEndpointOnBoundary = this._bnRule.isInBoundary(2)
+      if (closedEndpointOnBoundary) {
+        return line.getStartPoint()
+      } else {
+        return this._geomFact.createMultiPoint()
+      }
+    }
+    return this._geomFact.createMultiPoint([line.getStartPoint(), line.getEndPoint()])
+  }
+  getEmptyMultiPoint () {
+    return this._geomFact.createMultiPoint()
+  }
+  computeBoundaryCoordinates (mLine) {
+    const bdyPts = new ArrayList()
+    this._endpointMap = new TreeMap()
+    for (let i = 0; i < mLine.getNumGeometries(); i++) {
+      const line = mLine.getGeometryN(i)
+      if (line.getNumPoints() === 0) continue
+      this.addEndpoint(line.getCoordinateN(0))
+      this.addEndpoint(line.getCoordinateN(line.getNumPoints() - 1))
+    }
+    for (const it = this._endpointMap.entrySet().iterator(); it.hasNext();) {
+      const entry = it.next()
+      const counter = entry.getValue()
+      const valence = counter.count
+      if (this._bnRule.isInBoundary(valence)) {
+        bdyPts.add(entry.getKey())
+      }
+    }
+    return CoordinateArrays.toCoordinateArray(bdyPts)
+  }
+  addEndpoint (pt) {
+    let counter = this._endpointMap.get(pt)
+    if (counter === null) {
+      counter = new Counter()
+      this._endpointMap.put(pt, counter)
+    }
+    counter.count++
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return BoundaryOp
+  }
+  static getBoundary () {
+    if (arguments.length === 1) {
+      const g = arguments[0]
+      const bop = new BoundaryOp(g)
+      return bop.getBoundary()
+    } else if (arguments.length === 2) {
+      const g = arguments[0]
+      const bnRule = arguments[1]
+      const bop = new BoundaryOp(g, bnRule)
+      return bop.getBoundary()
+    }
+  }
+}
+
+class Counter {
+  constructor () {
+    this.count = null
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return Counter
+  }
+}

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

@@ -0,0 +1,2 @@
+// boundary
+export { default as BoundaryOp } from './boundary/BoundaryOp'

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

@@ -0,0 +1,150 @@
+import Location from '../../geom/Location'
+import BufferSubgraph from './BufferSubgraph'
+import PolygonBuilder from '../overlay/PolygonBuilder'
+import GeometryFactory from '../../geom/GeometryFactory'
+import Position from '../../geomgraph/Position'
+import MCIndexNoder from '../../noding/MCIndexNoder'
+import OffsetCurveBuilder from './OffsetCurveBuilder'
+import Collections from '../../../../../java/util/Collections'
+import SubgraphDepthLocater from './SubgraphDepthLocater'
+import OffsetCurveSetBuilder from './OffsetCurveSetBuilder'
+import Label from '../../geomgraph/Label'
+import OverlayNodeFactory from '../overlay/OverlayNodeFactory'
+import EdgeList from '../../geomgraph/EdgeList'
+import ArrayList from '../../../../../java/util/ArrayList'
+import RobustLineIntersector from '../../algorithm/RobustLineIntersector'
+import IntersectionAdder from '../../noding/IntersectionAdder'
+import Edge from '../../geomgraph/Edge'
+import PlanarGraph from '../../geomgraph/PlanarGraph'
+
+export default class BufferBuilder {
+  constructor (bufParams) {
+    this._workingPrecisionModel = null
+    this._workingNoder = null
+    this._geomFact = null
+    this._graph = null
+    this._edgeList = new EdgeList()
+    this._bufParams = bufParams || null
+  }
+  setWorkingPrecisionModel (pm) {
+    this._workingPrecisionModel = pm
+  }
+  insertUniqueEdge (e) {
+    const existingEdge = this._edgeList.findEqualEdge(e)
+    if (existingEdge !== null) {
+      const existingLabel = existingEdge.getLabel()
+      let labelToMerge = e.getLabel()
+      if (!existingEdge.isPointwiseEqual(e)) {
+        labelToMerge = new Label(e.getLabel())
+        labelToMerge.flip()
+      }
+      existingLabel.merge(labelToMerge)
+      const mergeDelta = BufferBuilder.depthDelta(labelToMerge)
+      const existingDelta = existingEdge.getDepthDelta()
+      const newDelta = existingDelta + mergeDelta
+      existingEdge.setDepthDelta(newDelta)
+    } else {
+      this._edgeList.add(e)
+      e.setDepthDelta(BufferBuilder.depthDelta(e.getLabel()))
+    }
+  }
+  buildSubgraphs (subgraphList, polyBuilder) {
+    const processedGraphs = new ArrayList()
+    for (const i = subgraphList.iterator(); i.hasNext();) {
+      const subgraph = i.next()
+      const p = subgraph.getRightmostCoordinate()
+      const locater = new SubgraphDepthLocater(processedGraphs)
+      const outsideDepth = locater.getDepth(p)
+      subgraph.computeDepth(outsideDepth)
+      subgraph.findResultEdges()
+      processedGraphs.add(subgraph)
+      polyBuilder.add(subgraph.getDirectedEdges(), subgraph.getNodes())
+    }
+  }
+  createSubgraphs (graph) {
+    const subgraphList = new ArrayList()
+    for (const i = graph.getNodes().iterator(); i.hasNext();) {
+      const node = i.next()
+      if (!node.isVisited()) {
+        const subgraph = new BufferSubgraph()
+        subgraph.create(node)
+        subgraphList.add(subgraph)
+      }
+    }
+    Collections.sort(subgraphList, Collections.reverseOrder())
+    return subgraphList
+  }
+  createEmptyResultGeometry () {
+    const emptyGeom = this._geomFact.createPolygon()
+    return emptyGeom
+  }
+  getNoder (precisionModel) {
+    if (this._workingNoder !== null) return this._workingNoder
+    const noder = new MCIndexNoder()
+    const li = new RobustLineIntersector()
+    li.setPrecisionModel(precisionModel)
+    noder.setSegmentIntersector(new IntersectionAdder(li))
+    return noder
+  }
+  buffer (g, distance) {
+    let precisionModel = this._workingPrecisionModel
+    if (precisionModel === null) precisionModel = g.getPrecisionModel()
+    this._geomFact = g.getFactory()
+    const curveBuilder = new OffsetCurveBuilder(precisionModel, this._bufParams)
+    const curveSetBuilder = new OffsetCurveSetBuilder(g, distance, curveBuilder)
+    const bufferSegStrList = curveSetBuilder.getCurves()
+    if (bufferSegStrList.size() <= 0) {
+      return this.createEmptyResultGeometry()
+    }
+    this.computeNodedEdges(bufferSegStrList, precisionModel)
+    this._graph = new PlanarGraph(new OverlayNodeFactory())
+    this._graph.addEdges(this._edgeList.getEdges())
+    const subgraphList = this.createSubgraphs(this._graph)
+    const polyBuilder = new PolygonBuilder(this._geomFact)
+    this.buildSubgraphs(subgraphList, polyBuilder)
+    const resultPolyList = polyBuilder.getPolygons()
+    if (resultPolyList.size() <= 0) {
+      return this.createEmptyResultGeometry()
+    }
+    const resultGeom = this._geomFact.buildGeometry(resultPolyList)
+    return resultGeom
+  }
+  computeNodedEdges (bufferSegStrList, precisionModel) {
+    const noder = this.getNoder(precisionModel)
+    noder.computeNodes(bufferSegStrList)
+    const nodedSegStrings = noder.getNodedSubstrings()
+    for (const i = nodedSegStrings.iterator(); i.hasNext();) {
+      const segStr = i.next()
+      const pts = segStr.getCoordinates()
+      if (pts.length === 2 && pts[0].equals2D(pts[1])) continue
+      const oldLabel = segStr.getData()
+      const edge = new Edge(segStr.getCoordinates(), new Label(oldLabel))
+      this.insertUniqueEdge(edge)
+    }
+  }
+  setNoder (noder) {
+    this._workingNoder = noder
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return BufferBuilder
+  }
+  static depthDelta (label) {
+    const lLoc = label.getLocation(0, Position.LEFT)
+    const rLoc = label.getLocation(0, Position.RIGHT)
+    if (lLoc === Location.INTERIOR && rLoc === Location.EXTERIOR) return 1; else if (lLoc === Location.EXTERIOR && rLoc === Location.INTERIOR) return -1
+    return 0
+  }
+  static convertSegStrings (it) {
+    const fact = new GeometryFactory()
+    const lines = new ArrayList()
+    while (it.hasNext()) {
+      const ss = it.next()
+      const line = fact.createLineString(ss.getCoordinates())
+      lines.add(line)
+    }
+    return fact.buildGeometry(lines)
+  }
+}

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

@@ -0,0 +1,98 @@
+import CGAlgorithms from '../../algorithm/CGAlgorithms'
+import CoordinateList from '../../geom/CoordinateList'
+
+export default class BufferInputLineSimplifier {
+  constructor (inputLine) {
+    this._distanceTol = null
+    this._isDeleted = null
+    this._angleOrientation = CGAlgorithms.COUNTERCLOCKWISE
+    this._inputLine = inputLine || null
+  }
+  isDeletable (i0, i1, i2, distanceTol) {
+    const p0 = this._inputLine[i0]
+    const p1 = this._inputLine[i1]
+    const p2 = this._inputLine[i2]
+    if (!this.isConcave(p0, p1, p2)) return false
+    if (!this.isShallow(p0, p1, p2, distanceTol)) return false
+    return this.isShallowSampled(p0, p1, i0, i2, distanceTol)
+  }
+  deleteShallowConcavities () {
+    let index = 1
+    // const maxIndex = this._inputLine.length - 1
+    let midIndex = this.findNextNonDeletedIndex(index)
+    let lastIndex = this.findNextNonDeletedIndex(midIndex)
+    let isChanged = false
+    while (lastIndex < this._inputLine.length) {
+      let isMiddleVertexDeleted = false
+      if (this.isDeletable(index, midIndex, lastIndex, this._distanceTol)) {
+        this._isDeleted[midIndex] = BufferInputLineSimplifier.DELETE
+        isMiddleVertexDeleted = true
+        isChanged = true
+      }
+      if (isMiddleVertexDeleted) index = lastIndex; else index = midIndex
+      midIndex = this.findNextNonDeletedIndex(index)
+      lastIndex = this.findNextNonDeletedIndex(midIndex)
+    }
+    return isChanged
+  }
+  isShallowConcavity (p0, p1, p2, distanceTol) {
+    const orientation = CGAlgorithms.computeOrientation(p0, p1, p2)
+    const isAngleToSimplify = orientation === this._angleOrientation
+    if (!isAngleToSimplify) return false
+    const dist = CGAlgorithms.distancePointLine(p1, p0, p2)
+    return dist < distanceTol
+  }
+  isShallowSampled (p0, p2, i0, i2, distanceTol) {
+    let inc = Math.trunc((i2 - i0) / BufferInputLineSimplifier.NUM_PTS_TO_CHECK)
+    if (inc <= 0) inc = 1
+    for (let i = i0; i < i2; i += inc) {
+      if (!this.isShallow(p0, p2, this._inputLine[i], distanceTol)) return false
+    }
+    return true
+  }
+  isConcave (p0, p1, p2) {
+    const orientation = CGAlgorithms.computeOrientation(p0, p1, p2)
+    const isConcave = orientation === this._angleOrientation
+    return isConcave
+  }
+  simplify (distanceTol) {
+    this._distanceTol = Math.abs(distanceTol)
+    if (distanceTol < 0) this._angleOrientation = CGAlgorithms.CLOCKWISE
+    this._isDeleted = new Array(this._inputLine.length).fill(null)
+    let isChanged = false
+    do {
+      isChanged = this.deleteShallowConcavities()
+    } while (isChanged)
+    return this.collapseLine()
+  }
+  findNextNonDeletedIndex (index) {
+    let next = index + 1
+    while (next < this._inputLine.length && this._isDeleted[next] === BufferInputLineSimplifier.DELETE) next++
+    return next
+  }
+  isShallow (p0, p1, p2, distanceTol) {
+    const dist = CGAlgorithms.distancePointLine(p1, p0, p2)
+    return dist < distanceTol
+  }
+  collapseLine () {
+    const coordList = new CoordinateList()
+    for (let i = 0; i < this._inputLine.length; i++) {
+      if (this._isDeleted[i] !== BufferInputLineSimplifier.DELETE) coordList.add(this._inputLine[i])
+    }
+    return coordList.toCoordinateArray()
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return BufferInputLineSimplifier
+  }
+  static simplify (inputLine, distanceTol) {
+    const simp = new BufferInputLineSimplifier(inputLine)
+    return simp.simplify(distanceTol)
+  }
+  static get INIT () { return 0 }
+  static get DELETE () { return 1 }
+  static get KEEP () { return 1 }
+  static get NUM_PTS_TO_CHECK () { return 10 }
+}

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

@@ -0,0 +1,139 @@
+import BufferParameters from './BufferParameters'
+import Geometry from '../../geom/Geometry'
+import BufferBuilder from './BufferBuilder'
+import ScaledNoder from '../../noding/ScaledNoder'
+import TopologyException from '../../geom/TopologyException'
+import MathUtil from '../../math/MathUtil'
+import PrecisionModel from '../../geom/PrecisionModel'
+import RuntimeException from '../../../../../java/lang/RuntimeException'
+import MCIndexSnapRounder from '../../noding/snapround/MCIndexSnapRounder'
+
+export default class BufferOp {
+  constructor () {
+    this._argGeom = null
+    this._distance = null
+    this._bufParams = new BufferParameters()
+    this._resultGeometry = null
+    this._saveException = null
+    if (arguments.length === 1) {
+      const g = arguments[0]
+      this._argGeom = g
+    } else if (arguments.length === 2) {
+      const g = arguments[0]
+      const bufParams = arguments[1]
+      this._argGeom = g
+      this._bufParams = bufParams
+    }
+  }
+  bufferFixedPrecision (fixedPM) {
+    const noder = new ScaledNoder(new MCIndexSnapRounder(new PrecisionModel(1.0)), fixedPM.getScale())
+    const bufBuilder = new BufferBuilder(this._bufParams)
+    bufBuilder.setWorkingPrecisionModel(fixedPM)
+    bufBuilder.setNoder(noder)
+    this._resultGeometry = bufBuilder.buffer(this._argGeom, this._distance)
+  }
+  bufferReducedPrecision () {
+    if (arguments.length === 0) {
+      for (let precDigits = BufferOp.MAX_PRECISION_DIGITS; precDigits >= 0; precDigits--) {
+        try {
+          this.bufferReducedPrecision(precDigits)
+        } catch (ex) {
+          if (ex instanceof TopologyException) {
+            this._saveException = ex
+          } else throw ex
+        } finally {}
+        if (this._resultGeometry !== null) return null
+      }
+      throw this._saveException
+    } else if (arguments.length === 1) {
+      const precisionDigits = arguments[0]
+      const sizeBasedScaleFactor = BufferOp.precisionScaleFactor(this._argGeom, this._distance, precisionDigits)
+      const fixedPM = new PrecisionModel(sizeBasedScaleFactor)
+      this.bufferFixedPrecision(fixedPM)
+    }
+  }
+  computeGeometry () {
+    this.bufferOriginalPrecision()
+    if (this._resultGeometry !== null) return null
+    const argPM = this._argGeom.getFactory().getPrecisionModel()
+    if (argPM.getType() === PrecisionModel.FIXED) this.bufferFixedPrecision(argPM); else this.bufferReducedPrecision()
+  }
+  setQuadrantSegments (quadrantSegments) {
+    this._bufParams.setQuadrantSegments(quadrantSegments)
+  }
+  bufferOriginalPrecision () {
+    try {
+      const bufBuilder = new BufferBuilder(this._bufParams)
+      this._resultGeometry = bufBuilder.buffer(this._argGeom, this._distance)
+    } catch (ex) {
+      if (ex instanceof RuntimeException) {
+        this._saveException = ex
+      } else throw ex
+    } finally {}
+  }
+  getResultGeometry (distance) {
+    this._distance = distance
+    this.computeGeometry()
+    return this._resultGeometry
+  }
+  setEndCapStyle (endCapStyle) {
+    this._bufParams.setEndCapStyle(endCapStyle)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return BufferOp
+  }
+  static bufferOp () {
+    if (arguments.length === 2) {
+      const g = arguments[0]
+      const distance = arguments[1]
+      const gBuf = new BufferOp(g)
+      const geomBuf = gBuf.getResultGeometry(distance)
+      return geomBuf
+    } else if (arguments.length === 3) {
+      if (Number.isInteger(arguments[2]) && (arguments[0] instanceof Geometry && typeof arguments[1] === 'number')) {
+        const g = arguments[0]
+        const distance = arguments[1]
+        const quadrantSegments = arguments[2]
+        const bufOp = new BufferOp(g)
+        bufOp.setQuadrantSegments(quadrantSegments)
+        const geomBuf = bufOp.getResultGeometry(distance)
+        return geomBuf
+      } else if (arguments[2] instanceof BufferParameters && (arguments[0] instanceof Geometry && typeof arguments[1] === 'number')) {
+        const g = arguments[0]
+        const distance = arguments[1]
+        const params = arguments[2]
+        const bufOp = new BufferOp(g, params)
+        const geomBuf = bufOp.getResultGeometry(distance)
+        return geomBuf
+      }
+    } else if (arguments.length === 4) {
+      const g = arguments[0]
+      const distance = arguments[1]
+      const quadrantSegments = arguments[2]
+      const endCapStyle = arguments[3]
+      const bufOp = new BufferOp(g)
+      bufOp.setQuadrantSegments(quadrantSegments)
+      bufOp.setEndCapStyle(endCapStyle)
+      const geomBuf = bufOp.getResultGeometry(distance)
+      return geomBuf
+    }
+  }
+  static precisionScaleFactor (g, distance, maxPrecisionDigits) {
+    const env = g.getEnvelopeInternal()
+    const envMax = MathUtil.max(Math.abs(env.getMaxX()), Math.abs(env.getMaxY()), Math.abs(env.getMinX()), Math.abs(env.getMinY()))
+    const expandByDistance = distance > 0.0 ? distance : 0.0
+    const bufEnvMax = envMax + 2 * expandByDistance
+    const bufEnvPrecisionDigits = Math.trunc(Math.log(bufEnvMax) / Math.log(10) + 1.0)
+    const minUnitLog10 = maxPrecisionDigits - bufEnvPrecisionDigits
+    const scaleFactor = Math.pow(10.0, minUnitLog10)
+    return scaleFactor
+  }
+  static get CAP_ROUND () { return BufferParameters.CAP_ROUND }
+  static get CAP_BUTT () { return BufferParameters.CAP_FLAT }
+  static get CAP_FLAT () { return BufferParameters.CAP_FLAT }
+  static get CAP_SQUARE () { return BufferParameters.CAP_SQUARE }
+  static get MAX_PRECISION_DIGITS () { return 12 }
+}

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

@@ -0,0 +1,95 @@
+export default class BufferParameters {
+  constructor () {
+    this._quadrantSegments = BufferParameters.DEFAULT_QUADRANT_SEGMENTS
+    this._endCapStyle = BufferParameters.CAP_ROUND
+    this._joinStyle = BufferParameters.JOIN_ROUND
+    this._mitreLimit = BufferParameters.DEFAULT_MITRE_LIMIT
+    this._isSingleSided = false
+    this._simplifyFactor = BufferParameters.DEFAULT_SIMPLIFY_FACTOR
+
+    if (arguments.length === 0) {} else if (arguments.length === 1) {
+      const quadrantSegments = arguments[0]
+      this.setQuadrantSegments(quadrantSegments)
+    } else if (arguments.length === 2) {
+      const quadrantSegments = arguments[0]
+      const endCapStyle = arguments[1]
+      this.setQuadrantSegments(quadrantSegments)
+      this.setEndCapStyle(endCapStyle)
+    } else if (arguments.length === 4) {
+      const quadrantSegments = arguments[0]
+      const endCapStyle = arguments[1]
+      const joinStyle = arguments[2]
+      const mitreLimit = arguments[3]
+      this.setQuadrantSegments(quadrantSegments)
+      this.setEndCapStyle(endCapStyle)
+      this.setJoinStyle(joinStyle)
+      this.setMitreLimit(mitreLimit)
+    }
+  }
+  getEndCapStyle () {
+    return this._endCapStyle
+  }
+  isSingleSided () {
+    return this._isSingleSided
+  }
+  setQuadrantSegments (quadSegs) {
+    this._quadrantSegments = quadSegs
+    if (this._quadrantSegments === 0) this._joinStyle = BufferParameters.JOIN_BEVEL
+    if (this._quadrantSegments < 0) {
+      this._joinStyle = BufferParameters.JOIN_MITRE
+      this._mitreLimit = Math.abs(this._quadrantSegments)
+    }
+    if (quadSegs <= 0) {
+      this._quadrantSegments = 1
+    }
+    if (this._joinStyle !== BufferParameters.JOIN_ROUND) {
+      this._quadrantSegments = BufferParameters.DEFAULT_QUADRANT_SEGMENTS
+    }
+  }
+  getJoinStyle () {
+    return this._joinStyle
+  }
+  setJoinStyle (joinStyle) {
+    this._joinStyle = joinStyle
+  }
+  setSimplifyFactor (simplifyFactor) {
+    this._simplifyFactor = simplifyFactor < 0 ? 0 : simplifyFactor
+  }
+  getSimplifyFactor () {
+    return this._simplifyFactor
+  }
+  getQuadrantSegments () {
+    return this._quadrantSegments
+  }
+  setEndCapStyle (endCapStyle) {
+    this._endCapStyle = endCapStyle
+  }
+  getMitreLimit () {
+    return this._mitreLimit
+  }
+  setMitreLimit (mitreLimit) {
+    this._mitreLimit = mitreLimit
+  }
+  setSingleSided (isSingleSided) {
+    this._isSingleSided = isSingleSided
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return BufferParameters
+  }
+  static bufferDistanceError (quadSegs) {
+    var alpha = Math.PI / 2.0 / quadSegs
+    return 1 - Math.cos(alpha / 2.0)
+  }
+  static get CAP_ROUND () { return 1 }
+  static get CAP_FLAT () { return 2 }
+  static get CAP_SQUARE () { return 3 }
+  static get JOIN_ROUND () { return 1 }
+  static get JOIN_MITRE () { return 2 }
+  static get JOIN_BEVEL () { return 3 }
+  static get DEFAULT_QUADRANT_SEGMENTS () { return 8 }
+  static get DEFAULT_MITRE_LIMIT () { return 5.0 }
+  static get DEFAULT_SIMPLIFY_FACTOR () { return 0.01 }
+}