ffi-geos 1.2.1 → 1.2.2

data/lib/ffi-geos/buffer_params.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
@@ -33,7 +32,7 @@ module Geos
 
         @params = {}
         VALID_PARAMETERS.each do |param|
-          self.send("#{param}=", params[param])
+          send("#{param}=", params[param])
         end
       end
 
@@ -44,43 +43,33 @@ module Geos
       def endcap=(value)
         check_enum_value(Geos::BufferCapStyles, value)
 
-        if bool_result(FFIGeos.GEOSBufferParams_setEndCapStyle_r(Geos.current_handle_pointer, ptr, value))
-          @params[:endcap] = symbol_for_enum(Geos::BufferCapStyles, value)
-        end
+        @params[:endcap] = symbol_for_enum(Geos::BufferCapStyles, value) if bool_result(FFIGeos.GEOSBufferParams_setEndCapStyle_r(Geos.current_handle_pointer, ptr, value))
       end
 
       def join=(value)
         check_enum_value(Geos::BufferJoinStyles, value)
 
-        if bool_result(FFIGeos.GEOSBufferParams_setJoinStyle_r(Geos.current_handle_pointer, ptr, value))
-          @params[:join] = symbol_for_enum(Geos::BufferJoinStyles, value)
-        end
+        @params[:join] = symbol_for_enum(Geos::BufferJoinStyles, value) if bool_result(FFIGeos.GEOSBufferParams_setJoinStyle_r(Geos.current_handle_pointer, ptr, value))
       end
 
       def mitre_limit=(value)
-        if bool_result(FFIGeos.GEOSBufferParams_setMitreLimit_r(Geos.current_handle_pointer, ptr, value))
-          @params[:mitre_limit] = value
-        end
+        @params[:mitre_limit] = value if bool_result(FFIGeos.GEOSBufferParams_setMitreLimit_r(Geos.current_handle_pointer, ptr, value))
       end
 
       def quad_segs=(value)
-        if bool_result(FFIGeos.GEOSBufferParams_setQuadrantSegments_r(Geos.current_handle_pointer, ptr, value))
-          @params[:quad_segs] = value
-        end
+        @params[:quad_segs] = value if bool_result(FFIGeos.GEOSBufferParams_setQuadrantSegments_r(Geos.current_handle_pointer, ptr, value))
       end
 
       def single_sided=(value)
-        if bool_result(FFIGeos.GEOSBufferParams_setSingleSided_r(Geos.current_handle_pointer, ptr, Geos::Tools.bool_to_int(value)))
-          @params[:single_sided] = value
-        end
+        @params[:single_sided] = value if bool_result(FFIGeos.GEOSBufferParams_setSingleSided_r(Geos.current_handle_pointer, ptr, Geos::Tools.bool_to_int(value)))
       end
 
       VALID_PARAMETERS.each do |param|
-        self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
           def #{param}
             @params[:#{param}]
           end
-        EOF
+        RUBY
       end
     else
       attr_accessor(*VALID_PARAMETERS)
@@ -89,7 +78,7 @@ module Geos
         params = Geos::Constants::BUFFER_PARAM_DEFAULTS.merge(params)
 
         VALID_PARAMETERS.each do |param|
-          self.send("#{param}=", params[param])
+          send("#{param}=", params[param])
         end
       end
     end

data/lib/ffi-geos/coordinate_sequence.rb

@@ -1,8 +1,6 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 module Geos
-
   # A CoordinateSequence is a list of coordinates in a Geometry.
   class CoordinateSequence
     class ParseError < Geos::ParseError
@@ -19,22 +17,22 @@ module Geos
       end
 
       def [](idx)
-        parent.get_ordinate(idx, self.dimension)
+        parent.get_ordinate(idx, dimension)
       end
 
       def []=(idx, value)
-        parent.set_ordinate(idx, self.dimension, value)
+        parent.set_ordinate(idx, dimension, value)
       end
 
       def each
         if block_given?
           parent.length.times do |n|
-            yield parent.get_ordinate(n, self.dimension)
+            yield parent.get_ordinate(n, dimension)
           end
           self
         else
           parent.length.times.collect { |n|
-            parent.get_ordinate(n, self.dimension)
+            parent.get_ordinate(n, dimension)
           }.to_enum
         end
       end
@@ -73,9 +71,9 @@ module Geos
           if lengths.empty?
             [ 0, 0 ]
           elsif lengths.length != 1
-            raise ParseError.new("Different sized points found in Array")
+            raise ParseError, 'Different sized points found in Array'
           elsif !lengths.first.between?(1, 3)
-            raise ParseError.new("Expected points to contain 1-3 elements")
+            raise ParseError, 'Expected points to contain 1-3 elements'
           else
             [ points.length, points.first.length ]
           end
@@ -83,7 +81,7 @@ module Geos
           args.first.values_at(:size, :dimensions)
         else
           if !args.length.between?(0, 2)
-            raise ArgumentError.new("wrong number of arguments (#{args.length} for 0-2)")
+            raise ArgumentError, "wrong number of arguments (#{args.length} for 0-2)"
           else
             [ args[0], args[1] ]
           end
@@ -107,11 +105,11 @@ module Geos
       @y = CoordinateAccessor.new(self, 1)
       @z = CoordinateAccessor.new(self, 2)
 
-      if points
-        points.each_with_index do |point, idx|
-          point.each_with_index do |val, dim|
-            self.set_ordinate(idx, dim, val)
-          end
+      return unless points
+
+      points.each_with_index do |point, idx|
+        point.each_with_index do |val, dim|
+          set_ordinate(idx, dim, val)
         end
       end
     end
@@ -135,13 +133,13 @@ module Geos
     # 2-dimensional CoordinateSequences.
     def each
       if block_given?
-        self.length.times do |n|
-          yield self.build_coordinate(n)
+        length.times do |n|
+          yield build_coordinate(n)
         end
         self
       else
-        self.length.times.collect { |n|
-          self.build_coordinate(n)
+        length.times.collect { |n|
+          build_coordinate(n)
         }.to_enum
       end
     end
@@ -149,82 +147,82 @@ module Geos
     def [](*args)
       if args.length == 1 && args.first.is_a?(Numeric) && args.first >= 0
         i = args.first
-        ary = [ self.get_x(i), self.get_y(i) ]
-        ary << self.get_z(i) if self.has_z?
+        ary = [ get_x(i), get_y(i) ]
+        ary << get_z(i) if has_z?
         ary
       else
-        self.to_a[*args]
+        to_a[*args]
       end
     end
-    alias_method :slice, :[]
+    alias slice []
 
     def has_z?
-      self.dimensions == 3
+      dimensions == 3
     end
 
     # Sets the x value of a coordinate. Can also be set via #x[]=.
     def set_x(idx, val)
-      self.check_bounds(idx)
-      FFIGeos.GEOSCoordSeq_setX_r(Geos.current_handle_pointer, self.ptr, idx, val.to_f)
+      check_bounds(idx)
+      FFIGeos.GEOSCoordSeq_setX_r(Geos.current_handle_pointer, ptr, idx, val.to_f)
     end
 
     # Sets the y value of a coordinate. Can also be set via #y[]=.
     def set_y(idx, val)
-      self.check_bounds(idx)
-      FFIGeos.GEOSCoordSeq_setY_r(Geos.current_handle_pointer, self.ptr, idx, val.to_f)
+      check_bounds(idx)
+      FFIGeos.GEOSCoordSeq_setY_r(Geos.current_handle_pointer, ptr, idx, val.to_f)
     end
 
     # Sets the z value of a coordinate. Can also be set via #z[]=.
     def set_z(idx, val)
-      self.check_bounds(idx)
-      FFIGeos.GEOSCoordSeq_setZ_r(Geos.current_handle_pointer, self.ptr, idx, val.to_f)
+      check_bounds(idx)
+      FFIGeos.GEOSCoordSeq_setZ_r(Geos.current_handle_pointer, ptr, idx, val.to_f)
     end
 
     def set_ordinate(idx, dim, val)
-      self.check_bounds(idx)
-      FFIGeos.GEOSCoordSeq_setOrdinate_r(Geos.current_handle_pointer, self.ptr, idx, dim, val.to_f)
+      check_bounds(idx)
+      FFIGeos.GEOSCoordSeq_setOrdinate_r(Geos.current_handle_pointer, ptr, idx, dim, val.to_f)
     end
 
     # Gets the x value of a coordinate. Can also be retrieved via #x[].
     def get_x(idx)
-      self.check_bounds(idx)
+      check_bounds(idx)
       double_ptr = FFI::MemoryPointer.new(:double)
-      FFIGeos.GEOSCoordSeq_getX_r(Geos.current_handle_pointer, self.ptr, idx, double_ptr)
+      FFIGeos.GEOSCoordSeq_getX_r(Geos.current_handle_pointer, ptr, idx, double_ptr)
       double_ptr.read_double
     end
 
     # Gets the y value of a coordinate. Can also be retrieved via #y[].
     def get_y(idx)
-      self.check_bounds(idx)
+      check_bounds(idx)
       double_ptr = FFI::MemoryPointer.new(:double)
-      FFIGeos.GEOSCoordSeq_getY_r(Geos.current_handle_pointer, self.ptr, idx, double_ptr)
+      FFIGeos.GEOSCoordSeq_getY_r(Geos.current_handle_pointer, ptr, idx, double_ptr)
       double_ptr.read_double
     end
 
     # Gets the z value of a coordinate. Can also be retrieved via #z[].
     def get_z(idx)
-      self.check_bounds(idx)
+      check_bounds(idx)
       double_ptr = FFI::MemoryPointer.new(:double)
-      FFIGeos.GEOSCoordSeq_getZ_r(Geos.current_handle_pointer, self.ptr, idx, double_ptr)
+      FFIGeos.GEOSCoordSeq_getZ_r(Geos.current_handle_pointer, ptr, idx, double_ptr)
       double_ptr.read_double
     end
 
     def get_ordinate(idx, dim)
-      self.check_bounds(idx)
+      check_bounds(idx)
       double_ptr = FFI::MemoryPointer.new(:double)
-      FFIGeos.GEOSCoordSeq_getOrdinate_r(Geos.current_handle_pointer, self.ptr, idx, dim, double_ptr)
+      FFIGeos.GEOSCoordSeq_getOrdinate_r(Geos.current_handle_pointer, ptr, idx, dim, double_ptr)
       double_ptr.read_double
     end
 
     def length
       int_ptr = FFI::MemoryPointer.new(:int)
-      FFIGeos.GEOSCoordSeq_getSize_r(Geos.current_handle_pointer, self.ptr, int_ptr)
+      FFIGeos.GEOSCoordSeq_getSize_r(Geos.current_handle_pointer, ptr, int_ptr)
       int_ptr.read_int
     end
-    alias_method :size, :length
+    alias size length
 
     def empty?
-      self.length == 0
+      length.zero?
     end
 
     def dimensions
@@ -232,47 +230,333 @@ module Geos
         @dimensions
       else
         int_ptr = FFI::MemoryPointer.new(:int)
-        FFIGeos.GEOSCoordSeq_getDimensions_r(Geos.current_handle_pointer, self.ptr, int_ptr)
+        FFIGeos.GEOSCoordSeq_getDimensions_r(Geos.current_handle_pointer, ptr, int_ptr)
         @dimensions = int_ptr.read_int
       end
     end
 
     def to_point(options = {})
-      Geos.create_point(self, :srid => options[:srid])
+      Geos.create_point(self, srid: options[:srid])
     end
 
     def to_linear_ring(options = {})
-      Geos.create_linear_ring(self, :srid => options[:srid])
+      Geos.create_linear_ring(self, srid: options[:srid])
     end
 
     def to_line_string(options = {})
-      Geos.create_line_string(self, :srid => options[:srid])
+      Geos.create_line_string(self, srid: options[:srid])
     end
 
     def to_polygon(options = {})
-      Geos.create_polygon(self, :srid => options[:srid])
+      Geos.create_polygon(self, srid: options[:srid])
     end
 
     def to_s
-      self.entries.collect { |entry|
+      entries.collect { |entry|
         entry.join(' ')
       }.join(', ')
     end
 
-    protected
+    %w{ x y z }.each do |m|
+      class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+        def #{m}_max
+          ret = nil
+          self.length.times do |i|
+            value = self.get_#{m}(i)
+            ret = value if !ret || value >= ret
+          end
+          ret
+        end
+
+        def #{m}_min
+          ret = nil
+          self.length.times do |i|
+            value = self.get_#{m}(i)
+            ret = value if !ret || value <= ret
+          end
+          ret
+        end
+      EOF
+    end
+
+    def snap_to_grid!(*args)
+      grid = {
+        :offset_x => 0, # 1
+        :offset_y => 0, # 2
+        :offset_z => 0, # -
+        :size_x => 0, # 3
+        :size_y => 0, # 4
+        :size_z => 0 # -
+      }
+
+      if args.length == 1 && args[0].is_a?(Numeric)
+        grid[:size_x] = grid[:size_y] = grid[:size_z] = args[0]
+      elsif args[0].is_a?(Hash)
+        grid.merge!(args[0])
+      end
+
+      if grid[:size]
+        grid[:size_x] = grid[:size_y] = grid[:size_z] = grid[:size]
+      end
+
+      if grid[:offset]
+        case grid[:offset]
+          when Geos::Geometry
+            point = grid[:offset].centroid
+
+            grid[:offset_x] = point.x
+            grid[:offset_y] = point.y
+            grid[:offset_z] = point.z
+          when Array
+            grid[:offset_x], grid[:offset_y], grid[:offset_z] = grid[:offset]
+          else
+            raise ArgumentError.new("Expected :offset option to be a Geos::Point")
+        end
+      end
+
+      self.length.times do |i|
+        if grid[:size_x] != 0
+          self.x[i] = ((self.x[i] - grid[:offset_x]) / grid[:size_x]).round * grid[:size_x] + grid[:offset_x]
+        end
+
+        if grid[:size_y] != 0
+          self.y[i] = ((self.y[i] - grid[:offset_y]) / grid[:size_y]).round * grid[:size_y] + grid[:offset_y]
+        end
+
+        if self.has_z? && grid[:size_z] != 0
+          self.z[i] = ((self.z[i] - grid[:offset_z]) / grid[:size_z]).round * grid[:size_z] + grid[:offset_z]
+        end
+      end
+
+      cs = self.remove_duplicate_coords
+      @ptr = cs.ptr
+
+      self
+    end
+
+    def snap_to_grid(*args)
+      self.dup.snap_to_grid!(*args)
+    end
+
+    def remove_duplicate_coords
+      Geos::CoordinateSequence.new(self.to_a.inject([]) { |memo, v|
+        memo << v unless memo.last == v
+        memo
+      })
+    end
+
+    def affine!(options)
+      options.default = 0.0
+
+      if self.has_z?
+        self.length.times do |i|
+          x, y, z = self.x[i], self.y[i], self.z[i]
+
+          self.x[i] = options[:afac] * x + options[:bfac] * y + options[:cfac] * z + options[:xoff]
+          self.y[i] = options[:dfac] * x + options[:efac] * y + options[:ffac] * z + options[:yoff]
+          self.z[i] = options[:gfac] * x + options[:hfac] * y + options[:ifac] * z + options[:zoff]
+        end
+      else
+        self.length.times do |i|
+          x, y = self.x[i], self.y[i]
+
+          self.x[i] = options[:afac] * x + options[:bfac] * y + options[:xoff]
+          self.y[i] = options[:dfac] * x + options[:efac] * y + options[:yoff]
+        end
+      end
+
+      self
+    end
 
-    def check_bounds(idx) #:nodoc:
-      if idx < 0 || idx >= self.length
-        raise Geos::IndexBoundsError.new("Index out of bounds")
+    def affine(options)
+      self.dup.affine!(options)
+    end
+
+    def rotate!(radians, origin = [ 0.0, 0.0 ])
+      origin = case origin
+        when Array
+          origin
+        when Geos::Geometry
+          center = origin.centroid
+          [ center.x, center.y ]
+        else
+          raise ArgumentError.new("Expected an Array or a Geos::Geometry for the origin")
       end
+
+      self.affine!({
+        :afac => Math.cos(radians),
+        :bfac => -Math.sin(radians),
+        :cfac => 0,
+        :dfac => Math.sin(radians),
+        :efac => Math.cos(radians),
+        :ffac => 0,
+        :gfac => 0,
+        :hfac => 0,
+        :ifac => 1,
+        :xoff => origin[0] - Math.cos(radians) * origin[0] + Math.sin(radians) * origin[1],
+        :yoff => origin[1] - Math.sin(radians) * origin[0] - Math.cos(radians) * origin[1],
+        :zoff => 0
+      })
+    end
+
+    def rotate(radians, origin = [ 0.0, 0.0 ])
+      self.dup.rotate!(radians, origin)
+    end
+
+    def rotate_x!(radians)
+      self.affine!({
+        :afac => 1,
+        :bfac => 0,
+        :cfac => 0,
+        :dfac => 0,
+        :efac => Math.cos(radians),
+        :ffac => -Math.sin(radians),
+        :gfac => 0,
+        :hfac => Math.sin(radians),
+        :ifac => Math.cos(radians),
+        :xoff => 0,
+        :yoff => 0,
+        :zoff => 0
+      })
+    end
+
+    def rotate_x(radians)
+      self.dup.rotate_x!(radians)
+    end
+
+    def rotate_y!(radians)
+      self.affine!({
+        :afac => Math.cos(radians),
+        :bfac => 0,
+        :cfac => Math.sin(radians),
+        :dfac => 0,
+        :efac => 1,
+        :ffac => 0,
+        :gfac => -Math.sin(radians),
+        :hfac => 0,
+        :ifac => Math.cos(radians),
+        :xoff => 0,
+        :yoff => 0,
+        :zoff => 0
+      })
+    end
+
+    def rotate_y(radians)
+      self.dup.rotate_y!(radians)
     end
 
-    def build_coordinate(n) #:nodoc:
-      [
-        self.get_x(n),
-        (self.dimensions >= 2 ? self.get_y(n) : nil),
-        (self.dimensions >= 3 ? self.get_z(n) : nil)
-      ].compact
+    def rotate_z!(radians)
+      self.rotate!(radians)
     end
+
+    def rotate_z(radians)
+      self.dup.rotate!(radians)
+    end
+
+    def scale!(*args)
+      x, y, z = if args.length == 1 && args[0].is_a?(Hash)
+        args[0].values_at(:x, :y, :z)
+      elsif args.length.between?(1, 3)
+        args.values_at(0...3)
+      else
+        raise ArgumentError.new("Wrong number of arguments #{args.length} for 1-3")
+      end
+
+      self.affine!({
+        :afac => x || 1,
+        :bfac => 0,
+        :cfac => 0,
+        :dfac => 0,
+        :efac => y || 1,
+        :ffac => 0,
+        :gfac => 0,
+        :hfac => 0,
+        :ifac => z || 1,
+        :xoff => 0,
+        :yoff => 0,
+        :zoff => 0
+      })
+    end
+
+    def scale(*args)
+      self.dup.scale!(*args)
+    end
+
+    def trans_scale!(*args)
+      delta_x, delta_y, x_factor, y_factor = if args.length == 1 && args[0].is_a?(Hash)
+        args[0].values_at(:delta_x, :delta_y, :x_factor, :y_factor)
+      elsif args.length.between?(1, 4)
+        args.values_at(0...4)
+      else
+        raise ArgumentError.new("Wrong number of arguments #{args.length} for 1-4")
+      end
+
+      x_factor ||= 1
+      y_factor ||= 1
+      delta_x ||= 0
+      delta_y ||= 0
+
+      self.affine!({
+        :afac => x_factor,
+        :bfac => 0,
+        :cfac => 0,
+        :dfac => 0,
+        :efac => y_factor,
+        :ffac => 0,
+        :gfac => 0,
+        :hfac => 0,
+        :ifac => 1,
+        :xoff => delta_x * x_factor,
+        :yoff => delta_y * y_factor,
+        :zoff => 0
+      })
+    end
+
+    def trans_scale(*args)
+      self.dup.trans_scale!(*args)
+    end
+
+    def translate!(*args)
+      x, y, z = if args.length == 1 && args[0].is_a?(Hash)
+        args[0].values_at(:x, :y, :z)
+      elsif args.length.between?(1, 3)
+        args.values_at(0...3)
+      else
+        raise ArgumentError.new("Wrong number of arguments #{args.length} for 1-3")
+      end
+
+      self.affine!({
+        :afac => 1,
+        :bfac => 0,
+        :cfac => 0,
+        :dfac => 0,
+        :efac => 1,
+        :ffac => 0,
+        :gfac => 0,
+        :hfac => 0,
+        :ifac => 1,
+        :xoff => x || 0,
+        :yoff => y || 0,
+        :zoff => z || 1
+      })
+    end
+
+    def translate(*args)
+      self.dup.translate!(*args)
+    end
+
+    protected
+
+      def check_bounds(idx) #:nodoc:
+        raise Geos::IndexBoundsError, 'Index out of bounds' if idx.negative? || idx >= length
+      end
+
+      def build_coordinate(n) #:nodoc:
+        [
+          get_x(n),
+          (dimensions >= 2 ? get_y(n) : nil),
+          (dimensions >= 3 ? get_z(n) : nil)
+        ].compact
+      end
   end
 end