ffi-geos 1.2.0 → 2.2.0

data/lib/ffi-geos/geometry.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
@@ -17,7 +16,7 @@ module Geos
     # WktReader and the various Geos.create_* methods.
     def initialize(ptr, options = {})
       options = {
-        :auto_free => true
+        auto_free: true
       }.merge(options)
 
       @ptr = FFI::AutoPointer.new(
@@ -45,52 +44,53 @@ module Geos
 
     # Returns the name of the Geometry type, i.e. "Point", "Polygon", etc.
     def geom_type
-      FFIGeos.GEOSGeomType_r(Geos.current_handle_pointer, self.ptr)
+      FFIGeos.GEOSGeomType_r(Geos.current_handle_pointer, ptr)
     end
 
     # Returns one of the values from Geos::GeomTypes.
     def type_id
-      FFIGeos.GEOSGeomTypeId_r(Geos.current_handle_pointer, self.ptr)
+      FFIGeos.GEOSGeomTypeId_r(Geos.current_handle_pointer, ptr)
     end
 
     def normalize!
-      if FFIGeos.GEOSNormalize_r(Geos.current_handle_pointer, self.ptr) == -1
-        raise Geos::Geometry::CouldntNormalizeError.new(self.class)
-      end
+      raise Geos::Geometry::CouldntNormalizeError, self.class if FFIGeos.GEOSNormalize_r(Geos.current_handle_pointer, ptr) == -1
 
       self
     end
-    alias_method :normalize, :normalize!
+    alias normalize normalize!
 
     def srid
-      FFIGeos.GEOSGetSRID_r(Geos.current_handle_pointer, self.ptr)
+      FFIGeos.GEOSGetSRID_r(Geos.current_handle_pointer, ptr)
     end
 
     def srid=(s)
-      FFIGeos.GEOSSetSRID_r(Geos.current_handle_pointer, self.ptr, s)
+      FFIGeos.GEOSSetSRID_r(Geos.current_handle_pointer, ptr, s)
     end
 
     def dimensions
-      FFIGeos.GEOSGeom_getDimensions_r(Geos.current_handle_pointer, self.ptr)
+      FFIGeos.GEOSGeom_getDimensions_r(Geos.current_handle_pointer, ptr)
     end
 
     def num_geometries
-      FFIGeos.GEOSGetNumGeometries_r(Geos.current_handle_pointer, self.ptr)
+      FFIGeos.GEOSGetNumGeometries_r(Geos.current_handle_pointer, ptr)
     end
 
     def num_coordinates
-      FFIGeos.GEOSGetNumCoordinates_r(Geos.current_handle_pointer, self.ptr)
+      FFIGeos.GEOSGetNumCoordinates_r(Geos.current_handle_pointer, ptr)
     end
 
     def coord_seq
-      CoordinateSequence.new(FFIGeos.GEOSGeom_getCoordSeq_r(Geos.current_handle_pointer, self.ptr), false, self)
+      CoordinateSequence.new(FFIGeos.GEOSGeom_getCoordSeq_r(Geos.current_handle_pointer, ptr), false, self)
     end
 
-    def intersection(geom)
+    def intersection(geom, precision: nil)
       check_geometry(geom)
-      cast_geometry_ptr(FFIGeos.GEOSIntersection_r(Geos.current_handle_pointer, self.ptr, geom.ptr), {
-        :srid_copy => pick_srid_from_geoms(self.srid, geom.srid)
-      })
+
+      if precision
+        cast_geometry_ptr(FFIGeos.GEOSIntersectionPrec_r(Geos.current_handle_pointer, ptr, geom.ptr, precision), srid_copy: pick_srid_from_geoms(srid, geom.srid))
+      else
+        cast_geometry_ptr(FFIGeos.GEOSIntersection_r(Geos.current_handle_pointer, ptr, geom.ptr), srid_copy: pick_srid_from_geoms(srid, geom.srid))
+      end
     end
 
     if FFIGeos.respond_to?(:GEOSBufferWithParams_r)
@@ -115,12 +115,12 @@ module Geos
           when Geos::BufferParams
             options
           when Numeric
-            Geos::BufferParams.new(:quad_segs => options)
+            Geos::BufferParams.new(quad_segs: options)
           else
-            raise ArgumentError.new("Expected Geos::BufferParams, a Hash or a Numeric")
+            raise ArgumentError, 'Expected Geos::BufferParams, a Hash or a Numeric'
         end
 
-        cast_geometry_ptr(FFIGeos.GEOSBufferWithParams_r(Geos.current_handle_pointer, self.ptr, params.ptr, width), :srid_copy => self.srid)
+        cast_geometry_ptr(FFIGeos.GEOSBufferWithParams_r(Geos.current_handle_pointer, ptr, params.ptr, width), srid_copy: srid)
       end
     else
       def buffer(width, options = nil)
@@ -133,109 +133,131 @@ module Geos
           when Numeric
             options
           else
-            raise ArgumentError.new("Expected Geos::BufferParams, a Hash or a Numeric")
+            raise ArgumentError, 'Expected Geos::BufferParams, a Hash or a Numeric'
         end
 
-        cast_geometry_ptr(FFIGeos.GEOSBuffer_r(Geos.current_handle_pointer, self.ptr, width, quad_segs), :srid_copy => self.srid)
+        cast_geometry_ptr(FFIGeos.GEOSBuffer_r(Geos.current_handle_pointer, ptr, width, quad_segs), srid_copy: srid)
       end
     end
 
     def convex_hull
-      cast_geometry_ptr(FFIGeos.GEOSConvexHull_r(Geos.current_handle_pointer, self.ptr), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSConvexHull_r(Geos.current_handle_pointer, ptr), srid_copy: srid)
     end
 
-    def difference(geom)
+    def difference(geom, precision: nil)
       check_geometry(geom)
-      cast_geometry_ptr(FFIGeos.GEOSDifference_r(Geos.current_handle_pointer, self.ptr, geom.ptr), {
-        :srid_copy => pick_srid_from_geoms(self.srid, geom.srid)
-      })
+
+      if precision
+        cast_geometry_ptr(FFIGeos.GEOSDifferencePrec_r(Geos.current_handle_pointer, ptr, geom.ptr, precision), srid_copy: pick_srid_from_geoms(srid, geom.srid))
+      else
+        cast_geometry_ptr(FFIGeos.GEOSDifference_r(Geos.current_handle_pointer, ptr, geom.ptr), srid_copy: pick_srid_from_geoms(srid, geom.srid))
+      end
     end
 
-    def sym_difference(geom)
+    def sym_difference(geom, precision: nil)
       check_geometry(geom)
-      cast_geometry_ptr(FFIGeos.GEOSSymDifference_r(Geos.current_handle_pointer, self.ptr, geom.ptr), {
-        :srid_copy => pick_srid_from_geoms(self.srid, geom.srid)
-      })
+
+      if precision
+        cast_geometry_ptr(FFIGeos.GEOSSymDifferencePrec_r(Geos.current_handle_pointer, ptr, geom.ptr, precision), srid_copy: pick_srid_from_geoms(srid, geom.srid))
+      else
+        cast_geometry_ptr(FFIGeos.GEOSSymDifference_r(Geos.current_handle_pointer, ptr, geom.ptr), srid_copy: pick_srid_from_geoms(srid, geom.srid))
+      end
     end
-    alias_method :symmetric_difference, :sym_difference
+    alias symmetric_difference sym_difference
 
     def boundary
-      cast_geometry_ptr(FFIGeos.GEOSBoundary_r(Geos.current_handle_pointer, self.ptr), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSBoundary_r(Geos.current_handle_pointer, ptr), srid_copy: srid)
     end
 
     # Calling without a geom argument is equivalent to calling unary_union when
     # using GEOS 3.3+ and is equivalent to calling union_cascaded in older
     # versions.
-    def union(geom = nil)
+    def union(geom = nil, precision: nil)
       if geom
         check_geometry(geom)
-        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
-        if self.respond_to?(:unary_union)
-          self.unary_union
+
+        if precision
+          cast_geometry_ptr(FFIGeos.GEOSUnionPrec_r(Geos.current_handle_pointer, ptr, geom.ptr, precision), srid_copy: pick_srid_from_geoms(srid, geom.srid))
         else
-          self.union_cascaded
+          cast_geometry_ptr(FFIGeos.GEOSUnion_r(Geos.current_handle_pointer, ptr, geom.ptr), srid_copy: pick_srid_from_geoms(srid, geom.srid))
         end
+      elsif respond_to?(:unary_union)
+        unary_union
+      else
+        union_cascaded
       end
     end
 
     def union_cascaded
-      cast_geometry_ptr(FFIGeos.GEOSUnionCascaded_r(Geos.current_handle_pointer, self.ptr), {
-        :srid_copy => self.srid
-      })
+      cast_geometry_ptr(FFIGeos.GEOSUnionCascaded_r(Geos.current_handle_pointer, ptr), srid_copy: srid)
+    end
+
+    if FFIGeos.respond_to?(:GEOSCoverageUnion_r)
+      # Added in GEOS 3.8+
+      def coverage_union
+        cast_geometry_ptr(FFIGeos.GEOSCoverageUnion_r(Geos.current_handle_pointer, ptr), srid_copy: srid)
+      end
     end
 
     if FFIGeos.respond_to?(:GEOSUnaryUnion_r)
       # Available in GEOS 3.3+
-      def unary_union
-        cast_geometry_ptr(FFIGeos.GEOSUnaryUnion_r(Geos.current_handle_pointer, self.ptr), {
-          :srid_copy => self.srid
-        })
+      def unary_union(precision = nil)
+        if precision
+          cast_geometry_ptr(FFIGeos.GEOSUnaryUnionPrec_r(Geos.current_handle_pointer, ptr, precision), srid_copy: srid)
+        else
+          cast_geometry_ptr(FFIGeos.GEOSUnaryUnion_r(Geos.current_handle_pointer, ptr), srid_copy: srid)
+        end
       end
     end
 
     if FFIGeos.respond_to?(:GEOSNode_r)
       # Available in GEOS 3.3.4+
       def node
-        cast_geometry_ptr(FFIGeos.GEOSNode_r(Geos.current_handle_pointer, self.ptr))
+        cast_geometry_ptr(FFIGeos.GEOSNode_r(Geos.current_handle_pointer, ptr))
       end
     end
 
     def point_on_surface
-      cast_geometry_ptr(FFIGeos.GEOSPointOnSurface_r(Geos.current_handle_pointer, self.ptr), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSPointOnSurface_r(Geos.current_handle_pointer, ptr), srid_copy: srid)
     end
-    alias_method :representative_point, :point_on_surface
+    alias 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_pointer, self.ptr, xmin, ymin, xmax, ymax))
+        cast_geometry_ptr(FFIGeos.GEOSClipByRect_r(Geos.current_handle_pointer, ptr, xmin, ymin, xmax, ymax))
       end
-      alias_method :clip_by_rectangle, :clip_by_rect
+      alias clip_by_rectangle clip_by_rect
     end
 
     def centroid
-      cast_geometry_ptr(FFIGeos.GEOSGetCentroid_r(Geos.current_handle_pointer, self.ptr), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSGetCentroid_r(Geos.current_handle_pointer, ptr), srid_copy: srid)
+    end
+    alias center centroid
+
+    if FFIGeos.respond_to?(:GEOSMinimumBoundingCircle_r)
+      # Added in GEOS 3.8+. Does not yet support the radius or center
+      # arguments.
+      def minimum_bounding_circle
+        cast_geometry_ptr(FFIGeos.GEOSMinimumBoundingCircle_r(Geos.current_handle_pointer, ptr, nil, nil), srid_copy: srid)
+      end
     end
-    alias_method :center, :centroid
 
     def envelope
-      cast_geometry_ptr(FFIGeos.GEOSEnvelope_r(Geos.current_handle_pointer, self.ptr), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSEnvelope_r(Geos.current_handle_pointer, ptr), srid_copy: 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_pointer, self.ptr, geom.ptr)
+      FFIGeos.GEOSRelate_r(Geos.current_handle_pointer, 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_pointer, self.ptr, geom.ptr, pattern))
+      bool_result(FFIGeos.GEOSRelatePattern_r(Geos.current_handle_pointer, ptr, geom.ptr, pattern))
     end
 
     if FFIGeos.respond_to?(:GEOSRelateBoundaryNodeRule_r)
@@ -243,60 +265,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_pointer, self.ptr, geom.ptr, bnr)
+        FFIGeos.GEOSRelateBoundaryNodeRule_r(Geos.current_handle_pointer, ptr, geom.ptr, bnr)
       end
     end
 
     def line_merge
-      cast_geometry_ptr(FFIGeos.GEOSLineMerge_r(Geos.current_handle_pointer, self.ptr), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSLineMerge_r(Geos.current_handle_pointer, ptr), srid_copy: srid)
     end
 
     def simplify(tolerance)
-      cast_geometry_ptr(FFIGeos.GEOSSimplify_r(Geos.current_handle_pointer, self.ptr, tolerance), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSSimplify_r(Geos.current_handle_pointer, ptr, tolerance), srid_copy: srid)
     end
 
     def topology_preserve_simplify(tolerance)
-      cast_geometry_ptr(FFIGeos.GEOSTopologyPreserveSimplify_r(Geos.current_handle_pointer, self.ptr, tolerance), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSTopologyPreserveSimplify_r(Geos.current_handle_pointer, ptr, tolerance), srid_copy: srid)
     end
 
     def extract_unique_points
-      cast_geometry_ptr(FFIGeos.GEOSGeom_extractUniquePoints_r(Geos.current_handle_pointer, self.ptr), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSGeom_extractUniquePoints_r(Geos.current_handle_pointer, ptr), srid_copy: srid)
     end
-    alias_method :unique_points, :extract_unique_points
+    alias unique_points extract_unique_points
 
     def disjoint?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSDisjoint_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSDisjoint_r(Geos.current_handle_pointer, ptr, geom.ptr))
     end
 
     def touches?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSTouches_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSTouches_r(Geos.current_handle_pointer, ptr, geom.ptr))
     end
 
     def intersects?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSIntersects_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSIntersects_r(Geos.current_handle_pointer, ptr, geom.ptr))
     end
 
     def crosses?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSCrosses_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSCrosses_r(Geos.current_handle_pointer, ptr, geom.ptr))
     end
 
     def within?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSWithin_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSWithin_r(Geos.current_handle_pointer, ptr, geom.ptr))
     end
 
     def contains?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSContains_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSContains_r(Geos.current_handle_pointer, ptr, geom.ptr))
     end
 
     def overlaps?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSOverlaps_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSOverlaps_r(Geos.current_handle_pointer, ptr, geom.ptr))
     end
 
     if FFIGeos.respond_to?(:GEOSCovers_r)
@@ -305,7 +327,7 @@ module Geos
       # implementation.
       def covers?(geom)
         check_geometry(geom)
-        bool_result(FFIGeos.GEOSCovers_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
+        bool_result(FFIGeos.GEOSCovers_r(Geos.current_handle_pointer, ptr, geom.ptr))
       end
     else
       def covers?(geom) #:nodoc:
@@ -315,9 +337,9 @@ module Geos
           *T****FF*
           ***T**FF*
           ****T*FF*
-        }.detect do |pattern|
-          self.relate_pattern(geom, pattern)
-        end
+        }.detect { |pattern|
+          relate_pattern(geom, pattern)
+        }
       end
     end
 
@@ -327,7 +349,7 @@ module Geos
       # implementation.
       def covered_by?(geom)
         check_geometry(geom)
-        bool_result(FFIGeos.GEOSCoveredBy_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
+        bool_result(FFIGeos.GEOSCoveredBy_r(Geos.current_handle_pointer, ptr, geom.ptr))
       end
     else
       def covered_by?(geom) #:nodoc:
@@ -337,58 +359,56 @@ module Geos
           *TF**F***
           **FT*F***
           **F*TF***
-        }.detect do |pattern|
-          self.relate_pattern(geom, pattern)
-        end
+        }.detect { |pattern|
+          relate_pattern(geom, pattern)
+        }
       end
     end
 
-    def eql?(geom)
-      check_geometry(geom)
-      bool_result(FFIGeos.GEOSEquals_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
+    def eql?(other)
+      check_geometry(other)
+      bool_result(FFIGeos.GEOSEquals_r(Geos.current_handle_pointer, ptr, other.ptr))
     end
-    alias_method :equals?, :eql?
+    alias equals? eql?
 
-    def ==(geom)
-      if geom.is_a?(Geos::Geometry)
-        self.eql?(geom)
-      else
-        false
-      end
+    def ==(other)
+      return eql?(other) if other.is_a?(Geos::Geometry)
+
+      false
     end
 
-    def eql_exact?(geom, tolerance)
-      check_geometry(geom)
-      bool_result(FFIGeos.GEOSEqualsExact_r(Geos.current_handle_pointer, self.ptr, geom.ptr, tolerance))
+    def eql_exact?(other, tolerance)
+      check_geometry(other)
+      bool_result(FFIGeos.GEOSEqualsExact_r(Geos.current_handle_pointer, ptr, other.ptr, tolerance))
     end
-    alias_method :equals_exact?, :eql_exact?
-    alias_method :exactly_equals?, :eql_exact?
+    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_pointer, self.ptr, geom.ptr, 0.5 * 10 ** (-decimal)))
+    def eql_almost?(other, decimal = 6)
+      check_geometry(other)
+      bool_result(FFIGeos.GEOSEqualsExact_r(Geos.current_handle_pointer, ptr, other.ptr, 0.5 * 10 ** -decimal))
     end
-    alias_method :equals_almost?, :eql_almost?
-    alias_method :almost_equals?, :eql_almost?
+    alias equals_almost? eql_almost?
+    alias almost_equals? eql_almost?
 
     def empty?
-      bool_result(FFIGeos.GEOSisEmpty_r(Geos.current_handle_pointer, self.ptr))
+      bool_result(FFIGeos.GEOSisEmpty_r(Geos.current_handle_pointer, ptr))
     end
 
     def valid?
-      bool_result(FFIGeos.GEOSisValid_r(Geos.current_handle_pointer, self.ptr))
+      bool_result(FFIGeos.GEOSisValid_r(Geos.current_handle_pointer, ptr))
     end
 
     # Returns a String describing whether or not the Geometry is valid.
     def valid_reason
-      FFIGeos.GEOSisValidReason_r(Geos.current_handle_pointer, self.ptr)
+      FFIGeos.GEOSisValidReason_r(Geos.current_handle_pointer, ptr)
     end
 
     # Returns a Hash containing the following structure on invalid geometries:
     #
     #   {
-    #     :detail => "String explaining the problem",
-    #     :location => Geos::Point # centered on the problem
+    #     detail: "String explaining the problem",
+    #     location: Geos::Point # centered on the problem
     #   }
     #
     # If the Geometry is valid, returns nil.
@@ -396,107 +416,112 @@ module Geos
       detail = FFI::MemoryPointer.new(:pointer)
       location = FFI::MemoryPointer.new(:pointer)
       valid = bool_result(
-        FFIGeos.GEOSisValidDetail_r(Geos.current_handle_pointer, self.ptr, flags, detail, location)
+        FFIGeos.GEOSisValidDetail_r(Geos.current_handle_pointer, ptr, flags, detail, location)
       )
 
-      if !valid
-        {
-          :detail => detail.read_pointer.read_string,
-          :location => cast_geometry_ptr(location.read_pointer, {
-            :srid_copy => self.srid
-          })
-        }
-      end
+      return if valid
+
+      {
+        detail: detail.read_pointer.read_string,
+        location: cast_geometry_ptr(location.read_pointer, srid_copy: srid)
+      }
     end
 
     def simple?
-      bool_result(FFIGeos.GEOSisSimple_r(Geos.current_handle_pointer, self.ptr))
+      bool_result(FFIGeos.GEOSisSimple_r(Geos.current_handle_pointer, ptr))
     end
 
     def ring?
-      bool_result(FFIGeos.GEOSisRing_r(Geos.current_handle_pointer, self.ptr))
+      bool_result(FFIGeos.GEOSisRing_r(Geos.current_handle_pointer, ptr))
     end
 
     def has_z?
-      bool_result(FFIGeos.GEOSHasZ_r(Geos.current_handle_pointer, self.ptr))
+      bool_result(FFIGeos.GEOSHasZ_r(Geos.current_handle_pointer, ptr))
     end
 
     # GEOS versions prior to 3.3.0 didn't handle exceptions and can crash on
     # bad input.
     if FFIGeos.respond_to?(:GEOSProject_r) && Geos::GEOS_VERSION >= '3.3.0'
       def project(geom, normalized = false)
-        raise TypeError.new("Expected Geos::Point type") if !geom.is_a?(Geos::Point)
+        raise TypeError, 'Expected Geos::Point type' unless geom.is_a?(Geos::Point)
 
         if normalized
-          FFIGeos.GEOSProjectNormalized_r(Geos.current_handle_pointer, self.ptr, geom.ptr)
+          FFIGeos.GEOSProjectNormalized_r(Geos.current_handle_pointer, ptr, geom.ptr)
         else
-          FFIGeos.GEOSProject_r(Geos.current_handle_pointer, self.ptr, geom.ptr)
+          FFIGeos.GEOSProject_r(Geos.current_handle_pointer, ptr, geom.ptr)
         end
       end
 
       def project_normalized(geom)
-        self.project(geom, true)
+        project(geom, true)
       end
     end
 
     def interpolate(d, normalized = false)
       ret = if normalized
-        FFIGeos.GEOSInterpolateNormalized_r(Geos.current_handle_pointer, self.ptr, d)
+        FFIGeos.GEOSInterpolateNormalized_r(Geos.current_handle_pointer, ptr, d)
       else
-        FFIGeos.GEOSInterpolate_r(Geos.current_handle_pointer, self.ptr, d)
+        FFIGeos.GEOSInterpolate_r(Geos.current_handle_pointer, ptr, d)
       end
 
-      cast_geometry_ptr(ret, :srid_copy => self.srid)
+      cast_geometry_ptr(ret, srid_copy: srid)
     end
 
     def interpolate_normalized(d)
-      self.interpolate(d, true)
+      interpolate(d, true)
     end
 
     def start_point
-      cast_geometry_ptr(FFIGeos.GEOSGeomGetStartPoint_r(Geos.current_handle_pointer, self.ptr), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSGeomGetStartPoint_r(Geos.current_handle_pointer, ptr), srid_copy: srid)
     end
 
     def end_point
-      cast_geometry_ptr(FFIGeos.GEOSGeomGetEndPoint_r(Geos.current_handle_pointer, self.ptr), :srid_copy => self.srid)
+      cast_geometry_ptr(FFIGeos.GEOSGeomGetEndPoint_r(Geos.current_handle_pointer, ptr), srid_copy: srid)
     end
 
     def area
-      if self.empty?
-        0
-      else
-        double_ptr = FFI::MemoryPointer.new(:double)
-        FFIGeos.GEOSArea_r(Geos.current_handle_pointer, self.ptr, double_ptr)
-        double_ptr.read_double
-      end
+      return 0 if empty?
+
+      double_ptr = FFI::MemoryPointer.new(:double)
+      FFIGeos.GEOSArea_r(Geos.current_handle_pointer, ptr, double_ptr)
+      double_ptr.read_double
     end
 
     def length
-      if self.empty?
-        0
-      else
-        double_ptr = FFI::MemoryPointer.new(:double)
-        FFIGeos.GEOSLength_r(Geos.current_handle_pointer, self.ptr, double_ptr)
-        double_ptr.read_double
-      end
+      return 0 if empty?
+
+      double_ptr = FFI::MemoryPointer.new(:double)
+      FFIGeos.GEOSLength_r(Geos.current_handle_pointer, ptr, double_ptr)
+      double_ptr.read_double
     end
 
     def distance(geom)
       check_geometry(geom)
       double_ptr = FFI::MemoryPointer.new(:double)
-      FFIGeos.GEOSDistance_r(Geos.current_handle_pointer, self.ptr, geom.ptr, double_ptr)
+      FFIGeos.GEOSDistance_r(Geos.current_handle_pointer, ptr, geom.ptr, double_ptr)
       double_ptr.read_double
     end
 
+    if FFIGeos.respond_to?(:GEOSDistanceIndexed_r)
+      # Available in GEOS 3.7+.
+      def distance_indexed(geom)
+        check_geometry(geom)
+        double_ptr = FFI::MemoryPointer.new(:double)
+        FFIGeos.GEOSDistanceIndexed_r(Geos.current_handle_pointer, ptr, geom.ptr, double_ptr)
+        double_ptr.read_double
+      end
+      alias indexed_distance distance_indexed
+    end
+
     def hausdorff_distance(geom, densify_frac = nil)
       check_geometry(geom)
 
       double_ptr = FFI::MemoryPointer.new(:double)
 
       if densify_frac
-        FFIGeos.GEOSHausdorffDistanceDensify_r(Geos.current_handle_pointer, self.ptr, geom.ptr, densify_frac, double_ptr)
+        FFIGeos.GEOSHausdorffDistanceDensify_r(Geos.current_handle_pointer, ptr, geom.ptr, densify_frac, double_ptr)
       else
-        FFIGeos.GEOSHausdorffDistance_r(Geos.current_handle_pointer, self.ptr, geom.ptr, double_ptr)
+        FFIGeos.GEOSHausdorffDistance_r(Geos.current_handle_pointer, ptr, geom.ptr, double_ptr)
       end
 
       double_ptr.read_double
@@ -506,72 +531,91 @@ module Geos
       # Available in GEOS 3.4+.
       def nearest_points(geom)
         check_geometry(geom)
-        ptr = FFIGeos.GEOSNearestPoints_r(Geos.current_handle_pointer, self.ptr, geom.ptr)
+        nearest_points_ptr = FFIGeos.GEOSNearestPoints_r(Geos.current_handle_pointer, ptr, geom.ptr)
 
-        if !ptr.null?
-          CoordinateSequence.new(ptr)
-        end
+        return CoordinateSequence.new(nearest_points_ptr) unless nearest_points_ptr.null?
       end
     end
 
     def snap(geom, tolerance)
       check_geometry(geom)
-      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)
-      })
+      cast_geometry_ptr(FFIGeos.GEOSSnap_r(Geos.current_handle_pointer, ptr, geom.ptr, tolerance), srid_copy: pick_srid_from_geoms(srid, geom.srid))
     end
-    alias_method :snap_to, :snap
+    alias snap_to snap
 
     def shared_paths(geom)
       check_geometry(geom)
-      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
+      cast_geometry_ptr(FFIGeos.GEOSSharedPaths_r(Geos.current_handle_pointer, ptr, geom.ptr), srid_copy: pick_srid_from_geoms(srid, geom.srid)).to_a
     end
 
     # Returns a Hash with the following structure:
     #
     #   {
-    #     :rings => [ ... ],
-    #     :cuts => [ ... ],
-    #     :dangles => [ ... ],
-    #     :invalid_rings => [ ... ]
+    #     rings: [ ... ],
+    #     cuts: [ ... ],
+    #     dangles: [ ... ],
+    #     invalid_rings: [ ... ]
     #   }
     def polygonize_full
       cuts = FFI::MemoryPointer.new(:pointer)
       dangles = FFI::MemoryPointer.new(:pointer)
       invalid_rings = FFI::MemoryPointer.new(:pointer)
 
-      rings = cast_geometry_ptr(
-        FFIGeos.GEOSPolygonize_full_r(Geos.current_handle_pointer, self.ptr, cuts, dangles, invalid_rings), {
-          :srid_copy => self.srid
-        }
-      )
+      rings = cast_geometry_ptr(FFIGeos.GEOSPolygonize_full_r(Geos.current_handle_pointer, ptr, cuts, dangles, invalid_rings), srid_copy: srid)
 
-      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)
+      cuts = cast_geometry_ptr(cuts.read_pointer, srid_copy: srid)
+      dangles = cast_geometry_ptr(dangles.read_pointer, srid_copy: srid)
+      invalid_rings = cast_geometry_ptr(invalid_rings.read_pointer, srid_copy: srid)
 
       {
-        :rings => rings.to_a,
-        :cuts => cuts.to_a,
-        :dangles => dangles.to_a,
-        :invalid_rings => invalid_rings.to_a
+        rings: rings.to_a,
+        cuts: cuts.to_a,
+        dangles: dangles.to_a,
+        invalid_rings: invalid_rings.to_a
       }
     end
 
-    def polygonize
-      ary = FFI::MemoryPointer.new(:pointer)
-      ary.write_array_of_pointer([ self.ptr ])
+    def polygonize(*geoms)
+      geoms.each do |geom|
+        raise ArgumentError unless geom.is_a?(Geos::Geometry)
+      end
+
+      ary = [ptr].concat(geoms.collect(&:ptr))
+      ary_ptr = FFI::MemoryPointer.new(:pointer, ary.length)
+      ary_ptr.write_array_of_pointer(ary)
 
-      cast_geometry_ptr(FFIGeos.GEOSPolygonize_r(Geos.current_handle_pointer, ary, 1), :srid_copy => self.srid).to_a
+      cast_geometry_ptr(FFIGeos.GEOSPolygonize_r(Geos.current_handle_pointer, ary_ptr, ary.length), srid_copy: srid).to_a
+    end
+
+    if FFIGeos.respond_to?(:GEOSPolygonize_valid_r)
+      # Added in GEOS 3.8+
+      def polygonize_valid
+        ary = FFI::MemoryPointer.new(:pointer)
+        ary.write_array_of_pointer([ptr])
+
+        cast_geometry_ptr(FFIGeos.GEOSPolygonize_valid_r(Geos.current_handle_pointer, ary, 1), srid_copy: srid)
+      end
     end
 
     def polygonize_cut_edges
       ary = FFI::MemoryPointer.new(:pointer)
-      ary.write_array_of_pointer([ self.ptr ])
+      ary.write_array_of_pointer([ptr])
+
+      cast_geometry_ptr(FFIGeos.GEOSPolygonizer_getCutEdges_r(Geos.current_handle_pointer, ary, 1), srid_copy: srid).to_a
+    end
+
+    if FFIGeos.respond_to?(:GEOSBuildArea_r)
+      # Added in GEOS 3.8+
+      def build_area
+        cast_geometry_ptr(FFIGeos.GEOSBuildArea_r(Geos.current_handle_pointer, ptr))
+      end
+    end
 
-      cast_geometry_ptr(FFIGeos.GEOSPolygonizer_getCutEdges_r(Geos.current_handle_pointer, ary, 1), :srid_copy => self.srid).to_a
+    if FFIGeos.respond_to?(:GEOSMakeValid_r)
+      # Added in GEOS 3.8+
+      def make_valid
+        cast_geometry_ptr(FFIGeos.GEOSMakeValid_r(Geos.current_handle_pointer, ptr))
+      end
     end
 
     if FFIGeos.respond_to?(:GEOSDelaunayTriangulation_r)
@@ -589,7 +633,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_pointer, self.ptr, tolerance, only_edges))
+        cast_geometry_ptr(FFIGeos.GEOSDelaunayTriangulation_r(Geos.current_handle_pointer, ptr, tolerance, only_edges))
       end
     end
 
@@ -617,7 +661,7 @@ module Geos
 
         only_edges = bool_to_int(options[:only_edges])
 
-        cast_geometry_ptr(FFIGeos.GEOSVoronoiDiagram_r(Geos.current_handle_pointer, self.ptr, envelope_ptr, tolerance, only_edges))
+        cast_geometry_ptr(FFIGeos.GEOSVoronoiDiagram_r(Geos.current_handle_pointer, ptr, envelope_ptr, tolerance, only_edges))
       end
     end
 
@@ -628,24 +672,22 @@ module Geos
     def to_s
       writer = WktWriter.new
       wkt = writer.write(self)
-      if wkt.length > 120
-        wkt = "#{wkt[0...120]} ... "
-      end
+      wkt = "#{wkt[0...120]} ... " if wkt.length > 120
 
-      "#<Geos::#{self.geom_type}: #{wkt}>"
+      "#<Geos::#{geom_type}: #{wkt}>"
     end
 
     if FFIGeos.respond_to?(:GEOSGeom_getPrecision_r)
       def precision
-        FFIGeos.GEOSGeom_getPrecision_r(Geos.current_handle_pointer, self.ptr)
+        FFIGeos.GEOSGeom_getPrecision_r(Geos.current_handle_pointer, ptr)
       end
     end
 
     if FFIGeos.respond_to?(:GEOSGeom_setPrecision_r)
       def with_precision(grid_size, options = {})
         options = {
-          :no_topology => false,
-          :keep_collapsed => false
+          no_topology: false,
+          keep_collapsed: false
         }.merge(options)
 
         flags = options.reduce(0) do |memo, (key, value)|
@@ -653,33 +695,67 @@ module Geos
           memo
         end
 
-        cast_geometry_ptr(FFIGeos.GEOSGeom_setPrecision_r(Geos.current_handle_pointer, self.ptr, grid_size, flags))
+        cast_geometry_ptr(FFIGeos.GEOSGeom_setPrecision_r(Geos.current_handle_pointer, 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))
+        cast_geometry_ptr(FFIGeos.GEOSMinimumRotatedRectangle_r(Geos.current_handle_pointer, 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)
+        FFIGeos.GEOSMinimumClearance_r(Geos.current_handle_pointer, 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))
+        cast_geometry_ptr(FFIGeos.GEOSMinimumClearanceLine_r(Geos.current_handle_pointer, ptr))
+      end
+    end
+
+    if FFIGeos.respond_to?(:GEOSMaximumInscribedCircle_r)
+      def maximum_inscribed_circle(precision)
+        cast_geometry_ptr(FFIGeos.GEOSMaximumInscribedCircle_r(Geos.current_handle_pointer, ptr, precision))
+      end
+    end
+
+    if FFIGeos.respond_to?(:GEOSLargestEmptyCircle_r)
+      def largest_empty_circle(precision, boundary: nil)
+        cast_geometry_ptr(FFIGeos.GEOSLargestEmptyCircle_r(Geos.current_handle_pointer, ptr, boundary ? boundary.ptr : nil, precision))
       end
     end
 
     if FFIGeos.respond_to?(:GEOSMinimumWidth_r)
       def minimum_width
-        cast_geometry_ptr(FFIGeos.GEOSMinimumWidth_r(Geos.current_handle_pointer, self.ptr))
+        cast_geometry_ptr(FFIGeos.GEOSMinimumWidth_r(Geos.current_handle_pointer, ptr))
+      end
+    end
+
+    if FFIGeos.respond_to?(:GEOSReverse_r)
+      def reverse
+        cast_geometry_ptr(FFIGeos.GEOSReverse_r(Geos.current_handle_pointer, ptr))
+      end
+    end
+
+    if FFIGeos.respond_to?(:GEOSFrechetDistance_r)
+      def frechet_distance(geom, densify_frac = nil)
+        check_geometry(geom)
+
+        double_ptr = FFI::MemoryPointer.new(:double)
+
+        if densify_frac
+          FFIGeos.GEOSFrechetDistanceDensify_r(Geos.current_handle_pointer, ptr, geom.ptr, densify_frac, double_ptr)
+        else
+          FFIGeos.GEOSFrechetDistance_r(Geos.current_handle_pointer, ptr, geom.ptr, double_ptr)
+        end
+
+        double_ptr.read_double
       end
     end
   end