ffi-gdal 1.0.0.beta6 → 1.0.0.beta7

data/spec/unit/gdal/dataset_mixins/warp_methods_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'gdal'
+
+RSpec.describe GDAL::Dataset do
+  let(:source_file_path) do
+    File.expand_path('../../../support/images/osgeo/geotiff/GeogToWGS84GeoKey/GeogToWGS84GeoKey5.tif', __dir__)
+  end
+
+  let(:output_dir) { Dir.mktmpdir(File.basename(__FILE__, '.rb')) }
+  let(:output_file) { File.join(output_dir, 'reprojected_image.tif') }
+
+  after { FileUtils.rm_rf(output_dir) if Dir.exist?(output_dir) }
+
+  subject { described_class.open(source_file_path, 'r', false) }
+
+  describe '#reproject_image' do
+    let(:dest_dataset) do
+      dest_width = subject.raster_x_size / 4
+      dest_height = subject.raster_y_size / 4
+      dataset = GDAL::Driver.by_name('GTiff').create_dataset(output_file, dest_width, dest_height,
+        data_type: subject.raster_band(1).data_type)
+      dataset.geo_transform = subject.geo_transform.dup
+      dataset.projection = OGR::SpatialReference.new_from_epsg(3857).to_wkt
+      dataset
+    end
+
+    after { dest_dataset.close }
+
+    it 'creates a valid dataset' do
+      subject.reproject_image(dest_dataset, :GRA_CubicSpline)
+
+      dest_dataset.flush_cache
+      expect(dest_dataset.projection).to match(/AUTHORITY\[\"EPSG\",\"3857\"\]/)
+      expect(dest_dataset.raster_count).to eq(subject.raster_count)
+    end
+  end
+
+  describe '#create_and_reproject_image' do
+    let(:output_projection) { OGR::SpatialReference.new_from_epsg(3857).to_wkt }
+
+    it 'creates a valid dataset' do
+      subject.create_and_reproject_image(output_file, :GRA_NearestNeighbor, OGR::SpatialReference.new_from_epsg(3857).to_wkt, GDAL::Driver.by_name('GTiff'))
+
+      dest_dataset = GDAL::Dataset.open(output_file, 'r')
+      expect(dest_dataset.projection).to match(/AUTHORITY\[\"EPSG\",\"3857\"\]/)
+      expect(dest_dataset.raster_count).to eq(subject.raster_count)
+
+      dest_driver = dest_dataset.driver
+      expect(dest_driver.long_name).to eq 'GeoTIFF'
+    end
+  end
+end

data/spec/unit/gdal/geo_transform_spec.rb

@@ -259,18 +259,5 @@ RSpec.describe GDAL::GeoTransform do
         expect(result).to eq pixel: -9000, line: -19_000
       end
     end
-
-    describe '#as_json' do
-      it 'returns the attributes as a Hash' do
-        expect(subject.as_json).to eq(
-          x_origin: 0.0,
-          x_rotation: 0.0,
-          pixel_width: 0.0,
-          y_origin: 0.0,
-          y_rotation: 0.0,
-          pixel_height: 0.0
-        )
-      end
-    end
   end
 end

data/spec/unit/gdal/grid_spec.rb

@@ -12,6 +12,14 @@ RSpec.describe GDAL::Grid do
     it { is_expected.to respond_to :algorithm_type }
   end
 
+  describe '#create' do
+    context 'no points to grid' do
+      it 'raises a GDAL::NoValuesToGrid' do
+        expect { subject.create([], {}, nil) }.to raise_exception GDAL::NoValuesToGrid
+      end
+    end
+  end
+
   describe '#make_points_pointer' do
     context 'array has values' do
       let(:points) { [1, 2, 3, 4] }

data/spec/unit/gdal/gridder_spec.rb

@@ -137,4 +137,44 @@ RSpec.describe GDAL::Gridder do
       end
     end
   end
+
+  describe '#build_block_count' do
+    it 'builds block sizes for both x and y' do
+      raster_width = 4
+      block_x_size = 2
+      raster_height = 5
+      block_y_size = 3
+
+      expect(subject).to receive(:build_block_size).with(raster_width, block_x_size).
+        and_call_original
+      expect(subject).to receive(:build_block_size).with(raster_height, block_y_size).
+        and_call_original
+
+      subject.send(:build_block_count, block_x_size, block_y_size, raster_width, raster_height)
+    end
+  end
+
+  describe '#build_block_size' do
+    context 'calculation should not be evenly divisible' do
+      it 'returns the floor of the count' do
+        raster_width = 4
+        block_x_size = 2
+
+        result = subject.send(:build_block_size, raster_width, block_x_size)
+
+        expect(result).to eq 2
+      end
+    end
+
+    context 'calculation should be evenly divisible' do
+      it 'returns the floor of the count' do
+        raster_width = 4
+        block_x_size = 1
+
+        result = subject.send(:build_block_size, raster_width, block_x_size)
+
+        expect(result).to eq 4
+      end
+    end
+  end
 end

data/spec/unit/gdal/options_spec.rb

@@ -2,5 +2,30 @@ require 'spec_helper'
 require 'gdal/options'
 
 RSpec.describe GDAL::Options do
-  pending 'Add some tests!'
+  describe '.to_hash' do
+    subject { described_class.to_hash(pointer) }
+
+    context 'options are set' do
+      let(:pointer) { described_class.pointer(hash) }
+
+      let(:hash) do
+        {
+          one: 'ONE',
+          two: 'TWO'
+        }
+      end
+
+      it 'returns the Ruby Hash' do
+        expect(subject).to eq(hash)
+      end
+    end
+
+    context 'pointer is null' do
+      let(:pointer) { FFI::MemoryPointer.new(:string) }
+
+      it 'returns an empty Hash' do
+        expect(subject).to eq({})
+      end
+    end
+  end
 end

data/spec/unit/gdal/warp_options_spec.rb

@@ -0,0 +1,336 @@
+require 'spec_helper'
+require 'gdal/warp_options'
+
+RSpec.describe GDAL::WarpOptions do
+  shared_examples 'a WarpOptions object' do
+    it 'inits proper types' do
+      expect(subject.warp_operation_options).to be_a Hash
+
+      expect(subject.source_bands).to be_a Array
+      expect(subject.destination_bands).to be_a Array
+
+      expect(subject.source_no_data_real).to be_a Array
+      expect(subject.source_no_data_imaginary).to be_a Array
+      expect(subject.destination_no_data_real).to be_a Array
+      expect(subject.destination_no_data_imaginary).to be_a Array
+
+      expect(subject.progress).to be_a FFI::Function
+      expect(subject.progress_arg).to be_a FFI::Pointer
+      expect(subject.transformer).to be_a FFI::Function
+      expect(subject.transformer_arg).to be_a FFI::Pointer
+
+      expect(subject.source_per_band_validity_mask_function).to be_a FFI::Pointer
+      expect(subject.source_per_band_validity_mask_function_arg).to be_a FFI::Pointer
+      expect(subject.source_validity_mask_function).to be_a FFI::Function
+      expect(subject.source_validity_mask_function_arg).to be_a FFI::Pointer
+      expect(subject.source_density_mask_function).to be_a FFI::Function
+      expect(subject.source_density_mask_function_arg).to be_a FFI::Pointer
+
+      expect(subject.destination_density_mask_function).to be_a FFI::Function
+      expect(subject.destination_density_mask_function_arg).to be_a FFI::Pointer
+      expect(subject.destination_validity_mask_function).to be_a FFI::Function
+      expect(subject.destination_validity_mask_function_arg).to be_a FFI::Pointer
+
+      expect(subject.pre_warp_chunk_processor).to be_a FFI::Function
+      expect(subject.pre_warp_processor_arg).to be_a FFI::Pointer
+      expect(subject.post_warp_chunk_processor).to be_a FFI::Function
+      expect(subject.post_warp_processor_arg).to be_a FFI::Pointer
+    end
+  end
+
+  describe '#initialize' do
+    context 'with no options' do
+      it_behaves_like 'a WarpOptions object'
+
+      it 'inits a FFI::GDAL::WarpOptions struct internally, with nothing set' do
+        expect(subject.warp_operation_options).to eq({})
+
+        expect(subject.warp_memory_limit).to be_zero
+        expect(subject.resample_alg).to eq(:GRA_NearestNeighbor) # 0 enum
+        expect(subject.working_data_type).to eq(:GDT_Unknown) # 0 enum
+
+        expect(subject.source_dataset).to be_nil
+        expect(subject.destination_dataset).to be_nil
+
+        expect(subject.band_count).to be_zero
+        expect(subject.source_bands).to be_empty
+        expect(subject.destination_bands).to be_empty
+
+        expect(subject.source_alpha_band).to be_zero
+        expect(subject.destination_alpha_band).to be_zero
+
+        expect(subject.source_no_data_real).to eq([])
+        expect(subject.source_no_data_imaginary).to eq([])
+        expect(subject.destination_no_data_real).to eq([])
+        expect(subject.destination_no_data_imaginary).to eq([])
+
+        expect(subject.progress).to_not be_null
+        expect(subject.progress_arg).to be_null
+
+        expect(subject.transformer).to be_null
+        expect(subject.transformer_arg).to be_null
+
+        expect(subject.source_per_band_validity_mask_function).to be_null
+        expect(subject.source_per_band_validity_mask_function_arg).to be_null
+
+        expect(subject.source_validity_mask_function).to be_null
+        expect(subject.source_validity_mask_function_arg).to be_null
+
+        expect(subject.source_density_mask_function).to be_null
+        expect(subject.source_density_mask_function_arg).to be_null
+
+        expect(subject.destination_density_mask_function).to be_null
+        expect(subject.destination_density_mask_function_arg).to be_null
+
+        expect(subject.destination_validity_mask_function).to be_null
+        expect(subject.destination_validity_mask_function_arg).to be_null
+
+        expect(subject.pre_warp_chunk_processor).to be_null
+        expect(subject.pre_warp_processor_arg).to be_null
+        expect(subject.post_warp_chunk_processor).to be_null
+        expect(subject.post_warp_processor_arg).to be_null
+
+        expect(subject.cutline).to be_nil
+        expect(subject.cutline_blend_distance).to eq(0.0)
+      end
+    end
+
+    context 'passing in options that are also accessor methods' do
+      let(:warp_operation_options) do
+        {
+          init_dest: 'NODATA',
+          write_flush: 'YES',
+          skip_nosource: 'NO',
+          sample_grid: 'YES'
+        }
+      end
+
+      let(:memory_driver) { GDAL::Driver.by_name('MEM') }
+      let(:source_dataset) { memory_driver.create_dataset 'source', 10, 20 }
+      let(:dest_dataset) { memory_driver.create_dataset 'dest', 20, 30 }
+      let(:cutline) { OGR::LineString.new }
+      let(:spb_validity_mask_function1) { proc { true } }
+      let(:spb_validity_mask_function2) { proc { false } }
+
+      after do
+        source_dataset.close
+        dest_dataset.close
+      end
+
+      subject do
+        described_class.new warp_operation_options: warp_operation_options,
+                            source_dataset: source_dataset,
+                            destination_dataset: dest_dataset,
+                            source_bands: [1, 2, 3],
+                            destination_bands: [2, 4, 6],
+                            cutline: cutline,
+                            source_no_data_real: [123.456, 78.9, -999.9],
+                            source_no_data_imaginary: [1.2, 3.4, -5.6],
+                            destination_no_data_real: [11.1, 22.2, 33.3],
+                            destination_no_data_imaginary: [-44.4, -55.5, -66.6],
+                            source_per_band_validity_mask_function: [
+                              spb_validity_mask_function1,
+                              spb_validity_mask_function2
+                            ]
+      end
+
+      it_behaves_like 'a WarpOptions object'
+
+      it 'sets warp_operation_options' do
+        expect(subject.warp_operation_options).to eq(warp_operation_options)
+      end
+
+      it' sets source_dataset and the internal pointer' do
+        expect(subject.source_dataset).to eq(source_dataset)
+        expect(subject.c_struct[:source_dataset]).to eq(source_dataset.c_pointer)
+      end
+
+      it' sets destination_dataset' do
+        expect(subject.destination_dataset).to eq(dest_dataset)
+        expect(subject.c_struct[:destination_dataset]).to eq(dest_dataset.c_pointer)
+      end
+
+      it 'sets source_bands' do
+        expect(subject.source_bands).to eq([1, 2, 3])
+      end
+
+      it 'sets destination_bands' do
+        expect(subject.destination_bands).to eq([2, 4, 6])
+      end
+
+      it 'sets band_count and the internal to 3' do
+        expect(subject.band_count).to eq 3
+        expect(subject.c_struct[:band_count]).to eq 3
+      end
+
+      it 'sets cutline and its internal pointer' do
+        expect(subject.cutline).to eq(cutline)
+        expect(subject.c_struct[:cutline]).to eq(cutline.c_pointer)
+      end
+
+      it 'sets source_no_data_real' do
+        expect(subject.source_no_data_real).to eq([123.456, 78.9, -999.9])
+      end
+
+      it 'sets source_no_data_imaginary' do
+        expect(subject.source_no_data_imaginary).to eq([1.2, 3.4, -5.6])
+      end
+
+      it 'sets destination_no_data_real' do
+        expect(subject.destination_no_data_real).to eq([11.1, 22.2, 33.3])
+      end
+
+      it 'sets destination_no_data_imaginary' do
+        expect(subject.destination_no_data_imaginary).to eq([-44.4, -55.5, -66.6])
+      end
+
+      it 'sets source_per_band_validity_mask_function' do
+        function_ptr = subject.source_per_band_validity_mask_function
+        expect(function_ptr).to be_a(FFI::Pointer)
+
+        function = function_ptr.read_pointer
+        expect(function).to_not be_null
+      end
+    end
+
+    context 'passing in options that are NOT accessor methods' do
+      def make_int_pointer(int)
+        i = FFI::MemoryPointer.new(:int)
+        i.write_int(int)
+        i
+      end
+
+      let(:progress) { proc { true } }
+      let(:test_mask_function) { proc { true } }
+
+      let(:source_per_band_validity_mask_function_arg) { make_int_pointer(5) }
+      let(:source_validity_mask_function_arg) { make_int_pointer(3) }
+      let(:source_density_mask_function_arg) { make_int_pointer(2) }
+      let(:destination_validity_mask_function_arg) { make_int_pointer(4) }
+      let(:destination_density_mask_function_arg) { make_int_pointer(11) }
+      let(:pre_warp_processor_arg) { make_int_pointer(7) }
+      let(:post_warp_processor_arg) { make_int_pointer(9) }
+
+      subject do
+        described_class.new warp_memory_limit: 123,
+                            resample_alg: :GRA_Lanczos,
+                            working_data_type: :GDT_CInt32,
+                            band_count: 3,
+                            source_alpha_band: 1,
+                            destination_alpha_band: 5,
+                            progress: progress,
+                            progress_arg: FFI::CPL::Progress::ScaledProgress,
+                            source_per_band_validity_mask_function_arg: source_per_band_validity_mask_function_arg,
+                            source_validity_mask_function: test_mask_function,
+                            source_validity_mask_function_arg: source_validity_mask_function_arg,
+                            source_density_mask_function: test_mask_function,
+                            source_density_mask_function_arg: source_density_mask_function_arg,
+                            destination_validity_mask_function: test_mask_function,
+                            destination_validity_mask_function_arg: destination_validity_mask_function_arg,
+                            destination_density_mask_function: test_mask_function,
+                            destination_density_mask_function_arg: destination_density_mask_function_arg,
+                            pre_warp_chunk_processor: proc { :CE_Warning },
+                            pre_warp_processor_arg: pre_warp_processor_arg,
+                            post_warp_chunk_processor: proc { :CE_Failure },
+                            post_warp_processor_arg: post_warp_processor_arg,
+                            cutline_blend_distance: 3.3
+      end
+
+      it_behaves_like 'a WarpOptions object'
+
+      it 'sets warp_memory_limit' do
+        expect(subject.warp_memory_limit).to eq(123)
+      end
+
+      it 'sets resample_alg' do
+        expect(subject.resample_alg).to eq(:GRA_Lanczos)
+      end
+
+      it 'sets working_data_type' do
+        expect(subject.working_data_type).to eq(:GDT_CInt32)
+      end
+
+      it 'sets band_count' do
+        expect(subject.band_count).to eq(3)
+      end
+
+      it 'sets source_alpha_band' do
+        expect(subject.source_alpha_band).to eq(1)
+      end
+
+      it 'sets destination_alpha_band' do
+        expect(subject.destination_alpha_band).to eq(5)
+      end
+
+      it 'sets progress_arg' do
+        expect(subject.progress_arg).to eq(FFI::CPL::Progress::ScaledProgress)
+      end
+
+      it 'sets source_per_band_validity_mask_function_arg' do
+        pointer = subject.source_per_band_validity_mask_function_arg
+        pointer.autorelease = false
+        expect(pointer.read_int).to eq 5
+      end
+
+      it 'sets source_validity_mask_function' do
+        expect(subject.source_validity_mask_function).to_not be_null
+      end
+
+      it 'sets source_validity_mask_function_arg' do
+        pointer = subject.source_validity_mask_function_arg
+        pointer.autorelease = false
+        expect(pointer.read_int).to eq 3
+      end
+
+      it 'sets source_density_mask_function' do
+        expect(subject.source_density_mask_function).to_not be_null
+      end
+
+      it 'sets source_density_mask_function_arg' do
+        pointer = subject.source_density_mask_function_arg
+        pointer.autorelease = false
+        expect(pointer.read_int).to eq 2
+      end
+
+      it 'sets destination_validity_mask_function' do
+        expect(subject.destination_validity_mask_function).to_not be_null
+      end
+
+      it 'sets destination_validity_mask_function_arg' do
+        pointer = subject.destination_validity_mask_function_arg
+        pointer.autorelease = false
+        expect(pointer.read_int).to eq 4
+      end
+
+      it 'sets destination_density_mask_function' do
+        expect(subject.destination_density_mask_function).to_not be_null
+      end
+
+      it 'sets destination_density_mask_function_arg' do
+        pointer = subject.destination_density_mask_function_arg
+        pointer.autorelease = false
+        expect(pointer.read_int).to eq 11
+      end
+
+      it 'sets pre_warp_chunk_processor' do
+        expect(subject.pre_warp_chunk_processor.call(nil, nil)).to eq(:CE_Warning)
+      end
+
+      it 'sets pre_warp_chunk_processor_arg' do
+        expect(subject.pre_warp_processor_arg).to_not be_null
+      end
+
+      it 'sets post_warp_chunk_processor' do
+        expect(subject.post_warp_chunk_processor.call(nil, nil)).to eq(:CE_Failure)
+      end
+
+      it 'sets post_warp_chunk_processor_arg' do
+        expect(subject.post_warp_processor_arg).to_not be_null
+      end
+
+      it 'sets cutline_blend_distance' do
+        expect(subject.cutline_blend_distance).to eq(3.3)
+      end
+    end
+  end
+end

data/spec/unit/ogr/feature_definition_spec.rb

@@ -291,23 +291,4 @@ RSpec.describe OGR::FeatureDefinition do
       end
     end
   end
-
-  describe '#as_json' do
-    it 'returns a Hash of all attributes and values' do
-      expect(subject.as_json).to eq(field_count: 0,
-                                    field_definitions: [],
-                                    geometry_field_count: 1,
-                                    geometry_type: :wkbMultiPolygon,
-                                    is_geometry_ignored: false,
-                                    is_style_ignored: false,
-                                    name: 'spec feature definition')
-    end
-  end
-
-  describe '#to_json' do
-    it 'is a String' do
-      expect(subject.to_json).to be_a String
-      expect(subject.to_json).to_not be_empty
-    end
-  end
 end

data/spec/unit/ogr/feature_extensions_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe OGR::Feature do
 
   let(:feature_definition) do
     fd = OGR::FeatureDefinition.new('test FD')
-    fd.add_field_definition(integer_field_def)        # 0
+    fd.add_field_definition(integer_field_def) # 0
 
     gfd = fd.geometry_field_definition(0)
     gfd.type = :wkbPoint

data/spec/unit/ogr/field_definition_spec.rb

@@ -113,23 +113,4 @@ RSpec.describe OGR::FieldDefinition do
       expect(subject).to be_ignored
     end
   end
-
-  describe '#as_json' do
-    it 'returns a Hash of attributes' do
-      expect(subject.as_json).to eq(
-        is_ignored: false,
-        justification: :OJUndefined,
-        name: 'test field',
-        precision: 0,
-        type: :OFTInteger,
-        width: 0
-      )
-    end
-  end
-
-  describe '#to_json' do
-    it 'returns a string' do
-      expect(subject.to_json).to be_a String
-    end
-  end
 end

data/spec/unit/ogr/geometry_field_definition_spec.rb

@@ -68,20 +68,4 @@ RSpec.describe OGR::GeometryFieldDefinition do
       end
     end
   end
-
-  describe '#as_json' do
-    it 'returns a Hash of attributes' do
-      expect(subject.as_json). to eq(
-        is_ignored: false,
-        name: 'test gfld',
-        spatial_reference: nil,
-        type: :wkbUnknown
-      )
-    end
-  end
-
-  describe '#to_json' do
-    subject { geometry_field_definition.to_json }
-    it { is_expected.to be_a String }
-  end
 end

data/spec/unit/ogr/style_table_spec.rb

@@ -103,30 +103,4 @@ RSpec.describe OGR::StyleTable do
       expect(subject.styles).to eq('style1' => '12345', 'style2' => '67890')
     end
   end
-
-  describe '#as_json' do
-    subject do
-      st = described_class.new
-      st.add_style('style1', '12345')
-      st.add_style('style2', '67890')
-      st
-    end
-
-    it 'returns the styles as a Hash' do
-      expect(subject.as_json).to eq('style1' => '12345', 'style2' => '67890')
-    end
-  end
-
-  describe '#to_json' do
-    subject do
-      st = described_class.new
-      st.add_style('style1', '12345')
-      st.add_style('style2', '67890')
-      st
-    end
-
-    it 'returns the styles' do
-      expect(subject.to_json).to eq('{"style1":"12345","style2":"67890"}')
-    end
-  end
 end