ffi-gdal 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 647e3eeffef3a444a35f32abcc8918172685030f
-  data.tar.gz: 0b30d6ff25a55d01d8859ea2f679a78ecf04cb5b
+  metadata.gz: 5be516e43cc426c9f1fe2f0f0b701b971597d8e6
+  data.tar.gz: 53d5d44e1450f3e3f4de809eb025723f1e2945d8
 SHA512:
-  metadata.gz: 6f59779cfb110c9e8eae87a8731df55a78437df2d2e495c138cffaa5054231c22ea69373afae68cc6bdb4814261fcd767da3b964300d4f6db152246351642405
-  data.tar.gz: 62d6225c376ced220a3270f0ca31f3c3b54a4761ed3df3cc5cde46e36c3295493ac7c0da9293975db2f0e5d78357599785e96beb1874670ba3bb08f6c0a40bef
+  metadata.gz: 434c97cb29adc90a5f3daee4e5ac47a9560b7cb4959301b342988deb9976d4f579b0bc3a117d596f522e31725ecc2aa5f1519cf2d3bfb338677bee2fe8b447fc
+  data.tar.gz: 186963aecb3376291c75694f2628393a36b3c31603bd79897610a0796c7dabcbbb1f5f2e6332bd269c4f5b143200e405ae3a5453f1cb558f0c7a8b1e1d0723e7

data/History.md

@@ -1,3 +1,16 @@
+### 0.0.3 / 2014-09-26
+
+* Improvements
+    * The `approx_ok` param for `RasterBand#histogram` should default to
+      `false` (prefering 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.
+
+
 ### 0.0.2 / 2014-09-26
 
 * New things

data/lib/ffi-gdal/dataset.rb

@@ -27,7 +27,7 @@ module GDAL
     # @param access_flag [String] 'r' or 'w'.
     def self.open(path, access_flag)
       uri = URI.parse(path)
-      file_path = u.scheme.nil? ? ::File.expand_path(path) : path
+      file_path = uri.scheme.nil? ? ::File.expand_path(path) : path
 
       pointer = FFI::GDAL.GDALOpen(file_path, ACCESS_FLAGS[access_flag])
       raise OpenFailure.new(file_path) if pointer.null?
@@ -53,7 +53,7 @@ module GDAL
           fail RequiredBandNotFound, 'Near-infrared'
         end
 
-        the_array = original.calculate_ndvi(red.to_a, nir.to_a)
+        the_array = calculate_ndvi(red.to_a, nir.to_a)
 
         ndvi_band = ndvi_dataset.raster_band(1)
         ndvi_band.write_array(the_array)
@@ -71,7 +71,7 @@ module GDAL
           fail RequiredBandNotFound, 'Near-infrared'
         end
 
-        the_array = original.calculate_ndvi(green.to_a, nir.to_a)
+        the_array = calculate_ndvi(green.to_a, nir.to_a)
 
         gndvi_band = gndvi_dataset.raster_band(1)
         gndvi_band.write_array(the_array)
@@ -114,6 +114,13 @@ module GDAL
       end
     end
 
+    # @param red_band_array [NArray]
+    # @param nir_band_array [NArray]
+    # @return [NArray]
+    def self.calculate_ndvi(red_band_array, nir_band_array)
+      (nir_band_array - red_band_array) / (nir_band_array + red_band_array)
+    end
+
     def self.extract_8bit(source, destination, driver_name)
       dataset = open(source, 'r')
       geo_transform = dataset.geo_transform
@@ -313,39 +320,40 @@ module GDAL
       end
     end
 
-    # @param red_band_array [NArray]
-    # @param nir_band_array [NArray]
-    # @return [NArray]
-    def calculate_ndvi(red_band_array, nir_band_array)
-      (nir_band_array - red_band_array) / (nir_band_array + red_band_array)
-    end
-
     # @return [GDAL::RasterBand]
     def red_band
-      find_band do |band|
+      band = find_band do |band|
         band.color_interpretation == :GCI_RedBand
       end
+
+      band.is_a?(GDAL::RasterBand) ? band : nil
     end
 
     # @return [GDAL::RasterBand]
     def green_band
-      find_band do |band|
+      band = find_band do |band|
         band.color_interpretation == :GCI_GreenBand
       end
+
+      band.is_a?(GDAL::RasterBand) ? band : nil
     end
 
     # @return [GDAL::RasterBand]
     def blue_band
-      find_band do |band|
+      band = find_band do |band|
         band.color_interpretation == :GCI_BlueBand
       end
+
+      band.is_a?(GDAL::RasterBand) ? band : nil
     end
 
     # @return [GDAL::RasterBand]
     def undefined_band
-      find_band do |band|
+      band = find_band do |band|
         band.color_interpretation == :GCI_Undefined
       end
+
+      band.is_a?(GDAL::RasterBand) ? band : nil
     end
   end
 end

data/lib/ffi-gdal/raster_band.rb

@@ -16,10 +16,10 @@ module GDAL
     # @param raster_band_pointer [FFI::Pointer] Requried if not passing in
     #   +band_id+.
     def initialize(dataset, band_id: nil, raster_band_pointer: nil)
-      if dataset.is_a? GDAL::Dataset
-        @dataset = dataset.c_pointer
+      @dataset = if dataset.is_a? GDAL::Dataset
+        dataset.c_pointer
       else
-        @dataset = dataset
+        dataset
       end
 
       @gdal_raster_band = if raster_band_pointer
@@ -303,6 +303,15 @@ module GDAL
       GDALSetRasterUnitType(@gdal_raster_band, new_unit_type)
     end
 
+    # @return [GDAL::RasterAttributeTable]
+    def default_raster_attribute_table
+      rat_pointer = GDALGetDefaultRAT(c_pointer)
+      return nil if rat_pointer.null?
+
+      GDAL::RasterAttributeTable.new(c_pointer,
+        raster_attribute_table_pointer: rat_pointer)
+    end
+
     # Gets the default raster histogram.  Results are returned as a Hash so some
     # metadata about the histogram can be returned.  Example:
     #
@@ -330,25 +339,26 @@ module GDAL
     #     ]
     #   }
     #
+    # Also, you can pass a block to get status on the processing.  Conforms to
+    # FFI::GDAL::GDALProgressFunc.
+    #
     # @param force [Boolean] Forces the computation of the histogram.  If
     #   +false+ and the default histogram isn't available, this returns nil.
     # @param block [Proc] No required, but can be used to output progess info
     #   during processing.
+    #
     # @yieldparam completion [Float] The ration completed as a decimal.
     # @yieldparam message [String] Message string to display.
+    #
     # @return [Hash{minimum => Float, maximum => Float, buckets => Fixnum,
-    #   totals => Array<Fixnum>}]
+    #   totals => Array<Fixnum>}] Returns +nil+ if no default histogram is
+    #   available.
     def default_histogram(force=false, &block)
       min_pointer = FFI::MemoryPointer.new(:double)
       max_pointer = FFI::MemoryPointer.new(:double)
       buckets_pointer = FFI::MemoryPointer.new(:int)
       histogram_pointer = FFI::MemoryPointer.new(:pointer)
-
-      progress_proc = block || Proc.new do |completion, message, progress_arg|
-        puts "completion: #{completion * 100}"
-        puts "message: #{message}"
-        true
-      end
+      progress_proc = block || nil
 
       cpl_err = GDALGetDefaultHistogram(@gdal_raster_band,
         min_pointer,
@@ -363,28 +373,14 @@ module GDAL
       min = min_pointer.read_double
       max = max_pointer.read_double
       buckets = buckets_pointer.read_int
-      totals = histogram_pointer.get_pointer(0).read_array_of_int(buckets)
 
-      case cpl_err.to_ruby
-      when :none, :debug
-        {
-          minimum: min,
-          maximum: max,
-          buckets: buckets,
-          totals: totals
-        }
-      when :warning then return nil
-      when :failure, :fatal then raise CPLError
+      totals = if buckets.zero?
+        []
+      else
+        histogram_pointer.get_pointer(0).read_array_of_int(buckets)
       end
-    end
 
-    # @return [GDAL::RasterAttributeTable]
-    def default_raster_attribute_table
-      rat_pointer = GDALGetDefaultRAT(c_pointer)
-      return nil if rat_pointer.null?
-
-      GDAL::RasterAttributeTable.new(c_pointer,
-        raster_attribute_table_pointer: rat_pointer)
+      formated_buckets(cpl_err, min, max, buckets, totals)
     end
 
     # Computes a histogram using the given inputs.  If you just want the default
@@ -397,18 +393,18 @@ module GDAL
     # @param approx_ok [Boolean]
     # @param block [Proc] No required, but can be used to output progess info
     #   during processing.
+    #
     # @yieldparam completion [Float] The ration completed as a decimal.
     # @yieldparam message [String] Message string to display.
+    #
     # @return [Hash{minimum => Float, maximum => Float, buckets => Fixnum,
     #   totals => Array<Fixnum>}]
+    #
+    # @see #default_histogram for more info.
     def histogram(min, max, buckets, include_out_of_range: false,
-      approx_ok: true, &block)
-      histogram_pointer = FFI::MemoryPointer.new(:int, buckets)
-
-      progress_proc = block || Proc.new do |completion, message, progress_arg|
-        puts "progress: #{completion * 100}"
-        true
-      end
+      approx_ok: false, &block)
+      histogram_pointer = FFI::MemoryPointer.new(:pointer, buckets)
+      progress_proc = block || nil
 
       cpl_err = GDALGetRasterHistogram(@gdal_raster_band,
         min.to_f,
@@ -418,21 +414,15 @@ module GDAL
         include_out_of_range,
         approx_ok,
         progress_proc,
-        'doing things'
-      )
-      totals = histogram_pointer.read_array_of_int(0)
+        'doing things')
 
-      case cpl_err.to_ruby
-      when :none
-        {
-          minimum: min,
-          maximum: max,
-          buckets: buckets,
-          totals: totals
-        }
-      when :warning then return nil
-      when :failure then raise CPLError
+      totals = if buckets.zero?
+        []
+      else
+        histogram_pointer.read_array_of_int(buckets)
       end
+
+      formated_buckets(cpl_err, min, max, buckets, totals)
     end
 
     # TODO: Something about the pointer allocation smells here...
@@ -567,5 +557,26 @@ module GDAL
 
       NArray.to_na(lines)
     end
+
+    #---------------------------------------------------------------------------
+    # Privates
+    #---------------------------------------------------------------------------
+
+    private
+
+    def formated_buckets(cpl_err, min, max, buckets, totals)
+      case cpl_err.to_ruby
+      when :none
+        {
+          minimum: min,
+          maximum: max,
+          buckets: buckets,
+          totals: totals
+        }
+      when :warning then return nil
+      when :failure then raise CPLError
+      end
+    end
+
   end
 end

data/lib/ffi/gdal/version.rb

@@ -1,5 +1,5 @@
 module FFI
   module GDAL
-    VERSION = '0.0.2'
+    VERSION = '0.0.3'
   end
 end

data/spec/ffi-gdal/integration/raster_band_info_spec.rb

@@ -4,329 +4,335 @@ require 'ffi-gdal'
 
 
 TIF_FILES.each do |file|
-  dataset =  GDAL::Dataset.open(file, 'r')
+  dataset = GDAL::Dataset.open(file, 'r')
+  dataset.each_band do |band_under_test|
 
-  describe 'Raster Band Info' do
-    after :all do
-      dataset.close
-    end
+    describe "Raster Band Info" do
+      after :suite do
+        dataset.close
+      end
 
-    # TODO: Test against each raster band
-    subject do
-      GDAL::RasterBand.new(dataset.c_pointer, band_id: 1)
-    end
+      # TODO: Test against each raster band
+      subject do
+        GDAL::RasterBand.new(dataset.c_pointer, raster_band_pointer: band_under_test.c_pointer)
+      end
 
-    it_behaves_like 'a major object'
+      it_behaves_like 'a major object'
 
-    describe '#x_size' do
-      it 'is a non-zero Integer' do
-        expect(subject.x_size).to be_a Fixnum
-        expect(subject.x_size).to be > 0
+      describe '#x_size' do
+        it 'is a non-zero Integer' do
+          expect(subject.x_size).to be_a Fixnum
+          expect(subject.x_size).to be > 0
+        end
       end
-    end
 
-    describe '#y_size' do
-      it 'is a non-zero Integer' do
-        expect(subject.y_size).to be_a Fixnum
-        expect(subject.y_size).to be > 0
+      describe '#y_size' do
+        it 'is a non-zero Integer' do
+          expect(subject.y_size).to be_a Fixnum
+          expect(subject.y_size).to be > 0
+        end
       end
-    end
 
-    describe '#access_flag' do
-      specify { expect(subject.access_flag).to eq :GA_ReadOnly }
-    end
+      describe '#access_flag' do
+        specify { expect(subject.access_flag).to eq :GA_ReadOnly }
+      end
 
-    describe '#band_number' do
-      it 'is a non-zero Integer' do
-        expect(subject.band_number).to be_a Fixnum
-        expect(subject.band_number).to be > 0
+      describe '#band_number' do
+        it 'is a non-zero Integer' do
+          expect(subject.band_number).to be_a Fixnum
+          expect(subject.band_number).to be > 0
+        end
       end
-    end
 
-    describe '#color_interpretation' do
-      it 'is a Symbol; one of FFI::GDAL::GDALColorInterp' do
-        expect(subject.color_interpretation).to be_a Symbol
-        expect(FFI::GDAL::GDALColorInterp.symbols).to include subject.color_interpretation
+      describe '#color_interpretation' do
+        it 'is a Symbol; one of FFI::GDAL::GDALColorInterp' do
+          expect(subject.color_interpretation).to be_a Symbol
+          expect(FFI::GDAL::GDALColorInterp.symbols).to include subject.color_interpretation
+        end
       end
-    end
 
-    describe '#color_table' do
-      it 'is a GDAL::ColorTable' do
-        if subject.color_table
-          expect(subject.color_table).to be_a GDAL::ColorTable
+      describe '#color_table' do
+        it 'is a GDAL::ColorTable' do
+          if subject.color_table
+            expect(subject.color_table).to be_a GDAL::ColorTable
+          end
         end
       end
-    end
 
-    describe '#data_type' do
-      it 'is a Symbol; one of FFI::GDAL::GDALDataType' do
-        expect(subject.data_type).to be_a Symbol
-        expect(FFI::GDAL::GDALDataType.symbols).to include subject.data_type
+      describe '#data_type' do
+        it 'is a Symbol; one of FFI::GDAL::GDALDataType' do
+          expect(subject.data_type).to be_a Symbol
+          expect(FFI::GDAL::GDALDataType.symbols).to include subject.data_type
+        end
       end
-    end
 
-    describe '#block_size' do
-      it 'is a Hash with x and y keys that are >= 1' do
-        expect(subject.block_size).to be_a Hash
-        expect(subject.block_size[:x]).to be >= 1
-        expect(subject.block_size[:y]).to be >= 1
+      describe '#block_size' do
+        it 'is a Hash with x and y keys that are >= 1' do
+          expect(subject.block_size).to be_a Hash
+          expect(subject.block_size[:x]).to be >= 1
+          expect(subject.block_size[:y]).to be >= 1
+        end
       end
-    end
 
-    describe '#category_names' do
-      it 'is an Array of Strings' do
-        expect(subject.category_names).to be_an Array
+      describe '#category_names' do
+        it 'is an Array of Strings' do
+          expect(subject.category_names).to be_an Array
 
-        subject.category_names.each do |category_name|
-          expect(category_name).to be_a String
-          expect(category_name).to_not be_empty
+          subject.category_names.each do |category_name|
+            expect(category_name).to be_a String
+            expect(category_name).to_not be_empty
+          end
         end
       end
-    end
 
-    describe '#category_names=' do
-      around do |example|
-        category_names = subject.category_names
-        example.run
-        subject.category_names = category_names
-      end
+      describe '#category_names=' do
+        around do |example|
+          category_names = subject.category_names
+          example.run
+          subject.category_names = category_names
+        end
 
-      it 'sets the category names' do
-        expect(subject.category_names).to be_empty
+        it 'sets the category names' do
+          expect(subject.category_names).to be_empty
 
-        subject.category_names = %w[one two three]
+          subject.category_names = %w[one two three]
 
-        expect(subject.category_names).to eq %w[one two three]
+          expect(subject.category_names).to eq %w[one two three]
+        end
       end
-    end
 
-    describe '#no_data_value' do
-      it 'is a Hash with :value and :is_associated keys' do
-        expect(subject.no_data_value).to be_an Hash
+      describe '#no_data_value' do
+        it 'is a Hash with :value and :is_associated keys' do
+          expect(subject.no_data_value).to be_an Hash
 
-        expect(subject.no_data_value[:value]).to be_a Float
-        expect(subject.no_data_value[:is_associated]).to_not be_nil
+          expect(subject.no_data_value[:value]).to be_a Float
+          expect(subject.no_data_value[:is_associated]).to_not be_nil
+        end
       end
-    end
 
-    describe '#overview_count' do
-      it 'is a Fixnum' do
-        expect(subject.overview_count).to be_a Fixnum
+      describe '#overview_count' do
+        it 'is a Fixnum' do
+          expect(subject.overview_count).to be_a Fixnum
+        end
       end
-    end
 
-    describe '#arbitrary_overviews?' do
-      it 'is true or false' do
-        expect([true, false]).to include subject.arbitrary_overviews?
+      describe '#arbitrary_overviews?' do
+        it 'is true or false' do
+          expect([true, false]).to include subject.arbitrary_overviews?
+        end
       end
-    end
 
-    describe '#overview' do
-      it 'returns a GDAL::RasterBand if the overview exists' do
-        overview = subject.overview(0)
-        expect(overview).to be_a GDAL::RasterBand if overview
+      describe '#overview' do
+        it 'returns a GDAL::RasterBand if the overview exists' do
+          overview = subject.overview(0)
+          expect(overview).to be_a GDAL::RasterBand if overview
+        end
       end
-    end
 
-    describe '#raster_sample_overview' do
-      it 'returns a GDAL::RasterBand if the overview exists' do
-        overview = subject.raster_sample_overview
-        expect(overview).to be_a GDAL::RasterBand
+      describe '#raster_sample_overview' do
+        it 'returns a GDAL::RasterBand if the overview exists' do
+          overview = subject.raster_sample_overview
+          expect(overview).to be_a GDAL::RasterBand
+        end
       end
-    end
 
-    describe '#mask_band' do
-      it 'returns a GDAL::RasterBand if the mask_band exists' do
-        overview = subject.mask_band
-        expect(overview).to be_a GDAL::RasterBand
+      describe '#mask_band' do
+        it 'returns a GDAL::RasterBand if the mask_band exists' do
+          overview = subject.mask_band
+          expect(overview).to be_a GDAL::RasterBand
+        end
       end
-    end
 
-    describe '#mask_flags' do
-      it 'returns an Array of Symbols' do
-        expect(subject.mask_flags).to eq [:GMF_ALL_VALID]
+      describe '#mask_flags' do
+        it 'returns an Array of Symbols' do
+          expect(subject.mask_flags).to eq [:GMF_ALL_VALID]
+        end
       end
-    end
 
-    describe '#statistics' do
-      it 'returns a Hash with populated values' do
-        expect(subject.statistics).to be_a Hash
-        expect(%i[minimum maximum mean standard_deviation]).
-          to eq subject.statistics.keys
-      end
+      describe '#statistics' do
+        it 'returns a Hash with populated values' do
+          expect(subject.statistics).to be_a Hash
+          expect(%i[minimum maximum mean standard_deviation]).
+            to eq subject.statistics.keys
+        end
 
-      it 'has a :minimum that ranges between 0.0/-32768.0 and 255.0' do
-        min = subject.statistics[:minimum]
-        unless min == -32768.0
-          expect(subject.statistics[:minimum]).to((be >= 0.0) || (eq -32768.0))
-          expect(subject.statistics[:minimum]).to be <= 255.0
+        it 'has a :minimum that ranges between 0.0/-32768.0 and 255.0' do
+          min = subject.statistics[:minimum]
+          unless min == -32768.0
+            expect(subject.statistics[:minimum]).to((be >= 0.0) || (eq -32768.0))
+            expect(subject.statistics[:minimum]).to be <= 255.0
+          end
         end
       end
-    end
 
-    describe '#scale' do
-      it 'returns a Hash with populated values' do
-        expect(subject.statistics).to be_a Hash
-        expect(%i[value is_meaningful]).to eq subject.scale.keys
-      end
+      describe '#scale' do
+        it 'returns a Hash with populated values' do
+          expect(subject.statistics).to be_a Hash
+          expect(%i[value is_meaningful]).to eq subject.scale.keys
+        end
 
-      it 'has a :value that is a Float' do
-        expect(subject.scale[:value]).to be_a Float
-      end
+        it 'has a :value that is a Float' do
+          expect(subject.scale[:value]).to be_a Float
+        end
 
-      it 'has a :is_meaningful that is false (since the examples are geotiffs)' do
-        expect(subject.scale[:is_meaningful]).to eq false
+        it 'has a :is_meaningful that is false (since the examples are geotiffs)' do
+          expect(subject.scale[:is_meaningful]).to eq false
+        end
       end
-    end
 
-    describe '#scale=' do
-      around do |example|
-        scale = subject.scale[:value]
-        example.run
-        subject.scale = scale
-      end
+      describe '#scale=' do
+        around do |example|
+          scale = subject.scale[:value]
+          example.run
+          subject.scale = scale
+        end
 
-      it 'does nothing (because the file formats dont support it)' do
-        subject.scale = 0.1
-        expect(subject.scale[:value]).to eq 0.1
+        it 'does nothing (because the file formats dont support it)' do
+          subject.scale = 0.1
+          expect(subject.scale[:value]).to eq 0.1
+        end
       end
-    end
 
-    describe '#offset' do
-      it 'returns a Hash with populated values' do
-        expect(subject.offset).to be_a Hash
-        expect(%i[value is_meaningful]).to eq subject.offset.keys
-      end
+      describe '#offset' do
+        it 'returns a Hash with populated values' do
+          expect(subject.offset).to be_a Hash
+          expect(%i[value is_meaningful]).to eq subject.offset.keys
+        end
 
-      it 'has a :value that is a Float' do
-        expect(subject.offset[:value]).to be_a Float
-      end
+        it 'has a :value that is a Float' do
+          expect(subject.offset[:value]).to be_a Float
+        end
 
-      it 'has a :is_meaningful that is false (since the examples are geotiffs)' do
-        expect(subject.offset[:is_meaningful]).to eq false
+        it 'has a :is_meaningful that is false (since the examples are geotiffs)' do
+          expect(subject.offset[:is_meaningful]).to eq false
+        end
       end
-    end
 
-    describe '#offset=' do
-      around do |example|
-        offset = subject.offset[:value]
-        example.run
-        subject.offset = offset
-      end
+      describe '#offset=' do
+        around do |example|
+          offset = subject.offset[:value]
+          example.run
+          subject.offset = offset
+        end
 
-      it 'does nothing (because the file formats dont support it)' do
-        subject.offset = 0.1
-        expect(subject.offset[:value]).to eq 0.1
+        it 'does nothing (because the file formats dont support it)' do
+          subject.offset = 0.1
+          expect(subject.offset[:value]).to eq 0.1
+        end
       end
-    end
 
-    describe '#unit_type' do
-      it 'returns a String' do
-        expect(subject.unit_type).to be_a String
+      describe '#unit_type' do
+        it 'returns a String' do
+          expect(subject.unit_type).to be_a String
+        end
       end
-    end
 
-    describe '#unit_type=' do
-      around do |example|
-        unit_type = subject.unit_type
-        example.run
-        subject.unit_type = unit_type
-      end
+      describe '#unit_type=' do
+        around do |example|
+          unit_type = subject.unit_type
+          example.run
+          subject.unit_type = unit_type
+        end
 
-      it 'does nothing (because the file formats dont support it)' do
-        subject.unit_type = 'ft'
-        expect(subject.unit_type).to eq 'ft'
+        it 'does nothing (because the file formats dont support it)' do
+          subject.unit_type = 'ft'
+          expect(subject.unit_type).to eq 'ft'
+        end
       end
-    end
 
-    describe '#default_histogram' do
-      let!(:histogram) { subject.default_histogram }
+      describe '#default_histogram' do
+        let!(:histogram) { subject.default_histogram }
 
-      it 'returns a Hash with :mininum, :maximum, :buckets, and :totals' do
-        expect(histogram).to be_a Hash
-        expect(histogram.keys).to eq %i[minimum maximum buckets totals]
-      end
+        it 'returns a Hash with :mininum, :maximum, :buckets, and :totals' do
+          if histogram
+            expect(histogram).to be_a Hash
+            expect(histogram.keys).to eq %i[minimum maximum buckets totals]
+          end
+        end
 
-      it 'has :mimimum as a Float' do
-        expect(histogram[:minimum]).to be_a Float
-      end
+        it 'has :mimimum as a Float' do
+          expect(histogram[:minimum]).to be_a Float if histogram
+        end
 
-      it 'has :maximum as a Float' do
-        expect(histogram[:maximum]).to be_a Float
-      end
+        it 'has :maximum as a Float' do
+          expect(histogram[:maximum]).to be_a Float if histogram
+        end
 
-      it 'has :buckets as a Fixnum' do
-        expect(histogram[:buckets]).to be_a Fixnum
-      end
+        it 'has :buckets as a Fixnum' do
+          expect(histogram[:buckets]).to be_a Fixnum if histogram
+        end
 
-      it 'has :totals as an Array of 256 Fixnums' do
-        expect(histogram[:totals]).to be_an Array
-        expect(histogram[:totals].size).to eq 256
-        expect(histogram[:totals].all? { |t| t.class == Fixnum}).to eq true
+        it 'has :totals as an Array of 256 Fixnums' do
+          if histogram
+            expect(histogram[:totals]).to be_an Array
+            expect(histogram[:totals].size).to eq 256
+            expect(histogram[:totals].all? { |t| t.class == Fixnum}).to eq true
+          end
+        end
       end
-    end
 
-    describe '#default_raster_attribute_table' do
-      it 'returns a GDAL::RasterAttributeTable' do
-        rat = subject.default_raster_attribute_table
+      describe '#default_raster_attribute_table' do
+        it 'returns a GDAL::RasterAttributeTable' do
+          rat = subject.default_raster_attribute_table
 
-        if rat
-          expect(rat).to be_a GDAL::RasterAttributeTable
+          if rat
+            expect(rat).to be_a GDAL::RasterAttributeTable
+          end
         end
       end
-    end
 
-    describe '#compute_min_max' do
-      it 'returns a 2-element Array of Floats' do
-        expect(subject.compute_min_max).to be_a Array
-        expect(subject.compute_min_max.size).to eq 2
-        expect(subject.compute_min_max.first).to be_a Float
-        expect(subject.compute_min_max.last).to be_a Float
-      end
+      describe '#compute_min_max' do
+        it 'returns a 2-element Array of Floats' do
+          expect(subject.compute_min_max).to be_a Array
+          expect(subject.compute_min_max.size).to eq 2
+          expect(subject.compute_min_max.first).to be_a Float
+          expect(subject.compute_min_max.last).to be_a Float
+        end
 
-      it 'has a min that is < its max' do
-        min, max = subject.compute_min_max
-        expect(min).to be < max
-      end
+        it 'has a min that is < its max' do
+          min, max = subject.compute_min_max
+          expect(min).to be < max
+        end
 
-      it 'has a min that == statistics[:minimum]' do
-        min, _ = subject.compute_min_max
-        expect(min).to eq subject.statistics[:minimum]
-      end
+        it 'has a min that == statistics[:minimum]' do
+          min, _ = subject.compute_min_max
+          expect(min).to eq subject.statistics[:minimum]
+        end
 
-      it 'has a min that == minimum_value[:value]' do
-        min, _ = subject.compute_min_max
-        expect(min).to eq subject.minimum_value[:value]
+        it 'has a min that == minimum_value[:value]' do
+          min, _ = subject.compute_min_max
+          expect(min).to eq subject.minimum_value[:value]
+        end
       end
-    end
 
-    describe '#minimum_value' do
-      it 'returns a Hash with populated values' do
-        expect(subject.minimum_value).to be_a Hash
-        expect(%i[value is_tight]).to eq subject.minimum_value.keys
-      end
+      describe '#minimum_value' do
+        it 'returns a Hash with populated values' do
+          expect(subject.minimum_value).to be_a Hash
+          expect(%i[value is_tight]).to eq subject.minimum_value.keys
+        end
 
-      it 'has a :value that is a Float' do
-        expect(subject.minimum_value[:value]).to be_a Float
-      end
+        it 'has a :value that is a Float' do
+          expect(subject.minimum_value[:value]).to be_a Float
+        end
 
-      it 'has a :is_tight that is nil (since the examples are geotiffs)' do
-        #expect(subject.minimum_value[:is_tight]).to eq nil
+        it 'has a :is_tight that is nil (since the examples are geotiffs)' do
+          #expect(subject.minimum_value[:is_tight]).to eq nil
+        end
       end
-    end
 
-    describe '#maximum_value' do
-      it 'returns a Hash with populated values' do
-        expect(subject.maximum_value).to be_a Hash
-        expect(%i[value is_tight]).to eq subject.maximum_value.keys
-      end
+      describe '#maximum_value' do
+        it 'returns a Hash with populated values' do
+          expect(subject.maximum_value).to be_a Hash
+          expect(%i[value is_tight]).to eq subject.maximum_value.keys
+        end
 
-      it 'has a :value that is a Float' do
-        expect(subject.maximum_value[:value]).to be_a Float
-      end
+        it 'has a :value that is a Float' do
+          expect(subject.maximum_value[:value]).to be_a Float
+        end
 
-      it 'has a :is_tight that is nil (since the examples are geotiffs)' do
-        #expect(subject.maximum_value[:is_tight]).to eq nil
+        it 'has a :is_tight that is nil (since the examples are geotiffs)' do
+          #expect(subject.maximum_value[:is_tight]).to eq nil
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ffi-gdal
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Steve Loveless