ffi-gdal 1.0.0.beta3 → 1.0.0.beta4

data/lib/ogr/envelope.rb

@@ -5,76 +5,87 @@ module OGR
   class Envelope
     include EnvelopeExtensions
 
-    def initialize(ogr_envelope_struct)
-      @ogr_envelope_struct = ogr_envelope_struct
+    # @return [FFI::OGR::Envelope, FFI::OGR::Envelope3D] The C struct that this
+    #   object wraps.
+    attr_reader :c_struct
+
+    # @param envelope_struct [FFI::OGR::Envelope]
+    def initialize(envelope_struct = nil, three_d: false)
+      @c_struct = envelope_struct
+      @c_struct ||= three_d ? FFI::OGR::Envelope3D.new : FFI::OGR::Envelope.new
+    end
+
+    # @return [FFI::Pointer] Pointer to the C struct.
+    def c_pointer
+      @c_struct.to_ptr
     end
 
     # @return [Float]
     def x_min
-      @ogr_envelope_struct[:min_x]
+      @c_struct[:min_x]
     end
 
     # @param new_x_min [Float]
     def x_min=(new_x_min)
-      @ogr_envelope_struct[:min_x] = new_x_min
+      @c_struct[:min_x] = new_x_min
     end
 
     # @return [Float]
     def x_max
-      @ogr_envelope_struct[:max_x]
+      @c_struct[:max_x]
     end
 
     # @param new_x_max [Float]
     def x_max=(new_x_max)
-      @ogr_envelope_struct[:max_x] = new_x_max
+      @c_struct[:max_x] = new_x_max
     end
 
     # @return [Float]
     def y_min
-      @ogr_envelope_struct[:min_y]
+      @c_struct[:min_y]
     end
 
     # @param new_y_min [Float]
     def y_min=(new_y_min)
-      @ogr_envelope_struct[:min_y] = new_y_min
+      @c_struct[:min_y] = new_y_min
     end
 
     # @return [Float]
     def y_max
-      @ogr_envelope_struct[:max_y]
+      @c_struct[:max_y]
     end
 
     # @param new_y_max [Float]
     def y_max=(new_y_max)
-      @ogr_envelope_struct[:max_y] = new_y_max
+      @c_struct[:max_y] = new_y_max
     end
 
     # @return [Float, nil]
     def z_min
-      return nil unless @ogr_envelope_struct.is_a? FFI::GDAL::OGREnvelope3D
+      return nil unless @c_struct.is_a? FFI::OGR::Envelope3D
 
-      @ogr_envelope_struct[:min_z]
+      @c_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
+      return nil unless @c_struct.is_a? FFI::OGR::Envelope3D
 
-      @ogr_envelope_struct[:min_z] = new_z_min
+      @c_struct[:min_z] = new_z_min
     end
 
     # @return [Float, nil]
     def z_max
-      return nil unless @ogr_envelope_struct.is_a? FFI::GDAL::OGREnvelope3D
+      return nil unless @c_struct.is_a? FFI::OGR::Envelope3D
 
-      @ogr_envelope_struct[:max_z]
+      @c_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
+      return nil unless @c_struct.is_a? FFI::OGR::Envelope3D
 
-      @ogr_envelope_struct[:max_z] = new_z_max
+      @c_struct[:max_z] = new_z_max
     end
   end
 end

data/lib/ogr/envelope_extensions.rb

@@ -2,56 +2,39 @@ require 'json'
 
 module OGR
   module EnvelopeExtensions
+    # @return [Float] x_max - x_min
+    def x_size
+      x_max - x_min
+    end
+
+    # @return [Float] y_max - y_min
+    def y_size
+      y_max - y_min
+    end
+
+    # @return [Float] z_max - z_min
+    def z_size
+      return unless z_max && z_min
+
+      z_max - z_min
+    end
 
     # Adapted from "Advanced Geospatial Python Modeling".  Calculates the
-    # pixel locations of these geospatial coordinates.
+    # pixel locations of these geospatial coordinates according to the given
+    # GeoTransform.
     #
     # @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)
+    # @return [Hash{x_min => Fixnum, y_min => Fixnum, x_max => Fixnum, y_max => Fixnum}]
+    def world_to_pixels(geo_transform)
       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
+
+      {
+        x_min: min_values[:pixel].round.to_i,
+        y_min: min_values[:line].round.to_i,
+        x_max: max_values[:pixel].round.to_i,
+        y_max: max_values[:line].round.to_i
+      }
     end
 
     # Compares min/max X and min/max Y to the other envelope.  The envelopes are
@@ -64,8 +47,46 @@ module OGR
         x_max == other_envelope.x_max && y_max == other_envelope.y_max
     end
 
+    # Stolen from http://www.gdal.org/ogr__core_8h_source.html.
+    #
+    # @param other_envelope [OGR::Envelope] The Envelope to merge self with.
+    # @return [OGR::Envelope]
+    def merge(other_envelope)
+      new_envelope = OGR::Envelope.new
+      new_envelope.x_min = [x_min, other_envelope.x_min].min
+      new_envelope.x_max = [x_max, other_envelope.x_max].max
+      new_envelope.y_min = [y_min, other_envelope.y_min].min
+      new_envelope.y_max = [y_max, other_envelope.y_max].max
+
+      new_envelope
+    end
+
+    # Stolen from http://www.gdal.org/ogr__core_8h_source.html.
+    #
+    # @param other_envelope [OGR::Envelope] The Envelope to check intersection
+    #   with.
+    # @return [OGR::Envelope]
+    def intersects?(other_envelope)
+      x_min <= other_envelope.x_max &&
+        x_max >= other_envelope.x_min &&
+        y_min <= other_envelope.y_max &&
+        y_max >= other_envelope.y_min
+    end
+
+    # Stolen from http://www.gdal.org/ogr__core_8h_source.html.
+    #
+    # @param other_envelope [OGR::Envelope] The Envelope to check containment
+    #   with.
+    # @return [OGR::Envelope]
+    def contains?(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
+    def as_json(_options = nil)
       json = {
         x_min: x_min,
         x_max: x_max,
@@ -73,16 +94,16 @@ module OGR
         y_max: y_max
       }
 
-      if @ogr_envelope_struct.is_a? FFI::GDAL::OGREnvelope3D
-        json.merge!({ min_z: min_z, max_z: max_z })
+      if @c_struct.is_a? FFI::GDAL::OGREnvelope3D
+        json.merge!(z_min: z_min, z_max: z_max)
       end
 
       json
     end
 
     # @return [String]
-    def to_json
-      as_json.to_json
+    def to_json(options = nil)
+      as_json(options).to_json
     end
 
     def to_a

data/lib/ogr/error_handling.rb

@@ -0,0 +1,46 @@
+require_relative 'exceptions'
+
+module OGR
+  # OGR returns errors as Integers--not as part of the GDAL/CPLErr error
+  # handling callback interface.  This hacks together a facility for sort of
+  # doing that with OGR.
+  #
+  # Unlike the OGR API, ffi-gdal defines an Enum for the OGRERR types, which
+  # in turns causes OGR to return Symbols on errors (the #defines for those can
+  # be found here: http://www.gdal.org/ogr__core_8h.html).  This maps those
+  # Symbols to Ruby exceptions (or lack thereof).  The sad part of this
+  # solution is that any function that returns an OGRErr needs to assign that
+  # Symbol to a variable, then call #handle_result to get that
+  # Symbol-to-Exception mapping to take place.
+  module ErrorHandling
+    def handle_result(msg = nil)
+      error_class_map(self).call(msg)
+    end
+
+    private
+
+    # @param [Symbol] error_class
+    # @return [Proc]
+    def error_class_map(error_class)
+      {
+        OGRERR_NONE: ->(_) { true },
+        OGRERR_NOT_ENOUGH_DATA: ->(msg) { raise_exception(OGR::NotEnoughData, msg) },
+        OGRERR_NOT_ENOUGH_MEMORY: ->(msg) { raise_exception(::NoMemoryError, msg) },
+        OGRERR_UNSUPPORTED_GEOMETRY_TYPE: ->(msg) { raise_exception(OGR::UnsupportedGeometryType, msg) },
+        OGRERR_UNSUPPORTED_OPERATION: ->(msg) { raise_exception(OGR::UnsupportedOperation, msg) },
+        OGRERR_CORRUPT_DATA: ->(msg) { raise_exception(OGR::CorruptData, msg) },
+        OGRERR_FAILURE: ->(msg) { raise_exception(OGR::Failure, msg) },
+        OGRERR_UNSUPPORTED_SRS: ->(msg) { raise_exception(OGR::UnsupportedSRS, msg) },
+        OGRERR_INVALID_HANDLE: ->(msg) { raise_exception(OGR::InvalidHandle, msg) }
+      }.fetch(error_class) { fail "Unknown OGRERR type: #{self}" }
+    end
+
+    # Exists solely to strip off the top 4 lines of the backtrace so it doesn't
+    # look like the problem is coming from here.
+    def raise_exception(exception, message)
+      e = exception.new(message)
+      e.set_backtrace(caller(4))
+      fail(e)
+    end
+  end
+end

data/lib/ogr/exceptions.rb

@@ -1,35 +1,81 @@
 module OGR
-  class OpenFailure < RuntimeError
-    def initialize(file, msg=nil)
-      message = msg || "Unable to open file '#{file}'. Perhaps an unsupported file format?"
+  class CorruptData < RuntimeError
+  end
+
+  class CreateFailure < RuntimeError
+  end
+
+  class DriverNotFound < RuntimeError
+    def initialize(driver, msg = nil)
+      message =
+        if msg
+          msg
+        elsif driver.is_a? String
+          "Driver not found with name '#{driver}'."
+        elsif driver.is_a? Fixnum
+          "Driver at index #{driver} not found."
+        end
+
       super(message)
     end
   end
 
-  class InvalidLayer < RuntimeError
+  class Failure < StandardError
   end
 
-  class NotEnoughData < RuntimeError
+  class InvalidDataSource < StandardError
   end
 
-  class NotEnoughMemory < RuntimeError
+  class InvalidFeature < StandardError
   end
 
-  class UnsupportedGeometryType < RuntimeError
+  class InvalidFeatureDefinition < StandardError
   end
 
-  class UnsupportedOperation < RuntimeError
+  class InvalidFieldDefinition < StandardError
   end
 
-  class CorruptData < RuntimeError
+  class InvalidGeometry < StandardError
   end
 
-  class Failure < RuntimeError
+  class InvalidGeometryFieldDefinition < StandardError
   end
 
-  class UnsupportedSRS < RuntimeError
+  class InvalidHandle < RuntimeError
   end
 
-  class InvalidHandle < RuntimeError
+  class InvalidLayer < StandardError
+  end
+
+  class InvalidStyleTable < StandardError
+  end
+
+  class InvalidSpatialReference < StandardError
+  end
+
+  class NotEnoughData < RuntimeError
+  end
+
+  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 ReadOnlyObject < StandardError
+    def initialize(msg = nil)
+      message = msg || "The object you're accessing is read-only.  Probably because it's internally managed by OGR."
+      super(message)
+    end
+  end
+
+  class UnsupportedGeometryType < StandardError
+  end
+
+  class UnsupportedOperation < StandardError
+  end
+
+  class UnsupportedSRS < StandardError
   end
 end