ffi-gdal 1.0.0.beta5 → 1.0.0.beta6

data/lib/gdal/virtual_dataset.rb

@@ -1,7 +1,5 @@
-require_relative '../ffi/gdal/vrt'
-require_relative '../ffi/cpl/minixml'
+require_relative '../gdal'
 require_relative 'major_object'
-require_relative 'options'
 
 module GDAL
   class VirtualDataset
@@ -25,7 +23,7 @@ module GDAL
       FFI::CPL::MiniXML.CPLSerializeXMLTree(xml_node)
     end
 
-    # @param data_type [FFI::GDAL::DataType]
+    # @param data_type [FFI::GDAL::GDAL::DataType]
     # @param options [Hash]
     # @return [Boolean]
     def add_band(data_type, **options)

data/lib/gdal/warp_operation.rb

@@ -1,19 +1,21 @@
-require_relative '../ffi/gdal/warper'
+require_relative '../gdal'
 
 module GDAL
   class WarpOperation
     # @return [FFI::Pointer]
     attr_reader :c_pointer
 
-    # @param warp_options [FFI::GDAL::WarpOptions]
+    # @param warp_options [GDAL::WarpOptions]
     def initialize(warp_options)
-      @c_pointer = FFI::GDAL::Warper.GDALCreateWarpOperation(warp_options)
-
-      ObjectSpace.define_finalizer self, -> { destroy! }
+      @c_pointer = FFI::GDAL::Warper.GDALCreateWarpOperation(warp_options.c_struct)
+      raise GDAL::Error, 'Unable to create warp operation' if @c_pointer.null?
     end
 
     def destroy!
+      return unless @c_pointer
+
       FFI::GDAL::Warper.GDALDestroyWarpOperation(@c_pointer)
+      @c_pointer = nil
     end
 
     # @param x_offset [Fixnum] X offset of the destination image.
@@ -28,15 +30,16 @@ module GDAL
         y_size)
     end
 
-    # @param _x_offset [Fixnum] X offset of the destination image.
-    # @param _y_offset [Fixnum] Y offset of the destination image.
-    # @param _x_size [Fixnum] X size (width) of the destination image.
-    # @param _y_size [Fixnum] Y size (height) of the destination image.
-    # @todo Implement
-    def chunk_and_warp_multi(_x_offset, _y_offset, _x_size, _y_size)
-      fail NotImplementedError, '#chunk_and_warp_multi not yet implemented.'
-
-      FFI::GDAL::Warper.GDALChunkAndWarpMulti(@c_pointer)
+    # @param x_offset [Fixnum] X offset of the destination image.
+    # @param y_offset [Fixnum] Y offset of the destination image.
+    # @param x_size [Fixnum] X size (width) of the destination image.
+    # @param y_size [Fixnum] Y size (height) of the destination image.
+    def chunk_and_warp_multi(x_offset, y_offset, x_size, y_size)
+      FFI::GDAL::Warper.GDALChunkAndWarpMulti(@c_pointer,
+        x_offset,
+        y_offset,
+        x_size,
+        y_size)
     end
 
     # @param destination_x_offset [Fixnum] X offset of the destination image.

data/lib/gdal/warp_options.rb

@@ -0,0 +1,132 @@
+require_relative '../gdal'
+
+module GDAL
+  class WarpOptions
+    attr_reader :c_struct
+
+    def initialize(options = {})
+      @c_struct = FFI::GDAL::WarpOptions.new
+
+      options.keys do |k|
+        @c_struct[k] = options[k]
+      end
+    end
+
+    def c_pointer
+      @c_struct.to_ptr
+    end
+
+    # @param options [Hash]
+    def warp_operation_options=(options)
+      @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
+
+    # @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
+    end
+
+    # @param dataset [GDAL::Dataset]
+    def source_dataset=(dataset)
+      @c_struct[:source_dataset] = dataset.c_pointer
+    end
+
+    # @param dataset [GDAL::Dataset]
+    def 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.write_array_of_int(band_numbers)
+
+      @c_struct[:source_bands] = bands_ptr
+    end
+
+    # @param band_numbers [Array<Fixnum>]
+    def destination_bands=(band_numbers)
+      bands_ptr = FFI::MemoryPointer.new(:pointer, band_numbers.length)
+      bands_ptr.write_array_of_int(band_numbers)
+
+      @c_struct[:destination_bands] = bands_ptr
+    end
+
+    def transformer_arg=(transformation_object)
+      @c_struct[:transformer_arg] = transformation_object.c_pointer
+
+      @c_struct[:transformer] = transformation_object.function
+    end
+
+    def transformer=(transformer)
+      @c_struct[:transformer] = transformer
+    end
+
+    def progress_formatter=(output_proc)
+      @c_struct[:progress] = output_proc
+    end
+
+    def cutline_geometry=(geometry)
+      raise 'Not a geom' unless geometry.is_a?(OGR::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
+
+    def source_no_data_real=(values)
+      values_ptr = FFI::MemoryPointer.new(:double, values.length)
+      values_ptr.write_array_of_double(values)
+
+      @c_struct[:source_no_data_real] = values_ptr
+    end
+
+    def source_no_data_imaginary=(values)
+      values_ptr = FFI::MemoryPointer.new(:double, values.length)
+      values_ptr.write_array_of_double(values)
+
+      @c_struct[:source_no_data_imaginary] = values_ptr
+    end
+
+    def destination_no_data_real=(values)
+      values_ptr = FFI::MemoryPointer.new(:double, values.length)
+      values_ptr.write_array_of_double(values)
+
+      @c_struct[:destination_no_data_real] = values_ptr
+    end
+
+    def destination_no_data_imaginary=(values)
+      values_ptr = FFI::MemoryPointer.new(:double, values.length)
+      values_ptr.write_array_of_double(values)
+
+      @c_struct[:destination_no_data_imaginary] = values_ptr
+    end
+
+    # Used for getting attributes of the internal WarpOptions struct.
+    #
+    # @param meth [Symbol] The FFI::GDAL::WarpOptions key.
+    def method_missing(meth)
+      super unless FFI::GDAL::WarpOptions.members.include?(meth)
+
+      @c_struct[meth]
+    end
+  end
+end

data/lib/gdal.rb

@@ -1,4 +1,41 @@
-require_relative 'ffi/gdal'
+require_relative 'ffi-gdal'
+
+module GDAL
+  class << self
+    # Use when you want something quick and easy for when you need something
+    # quick for a +FFI::GDAL::GDALProgressFunc+. Outputs the duration and
+    # percentage completed.
+    #
+    # @return [Proc] A Proc that works for a +GDALProgressFunc+ callback.
+    def simple_progress_formatter
+      start = Time.now
+
+      lambda do |d, _, _|
+        print "Duration: #{(Time.now - start).to_f.round(2)}s\t| #{(d * 100).round(2)}%\r"
+        true
+      end
+    end
+
+    private
+
+    def gdal_require(path)
+      File.expand_path(path, __dir__)
+    end
+  end
+
+  # Autoload just the core GDAL object types.
+  autoload :ColorTable,           gdal_require('gdal/color_table')
+  autoload :Dataset,              gdal_require('gdal/dataset')
+  autoload :DataType,             gdal_require('gdal/data_type')
+  autoload :Driver,               gdal_require('gdal/driver')
+  autoload :GeoTransform,         gdal_require('gdal/geo_transform')
+  autoload :Logger,               gdal_require('gdal/logger')
+  autoload :Options,              gdal_require('gdal/options')
+  autoload :RasterAttributeTable, gdal_require('gdal/raster_attribute_table')
+  autoload :RasterBand,           gdal_require('gdal/raster_band')
+end
+
+require_relative 'gdal/exceptions'
 require_relative 'gdal/version_info'
 require_relative 'gdal/environment_methods'
 require_relative 'gdal/internal_helpers'
@@ -10,8 +47,10 @@ module GDAL
   include InternalHelpers
 
   # Register all drivers!
-  ::FFI::GDAL.GDALAllRegister
+  ::FFI::GDAL::GDAL.GDALAllRegister
 
+  # We define our own error handler so we can turn GDAL errors into Ruby
+  # exceptions.
   FFI_GDAL_ERROR_HANDLER = GDAL::CPLErrorHandler.handle_error
   ::FFI::CPL::Error.CPLSetErrorHandler(FFI_GDAL_ERROR_HANDLER)
 end

data/lib/ogr/coordinate_transformation.rb

@@ -1,5 +1,6 @@
 require 'narray'
-require_relative '../ffi/ogr/srs_api'
+require_relative '../ogr'
+require_relative '../gdal'
 
 module OGR
   class CoordinateTransformation
@@ -7,7 +8,10 @@ module OGR
     # @return [String]
     def self.proj4_normalize(proj4_source)
       if GDAL._supported?(:OCTProj4Normalize)
-        FFI::GDAL.OCTProj4Normalize(proj4_source)
+        FFI::GDAL::GDAL.OCTProj4Normalize(proj4_source)
+      else
+        raise OGR::UnsupportedOperation,
+          'Your version of GDAL/OGR does not support OCTProj4Normalize'
       end
     end
 
@@ -20,33 +24,94 @@ module OGR
     # @return [FFI::Pointer] C pointer that represents the CoordinateTransformation.
     attr_reader :c_pointer
 
+    # @param source_srs [OGR::SpatialReference]
+    # @param destination_srs [OGR::SpatialReference]
     def initialize(source_srs, destination_srs)
       source_ptr = GDAL._pointer(OGR::SpatialReference, source_srs)
       destination_ptr = GDAL._pointer(OGR::SpatialReference, destination_srs)
       @c_pointer = FFI::OGR::SRSAPI.OCTNewCoordinateTransformation(source_ptr, destination_ptr)
 
-      if @c_pointer.null?
-        fail OGR::Failure, 'Unable to create coordinate transformation'
-      end
-
-      close_me = -> { destroy! }
-      ObjectSpace.define_finalizer self, close_me
+      raise OGR::Failure, 'Unable to create coordinate transformation' if @c_pointer.null?
     end
 
-    # Deletes the object and deallocates all related resources.
+    # Deletes the object and deallocates all related C resources.
     def destroy!
+      return unless @c_pointer
+
       FFI::OGR::SRSAPI.OCTDestroyCoordinateTransformation(@c_pointer)
+      @c_pointer = nil
     end
 
-    # Transforms points in the +source_srs+ space to points in the
-    # +destination_space+ (given in .create).
+    # Transforms points in the +#source_coordinate_system+ space to points in the
+    # +#destination_coordinate_system+ (given in {#initialize}).
     #
     # @param x_vertices [Array<Float>]
     # @param y_vertices [Array<Float>]
     # @param z_vertices [Array<Float>]
-    # @return [Array<Array<Float>,Array<Float>,Array<Float>>] [[x1, y1], [x2,
-    #   y2], etc]
+    # @return [Array<Array<Float>,Array<Float>,Array<Float>>] [[x1, x2, etc], [y1, y2, etc]]
+    #   Will include a 3rd array of Z values if z vertices are given.
     def transform(x_vertices, y_vertices, z_vertices = [])
+      _transform(x_vertices, y_vertices, z_vertices) do |point_count, x_ptr, y_ptr, z_ptr|
+        FFI::OGR::SRSAPI.OCTTransform(@c_pointer, point_count, x_ptr, y_ptr, z_ptr)
+      end
+    end
+
+    # @param x_vertices [Array<Float>]
+    # @param y_vertices [Array<Float>]
+    # @param z_vertices [Array<Float>]
+    # @return [Hash{points => Array<Array<Float>,Array<Float>,Array<Float>>, success_at => Array}]
+    #   [[x1, y1], [x2, y2], etc]
+    def transform_ex(x_vertices, y_vertices, z_vertices = [])
+      success_ptr = nil
+
+      point_array = _transform(x_vertices, y_vertices, z_vertices) do |point_count, x_ptr, y_ptr, z_ptr|
+        success_ptr = FFI::MemoryPointer.new(:bool, point_count)
+        FFI::OGR::SRSAPI.OCTTransformEx(@c_pointer, point_count, x_ptr, y_ptr, z_ptr, success_ptr)
+      end
+
+      successes = success_ptr.read_array_of_type(FFI::Type::BOOL, :read_char, point_array.first.length).map do |value|
+        !value.zero?
+      end
+
+      { points: point_array, successes: successes }
+    end
+
+    private
+
+    # @param x_vertices [Array<Float>]
+    # @param y_vertices [Array<Float>]
+    # @param z_vertices [Array<Float>]
+    # @yieldparam point_count [Fixnum]
+    # @yieldparam x_ptr [FFI::MemortyPointer]
+    # @yieldparam y_ptr [FFI::MemortyPointer]
+    # @yieldparam z_ptr [FFI::MemortyPointer]
+    # @yieldreturn [Boolean]
+    # @return [Array<Array<Float>,Array<Float>,Array<Float>>] [[x1, x2, etc], [y1, y2, etc]]
+    #   Will include a 3rd array of Z values if z vertices are given.
+    def _transform(x_vertices, y_vertices, z_vertices = [])
+      x_ptr, y_ptr, z_ptr = init_transform_pointers(x_vertices, y_vertices, z_vertices)
+      point_count = [x_vertices.length, y_vertices.length, z_vertices.length].max
+
+      result = yield point_count, x_ptr, y_ptr, z_ptr
+
+      # TODO: maybe this should raise?
+      return false unless result
+
+      x_vals = x_ptr.read_array_of_double(x_vertices.size)
+      y_vals = y_ptr.read_array_of_double(y_vertices.size)
+      z_vals = z_vertices.empty? ? nil : z_ptr.read_array_of_double(z_vertices.size)
+
+      points = [x_vals, y_vals]
+      points << z_vals unless z_vertices.empty?
+
+      points
+    end
+
+    # @param x_vertices [Array<Float>]
+    # @param y_vertices [Array<Float>]
+    # @param z_vertices [Array<Float>]
+    # @return [Array<FFI::Pointer>]
+    def init_transform_pointers(x_vertices, y_vertices, z_vertices)
       x_ptr = FFI::MemoryPointer.new(:pointer, x_vertices.size)
       x_ptr.write_array_of_double(x_vertices)
       y_ptr = FFI::MemoryPointer.new(:pointer, y_vertices.size)
@@ -59,25 +124,7 @@ module OGR
         z_ptr.write_array_of_double(z_vertices)
       end
 
-      point_count = x_vertices.size + y_vertices.size + z_vertices.size
-
-      result = FFI::OGR::SRSAPI.OCTTransform(@c_pointer, point_count,
-        x_ptr, y_ptr, z_ptr)
-
-      # maybe this should raise?
-      return false unless result
-
-      x_vals = x_ptr.read_array_of_double
-      y_vals = y_ptr.read_array_of_double
-      z_vals = z_vertices.empty? ? nil : z_ptr.read_array_of_double
-
-      points = if z_vertices.empty?
-                 NMatrix[x_vals, y_vals]
-               else
-                 NMatrix[x_vals, y_vals, z_vals]
-               end
-
-      points.transpose.to_a
+      [x_ptr, y_ptr, z_ptr]
     end
   end
 end

data/lib/ogr/data_source.rb

@@ -1,13 +1,9 @@
 require 'uri'
 require 'json'
-require_relative '../ffi/gdal'
-require_relative '../ffi/ogr'
+require_relative '../gdal'
+require_relative '../ogr'
 require_relative 'data_source_extensions'
-require_relative 'exceptions'
-require_relative 'driver'
 require_relative 'data_source_mixins/capability_methods'
-require_relative 'style_table'
-require_relative 'layer'
 require_relative '../gdal/major_object'
 
 module OGR
@@ -23,7 +19,15 @@ module OGR
     # @param access_flag [String] 'r' for read, 'w', for write.
     # @return [OGR::DataSource]
     def self.open(path, access_flag = 'r')
-      new(path, access_flag)
+      ds = new(path, access_flag)
+
+      if block_given?
+        result = yield ds
+        ds.close
+        result
+      else
+        ds
+      end
     end
 
     # @return [FFI::Pointer]
@@ -34,7 +38,7 @@ module OGR
     # @param access_flag [String] 'r' for read, 'w', for write.
     def initialize(path_or_pointer, access_flag)
       @c_pointer =
-        if path_or_pointer.is_a? String
+        if path_or_pointer.is_a?(String)
           uri = URI.parse(path_or_pointer)
           file_path = uri.scheme.nil? ? ::File.expand_path(path_or_pointer) : path_or_pointer
           FFI::OGR::API.OGROpen(file_path, OGR._boolean_access_flag(access_flag), nil)
@@ -42,10 +46,9 @@ module OGR
           path_or_pointer
         end
 
-      fail OGR::OpenFailure, file_path if @c_pointer.null?
+      raise OGR::OpenFailure, file_path if @c_pointer.null?
 
       @layers = []
-      ObjectSpace.define_finalizer self, -> { destroy! }
     end
 
     # Closes opened data source and releases allocated resources.
@@ -55,7 +58,7 @@ module OGR
       FFI::OGR::API.OGR_DS_Destroy(@c_pointer)
       @c_pointer = nil
     end
-    alias_method :close, :destroy!
+    alias close destroy!
 
     # Name of the file represented by this object.
     #
@@ -108,7 +111,7 @@ module OGR
     # @return [OGR::Layer]
     def create_layer(name, geometry_type: :wkbUnknown, spatial_reference: nil, **options)
       unless can_create_layer?
-        fail OGR::UnsupportedOperation, 'This data source does not support creating layers.'
+        raise OGR::UnsupportedOperation, 'This data source does not support creating layers.'
       end
 
       spatial_ref_ptr = GDAL._pointer(OGR::SpatialReference, spatial_reference) if spatial_reference
@@ -118,7 +121,7 @@ module OGR
         spatial_ref_ptr, geometry_type, options_obj)
 
       unless layer_ptr
-        fail OGR::InvalidLayer, "Unable to create layer '#{name}'."
+        raise OGR::InvalidLayer, "Unable to create layer '#{name}'."
       end
 
       @layers << OGR::Layer.new(layer_ptr)
@@ -145,7 +148,7 @@ module OGR
     # @return +true+ if successful, otherwise raises an OGR exception.
     def delete_layer(index)
       unless can_delete_layer?
-        fail OGR::UnsupportedOperation, 'This data source does not support deleting layers.'
+        raise OGR::UnsupportedOperation, 'This data source does not support deleting layers.'
       end
 
       ogr_err = FFI::OGR::API.OGR_DS_DeleteLayer(@c_pointer, index)

data/lib/ogr/data_source_extensions.rb

@@ -2,11 +2,7 @@ module OGR
   module DataSourceExtensions
     # @return [Array<OGR::Layer>]
     def layers
-      l = layer_count.times.map do |i|
-        layer(i)
-      end
-
-      @layers = l
+      @layers = Array.new(layer_count) { |i| layer(i) }
     end
 
     # @return [Hash]

data/lib/ogr/driver.rb

@@ -1,8 +1,7 @@
-require_relative '../ffi/ogr'
+require_relative '../ogr'
+require_relative '../gdal'
 require_relative '../gdal/major_object'
-require_relative '../gdal/options'
 require_relative 'driver_mixins/capability_methods'
-require_relative 'data_source'
 
 module OGR
   # Wrapper for OGR's Driver class.  In this case, to use a driver, find the
@@ -25,7 +24,7 @@ module OGR
     # @raise [OGR::DriverNotFound] if a driver with +name+ isn't found.
     def self.by_name(name)
       driver_ptr = FFI::OGR::API.OGRGetDriverByName(name)
-      fail OGR::DriverNotFound, name if driver_ptr.null?
+      raise OGR::DriverNotFound, name if driver_ptr.null?
 
       new(driver_ptr)
     end
@@ -35,20 +34,18 @@ module OGR
     # @return [OGR::Driver]
     # @raise [OGR::DriverNotFound] if a driver at +index+ isn't found.
     def self.at_index(index)
-      fail OGR::DriverNotFound, index if index > count
+      raise OGR::DriverNotFound, index if index > count
 
       driver_ptr = FFI::OGR::API.OGRGetDriver(index)
       return nil if driver_ptr.null?
-      fail OGR::DriverNotFound, index if driver_ptr.null?
+      raise OGR::DriverNotFound, index if driver_ptr.null?
 
       new(driver_ptr)
     end
 
     # @return [Array<String>]
     def self.names
-      count.times.map do |i|
-        at_index(i).name
-      end.sort
+      Array.new(count) { |i| at_index(i).name }.sort
     end
 
     # @return [FFI::Pointer] C pointer that represents the Driver.
@@ -76,7 +73,7 @@ module OGR
       data_source_ptr = FFI::OGR::API.OGR_Dr_Open(@c_pointer, file_name, update)
 
       if data_source_ptr.null?
-        fail OGR::InvalidDataSource, "Unable to open data source at #{file_name}"
+        raise OGR::InvalidDataSource, "Unable to open data source at #{file_name}"
       end
 
       OGR::DataSource.new(data_source_ptr, nil)
@@ -91,7 +88,7 @@ module OGR
     # @return [OGR::DataSource, nil]
     def create_data_source(file_name, **options)
       unless can_create_data_source?
-        fail OGR::UnsupportedOperation, 'This driver does not support data source creation.'
+        raise OGR::UnsupportedOperation, 'This driver does not support data source creation.'
       end
 
       options_ptr = GDAL::Options.pointer(options)
@@ -100,7 +97,7 @@ module OGR
         file_name, options_ptr)
       return nil if data_source_ptr.null?
 
-      ds = OGR::DataSource.new(data_source_ptr, nil)
+      ds = OGR::DataSource.new(data_source_ptr, 'w')
       yield ds if block_given?
 
       ds
@@ -110,7 +107,7 @@ module OGR
     # @return +true+ if successful, otherwise raises an OGR exception.
     def delete_data_source(file_name)
       unless can_delete_data_source?
-        fail OGR::UnsupportedOperation, 'This driver does not support deleting data sources.'
+        raise OGR::UnsupportedOperation, 'This driver does not support deleting data sources.'
       end
 
       ogr_err = FFI::OGR::API.OGR_Dr_DeleteDataSource(@c_pointer, file_name)
@@ -126,7 +123,7 @@ module OGR
       source_ptr = GDAL._pointer(OGR::DataSource, source_data_source)
 
       if source_ptr.nil? || source_ptr.null?
-        fail OGR::InvalidDataSource, source_data_source
+        raise OGR::InvalidDataSource, source_data_source
       end
 
       options_ptr = GDAL::Options.pointer(options)

data/lib/ogr/envelope.rb

@@ -1,4 +1,4 @@
-require_relative '../ffi/ogr'
+require_relative '../ogr'
 require_relative 'envelope_extensions'
 
 module OGR

data/lib/ogr/envelope_extensions.rb

@@ -40,11 +40,11 @@ module OGR
     # 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]
+    # @param other [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
+    def ==(other)
+      x_min == other.x_min && y_min == other.y_min &&
+        x_max == other.x_max && y_max == other.y_max
     end
 
     # Stolen from http://www.gdal.org/ogr__core_8h_source.html.
@@ -85,6 +85,22 @@ module OGR
         y_max >= other_envelope.y_max
     end
 
+    # @return [OGR::Polygon]
+    def to_polygon
+      ring = OGR::LinearRing.new
+      ring.point_count = 5
+      ring.set_point(0, x_min, y_max)
+      ring.set_point(1, x_max, y_max)
+      ring.set_point(2, x_max, y_min)
+      ring.set_point(3, x_min, y_min)
+      ring.set_point(4, x_min, y_max)
+
+      polygon = OGR::Polygon.new
+      polygon.add_geometry(ring)
+
+      polygon
+    end
+
     # @return [Hash]
     def as_json(_options = nil)
       json = {
@@ -94,8 +110,9 @@ module OGR
         y_max: y_max
       }
 
-      if @c_struct.is_a? FFI::GDAL::OGREnvelope3D
-        json.merge!(z_min: z_min, z_max: z_max)
+      if @c_struct.is_a? FFI::OGR::Envelope3D
+        json[:z_min] = z_min
+        json[:z_max] = z_max
       end
 
       json

data/lib/ogr/error_handling.rb

@@ -23,7 +23,7 @@ module OGR
     # @return [Proc]
     def error_class_map(error_class)
       {
-        OGRERR_NONE: ->(_) { true },
+        OGRERR_NONE: proc { 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) },
@@ -32,7 +32,7 @@ module OGR
         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}" }
+      }.fetch(error_class) { raise "Unknown OGRERR type: #{self}" }
     end
 
     # Exists solely to strip off the top 4 lines of the backtrace so it doesn't
@@ -40,7 +40,7 @@ module OGR
     def raise_exception(exception, message)
       e = exception.new(message)
       e.set_backtrace(caller(4))
-      fail(e)
+      raise(e)
     end
   end
 end