ffi-gdal 1.0.0.beta16 → 1.0.0

data/spec/integration/gdal/gridder_spec.rb

@@ -1,331 +0,0 @@
-# frozen_string_literal: true
-
-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,229 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'ffi-gdal'
-require 'gdal'
-
-RSpec.describe 'Raster Attribute Table Info', type: :integration do
-  let(:file) { make_temp_test_file(original_source_tiff) }
-
-  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
-
-    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) }
-
-    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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-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