ffi-gdal 1.0.0.beta5 → 1.0.0.beta6

data/lib/gdal/dataset_mixins/extensions.rb

@@ -39,8 +39,8 @@ module GDAL
         output_data_type: nil, remove_negatives: false, no_data_value: -9999.0, **options)
         red = raster_band(red_band_number)
         nir = raster_band(nir_band_number)
-        fail RequiredBandNotFound, 'Red band not found.' if red.nil?
-        fail RequiredBandNotFound, 'Near-infrared' if nir.nil?
+        raise RequiredBandNotFound, 'Red band not found.' if red.nil?
+        raise RequiredBandNotFound, 'Near-infrared' if nir.nil?
 
         output_data_type ||= red.data_type
         the_array = calculate_ndvi(red.to_na, nir.to_na, no_data_value, remove_negatives, output_data_type)
@@ -52,7 +52,7 @@ module GDAL
           ndvi_dataset.projection = projection
 
           ndvi_band = ndvi_dataset.raster_band(1)
-          ndvi_band.write_array(the_array)
+          ndvi_band.write_xy_narray(the_array)
           ndvi_band.no_data_value = no_data_value
         end
 
@@ -78,7 +78,7 @@ module GDAL
       #   this object or the data may not persist!*
       def extract_nir(destination, band_number, driver_name: 'GTiff', output_data_type: nil, **options)
         original_nir_band = raster_band(band_number)
-        fail InvalidBandNumber, "Band #{band_number} found but was nil." if original_nir_band.nil?
+        raise InvalidBandNumber, "Band #{band_number} found but was nil." if original_nir_band.nil?
 
         output_data_type ||= original_nir_band.data_type
         driver = GDAL::Driver.by_name(driver_name)
@@ -164,7 +164,7 @@ module GDAL
         final_array = case output_data_type
                       when :GDT_Byte then calculate_ndvi_byte(ndvi)
                       when :GDT_UInt16 then calculate_ndvi_uint16(ndvi)
-                      else ndvi        # Already in Float32
+                      else ndvi # Already in Float32
                       end
 
         remove_negatives ? remove_negatives_from(final_array, no_data_value) : final_array
@@ -271,11 +271,16 @@ module GDAL
           spatial_ref = nil
         else
           spatial_ref = OGR::SpatialReference.new(projection)
-          spatial_ref.auto_identify_epsg! rescue OGR::UnsupportedSRS
+          begin
+            spatial_ref.auto_identify_epsg!
+          rescue
+            OGR::UnsupportedSRS
+          end
         end
 
         data_source = ogr_driver.create_data_source(file_name)
 
+        # TODO: fasterer: each_with_index is slower than loop
         band_numbers.each_with_index do |band_number, i|
           log "Starting to polygonize raster band #{band_number}..."
           layer_name = "#{layer_name_prefix}-#{band_number}"
@@ -287,12 +292,12 @@ module GDAL
           band = raster_band(band_number)
 
           unless band
-            fail GDAL::InvalidBandNumber, "Unknown band number: #{band_number}"
+            raise GDAL::InvalidBandNumber, "Unknown band number: #{band_number}"
           end
 
           pixel_value_field = layer.feature_definition.field_index(field_name)
           options = { pixel_value_field: pixel_value_field }
-          options.merge!(mask_band: band.mask_band) if use_band_masks
+          options[:mask_band] = band.mask_band if use_band_masks
           band.polygonize(layer, options)
         end
 
@@ -307,10 +312,26 @@ module GDAL
       # Gets the OGR::Geometry that represents the extent of the dataset.
       #
       # @return [OGR::Polygon]
+      # TODO: This should return an OGR::Envelope.
       def extent
-        raster_data_source = to_vector('memory data source', 'Memory', geometry_type: :wkbLinearRing)
-
-        raster_data_source.layer(0).geometry_from_extent
+        ul = geo_transform.apply_geo_transform(0, 0)
+        ur = geo_transform.apply_geo_transform(raster_x_size, 0)
+        lr = geo_transform.apply_geo_transform(raster_x_size, raster_y_size)
+        ll = geo_transform.apply_geo_transform(0, raster_y_size)
+
+        ring = OGR::LinearRing.new
+        ring.point_count = 5
+        ring.set_point(0, ul[:x_geo], ul[:y_geo])
+        ring.set_point(1, ur[:x_geo], ur[:y_geo])
+        ring.set_point(2, lr[:x_geo], lr[:y_geo])
+        ring.set_point(3, ll[:x_geo], ll[:y_geo])
+        ring.set_point(4, ul[:x_geo], ul[:y_geo])
+
+        polygon = OGR::Polygon.new
+        polygon.add_geometry(ring)
+        polygon.spatial_reference = spatial_reference
+
+        polygon
       end
 
       # @param wkt_geometry_string [String]
@@ -328,56 +349,6 @@ module GDAL
         @raster_geometry.contains? source_geometry
       end
 
-      def image_warp(destination_file, driver, band_numbers, **warp_options)
-        fail NotImplementedError, '#image_warp not yet implemented.'
-
-        _options_ptr = GDAL::Options.pointer(warp_options)
-        driver = GDAL::Driver.by_name(driver)
-        destination_dataset = driver.create_dataset(destination_file, raster_x_size, raster_y_size)
-
-        band_numbers = band_numbers.is_a?(Array) ? band_numbers : [band_numbers]
-        log "band numbers: #{band_numbers}"
-
-        bands_ptr = FFI::MemoryPointer.new(:pointer, band_numbers.size)
-        bands_ptr.write_array_of_int(band_numbers)
-        log "band numbers ptr null? #{bands_ptr.null?}"
-
-        warp_options_struct = FFI::GDAL::WarpOptions.new
-
-        warp_options.each do |k, _|
-          warp_options_struct[k] = warp_options[k]
-        end
-
-        warp_options[:source_dataset] = c_pointer
-        warp_options[:destination_dataset] = destination_dataset.c_pointer
-        warp_options[:band_count] = band_numbers.size
-        warp_options[:source_bands] = bands_ptr
-        warp_options[:transformer] = transformer
-        warp_options[:transformer_arg] = transformer_arg
-
-        log "transformer: #{transformer}"
-        error_threshold = 0.0
-        order = 0
-
-        _transformer_ptr = FFI::GDAL::Alg.GDALCreateGenImgProjTransformer(@c_pointer,
-          projection,
-          destination_dataset.c_pointer,
-          destination.projection,
-          false,
-          error_threshold,
-          order)
-
-        warp_operation = GDAL::WarpOperation.new(warp_options)
-        warp_operation.chunk_and_warp_image(0, 0, raster_x_size, raster_y_size)
-        transformer.destroy!
-        warp_operation.destroy!
-
-        destination = GDAL::Dataset.new(destination_dataset_ptr)
-        destination.close
-
-        destination
-      end
-
       # Retrieves pixels from each raster band and converts this to an array of
       # points per pixel.  For example:
       #

data/lib/gdal/dataset_mixins/matching.rb

@@ -1,5 +1,3 @@
-require_relative '../../ffi/gdal/matching'
-
 module GDAL
   module DatasetMixins
     module Matching

data/lib/gdal/dataset_mixins/warp_methods.rb

@@ -0,0 +1,42 @@
+module GDAL
+  module DatasetMixins
+    # Methods used for warping; most taken from gdalwarper.h.
+    module WarpMethods
+      # @param destination_dataset [GDAL::Dataset]
+      # @param resample_algorithm [Symbol] One from FFI::GDAL::Warper::GDALResampleAlg.
+      # @param destination_spatial_reference [OGR::SpatialReference]
+      # @param warp_memory_limit [Float] The amount of memory (in bytes) the API
+      #   is allowed to use for caching. This is in addition to the amount of
+      #   memory already allocated for caching (using GDALSetCacheMax). 0.0 uses
+      #   default settings.
+      # @param max_error [Float] Maximum error, measured in input pixels that is
+      #   allowed in approximating the transformation. Defaults to 0.0.
+      # @param progress_function [Proc, FFI::GDAL::GDAL::GDALProgressFunc] A
+      #   callback for reporting progress.
+      # @param progress_arg [FFI::Pointer] Argument to be passed to
+      #   +progress_function+.
+      # @param options [Hash] Warp options, normally empty.
+      def reproject_image(destination_dataset, resample_algorithm, destination_spatial_reference: nil,
+        warp_memory_limit: 0.0, max_error: 0.0, progress_function: nil, progress_arg: nil, **options)
+        destination_spatial_reference_wkt = if destination_spatial_reference
+                                              destination_spatial_reference.to_wkt
+                                            end
+
+        options_ptr = GDAL::Options.pointer(options)
+
+        FFI::GDAL::Warper.GDALReprojectImage(
+          @c_pointer,                           # hSrcDS
+          nil,                                  # pszSrcWKT
+          destination_dataset.c_pointer,        # hDstDS
+          destination_spatial_reference_wkt,    # pszDstWKT
+          resample_algorithm,                   # eResampleAlg
+          warp_memory_limit,                    # dfWarpMemoryLimit
+          max_error,                            # dfMaxError
+          progress_function,                    # pfnProgress
+          progress_arg,                         # pProgressArg
+          options_ptr                           # psOptions
+        )
+      end
+    end
+  end
+end

data/lib/gdal/driver.rb

@@ -1,10 +1,7 @@
-require_relative '../ffi/gdal'
+require 'multi_xml'
+require_relative '../gdal'
 require_relative 'major_object'
-require_relative 'exceptions'
 require_relative 'driver_mixins/extensions'
-require_relative 'dataset'
-require_relative 'options'
-require 'multi_xml'
 
 module GDAL
   # Wrapper for GDAL drivers (aka "formats"). Useful for opening and working
@@ -14,11 +11,11 @@ module GDAL
     include GDAL::Logger
     include DriverMixins::Extensions
 
-    GDAL_DOCS_URL = 'http://gdal.org'
+    GDAL_DOCS_URL = 'http://gdal.org'.freeze
 
     # @return [Fixnum]
     def self.count
-      FFI::GDAL.GDALGetDriverCount
+      FFI::GDAL::GDAL.GDALGetDriverCount
     end
 
     # @param name [String] Short name of the registered GDALDriver.
@@ -26,10 +23,10 @@ module GDAL
     # @raise [GDAL::InvalidDriverName] If +name+ does not represent a valid
     #   driver name.
     def self.by_name(name)
-      driver_ptr = FFI::GDAL.GDALGetDriverByName(name)
+      driver_ptr = FFI::GDAL::GDAL.GDALGetDriverByName(name)
 
       if driver_ptr.null?
-        fail InvalidDriverName, "'#{name}' is not a valid driver name."
+        raise InvalidDriverName, "'#{name}' is not a valid driver name."
       end
 
       new(driver_ptr)
@@ -41,10 +38,10 @@ module GDAL
     # @raise [GDAL::InvalidDriverIndex] If driver at +index+ does not exist.
     def self.at_index(index)
       if index > count
-        fail InvalidDriverIndex, "index must be between 0 and #{count - 1}."
+        raise InvalidDriverIndex, "index must be between 0 and #{count - 1}."
       end
 
-      driver_ptr = FFI::GDAL.GDALGetDriver(index)
+      driver_ptr = FFI::GDAL::GDAL.GDALGetDriver(index)
 
       new(driver_ptr)
     end
@@ -52,7 +49,7 @@ module GDAL
     # @param file_path [String] File to get the driver for.
     # @return [GDAL::Driver] Returns nil if the file is unsupported.
     def self.identify_driver(file_path)
-      driver_ptr = FFI::GDAL.GDALIdentifyDriver(::File.expand_path(file_path), nil)
+      driver_ptr = FFI::GDAL::GDAL.GDALIdentifyDriver(::File.expand_path(file_path), nil)
       return nil if driver_ptr.null?
 
       new(driver_ptr)
@@ -67,17 +64,17 @@ module GDAL
 
     # @return [String]
     def short_name
-      FFI::GDAL.GDALGetDriverShortName(@c_pointer)
+      FFI::GDAL::GDAL.GDALGetDriverShortName(@c_pointer)
     end
 
     # @return [String]
     def long_name
-      FFI::GDAL.GDALGetDriverLongName(@c_pointer)
+      FFI::GDAL::GDAL.GDALGetDriverLongName(@c_pointer)
     end
 
     # @return [String]
     def help_topic
-      "#{GDAL_DOCS_URL}/#{FFI::GDAL.GDALGetDriverHelpTopic(@c_pointer)}"
+      "#{GDAL_DOCS_URL}/#{FFI::GDAL::GDAL.GDALGetDriverHelpTopic(@c_pointer)}"
     end
 
     # Lists and describes the options that can be used when calling
@@ -87,7 +84,7 @@ module GDAL
     def creation_option_list
       return [] unless @c_pointer
 
-      creation_option_list_xml = FFI::GDAL.GDALGetDriverCreationOptionList(@c_pointer)
+      creation_option_list_xml = FFI::GDAL::GDAL.GDALGetDriverCreationOptionList(@c_pointer)
       root = MultiXml.parse(creation_option_list_xml)
       return [] if root.nil? || root.empty?
 
@@ -106,7 +103,7 @@ module GDAL
                           GDAL::Options.pointer(options)
                         end
 
-      FFI::GDAL.GDALValidateCreationOptions(@c_pointer, options_pointer).to_bool
+      FFI::GDAL::GDAL.GDALValidateCreationOptions(@c_pointer, options_pointer)
     end
 
     # Copy all of the associated files of a dataset from one file to another.
@@ -116,7 +113,7 @@ module GDAL
     # @return true on success, false on warning.
     # @raise [GDAL::CPLErrFailure] If failures.
     def copy_dataset_files(old_name, new_name)
-      FFI::GDAL.GDALCopyDatasetFiles(@c_pointer, new_name, old_name)
+      FFI::GDAL::GDAL.GDALCopyDatasetFiles(@c_pointer, new_name, old_name)
     end
 
     # Create a new Dataset with this driver.  Legal arguments depend on the
@@ -127,13 +124,14 @@ module GDAL
     # @param x_size [Fixnum] Width of created raster in pixels.
     # @param y_size [Fixnum] Height of created raster in pixels.
     # @param band_count [Fixnum]
-    # @param data_type [FFI::GDAL::DataType]
-    # @return [GDAL::Dataset] Returns the *open* dataset.  You'll need to
-    #   close it.
+    # @param data_type [FFI::GDAL::GDAL::DataType]
+    # @return [GDAL::Dataset] If no block is given, returns the *open*
+    #   (writable) dataset; you'll need to close it. If a block is given,
+    #   returns the result of the block.
     def create_dataset(filename, x_size, y_size, band_count: 1, data_type: :GDT_Byte, **options)
       options_pointer = GDAL::Options.pointer(options)
 
-      dataset_pointer = FFI::GDAL.GDALCreate(
+      dataset_pointer = FFI::GDAL::GDAL.GDALCreate(
         @c_pointer,
         filename,
         x_size,
@@ -143,43 +141,62 @@ module GDAL
         options_pointer
       )
 
-      fail CreateFail if dataset_pointer.null?
+      raise CreateFail if dataset_pointer.null?
+
+      dataset = GDAL::Dataset.new(dataset_pointer, 'w')
 
-      dataset = GDAL::Dataset.new(dataset_pointer, nil)
-      yield(dataset) if block_given?
+      if block_given?
+        result = yield(dataset)
+        dataset.close
 
-      dataset
+        result
+      else
+        dataset
+      end
     end
 
+    # Copies +source_dataset+ to +destination_path+. Will yield a writable
+    # {{GDAL::Dataset}} of the destination dataset then close it if a block is
+    # given.
+    #
     # @param source_dataset [GDAL::Dataset, FFI::Pointer] The dataset to copy.
     # @param destination_path [String] The name for the new dataset file.
     # @param strict [Boolean] +false+ indicates the copy may adapt as needed for
     #   the output format.
     # @param options [Hash]
-    # @param progress [Proc] For outputting copy progress.  Conforms to the
-    #   FFI::GDAL::GDALProgressFunc signature.
-    def copy_dataset(source_dataset, destination_path, strict: true, **options, &progress)
-      options_ptr = GDAL::Options.pointer(options)
+    # @param progress_block [Proc, FFI::GDAL::GDAL.GDALProgressFunc] For
+    #   outputting copy progress.  Conforms to the
+    #   FFI::GDAL::GDAL.GDALProgressFunc signature.
+    # @param progress_arg [Proc]
+    # @return [true]
+    # @raise [GDAL::CreateFail] if it couldn't copy the dataset.
+    # @yieldparam destination_dataset [GDAL::Dataset]
+    def copy_dataset(source_dataset, destination_path, progress_block = nil, progress_arg = nil, strict: true,
+      **options)
       source_dataset_ptr = make_dataset_pointer(source_dataset)
-      fail "Source dataset couldn't be read" if source_dataset_ptr.null?
+      raise GDAL::OpenFailure, "Source dataset couldn't be read" if source_dataset_ptr && source_dataset_ptr.null?
+
+      options_ptr = GDAL::Options.pointer(options)
 
-      destination_dataset_ptr = FFI::GDAL.GDALCreateCopy(
+      destination_dataset_ptr = FFI::GDAL::GDAL.GDALCreateCopy(
         @c_pointer,
         destination_path,
         source_dataset_ptr,
         strict,
         options_ptr,
-        progress,
-        nil
+        progress_block,
+        progress_arg
       )
 
-      fail CreateFail if destination_dataset_ptr.null?
+      raise CreateFail if destination_dataset_ptr.nil? || destination_dataset_ptr.null?
 
-      dataset = Dataset.new(destination_dataset_ptr, 'w')
-      yield(dataset) if block_given?
-      dataset.close
+      if block_given?
+        dataset = Dataset.new(destination_dataset_ptr, 'w')
+        yield(dataset)
+        dataset.close
+      end
 
-      dataset
+      true
     end
 
     # Delete the dataset represented by +file_name+.  Depending on the driver,
@@ -189,15 +206,15 @@ module GDAL
     # @return true on success, false on warning.
     # @raise [GDAL::CPLErrFailure] If failures.
     def delete_dataset(file_name)
-      FFI::GDAL.GDALDeleteDataset(@c_pointer, file_name)
+      FFI::GDAL::GDAL.GDALDeleteDataset(@c_pointer, file_name)
     end
 
-    # @param new_name [String]
     # @param old_name [String]
+    # @param new_name [String]
     # @return true on success, false on warning.
     # @raise [GDAL::CPLErrFailure] If failures.
-    def rename_dataset(new_name, old_name)
-      FFI::GDAL.GDALRenameDataset(@c_pointer, new_name, old_name)
+    def rename_dataset(old_name, new_name)
+      FFI::GDAL::GDAL.GDALRenameDataset(@c_pointer, new_name, old_name)
     end
 
     private
@@ -206,12 +223,10 @@ module GDAL
     #   dataset, the pointer to another dataset, or the path to a dataset.
     # @return [GDAL::Dataset]
     def make_dataset_pointer(dataset)
-      if dataset.is_a? GDAL::Dataset
-        dataset.c_pointer
-      elsif dataset.is_a? String
+      if dataset.is_a? String
         GDAL::Dataset.open(dataset, 'r').c_pointer
       else
-        dataset
+        GDAL._pointer(GDAL::Dataset, dataset)
       end
     end
   end

data/lib/gdal/driver_mixins/extensions.rb

@@ -8,19 +8,14 @@ module GDAL
       module ClassMethods
         # @return [Array<String>]
         def short_names
-          names = count.times.map do |i|
-            driver = at_index(i)
-            driver.short_name
-          end
+          names = Array.new(count) { |i| at_index(i).short_name }
 
           names.compact.sort
         end
 
         # @return [Array<String>]
         def long_names
-          names = count.times.map do |i|
-            at_index(i).long_name
-          end
+          names = Array.new(count) { |i| at_index(i).long_name }
 
           names.compact.sort
         end

data/lib/gdal/environment_methods.rb

@@ -1,43 +1,46 @@
 module GDAL
+  # Getters and setters for the GDAL environment.
   module EnvironmentMethods
     # @return [Fixnum] The maximum cache memory.
     def cache_max
-      FFI::GDAL.GDALGetCacheMax
+      FFI::GDAL::GDAL.GDALGetCacheMax
     end
 
     # @param bytes [Fixnum]
     def cache_max=(bytes)
-      FFI::GDAL.GDALSetCacheMax(bytes)
+      FFI::GDAL::GDAL.GDALSetCacheMax(bytes)
     end
 
     # @return [Fixnum] The maximum cache memory.
     def cache_max64
-      FFI::GDAL.GDALGetCacheMax64
+      FFI::GDAL::GDAL.GDALGetCacheMax64
     end
 
     # @param bytes [Fixnum]
     def cache_max64=(bytes)
-      FFI::GDAL.GDALSetCacheMax64(bytes)
+      FFI::GDAL::GDAL.GDALSetCacheMax64(bytes)
     end
 
     # @return [Fixnum] The amount of used cache memory.
     def cache_used
-      FFI::GDAL.GDALGetCacheUsed
+      FFI::GDAL::GDAL.GDALGetCacheUsed
     end
 
     # @return [Fixnum] The amount of used cache memory.
     def cache_used64
-      FFI::GDAL.GDALGetCacheUsed64
+      FFI::GDAL::GDAL.GDALGetCacheUsed64
     end
 
     # @return [Boolean]
     def flush_cache_block
-      FFI::GDAL.GDALFlushCacheBlock
+      FFI::GDAL::GDAL.GDALFlushCacheBlock
     end
 
-    # @param file_name [String]
-    def dump_open_datasets(file_name)
-      FFI::GDAL.GDALDumpOpenDatasets(file_name)
+    # @param file_path [String]
+    def dump_open_datasets(file_path)
+      file_ptr = FFI::CPL::Conv.CPLOpenShared(file_path, 'w', false)
+      FFI::GDAL::GDAL.GDALDumpOpenDatasets(file_ptr)
+      FFI::CPL::Conv.CPLCloseShared(file_ptr)
     end
   end
 end

data/lib/gdal/exceptions.rb

@@ -1,4 +1,7 @@
 module GDAL
+  class BufferTooSmall < StandardError
+  end
+
   class CreateFail < StandardError
   end
 
@@ -12,25 +15,41 @@ module GDAL
     end
   end
 
+  class InvalidAccessFlag < RuntimeError
+  end
+
   class InvalidBandNumber < StandardError
   end
 
   class InvalidColorTable < StandardError
   end
 
+  class InvalidDataType < StandardError
+  end
+
   class InvalidDriverIndex < StandardError
   end
 
   class InvalidDriverName < StandardError
   end
 
+  class InvalidGeoTransform < StandardError
+  end
+
   class InvalidRasterBand < StandardError
   end
 
-  class NoWriteAccess < RuntimeError
+  # Used when a RasterBand erase operation can't find a value to use to set for
+  # values to erase.
+  class NoRasterEraseValue < RuntimeError
   end
 
-  class InvalidAccessFlag < RuntimeError
+  # Indicates that neither field attributes were selected nor Z fields were
+  # provided to allow for gridding.
+  class NoValuesToGrid < RuntimeError
+  end
+
+  class NoWriteAccess < RuntimeError
   end
 
   class NullObject < TypeError
@@ -46,6 +65,9 @@ module GDAL
     end
   end
 
+  class UnknownRasterAttributeTableType < StandardError
+  end
+
   class UnsupportedOperation < StandardError
   end
 end

data/lib/gdal/geo_transform.rb

@@ -1,4 +1,4 @@
-require_relative '../ffi/gdal'
+require_relative '../gdal'
 require_relative 'geo_transform_mixins/extensions'
 
 module GDAL
@@ -21,9 +21,9 @@ module GDAL
       gt_ptr = new_pointer
 
       result = if extension
-                 FFI::GDAL.GDALReadWorldFile(filename, extension, gt_ptr)
+                 FFI::GDAL::GDAL.GDALReadWorldFile(filename, extension, gt_ptr)
                else
-                 FFI::GDAL.GDALLoadWorldFile(filename, gt_ptr)
+                 FFI::GDAL::GDAL.GDALLoadWorldFile(filename, gt_ptr)
                end
 
       return nil unless result
@@ -33,13 +33,7 @@ module GDAL
 
     # @param geo_transform [FFI::Pointer]
     def initialize(geo_transform = nil)
-      @c_pointer = if geo_transform.is_a? GDAL::GeoTransform
-                     geo_transform.c_pointer
-                   elsif geo_transform
-                     geo_transform
-                   else
-                     self.class.new_pointer
-                   end
+      @c_pointer = geo_transform ? GDAL._pointer(GDAL::GeoTransform, geo_transform) : self.class.new_pointer
 
       self.pixel_width ||= 1.0
       self.pixel_height ||= 1.0
@@ -160,11 +154,11 @@ module GDAL
     def apply_geo_transform(pixel, line)
       geo_x_ptr = FFI::MemoryPointer.new(:double)
       geo_y_ptr = FFI::MemoryPointer.new(:double)
-      FFI::GDAL.GDALApplyGeoTransform(@c_pointer, pixel, line, geo_x_ptr, geo_y_ptr)
+      FFI::GDAL::GDAL.GDALApplyGeoTransform(@c_pointer, pixel, line, geo_x_ptr, geo_y_ptr)
 
       { x_geo: geo_x_ptr.read_double, y_geo: geo_y_ptr.read_double }
     end
-    alias_method :pixel_to_world, :apply_geo_transform
+    alias pixel_to_world apply_geo_transform
 
     # Composes this and the given geo_transform.  The resulting GeoTransform is
     # equivalent to applying both GeoTransforms to a point.
@@ -175,11 +169,11 @@ module GDAL
       other_ptr = GDAL._pointer(GDAL::GeoTransform, other_geo_transform)
 
       unless other_ptr
-        fail GDAL::NullObject, "Unable to access pointer for '#{other_geo_transform}'"
+        raise GDAL::NullObject, "Unable to access pointer for '#{other_geo_transform}'"
       end
 
       new_gt_ptr = self.class.new_pointer
-      FFI::GDAL.GDALComposeGeoTransforms(@c_pointer, other_ptr, new_gt_ptr)
+      FFI::GDAL::GDAL.GDALComposeGeoTransforms(@c_pointer, other_ptr, new_gt_ptr)
       return nil if new_gt_ptr.null?
 
       GDAL::GeoTransform.new(new_gt_ptr)
@@ -192,7 +186,7 @@ module GDAL
     # @return [GDAL::GeoTransform]
     def invert
       new_geo_transform_ptr = self.class.new_pointer
-      success = FFI::GDAL.GDALInvGeoTransform(@c_pointer, new_geo_transform_ptr)
+      success = FFI::GDAL::GDAL.GDALInvGeoTransform(@c_pointer, new_geo_transform_ptr)
       return nil unless success
 
       self.class.new(new_geo_transform_ptr)
@@ -202,7 +196,7 @@ module GDAL
     # @param world_extension [String]
     # @return [Boolean]
     def to_world_file(raster_filename, world_extension)
-      FFI::GDAL.GDALWriteWorldFile(raster_filename, world_extension, @c_pointer)
+      FFI::GDAL::GDAL.GDALWriteWorldFile(raster_filename, world_extension, @c_pointer)
     end
   end
 end