ffi-gdal 0.0.4 → 1.0.0.beta1

data/lib/ogr/data_source_extensions.rb

@@ -0,0 +1,32 @@
+module OGR
+  module DataSourceExtensions
+
+    # @return [Array<OGR::Layer>]
+    def layers
+      l = 0.upto(layer_count - 1).map do |i|
+        layer(i)
+      end
+
+      @layers = l
+    end
+
+    # @return [Hash]
+    def as_json
+      {
+        data_source: {
+          driver: driver.name,
+          layer_count: layer_count,
+          layers: layers.map(&:as_json),
+          name: name,
+          style_table: style_table ? style_table.as_json : nil
+        },
+        metadata: all_metadata
+      }
+    end
+
+    # @return [String]
+    def to_json
+      as_json.to_json
+    end
+  end
+end

data/lib/ogr/driver.rb

@@ -0,0 +1,119 @@
+module OGR
+  class Driver
+    include GDAL::MajorObject
+    include GDAL::Logger
+
+    # @return [Fixnum]
+    def self.count
+      FFI::GDAL.OGRGetDriverCount
+    end
+
+    # @param name [String] Short name of the registered OGRDriver.
+    # @return [OGR::Driver]
+    def self.by_name(name)
+      driver_ptr = FFI::GDAL.OGRGetDriverByName(name)
+      return nil if driver_ptr.null?
+
+      new(driver_ptr)
+    end
+
+    # @param index [Fixnum] Index of the registered driver.  Must be less than
+    #   OGR::Driver.count.
+    # @return [OGR::Driver]
+    def self.at_index(index)
+      if index > count
+        raise "index must be between 0 and #{count - 1}."
+      end
+
+      driver_ptr = FFI::GDAL.OGRGetDriver(index)
+      return nil if driver_ptr.null?
+
+      new(driver_ptr)
+    end
+
+    # @return [Array<String>]
+    def self.names
+      return @names if @names
+
+      names = 0.upto(count - 1).map do |i|
+        at_index(i).name
+      end
+
+      @names = names.compact.sort
+    end
+
+    # @param driver [OGR::Driver, FFI::Pointer]
+    def initialize(driver)
+      @driver_pointer = GDAL._pointer(OGR::Driver, driver)
+    end
+
+    def c_pointer
+      @driver_pointer
+    end
+
+    # @return [String]
+    def name
+      FFI::GDAL.OGR_Dr_GetName(@driver_pointer)
+    end
+
+    # @param file_name [String]
+    # @param access_flag [String] 'r' or 'w'.
+    # @return [OGR::DataSource, nil]
+    def open(file_name, access_flag = 'r')
+      update = OGR._boolean_access_flag(access_flag)
+
+      data_source_ptr = FFI::GDAL.OGR_Dr_Open(@driver_pointer, file_name, update)
+      return nil if data_source_ptr.null?
+
+      OGR::DataSource.new(data_source_ptr)
+    end
+
+    # Creates a new data source at path +file_name+.  Yields the newly created
+    # data source to a block, if given.  NOTE: in order to write out all
+    # in-memory data, you need to call #close on the created DataSource.
+    #
+    # @param file_name [String]
+    # @param options [Hash]
+    # @return [OGR::DataSource, nil]
+    def create_data_source(file_name, **options)
+      options_ptr = GDAL::Options.pointer(options)
+
+      data_source_ptr = FFI::GDAL.OGR_Dr_CreateDataSource(@driver_pointer,
+        file_name, options_ptr)
+      return nil if data_source_ptr.null?
+
+      ds = OGR::DataSource.new(data_source_ptr)
+
+      yield ds if block_given?
+
+      ds
+    rescue GDAL::InvalidBandNumber
+      ds.close if ds
+      delete_data_source(file_name)
+      raise
+    end
+
+    # @param file_name [String]
+    # @return +true+ if successful, otherwise raises an OGR exception.
+    def delete_data_source(file_name)
+      ogr_err = FFI::GDAL.OGR_Dr_DeleteDataSource(@driver_pointer, file_name)
+
+      ogr_err.to_ruby
+    end
+
+    # @param source_data_source [OGR::DataSource, FFI::Pointer]
+    # @param new_file_name [String]
+    # @param options [Hash]
+    # @return [OGR::DataSource, nil]
+    def copy_data_source(source_data_source, new_file_name, **options)
+      source_ptr = GDAL._pointer(OGR::DataSource, source_data_source)
+      options_ptr = GDAL::Options.pointer(options)
+
+      data_source_ptr = FFI::GDAL.OGR_Dr_CopyDataSource(@driver_pointer,
+        source_ptr, new_file_name, options_ptr)
+      return nil if data_source_ptr.null?
+
+      OGR::DataSource.new(data_source_ptr)
+    end
+  end
+end

data/lib/ogr/envelope.rb

@@ -0,0 +1,80 @@
+require_relative '../ffi/ogr'
+require_relative 'envelope_extensions'
+
+module OGR
+  class Envelope
+    include EnvelopeExtensions
+
+    def initialize(ogr_envelope_struct)
+      @ogr_envelope_struct = ogr_envelope_struct
+    end
+
+    # @return [Float]
+    def x_min
+      @ogr_envelope_struct[:min_x]
+    end
+
+    # @param new_x_min [Float]
+    def x_min=(new_x_min)
+      @ogr_envelope_struct[:min_x] = new_x_min
+    end
+
+    # @return [Float]
+    def x_max
+      @ogr_envelope_struct[:max_x]
+    end
+
+    # @param new_x_max [Float]
+    def x_max=(new_x_max)
+      @ogr_envelope_struct[:max_x] = new_x_max
+    end
+
+    # @return [Float]
+    def y_min
+      @ogr_envelope_struct[:min_y]
+    end
+
+    # @param new_y_min [Float]
+    def y_min=(new_y_min)
+      @ogr_envelope_struct[:min_y] = new_y_min
+    end
+
+    # @return [Float]
+    def y_max
+      @ogr_envelope_struct[:max_y]
+    end
+
+    # @param new_y_max [Float]
+    def y_max=(new_y_max)
+      @ogr_envelope_struct[:max_y] = new_y_max
+    end
+
+    # @return [Float, nil]
+    def z_min
+      return nil unless @ogr_envelope_struct.is_a? FFI::GDAL::OGREnvelope3D
+
+      @ogr_envelope_struct[:min_z]
+    end
+
+    # @param new_z_min [Float]
+    def z_min=(new_z_min)
+      return nil unless @ogr_envelope_struct.is_a? FFI::GDAL::OGREnvelope3D
+
+      @ogr_envelope_struct[:min_z] = new_z_min
+    end
+
+    # @return [Float, nil]
+    def z_max
+      return nil unless @ogr_envelope_struct.is_a? FFI::GDAL::OGREnvelope3D
+
+      @ogr_envelope_struct[:max_z]
+    end
+
+    # @param new_z_max [Float]
+    def z_max=(new_z_max)
+      return nil unless @ogr_envelope_struct.is_a? FFI::GDAL::OGREnvelope3D
+
+      @ogr_envelope_struct[:max_z] = new_z_max
+    end
+  end
+end

data/lib/ogr/envelope_extensions.rb

@@ -0,0 +1,92 @@
+require 'json'
+
+module OGR
+  module EnvelopeExtensions
+
+    # Adapted from "Advanced Geospatial Python Modeling".  Calculates the
+    # pixel locations of these geospatial coordinates.
+    #
+    # @param geo_transform [GDAL::GeoTransform]
+    # @param value_type [Symbol] Data type to return: :float or :integer.
+    # @return [Hash<x_origin, y_origin, x_max, y_max>]
+    def world_to_pixel(geo_transform, value_type=:integer)
+      min_values = geo_transform.world_to_pixel(x_min, y_max)
+      max_values = geo_transform.world_to_pixel(x_max, y_min)
+      pixel_count = max_values[:x] - min_values[:x]
+      line_count = max_values[:y] - min_values[:y]
+      pixel_width = (x_max - x_min) / pixel_count
+      pixel_height = (y_max - y_min) / pixel_count
+
+      case value_type
+      when :float
+        {
+          x_origin: min_values[:x].to_f.abs,
+          y_origin: min_values[:y].to_f.abs,
+          x_max: max_values[:x].to_f.abs,
+          y_max: max_values[:y].to_f.abs,
+          pixel_count: pixel_count.to_i.abs,
+          line_count: line_count.to_i.abs,
+          pixel_width: pixel_width.to_f,
+          pixel_height: pixel_height.to_f
+        }
+      when :integer
+        {
+          x_origin: min_values[:x].to_i.abs,
+          y_origin: min_values[:y].to_i.abs,
+          x_max: max_values[:x].to_i.abs,
+          y_max: max_values[:y].to_i.abs,
+          pixel_count: pixel_count.to_i.abs,
+          line_count: line_count.to_i.abs,
+          pixel_width: pixel_width.to_f,
+          pixel_height: pixel_height.to_f
+        }
+      else
+        {
+          x_origin: min_values[:x].abs,
+          y_origin: min_values[:y].abs,
+          x_max: max_values[:x].abs,
+          y_max: max_values[:y].abs,
+          pixel_count: pixel_count.to_i.abs,
+          line_count: line_count.to_i.abs,
+          pixel_width: pixel_width.to_f,
+          pixel_height: pixel_height.to_f
+        }
+      end
+    end
+
+    # Compares min/max X and min/max Y to the other envelope.  The envelopes are
+    # considered equal if those values are the same.
+    #
+    # @param other_envelope [OGR::Envelope]
+    # @return [Boolean]
+    def ==(other_envelope)
+      x_min == other_envelope.x_min && y_min == other_envelope.y_min &&
+        x_max == other_envelope.x_max && y_max == other_envelope.y_max
+    end
+
+    # @return [Hash]
+    def as_json
+      json = {
+        x_min: x_min,
+        x_max: x_max,
+        y_min: y_min,
+        y_max: y_max
+      }
+
+      if @ogr_envelope_struct.is_a? FFI::GDAL::OGREnvelope3D
+        json.merge!({ min_z: min_z, max_z: max_z })
+      end
+
+      json
+    end
+
+    # @return [String]
+    def to_json
+      as_json.to_json
+    end
+
+    def to_a
+      [x_min, y_min, x_max, y_max]
+    end
+  end
+end

data/lib/ogr/exceptions.rb

@@ -0,0 +1,35 @@
+module OGR
+  class OpenFailure < RuntimeError
+    def initialize(file, msg=nil)
+      message = msg || "Unable to open file '#{file}'. Perhaps an unsupported file format?"
+      super(message)
+    end
+  end
+
+  class InvalidLayer < RuntimeError
+  end
+
+  class NotEnoughData < RuntimeError
+  end
+
+  class NotEnoughMemory < RuntimeError
+  end
+
+  class UnsupportedGeometryType < RuntimeError
+  end
+
+  class UnsupportedOperation < RuntimeError
+  end
+
+  class CorruptData < RuntimeError
+  end
+
+  class Failure < RuntimeError
+  end
+
+  class UnsupportedSRS < RuntimeError
+  end
+
+  class InvalidHandle < RuntimeError
+  end
+end

data/lib/ogr/feature.rb

@@ -0,0 +1,212 @@
+require_relative '../ffi/ogr'
+require_relative 'feature_extensions'
+require_relative 'feature_definition'
+require_relative 'field'
+
+module OGR
+  class Feature
+    include FeatureExtensions
+
+    # @param feature_definition [OGR::FeatureDefinition,FFI::Pointer]
+    # @return [OGR::Feature]
+    def self.create(feature_definition)
+      feature_def_ptr = GDAL._pointer(OGR::FeatureDefinition, feature_definition)
+      feature_ptr = FFI::GDAL::OGR_F_Create(feature_def_ptr)
+      return nil if feature_ptr.null?
+
+      new(feature_ptr)
+    end
+
+    # @param feature [OGR::Feature, FFI::Pointer]
+    def initialize(feature)
+      @feature_pointer = GDAL._pointer(OGR::Feature, feature)
+
+      close_me = -> { FFI::GDAL.OGR_F_Destroy(@feature_pointer) }
+      ObjectSpace.define_finalizer self, close_me
+    end
+
+    def c_pointer
+      @feature_pointer
+    end
+
+    # @return [Fixnum]
+    def field_count
+      FFI::GDAL.OGR_F_GetFieldCount(@feature_pointer)
+    end
+
+    def add_field(index, value)
+      case value.class.name
+      when 'String'
+        FFI::GDAL.OGR_F_SetFieldString(@feature_pointer, index, value)
+      when 'Fixnum'
+        FFI::GDAL.OGR_F_SetFieldInteger(@feature_pointer, index, value)
+      when 'Float'
+        FFI::GDAL.OGR_F_SetFieldDouble(@feature_pointer, index, value)
+      when ('Date' or 'Time' or 'DateTime')
+        time = value.to_time
+        zone = if time.zone =~ /GMT/
+          100
+        elsif time.zone
+          1
+        else
+          0
+        end
+
+        FFI::GDAL.OGR_F_SetFieldDateTime(@feature_pointer, index,
+          time.year,
+          time.month,
+          time.day,
+          time.hour,
+          time.min,
+          time.sec,
+          zone)
+      else
+        raise "Unknown field type: #{value.class.name}"
+      end
+    end
+
+    # @param index [Fixnum]
+    # @return [OGR::Field]
+    def field(index)
+      field_pointer = FFI::GDAL.OGR_F_GetFieldDefnRef(@feature_pointer, index)
+      return nil if field_pointer.null?
+
+      OGR::Field.new(field_pointer)
+    end
+
+    # @param name [String]
+    # @return [Fixnum]
+    def field_index(name)
+      FFI::GDAL.OGR_F_GetFieldIndex(@feature_pointer, name)
+    end
+
+    # @param index [Fixnum]
+    # @return [Boolean]
+    def field_set?(index)
+      FFI::GDAL.OGR_F_IsFieldSet(@feature_pointer, index)
+    end
+
+    # @param index [Fixnum]
+    def unset_field(index)
+      FFI::GDAL.OGR_F_UnsetField(@feature_pointer, index)
+    end
+
+    # @return [OGR::FeatureDefinition,nil]
+    def definition
+      return @definition if @definition
+
+      feature_defn_ptr = FFI::GDAL.OGR_F_GetDefnRef(@feature_pointer)
+      return nil if feature_defn_ptr.null?
+
+      @definition = OGR::FeatureDefinition.new(feature_defn_ptr)
+    end
+
+    # @return [OGR::Geometry]
+    def geometry
+      return @geometry if @geometry
+
+      geometry_ptr = FFI::GDAL.OGR_F_GetGeometryRef(@feature_pointer)
+      return nil if geometry_ptr.null?
+
+      @geometry = OGR::Geometry._to_geometry_type(geometry_ptr)
+    end
+
+    # @param new_geometry [OGR::Geometry]
+    # @return +true+ if successful, otherwise raises an OGR exception.
+    def geometry=(new_geometry)
+      ogr_err = FFI::GDAL.OGR_F_SetGeometryDirectly(@feature_pointer, new_geometry.c_pointer)
+      @geometry = new_geometry
+
+      ogr_err.to_ruby
+    end
+
+    # @return [Fixnum]
+    def fid
+      FFI::GDAL.OGR_F_GetFID(@feature_pointer)
+    end
+
+    # @param new_fid [Fixnum]
+    # @return +true+ if successful, otherwise raises an OGR exception.
+    def fid=(new_fid)
+      ogr_err = FFI::GDAL.OGR_F_SetFID(@feature_pointer, new_fid)
+
+      ogr_err.to_ruby
+    end
+
+    # @return [Fixnum]
+    def geometry_field_count
+      FFI::GDAL.OGR_F_GetGeomFieldCount(@feature_pointer)
+    end
+
+    # @return [Boolean]
+    def equal?(other_feature)
+      FFI::GDAL.OGR_F_Equal(@feature_pointer, feature_pointer_from(other_feature))
+    end
+    alias_method :equals?, :equal?
+
+    # @param index [Fixnum]
+    # @return [Fixnum]
+    def field_as_integer(index)
+      FFI::GDAL.OGR_F_GetFieldAsInteger(@feature_pointer, index)
+    end
+
+    # @param index [Fixnum]
+    # @return [Array<Fixnum>]
+    def field_as_integer_list(index)
+      count_ptr = FFI::MemoryPointer.new(:int)
+      list_ints = FFI::GDAL.OGR_F_GetFieldAsIntegerList(@feature_pointer, index, count_ptr)
+
+      list_ints.read_array_of_int
+    end
+
+    # @param index [Fixnum]
+    # @return [Float]
+    def field_as_double(index)
+      FFI::GDAL.OGR_F_GetFieldAsDouble(@feature_pointer, index)
+    end
+
+    # @param index [Fixnum]
+    # @return [Array<Float>]
+    def field_as_double_list(index)
+      count_ptr = FFI::MemoryPointer.new(:int)
+      list_ints = FFI::GDAL.OGR_F_GetFieldAsDoubleList(@feature_pointer, index, count_ptr)
+
+      list_ints.read_array_of_double
+    end
+
+    # @param index [Fixnum]
+    # @return [String]
+    def field_as_string(index)
+      FFI::GDAL.OGR_F_GetFieldAsString(@feature_pointer, index)
+    end
+
+    # @param index [Fixnum]
+    # @return [Array<String>]
+    def field_as_string_list(index)
+      count_ptr = FFI::MemoryPointer.new(:int)
+      list_ints = FFI::GDAL.OGR_F_GetFieldAsStringList(@feature_pointer, index, count_ptr)
+
+      list_ints.read_array_of_string
+    end
+
+    # @return [String]
+    def style_string
+      FFI::GDAL.OGR_F_GetStyleString(@feature_pointer)
+    end
+
+    # @param new_style [String]
+    def style_string=(new_style)
+      FFI::GDAL.OGR_F_SetStyleString(@feature_pointer, new_style)
+    end
+
+    private
+
+    def feature_pointer_from(feature)
+      if feature.is_a? OGR::Feature
+        feature.c_pointer
+      elsif feature.kind_of? FFI::Pointer
+        feature
+      end
+    end
+  end
+end