ffi-geos 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8a4b9c08a3bc02eae724aa2cadfc9ece840ac21a
-  data.tar.gz: f7cd4fad310f187c6d89314c286ac541c7c9ab43
+  metadata.gz: ccb3a99801ff6039bf36d14f2d0be9cd7a084aa7
+  data.tar.gz: 183a295b0c845bbc1fb856d98ddf9771c6f1a4ee
 SHA512:
-  metadata.gz: 8948b1bb43ed78ae20cfbe273b77c9795b6ec90f475ae7b42b627c76ae11cbdebc4e9ad7e31b63b3e20cc21283595c422e3fd14e2878988b350cff859fc6f50f
-  data.tar.gz: 4280e8773e0ad61616e54066a98131fcbc9849a692e1c433e5d93534e2294cefa39926b751e7a0fddeee61bbe1cb764ec256b68ded7757a45d0832e4f89e3e6c
+  metadata.gz: 951a4938f5844873b3cd3d0d0fe6ae6cbee3e336380a18b9fe9af4777cc4c4526c932685472750d118671ea3f139c10c983909fb3bab8b18e44c8761072891ff
+  data.tar.gz: 054b81d1f27bb26f5c2220fa2618cdd1a1eef4ef74668c658133728a34a9e4a69ca7335968cde10cfda47d7133b6d584a9fe4d1805158c57c1c401a10b7250f7

data/.travis.yml

@@ -2,12 +2,15 @@ cache: bundler
 sudo: false
 language: ruby
 rvm:
-  - 2.2.3
-  - 2.1.7
-  - 2.0.0
-  - 1.9.3
-  - rbx-2
+  - 2.4.0
+  - 2.3.3
+  - 2.2.6
+  - rbx-3
   - jruby-19mode
+matrix:
+  allow_failures:
+    - rvm: rbx-3
+    - rvm: jruby-19mode
 addons:
   apt:
     packages:

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2016 J Smith <dark.panda@gmail.com>
+Copyright (c) 2010-2017 J Smith <dark.panda@gmail.com>
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/lib/ffi-geos.rb

@@ -1,4 +1,5 @@
 # encoding: UTF-8
+# frozen_string_literal: true
 
 require 'ffi'
 require 'rbconfig'
@@ -135,6 +136,11 @@ module Geos
       :geometry_collection, 7
     ])
 
+    Geos::PrecisionOptions = enum(:precision_option, [
+      :no_topology, 1 << 0,
+      :keep_collapsed, 1 << 1
+    ])
+
     FFI_LAYOUT = {
       #### Utility functions ####
 
@@ -712,6 +718,36 @@ module Geos
         # *point, *handle, *geom
         :pointer, :pointer, :pointer
       ],
+
+      :GEOSGeom_setPrecision_r => [
+        # *geom, *hande, *geom, grid_size, int flags
+        :pointer, :pointer, :pointer, :double, :int
+      ],
+
+      :GEOSGeom_getPrecision_r => [
+        # precision, *hande, *geom
+        :double, :pointer, :pointer
+      ],
+
+      :GEOSMinimumRotatedRectangle_r => [
+        # *geom, *handle, *geom
+        :pointer, :pointer, :pointer
+      ],
+
+      :GEOSMinimumClearance_r => [
+        # 0 on success, *handle, *geom, *clearance
+        :int, :pointer, :pointer, :pointer
+      ],
+
+      :GEOSMinimumClearanceLine_r => [
+        # *geom, *handle, *geom
+        :pointer, :pointer, :pointer
+      ],
+
+      :GEOSMinimumWidth_r => [
+        # *geom, *handle, *geom
+        :pointer, :pointer, :pointer
+      ],
       #### /Geometry functions ####
 
       #### STRtree functions ####
@@ -744,6 +780,11 @@ module Geos
         # void, *handle, *tree
         :void, :pointer, :pointer
       ],
+
+      :GEOSSTRtree_nearest_generic_r => [
+        # *void, *handle, *tree, *item, *item_envelope, int distance_callback(*item_1, *item_2, *double, void *user_data), *user_data
+        :pointer, :pointer, :pointer, :pointer, :pointer, callback([ :pointer, :pointer, :pointer, :pointer ], :int), :pointer
+      ],
       #### /STRtree functions ####
 
       #### PreparedGeometry functions ####
@@ -1041,21 +1082,51 @@ module Geos
       def initialize
         @ptr = FFI::AutoPointer.new(FFIGeos.GEOS_init_r, self.class.method(:release))
 
-        FFIGeos.GEOSContext_setNoticeMessageHandler_r(@ptr, @notice_handler = self.method(:notice_handler), nil)
-        FFIGeos.GEOSContext_setErrorMessageHandler_r(@ptr, @error_handler = self.method(:error_handler), nil)
+        reset_notice_handler
+        reset_error_handler
       end
 
       def self.release(ptr)
         FFIGeos.GEOS_finish_r(ptr)
       end
 
+      def notice_handler=(method_or_block)
+        @notice_handler = method_or_block
+        FFIGeos.GEOSContext_setNoticeMessageHandler_r(@ptr, @notice_handler, nil)
+        @notice_handler
+      end
+
+      def error_handler=(method_or_block)
+        @error_handler = method_or_block
+        FFIGeos.GEOSContext_setErrorMessageHandler_r(@ptr, @error_handler, nil)
+        @error_handler
+      end
+
+      def notice_handler(&block)
+        self.notice_handler = block if block_given?
+        @notice_handler
+      end
+
+      def error_handler(&block)
+        self.error_handler = block if block_given?
+        @error_handler
+      end
+
+      def reset_notice_handler
+        self.notice_handler = self.method(:default_notice_handler)
+      end
+
+      def reset_error_handler
+        self.error_handler = self.method(:default_error_handler)
+      end
+
     # Deprecated initialization and teardown...
     else
       def initialize
         @ptr = FFI::AutoPointer.new(
           FFIGeos.initGEOS_r(
-            @notice_handler = self.method(:notice_handler),
-            @error_handler = self.method(:error_handler)
+            @notice_handler = self.method(:default_notice_handler),
+            @error_handler = self.method(:default_error_handler)
           ),
           self.class.method(:release)
         )
@@ -1064,14 +1135,22 @@ module Geos
       def self.release(ptr)
         FFIGeos.finishGEOS_r(ptr)
       end
+
+      def notice_handler
+        @notice_handler
+      end
+
+      def error_handler
+        @error_handler
+      end
     end
 
     private
-      def notice_handler(*args)
-        # no-op, just to appease initGEOS.
+      def default_notice_handler(*args)
+        # no-op
       end
 
-      def error_handler(*args)
+      def default_error_handler(*args)
         raise Geos::GEOSException.new(args[0] % args[1])
       end
   end
@@ -1087,7 +1166,10 @@ module Geos
 
     def current_handle
       Thread.current[:ffi_geos_handle] ||= Geos::Handle.new
-      Thread.current[:ffi_geos_handle].ptr
+    end
+
+    def current_handle_pointer
+      current_handle.ptr
     end
 
     def srid_copy_policy

data/lib/ffi-geos/buffer_params.rb

@@ -1,4 +1,5 @@
 # encoding: UTF-8
+# frozen_string_literal: true
 
 module Geos
   class BufferParams
@@ -24,7 +25,7 @@ module Geos
       def initialize(params = {})
         params = Geos::Constants::BUFFER_PARAM_DEFAULTS.merge(params)
 
-        ptr = FFIGeos.GEOSBufferParams_create_r(Geos.current_handle)
+        ptr = FFIGeos.GEOSBufferParams_create_r(Geos.current_handle_pointer)
         @ptr = FFI::AutoPointer.new(
           ptr,
           self.class.method(:release)
@@ -37,13 +38,13 @@ module Geos
       end
 
       def self.release(ptr) #:nodoc:
-        FFIGeos.GEOSBufferParams_destroy_r(Geos.current_handle, ptr)
+        FFIGeos.GEOSBufferParams_destroy_r(Geos.current_handle_pointer, ptr)
       end
 
       def endcap=(value)
         check_enum_value(Geos::BufferCapStyles, value)
 
-        if bool_result(FFIGeos.GEOSBufferParams_setEndCapStyle_r(Geos.current_handle, ptr, value))
+        if bool_result(FFIGeos.GEOSBufferParams_setEndCapStyle_r(Geos.current_handle_pointer, ptr, value))
           @params[:endcap] = symbol_for_enum(Geos::BufferCapStyles, value)
         end
       end
@@ -51,25 +52,25 @@ module Geos
       def join=(value)
         check_enum_value(Geos::BufferJoinStyles, value)
 
-        if bool_result(FFIGeos.GEOSBufferParams_setJoinStyle_r(Geos.current_handle, ptr, value))
+        if bool_result(FFIGeos.GEOSBufferParams_setJoinStyle_r(Geos.current_handle_pointer, ptr, value))
           @params[:join] = symbol_for_enum(Geos::BufferJoinStyles, value)
         end
       end
 
       def mitre_limit=(value)
-        if bool_result(FFIGeos.GEOSBufferParams_setMitreLimit_r(Geos.current_handle, ptr, value))
+        if bool_result(FFIGeos.GEOSBufferParams_setMitreLimit_r(Geos.current_handle_pointer, ptr, value))
           @params[:mitre_limit] = value
         end
       end
 
       def quad_segs=(value)
-        if bool_result(FFIGeos.GEOSBufferParams_setQuadrantSegments_r(Geos.current_handle, ptr, value))
+        if bool_result(FFIGeos.GEOSBufferParams_setQuadrantSegments_r(Geos.current_handle_pointer, ptr, value))
           @params[:quad_segs] = value
         end
       end
 
       def single_sided=(value)
-        if bool_result(FFIGeos.GEOSBufferParams_setSingleSided_r(Geos.current_handle, ptr, Geos::Tools.bool_to_int(value)))
+        if bool_result(FFIGeos.GEOSBufferParams_setSingleSided_r(Geos.current_handle_pointer, ptr, Geos::Tools.bool_to_int(value)))
           @params[:single_sided] = value
         end
       end

data/lib/ffi-geos/coordinate_sequence.rb

@@ -1,4 +1,5 @@
 # encoding: UTF-8
+# frozen_string_literal: true
 
 module Geos
 
@@ -91,7 +92,7 @@ module Geos
         size ||= 0
         dimensions ||= 0
 
-        [ FFIGeos.GEOSCoordSeq_create_r(Geos.current_handle, size, dimensions), true ]
+        [ FFIGeos.GEOSCoordSeq_create_r(Geos.current_handle_pointer, size, dimensions), true ]
       end
 
       @ptr = FFI::AutoPointer.new(
@@ -117,7 +118,7 @@ module Geos
 
     def initialize_copy(source)
       @ptr = FFI::AutoPointer.new(
-        FFIGeos.GEOSCoordSeq_clone_r(Geos.current_handle, source.ptr),
+        FFIGeos.GEOSCoordSeq_clone_r(Geos.current_handle_pointer, source.ptr),
         self.class.method(:release)
       )
 
@@ -127,7 +128,7 @@ module Geos
     end
 
     def self.release(ptr) #:nodoc:
-      FFIGeos.GEOSCoordSeq_destroy_r(Geos.current_handle, ptr)
+      FFIGeos.GEOSCoordSeq_destroy_r(Geos.current_handle_pointer, ptr)
     end
 
     # Yields coordinates as [ x, y, z ]. The z coordinate may be omitted for
@@ -164,31 +165,31 @@ module Geos
     # Sets the x value of a coordinate. Can also be set via #x[]=.
     def set_x(idx, val)
       self.check_bounds(idx)
-      FFIGeos.GEOSCoordSeq_setX_r(Geos.current_handle, self.ptr, idx, val.to_f)
+      FFIGeos.GEOSCoordSeq_setX_r(Geos.current_handle_pointer, self.ptr, idx, val.to_f)
     end
 
     # Sets the y value of a coordinate. Can also be set via #y[]=.
     def set_y(idx, val)
       self.check_bounds(idx)
-      FFIGeos.GEOSCoordSeq_setY_r(Geos.current_handle, self.ptr, idx, val.to_f)
+      FFIGeos.GEOSCoordSeq_setY_r(Geos.current_handle_pointer, self.ptr, idx, val.to_f)
     end
 
     # Sets the z value of a coordinate. Can also be set via #z[]=.
     def set_z(idx, val)
       self.check_bounds(idx)
-      FFIGeos.GEOSCoordSeq_setZ_r(Geos.current_handle, self.ptr, idx, val.to_f)
+      FFIGeos.GEOSCoordSeq_setZ_r(Geos.current_handle_pointer, self.ptr, idx, val.to_f)
     end
 
     def set_ordinate(idx, dim, val)
       self.check_bounds(idx)
-      FFIGeos.GEOSCoordSeq_setOrdinate_r(Geos.current_handle, self.ptr, idx, dim, val.to_f)
+      FFIGeos.GEOSCoordSeq_setOrdinate_r(Geos.current_handle_pointer, self.ptr, idx, dim, val.to_f)
     end
 
     # Gets the x value of a coordinate. Can also be retrieved via #x[].
     def get_x(idx)
       self.check_bounds(idx)
       double_ptr = FFI::MemoryPointer.new(:double)
-      FFIGeos.GEOSCoordSeq_getX_r(Geos.current_handle, self.ptr, idx, double_ptr)
+      FFIGeos.GEOSCoordSeq_getX_r(Geos.current_handle_pointer, self.ptr, idx, double_ptr)
       double_ptr.read_double
     end
 
@@ -196,7 +197,7 @@ module Geos
     def get_y(idx)
       self.check_bounds(idx)
       double_ptr = FFI::MemoryPointer.new(:double)
-      FFIGeos.GEOSCoordSeq_getY_r(Geos.current_handle, self.ptr, idx, double_ptr)
+      FFIGeos.GEOSCoordSeq_getY_r(Geos.current_handle_pointer, self.ptr, idx, double_ptr)
       double_ptr.read_double
     end
 
@@ -204,20 +205,20 @@ module Geos
     def get_z(idx)
       self.check_bounds(idx)
       double_ptr = FFI::MemoryPointer.new(:double)
-      FFIGeos.GEOSCoordSeq_getZ_r(Geos.current_handle, self.ptr, idx, double_ptr)
+      FFIGeos.GEOSCoordSeq_getZ_r(Geos.current_handle_pointer, self.ptr, idx, double_ptr)
       double_ptr.read_double
     end
 
     def get_ordinate(idx, dim)
       self.check_bounds(idx)
       double_ptr = FFI::MemoryPointer.new(:double)
-      FFIGeos.GEOSCoordSeq_getOrdinate_r(Geos.current_handle, self.ptr, idx, dim, double_ptr)
+      FFIGeos.GEOSCoordSeq_getOrdinate_r(Geos.current_handle_pointer, self.ptr, idx, dim, double_ptr)
       double_ptr.read_double
     end
 
     def length
       int_ptr = FFI::MemoryPointer.new(:int)
-      FFIGeos.GEOSCoordSeq_getSize_r(Geos.current_handle, self.ptr, int_ptr)
+      FFIGeos.GEOSCoordSeq_getSize_r(Geos.current_handle_pointer, self.ptr, int_ptr)
       int_ptr.read_int
     end
     alias_method :size, :length
@@ -231,7 +232,7 @@ module Geos
         @dimensions
       else
         int_ptr = FFI::MemoryPointer.new(:int)
-        FFIGeos.GEOSCoordSeq_getDimensions_r(Geos.current_handle, self.ptr, int_ptr)
+        FFIGeos.GEOSCoordSeq_getDimensions_r(Geos.current_handle_pointer, self.ptr, int_ptr)
         @dimensions = int_ptr.read_int
       end
     end

data/lib/ffi-geos/geometry.rb

@@ -1,4 +1,5 @@
 # encoding: UTF-8
+# frozen_string_literal: true
 
 module Geos
   class Geometry
@@ -30,7 +31,7 @@ module Geos
 
     def initialize_copy(source)
       @ptr = FFI::AutoPointer.new(
-        FFIGeos.GEOSGeom_clone_r(Geos.current_handle, source.ptr),
+        FFIGeos.GEOSGeom_clone_r(Geos.current_handle_pointer, source.ptr),
         self.class.method(:release)
       )
 
@@ -39,21 +40,21 @@ module Geos
     end
 
     def self.release(ptr) #:nodoc:
-      FFIGeos.GEOSGeom_destroy_r(Geos.current_handle, ptr)
+      FFIGeos.GEOSGeom_destroy_r(Geos.current_handle_pointer, ptr)
     end
 
     # Returns the name of the Geometry type, i.e. "Point", "Polygon", etc.
     def geom_type
-      FFIGeos.GEOSGeomType_r(Geos.current_handle, self.ptr)
+      FFIGeos.GEOSGeomType_r(Geos.current_handle_pointer, self.ptr)
     end
 
     # Returns one of the values from Geos::GeomTypes.
     def type_id
-      FFIGeos.GEOSGeomTypeId_r(Geos.current_handle, self.ptr)
+      FFIGeos.GEOSGeomTypeId_r(Geos.current_handle_pointer, self.ptr)
     end
 
     def normalize!
-      if FFIGeos.GEOSNormalize_r(Geos.current_handle, self.ptr) == -1
+      if FFIGeos.GEOSNormalize_r(Geos.current_handle_pointer, self.ptr) == -1
         raise Geos::Geometry::CouldntNormalizeError.new(self.class)
       end
 
@@ -62,32 +63,32 @@ module Geos
     alias_method :normalize, :normalize!
 
     def srid
-      FFIGeos.GEOSGetSRID_r(Geos.current_handle, self.ptr)
+      FFIGeos.GEOSGetSRID_r(Geos.current_handle_pointer, self.ptr)
     end
 
     def srid=(s)
-      FFIGeos.GEOSSetSRID_r(Geos.current_handle, self.ptr, s)
+      FFIGeos.GEOSSetSRID_r(Geos.current_handle_pointer, self.ptr, s)
     end
 
     def dimensions
-      FFIGeos.GEOSGeom_getDimensions_r(Geos.current_handle, self.ptr)
+      FFIGeos.GEOSGeom_getDimensions_r(Geos.current_handle_pointer, self.ptr)
     end
 
     def num_geometries
-      FFIGeos.GEOSGetNumGeometries_r(Geos.current_handle, self.ptr)
+      FFIGeos.GEOSGetNumGeometries_r(Geos.current_handle_pointer, self.ptr)
     end
 
     def num_coordinates
-      FFIGeos.GEOSGetNumCoordinates_r(Geos.current_handle, self.ptr)
+      FFIGeos.GEOSGetNumCoordinates_r(Geos.current_handle_pointer, self.ptr)
     end
 
     def coord_seq
-      CoordinateSequence.new(FFIGeos.GEOSGeom_getCoordSeq_r(Geos.current_handle, self.ptr), false, self)
+      CoordinateSequence.new(FFIGeos.GEOSGeom_getCoordSeq_r(Geos.current_handle_pointer, self.ptr), false, self)
     end
 
     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_pointer, self.ptr, geom.ptr), {
         :srid_copy => pick_srid_from_geoms(self.srid, geom.srid)
       })
     end
@@ -119,7 +120,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), :srid_copy => self.srid)
+        cast_geometry_ptr(FFIGeos.GEOSBufferWithParams_r(Geos.current_handle_pointer, self.ptr, params.ptr, width), :srid_copy => self.srid)
       end
     else
       def buffer(width, options = nil)
@@ -135,31 +136,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), :srid_copy => self.srid)
+        cast_geometry_ptr(FFIGeos.GEOSBuffer_r(Geos.current_handle_pointer, 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), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSConvexHull_r(Geos.current_handle_pointer, 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_pointer, 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_pointer, self.ptr, geom.ptr), {
         :srid_copy => pick_srid_from_geoms(self.srid, geom.srid)
       })
     end
     alias_method :symmetric_difference, :sym_difference
 
     def boundary
-      cast_geometry_ptr(FFIGeos.GEOSBoundary_r(Geos.current_handle, self.ptr), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSBoundary_r(Geos.current_handle_pointer, self.ptr), :srid_copy => self.srid)
     end
 
     # Calling without a geom argument is equivalent to calling unary_union when
@@ -168,7 +169,7 @@ 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_pointer, self.ptr, geom.ptr), {
           :srid_copy => pick_srid_from_geoms(self.srid, geom.srid)
         })
       else
@@ -181,7 +182,7 @@ 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_pointer, self.ptr), {
         :srid_copy => self.srid
       })
     end
@@ -189,7 +190,7 @@ module Geos
     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_pointer, self.ptr), {
           :srid_copy => self.srid
         })
       end
@@ -198,43 +199,43 @@ module Geos
     if FFIGeos.respond_to?(:GEOSNode_r)
       # Available in GEOS 3.3.4+
       def node
-        cast_geometry_ptr(FFIGeos.GEOSNode_r(Geos.current_handle, self.ptr))
+        cast_geometry_ptr(FFIGeos.GEOSNode_r(Geos.current_handle_pointer, self.ptr))
       end
     end
 
     def point_on_surface
-      cast_geometry_ptr(FFIGeos.GEOSPointOnSurface_r(Geos.current_handle, self.ptr), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSPointOnSurface_r(Geos.current_handle_pointer, self.ptr), :srid_copy => self.srid)
     end
     alias_method :representative_point, :point_on_surface
 
     if FFIGeos.respond_to?(:GEOSClipByRect_r)
       # Available in GEOS 3.5.0+.
       def clip_by_rect(xmin, ymin, xmax, ymax)
-        cast_geometry_ptr(FFIGeos.GEOSClipByRect_r(Geos.current_handle, self.ptr, xmin, ymin, xmax, ymax))
+        cast_geometry_ptr(FFIGeos.GEOSClipByRect_r(Geos.current_handle_pointer, self.ptr, xmin, ymin, xmax, ymax))
       end
       alias_method :clip_by_rectangle, :clip_by_rect
     end
 
     def centroid
-      cast_geometry_ptr(FFIGeos.GEOSGetCentroid_r(Geos.current_handle, self.ptr), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSGetCentroid_r(Geos.current_handle_pointer, self.ptr), :srid_copy => self.srid)
     end
     alias_method :center, :centroid
 
     def envelope
-      cast_geometry_ptr(FFIGeos.GEOSEnvelope_r(Geos.current_handle, self.ptr), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSEnvelope_r(Geos.current_handle_pointer, self.ptr), :srid_copy => self.srid)
     end
 
     # Returns the Dimensionally Extended Nine-Intersection Model (DE-9IM)
     # matrix of the geometries as a String.
     def relate(geom)
       check_geometry(geom)
-      FFIGeos.GEOSRelate_r(Geos.current_handle, self.ptr, geom.ptr)
+      FFIGeos.GEOSRelate_r(Geos.current_handle_pointer, self.ptr, geom.ptr)
     end
 
     # Checks the DE-9IM pattern against the geoms.
     def relate_pattern(geom, pattern)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSRelatePattern_r(Geos.current_handle, self.ptr, geom.ptr, pattern))
+      bool_result(FFIGeos.GEOSRelatePattern_r(Geos.current_handle_pointer, self.ptr, geom.ptr, pattern))
     end
 
     if FFIGeos.respond_to?(:GEOSRelateBoundaryNodeRule_r)
@@ -242,60 +243,60 @@ module Geos
       def relate_boundary_node_rule(geom, bnr = :mod2)
         check_geometry(geom)
         check_enum_value(Geos::RelateBoundaryNodeRules, bnr)
-        FFIGeos.GEOSRelateBoundaryNodeRule_r(Geos.current_handle, self.ptr, geom.ptr, bnr)
+        FFIGeos.GEOSRelateBoundaryNodeRule_r(Geos.current_handle_pointer, self.ptr, geom.ptr, bnr)
       end
     end
 
     def line_merge
-      cast_geometry_ptr(FFIGeos.GEOSLineMerge_r(Geos.current_handle, self.ptr), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSLineMerge_r(Geos.current_handle_pointer, self.ptr), :srid_copy => self.srid)
     end
 
     def simplify(tolerance)
-      cast_geometry_ptr(FFIGeos.GEOSSimplify_r(Geos.current_handle, self.ptr, tolerance), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSSimplify_r(Geos.current_handle_pointer, 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), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSTopologyPreserveSimplify_r(Geos.current_handle_pointer, self.ptr, tolerance), :srid_copy => self.srid)
     end
 
     def extract_unique_points
-      cast_geometry_ptr(FFIGeos.GEOSGeom_extractUniquePoints_r(Geos.current_handle, self.ptr), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSGeom_extractUniquePoints_r(Geos.current_handle_pointer, self.ptr), :srid_copy => self.srid)
     end
     alias_method :unique_points, :extract_unique_points
 
     def disjoint?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSDisjoint_r(Geos.current_handle, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSDisjoint_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
     end
 
     def touches?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSTouches_r(Geos.current_handle, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSTouches_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
     end
 
     def intersects?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSIntersects_r(Geos.current_handle, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSIntersects_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
     end
 
     def crosses?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSCrosses_r(Geos.current_handle, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSCrosses_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
     end
 
     def within?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSWithin_r(Geos.current_handle, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSWithin_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
     end
 
     def contains?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSContains_r(Geos.current_handle, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSContains_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
     end
 
     def overlaps?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSOverlaps_r(Geos.current_handle, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSOverlaps_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
     end
 
     if FFIGeos.respond_to?(:GEOSCovers_r)
@@ -304,7 +305,7 @@ module Geos
       # implementation.
       def covers?(geom)
         check_geometry(geom)
-        bool_result(FFIGeos.GEOSCovers_r(Geos.current_handle, self.ptr, geom.ptr))
+        bool_result(FFIGeos.GEOSCovers_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
       end
     else
       def covers?(geom) #:nodoc:
@@ -326,7 +327,7 @@ module Geos
       # implementation.
       def covered_by?(geom)
         check_geometry(geom)
-        bool_result(FFIGeos.GEOSCoveredBy_r(Geos.current_handle, self.ptr, geom.ptr))
+        bool_result(FFIGeos.GEOSCoveredBy_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
       end
     else
       def covered_by?(geom) #:nodoc:
@@ -344,7 +345,7 @@ module Geos
 
     def eql?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSEquals_r(Geos.current_handle, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSEquals_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
     end
     alias_method :equals?, :eql?
 
@@ -358,29 +359,29 @@ module Geos
 
     def eql_exact?(geom, tolerance)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSEqualsExact_r(Geos.current_handle, self.ptr, geom.ptr, tolerance))
+      bool_result(FFIGeos.GEOSEqualsExact_r(Geos.current_handle_pointer, self.ptr, geom.ptr, tolerance))
     end
     alias_method :equals_exact?, :eql_exact?
     alias_method :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)))
+      bool_result(FFIGeos.GEOSEqualsExact_r(Geos.current_handle_pointer, self.ptr, geom.ptr, 0.5 * 10 ** (-decimal)))
     end
     alias_method :equals_almost?, :eql_almost?
     alias_method :almost_equals?, :eql_almost?
 
     def empty?
-      bool_result(FFIGeos.GEOSisEmpty_r(Geos.current_handle, self.ptr))
+      bool_result(FFIGeos.GEOSisEmpty_r(Geos.current_handle_pointer, self.ptr))
     end
 
     def valid?
-      bool_result(FFIGeos.GEOSisValid_r(Geos.current_handle, self.ptr))
+      bool_result(FFIGeos.GEOSisValid_r(Geos.current_handle_pointer, self.ptr))
     end
 
     # Returns a String describing whether or not the Geometry is valid.
     def valid_reason
-      FFIGeos.GEOSisValidReason_r(Geos.current_handle, self.ptr)
+      FFIGeos.GEOSisValidReason_r(Geos.current_handle_pointer, self.ptr)
     end
 
     # Returns a Hash containing the following structure on invalid geometries:
@@ -395,7 +396,7 @@ module Geos
       detail = FFI::MemoryPointer.new(:pointer)
       location = FFI::MemoryPointer.new(:pointer)
       valid = bool_result(
-        FFIGeos.GEOSisValidDetail_r(Geos.current_handle, self.ptr, flags, detail, location)
+        FFIGeos.GEOSisValidDetail_r(Geos.current_handle_pointer, self.ptr, flags, detail, location)
       )
 
       if !valid
@@ -409,15 +410,15 @@ module Geos
     end
 
     def simple?
-      bool_result(FFIGeos.GEOSisSimple_r(Geos.current_handle, self.ptr))
+      bool_result(FFIGeos.GEOSisSimple_r(Geos.current_handle_pointer, self.ptr))
     end
 
     def ring?
-      bool_result(FFIGeos.GEOSisRing_r(Geos.current_handle, self.ptr))
+      bool_result(FFIGeos.GEOSisRing_r(Geos.current_handle_pointer, self.ptr))
     end
 
     def has_z?
-      bool_result(FFIGeos.GEOSHasZ_r(Geos.current_handle, self.ptr))
+      bool_result(FFIGeos.GEOSHasZ_r(Geos.current_handle_pointer, self.ptr))
     end
 
     # GEOS versions prior to 3.3.0 didn't handle exceptions and can crash on
@@ -427,9 +428,9 @@ module Geos
         raise TypeError.new("Expected Geos::Point type") if !geom.is_a?(Geos::Point)
 
         if normalized
-          FFIGeos.GEOSProjectNormalized_r(Geos.current_handle, self.ptr, geom.ptr)
+          FFIGeos.GEOSProjectNormalized_r(Geos.current_handle_pointer, self.ptr, geom.ptr)
         else
-          FFIGeos.GEOSProject_r(Geos.current_handle, self.ptr, geom.ptr)
+          FFIGeos.GEOSProject_r(Geos.current_handle_pointer, self.ptr, geom.ptr)
         end
       end
 
@@ -440,9 +441,9 @@ module Geos
 
     def interpolate(d, normalized = false)
       ret = if normalized
-        FFIGeos.GEOSInterpolateNormalized_r(Geos.current_handle, self.ptr, d)
+        FFIGeos.GEOSInterpolateNormalized_r(Geos.current_handle_pointer, self.ptr, d)
       else
-        FFIGeos.GEOSInterpolate_r(Geos.current_handle, self.ptr, d)
+        FFIGeos.GEOSInterpolate_r(Geos.current_handle_pointer, self.ptr, d)
       end
 
       cast_geometry_ptr(ret, :srid_copy => self.srid)
@@ -453,11 +454,11 @@ module Geos
     end
 
     def start_point
-      cast_geometry_ptr(FFIGeos.GEOSGeomGetStartPoint_r(Geos.current_handle, self.ptr), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSGeomGetStartPoint_r(Geos.current_handle_pointer, self.ptr), :srid_copy => self.srid)
     end
 
     def end_point
-      cast_geometry_ptr(FFIGeos.GEOSGeomGetEndPoint_r(Geos.current_handle, self.ptr), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSGeomGetEndPoint_r(Geos.current_handle_pointer, self.ptr), :srid_copy => self.srid)
     end
 
     def area
@@ -465,7 +466,7 @@ module Geos
         0
       else
         double_ptr = FFI::MemoryPointer.new(:double)
-        FFIGeos.GEOSArea_r(Geos.current_handle, self.ptr, double_ptr)
+        FFIGeos.GEOSArea_r(Geos.current_handle_pointer, self.ptr, double_ptr)
         double_ptr.read_double
       end
     end
@@ -475,7 +476,7 @@ module Geos
         0
       else
         double_ptr = FFI::MemoryPointer.new(:double)
-        FFIGeos.GEOSLength_r(Geos.current_handle, self.ptr, double_ptr)
+        FFIGeos.GEOSLength_r(Geos.current_handle_pointer, self.ptr, double_ptr)
         double_ptr.read_double
       end
     end
@@ -483,7 +484,7 @@ module Geos
     def distance(geom)
       check_geometry(geom)
       double_ptr = FFI::MemoryPointer.new(:double)
-      FFIGeos.GEOSDistance_r(Geos.current_handle, self.ptr, geom.ptr, double_ptr)
+      FFIGeos.GEOSDistance_r(Geos.current_handle_pointer, self.ptr, geom.ptr, double_ptr)
       double_ptr.read_double
     end
 
@@ -493,9 +494,9 @@ module Geos
       double_ptr = FFI::MemoryPointer.new(:double)
 
       if densify_frac
-        FFIGeos.GEOSHausdorffDistanceDensify_r(Geos.current_handle, self.ptr, geom.ptr, densify_frac, double_ptr)
+        FFIGeos.GEOSHausdorffDistanceDensify_r(Geos.current_handle_pointer, self.ptr, geom.ptr, densify_frac, double_ptr)
       else
-        FFIGeos.GEOSHausdorffDistance_r(Geos.current_handle, self.ptr, geom.ptr, double_ptr)
+        FFIGeos.GEOSHausdorffDistance_r(Geos.current_handle_pointer, self.ptr, geom.ptr, double_ptr)
       end
 
       double_ptr.read_double
@@ -505,7 +506,7 @@ module Geos
       # Available in GEOS 3.4+.
       def nearest_points(geom)
         check_geometry(geom)
-        ptr = FFIGeos.GEOSNearestPoints_r(Geos.current_handle, self.ptr, geom.ptr)
+        ptr = FFIGeos.GEOSNearestPoints_r(Geos.current_handle_pointer, self.ptr, geom.ptr)
 
         if !ptr.null?
           CoordinateSequence.new(ptr)
@@ -515,7 +516,7 @@ 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_pointer, self.ptr, geom.ptr, tolerance), {
         :srid_copy => pick_srid_from_geoms(self.srid, geom.srid)
       })
     end
@@ -523,7 +524,7 @@ module Geos
 
     def shared_paths(geom)
       check_geometry(geom)
-      cast_geometry_ptr(FFIGeos.GEOSSharedPaths_r(Geos.current_handle, self.ptr, geom.ptr), {
+      cast_geometry_ptr(FFIGeos.GEOSSharedPaths_r(Geos.current_handle_pointer, self.ptr, geom.ptr), {
         :srid_copy => pick_srid_from_geoms(self.srid, geom.srid)
       }).to_a
     end
@@ -542,7 +543,7 @@ 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_pointer, self.ptr, cuts, dangles, invalid_rings), {
           :srid_copy => self.srid
         }
       )
@@ -563,14 +564,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), :srid_copy => self.srid).to_a
+      cast_geometry_ptr(FFIGeos.GEOSPolygonize_r(Geos.current_handle_pointer, 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), :srid_copy => self.srid).to_a
+      cast_geometry_ptr(FFIGeos.GEOSPolygonizer_getCutEdges_r(Geos.current_handle_pointer, ary, 1), :srid_copy => self.srid).to_a
     end
 
     if FFIGeos.respond_to?(:GEOSDelaunayTriangulation_r)
@@ -588,7 +589,7 @@ module Geos
         tolerance = args.first || options[:tolerance] || 0.0
         only_edges = bool_to_int(options[:only_edges])
 
-        cast_geometry_ptr(FFIGeos.GEOSDelaunayTriangulation_r(Geos.current_handle, self.ptr, tolerance, only_edges))
+        cast_geometry_ptr(FFIGeos.GEOSDelaunayTriangulation_r(Geos.current_handle_pointer, self.ptr, tolerance, only_edges))
       end
     end
 
@@ -616,7 +617,7 @@ module Geos
 
         only_edges = bool_to_int(options[:only_edges])
 
-        cast_geometry_ptr(FFIGeos.GEOSVoronoiDiagram_r(Geos.current_handle, self.ptr, envelope_ptr, tolerance, only_edges))
+        cast_geometry_ptr(FFIGeos.GEOSVoronoiDiagram_r(Geos.current_handle_pointer, self.ptr, envelope_ptr, tolerance, only_edges))
       end
     end
 
@@ -633,5 +634,53 @@ module Geos
 
       "#<Geos::#{self.geom_type}: #{wkt}>"
     end
+
+    if FFIGeos.respond_to?(:GEOSGeom_getPrecision_r)
+      def precision
+        FFIGeos.GEOSGeom_getPrecision_r(Geos.current_handle_pointer, self.ptr)
+      end
+    end
+
+    if FFIGeos.respond_to?(:GEOSGeom_setPrecision_r)
+      def with_precision(grid_size, options = {})
+        options = {
+          :no_topology => false,
+          :keep_collapsed => false
+        }.merge(options)
+
+        flags = options.reduce(0) do |memo, (key, value)|
+          memo |= Geos::PrecisionOptions[key] if value
+          memo
+        end
+
+        cast_geometry_ptr(FFIGeos.GEOSGeom_setPrecision_r(Geos.current_handle_pointer, self.ptr, grid_size, flags))
+      end
+    end
+
+    if FFIGeos.respond_to?(:GEOSMinimumRotatedRectangle_r)
+      def minimum_rotated_rectangle
+        cast_geometry_ptr(FFIGeos.GEOSMinimumRotatedRectangle_r(Geos.current_handle_pointer, self.ptr))
+      end
+    end
+
+    if FFIGeos.respond_to?(:GEOSMinimumClearance_r)
+      def minimum_clearance
+        double_ptr = FFI::MemoryPointer.new(:double)
+        ret = FFIGeos.GEOSMinimumClearance_r(Geos.current_handle_pointer, self.ptr, double_ptr)
+        double_ptr.read_double
+      end
+    end
+
+    if FFIGeos.respond_to?(:GEOSMinimumClearanceLine_r)
+      def minimum_clearance_line
+        cast_geometry_ptr(FFIGeos.GEOSMinimumClearanceLine_r(Geos.current_handle_pointer, self.ptr))
+      end
+    end
+
+    if FFIGeos.respond_to?(:GEOSMinimumWidth_r)
+      def minimum_width
+        cast_geometry_ptr(FFIGeos.GEOSMinimumWidth_r(Geos.current_handle_pointer, self.ptr))
+      end
+    end
   end
 end