ffi-gdal 1.0.0.beta16 → 1.0.0

data/lib/gdal/raster_band_mixins/algorithm_methods.rb

@@ -17,7 +17,7 @@ module GDAL
         # @param red_band [GDAL::RasterBand, FFI::Pointer]
         # @param green_band [GDAL::RasterBand, FFI::Pointer]
         # @param blue_band [GDAL::RasterBand, FFI::Pointer]
-        # @param colors [Fixnum] Number of colors to return; 2-256.
+        # @param colors [Integer] Number of colors to return; 2-256.
         # @param color_interpretation [FFI::GDAL::GDAL::PaletteInterp] The type
         #   of ColorTable to return.
         # @param progress_function [Proc, FFI:GDAL::GDAL.ProgressFunc]
@@ -90,11 +90,11 @@ module GDAL
       # of the raster data won't affect the checksum.  Real and imaginary
       # components of complex bands influence the result.
       #
-      # @param x_offset [Fixnum]
-      # @param y_offset [Fixnum]
-      # @param x_size [Fixnum]
-      # @param y_size [Fixnum]
-      # @return [Fixnum] The checksum value.
+      # @param x_offset [Integer]
+      # @param y_offset [Integer]
+      # @param x_size [Integer]
+      # @param y_size [Integer]
+      # @return [Integer] The checksum value.
       def checksum_image(x_offset, y_offset, x_size, y_size)
         !!FFI::GDAL::Alg.GDALChecksumImage(
           @c_pointer,
@@ -123,11 +123,11 @@ module GDAL
       #   from non-zero pixel values.
       # @option options [String] distunits (PIXEL) Indicates what unit type to
       #   use for computing.
-      # @option options [Fixnum] maxdist The maximum distance to search.
-      # @option options [Fixnum] nodata If not given, it will try to use the
+      # @option options [Integer] maxdist The maximum distance to search.
+      # @option options [Integer] nodata If not given, it will try to use the
       #   nodata value on the +proximity_band+. If not found there, will use
       #   65535.
-      # @option options [Fixnum] fixed_buf_val If set, all pixels within the
+      # @option options [Integer] fixed_buf_val If set, all pixels within the
       #   +maxdist+ threshold are set to this fixed value instead of to a
       #   proximity distance.
       def compute_proximity!(proximity_band, progress_function: nil, progress_arg: nil, **options)
@@ -164,7 +164,7 @@ module GDAL
       #   be interpolated (it does so using 0-valued pixels).
       # @param max_search_distance [Float] Max number of pixels to search in all
       #   directions to find values to interpolate from.
-      # @param smoothing_iterations [Fixnum] The number of 3x3 smoothing filter
+      # @param smoothing_iterations [Integer] The number of 3x3 smoothing filter
       #   passes to run.  Can be 0.
       # @param progress_function [Proc, FFI:GDAL::GDAL.ProgressFunc]
       # @param progress_arg [FFI::Pointer] Usually used when when using a
@@ -177,13 +177,13 @@ module GDAL
         options_ptr = GDAL::Options.pointer(options)
 
         !!FFI::GDAL::Alg.GDALFillNodata(@c_pointer,
-          mask_band_ptr,
-          max_search_distance,
-          0, # deprecated option in GDAL
-          smoothing_iterations,
-          options_ptr,
-          progress_function,
-          progress_arg)
+                                        mask_band_ptr,
+                                        max_search_distance,
+                                        0, # deprecated option in GDAL
+                                        smoothing_iterations,
+                                        options_ptr,
+                                        progress_function,
+                                        progress_arg)
       end
 
       # Creates vector polygons for all connected regions of pixels in the raster
@@ -211,7 +211,7 @@ module GDAL
       # @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
+      # @param pixel_value_field [Integer] Index of the feature attribute into
       #   which the pixel value of the polygon should be written.
       # @param use_integer_function [Boolean] Indicates using GDAL's
       #   GDALPolygonize() instead of GDALFPolygonize(); the former uses a
@@ -219,7 +219,7 @@ module GDAL
       #   32-bit float buffer. The integer based function is faster but less
       #   precise.
       # @param options [Hash]
-      # @option options [Fixnum] '8CONNECTED' (4) Set to 8 to use 8
+      # @option options [Integer] '8CONNECTED' (4) Set to 8 to use 8
       #   connectedness.
       # @param progress_function [Proc, FFI:GDAL::GDAL.ProgressFunc]
       # @param progress_arg [FFI::Pointer] Usually used when when using a
@@ -227,9 +227,10 @@ module GDAL
       # @return [OGR::Layer]
       def polygonize(layer, mask_band: nil, pixel_value_field: -1, use_integer_function: false, progress_function: nil,
         progress_arg: nil, **options)
-        mask_band_ptr = GDAL._pointer(GDAL::RasterBand, mask_band, false)
+        mask_band_ptr = GDAL._pointer(GDAL::RasterBand, mask_band, warn_on_nil: false)
         layer_ptr = GDAL._pointer(OGR::Layer, layer)
         raise OGR::InvalidLayer, "Invalid layer: #{layer.inspect}" if layer_ptr.null?
+
         log "Pixel value field: #{pixel_value_field}"
 
         options_ptr = GDAL::Options.pointer(options)
@@ -258,9 +259,9 @@ module GDAL
       # If +mask_band+ is given, "nodata" pixels in the band will not be treated
       # as part of a polygon, regardless of their pixel values.
       #
-      # @param size_threshold [Fixnum] Polygons found in the raster with sizes
+      # @param size_threshold [Integer] Polygons found in the raster with sizes
       #   smaller than this will be merged into their largest neighbor.
-      # @param connectedness [Fixnum] 4 or 8. 4 indicates that diagonal pixels
+      # @param connectedness [Integer] 4 or 8. 4 indicates that diagonal pixels
       #   are not considered directly adjacent for polygon membership purposes;
       #   8 indicates they are.
       # @param mask_band [GDAL::RasterBand] [description] All pixels in this
@@ -299,9 +300,9 @@ module GDAL
 
       private
 
-      # @param size_threshold [Fixnum] Polygons found in the raster with sizes
+      # @param size_threshold [Integer] Polygons found in the raster with sizes
       #   smaller than this will be merged into their largest neighbor.
-      # @param connectedness [Fixnum] 4 or 8. 4 indicates that diagonal pixels
+      # @param connectedness [Integer] 4 or 8. 4 indicates that diagonal pixels
       #   are not considered directly adjacent for polygon membership purposes;
       #   8 indicates they are.
       # @param mask_band [GDAL::RasterBand] [description] All pixels in this
@@ -313,7 +314,7 @@ module GDAL
       # @param options [Hash] None supported in GDAL as of this writing.
       def _sieve_filter(size_threshold, connectedness, destination_band, mask_band: nil, progress_function: nil,
         progress_arg: nil, **options)
-        mask_band_ptr = GDAL._pointer(GDAL::RasterBand, mask_band, false)
+        mask_band_ptr = GDAL._pointer(GDAL::RasterBand, mask_band, warn_on_nil: false)
         destination_band_ptr = GDAL._pointer(GDAL::RasterBand, destination_band)
 
         if destination_band.nil? || destination_band.null?

data/lib/gdal/rpc_info.rb

@@ -14,9 +14,10 @@ module GDAL
 
     # @param struct_or_ptr [FFI::GDAL::RPCInfo, FFI::Pointer]
     def initialize(struct_or_ptr = nil)
-      @c_struct = if struct_or_ptr.is_a? FFI::GDAL::RPCInfo
+      @c_struct = case struct_or_ptr
+                  when FFI::GDAL::RPCInfo
                     struct_or_ptr
-                  elsif struct_or_ptr.is_a? FFI::Pointer
+                  when FFI::Pointer
                     FFI::GDAL::RPCInfo.new(struct_or_ptr)
                   else
                     FFI::GDAL::RPCInfo.new

data/lib/gdal/transformers/approximate_transformer.rb

@@ -8,6 +8,14 @@ module GDAL
         FFI::GDAL::Alg::ApproxTransform
       end
 
+      # @param pointer [FFI::Pointer]
+      def self.release(pointer)
+        return unless pointer && !pointer.null?
+
+        FFI::GDAL::Alg.GDALDestroyApproxTransformer(pointer)
+      end
+
+      # @return [FFI::Pointer]
       attr_reader :c_pointer
 
       # @param base_transformer [GDAL::Transformer]
@@ -17,17 +25,18 @@ module GDAL
         base_transformer_function = base_transformer.function
         transformer_arg_ptr = base_transformer.c_pointer
 
-        @c_pointer = FFI::GDAL::Alg.GDALCreateApproxTransformer(
+        pointer = FFI::GDAL::Alg.GDALCreateApproxTransformer(
           base_transformer_function,
           transformer_arg_ptr,
           max_error
         )
+
+        @c_pointer = FFI::AutoPointer.new(pointer, ApproximateTransformer.method(:destroy))
       end
 
       def destroy!
-        return unless @c_pointer
+        ApproximateTransformer.destroy(@c_pointer)
 
-        FFI::GDAL::Alg.GDALDestroyApproxTransformer(@c_pointer)
         @c_pointer = nil
       end
 

data/lib/gdal/transformers/base_general_image_projection_transformer.rb

@@ -8,12 +8,19 @@ module GDAL
         FFI::GDAL::Alg::GenImgProjTransform
       end
 
+      # @param pointer [FFI::Pointer]
+      def self.release(pointer)
+        return unless pointer && !pointer.null?
+
+        FFI::GDAL::Alg.GDALDestroyGenImgProjTransformer(pointer)
+      end
+
+      # @return [FFI::Pointer]
       attr_reader :c_pointer
 
       def destroy!
-        return unless @c_pointer
+        BaseGeneralImageProjectionTransformer.release(@c_pointer)
 
-        FFI::GDAL::Alg.GDALDestroyGenImgProjTransformer(@c_pointer)
         @c_pointer = nil
       end
 
@@ -37,6 +44,12 @@ module GDAL
           @c_pointer, geo_transform_ptr
         )
       end
+
+      private
+
+      def init_pointer(pointer)
+        @c_pointer = FFI::AutoPointer.new(pointer, BaseGeneralImageProjectionTransformer.method(:release))
+      end
     end
   end
 end

data/lib/gdal/transformers/gcp_transformer.rb

@@ -8,13 +8,20 @@ module GDAL
         FFI::GDAL::Alg::GCPTransform
       end
 
+      # @param pointer [FFI::Pointer]
+      def self.release(pointer)
+        return unless pointer && !pointer.null?
+
+        FFI::GDAL::Alg.GDALDestroyGCPTransformer(pointer)
+      end
+
       # @return [FFI::Pointer] C pointer to the GCP transformer.
       attr_reader :c_pointer
 
       # @param gcp_list [Array<FFI::GDAL::GCP>]
-      # @param requested_polynomial_order [Fixnum] 1, 2, or 3.
+      # @param requested_polynomial_order [Integer] 1, 2, or 3.
       # @param reversed [Boolean]
-      def initialize(gcp_list, requested_polynomial_order, reversed = false, tolerance: nil, minimum_gcps: nil)
+      def initialize(gcp_list, requested_polynomial_order, reversed: false, tolerance: nil, minimum_gcps: nil)
         gcp_list_ptr = FFI::MemoryPointer.new(:pointer, gcp_list.size)
 
         # TODO: fasterer: each_with_index is slower than loop
@@ -22,27 +29,28 @@ module GDAL
           gcp_list_ptr[i].put_pointer(0, gcp.to_ptr)
         end
 
-        @c_pointer = if tolerance || minimum_gcps
-                       FFI::GDAL::Alg.GDALCreateGCPRefineTransformer(
-                         gcp_list.size,
-                         gcp_list_ptr,
-                         requested_polynomial_order,
-                         reversed
-                       )
-                     else
-                       FFI::GDAL::Alg.GDALCreateGCPTransformer(
-                         gcp_list.size,
-                         gcp_list_ptr,
-                         requested_polynomial_order,
-                         reversed
-                       )
-                     end
+        pointer = if tolerance || minimum_gcps
+                    FFI::GDAL::Alg.GDALCreateGCPRefineTransformer(
+                      gcp_list.size,
+                      gcp_list_ptr,
+                      requested_polynomial_order,
+                      reversed
+                    )
+                  else
+                    FFI::GDAL::Alg.GDALCreateGCPTransformer(
+                      gcp_list.size,
+                      gcp_list_ptr,
+                      requested_polynomial_order,
+                      reversed
+                    )
+                  end
+
+        @c_pointer = FFI::AutoPointer.new(pointer, GCPTransformer.method(:release))
       end
 
       def destroy!
-        return unless @c_pointer
+        GCPTransformer.release(@c_pointer)
 
-        FFI::GDAL::Alg.GDALDestroyGCPTransformer(@c_pointer)
         @c_pointer = nil
       end
 

data/lib/gdal/transformers/general_image_projection_transformer.rb

@@ -10,13 +10,15 @@ module GDAL
       # @param source_wkt [String]
       # @param destination_wkt [String]
       # @param gcp_use_ok [Boolean]
-      # @param order [Fixnum]
+      # @param order [Integer]
       def initialize(source_dataset, destination_dataset: nil, source_wkt: nil, destination_wkt: nil,
         gcp_use_ok: false, order: 0)
-        source_ptr = GDAL._pointer(GDAL::Dataset, source_dataset)
-        dest_ptr = GDAL._pointer(GDAL::Dataset, destination_dataset, false)
+        super()
+
+        source_ptr = GDAL::Dataset.new_pointer(source_dataset)
+        dest_ptr = GDAL::Dataset.new_pointer(destination_dataset, warn_on_nil: false)
 
-        @c_pointer = FFI::GDAL::Alg.GDALCreateGenImgProjTransformer(
+        pointer = FFI::GDAL::Alg.GDALCreateGenImgProjTransformer(
           source_ptr,
           source_wkt,
           dest_ptr,
@@ -25,9 +27,9 @@ module GDAL
           0.0,
           order
         )
-        raise if @c_pointer.null?
+        raise if pointer.null?
 
-        super()
+        init_pointer(pointer)
       end
     end
   end

data/lib/gdal/transformers/general_image_projection_transformer2.rb

@@ -15,11 +15,11 @@ module GDAL
       # @option options [String] dst_srs Use to override +destination_dataset+'s WKT
       #   SRS.
       # @option options [Boolean] gcps_ok (true)
-      # @option options [Fixnum] refine_minimum_gcps Minimum amount of GCPs that
+      # @option options [Integer] refine_minimum_gcps Minimum amount of GCPs that
       #   should be available after the refinement.
       # @option options [Float] refine_tolerance The tolerance that specifies
       #   when a GCP will be eliminated.
-      # @option options [Fixnum] max_gcp_order Max order to use for GCP-derived
+      # @option options [Integer] max_gcp_order Max order to use for GCP-derived
       #   polynomials, if possible. Default is to auto-select based on the number
       #   of GCPs. A value of -1 triggers use of Thin Plate Spline instead of
       #   polynomials.
@@ -38,17 +38,20 @@ module GDAL
       #   up a CENTER_LONG value on the coordinate system to rewrap things around
       #   the center of the image.
       def initialize(source_dataset, destination_dataset: nil, **options)
-        source_ptr = GDAL._pointer(GDAL::Dataset, source_dataset)
-        destination_ptr = GDAL._pointer(GDAL::Dataset, destination_dataset, false)
+        super()
+
+        source_ptr = GDAL::Dataset.new_pointer(source_dataset)
+        destination_ptr = GDAL::Dataset.new_pointer(destination_dataset, warn_on_nil: false)
         options_ptr = GDAL::Options.pointer(options)
 
-        @c_pointer = FFI::GDAL::Alg.GDALCreateGenImgProjTransformer2(
+        pointer = FFI::GDAL::Alg.GDALCreateGenImgProjTransformer2(
           source_ptr,
           destination_ptr,
           options_ptr
         )
+        raise if pointer.null?
 
-        super()
+        init_pointer(pointer)
       end
     end
   end

data/lib/gdal/transformers/general_image_projection_transformer3.rb

@@ -11,17 +11,21 @@ module GDAL
       # @param destination_geo_transform [GDAL::GeoTransform, FFI::Pointer]
       # @return [FFI::Pointer]
       def initialize(source_wkt, source_geo_transform, destination_wkt, destination_geo_transform)
+        super()
+
         source_ptr = GDAL._pointer(GDAL::GeoTransform, source_geo_transform)
         destination_ptr = GDAL._pointer(GDAL::GeoTransform, destination_geo_transform)
 
-        @c_pointer = FFI::GDAL::Alg.GDALCreateGenImgProjTransformer3(
+        pointer = FFI::GDAL::Alg.GDALCreateGenImgProjTransformer3(
           source_wkt,
           source_ptr,
           destination_wkt,
           destination_ptr
         )
 
-        super()
+        raise if pointer.null?
+
+        init_pointer(pointer)
       end
     end
   end

data/lib/gdal/transformers/geolocation_transformer.rb

@@ -8,27 +8,35 @@ module GDAL
         FFI::GDAL::Alg::GeoLocTransform
       end
 
+      # @param pointer [FFI::Pointer]
+      def self.release(pointer)
+        return unless pointer && !pointer.null?
+
+        FFI::GDAL::Alg.GDALDestroyGeoLocTransformer(pointer)
+      end
+
       # @return [FFI::Pointer] C pointer to the C geolocation transformer.
       attr_reader :c_pointer
 
       # @param base_dataset [GDAL::Dataset]
       # @param geolocation_info [Array<String>]
       # @param reversed [Boolean]
-      def intialize(base_dataset, geolocation_info, reversed = false)
+      def intialize(base_dataset, geolocation_info, reversed: false)
         base_dataset_ptr = GDAL._pointer(GDAL::Dataset, base_dataset)
         geolocation_info_ptr = GDAL._string_array_to_pointer(geolocation_info)
 
-        @c_pointer = FFI::GDAL::Alg.CreateGeoLocTransformer(
+        pointer = FFI::GDAL::Alg.CreateGeoLocTransformer(
           base_dataset_ptr,
           geolocation_info_ptr,
           reversed
         )
+
+        @c_pointer = FFI::AutoPointer.new(pointer, GeolocationTransformer.method(:release))
       end
 
       def destroy!
-        return unless @c_pointer
+        GeolocationTransformer.release(@c_pointer)
 
-        FFI::GDAL::Alg.GDALDestroyGeoLocTransformer(@c_pointer)
         @c_pointer = nil
       end
 

data/lib/gdal/transformers/reprojection_transformer.rb

@@ -8,19 +8,27 @@ module GDAL
         FFI::GDAL::Alg::ReprojectionTransform
       end
 
+      # @param pointer [FFI::Pointer]
+      def self.release(pointer)
+        return unless pointer && !pointer.null?
+
+        FFI::GDAL::Alg.GDALDestroyReprojectionTransformer(pointer)
+      end
+
       # @return [FFI::Pointer] C pointer to the C reprojection transformer.
       attr_reader :c_pointer
 
       # @param source_wkt [String]
       # @param destination_wkt [String]
       def initialize(source_wkt, destination_wkt)
-        @c_pointer = FFI::GDAL::Alg.GDALCreateReprojectionTransformer(source_wkt, destination_wkt)
+        pointer = FFI::GDAL::Alg.GDALCreateReprojectionTransformer(source_wkt, destination_wkt)
+
+        @c_pointer = FFI::AutoPointer.new(pointer, ReprojectionTransformer.method(:release))
       end
 
       def destroy!
-        return unless @c_pointer
+        ReprojectionTransformer.release(@c_pointer)
 
-        FFI::GDAL::Alg.GDALDestroyReprojectionTransformer(@c_pointer)
         @c_pointer = nil
       end
 

data/lib/gdal/transformers/rpc_transformer.rb

@@ -8,6 +8,13 @@ module GDAL
         FFI::GDAL::Alg::RPCTransform
       end
 
+      # @param pointer [FFI::Pointer]
+      def self.release(pointer)
+        return unless pointer && !pointer.null?
+
+        FFI::GDAL::Alg.GDALDestroyRPCTransformer(pointer)
+      end
+
       # @return [FFI::Pointer] C pointer to the C RPC transformer.
       attr_reader :c_pointer
 
@@ -28,15 +35,17 @@ module GDAL
       # @option options [Number] rpc_dem_missing_value Value of DEM height that
       #   must be unsed in case the DEM has a nodata value at the sampling point,
       #   or if its extent doesn't cover the requested coordinate.
-      def initialize(rpc_info, pixel_error_threshold, reversed = false, **options)
+      def initialize(rpc_info, pixel_error_threshold, reversed: false, **options)
         options_ptr = GDAL::Options.pointer(options)
 
-        @c_pointer = FFI::GDAL::Alg.GDALCreateRPCTransformer(
+        pointer = FFI::GDAL::Alg.GDALCreateRPCTransformer(
           rpc_info,
           reversed,
           pixel_error_threshold,
           options_ptr
         )
+
+        @c_pointer = FFI::AutoPointer.new(pointer, RPCTransformer.method(:release))
       end
 
       def destroy!

data/lib/gdal/transformers/tps_transformer.rb

@@ -8,12 +8,19 @@ module GDAL
         FFI::GDAL::Alg::TPSTransform
       end
 
+      # @param pointer [FFI::Pointer]
+      def self.release(pointer)
+        return unless pointer && !pointer.null?
+
+        FFI::GDAL::Alg.GDALDestroyTPSTransformer(pointer)
+      end
+
       # @return [FFI::Pointer] C pointer to the C TPS transformer.
       attr_reader :c_pointer
 
       # @param gcp_list [Array<FFI::GDAL::GCP>]
       # @param reversed [Boolean]
-      def initialize(gcp_list, reversed = false)
+      def initialize(gcp_list, reversed: false)
         gcp_list_ptr = FFI::MemoryPointer.new(:pointer, gcp_list.size)
 
         # TODO: fasterer: each_with_index is slower than loop
@@ -21,13 +28,14 @@ module GDAL
           gcp_list_ptr[i].put_pointer(0, gcp.to_ptr)
         end
 
-        @c_pointer = FFI::GDAL::Alg.GDALCreateTPSTransformer(gcp_list.size, gcp_list_ptr, reversed)
+        pointer = FFI::GDAL::Alg.GDALCreateTPSTransformer(gcp_list.size, gcp_list_ptr, reversed)
+
+        @c_pointer = FFI::AutoPointer.new(pointer, TPSTransformer.method(:release))
       end
 
       def destroy!
-        return unless @c_pointer
+        TPSTransformer.release(@c_pointer)
 
-        FFI::GDAL::Alg.GDALDestroyTPSTransformer(@c_pointer)
         @c_pointer = nil
       end
 

data/lib/gdal/version_info.rb

@@ -46,8 +46,8 @@ module GDAL
       FFI::GDAL.GDALVersionInfo('--version')
     end
 
-    # @param major [Fixnum]
-    # @param minor [Fixnum]
+    # @param major [Integer]
+    # @param minor [Integer]
     # @return [Boolean] +true+ if the runtime GDAL library matches the given
     #   version params.
     def check_version(major, minor)

data/lib/gdal/virtual_dataset.rb

@@ -41,6 +41,7 @@ module GDAL
       FFI::GDAL::VRT.VRTAddSource(vrt_band, new_source)
     end
 
+    # rubocop:disable Metrics/ParameterLists
     # @return [Boolean]
     def add_simple_source(vrt_band, source_band, no_data_value,
       src_x_offset: 0, src_y_offset: 0, src_x_size: nil, src_y_size: nil,
@@ -83,6 +84,7 @@ module GDAL
         no_data_value     # dfNoDataValue
       )
     end
+    # rubocop:enable Metrics/ParameterLists
 
     # @param vrt_band [FFI::Pointer]
     # @param read_function [Proc]