ffi-gdal 0.0.4 → 1.0.0.beta1

data/lib/{ffi-gdal → gdal}/raster_band.rb

@@ -1,4 +1,6 @@
 require_relative '../ffi/gdal'
+require_relative '../ffi/ogr/api_h'
+require_relative 'raster_band_extensions'
 require_relative 'color_table'
 require_relative 'major_object'
 require_relative 'raster_attribute_table'
@@ -6,33 +8,29 @@ require 'narray'
 
 module GDAL
   class RasterBand
-    include FFI::GDAL
     include MajorObject
+    include GDAL::Logger
+    include RasterBandExtensions
 
-    attr_reader :dataset
+    ALL_VALID = 0x01
+    PER_DATASET = 0x02
+    ALPHA = 0x04
+    NODATA = 0x08
 
-    # @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)
-      @dataset = if dataset.is_a? GDAL::Dataset
-        dataset.c_pointer
-      else
-        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
+    # @param raster_band [GDAL::RasterBand, FFI::Pointer]
+    def initialize(raster_band=nil)
+      @raster_band_pointer = GDAL._pointer(GDAL::RasterBand, raster_band)
     end
 
     def c_pointer
-      @gdal_raster_band
+      @raster_band_pointer
+    end
+
+    # @return [Boolean]
+    def flush_cache
+      cpl_err = FFI::GDAL.GDALFlushRasterCache(@raster_band_pointer)
+
+      cpl_err.to_bool
     end
 
     # The raster width in pixels.
@@ -41,7 +39,7 @@ module GDAL
     def x_size
       return nil if null?
 
-      GDALGetRasterBandXSize(@gdal_raster_band)
+      FFI::GDAL.GDALGetRasterBandXSize(@raster_band_pointer)
     end
 
     # The raster height in pixels.
@@ -50,7 +48,7 @@ module GDAL
     def y_size
       return nil if null?
 
-      GDALGetRasterBandYSize(@gdal_raster_band)
+      FFI::GDAL.GDALGetRasterBandYSize(@raster_band_pointer)
     end
 
     # The type of access to the raster band this object currently has.
@@ -59,38 +57,66 @@ module GDAL
     def access_flag
       return nil if null?
 
-      GDALGetRasterAccess(@gdal_raster_band)
+      FFI::GDAL.GDALGetRasterAccess(@raster_band_pointer)
     end
 
     # The number of band within the associated dataset that this band
     # represents.
     #
     # @return [Fixnum]
-    def band_number
+    def number
       return nil if null?
 
-      GDALGetBandNumber(@gdal_raster_band)
+      FFI::GDAL.GDALGetBandNumber(@raster_band_pointer)
+    end
+
+    # @return [GDAL::Dataset, nil]
+    def dataset
+      return @dataset if @dataset
+
+      dataset_ptr = FFI::GDAL.GDALGetBandDataset(@raster_band_pointer)
+      return nil if dataset_ptr.null?
+
+      @dataset = GDAL::Dataset.new(dataset_ptr)
     end
 
     # @return [Symbol] One of FFI::GDAL::GDALColorInterp.
     def color_interpretation
-      GDALGetRasterColorInterpretation(@gdal_raster_band)
+      FFI::GDAL.GDALGetRasterColorInterpretation(@raster_band_pointer)
+    end
+
+    # @return [Boolean]
+    def color_interpretation=(new_color_interp)
+      cpl_err = FFI::GDAL.GDALSetRasterColorInterpretation(@raster_band_pointer,
+        new_color_interp)
+
+      cpl_err.to_bool
     end
 
     # @return [GDAL::ColorTable]
     def color_table
-      gdal_color_table = GDALGetRasterColorTable(@gdal_raster_band)
+      return @color_table if @color_table
+
+      gdal_color_table = FFI::GDAL.GDALGetRasterColorTable(@raster_band_pointer)
       return nil if gdal_color_table.null?
 
-      @color_table ||= ColorTable.new(@gdal_raster_band,
-        color_table_pointer: gdal_color_table)
+      @color_table = ColorTable.new(gdal_color_table)
+    end
+
+    # @param new_color_table [GDAL::ColorTable]
+    def color_table=(new_color_table)
+      color_table_pointer = GDAL._pointer(GDAL::ColorTable, new_color_table)
+      cpl_err = FFI::GDAL.GDALSetRasterColorTable(@raster_band_pointer, color_table_pointer)
+      @color_table = ColorTable.new(color_table_pointer)
+
+      cpl_err.to_bool
     end
 
     # The pixel data type for this band.
     #
     # @return [Symbol] One of FFI::GDAL::GDALDataType.
     def data_type
-      GDALGetRasterDataType(@gdal_raster_band)
+      FFI::GDAL.GDALGetRasterDataType(@raster_band_pointer)
     end
 
     # The natural block size is the block size that is most efficient for
@@ -101,14 +127,14 @@ module GDAL
     def block_size
       x_pointer = FFI::MemoryPointer.new(:int)
       y_pointer = FFI::MemoryPointer.new(:int)
-      GDALGetBlockSize(@gdal_raster_band, x_pointer, y_pointer)
+      FFI::GDAL.GDALGetBlockSize(@raster_band_pointer, 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)
+      names = FFI::GDAL.GDALGetRasterCategoryNames(@raster_band_pointer)
       return [] if names.null?
 
       names.get_array_of_string(0)
@@ -128,7 +154,7 @@ module GDAL
         names_pointer[i].put_pointer(0, ptr)
       end
 
-      cpl_err = GDALSetRasterCategoryNames(@gdal_raster_band, names_pointer)
+      cpl_err = FFI::GDAL.GDALSetRasterCategoryNames(@raster_band_pointer, names_pointer)
 
       cpl_err.to_ruby(warning: [])
     end
@@ -140,19 +166,29 @@ module GDAL
     # @return [Hash{value => Float, is_associated => Boolean}]
     def no_data_value
       associated = FFI::MemoryPointer.new(:bool)
-      value = GDALGetRasterNoDataValue(@gdal_raster_band, associated)
+      value = FFI::GDAL.GDALGetRasterNoDataValue(@raster_band_pointer, associated)
 
       { value: value, is_associated: associated.read_bytes(1).to_bool }
     end
 
+    # Sets the no data value for this band.
+    #
+    # @param value [Float]
+    # @return [Boolean]
+    def no_data_value=(value)
+      cpl_err = FFI::GDAL.GDALSetRasterNoDataValue(@raster_band_pointer, value)
+
+      cpl_err.to_bool
+    end
+
     # @return [Fixnum]
     def overview_count
-      GDALGetOverviewCount(@gdal_raster_band)
+      FFI::GDAL.GDALGetOverviewCount(@raster_band_pointer)
     end
 
     # @return [Boolean]
     def arbitrary_overviews?
-      GDALHasArbitraryOverviews(@gdal_raster_band).zero? ? false : true
+      FFI::GDAL.GDALHasArbitraryOverviews(@raster_band_pointer).zero? ? false : true
     end
 
     # @param index [Fixnum] Must be between 0 and (#overview_count - 1).
@@ -160,10 +196,10 @@ module GDAL
     def overview(index)
       return nil if overview_count.zero?
 
-      overview_pointer = GDALGetOverview(@gdal_raster_band, index)
+      overview_pointer = FFI::GDAL.GDALGetOverview(@raster_band_pointer, index)
       return nil if overview_pointer.null?
 
-      self.class.new(dataset, raster_band_pointer: overview_pointer)
+      self.class.new(overview_pointer)
     end
 
     # @param desired_samples [Fixnum] The returned band will have at least this
@@ -171,23 +207,23 @@ module GDAL
     # @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)
+      band_pointer = FFI::GDAL.GDALGetRasterSampleOverview(@raster_band_pointer, desired_samples)
       return nil if band_pointer.null?
 
-      self.class.new(dataset, raster_band_pointer: band_pointer)
+      self.class.new(band_pointer)
     end
 
     # @return [GDAL::RasterBand]
     def mask_band
-      band_pointer = GDALGetMaskBand(@gdal_raster_band)
+      band_pointer = FFI::GDAL.GDALGetMaskBand(@raster_band_pointer)
       return nil if band_pointer.null?
 
-      self.class.new(dataset, raster_band_pointer: band_pointer)
+      self.class.new(band_pointer)
     end
 
     # @return [Array<Symbol>]
     def mask_flags
-      flag_list = GDALGetMaskFlags(@gdal_raster_band).to_s(2).scan(/\d/)
+      flag_list = FFI::GDAL.GDALGetMaskFlags(@raster_band_pointer).to_s(2).scan(/\d/)
       flags = []
 
       flag_list.reverse.each_with_index do |flag, i|
@@ -205,6 +241,24 @@ module GDAL
       flags
     end
 
+    # @return [Boolean]
+    def create_mask_band(flags)
+      cpl_err = FFI::GDAL.GDALCreateMaskBand(@raster_band_pointer, flags)
+
+      cpl_err.to_bool
+    end
+
+    # Fill this band with constant value.  Useful for clearing a band and
+    # setting to a default value.
+    #
+    # @param real_value [Float]
+    # @param imaginary_value [Float]
+    def fill(real_value, imaginary_value=0)
+      cpl_err = FFI::GDAL.GDALFillRaster(@raster_band_pointer, real_value, imaginary_value)
+
+      cpl_err.to_bool
+    end
+
     # Returns minimum, maximum, mean, and standard deviation of all pixel values
     # in this band.
     #
@@ -212,7 +266,7 @@ module GDAL
     #   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,
+    # @return [Hash{minimum: Float, maximum: Float, mean: Float,
     #   standard_deviation: Float}]
     def statistics(approx_ok=true, force=true)
       min = FFI::MemoryPointer.new(:double)
@@ -220,7 +274,7 @@ module GDAL
       mean = FFI::MemoryPointer.new(:double)
       standard_deviation = FFI::MemoryPointer.new(:double)
 
-      cpl_err = GDALGetRasterStatistics(@gdal_raster_band,
+      cpl_err = FFI::GDAL.GDALGetRasterStatistics(@raster_band_pointer,
         approx_ok,
         force,
         min,
@@ -228,8 +282,6 @@ module GDAL
         mean,
         standard_deviation)
 
-      minimum = min.null? ? 0.0 : min.read_double
-
       case cpl_err.to_ruby
       when :none, :debug
         {
@@ -240,6 +292,7 @@ module GDAL
         }
       when :warning then {}
       when :failure, :fatal then raise CPLErrFailure
+      else raise CPLErrFailure
       end
     end
 
@@ -256,15 +309,17 @@ module GDAL
     # @return [Hash{value => Float, is_meaningful => Boolean}]
     def scale
       meaningful = FFI::MemoryPointer.new(:bool)
-      result = GDALGetRasterScale(@gdal_raster_band, meaningful)
+      result = FFI::GDAL.GDALGetRasterScale(@raster_band_pointer, meaningful)
 
       { value: result, is_meaningful: meaningful.read_bytes(1).to_bool }
     end
 
     # @param new_scale [Float]
-    # @return [FFI::GDAL::CPLErr]
+    # @return [Boolean]
     def scale=(new_scale)
-      GDALSetRasterScale(@gdal_raster_band, new_scale.to_f)
+      cpl_err = FFI::GDAL.GDALSetRasterScale(@raster_band_pointer, new_scale.to_f)
+
+      cpl_err.to_bool
     end
 
     # This value (in combination with the GetScale() value) is used to
@@ -280,28 +335,32 @@ module GDAL
     # @return [Hash{value => Float, is_meaningful => Boolean}]
     def offset
       meaningful = FFI::MemoryPointer.new(:bool)
-      result = GDALGetRasterOffset(@gdal_raster_band, meaningful)
+      result = FFI::GDAL.GDALGetRasterOffset(@raster_band_pointer, meaningful)
 
       { value: result, is_meaningful: meaningful.read_bytes(1).to_bool }
     end
 
     # @param new_offset [Float]
-    # @return [FFI::GDAL::CPLErr]
+    # @return [Boolean]
     def offset=(new_offset)
-      GDALSetRasterOffset(@gdal_raster_band, new_offset)
+      cpl_err = FFI::GDAL.GDALSetRasterOffset(@raster_band_pointer, new_offset)
+
+      cpl_err.to_bool
     end
 
     # @return [String]
     def unit_type
-      GDALGetRasterUnitType(@gdal_raster_band)
+      FFI::GDAL.GDALGetRasterUnitType(@raster_band_pointer)
     end
 
     # @param new_unit_type [String] "" indicates unknown, "m" is meters, "ft"
     #   is feet; other non-standard values are allowed.
-    # @return [FFI::GDAL::CPLErr]
+    # @return [Boolean]
     def unit_type=(new_unit_type)
       if defined? FFI::GDAL::GDALSetRasterUnitType
-        GDALSetRasterUnitType(@gdal_raster_band, new_unit_type)
+        cpl_err = FFI::GDAL.GDALSetRasterUnitType(@raster_band_pointer, new_unit_type)
+
+        cpl_err.to_bool
       else
         warn "GDALSetRasterUnitType is not defined.  Can't call RasterBand#unit_type="
       end
@@ -309,11 +368,21 @@ module GDAL
 
     # @return [GDAL::RasterAttributeTable]
     def default_raster_attribute_table
-      rat_pointer = GDALGetDefaultRAT(c_pointer)
+      return @default_raster_attribute_table if @default_raster_attribute_table
+
+      rat_pointer = FFI::GDAL.GDALGetDefaultRAT(@raster_band_pointer)
       return nil if rat_pointer.null?
 
-      GDAL::RasterAttributeTable.new(c_pointer,
-        raster_attribute_table_pointer: rat_pointer)
+      @default_raster_attribute_table = GDAL::RasterAttributeTable.new(rat_pointer)
+    end
+
+    # @return [GDAL::RasterAttributeTable]
+    def default_raster_attribute_table=(rat_table)
+      rat_table_ptr = GDAL._pointer(GDAL::RasterAttributeTable, rat_table)
+      cpl_err = FFI::GDAL.GDALSetDefaultRAT(@raster_band_pointer, rat_table_ptr)
+      @default_raster_attribute_table = GDAL::RasterAttributeTable.new(rat_table_pointer)
+
+      cpl_err.to_bool
     end
 
     # Gets the default raster histogram.  Results are returned as a Hash so some
@@ -364,7 +433,7 @@ module GDAL
       histogram_pointer = FFI::MemoryPointer.new(:pointer)
       progress_proc = block || nil
 
-      cpl_err = GDALGetDefaultHistogram(@gdal_raster_band,
+      cpl_err = FFI::GDAL.GDALGetDefaultHistogram(@raster_band_pointer,
         min_pointer,
         max_pointer,
         buckets_pointer,
@@ -374,6 +443,7 @@ module GDAL
         nil
       )
 
+      cpl_err.to_bool
       min = min_pointer.read_double
       max = max_pointer.read_double
       buckets = buckets_pointer.read_int
@@ -384,7 +454,7 @@ module GDAL
         histogram_pointer.get_pointer(0).read_array_of_int(buckets)
       end
 
-      formated_buckets(cpl_err, min, max, buckets, totals)
+      formatted_buckets(cpl_err, min, max, buckets, totals)
     end
 
     # Computes a histogram using the given inputs.  If you just want the default
@@ -395,7 +465,7 @@ module GDAL
     # @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
+    # @param block [Proc] No required, but can be used to output progress info
     #   during processing.
     #
     # @yieldparam completion [Float] The ration completed as a decimal.
@@ -410,7 +480,7 @@ module GDAL
       histogram_pointer = FFI::MemoryPointer.new(:pointer, buckets)
       progress_proc = block || nil
 
-      cpl_err = GDALGetRasterHistogram(@gdal_raster_band,
+      cpl_err = FFI::GDAL.GDALGetRasterHistogram(@raster_band_pointer,
         min.to_f,
         max.to_f,
         buckets,
@@ -420,26 +490,57 @@ module GDAL
         progress_proc,
         'doing things')
 
+      cpl_err.to_bool
+
       totals = if buckets.zero?
         []
       else
         histogram_pointer.read_array_of_int(buckets)
       end
 
-      formated_buckets(cpl_err, min, max, buckets, totals)
+      formatted_buckets(cpl_err, min, max, buckets, totals)
+    end
+
+    # Copies the contents of one raster to another similarly configure band.
+    # The two bands must have the same width and height but do not have to be
+    # the same data type.
+    #
+    # Options:
+    #   * :compressed
+    #     * 'YES': forces alignment on the destination_band to acheive the best
+    #       compression.
+    #
+    # @param destination_band [GDAL::RasterBand]
+    # @param options [Hash]
+    # @option options compress [String] Only 'YES' is supported.
+    # @return [Boolean]
+    def copy_whole_raster(destination_band, **options, &progress)
+      destination_pointer = GDAL._pointer(GDAL::RasterBand, destination_band)
+      options_ptr = GDAL::Options.pointer(options)
+      cpl_err = FFI::GDAL.GDALRasterBandCopyWholeRaster(@raster_band_pointer,
+        destination_pointer,
+        options_ptr,
+        progress,
+        nil)
+
+      cpl_err.to_bool
     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
+    # Reads the raster line-by-line and returns as an NArray.  Will yield each
+    # line and the line number if a block is given.
+    #
+    # @yieldparam pixel_line [Array]
+    # @yieldparam line_number [Fixnum]
+    # @return [NArray]
+    def readlines(data_type: :GDT_Byte)
       x_offset = 0
       line_size = 1
       pixel_space = 0
       line_space = 0
-      scan_line = FFI::MemoryPointer.new(:float, x_size)
+      scan_line = GDAL._pointer_from_data_type(data_type, x_size)
 
-      0.upto(y_size - 1) do |y|
-        GDALRasterIO(@gdal_raster_band,
+      the_array = 0.upto(y_size - 1).map do |y|
+        FFI::GDAL.GDALRasterIO(@raster_band_pointer,
           :GF_Read,
           x_offset,
           y,
@@ -453,8 +554,18 @@ module GDAL
           line_space
         )
 
-        yield scan_line.read_array_of_float(x_size).dup
+        line_array = if data_type == :GDT_Byte
+          scan_line.read_array_of_uint8(x_size)
+        else
+          scan_line.read_array_of_float(x_size)
+        end
+
+        yield(line_array, y) if block_given?
+
+        line_array
       end
+
+      NArray.to_na(the_array)
     end
 
     # @param pixel_array [NArray] The NArray of pixels.
@@ -474,13 +585,15 @@ module GDAL
 
       columns_to_write = x_size - x_offset
       lines_to_write = y_size - y_offset
-      scan_line = FFI::MemoryPointer.new(:float, columns_to_write)
+      scan_line = GDAL._pointer_from_data_type(data_type, 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)
+        ffi_type = GDAL._gdal_data_type_to_ffi(data_type)
+        meth = "write_array_of_#{ffi_type}".to_sym
+        scan_line.send(meth, pixels.to_a)
 
-        GDALRasterIO(@gdal_raster_band,
+        FFI::GDAL.GDALRasterIO(@raster_band_pointer,
           :GF_Write,
           x_offset,     # nXOff
           y,
@@ -495,7 +608,7 @@ module GDAL
         )
       end
 
-      GDALFlushRasterCache(@gdal_raster_band)
+      flush_cache
     end
 
     # Read a block of image data, more efficiently than #read.  Doesn't
@@ -507,25 +620,19 @@ module GDAL
     #   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 = FFI::GDAL.GDALReadBlock(@raster_band_pointer, x_offset, y_offset, image_buffer)
 
-      result = GDALReadBlock(@gdal_raster_band, x_offset, y_offset, image_buffer)
-
-      if result == :none
-      elsif result == :failure
-
-      end
+      result.to_bool
     end
 
     # The minimum and maximum values for this band.
     #
     # @return [Array{min => Float, max => Float}]
-    def compute_min_max
+    def 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)
+        FFI::GDAL.GDALComputeRasterMinMax(@raster_band_pointer, 1, min_max)
 
         [min_max[0].read_double, min_max[1].read_double]
       else
@@ -536,7 +643,7 @@ module GDAL
     # @return [Hash{value => Float, it_tight => Boolean}]
     def minimum_value
       is_tight = FFI::MemoryPointer.new(:bool)
-      value = GDALGetRasterMinimum(@gdal_raster_band, is_tight)
+      value = FFI::GDAL.GDALGetRasterMinimum(@raster_band_pointer, is_tight)
 
       { value: value, is_tight: is_tight.read_bytes(1).to_bool }
     end
@@ -544,22 +651,43 @@ module GDAL
     # @return [Hash{value => Float, it_tight => Boolean}]
     def maximum_value
       is_tight = FFI::MemoryPointer.new(:double)
-      value = GDALGetRasterMaximum(@gdal_raster_band, is_tight)
+      value = FFI::GDAL.GDALGetRasterMaximum(@raster_band_pointer, is_tight)
 
       { value: value, is_tight: is_tight.read_bytes(1).to_bool }
     end
 
-    # Iterates through all lines and builds an NArray of pixels.
+    # Creates vector polygons for all connected regions of pixels in the raster
+    # that share a common pixel value.
     #
-    # @return [NArray]
-    def to_a
-      lines = []
-
-      readlines do |line|
-        lines << line
-      end
+    # @param layer [OGR::Layer, FFI::Pointer] The layer to write the polygons
+    #   to.
+    # @param mask_band [GDAL::RasterBand, FFI::Pointer] Optional band, where all
+    #   pixels in the mask with a value other than zero will be considered
+    #   suitable for collection as polygons.
+    # @param pixel_value_field [Fixnum] Index of the feature attribute into
+    #   which the pixel value of the polygon should be written.
+    # @param options [Hash]
+    # @param progress [Proc]
+    # @return [OGR::Layer]
+    def polygonize(layer, mask_band: nil, pixel_value_field: -1, **options, &progress)
+      mask_band_ptr = GDAL._pointer(GDAL::RasterBand, mask_band, false)
+
+      layer_ptr = GDAL._pointer(OGR::Layer, layer)
+      raise "Invalid layer: #{layer.inspect}" if layer_ptr.null?
+
+      options_ptr = GDAL::Options.pointer(options)
+
+      cpl_err = FFI::GDAL.GDALFPolygonize(@raster_band_pointer,    # hSrcBand
+        mask_band_ptr,                                  # hMaskBand
+        layer_ptr,                                      # hOutLayer
+        pixel_value_field,                              # iPixValField
+        options_ptr,                                    # papszOptions
+        progress,                                      # pfnProgress
+        nil                                             # pProgressArg
+      )
+      cpl_err.to_ruby
 
-      NArray.to_na(lines)
+      OGR::Layer.new(layer_ptr)
     end
 
     #---------------------------------------------------------------------------
@@ -568,7 +696,7 @@ module GDAL
 
     private
 
-    def formated_buckets(cpl_err, min, max, buckets, totals)
+    def formatted_buckets(cpl_err, min, max, buckets, totals)
       case cpl_err.to_ruby
       when :none
         {
@@ -579,8 +707,8 @@ module GDAL
         }
       when :warning then return nil
       when :failure then raise CPLError
+      else raise CPLError
       end
     end
-
   end
 end