ffi-gdal 0.0.4 → 1.0.0.beta1

data/lib/gdal/color_entry.rb

@@ -0,0 +1,47 @@
+require_relative 'color_entry_extensions'
+
+module GDAL
+  class ColorEntry
+    include ColorEntryExtensions
+    
+    def initialize(color_entry=nil)
+      @color_entry_struct = color_entry || FFI::GDAL::GDALColorEntry.new
+    end
+
+    def c_pointer
+      @color_entry_struct
+    end
+
+    def color1
+      @color_entry_struct[:c1]
+    end
+
+    def color1=(new_color)
+      @color_entry_struct[:c1] = new_color
+    end
+
+    def color2
+      @color_entry_struct[:c2]
+    end
+
+    def color2=(new_color)
+      @color_entry_struct[:c2] = new_color
+    end
+
+    def color3
+      @color_entry_struct[:c3]
+    end
+
+    def color3=(new_color)
+      @color_entry_struct[:c3] = new_color
+    end
+
+    def color4
+      @color_entry_struct[:c4]
+    end
+
+    def color4=(new_color)
+      @color_entry_struct[:c4] = new_color
+    end
+  end
+end

data/lib/gdal/color_entry_extensions.rb

@@ -0,0 +1,30 @@
+require 'json'
+
+module GDAL
+  module ColorEntryExtensions
+
+    # @param include_fourth [Boolean] Turn off in case you don't want the fourth
+    #   color in the array.
+    # @return [Array]
+    def to_a(include_fourth=true)
+      if include_fourth
+        [color1, color2, color3, color4]
+      else
+        [color1, color2, color3]
+      end
+    end
+
+    def as_json
+      {
+        color1: color1,
+        color2: color2,
+        color3: color3,
+        color4: color4
+      }
+    end
+
+    def to_json
+      as_json.to_json
+    end
+  end
+end

data/lib/gdal/color_interpretation.rb

@@ -0,0 +1,15 @@
+module GDAL
+  class ColorInterpretation
+    # @param gdal_color_interp [FFI::GDAL::GDALColorInterp]
+    # @return [String]
+    def self.name(gdal_color_interp)
+      FFI::GDAL.GDALGetColorInterpretationName(gdal_color_interp)
+    end
+
+    # @param name [String]
+    # @return [FFI::GDAL::GDALColorInterp]
+    def self.by_name(name)
+      FFI::GDAL.GDALGetColorInterpretationByName(name)
+    end
+  end
+end

data/lib/gdal/color_table.rb

@@ -0,0 +1,146 @@
+require_relative '../ffi/gdal'
+require_relative 'color_table_extensions'
+require_relative 'color_entry'
+
+
+module GDAL
+  module ColorTableTypes
+    autoload :CMYK,
+      File.expand_path('color_table_types/cmyk', __dir__)
+    autoload :Gray,
+      File.expand_path('color_table_types/gray', __dir__)
+    autoload :HLS,
+      File.expand_path('color_table_types/hls', __dir__)
+    autoload :RGB,
+      File.expand_path('color_table_types/rgb', __dir__)
+  end
+
+  class ColorTable
+    include ColorTableExtensions
+
+    # @param palette_interpretation [FFI::GDAL::GDALPaletteInterp]
+    # @return [GDAL::ColorTable]
+    def self.create(palette_interpretation)
+      color_table_pointer = FFI::GDAL::GDALCreateColorTable(palette_interpretation)
+      return nil if color_table_pointer.null?
+
+      new(color_table_pointer)
+    end
+
+    # @param color_table
+    def initialize(color_table)
+      @color_table_pointer = GDAL._pointer(self.class, color_table)
+      @color_entries = []
+
+      case palette_interpretation
+      when :GPI_Gray then extend GDAL::ColorTableTypes::Gray
+      when :GPI_RGB then extend GDAL::ColorTableTypes::RGB
+      when :GPI_CMYK then extend GDAL::ColorTableTypes::CMYK
+      when :GPI_HLS then extend GDAL::ColorTableTypes::HLS
+      else
+        raise "Unknown PaletteInterpretation: #{palette_interpretation}"
+      end
+    end
+
+    def c_pointer
+      @color_table_pointer
+    end
+
+    def destroy!
+      FFI::GDAL.GDALDestroyColorTable(@color_table_pointer)
+    end
+
+    # Clones the ColorTable using the C API.
+    #
+    # @return [GDAL::ColorTable]
+    def clone
+      ct_ptr = FFI::GDAL.GDALCloneColorTable(@color_table_pointer)
+      return nil if ct_ptr.null?
+
+      GDAL::ColorTable.new(ct_ptr)
+    end
+
+    # Usually :GPI_RGB.
+    #
+    # @return [Symbol] One of FFI::GDAL::GDALPaletteInterp.
+    def palette_interpretation
+      @palette_interpretation ||= FFI::GDAL.GDALGetPaletteInterpretation(@color_table_pointer)
+    end
+
+    # @return [Fixnum]
+    def color_entry_count
+      FFI::GDAL.GDALGetColorEntryCount(@color_table_pointer)
+    end
+
+    # @param index [Fixnum]
+    # @return [GDAL::ColorEntry]
+    def color_entry(index)
+      @color_entries.fetch(index) do
+        color_entry = FFI::GDAL.GDALGetColorEntry(@color_table_pointer, index)
+        return nil if color_entry.null?
+
+        GDAL::ColorEntry.new(color_entry)
+      end
+    end
+
+    # @param index [Fixnum]
+    # @return [GDAL::ColorEntry]
+    def color_entry_as_rgb(index)
+      entry = color_entry(index)
+      return unless entry
+
+      FFI::GDAL.GDALGetColorEntryAsRGB(@color_table_pointer, index, entry.c_pointer)
+      return nil if entry.c_pointer.null?
+
+      entry
+    end
+
+    # Add a new ColorEntry to the ColorTable.  Valid values depend on the image
+    # type you're working with (i.e. for Tiff, values can be between 0 and
+    # 65535).  Values must also be relevant to the PaletteInterp type you're
+    # working with.
+    #
+    # @param index [Fixnum] The index of the color table's color entry to set.
+    #   Must be between 0 and color_entry_count - 1.
+    # @param one [Fixnum] The `c1` value of the GDAL::ColorEntry struct
+    #   to set.
+    # @param two [Fixnum] The `c2` value of the GDAL::ColorEntry struct
+    #   to set.
+    # @param three [Fixnum] The `c3` value of the GDAL::ColorEntry
+    #   struct to set.
+    # @param four [Fixnum] The `c4` value of the GDAL::ColorEntry
+    #   struct to set.
+    # @return [GDAL::ColorEntry]
+    def add_color_entry(index, one=nil, two=nil, three=nil, four=nil)
+      entry = GDAL::ColorEntry.new
+      entry.color1 = one if one
+      entry.color2 = two if two
+      entry.color3 = three if three
+      entry.color4 = four if four
+
+      FFI::GDAL.GDALSetColorEntry(@color_table_pointer, index, entry.c_pointer)
+      @color_entries.insert(index, entry)
+
+      entry
+    end
+
+    # Automatically creates a color ramp from one color entry to another.  It
+    # can be called several times to create multiple ramps in the same color
+    # table.
+    #
+    # @param start_index [Fixnum] Index to start the ramp on (0..255)
+    # @param start_color [GDAL::ColorEntry] Value to start the ramp.
+    # @param end_index [Fixnum] Index to end the ramp on (0..255)
+    # @param end_color [GDAL::ColorEntry] Value to end the ramp.
+    # @return [Fixnum] The total number of entries.  nil or -1 on error.
+    def create_color_ramp!(start_index, start_color, end_index, end_color)
+      start_color_ptr = GDAL._pointer(GDAL::ColorEntry, start_color)
+      end_color_ptr = GDAL._pointer(GDAL::ColorEntry, end_color)
+
+      FFI::GDAL.GDALCreateColorRamp(@color_table_pointer, start_index,
+        start_color_ptr,
+        end_index,
+        end_color_ptr)
+    end
+  end
+end

data/lib/gdal/color_table_extensions.rb

@@ -0,0 +1,47 @@
+require 'json'
+
+module GDAL
+  module ColorTableExtensions
+
+    def color_entries_for(color_number)
+      unless (1..4).to_a.include? color_number
+        raise "Invalid ColorEntry number 'color#{color_number}'"
+      end
+
+      0.upto(color_entry_count - 1).map do |i|
+        color_entry(i).send("color#{color_number}".to_sym)
+      end
+    end
+
+    # @return [Array<GDAL::ColorEntry>]
+    def color_entries
+      0.upto(color_entry_count - 1).map do |i|
+        color_entry(i)
+      end
+    end
+
+    # Does the same as #color_entries, but calls #color_entry_as_rgb() instead
+    # of #color_entry().
+    #
+    # @return [Array<GDAL::ColorEntry>]
+    def color_entries_as_rgb
+      0.upto(color_entry_count - 1).map do |i|
+        color_entry_as_rgb(i)
+      end
+    end
+
+    # @return [Hash]
+    def as_json
+      {
+        color_entry_count: color_entry_count,
+        color_entries: color_entries.map(&:as_json),
+        palette_interpretation: palette_interpretation,
+      }
+    end
+
+    # @return [String]
+    def to_json
+      as_json.to_json
+    end
+  end
+end

data/lib/gdal/color_table_types/cmyk.rb

@@ -0,0 +1,25 @@
+module GDAL
+  module ColorTableTypes
+    module CMYK
+      def cyans
+        color_entries_for(1)
+      end
+
+      def magentas
+        color_entries_for(2)
+      end
+
+      def yellows
+        color_entries_for(3)
+      end
+
+      def blacks
+        color_entries_for(4)
+      end
+
+      def to_a
+        NMatrix[cyans, magentas, yellows, blacks].transpose.to_a
+      end
+    end
+  end
+end

data/lib/gdal/color_table_types/gray.rb

@@ -0,0 +1,9 @@
+module GDAL
+  module ColorTableTypes
+    module Gray
+      def grays
+        color_entries_for(1)
+      end
+    end
+  end
+end

data/lib/gdal/color_table_types/hls.rb

@@ -0,0 +1,21 @@
+module GDAL
+  module ColorTableTypes
+    module HLS
+      def hues
+        color_entries_for(1)
+      end
+
+      def lightnesses
+        color_entries_for(2)
+      end
+
+      def saturations
+        color_entries_for(3)
+      end
+
+      def to_a
+        NMatrix[hues, lightnesses, saturations].transpose.to_a
+      end
+    end
+  end
+end

data/lib/gdal/color_table_types/rgb.rb

@@ -0,0 +1,25 @@
+module GDAL
+  module ColorTableTypes
+    module RGB
+      def reds
+        color_entries_for(1)
+      end
+
+      def greens
+        color_entries_for(2)
+      end
+
+      def blues
+        color_entries_for(3)
+      end
+
+      def alphas
+        color_entries_for(4)
+      end
+
+      def to_a
+        NMatrix[reds, greens, blues, alphas].transpose.to_a
+      end
+    end
+  end
+end

data/lib/gdal/data_type.rb

@@ -0,0 +1,38 @@
+module GDAL
+  class DataType
+    # The size in bits.
+    #
+    # @param gdal_data_type [FFI::GDAL::GDALDataType]
+    # @return [Fixnum]
+    def self.size(gdal_data_type)
+      FFI::GDAL.GDALGetDataTypeSize(gdal_data_type)
+    end
+
+    # @param gdal_data_type [FFI::GDAL::GDALDataType]
+    # @return [Fixnum]
+    def self.complex?(gdal_data_type)
+      FFI::GDAL.GDALDataTypeIsComplex(gdal_data_type)
+    end
+
+    # @param gdal_data_type [FFI::GDAL::GDALDataType]
+    # @return [String]
+    def self.name(gdal_data_type)
+      FFI::GDAL.GDALGetDataTypeName(gdal_data_type)
+    end
+
+    # The data type's symbolic name.
+    #
+    # @param name [String]
+    # @return [FFI::GDAL::GDALDataType]
+    def self.by_name(name)
+      FFI::GDAL.GDALGetDataTypeByName(name)
+    end
+
+    # @param gdal_data_type1 [FFI::GDAL::GDALDataType]
+    # @param gdal_data_type2 [FFI::GDAL::GDALDataType]
+    # @return [FFI::GDAL::GDALDataType]
+    def self.union(gdal_data_type1, gdal_data_type2)
+      FFI::GDAL.GDALDataTypeUnion(gdal_data_type1, gdal_data_type2)
+    end
+  end
+end

data/lib/gdal/dataset.rb

@@ -0,0 +1,437 @@
+require 'uri'
+require_relative '../ffi/gdal'
+require_relative 'driver'
+require_relative 'geo_transform'
+require_relative 'raster_band'
+require_relative 'exceptions'
+require_relative 'major_object'
+require_relative 'dataset_extensions'
+require_relative '../ogr/spatial_reference'
+
+
+module GDAL
+
+  # A set of associated raster bands and info common to them all.  It's also
+  # responsible for the georeferencing transform and coordinate system
+  # definition of all bands.
+  class Dataset
+    include MajorObject
+    include DatasetExtensions
+    include GDAL::Logger
+
+    ACCESS_FLAGS = {
+      'r' => :GA_ReadOnly,
+      'w' => :GA_Update
+    }
+
+    # @param path [String] Path to the file that contains the dataset.  Can be
+    #   a local file or a URL.
+    # @param access_flag [String] 'r' or 'w'.
+    def self.open(path, access_flag)
+      uri = URI.parse(path)
+      file_path = uri.scheme.nil? ? ::File.expand_path(path) : path
+
+      pointer = FFI::GDAL.GDALOpen(file_path, ACCESS_FLAGS[access_flag])
+      raise OpenFailure.new(file_path) if pointer.null?
+
+      new(pointer)
+    end
+
+    #---------------------------------------------------------------------------
+    # Instance methods
+    #---------------------------------------------------------------------------
+
+    # @param dataset_pointer [FFI::Pointer] Pointer to the dataset in memory.
+    def initialize(dataset_pointer)
+      @dataset_pointer = dataset_pointer
+      @last_known_file_list = []
+      @open = true
+      close_me = -> { self.close }
+      ObjectSpace.define_finalizer self, close_me
+    end
+
+    # @return [FFI::Pointer] Pointer to the GDALDatasetH that's represented by
+    # this Ruby object.
+    def c_pointer
+      @dataset_pointer
+    end
+
+    # Close the dataset.
+    def close
+      if @dataset_pointer.null?
+        false
+      else
+        FFI::GDAL.GDALClose(@dataset_pointer)
+      end
+    end
+
+    # @return [Symbol]
+    def access_flag
+      return nil if null?
+
+      flag = FFI::GDAL.GDALGetAccess(@dataset_pointer)
+
+      FFI::GDAL.GDALAccess[flag]
+    end
+
+    # @return [GDAL::Driver] The driver to be used for working with this
+    #   dataset.
+    def driver
+      return @driver if @driver
+      driver_ptr = FFI::GDAL.GDALGetDatasetDriver(@dataset_pointer)
+
+      @driver = Driver.new(driver_ptr)
+    end
+
+    # Fetches all files that form the dataset.
+    # @return [Array<String>]
+    def file_list
+      list_pointer = FFI::GDAL.GDALGetFileList(@dataset_pointer)
+      return [] if list_pointer.null?
+      file_list = list_pointer.get_array_of_string(0)
+      FFI::GDAL.CSLDestroy(list_pointer)
+
+      file_list
+    end
+
+    # Flushes all write-cached data to disk.
+    def flush_cache
+      FFI::GDAL.GDALFlushCache(@dataset_pointer)
+    end
+
+    # @return [Fixnum]
+    def raster_x_size
+      return nil if null?
+
+      FFI::GDAL.GDALGetRasterXSize(@dataset_pointer)
+    end
+
+    # @return [Fixnum]
+    def raster_y_size
+      return nil if null?
+
+      FFI::GDAL.GDALGetRasterYSize(@dataset_pointer)
+    end
+
+    # @return [Fixnum]
+    def raster_count
+      return 0 if null?
+
+      FFI::GDAL.GDALGetRasterCount(@dataset_pointer)
+    end
+
+    # @param raster_index [Fixnum]
+    # @return [GDAL::RasterBand]
+    def raster_band(raster_index)
+      @raster_bands ||= Array.new(raster_count)
+      zero_index = raster_index - 1
+
+      if @raster_bands[zero_index] && !@raster_bands[zero_index].null?
+        return @raster_bands[zero_index]
+      end
+
+      raster_band_ptr = FFI::GDAL.GDALGetRasterBand(@dataset_pointer, raster_index)
+      @raster_bands[zero_index] = GDAL::RasterBand.new(raster_band_ptr)
+      @raster_bands.compact!
+
+      @raster_bands[zero_index]
+    end
+
+    # @param type [FFI::GDAL::GDALDataType]
+    # @param options [Hash]
+    # @return [GDAL::RasterBand, nil]
+    def add_band(type, **options)
+      options_ptr = GDAL::Options.pointer(options)
+      cpl_err = FFI::GDAL.GDALAddBand(@dataset_pointer, type, options_ptr)
+      cpl_err.to_bool
+
+      raster_band(raster_count)
+    end
+
+    # Adds a mask band to the dataset
+    #
+    # @return [Boolean]
+    def create_mask_band
+      cpl_err = FFI::GDAL.GDALCreateDatasetMaskBand(@dataset_pointer, 0)
+
+      cpl_err.to_bool
+    end
+
+    # @return [String]
+    def projection
+      FFI::GDAL.GDALGetProjectionRef(@dataset_pointer)
+    end
+
+    # @param new_projection [String]
+    # @return [Boolean]
+    def projection=(new_projection)
+      cpl_err = FFI::GDAL.GDALSetProjection(@dataset_pointer, new_projection)
+
+      cpl_err.to_bool
+    end
+
+    # @return [GDAL::GeoTransform]
+    def geo_transform
+      return @geo_transform if @geo_transform
+
+      geo_transform_pointer = FFI::MemoryPointer.new(:double, 6)
+      cpl_err = FFI::GDAL.GDALGetGeoTransform(@dataset_pointer, geo_transform_pointer)
+      cpl_err.to_ruby
+
+      @geo_transform = GeoTransform.new(geo_transform_pointer)
+    end
+
+    # @param new_transform [GDAL::GeoTransform]
+    # @return [GDAL::GeoTransform]
+    def geo_transform=(new_transform)
+      new_pointer = FFI::Pointer.new(new_transform.c_pointer)
+      cpl_err = FFI::GDAL.GDALSetGeoTransform(@dataset_pointer, new_pointer)
+      cpl_err.to_bool
+
+      @geo_transform = GeoTransform.new(new_pointer)
+    end
+
+    # @return [Fixnum]
+    def gcp_count
+      return 0 if null?
+
+      FFI::GDAL.GDALGetGCPCount(@dataset_pointer)
+    end
+
+    # @return [String]
+    def gcp_projection
+      return '' if null?
+
+      FFI::GDAL.GDALGetGCPProjection(@dataset_pointer)
+    end
+
+    # @return [FFI::GDAL::GDALGCP]
+    def gcps
+      return FFI::GDAL.GDALGCP.new if null?
+
+      gcp_array_pointer = FFI::GDAL.GDALGetGCPs(@dataset_pointer)
+
+      if gcp_array_pointer.null?
+        FFI::GDAL.GDALGCP.new
+      else
+        FFI::GDAL.GDALGCP.new(gcp_array_pointer)
+      end
+    end
+
+    # @return [Fixnum]
+    def layer_count
+      if GDAL._supported?(:GDALDatasetGetLayerCount)
+        FFI::GDAL.GDALDatasetGetLayerCount(@dataset_pointer)
+      end
+    end
+
+    # @param resampling [String, Symbol] One of:
+    #   * :nearest
+    #   * :gauss
+    #   * :cubic
+    #   * :average
+    #   * :mode
+    #   * :average_magphase
+    #   * :none
+    # @param overview_levels [Array<Fixnum>] The list of overview decimation
+    #   factors to build.
+    # @param band_numbers [Array<Fixnum>] The numbers of the bands to build
+    #   overviews from.
+    def build_overviews(resampling, overview_levels, band_numbers=nil, &progress)
+      resampling_string = if resampling.is_a? String
+        resampling.upcase
+      elsif resampling.is_a? Symbol
+        resampling.to_s.upcase
+      end
+
+      overview_levels_ptr = FFI::MemoryPointer.new(:int, overview_levels.size)
+      overview_levels_ptr.write_array_of_int(overview_levels)
+
+      if band_numbers
+        band_count = band_numbers.size
+        band_numbers_ptr = FFI::MemoryPointer.new(:int, band_count)
+        band_numbers_ptr.write_array_of_int(band_numbers)
+      else
+        band_numbers_ptr = nil
+        band_count = nil
+      end
+
+      cpl_err = FFI::GDAL.GDALBuildOverviews(@dataset_pointer,
+        resampling_string,
+        overview_levels.size,
+        overview_levels_ptr,
+        band_count,
+        band_numbers_ptr,
+        progress,
+        nil
+      )
+
+      cpl_err.to_bool
+    end
+
+    # Rasterizes the geometric objects +geometries+ into this raster dataset.
+    # +transformer+ can be nil as long as the +geometries+ are within the
+    # georeferenced coordinates of this raster's dataset.
+    #
+    # @param band_numbers [Array<Fixnum>, Fixnum]
+    # @param geometries [Array<OGR::Geometry>, OGR::Geometry]
+    # @param burn_values [Array<Float>, Float]
+    # @param transformer [Proc]
+    # @param options [Hash]
+    # @option options all_touched [Boolean]  If +true+, sets all pixels touched
+    #   by the line or polygons, not just those whose center is within the
+    #   polygon or that are selected by Brezenham's line algorithm.  Defaults to
+    #   +false+.
+    # @option options burn_value_from ["Z"] Use the Z values of the geometries.
+    # @option @options merge_alg [String] "REPLACE" or "ADD".  REPLACE results
+    #   in overwriting of value, while ADD adds the new value to the existing
+    #   raster, suitable for heatmaps for instance.
+    def rasterize_geometries!(band_numbers, geometries, burn_values,
+      transformer: nil, transform_arg: nil, **options, &progress_block)
+
+      if geo_transform.nil? && gcp_count.zero?
+        raise "Can't rasterize geometries--no geo_transform or GCPs have been defined on the dataset."
+      end
+
+      gdal_options = GDAL::Options.pointer(options)
+      band_numbers = band_numbers.is_a?(Array) ? band_numbers : [band_numbers]
+      geometries = geometries.is_a?(Array) ? geometries : [geometries]
+      burn_values = burn_values.is_a?(Array) ? burn_values : [burn_values]
+
+      band_numbers_ptr = FFI::MemoryPointer.new(:pointer, band_numbers.size)
+      band_numbers_ptr.write_array_of_int(band_numbers)
+
+      geometries_ptr = FFI::MemoryPointer.new(:pointer, geometries.size)
+      geometries_ptr.write_array_of_pointer(geometries.map(&:c_pointer))
+
+      burn_values_ptr = FFI::MemoryPointer.new(:pointer, burn_values.size)
+      burn_values_ptr.write_array_of_double(burn_values)
+
+      # not allowing for now
+      progress_callback_data = nil
+
+      cpl_err = FFI::GDAL.GDALRasterizeGeometries(@dataset_pointer,
+        band_numbers.size,
+        band_numbers_ptr,
+        geometries.size,
+        geometries_ptr,
+        transformer,
+        transform_arg,
+        burn_values_ptr,
+        gdal_options,
+        progress_block,
+        progress_callback_data)
+
+      cpl_err.to_bool
+    end
+
+    # @param band_numbers [Array<Fixnum>, Fixnum]
+    # @param layers [Array<OGR::Layer>, OGR::Layer]
+    # @param burn_values [Array<Float>, Float]
+    # @param transformer [Proc]
+    # @param options [Hash]
+    # @option options attribute [String] An attribute field on features to be
+    #   used for a burn-in value, which will be burned into all output bands.
+    # @option options chunkysize [Fixnum] The height in lines of the chunk to
+    #   operate on.
+    # @option options all_touched [Boolean]  If +true+, sets all pixels touched
+    #   by the line or polygons, not just those whose center is within the
+    #   polygon or that are selected by Brezenham's line algorithm.  Defaults to
+    #   +false+.
+    # @option options burn_value_from ["Z"] Use the Z values of the geometries.
+    # @option @options merge_alg [String] "REPLACE" or "ADD".  REPLACE results
+    #   in overwriting of value, while ADD adds the new value to the existing
+    #   raster, suitable for heatmaps for instance.
+    def rasterize_layers!(band_numbers, layers, burn_values,
+      transformer: nil, transform_arg: nil, **options, &progress_block)
+      gdal_options = GDAL::Options.pointer(options)
+      band_numbers = band_numbers.is_a?(Array) ? band_numbers : [band_numbers]
+      log "band numbers: #{band_numbers}"
+
+      layers = layers.is_a?(Array) ? layers : [layers]
+      log "layers: #{layers}"
+
+      burn_values = burn_values.is_a?(Array) ? burn_values : [burn_values]
+      log "burn values: #{burn_values}"
+
+      band_numbers_ptr = FFI::MemoryPointer.new(:pointer, band_numbers.size)
+      band_numbers_ptr.write_array_of_int(band_numbers)
+      log "band numbers ptr null? #{band_numbers_ptr.null?}"
+
+      layers_ptr = FFI::MemoryPointer.new(:pointer, layers.size)
+      layers_ptr.write_array_of_pointer(layers.map(&:c_pointer))
+      log "layers ptr null? #{layers_ptr.null?}"
+
+      burn_values_ptr = FFI::MemoryPointer.new(:pointer, burn_values.size)
+      burn_values_ptr.write_array_of_double(burn_values)
+      log "burn value ptr null? #{burn_values_ptr.null?}"
+
+      cpl_err = FFI::GDAL.GDALRasterizeLayers(@dataset_pointer,     # hDS
+        band_numbers.size,                                # nBandCount
+        band_numbers_ptr,                                 # panBandList
+        layers.size,                                      # nLayerCount
+        layers_ptr,                                       # pahLayers
+        transformer,                                      # pfnTransformer
+        transform_arg,                                    # pTransformerArg
+        burn_values_ptr,                                  # padfLayerBurnValues
+        gdal_options,                                     # papszOptions
+        progress_block,                                   # pfnProgress
+        nil)                                              # pProgressArg
+
+      cpl_err.to_bool
+    end
+
+    # @todo Implement
+    def simple_image_warp(destination_file, driver, band_numbers,
+      transformer, transformer_arg, **options)
+      raise NotImplementedError, '#simple_image_warp not yet implemented.'
+
+      options_ptr = GDAL::Options.pointer(options)
+      driver = GDAL::Driver.by_name(driver)
+      destination_dataset_ptr = driver.open(destination_file, 'w')
+
+      band_numbers = band_numbers.is_a?(Array) ? band_numbers : [band_numbers]
+      log "band numbers: #{band_numbers}"
+
+      bands_ptr = FFI::MemoryPointer.new(:pointer, band_numbers.size)
+      bands_ptr.write_array_of_int(band_numbers)
+      log "band numbers ptr null? #{bands_ptr.null?}"
+
+      log "transformer: #{transformer}"
+
+      success = FFI::GDAL.GDALSimpleImageWarp(@dataset_pointer,
+        destination_dataset_ptr,
+        band_numbers.size,
+        bands_ptr,
+        transformer,
+        nil,
+        nil,
+        nil,
+        options_ptr)
+
+      raise 'Image warp failed!' unless success
+
+      GDAL::Dataset.new(destination_dataset_ptr)
+    end
+
+    # @return [FFI::Pointer] Pointer to be used for transformations.
+    def create_general_image_projection_transformer(destination_dataset,
+      source_projection: nil, destination_projection: nil, use_gcps: false)
+      log "destination dataset: #{destination_dataset}"
+
+      error_threshold = 0.0
+      order = 0
+
+      transformer_ptr = FFI::GDAL.GDALCreateGenImgProjTransformer(@dataset_pointer,
+        source_projection,
+        destination_dataset.c_pointer,
+        destination_projection,
+        use_gcps,
+        error_threshold,
+        order)
+
+      log "transformer pointer: #{transformer_ptr}"
+      transformer_ptr
+    end
+  end
+end