ffi-gdal 1.0.0.beta16 → 1.0.0

data/lib/gdal/dataset.rb

@@ -3,7 +3,6 @@
 require_relative '../gdal'
 require_relative '../ogr'
 require_relative 'major_object'
-require_relative 'dataset_mixins/extensions'
 require_relative 'dataset_mixins/matching'
 require_relative 'dataset_mixins/algorithm_methods'
 require_relative 'dataset_mixins/warp_methods'
@@ -14,7 +13,6 @@ module GDAL
   # definition of all bands.
   class Dataset
     include MajorObject
-    include DatasetMixins::Extensions
     include DatasetMixins::Matching
     include DatasetMixins::AlgorithmMethods
     include DatasetMixins::WarpMethods
@@ -28,10 +26,10 @@ module GDAL
     # @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'.
-    # @param shared_open [Boolean] Whether or not to open using GDALOpenShared
+    # @param shared [Boolean] Whether or not to open using GDALOpenShared
     #   vs GDALOpen. Defaults to +true+.
-    def self.open(path, access_flag, shared_open = true)
-      ds = new(path, access_flag, shared_open)
+    def self.open(path, access_flag, shared: true)
+      ds = new(path, access_flag, shared_open: shared)
 
       if block_given?
         result = yield ds
@@ -42,6 +40,51 @@ module GDAL
       end
     end
 
+    # Copy all dataset raster data.
+    #
+    # This function copies the complete raster contents of one dataset to
+    # another similarly configured dataset. The source and destination dataset
+    # must have the same number of bands, and the same width and height. The
+    # bands do not have to have the same data type.
+    #
+    # This function is primarily intended to support implementation of driver
+    # specific CreateCopy() functions. It implements efficient copying, in
+    # particular "chunking" the copy in substantial blocks and, if appropriate,
+    # performing the transfer in a pixel interleaved fashion.
+    #
+    # @param source [GDAL::Dataset, FFI::Pointer]
+    # @param destination [GDAL::Dataset, FFI::Pointer]
+    # @param options [Hash]
+    # @option options interleave: 'pixel'
+    # @option options compressed: true
+    # @option options skip_holes: true
+    # @param progress_function [Proc]
+    # @raise [GDAL::Error]
+    def self.copy_whole_raster(source, destination, options = {}, progress_function = nil)
+      source_ptr = GDAL._pointer(GDAL::Dataset, source, autorelease: false)
+      dest_ptr = GDAL._pointer(GDAL::Dataset, destination, autorelease: false)
+      options_ptr = GDAL::Options.pointer(options)
+
+      GDAL::CPLErrorHandler.manually_handle('Unable to copy whole raster') do
+        FFI::GDAL::GDAL.GDALDatasetCopyWholeRaster(source_ptr, dest_ptr, options_ptr, progress_function, nil)
+      end
+    end
+
+    # @param dataset [GDAL::Dataset]
+    # @return [FFI::AutoPointer]
+    def self.new_pointer(dataset, warn_on_nil: true)
+      ptr = GDAL._pointer(GDAL::Dataset, dataset, warn_on_nil: warn_on_nil, autorelease: false)
+
+      FFI::AutoPointer.new(ptr, Dataset.method(:release))
+    end
+
+    # @param pointer [FFI::Pointer]
+    def self.release(pointer)
+      return unless pointer && !pointer.null?
+
+      FFI::GDAL::GDAL.GDALClose(pointer)
+    end
+
     #---------------------------------------------------------------------------
     # Instance methods
     #---------------------------------------------------------------------------
@@ -56,7 +99,7 @@ module GDAL
     # @param access_flag [String] 'r' or 'w'.
     # @param shared_open [Boolean] Whether or not to open using GDALOpenShared
     #   vs GDALOpen. Defaults to +true+.
-    def initialize(path_or_pointer, access_flag, shared_open = true)
+    def initialize(path_or_pointer, access_flag, shared_open: true)
       @c_pointer =
         if path_or_pointer.is_a? String
           if shared_open
@@ -77,9 +120,8 @@ module GDAL
 
     # Close the dataset.
     def close
-      return unless @c_pointer
+      Dataset.release(@c_pointer)
 
-      FFI::GDAL::GDAL.GDALClose(@c_pointer)
       @c_pointer = nil
     end
 
@@ -103,6 +145,7 @@ module GDAL
     def file_list
       list_pointer = FFI::GDAL::GDAL.GDALGetFileList(@c_pointer)
       return [] if list_pointer.null?
+
       file_list = list_pointer.get_array_of_string(0)
       FFI::CPL::String.CSLDestroy(list_pointer)
 
@@ -114,28 +157,28 @@ module GDAL
       FFI::GDAL::GDAL.GDALFlushCache(@c_pointer)
     end
 
-    # @return [Fixnum]
+    # @return [Integer]
     def raster_x_size
       return nil if null?
 
       FFI::GDAL::GDAL.GDALGetRasterXSize(@c_pointer)
     end
 
-    # @return [Fixnum]
+    # @return [Integer]
     def raster_y_size
       return nil if null?
 
       FFI::GDAL::GDAL.GDALGetRasterYSize(@c_pointer)
     end
 
-    # @return [Fixnum]
+    # @return [Integer]
     def raster_count
       return 0 if null?
 
       FFI::GDAL::GDAL.GDALGetRasterCount(@c_pointer)
     end
 
-    # @param raster_index [Fixnum]
+    # @param raster_index [Integer]
     # @return [GDAL::RasterBand]
     def raster_band(raster_index)
       if raster_index > raster_count
@@ -143,16 +186,21 @@ module GDAL
       end
 
       raster_band_ptr = FFI::GDAL::GDAL.GDALGetRasterBand(@c_pointer, raster_index)
+      raster_band_ptr.autorelease = false
 
-      GDAL::RasterBand.new(raster_band_ptr)
+      GDAL::RasterBand.new(raster_band_ptr, self)
     end
 
     # @param type [FFI::GDAL::GDAL::DataType]
     # @param options [Hash]
+    # @raise [GDAL::Error]
     # @return [GDAL::RasterBand, nil]
     def add_band(type, **options)
       options_ptr = GDAL::Options.pointer(options)
-      FFI::GDAL::GDAL.GDALAddBand(@c_pointer, type, options_ptr)
+
+      GDAL::CPLErrorHandler.manually_handle('Unable to add band') do
+        FFI::GDAL::GDAL.GDALAddBand(@c_pointer, type, options_ptr)
+      end
 
       raster_band(raster_count)
     end
@@ -160,45 +208,61 @@ module GDAL
     # Adds a mask band to the dataset.
     #
     # @param flags [Array<Symbol>, Symbol] Any of the :GMF symbols.
-    # @return [Boolean]
+    # @raise [GDAL::Error]
     def create_mask_band(*flags)
       flag_value = parse_mask_flag_symbols(flags)
 
-      !!FFI::GDAL::GDAL.GDALCreateDatasetMaskBand(@c_pointer, flag_value)
+      GDAL::CPLErrorHandler.manually_handle('Unable to create Dataset mask band') do
+        FFI::GDAL::GDAL.GDALCreateDatasetMaskBand(@c_pointer, flag_value)
+      end
     end
 
     # @return [String]
     def projection
-      FFI::GDAL::GDAL.GDALGetProjectionRef(@c_pointer) || ''
+      # Returns a pointer to an internal projection reference string. It should
+      # not be altered, freed or expected to last for long.
+      proj, ptr = FFI::GDAL::GDAL.GDALGetProjectionRef(@c_pointer)
+      ptr.autorelease = false
+
+      proj || ''
     end
 
-    # @param new_projection [String]
-    # @return [Boolean]
+    # @param new_projection [String] Should be in WKT or PROJ.4 format.
+    # @raise [GDAL::Error]
     def projection=(new_projection)
-      FFI::GDAL::GDAL.GDALSetProjection(@c_pointer, new_projection.to_s)
+      GDAL::CPLErrorHandler.manually_handle('Unable to set projection') do
+        FFI::GDAL::GDAL.GDALSetProjection(@c_pointer, new_projection.to_s)
+      end
     end
 
     # @return [GDAL::GeoTransform]
+    # @raise [GDAL::Error]
     def geo_transform
       return @geo_transform if @geo_transform
 
       geo_transform_pointer = GDAL::GeoTransform.new_pointer
-      geo_transform_pointer.autorelease = false
-      FFI::GDAL::GDAL.GDALGetGeoTransform(@c_pointer, geo_transform_pointer)
+
+      GDAL::CPLErrorHandler.manually_handle('Unable to get geo_transform') do
+        FFI::GDAL::GDAL.GDALGetGeoTransform(@c_pointer, geo_transform_pointer)
+      end
 
       @geo_transform = GeoTransform.new(geo_transform_pointer)
     end
 
     # @param new_transform [GDAL::GeoTransform, FFI::Pointer]
     # @return [GDAL::GeoTransform]
+    # @raise [GDAL::Error]
     def geo_transform=(new_transform)
       new_pointer = GDAL._pointer(GDAL::GeoTransform, new_transform)
-      FFI::GDAL::GDAL.GDALSetGeoTransform(@c_pointer, new_pointer)
+
+      GDAL::CPLErrorHandler.manually_handle('Unable to set geo_transform') do
+        FFI::GDAL::GDAL.GDALSetGeoTransform(@c_pointer, new_pointer)
+      end
 
       @geo_transform = new_transform.is_a?(FFI::Pointer) ? GeoTransform.new(new_pointer) : new_transform
     end
 
-    # @return [Fixnum]
+    # @return [Integer]
     def gcp_count
       return 0 if null?
 
@@ -209,7 +273,10 @@ module GDAL
     def gcp_projection
       return '' if null?
 
-      FFI::GDAL::GDAL.GDALGetGCPProjection(@c_pointer)
+      proj, ptr = FFI::GDAL::GDAL.GDALGetGCPProjection(@c_pointer)
+      ptr.autorelease = false
+
+      proj
     end
 
     # @return [FFI::GDAL::GCP]
@@ -233,15 +300,17 @@ module GDAL
     #   * :mode             - Selects the value that occurs most often
     #   * :average_magphase - Averages complex data in mag/phase space
     #   * :none
-    # @param overview_levels [Array<Fixnum>] The list of overview decimation
+    # @param overview_levels [Array<Integer>] The list of overview decimation
     #   factors to build.
-    # @param band_numbers [Array<Fixnum>] The numbers of the bands to build
+    # @param band_numbers [Array<Integer>] The numbers of the bands to build
     #   overviews from.
     # @see http://www.gdal.org/gdaladdo.html
+    # @raise [GDAL::Error]
     def build_overviews(resampling, overview_levels, band_numbers: nil, &progress)
-      resampling_string = if resampling.is_a? String
+      resampling_string = case resampling
+                          when String
                             resampling.upcase
-                          elsif resampling.is_a? Symbol
+                          when Symbol
                             resampling.to_s.upcase
                           end
 
@@ -249,52 +318,57 @@ module GDAL
       overview_levels_ptr.write_array_of_int(overview_levels)
       band_numbers_ptr, band_count = band_numbers_args(band_numbers)
 
-      !!FFI::GDAL::GDAL.GDALBuildOverviews(
-        @c_pointer,
-        resampling_string,
-        overview_levels.size,
-        overview_levels_ptr,
-        band_count,
-        band_numbers_ptr,
-        progress,
-        nil
-      )
+      GDAL::CPLErrorHandler.manually_handle('Unable to build overviews') do
+        FFI::GDAL::GDAL.GDALBuildOverviews(
+          @c_pointer,
+          resampling_string,
+          overview_levels.size,
+          overview_levels_ptr,
+          band_count,
+          band_numbers_ptr,
+          progress,
+          nil
+        )
+      end
     end
 
     # @param access_flag [String] 'r' or 'w'.
     # @param buffer [FFI::MemoryPointer] The pointer to the data to read/write
     #   to the dataset.
-    # @param x_size [Fixnum] If not given, uses {{#raster_x_size}}.
-    # @param y_size [Fixnum] If not given, uses {{#raster_y_size}}.
-    # @param x_offset [Fixnum] The pixel number in the line to start operating
-    #   on. Note that when using this, {#x_size} - +x_offset+ should be >= 0,
+    # @param x_size [Integer] If not given, uses {{#raster_x_size}}.
+    # @param y_size [Integer] If not given, uses {{#raster_y_size}}.
+    # @param x_offset [Integer] The pixel number in the line to start operating
+    #   on. Note that when using this, +x_size+ - +x_offset+ should be >= 0,
     #   otherwise this means you're telling the method to read past the end of
     #   the line. Defaults to 0.
-    # @param y_offset [Fixnum] The line number to start operating on. Note that
-    #   when using this, {#y_size} - +y_offset+ should be >= 0, otherwise this
+    # @param y_offset [Integer] The line number to start operating on. Note that
+    #   when using this, +y_size+ - +y_offset+ should be >= 0, otherwise this
     #   means you're telling the method to read more lines than the raster has.
     #   Defaults to 0.
-    # @param buffer_x_size [Fixnum] The width of the buffer image in which to
+    # @param buffer_x_size [Integer] The width of the buffer image in which to
     #   read/write the raster data into/from. Typically this should be the same
     #   size as +x_size+; if it's different, GDAL will resample accordingly.
-    # @param buffer_y_size [Fixnum] The height of the buffer image in which to
+    # @param buffer_y_size [Integer] The height of the buffer image in which to
     #   read/write the raster data into/from. Typically this should be the same
     #   size as +y_size+; if it's different, GDAL will resample accordingly.
     # @param buffer_data_type [FFI::GDAL::GDAL::DataType] Can be used to convert the
     #   data to a different type. You must account for this when reading/writing
     #   to/from your buffer--your buffer size must be +buffer_x_size+ *
     #   +buffer_y_size+.
-    # @param band_numbers [Array<Fixnum>] The numbers of the bands to do IO on.
-    # @param pixel_space [Fixnum] The byte offset from the start of one pixel
+    # @param band_numbers [Array<Integer>] The numbers of the bands to do IO on.
+    #   Pass +nil+ defaults to choose the first band.
+    # @param pixel_space [Integer] The byte offset from the start of one pixel
     #   value in the buffer to the start of the next pixel value within a line.
     #   If defaulted (0), the size of +buffer_data_type+ is used.
-    # @param line_space [Fixnum] The byte offset from the start of one line in
+    # @param line_space [Integer] The byte offset from the start of one line in
     #   the buffer to the start of the next. If defaulted (0), the size of
     #   +buffer_data_type+ * +buffer_x_size* is used.
-    # @param band_space [Fixnum] The byte offset from the start of one band's
+    # @param band_space [Integer] The byte offset from the start of one band's
     #   data to the start of the next. If defaulted (0), the size of
     #   +line_space+ * +buffer_y_size* is used.
-    # rubocop:disable: Metrics/MethodLength
+    # @return [FFI::MemoryPointer] The buffer that was passed in.
+    # @raise [GDAL::Error] On failure.
+    # rubocop:disable Metrics/ParameterLists
     def raster_io(access_flag, buffer = nil,
       x_size: nil, y_size: nil, x_offset: 0, y_offset: 0,
       buffer_x_size: nil, buffer_y_size: nil, buffer_data_type: nil,
@@ -305,6 +379,7 @@ module GDAL
       buffer_x_size ||= x_size
       buffer_y_size ||= y_size
       buffer_data_type ||= raster_band(1).data_type
+
       band_numbers_ptr, band_count = band_numbers_args(band_numbers)
       band_count = raster_count if band_count.zero?
 
@@ -318,27 +393,40 @@ module GDAL
         raise GDAL::BufferTooSmall, "Buffer size (#{buffer.size}) too small (#{min_buffer_size})"
       end
 
-      FFI::GDAL::GDAL::GDALDatasetRasterIO(
-        @c_pointer,                     # hDS
-        gdal_access_flag,               # eRWFlag
-        x_offset,                       # nXOff
-        y_offset,                       # nYOff
-        x_size,                         # nXSize
-        y_size,                         # nYSize
-        buffer,                         # pData
-        buffer_x_size,                  # nBufXSize
-        buffer_y_size,                  # nBufYSize
-        buffer_data_type,               # eBufType
-        band_count,                     # nBandCount
-        band_numbers_ptr,               # panBandMap (WTH is this?)
-        pixel_space,                    # nPixelSpace
-        line_space,                     # nLineSpace
-        band_space                      # nBandSpace
-      )
+      GDAL::CPLErrorHandler.manually_handle('Unable to perform raster band IO') do
+        FFI::GDAL::GDAL::GDALDatasetRasterIO(
+          @c_pointer,                     # hDS
+          gdal_access_flag,               # eRWFlag
+          x_offset,                       # nXOff
+          y_offset,                       # nYOff
+          x_size,                         # nXSize
+          y_size,                         # nYSize
+          buffer,                         # pData
+          buffer_x_size,                  # nBufXSize
+          buffer_y_size,                  # nBufYSize
+          buffer_data_type,               # eBufType
+          band_count,                     # nBandCount
+          band_numbers_ptr,               # panBandMap (WTH is this?)
+          pixel_space,                    # nPixelSpace
+          line_space,                     # nLineSpace
+          band_space                      # nBandSpace
+        )
+      end
 
       buffer
     end
-    # rubocop:enable: Metrics/MethodLength
+    # rubocop:enable Metrics/ParameterLists
+
+    # Creates a OGR::SpatialReference object from the dataset's projection.
+    #
+    # @return [OGR::SpatialReference]
+    def spatial_reference
+      return @spatial_reference if @spatial_reference
+
+      return nil if projection.empty?
+
+      @spatial_reference = OGR::SpatialReference.new(projection)
+    end
 
     private
 
@@ -346,7 +434,7 @@ module GDAL
     # ors them.
     #
     # @param flags [Symbol]
-    # @return [Fixnum]
+    # @return [Integer]
     def parse_mask_flag_symbols(*flags)
       flags.reduce(0) do |result, flag|
         result | case flag
@@ -360,9 +448,9 @@ module GDAL
     end
 
     # @param buffer_data_type [FFI::GDAL::GDAL::DataType]
-    # @param x_buffer_size [Fixnum]
-    # @param y_buffer_size [Fixnum]
-    # @return [Fixnum]
+    # @param x_buffer_size [Integer]
+    # @param y_buffer_size [Integer]
+    # @return [Integer]
     def valid_min_buffer_size(buffer_data_type, x_buffer_size, y_buffer_size)
       data_type_bytes = GDAL::DataType.size(buffer_data_type) / 8
 
@@ -371,19 +459,17 @@ module GDAL
 
     # Makes a pointer of +band_numbers+.
     #
-    # @param band_numbers [Array<Fixnum>]
-    # @return [Array<FFI::Pointer, Fixnum>]
+    # @param band_numbers [Array<Integer>]
+    # @return [Array<FFI::MemoryPointer, Integer>]
     def band_numbers_args(band_numbers)
-      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 = 0
-      end
+      band_count = band_numbers&.size || 0
+      ptr = FFI::MemoryPointer.new(:int, band_count)
+
+      ptr.write_array_of_int(band_numbers) if band_numbers
+
+      ptr.autorelease = false
 
-      [band_numbers_ptr, band_count]
+      [ptr, band_count]
     end
   end
 end

data/lib/gdal/dataset_mixins/algorithm_methods.rb

@@ -8,7 +8,7 @@ module GDAL
       # +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 band_numbers [Array<Integer>, Integer]
       # @param geometries [Array<OGR::Geometry>, OGR::Geometry]
       # @param burn_values [Array<Float>, Float]
       # @param transformer [Proc]
@@ -29,9 +29,9 @@ module GDAL
         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 = Array(band_numbers)
+        geometries = Array(geometries)
+        burn_values = Array(burn_values)
 
         band_numbers_ptr = FFI::MemoryPointer.new(:pointer, band_numbers.size)
         band_numbers_ptr.write_array_of_int(band_numbers)
@@ -43,26 +43,26 @@ module GDAL
         burn_values_ptr.write_array_of_double(burn_values)
 
         FFI::GDAL::Alg.GDALRasterizeGeometries(@c_pointer,
-          band_numbers.size,
-          band_numbers_ptr,
-          geometries.size,
-          geometries_ptr,
-          transformer,
-          transform_arg,
-          burn_values_ptr,
-          gdal_options,
-          progress_block,
-          nil)
+                                               band_numbers.size,
+                                               band_numbers_ptr,
+                                               geometries.size,
+                                               geometries_ptr,
+                                               transformer,
+                                               transform_arg,
+                                               burn_values_ptr,
+                                               gdal_options,
+                                               progress_block,
+                                               nil)
       end
 
-      # @param band_numbers [Array<Fixnum>, Fixnum]
+      # @param band_numbers [Array<Integer>, Integer]
       # @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
+      # @option options chunkysize [Integer] 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
@@ -75,13 +75,13 @@ module GDAL
       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]
+        band_numbers = Array(band_numbers)
         log "band numbers: #{band_numbers}"
 
-        layers = layers.is_a?(Array) ? layers : [layers]
+        layers = Array(layers)
         log "layers: #{layers}"
 
-        burn_values = burn_values.is_a?(Array) ? burn_values : [burn_values]
+        burn_values = Array(burn_values)
         log "burn values: #{burn_values}"
 
         band_numbers_ptr = FFI::MemoryPointer.new(:pointer, band_numbers.size)
@@ -96,17 +96,17 @@ module GDAL
         burn_values_ptr.write_array_of_double(burn_values)
         log "burn value ptr null? #{burn_values_ptr.null?}"
 
-        FFI::GDAL::Alg.GDALRasterizeLayers(@c_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
+        FFI::GDAL::Alg.GDALRasterizeLayers(@c_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
       end
 
       # @param destination_dataset [String]
@@ -117,7 +117,7 @@ module GDAL
       # @option warp_options [String] init Indicates that the output dataset should be
       #   initialized to the given value in any area where valid data isn't
       #   written.  In form: "v[,v...]"
-      # @param band_numbers [Fixnum, Array<Fixnum>] Raster bands to include in the
+      # @param band_numbers [Integer, Array<Integer>] Raster bands to include in the
       #   warping.  0 indicates all bands.
       # @param progress [Proc]
       # @return [GDAL::Dataset, nil] The new dataset or nil if the warping failed.
@@ -125,7 +125,7 @@ module GDAL
         warp_options, band_numbers = 0, progress = nil)
         destination_dataset_ptr = destination_dataset.c_pointer
 
-        band_numbers = band_numbers.is_a?(Array) ? band_numbers : [band_numbers]
+        band_numbers = Array(band_numbers)
         log "band numbers: #{band_numbers}"
 
         bands_ptr = FFI::MemoryPointer.new(:pointer, band_numbers.size)
@@ -133,20 +133,20 @@ module GDAL
         log "band numbers ptr null? #{bands_ptr.null?}"
 
         success = FFI::GDAL::Alg.GDALSimpleImageWarp(@c_pointer,
-          destination_dataset_ptr,
-          band_numbers.size,
-          bands_ptr,
-          transformer,
-          transformer_arg_ptr,
-          progress,
-          nil,
-          warp_options.c_pointer)
+                                                     destination_dataset_ptr,
+                                                     band_numbers.size,
+                                                     bands_ptr,
+                                                     transformer,
+                                                     transformer_arg_ptr,
+                                                     progress,
+                                                     nil,
+                                                     warp_options.c_pointer)
 
         success ? destination_dataset : nil
       end
 
       # @param transformer [GDAL::Transformers]
-      # @return [Hash{geo_transform: GDAL::GeoTransform, lines: Fixnum, pixels: Fixnum}]
+      # @return [Hash{geo_transform: GDAL::GeoTransform, lines: Integer, pixels: Integer}]
       def suggested_warp_output(transformer)
         geo_transform = GDAL::GeoTransform.new
         pixels_ptr = FFI::MemoryPointer.new(:int)
@@ -169,9 +169,9 @@ module GDAL
       end
 
       # @param transformer [GDAL::Transformers]
-      # @return [Hash{extents: Hash{ min_x: Fixnum, min_y: Fixnum, max_x: Fixnum,
-      #   max_y: Fixnum }, geo_transform: GDAL::GeoTransform, lines: Fixnum,
-      #   pixels: Fixnum}]
+      # @return [Hash{extents: Hash{ min_x: Integer, min_y: Integer, max_x: Integer,
+      #   max_y: Integer }, geo_transform: GDAL::GeoTransform, lines: Integer,
+      #   pixels: Integer}]
       def suggested_warp_output2(transformer)
         geo_transform = GDAL::GeoTransform.new
         pixels_ptr = FFI::MemoryPointer.new(:int)

data/lib/gdal/dataset_mixins/matching.rb

@@ -5,7 +5,7 @@ module GDAL
     module Matching
       # @param other_dataset [GDAL::Dataset]
       # @param options [Hash]
-      # @return [Hash{count => Fixnum, gcp: => FFI::GDAL::GCP}] Not sure why,
+      # @return [Hash{count => Integer, gcp: => FFI::GDAL::GCP}] Not sure why,
       #   but the C function seems to return a single GCP instead of an Array of
       #   them.
       def compute_matching_points(other_dataset, **options)