ffi-gdal 1.0.0.beta5 → 1.0.0.beta6

data/spec/unit/gdal/gridder_options_spec.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+require 'gdal/gridder_options'
+
+RSpec.describe GDAL::GridderOptions do
+  subject(:gridder_options) { described_class.new(:metric_count) }
+
+  describe 'attributes' do
+    it { is_expected.to respond_to :input_clipping_geometry }
+    it { is_expected.to respond_to :input_clipping_geometry= }
+    it { is_expected.to respond_to :input_field_name }
+    it { is_expected.to respond_to :input_field_name= }
+
+    it { is_expected.to respond_to :progress_formatter }
+    it { is_expected.to respond_to :progress_formatter= }
+    it { is_expected.to respond_to :grid }
+    it { is_expected.to respond_to :algorithm_options }
+
+    it { is_expected.to respond_to :output_creation_options }
+    it { is_expected.to respond_to :output_creation_options= }
+    it { is_expected.to respond_to :output_format }
+    it { is_expected.to respond_to :output_format= }
+    it { is_expected.to respond_to :output_x_extent }
+    it { is_expected.to respond_to :output_x_extent= }
+    it { is_expected.to respond_to :output_y_extent }
+    it { is_expected.to respond_to :output_y_extent= }
+    it { is_expected.to respond_to :output_projection }
+    it { is_expected.to respond_to :output_projection= }
+    it { is_expected.to respond_to :output_size }
+    it { is_expected.to respond_to :output_size= }
+    it { is_expected.to respond_to :output_data_type }
+    it { is_expected.to respond_to :output_data_type= }
+  end
+
+  describe 'default values' do
+    describe '#output_data_type' do
+      subject { gridder_options.output_data_type }
+      it { is_expected.to eq :GDT_Float64 }
+    end
+
+    describe '#output_format' do
+      subject { gridder_options.output_format }
+      it { is_expected.to eq 'GTiff' }
+    end
+
+    describe '#output_size' do
+      subject { gridder_options.output_size }
+      it { is_expected.to eq(width: 256, height: 256) }
+    end
+  end
+
+  describe '#input_clipping_geometry=' do
+    context 'param is a OGR::Geometry' do
+      it 'sets the attribute' do
+        geom = OGR::Point.new
+        subject.input_clipping_geometry = geom
+        expect(subject.input_clipping_geometry).to eq geom
+      end
+    end
+
+    context 'param is not a OGR::Geometry' do
+      it 'raises a OGR::InvalidGeometry exception' do
+        expect { subject.input_clipping_geometry = 'meow' }.
+          to raise_exception OGR::InvalidGeometry
+      end
+    end
+  end
+
+  describe '#output_data_type=' do
+    context 'param is a FFI::GDAL::GDAL::DataType' do
+      it 'sets the attribute and the grid data type' do
+        subject.output_data_type = :GDT_Byte
+        expect(subject.output_data_type).to eq :GDT_Byte
+        expect(subject.grid.data_type).to eq :GDT_Byte
+      end
+    end
+
+    context 'param is not a FFI::GDAL::GDAL::DataType' do
+      it 'raises a OGR::InvalidGeometry exception' do
+        expect { subject.output_data_type = 'meow' }.
+          to raise_exception GDAL::InvalidDataType
+      end
+    end
+  end
+
+  describe '#output_format=' do
+    context 'param is a GDAL::Driver short name' do
+      it 'sets the attribute' do
+        subject.output_format = 'SAGA'
+        expect(subject.output_format).to eq 'SAGA'
+      end
+    end
+
+    context 'param is not a GDAL::Driver short name' do
+      it 'raises a GDAL::InvalidDriverName exception' do
+        expect { subject.output_format = 'meow' }.
+          to raise_exception GDAL::InvalidDriverName
+      end
+    end
+  end
+
+  describe '#output_x_extent=' do
+    it 'returns a Hash with min and max keys' do
+      expect(subject).to receive(:extract_min_max).with(%w[some values], :min, :max).
+        and_return(%w[some values])
+      subject.output_x_extent = %w[some values]
+      expect(subject.output_x_extent).to eq(min: 'some', max: 'values')
+    end
+  end
+
+  describe '#output_y_extent=' do
+    it 'returns a Hash with min and max keys' do
+      expect(subject).to receive(:extract_min_max).with(%w[some values], :min, :max).
+        and_return(%w[some values])
+      subject.output_y_extent = %w[some values]
+      expect(subject.output_y_extent).to eq(min: 'some', max: 'values')
+    end
+  end
+
+  describe '#output_size=' do
+    it 'returns a Hash with min and max keys' do
+      expect(subject).to receive(:extract_min_max).with(%w[some values], :width, :height).
+        and_return(%w[some values])
+      subject.output_size = %w[some values]
+      expect(subject.output_size).to eq(width: 'some', height: 'values')
+    end
+  end
+
+  describe '#output_projection=' do
+    context 'param is a OGR::SpatialReference' do
+      it 'sets the attribute' do
+        projection = OGR::SpatialReference.new_from_epsg(4326)
+        subject.output_projection = projection
+        expect(subject.output_projection).to eq projection
+      end
+    end
+
+    context 'param is not a OGR::SpatialReference' do
+      it 'raises a OGR::InvalidSpatialReference exception' do
+        expect { subject.output_projection = 'meow' }.
+          to raise_exception OGR::InvalidSpatialReference
+      end
+    end
+  end
+
+  describe '#extract_min_max_from_array' do
+    context 'param is a 2-element Array' do
+      it 'sets the attribute' do
+        expect(subject.send(:extract_min_max_from_array, [1, 20], :foo, :bar)).
+          to eq([1, 20])
+      end
+    end
+
+    context 'param is an Array with not 2 elements' do
+      it 'raises an ArgumentError' do
+        expect { subject.send(:extract_min_max_from_array, [1, 20, 30], :foo, :bar) }.
+          to raise_exception ArgumentError
+      end
+    end
+  end
+
+  describe '#extract_min_max_from_hash' do
+    context 'param is a Hash with :min and :max keys' do
+      it 'sets the attribute' do
+        expect(subject.send(:extract_min_max_from_hash, { min: 1, max: 20 }, :min, :max)).
+          to eq([1, 20])
+      end
+    end
+
+    context 'param is a Hash with :min, :max, and :other' do
+      it 'raises an ArgumentError' do
+        expect { subject.send(:extract_min_max_from_hash, { min: 1, max: 20, other: 30 }, :min, :max) }.
+          to raise_exception ArgumentError
+      end
+    end
+
+    context 'param is a Hash without :min and :max' do
+      it 'raises an ArgumentError' do
+        expect { subject.send(:extract_min_max_from_hash, { things: 1, stuff: 20 }, :min, :max) }.
+          to raise_exception ArgumentError
+      end
+    end
+  end
+end

data/spec/unit/gdal/gridder_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+require 'gdal/gridder'
+
+RSpec.describe GDAL::Gridder do
+  let(:source_layer) { instance_double 'OGR::Layer' }
+  let(:dest_file_name) { 'blah.docx' }
+  let(:gridder_options) { instance_double 'GDAL::GridderOptions' }
+
+  subject(:gridder) { described_class.new(source_layer, dest_file_name, gridder_options) }
+
+  describe '#build_output_spatial_reference' do
+    let(:spatial_reference) { instance_double 'OGR::SpatialRefernce' }
+
+    context 'no output_projection given, source layer has one set' do
+      before do
+        allow(gridder_options).to receive(:output_projection).and_return nil
+        allow(source_layer).to receive(:spatial_reference).and_return spatial_reference
+        allow(spatial_reference).to receive(:to_wkt).and_return 'BLAH'
+      end
+
+      it "returns WKT of the source layer's SpatialReference" do
+        expect(subject.send(:build_output_spatial_reference)).to eq 'BLAH'
+      end
+    end
+
+    context 'output_projection given' do
+      before do
+        allow(gridder_options).to receive(:output_projection).and_return spatial_reference
+        allow(spatial_reference).to receive(:to_wkt).and_return 'MEOW'
+      end
+
+      it "returns WKT of the source layer's SpatialReference" do
+        expect(subject.send(:build_output_spatial_reference)).to eq 'MEOW'
+      end
+    end
+
+    context 'no output_projection given, source layer does not have one set' do
+      before do
+        allow(gridder_options).to receive(:output_projection).and_return nil
+        allow(source_layer).to receive(:spatial_reference).and_return nil
+      end
+
+      it 'returns nil' do
+        expect(subject.send(:build_output_spatial_reference)).to eq nil
+      end
+    end
+  end
+
+  describe '#x_min' do
+    context 'output_x_extent is set' do
+      before { allow(gridder_options).to receive(:output_x_extent).and_return(min: 123) }
+
+      it 'sets x_min to that value' do
+        expect(subject.send(:x_min)).to eq 123
+      end
+    end
+
+    context 'output_x_extent is not set' do
+      let(:extent) { instance_double 'OGR::Envelope', x_min: 456 }
+
+      before do
+        allow(gridder_options).to receive(:output_x_extent).and_return({})
+        allow(source_layer).to receive(:extent).and_return extent
+      end
+
+      it "sets x_min to the source layer's extent's x_min value" do
+        expect(subject.send(:x_min)).to eq 456
+      end
+    end
+  end
+
+  describe '#x_max' do
+    context 'output_x_extent is set' do
+      before { allow(gridder_options).to receive(:output_x_extent).and_return(max: 321) }
+
+      it 'sets x_max to that value' do
+        expect(subject.send(:x_max)).to eq 321
+      end
+    end
+
+    context 'output_x_extent is not set' do
+      let(:extent) { instance_double 'OGR::Envelope', x_max: 654 }
+
+      before do
+        allow(gridder_options).to receive(:output_x_extent).and_return({})
+        allow(source_layer).to receive(:extent).and_return extent
+      end
+
+      it "sets x_max to the source layer's extent's x_max value" do
+        expect(subject.send(:x_max)).to eq 654
+      end
+    end
+  end
+
+  describe '#y_min' do
+    context 'output_y_extent is set' do
+      before { allow(gridder_options).to receive(:output_y_extent).and_return(min: 123) }
+
+      it 'sets y_min to that value' do
+        expect(subject.send(:y_min)).to eq 123
+      end
+    end
+
+    context 'output_y_extent is not set' do
+      let(:extent) { instance_double 'OGR::Envelope', y_min: 456 }
+
+      before do
+        allow(gridder_options).to receive(:output_y_extent).and_return({})
+        allow(source_layer).to receive(:extent).and_return extent
+      end
+
+      it "sets y_min to the source layer's extent's y_min value" do
+        expect(subject.send(:y_min)).to eq 456
+      end
+    end
+  end
+
+  describe '#y_max' do
+    context 'output_y_extent is set' do
+      before { allow(gridder_options).to receive(:output_y_extent).and_return(max: 321) }
+
+      it 'sets y_max to that value' do
+        expect(subject.send(:y_max)).to eq 321
+      end
+    end
+
+    context 'output_y_extent is not set' do
+      let(:extent) { instance_double 'OGR::Envelope', y_max: 654 }
+
+      before do
+        allow(gridder_options).to receive(:output_y_extent).and_return({})
+        allow(source_layer).to receive(:extent).and_return extent
+      end
+
+      it "sets y_max to the source layer's extent's y_max value" do
+        expect(subject.send(:y_max)).to eq 654
+      end
+    end
+  end
+end

data/spec/unit/gdal/internal_helpers_spec.rb

@@ -93,8 +93,58 @@ RSpec.describe GDAL::InternalHelpers do
     end
 
     context 'data type is not one listed' do
-      subject { tester._gdal_data_type_to_ffi(:blargh) }
-      it { is_expected.to eq :float }
+      it 'raises a GDAL::InvalidDataType' do
+        expect { tester._gdal_data_type_to_ffi(:blargh) }.
+          to raise_exception(GDAL::InvalidDataType)
+      end
+    end
+  end
+
+  describe '._read_pointer' do
+    context 'length is 1' do
+      let(:pointer) do
+        p = FFI::MemoryPointer.new(:int16)
+        p.write_int16(12_345)
+
+        p
+      end
+
+      it 'returns the data value' do
+        expect(GDAL._read_pointer(pointer, :GDT_Int16)).to eq(12_345)
+      end
+    end
+
+    context 'length is > 1' do
+      let(:pointer) do
+        p = FFI::MemoryPointer.new(:int16, 2)
+        p.write_array_of_int16([12_345, 222])
+
+        p
+      end
+
+      it 'returns the data value' do
+        expect(GDAL._read_pointer(pointer, :GDT_Int16, 2)).to eq([12_345, 222])
+      end
+    end
+  end
+
+  describe '._write_pointer' do
+    context 'data is not an Array' do
+      let(:pointer) { FFI::MemoryPointer.new(:int16) }
+
+      it 'writes the single value to the pointer' do
+        expect(pointer).to receive(:write_int16).with(12_345)
+        GDAL._write_pointer(pointer, :GDT_Int16, 12_345)
+      end
+    end
+
+    context 'data is an Array' do
+      let(:pointer) { FFI::MemoryPointer.new(:int16, 2) }
+
+      it 'writes the values to the pointer' do
+        expect(pointer).to receive(:write_array_of_int16).with([12_345, 222])
+        GDAL._write_pointer(pointer, :GDT_Int16, [12_345, 222])
+      end
     end
   end
 
@@ -109,4 +159,118 @@ RSpec.describe GDAL::InternalHelpers do
       it { is_expected.to eq false }
     end
   end
+
+  describe '._gdal_data_type_to_narray' do
+    subject { GDAL._gdal_data_type_to_narray(data_type) }
+
+    context 'data_type is :GDT_Byte' do
+      let(:data_type) { :GDT_Byte }
+      it { is_expected.to eq(:byte) }
+    end
+
+    context 'data_type is :GDT_Int16' do
+      let(:data_type) { :GDT_Int16 }
+      it { is_expected.to eq(:sint) }
+    end
+
+    context 'data_type is :GDT_UInt16' do
+      let(:data_type) { :GDT_UInt16 }
+      it { is_expected.to eq(:int) }
+    end
+
+    context 'data_type is :GDT_Int32' do
+      let(:data_type) { :GDT_Int32 }
+      it { is_expected.to eq(:int) }
+    end
+
+    context 'data_type is :GDT_UInt32' do
+      let(:data_type) { :GDT_UInt32 }
+      it { is_expected.to eq(:int) }
+    end
+
+    context 'data_type is :GDT_Float32' do
+      let(:data_type) { :GDT_Float32 }
+      it { is_expected.to eq(:float) }
+    end
+
+    context 'data_type is :GDT_Float64' do
+      let(:data_type) { :GDT_Float64 }
+      it { is_expected.to eq(:dfloat) }
+    end
+
+    context 'data_type is :GDT_CInt16' do
+      let(:data_type) { :GDT_CInt16 }
+      it { is_expected.to eq(:scomplex) }
+    end
+
+    context 'data_type is :GDT_CInt32' do
+      let(:data_type) { :GDT_CInt32 }
+      it { is_expected.to eq(:scomplex) }
+    end
+
+    context 'data_type is :GDT_CFloat32' do
+      let(:data_type) { :GDT_CFloat32 }
+      it { is_expected.to eq(:complex) }
+    end
+
+    context 'data_type is :GDT_CFloat64' do
+      let(:data_type) { :GDT_CFloat64 }
+      it { is_expected.to eq(:dcomplex) }
+    end
+
+    context 'unknown data_type' do
+      it 'raises a GDAL::InvalidDataType exception' do
+        expect { GDAL._gdal_data_type_to_narray(:meow) }.
+          to raise_exception(GDAL::InvalidDataType)
+      end
+    end
+  end
+
+  describe '._narray_from_data_type' do
+    context '0 narray_args and known GDAL data_type' do
+      subject { GDAL._narray_from_data_type(:GDT_Byte) }
+      it { is_expected.to be_a NArray }
+
+      it 'has size 0' do
+        expect(subject.size).to be_zero
+      end
+
+      it 'has shape []' do
+        expect(subject.shape).to eq([])
+      end
+    end
+
+    context '1 narray_args and known GDAL data_type' do
+      subject { GDAL._narray_from_data_type(:GDT_Byte, 2) }
+      it { is_expected.to be_a NArray }
+
+      it 'has size of the 2nd param' do
+        expect(subject.size).to eq(2)
+      end
+
+      it 'has 1D shape with size of the 2nd param' do
+        expect(subject.shape).to eq([2])
+      end
+    end
+
+    context '2 narray_args and known GDAL data_type' do
+      subject { GDAL._narray_from_data_type(:GDT_Byte, 2, 3) }
+      it { is_expected.to be_a NArray }
+
+      it 'has size of the 2nd param * 3rd param' do
+        expect(subject.size).to eq(6)
+      end
+
+      it 'has 2D shape with size of each of the params' do
+        expect(subject.shape).to eq([2, 3])
+      end
+    end
+
+    context 'unknown GDAL data_type' do
+      it 'raises a GDAL::InvalidDataType exception' do
+        expect { GDAL._narray_from_data_type(:bobo) }.
+          to raise_exception(GDAL::InvalidDataType)
+      end
+    end
+  end
 end

data/spec/unit/gdal/major_object_spec.rb

@@ -3,4 +3,6 @@ require 'gdal/major_object'
 
 RSpec.describe GDAL::MajorObject do
   subject { Object.new.extend(described_class) }
+
+  pending 'Add some tests!'
 end

data/spec/unit/gdal/options_spec.rb

@@ -2,4 +2,5 @@ require 'spec_helper'
 require 'gdal/options'
 
 RSpec.describe GDAL::Options do
+  pending 'Add some tests!'
 end

data/spec/unit/gdal/raster_band_classifier_spec.rb

@@ -6,16 +6,15 @@ RSpec.describe GDAL::RasterBandClassifier do
   let(:driver) { GDAL::Driver.by_name('MEM') }
 
   let(:dataset) do
-    driver.create_dataset 'test dataset', 640, 480
-  end
-
-  let(:raster_band) do
-    band = dataset.raster_band 1
+    d = driver.create_dataset('test dataset', 640, 480)
+    band = d.raster_band 1
     new_values = band.to_na.indgen!
-    band.write_array(new_values)
-    band
+    band.write_xy_narray(new_values)
+
+    d
   end
 
+  let(:raster_band) { dataset.raster_band 1 }
   subject(:classifier) { described_class.new(raster_band) }
 
   describe '#add_range' do
@@ -70,7 +69,7 @@ RSpec.describe GDAL::RasterBandClassifier do
       let(:raster_band) do
         band = float_dataset.raster_band 1
         new_values = band.to_na.indgen!
-        band.write_array(new_values)
+        band.write_xy_narray(new_values)
         band
       end
 
@@ -95,6 +94,15 @@ RSpec.describe GDAL::RasterBandClassifier do
       subject { classifier.equal_count_ranges(1_000) }
       it { is_expected.to be_nil }
     end
+
+    context 'all nodata pixels' do
+      let(:band_narray) { NArray.byte(0) }
+      before { allow(raster_band).to receive(:to_na).and_return(band_narray) }
+
+      it 'returns an empty Array' do
+        expect(subject.equal_count_ranges(10)).to eq([])
+      end
+    end
   end
 
   describe '#classify!' do
@@ -103,37 +111,87 @@ RSpec.describe GDAL::RasterBandClassifier do
       subject.add_ranges(ranges)
     end
 
-    context 'no_data_value is set' do
+    context 'no_data_value is set to 0' do
       before do
         raster_band.no_data_value = 0
-        subject.classify!
       end
 
       it 'has a max value equal to the number of ranges' do
+        subject.classify!
         min_max = raster_band.min_max
         expect(min_max[:max]).to eq 10
       end
 
       it 'has a min value of 1' do
+        subject.classify!
         min_max = raster_band.min_max
         expect(min_max[:min]).to eq 1
       end
+
+      it 'retains its NODATA pixels' do
+        expect { subject.classify! }.to_not change { raster_band.to_na.eq(-9999.0).count_true }
+      end
     end
 
-    context 'no_data_value is not set' do
-      before do
+    # Relevant because NArray inits its arrays to 0.
+    context 'no_data_value is set to non-0' do
+      let(:dataset) do
+        d = driver.create_dataset('test dataset', 640, 480, data_type: :GDT_Float32)
+        band = d.raster_band 1
+        band.no_data_value = -9999.0
+        new_values = band.to_na.indgen!
+        new_values[true, 0] = -9999.0
+        band.write_xy_narray(new_values)
+
+        d
+      end
+
+      it 'has a max value equal to the number of ranges' do
         subject.classify!
+        min_max = raster_band.min_max
+        expect(min_max[:max]).to eq 10
+      end
+
+      it 'has a min value of 1' do
+        subject.classify!
+        min_max = raster_band.min_max
+        expect(min_max[:min]).to eq 1
       end
 
+      it 'retains its NODATA pixels' do
+        expect { subject.classify! }.to_not change { raster_band.to_na.eq(-9999.0).count_true }
+        pixels = raster_band.to_na
+        expect(pixels.eq(-9999).count_true).to eq 640
+        expect(pixels.eq(0).count_true).to eq 0
+        expect(pixels.eq(1).count_true).to eq 30_656
+        expect(pixels.eq(2).count_true).to eq 30_656
+        expect(pixels.eq(3).count_true).to eq 30_656
+        expect(pixels.eq(4).count_true).to eq 30_656
+        expect(pixels.eq(5).count_true).to eq 30_656
+        expect(pixels.eq(6).count_true).to eq 30_656
+        expect(pixels.eq(7).count_true).to eq 30_656
+        expect(pixels.eq(8).count_true).to eq 30_656
+        expect(pixels.eq(9).count_true).to eq 30_656
+        expect(pixels.eq(10).count_true).to eq 30_656
+      end
+    end
+
+    context 'no_data_value is not set' do
       it 'has a max value equal to the number of ranges' do
+        subject.classify!
         min_max = raster_band.min_max
         expect(min_max[:max]).to eq 10
       end
 
       it 'has a min value of 0' do
+        subject.classify!
         min_max = raster_band.min_max
         expect(min_max[:min]).to eq 0
       end
+
+      it 'retains its NODATA pixels' do
+        expect { subject.classify! }.to_not change { raster_band.to_na.eq(-9999.0).count_true }
+      end
     end
   end
 end