ffi-gdal 1.0.0.beta5 → 1.0.0.beta6

data/lib/gdal/raster_band_classifier.rb

@@ -1,3 +1,5 @@
+require_relative '../gdal'
+
 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
@@ -28,7 +30,7 @@ module GDAL
     # @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
+      raise 'range must be a Ruby Range' unless range.is_a? Range
 
       @ranges << { range: range, map_to: map_to_value }
     end
@@ -49,14 +51,16 @@ module GDAL
     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])]
+      return [] if sorted_and_masked_pixels.empty?
+
       range_size = (sorted_and_masked_pixels.size / range_count).to_i
 
-      log "Pixel count: #{sorted_and_masked_pixels.size}"
+      log "Masked pixel count/total pixel count: #{sorted_and_masked_pixels.size}/#{sorted_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}"
 
-      break_values = range_count.times.map { |i| sorted_and_masked_pixels[range_size * i] }
+      break_values = Array.new(range_count) { |i| sorted_and_masked_pixels[range_size * i] }.uniq
       log "Break values: #{break_values}"
       return if break_values.uniq.size != range_count
 
@@ -82,23 +86,20 @@ module GDAL
     # 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
+      nodata_value = @raster_band.no_data_value[:value]
+      band_pixels = @raster_band.to_na
+      new_band_pixels = GDAL._narray_from_data_type(@raster_band.data_type, @raster_band.x_size, @raster_band.y_size)
+      new_band_pixels[band_pixels.eq(nodata_value)] = nodata_value
+
+      @ranges.each do |r|
+        new_band_pixels[
+          band_pixels.ne(nodata_value).
+          and(band_pixels.le(r[:range].max)).
+          and(band_pixels.ge(r[:range].min))
+        ] = r[:map_to]
       end
 
-      @raster_band.write_array(narray, buffer_data_type: @raster_band.data_type)
+      @raster_band.write_xy_narray(new_band_pixels)
     end
 
     private

data/lib/gdal/raster_band_mixins/algorithm_extensions.rb

@@ -0,0 +1,107 @@
+require_relative '../../ogr'
+
+module GDAL
+  module RasterBandMixins
+    # RasterBand methods for doing warp-like things, but not using GDAL's Warp
+    # API.
+    module AlgorithmExtensions
+      # A method that doesn't use GDAL's Warp API for erasing pixels (setting to
+      # NODATA) in the method-owning RasterBand. It simply iterates over all of
+      # the valued pixels (ones that aren't NODATA pixels) and yields them to a
+      # block. The return value of the block tells the method whether to keep
+      # the pixel or not: a truthy return value keeps the pixel; a false value
+      # sets the pixel value to the band's NODATA value. If there's no NODATA
+      # value set, it will raise an exception.
+      #
+      # A typical clip operation would be from checking to see if the
+      # RasterBand's pixel is within some Polygon. Doing so would look like:
+      #
+      # @example Clipping by polygon
+      #
+      #   contrived_wkt = 'POLYGON ((0 0, 0 20, 20 20, 20 0, 0 0))'
+      #   polygon = OGR::Geometry.create_from_wkt(contrived_wkt)
+      #
+      #   # Note the 'w' to open for writing!
+      #   dataset = GDAL::Dataset.open('my.tif', 'w')
+      #   geo_transform = dataset.geo_transform
+      #   test_point = OGR::Point.new
+      #
+      #   dataset.raster_band(1).simple_erase! do |pixel_num, line_num|
+      #     # Project the pixel using the dataset's GeoTransform
+      #     projected_point_values = geo_transform.apply_geo_transform(pixel_num, line_num)
+      #     test_point.set_point(projected_point_values[:x_geo], projected_point_values[:y_geo])
+      #
+      #     test_point.within? polygon
+      #   end
+      #
+      #   # Make sure to close the dataset so the changes get flushed to disk.
+      #   dataset.close
+      #
+      # You could, however use any other criteria in the block for erasing
+      # points away. The method also the pixel value in case you can use it for
+      # erasing. Perhaps, for example, you want to remove all pixels in the
+      # upper left quadrant of your raster that have a value less than 0. That
+      # would look like:
+      #
+      # @example Erasing using pixel location and values
+      #
+      #   dataset = GDAL::Dataset.open('my.tif', 'w')
+      #   raster_band = dataset.raster_band(1)
+      #
+      #   raster_band.simple_erase! do |x, y, value|
+      #     if x < (raster_band.x_size / 2) && y < (raster_band.y_size / 2) && value < 0
+      #       false
+      #     else
+      #       true
+      #     end
+      #   end
+      #
+      # @return [Fixnum] The number of pixels that were erased.
+      def simple_erase!
+        erase_value = no_data_value[:value]
+        write_buffer = GDAL._buffer_from_data_type(data_type, x_size)
+        erased_pixel_count = 0
+
+        unless erase_value
+          raise GDAL::NoRasterEraseValue,
+            'Cannot erase values, RasterBand does not have a NODATA value set'
+        end
+
+        y_size.times do |line_num|
+          pixel_row = raster_io('r', x_size: x_size, y_size: 1, x_offset: 0, y_offset: line_num)
+          pixel_values = GDAL._read_pointer(pixel_row, data_type, x_size)
+          row_changed = false
+          pixel_num = 0
+
+          while pixel_num < pixel_values.length
+            pixel_value = pixel_values[pixel_num]
+            next if pixel_value == no_data_value[:value]
+
+            keep_in_raster = yield(pixel_num, line_num, pixel_value)
+            next if keep_in_raster
+
+            erased_pixel_count += 1
+            pixel_values[pixel_num] = erase_value
+            row_changed = true
+            pixel_num += 1
+          end
+
+          rewrite_pixel_row(write_buffer, pixel_values, line_num) if row_changed
+        end
+
+        erased_pixel_count
+      end
+
+      private
+
+      # @param write_buffer [FFI::Buffer]
+      # @param pixel_values [Array<Number>]
+      # @param line_number [Fixnum]
+      def rewrite_pixel_row(write_buffer, pixel_values, line_number)
+        GDAL._write_pointer(write_buffer, data_type, pixel_values)
+        raster_io('w', write_buffer, x_size: x_size, y_size: 1, y_offset: line_number)
+        write_buffer.clear
+      end
+    end
+  end
+end

data/lib/gdal/raster_band_mixins/algorithm_methods.rb

@@ -1,5 +1,3 @@
-require_relative '../../ffi/gdal/alg'
-
 module GDAL
   module RasterBandMixins
     module AlgorithmMethods
@@ -18,22 +16,25 @@ module GDAL
         # @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
+        # @param color_interpretation [FFI::GDAL::GDAL::PaletteInterp] The type
         #   of ColorTable to return.
+        # @param progress_function [Proc, FFI:GDAL::GDAL.ProgressFunc]
+        # @param progress_arg [FFI::Pointer] Usually used when when using a
+        #   +FFI::CPL::Progress.GDALCreateScaledProgress+.
         # @return [GDAL::ColorTable]
         def compute_median_cut_pct(red_band, green_band, blue_band,
-          colors, color_interpretation, &progress)
+          colors, color_interpretation, progress_function: nil, progress_arg: nil)
           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.
+            nil, # This isn't yet supported in GDAL.
             colors,
             color_table.c_pointer,
-            progress,
-            nil)
+            progress_function,
+            progress_arg)
 
           color_table
         end
@@ -54,10 +55,13 @@ module GDAL
         # @param blue_band [GDAL::RasterBand, FFI::Pointer]
         # @param output_band [GDAL::RasterBand, FFI::Pointer]
         # @param color_table [GDAL::ColorTable, FFI::Pointer]
+        # @param progress_function [Proc, FFI:GDAL::GDAL.ProgressFunc]
+        # @param progress_arg [FFI::Pointer] Usually used when when using a
+        #   +FFI::CPL::Progress.GDALCreateScaledProgress+.
         # @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)
+          color_table, progress_function: nil, progress_arg: nil)
           red_ptr = GDAL._pointer(GDAL::RasterBand, red_band)
           green_ptr = GDAL._pointer(GDAL::RasterBand, green_band)
           blue_ptr = GDAL._pointer(GDAL::RasterBand, blue_band)
@@ -70,8 +74,8 @@ module GDAL
             blue_ptr,
             output_ptr,
             color_table_ptr,
-            progress,
-            nil)
+            progress_function,
+            progress_arg)
 
           output_band
         end
@@ -105,6 +109,9 @@ module GDAL
       # values.
       #
       # @param proximity_band [GDAL::RasterBand, FFI::Pointer]
+      # @param progress_function [Proc, FFI:GDAL::GDAL.ProgressFunc]
+      # @param progress_arg [FFI::Pointer] Usually used when when using a
+      #   +FFI::CPL::Progress.GDALCreateScaledProgress+.
       # @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
@@ -118,7 +125,7 @@ module GDAL
       # @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)
+      def compute_proximity!(proximity_band, progress_function: nil, progress_arg: nil, **options)
         proximity_band_ptr = GDAL._pointer(GDAL::RasterBand, proximity_band)
         options_ptr = GDAL::Options.pointer(options)
 
@@ -126,8 +133,8 @@ module GDAL
           @c_pointer,
           proximity_band_ptr,
           options_ptr,
-          progress,
-          nil)
+          progress_function,
+          progress_arg)
       end
 
       # Fill selected raster regions by interpolation from the edges. It
@@ -153,20 +160,24 @@ module GDAL
       #   directions to find values to interpolate from.
       # @param smoothing_iterations [Fixnum] 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
+      #   +FFI::CPL::Progress.GDALCreateScaledProgress+.
       # @param options [Hash]
       # TODO: document what valid options are.
-      def fill_nodata!(mask_band, max_search_distance, smoothing_iterations, **options, &progress)
+      def fill_nodata!(mask_band, max_search_distance, smoothing_iterations, progress_function: nil, progress_arg: nil,
+        **options)
         mask_band_ptr = GDAL._pointer(GDAL::RasterBand, mask_band)
         options_ptr = GDAL::Options.pointer(options)
 
-        !!FFI::GDAL.GDALFillNodata(@c_pointer,
+        !!FFI::GDAL::Alg.GDALFillNodata(@c_pointer,
           mask_band_ptr,
           max_search_distance,
-          0,                    # deprecated option in GDAL
+          0, # deprecated option in GDAL
           smoothing_iterations,
           options_ptr,
-          progress,
-          nil)
+          progress_function,
+          progress_arg)
       end
 
       # Creates vector polygons for all connected regions of pixels in the raster
@@ -196,16 +207,23 @@ module GDAL
       #   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 use_integer_function [Boolean] Indicates using GDAL's
+      #   GDALPolygonize() instead of GDALFPolygonize(); the former uses a
+      #   32-bit integer buffer for reading pixel band values, the latter uses a
+      #   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
       #   connectedness.
-      # @param progress [Proc]
+      # @param progress_function [Proc, FFI:GDAL::GDAL.ProgressFunc]
+      # @param progress_arg [FFI::Pointer] Usually used when when using a
+      #   +FFI::CPL::Progress.GDALCreateScaledProgress+.
       # @return [OGR::Layer]
-      def polygonize(layer, mask_band: nil, pixel_value_field: -1, use_integer_function: false,
-        **options, &progress)
+      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)
         layer_ptr = GDAL._pointer(OGR::Layer, layer)
-        fail OGR::InvalidLayer, "Invalid layer: #{layer.inspect}" if layer_ptr.null?
+        raise OGR::InvalidLayer, "Invalid layer: #{layer.inspect}" if layer_ptr.null?
         log "Pixel value field: #{pixel_value_field}"
 
         options_ptr = GDAL::Options.pointer(options)
@@ -219,8 +237,8 @@ module GDAL
           layer_ptr,              # hOutLayer
           pixel_value_field,      # iPixValField
           options_ptr,            # papszOptions
-          progress,               # pfnProgress
-          nil                     # pProgressArg
+          progress_function,      # pfnProgress
+          progress_arg            # pProgressArg
         )
 
         layer_ptr.instance_of?(OGR::Layer) ? layer_ptr : OGR::Layer.new(layer_ptr)
@@ -242,10 +260,16 @@ module GDAL
       # @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 progress_function [Proc, FFI:GDAL::GDAL.ProgressFunc]
+      # @param progress_arg [FFI::Pointer] Usually used when when using a
+      #   +FFI::CPL::Progress.GDALCreateScaledProgress+.
       # @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)
+      def sieve_filter!(size_threshold, connectedness, mask_band: nil, progress_function: nil, progress_arg: nil,
+        **options)
+        _sieve_filter(size_threshold, connectedness, self, mask_band: mask_band,
+                                                           progress_function: progress_function,
+                                                           progress_arg: progress_arg,
+                                                           **options)
       end
 
       # The same as +sieve_filter!+, but returns a new GDAL::RasterBand as the
@@ -253,15 +277,12 @@ module GDAL
       #
       # @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)
+      def sieve_filter(size_threshold, connectedness, destination_band, mask_band: nil, progress_function: nil,
+        progress_arg: nil, **options)
+        _sieve_filter(size_threshold, connectedness, destination_band, mask_band: mask_band,
+                                                                       progress_function: progress_function,
+                                                                       progress_arg: progress_arg,
+                                                                       **options)
 
         if destination_band.is_a? GDAL::RasterBand
           destination_band
@@ -272,9 +293,27 @@ module GDAL
 
       private
 
-      def _sieve_filter(size_threshold, connectedness, destination_band_ptr = nil,
-        mask_band: nil, **options, &progress)
+      # @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 progress_function [Proc, FFI:GDAL::GDAL.ProgressFunc]
+      # @param progress_arg [FFI::Pointer] Usually used when when using a
+      #   +FFI::CPL::Progress.GDALCreateScaledProgress+.
+      # @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)
+        destination_band_ptr = GDAL._pointer(GDAL::RasterBand, destination_band)
+
+        if destination_band.nil? || destination_band.null?
+          raise GDAL::InvalidRasterBand, "destination_band isn't a valid GDAL::RasterBand: #{destination_band}"
+        end
+
         options_ptr = GDAL::Options.pointer(options)
 
         FFI::GDAL::Alg.GDALSieveFilter(
@@ -284,8 +323,8 @@ module GDAL
           size_threshold,
           connectedness,
           options_ptr,
-          progress,
-          nil)
+          progress_function,
+          progress_arg)
       end
     end
   end

data/lib/gdal/raster_band_mixins/coloring_extensions.rb

@@ -0,0 +1,84 @@
+module GDAL
+  module RasterBandMixins
+    # RasterBand methods added for dealing with colorizing.
+    module ColoringExtensions
+      # 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?
+
+        self.color_interpretation ||= :GCI_PaletteIndex
+        table = GDAL::ColorTable.new(:GPI_RGB)
+        table.add_color_entry(0, 0, 0, 0, 255)
+
+        # Start at 1 instead of 0 because we manually set the first color entry
+        # to white.
+        color_entry_index_range =
+          case data_type
+          when :GDT_Byte then 1..255
+          when :GDT_UInt16 then 1..65_535
+          else raise "Can't colorize a #{data_type} band--must be :GDT_Byte or :GDT_UInt16"
+          end
+
+        bin_count = (color_entry_index_range.last + 1) / colors.size.to_f
+
+        color_entry_index_range.step do |color_entry_index|
+          color_number = (color_entry_index / bin_count).floor.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
+    end
+  end
+end