ffi-gdal 1.0.0.beta5 → 1.0.0.beta6

data/spec/integration/gdal/gridder_spec.rb

@@ -0,0 +1,329 @@
+require 'spec_helper'
+require 'gdal/gridder'
+require 'ogr/data_source'
+
+RSpec.describe 'GDAL::Gridder', type: :integration do
+  let(:shapefile_path) { File.expand_path('../../../spec/support/shapefiles/states_21basic', __dir__) }
+  let(:source_data_source) { OGR::DataSource.open(shapefile_path, 'r') }
+  let(:source_layer) { source_data_source.layer(0) }
+  let(:dataset) { GDAL::Dataset.open(output_file_name, 'w', true) }
+
+  after do
+    source_data_source.close if source_data_source.c_pointer
+    dataset.close if File.exist?(output_file_name)
+
+    Dir.glob("#{output_file_name}*").each do |file|
+      File.unlink(file) if File.exist?(file)
+    end
+  end
+
+  describe 'Inverse Distance to a Power' do
+    let(:gridder_options) do
+      gridder_options = GDAL::GridderOptions.new(:inverse_distance_to_a_power)
+
+      gridder_options.algorithm_options[:angle] = 10
+      gridder_options.algorithm_options[:max_points] = 5
+      gridder_options.algorithm_options[:min_points] = 1
+      gridder_options.algorithm_options[:no_data_value] = -9999
+      gridder_options.algorithm_options[:power] = 2
+      gridder_options.algorithm_options[:radius1] = 20
+      gridder_options.algorithm_options[:radius2] = 15
+      gridder_options.algorithm_options[:smoothing] = 5
+
+      gridder_options.input_field_name = 'STATE_FIPS'
+      gridder_options.output_size = { width: 300, height: 200 }
+      gridder_options.output_data_type = :GDT_UInt16
+
+      gridder_options
+    end
+
+    let(:output_file_name) { File.expand_path('../../../tmp/gridder_spec-idtap.tif', __dir__) }
+
+    it 'results in a raster with relevant data to the grid algorithm' do
+      gridder = GDAL::Gridder.new(source_layer, output_file_name, gridder_options)
+      gridder.grid!
+
+      expect(dataset.spatial_reference.authority_code.to_i).to eq 4269
+      expect(dataset.raster_band(1)).to be_a GDAL::RasterBand
+      expect(dataset.raster_band(1).no_data_value[:value]).to eq(-9999)
+      expect(dataset.raster_band(1).x_size).to eq 300
+      expect(dataset.raster_band(1).y_size).to eq 200
+      expect(dataset.raster_band(1).data_type).to eq :GDT_UInt16
+
+      stats = dataset.raster_band(1).statistics
+      expect(stats[:minimum]).to eq 0.0
+      expect(stats[:maximum]).to eq 55.0
+      expect(stats[:mean]).to be_within(0.000000000001).of 25.549166666667
+      expect(stats[:standard_deviation]).to be_within(0.000000000001).of 19.127859747926
+    end
+  end
+
+  describe 'Nearest Neighbor' do
+    let(:gridder_options) do
+      gridder_options = GDAL::GridderOptions.new(:nearest_neighbor)
+
+      gridder_options.algorithm_options[:angle] = 3
+      gridder_options.algorithm_options[:no_data_value] = -9999
+      gridder_options.algorithm_options[:radius1] = 2
+      gridder_options.algorithm_options[:radius2] = 1
+
+      gridder_options.input_field_name = 'STATE_FIPS'
+      gridder_options.output_size = { width: 10, height: 15 }
+      gridder_options.output_data_type = :GDT_Int16
+
+      gridder_options
+    end
+
+    let(:output_file_name) { File.expand_path('../../../tmp/gridder_spec-nearest_neighbor.tif', __dir__) }
+
+    it 'results in a raster with relevant data to the grid algorithm' do
+      gridder = GDAL::Gridder.new(source_layer, output_file_name, gridder_options)
+      gridder.grid!
+
+      expect(dataset.spatial_reference.authority_code.to_i).to eq 4269
+      expect(dataset.raster_band(1)).to be_a GDAL::RasterBand
+      expect(dataset.raster_band(1).no_data_value[:value]).to eq(-9999)
+      expect(dataset.raster_band(1).x_size).to eq 10
+      expect(dataset.raster_band(1).y_size).to eq 15
+      expect(dataset.raster_band(1).data_type).to eq :GDT_Int16
+
+      stats = dataset.raster_band(1).statistics
+      expect(stats[:minimum]).to eq 2.0
+      expect(stats[:maximum]).to eq 56.0
+      expect(stats[:mean]).to be_within(0.00000000001).of 16.972222222222
+      expect(stats[:standard_deviation]).to be_within(0.00000000001).of 16.308631169331
+    end
+  end
+
+  describe 'Metric Average Distance' do
+    let(:gridder_options) do
+      gridder_options = GDAL::GridderOptions.new(:metric_average_distance)
+
+      gridder_options.algorithm_options[:angle] = 30
+      gridder_options.algorithm_options[:no_data_value] = -9999
+      gridder_options.algorithm_options[:radius1] = 20
+      gridder_options.algorithm_options[:radius2] = 15
+      gridder_options.algorithm_options[:min_points] = 1000
+
+      gridder_options.input_field_name = 'STATE_FIPS'
+      gridder_options.output_size = { width: 100, height: 150 }
+      gridder_options.output_data_type = :GDT_UInt32
+
+      gridder_options
+    end
+
+    let(:output_file_name) { File.expand_path('../../../tmp/gridder_spec-metric_average_distance.tif', __dir__) }
+
+    it 'results in a raster with relevant data to the grid algorithm' do
+      gridder = GDAL::Gridder.new(source_layer, output_file_name, gridder_options)
+      gridder.grid!
+
+      expect(dataset.spatial_reference.authority_code.to_i).to eq 4269
+      expect(dataset.raster_band(1)).to be_a GDAL::RasterBand
+      expect(dataset.raster_band(1).no_data_value[:value]).to eq(-9999)
+      expect(dataset.raster_band(1).x_size).to eq 100
+      expect(dataset.raster_band(1).y_size).to eq 150
+      expect(dataset.raster_band(1).data_type).to eq :GDT_UInt32
+
+      stats = dataset.raster_band(1).statistics
+      expect(stats[:minimum]).to eq 0.0
+      expect(stats[:maximum]).to eq 17.0
+      expect(stats[:mean]).to be_within(0.000000000001).of 6.211
+      expect(stats[:standard_deviation]).to be_within(0.000000000001).of 5.9461944973235
+    end
+  end
+
+  describe 'Metric Average Distance Between Points' do
+    let(:gridder_options) do
+      gridder_options = GDAL::GridderOptions.new(:metric_average_distance_pts)
+
+      gridder_options.algorithm_options[:angle] = 0.1
+      gridder_options.algorithm_options[:no_data_value] = -9999
+      gridder_options.algorithm_options[:radius1] = 0.2
+      gridder_options.algorithm_options[:radius2] = 0.3
+      gridder_options.algorithm_options[:min_points] = 1
+
+      gridder_options.input_field_name = 'STATE_FIPS'
+      gridder_options.output_size = { width: 50, height: 250 }
+      gridder_options.output_data_type = :GDT_Float32
+
+      gridder_options
+    end
+
+    let(:output_file_name) { File.expand_path('../../../tmp/gridder_spec-metric_average_distance_pts.tif', __dir__) }
+
+    it 'results in a raster with relevant data to the grid algorithm' do
+      gridder = GDAL::Gridder.new(source_layer, output_file_name, gridder_options)
+      gridder.grid!
+
+      expect(dataset.spatial_reference.authority_code.to_i).to eq 4269
+      expect(dataset.raster_band(1)).to be_a GDAL::RasterBand
+      expect(dataset.raster_band(1).no_data_value[:value]).to eq(-9999)
+      expect(dataset.raster_band(1).x_size).to eq 50
+      expect(dataset.raster_band(1).y_size).to eq 250
+      expect(dataset.raster_band(1).data_type).to eq :GDT_Float32
+
+      stats = dataset.raster_band(1).statistics
+      expect(stats[:minimum]).to eq 0.0
+      expect(stats[:maximum]).to be_within(0.000000000001).of 0.43194779753685
+      expect(stats[:mean]).to be_within(0.000000000001).of 0.11661225064791
+      expect(stats[:standard_deviation]).to be_within(0.000000000001).of 0.081518691345895
+    end
+  end
+
+  describe 'Metric Count' do
+    let(:gridder_options) do
+      gridder_options = GDAL::GridderOptions.new(:metric_count)
+
+      gridder_options.algorithm_options[:angle] = 0.5
+      gridder_options.algorithm_options[:no_data_value] = -9999
+      gridder_options.algorithm_options[:radius1] = 0.1
+      gridder_options.algorithm_options[:radius2] = 0.2
+      gridder_options.algorithm_options[:min_points] = 1
+
+      gridder_options.input_field_name = 'STATE_FIPS'
+      gridder_options.output_size = { width: 50, height: 50 }
+      gridder_options.output_data_type = :GDT_Int32
+
+      gridder_options
+    end
+
+    let(:output_file_name) { File.expand_path('../../../tmp/gridder_spec-metric_count.tif', __dir__) }
+
+    it 'results in a raster with relevant data to the grid algorithm' do
+      gridder = GDAL::Gridder.new(source_layer, output_file_name, gridder_options)
+      gridder.grid!
+
+      expect(dataset.spatial_reference.authority_code.to_i).to eq 4269
+      expect(dataset.raster_band(1)).to be_a GDAL::RasterBand
+      expect(dataset.raster_band(1).no_data_value[:value]).to eq(-9999)
+      expect(dataset.raster_band(1).x_size).to eq 50
+      expect(dataset.raster_band(1).y_size).to eq 50
+      expect(dataset.raster_band(1).data_type).to eq :GDT_Int32
+
+      stats = dataset.raster_band(1).statistics
+      expect(stats[:minimum]).to eq 1.0
+      expect(stats[:maximum]).to eq 18.0
+      expect(stats[:mean]).to be_within(0.000000000001).of 3.9318181818182
+      expect(stats[:standard_deviation]).to be_within(0.000000000001).of 3.7135974182892
+    end
+  end
+
+  describe 'Metric Maximum' do
+    let(:gridder_options) do
+      gridder_options = GDAL::GridderOptions.new(:metric_maximum)
+
+      gridder_options.algorithm_options[:angle] = 30
+      gridder_options.algorithm_options[:no_data_value] = -9999
+      gridder_options.algorithm_options[:radius1] = 90
+      gridder_options.algorithm_options[:radius2] = 0.1
+      gridder_options.algorithm_options[:min_points] = 1
+
+      gridder_options.input_field_name = 'STATE_FIPS'
+      gridder_options.output_size = { width: 50, height: 50 }
+      gridder_options.output_data_type = :GDT_Byte
+
+      gridder_options
+    end
+
+    let(:output_file_name) { File.expand_path('../../../tmp/gridder_spec-metric_maximum.tif', __dir__) }
+
+    it 'results in a raster with relevant data to the grid algorithm' do
+      skip 'AGDEV-13650 figure out why this test causes a crash'
+      gridder = GDAL::Gridder.new(source_layer, output_file_name, gridder_options)
+      gridder.grid!
+
+      expect(dataset.spatial_reference.authority_code.to_i).to eq 4269
+      expect(dataset.raster_band(1)).to be_a GDAL::RasterBand
+      expect(dataset.raster_band(1).no_data_value[:value]).to eq(-9999)
+      expect(dataset.raster_band(1).x_size).to eq 50
+      expect(dataset.raster_band(1).y_size).to eq 50
+      expect(dataset.raster_band(1).data_type).to eq :GDT_Byte
+
+      stats = dataset.raster_band(1).statistics
+      expect(stats[:minimum]).to eq 0.0
+      expect(stats[:maximum]).to eq 56.0
+      expect(stats[:mean]).to be_within(0.000000000001).of 26.3916
+      expect(stats[:standard_deviation]).to be_within(0.000000000001).of 24.779859754244
+    end
+  end
+
+  describe 'Metric Minimum' do
+    let(:gridder_options) do
+      gridder_options = GDAL::GridderOptions.new(:metric_minimum)
+
+      gridder_options.algorithm_options[:angle] = 30
+      gridder_options.algorithm_options[:no_data_value] = -9999
+      gridder_options.algorithm_options[:radius1] = 90
+      gridder_options.algorithm_options[:radius2] = 0.1
+      gridder_options.algorithm_options[:min_points] = 1
+
+      gridder_options.input_field_name = 'STATE_FIPS'
+      gridder_options.output_size = { width: 50, height: 50 }
+      gridder_options.output_data_type = :GDT_CInt16
+
+      gridder_options
+    end
+
+    let(:output_file_name) { File.expand_path('../../../tmp/gridder_spec-metric_minimum.tif', __dir__) }
+
+    it 'results in a raster with relevant data to the grid algorithm' do
+      skip 'AGDEV-13650 figure out why this test causes a crash'
+      gridder = GDAL::Gridder.new(source_layer, output_file_name, gridder_options)
+      gridder.grid!
+
+      expect(dataset.spatial_reference.authority_code.to_i).to eq 4269
+      expect(dataset.raster_band(1)).to be_a GDAL::RasterBand
+      expect(dataset.raster_band(1).no_data_value[:value]).to eq(-9999)
+      expect(dataset.raster_band(1).x_size).to eq 50
+      expect(dataset.raster_band(1).y_size).to eq 50
+      expect(dataset.raster_band(1).data_type).to eq :GDT_CInt16
+
+      stats = dataset.raster_band(1).statistics
+      expect(stats[:minimum]).to eq 1.0
+      expect(stats[:maximum]).to eq 53.0
+      expect(stats[:mean]).to be_within(0.000000000001).of 9.1150793650794
+      expect(stats[:standard_deviation]).to be_within(0.000000000001).of 12.575393694871
+    end
+  end
+
+  # TODO: This test seems particularly prone to ruby malloc errors.
+  describe 'Metric Range' do
+    let(:gridder_options) do
+      gridder_options = GDAL::GridderOptions.new(:metric_range)
+
+      gridder_options.algorithm_options[:angle] = 10
+      gridder_options.algorithm_options[:no_data_value] = -9999
+      gridder_options.algorithm_options[:radius1] = 40
+      gridder_options.algorithm_options[:radius2] = 10
+      gridder_options.algorithm_options[:min_points] = 1
+
+      gridder_options.input_field_name = 'STATE_FIPS'
+      gridder_options.output_size = { width: 50, height: 50 }
+      gridder_options.output_data_type = :GDT_CFloat64
+
+      gridder_options
+    end
+
+    let(:output_file_name) { File.expand_path('../../../tmp/gridder_spec-metric_range.tif', __dir__) }
+
+    it 'results in a raster with relevant data to the grid algorithm' do
+      skip 'AGDEV-13650 figure out why this test causes a crash'
+      gridder = GDAL::Gridder.new(source_layer, output_file_name, gridder_options)
+      gridder.grid!
+
+      expect(dataset.spatial_reference.authority_code.to_i).to eq 4269
+      expect(dataset.raster_band(1)).to be_a GDAL::RasterBand
+      expect(dataset.raster_band(1).no_data_value[:value]).to eq(-9999)
+      expect(dataset.raster_band(1).x_size).to eq 50
+      expect(dataset.raster_band(1).y_size).to eq 50
+      expect(dataset.raster_band(1).data_type).to eq :GDT_CFloat64
+
+      stats = dataset.raster_band(1).statistics
+      expect(stats[:minimum]).to eq 0.0
+      expect(stats[:maximum]).to eq 55.0
+      expect(stats[:mean]).to be_within(0.000000000001).of 28.216176470588234
+      expect(stats[:standard_deviation]).to be_within(0.000000000001).of 24.681864682477947
+    end
+  end
+end

data/spec/integration/gdal/raster_attribute_table_info_spec.rb

@@ -1,22 +1,227 @@
 require 'spec_helper'
-require 'support/integration_help'
 require 'ffi-gdal'
+require 'gdal'
 
-TIF_FILES.each do |file|
-  dataset =  GDAL::Dataset.open(file, 'r')
+RSpec.describe 'Raster Attribute Table Info', type: :integration do
+  let(:file) { make_temp_test_file(original_source_tiff) }
 
-  RSpec.describe 'Raster Band Info' do
-    after :all do
-      dataset.close
+  let(:original_source_tiff) do
+    path = '../../../spec/support/images/osgeo/gdal/data/hfa/float-rle.img'
+    File.expand_path(path, __dir__)
+  end
+
+  let(:dataset) { GDAL::Dataset.open(file, 'r') }
+  after { dataset.close }
+
+  subject do
+    band = dataset.raster_band(1)
+    band.default_raster_attribute_table
+  end
+
+  describe '#changes_written_to_file?' do
+    context 'no changes to file' do
+      it 'is true' do
+        expect(subject.changes_written_to_file?).to eq true
+      end
+    end
+  end
+
+  describe '#column_count' do
+    it 'retrieves the column count' do
+      expect(subject.column_count).to eq 1
+    end
+  end
+
+  describe '#column_name' do
+    it 'retrieves the column name' do
+      expect(subject.column_name(0)).to eq 'Histogram'
+    end
+  end
+
+  describe '#column_usage' do
+    it 'retrieves the column usage' do
+      expect(subject.column_usage(0)).to eq :GFU_PixelCount
+    end
+  end
+
+  describe '#column_type' do
+    context 'column number exists' do
+      it 'retrieves the column type' do
+        expect(subject.column_type(0)).to eq :GFT_Real
+      end
+    end
+
+    context 'column number does not exist' do
+      it 'returns :GFT_Integer' do
+        expect(subject.column_type(110)).to eq :GFT_Integer
+      end
+    end
+  end
+
+  describe '#column_of_usage' do
+    context 'column with usage type exists' do
+      it 'retrieves the index of column' do
+        expect(subject.column_of_usage(:GFU_PixelCount)).to eq 0
+      end
+    end
+
+    context 'column with usage type does not exist' do
+      it 'returns nil' do
+        expect(subject.column_of_usage(:GFU_Name)).to be_nil
+      end
+    end
+
+    context 'column with invalid usage type' do
+      it 'returns nil' do
+        expect { subject.column_of_usage(:GFU_Meow) }.to raise_exception ArgumentError
+      end
+    end
+  end
+
+  describe '#create_column' do
+    context 'valid params, dataset not opened in write mode' do
+      it 'raises a GDAL::NoWriteAccess' do
+        expect { subject.create_column('things', :GFT_String, :GFU_Name) }.
+          to raise_exception GDAL::NoWriteAccess
+      end
+    end
+
+    context 'valid params' do
+      let(:dataset) { GDAL::Dataset.open(file, 'w') }
+
+      it 'adds the column' do
+        subject.create_column('things', :GFT_Integer, :GFU_Red)
+        expect(subject.column_name(1)).to eq 'Red'
+        expect(subject.column_usage(1)).to eq :GFU_Red
+        expect(subject.column_type(1)).to eq :GFT_Integer
+      end
+    end
+  end
+
+  describe '#row_count' do
+    it 'returns the number of rows' do
+      expect(subject.row_count).to eq 256
+    end
+  end
+
+  describe '#row_count=' do
+    context 'dataset not opened in write mode' do
+      it 'raises a GDAL::NoWriteAccess' do
+        expect { subject.row_count = 1 }.to raise_exception GDAL::NoWriteAccess
+      end
     end
 
-    subject do
-      band = dataset.raster_band(1)
-      band.default_raster_attribute_table
+    context 'dataset opened in write mode' do
+      let(:dataset) { GDAL::Dataset.open(file, 'w') }
+
+      it 'sets the number of rows' do
+        subject.row_count = 2
+        expect(subject.row_count).to eq 2
+      end
+    end
+  end
+
+  describe '#row_of_value' do
+    context 'a row exists for the given pixel value' do
+      it 'returns the row index' do
+        expect(subject.row_of_value(58_595)).to eq 253
+      end
+    end
+
+    context 'a row does not exist for the given pixel value' do
+      it 'returns nil' do
+        expect(subject.row_of_value(123_456)).to eq nil
+      end
+    end
+  end
+
+  describe '#set_value_as_string' do
+    context 'dataset not opened in write mode' do
+      it 'raises a GDAL::NoWriteAccess' do
+        expect { subject.set_value_as_string(0, 0, 'test') }.to raise_exception GDAL::NoWriteAccess
+      end
+    end
+
+    context 'column is a double' do
+      let(:dataset) { GDAL::Dataset.open(file, 'w') }
+
+      it 'sets the value' do
+        subject.set_value_as_string(0, 0, 'test')
+        expect(subject.value_as_string(0, 0)).to eq '0'
+      end
+    end
+  end
+
+  describe '#set_value_as_double' do
+    context 'dataset not opened in write mode' do
+      it 'raises a GDAL::NoWriteAccess' do
+        expect { subject.set_value_as_double(0, 0, 1.2) }.to raise_exception GDAL::NoWriteAccess
+      end
+    end
+
+    context 'column is a double' do
+      let(:dataset) { GDAL::Dataset.open(file, 'w') }
+
+      it 'sets the value' do
+        subject.set_value_as_double(0, 0, 1.2)
+        expect(subject.value_as_double(0, 0)).to eq 1.2
+      end
+    end
+  end
+
+  describe '#set_value_as_integer' do
+    context 'dataset not opened in write mode' do
+      it 'raises a GDAL::NoWriteAccess' do
+        expect { subject.set_value_as_integer(0, 0, 1) }.to raise_exception GDAL::NoWriteAccess
+      end
+    end
+
+    context 'column is a double' do
+      let(:dataset) { GDAL::Dataset.open(file, 'w') }
+
+      it 'sets the value' do
+        subject.set_value_as_integer(0, 0, 1)
+        expect(subject.value_as_integer(0, 0)).to eq 1
+      end
     end
+  end
+
+  describe '#linear_binning' do
+    it 'returns a Hash that contains binning info' do
+      expect(subject.linear_binning).to eq(row_0_minimum: 0.0, bin_size: 230.79607843137254)
+    end
+  end
+
+  describe '#set_linear_binning' do
+    context 'dataset not opened in write mode' do
+      it 'raises a GDAL::NoWriteAccess' do
+        expect { subject.set_linear_binning(0, 0) }.to raise_exception GDAL::NoWriteAccess
+      end
+    end
+
+    context 'valid binning params' do
+      let(:dataset) { GDAL::Dataset.open(file, 'w') }
+
+      it 'returns a Hash that contains binning info' do
+        subject.set_linear_binning(1, 20)
+        expect(subject.linear_binning).to eq(row_0_minimum: 1.0, bin_size: 20.0)
+      end
+    end
+  end
+
+  describe '#to_color_table' do
+    it 'returns nil' do
+      expect(subject.to_color_table).to be_nil
+    end
+  end
+
+  describe '#dump_readable' do
+    let(:output_path) { File.expand_path('tmp/raster_attribute_table_info') }
+    after { File.unlink(output_path) if File.exist?(output_path) }
 
-    describe '#column_count' do
-      pending 'Test files with RATs'
+    it 'writes to the file' do
+      subject.dump_readable(output_path)
+      expect(File.exist?(output_path)).to eq true
     end
   end
 end

data/spec/integration/gdal/raster_band_algorithms_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'gdal/dataset'
+require 'gdal/raster_band'
+
+RSpec.describe GDAL::RasterBand, type: :integration do
+  describe '#sieve_filter!' do
+    let(:source_image_path) { 'spec/support/images/osgeo/geotiff/zi_imaging/image0.tif' }
+    let(:dest_image_path) { 'tmp/image0.tif' }
+
+    before do
+      FileUtils.rm(dest_image_path) if File.exist?(dest_image_path)
+      FileUtils.cp(source_image_path, dest_image_path)
+    end
+
+    it 'removes some polygons' do
+      dataset = GDAL::Dataset.open(dest_image_path, 'w')
+      band = dataset.raster_band(1)
+
+      ogr_driver = OGR::Driver.by_name('Memory')
+      data_source = ogr_driver.create_data_source('meow')
+      layer_before = data_source.create_layer('before', spatial_reference: dataset.spatial_reference)
+      band.polygonize(layer_before)
+
+      band.sieve_filter!(1000, 4)
+      layer_after = data_source.create_layer('after', spatial_reference: dataset.spatial_reference)
+      band.polygonize(layer_after)
+
+      expect(layer_before.feature_count).to eq 62
+      expect(layer_after.feature_count).to eq 15
+      dataset.close
+    end
+  end
+end