ffi-geos 2.0.0 → 2.1.0

data/lib/ffi-geos/geometry.rb

@@ -53,9 +53,7 @@ module Geos
     end
 
     def normalize!
-      if FFIGeos.GEOSNormalize_r(Geos.current_handle_pointer, ptr) == -1
-        raise Geos::Geometry::CouldntNormalizeError, self.class
-      end
+      raise Geos::Geometry::CouldntNormalizeError, self.class if FFIGeos.GEOSNormalize_r(Geos.current_handle_pointer, ptr) == -1
 
       self
     end
@@ -163,12 +161,10 @@ module Geos
       if geom
         check_geometry(geom)
         cast_geometry_ptr(FFIGeos.GEOSUnion_r(Geos.current_handle_pointer, ptr, geom.ptr), srid_copy: pick_srid_from_geoms(srid, geom.srid))
+      elsif respond_to?(:unary_union)
+        unary_union
       else
-        if respond_to?(:unary_union)
-          unary_union
-        else
-          union_cascaded
-        end
+        union_cascaded
       end
     end
 
@@ -176,6 +172,13 @@ module Geos
       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
@@ -208,6 +211,14 @@ module Geos
     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
+
     def envelope
       cast_geometry_ptr(FFIGeos.GEOSEnvelope_r(Geos.current_handle_pointer, ptr), srid_copy: srid)
     end
@@ -302,9 +313,9 @@ module Geos
           *T****FF*
           ***T**FF*
           ****T*FF*
-        }.detect do |pattern|
+        }.detect { |pattern|
           relate_pattern(geom, pattern)
-        end
+        }
       end
     end
 
@@ -324,9 +335,9 @@ module Geos
           *TF**F***
           **FT*F***
           **F*TF***
-        }.detect do |pattern|
+        }.detect { |pattern|
           relate_pattern(geom, pattern)
-        end
+        }
       end
     end
 
@@ -467,6 +478,17 @@ module Geos
       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)
 
@@ -529,20 +551,49 @@ module Geos
       }
     end
 
-    def polygonize
-      ary = FFI::MemoryPointer.new(:pointer)
-      ary.write_array_of_pointer([ ptr ])
+    def polygonize(*geoms)
+      geoms.each do |geom|
+        raise ArgumentError unless geom.is_a?(Geos::Geometry)
+      end
 
-      cast_geometry_ptr(FFIGeos.GEOSPolygonize_r(Geos.current_handle_pointer, ary, 1), srid_copy: srid).to_a
+      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_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([ 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
+
+    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)
       # :call-seq:
       #   delaunay_triangulation(options = {})

data/lib/ffi-geos/geometry_collection.rb

@@ -46,13 +46,27 @@ module Geos
 
     %w{ x y z }.each do |dimension|
       %w{ max min }.each do |op|
-        self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
-          def #{dimension}_#{op}
-            unless self.empty?
-              self.collect(&:#{dimension}_#{op}).#{op}
+        native_method = "GEOSGeom_get#{dimension.upcase}#{op[0].upcase}#{op[1..-1]}_r"
+
+        if FFIGeos.respond_to?(native_method)
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def #{dimension}_#{op}
+              return if empty?
+
+              double_ptr = FFI::MemoryPointer.new(:double)
+              FFIGeos.#{native_method}(Geos.current_handle_pointer, ptr, double_ptr)
+              double_ptr.read_double
             end
-          end
-        EOF
+          RUBY
+        else
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def #{dimension}_#{op}
+              unless self.empty?
+                self.collect(&:#{dimension}_#{op}).#{op}
+              end
+            end
+          RUBY
+        end
       end
     end
 
@@ -67,7 +81,7 @@ module Geos
       trans_scale
       translate
     }.each do |m|
-      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
         def #{m}!(*args)
           unless self.empty?
             self.num_geometries.times do |i|
@@ -83,7 +97,7 @@ module Geos
           ret.srid = pick_srid_according_to_policy(self.srid)
           ret
         end
-      EOF
+      RUBY
     end
   end
 end

data/lib/ffi-geos/interrupt.rb

@@ -25,23 +25,20 @@ module Geos
         # collector may not play nicely with GEOS and objects may get cleaned
         # up in unexpected ways while interrupts are firing.
         def register(method_or_block = nil, &block)
-          if method_or_block.nil? && !block_given?
-            raise ArgumentError, 'Expected either a method or a block for Geos::Interrupt.register'
-          elsif !method_or_block.nil? && block_given?
-            raise ArgumentError, 'Cannot use both a method and a block for Geos::Interrupt.register'
-          else
-            retval = @current_interrupt_callback
+          raise ArgumentError, 'Expected either a method or a block for Geos::Interrupt.register' if method_or_block.nil? && !block_given?
+          raise ArgumentError, 'Cannot use both a method and a block for Geos::Interrupt.register' if !method_or_block.nil? && block_given?
 
-            @current_interrupt_callback = if method_or_block
-              FFIGeos.GEOS_interruptRegisterCallback(method_or_block)
-              method_or_block
-            elsif block_given?
-              FFIGeos.GEOS_interruptRegisterCallback(block)
-              block
-            end
+          retval = @current_interrupt_callback
 
-            retval
+          @current_interrupt_callback = if method_or_block
+            FFIGeos.GEOS_interruptRegisterCallback(method_or_block)
+            method_or_block
+          elsif block_given?
+            FFIGeos.GEOS_interruptRegisterCallback(block)
+            block
           end
+
+          retval
         end
 
         # Interrupt the current operation. This method should generally be

data/lib/ffi-geos/line_string.rb

@@ -28,7 +28,7 @@ module Geos
     end
 
     def point_n(n)
-      raise Geos::IndexBoundsError if n < 0 || n >= num_points
+      raise Geos::IndexBoundsError if n.negative? || n >= num_points
 
       cast_geometry_ptr(FFIGeos.GEOSGeomGetPointN_r(Geos.current_handle_pointer, ptr, n), srid_copy: srid)
     end
@@ -45,14 +45,17 @@ module Geos
     def offset_curve(width, options = {})
       options = Constants::BUFFER_PARAM_DEFAULTS.merge(options)
 
-      cast_geometry_ptr(FFIGeos.GEOSOffsetCurve_r(
-        Geos.current_handle_pointer,
-        ptr,
-        width,
-        options[:quad_segs],
-        options[:join],
-        options[:mitre_limit]
-      ), srid_copy: srid)
+      cast_geometry_ptr(
+        FFIGeos.GEOSOffsetCurve_r(
+          Geos.current_handle_pointer,
+          ptr,
+          width,
+          options[:quad_segs],
+          options[:join],
+          options[:mitre_limit]
+        ),
+        srid_copy: srid
+      )
     end
 
     if FFIGeos.respond_to?(:GEOSisClosed_r)
@@ -79,13 +82,13 @@ module Geos
     end
 
     def snap_to_grid!(*args)
-      if !self.empty?
-        cs = self.coord_seq.snap_to_grid!(*args)
+      unless empty?
+        cs = coord_seq.snap_to_grid!(*args)
 
-        if cs.length == 0
-          @ptr = Geos.create_empty_line_string(:srid => self.srid).ptr
+        if cs.empty?
+          @ptr = Geos.create_empty_line_string(srid: srid).ptr
         elsif cs.length <= 1
-          raise Geos::InvalidGeometryError.new("snap_to_grid! produced an invalid number of points in for a LineString - found #{cs.length} - must be 0 or > 1")
+          raise Geos::InvalidGeometryError, "snap_to_grid! produced an invalid number of points in for a LineString - found #{cs.length} - must be 0 or > 1"
         else
           @ptr = Geos.create_line_string(cs).ptr
         end
@@ -95,41 +98,39 @@ module Geos
     end
 
     def snap_to_grid(*args)
-      ret = self.dup.snap_to_grid!(*args)
-      ret.srid = pick_srid_according_to_policy(self.srid)
+      ret = dup.snap_to_grid!(*args)
+      ret.srid = pick_srid_according_to_policy(srid)
       ret
     end
 
     def line_interpolate_point(fraction)
-      if !fraction.between?(0, 1)
-        raise ArgumentError.new("fraction must be between 0 and 1")
-      end
+      raise ArgumentError, 'fraction must be between 0 and 1' unless fraction.between?(0, 1)
 
       case fraction
         when 0
-          self.start_point
+          start_point
         when 1
-          self.end_point
+          end_point
         else
           length = self.length
           total_length = 0
-          segs = self.num_points - 1
+          segs = num_points - 1
 
           segs.times do |i|
-            p1 = self[i]
-            p2 = self[i + 1]
+            p_1 = self[i]
+            p_2 = self[i + 1]
 
-            seg_length = p1.distance(p2) / length
+            seg_length = p_1.distance(p_2) / length
 
             if fraction < total_length + seg_length
-              dseg = (fraction - total_length) / seg_length;
+              dseg = (fraction - total_length) / seg_length
 
               args = []
-              args << p1.x + ((p2.x - p1.x) * dseg)
-              args << p1.y + ((p2.y - p1.y) * dseg)
-              args << p1.z + ((p2.z - p1.z) * dseg) if self.has_z?
+              args << p_1.x + ((p_2.x - p_1.x) * dseg)
+              args << p_1.y + ((p_2.y - p_1.y) * dseg)
+              args << p_1.z + ((p_2.z - p_1.z) * dseg) if has_z?
 
-              args << { :srid => pick_srid_according_to_policy(self.srid) } unless self.srid == 0
+              args << { srid: pick_srid_according_to_policy(srid) } unless srid.zero?
 
               return Geos.create_point(*args)
             end
@@ -138,23 +139,37 @@ module Geos
           end
 
           # if all else fails...
-          self.end_point
+          end_point
       end
     end
-    alias_method :interpolate_point, :line_interpolate_point
+    alias interpolate_point line_interpolate_point
 
     %w{ max min }.each do |op|
       %w{ x y }.each do |dimension|
-        self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
-          def #{dimension}_#{op}
-            unless self.empty?
-              self.coord_seq.#{dimension}_#{op}
+        native_method = "GEOSGeom_get#{dimension.upcase}#{op[0].upcase}#{op[1..-1]}_r"
+
+        if FFIGeos.respond_to?(native_method)
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def #{dimension}_#{op}
+              return if empty?
+
+              double_ptr = FFI::MemoryPointer.new(:double)
+              FFIGeos.#{native_method}(Geos.current_handle_pointer, ptr, double_ptr)
+              double_ptr.read_double
             end
-          end
-        EOF
+          RUBY
+        else
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def #{dimension}_#{op}
+              unless self.empty?
+                self.coord_seq.#{dimension}_#{op}
+              end
+            end
+          RUBY
+        end
       end
 
-      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
         def z_#{op}
           unless self.empty?
             if self.has_z?
@@ -164,7 +179,7 @@ module Geos
             end
           end
         end
-      EOF
+      RUBY
     end
 
     %w{
@@ -177,7 +192,7 @@ module Geos
       trans_scale
       translate
     }.each do |m|
-      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
         def #{m}!(*args)
           unless self.empty?
             self.coord_seq.#{m}!(*args)
@@ -191,7 +206,7 @@ module Geos
           ret.srid = pick_srid_according_to_policy(self.srid)
           ret
         end
-      EOF
+      RUBY
     end
   end
 end

data/lib/ffi-geos/point.rb

@@ -79,31 +79,31 @@ module Geos
     end
 
     def dump_points(cur_path = [])
-      cur_path.push(self.dup)
+      cur_path.push(dup)
     end
 
     %w{ max min }.each do |op|
       %w{ x y }.each do |dimension|
-        self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
           def #{dimension}_#{op}
-            unless self.empty?
-              self.#{dimension}
+            unless empty?
+              #{dimension}
             end
           end
-        EOF
+        RUBY
       end
 
-      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
         def z_#{op}
-          unless self.empty?
-            if self.has_z?
-              self.z
+          unless empty?
+            if has_z?
+              z
             else
               0
             end
           end
         end
-      EOF
+      RUBY
     end
 
     %w{
@@ -117,21 +117,21 @@ module Geos
       trans_scale
       translate
     }.each do |m|
-      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
         def #{m}!(*args)
-          unless self.empty?
-            self.coord_seq.#{m}!(*args)
+          unless empty?
+            coord_seq.#{m}!(*args)
           end
 
           self
         end
 
         def #{m}(*args)
-          ret = self.dup.#{m}!(*args)
-          ret.srid = pick_srid_according_to_policy(self.srid)
+          ret = dup.#{m}!(*args)
+          ret.srid = pick_srid_according_to_policy(srid)
           ret
         end
-      EOF
+      RUBY
     end
   end
 end