ffi-geos 1.2.1 → 1.2.2

data/lib/ffi-geos/polygon.rb

@@ -1,41 +1,130 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
   class Polygon < Geometry
     def num_interior_rings
-      FFIGeos.GEOSGetNumInteriorRings_r(Geos.current_handle_pointer, self.ptr)
+      FFIGeos.GEOSGetNumInteriorRings_r(Geos.current_handle_pointer, ptr)
     end
 
     def interior_ring_n(n)
-      if n < 0 || n >= self.num_interior_rings
-        raise Geos::IndexBoundsError.new
-      else
-        cast_geometry_ptr(
-          FFIGeos.GEOSGetInteriorRingN_r(Geos.current_handle_pointer, self.ptr, n), {
-            :auto_free => false,
-            :srid_copy => self.srid,
-            :parent => self
-          }
-        )
-      end
+      raise Geos::IndexBoundsError if n.negative? || n >= num_interior_rings
+
+      cast_geometry_ptr(
+        FFIGeos.GEOSGetInteriorRingN_r(Geos.current_handle_pointer, ptr, n),
+        auto_free: false,
+        srid_copy: srid,
+        parent: self
+      )
     end
-    alias_method :interior_ring, :interior_ring_n
+    alias interior_ring interior_ring_n
 
     def exterior_ring
       cast_geometry_ptr(
-        FFIGeos.GEOSGetExteriorRing_r(Geos.current_handle_pointer, self.ptr), {
-          :auto_free => false,
-          :srid_copy => self.srid,
-          :parent => self
-        }
+        FFIGeos.GEOSGetExteriorRing_r(Geos.current_handle_pointer, ptr),
+        auto_free: false,
+        srid_copy: srid,
+        parent: self
       )
     end
 
     def interior_rings
-      self.num_interior_rings.times.collect do |n|
-        self.interior_ring_n(n)
+      num_interior_rings.times.collect do |n|
+        interior_ring_n(n)
       end
     end
+
+    def dump_points(cur_path = [])
+      points = [ exterior_ring.dump_points ]
+
+      interior_rings.each do |ring|
+        points.push(ring.dump_points)
+      end
+
+      cur_path.concat(points)
+    end
+
+    def snap_to_grid!(*args)
+      if !self.empty?
+        exterior_ring = self.exterior_ring.coord_seq.snap_to_grid!(*args)
+
+        if exterior_ring.length == 0
+          @ptr = Geos.create_empty_polygon(:srid => self.srid).ptr
+        elsif exterior_ring.length < 4
+          raise Geos::InvalidGeometryError.new("snap_to_grid! produced an invalid number of points in exterior ring - found #{exterior_ring.length} - must be 0 or >= 4")
+        else
+          interior_rings = []
+
+          self.num_interior_rings.times { |i|
+            interior_ring = self.interior_ring_n(i).coord_seq.snap_to_grid!(*args)
+
+            interior_rings << interior_ring unless interior_ring.length < 4
+          }
+
+          interior_rings.compact!
+
+          polygon = Geos.create_polygon(exterior_ring, interior_rings, :srid => self.srid)
+          @ptr = polygon.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
+
+    %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.envelope.exterior_ring.#{dimension}_#{op}
+            end
+          end
+        EOF
+      end
+
+      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+        def z_#{op}
+          unless self.empty?
+            if self.has_z?
+              self.exterior_ring.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)
+          self.exterior_ring.coord_seq.#{m}!(*args)
+          self.interior_rings.each do |ring|
+            ring.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/prepared_geometry.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
@@ -13,7 +12,7 @@ module Geos
       check_geometry(geom)
 
       options = {
-        :auto_free => true
+        auto_free: true
       }.merge(options)
 
       @ptr = FFI::AutoPointer.new(
@@ -31,52 +30,52 @@ module Geos
 
     def contains?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSPreparedContains_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSPreparedContains_r(Geos.current_handle_pointer, ptr, geom.ptr))
     end
 
     def contains_properly?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSPreparedContainsProperly_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSPreparedContainsProperly_r(Geos.current_handle_pointer, ptr, geom.ptr))
     end
 
     def covered_by?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSPreparedCoveredBy_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSPreparedCoveredBy_r(Geos.current_handle_pointer, ptr, geom.ptr))
     end
 
     def covers?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSPreparedCovers_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSPreparedCovers_r(Geos.current_handle_pointer, ptr, geom.ptr))
     end
 
     def crosses?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSPreparedCrosses_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSPreparedCrosses_r(Geos.current_handle_pointer, ptr, geom.ptr))
     end
 
     def disjoint?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSPreparedDisjoint_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSPreparedDisjoint_r(Geos.current_handle_pointer, ptr, geom.ptr))
     end
 
     def intersects?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSPreparedIntersects_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSPreparedIntersects_r(Geos.current_handle_pointer, ptr, geom.ptr))
     end
 
     def overlaps?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSPreparedOverlaps_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSPreparedOverlaps_r(Geos.current_handle_pointer, ptr, geom.ptr))
     end
 
     def touches?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSPreparedTouches_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSPreparedTouches_r(Geos.current_handle_pointer, ptr, geom.ptr))
     end
 
     def within?(geom)
       check_geometry(geom)
-      bool_result(FFIGeos.GEOSPreparedWithin_r(Geos.current_handle_pointer, self.ptr, geom.ptr))
+      bool_result(FFIGeos.GEOSPreparedWithin_r(Geos.current_handle_pointer, ptr, geom.ptr))
     end
   end
 end

data/lib/ffi-geos/strtree.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
@@ -12,7 +11,7 @@ module Geos
 
     class AlreadyBuiltError < Geos::Error
       def initialize(*)
-        super("STRtree has already been built")
+        super('STRtree has already been built')
       end
     end
 
@@ -33,13 +32,13 @@ module Geos
           args
         end
 
-        geoms_and_objects.each do |geom, obj|
+        geoms_and_objects.each do |geom, _obj|
           check_geometry(geom)
         end
       end
 
       if capacity <= 0
-        raise ArgumentError.new("STRtree capacity must be greater than 0")
+        raise ArgumentError, 'STRtree capacity must be greater than 0'
       end
 
       ptr = FFIGeos.GEOSSTRtree_create_r(Geos.current_handle_pointer, capacity)
@@ -55,10 +54,10 @@ module Geos
       @storage_key = 0
       @built = false
 
-      if geoms_and_objects
-        geoms_and_objects.each do |geom, obj|
-          self.insert(geom, obj)
-        end
+      return unless geoms_and_objects
+
+      geoms_and_objects.each do |geom, obj|
+        insert(geom, obj)
       end
     end
 
@@ -80,23 +79,21 @@ module Geos
     private :next_key
 
     def insert(geom, item = nil)
-      if self.built?
-        raise AlreadyBuiltError.new
-      else
-        check_geometry(geom)
+      raise AlreadyBuiltError if built?
 
-        key = next_key
-        key_ptr = FFI::MemoryPointer.new(:pointer)
-        key_ptr.write_int(key)
+      check_geometry(geom)
 
-        @storage[key] = {
-          :item => item,
-          :geometry => geom
-        }
-        @ptrs[key] = key_ptr
+      key = next_key
+      key_ptr = FFI::MemoryPointer.new(:pointer)
+      key_ptr.write_int(key)
 
-        FFIGeos.GEOSSTRtree_insert_r(Geos.current_handle_pointer, self.ptr, geom.ptr, key_ptr)
-      end
+      @storage[key] = {
+        item: item,
+        geometry: geom
+      }
+      @ptrs[key] = key_ptr
+
+      FFIGeos.GEOSSTRtree_insert_r(Geos.current_handle_pointer, ptr, geom.ptr, key_ptr)
     end
 
     def remove(geom, item)
@@ -106,15 +103,13 @@ module Geos
         storage[0]
       end
 
-      if key
-        key_ptr = @ptrs[key]
-        result = FFIGeos.GEOSSTRtree_remove_r(Geos.current_handle_pointer, self.ptr, geom.ptr, key_ptr)
-        built!
+      return unless key
 
-        if result == 1
-          @storage.delete(key)
-        end
-      end
+      key_ptr = @ptrs[key]
+      result = FFIGeos.GEOSSTRtree_remove_r(Geos.current_handle_pointer, ptr, geom.ptr, key_ptr)
+      built!
+
+      @storage.delete(key) if result == 1
     end
 
     def query_all(geom)
@@ -128,14 +123,12 @@ module Geos
         storage = @storage[key]
         retval << storage
 
-        if block_given?
-          yield(storage)
-        end
+        yield(storage) if block_given?
       }
 
       FFIGeos.GEOSSTRtree_query_r(
         Geos.current_handle_pointer,
-        self.ptr,
+        ptr,
         geom.ptr,
         callback,
         nil
@@ -145,12 +138,12 @@ module Geos
     end
 
     def query(geom, ret = :item)
-      self.query_all(geom).collect { |storage|
+      query_all(geom).collect { |storage|
         item = if ret.is_a?(Array)
           storage.inject({}) do |memo, k|
-            memo.tap {
+            memo.tap do
               memo[k] = storage[k]
-            }
+            end
           end
         elsif ret == :all
           storage
@@ -158,27 +151,23 @@ module Geos
           storage[ret]
         end
 
-        item.tap {
-          if block_given?
-            yield(item)
-          end
-        }
+        item.tap do
+          yield(item) if block_given?
+        end
       }.compact
     end
 
     def query_geometries(geom)
-      self.query_all(geom).collect { |storage|
-        storage[:geometry].tap { |val|
-          if block_given?
-            yield(val)
-          end
-        }
+      query_all(geom).collect { |storage|
+        storage[:geometry].tap do |val|
+          yield(val) if block_given?
+        end
       }.compact
     end
-    alias_method :query_geoms, :query_geometries
+    alias query_geoms query_geometries
 
     def iterate
-      @storage.values.each do |v|
+      @storage.each_value do |v|
         yield(v)
       end
     end
@@ -205,7 +194,7 @@ module Geos
 
         key_ptr = FFIGeos.GEOSSTRtree_nearest_generic_r(
           Geos.current_handle_pointer,
-          self.ptr,
+          ptr,
           geom.ptr,
           geom.envelope.ptr,
           callback,
@@ -219,7 +208,7 @@ module Geos
         item = nearest_generic(geom)
         item[:geometry] if item
       end
-      alias_method :nearest_geometry, :nearest
+      alias nearest_geometry nearest
 
       def nearest_item(geom)
         item = nearest_generic(geom)

data/lib/ffi-geos/tools.rb

@@ -1,16 +1,15 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
   class NullPointerError < Geos::Error
     def initialize(*)
-      super("Tried to create a Geometry from a NULL pointer!")
+      super('Tried to create a Geometry from a NULL pointer!')
     end
   end
 
   class InvalidGeometryTypeError < Geos::Error
     def initialize(*)
-      super("Invalid geometry type")
+      super('Invalid geometry type')
     end
   end
 
@@ -25,12 +24,10 @@ module Geos
 
     def cast_geometry_ptr(geom_ptr, options = {})
       options = {
-        :auto_free => true
+        auto_free: true
       }.merge(options)
 
-      if geom_ptr.null?
-        raise Geos::NullPointerError.new
-      end
+      raise Geos::NullPointerError if geom_ptr.null?
 
       klass = case FFIGeos.GEOSGeomTypeId_r(Geos.current_handle_pointer, geom_ptr)
         when GEOS_POINT
@@ -53,7 +50,7 @@ module Geos
           raise Geos::InvalidGeometryTypeError.new
       end
 
-      klass.new(geom_ptr, options).tap { |ret|
+      klass.new(geom_ptr, options).tap do |ret|
         if options[:srid]
           ret.srid = options[:srid] || 0
         elsif options[:srid_copy]
@@ -63,11 +60,11 @@ module Geos
             options[:srid_copy] || 0
           end
         end
-      }
+      end
     end
 
     def check_geometry(geom)
-      raise TypeError.new("Expected Geos::Geometry") unless geom.is_a?(Geos::Geometry)
+      raise TypeError, 'Expected Geos::Geometry' unless geom.is_a?(Geos::Geometry)
     end
 
     def pick_srid_from_geoms(srid_a, srid_b, policy = Geos.srid_copy_policy)
@@ -81,7 +78,7 @@ module Geos
         when :strict
           raise Geos::MixedSRIDsError.new(srid_a, srid_b)
         else
-          raise ArgumentError.new("Unexpected policy value: #{policy}")
+          raise ArgumentError, "Unexpected policy value: #{policy}"
       end
     end
 
@@ -97,12 +94,12 @@ module Geos
 
     def bool_result(result)
       case result
-      when 1
-        true
-      when 0
-        false
-      else
-        raise Geos::UnexpectedBooleanResultError.new(result)
+        when 1
+          true
+        when 0
+          false
+        else
+          raise Geos::UnexpectedBooleanResultError, result
       end
     end
 
@@ -116,7 +113,7 @@ module Geos
 
     def check_enum_value(enum, value)
       enum[value] or
-        raise TypeError.new("Couldn't find valid #{enum.tag} value: #{value}")
+        raise TypeError, "Couldn't find valid #{enum.tag} value: #{value}"
     end
 
     def symbol_for_enum(enum, value)