ffi-gdal 1.0.0.beta4 → 1.0.0.beta5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 034858e4f3db966a8a5d994ed558d88727b87a3b
-  data.tar.gz: d4a624f17336db3eb515c2b3edcf2b5cba6d692a
+  metadata.gz: b5e2273d2b75bb5a7af15693af6a84cb32c74852
+  data.tar.gz: f986fe1b75a472ce0a0d663d13ceed15714e0ef0
 SHA512:
-  metadata.gz: 5eb6d526bf0a2a0d2524426d63d619a5bc44a0ee8a97c2cc1c814dc180257e688fdd7f00b0089720ee9a943468ac6857c4ee546ba0969fc33a5b7a8ab8b4c48c
-  data.tar.gz: 4bab75341f049696458a47293ebe6c36977b7d53920db502ee6d6e54a6c3f94415bcbebf53a636a1bef54cae5f57a0773aa69ecc909852319be831400d00cc3d
+  metadata.gz: 584e34e7de26e51fff046707de49750f8071d937dac8259ad594387f1ff60c7bca2fa72c22fad48525fdd3cf42a6d734a564d4d054aac675ba48c7a55ed4e3e8
+  data.tar.gz: c8eca7619a1eeaf878582c8efead2bde968a52149e92cd64ad37fbb3475bcc2f25ba2182da3cfa200e9ce8925ca90c60a55be5b59b43998d1d2a867843f35e7a

data/History.md

@@ -1,83 +1,109 @@
-### 1.0.0.beta4 / 2015-04-22
+# Change Log
+
+Format for this file derived from [http://keepachangelog.com](http://keepachangelog.com).
+
+## 1.0.0.beta5 / 2015-06-16
+
+* Improvements
+    * `GDAL::RasterBandClassifier#equal_count_ranges` now returns `nil` if there
+      aren't enough points per group/class to return the requested number of
+      breaks.
+    * Simplified NDVI (and related) methods in
+      `GDAL::DatasetMixins::Extensions`.
+    * NDVI and related methods in `GDAL::DatasetMixins::Extensions` now close
+      the newly created dataset instead of leaving it open. It's been far too
+      easy to forget to close the dataset after creation, leaving seemingly
+      incorrect resulting datasets (since GDAL doesn't flush writes until the
+      dataset is closed).
+    * NDVI methods in `GDAL::DatasetMixins::Extensions` no longer check for
+      NaNs after doing the NDVI calculations, thus speeding up the algorithm.
+    * `GDAL::DatasetMixins::Extensions#remove_negatives_from` now uses an NArray
+      mask to remove the negative values instead of looping through each value.
+    * Added `GDAL::RasterBand#raster_io` and refactored
+      `GDAL::RasterBand#write_array` to use it.
+    * `GDAL::DatasetMixins::Extensions` NDVI methods now default to NODATA of -9999.0.
+
+## 1.0.0.beta4 / 2015-04-22
 
 Whoa there's lots of changes here... Many are outlined below, but there's really
 a ton more.
 
 * Improvements
-  * Full refactor of FFI/C function wrapper. Closer mapping of Ruby functions
-    within modules to the C-header files where the functions actually reside.
-  * Full redesign of the error handling mechanism; ffi-gdal now hooks in to
-    GDAL's error handling, thus errors raised from GDAL automagically get handed
-    over as Ruby exceptions. (GDAL only; OGR doesn't provide this.) This also
-    entailed adding a bunch of new exceptions and renaming some old ones.
-  * Better library finding on Linux.
-  * Wrapped most of GDAL's Grid API.
-  * Wrapped some of GDAL's Warp API.
-  * GDAL::Dataset can now open PostGISRaster datasets.
-  * Lots more OGR love. Much of this API has now been vetted.
-  * Added `GDAL::RasterClassifier` for classifying raster bands.
-  * Added some wrapper methods for classes that support capability testing.
+    * Full refactor of FFI/C function wrapper. Closer mapping of Ruby functions
+      within modules to the C-header files where the functions actually reside.
+    * Full redesign of the error handling mechanism; ffi-gdal now hooks in to
+      GDAL's error handling, thus errors raised from GDAL automagically get handed
+      over as Ruby exceptions. (GDAL only; OGR doesn't provide this.) This also
+      entailed adding a bunch of new exceptions and renaming some old ones.
+    * Better library finding on Linux.
+    * Wrapped most of GDAL's Grid API.
+    * Wrapped some of GDAL's Warp API.
+    * GDAL::Dataset can now open PostGISRaster datasets.
+    * Lots more OGR love. Much of this API has now been vetted.
+    * Added `GDAL::RasterClassifier` for classifying raster bands.
+    * Added some wrapper methods for classes that support capability testing.
 * Bug fixes
-  * Fixed some GDAL::Dataset extension methods (`extract_ndvi` and friends)
-    that weren't properly handling various data types.
-  * Better handling of large files.
-  * Fixed regular crashes when dealing with OGR Geometries and
-    SpatialReferences.
+    * Fixed some GDAL::Dataset extension methods (`extract_ndvi` and friends)
+      that weren't properly handling various data types.
+    * Better handling of large files.
+    * Fixed regular crashes when dealing with OGR Geometries and
+      SpatialReferences.
 
-### 1.0.0.beta3 / 2014-11-11
+## 1.0.0.beta3 / 2014-11-11
 
 * Bug fixes
-  * `ogr/exceptions` wasn't being required for `ext/error_symbols.rb`, thus
-    any use of an OGR exception was causing a `NameError`.
+    * `ogr/exceptions` wasn't being required for `ext/error_symbols.rb`, thus
+      any use of an OGR exception was causing a `NameError`.
 
-### 1.0.0.beta2 / 2014-10-23
+## 1.0.0.beta2 / 2014-10-23
 
 * Improvements
-  * Added more documentation
-  * Uncommented `attach_function` calls that had been commented out due to
-    lack of support in versions I'd tested on.  These get handled now on load.
+    * Added more documentation
+    * Uncommented `attach_function` calls that had been commented out due to
+      lack of support in versions I'd tested on.  These get handled now on load.
+
+## 1.0.0.beta1 / 2014-10-23
 
-### 1.0.0.beta1 / 2014-10-23
+Lots of changes, so just the highlights here...
 
-* Lots of changes, so just the highlights here...
 * API Improvements
-  * Added C and Ruby wrapper for most of OGR.
-  * Better handling of CPLErr return values.
-  * Allow loading, even when C functions aren't defined in the version of
-    GDAL that you're using.
-  * Split out additions to GDAL/OGR in `*_extensions.rb` modules.  Methods
-    contained in `Extentions` modules don't directly wrap GDAL/OGR functions,
-    but either provide new functionality or attempt to make library usage more
-    Rubyesque.
-  * Added `#as_json`, `#to_json` to many classes.
+    * Added C and Ruby wrapper for most of OGR.
+    * Better handling of CPLErr return values.
+    * Allow loading, even when C functions aren't defined in the version of
+      GDAL that you're using.
+    * Split out additions to GDAL/OGR in `*_extensions.rb` modules.  Methods
+      contained in `Extentions` modules don't directly wrap GDAL/OGR functions,
+      but either provide new functionality or attempt to make library usage more
+      Rubyesque.
+    * Added `#as_json`, `#to_json` to many classes.
 * Internal Improvements
-  * Lots of cleanup of class internals.
-  * `autoload` child GDAL and OGR Ruby classes.
-  * Renamed files under ffi/ that were derived from GDAL/OGR header files to
-    include `_h` in the name.
+    * Lots of cleanup of class internals.
+    * `autoload` child GDAL and OGR Ruby classes.
+    * Renamed files under ffi/ that were derived from GDAL/OGR header files to
+      include `_h` in the name.
 
-### 0.0.4 / 2014-09-27
+## 0.0.4 / 2014-09-27
 
 * Bug fixes
-  * Fixed failure to load on Ubuntu 12.04 (GDAL v1.7.3).
+    * Fixed failure to load on Ubuntu 12.04 (GDAL v1.7.3).
 
-### 0.0.3 / 2014-09-26
+## 0.0.3 / 2014-09-26
 
 * Improvements
-  * The `approx_ok` param for `RasterBand#histogram` should default to
-    `false` (preferring data exactness over performance).
+    * The `approx_ok` param for `RasterBand#histogram` should default to
+      `false` (preferring data exactness over performance).
 * Bug fixes
-  * Fixed URL silliness introduced in 0.0.2.
-  * `Dataset#*_band` methods should return `nil` if the band with that color
-    isn't found.
-  * `RasterBand#default_histogram` died if the band didn't have any values.
-  * `RasterBand#histogram` wasn't returning totals.
+    * Fixed URL silliness introduced in 0.0.2.
+    * `Dataset#*_band` methods should return `nil` if the band with that color
+      isn't found.
+    * `RasterBand#default_histogram` died if the band didn't have any values.
+    * `RasterBand#histogram` wasn't returning totals.
 
-### 0.0.2 / 2014-09-26
+## 0.0.2 / 2014-09-26
 
 * New things
-  * Added ability to pass a URL into `GDAL::Dataset`.
+    * Added ability to pass a URL into `GDAL::Dataset`.
 
-### 0.0.1 / 2014-09-26
+## 0.0.1 / 2014-09-26
 
 * Happy Birthday!

data/README.md

@@ -52,7 +52,7 @@ Testing
 
 You'll need some images to run the integration specs against, and instead of
 keeping those as part of this repo, there's a Rake task that will pull OSGeo's
-set of sample geotiffs down via FTP.  Running `rake get_tifs` will pull
+set of sample geotiffs down via FTP.  Running `rake get_tiffs` will pull
 everything down from ftp://downloads.osgeo.org/geotiff/samples and put the
 files under spec/support/images/osgeo/geotiff.
 

data/lib/ffi/gdal/grid_inverse_distance_to_a_power_options.rb

@@ -10,8 +10,8 @@ module FFI
         :radius1, :double,
         :radius2, :double,
         :angle, :double,
-        :max_points, :GUInt32,
-        :min_points, :GUInt32,
+        :max_points, CPL::Port.find_type(:GUInt32),
+        :min_points, CPL::Port.find_type(:GUInt32),
         :no_data_value, :double
     end
   end

data/lib/ffi/gdal/version.rb

@@ -1,5 +1,5 @@
 module FFI
   module GDAL
-    VERSION = '1.0.0.beta4'
+    VERSION = '1.0.0.beta5'
   end
 end

data/lib/gdal/dataset.rb

@@ -66,6 +66,7 @@ module GDAL
       ObjectSpace.define_finalizer self, -> { close }
 
       @geo_transform = nil
+      @raster_bands = Array.new(raster_count)
     end
 
     # Close the dataset.
@@ -137,18 +138,9 @@ module GDAL
         fail GDAL::InvalidRasterBand, "Invalid raster band number '#{raster_index}'. Must be <= #{raster_count}"
       end
 
-      @raster_bands ||= Array.new(raster_count)
-      zero_index = raster_index - 1
-
-      if @raster_bands[zero_index] && !@raster_bands[zero_index].null?
-        return @raster_bands[zero_index]
-      end
-
       raster_band_ptr = FFI::GDAL.GDALGetRasterBand(@c_pointer, raster_index)
-      @raster_bands[zero_index] = GDAL::RasterBand.new(raster_band_ptr)
-      @raster_bands.compact!
 
-      @raster_bands[zero_index]
+      GDAL::RasterBand.new(raster_band_ptr)
     end
 
     # @param type [FFI::GDAL::DataType]
@@ -177,7 +169,7 @@ module GDAL
     # @param new_projection [String]
     # @return [Boolean]
     def projection=(new_projection)
-      !!FFI::GDAL.GDALSetProjection(@c_pointer, new_projection)
+      FFI::GDAL.GDALSetProjection(@c_pointer, new_projection.to_s)
     end
 
     # @return [GDAL::GeoTransform]
@@ -299,13 +291,7 @@ module GDAL
       x_size ||= raster_x_size
       y_size ||= raster_y_size
 
-      gdal_access_flag =
-        case access_flag
-        when 'r' then :GF_Read
-        when 'w' then :GF_Write
-        else fail "Invalid access flag: #{access_flag}"
-        end
-
+      gdal_access_flag = GDAL._gdal_access_flag(access_flag)
       x_buffer_size = x_size
       y_buffer_size = y_size
 

data/lib/gdal/dataset_mixins/extensions.rb

@@ -1,5 +1,6 @@
 require 'json'
 require 'narray'
+require_relative '../../ffi-gdal'
 require_relative '../raster_band'
 require_relative '../warp_operation'
 require_relative '../../ogr/driver'
@@ -11,119 +12,53 @@ module GDAL
   module DatasetMixins
     # Methods not originally supplied with GDAL, but enhance it.
     module Extensions
-      # Computes NDVI from the red and near-infrared bands in the dataset.  Raises
-      # a GDAL::RequiredBandNotFound if one of those band types isn't found.
+      # Computes NDVI from the red and near-infrared bands in the dataset.
+      # Raises a GDAL::RequiredBandNotFound if one of those band types isn't
+      # found. Also, it closes the dataset to ensure all data and metadata have
+      # been flushed to disk. To work with the file, you'll need to reopen it.
       #
       # @param destination [String] Path to output the new dataset to.
-      # @param driver_name [String] The type of dataset to create.
-      # @param band_order [Array<String>] The list of band types, i.e. ['red',
-      #   'green', 'blue'].
+      # @param red_band_number [Fixnum] Number of the band in the dataset that
+      #   contains red data. Note that you can pass in band numbers of other
+      #   types to perform NDVI using that type (ex. GNDVI).
+      # @param nir_band_number [Fixnum] Number of the band in the dataset that
+      #   contains near-infrared data data.
+      # @param driver_name [String] The driver name to use for creating the
+      #   dataset. Defaults to "GTiff".
       # @param output_data_type [FFI::GDAL::DataType] Resulting dataset will be
-      #   in this data type.
+      #   in this data type. Defaults to use the current data type.
       # @param remove_negatives [Boolean] Remove negative values after
-      #   calculating NDVI.
-      # @param no_data_value [Float]
+      #   calculating NDVI. Defaults to +false+.
+      # @param no_data_value [Float] Value to set the band's NODATA value to.
+      #   Defaults to -9999.0.
       # @param options [Hash] Options that get used for creating the new NDVI
       #   dataset. See docs for GDAL::Driver#create_dataset.
       # @return [GDAL::Dataset] The new NDVI dataset. *Be sure to call #close on
       #   this object or the data may not persist!*
-      def extract_ndvi(destination, driver_name: 'GTiff', band_order: nil,
-                       output_data_type: :GDT_Byte, remove_negatives: false,
-                       no_data_value: -9999.0,
-                       **options)
-        original_bands =
-          if band_order
-            bands_with_labels(band_order)
-          else
-            {
-              red: red_band,
-              green: green_band,
-              blue: blue_band,
-              nir: undefined_band
-            }
-          end
-
-        red = original_bands[:red]
-        nir = original_bands[:nir]
-
-        if red.nil?
-          fail RequiredBandNotFound, 'Red band not found.'
-        elsif nir.nil?
-          fail RequiredBandNotFound, 'Near-infrared'
-        end
-
-        the_array = calculate_ndvi(red.to_na,
-          nir.to_na,
-          no_data_value,
-          remove_negatives,
-          output_data_type)
+      def extract_ndvi(destination, red_band_number, nir_band_number, driver_name: 'GTiff',
+        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?
+
+        output_data_type ||= red.data_type
+        the_array = calculate_ndvi(red.to_na, nir.to_na, no_data_value, remove_negatives, output_data_type)
         driver = GDAL::Driver.by_name(driver_name)
 
-        driver.create_dataset(destination, raster_x_size, raster_y_size,
+        ndvi = driver.create_dataset(destination, raster_x_size, raster_y_size,
           data_type: output_data_type, **options) do |ndvi_dataset|
           ndvi_dataset.geo_transform = geo_transform
           ndvi_dataset.projection = projection
 
           ndvi_band = ndvi_dataset.raster_band(1)
-          ndvi_band.write_array(the_array, data_type: output_data_type)
+          ndvi_band.write_array(the_array)
           ndvi_band.no_data_value = no_data_value
         end
-      end
-
-      # Computes GNDVI from the green and near-infrared bands in the dataset.
-      # Raises a GDAL::RequiredBandNotFound if one of those band types isn't
-      # found.
-      #
-      # @param destination [String] Path to output the new dataset to.
-      # @param driver_name [String] The type of dataset to create.
-      # @param band_order [Array<String>] The list of band types, i.e. ['red',
-      #   'green', 'blue'].
-      # @param output_data_type [FFI::GDAL::DataType] Resulting dataset will be
-      #   in this data type.
-      # @param remove_negatives [Boolean] Remove negative values after
-      #   calculating NDVI.
-      # @param no_data_value [Float]
-      # @param options [Hash] Options that get used for creating the new NDVI
-      #   dataset. See docs for GDAL::Driver#create_dataset.
-      # @return [GDAL::Dataset] The new NDVI dataset. *Be sure to call #close on
-      #   this object or the data may not persist!*
-      def extract_gndvi(destination, driver_name: 'GTiff', band_order: nil,
-        output_data_type: :GDT_Byte, remove_negatives: false, no_data_value: -9999.0,
-        **options)
-        original_bands =
-          if band_order
-            bands_with_labels(band_order)
-          else
-            {
-              red: red_band,
-              green: green_band,
-              blue: blue_band,
-              nir: undefined_band
-            }
-          end
-
-        green = original_bands[:green]
-        nir = original_bands[:nir]
-
-        if green.nil?
-          fail RequiredBandNotFound, 'Green band not found.'
-        elsif nir.nil?
-          fail RequiredBandNotFound, 'Near-infrared'
-        end
-
-        the_array = calculate_ndvi(green.to_na, nir.to_na,
-          no_data_value, remove_negatives, output_data_type)
-        driver = GDAL::Driver.by_name(driver_name)
 
-        driver.create_dataset(destination, raster_x_size, raster_y_size,
-          data_type: output_data_type, **options) do |gndvi_dataset|
-          gndvi_dataset.geo_transform = geo_transform
-          gndvi_dataset.projection = projection
+        ndvi.close
 
-          gndvi_band = gndvi_dataset.raster_band(1)
-          gndvi_band.write_array(the_array, data_type: output_data_type)
-          gndvi_band.no_data_value = no_data_value
-        end
+        ndvi
       end
 
       # Extracts the NIR band and writes to a new file.  NOTE: be sure to close
@@ -136,20 +71,19 @@ module GDAL
       # @param driver_name [String] the GDAL::Driver short name to use for the
       #   new dataset.
       # @param output_data_type [FFI::GDAL::DataType] Resulting dataset will be
-      #   in this data type.
+      #   in this data type. Defaults to use the current data type.
       # @param options [Hash] Options that get used for creating the new NDVI
       #   dataset. See docs for GDAL::Driver#create_dataset.
       # @return [GDAL::Dataset] The new NIR dataset. *Be sure to call #close on
       #   this object or the data may not persist!*
-      def extract_nir(destination, band_number, driver_name: 'GTiff', output_data_type: :GDT_Byte, **options)
-        driver = GDAL::Driver.by_name(driver_name)
+      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?
 
-        if original_nir_band.nil?
-          fail InvalidBandNumber, "Band #{band_number} found but was nil."
-        end
+        output_data_type ||= original_nir_band.data_type
+        driver = GDAL::Driver.by_name(driver_name)
 
-        driver.create_dataset(destination, raster_x_size, raster_y_size,
+        nir = driver.create_dataset(destination, raster_x_size, raster_y_size,
           data_type: output_data_type, **options) do |nir_dataset|
           nir_dataset.geo_transform = geo_transform
           nir_dataset.projection = projection
@@ -157,37 +91,39 @@ module GDAL
           nir_band = nir_dataset.raster_band(1)
           original_nir_band.copy_whole_raster(nir_band)
         end
+
+        nir.close
+
+        nir
       end
 
-      # Extracts the RGB bands and writes to a new file.  NOTE: be sure to close
-      # the dataset object that gets returned or your data will not get written
-      # to the file.
+      # Extracts the RGB bands and writes to a new file.  NOTE: this closes the
+      # dataset to ensure all data and metadata have  been flushed to disk. To
+      # work with the file, you'll need to reopen it.
       #
       # @param destination [String] The destination file path.
+      # @param red_band_number [Fixnum]
+      # @param green_band_number [Fixnum]
+      # @param blue_band_number [Fixnum]
       # @param driver_name [String] the GDAL::Driver short name to use for the
       #   new dataset.
-      # @param band_order [Array<String>] The list of band types, i.e. ['red',
-      #   'green', 'blue'].
+      # @param output_data_type [FFI::GDAL::DataType] Resulting dataset will be
+      #   in this data type. Defaults to use the current data type.
       # @param options [Hash] Options that get used for creating the new NDVI
       #   dataset. See docs for GDAL::Driver#create_dataset.
       # @return [GDAL::Dataset]
-      def extract_natural_color(destination, driver_name: 'GTiff',
-                                band_order: nil, output_data_type: :GDT_Byte, **options)
-        rows = raster_y_size
-        columns = raster_x_size
+      def extract_natural_color(destination, red_band_number, green_band_number, blue_band_number,
+        driver_name: 'GTiff', output_data_type: nil, **options)
+        original_bands = {
+          red: raster_band(red_band_number),
+          green: raster_band(green_band_number),
+          blue: raster_band(blue_band_number)
+        }
+
+        output_data_type ||= raster_band(1).data_type
         driver = GDAL::Driver.by_name(driver_name)
 
-        original_bands = if band_order
-                           bands_with_labels(band_order)
-                         else
-                           {
-                             red: red_band,
-                             green: green_band,
-                             blue: blue_band
-                           }
-                         end
-
-        driver.create_dataset(destination, columns, rows,
+        natural_color = driver.create_dataset(destination, raster_x_size, raster_y_size,
           band_count: 3, data_type: output_data_type, **options) do |new_dataset|
           new_dataset.geo_transform = geo_transform
           new_dataset.projection = projection
@@ -201,11 +137,15 @@ module GDAL
           new_blue_band = new_dataset.raster_band(3)
           original_bands[:blue].copy_whole_raster(new_blue_band)
         end
+
+        natural_color.close
+
+        natural_color
       end
 
       # @param red_band_array [NArray]
       # @param nir_band_array [NArray]
-      # @param remove_negatives [Fixnum] Value to replace negative values with.
+      # @param no_data_value [Number] Value to represent NODATA.
       # @return [NArray]
       def calculate_ndvi(red_band_array, nir_band_array, no_data_value,
         remove_negatives = false, output_data_type = nil)
@@ -215,53 +155,19 @@ module GDAL
         red_band_array = red_band_array.to_type(NArray::DFLOAT)
 
         numerator = nir_band_array - red_band_array
-        denominator = (nir_band_array + red_band_array)
+        denominator = nir_band_array + red_band_array
         ndvi = numerator / denominator
-
-        # Remove NaNs
-        0.upto(ndvi.size - 1) do |i|
-          ndvi[i] = no_data_value if ndvi[i].is_a?(Float) && ndvi[i].nan?
-        end
+        mask = nir_band_array.and(red_band_array).not
+        ndvi[mask] = no_data_value
 
         # Convert to output data type
         final_array = case output_data_type
-                      when :GDT_Byte
-                        calculate_ndvi_byte(ndvi)
-                      when :GDT_UInt16
-                        calculate_ndvi_uint16(ndvi)
-                      else
-                        ndvi
+                      when :GDT_Byte then calculate_ndvi_byte(ndvi)
+                      when :GDT_UInt16 then calculate_ndvi_uint16(ndvi)
+                      else ndvi        # Already in Float32
                       end
 
-        remove_negatives ? remove_negatives_from(final_array) : final_array
-      end
-
-      # Map raster bands to a label, as a hash.  Useful for when bands don't match
-      # the color_interpretation that's returned from GDAL.  This simply maps the
-      # list of labels you pass in to the raster bands.
-      #
-      # Valid labels:
-      #   * Near-infrared: 'N', :nir
-      #   * Red: 'R', :red
-      #   * Green: 'G', :green
-      #   * Blue: 'B', :blue
-      #   * Alpha: 'A', :alpha
-      #
-      # @param order [Array<Object>]
-      # @return [Hash{<Object> => GDAL::RasterBand}]
-      def bands_with_labels(order)
-        order.each_with_object({}).each_with_index do |(band_label, obj), i|
-          label = case band_label.to_s
-                  when 'N', 'nir' then :nir
-                  when 'R', 'red' then :red
-                  when 'G', 'green' then :green
-                  when 'B', 'blue' then :blue
-                  else
-                    band_label
-                  end
-
-          obj[label] = raster_band(i + 1)
-        end
+        remove_negatives ? remove_negatives_from(final_array, no_data_value) : final_array
       end
 
       # @return [Array<GDAL::RasterBand>]
@@ -490,6 +396,7 @@ module GDAL
         NArray[*na.transpose]
       end
 
+      # @return [Hash]
       def as_json(options = nil)
         {
           dataset: {
@@ -526,14 +433,14 @@ module GDAL
         ((ndvi + 1) * (65_535.0 / 2)).to_type(NArray::INT)
       end
 
-      # Sets any negative values in the NArray to 0.
+      # Sets any negative values in the NArray to +replace_with+.
       #
       # @param narray [NArray]
+      # @param replace_with [Number] Replace negative values with this. Useful
+      #   for setting to a NODATA value.
       # @return [NArray]
-      def remove_negatives_from(narray, replace_with = 0)
-        0.upto(narray.size - 1) do |i|
-          narray[i] = replace_with if narray[i] < 0
-        end
+      def remove_negatives_from(narray, replace_with)
+        narray[narray.lt(0)] = replace_with
 
         narray
       end

data/lib/gdal/exceptions.rb

@@ -30,6 +30,9 @@ module GDAL
   class NoWriteAccess < RuntimeError
   end
 
+  class InvalidAccessFlag < RuntimeError
+  end
+
   class NullObject < TypeError
   end
 

data/lib/gdal/grid_types/data_metrics_base.rb

@@ -1,4 +1,4 @@
-require_relative '../../ffi/gdal/gdal_grid_data_metrics_options'
+require_relative '../../ffi/gdal/grid_data_metrics_options'
 
 module GDAL
   module GridTypes

data/lib/gdal/grid_types/inverse_distance_to_a_power.rb

@@ -1,4 +1,4 @@
-require_relative '../../ffi/gdal/gdal_grid_inverse_distance_to_a_power_options'
+require_relative '../../ffi/gdal/grid_inverse_distance_to_a_power_options'
 
 module GDAL
   module GridTypes

data/lib/gdal/grid_types/moving_average.rb

@@ -1,4 +1,4 @@
-require_relative '../../ffi/gdal/gdal_grid_moving_average_options'
+require_relative '../../ffi/gdal/grid_moving_average_options'
 
 module GDAL
   module GridTypes

data/lib/gdal/grid_types/nearest_neighbor.rb

@@ -1,4 +1,4 @@
-require_relative '../../ffi/gdal/gdal_grid_nearest_neighbor_options'
+require_relative '../../ffi/gdal/grid_nearest_neighbor_options'
 
 module GDAL
   module GridTypes

data/lib/gdal/internal_helpers.rb

@@ -5,6 +5,7 @@ module GDAL
     include LogSwitch
   end
 
+  # @private
   module InternalHelpers
     def self.included(base)
       base.extend(ClassMethods)
@@ -89,6 +90,17 @@ module GDAL
         !FFI::GDAL.unsupported_gdal_functions.include?(function_name) &&
           FFI::GDAL.respond_to?(function_name)
       end
+
+      # @param char [String] 'r' or 'w'
+      # @return [Symbol] :GF_Read if 'r' or :GF_Write if 'w'.
+      # @raise [GDAL::InvalidAccessFlag] If +char+ is not 'r' or 'w'.
+      def _gdal_access_flag(char)
+        case char
+        when 'r' then :GF_Read
+        when 'w' then :GF_Write
+        else fail GDAL::InvalidAccessFlag, "Invalid access flag: #{char}"
+        end
+      end
     end
   end
 end

data/lib/gdal/raster_band.rb

@@ -36,8 +36,6 @@ module GDAL
     #
     # @return [Fixnum]
     def x_size
-      return nil if null?
-
       FFI::GDAL.GDALGetRasterBandXSize(@c_pointer)
     end
 
@@ -45,8 +43,6 @@ module GDAL
     #
     # @return [Fixnum]
     def y_size
-      return nil if null?
-
       FFI::GDAL.GDALGetRasterBandYSize(@c_pointer)
     end
 
@@ -54,8 +50,6 @@ module GDAL
     #
     # @return [Symbol] Either :GA_Update or :GA_ReadOnly.
     def access_flag
-      return nil if null?
-
       FFI::GDAL.GDALGetRasterAccess(@c_pointer)
     end
 
@@ -64,8 +58,6 @@ module GDAL
     #
     # @return [Fixnum]
     def number
-      return nil if null?
-
       FFI::GDAL.GDALGetBandNumber(@c_pointer)
     end
 
@@ -583,49 +575,114 @@ module GDAL
       NArray.to_na(the_array)
     end
 
-    # @param pixel_array [NArray] The list of pixels.
+    # Writes an NArray of pixels to the raster band using {#raster_io}. It
+    # determines +x_size+ and +y_size+ for the {#raster_io} call using the
+    # dimensions of the array.
+    #
+    # @param pixel_array [NArray] The 2d list of pixels.
     # @param x_offset [Fixnum] The left-most pixel to start writing.
-    # @param y_offset [Fixnum] The top-most pixel to start writing.
-    # @param data_type [FFI::GDAL::DataType] The type of pixel contained in
+    # @param y_offset [Fixnum] The top-most line to start writing.
+    # @param buffer_data_type [FFI::GDAL::DataType] The type of pixel contained in
     #   the +pixel_array+.
     # @param line_space [Fixnum]
     # @param pixel_space [Fixnum]
     # TODO: Write using #buffer_size to write most efficiently.
-    def write_array(pixel_array, x_offset: 0, y_offset: 0, data_type: self.data_type,
+    def write_array(pixel_array, x_offset: 0, y_offset: 0, x_size: nil, y_size: nil,
+      buffer_x_size: nil, buffer_y_size: nil, buffer_data_type: data_type,
       line_space: 0, pixel_space: 0)
-      line_size = 1
-      x_size = pixel_array.sizes.first
-      y_size = pixel_array.sizes.last
+      x_size ||= pixel_array.sizes.first
+      y_size ||= pixel_array.sizes.last
 
       columns_to_write = x_size - x_offset
       lines_to_write = y_size - y_offset
-      scan_line = GDAL._pointer_from_data_type(data_type, columns_to_write)
+      scan_line = GDAL._pointer_from_data_type(buffer_data_type, columns_to_write * lines_to_write)
 
-      (y_offset).upto(lines_to_write - 1) do |y|
-        pixels = pixel_array[true, y]
-        ffi_type = GDAL._gdal_data_type_to_ffi(data_type)
+      (y_offset).upto(lines_to_write - 1) do |line_number|
+        pixels = pixel_array[true, line_number]
+        ffi_type = GDAL._gdal_data_type_to_ffi(buffer_data_type)
         meth = "write_array_of_#{ffi_type}".to_sym
         scan_line.send(meth, pixels.to_a)
 
-        FFI::GDAL.GDALRasterIO(
-          @c_pointer,
-          :GF_Write,
-          x_offset,     # nXOff
-          y,
-          x_size,       # nXSize
-          line_size,    # nYSize
-          scan_line,    # pData
-          x_size,       # nBufXSize
-          line_size,    # nBufYSize
-          data_type,    # eBufType
-          pixel_space,  # nPixelSpace
-          line_space    # nLineSpace
-        )
+        raster_io('w', scan_line, x_size: x_size, y_size: 1, x_offset: x_offset, y_offset: line_number,
+                                  buffer_x_size: x_size, buffer_y_size: line_number, buffer_data_type: buffer_data_type,
+                                  pixel_space: pixel_space, line_space: line_space)
       end
 
       flush_cache
     end
 
+    # IO access for raster data in this band. Default values are set up to
+    # operate on one line at a time, keeping the same aspect ratio.
+    #
+    # On buffers... You can use different size buffers from the original x and
+    # y size to allow for resampling. Using larger buffers will upsample the
+    # raster data; smaller buffers will downsample it.
+    #
+    # On +pixel_space+ and +line_space+.... These values control how data is
+    # organized in the buffer.
+    #
+    # @param [Symbol] access_flag Must be 'r' or 'w'.
+    # @param [FFI::MemoryPointer] buffer Allows for passing in your own buffer,
+    #   which is really only useful when writing.
+    # @param [Fixnum] x_size The number of pixels per line to operate on.
+    #   Defaults to the value of {#x_size} - +x_offset+.
+    # @param [Fixnum] y_size The number of lines to operate on. Defaults to 1.
+    # @param [Fixnum] x_offset The pixel number in the line to start operating
+    #   on. Note that when using this, {#x_size} - +x_offset+ should be >= 0,
+    #   otherwise this means you're telling the method to read past the end of
+    #   the line. Defaults to 0.
+    # @param [Fixnum] y_offset The line number to start operating on. Note that
+    #   when using this, {#y_size} - +y_offset+ should be >= 0, otherwise this
+    #   means you're telling the method to read more lines than the raster has.
+    #   Defaults to 0.
+    # @param [Fixnum] buffer_x_size The width of the buffer image in which to
+    #   read/write the raster data into/from. Typically this should be the same
+    #   size as +x_size+; if it's different, GDAL will resample accordingly.
+    # @param [Fixnum] buffer_y_size The height of the buffer image in which to
+    #   read/write the raster data into/from. Typically this should be the same
+    #   size as +y_size+; if it's different, GDAL will resample accordingly.
+    # @param [FFI::GDAL::DataType] buffer_data_type Can be used to convert the
+    #   data to a different type. You must account for this when reading/writing
+    #   to/from your buffer--your buffer size must be +buffer_x_size+ *
+    #   +buffer_y_size+. Defaults to {#data_type}.
+    # @param [Fixnum] pixel_space The byte offset from the start of one pixel
+    #   value in the buffer to the start of the next pixel value within a line.
+    #   If defaulted (0), the size of +buffer_data_type+ is used.
+    # @param [Fixnum] line_space The byte offset from the start of one line in
+    #   the buffer to the start of the next. If defaulted (0), the size of
+    #   +buffer_data_type+ * +buffer_x_size* is used.
+    # @return [FFI::MemoryPointer] Pointer to the data that was read/written.
+    def raster_io(access_flag, buffer = nil,
+      x_size: nil, y_size: nil, x_offset: 0, y_offset: 0,
+      buffer_x_size: nil, buffer_y_size: nil, buffer_data_type: data_type,
+      pixel_space: 0, line_space: 0)
+      x_size ||= self.x_size
+      y_size ||= self.y_size
+      pixels_to_io = x_size - x_offset
+      lines_to_io = y_size - y_offset
+
+      buffer_x_size ||= pixels_to_io
+      buffer_y_size ||= lines_to_io
+      buffer ||= GDAL._pointer_from_data_type(buffer_data_type, buffer_x_size * buffer_y_size)
+
+      FFI::GDAL.GDALRasterIO(
+        @c_pointer,
+        GDAL._gdal_access_flag(access_flag),
+        x_offset,
+        y_offset,
+        x_size,
+        y_size,
+        buffer,
+        buffer_x_size,
+        buffer_y_size,
+        buffer_data_type,
+        pixel_space,
+        line_space
+      )
+
+      buffer
+    end
+
     # Read a block of image data, more efficiently than #read.  Doesn't
     # resample or do data type conversion.
     #

data/lib/gdal/raster_band_classifier.rb

@@ -45,17 +45,20 @@ module GDAL
     # max end of the values, those get lumped in with the last range.
     #
     # @param range_count [Fixnum] The number of ranges to create.
+    # @return [Array<Hash>, nil]
     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}"
+      return if break_values.uniq.size != range_count
 
       breakpoint_calculator = lambda do |range_number|
         min = break_values[range_number]
@@ -95,7 +98,7 @@ module GDAL
         end
       end
 
-      @raster_band.write_array(narray, data_type: @raster_band.data_type)
+      @raster_band.write_array(narray, buffer_data_type: @raster_band.data_type)
     end
 
     private

data/lib/gdal/raster_band_mixins/extensions.rb

@@ -121,25 +121,24 @@ module GDAL
       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)
 
-        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"
+        # Start at 1 instead of 0 because we manually set the first color entry
+        # to white.
+        color_entry_index_range =
+          if data_type == :GDT_Byte then 1..255
+          elsif data_type == :GDT_UInt16 then 1..65_535
+          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
+        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,

data/lib/ogr/geometry.rb

@@ -29,7 +29,6 @@ module OGR
           end
 
         new_pointer = geometry.c_pointer
-        # geometry.c_pointer.autorelease = true
 
         case geometry.type
         when :wkbPoint, :wkbPoint25D then OGR::Point.new(new_pointer)
@@ -122,6 +121,7 @@ module OGR
     def self.included(base)
       base.send(:include, GDAL::Logger)
       base.send(:include, GeometryExtensions)
+      base.send(:extend, ClassMethods)
     end
 
     #--------------------------------------------------------------------------

data/lib/ogr/internal_helpers.rb

@@ -6,6 +6,7 @@ module OGR
       base.extend(ClassMethods)
     end
 
+    # @private
     module ClassMethods
       # Makes the interface consistent with the access flags for GDAL.
       #

data/lib/ogr/layer_mixins/ogr_field_methods.rb

@@ -1,6 +1,7 @@
 require_relative '../field_definition'
 require_relative '../field'
 require_relative '../geometry_field_definition'
+require_relative '../../ffi/ogr/api'
 
 module OGR
   module LayerMixins

data/lib/ogr/spatial_reference.rb

@@ -1,4 +1,5 @@
 require_relative '../ffi/ogr'
+require_relative '../gdal/logger'
 require_relative 'spatial_reference_extensions'
 require_relative 'spatial_reference_mixins/coordinate_system_getter_setters'
 require_relative 'spatial_reference_mixins/exporters'

data/spec/unit/gdal/raster_band_classifier_spec.rb

@@ -90,6 +90,11 @@ RSpec.describe GDAL::RasterBandClassifier do
         expect(map_to_values).to contain_exactly(1.0, 2.0, 3.0, 4.0)
       end
     end
+
+    context 'not enough values between breaks to generate unique break values' do
+      subject { classifier.equal_count_ranges(1_000) }
+      it { is_expected.to be_nil }
+    end
   end
 
   describe '#classify!' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffi-gdal
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta4
+  version: 1.0.0.beta5
 platform: ruby
 authors:
 - Steve Loveless
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-22 00:00:00.000000000 Z
+date: 2015-06-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi