ffi-gdal 1.0.0.beta5 → 1.0.0.beta6

data/lib/gdal/dataset.rb

@@ -1,16 +1,11 @@
 require 'uri'
-require_relative '../ffi/gdal'
-require_relative '../ffi/cpl/string'
-require_relative '../ogr/spatial_reference'
-require_relative 'driver'
-require_relative 'geo_transform'
-require_relative 'raster_band'
-require_relative 'exceptions'
+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 'options'
+require_relative 'dataset_mixins/warp_methods'
 
 module GDAL
   # A set of associated raster bands and info common to them all.  It's also
@@ -21,18 +16,29 @@ module GDAL
     include DatasetMixins::Extensions
     include DatasetMixins::Matching
     include DatasetMixins::AlgorithmMethods
+    include DatasetMixins::WarpMethods
     include GDAL::Logger
 
     ACCESS_FLAGS = {
       'r' => :GA_ReadOnly,
       'w' => :GA_Update
-    }
+    }.freeze
 
     # @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)
-      new(path, access_flag)
+    # @param shared_open [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)
+
+      if block_given?
+        result = yield ds
+        ds.close
+        result
+      else
+        ds
+      end
     end
 
     #---------------------------------------------------------------------------
@@ -47,7 +53,9 @@ module GDAL
     #   contains the dataset or a pointer to the dataset. If it's a path, it can
     #   be a local file or a URL.
     # @param access_flag [String] 'r' or 'w'.
-    def initialize(path_or_pointer, access_flag)
+    # @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)
       @c_pointer =
         if path_or_pointer.is_a? String
           file_path = begin
@@ -57,15 +65,19 @@ module GDAL
             path_or_pointer
           end
 
-          FFI::GDAL.GDALOpen(file_path, ACCESS_FLAGS[access_flag])
+          if shared_open
+            FFI::GDAL::GDAL.GDALOpenShared(file_path, ACCESS_FLAGS[access_flag])
+          else
+            FFI::GDAL::GDAL.GDALOpen(file_path, ACCESS_FLAGS[access_flag])
+          end
         else
           path_or_pointer
         end
 
-      fail OpenFailure, path_or_pointer if @c_pointer.null?
-      ObjectSpace.define_finalizer self, -> { close }
+      raise OpenFailure, path_or_pointer if @c_pointer.null?
 
       @geo_transform = nil
+      @spatial_reference = nil
       @raster_bands = Array.new(raster_count)
     end
 
@@ -73,23 +85,21 @@ module GDAL
     def close
       return unless @c_pointer
 
-      FFI::GDAL.GDALClose(@c_pointer)
+      FFI::GDAL::GDAL.GDALClose(@c_pointer)
       @c_pointer = nil
     end
 
     # @return [Symbol]
     def access_flag
-      return nil if null?
-
-      flag = FFI::GDAL.GDALGetAccess(@c_pointer)
+      flag = FFI::GDAL::GDAL.GDALGetAccess(@c_pointer)
 
-      FFI::GDAL::Access[flag]
+      FFI::GDAL::GDAL::Access[flag]
     end
 
     # @return [GDAL::Driver] The driver to be used for working with this
     #   dataset.
     def driver
-      driver_ptr = FFI::GDAL.GDALGetDatasetDriver(@c_pointer)
+      driver_ptr = FFI::GDAL::GDAL.GDALGetDatasetDriver(@c_pointer)
 
       Driver.new(driver_ptr)
     end
@@ -97,7 +107,7 @@ module GDAL
     # Fetches all files that form the dataset.
     # @return [Array<String>]
     def file_list
-      list_pointer = FFI::GDAL.GDALGetFileList(@c_pointer)
+      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)
@@ -107,69 +117,71 @@ module GDAL
 
     # Flushes all write-cached data to disk.
     def flush_cache
-      FFI::GDAL.GDALFlushCache(@c_pointer)
+      FFI::GDAL::GDAL.GDALFlushCache(@c_pointer)
     end
 
     # @return [Fixnum]
     def raster_x_size
       return nil if null?
 
-      FFI::GDAL.GDALGetRasterXSize(@c_pointer)
+      FFI::GDAL::GDAL.GDALGetRasterXSize(@c_pointer)
     end
 
     # @return [Fixnum]
     def raster_y_size
       return nil if null?
 
-      FFI::GDAL.GDALGetRasterYSize(@c_pointer)
+      FFI::GDAL::GDAL.GDALGetRasterYSize(@c_pointer)
     end
 
     # @return [Fixnum]
     def raster_count
       return 0 if null?
 
-      FFI::GDAL.GDALGetRasterCount(@c_pointer)
+      FFI::GDAL::GDAL.GDALGetRasterCount(@c_pointer)
     end
 
     # @param raster_index [Fixnum]
     # @return [GDAL::RasterBand]
     def raster_band(raster_index)
       if raster_index > raster_count
-        fail GDAL::InvalidRasterBand, "Invalid raster band number '#{raster_index}'. Must be <= #{raster_count}"
+        raise GDAL::InvalidRasterBand, "Invalid raster band number '#{raster_index}'. Must be <= #{raster_count}"
       end
 
-      raster_band_ptr = FFI::GDAL.GDALGetRasterBand(@c_pointer, raster_index)
+      raster_band_ptr = FFI::GDAL::GDAL.GDALGetRasterBand(@c_pointer, raster_index)
 
       GDAL::RasterBand.new(raster_band_ptr)
     end
 
-    # @param type [FFI::GDAL::DataType]
+    # @param type [FFI::GDAL::GDAL::DataType]
     # @param options [Hash]
     # @return [GDAL::RasterBand, nil]
     def add_band(type, **options)
       options_ptr = GDAL::Options.pointer(options)
-      FFI::GDAL.GDALAddBand(@c_pointer, type, options_ptr)
+      FFI::GDAL::GDAL.GDALAddBand(@c_pointer, type, options_ptr)
 
       raster_band(raster_count)
     end
 
     # Adds a mask band to the dataset.
     #
-    # @param flags [Fixnum] Any of of the GDAL::RasterBand flags.
+    # @param flags [Array<Symbol>, Symbol] Any of the :GMF symbols.
     # @return [Boolean]
-    def create_mask_band(flags)
-      !!FFI::GDAL.GDALCreateDatasetMaskBand(@c_pointer, flags)
+    def create_mask_band(*flags)
+      flag_value = parse_mask_flag_symbols(flags)
+
+      !!FFI::GDAL::GDAL.GDALCreateDatasetMaskBand(@c_pointer, flag_value)
     end
 
     # @return [String]
     def projection
-      FFI::GDAL.GDALGetProjectionRef(@c_pointer) || ''
+      FFI::GDAL::GDAL.GDALGetProjectionRef(@c_pointer) || ''
     end
 
     # @param new_projection [String]
     # @return [Boolean]
     def projection=(new_projection)
-      FFI::GDAL.GDALSetProjection(@c_pointer, new_projection.to_s)
+      FFI::GDAL::GDAL.GDALSetProjection(@c_pointer, new_projection.to_s)
     end
 
     # @return [GDAL::GeoTransform]
@@ -177,39 +189,40 @@ module GDAL
       return @geo_transform if @geo_transform
 
       geo_transform_pointer = GDAL::GeoTransform.new_pointer
-      FFI::GDAL.GDALGetGeoTransform(@c_pointer, geo_transform_pointer)
+      geo_transform_pointer.autorelease = false
+      FFI::GDAL::GDAL.GDALGetGeoTransform(@c_pointer, geo_transform_pointer)
 
       @geo_transform = GeoTransform.new(geo_transform_pointer)
     end
 
-    # @param new_transform [GDAL::GeoTransform]
+    # @param new_transform [GDAL::GeoTransform, FFI::Pointer]
     # @return [GDAL::GeoTransform]
     def geo_transform=(new_transform)
       new_pointer = GDAL._pointer(GDAL::GeoTransform, new_transform)
-      FFI::GDAL.GDALSetGeoTransform(@c_pointer, new_pointer)
+      FFI::GDAL::GDAL.GDALSetGeoTransform(@c_pointer, new_pointer)
 
-      @geo_transform = GeoTransform.new(new_pointer)
+      @geo_transform = new_transform.is_a?(FFI::Pointer) ? GeoTransform.new(new_pointer) : new_transform
     end
 
     # @return [Fixnum]
     def gcp_count
       return 0 if null?
 
-      FFI::GDAL.GDALGetGCPCount(@c_pointer)
+      FFI::GDAL::GDAL.GDALGetGCPCount(@c_pointer)
     end
 
     # @return [String]
     def gcp_projection
       return '' if null?
 
-      FFI::GDAL.GDALGetGCPProjection(@c_pointer)
+      FFI::GDAL::GDAL.GDALGetGCPProjection(@c_pointer)
     end
 
     # @return [FFI::GDAL::GCP]
     def gcps
       return FFI::GDAL::GCP.new if null?
 
-      gcp_array_pointer = FFI::GDAL.GDALGetGCPs(@c_pointer)
+      gcp_array_pointer = FFI::GDAL::GDAL.GDALGetGCPs(@c_pointer)
 
       if gcp_array_pointer.null?
         FFI::GDAL::GCP.new
@@ -218,26 +231,20 @@ module GDAL
       end
     end
 
-    # @return [Fixnum]
-    def layer_count
-      fail GDAL::UnsupportedOperation unless GDAL._supported?(:GDALDatasetGetLayerCount)
-
-      FFI::GDAL.GDALDatasetGetLayerCount(@c_pointer)
-    end
-
     # @param resampling [String, Symbol] One of:
-    #   * :nearest
-    #   * :gauss
-    #   * :cubic
-    #   * :average
-    #   * :mode
-    #   * :average_magphase
+    #   * :nearest          - Nearest neighbor resampling
+    #   * :gauss            - Gaussian kernel resampling
+    #   * :cubic            - Cubic convolution resampling
+    #   * :average          - Average of all non-NODATA
+    #   * :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
     #   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)
+    # @see http://www.gdal.org/gdaladdo.html
+    def build_overviews(resampling, overview_levels, band_numbers: nil, &progress)
       resampling_string = if resampling.is_a? String
                             resampling.upcase
                           elsif resampling.is_a? Symbol
@@ -246,17 +253,9 @@ module GDAL
 
       overview_levels_ptr = FFI::MemoryPointer.new(:int, overview_levels.size)
       overview_levels_ptr.write_array_of_int(overview_levels)
+      band_numbers_ptr, band_count = 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 = nil
-      end
-
-      !!FFI::GDAL.GDALBuildOverviews(
+      !!FFI::GDAL::GDAL.GDALBuildOverviews(
         @c_pointer,
         resampling_string,
         overview_levels.size,
@@ -268,50 +267,127 @@ module GDAL
       )
     end
 
-    # @param access_flag [String] 'r' or 'w'
-    # @param data_ptr [FFI::MemoryPointer] The pointer to the data to 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 data_type [FFI::GDAL::DataType]
-    # @param band_count [Fixnum] The number of bands to create in the raster.
-    # @param pixel_space
-    def raster_io(access_flag, data_ptr,
-                  x_size: nil,
-                  y_size: nil,
-                  x_offset: 0,
-                  y_offset: 0,
-                  data_type: :GDT_Byte,
-                  band_count: 1,
-                  pixel_space: 0,
-                  line_space: 0,
-                  band_space: 0
-                 )
-
+    # @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,
+    #   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
+    #   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
+    #   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
+    #   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
+    #   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
+    #   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
+    #   data to the start of the next. If defaulted (0), the size of
+    #   +line_space+ * +buffer_y_size* is used.
+    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,
+      band_numbers: nil,
+      pixel_space: 0, line_space: 0, band_space: 0)
       x_size ||= raster_x_size
       y_size ||= raster_y_size
+      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?
+
+      buffer ||= GDAL._pointer_from_data_type(buffer_data_type, buffer_x_size * buffer_y_size * band_count)
 
       gdal_access_flag = GDAL._gdal_access_flag(access_flag)
-      x_buffer_size = x_size
-      y_buffer_size = y_size
 
-      !!FFI::GDAL::GDALDatasetRasterIO(
+      min_buffer_size = valid_min_buffer_size(buffer_data_type, buffer_x_size, buffer_y_size)
+
+      unless buffer.size >= min_buffer_size
+        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
-        data_ptr,                       # pData
-        x_buffer_size,                  # nBufXSize
-        y_buffer_size,                  # nBufYSize
-        data_type,                      # eBufType
+        buffer,                         # pData
+        buffer_x_size,                  # nBufXSize
+        buffer_y_size,                  # nBufYSize
+        buffer_data_type,               # eBufType
         band_count,                     # nBandCount
-        nil,                            # panBandMap (WTH is this?)
+        band_numbers_ptr,               # panBandMap (WTH is this?)
         pixel_space,                    # nPixelSpace
         line_space,                     # nLineSpace
         band_space                      # nBandSpace
       )
+
+      buffer
+    end
+
+    private
+
+    # Lets you pass in :GMF_ symbols that represent mask band flags and bitwise
+    # ors them.
+    #
+    # @param flags [Symbol]
+    # @return [Fixnum]
+    def parse_mask_flag_symbols(*flags)
+      flags.reduce(0) do |result, flag|
+        result |= case flag
+                  when :GMF_ALL_VALID then 0x01
+                  when :GMF_PER_DATASET then 0x02
+                  when :GMF_PER_ALPHA then 0x04
+                  when :GMF_NODATA then 0x08
+                  else 0
+                  end
+      end
+    end
+
+    # @param buffer_data_type [FFI::GDAL::GDAL::DataType]
+    # @param x_buffer_size [Fixnum]
+    # @param y_buffer_size [Fixnum]
+    # @return [Fixnum]
+    def valid_min_buffer_size(buffer_data_type, x_buffer_size, y_buffer_size)
+      data_type_bytes = GDAL::DataType.size(buffer_data_type) / 8
+
+      data_type_bytes * x_buffer_size * y_buffer_size
+    end
+
+    # Makes a pointer of +band_numbers+.
+    #
+    # @param band_numbers [Array<Fixnum>]
+    # @return [Array<FFI::Pointer, Fixnum>]
+    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_numbers_ptr, band_count]
     end
   end
 end

data/lib/gdal/dataset_mixins/algorithm_methods.rb

@@ -1,5 +1,6 @@
 module GDAL
   module DatasetMixins
+    # Wrappers for Warp algorithm methods defined in gdal_alg.h.
     module AlgorithmMethods
       # Rasterizes the geometric objects +geometries+ into this raster dataset.
       # +transformer+ can be nil as long as the +geometries+ are within the
@@ -22,7 +23,7 @@ module GDAL
         transformer: nil, transform_arg: nil, **options, &progress_block)
 
         if geo_transform.nil? && gcp_count.zero?
-          fail "Can't rasterize geometries--no geo_transform or GCPs have been defined on the dataset."
+          raise "Can't rasterize geometries--no geo_transform or GCPs have been defined on the dataset."
         end
 
         gdal_options = GDAL::Options.pointer(options)
@@ -39,7 +40,7 @@ module GDAL
         burn_values_ptr = FFI::MemoryPointer.new(:pointer, burn_values.size)
         burn_values_ptr.write_array_of_double(burn_values)
 
-        FFI::GDAL.GDALRasterizeGeometries(@c_pointer,
+        FFI::GDAL::GDAL.GDALRasterizeGeometries(@c_pointer,
           band_numbers.size,
           band_numbers_ptr,
           geometries.size,
@@ -93,7 +94,7 @@ module GDAL
         burn_values_ptr.write_array_of_double(burn_values)
         log "burn value ptr null? #{burn_values_ptr.null?}"
 
-        FFI::GDAL.GDALRasterizeLayers(@c_pointer,     # hDS
+        FFI::GDAL::GDAL.GDALRasterizeLayers(@c_pointer,     # hDS
           band_numbers.size,                                # nBandCount
           band_numbers_ptr,                                 # panBandList
           layers.size,                                      # nLayerCount
@@ -106,23 +107,21 @@ module GDAL
           nil)                                              # pProgressArg
       end
 
-      # @param destination_file [String]
-      # @param driver [String] Name of the driver to use for outputing the new
-      #   image.
-      # @param transformer [Proc]
-      # @param transformer_arg_ptr [FFI::Pointer]
-      # @param band_numbers [Fixnum, Array<Fixnum>] Raster bands to include in the
-      #   warping.  0 indicates all bands.
-      # @param options [Hash]
-      # @option options [String] init Indicates that the output dataset should be
+      # @param destination_dataset [String]
+      # @param transformer [Proc, FFI::Function]
+      # @param transformer_arg_ptr [FFI::Pointer] The pointer created from one
+      #   of the GDAL::Transformers.
+      # @param warp_options [Hash]
+      # @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
+      #   warping.  0 indicates all bands.
+      # @param progress [Proc]
       # @return [GDAL::Dataset, nil] The new dataset or nil if the warping failed.
-      def simple_image_warp(destination_file, driver, transformer,
-        transformer_arg_ptr, band_numbers = 0, **options, &progress)
-        options_ptr = GDAL::Options.pointer(options)
-        driver = GDAL::Driver.by_name(driver)
-        destination_dataset_ptr = driver.open(destination_file, 'w')
+      def simple_image_warp(destination_dataset, transformer, transformer_arg_ptr,
+        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]
         log "band numbers: #{band_numbers}"
@@ -131,7 +130,7 @@ module GDAL
         bands_ptr.write_array_of_int(band_numbers)
         log "band numbers ptr null? #{bands_ptr.null?}"
 
-        success = FFI::GDAL.GDALSimpleImageWarp(@c_pointer,
+        success = FFI::GDAL::Alg.GDALSimpleImageWarp(@c_pointer,
           destination_dataset_ptr,
           band_numbers.size,
           bands_ptr,
@@ -139,17 +138,44 @@ module GDAL
           transformer_arg_ptr,
           progress,
           nil,
-          options_ptr)
+          warp_options.c_pointer)
 
-        success ? GDAL::Dataset.new(destination_dataset_ptr) : nil
+        success ? destination_dataset : nil
       end
 
+      # @param transformer [GDAL::Transformers]
+      # @return [Hash{geo_transform: GDAL::GeoTransform, lines: Fixnum, pixels: Fixnum}]
       def suggested_warp_output(transformer)
         geo_transform = GDAL::GeoTransform.new
         pixels_ptr = FFI::MemoryPointer.new(:int)
         lines_ptr = FFI::MemoryPointer.new(:int)
+
+        FFI::GDAL::Alg.GDALSuggestedWarpOutput(
+          @c_pointer,
+          transformer.function,
+          transformer.c_pointer,
+          geo_transform.c_pointer,
+          pixels_ptr,
+          lines_ptr
+        )
+
+        {
+          geo_transform: geo_transform,
+          lines: lines_ptr.read_int,
+          pixels: pixels_ptr.read_int
+        }
+      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}]
+      def suggested_warp_output2(transformer)
+        geo_transform = GDAL::GeoTransform.new
+        pixels_ptr = FFI::MemoryPointer.new(:int)
+        lines_ptr = FFI::MemoryPointer.new(:int)
         extents_ptr = FFI::MemoryPointer.new(:double, 4)
-        options = 0     # C code says this isn't used yet.
+        options = 0 # C code says this isn't used yet.
 
         FFI::GDAL::Alg.GDALSuggestedWarpOutput2(
           @c_pointer,