ffi-geos 1.2.1 → 1.2.2

data/lib/ffi-geos/geometry_collection.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
@@ -8,34 +7,83 @@ 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|
+        self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+          def #{dimension}_#{op}
+            unless self.empty?
+              self.collect(&:#{dimension}_#{op}).#{op}
+            end
+          end
+        EOF
+      end
+    end
+
+    %w{
+      affine
+      rotate
+      rotate_x
+      rotate_y
+      rotate_z
+      scale
+      snap_to_grid
+      trans_scale
+      translate
+    }.each do |m|
+      self.class_eval(<<-EOF, __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
+      EOF
+    end
   end
 end

data/lib/ffi-geos/interrupt.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
@@ -27,9 +26,9 @@ module Geos
         # 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")
+            raise ArgumentError, '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")
+            raise ArgumentError, 'Cannot use both a method and a block for Geos::Interrupt.register'
           else
             retval = @current_interrupt_callback
 
@@ -72,4 +71,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,192 @@ 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 < 0 || 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(
-          Geos.current_handle_pointer,
-          self.ptr,
-          width,
-          options[:quad_segs],
-          options[:join],
-          options[:mitre_limit]
-      ), {
-        :srid_copy => self.srid
-      })
+        Geos.current_handle_pointer,
+        ptr,
+        width,
+        options[:quad_segs],
+        options[:join],
+        options[:mitre_limit]
+      ), 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)
+      if !self.empty?
+        cs = self.coord_seq.snap_to_grid!(*args)
+
+        if cs.length == 0
+          @ptr = Geos.create_empty_line_string(:srid => self.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")
+        else
+          @ptr = Geos.create_line_string(cs).ptr
+        end
+      end
+
+      self
+    end
+
+    def snap_to_grid(*args)
+      ret = self.dup.snap_to_grid!(*args)
+      ret.srid = pick_srid_according_to_policy(self.srid)
+      ret
+    end
+
+    def line_interpolate_point(fraction)
+      if !fraction.between?(0, 1)
+        raise ArgumentError.new("fraction must be between 0 and 1")
+      end
+
+      case fraction
+        when 0
+          self.start_point
+        when 1
+          self.end_point
+        else
+          length = self.length
+          total_length = 0
+          segs = self.num_points - 1
+
+          segs.times do |i|
+            p1 = self[i]
+            p2 = self[i + 1]
+
+            seg_length = p1.distance(p2) / length
+
+            if 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 << { :srid => pick_srid_according_to_policy(self.srid) } unless self.srid == 0
+
+              return Geos.create_point(*args)
+            end
+
+            total_length += seg_length
+          end
+
+          # if all else fails...
+          self.end_point
+      end
+    end
+    alias_method :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}
+            end
+          end
+        EOF
+      end
+
+      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+        def z_#{op}
+          unless self.empty?
+            if self.has_z?
+              self.coord_seq.z_#{op}
+            else
+              0
+            end
+          end
+        end
+      EOF
+    end
+
+    %w{
+      affine
+      rotate
+      rotate_x
+      rotate_y
+      rotate_z
+      scale
+      trans_scale
+      translate
+    }.each do |m|
+      self.class_eval(<<-EOF, __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
+      EOF
     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,11 +69,67 @@ 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
+      RUBY
+    end
+
+    def dump_points(cur_path = [])
+      cur_path.push(self.dup)
+    end
+
+    %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.#{dimension}
+            end
+          end
+        EOF
+      end
+
+      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+        def z_#{op}
+          unless self.empty?
+            if self.has_z?
+              self.z
+            else
+              0
+            end
+          end
+        end
+      EOF
+    end
+
+    %w{
+      affine
+      rotate
+      rotate_x
+      rotate_y
+      rotate_z
+      scale
+      snap_to_grid
+      trans_scale
+      translate
+    }.each do |m|
+      self.class_eval(<<-EOF, __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
       EOF
     end