ffi-geos 0.0.6 → 0.1.0

data/README.rdoc

@@ -9,15 +9,21 @@
 
 Ruby versions known to work:
 
-* Ruby MRI 1.8.7 and 1.9.2, x86_64, OSX 10.6.5+
+* Ruby MRI 1.8.7, 1.9.2 and 1.9.3 x86_64, OSX 10.6.5+
 * Ruby MRI 1.8.7 and 1.9.2, i386, linux
-* Ruby MRI 1.8.7, x86_64, linux
-* JRuby 1.6.3, x86_64 OSX 10.6.5+
+* Ruby MRI 1.8.7, 1.9.2 and 1.9.3, x86_64, linux
+* JRuby 1.6, x86_64 OSX 10.6.5+
+
+=== JRuby Notes
 
 Note that versions of JRuby prior to version 1.6.3 have problems in their ffi
 implementation when dealing with AutoPointers that can lead to segfaults during
 garbage collection.
 
+JRuby 1.7.0 is exhibiting some strange and sporadic memory problems that are
+difficult to lock down. Unit tests show that the errors do not occur 100% of
+the time, so it has been difficult to trace the root cause of the errors.
+
 == Features
 
 ffi-geos supports all of the features found in the binary SWIG-based GEOS
@@ -54,6 +60,13 @@ Ruby bindings along with the following enhancements and additions:
 
 == New Methods and Additions (not exhaustive)
 
+* SRIDs can be copied on many operations. GEOS doesn't usually copy SRIDs
+  around, but for the sake of convenience, we do. The default behaviour for
+  SRID copying can be set via the Geos.srid_copy_policy= method. The default
+  behaviour is to use 0 values as before, but you can optionally allow for
+  copying in either a lenient or a strict sort of manner. See the documentation
+  for Geos.srid_copy_policy= for details.
+
 === Geos
 
 * Geos.create_multi_point
@@ -149,3 +162,8 @@ Ruby bindings along with the following enhancements and additions:
 
 * Charlie Savage for the original SWIG-based GEOS bindings implementation and
   some fixes for MinGW.
+
+== License
+
+This gem is licensed under an MIT-style license. See the +MIT-LICENSE+ file for
+details.

data/ffi-geos.gemspec

@@ -23,5 +23,7 @@ Gem::Specification.new do |s|
   s.add_dependency("ffi", [">= 1.0.0"])
   s.add_dependency("rdoc")
   s.add_dependency("rake", ["~> 0.9"])
+  s.add_dependency("minitest")
+  s.add_dependency("turn")
 end
 

data/lib/ffi-geos.rb

@@ -59,15 +59,19 @@ module Geos
     end
 
     def self.find_lib(lib)
-      Dir.glob(search_paths.map { |path|
-        File.expand_path(File.join(path, "#{lib}.#{FFI::Platform::LIBSUFFIX}"))
-      }).first
+      if ENV['GEOS_LIBRARY_PATH'] && File.file?(ENV['GEOS_LIBRARY_PATH'])
+        ENV['GEOS_LIBRARY_PATH']
+      else
+        Dir.glob(search_paths.map { |path|
+          File.expand_path(File.join(path, "#{lib}.#{FFI::Platform::LIBSUFFIX}"))
+        }).first
+      end
     end
 
     def self.geos_library_path
       @geos_library_path ||= begin
         # On MingW the libraries have version numbers
-        find_lib('libgeos_c{,-?}')
+        find_lib('{lib,}geos_c{,-?}')
       end
     end
 
@@ -79,8 +83,6 @@ module Geos
 
     extend ::FFI::Library
 
-    ffi_lib(geos_library_path)
-
     Geos::DimensionTypes = enum(:dimension_type, [
       :dontcare, -3,
       :non_empty, -2,
@@ -626,6 +628,11 @@ module Geos
         :int, :pointer, :pointer, :pointer
       ],
 
+      :GEOSGeomGetZ_r => [
+        # -1 on exception, *handle, *geom, *point
+        :int, :pointer, :pointer, :pointer
+      ],
+
       :GEOSGeomGetPointN_r => [
         # *point, *handle, *geom, n
         :pointer, :pointer, :pointer, :int
@@ -940,15 +947,25 @@ module Geos
       #### /Algorithms ####
     }
 
-    FFI_LAYOUT.each do |fun, ary|
-      ret = ary.shift
-      begin
-        self.class_eval do
-          attach_function(fun, ary, ret)
+    begin
+      ffi_lib(geos_library_path)
+
+      FFI_LAYOUT.each do |fun, ary|
+        ret = ary.shift
+        begin
+          self.class_eval do
+            attach_function(fun, ary, ret)
+          end
+        rescue FFI::NotFoundError
+          # that's okay
         end
-      rescue FFI::NotFoundError
-        # that's okay
       end
+
+      # Checks to see if we actually have the GEOS library loaded.
+      FFIGeos.GEOSversion
+
+    rescue LoadError, NoMethodError
+      raise LoadError.new("Couldn't load the GEOS CAPI library.")
     end
   end
 
@@ -989,6 +1006,54 @@ module Geos
       Thread.current[:ffi_geos_handle].ptr
     end
 
+    def srid_copy_policy
+      Thread.current[:ffi_geos_srid_copy_policy] ||= srid_copy_policy_default
+    end
+
+    # Sets the SRID copying behaviour. This value can be one of the values
+    # found in Geos::Constants::SRID_COPY_POLICIES and are local to the
+    # current thread. A special value of +:default+ can also be used, which
+    # will use a global default that can be set with srid_copy_policy_default=.
+    # Setting this value will cause all future threads to use this global
+    # default rather than the true default value which is set to +:zero+ for
+    # the sake of backwards compatibility with
+    #
+    # The available values for +policy+ are:
+    #
+    # * +:default+ - use the value set with srid_copy_policy_default=,
+    #   which itself is +:zero+.
+    # * +:zero+ - set all SRIDs to 0. The only exception to this is when
+    #   cloning a Geometry, in which the SRID is always copied as per the
+    #   previous behaviour.
+    # * +:lenient+ - when copying SRIDs, use the SRID of the object that the
+    #   operation is being performed on, even if operation involves multiple
+    #   Geometry objects that may have different SRIDs.
+    # * +:strict+ - when copying SRIDs, raise a Geos::MixedSRIDsError exception
+    #   if an operation is performed on mixed SRIDs. This setting
+    def srid_copy_policy=(policy)
+      if policy == :default
+        Thread.current[:ffi_geos_srid_copy_policy] = srid_copy_policy_default
+      elsif Geos::Constants::SRID_COPY_POLICIES.include?(policy)
+        Thread.current[:ffi_geos_srid_copy_policy] = policy
+      else
+        raise ArgumentError.new("Invalid SRID policy #{policy} (must be one of #{Geos::Constants::SRID_COPY_POLICIES})")
+      end
+    end
+
+    def srid_copy_policy_default
+      @srid_copy_policy_default ||= :zero
+    end
+
+    def srid_copy_policy_default=(policy)
+      if policy == :default
+        @srid_copy_policy_default = :zero
+      elsif Geos::Constants::SRID_COPY_POLICIES.include?(policy)
+        @srid_copy_policy_default = policy
+      else
+        raise ArgumentError.new("Invalid SRID policy #{policy} (must be one of #{Geos::Constants::SRID_COPY_POLICIES})")
+      end
+    end
+
     %w{
       create_point
       create_line_string
@@ -1070,6 +1135,18 @@ module Geos
       :join => :round,
       :mitre_limit => 5.0
     }.freeze
+
+    SRID_COPY_POLICIES = [
+      :zero,
+      :lenient,
+      :strict
+    ].freeze
+  end
+
+  class MixedSRIDsError < RuntimeError
+    def initialize(srid_a, srid_b)
+      super("Operation on mixed SRIDs (#{srid_a} vs. #{srid_b})")
+    end
   end
 
   include GeomTypes

data/lib/ffi-geos/coordinate_sequence.rb

@@ -95,12 +95,10 @@ module Geos
 
       @ptr = FFI::AutoPointer.new(
         ptr,
-        auto_free ? self.class.method(:release) : self.class.method(:no_release)
+        self.class.method(:release)
       )
 
-      if !auto_free
-        @ptr.autorelease = false
-      end
+      @ptr.autorelease = auto_free
 
       @x = CoordinateAccessor.new(self, 0)
       @y = CoordinateAccessor.new(self, 1)
@@ -120,9 +118,10 @@ module Geos
         FFIGeos.GEOSCoordSeq_clone_r(Geos.current_handle, source.ptr),
         self.class.method(:release)
       )
-    end
 
-    def self.no_release(ptr) #:nodoc:
+      @x = CoordinateAccessor.new(self, 0)
+      @y = CoordinateAccessor.new(self, 1)
+      @z = CoordinateAccessor.new(self, 2)
     end
 
     def self.release(ptr) #:nodoc:
@@ -144,6 +143,22 @@ module Geos
       end
     end
 
+    def [](*args)
+      if args.length == 1 && args.first.is_a?(Numeric) && args.first >= 0
+        i = args.first
+        ary = [ self.get_x(i), self.get_y(i) ]
+        ary << self.get_z(i) if self.has_z?
+        ary
+      else
+        self.to_a[*args]
+      end
+    end
+    alias :slice :[]
+
+    def has_z?
+      self.dimensions == 3
+    end
+
     # Sets the x value of a coordinate. Can also be set via #x[]=.
     def set_x(idx, val)
       self.check_bounds(idx)
@@ -215,20 +230,20 @@ module Geos
       }.read_int
     end
 
-    def to_point
-      Geos.create_point(self)
+    def to_point(options = {})
+      Geos.create_point(self, :srid => options[:srid])
     end
 
-    def to_linear_ring
-      Geos.create_linear_ring(self)
+    def to_linear_ring(options = {})
+      Geos.create_linear_ring(self, :srid => options[:srid])
     end
 
-    def to_line_string
-      Geos.create_line_string(self)
+    def to_line_string(options = {})
+      Geos.create_line_string(self, :srid => options[:srid])
     end
 
-    def to_polygon
-      Geos.create_polygon(self)
+    def to_polygon(options = {})
+      Geos.create_polygon(self, :srid => options[:srid])
     end
 
     def to_s

data/lib/ffi-geos/geometry.rb

@@ -10,12 +10,10 @@ module Geos
     def initialize(ptr, auto_free = true)
       @ptr = FFI::AutoPointer.new(
         ptr,
-        auto_free ? self.class.method(:release) : self.class.method(:no_release)
+        self.class.method(:release)
       )
 
-      if !auto_free
-        @ptr.autorelease = false
-      end
+      @ptr.autorelease = auto_free
     end
 
     def initialize_copy(source)
@@ -28,9 +26,6 @@ module Geos
       self.srid = source.srid
     end
 
-    def self.no_release(ptr) #:nodoc:
-    end
-
     def self.release(ptr) #:nodoc:
       FFIGeos.GEOSGeom_destroy_r(Geos.current_handle, ptr)
     end
@@ -80,7 +75,9 @@ module Geos
 
     def intersection(geom)
       check_geometry(geom)
-      cast_geometry_ptr(FFIGeos.GEOSIntersection_r(Geos.current_handle, self.ptr, geom.ptr))
+      cast_geometry_ptr(FFIGeos.GEOSIntersection_r(Geos.current_handle, self.ptr, geom.ptr), {
+        :srid_copy => pick_srid_from_geoms(self.srid, geom.srid)
+      })
     end
 
     if FFIGeos.respond_to?(:GEOSBufferWithParams_r)
@@ -110,7 +107,7 @@ module Geos
             raise ArgumentError.new("Expected Geos::BufferParams, a Hash or a Numeric")
         end
 
-        cast_geometry_ptr(FFIGeos.GEOSBufferWithParams_r(Geos.current_handle, self.ptr, params.ptr, width))
+        cast_geometry_ptr(FFIGeos.GEOSBufferWithParams_r(Geos.current_handle, self.ptr, params.ptr, width), :srid_copy => self.srid)
       end
     else
       def buffer(width, options = nil)
@@ -126,26 +123,31 @@ module Geos
             raise ArgumentError.new("Expected Geos::BufferParams, a Hash or a Numeric")
         end
 
-        cast_geometry_ptr(FFIGeos.GEOSBuffer_r(Geos.current_handle, self.ptr, width, quad_segs))
+        cast_geometry_ptr(FFIGeos.GEOSBuffer_r(Geos.current_handle, self.ptr, width, quad_segs), :srid_copy => self.srid)
       end
     end
 
     def convex_hull
-      cast_geometry_ptr(FFIGeos.GEOSConvexHull_r(Geos.current_handle, self.ptr))
+      cast_geometry_ptr(FFIGeos.GEOSConvexHull_r(Geos.current_handle, self.ptr), :srid_copy => self.srid)
     end
 
     def difference(geom)
       check_geometry(geom)
-      cast_geometry_ptr(FFIGeos.GEOSDifference_r(Geos.current_handle, self.ptr, geom.ptr))
+      cast_geometry_ptr(FFIGeos.GEOSDifference_r(Geos.current_handle, self.ptr, geom.ptr), {
+        :srid_copy => pick_srid_from_geoms(self.srid, geom.srid)
+      })
     end
 
     def sym_difference(geom)
       check_geometry(geom)
-      cast_geometry_ptr(FFIGeos.GEOSSymDifference_r(Geos.current_handle, self.ptr, geom.ptr))
+      cast_geometry_ptr(FFIGeos.GEOSSymDifference_r(Geos.current_handle, self.ptr, geom.ptr), {
+        :srid_copy => pick_srid_from_geoms(self.srid, geom.srid)
+      })
     end
+    alias :symmetric_difference :sym_difference
 
     def boundary
-      cast_geometry_ptr(FFIGeos.GEOSBoundary_r(Geos.current_handle, self.ptr))
+      cast_geometry_ptr(FFIGeos.GEOSBoundary_r(Geos.current_handle, self.ptr), :srid_copy => self.srid)
     end
 
     # Calling without a geom argument is equivalent to calling unary_union when
@@ -154,7 +156,9 @@ module Geos
     def union(geom = nil)
       if geom
         check_geometry(geom)
-        cast_geometry_ptr(FFIGeos.GEOSUnion_r(Geos.current_handle, self.ptr, geom.ptr))
+        cast_geometry_ptr(FFIGeos.GEOSUnion_r(Geos.current_handle, self.ptr, geom.ptr), {
+          :srid_copy => pick_srid_from_geoms(self.srid, geom.srid)
+        })
       else
         if self.respond_to?(:unary_union)
           self.unary_union
@@ -165,27 +169,32 @@ module Geos
     end
 
     def union_cascaded
-      cast_geometry_ptr(FFIGeos.GEOSUnionCascaded_r(Geos.current_handle, self.ptr))
+      cast_geometry_ptr(FFIGeos.GEOSUnionCascaded_r(Geos.current_handle, self.ptr), {
+        :srid_copy => self.srid
+      })
     end
 
     if FFIGeos.respond_to?(:GEOSUnaryUnion_r)
       # Available in GEOS 3.3+
       def unary_union
-        cast_geometry_ptr(FFIGeos.GEOSUnaryUnion_r(Geos.current_handle, self.ptr))
+        cast_geometry_ptr(FFIGeos.GEOSUnaryUnion_r(Geos.current_handle, self.ptr), {
+          :srid_copy => self.srid
+        })
       end
     end
 
     def point_on_surface
-      cast_geometry_ptr(FFIGeos.GEOSPointOnSurface_r(Geos.current_handle, self.ptr))
+      cast_geometry_ptr(FFIGeos.GEOSPointOnSurface_r(Geos.current_handle, self.ptr), :srid_copy => self.srid)
     end
+    alias :representative_point :point_on_surface
 
     def centroid
-      cast_geometry_ptr(FFIGeos.GEOSGetCentroid_r(Geos.current_handle, self.ptr))
+      cast_geometry_ptr(FFIGeos.GEOSGetCentroid_r(Geos.current_handle, self.ptr), :srid_copy => self.srid)
     end
     alias :center :centroid
 
     def envelope
-      cast_geometry_ptr(FFIGeos.GEOSEnvelope_r(Geos.current_handle, self.ptr))
+      cast_geometry_ptr(FFIGeos.GEOSEnvelope_r(Geos.current_handle, self.ptr), :srid_copy => self.srid)
     end
 
     # Returns the Dimensionally Extended Nine-Intersection Model (DE-9IM)
@@ -211,19 +220,19 @@ module Geos
     end
 
     def line_merge
-      cast_geometry_ptr(FFIGeos.GEOSLineMerge_r(Geos.current_handle, self.ptr))
+      cast_geometry_ptr(FFIGeos.GEOSLineMerge_r(Geos.current_handle, self.ptr), :srid_copy => self.srid)
     end
 
     def simplify(tolerance)
-      cast_geometry_ptr(FFIGeos.GEOSSimplify_r(Geos.current_handle, self.ptr, tolerance))
+      cast_geometry_ptr(FFIGeos.GEOSSimplify_r(Geos.current_handle, self.ptr, tolerance), :srid_copy => self.srid)
     end
 
     def topology_preserve_simplify(tolerance)
-      cast_geometry_ptr(FFIGeos.GEOSTopologyPreserveSimplify_r(Geos.current_handle, self.ptr, tolerance))
+      cast_geometry_ptr(FFIGeos.GEOSTopologyPreserveSimplify_r(Geos.current_handle, self.ptr, tolerance), :srid_copy => self.srid)
     end
 
     def extract_unique_points
-      cast_geometry_ptr(FFIGeos.GEOSGeom_extractUniquePoints_r(Geos.current_handle, self.ptr))
+      cast_geometry_ptr(FFIGeos.GEOSGeom_extractUniquePoints_r(Geos.current_handle, self.ptr), :srid_copy => self.srid)
     end
     alias :unique_points :extract_unique_points
 
@@ -311,11 +320,21 @@ module Geos
       bool_result(FFIGeos.GEOSEquals_r(Geos.current_handle, self.ptr, geom.ptr))
     end
     alias :== :eql?
+    alias :equals? :eql?
 
     def eql_exact?(geom, tolerance)
       check_geometry(geom)
       bool_result(FFIGeos.GEOSEqualsExact_r(Geos.current_handle, self.ptr, geom.ptr, tolerance))
     end
+    alias :equals_exact? :eql_exact?
+    alias :exactly_equals? :eql_exact?
+
+    def eql_almost?(geom, decimal = 6)
+      check_geometry(geom)
+      bool_result(FFIGeos.GEOSEqualsExact_r(Geos.current_handle, self.ptr, geom.ptr, 0.5 * 10 ** (-decimal)))
+    end
+    alias :equals_almost? :eql_almost?
+    alias :almost_equals? :eql_almost?
 
     def empty?
       bool_result(FFIGeos.GEOSisEmpty_r(Geos.current_handle, self.ptr))
@@ -348,7 +367,9 @@ module Geos
       if !valid
         {
           :detail => detail.read_pointer.read_string,
-          :location => cast_geometry_ptr(location.read_pointer)
+          :location => cast_geometry_ptr(location.read_pointer, {
+            :srid_copy => self.srid
+          })
         }
       end
     end
@@ -390,7 +411,7 @@ module Geos
         FFIGeos.GEOSInterpolate_r(Geos.current_handle, self.ptr, d)
       end
 
-      cast_geometry_ptr(ret)
+      cast_geometry_ptr(ret, :srid_copy => self.srid)
     end
 
     def interpolate_normalized(d)
@@ -398,23 +419,31 @@ module Geos
     end
 
     def start_point
-      cast_geometry_ptr(FFIGeos.GEOSGeomGetStartPoint_r(Geos.current_handle, self.ptr))
+      cast_geometry_ptr(FFIGeos.GEOSGeomGetStartPoint_r(Geos.current_handle, self.ptr), :srid_copy => self.srid)
     end
 
     def end_point
-      cast_geometry_ptr(FFIGeos.GEOSGeomGetEndPoint_r(Geos.current_handle, self.ptr))
+      cast_geometry_ptr(FFIGeos.GEOSGeomGetEndPoint_r(Geos.current_handle, self.ptr), :srid_copy => self.srid)
     end
 
     def area
-      FFI::MemoryPointer.new(:double).tap { |ret|
-        FFIGeos.GEOSArea_r(Geos.current_handle, self.ptr, ret)
-      }.read_double
+      if self.empty?
+        0
+      else
+        FFI::MemoryPointer.new(:double).tap { |ret|
+          FFIGeos.GEOSArea_r(Geos.current_handle, self.ptr, ret)
+        }.read_double
+      end
     end
 
     def length
-      FFI::MemoryPointer.new(:double).tap { |ret|
-        FFIGeos.GEOSLength_r(Geos.current_handle, self.ptr, ret)
-      }.read_double
+      if self.empty?
+        0
+      else
+        FFI::MemoryPointer.new(:double).tap { |ret|
+          FFIGeos.GEOSLength_r(Geos.current_handle, self.ptr, ret)
+        }.read_double
+      end
     end
 
     def distance(geom)
@@ -437,13 +466,17 @@ module Geos
 
     def snap(geom, tolerance)
       check_geometry(geom)
-      cast_geometry_ptr(FFIGeos.GEOSSnap_r(Geos.current_handle, self.ptr, geom.ptr, tolerance))
+      cast_geometry_ptr(FFIGeos.GEOSSnap_r(Geos.current_handle, self.ptr, geom.ptr, tolerance), {
+        :srid_copy => pick_srid_from_geoms(self.srid, geom.srid)
+      })
     end
     alias :snap_to :snap
 
     def shared_paths(geom)
       check_geometry(geom)
-      cast_geometry_ptr(FFIGeos.GEOSSharedPaths_r(Geos.current_handle, self.ptr, geom.ptr)).to_a
+      cast_geometry_ptr(FFIGeos.GEOSSharedPaths_r(Geos.current_handle, self.ptr, geom.ptr), {
+        :srid_copy => pick_srid_from_geoms(self.srid, geom.srid)
+      }).to_a
     end
 
     # Returns a Hash with the following structure:
@@ -460,12 +493,14 @@ module Geos
       invalid_rings = FFI::MemoryPointer.new(:pointer)
 
       rings = cast_geometry_ptr(
-        FFIGeos.GEOSPolygonize_full_r(Geos.current_handle, self.ptr, cuts, dangles, invalid_rings)
+        FFIGeos.GEOSPolygonize_full_r(Geos.current_handle, self.ptr, cuts, dangles, invalid_rings), {
+          :srid_copy => self.srid
+        }
       )
 
-      cuts = cast_geometry_ptr(cuts.read_pointer)
-      dangles = cast_geometry_ptr(dangles.read_pointer)
-      invalid_rings = cast_geometry_ptr(invalid_rings.read_pointer)
+      cuts = cast_geometry_ptr(cuts.read_pointer, :srid_copy => self.srid)
+      dangles = cast_geometry_ptr(dangles.read_pointer, :srid_copy => self.srid)
+      invalid_rings = cast_geometry_ptr(invalid_rings.read_pointer, :srid_copy => self.srid)
 
       {
         :rings => rings.to_a,
@@ -479,14 +514,14 @@ module Geos
       ary = FFI::MemoryPointer.new(:pointer)
       ary.write_array_of_pointer([ self.ptr ])
 
-      cast_geometry_ptr(FFIGeos.GEOSPolygonize_r(Geos.current_handle, ary, 1)).to_a
+      cast_geometry_ptr(FFIGeos.GEOSPolygonize_r(Geos.current_handle, ary, 1), :srid_copy => self.srid).to_a
     end
 
     def polygonize_cut_edges
       ary = FFI::MemoryPointer.new(:pointer)
       ary.write_array_of_pointer([ self.ptr ])
 
-      cast_geometry_ptr(FFIGeos.GEOSPolygonizer_getCutEdges_r(Geos.current_handle, ary, 1)).to_a
+      cast_geometry_ptr(FFIGeos.GEOSPolygonizer_getCutEdges_r(Geos.current_handle, ary, 1), :srid_copy => self.srid).to_a
     end
 
     def to_prepared