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

package/node_modules/jsts/org/locationtech/jts/operation/IsSimpleOp.js

@@ -1,165 +0,0 @@
-import TreeSet from '../../../../java/util/TreeSet'
-import LineString from '../geom/LineString'
-import hasInterface from '../../../../hasInterface'
-import MultiPoint from '../geom/MultiPoint'
-import GeometryGraph from '../geomgraph/GeometryGraph'
-import GeometryCollection from '../geom/GeometryCollection'
-import Polygonal from '../geom/Polygonal'
-import RobustLineIntersector from '../algorithm/RobustLineIntersector'
-import LinearComponentExtracter from '../geom/util/LinearComponentExtracter'
-import TreeMap from '../../../../java/util/TreeMap'
-import MultiLineString from '../geom/MultiLineString'
-export default class IsSimpleOp {
-  constructor() {
-    IsSimpleOp.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._inputGeom = null
-    this._isClosedEndpointsInInterior = true
-    this._nonSimpleLocation = null
-    if (arguments.length === 1) {
-      const geom = arguments[0]
-      this._inputGeom = geom
-    } else if (arguments.length === 2) {
-      const geom = arguments[0], boundaryNodeRule = arguments[1]
-      this._inputGeom = geom
-      this._isClosedEndpointsInInterior = !boundaryNodeRule.isInBoundary(2)
-    }
-  }
-  static isSimple() {
-    if (arguments.length === 1) {
-      const geom = arguments[0]
-      const op = new IsSimpleOp(geom)
-      return op.isSimple()
-    } else if (arguments.length === 2) {
-      const geom = arguments[0], boundaryNodeRule = arguments[1]
-      const op = new IsSimpleOp(geom, boundaryNodeRule)
-      return op.isSimple()
-    }
-  }
-  isSimpleMultiPoint(mp) {
-    if (mp.isEmpty()) return true
-    const points = new TreeSet()
-    for (let i = 0; i < mp.getNumGeometries(); i++) {
-      const pt = mp.getGeometryN(i)
-      const p = pt.getCoordinate()
-      if (points.contains(p)) {
-        this._nonSimpleLocation = p
-        return false
-      }
-      points.add(p)
-    }
-    return true
-  }
-  isSimplePolygonal(geom) {
-    const rings = LinearComponentExtracter.getLines(geom)
-    for (let i = rings.iterator(); i.hasNext(); ) {
-      const ring = i.next()
-      if (!this.isSimpleLinearGeometry(ring)) return false
-    }
-    return true
-  }
-  hasClosedEndpointIntersection(graph) {
-    const endPoints = new TreeMap()
-    for (let i = graph.getEdgeIterator(); i.hasNext(); ) {
-      const e = i.next()
-      const isClosed = e.isClosed()
-      const p0 = e.getCoordinate(0)
-      this.addEndpoint(endPoints, p0, isClosed)
-      const p1 = e.getCoordinate(e.getNumPoints() - 1)
-      this.addEndpoint(endPoints, p1, isClosed)
-    }
-    for (let i = endPoints.values().iterator(); i.hasNext(); ) {
-      const eiInfo = i.next()
-      if (eiInfo.isClosed && eiInfo.degree !== 2) {
-        this._nonSimpleLocation = eiInfo.getCoordinate()
-        return true
-      }
-    }
-    return false
-  }
-  getNonSimpleLocation() {
-    return this._nonSimpleLocation
-  }
-  isSimpleLinearGeometry(geom) {
-    if (geom.isEmpty()) return true
-    const graph = new GeometryGraph(0, geom)
-    const li = new RobustLineIntersector()
-    const si = graph.computeSelfNodes(li, true)
-    if (!si.hasIntersection()) return true
-    if (si.hasProperIntersection()) {
-      this._nonSimpleLocation = si.getProperIntersectionPoint()
-      return false
-    }
-    if (this.hasNonEndpointIntersection(graph)) return false
-    if (this._isClosedEndpointsInInterior) 
-      if (this.hasClosedEndpointIntersection(graph)) return false
-    
-    return true
-  }
-  hasNonEndpointIntersection(graph) {
-    for (let i = graph.getEdgeIterator(); i.hasNext(); ) {
-      const e = i.next()
-      const maxSegmentIndex = e.getMaximumSegmentIndex()
-      for (let eiIt = e.getEdgeIntersectionList().iterator(); eiIt.hasNext(); ) {
-        const ei = eiIt.next()
-        if (!ei.isEndPoint(maxSegmentIndex)) {
-          this._nonSimpleLocation = ei.getCoordinate()
-          return true
-        }
-      }
-    }
-    return false
-  }
-  addEndpoint(endPoints, p, isClosed) {
-    let eiInfo = endPoints.get(p)
-    if (eiInfo === null) {
-      eiInfo = new EndpointInfo(p)
-      endPoints.put(p, eiInfo)
-    }
-    eiInfo.addEndpoint(isClosed)
-  }
-  computeSimple(geom) {
-    this._nonSimpleLocation = null
-    if (geom.isEmpty()) return true
-    if (geom instanceof LineString) return this.isSimpleLinearGeometry(geom)
-    if (geom instanceof MultiLineString) return this.isSimpleLinearGeometry(geom)
-    if (geom instanceof MultiPoint) return this.isSimpleMultiPoint(geom)
-    if (hasInterface(geom, Polygonal)) return this.isSimplePolygonal(geom)
-    if (geom instanceof GeometryCollection) return this.isSimpleGeometryCollection(geom)
-    return true
-  }
-  isSimple() {
-    this._nonSimpleLocation = null
-    return this.computeSimple(this._inputGeom)
-  }
-  isSimpleGeometryCollection(geom) {
-    for (let i = 0; i < geom.getNumGeometries(); i++) {
-      const comp = geom.getGeometryN(i)
-      if (!this.computeSimple(comp)) return false
-    }
-    return true
-  }
-}
-class EndpointInfo {
-  constructor() {
-    EndpointInfo.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this.pt = null
-    this.isClosed = null
-    this.degree = null
-    const pt = arguments[0]
-    this.pt = pt
-    this.isClosed = false
-    this.degree = 0
-  }
-  addEndpoint(isClosed) {
-    this.degree++
-    this.isClosed |= isClosed
-  }
-  getCoordinate() {
-    return this.pt
-  }
-}
-IsSimpleOp.EndpointInfo = EndpointInfo

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

@@ -1,148 +0,0 @@
-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() {
-    BufferBuilder.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._bufParams = null
-    this._workingPrecisionModel = null
-    this._workingNoder = null
-    this._geomFact = null
-    this._graph = null
-    this._edgeList = new EdgeList()
-    const bufParams = arguments[0]
-    this._bufParams = bufParams
-  }
-  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)
-  }
-  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 (let 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 (let 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 (let 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
-  }
-}

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

@@ -1,96 +0,0 @@
-import CoordinateList from '../../geom/CoordinateList'
-import Orientation from '../../algorithm/Orientation'
-import Distance from '../../algorithm/Distance'
-export default class BufferInputLineSimplifier {
-  constructor() {
-    BufferInputLineSimplifier.constructor_.apply(this, arguments)
-  }
-  static constructor_() {
-    this._inputLine = null
-    this._distanceTol = null
-    this._isDeleted = null
-    this._angleOrientation = Orientation.COUNTERCLOCKWISE
-    const inputLine = arguments[0]
-    this._inputLine = inputLine
-  }
-  static simplify(inputLine, distanceTol) {
-    const simp = new BufferInputLineSimplifier(inputLine)
-    return simp.simplify(distanceTol)
-  }
-  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
-    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 = Orientation.index(p0, p1, p2)
-    const isAngleToSimplify = orientation === this._angleOrientation
-    if (!isAngleToSimplify) return false
-    const dist = Distance.pointToSegment(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 = Orientation.index(p0, p1, p2)
-    const isConcave = orientation === this._angleOrientation
-    return isConcave
-  }
-  simplify(distanceTol) {
-    this._distanceTol = Math.abs(distanceTol)
-    if (distanceTol < 0) this._angleOrientation = Orientation.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 = Distance.pointToSegment(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()
-  }
-}
-BufferInputLineSimplifier.INIT = 0
-BufferInputLineSimplifier.DELETE = 1
-BufferInputLineSimplifier.KEEP = 1
-BufferInputLineSimplifier.NUM_PTS_TO_CHECK = 10

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

@@ -1,126 +0,0 @@
-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() {
-    BufferOp.constructor_.apply(this, arguments)
-  }
-  static 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], bufParams = arguments[1]
-      this._argGeom = g
-      this._bufParams = bufParams
-    }
-  }
-  static bufferOp() {
-    if (arguments.length === 2) {
-      const g = arguments[0], 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], distance = arguments[1], 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], distance = arguments[1], 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], distance = arguments[1], quadrantSegments = arguments[2], 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
-  }
-  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)
-  }
-}
-BufferOp.CAP_ROUND = BufferParameters.CAP_ROUND
-BufferOp.CAP_BUTT = BufferParameters.CAP_FLAT
-BufferOp.CAP_FLAT = BufferParameters.CAP_FLAT
-BufferOp.CAP_SQUARE = BufferParameters.CAP_SQUARE
-BufferOp.MAX_PRECISION_DIGITS = 12

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

@@ -1,87 +0,0 @@
-export default class BufferParameters {
-  constructor() {
-    BufferParameters.constructor_.apply(this, arguments)
-  }
-  static 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], endCapStyle = arguments[1]
-      this.setQuadrantSegments(quadrantSegments)
-      this.setEndCapStyle(endCapStyle)
-    } else if (arguments.length === 4) {
-      const quadrantSegments = arguments[0], endCapStyle = arguments[1], joinStyle = arguments[2], mitreLimit = arguments[3]
-      this.setQuadrantSegments(quadrantSegments)
-      this.setEndCapStyle(endCapStyle)
-      this.setJoinStyle(joinStyle)
-      this.setMitreLimit(mitreLimit)
-    }
-  }
-  static bufferDistanceError(quadSegs) {
-    const alpha = Math.PI / 2.0 / quadSegs
-    return 1 - Math.cos(alpha / 2.0)
-  }
-  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
-  }
-}
-BufferParameters.CAP_ROUND = 1
-BufferParameters.CAP_FLAT = 2
-BufferParameters.CAP_SQUARE = 3
-BufferParameters.JOIN_ROUND = 1
-BufferParameters.JOIN_MITRE = 2
-BufferParameters.JOIN_BEVEL = 3
-BufferParameters.DEFAULT_QUADRANT_SEGMENTS = 8
-BufferParameters.DEFAULT_MITRE_LIMIT = 5.0
-BufferParameters.DEFAULT_SIMPLIFY_FACTOR = 0.01