ffi-gdal 0.0.1

data/lib/ffi-gdal/raster_attribute_table.rb

@@ -0,0 +1,78 @@
+require_relative '../ffi/gdal'
+
+
+module GDAL
+  class RasterAttributeTable
+    include FFI::GDAL
+
+    # @param raster_band [GDAL::RasterBand, FFI::Pointer]
+    # @param raster_attribute_table_pointer [FFI::Pointer]
+    def initialize(raster_band, raster_attribute_table_pointer: nil)
+      @raster_band = if raster_band.is_a? GDAL::RasterBand
+        raster_band.c_pointer
+      else
+        raster_band
+      end
+
+      @gdal_raster_attribute_table = if raster_attribute_table_pointer
+        raster_attribute_table_pointer
+      else
+        GDALGetDefaultRAT(@raster_band)
+      end
+    end
+
+    def c_pointer
+      @gdal_raster_attribute_table
+    end
+
+    # @param index [Fixnum] The column number.
+    # @return [Fixnum]
+    def column_count
+      GDALRATGetColumnCount(c_pointer)
+    end
+
+    # @param index [Fixnum] The column number.
+    # @return [String]
+    def columnn_name(index)
+      GDALRATGetNameOfCol(c_pointer, index)
+    end
+
+    # @param index [Fixnum] The column number.
+    # @return [GDALRATFieldUsage]
+    def column_usage(index)
+      GDALRATGetUsageOfCol(c_pointer, index)
+    end
+
+    # @param index [Fixnum] The column number.
+    # @return [GDALRATFieldType]
+    def column_type(index)
+      GDALRATGetTypeOfCol(c_pointer, index)
+    end
+
+    # @param field_usage [GDALRATFieldUsage]
+    # @return [Fixnum] The column number.
+    def column_of_usage(field_usage)
+      GDALRATGetColOfUsage(c_pointer, index)
+    end
+
+    # @param field_usage [GDALRATFieldUsage]
+    # @return [Fixnum] The column number.
+    def row_count
+      GDALRATGetRowCount(c_pointer)
+    end
+
+    # @param entry_count [Fixnum] The number of entries to produce.  The default
+    #   will try to auto-determine the number.
+    # @return [GDAL::ColorTable]
+    def to_color_table(entry_count = -1)
+      color_table_pointer = GDALRATTranslateToColorTable(c_pointer, entry_count)
+
+      GDAL::ColorTable.new(@raster_band, color_table_pointer: color_table_pointer)
+    end
+
+    # @param file_path [String]
+    def dump_readable(file_path = 'stdout')
+      GDALRATDumpReadable(c_pointer, file_path)
+    end
+  end
+end

data/lib/ffi-gdal/raster_band.rb

@@ -0,0 +1,571 @@
+require_relative '../ffi/gdal'
+require_relative 'color_table'
+require_relative 'major_object'
+require_relative 'raster_attribute_table'
+require 'narray'
+
+module GDAL
+  class RasterBand
+    include FFI::GDAL
+    include MajorObject
+
+    attr_reader :dataset
+
+    # @param dataset [GDAL::Dataset, FFI::Pointer]
+    # @param band_id [Fixnum] Requried if not passing in +raster_band_pointer+.
+    # @param raster_band_pointer [FFI::Pointer] Requried if not passing in
+    #   +band_id+.
+    def initialize(dataset, band_id: nil, raster_band_pointer: nil)
+      if dataset.is_a? GDAL::Dataset
+        @dataset = dataset.c_pointer
+      else
+        @dataset = dataset
+      end
+
+      @gdal_raster_band = if raster_band_pointer
+        raster_band_pointer
+      elsif band_id
+        GDALGetRasterBand(@dataset, band_id)
+      else
+        raise 'Must pass in band_id or the raster_band_pointer.'
+      end
+    end
+
+    def c_pointer
+      @gdal_raster_band
+    end
+
+    # The raster width in pixels.
+    #
+    # @return [Fixnum]
+    def x_size
+      return nil if null?
+
+      GDALGetRasterBandXSize(@gdal_raster_band)
+    end
+
+    # The raster height in pixels.
+    #
+    # @return [Fixnum]
+    def y_size
+      return nil if null?
+
+      GDALGetRasterBandYSize(@gdal_raster_band)
+    end
+
+    # The type of access to the raster band this object currently has.
+    #
+    # @return [Symbol] Either :GA_Update or :GA_ReadOnly.
+    def access_flag
+      return nil if null?
+
+      GDALGetRasterAccess(@gdal_raster_band)
+    end
+
+    # The number of band within the associated dataset that this band
+    # represents.
+    #
+    # @return [Fixnum]
+    def band_number
+      return nil if null?
+
+      GDALGetBandNumber(@gdal_raster_band)
+    end
+
+    # @return [Symbol] One of FFI::GDAL::GDALColorInterp.
+    def color_interpretation
+      GDALGetRasterColorInterpretation(@gdal_raster_band)
+    end
+
+    # @return [GDAL::ColorTable]
+    def color_table
+      gdal_color_table = GDALGetRasterColorTable(@gdal_raster_band)
+      return nil if gdal_color_table.null?
+
+      @color_table ||= ColorTable.new(@gdal_raster_band,
+        color_table_pointer: gdal_color_table)
+    end
+
+    # The pixel data type for this band.
+    #
+    # @return [Symbol] One of FFI::GDAL::GDALDataType.
+    def data_type
+      GDALGetRasterDataType(@gdal_raster_band)
+    end
+
+    # The natural block size is the block size that is most efficient for
+    # accessing the format. For many formats this is simply a whole scanline
+    # in which case x is set to #x_size, and y is set to 1.
+    #
+    # @return [Hash{x => Fixnum, y => Fixnum}]
+    def block_size
+      x_pointer = FFI::MemoryPointer.new(:int)
+      y_pointer = FFI::MemoryPointer.new(:int)
+      GDALGetBlockSize(@gdal_raster_band, x_pointer, y_pointer)
+
+      { x: x_pointer.read_int, y: y_pointer.read_int }
+    end
+
+    # @return [Array<String>]
+    def category_names
+      names = GDALGetRasterCategoryNames(@gdal_raster_band)
+      return [] if names.null?
+
+      names.get_array_of_string(0)
+    end
+
+    # @param names [Array<String>]
+    # @return [Array<String>]
+    def category_names=(names)
+      str_pointers = names.map do |name|
+        FFI::MemoryPointer.from_string(name.to_s)
+      end
+
+      str_pointers << nil
+      names_pointer = FFI::MemoryPointer.new(:pointer, str_pointers.length)
+
+      str_pointers.each_with_index do |ptr, i|
+        names_pointer[i].put_pointer(0, ptr)
+      end
+
+      cpl_err = GDALSetRasterCategoryNames(@gdal_raster_band, names_pointer)
+
+      cpl_err.to_ruby(warning: [])
+    end
+
+    # The no data value for a band is generally a special marker value used to
+    # mark pixels that are not valid data. Such pixels should generally not be
+    # displayed, nor contribute to analysis operations.
+    #
+    # @return [Hash{value => Float, is_associated => Boolean}]
+    def no_data_value
+      associated = FFI::MemoryPointer.new(:bool)
+      value = GDALGetRasterNoDataValue(@gdal_raster_band, associated)
+
+      { value: value, is_associated: associated.read_bytes(1).to_bool }
+    end
+
+    # @return [Fixnum]
+    def overview_count
+      GDALGetOverviewCount(@gdal_raster_band)
+    end
+
+    # @return [Boolean]
+    def arbitrary_overviews?
+      GDALHasArbitraryOverviews(@gdal_raster_band).zero? ? false : true
+    end
+
+    # @param index [Fixnum] Must be between 0 and (#overview_count - 1).
+    # @return [GDAL::RasterBand]
+    def overview(index)
+      return nil if overview_count.zero?
+
+      overview_pointer = GDALGetOverview(@gdal_raster_band, index)
+      return nil if overview_pointer.null?
+
+      self.class.new(dataset, raster_band_pointer: overview_pointer)
+    end
+
+    # @param desired_samples [Fixnum] The returned band will have at least this
+    #   many pixels.
+    # @return [GDAL::RasterBand] An optimal overview or the same raster band if
+    #   the raster band has no overviews.
+    def raster_sample_overview(desired_samples=0)
+      band_pointer = GDALGetRasterSampleOverview(@gdal_raster_band, desired_samples)
+      return nil if band_pointer.null?
+
+      self.class.new(dataset, raster_band_pointer: band_pointer)
+    end
+
+    # @return [GDAL::RasterBand]
+    def mask_band
+      band_pointer = GDALGetMaskBand(@gdal_raster_band)
+      return nil if band_pointer.null?
+
+      self.class.new(dataset, raster_band_pointer: band_pointer)
+    end
+
+    # @return [Array<Symbol>]
+    def mask_flags
+      flag_list = GDALGetMaskFlags(@gdal_raster_band).to_s(2).scan(/\d/)
+      flags = []
+
+      flag_list.reverse.each_with_index do |flag, i|
+        if i == 0 && flag.to_i == 1
+          flags << :GMF_ALL_VALID
+        elsif i == 1 && flag.to_i == 1
+          flags << :GMF_PER_DATASET
+        elsif i == 2 && flag.to_i == 1
+          flags << :GMF_ALPHA
+        elsif i == 3 && flag.to_i == 1
+          flags << :GMF_NODATA
+        end
+      end
+
+      flags
+    end
+
+    # Returns minimum, maximum, mean, and standard deviation of all pixel values
+    # in this band.
+    #
+    # @param approx_ok [Boolean] If +true+, stats may be computed based on
+    #   overviews or a subset of all tiles.
+    # @param force [Boolean] If +false+, stats will only be returned if the
+    #   calculating can be done without rescanning the image.
+    # @return [Hash{mininum: Float, maximum: Float, mean: Float,
+    #   standard_deviation: Float}]
+    def statistics(approx_ok=true, force=true)
+      min = FFI::MemoryPointer.new(:double)
+      max = FFI::MemoryPointer.new(:double)
+      mean = FFI::MemoryPointer.new(:double)
+      standard_deviation = FFI::MemoryPointer.new(:double)
+
+      cpl_err = GDALGetRasterStatistics(@gdal_raster_band,
+        approx_ok,
+        force,
+        min,
+        max,
+        mean,
+        standard_deviation)
+
+      minimum = min.null? ? 0.0 : min.read_double
+
+      case cpl_err.to_ruby
+      when :none, :debug
+        {
+          minimum: min.read_double,
+          maximum: max.read_double,
+          mean: mean.read_double,
+          standard_deviation: standard_deviation.read_double
+        }
+      when :warning then {}
+      when :failure, :fatal then raise CPLErrFailure
+      end
+    end
+
+    # The raster value scale.  This value (in combination with the #offset
+    # value) is used to transform raw pixel values into the units returned by
+    # #units. For example this might be used to store elevations in GUInt16
+    # bands with a precision of 0.1, and starting from -100.
+    #
+    # Units value = (raw value * scale) + offset
+    #
+    # For file formats that don't know this intrinsically a value of one is
+    # returned.
+    #
+    # @return [Hash{value => Float, is_meaningful => Boolean}]
+    def scale
+      meaningful = FFI::MemoryPointer.new(:bool)
+      result = GDALGetRasterScale(@gdal_raster_band, meaningful)
+
+      { value: result, is_meaningful: meaningful.read_bytes(1).to_bool }
+    end
+
+    # @param new_scale [Float]
+    # @return [FFI::GDAL::CPLErr]
+    def scale=(new_scale)
+      GDALSetRasterScale(@gdal_raster_band, new_scale.to_f)
+    end
+
+    # This value (in combination with the GetScale() value) is used to
+    # transform raw pixel values into the units returned by #units. For example
+    # this might be used to store elevations in GUInt16 bands with a precision
+    # of 0.1, and starting from -100.
+    #
+    # Units value = (raw value * scale) + offset.
+    #
+    # For file formats that don't know this intrinsically a value of 0.0 is
+    # returned.
+    #
+    # @return [Hash{value => Float, is_meaningful => Boolean}]
+    def offset
+      meaningful = FFI::MemoryPointer.new(:bool)
+      result = GDALGetRasterOffset(@gdal_raster_band, meaningful)
+
+      { value: result, is_meaningful: meaningful.read_bytes(1).to_bool }
+    end
+
+    # @param new_offset [Float]
+    # @return [FFI::GDAL::CPLErr]
+    def offset=(new_offset)
+      GDALSetRasterOffset(@gdal_raster_band, new_offset)
+    end
+
+    # @return [String]
+    def unit_type
+      GDALGetRasterUnitType(@gdal_raster_band)
+    end
+
+    # @param new_unit_type [String] "" indicates unknown, "m" is meters, "ft"
+    #   is feet; other non-standard values are allowed.
+    # @return [FFI::GDAL::CPLErr]
+    def unit_type=(new_unit_type)
+      GDALSetRasterUnitType(@gdal_raster_band, new_unit_type)
+    end
+
+    # Gets the default raster histogram.  Results are returned as a Hash so some
+    # metadata about the histogram can be returned.  Example:
+    #
+    #   {
+    #     :mininum => -0.9,
+    #     :maximum => 255.9,
+    #     :buckets => 256,
+    #     :totals => [
+    #       3954, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    #       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1, 0,
+    #       0, 0, 10, 27, 201, 699, 1766, 3472, 5013, 6464, 7698, 8352,
+    #       9039, 10054, 11378, 13132, 14377, 14371, 14221, 14963, 14740,
+    #       14379, 13724, 12938, 11318, 9828, 8504, 7040, 5700, 4890,
+    #       4128, 3276, 2749, 2322, 1944, 1596, 1266, 1050, 784, 663,
+    #       547, 518, 367, 331, 309, 279, 178, 169, 162, 149, 109, 98,
+    #       90, 89, 82, 85, 74, 75, 42, 40, 39, 35, 39, 36, 36, 27, 20,
+    #       12, 13, 19, 16, 12, 11, 6, 6, 8, 12, 6, 8, 11, 3, 7, 9, 2,
+    #       5, 2, 5, 1, 4, 0, 0, 1, 0, 1, 2, 1, 0, 2, 1, 0, 0, 1, 0, 1,
+    #       1, 1, 0, 2, 1, 2, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
+    #       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    #       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    #       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    #       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    #       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+    #     ]
+    #   }
+    #
+    # @param force [Boolean] Forces the computation of the histogram.  If
+    #   +false+ and the default histogram isn't available, this returns nil.
+    # @param block [Proc] No required, but can be used to output progess info
+    #   during processing.
+    # @yieldparam completion [Float] The ration completed as a decimal.
+    # @yieldparam message [String] Message string to display.
+    # @return [Hash{minimum => Float, maximum => Float, buckets => Fixnum,
+    #   totals => Array<Fixnum>}]
+    def default_histogram(force=false, &block)
+      min_pointer = FFI::MemoryPointer.new(:double)
+      max_pointer = FFI::MemoryPointer.new(:double)
+      buckets_pointer = FFI::MemoryPointer.new(:int)
+      histogram_pointer = FFI::MemoryPointer.new(:pointer)
+
+      progress_proc = block || Proc.new do |completion, message, progress_arg|
+        puts "completion: #{completion * 100}"
+        puts "message: #{message}"
+        true
+      end
+
+      cpl_err = GDALGetDefaultHistogram(@gdal_raster_band,
+        min_pointer,
+        max_pointer,
+        buckets_pointer,
+        histogram_pointer,
+        force,
+        progress_proc,
+        nil
+      )
+
+      min = min_pointer.read_double
+      max = max_pointer.read_double
+      buckets = buckets_pointer.read_int
+      totals = histogram_pointer.get_pointer(0).read_array_of_int(buckets)
+
+      case cpl_err.to_ruby
+      when :none, :debug
+        {
+          minimum: min,
+          maximum: max,
+          buckets: buckets,
+          totals: totals
+        }
+      when :warning then return nil
+      when :failure, :fatal then raise CPLError
+      end
+    end
+
+    # @return [GDAL::RasterAttributeTable]
+    def default_raster_attribute_table
+      rat_pointer = GDALGetDefaultRAT(c_pointer)
+      return nil if rat_pointer.null?
+
+      GDAL::RasterAttributeTable.new(c_pointer,
+        raster_attribute_table_pointer: rat_pointer)
+    end
+
+    # Computes a histogram using the given inputs.  If you just want the default
+    # histogram, use #default_histogram.
+    #
+    # @param min [Float]
+    # @param max [Float]
+    # @param buckets [Fixnum]
+    # @param include_out_of_range [Boolean]
+    # @param approx_ok [Boolean]
+    # @param block [Proc] No required, but can be used to output progess info
+    #   during processing.
+    # @yieldparam completion [Float] The ration completed as a decimal.
+    # @yieldparam message [String] Message string to display.
+    # @return [Hash{minimum => Float, maximum => Float, buckets => Fixnum,
+    #   totals => Array<Fixnum>}]
+    def histogram(min, max, buckets, include_out_of_range: false,
+      approx_ok: true, &block)
+      histogram_pointer = FFI::MemoryPointer.new(:int, buckets)
+
+      progress_proc = block || Proc.new do |completion, message, progress_arg|
+        puts "progress: #{completion * 100}"
+        true
+      end
+
+      cpl_err = GDALGetRasterHistogram(@gdal_raster_band,
+        min.to_f,
+        max.to_f,
+        buckets,
+        histogram_pointer,
+        include_out_of_range,
+        approx_ok,
+        progress_proc,
+        'doing things'
+      )
+      totals = histogram_pointer.read_array_of_int(0)
+
+      case cpl_err.to_ruby
+      when :none
+        {
+          minimum: min,
+          maximum: max,
+          buckets: buckets,
+          totals: totals
+        }
+      when :warning then return nil
+      when :failure then raise CPLError
+      end
+    end
+
+    # TODO: Something about the pointer allocation smells here...
+    #def read(x_offset: 0, y_offset: 0, x_size: x_size, y_size: 1, pixel_space: 0, line_space: 0)
+    def readlines
+      x_offset = 0
+      line_size = 1
+      pixel_space = 0
+      line_space = 0
+      scan_line = FFI::MemoryPointer.new(:float, x_size)
+
+      0.upto(y_size - 1) do |y|
+        GDALRasterIO(@gdal_raster_band,
+          :GF_Read,
+          x_offset,
+          y,
+          x_size,
+          line_size,
+          scan_line,
+          x_size,
+          line_size,
+          data_type,
+          pixel_space,
+          line_space
+        )
+
+        yield scan_line.read_array_of_float(x_size).dup
+      end
+    end
+
+    # @param pixel_array [NArray] The NArray of pixels.
+    # @param x_offset [Fixnum] The left-most pixel to start writing.
+    # @param y_offset [Fixnum] The top-most pixel to start writing.
+    # @param data_type [FFI::GDAL::GDALDataType] The type of pixel contained in
+    #   the +pixel_array+.
+    # @param line_space [Fixnum]
+    # @param pixel_space [Fixnum]
+    # TODO: Write using #buffer_size to write most efficiently.
+    # TODO: Return a value!
+    def write_array(pixel_array, x_offset: 0, y_offset: 0, data_type: :GDT_Byte,
+      line_space: 0, pixel_space: 0)
+      line_size = 1
+      x_size = pixel_array.sizes.first
+      y_size = pixel_array.sizes.last
+
+      columns_to_write = x_size - x_offset
+      lines_to_write = y_size - y_offset
+      scan_line = FFI::MemoryPointer.new(:float, columns_to_write)
+
+      (y_offset).upto(lines_to_write - 1) do |y|
+        pixels = pixel_array[true, y]
+        scan_line.write_array_of_float(pixels.to_a)
+
+        GDALRasterIO(@gdal_raster_band,
+          :GF_Write,
+          x_offset,     # nXOff
+          y,
+          x_size,       # nXSize
+          line_size,    # nYSize
+          scan_line,    # pData
+          x_size,       # nBufXSize
+          line_size,    # nBufYSize
+          data_type,    # eBufType
+          pixel_space,  # nPixelSpace
+          line_space    # nLineSpace
+        )
+      end
+
+      GDALFlushRasterCache(@gdal_raster_band)
+    end
+
+    # Read a block of image data, more efficiently than #read.  Doesn't
+    # resample or do data type conversion.
+    #
+    # @param x_offset [Fixnum] The horizontal block offset, with 0 indicating
+    #   the left-most block, 1 the next block, etc.
+    # @param y_offset [Fixnum] The vertical block offset, with 0 indicating the
+    #   top-most block, 1 the next block, etc.
+    def read_block(x_offset, y_offset, image_buffer=nil)
+      image_buffer ||= FFI::MemoryPointer.new(:void)
+      #puts "x offset: #{x_offset}"
+      #puts "y offset: #{y_offset}"
+
+      result = GDALReadBlock(@gdal_raster_band, x_offset, y_offset, image_buffer)
+
+      if result == :none
+      elsif result == :failure
+
+      end
+    end
+
+    # The minimum and maximum values for this band.
+    #
+    # @return [Array{min => Float, max => Float}]
+    def compute_min_max
+      @min_max = if minimum_value[:value] && maximum_value[:value]
+        min_max = FFI::MemoryPointer.new(:double, 2)
+        min_max.put_array_of_double 0, [minimum_value[:value], maximum_value[:value]]
+        GDALComputeRasterMinMax(@gdal_raster_band, 1, min_max)
+
+        [min_max[0].read_double, min_max[1].read_double]
+      else
+        [0.0, 0.0]
+      end
+    end
+
+    # @return [Hash{value => Float, it_tight => Boolean}]
+    def minimum_value
+      is_tight = FFI::MemoryPointer.new(:bool)
+      value = GDALGetRasterMinimum(@gdal_raster_band, is_tight)
+
+      { value: value, is_tight: is_tight.read_bytes(1).to_bool }
+    end
+
+    # @return [Hash{value => Float, it_tight => Boolean}]
+    def maximum_value
+      is_tight = FFI::MemoryPointer.new(:double)
+      value = GDALGetRasterMaximum(@gdal_raster_band, is_tight)
+
+      { value: value, is_tight: is_tight.read_bytes(1).to_bool }
+    end
+
+    # Iterates through all lines and builds an NArray of pixels.
+    #
+    # @return [NArray]
+    def to_a
+      lines = []
+
+      readlines do |line|
+        lines << line
+      end
+
+      NArray.to_na(lines)
+    end
+  end
+end

data/lib/ffi-gdal/version_info.rb

@@ -0,0 +1,48 @@
+require_relative '../ffi/gdal'
+require 'date'
+
+module GDAL
+  module VersionInfo
+    # Version in the form "1170".
+    #
+    # @return [String]
+    def version_num
+      FFI::GDAL.GDALVersionInfo('VERSION_NUM')
+    end
+
+    # @return [Date]
+    def release_date
+      Date.parse(FFI::GDAL.GDALVersionInfo('RELEASE_DATE'))
+    end
+
+    # Version in the form "1.1.7".
+    #
+    # @return [String]
+    def release_name
+      FFI::GDAL.GDALVersionInfo('RELEASE_NAME')
+    end
+
+    # The long licensing info.
+    #
+    # @return [String]
+    def license
+      FFI::GDAL.GDALVersionInfo('LICENSE')
+    end
+
+    # Options used when building GDAL.
+    #
+    # @return [Hash{String => String}]
+    def build_info
+      key_value_pairs = FFI::GDAL.GDALVersionInfo('BUILD_INFO')
+      key_value_pairs.split.each_with_object({}) do |kv, obj|
+        key, value = kv.split('=', 2)
+        obj[key] = value
+      end
+    end
+
+    # @return [String]
+    def long_version
+      FFI::GDAL.GDALVersionInfo('--version')
+    end
+  end
+end

data/lib/ffi-gdal.rb

@@ -0,0 +1,12 @@
+require 'log_switch'
+require_relative 'ffi-gdal/version_info'
+
+module GDAL
+  extend VersionInfo
+  extend LogSwitch
+end
+
+GDAL.log_class_name = true
+
+require_relative 'ffi/gdal'
+require_relative 'ffi-gdal/dataset'