ffi-geos 1.2.0 → 2.2.0

data/lib/ffi-geos/geometry_collection.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
@@ -8,34 +7,97 @@ module Geos
     # Yields each Geometry in the GeometryCollection.
     def each
       if block_given?
-        self.num_geometries.times do |n|
-          yield self.get_geometry_n(n)
+        num_geometries.times do |n|
+          yield get_geometry_n(n)
         end
         self
       else
-        self.num_geometries.times.collect { |n|
-          self.get_geometry_n(n)
+        num_geometries.times.collect { |n|
+          get_geometry_n(n)
         }.to_enum
       end
     end
 
     def get_geometry_n(n)
-      if n < 0 || n >= self.num_geometries
+      if n.negative? || n >= num_geometries
         nil
       else
-        cast_geometry_ptr(FFIGeos.GEOSGetGeometryN_r(Geos.current_handle_pointer, self.ptr, n), :auto_free => false)
+        cast_geometry_ptr(FFIGeos.GEOSGetGeometryN_r(Geos.current_handle_pointer, ptr, n), auto_free: false)
       end
     end
-    alias_method :geometry_n, :get_geometry_n
+    alias geometry_n get_geometry_n
 
     def [](*args)
       if args.length == 1 && args.first.is_a?(Numeric) && args.first >= 0
-        self.get_geometry_n(args.first)
+        get_geometry_n(args.first)
       else
-        self.to_a[*args]
+        to_a[*args]
       end
     end
-    alias_method :slice, :[]
-    alias_method :at, :[]
+    alias slice []
+    alias at []
+
+    def dump_points(cur_path = [])
+      each do |geom|
+        cur_path << geom.dump_points
+      end
+      cur_path
+    end
+
+    %w{ x y z }.each do |dimension|
+      %w{ max min }.each do |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
+          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
+
+    %w{
+      affine
+      rotate
+      rotate_x
+      rotate_y
+      rotate_z
+      scale
+      snap_to_grid
+      trans_scale
+      translate
+    }.each do |m|
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def #{m}!(*args)
+          unless self.empty?
+            self.num_geometries.times do |i|
+              self[i].#{m}!(*args)
+            end
+          end
+
+          self
+        end
+
+        def #{m}(*args)
+          ret = self.dup.#{m}!(*args)
+          ret.srid = pick_srid_according_to_policy(self.srid)
+          ret
+        end
+      RUBY
+    end
   end
 end

data/lib/ffi-geos/interrupt.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
@@ -26,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.new("Expected either a method or a block for Geos::Interrupt.register")
-          elsif !method_or_block.nil? && block_given?
-            raise ArgumentError.new("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
@@ -72,4 +68,3 @@ module Geos
     end
   end
 end
-

data/lib/ffi-geos/line_string.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
@@ -7,82 +6,207 @@ module Geos
 
     def each
       if block_given?
-        self.num_points.times do |n|
-          yield self.point_n(n)
+        num_points.times do |n|
+          yield point_n(n)
         end
         self
       else
-        self.num_points.times.collect { |n|
-          self.point_n(n)
+        num_points.times.collect { |n|
+          point_n(n)
         }.to_enum
       end
     end
 
     if FFIGeos.respond_to?(:GEOSGeomGetNumPoints_r)
       def num_points
-        FFIGeos.GEOSGeomGetNumPoints_r(Geos.current_handle_pointer, self.ptr)
+        FFIGeos.GEOSGeomGetNumPoints_r(Geos.current_handle_pointer, ptr)
       end
     else
       def num_points
-        self.coord_seq.length
+        coord_seq.length
       end
     end
 
     def point_n(n)
-      if n < 0 || n >= self.num_points
-        raise Geos::IndexBoundsError.new
-      else
-        cast_geometry_ptr(
-          FFIGeos.GEOSGeomGetPointN_r(Geos.current_handle_pointer, self.ptr, n), {
-            :srid_copy => self.srid
-          }
-        )
-      end
+      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
 
     def [](*args)
       if args.length == 1 && args.first.is_a?(Numeric) && args.first >= 0
-        self.point_n(args.first)
+        point_n(args.first)
       else
-        self.to_a[*args]
+        to_a[*args]
       end
     end
-    alias_method :slice, :[]
+    alias slice []
 
     def offset_curve(width, options = {})
       options = Constants::BUFFER_PARAM_DEFAULTS.merge(options)
 
-      cast_geometry_ptr(FFIGeos.GEOSOffsetCurve_r(
+      cast_geometry_ptr(
+        FFIGeos.GEOSOffsetCurve_r(
           Geos.current_handle_pointer,
-          self.ptr,
+          ptr,
           width,
           options[:quad_segs],
           options[:join],
           options[:mitre_limit]
-      ), {
-        :srid_copy => self.srid
-      })
+        ),
+        srid_copy: srid
+      )
     end
 
     if FFIGeos.respond_to?(:GEOSisClosed_r)
       def closed?
-        bool_result(FFIGeos.GEOSisClosed_r(Geos.current_handle_pointer, self.ptr))
+        bool_result(FFIGeos.GEOSisClosed_r(Geos.current_handle_pointer, ptr))
       end
     end
 
     def to_linear_ring
-      if self.closed?
-        Geos.create_linear_ring(self.coord_seq, :srid => pick_srid_according_to_policy(self.srid))
-      else
-        self_cs = self.coord_seq.to_a
-        self_cs.push(self_cs[0])
+      return Geos.create_linear_ring(coord_seq, srid: pick_srid_according_to_policy(srid)) if closed?
 
-        Geos.create_linear_ring(self_cs, :srid => pick_srid_according_to_policy(self.srid))
-      end
+      self_cs = coord_seq.to_a
+      self_cs.push(self_cs[0])
+
+      Geos.create_linear_ring(self_cs, srid: pick_srid_according_to_policy(srid))
     end
 
     def to_polygon
-      self.to_linear_ring.to_polygon
+      to_linear_ring.to_polygon
+    end
+
+    def dump_points(cur_path = [])
+      cur_path.concat(to_a)
+    end
+
+    def snap_to_grid!(*args)
+      unless empty?
+        cs = coord_seq.snap_to_grid!(*args)
+
+        if cs.empty?
+          @ptr = Geos.create_empty_line_string(srid: srid).ptr
+        elsif cs.length <= 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
+      end
+
+      self
+    end
+
+    def snap_to_grid(*args)
+      ret = dup.snap_to_grid!(*args)
+      ret.srid = pick_srid_according_to_policy(srid)
+      ret
+    end
+
+    def line_interpolate_point(fraction)
+      raise ArgumentError, 'fraction must be between 0 and 1' unless fraction.between?(0, 1)
+
+      case fraction
+        when 0
+          start_point
+        when 1
+          end_point
+        else
+          length = self.length
+          total_length = 0
+          segs = num_points - 1
+
+          segs.times do |i|
+            p_1 = self[i]
+            p_2 = self[i + 1]
+
+            seg_length = p_1.distance(p_2) / length
+
+            if fraction < total_length + seg_length
+              dseg = (fraction - total_length) / seg_length
+
+              args = []
+              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(srid) } unless srid.zero?
+
+              return Geos.create_point(*args)
+            end
+
+            total_length += seg_length
+          end
+
+          # if all else fails...
+          end_point
+      end
+    end
+    alias interpolate_point line_interpolate_point
+
+    %w{ max min }.each do |op|
+      %w{ x y }.each do |dimension|
+        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
+          RUBY
+        else
+          class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+            def #{dimension}_#{op}
+              unless self.empty?
+                self.coord_seq.#{dimension}_#{op}
+              end
+            end
+          RUBY
+        end
+      end
+
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def z_#{op}
+          unless self.empty?
+            if self.has_z?
+              self.coord_seq.z_#{op}
+            else
+              0
+            end
+          end
+        end
+      RUBY
+    end
+
+    %w{
+      affine
+      rotate
+      rotate_x
+      rotate_y
+      rotate_z
+      scale
+      trans_scale
+      translate
+    }.each do |m|
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def #{m}!(*args)
+          unless self.empty?
+            self.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
+        end
+      RUBY
     end
   end
 end

data/lib/ffi-geos/linear_ring.rb

@@ -1,14 +1,13 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
   class LinearRing < LineString
     def to_polygon
-      Geos.create_polygon(self, :srid => pick_srid_according_to_policy(self.srid))
+      Geos.create_polygon(self, srid: pick_srid_according_to_policy(srid))
     end
 
     def to_line_string
-      Geos.create_line_string(self.coord_seq, :srid => pick_srid_according_to_policy(self.srid))
+      Geos.create_line_string(coord_seq, srid: pick_srid_according_to_policy(srid))
     end
   end
 end

data/lib/ffi-geos/multi_line_string.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
@@ -6,7 +5,7 @@ module Geos
     if FFIGeos.respond_to?(:GEOSisClosed_r) && Geos::GEOS_VERSION >= '3.5.0'
       # Available in GEOS 3.5.0+.
       def closed?
-        bool_result(FFIGeos.GEOSisClosed_r(Geos.current_handle_pointer, self.ptr))
+        bool_result(FFIGeos.GEOSisClosed_r(Geos.current_handle_pointer, ptr))
       end
     end
   end

data/lib/ffi-geos/multi_point.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos

data/lib/ffi-geos/multi_polygon.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos

data/lib/ffi-geos/point.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
@@ -6,41 +5,41 @@ module Geos
     if FFIGeos.respond_to?(:GEOSGeomGetX_r)
       def get_x
         double_ptr = FFI::MemoryPointer.new(:double)
-        FFIGeos.GEOSGeomGetX_r(Geos.current_handle_pointer, self.ptr, double_ptr)
+        FFIGeos.GEOSGeomGetX_r(Geos.current_handle_pointer, ptr, double_ptr)
         double_ptr.read_double
       end
     else
       def get_x
-        self.coord_seq.get_x(0)
+        coord_seq.get_x(0)
       end
     end
-    alias_method :x, :get_x
+    alias x get_x
 
     if FFIGeos.respond_to?(:GEOSGeomGetY_r)
       def get_y
         double_ptr = FFI::MemoryPointer.new(:double)
-        FFIGeos.GEOSGeomGetY_r(Geos.current_handle_pointer, self.ptr, double_ptr)
+        FFIGeos.GEOSGeomGetY_r(Geos.current_handle_pointer, ptr, double_ptr)
         double_ptr.read_double
       end
     else
       def get_y
-        self.coord_seq.get_y(0)
+        coord_seq.get_y(0)
       end
     end
-    alias_method :y, :get_y
+    alias y get_y
 
     if FFIGeos.respond_to?(:GEOSGeomGetZ_r)
       def get_z
         double_ptr = FFI::MemoryPointer.new(:double)
-        FFIGeos.GEOSGeomGetZ_r(Geos.current_handle_pointer, self.ptr, double_ptr)
+        FFIGeos.GEOSGeomGetZ_r(Geos.current_handle_pointer, ptr, double_ptr)
         double_ptr.read_double
       end
     else
       def get_z
-        self.coord_seq.get_z(0)
+        coord_seq.get_z(0)
       end
     end
-    alias_method :z, :get_z
+    alias z get_z
 
     def area
       0
@@ -61,7 +60,7 @@ module Geos
     def normalize!
       self
     end
-    alias_method :normalize, :normalize!
+    alias normalize normalize!
 
     %w{
       convex_hull
@@ -70,13 +69,69 @@ module Geos
       envelope
       topology_preserve_simplify
     }.each do |method|
-      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
         def #{method}(*args)
-          self.dup.tap { |ret|
+          dup.tap do |ret|
             ret.srid = pick_srid_according_to_policy(ret.srid)
-          }
+          end
         end
-      EOF
+      RUBY
+    end
+
+    def dump_points(cur_path = [])
+      cur_path.push(dup)
+    end
+
+    %w{ max min }.each do |op|
+      %w{ x y }.each do |dimension|
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def #{dimension}_#{op}
+            unless empty?
+              #{dimension}
+            end
+          end
+        RUBY
+      end
+
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def z_#{op}
+          unless empty?
+            if has_z?
+              z
+            else
+              0
+            end
+          end
+        end
+      RUBY
+    end
+
+    %w{
+      affine
+      rotate
+      rotate_x
+      rotate_y
+      rotate_z
+      scale
+      snap_to_grid
+      trans_scale
+      translate
+    }.each do |m|
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def #{m}!(*args)
+          unless empty?
+            coord_seq.#{m}!(*args)
+          end
+
+          self
+        end
+
+        def #{m}(*args)
+          ret = dup.#{m}!(*args)
+          ret.srid = pick_srid_according_to_policy(srid)
+          ret
+        end
+      RUBY
     end
   end
 end