ffi-gdal 1.0.0.beta6 → 1.0.0.beta7

data/lib/gdal/raster_band_mixins/io_extensions.rb

@@ -24,6 +24,7 @@ module GDAL
       # @param pixel_array [NArray] The 2d list of pixels.
       def write_xy_narray(pixel_array)
         data_pointer = FFI::MemoryPointer.new(:buffer_out, block_buffer_size)
+        read_start = 0
 
         block_count[:y].times do |y_block_number|
           block_count[:x].times do |x_block_number|
@@ -31,14 +32,14 @@ module GDAL
             x_block_size = calculate_x_block_size(x_block_number)
 
             pixel_count_per_block = x_block_size * y_block_size
-            read_offset = (y_block_number + 1) * (x_block_number + 1)
-            read_range = ((read_offset - 1) * pixel_count_per_block)...(read_offset * pixel_count_per_block)
+            read_range = (read_start...(read_start + pixel_count_per_block))
             pixels = pixel_array[read_range]
             GDAL._write_pointer(data_pointer, data_type, pixels.to_a)
 
             write_block(x_block_number, y_block_number, data_pointer)
 
             data_pointer.clear
+            read_start = read_range.end
           end
         end
       end
@@ -69,7 +70,7 @@ module GDAL
       # Determines not only x and y block counts (how many blocks there are in
       # the raster band when using GDAL's suggested block size), but remainder
       # x and y counts for when the total number of pixels and lines does not
-      # divide evently using GDAL's block count.
+      # divide evenly using GDAL's block count.
       #
       # @return [Hash{x => Fixnum, x_remainder => Fixnum, y => Fixnum,
       #   y_remainder => Fixnum}]

data/lib/gdal/warp_options.rb

@@ -3,12 +3,28 @@ require_relative '../gdal'
 module GDAL
   class WarpOptions
     attr_reader :c_struct
+    attr_reader :source_dataset
+    attr_reader :destination_dataset
+    attr_reader :cutline
 
     def initialize(options = {})
       @c_struct = FFI::GDAL::WarpOptions.new
-
-      options.keys do |k|
-        @c_struct[k] = options[k]
+      @source_dataset = nil
+      @destination_dataset = nil
+
+      options.each_key do |k|
+        assign_meth = "#{k}=".to_sym
+
+        begin
+          if respond_to?(assign_meth)
+            send(assign_meth, options[k])
+          else
+            @c_struct[k] = options[k]
+          end
+        rescue ArgumentError => ex
+          new_message = "#{k}; #{ex.message}"
+          raise $ERROR_INFO, new_message, $ERROR_INFO.backtrace
+        end
       end
     end
 
@@ -21,42 +37,40 @@ module GDAL
       @c_struct[:warp_operation_options] = GDAL::Options.pointer(options)
     end
 
-    # @param limit [Float]
-    def warp_memory_limit=(limit)
-      @c_struct[:warp_memory_limit] = limit
-    end
+    # @return [Hash]
+    def warp_operation_options
+      options = @c_struct[:warp_operation_options]
 
-    # @param algorithm_type [FFI::GDAL::Warper::ResampleAlg]
-    def resample_algorithm=(algorithm_type)
-      @c_struct[:resample_alg] = algorithm_type
-    end
-
-    # @param data_type [FFI::GDAL::GDAL::DataType]
-    def working_data_type=(data_type)
-      @c_struct[:working_data_type] = data_type
+      GDAL::Options.to_hash(options)
     end
 
     # @param dataset [GDAL::Dataset]
     def source_dataset=(dataset)
+      @source_dataset = dataset
       @c_struct[:source_dataset] = dataset.c_pointer
     end
 
     # @param dataset [GDAL::Dataset]
     def destination_dataset=(dataset)
+      @destination_dataset = dataset
       @c_struct[:destination_dataset] = dataset.c_pointer
     end
 
-    # @param count [Fixnum]
-    def band_count=(count)
-      @c_struct[:band_count] = count
-    end
-
     # @param band_numbers [Array<Fixnum>]
     def source_bands=(band_numbers)
-      bands_ptr = FFI::MemoryPointer.new(:pointer, band_numbers.length)
+      bands_ptr = FFI::MemoryPointer.new(:int, band_numbers.length)
       bands_ptr.write_array_of_int(band_numbers)
 
       @c_struct[:source_bands] = bands_ptr
+      @c_struct[:band_count] = band_numbers.length if band_numbers.length > @c_struct[:band_count]
+    end
+
+    # @return [Array<Fixnum>]
+    def source_bands
+      pointer = @c_struct[:source_bands]
+      return [] if pointer.null?
+
+      pointer.read_array_of_int(@c_struct[:band_count])
     end
 
     # @param band_numbers [Array<Fixnum>]
@@ -65,33 +79,32 @@ module GDAL
       bands_ptr.write_array_of_int(band_numbers)
 
       @c_struct[:destination_bands] = bands_ptr
+      @c_struct[:band_count] = band_numbers.length if band_numbers.length > @c_struct[:band_count]
     end
 
-    def transformer_arg=(transformation_object)
-      @c_struct[:transformer_arg] = transformation_object.c_pointer
+    # @return [Array<Fixnum>]
+    def destination_bands
+      pointer = @c_struct[:destination_bands]
+      return [] if pointer.null?
 
-      @c_struct[:transformer] = transformation_object.function
+      pointer.read_array_of_int(@c_struct[:band_count])
     end
 
-    def transformer=(transformer)
-      @c_struct[:transformer] = transformer
-    end
+    def transformer_arg=(transformation_object)
+      @c_struct[:transformer_arg] = transformation_object.c_pointer
 
-    def progress_formatter=(output_proc)
-      @c_struct[:progress] = output_proc
+      @c_struct[:transformer] = transformation_object.function
     end
 
-    def cutline_geometry=(geometry)
+    # @param geometry [OGR::Geometry]
+    def cutline=(geometry)
       raise 'Not a geom' unless geometry.is_a?(OGR::Geometry)
+      @cutline = geometry
 
       @c_struct[:cutline] = geometry.c_pointer
-      # @c_struct[:cutline] = geometry.clone.c_pointer
-    end
-
-    def cutline_blend_distance=(distance)
-      @c_struct[:cutline_blend_distance] = distance
     end
 
+    # @param values [Array<Float>]
     def source_no_data_real=(values)
       values_ptr = FFI::MemoryPointer.new(:double, values.length)
       values_ptr.write_array_of_double(values)
@@ -99,6 +112,15 @@ module GDAL
       @c_struct[:source_no_data_real] = values_ptr
     end
 
+    # @return [Array<Float>]
+    def source_no_data_real
+      pointer = @c_struct[:source_no_data_real]
+      return [] if pointer.null?
+
+      pointer.read_array_of_double(@c_struct[:band_count])
+    end
+
+    # @param values [Array<Float>]
     def source_no_data_imaginary=(values)
       values_ptr = FFI::MemoryPointer.new(:double, values.length)
       values_ptr.write_array_of_double(values)
@@ -106,6 +128,15 @@ module GDAL
       @c_struct[:source_no_data_imaginary] = values_ptr
     end
 
+    # @return [Array<Float>]
+    def source_no_data_imaginary
+      pointer = @c_struct[:source_no_data_imaginary]
+      return [] if pointer.null?
+
+      pointer.read_array_of_double(@c_struct[:band_count])
+    end
+
+    # @param values [Array<Float>]
     def destination_no_data_real=(values)
       values_ptr = FFI::MemoryPointer.new(:double, values.length)
       values_ptr.write_array_of_double(values)
@@ -113,6 +144,15 @@ module GDAL
       @c_struct[:destination_no_data_real] = values_ptr
     end
 
+    # @return [Array<Float>]
+    def destination_no_data_real
+      pointer = @c_struct[:destination_no_data_real]
+      return [] if pointer.null?
+
+      pointer.read_array_of_double(@c_struct[:band_count])
+    end
+
+    # @param values [Array<Float>]
     def destination_no_data_imaginary=(values)
       values_ptr = FFI::MemoryPointer.new(:double, values.length)
       values_ptr.write_array_of_double(values)
@@ -120,6 +160,30 @@ module GDAL
       @c_struct[:destination_no_data_imaginary] = values_ptr
     end
 
+    # @return [Array<Float>]
+    def destination_no_data_imaginary
+      pointer = @c_struct[:destination_no_data_imaginary]
+      return [] if pointer.null?
+
+      pointer.read_array_of_double(@c_struct[:band_count])
+    end
+
+    # Set a Proc per source band; number of procs in +band_procs+ should equal
+    # {band_count}.
+    #
+    # @param band_procs [Array<Proc>]
+    def source_per_band_validity_mask_function=(band_procs)
+      mask_func = FFI::GDAL::Warper::MaskFunc
+
+      funcs = band_procs.map do |band_proc|
+        FFI::Function.new(mask_func.result_type, mask_func.param_types, band_proc, blocking: true)
+      end
+
+      pointer = FFI::MemoryPointer.new(:pointer, band_procs.length)
+      pointer.write_array_of_pointer(funcs)
+      @c_struct[:source_per_band_validity_mask_function] = pointer
+    end
+
     # Used for getting attributes of the internal WarpOptions struct.
     #
     # @param meth [Symbol] The FFI::GDAL::WarpOptions key.

data/lib/gdal.rb

@@ -30,6 +30,7 @@ module GDAL
   autoload :Driver,               gdal_require('gdal/driver')
   autoload :GeoTransform,         gdal_require('gdal/geo_transform')
   autoload :Logger,               gdal_require('gdal/logger')
+  autoload :MajorObject,          gdal_require('gdal/major_object')
   autoload :Options,              gdal_require('gdal/options')
   autoload :RasterAttributeTable, gdal_require('gdal/raster_attribute_table')
   autoload :RasterBand,           gdal_require('gdal/raster_band')

data/lib/ogr/data_source_extensions.rb

@@ -4,24 +4,5 @@ module OGR
     def layers
       @layers = Array.new(layer_count) { |i| layer(i) }
     end
-
-    # @return [Hash]
-    def as_json(options = nil)
-      {
-        data_source: {
-          driver: driver.name,
-          layer_count: layer_count,
-          layers: layers.map(&:as_json),
-          name: name,
-          style_table: style_table ? style_table.as_json(options) : nil
-        },
-        metadata: all_metadata
-      }
-    end
-
-    # @return [String]
-    def to_json(options = nil)
-      as_json(options).to_json
-    end
   end
 end

data/lib/ogr/envelope_extensions.rb

@@ -101,28 +101,6 @@ module OGR
       polygon
     end
 
-    # @return [Hash]
-    def as_json(_options = nil)
-      json = {
-        x_min: x_min,
-        x_max: x_max,
-        y_min: y_min,
-        y_max: y_max
-      }
-
-      if @c_struct.is_a? FFI::OGR::Envelope3D
-        json[:z_min] = z_min
-        json[:z_max] = z_max
-      end
-
-      json
-    end
-
-    # @return [String]
-    def to_json(options = nil)
-      as_json(options).to_json
-    end
-
     def to_a
       [x_min, y_min, x_max, y_max]
     end

data/lib/ogr/feature_definition_extensions.rb

@@ -33,23 +33,5 @@ module OGR
 
       geometry_field_definition(g)
     end
-
-    # @return [Hash]
-    def as_json(_options = nil)
-      {
-        field_count: field_count,
-        field_definitions: field_definitions.map(&:as_json),
-        geometry_field_count: geometry_field_count,
-        geometry_type: geometry_type,
-        is_geometry_ignored: geometry_ignored?,
-        is_style_ignored: style_ignored?,
-        name: name
-      }
-    end
-
-    # @return [String]
-    def to_json(options = nil)
-      as_json(options).to_json
-    end
   end
 end

data/lib/ogr/feature_extensions.rb

@@ -81,32 +81,5 @@ module OGR
     def geometry_fields
       each_geometry_field.to_a
     end
-
-    # @return [Hash]
-    def as_json(options = nil)
-      fields_with_nested_json = fields.map.with_index do |f, i|
-        {
-          field_definition: field_definition(i).as_json(options),
-          value: f
-        }
-      end
-
-      {
-        definition: definition.as_json(options),
-        fid: fid,
-        field_count: field_count,
-        fields: fields_with_nested_json,
-        geometry: geometry ? geometry.as_json(options) : nil,
-        geometry_field_count: geometry_field_count,
-        geometry_field_definition: each_geometry_field_definition.map { |gfd| gfd.as_json(options) },
-        style_string: style_string,
-        style_table: style_table ? style_table.as_json(options) : nil
-      }
-    end
-
-    # @return [String]
-    def to_json(options = nil)
-      as_json(options).to_json
-    end
   end
 end

data/lib/ogr/field_definition.rb

@@ -1,10 +1,7 @@
 require_relative '../ogr'
-require_relative 'field_definition_extensions'
 
 module OGR
   class FieldDefinition
-    include FieldDefinitionExtensions
-
     # @return [FFI::Pointer] C pointer to the C FieldDefn.
     attr_reader :c_pointer
 

data/lib/ogr/geometry.rb

@@ -240,7 +240,6 @@ module OGR
     end
 
     # @return [Fixnum]
-    # @todo This regularly crashes, so disabling it.
     def centroid
       point = is_3d? ? OGR::Point25D.new : OGR::Point.new
 

data/lib/ogr/geometry_field_definition.rb

@@ -1,9 +1,5 @@
-require_relative 'geometry_field_definition_extensions'
-
 module OGR
   class GeometryFieldDefinition
-    include GeometryFieldDefinitionExtensions
-
     # @return [FFI::Pointer]
     attr_reader :c_pointer
 

data/lib/ogr/geometry_mixins/extensions.rb

@@ -53,35 +53,6 @@ module OGR
         !valid?
       end
 
-      # @return [Hash]
-      def as_json(options = nil)
-        json = {
-          coordinate_dimension: coordinate_dimension,
-          geometry_count: geometry_count,
-          dimension: dimension,
-          is_empty: empty?,
-          is_ring: ring?,
-          is_simple: simple?,
-          is_valid: valid?,
-          name: name,
-          point_count: point_count,
-          spatial_reference: spatial_reference.nil? ? nil : spatial_reference.as_json(options),
-          type: type_to_name,
-          wkb_size: wkb_size
-        }
-
-        json[:area] = area if respond_to? :area
-        json[:length] = length if respond_to? :length
-        json[:points] = points if respond_to? :points
-
-        json
-      end
-
-      # @return [String]
-      def to_json(options = nil)
-        as_json(options).to_json
-      end
-
       def collection?
         false
       end

data/lib/ogr/geometry_types/curve.rb

@@ -102,7 +102,7 @@ module OGR
         y_buffer = FFI::MemoryPointer.new(:buffer_out, buffer_size)
         z_buffer = FFI::MemoryPointer.new(:buffer_out, buffer_size) if coordinate_dimension == 3
 
-        FFI::OGR::API.OGR_G_GetPoints(@c_pointer,
+        num_points = FFI::OGR::API.OGR_G_GetPoints(@c_pointer,
           x_buffer, x_stride, y_buffer,
           y_stride, z_buffer, z_stride)
 

data/lib/ogr/layer.rb

@@ -20,7 +20,9 @@ module OGR
     include LayerMixins::OGRQueryFilterMethods
     include LayerMixins::OGRSQLMethods
 
-    class_eval FFI::OGR::Core::OGR_ALTER.to_ruby
+    FFI::OGR::Core::OGR_ALTER.constants.each do |_name, obj|
+      const_set(obj.ruby_name, obj.value.to_i(16))
+    end
 
     # @return [FFI::Pointer] C pointer to the C Layer.
     attr_reader :c_pointer

data/lib/ogr/layer_mixins/extensions.rb

@@ -66,7 +66,7 @@ module OGR
       #
       # @return [Array<OGR::Feature>]
       def features
-        each_feature.map { |f| f.clone }
+        each_feature.map(&:clone)
       end
 
       # @return [OGR::Polygon] A polygon derived from a LinearRing that connects
@@ -229,30 +229,6 @@ module OGR
         found_z_geom
       end
 
-      # @return [Hash]
-      def as_json(options = nil)
-        {
-          layer: {
-            extent: extent.as_json(options),
-            feature_count: feature_count,
-            feature_definition: feature_definition.as_json(options),
-            features: each_feature.map { |f| f.as_json(options) },
-            fid_column: fid_column,
-            geometry_column: geometry_column,
-            geometry_type: geometry_type,
-            name: name,
-            spatial_reference: spatial_reference ? spatial_reference.as_json(options) : nil,
-            style_table: style_table ? style_table.as_json(options) : nil
-          },
-          metadata: nil # all_metadata
-        }
-      end
-
-      # @return [String]
-      def to_json(options = nil)
-        as_json(options).to_json
-      end
-
       private
 
       # @param geometry_ptr [FFI::Pointer]

data/lib/ogr/spatial_reference.rb

@@ -22,9 +22,17 @@ module OGR
     include SpatialReferenceMixins::ParameterGetterSetters
     include SpatialReferenceMixins::TypeChecks
 
-    class_eval FFI::OGR::SRSAPI::SRS_UL.to_ruby
+    # class_eval FFI::OGR::SRSAPI::SRS_UL.to_ruby
+    FFI::OGR::SRSAPI::SRS_UL.constants.each do |_name, obj|
+      const_set(obj.ruby_name, obj.value)
+    end
+
     METER_TO_METER = 1.0
-    class_eval FFI::OGR::SRSAPI::SRS_UA.to_ruby
+
+    FFI::OGR::SRSAPI::SRS_UA.constants.each do |_name, obj|
+      const_set(obj.ruby_name, obj.value)
+    end
+
     RADIAN_TO_RADIAN = 1.0
 
     # @return [Array<String>]

data/lib/ogr/spatial_reference_extensions.rb

@@ -28,31 +28,5 @@ module OGR
     rescue NameError
       raise NameError, "Param must be a known linear unit type: #{unit_label}"
     end
-
-    # @return [Hash]
-    def as_json(_options = nil)
-      {
-        angular_units: angular_units,
-        epsg_treats_as_lat_long: epsg_treats_as_lat_long?,
-        epsg_treats_as_northing_easting: epsg_treats_as_northing_easting?,
-        is_compound: compound?,
-        is_geocentric: geocentric?,
-        is_geographic: geographic?,
-        is_local: local?,
-        is_projected: projected?,
-        is_vertical: vertical?,
-        linear_units: linear_units,
-        prime_meridian: prime_meridian,
-        semi_major: semi_major,
-        semi_minor: semi_minor,
-        spheroid_inverse_flattening: spheroid_inverse_flattening,
-        utm_zone: utm_zone
-      }
-    end
-
-    # @return [String]
-    def to_json(options = nil)
-      as_json(options).to_json
-    end
   end
 end

data/lib/ogr/style_table_extensions.rb

@@ -20,15 +20,5 @@ module OGR
 
       styles
     end
-
-    # @return [Hash]
-    def as_json(_options = nil)
-      styles
-    end
-
-    # @return [String]
-    def to_json(options = nil)
-      as_json(options).to_json
-    end
   end
 end

data/spec/integration/gdal/raster_band_info_spec.rb

@@ -8,6 +8,13 @@ RSpec.describe 'Raster Band Info', type: :integration do
     File.expand_path(path, __dir__)
   end
 
+  let(:nodata_tiff) do
+    path = '../../../spec/support/images/123.tiff'
+    File.expand_path(path, __dir__)
+  end
+
+  let(:nodata_dataset) { GDAL::Dataset.open(nodata_tiff, 'r') }
+
   let(:tmp_tiff) { make_temp_test_file(original_tiff) }
   let(:dataset) { GDAL::Dataset.open(tmp_tiff, 'w') }
   after { dataset.close }
@@ -89,12 +96,27 @@ RSpec.describe 'Raster Band Info', type: :integration do
     end
   end
 
-  describe '#no_data_value' do
-    it 'is a Hash with :value and :is_associated keys' do
-      expect(subject.no_data_value).to be_an Hash
+  context 'no data not set' do
+    describe '#no_data_value' do
+      it 'is a Hash with :value and :is_associated keys' do
+        expect(subject.no_data_value).to be_an Hash
 
-      expect(subject.no_data_value[:value]).to be_a Float
-      expect(subject.no_data_value[:is_associated]).to_not be_nil
+        expect(subject.no_data_value[:value]).to be_nil
+        expect(subject.no_data_value[:is_associated]).to_not be_nil
+      end
+    end
+  end
+
+  context 'no data is set' do
+    subject { nodata_dataset.raster_band(1) }
+
+    describe '#no_data_value' do
+      it 'is a Hash with :value and :is_associated keys' do
+        expect(subject.no_data_value).to be_an Hash
+
+        expect(subject.no_data_value[:value]).to be_a Float
+        expect(subject.no_data_value[:is_associated]).to_not be_nil
+      end
     end
   end
 

data/spec/integration/ogr/layer_spec.rb

@@ -90,10 +90,4 @@ RSpec.describe 'OGR::Layer' do
       expect(geometry).to be_a OGR::Polygon
     end
   end
-
-  describe '#as_json' do
-    specify do
-      expect { subject.as_json }.to_not raise_exception
-    end
-  end
 end

data/spec/unit/ffi/gdal_spec.rb

@@ -9,6 +9,7 @@ RSpec.describe FFI::GDAL do
       end
 
       it 'returns GDAL_LIBRARY_PATH + libgdal file name' do
+        expect(Dir).to receive(:[]).with(%r{/pants/stuff\.+}).and_return '/pants/stuff.dylib'
         expect(described_class.find_lib('stuff')).to match %r{\A/pants/stuff\.+}
       end
     end