ffi-gdal 1.0.0.beta5 → 1.0.0.beta6

data/lib/gdal/internal_helpers.rb

@@ -1,10 +1,4 @@
-require 'log_switch'
-
 module GDAL
-  module Logger
-    include LogSwitch
-  end
-
   # @private
   module InternalHelpers
     def self.included(base)
@@ -32,18 +26,38 @@ module GDAL
         end
       end
 
-      # @param data_type [FFI::GDAL::DataType]
-      # @return [Symbol] The FFI Symbol that represents a data type.
+      # @param data_type [FFI::GDAL::GDAL::DataType]
+      # @param size [Fixnum] Size of the pointer to allocate.
+      # @return [FFI::MemoryPointer]
       def _pointer_from_data_type(data_type, size = nil)
         pointer_type = _gdal_data_type_to_ffi(data_type)
 
+        size ? FFI::MemoryPointer.new(pointer_type, size) : FFI::MemoryPointer.new(pointer_type)
+      end
+
+      # @param data_type [FFI::GDAL::GDAL::DataType]
+      # @param size [Fixnum] Size of the pointer to allocate.
+      # @return [FFI::Buffer]
+      def _buffer_from_data_type(data_type, size = nil)
+        pointer_type = _gdal_data_type_to_ffi(data_type)
+
         if size
-          FFI::MemoryPointer.new(pointer_type, size)
+          FFI::Buffer.alloc_inout(pointer_type, size)
         else
-          FFI::MemoryPointer.new(pointer_type)
+          FFI::Buffer.alloc_inout(pointer_type)
         end
       end
 
+      # @param data_type [FFI::GDAL::GDAL::DataType]
+      # @param narray_args Args to pass to the NArray initializer.
+      # @return [NArray]
+      def _narray_from_data_type(data_type, *narray_args)
+        init_meth = _gdal_data_type_to_narray(data_type)
+        narray_args = 0 if narray_args.empty?
+
+        NArray.send(init_meth, *narray_args)
+      end
+
       # Takes an array of strings (or things that should be converted to
       # strings) and creates a char**.
       #
@@ -56,28 +70,121 @@ module GDAL
 
         string_pointers << nil
         array_pointer = FFI::MemoryPointer.new(:pointer, strings.size + 1)
+        i = 0
 
-        string_pointers.each_with_index do |ptr, i|
-          array_pointer[i].put_pointer(0, ptr)
+        # fast-ruby says while is faster than each_with_index
+        while i < string_pointers.length
+          array_pointer[i].put_pointer(0, string_pointers[i])
+          i += 1
         end
 
         array_pointer
       end
 
+      # @param type [Symbol] FFI type of pointer to make a pointer to.
+      # @return [FFI::MemoryPointer] Pointer to a pointer.
+      def _pointer_pointer(type)
+        pointer = FFI::MemoryPointer.new(type)
+        pointer_ptr = FFI::MemoryPointer.new(:pointer)
+        pointer_ptr.write_pointer(pointer)
+
+        pointer_ptr
+      end
+
+      # @return [String, nil]
+      def _read_pointer_pointer_safely(pointer_ptr, type)
+        return if pointer_ptr.read_pointer.null?
+
+        pointer_ptr.read_pointer.send("read_#{type}".to_sym)
+      end
+
       # Maps GDAL DataTypes to FFI types.
       #
-      # @param data_type [FFI::GDAL::DataType]
+      # @param data_type [FFI::GDAL::GDAL::DataType]
+      # @return [Symbol]
       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
+        when :GDT_Byte                    then :uchar
+        when :GDT_UInt16                  then :uint16
+        when :GDT_Int16, :GDT_CInt16      then :int16
+        when :GDT_UInt32                  then :uint32
+        when :GDT_Int32, :GDT_CInt32      then :int32
+        when :GDT_Float32, :GDT_CFloat32  then :float
+        when :GDT_Float64, :GDT_CFloat64  then :double
+        else
+          raise GDAL::InvalidDataType, "Unknown data type: #{data_type}"
+        end
+      end
+
+      # Maps GDAL DataTypes to NArray types.
+      #
+      # @param data_type [FFI::GDAL::GDAL::DataType]
+      # @return [Symbol]
+      def _gdal_data_type_to_narray(data_type)
+        case data_type
+        when :GDT_Byte                                then :byte
+        when :GDT_Int16                               then :sint
+        when :GDT_UInt16, :GDT_Int32, :GDT_UInt32     then :int
+        when :GDT_Float32                             then :float
+        when :GDT_Float64                             then :dfloat
+        when :GDT_CInt16, :GDT_CInt32                 then :scomplex
+        when :GDT_CFloat32                            then :complex
+        when :GDT_CFloat64                            then :dcomplex
+        else
+          raise GDAL::InvalidDataType, "Unknown data type: #{data_type}"
+        end
+      end
+
+      # Maps GDAL DataTypes to NArray type constants.
+      #
+      # @param data_type [FFI::GDAL::GDAL::DataType]
+      # @return [Symbol]
+      def _gdal_data_type_to_narray_type_constant(data_type)
+        case data_type
+        when :GDT_Byte                            then NArray::BYTE
+        when :GDT_Int16                           then NArray::SINT
+        when :GDT_UInt16, :GDT_Int32, :GDT_UInt32 then NArray::INT
+        when :GDT_Float32                         then NArray::FLOAT
+        when :GDT_Float64                         then NArray::DFLOAT
+        when :GDT_CInt16, :GDT_CInt32             then NArray::SCOMPLEX
+        when :GDT_CFloat32                        then NArray::COMPLEX
+        when :GDT_CFloat64                        then NArray::DCOMPLEX
+        else
+          raise GDAL::InvalidDataType, "Unknown data type: #{data_type}"
+        end
+      end
+
+      # Helper method for reading an FFI pointer based on the GDAL DataType of
+      # the pointer.
+      #
+      # @param pointer [FFI::Pointer] The pointer to read from.
+      # @param data_type [FFI::GDAL::GDAL::DataType] The GDAL data type that
+      #   determines what FFI type to use when reading.
+      # @param length [Fixnum] The amount of data to read from the pointer. If
+      #   > 1, the "read_array_of_" method will be called.
+      # @return [Number, Array<Number>]
+      def _read_pointer(pointer, data_type, length = 1)
+        if length == 1
+          pointer.send("read_#{_gdal_data_type_to_ffi(data_type)}")
+        else
+          pointer.send("read_array_of_#{_gdal_data_type_to_ffi(data_type)}", length)
+        end
+      end
+
+      # Helper method for writing data to an FFI pointer based on the GDAL
+      # DataType of the pointer.
+      #
+      # @param pointer [FFI::Pointer] The pointer to write to.
+      # @param data_type [FFI::GDAL::GDAL::DataType] The GDAL data type that
+      #   determines what FFI type to use when writing.
+      # @param data [Fixnum] The data to write to the pointer. If it's an Array
+      #   with size > 1, the "write_array_of_" method will be called.
+      def _write_pointer(pointer, data_type, data)
+        if data.is_a?(Array) && data.size > 1
+          pointer.send("write_array_of_#{_gdal_data_type_to_ffi(data_type)}", data)
         else
-          :float
+          data = data.first if data.is_a?(Array)
+          pointer.send("write_#{_gdal_data_type_to_ffi(data_type)}", data)
         end
       end
 
@@ -86,9 +193,11 @@ module GDAL
       #
       # @param function_name [Symbol]
       # @return [Boolean]
+      # TODO: Should the #respond_to? check all FFI::GDAL::* classes? What about
+      #   OGR?
       def _supported?(function_name)
         !FFI::GDAL.unsupported_gdal_functions.include?(function_name) &&
-          FFI::GDAL.respond_to?(function_name)
+          FFI::GDAL::GDAL.respond_to?(function_name)
       end
 
       # @param char [String] 'r' or 'w'
@@ -98,7 +207,7 @@ module GDAL
         case char
         when 'r' then :GF_Read
         when 'w' then :GF_Write
-        else fail GDAL::InvalidAccessFlag, "Invalid access flag: #{char}"
+        else raise GDAL::InvalidAccessFlag, "Invalid access flag: #{char}"
         end
       end
     end

data/lib/gdal/major_object.rb

@@ -1,15 +1,16 @@
-require_relative '../ffi/gdal'
+require_relative '../gdal'
+require 'multi_xml'
 
 module GDAL
   module MajorObject
     # @return [Array<String>]
     def metadata_domain_list
-      unless defined? FFI::GDAL.GDALGetMetadataDomainList
+      unless defined? FFI::GDAL::GDAL.GDALGetMetadataDomainList
         warn "GDALGetMetadataDomainList is't defined. GDAL::MajorObject#metadata_domain_list disabled."
         return []
       end
 
-      list_pointer = FFI::GDAL.GDALGetMetadataDomainList(c_pointer)
+      list_pointer = FFI::GDAL::GDAL.GDALGetMetadataDomainList(@c_pointer)
       return [] if list_pointer.null?
 
       strings = list_pointer.get_array_of_string(0)
@@ -19,8 +20,10 @@ module GDAL
 
     # @param domain [String] Name of the domain to get metadata for.
     # @return [Hash]
-    def metadata(domain = '')
-      m = FFI::GDAL.GDALGetMetadata(c_pointer, domain)
+    def metadata(domain = nil)
+      return unless @c_pointer
+
+      m = FFI::GDAL::GDAL.GDALGetMetadata(@c_pointer, domain)
       return {} if m.null?
 
       data_array = m.get_array_of_string(0)
@@ -40,11 +43,11 @@ module GDAL
     # @param domain [String]
     # @return [String]
     def metadata_item(name, domain = '')
-      FFI::GDAL.GDALGetMetadataItem(c_pointer, name, domain)
+      FFI::GDAL::GDAL.GDALGetMetadataItem(@c_pointer, name, domain)
     end
 
     def set_metadata_item(name, value, domain = '')
-      FFI::GDAL.GDALSetMetadataItem(c_pointer, name, value.to_s, domain)
+      FFI::GDAL::GDAL.GDALSetMetadataItem(@c_pointer, name, value.to_s, domain)
     end
 
     # @return [Hash{domain => Array<String>}]
@@ -59,16 +62,16 @@ module GDAL
 
     # @return [String]
     def description
-      FFI::GDAL.GDALGetDescription(c_pointer)
+      FFI::GDAL::GDAL.GDALGetDescription(@c_pointer)
     end
 
     # @param new_description [String]
     def description=(new_description)
-      FFI::GDAL.GDALSetDescription(c_pointer, new_description.to_s)
+      FFI::GDAL::GDAL.GDALSetDescription(@c_pointer, new_description.to_s)
     end
 
     def null?
-      c_pointer.null?
+      @c_pointer.null?
     end
   end
 end

data/lib/gdal/merger.rb

@@ -0,0 +1,130 @@
+require_relative 'driver'
+
+module GDAL
+  # NOT YET WORKING!
+  #
+  # Port from gdal_merge.py, this lets you programmatically merge datasets.
+  class Merger
+    # @param [String] output_driver_name
+    # @param [String] output_file_name
+    # @param [Symbol] output_data_type
+    # @param [Array<GDAL::Dataset>] datasets
+    # @param [Hash] creation_options
+    def initialize(output_driver_name, output_file_name, output_data_type, datasets, **creation_options)
+      @output_driver = Driver.by_name(output_driver_name)
+      @output_file_name = output_file_name
+      @output_data_type = output_data_type
+      @datasets = datasets
+      @creation_options = creation_options
+    end
+
+    # @return [GDAL::Dataset]
+    def merge(target_align_pixels: false)
+      dest_geo_transform = build_geo_transform(target_align_pixels)
+      dest_dataset = build_empty_dataset(dest_geo_transform)
+      calculate_dimensions(dest_dataset)
+    end
+
+    private
+
+    def calculate_dimensions(dest_dataset)
+      @datasets.map.with_index do |d, _i|
+        dest_ulx = [dest_dataset.geo_transform.x_origin, d.geo_transform.x_origin].max
+        dest_lrx = [dest_dataset.lower_right_x, d.lower_right_x].min
+
+        uly_candidates = [dest_dataset.geo_transform.y_origin, d.geo_transform.y_origin]
+        lry_candidates = [dest_dataset.lower_right_y, d.lower_right_y]
+
+        if dest_dataset.geo_transform.y_origin < 0
+          dest_uly = uly_candidates.min
+          dest_lry = lry_candidates.max
+        else
+          dest_uly = uly_candidates.max
+          dest_lry = lry_candidates.min
+        end
+
+        dest_offsets = dest_dataset.geo_transform.world_to_pixel(dest_ulx, dest_uly, 0.1)
+        dest_sizes = dest_dataset.geo_transform.world_to_pixel(dest_lrx, dest_lry, 0.5)
+        dest_x_size = dest_sizes[:pixel] - dest_offsets[:pixel]
+        dest_y_size = dest_sizes[:line] - dest_offsets[:line]
+
+        src_offsets = d.geo_transform.world_to_pixel(dest_ulx, dest_uly)
+        src_sizes = d.geo_transform.world_to_pixel(dest_lrx, dest_lry, 0.5)
+        src_x_size = src_sizes[:pixel] - src_offsets[:pixel]
+        src_y_size = src_sizes[:line] - src_offsets[:line]
+
+        {
+          dest_x_offset: dest_offsets[:pixel],
+          dest_y_offset: dest_offsets[:line],
+          dest_x_size: dest_x_size,
+          dest_y_size: dest_y_size,
+          src_x_offset: src_offsets[:pixel],
+          src_y_offset: src_offsets[:line],
+          src_x_size: src_x_size,
+          src_y_size: src_y_size
+        }
+      end
+    end
+
+    # @return [GDAL::GeoTransform]
+    def build_geo_transform(target_align_pixels)
+      gt = GDAL::GeoTransform.new
+
+      gt.x_origin = overall_x_origin
+      gt.y_origin = overall_y_origin
+
+      first_transform = @datasets.first.geo_transform
+      gt.pixel_width = first_transform.pixel_width    # psize_x
+      gt.pixel_height = first_transform.pixel_height  # psize_y
+      gt.x_rotation = first_transform.x_rotation
+      gt.y_rotation = first_transform.y_rotation
+
+      gt.align! if target_align_pixels
+
+      gt
+    end
+
+    # @param [GDAL::GeoTransform] geo_transform
+    def build_empty_dataset(geo_transform)
+      x_size = x_size(geo_transform, overall_lower_x)
+      y_size = x_size(geo_transform, overall_lower_y)
+      data_type = @output_data_type
+
+      dataset = @output_driver.create_dataset(@output_file_name, x_size, y_size, data_type: data_type)
+      dataset.geo_transform = geo_transform
+      dataset.projection = @datasets.first.projection
+      dataset
+      # new_band = dataset.raster_band(1)
+      # new_band.write_xy_narray(raster_band.to_na)
+
+      # @datasets.each do |d|
+      #   dataset.raster_band(1).copy_whole_raster(new_band)
+      #   new_band.write_xy_narray(dataset.raster_band(1).to_na)
+      # end
+    end
+
+    def overall_x_origin
+      @datasets.map { |dataset| dataset.geo_transform.x_origin }.min
+    end
+
+    def overall_y_origin
+      @datasets.map { |dataset| dataset.geo_transform.y_origin }.max
+    end
+
+    def overall_lower_x
+      @datasets.map(&:lower_right_x).max
+    end
+
+    def overall_lower_y
+      @datasets.map(&:lower_right_y).min
+    end
+
+    def x_size(geo_transform, lower_right_x)
+      ((lower_right_x - geo_transform.x_origin) / geo_transform.pixel_width + 0.5).to_i
+    end
+
+    def y_size(geo_transform, lower_right_y)
+      ((lower_right_y - geo_transform.y_origin) / geo_transform.pixel_height + 0.5).to_i
+    end
+  end
+end

data/lib/gdal/options.rb

@@ -1,5 +1,4 @@
 require 'ffi'
-require_relative '../ffi/cpl/string'
 
 module GDAL
   # A wrapper for the way GDAL does key/value pair options for methods.
@@ -19,6 +18,8 @@ module GDAL
       end
     end
 
+    # @param hash [Hash] The hash of options to turn into a CPL key/value pair
+    #   set.
     def initialize(hash = {})
       super()
       capitalize_keys!(hash)
@@ -30,7 +31,7 @@ module GDAL
       options_ptr = FFI::MemoryPointer.new(:pointer, size)
 
       each do |key, value|
-        options_ptr = FFI::CPL::String.CSLSetNameValue(options_ptr, key, value)
+        options_ptr = FFI::CPL::String.CSLSetNameValue(options_ptr, key, value.to_s)
       end
 
       options_ptr

data/lib/gdal/raster_attribute_table.rb

@@ -1,4 +1,4 @@
-require_relative '../ffi/gdal'
+require_relative '../gdal'
 require_relative 'raster_attribute_table_mixins/extensions'
 
 module GDAL
@@ -11,8 +11,8 @@ module GDAL
     # @return [GDAL::RasterAttributeTable]
     def self.from_color_table(color_table)
       color_table_ptr = GDAL._pointer(GDAL::ColorTable, color_table)
-      rat_ptr = FFI::GDAL.GDALCreateRasterAttributeTable
-      FFI::GDAL.GDALRATInitializeFromColorTable(rat_ptr, color_table_ptr)
+      rat_ptr = FFI::GDAL::GDAL.GDALCreateRasterAttributeTable
+      FFI::GDAL::GDAL.GDALRATInitializeFromColorTable(rat_ptr, color_table_ptr)
 
       new(rat_ptr)
     end
@@ -22,13 +22,13 @@ module GDAL
 
     # @param pointer [FFI::Pointer]
     def initialize(pointer = nil)
-      @c_pointer = pointer || FFI::GDAL.GDALCreateRasterAttributeTable
+      @c_pointer = pointer || FFI::GDAL::GDAL.GDALCreateRasterAttributeTable
     end
 
     def destroy!
       return unless @c_pointer
 
-      FFI::GDAL.GDALDestroyRasterAttributeTable(@c_pointer)
+      FFI::GDAL::GDAL.GDALDestroyRasterAttributeTable(@c_pointer)
       @c_pointer = nil
     end
 
@@ -36,8 +36,8 @@ module GDAL
     #
     # @return [GDAL::RasterAttributeTable]
     def clone
-      rat_ptr = FFI::GDAL.GDALRATClone(@c_pointer)
-      return nil if rat_ptr.null?
+      rat_ptr = FFI::GDAL::GDAL.GDALRATClone(@c_pointer)
+      return nil if rat_ptr.nil? || rat_ptr.null?
 
       self.class.new(rat_ptr)
     end
@@ -47,106 +47,125 @@ module GDAL
     #
     # @return [Boolean]
     def changes_written_to_file?
-      FFI::GDAL.GDALRATChangesAreWrittenToFile(@c_pointer)
+      FFI::GDAL::GDAL.GDALRATChangesAreWrittenToFile(@c_pointer)
     end
 
     # @return [Fixnum]
     def column_count
-      FFI::GDAL.GDALRATGetColumnCount(@c_pointer)
+      FFI::GDAL::GDAL.GDALRATGetColumnCount(@c_pointer)
     end
 
     # @param index [Fixnum] The column number.
     # @return [String]
     def column_name(index)
-      FFI::GDAL.GDALRATGetNameOfCol(@c_pointer, index)
+      FFI::GDAL::GDAL.GDALRATGetNameOfCol(@c_pointer, index)
     end
+    alias name_of_col column_name
 
     # @param index [Fixnum] The column number.
     # @return [GDALRATFieldUsage]
     def column_usage(index)
-      FFI::GDAL.GDALRATGetUsageOfCol(@c_pointer, index)
+      FFI::GDAL::GDAL.GDALRATGetUsageOfCol(@c_pointer, index)
     end
+    alias usage_of_col column_usage
 
     # @param index [Fixnum] The column number.
     # @return [GDALRATFieldType]
     def column_type(index)
-      FFI::GDAL.GDALRATGetTypeOfCol(@c_pointer, index)
+      FFI::GDAL::GDAL.GDALRATGetTypeOfCol(@c_pointer, index)
     end
+    alias type_of_col column_type
 
     # @param field_usage [GDALRATFieldUsage]
-    # @return [Fixnum] The column number.
+    # @return [Fixnum] The column number or nil.
     def column_of_usage(field_usage)
-      FFI::GDAL.GDALRATGetColOfUsage(@c_pointer, field_usage)
+      column_number = FFI::GDAL::GDAL.GDALRATGetColOfUsage(@c_pointer, field_usage)
+      return if column_number < 0
+
+      column_number
     end
 
     # @param name [String]
-    # @param type [FFI::GDALRATFieldType]
-    # @param usage [FFI::GDALRATFieldUsage]
+    # @param type [FFI::GDAL::GDALRATFieldType]
+    # @param usage [FFI::GDAL::GDALRATFieldUsage]
     # @return [Boolean]
     def create_column(name, type, usage)
-      !!FFI::GDAL.GDALRATCreateColumn(@c_pointer, name, type, usage)
+      FFI::GDAL::GDAL.GDALRATCreateColumn(@c_pointer, name, type, usage)
     end
 
     # @return [Fixnum] The number of rows.
     def row_count
-      FFI::GDAL.GDALRATGetRowCount(@c_pointer)
+      FFI::GDAL::GDAL.GDALRATGetRowCount(@c_pointer)
     end
 
     # @return [Fixnum] The number of rows.
     def row_count=(count)
-      FFI::GDAL.GDALRATSetRowCount(@c_pointer, count)
+      FFI::GDAL::GDAL.GDALRATSetRowCount(@c_pointer, count)
     end
 
     # Get the row for a pixel value.
     #
-    # @param value [Float]
-    # @return [Fixnum]
-    def row_of_value(value)
-      FFI::GDAL.GDALRATGetRowOfValue(@c_pointer, value)
+    # @param pixel_value [Float]
+    # @return [Fixnum] Index of the row or nil.
+    def row_of_value(pixel_value)
+      row_index = FFI::GDAL::GDAL.GDALRATGetRowOfValue(@c_pointer, pixel_value)
+      return if row_index < 0
+
+      row_index
     end
 
     # @param row [Fixnum]
     # @param field [Fixnum]
     # @return [String]
-    def value_to_s(row, field)
-      FFI::GDAL.GDALRATGetValueAsString(@c_pointer, row, field)
+    def value_as_string(row, field)
+      FFI::GDAL::GDAL.GDALRATGetValueAsString(@c_pointer, row, field)
     end
 
     # @param row [Fixnum]
     # @param field [Fixnum]
     # @return [Fixnum]
-    def value_to_i(row, field)
-      FFI::GDAL.GDALRATGetValueAsInt(@c_pointer, row, field)
+    def value_as_integer(row, field)
+      FFI::GDAL::GDAL.GDALRATGetValueAsInt(@c_pointer, row, field)
     end
+    alias value_as_int value_as_integer
 
     # @param row [Fixnum]
     # @param field [Fixnum]
     # @return [Float]
-    def value_to_f(row, field)
-      FFI::GDAL.GDALRATGetValueAsDouble(@c_pointer, row, field)
+    def value_as_double(row, field)
+      FFI::GDAL::GDAL.GDALRATGetValueAsDouble(@c_pointer, row, field)
     end
+    alias value_as_float value_as_double
 
     # @param row [Fixnum]
     # @param field [Fixnum]
-    # @param value [String, Float, Fixnum]
-    def add_value(row, field, value)
-      case value.class.name
-      when 'String'
-        FFI::GDAL.GDALRATSetValueAsString(@c_pointer, row, field, value)
-      when 'Float'
-        FFI::GDAL.GDALRATSetValueAsDouble(@c_pointer, row, field, value)
-      when 'Fixnum'
-        FFI::GDAL.GDALRATSetValueAsInt(@c_pointer, row, field, value)
-      else
-        fail "Unknown value type for value '#{value}'"
-      end
+    # @param value [String]
+    def set_value_as_string(row, field, value)
+      FFI::GDAL::GDAL.GDALRATSetValueAsString(@c_pointer, row, field, value)
     end
 
+    # @param row [Fixnum]
+    # @param field [Fixnum]
+    # @param value [Float]
+    def set_value_as_double(row, field, value)
+      FFI::GDAL::GDAL.GDALRATSetValueAsDouble(@c_pointer, row, field, value)
+    end
+    alias set_value_as_float set_value_as_double
+
+    # @param row [Fixnum]
+    # @param field [Fixnum]
+    # @param value [Fixnum]
+    def set_value_as_integer(row, field, value)
+      FFI::GDAL::GDAL.GDALRATSetValueAsInt(@c_pointer, row, field, value)
+    end
+    alias set_value_as_int set_value_as_integer
+
     # @return [Hash{row_0_minimum => Float, bin_size => Float}]
     def linear_binning
       row_0_min_ptr = FFI::MemoryPointer.new(:double)
       bin_size_ptr = FFI::MemoryPointer.new(:double)
-      FFI::GDAL.GDALRATGetLinearBinning(@c_pointer, row_0_min_ptr, bin_size_ptr)
+      result = FFI::GDAL::GDAL.GDALRATGetLinearBinning(@c_pointer, row_0_min_ptr, bin_size_ptr)
+      return unless result
 
       {
         row_0_minimum: row_0_min_ptr.read_double,
@@ -154,23 +173,27 @@ module GDAL
       }
     end
 
+    # @param row_0_minimum [Float]
+    # @param bin_size [Float]
+    def set_linear_binning(row_0_minimum, bin_size)
+      FFI::GDAL::GDAL.GDALRATSetLinearBinning(@c_pointer, row_0_minimum, bin_size)
+    end
+
     # @param entry_count [Fixnum] The number of entries to produce.  The default
     #   will try to auto-determine the number.
-    # @return [GDAL::ColorTable]
+    # @return [GDAL::ColorTable, nil]
     def to_color_table(entry_count = -1)
-      color_table_pointer = FFI::GDAL.GDALRATTranslateToColorTable(@c_pointer, entry_count)
+      color_table_pointer = FFI::GDAL::GDAL.GDALRATTranslateToColorTable(@c_pointer, entry_count)
+      return if color_table_pointer.nil? || color_table_pointer.null?
 
       GDAL::ColorTable.new(color_table_pointer)
     end
 
-    # @param file_path [String]
+    # @param file_path [String] Without giving a +file_path+, dumps to STDOUT.
     def dump_readable(file_path = nil)
-      file = if file_path
-               File.open(file_path, 'r')
-             else
-               file_path
-             end
-      FFI::GDAL.GDALRATDumpReadable(@c_pointer, file)
+      file_ptr = file_path ? FFI::CPL::Conv.CPLOpenShared(file_path, 'w', false) : nil
+      FFI::GDAL::GDAL.GDALRATDumpReadable(@c_pointer, file_ptr)
+      FFI::CPL::Conv.CPLCloseShared(file_ptr) if file_ptr
     end
   end
 end