ffi-gdal 1.0.0.beta3 → 1.0.0.beta4

data/lib/ogr/geometry_extensions.rb

@@ -2,12 +2,11 @@ require 'json'
 
 module OGR
   module GeometryExtensions
-
     # @return [Hash]
-    def as_json
+    def as_json(options = nil)
       json = {
         coordinate_dimension: coordinate_dimension,
-        count: count,
+        geometry_count: geometry_count,
         dimension: dimension,
         is_empty: empty?,
         is_ring: ring?,
@@ -15,7 +14,7 @@ module OGR
         is_valid: valid?,
         name: name,
         point_count: point_count,
-        spatial_reference: spatial_reference.as_json,
+        spatial_reference: spatial_reference.nil? ? nil : spatial_reference.as_json(options),
         type: type_to_name,
         wkb_size: wkb_size
       }
@@ -28,8 +27,8 @@ module OGR
     end
 
     # @return [String]
-    def to_json
-      as_json.to_json
+    def to_json(options = nil)
+      as_json(options).to_json
     end
 
     def collection?
@@ -42,13 +41,13 @@ module OGR
       data_source = driver.create_data_source(file_name)
       log "Creating layer #{layer_name}, type: #{type}"
       layer = data_source.create_layer(layer_name, geometry_type: type,
-      spatial_reference: spatial_reference)
+                                                   spatial_reference: spatial_reference)
 
-      # field = Field.create('Name', :OFTString)
+      # field = FieldDefinition.new('Name', :OFTString)
       # field.width = 32
 
       unless layer
-        raise OGR::InvalidLayer, "Unable to create layer '#{layer_name}'."
+        fail OGR::InvalidLayer, "Unable to create layer '#{layer_name}'."
       end
 
       feature = layer.create_feature(layer_name)

data/lib/ogr/geometry_field_definition.rb

@@ -0,0 +1,99 @@
+require_relative 'geometry_field_definition_extensions'
+
+module OGR
+  class GeometryFieldDefinition
+    include GeometryFieldDefinitionExtensions
+
+    # @return [FFI::Pointer]
+    attr_reader :c_pointer
+
+    # @param value [Boolean]
+    attr_writer :read_only
+
+    # @param name_or_pointer [String, FFI::Pointer]
+    # @param type [FFI::OGR::API::WKBGeometryType]
+    def initialize(name_or_pointer, type = :wkbUnknown)
+      @c_pointer =
+        if name_or_pointer.is_a? String
+          FFI::OGR::API.OGR_GFld_Create(name_or_pointer, type)
+        else
+          name_or_pointer
+        end
+
+      unless @c_pointer.is_a?(FFI::Pointer) && !@c_pointer.null?
+        fail OGR::InvalidGeometryFieldDefinition,
+          "Unable to create #{self.class.name} from #{name_or_pointer}"
+      end
+
+      @read_only = false
+    end
+
+    # @return [Boolean]
+    def read_only?
+      @read_only || false
+    end
+
+    def destroy!
+      FFI::OGR::API.OGR_GFld_Destroy(@c_pointer)
+      @c_pointer = nil
+    end
+
+    # @return [String]
+    def name
+      FFI::OGR::API.OGR_GFld_GetNameRef(@c_pointer)
+    end
+
+    # @param new_name [String]
+    def name=(new_name)
+      fail OGR::ReadOnlyObject if @read_only
+
+      FFI::OGR::API.OGR_GFld_SetName(@c_pointer, new_name)
+    end
+
+    # @return [FFI::OGR::API::WKBGeometryType]
+    def type
+      FFI::OGR::API.OGR_GFld_GetType(@c_pointer)
+    end
+
+    # @param new_type [FFI::OGR::API::WKBGeometryType]
+    def type=(new_type)
+      fail OGR::ReadOnlyObject if @read_only
+
+      FFI::OGR::API.OGR_GFld_SetType(@c_pointer, new_type)
+    end
+
+    # @return [OGR::SpatialReference]
+    def spatial_reference
+      spatial_ref_ptr = FFI::OGR::API.OGR_GFld_GetSpatialRef(@c_pointer)
+
+      if spatial_ref_ptr.nil? || spatial_ref_ptr.null?
+        nil
+      else
+        OGR::SpatialReference.new(spatial_ref_ptr)
+      end
+    end
+
+    # @param new_spatial_reference [OGR::SpatialReference, FFI::Pointer]
+    def spatial_reference=(new_spatial_reference)
+      fail OGR::ReadOnlyObject if @read_only
+
+      spatial_ref_ptr = GDAL._pointer(OGR::SpatialReference, new_spatial_reference)
+
+      FFI::OGR::API.OGR_GFld_SetSpatialRef(
+        @c_pointer,
+        spatial_ref_ptr)
+    end
+
+    # @return [Boolean]
+    def ignored?
+      FFI::OGR::API.OGR_GFld_IsIgnored(@c_pointer)
+    end
+
+    # @param value [Boolean]
+    def ignore=(value)
+      fail OGR::ReadOnlyObject if @read_only
+
+      FFI::OGR::API.OGR_GFld_SetIgnored(@c_pointer, value)
+    end
+  end
+end

data/lib/ogr/geometry_field_definition_extensions.rb

@@ -0,0 +1,19 @@
+require 'json'
+
+module OGR
+  module GeometryFieldDefinitionExtensions
+    # @return [Hash]
+    def as_json(options = nil)
+      {
+        is_ignored: ignored?,
+        name: name,
+        spatial_reference: spatial_reference ? spatial_reference.as_json(options) : nil,
+        type: type
+      }
+    end
+
+    def to_json(options = nil)
+      as_json(options).to_json
+    end
+  end
+end

data/lib/ogr/geometry_types/container.rb

@@ -0,0 +1,75 @@
+module OGR
+  module GeometryTypes
+    module Container
+      def collection?
+        true
+      end
+
+      # If this geometry is a container, this adds +geometry+ to the container.
+      # If this is a Polygon, +geometry+ must be a LinearRing.  If the Polygon is
+      # empty, the first added +geometry+ will be the exterior ring.  Subsequent
+      # geometries added will be interior rings.
+      #
+      # @param sub_geometry [OGR::Geometry, FFI::Pointer]
+      # @return +true+ if successful, otherwise raises an OGR exception.
+      def add_geometry(sub_geometry)
+        sub_geometry_ptr = GDAL._pointer(OGR::Geometry, sub_geometry)
+        ogr_err = FFI::OGR::API.OGR_G_AddGeometry(@c_pointer, sub_geometry_ptr)
+
+        ogr_err.handle_result "Unable to add geometry: #{sub_geometry}"
+      end
+
+      # @param sub_geometry [OGR::Geometry, FFI::Pointer]
+      # @return +true+ if successful, otherwise raises an OGR exception.
+      def add_directly(sub_geometry)
+        sub_geometry_ptr = GDAL._pointer(OGR::Geometry, sub_geometry)
+        ogr_err = FFI::OGR::API.OGR_G_AddGeometryDirectly(@c_pointer, sub_geometry_ptr)
+
+        ogr_err.handle_result
+      end
+
+      # @param geometry_index [Fixnum]
+      # @param delete [Boolean]
+      # @return +true+ if successful, otherwise raises an OGR exception.
+      def remove_geometry(geometry_index, delete = true)
+        ogr_err = FFI::OGR::API.OGR_G_RemoveGeometry(@c_pointer, geometry_index, delete)
+
+        ogr_err.handle_result
+      end
+
+      # If this geometry is a container, this fetches the geometry at the
+      # sub_geometry_index.
+      #
+      # @param sub_geometry_index [Fixnum]
+      # @return [OGR::Geometry]
+      def geometry_at(sub_geometry_index)
+        build_geometry do |ptr|
+          FFI::OGR::API.OGR_G_GetGeometryRef(ptr, sub_geometry_index)
+        end
+      end
+
+      # Build a ring from a bunch of arcs.  The collection must be
+      # a MultiLineString or GeometryCollection.
+      #
+      # @param tolerance [Float]
+      # @param auto_close [Boolean]
+      # @return [OGR::Geometry]
+      def polygon_from_edges(tolerance, auto_close: false)
+        best_effort = false
+        ogrerr_ptr = FFI::MemoryPointer.new(:pointer)
+
+        new_geometry_ptr = FFI::OGR::API.OGRBuildPolygonFromEdges(@c_pointer,
+          best_effort,
+          auto_close,
+          tolerance,
+          ogrerr_ptr)
+
+        ogrerr_int = ogrerr_ptr.read_int
+        ogrerr = FFI::OGR::Core::Err[ogrerr_int]
+        ogrerr.handle_result "Couldn't create polygon"
+
+        OGR::Geometry.factory(new_geometry_ptr)
+      end
+    end
+  end
+end

data/lib/ogr/geometry_types/curve.rb

@@ -1,20 +1,19 @@
 module OGR
   module GeometryTypes
     module Curve
-
       # @return [Float]
       def x(point_number)
-        FFI::GDAL.OGR_G_GetX(@geometry_pointer, point_number)
+        FFI::OGR::API.OGR_G_GetX(@c_pointer, point_number)
       end
 
       # @return [Float]
       def y(point_number)
-        FFI::GDAL.OGR_G_GetY(@geometry_pointer, point_number)
+        FFI::OGR::API.OGR_G_GetY(@c_pointer, point_number)
       end
 
       # @return [Float]
       def z(point_number)
-        FFI::GDAL.OGR_G_GetZ(@geometry_pointer, point_number)
+        FFI::OGR::API.OGR_G_GetZ(@c_pointer, point_number)
       end
 
       # @return [Array<Float, Float, Float>] [x, y] if 2d or [x, y, z] if 3d.
@@ -23,7 +22,7 @@ module OGR
         y_ptr = FFI::MemoryPointer.new(:double)
         z_ptr = FFI::MemoryPointer.new(:double)
 
-        FFI::GDAL.OGR_G_GetPoint(@geometry_pointer, number, x_ptr, y_ptr, z_ptr)
+        FFI::OGR::API.OGR_G_GetPoint(@c_pointer, number, x_ptr, y_ptr, z_ptr)
 
         if coordinate_dimension == 2
           [x_ptr.read_double, y_ptr.read_double]
@@ -37,16 +36,16 @@ module OGR
       # @param x [Float]
       # @param y [Float]
       # @param z [Float]
-      def add_point(x, y, z=0)
+      def add_point(x, y, z = 0)
         if coordinate_dimension == 3
-          FFI::GDAL.OGR_G_AddPoint(@geometry_pointer, x, y, z)
+          FFI::OGR::API.OGR_G_AddPoint(@c_pointer, x, y, z)
         else
-          FFI::GDAL.OGR_G_AddPoint_2D(@geometry_pointer, x, y)
+          FFI::OGR::API.OGR_G_AddPoint_2D(@c_pointer, x, y)
         end
       end
 
-      def set_point(index, x, y, z=0)
-        FFI::GDAL.OGR_G_SetPoint(@geometry_pointer, index, x, y, z)
+      def set_point(index, x, y, z = 0)
+        FFI::OGR::API.OGR_G_SetPoint(@c_pointer, index, x, y, z)
       end
 
       # @return [Array<Array>] An array of (x, y) or (x, y, z) points.
@@ -61,21 +60,19 @@ module OGR
         y_buffer = FFI::MemoryPointer.new(:buffer_out, buffer_size)
 
         z_buffer = if coordinate_dimension == 3
-          z_size = FFI::Type::DOUBLE.size * point_count
-          FFI::MemoryPointer.new(:buffer_out, z_size)
-        else
-          nil
-        end
-
-        num_points = FFI::GDAL.OGR_G_GetPoints(@geometry_pointer,
-        x_buffer,
-        x_stride,
-        y_buffer,
-        y_stride,
-        z_buffer,
-        z_stride)
-
-        0.upto(num_points - 1).map do |i|
+                     z_size = FFI::Type::DOUBLE.size * point_count
+                     FFI::MemoryPointer.new(:buffer_out, z_size)
+                   end
+
+        num_points = FFI::OGR::API.OGR_G_GetPoints(@c_pointer,
+          x_buffer,
+          x_stride,
+          y_buffer,
+          y_stride,
+          z_buffer,
+          z_stride)
+
+        num_points.times.map do |i|
           point(i)
         end
       end
@@ -87,13 +84,13 @@ module OGR
         points.map do |x_and_y|
           result = geo_transform.world_to_pixel(*x_and_y)
 
-          [result[:x].to_i.abs, result[:y].to_i.abs]
+          [result[:pixel].to_i.abs, result[:line].to_i.abs]
         end
       end
 
       # @param new_count [Fixnum]
       def point_count=(new_count)
-        FFI::GDAL.OGR_G_SetPointCount(@geometry_pointer, new_count)
+        FFI::OGR::API.OGR_G_SetPointCount(@c_pointer, new_count)
       end
 
       # Computes the length for this geometry.  Computes area for Curve or
@@ -101,7 +98,7 @@ module OGR
       #
       # @return [Float] 0.0 for unsupported geometry types.
       def length
-        FFI::GDAL.OGR_G_Length(@geometry_pointer)
+        FFI::OGR::API.OGR_G_Length(@c_pointer)
       end
 
       def start_point

data/lib/ogr/geometry_types/surface.rb

@@ -1,19 +1,28 @@
+require_relative '../../ffi/ogr/api'
+
 module OGR
   module GeometryTypes
     module Surface
-
-      # Computes area for a LinearRing, Polygon, or MultiPolygon.
+      # Computes area for a LinearRing, Polygon, or MultiPolygon.  The area of
+      # the feature is in square units of the spatial reference system in use.
       #
       # @return [Float] 0.0 for unsupported geometry types.
       def area
-        FFI::GDAL.OGR_G_Area(@geometry_pointer)
+        FFI::OGR::API.OGR_G_Area(@c_pointer)
+      end
+
+      # Returns the units used by the associated OGR::SpatialReference.
+      #
+      # @return [Hash]
+      def area_units
+        spatial_reference ? spatial_reference.linear_units : nil
       end
 
       # Returns a point that's guaranteed to lie on the surface.
       #
       # @return [OGR::Point]
       def point_on_surface
-        build_geometry { |ptr| FFI::GDAL.OGR_G_PointOnSurface(ptr) }
+        build_geometry { |ptr| FFI::OGR::API.OGR_G_PointOnSurface(ptr) }
       end
     end
   end

data/lib/ogr/internal_helpers.rb

@@ -0,0 +1,57 @@
+require 'time'
+
+module OGR
+  module InternalHelpers
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # Makes the interface consistent with the access flags for GDAL.
+      #
+      # @param flag [String] 'w' for writing, 'r' for reading.
+      def _boolean_access_flag(flag)
+        case flag
+        when 'w' then true
+        when 'r' then false
+        else fail "Invalid access_flag '#{flag}'.  Use 'r' or 'w'."
+        end
+      end
+
+      # OGR's time zone rules:
+      #   * 0 = unknown
+      #   * 1 = local time
+      #   * 100 = GMT
+      #
+      # This converts the OGR integer into something usable by Ruby's DateTime.
+      #
+      # @param time_zone [Fixnum]
+      def _format_time_zone_for_ruby(time_zone)
+        case time_zone
+        when 0 then nil
+        when 1 then (Time.now.getlocal.utc_offset / 3600).to_s
+        when 100 then '+0'
+        else fail "Unable to process time zone: #{time_zone}"
+        end
+      end
+
+      # OGR's time zone rules:
+      #   * 0 = unknown
+      #   * 1 = local time
+      #   * 100 = GMT
+      #
+      # This converts Ruby's DateTime time zone info into OGR's integer.
+      #
+      # @param time_zone [String]
+      def _format_time_zone_for_ogr(time_zone)
+        if time_zone =~ /GMT/
+          100
+        elsif time_zone
+          1
+        else
+          0
+        end
+      end
+    end
+  end
+end