ffi-geos 1.2.0 → 2.2.0

data/lib/ffi-geos/polygon.rb

@@ -1,41 +1,144 @@
-# 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)
+      unless empty?
+        exterior_ring = self.exterior_ring.coord_seq.snap_to_grid!(*args)
+
+        if exterior_ring.empty?
+          @ptr = Geos.create_empty_polygon(srid: srid).ptr
+        elsif exterior_ring.length < 4
+          raise Geos::InvalidGeometryError, "snap_to_grid! produced an invalid number of points in exterior ring - found #{exterior_ring.length} - must be 0 or >= 4"
+        else
+          interior_rings = []
+
+          num_interior_rings.times do |i|
+            interior_ring = interior_ring_n(i).coord_seq.snap_to_grid!(*args)
+
+            interior_rings << interior_ring unless interior_ring.length < 4
+          end
+
+          interior_rings.compact!
+
+          polygon = Geos.create_polygon(exterior_ring, interior_rings, srid: srid)
+          @ptr = polygon.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
+
+    %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 empty?
+                envelope.exterior_ring.#{dimension}_#{op}
+              end
+            end
+          RUBY
+        end
+      end
+
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        def z_#{op}
+          unless empty?
+            if has_z?
+              exterior_ring.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)
+          exterior_ring.coord_seq.#{m}!(*args)
+          interior_rings.each do |ring|
+            ring.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

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
 
@@ -24,23 +23,22 @@ module Geos
       geoms_and_objects = nil # forward declaration
       capacity = 10
 
-      if args.first.is_a?(Integer)
-        capacity = args.first
-      elsif args.first.is_a?(Array)
-        geoms_and_objects = if args.first.first.is_a?(Array)
-          args.first
-        else
-          args
-        end
+      case args.first
+        when Integer
+          capacity = args.first
+        when Array
+          geoms_and_objects = if args.first.first.is_a?(Array)
+            args.first
+          else
+            args
+          end
 
-        geoms_and_objects.each do |geom, obj|
-          check_geometry(geom)
-        end
+          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")
-      end
+      raise ArgumentError, 'STRtree capacity must be greater than 0' if capacity <= 0
 
       ptr = FFIGeos.GEOSSTRtree_create_r(Geos.current_handle_pointer, capacity)
 
@@ -55,10 +53,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,41 +78,37 @@ 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)
       check_geometry(geom)
 
-      key = if storage = @storage.detect { |k, v| v[:item] == item }
+      key = if (storage = @storage.detect { |_k, v| v[:item] == item })
         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 +122,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,42 +137,37 @@ module Geos
     end
 
     def query(geom, ret = :item)
-      self.query_all(geom).collect { |storage|
-        item = if ret.is_a?(Array)
-          storage.inject({}) do |memo, k|
-            memo.tap {
-              memo[k] = storage[k]
-            }
-          end
-        elsif ret == :all
-          storage
-        else
-          storage[ret]
+      query_all(geom).collect { |storage|
+        item = case ret
+          when Array
+            storage.inject({}) do |memo, k|
+              memo.tap do
+                memo[k] = storage[k]
+              end
+            end
+          when :all
+            storage
+          else
+            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|
-        yield(v)
-      end
+    def iterate(&block)
+      @storage.each_value(&block)
     end
 
     if FFIGeos.respond_to?(:GEOSSTRtree_nearest_generic_r)
@@ -191,7 +178,7 @@ module Geos
 
         return nil if @storage.empty?
 
-        callback = proc { |item, _item2, distance_ptr|
+        callback = proc { |item, _item_2, distance_ptr|
           key = item.read_int
           geom_from_storage = @storage[key][:geometry]
 
@@ -205,7 +192,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 +206,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)