ffi-gdal 1.0.0.beta16 → 1.0.0

data/spec/unit/gdal/internal_helpers_spec.rb

@@ -1,278 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'gdal/internal_helpers'
-require 'ogr/spatial_reference'
-require 'gdal/dataset'
-
-RSpec.describe GDAL::InternalHelpers do
-  subject(:tester) do
-    module Tester
-      include GDAL::InternalHelpers
-    end
-  end
-
-  describe '._pointer' do
-    context 'variable is a kind of the klass that was passed in' do
-      let(:variable) { OGR::SpatialReference.new }
-
-      it "returns the variable's pointer with autorelease = true" do
-        expect(variable.c_pointer).to receive(:autorelease=).with(true)
-        expect(subject._pointer(OGR::SpatialReference, variable)).to eq variable.c_pointer
-      end
-    end
-
-    context 'variable is an FFI::Pointer' do
-      let(:variable) { FFI::MemoryPointer.new(:pointer) }
-
-      it 'returns the pointer with autorelease = true' do
-        expect(variable).to receive(:autorelease=).with(true)
-        expect(subject._pointer(GDAL::Dataset, variable)).to eq variable
-      end
-    end
-
-    context 'variable is nil' do
-      it 'returns nil' do
-        expect(subject._pointer(GDAL::Dataset, nil, false)).to be_nil
-      end
-    end
-  end
-
-  describe '._string_array_to_pointer' do
-    context 'an array' do
-      let(:array) { ['one', 2, 3.0, :four] }
-
-      it 'returns a pointer that contains the array values as strings' do
-        pointer = subject._string_array_to_pointer(array)
-        expect(pointer).to be_an FFI::MemoryPointer
-        expect(pointer.get_array_of_string(0)).to eq %w[one 2 3.0 four]
-      end
-    end
-
-    context 'not an array' do
-      it 'raises an error about no responding to #map' do
-        expect do
-          subject._string_array_to_pointer('blarg')
-        end.to raise_exception NoMethodError
-      end
-    end
-  end
-
-  describe '._gdal_data_type_to_ffi' do
-    context 'data type is :GDT_Byte' do
-      subject { tester._gdal_data_type_to_ffi(:GDT_Byte) }
-      it { is_expected.to eq :uchar }
-    end
-
-    context 'data type is :GDT_UInt16' do
-      subject { tester._gdal_data_type_to_ffi(:GDT_UInt16) }
-      it { is_expected.to eq :uint16 }
-    end
-
-    context 'data type is :GDT_Int16' do
-      subject { tester._gdal_data_type_to_ffi(:GDT_Int16) }
-      it { is_expected.to eq :int16 }
-    end
-
-    context 'data type is :GDT_UInt32' do
-      subject { tester._gdal_data_type_to_ffi(:GDT_UInt32) }
-      it { is_expected.to eq :uint32 }
-    end
-
-    context 'data type is :GDT_Int32' do
-      subject { tester._gdal_data_type_to_ffi(:GDT_Int32) }
-      it { is_expected.to eq :int32 }
-    end
-
-    context 'data type is :GDT_Float32' do
-      subject { tester._gdal_data_type_to_ffi(:GDT_Float32) }
-      it { is_expected.to eq :float }
-    end
-
-    context 'data type is :GDT_Float64' do
-      subject { tester._gdal_data_type_to_ffi(:GDT_Float64) }
-      it { is_expected.to eq :double }
-    end
-
-    context 'data type is not one listed' do
-      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
-
-  describe '._supported?' do
-    context 'function is supported' do
-      subject { tester._supported?(:GDALAllRegister) }
-      it { is_expected.to eq true }
-    end
-
-    context 'function is not supported' do
-      subject { tester._supported?(:darrells) }
-      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

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-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

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'gdal/options'
-
-RSpec.describe GDAL::Options do
-  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/raster_attribute_table_spec.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'gdal/raster_attribute_table'
-
-RSpec.describe GDAL::RasterAttributeTable do
-end

data/spec/unit/gdal/raster_band_classifier_spec.rb

@@ -1,260 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'gdal/driver'
-require 'gdal/raster_band_classifier'
-
-RSpec.describe GDAL::RasterBandClassifier do
-  let(:driver) { GDAL::Driver.by_name('MEM') }
-
-  let(:dataset) do
-    d = driver.create_dataset('test dataset', 640, 480)
-    band = d.raster_band 1
-    new_values = band.to_na.indgen!
-    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
-    context 'range param is a Range' do
-      it 'adds the hash to the list of @ranges' do
-        expect do
-          subject.add_range 0..10, 1
-        end.to change { subject.ranges.size }.by 1
-      end
-    end
-
-    context 'range param is not a Range' do
-      it 'raises a RuntimeError' do
-        expect do
-          subject.add_range [1, 2, 3], 1
-        end.to raise_exception RuntimeError
-      end
-    end
-  end
-
-  describe '#add_ranges' do
-    let(:ranges) do
-      [
-        { range: 0..10, map_to: 1000 },
-        { range: 10..100, map_to: 1 }
-      ]
-    end
-
-    it 'adds a list of ranges to @ranges' do
-      expect do
-        subject.add_ranges(ranges)
-      end.to change { subject.ranges.size }.by ranges.size
-    end
-  end
-
-  describe '#equal_count_ranges' do
-    context 'band type is :GDT_Byte' do
-      subject { classifier.equal_count_ranges(4) }
-
-      it 'is an Array of Hashes' do
-        expect(subject).to be_an Array
-        expect(subject.first).to be_a Hash
-      end
-
-      it 'has map_to values that are between 1 and 4' do
-        map_to_values = subject.map { |range| range[:map_to] }.uniq
-        expect(map_to_values).to contain_exactly(1, 2, 3, 4)
-      end
-    end
-
-    context 'band type is :GDT_Float32' do
-      let(:raster_band) do
-        band = float_dataset.raster_band 1
-        new_values = band.to_na.indgen!
-        band.write_xy_narray(new_values)
-        band
-      end
-
-      let(:float_dataset) do
-        driver.create_dataset 'test dataset', 640, 480, data_type: :GDT_Float32
-      end
-
-      subject { classifier.equal_count_ranges(4) }
-
-      it 'is an Array of Hashes' do
-        expect(subject).to be_an Array
-        expect(subject.first).to be_a Hash
-      end
-
-      it 'has map_to values that are between 1 and 4' do
-        map_to_values = subject.map { |range| range[:map_to] }.uniq
-        expect(map_to_values).to contain_exactly(1.0, 2.0, 3.0, 4.0)
-      end
-    end
-
-    context 'not enough values between breaks to generate unique break values' do
-      subject { classifier.equal_count_ranges(1_000) }
-      it { is_expected.to be_nil }
-    end
-
-    context 'all same value' do
-      let(:band_narray) { Numo::Int8.new(3, 5).fill(1) }
-      before { allow(raster_band).to receive(:to_nna).and_return(band_narray) }
-
-      it 'returns a single range when 1 is requested' do
-        expect(subject.equal_count_ranges(1)).to eq [{ range: 1..1, map_to: 1 }]
-      end
-    end
-
-    context 'all nodata pixels' do
-      let(:band_narray) { Numo::Int8.new(3, 5).fill(0) }
-      before { allow(raster_band).to receive(:to_nna).and_return(band_narray) }
-
-      it 'returns an empty Array' do
-        expect(subject.equal_count_ranges(10)).to eq([])
-      end
-    end
-  end
-
-  describe '#ensure_min_gap' do
-    let(:break_values) do
-      [29_491.177616329518, 34_999.999999999985, 34_999.99999999999, 35_000.0, 35_000.01582852495, 36_499.9508667737]
-    end
-
-    let(:expected_values) do
-      [29_438.61973121367, 34_947.44211488414, 34_982.48598113636, 35_017.52984738857, 35_052.57371364079,
-       36_552.508751889545]
-    end
-
-    it 'ensures breakpoints have a gap between them of 0.5% of the total range' do
-      subject.send(:ensure_min_gap, break_values)
-      expect(break_values).to eq expected_values
-    end
-  end
-
-  describe '#classify!' do
-    before do
-      ranges = subject.equal_count_ranges(10)
-      subject.add_ranges(ranges)
-    end
-
-    context 'no_data_value is set to 0' do
-      before do
-        raster_band.no_data_value = 0
-      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
-
-    # 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
-
-  describe '#masked_pixels' do
-    let(:pixels) { dataset.raster_band(1).to_nna }
-    let(:raster_band) { double 'Band', no_data_value: { value: nodata_value } }
-
-    before { subject.instance_variable_set(:@raster_band, raster_band) }
-
-    context 'nodata is NaN' do
-      let(:nodata_value) { Float::NAN }
-      let(:pixels) { Numo::DFloat.cast(dataset.raster_band(1).to_nna) }
-
-      before do
-        pixels[pixels.eq(0)] = nodata_value
-      end
-
-      it 'removes all nodata values' do
-        expect(subject.send(:masked_pixels, pixels).isnan.count_true).to eq 0
-      end
-    end
-
-    context 'nodata is a number' do
-      let(:nodata_value) { 0 }
-
-      it 'removes all nodata values' do
-        expect(subject.send(:masked_pixels, pixels).eq(0).count_true).to eq 0
-      end
-    end
-
-    context 'nodata is nil' do
-      let(:nodata_value) { nil }
-
-      it 'returns the original pixels' do
-        expect(subject.send(:masked_pixels, pixels)).to eq pixels
-      end
-    end
-  end
-end

data/spec/unit/gdal/raster_band_mixins/extensions_spec.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'gdal/driver'
-require 'gdal/raster_band'
-
-RSpec.describe 'GDAL::RasterBandMixins::Extensions' do
-  let(:driver) { GDAL::Driver.by_name('MEM') }
-  let(:dataset_byte) { driver.create_dataset('test', 15, 25, data_type: :GDT_Byte) }
-  subject(:raster_band) { dataset_byte.raster_band(1) }
-
-  describe '#to_a' do
-    subject { raster_band.to_a }
-    it { is_expected.to eq(Array.new(25, Array.new(15, 0))) }
-  end
-
-  describe '#to_na' do
-    context 'no conversion' do
-      subject { raster_band.to_na }
-      it { is_expected.to eq(NArray.byte(15, 25)) }
-    end
-
-    context 'convert to Int16' do
-      subject { raster_band.to_na(:GDT_Int16) }
-      it { is_expected.to eq(NArray.sint(15, 25)) }
-    end
-
-    context 'convert to UInt16' do
-      subject { raster_band.to_na(:GDT_UInt16) }
-      it { is_expected.to eq(NArray.int(15, 25)) }
-    end
-
-    context 'convert to Int32' do
-      subject { raster_band.to_na(:GDT_Int32) }
-      it { is_expected.to eq(NArray.int(15, 25)) }
-    end
-
-    context 'convert to UInt32' do
-      subject { raster_band.to_na(:GDT_UInt32) }
-      it { is_expected.to eq(NArray.int(15, 25)) }
-    end
-
-    context 'convert to Float32' do
-      subject { raster_band.to_na(:GDT_Float32) }
-      it { is_expected.to eq(NArray.sfloat(15, 25)) }
-    end
-
-    context 'convert to Float64' do
-      subject { raster_band.to_na(:GDT_Float64) }
-      it { is_expected.to eq(NArray.float(15, 25)) }
-    end
-
-    context 'convert to CInt16' do
-      subject { raster_band.to_na(:GDT_CInt16) }
-      it { is_expected.to eq(NArray.scomplex(15, 25)) }
-    end
-
-    context 'convert to CInt32' do
-      subject { raster_band.to_na(:GDT_CInt32) }
-      it { is_expected.to eq(NArray.scomplex(15, 25)) }
-    end
-
-    context 'convert to CFloat32' do
-      subject { raster_band.to_na(:GDT_CFloat32) }
-      it { is_expected.to eq(NArray.scomplex(15, 25)) }
-    end
-
-    context 'convert to CFloat64' do
-      subject { raster_band.to_na(:GDT_CFloat64) }
-      it { is_expected.to eq(NArray.complex(15, 25)) }
-    end
-  end
-end