ffi-geos 0.0.1.beta1

data/lib/geometry_collection.rb

@@ -0,0 +1,28 @@
+
+module Geos
+  class GeometryCollection < Geometry
+    include Enumerable
+
+    # Yields each Geometry in the GeometryCollection.
+    def each
+      self.num_geometries.times do |n|
+        yield self.get_geometry_n(n)
+      end
+      nil
+    end
+
+    def get_geometry_n(n)
+      if n < 0 || n >= self.num_geometries
+        nil
+      else
+        cast_geometry_ptr(FFIGeos.GEOSGetGeometryN_r(Geos.current_handle, self.ptr, n), false)
+      end
+    end
+
+    def [](*args)
+      self.to_a[*args]
+    end
+    alias :slice :[]
+    alias :at :[]
+  end
+end

data/lib/line_string.rb

@@ -0,0 +1,61 @@
+
+module Geos
+  class LineString < Geometry
+    include Enumerable
+
+    def each
+      self.num_points.times do |n|
+        yield self.point_n(n)
+      end
+      nil
+    end
+
+    if FFIGeos.respond_to?(:GEOSGeomGetNumPoints_r)
+      def num_points
+        FFIGeos.GEOSGeomGetNumPoints_r(Geos.current_handle, self.ptr)
+      end
+    else
+      def num_points
+        self.coord_seq.length
+      end
+    end
+
+    def point_n(n)
+      if n < 0 || n >= self.num_points
+        raise RuntimeError.new("Index out of bounds")
+      else
+        cast_geometry_ptr(FFIGeos.GEOSGeomGetPointN_r(Geos.current_handle, self.ptr, n))
+      end
+    end
+
+    def [](*args)
+      self.to_a[*args]
+    end
+    alias :slice :[]
+
+    def buffer_single_sided(width, options = {})
+      options = {
+        :quad_segs => 8,
+        :join => :round,
+        :mitre_limit => 5.0,
+        :left_side => false
+      }.merge(options)
+
+      cast_geometry_ptr(FFIGeos.GEOSSingleSidedBuffer_r(
+          Geos.current_handle,
+          self.ptr,
+          width,
+          options[:quad_segs],
+          options[:join],
+          options[:mitre_limit],
+          options[:left_side] ? 1 : 0
+      ))
+    end
+
+    if FFIGeos.respond_to?(:GEOSisClosed_r)
+      def closed?
+        bool_result(FFIGeos.GEOSisClosed_r(Geos.current_handle, self.ptr))
+      end
+    end
+  end
+end

data/lib/linear_ring.rb

@@ -0,0 +1,5 @@
+
+module Geos
+  class LinearRing < LineString
+  end
+end

data/lib/multi_line_string.rb

@@ -0,0 +1,5 @@
+
+module Geos
+  class MultiLineString < GeometryCollection
+  end
+end

data/lib/multi_point.rb

@@ -0,0 +1,5 @@
+
+module Geos
+  class MultiPoint < GeometryCollection
+  end
+end

data/lib/multi_polygon.rb

@@ -0,0 +1,5 @@
+
+module Geos
+  class MultiPolygon < GeometryCollection
+  end
+end

data/lib/point.rb

@@ -0,0 +1,22 @@
+
+module Geos
+  class Point < Geometry
+    if FFIGeos.respond_to?(:GEOSGeomGetX_r)
+      def get_x
+        FFI::MemoryPointer.new(:double).tap { |ret|
+          FFIGeos.GEOSGeomGetX_r(Geos.current_handle, self.ptr, ret)
+        }.read_double
+      end
+      alias :x :get_x
+    end
+
+    if FFIGeos.respond_to?(:GEOSGeomGetY_r)
+      def get_y
+        FFI::MemoryPointer.new(:double).tap { |ret|
+          FFIGeos.GEOSGeomGetY_r(Geos.current_handle, self.ptr, ret)
+        }.read_double
+      end
+      alias :y :get_y
+    end
+  end
+end

data/lib/polygon.rb

@@ -0,0 +1,20 @@
+
+module Geos
+  class Polygon < Geometry
+    def num_interior_rings
+      FFIGeos.GEOSGetNumInteriorRings_r(Geos.current_handle, self.ptr)
+    end
+
+    def interior_ring_n(n)
+      if n < 0 || n >= self.num_interior_rings
+        raise RuntimeError.new("Index out of bounds")
+      else
+        cast_geometry_ptr(FFIGeos.GEOSGetInteriorRingN_r(Geos.current_handle, self.ptr, n), false)
+      end
+    end
+
+    def exterior_ring
+      cast_geometry_ptr(FFIGeos.GEOSGetExteriorRing_r(Geos.current_handle, self.ptr), false)
+    end
+  end
+end

data/lib/prepared_geometry.rb

@@ -0,0 +1,42 @@
+
+module Geos
+  class PreparedGeometry
+    include Geos::Tools
+
+    attr_reader :ptr
+
+    def initialize(ptr, auto_free = true)
+      @ptr = FFI::AutoPointer.new(
+        ptr,
+        auto_free ? self.class.method(:release) : self.class.method(:no_release)
+      )
+    end
+
+    def self.no_release(ptr) #:nodoc:
+    end
+
+    def self.release(ptr) #:nodoc:
+      FFIGeos.GEOSPreparedGeom_destroy_r(Geos.current_handle, ptr)
+    end
+
+    def contains?(geom)
+      check_geometry(geom)
+      bool_result(FFIGeos.GEOSPreparedContains_r(Geos.current_handle, self.ptr, geom.ptr))
+    end
+
+    def contains_properly?(geom)
+      check_geometry(geom)
+      bool_result(FFIGeos.GEOSPreparedContainsProperly_r(Geos.current_handle, self.ptr, geom.ptr))
+    end
+
+    def covers?(geom)
+      check_geometry(geom)
+      bool_result(FFIGeos.GEOSPreparedCovers_r(Geos.current_handle, self.ptr, geom.ptr))
+    end
+
+    def intersects?(geom)
+      check_geometry(geom)
+      bool_result(FFIGeos.GEOSPreparedIntersects_r(Geos.current_handle, self.ptr, geom.ptr))
+    end
+  end
+end

data/lib/strtree.rb

@@ -0,0 +1,111 @@
+
+module Geos
+  class STRtree
+    include Geos::Tools
+    include Enumerable
+
+    attr_reader :ptr
+
+    def initialize(capacity)
+      ptr = FFIGeos.GEOSSTRtree_create_r(Geos.current_handle, capacity)
+
+      @ptr = FFI::AutoPointer.new(
+        ptr,
+        self.class.method(:release)
+      )
+
+      @storage = {}
+      @storage_pointers = {}
+      @storage_key = 0
+      @built = false
+    end
+
+    def self.release(ptr) #:nodoc:
+      FFIGeos.GEOSSTRtree_destroy_r(Geos.current_handle, ptr)
+    end
+
+    def built?
+      @built
+    end
+
+    def next_key
+      @storage_key += 1
+    end
+    private :next_key
+
+    def insert(geom, item)
+      check_geometry(geom)
+
+      if self.built?
+        raise RuntimeError.new("STRtree has already been built")
+      else
+        key = next_key
+        key_ptr = FFI::MemoryPointer.new(:pointer)
+        key_ptr.write_int(key)
+
+        @storage[key] = item
+        @storage_pointers[key] = key_ptr
+        FFIGeos.GEOSSTRtree_insert_r(Geos.current_handle, self.ptr, geom.ptr, key_ptr)
+      end
+    end
+
+    def remove(geom, item)
+      check_geometry(geom)
+
+      key = if @storage.respond_to?(:key)
+        @storage.key(item)
+      else
+        @storage.index(item)
+      end
+
+      if key
+        key_ptr = @storage_pointers[key]
+        result = FFIGeos.GEOSSTRtree_remove_r(Geos.current_handle, self.ptr, geom.ptr, key_ptr)
+        @built = true
+
+        if result == 1
+          @storage[key] = nil
+          @storage_pointers[key] = nil
+        end
+      end
+    end
+
+    def query(geom)
+      check_geometry(geom)
+
+      @built = true
+      retval = nil
+
+      callback = if block_given?
+        proc { |*args|
+          key = args.first.read_int
+          yield(@storage[key])
+        }
+      else
+        retval = []
+        proc { |*args|
+          retval << @storage[args.first.read_int]
+        }
+      end
+
+      FFIGeos.GEOSSTRtree_query_r(
+        Geos.current_handle,
+        self.ptr,
+        geom.ptr,
+        callback,
+        nil
+      )
+
+      if retval
+        retval.compact
+      end
+      retval
+    end
+
+    def iterate
+      @storage.values.each do |v|
+        yield(v)
+      end
+    end
+  end
+end

data/lib/tools.rb

@@ -0,0 +1,54 @@
+
+module Geos
+  module Tools
+    include GeomTypes
+
+    def cast_geometry_ptr(geom_ptr, auto_free = true)
+      if geom_ptr.null?
+        raise RuntimeError.new("Tried to create a Geometry from a NULL pointer!")
+      end
+
+      klass = case FFIGeos.GEOSGeomTypeId_r(Geos.current_handle, geom_ptr)
+        when GEOS_POINT
+          Point
+        when GEOS_LINESTRING
+          LineString
+        when GEOS_LINEARRING
+          LinearRing
+        when GEOS_POLYGON
+          Polygon
+        when GEOS_MULTIPOINT
+          MultiPoint
+        when GEOS_MULTILINESTRING
+          MultiLineString
+        when GEOS_MULTIPOLYGON
+          MultiPolygon
+        when GEOS_GEOMETRYCOLLECTION
+          GeometryCollection
+        else
+          raise RuntimeError.new("Invalid geometry type")
+      end
+
+      klass.new(geom_ptr, auto_free)
+    end
+
+    def check_geometry(geom)
+      raise TypeError.new("Expected Geos::Geometry") unless geom.is_a?(Geos::Geometry)
+    end
+
+    def bool_result(r)
+      case r
+      when 1
+        true
+      when 0
+        false
+      else
+        raise RuntimeError.new("Unexpected boolean result: #{r}")
+      end
+    end
+
+    def check_enum_value(enum, value)
+      raise TypeError.new("Couldn't find valid #{enum.tag} value: #{value}") unless enum[value]
+    end
+  end
+end

data/lib/utils.rb

@@ -0,0 +1,145 @@
+
+module Geos
+  module Utils
+    class << self
+      include Geos::Tools
+
+      if FFIGeos.respond_to?(:GEOSOrientationIndex_r)
+        # Available in GEOS 3.3+.
+        def orientation_index(ax, ay, bx, by, px, py)
+          FFIGeos.GEOSOrientationIndex_r(
+            Geos.current_handle,
+            ax, ay, bx, by, px, py
+          )
+        end
+      end
+
+      if FFIGeos.respond_to?(:GEOSRelatePatternMatch_r)
+        # Available in GEOS 3.3+.
+        def relate_match(mat, pat)
+          bool_result(FFIGeos.GEOSRelatePatternMatch_r(Geos.current_handle, mat, pat))
+        end
+      end
+
+      def create_point(cs)
+        if cs.length != 1
+          raise RuntimeError.new("IllegalArgumentException: Point coordinate list must contain a single element")
+        end
+
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createPoint_r(Geos.current_handle, cs.ptr)).tap {
+          cs.ptr.autorelease = false
+        }
+      end
+
+      def create_line_string(cs)
+        if cs.length <= 1 && cs.length != 0
+          raise RuntimeError.new("IllegalArgumentException: point array must contain 0 or >1 elements")
+        end
+
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createLineString_r(Geos.current_handle, cs.ptr)).tap {
+          cs.ptr.autorelease = false
+        }
+      end
+
+      def create_linear_ring(cs)
+        if cs.length <= 1 && cs.length != 0
+          raise RuntimeError.new("IllegalArgumentException: point array must contain 0 or >1 elements")
+        end
+
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createLinearRing_r(Geos.current_handle, cs.ptr)).tap {
+          cs.ptr.autorelease = false
+        }
+      end
+
+      def create_polygon(outer, *inner)
+        inner = Array(inner).flatten.tap { |i|
+          if i.detect { |g| !g.is_a?(Geos::LinearRing) }
+            raise TypeError.new("Expected inner Array to contain Geometry::LinearRing objects")
+          end
+        }
+
+        ary = FFI::MemoryPointer.new(:pointer, inner.length)
+        ary.write_array_of_pointer(inner.map(&:ptr))
+
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createPolygon_r(Geos.current_handle, outer.ptr, ary, inner.length)).tap {
+          outer.ptr.autorelease = false
+          inner.each { |i| i.ptr.autorelease = false }
+        }
+      end
+
+      def create_empty_point
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyPoint_r(Geos.current_handle))
+      end
+
+      def create_empty_line_string
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyLineString_r(Geos.current_handle))
+      end
+
+      def create_empty_polygon
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyPolygon_r(Geos.current_handle))
+      end
+
+      def create_empty_collection(t)
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyCollection_r(Geos.current_handle, t))
+      end
+
+      def create_empty_multi_point
+        create_empty_collection(Geos::GeomTypes::GEOS_MULTIPOINT)
+      end
+
+      def create_empty_multi_line_string
+        create_empty_collection(Geos::GeomTypes::GEOS_MULTILINESTRING)
+      end
+
+      def create_empty_multi_polygon
+        create_empty_collection(Geos::GeomTypes::GEOS_MULTIPOLYGON)
+      end
+
+      def create_empty_geometry_collection
+        create_empty_collection(Geos::GeomTypes::GEOS_GEOMETRYCOLLECTION)
+      end
+
+      def create_collection(t, *geoms)
+        klass = case t
+          when Geos::GeomTypes::GEOS_MULTIPOINT
+            Geos::Point
+          when Geos::GeomTypes::GEOS_MULTILINESTRING
+            Geos::LineString
+          when Geos::GeomTypes::GEOS_MULTIPOLYGON
+            Geos::Polygon
+          when Geos::GeomTypes::GEOS_GEOMETRYCOLLECTION
+            Geos::Geometry
+        end
+
+        geoms = Array(geoms).flatten.tap { |i|
+          if i.detect { |g| !g.is_a?(klass) }
+            raise TypeError.new("Expected geoms Array to contain #{klass} objects")
+          end
+        }
+
+        ary = FFI::MemoryPointer.new(:pointer, geoms.length)
+        ary.write_array_of_pointer(geoms.map(&:ptr))
+
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createCollection_r(Geos.current_handle, t, ary, geoms.length)).tap {
+          geoms.each { |i| i.ptr.autorelease = false }
+        }
+      end
+
+      def create_multi_point(*geoms)
+        create_collection(Geos::GeomTypes::GEOS_MULTIPOINT, *geoms)
+      end
+
+      def create_multi_line_string(*geoms)
+        create_collection(Geos::GeomTypes::GEOS_MULTILINESTRING, *geoms)
+      end
+
+      def create_multi_polygon(*geoms)
+        create_collection(Geos::GeomTypes::GEOS_MULTIPOLYGON, *geoms)
+      end
+
+      def create_geometry_collection(*geoms)
+        create_collection(Geos::GeomTypes::GEOS_GEOMETRYCOLLECTION, *geoms)
+      end
+    end
+  end
+end