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

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

@@ -0,0 +1,136 @@
+import HashMap from '../../../../java/util/HashMap'
+import Coordinate from './Coordinate'
+import Double from '../../../../java/lang/Double'
+import Integer from '../../../../java/lang/Integer'
+import Comparable from '../../../../java/lang/Comparable'
+import Serializable from '../../../../java/io/Serializable'
+
+export default class PrecisionModel {
+  constructor () {
+    this._modelType = null
+    this._scale = null
+    if (arguments.length === 0) {
+      this._modelType = PrecisionModel.FLOATING
+    } else if (arguments.length === 1) {
+      if (arguments[0] instanceof Type) {
+        let modelType = arguments[0]
+        this._modelType = modelType
+        if (modelType === PrecisionModel.FIXED) {
+          this.setScale(1.0)
+        }
+      } else if (typeof arguments[0] === 'number') {
+        let scale = arguments[0]
+        this._modelType = PrecisionModel.FIXED
+        this.setScale(scale)
+      } else if (arguments[0] instanceof PrecisionModel) {
+        let pm = arguments[0]
+        this._modelType = pm._modelType
+        this._scale = pm._scale
+      }
+    }
+  }
+  equals (other) {
+    if (!(other instanceof PrecisionModel)) {
+      return false
+    }
+    var otherPrecisionModel = other
+    return this._modelType === otherPrecisionModel._modelType && this._scale === otherPrecisionModel._scale
+  }
+  compareTo (o) {
+    var other = o
+    var sigDigits = this.getMaximumSignificantDigits()
+    var otherSigDigits = other.getMaximumSignificantDigits()
+    return new Integer(sigDigits).compareTo(new Integer(otherSigDigits))
+  }
+  getScale () {
+    return this._scale
+  }
+  isFloating () {
+    return this._modelType === PrecisionModel.FLOATING || this._modelType === PrecisionModel.FLOATING_SINGLE
+  }
+  getType () {
+    return this._modelType
+  }
+  toString () {
+    var description = 'UNKNOWN'
+    if (this._modelType === PrecisionModel.FLOATING) {
+      description = 'Floating'
+    } else if (this._modelType === PrecisionModel.FLOATING_SINGLE) {
+      description = 'Floating-Single'
+    } else if (this._modelType === PrecisionModel.FIXED) {
+      description = 'Fixed (Scale=' + this.getScale() + ')'
+    }
+    return description
+  }
+  makePrecise () {
+    if (typeof arguments[0] === 'number') {
+      let val = arguments[0]
+      if (Double.isNaN(val)) return val
+      if (this._modelType === PrecisionModel.FLOATING_SINGLE) {
+        var floatSingleVal = val
+        return floatSingleVal
+      }
+      if (this._modelType === PrecisionModel.FIXED) {
+        return Math.round(val * this._scale) / this._scale
+      }
+      return val
+    } else if (arguments[0] instanceof Coordinate) {
+      let coord = arguments[0]
+      if (this._modelType === PrecisionModel.FLOATING) return null
+      coord.x = this.makePrecise(coord.x)
+      coord.y = this.makePrecise(coord.y)
+    }
+  }
+  getMaximumSignificantDigits () {
+    var maxSigDigits = 16
+    if (this._modelType === PrecisionModel.FLOATING) {
+      maxSigDigits = 16
+    } else if (this._modelType === PrecisionModel.FLOATING_SINGLE) {
+      maxSigDigits = 6
+    } else if (this._modelType === PrecisionModel.FIXED) {
+      maxSigDigits = 1 + Math.trunc(Math.ceil(Math.log(this.getScale()) / Math.log(10)))
+    }
+    return maxSigDigits
+  }
+  setScale (scale) {
+    this._scale = Math.abs(scale)
+  }
+  interfaces_ () {
+    return [Serializable, Comparable]
+  }
+  getClass () {
+    return PrecisionModel
+  }
+  static mostPrecise (pm1, pm2) {
+    if (pm1.compareTo(pm2) >= 0) return pm1
+    return pm2
+  }
+  static get serialVersionUID () { return 7777263578777803835 }
+  static get maximumPreciseValue () { return 9007199254740992.0 }
+}
+
+class Type {
+  constructor (name) {
+    this._name = name || null
+    Type.nameToTypeMap.put(name, this)
+  }
+  readResolve () {
+    return Type.nameToTypeMap.get(this._name)
+  }
+  toString () {
+    return this._name
+  }
+  interfaces_ () {
+    return [Serializable]
+  }
+  getClass () {
+    return Type
+  }
+  static get serialVersionUID () { return -5528602631731589822 }
+  static get nameToTypeMap () { return new HashMap() }
+}
+
+PrecisionModel.Type = Type
+PrecisionModel.FIXED = new Type('FIXED')
+PrecisionModel.FLOATING = new Type('FLOATING')
+PrecisionModel.FLOATING_SINGLE = new Type('FLOATING SINGLE')

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

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

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

@@ -0,0 +1,23 @@
+import Coordinate from './Coordinate'
+import RuntimeException from '../../../../java/lang/RuntimeException'
+
+export default class TopologyException extends RuntimeException {
+  constructor (msg, pt) {
+    super(TopologyException.msgWithCoord(msg, pt))
+    this.pt = pt ? new Coordinate(pt) : null
+    this.name = 'TopologyException'
+  }
+  getCoordinate () {
+    return this.pt
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return TopologyException
+  }
+  static msgWithCoord (msg, pt) {
+    if (!pt) return msg + ' [ ' + pt + ' ]'
+    return msg
+  }
+}

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

@@ -0,0 +1,143 @@
+import Coordinate from './Coordinate'
+import IllegalArgumentException from '../../../../java/lang/IllegalArgumentException'
+import Angle from '../algorithm/Angle'
+import HCoordinate from '../algorithm/HCoordinate'
+
+export default class Triangle {
+  constructor (p0, p1, p2) {
+    this.p0 = p0 || null
+    this.p1 = p1 || null
+    this.p2 = p2 || null
+  }
+  area () {
+    return Triangle.area(this.p0, this.p1, this.p2)
+  }
+  signedArea () {
+    return Triangle.signedArea(this.p0, this.p1, this.p2)
+  }
+  interpolateZ (p) {
+    if (p === null) throw new IllegalArgumentException('Supplied point is null.')
+    return Triangle.interpolateZ(p, this.p0, this.p1, this.p2)
+  }
+  longestSideLength () {
+    return Triangle.longestSideLength(this.p0, this.p1, this.p2)
+  }
+  isAcute () {
+    return Triangle.isAcute(this.p0, this.p1, this.p2)
+  }
+  circumcentre () {
+    return Triangle.circumcentre(this.p0, this.p1, this.p2)
+  }
+  area3D () {
+    return Triangle.area3D(this.p0, this.p1, this.p2)
+  }
+  centroid () {
+    return Triangle.centroid(this.p0, this.p1, this.p2)
+  }
+  inCentre () {
+    return Triangle.inCentre(this.p0, this.p1, this.p2)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return Triangle
+  }
+  static area (a, b, c) {
+    return Math.abs(((c.x - a.x) * (b.y - a.y) - (b.x - a.x) * (c.y - a.y)) / 2)
+  }
+  static signedArea (a, b, c) {
+    return ((c.x - a.x) * (b.y - a.y) - (b.x - a.x) * (c.y - a.y)) / 2
+  }
+  static det (m00, m01, m10, m11) {
+    return m00 * m11 - m01 * m10
+  }
+  static interpolateZ (p, v0, v1, v2) {
+    var x0 = v0.x
+    var y0 = v0.y
+    var a = v1.x - x0
+    var b = v2.x - x0
+    var c = v1.y - y0
+    var d = v2.y - y0
+    var det = a * d - b * c
+    var dx = p.x - x0
+    var dy = p.y - y0
+    var t = (d * dx - b * dy) / det
+    var u = (-c * dx + a * dy) / det
+    var z = v0.z + t * (v1.z - v0.z) + u * (v2.z - v0.z)
+    return z
+  }
+  static longestSideLength (a, b, c) {
+    var lenAB = a.distance(b)
+    var lenBC = b.distance(c)
+    var lenCA = c.distance(a)
+    var maxLen = lenAB
+    if (lenBC > maxLen) maxLen = lenBC
+    if (lenCA > maxLen) maxLen = lenCA
+    return maxLen
+  }
+  static isAcute (a, b, c) {
+    if (!Angle.isAcute(a, b, c)) return false
+    if (!Angle.isAcute(b, c, a)) return false
+    if (!Angle.isAcute(c, a, b)) return false
+    return true
+  }
+  static circumcentre (a, b, c) {
+    var cx = c.x
+    var cy = c.y
+    var ax = a.x - cx
+    var ay = a.y - cy
+    var bx = b.x - cx
+    var by = b.y - cy
+    var denom = 2 * Triangle.det(ax, ay, bx, by)
+    var numx = Triangle.det(ay, ax * ax + ay * ay, by, bx * bx + by * by)
+    var numy = Triangle.det(ax, ax * ax + ay * ay, bx, bx * bx + by * by)
+    var ccx = cx - numx / denom
+    var ccy = cy + numy / denom
+    return new Coordinate(ccx, ccy)
+  }
+  static perpendicularBisector (a, b) {
+    var dx = b.x - a.x
+    var dy = b.y - a.y
+    var l1 = new HCoordinate(a.x + dx / 2.0, a.y + dy / 2.0, 1.0)
+    var l2 = new HCoordinate(a.x - dy + dx / 2.0, a.y + dx + dy / 2.0, 1.0)
+    return new HCoordinate(l1, l2)
+  }
+  static angleBisector (a, b, c) {
+    var len0 = b.distance(a)
+    var len2 = b.distance(c)
+    var frac = len0 / (len0 + len2)
+    var dx = c.x - a.x
+    var dy = c.y - a.y
+    var splitPt = new Coordinate(a.x + frac * dx, a.y + frac * dy)
+    return splitPt
+  }
+  static area3D (a, b, c) {
+    var ux = b.x - a.x
+    var uy = b.y - a.y
+    var uz = b.z - a.z
+    var vx = c.x - a.x
+    var vy = c.y - a.y
+    var vz = c.z - a.z
+    var crossx = uy * vz - uz * vy
+    var crossy = uz * vx - ux * vz
+    var crossz = ux * vy - uy * vx
+    var absSq = crossx * crossx + crossy * crossy + crossz * crossz
+    var area3D = Math.sqrt(absSq) / 2
+    return area3D
+  }
+  static centroid (a, b, c) {
+    var x = (a.x + b.x + c.x) / 3
+    var y = (a.y + b.y + c.y) / 3
+    return new Coordinate(x, y)
+  }
+  static inCentre (a, b, c) {
+    var len0 = b.distance(c)
+    var len1 = a.distance(c)
+    var len2 = a.distance(b)
+    var circum = len0 + len1 + len2
+    var inCentreX = (len0 * a.x + len1 * b.x + len2 * c.x) / circum
+    var inCentreY = (len0 * a.y + len1 * b.y + len2 * c.y) / circum
+    return new Coordinate(inCentreX, inCentreY)
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/geom/impl/CoordinateArraySequence.js

@@ -0,0 +1,152 @@
+import StringBuffer from '../../../../../java/lang/StringBuffer'
+import hasInterface from '../../../../../hasInterface'
+import Coordinate from '../Coordinate'
+import IllegalArgumentException from '../../../../../java/lang/IllegalArgumentException'
+import Double from '../../../../../java/lang/Double'
+import CoordinateSequence from '../CoordinateSequence'
+import Serializable from '../../../../../java/io/Serializable'
+
+export default class CoordinateArraySequence {
+  constructor () {
+    this._dimension = 3
+    this._coordinates = null
+    if (arguments.length === 1) {
+      if (arguments[0] instanceof Array) {
+        this._coordinates = arguments[0]
+        this._dimension = 3
+      } else if (Number.isInteger(arguments[0])) {
+        const size = arguments[0]
+        this._coordinates = new Array(size).fill(null)
+        for (let i = 0; i < size; i++) {
+          this._coordinates[i] = new Coordinate()
+        }
+      } else if (hasInterface(arguments[0], CoordinateSequence)) {
+        const coordSeq = arguments[0]
+        if (coordSeq === null) {
+          this._coordinates = new Array(0).fill(null)
+          return null
+        }
+        this._dimension = coordSeq.getDimension()
+        this._coordinates = new Array(coordSeq.size()).fill(null)
+        for (let i = 0; i < this._coordinates.length; i++) {
+          this._coordinates[i] = coordSeq.getCoordinateCopy(i)
+        }
+      }
+    } else if (arguments.length === 2) {
+      if (arguments[0] instanceof Array && Number.isInteger(arguments[1])) {
+        const coordinates = arguments[0]
+        const dimension = arguments[1]
+        this._coordinates = coordinates
+        this._dimension = dimension
+        if (coordinates === null) this._coordinates = new Array(0).fill(null)
+      } else if (Number.isInteger(arguments[0]) && Number.isInteger(arguments[1])) {
+        const size = arguments[0]
+        const dimension = arguments[1]
+        this._coordinates = new Array(size).fill(null)
+        this._dimension = dimension
+        for (let i = 0; i < size; i++) {
+          this._coordinates[i] = new Coordinate()
+        }
+      }
+    }
+  }
+  setOrdinate (index, ordinateIndex, value) {
+    switch (ordinateIndex) {
+      case CoordinateSequence.X:
+        this._coordinates[index].x = value
+        break
+      case CoordinateSequence.Y:
+        this._coordinates[index].y = value
+        break
+      case CoordinateSequence.Z:
+        this._coordinates[index].z = value
+        break
+      default:
+        throw new IllegalArgumentException('invalid ordinateIndex')
+    }
+  }
+  size () {
+    return this._coordinates.length
+  }
+  getOrdinate (index, ordinateIndex) {
+    switch (ordinateIndex) {
+      case CoordinateSequence.X:
+        return this._coordinates[index].x
+      case CoordinateSequence.Y:
+        return this._coordinates[index].y
+      case CoordinateSequence.Z:
+        return this._coordinates[index].z
+      default:
+    }
+    return Double.NaN
+  }
+  getCoordinate () {
+    if (arguments.length === 1) {
+      let i = arguments[0]
+      return this._coordinates[i]
+    } else if (arguments.length === 2) {
+      const index = arguments[0]
+      const coord = arguments[1]
+      coord.x = this._coordinates[index].x
+      coord.y = this._coordinates[index].y
+      coord.z = this._coordinates[index].z
+    }
+  }
+  getCoordinateCopy (i) {
+    return new Coordinate(this._coordinates[i])
+  }
+  getDimension () {
+    return this._dimension
+  }
+  getX (index) {
+    return this._coordinates[index].x
+  }
+  clone () {
+    const cloneCoordinates = new Array(this.size()).fill(null)
+    for (let i = 0; i < this._coordinates.length; i++) {
+      cloneCoordinates[i] = this._coordinates[i].clone()
+    }
+    return new CoordinateArraySequence(cloneCoordinates, this._dimension)
+  }
+  expandEnvelope (env) {
+    for (let i = 0; i < this._coordinates.length; i++) {
+      env.expandToInclude(this._coordinates[i])
+    }
+    return env
+  }
+  copy () {
+    const cloneCoordinates = new Array(this.size()).fill(null)
+    for (let i = 0; i < this._coordinates.length; i++) {
+      cloneCoordinates[i] = this._coordinates[i].copy()
+    }
+    return new CoordinateArraySequence(cloneCoordinates, this._dimension)
+  }
+  toString () {
+    if (this._coordinates.length > 0) {
+      const strBuf = new StringBuffer(17 * this._coordinates.length)
+      strBuf.append('(')
+      strBuf.append(this._coordinates[0])
+      for (let i = 1; i < this._coordinates.length; i++) {
+        strBuf.append(', ')
+        strBuf.append(this._coordinates[i])
+      }
+      strBuf.append(')')
+      return strBuf.toString()
+    } else {
+      return '()'
+    }
+  }
+  getY (index) {
+    return this._coordinates[index].y
+  }
+  toCoordinateArray () {
+    return this._coordinates
+  }
+  interfaces_ () {
+    return [CoordinateSequence, Serializable]
+  }
+  getClass () {
+    return CoordinateArraySequence
+  }
+  static get serialVersionUID () { return -915438501601840650 }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/geom/impl/CoordinateArraySequenceFactory.js

@@ -0,0 +1,40 @@
+import CoordinateSequenceFactory from '../CoordinateSequenceFactory'
+import hasInterface from '../../../../../hasInterface'
+import CoordinateArraySequence from './CoordinateArraySequence'
+import CoordinateSequence from '../CoordinateSequence'
+import Serializable from '../../../../../java/io/Serializable'
+
+export default class CoordinateArraySequenceFactory {
+  readResolve () {
+    return CoordinateArraySequenceFactory.instance()
+  }
+  create () {
+    if (arguments.length === 1) {
+      if (arguments[0] instanceof Array) {
+        const coordinates = arguments[0]
+        return new CoordinateArraySequence(coordinates)
+      } else if (hasInterface(arguments[0], CoordinateSequence)) {
+        const coordSeq = arguments[0]
+        return new CoordinateArraySequence(coordSeq)
+      }
+    } else if (arguments.length === 2) {
+      const size = arguments[0]
+      let dimension = arguments[1]
+      if (dimension > 3) dimension = 3
+      if (dimension < 2) return new CoordinateArraySequence(size)
+      return new CoordinateArraySequence(size, dimension)
+    }
+  }
+  interfaces_ () {
+    return [CoordinateSequenceFactory, Serializable]
+  }
+  getClass () {
+    return CoordinateArraySequenceFactory
+  }
+  static instance () {
+    return CoordinateArraySequenceFactory.instanceObject
+  }
+
+  static get serialVersionUID () { return -4099577099607551657 }
+  static get instanceObject () { return new CoordinateArraySequenceFactory() }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/geom/prep/AbstractPreparedPolygonContains.js

@@ -0,0 +1,62 @@
+import hasInterface from '../../../../../hasInterface'
+import SegmentIntersectionDetector from '../../noding/SegmentIntersectionDetector'
+import SegmentStringUtil from '../../noding/SegmentStringUtil'
+import Polygonal from '../Polygonal'
+import PreparedPolygonPredicate from './PreparedPolygonPredicate'
+
+export default class AbstractPreparedPolygonContains extends PreparedPolygonPredicate {
+  constructor (prepPoly) {
+    super(prepPoly)
+    this._requireSomePointInInterior = true
+    this._hasSegmentIntersection = false
+    this._hasProperIntersection = false
+    this._hasNonProperIntersection = false
+  }
+  eval (geom) {
+    const isAllInTargetArea = this.isAllTestComponentsInTarget(geom)
+    if (!isAllInTargetArea) return false
+    if (this._requireSomePointInInterior && geom.getDimension() === 0) {
+      const isAnyInTargetInterior = this.isAnyTestComponentInTargetInterior(geom)
+      return isAnyInTargetInterior
+    }
+    const properIntersectionImpliesNotContained = this.isProperIntersectionImpliesNotContainedSituation(geom)
+    this.findAndClassifyIntersections(geom)
+    if (properIntersectionImpliesNotContained && this._hasProperIntersection) return false
+    if (this._hasSegmentIntersection && !this._hasNonProperIntersection) return false
+    if (this._hasSegmentIntersection) {
+      return this.fullTopologicalPredicate(geom)
+    }
+    if (hasInterface(geom, Polygonal)) {
+      const isTargetInTestArea = this.isAnyTargetComponentInAreaTest(geom, this._prepPoly.getRepresentativePoints())
+      if (isTargetInTestArea) return false
+    }
+    return true
+  }
+  findAndClassifyIntersections (geom) {
+    const lineSegStr = SegmentStringUtil.extractSegmentStrings(geom)
+    const intDetector = new SegmentIntersectionDetector()
+    intDetector.setFindAllIntersectionTypes(true)
+    this._prepPoly.getIntersectionFinder().intersects(lineSegStr, intDetector)
+    this._hasSegmentIntersection = intDetector.hasIntersection()
+    this._hasProperIntersection = intDetector.hasProperIntersection()
+    this._hasNonProperIntersection = intDetector.hasNonProperIntersection()
+  }
+  isProperIntersectionImpliesNotContainedSituation (testGeom) {
+    if (hasInterface(testGeom, Polygonal)) return true
+    if (this.isSingleShell(this._prepPoly.getGeometry())) return true
+    return false
+  }
+  isSingleShell (geom) {
+    if (geom.getNumGeometries() !== 1) return false
+    const poly = geom.getGeometryN(0)
+    const numHoles = poly.getNumInteriorRing()
+    if (numHoles === 0) return true
+    return false
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return AbstractPreparedPolygonContains
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/geom/prep/BasicPreparedGeometry.js

@@ -0,0 +1,72 @@
+import PointLocator from '../../algorithm/PointLocator'
+import ComponentCoordinateExtracter from '../util/ComponentCoordinateExtracter'
+import PreparedGeometry from './PreparedGeometry'
+
+export default class BasicPreparedGeometry {
+  constructor (geom) {
+    this._baseGeom = geom || null
+    this._representativePts = ComponentCoordinateExtracter.getCoordinates(geom || null)
+  }
+  getRepresentativePoints () {
+    return this._representativePts
+  }
+  containsProperly (g) {
+    if (!this._baseGeom.getEnvelopeInternal().contains(g.getEnvelopeInternal())) return false
+    return this._baseGeom.relate(g, 'T**FF*FF*')
+  }
+  getGeometry () {
+    return this._baseGeom
+  }
+  envelopesIntersect (g) {
+    if (!this._baseGeom.getEnvelopeInternal().intersects(g.getEnvelopeInternal())) return false
+    return true
+  }
+  covers (g) {
+    return this._baseGeom.covers(g)
+  }
+  intersects (g) {
+    return this._baseGeom.intersects(g)
+  }
+  touches (g) {
+    return this._baseGeom.touches(g)
+  }
+  within (g) {
+    return this._baseGeom.within(g)
+  }
+  isAnyTargetComponentInTest (testGeom) {
+    const locator = new PointLocator()
+    for (const i = this._representativePts.iterator(); i.hasNext();) {
+      const p = i.next()
+      if (locator.intersects(p, testGeom)) return true
+    }
+    return false
+  }
+  coveredBy (g) {
+    return this._baseGeom.coveredBy(g)
+  }
+  overlaps (g) {
+    return this._baseGeom.overlaps(g)
+  }
+  toString () {
+    return this._baseGeom.toString()
+  }
+  disjoint (g) {
+    return !this.intersects(g)
+  }
+  crosses (g) {
+    return this._baseGeom.crosses(g)
+  }
+  contains (g) {
+    return this._baseGeom.contains(g)
+  }
+  envelopeCovers (g) {
+    if (!this._baseGeom.getEnvelopeInternal().covers(g.getEnvelopeInternal())) return false
+    return true
+  }
+  interfaces_ () {
+    return [PreparedGeometry]
+  }
+  getClass () {
+    return BasicPreparedGeometry
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/geom/prep/PreparedGeometry.js

@@ -0,0 +1,19 @@
+export default class PreparedGeometry {
+  containsProperly (geom) {}
+  getGeometry () {}
+  covers (geom) {}
+  intersects (geom) {}
+  touches (geom) {}
+  within (geom) {}
+  coveredBy (geom) {}
+  overlaps (geom) {}
+  disjoint (geom) {}
+  crosses (geom) {}
+  contains (geom) {}
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return PreparedGeometry
+  }
+}

package/node_modules/turf-jsts/src/org/locationtech/jts/geom/prep/PreparedGeometryFactory.js

@@ -0,0 +1,26 @@
+import PreparedPoint from './PreparedPoint'
+import hasInterface from '../../../../../hasInterface'
+import Lineal from '../Lineal'
+import PreparedLineString from './PreparedLineString'
+import Polygonal from '../Polygonal'
+import PreparedPolygon from './PreparedPolygon'
+import Puntal from '../Puntal'
+import BasicPreparedGeometry from './BasicPreparedGeometry'
+
+export default class PreparedGeometryFactory {
+  create (geom) {
+    if (hasInterface(geom, Polygonal)) return new PreparedPolygon(geom)
+    if (hasInterface(geom, Lineal)) return new PreparedLineString(geom)
+    if (hasInterface(geom, Puntal)) return new PreparedPoint(geom)
+    return new BasicPreparedGeometry(geom)
+  }
+  interfaces_ () {
+    return []
+  }
+  getClass () {
+    return PreparedGeometryFactory
+  }
+  static prepare (geom) {
+    return new PreparedGeometryFactory().create(geom)
+  }
+}