ffi-gdal 1.0.0.beta3 → 1.0.0.beta4

data/lib/gdal/raster_band_classifier.rb

@@ -0,0 +1,107 @@
+module GDAL
+  # Takes a list of Ranges of color values and remaps them.  Note that these
+  # values are directly written to the raster band, overwriting all existing
+  # values.
+  #
+  # @example
+  #   classifier = GDAL::RasterBandClassifier.new(raster_band)
+  #   ranges = [
+  #     { range: 0...20, map_to: 1 },
+  #     { range: 20...50, map_to: 2 },
+  #     { range: 50...250, map_to: 3 }
+  #   ]
+  #   classifier.add_ranges(ranges)
+  #   classifier.classify!(ranges)
+  #
+  # @param ranges [Array<Hash{range => Range, map_to => Number}>]
+  class RasterBandClassifier
+    include GDAL::Logger
+
+    attr_reader :ranges
+
+    # @param raster_band [GDAL::RasterBand]
+    def initialize(raster_band)
+      @raster_band = raster_band
+      @ranges = []
+    end
+
+    # @param range [Range] The range of values to map to a new value.
+    # @param map_to_value [Number]
+    def add_range(range, map_to_value)
+      fail 'range must be a Ruby Range' unless range.is_a? Range
+
+      @ranges << { range: range, map_to: map_to_value }
+    end
+
+    # @param range_array [Array<Hash{range => Range, map_to => Number}>]
+    def add_ranges(range_array)
+      range_array.each do |range|
+        add_range range[:range], range[:map_to]
+      end
+    end
+
+    # Uses the max value of the associated RasterBand and +range_count+ to
+    # calculate evenly-weighted ranges.  If there are remainder values at the
+    # max end of the values, those get lumped in with the last range.
+    #
+    # @param range_count [Fixnum] The number of ranges to create.
+    def equal_count_ranges(range_count)
+      sorted_pixels = @raster_band.to_na.sort
+      sorted_and_masked_pixels = sorted_pixels[sorted_pixels.ne(@raster_band.no_data_value[:value])]
+      range_size = (sorted_and_masked_pixels.size / range_count).to_i
+      log "Pixel count: #{sorted_and_masked_pixels.size}"
+      log "Min pixel value: #{sorted_and_masked_pixels.min}"
+      log "Max pixel value: #{sorted_and_masked_pixels.max}"
+      log "Range size: #{range_size}"
+      log 'Break offsets:'
+      break_values = range_count.times.map { |i| sorted_and_masked_pixels[range_size * i] }
+      log "Break values: #{break_values}"
+
+      breakpoint_calculator = lambda do |range_number|
+        min = break_values[range_number]
+        max = break_values[range_number + 1] || sorted_and_masked_pixels.max
+
+        range_for_type(min, max)
+      end
+
+      range_count.times.each_with_object([]) do |i, ranges|
+        range = breakpoint_calculator.call(i)
+
+        ranges << {
+          range: range,
+          map_to: (i + 1).to_data_type(@raster_band.data_type)
+        }
+      end
+    end
+
+    # Uses the ranges that have been added to remap ranges to map_to values.
+    # Note that this *will* overwrite the associated RasterBand with these
+    # values, so if you don't want to overwrite the Dataset you're working with,
+    # you should copy it first.
+    def classify!
+      narray = @raster_band.to_na.dup
+
+      0.upto(narray.size - 1) do |pixel_number|
+        next if narray[pixel_number] == @raster_band.no_data_value[:value]
+
+        range = @ranges.find do |r|
+          r[:range].member? narray[pixel_number]
+        end
+
+        if range
+          narray[pixel_number] = range[:map_to]
+        else
+          log "pixel #{pixel_number} (value: #{narray[pixel_number]}) not in any given range"
+        end
+      end
+
+      @raster_band.write_array(narray, data_type: @raster_band.data_type)
+    end
+
+    private
+
+    def range_for_type(min, max)
+      min.to_data_type(@raster_band.data_type)..max.to_data_type(@raster_band.data_type)
+    end
+  end
+end

data/lib/gdal/raster_band_mixins/algorithm_methods.rb

@@ -0,0 +1,292 @@
+require_relative '../../ffi/gdal/alg'
+
+module GDAL
+  module RasterBandMixins
+    module AlgorithmMethods
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # Compute the optimal PCT for RGB image. Implements a median cut
+        # algorithm to compute an "optimal" pseudo-color table for representing
+        # an input RGB image. This PCT could then be used with
+        # +dither_rgb_to_pct+ to convert a 24-bit RGB image into an 8-bit
+        # pseudo-colored image.
+        #
+        # @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 color_interpretation [FFI::GDAL::PaletteInterp] The type
+        #   of ColorTable to return.
+        # @return [GDAL::ColorTable]
+        def compute_median_cut_pct(red_band, green_band, blue_band,
+          colors, color_interpretation, &progress)
+          color_table = GDAL::ColorTable.new(color_interpretation)
+
+          FFI::GDAL::Alg.GDALComputeMedianCutPCT(
+            red_band,
+            green_band,
+            blue_band,
+            nil,            # This isn't yet supported in GDAL.
+            colors,
+            color_table.c_pointer,
+            progress,
+            nil)
+
+          color_table
+        end
+
+        # 24-bit to 8-bit conversion with dithering.  Utilizes Floyd-Steinberg
+        # dithering, using the provided color table.
+        #
+        # The red, green, and blue input bands do not necessarily need to come
+        # from the same file, but they must be the same width and height. They
+        # will be clipped to 8-bit during reading, so non-eight bit bands are
+        # generally inappropriate. Likewise, +output_band+ will be written with
+        # 8-bit values and must match the width and height of the source bands.
+        #
+        # The ColorTable cannot have more than 256 entries.
+        #
+        # @param red_band [GDAL::RasterBand, FFI::Pointer]
+        # @param green_band [GDAL::RasterBand, FFI::Pointer]
+        # @param blue_band [GDAL::RasterBand, FFI::Pointer]
+        # @param output_band [GDAL::RasterBand, FFI::Pointer]
+        # @param color_table [GDAL::ColorTable, FFI::Pointer]
+        # @return [GDAL::RasterBand] +output_band+ with the dithering algorithm
+        #   applied.
+        def dither_rgb_to_pct(red_band, green_band, blue_band, output_band,
+          color_table, &progress)
+          red_ptr = GDAL._pointer(GDAL::RasterBand, red_band)
+          green_ptr = GDAL._pointer(GDAL::RasterBand, green_band)
+          blue_ptr = GDAL._pointer(GDAL::RasterBand, blue_band)
+          output_ptr = GDAL._pointer(GDAL::RasterBand, output_band)
+          color_table_ptr = GDAL._pointer(GDAL::ColorTable, color_table)
+
+          FFI::GDAL::Alg.GDALDitherRGB2PCT(
+            red_ptr,
+            green_ptr,
+            blue_ptr,
+            output_ptr,
+            color_table_ptr,
+            progress,
+            nil)
+
+          output_band
+        end
+      end
+
+      # Computes a 16-bit (0-65535) checksum from a region of raster data.
+      # Floating point data is converted to 32-bit integers so decimal portions
+      # 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.
+      def checksum_image(x_offset, y_offset, x_size, y_size)
+        !!FFI::GDAL::Alg.GDALChecksumImage(
+          @c_pointer,
+          x_offset,
+          y_offset,
+          x_size,
+          y_size)
+      end
+
+      # Computes the proximity of all pixels in the proximity_band to those in
+      # this band. By default all non-zero pixels in this band will be
+      # considered as "target", and all proximities will be computed in pixels.
+      # Target pixels are set to the value corresponding to a distance of zero.
+      #
+      # Note that this modifies the source band in place with the computed
+      # values.
+      #
+      # @param proximity_band [GDAL::RasterBand, FFI::Pointer]
+      # @param options [Hash]
+      # @option options [String] values A list of target pixel values to measure
+      #   the distance from. If this isn't provided, proximity will be computed
+      #   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
+      #   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
+      #   +maxdist+ threshold are set to this fixed value instead of to a
+      #   proximity distance.
+      def compute_proximity!(proximity_band, **options, &progress)
+        proximity_band_ptr = GDAL._pointer(GDAL::RasterBand, proximity_band)
+        options_ptr = GDAL::Options.pointer(options)
+
+        FFI::GDAL::Alg.GDALComputeProximity(
+          @c_pointer,
+          proximity_band_ptr,
+          options_ptr,
+          progress,
+          nil)
+      end
+
+      # Fill selected raster regions by interpolation from the edges. It
+      # interpolates values for all designated nodata pixels (marked by zeroes
+      # in +mask_band+). For each pixel, a four-direction conic search is done
+      # to find values to interpolate from (using inverse distance weighting).
+      # Once all values are interpolated, zero or more smoothing iterations
+      # (3x3 average filters on interpolated pixels) are applied to smooth out
+      # artifacts.
+      #
+      # This is generally suitable for interpolating missing regions of fairly
+      # continuously varying rasters (such as elevation models, for instance).
+      # It is also suitable for filling small holes and cracks in more
+      # irregularly varying images (like aerial photos). Its is generally not so
+      # great for interpolating a raster from sparse point data. See GDAL::Grid
+      # for that case.
+      #
+      # Note that this alters values of the current raster band.
+      #
+      # @param mask_band [GDAL::RasterBand] Band that indicates which pixels to
+      #   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
+      #   passes to run.  Can be 0.
+      # @param options [Hash]
+      # TODO: document what valid options are.
+      def fill_nodata!(mask_band, max_search_distance, smoothing_iterations, **options, &progress)
+        mask_band_ptr = GDAL._pointer(GDAL::RasterBand, mask_band)
+        options_ptr = GDAL::Options.pointer(options)
+
+        !!FFI::GDAL.GDALFillNodata(@c_pointer,
+          mask_band_ptr,
+          max_search_distance,
+          0,                    # deprecated option in GDAL
+          smoothing_iterations,
+          options_ptr,
+          progress,
+          nil)
+      end
+
+      # Creates vector polygons for all connected regions of pixels in the raster
+      # that share a common pixel value. Optionally, each polygon may be
+      # labeled with the pixel value in an attribute. Optionally, a mask band
+      # can be provided to determine which pixels are eligible for processing.
+      #
+      # The C API implements two functions for this: +GDALPolygonize+ and
+      # +GDALFPolygonize+, where the former uses a 32-bit Integer buffer and the
+      # latter uses a 32-bit Float buffer. The Integer version may be quicker,
+      # but the Float version more accurate. As such, calling +polygonize+
+      # defaults to use the Float version internally, but you can tell it to use
+      # the Integer version by using the +use_integer_function+ flag.
+      #
+      # Polygon features will be created on +layer+ with Polygon geometries
+      # representing the polygons. The geometries will be in the georeferenced
+      # coordinate system of the image (based on the GeoTransform) of the source
+      # Dataset). It is acceptable for +layer+ to already have other features.
+      #
+      # Note that this does not set the coordinate system on the output
+      # layer--the application is responsible for doing so.
+      #
+      # @param layer [OGR::Layer, FFI::Pointer] The layer to write the polygons
+      #   to.
+      # @param mask_band [GDAL::RasterBand, FFI::Pointer] Optional band, where all
+      #   pixels in the mask with a value other than zero will be considered
+      #   suitable for collection as polygons.
+      # @param pixel_value_field [Fixnum] Index of the feature attribute into
+      #   which the pixel value of the polygon should be written.
+      # @param options [Hash]
+      # @option options [Fixnum] '8CONNECTED' (4) Set to 8 to use 8
+      #   connectedness.
+      # @param progress [Proc]
+      # @return [OGR::Layer]
+      def polygonize(layer, mask_band: nil, pixel_value_field: -1, use_integer_function: false,
+        **options, &progress)
+        mask_band_ptr = GDAL._pointer(GDAL::RasterBand, mask_band, false)
+        layer_ptr = GDAL._pointer(OGR::Layer, layer)
+        fail OGR::InvalidLayer, "Invalid layer: #{layer.inspect}" if layer_ptr.null?
+        log "Pixel value field: #{pixel_value_field}"
+
+        options_ptr = GDAL::Options.pointer(options)
+
+        function = use_integer_function ? :GDALPolygonize : :GDALFPolygonize
+
+        FFI::GDAL::Alg.send(
+          function,
+          @c_pointer,             # hSrcBand
+          mask_band_ptr,          # hMaskBand
+          layer_ptr,              # hOutLayer
+          pixel_value_field,      # iPixValField
+          options_ptr,            # papszOptions
+          progress,               # pfnProgress
+          nil                     # pProgressArg
+        )
+
+        layer_ptr.instance_of?(OGR::Layer) ? layer_ptr : OGR::Layer.new(layer_ptr)
+      end
+
+      # Removes raster polygons that are smaller than the given threshold (in
+      # pixels) and replaces them with the pixel value of the largest neighbor
+      # polygon. Polygons are determined as regions of the raster where the
+      # pixels all have the same value, and that are contiguous (connected).
+      #
+      # 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
+      #   smaller than this will be merged into their largest neighbor.
+      # @param connectedness [Fixnum] 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
+      #   band with a value other than 0 will be considered suitable for
+      #   inclusion in polygons.
+      # @param options [Hash] None supported in GDAL as of this writing.
+      def sieve_filter!(size_threshold, connectedness, mask_band: nil, **options, &progress)
+        _sieve_filter(size_threshold, connectedness, @c_pointer,
+          mask_band: mask_band, **options, &progress)
+      end
+
+      # The same as +sieve_filter!+, but returns a new GDAL::RasterBand as the
+      # result.
+      #
+      # @see +sieve_filter!
+      # @param destination_band [GDAL::RasterBand]
+      def sieve_filter(size_threshold, connectedness, destination_band,
+        mask_band: nil, **options, &progress)
+        destination_band_ptr = GDAL._pointer(GDAL::RasterBand, destination_band)
+        if destination_band.nil? || destination_band.null?
+          fail GDAL::InvalidRasterBand, "destination_band isn't a valid GDAL::RasterBand: #{destination_band}"
+        end
+
+        _sieve_filter(size_threshold, connectedness, destination_band_ptr,
+          mask_band: mask_band, **options, &progress)
+
+        if destination_band.is_a? GDAL::RasterBand
+          destination_band
+        else
+          GDAL::RasterBand.new(destination_band)
+        end
+      end
+
+      private
+
+      def _sieve_filter(size_threshold, connectedness, destination_band_ptr = nil,
+        mask_band: nil, **options, &progress)
+        mask_band_ptr = GDAL._pointer(GDAL::RasterBand, mask_band, false)
+        options_ptr = GDAL::Options.pointer(options)
+
+        FFI::GDAL::Alg.GDALSieveFilter(
+          @c_pointer,
+          mask_band_ptr,
+          destination_band_ptr,
+          size_threshold,
+          connectedness,
+          options_ptr,
+          progress,
+          nil)
+      end
+    end
+  end
+end

data/lib/gdal/raster_band_mixins/extensions.rb

@@ -0,0 +1,238 @@
+require 'json'
+
+module GDAL
+  module RasterBandMixins
+    module Extensions
+      def overviews
+        overview_count.times.map do |i|
+          overview(i)
+        end
+      end
+
+      # @return [Hash{x => Fixnum, y => Fixnum}]
+      def block_count
+        x_blocks = (x_size + block_size[:x]).divmod(block_size[:x])
+        y_blocks = (y_size + block_size[:y]).divmod(block_size[:y])
+
+        {
+          x: x_blocks.first - 1,
+          x_remainder: x_blocks.last,
+          y: y_blocks.first - 1,
+          y_remainder: y_blocks.last
+        }
+      end
+
+      # The buffer size to use for block-based IO, based on #block_size.
+      #
+      # @return [Fixnum]
+      def block_buffer_size
+        block_size[:x] * block_size[:y]
+      end
+
+      # Reads through the raster, block-by-block and yields the pixel data that
+      # it gathered.
+      #
+      # @param to_data_type [FFI::GDAL::DataType]
+      # @return [Enumerator, nil] Returns an Enumerable if no block is given,
+      #   allowing to chain with other Enumerable methods.  Returns nil if a
+      #   block is given.
+      def each_by_block(to_data_type = nil)
+        return enum_for(:each_by_block) unless block_given?
+
+        data_type = to_data_type || self.data_type
+        data_pointer = GDAL._pointer_from_data_type(data_type, block_buffer_size)
+
+        0.upto(block_count[:y]).each do |y_block_number|
+          0.upto(block_count[:x] - 1).each do |x_block_number|
+            y_block_size = if y_block_number == block_count[:y] && !block_count[:y_remainder].zero?
+                             block_count[:y_remainder]
+                           elsif y_block_number == block_count[:y]
+                             0
+                           else
+                             block_size[:y]
+                           end
+
+            next if y_block_size.zero?
+
+            read_block(x_block_number, y_block_number, data_pointer)
+
+            0.upto(y_block_size - 1).each do |block_index|
+              x_read_offset = block_size[:x] * block_index
+
+              pixels = if data_type == :GDT_Byte
+                         data_pointer.get_array_of_uint8(x_read_offset, block_size[:x])
+                       elsif data_type == :GDT_UInt16
+                         data_pointer.get_array_of_uint16(x_read_offset, block_size[:x])
+                       else
+                         data_pointer.get_array_of_float(x_read_offset, block_size[:x])
+                       end
+
+              yield(pixels)
+            end
+          end
+        end
+      end
+
+      # Iterates through all lines and builds an NArray of pixels.
+      #
+      # @return [NArray]
+      def to_na(to_data_type = nil)
+        values = each_by_block.map do |pixels|
+          pixels
+        end
+
+        if to_data_type
+          case to_data_type
+          when :GDT_Byte then NArray.to_na(values).to_type(NArray::BYTE)
+          when :GDT_Int16 then NArray.to_na(values).to_type(NArray::SINT)
+          when :GDT_UInt16 then NArray.to_na(values).to_type(NArray::INT)
+          when :GDT_Int32 then NArray.to_na(values).to_type(NArray::INT)
+          when :GDT_UInt32 then NArray.to_na(values).to_type(NArray::INT)
+          when :GDT_Float32 then NArray.to_na(values).to_type(NArray::SFLOAT)
+          when :GDT_Float64 then NArray.to_na(values).to_type(NArray::DFLOAT)
+          when :GDT_CInt16 then NArray.to_na(values).to_type(NArray::SCOMPLEX)
+          when :GDT_CInt32 then NArray.to_na(values).to_type(NArray::DCOMPLEX)
+          when :GDT_CFloat32 then NArray.to_na(values).to_type(NArray::SCOMPLEX)
+          when :GDT_CFloat64 then NArray.to_na(values).to_type(NArray::DCOMPLEX)
+          else
+            fail "Unknown data type: #{to_data_type}"
+          end
+        else
+          NArray.to_na(values)
+        end
+      end
+
+      # Sets the band to be a Palette band, then applies an RGB color table using
+      # the given colors.  Colors are distributed evenly across the table based
+      # on the number of colors given.  Note that this will overwrite any existing
+      # color table that may be set on this band.
+      #
+      # @param colors [Array<Fixnum, String>, Fixnum, String] Can be a single or
+      #   many colors, given as either R, G, and B integers (0-255) or as strings
+      #   of Hex.
+      #
+      # @example Colors as RGB values
+      #   # This will make the first 128 values black, and the last 128, red.
+      #   my_band.colorize!([[0, 0, 0], [255, 0, 0]])
+      #
+      # @example Colors as Hex values
+      #   # Same as above...
+      #   my_band.colorize!(%w[#000000 #FF0000])
+      def colorize!(*colors)
+        return if colors.empty?
+
+        table = GDAL::ColorTable.new(:GPI_RGB)
+
+        color_entry_index_count =
+          if data_type == :GDT_Byte
+            256
+          elsif data_type == :GDT_UInt16
+            65_536
+          else
+            fail "Can't colorize a #{data_type} band--must be :GDT_Byte or :GDT_UInt16"
+          end
+
+        self.color_interpretation ||= :GCI_PaletteIndex
+        table.add_color_entry(0, 0, 0, 0, 255)
+        bin_count = color_entry_index_count / colors.size.to_f
+
+        1.upto(color_entry_index_count - 1) do |color_entry_index|
+          color_number = (color_entry_index / bin_count).to_i
+
+          color = colors[color_number]
+          # TODO: Fix possible uninitialized rgb_array
+          rgb_array = hex_to_rgb(color) unless color.is_a?(Array)
+          table.add_color_entry(color_entry_index,
+            rgb_array[0], rgb_array[1], rgb_array[2], 255)
+        end
+
+        self.color_table = table
+      end
+
+      # Gets the colors from the associated ColorTable and returns an Array of
+      # those, where each ColorEntry is [R, G, B, A].
+      #
+      # @return [Array<Array<Fixnum>>]
+      def colors_as_rgb
+        return [] unless color_table
+
+        color_table.color_entries_as_rgb.map(&:to_a)
+      end
+
+      # Gets the colors from the associated ColorTable and returns an Array of
+      # Strings, where the RGB color for each ColorEntry has been converted to
+      # Hex.
+      #
+      # @return [Array<String>]
+      def colors_as_hex
+        colors_as_rgb.map do |rgba|
+          rgb = rgba.to_a[0..2]
+
+          "##{rgb[0].to_s(16)}#{rgb[1].to_s(16)}#{rgb[2].to_s(16)}"
+        end
+      end
+
+      # @param hex [String]
+      def hex_to_rgb(hex)
+        hex.sub!(/^#/, '')
+        matches = hex.match(/(?<red>[a-zA-Z0-9]{2})(?<green>[a-zA-Z0-9]{2})(?<blue>[a-zA-Z0-9]{2})/)
+
+        [matches[:red].to_i(16), matches[:green].to_i(16), matches[:blue].to_i(16)]
+      end
+
+      # Each pixel of the raster projected using the dataset's geo_transform.
+      #
+      # @return [NArray]
+      def projected_points
+        point_count = (y_size) * (x_size)
+        narray = NArray.object(2, point_count)
+
+        0.upto(y_size - 1).each do |y_point|
+          0.upto(x_size - 1).each do |x_point|
+            hash = dataset.geo_transform.apply_geo_transform(y_point, x_point)
+            point_number = y_point * x_point
+            narray[0, point_number] = hash[:y_geo] || 0
+            narray[1, point_number] = hash[:x_geo] || 0
+          end
+        end
+
+        narray
+      end
+
+      # @return [Hash]
+      def as_json(_options = nil)
+        {
+          raster_band: {
+            block_size: block_size,
+            category_names: category_names,
+            color_interpretation: color_interpretation,
+            color_table: color_table,
+            data_type: data_type,
+            default_histogram: default_histogram(true),
+            default_raster_attribute_table: default_raster_attribute_table,
+            has_arbitrary_overviews: arbitrary_overviews?,
+            mask_flags: mask_flags,
+            maximum_value: maximum_value,
+            minimum_value: minimum_value,
+            no_data_value: no_data_value,
+            number: number,
+            offset: offset,
+            overview_count: overview_count,
+            overviews: overviews,
+            scale: scale,
+            statistics: statistics,
+            unit_type: unit_type,
+            x_size: x_size,
+            y_size: y_size
+          },
+          metadata: all_metadata
+        }
+      end
+
+      # @return [String]
+      def to_json(options = nil)
+        as_json(options).to_json
+      end
+    end
+  end
+end

data/lib/gdal/rpc_info.rb

@@ -0,0 +1,35 @@
+require_relative '../ffi/gdal/rpc_info'
+require_relative '../ffi/gdal/alg'
+require 'forwardable'
+
+module GDAL
+  # @return [FFI::GDAL::RPCInfo]
+  attr_reader :c_struct
+
+  # Wrapper for FFI::GDAL::RPCInfo.
+  class RPCInfo
+    extend Forwardable
+    def_delegator :@c_struct, :[]
+
+    # @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
+                    struct_or_ptr
+                  elsif struct_or_ptr.is_a? FFI::Pointer
+                    FFI::GDAL::RPCInfo.new(struct_or_ptr)
+                  else
+                    FFI::GDAL::RPCInfo.new
+                  end
+    end
+
+    # @return [FFI::Pointer]
+    def c_pointer
+      @c_struct.to_ptr
+    end
+
+    # @return [Array<String>]
+    def to_metadata
+      FFI::GDAL::Alg.RPCInfoToMD(@c_struct).read_array_of_string(0)
+    end
+  end
+end

data/lib/gdal/transformer.rb

@@ -0,0 +1,15 @@
+require_relative '../ffi/gdal/alg'
+
+module GDAL
+  class Transformer
+    # @return [FFI::Pointer]
+    def self.create_similar_transformer(transformer_arg_ptr, source_ratio_x, source_ratio_y)
+      FFI::GDAL::Alg.GDALCreateSimilarTransformer(transformer_arg_ptr, source_ratio_x, source_ratio_y)
+    end
+
+    # @param transformer_arg [FFI::Pointer]
+    def self.destroy_transformer(transformer_arg)
+      FFI::GDAL::Alg.GDALDestroyTransformer(transformer_arg)
+    end
+  end
+end