ffi-gdal 1.0.0.beta3 → 1.0.0.beta4

data/lib/gdal/geo_transform_mixins/extensions.rb

@@ -0,0 +1,57 @@
+require 'json'
+
+module GDAL
+  module GeoTransformMixins
+    module Extensions
+      # Calculates the pixel and line location of a geospatial coordinate.  Used
+      # for converting from world coordinates to to image pixels.
+      #
+      # @param x_geo [Fixnum]
+      # @param y_geo [Fixnum]
+      # @return [Hash{pixel => Fixnum, line Fixnum}]
+      def world_to_pixel(x_geo, y_geo)
+        pixel = (x_geo - x_origin) / pixel_width
+        line = (y_origin - y_geo) / pixel_height
+
+        { pixel: pixel.round.to_i, line: line.round.to_i }
+      end
+
+      # All attributes as an Array, in the order the C-Struct describes them:
+      #   * x_origin
+      #   * pixel_width
+      #   * x_rotation
+      #   * y_origin
+      #   * y_rotation
+      #   * pixel_height
+      #
+      # @return [Array]
+      def to_a
+        [
+          x_origin,
+          pixel_width,
+          x_rotation,
+          y_origin,
+          y_rotation,
+          pixel_height
+        ]
+      end
+
+      # @return [Hash]
+      def as_json(_options = nil)
+        {
+          x_origin: x_origin,
+          x_rotation: x_rotation,
+          pixel_width: pixel_width,
+          y_origin: y_origin,
+          y_rotation: y_rotation,
+          pixel_height: pixel_height
+        }
+      end
+
+      # @return [String]
+      def to_json(options = nil)
+        as_json(options).to_json
+      end
+    end
+  end
+end

data/lib/gdal/grid.rb

@@ -0,0 +1,144 @@
+require 'forwardable'
+require 'narray'
+require_relative '../ffi/gdal/alg'
+require_relative 'grid_types'
+require_relative 'geo_transform'
+
+module GDAL
+  # Wrapper for GDAL's [Grid API](http://www.gdal.org/grid_tutorial.html).
+  class Grid
+    extend Forwardable
+    include GDAL::Logger
+
+    # @return [NArray]
+    attr_accessor :points
+
+    # @return [GDAL::GeoTransform]
+    attr_reader :geo_transform
+
+    # @return [FFI::GDAL::DataType]
+    attr_accessor :data_type
+
+    def_delegator :@gridder, :options, :options
+
+    # @param algorithm [Symbol]
+    # @param data_type [FFI::GDAL::DataType]
+    def initialize(algorithm, data_type: :GDT_Byte)
+      @data_type = data_type
+      @gridder = init_gridder(algorithm)
+      @points = nil
+      @geo_transform = GDAL::GeoTransform.new
+    end
+
+    # @return [FFI::MemoryPointer] Pointer to the grid data.
+    def create(&progress_block)
+      update_geo_transform
+
+      log "Number of points: #{point_count}"
+      x_coordinates_ptr = FFI::MemoryPointer.new(:double, point_count)
+      y_coordinates_ptr = FFI::MemoryPointer.new(:double, point_count)
+      x_coordinates_ptr.write_array_of_float(@points[0, true].to_a)
+      y_coordinates_ptr.write_array_of_float(@points[1, true].to_a)
+
+      if @points.shape.first == 3
+        z_coordinates_ptr = FFI::MemoryPointer.new(:double, point_count)
+        z_coordinates_ptr.write_array_of_float(@points[2, true].to_a)
+      else
+        z_coordinates_ptr = nil
+      end
+
+      log "x_min, y_min: #{x_min}, #{y_min}"
+      log "x_max, y_max: #{x_max}, #{y_max}"
+      log "x_size, y_size: #{x_size}, #{y_size}"
+      log "pixel_width: #{@geo_transform.pixel_width}"
+      log "pixel_height: #{@geo_transform.pixel_height}"
+      data_ptr = FFI::MemoryPointer.new(:buffer_inout, x_size * y_size)
+
+      # gdal_grid.cpp lists this as the corner coordinates, which ends up being
+      # larger than my x_max/y_min test values. That seems odd.
+      # x_end = x_max + (@geo_transform.x_size(x_max) / 2)
+      # y_end = y_min - (@geo_transform.y_size(y_max) / 2)
+      max_pixel = @geo_transform.world_to_pixel(x_max, y_max)
+      x_end = x_max + (max_pixel[:pixel] / 2)
+      y_end = y_min - (max_pixel[:line] / 2)
+      log "corner x1 (gdal_grid.cpp): #{x_end}"
+      log "corner y1 (gdal_grid.cpp): #{y_end}"
+
+      FFI::GDAL::Alg.GDALGridCreate(
+        @gridder.algorithm,                             # eAlgorithm
+        @gridder.options.to_ptr,                        # poOptions
+        point_count,                                    # nPoints
+        x_coordinates_ptr,                              # padfX
+        y_coordinates_ptr,                              # padfY
+        z_coordinates_ptr,                              # padfZ
+        x_min,                                          # dfXMin
+        x_max,                                          # dfXMax
+        y_min,                                          # dfYMin
+        y_max,                                          # dfYMax
+        x_size,                                         # nXSize
+        y_size,                                         # nYSize
+        @data_type,                                     # eType
+        data_ptr,                                       # pData,
+        progress_block,                                 # pfnProgress
+        nil                                             # pProgressArg
+      )
+
+      data_ptr
+    end
+
+    # @return [Fixnum] The number of points (x,y,z) in the grid.
+    def point_count
+      @points.shape.last
+    end
+
+    def x_min
+      @points.nil? ? nil : @points[0, true].to_a.compact.min
+    end
+
+    def x_max
+      @points.nil? ? nil : @points[0, true].to_a.compact.max
+    end
+
+    def x_size
+      @points.nil? ? nil : (x_max - x_min)
+    end
+
+    def y_min
+      @points.nil? ? nil : @points[1, true].to_a.compact.min
+    end
+
+    def y_max
+      @points.nil? ? nil : @points[1, true].to_a.compact.max
+    end
+
+    def y_size
+      @points.nil? ? nil : (y_max - y_min)
+    end
+
+    private
+
+    def init_gridder(algorithm)
+      case algorithm
+      when :inverse_distance_to_a_power then GDAL::GridTypes::InverseDistanceToAPower.new
+      when :moving_average then GDAL::GridTypes::MovingAverage.new
+      when :nearest_neighbor then GDAL::GridTypes::NearestNeighbor.new
+      when :metric_average_distance then GDAL::GridTypes::MetricAverageDistance.new
+      when :metric_average_distance_pts then GDAL::GridTypes::MetricAverageDistancePts.new
+      when :metric_count then GDAL::GridTypes::MetricCount.new
+      when :metric_maximum then GDAL::GridTypes::MetricMaximum.new
+      when :metric_minimum then GDAL::GridTypes::MetricMinimum.new
+      when :metric_range then GDAL::GridTypes::MetricRange.new
+      else fail GDAL::UnknownGridAlgorithm, algorithm
+      end
+    end
+
+    def update_geo_transform
+      return if @points.nil?
+
+      @geo_transform.x_origin = x_min
+      @geo_transform.y_origin = y_max
+      @geo_transform.pixel_width = (x_max - x_min) / x_size
+      @geo_transform.pixel_height = (y_max - y_min) / y_size
+    end
+  end
+end

data/lib/gdal/grid_types/data_metrics_base.rb

@@ -0,0 +1,14 @@
+require_relative '../../ffi/gdal/gdal_grid_data_metrics_options'
+
+module GDAL
+  module GridTypes
+    class DataMetricsBase
+      # @return [FFI::GDAL::GridDataMetricsOptions]
+      attr_reader :options
+
+      def initialize
+        @options = FFI::GDAL::GridDataMetricsOptions.new
+      end
+    end
+  end
+end

data/lib/gdal/grid_types/inverse_distance_to_a_power.rb

@@ -0,0 +1,19 @@
+require_relative '../../ffi/gdal/gdal_grid_inverse_distance_to_a_power_options'
+
+module GDAL
+  module GridTypes
+    class InverseDistanceToAPower
+      # @return [FFI::GDAL::GridInverseDistanceToAPowerOptions]
+      attr_reader :options
+
+      def initialize
+        @options = FFI::GDAL::GridInverseDistanceToAPowerOptions.new
+      end
+
+      # @return [Symbol]
+      def algorithm
+        :GGA_InverseDistanceToAPower
+      end
+    end
+  end
+end

data/lib/gdal/grid_types/metric_average_distance.rb

@@ -0,0 +1,12 @@
+require_relative 'data_metrics_base'
+
+module GDAL
+  module GridTypes
+    class MetricAverageDistance < DataMetricsBase
+      # @return [Symbol]
+      def algorithm
+        :GGA_MetricAverageDistance
+      end
+    end
+  end
+end

data/lib/gdal/grid_types/metric_average_distance_pts.rb

@@ -0,0 +1,12 @@
+require_relative 'data_metrics_base'
+
+module GDAL
+  module GridTypes
+    class MetricAverageDistancePts < DataMetricsBase
+      # @return [Symbol]
+      def algorithm
+        :GGA_MetricAverageDistancePts
+      end
+    end
+  end
+end

data/lib/gdal/grid_types/metric_count.rb

@@ -0,0 +1,12 @@
+require_relative 'data_metrics_base'
+
+module GDAL
+  module GridTypes
+    class MetricCount < DataMetricsBase
+      # @return [Symbol]
+      def algorithm
+        :GGA_MetricCount
+      end
+    end
+  end
+end

data/lib/gdal/grid_types/metric_maximum.rb

@@ -0,0 +1,12 @@
+require_relative 'data_metrics_base'
+
+module GDAL
+  module GridTypes
+    class MetricMaximum < DataMetricsBase
+      # @return [Symbol]
+      def algorithm
+        :GGA_MetricMaximum
+      end
+    end
+  end
+end

data/lib/gdal/grid_types/metric_minimum.rb

@@ -0,0 +1,12 @@
+require_relative 'data_metrics_base'
+
+module GDAL
+  module GridTypes
+    class MetricMinimum < DataMetricsBase
+      # @return [Symbol]
+      def algorithm
+        :GGA_MetricMinimum
+      end
+    end
+  end
+end

data/lib/gdal/grid_types/metric_range.rb

@@ -0,0 +1,12 @@
+require_relative 'data_metrics_base'
+
+module GDAL
+  module GridTypes
+    class MetricRange < DataMetricsBase
+      # @return [Symbol]
+      def algorithm
+        :GGA_MetricRange
+      end
+    end
+  end
+end

data/lib/gdal/grid_types/moving_average.rb

@@ -0,0 +1,19 @@
+require_relative '../../ffi/gdal/gdal_grid_moving_average_options'
+
+module GDAL
+  module GridTypes
+    class MovingAverage
+      # @return [FFI::GDAL::GridMovingAverageOptions]
+      attr_reader :options
+
+      def initialize
+        @options = FFI::GDAL::GridMovingAverageOptions.new
+      end
+
+      # @return [Symbol]
+      def algorithm
+        :GGA_MovingAverage
+      end
+    end
+  end
+end

data/lib/gdal/grid_types/nearest_neighbor.rb

@@ -0,0 +1,19 @@
+require_relative '../../ffi/gdal/gdal_grid_nearest_neighbor_options'
+
+module GDAL
+  module GridTypes
+    class NearestNeighbor
+      # @return [FFI::GDAL::GridNearestNeighborOptions]
+      attr_reader :options
+
+      def initialize
+        @options = FFI::GDAL::GridNearestNeighborOptions.new
+      end
+
+      # @return [Symbol]
+      def algorithm
+        :GGA_NearestNeighbor
+      end
+    end
+  end
+end

data/lib/gdal/grid_types.rb

@@ -0,0 +1,22 @@
+module GDAL
+  module GridTypes
+    autoload :InverseDistanceToAPower,
+      File.expand_path('grid_types/inverse_distance_to_a_power', __dir__)
+    autoload :MetricAverageDistance,
+      File.expand_path('grid_types/metric_average_distance', __dir__)
+    autoload :MetricAverageDistancePts,
+      File.expand_path('grid_types/metric_average_distance_pts', __dir__)
+    autoload :MetricCount,
+      File.expand_path('grid_types/metric_count', __dir__)
+    autoload :MetricMaximum,
+      File.expand_path('grid_types/metric_maximum', __dir__)
+    autoload :MetricMinimum,
+      File.expand_path('grid_types/metric_minimum', __dir__)
+    autoload :MetricRange,
+      File.expand_path('grid_types/metric_range', __dir__)
+    autoload :MovingAverage,
+      File.expand_path('grid_types/moving_average', __dir__)
+    autoload :NearestNeighbor,
+      File.expand_path('grid_types/nearest_neighbor', __dir__)
+  end
+end

data/lib/gdal/internal_helpers.rb

@@ -0,0 +1,94 @@
+require 'log_switch'
+
+module GDAL
+  module Logger
+    include LogSwitch
+  end
+
+  module InternalHelpers
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Internal factory method for returning a pointer from +variable+, which could
+      # be either of +klass+ class or a type of FFI::Pointer.
+      def _pointer(klass, variable, warn_on_nil = true)
+        if variable.is_a?(klass)
+          variable.c_pointer.autorelease = true
+          variable.c_pointer
+        elsif variable.is_a? FFI::Pointer
+          variable.autorelease = true
+          variable
+        else
+          if warn_on_nil && Logger.logging_enabled
+            Logger.logger.debug "<#{name}._pointer> #{variable.inspect} is not a valid #{klass} or FFI::Pointer."
+            Logger.logger.debug "<#{name}._pointer> Called at:"
+            caller(1, 2).each { |line| Logger.logger.debug "<#{name}._pointer>\t#{line}" }
+          end
+
+          nil
+        end
+      end
+
+      # @param data_type [FFI::GDAL::DataType]
+      # @return [Symbol] The FFI Symbol that represents a data type.
+      def _pointer_from_data_type(data_type, size = nil)
+        pointer_type = _gdal_data_type_to_ffi(data_type)
+
+        if size
+          FFI::MemoryPointer.new(pointer_type, size)
+        else
+          FFI::MemoryPointer.new(pointer_type)
+        end
+      end
+
+      # Takes an array of strings (or things that should be converted to
+      # strings) and creates a char**.
+      #
+      # @param strings [Array<String>]
+      # @return [FFI::MemoryPointer]
+      def _string_array_to_pointer(strings)
+        string_pointers = strings.map do |string|
+          FFI::MemoryPointer.from_string(string.to_s)
+        end
+
+        string_pointers << nil
+        array_pointer = FFI::MemoryPointer.new(:pointer, strings.size + 1)
+
+        string_pointers.each_with_index do |ptr, i|
+          array_pointer[i].put_pointer(0, ptr)
+        end
+
+        array_pointer
+      end
+
+      # Maps GDAL DataTypes to FFI types.
+      #
+      # @param data_type [FFI::GDAL::DataType]
+      def _gdal_data_type_to_ffi(data_type)
+        case data_type
+        when :GDT_Byte then :uchar
+        when :GDT_UInt16 then :uint16
+        when :GDT_Int16 then :int16
+        when :GDT_UInt32 then :uint32
+        when :GDT_Int32 then :int32
+        when :GDT_Float32 then :float
+        when :GDT_Float64 then :double
+        else
+          :float
+        end
+      end
+
+      # Check to see if the function is supported in the version of GDAL that we're
+      # using.
+      #
+      # @param function_name [Symbol]
+      # @return [Boolean]
+      def _supported?(function_name)
+        !FFI::GDAL.unsupported_gdal_functions.include?(function_name) &&
+          FFI::GDAL.respond_to?(function_name)
+      end
+    end
+  end
+end

data/lib/gdal/major_object.rb

@@ -1,6 +1,5 @@
 require_relative '../ffi/gdal'
 
-
 module GDAL
   module MajorObject
     # @return [Array<String>]
@@ -20,7 +19,7 @@ module GDAL
 
     # @param domain [String] Name of the domain to get metadata for.
     # @return [Hash]
-    def metadata(domain='')
+    def metadata(domain = '')
       m = FFI::GDAL.GDALGetMetadata(c_pointer, domain)
       return {} if m.null?
 
@@ -40,14 +39,12 @@ module GDAL
     # @param name [String]
     # @param domain [String]
     # @return [String]
-    def metadata_item(name, domain='')
+    def metadata_item(name, domain = '')
       FFI::GDAL.GDALGetMetadataItem(c_pointer, name, domain)
     end
 
-    def set_metadata_item(name, value, domain='')
-      cpl_err = FFI::GDAL.GDALSetMetadataItem(c_pointer, name, value.to_s, domain)
-
-      cpl_err.to_bool
+    def set_metadata_item(name, value, domain = '')
+      FFI::GDAL.GDALSetMetadataItem(c_pointer, name, value.to_s, domain)
     end
 
     # @return [Hash{domain => Array<String>}]

data/lib/gdal/options.rb

@@ -1,5 +1,5 @@
 require 'ffi'
-
+require_relative '../ffi/cpl/string'
 
 module GDAL
   # A wrapper for the way GDAL does key/value pair options for methods.
@@ -8,12 +8,18 @@ module GDAL
     # them.
     #
     # @param hash [Hash]
+    # @param nil_on_empty [Boolean] When +true+, if +hash+ is empty, return
+    #   +nil+.  If +false+, creates a 0-size pointer.
     # @return [FFI::MemoryPointer, nil]
-    def self.pointer(hash)
-      hash.empty? ? nil : new(hash).c_pointer
+    def self.pointer(hash, nil_on_empty: true)
+      if nil_on_empty
+        hash.empty? ? nil : new(hash).c_pointer
+      else
+        new(hash).c_pointer
+      end
     end
 
-    def initialize(hash={})
+    def initialize(hash = {})
       super()
       capitalize_keys!(hash)
     end
@@ -21,10 +27,10 @@ module GDAL
     # @return [FFI::MemoryPointer] The double-char pointer that contains the
     #   options for GDAL to use.
     def c_pointer
-      options_ptr = FFI::MemoryPointer.new(:pointer, self.size)
+      options_ptr = FFI::MemoryPointer.new(:pointer, size)
 
-      self.each do |key, value|
-        options_ptr = FFI::GDAL.CSLSetNameValue(options_ptr, key, value)
+      each do |key, value|
+        options_ptr = FFI::CPL::String.CSLSetNameValue(options_ptr, key, value)
       end
 
       options_ptr
@@ -38,6 +44,7 @@ module GDAL
     #     options_array[i].first.read_string
     #   end
     # end
+
     private
 
     def capitalize_keys!(hash)