ffi-gdal 1.0.0.beta3 → 1.0.0.beta4

data/lib/ogr/field_definition.rb

@@ -0,0 +1,110 @@
+require_relative '../ffi/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
+
+    # @param name_or_pointer [String, FFI::Pointer]
+    # @param type [FFI::OGR::FieldType]
+    def initialize(name_or_pointer, type)
+      @c_pointer = if name_or_pointer.is_a? String
+                     FFI::OGR::API.OGR_Fld_Create(name_or_pointer, type)
+                   else
+                     name_or_pointer
+                   end
+
+      unless @c_pointer.is_a?(FFI::Pointer) && !@c_pointer.null?
+        fail OGR::InvalidFieldDefinition, "Unable to create #{self.class.name} from #{name_or_pointer}"
+      end
+
+      ObjectSpace.define_finalizer(self, -> { destroy! })
+    end
+
+    def destroy!
+      FFI::OGR::API.OGR_Fld_Destroy(@c_pointer)
+      @c_pointer = nil
+    end
+
+    # Set all defining attributes in one call.
+    #
+    # @param name [String]
+    # @param type [FFI::OGR::FieldType]
+    # @param width [Fixnum]
+    # @param precision [Fixnum]
+    # @param justification [FFI::OGR::Justification]
+    def set(name, type, width, precision, justification)
+      FFI::OGR::API.OGR_Fld_Set(
+        @c_pointer,
+        name,
+        type,
+        width,
+        precision,
+        justification
+      )
+    end
+
+    # @return [String]
+    def name
+      FFI::OGR::API.OGR_Fld_GetNameRef(@c_pointer)
+    end
+
+    # @param new_value [String]
+    def name=(new_value)
+      FFI::OGR::API.OGR_Fld_SetName(@c_pointer, new_value)
+    end
+
+    # @return [FFI::OGR::Justification]
+    def justification
+      FFI::OGR::API.OGR_Fld_GetJustify(@c_pointer)
+    end
+
+    # @param new_value [FFI::OGR::Justification]
+    def justification=(new_value)
+      FFI::OGR::API.OGR_Fld_SetJustify(@c_pointer, new_value)
+    end
+
+    # @return [Fixnum]
+    def precision
+      FFI::OGR::API.OGR_Fld_GetPrecision(@c_pointer)
+    end
+
+    # @param new_value [Fixnum]
+    def precision=(new_value)
+      FFI::OGR::API.OGR_Fld_SetPrecision(@c_pointer, new_value)
+    end
+
+    # @return [FFI::OGR::FieldType]
+    def type
+      FFI::OGR::API.OGR_Fld_GetType(@c_pointer)
+    end
+
+    # @param new_value [FFI::OGR::FieldType]
+    def type=(new_value)
+      FFI::OGR::API.OGR_Fld_SetType(@c_pointer, new_value)
+    end
+
+    # @return [Fixnum]
+    def width
+      FFI::OGR::API.OGR_Fld_GetWidth(@c_pointer)
+    end
+
+    # @param new_value [Fixnum]
+    def width=(new_value)
+      FFI::OGR::API.OGR_Fld_SetWidth(@c_pointer, new_value)
+    end
+
+    # @return [Boolean]
+    def ignored?
+      FFI::OGR::API.OGR_Fld_IsIgnored(@c_pointer)
+    end
+
+    # @param new_value [Boolean]
+    def ignore=(new_value)
+      FFI::OGR::API.OGR_Fld_SetIgnored(@c_pointer, new_value)
+    end
+  end
+end

data/lib/ogr/{field_extensions.rb → field_definition_extensions.rb}

@@ -1,10 +1,9 @@
 require 'json'
 
 module OGR
-  module FieldExtensions
-
+  module FieldDefinitionExtensions
     # @return [Hash]
-    def as_json
+    def as_json(_options = nil)
       {
         is_ignored: ignored?,
         justification: justification,
@@ -16,8 +15,8 @@ module OGR
     end
 
     # @return [String]
-    def to_json
-      as_json.to_json
+    def to_json(options = nil)
+      as_json(options).to_json
     end
   end
 end

data/lib/ogr/{geocoding_session.rb → geocoder.rb}

@@ -1,9 +1,11 @@
 require_relative 'layer'
 
 module OGR
-
   # Geocode things!  http://www.gdal.org/ogr__geocoding_8h.html
-  class GeocodingSession
+  class Geocoder
+    # @return [FFI::Pointer] C pointer to the C geocoding session.
+    attr_reader :c_pointer
+
     # @param options [Hash]
     # @option options cache_file [String] Name of the file to write the cache
     #   to.
@@ -32,21 +34,20 @@ module OGR
 
       options_ptr = GDAL::Options.pointer(converted_options)
 
-      @geocoding_session_pointer = FFI::GDAL.OGRGeocodeCreateSession(options_ptr)
-    end
-
-    def c_pointer
-      @geocoding_session_pointer
+      @c_pointer = FFI::GDAL.OGRGeocodeCreateSession(options_ptr)
     end
 
     def destroy!
-      FFI::GDAL.OGRGeocodeDestroySession(@geocoding_session_pointer)
+      return unless @c_pointer
+
+      FFI::GDAL.OGRGeocodeDestroySession(@c_pointer)
+      @c_pointer = nil
     end
 
     # @param query [String]
     # @param options [Hash]
     # @option options addressdetails [Boolean] +true+ to include a breakdown of
-    #   the adddress into elements.  Only works with some geocoding services.
+    #   the address into elements.  Only works with some geocoding services.
     # @option options countrycodes [Array<String, Symbol>] Limit the search to a
     #   specific country or countries.  Only works with some geocoding services.
     # @option options limit [Fixnum] Limit the number of records returned.  Only
@@ -57,8 +58,8 @@ module OGR
     # @return [OGR::Layer, nil]
     def geocode(query, **options)
       options_ptr = GDAL::Options.pointer(options)
-      layer_ptr = FFI::GDAL.OGRGeocode(@geocoding_session_pointer, query, nil,
-        options_ptr)
+      layer_ptr =
+        FFI::GDAL.OGRGeocode(@c_pointer, query, nil, options_ptr)
       return nil if layer_ptr.null?
 
       OGR::Layer.new(layer_ptr)
@@ -74,8 +75,8 @@ module OGR
     # @return [OGR::Layer]
     def reverse_geocode(lon, lat, **options)
       options_ptr = GDAL::Options.pointer(options)
-      layer_ptr = FFI::GDAL.OGRGeocodeReverse(@geocoding_session_pointer, lon,
-        lat, options_ptr)
+      layer_ptr =
+        FFI::GDAL.OGRGeocodeReverse(@c_pointer, lon, lat, options_ptr)
       return nil if layer_ptr.null?
 
       OGR::Layer.new(layer_ptr)

data/lib/ogr/geometries/geometry_collection.rb

@@ -0,0 +1,13 @@
+require_relative '../geometry_types/container'
+
+module OGR
+  class GeometryCollection
+    include OGR::Geometry
+    include GeometryTypes::Container
+
+    def initialize(geometry_ptr = nil)
+      geometry_ptr ||= OGR::Geometry.create(:wkbGeometryCollection)
+      initialize_from_pointer(geometry_ptr)
+    end
+  end
+end

data/lib/ogr/geometries/line_string.rb

@@ -0,0 +1,35 @@
+require_relative '../geometry_types/curve'
+
+module OGR
+  class LineString
+    include OGR::Geometry
+    include GeometryTypes::Curve
+
+    def self.approximate_arc_angles(center_x, center_y,
+                                    z,
+                                    primary_radius, secondary_radius,
+                                    rotation,
+                                    start_angle, end_angle,
+                                    max_angle_step_size_degrees = 0)
+      geometry_ptr = FFI::GDAL.OGR_G_ApproximateArcAngles(
+        center_x,
+        center_y,
+        z,
+        primary_radius,
+        secondary_radius,
+        rotation,
+        start_angle,
+        end_angle,
+        max_angle_step_size_degrees
+      )
+      return nil if geometry_ptr.null?
+
+      new(geometry_ptr)
+    end
+
+    def initialize(geometry_ptr = nil)
+      geometry_ptr ||= OGR::Geometry.create(:wkbLineString)
+      initialize_from_pointer(geometry_ptr)
+    end
+  end
+end

data/lib/ogr/geometries/linear_ring.rb

@@ -0,0 +1,11 @@
+require_relative 'line_string'
+
+module OGR
+  class LinearRing < LineString
+    # @param [FFI::Pointer] geometry_ptr
+    def initialize(geometry_ptr = nil)
+      geometry_ptr ||= OGR::Geometry.create(:wkbLinearRing)
+      initialize_from_pointer(geometry_ptr)
+    end
+  end
+end

data/lib/ogr/geometries/multi_line_string.rb

@@ -0,0 +1,16 @@
+require_relative '../geometry_types/curve'
+require_relative '../geometry_types/container'
+
+module OGR
+  class MultiLineString
+    include OGR::Geometry
+    include GeometryTypes::Curve
+    include GeometryTypes::Container
+
+    # @param [FFI::Pointer] geometry_ptr
+    def initialize(geometry_ptr = nil)
+      geometry_ptr ||= OGR::Geometry.create(:wkbMultiLineString)
+      initialize_from_pointer(geometry_ptr)
+    end
+  end
+end

data/lib/ogr/geometries/multi_point.rb

@@ -0,0 +1,14 @@
+require_relative '../geometry_types/container'
+
+module OGR
+  class MultiPoint
+    include OGR::Geometry
+    include GeometryTypes::Container
+
+    # @param [FFI::Pointer] geometry_ptr
+    def initialize(geometry_ptr = nil)
+      geometry_ptr ||= OGR::Geometry.create(:wkbMultiPoint)
+      initialize_from_pointer(geometry_ptr)
+    end
+  end
+end

data/lib/ogr/geometries/multi_polygon.rb

@@ -0,0 +1,21 @@
+require_relative '../geometry_types/container'
+require_relative '../geometry_types/surface'
+
+module OGR
+  class MultiPolygon
+    include OGR::Geometry
+    include GeometryTypes::Container
+    include GeometryTypes::Surface
+
+    # @param [FFI::Pointer] geometry_ptr
+    def initialize(geometry_ptr = nil)
+      geometry_ptr ||= OGR::Geometry.create(:wkbMultiPolygon)
+      initialize_from_pointer(geometry_ptr)
+    end
+
+    # @return [OGR::Geometry]
+    def union_cascaded
+      build_geometry { |ptr| FFI::OGR::API.OGR_G_UnionCascaded(ptr) }
+    end
+  end
+end

data/lib/ogr/geometries/none_geometry.rb

@@ -0,0 +1,13 @@
+module OGR
+  class NoneGeometry
+    include OGR::Geometry
+
+    # OGR doesn't seem to let you create NoneGeometries, so let's only allow
+    # creation from a pointer.
+    #
+    # @param geometry_ptr [FFI::Pointer]
+    def initialize(geometry_ptr)
+      initialize_from_pointer(geometry_ptr)
+    end
+  end
+end

data/lib/ogr/geometries/point.rb

@@ -0,0 +1,65 @@
+require_relative 'point_extensions'
+
+module OGR
+  class Point
+    include OGR::Geometry
+    include PointExtensions
+
+    # @param [FFI::Pointer] geometry_ptr
+    def initialize(geometry_ptr = nil)
+      geometry_ptr ||= OGR::Geometry.create(:wkbPoint)
+      initialize_from_pointer(geometry_ptr)
+    end
+
+    # @return [Float]
+    def x
+      return nil if empty?
+
+      FFI::OGR::API.OGR_G_GetX(@c_pointer, 0)
+    end
+
+    # @return [Float]
+    def y
+      return nil if empty?
+
+      FFI::OGR::API.OGR_G_GetY(@c_pointer, 0)
+    end
+
+    # @return [Float]
+    def z
+      return nil if empty?
+
+      FFI::OGR::API.OGR_G_GetZ(@c_pointer, 0)
+    end
+
+    # @return [Array<Float, Float, Float>] [x, y] if 2d or [x, y, z] if 3d.
+    def point
+      return [] if empty?
+
+      x_ptr = FFI::MemoryPointer.new(:double)
+      y_ptr = FFI::MemoryPointer.new(:double)
+      z_ptr = FFI::MemoryPointer.new(:double)
+
+      FFI::OGR::API.OGR_G_GetPoint(@c_pointer, 0, x_ptr, y_ptr, z_ptr)
+
+      if coordinate_dimension == 2
+        [x_ptr.read_double, y_ptr.read_double]
+      else
+        [x_ptr.read_double, y_ptr.read_double, z_ptr.read_double]
+      end
+    end
+
+    def set_point(x, y, z = 0)
+      FFI::OGR::API.OGR_G_SetPoint(@c_pointer, 0, x, y, z)
+    end
+
+    # Adds a point to a LineString or Point geometry.
+    #
+    # @param x [Float]
+    # @param y [Float]
+    # @param z [Float]
+    def add_point(x, y, z = 0)
+      FFI::OGR::API.OGR_G_AddPoint(@c_pointer, x, y, z)
+    end
+  end
+end

data/lib/ogr/geometries/point_extensions.rb

@@ -0,0 +1,32 @@
+module OGR
+  module PointExtensions
+    # @return [Array<Array>] An array of (x, y) or (x, y, z) points.
+    def points
+      return [[]] if empty?
+
+      x_stride = 2
+      y_stride = 2
+      z_stride = coordinate_dimension == 3 ? 1 : 0
+
+      buffer_size = FFI::Type::DOUBLE.size * 2 * point_count
+
+      x_buffer = FFI::MemoryPointer.new(:buffer_out, buffer_size)
+      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)
+                 end
+
+      _num_points = FFI::OGR::API.OGR_G_GetPoints(@c_pointer,
+        x_buffer,
+        x_stride,
+        y_buffer,
+        y_stride,
+        z_buffer,
+        z_stride)
+
+      [point]
+    end
+  end
+end

data/lib/ogr/geometries/polygon.rb

@@ -0,0 +1,14 @@
+require_relative '../geometry_types/surface'
+
+module OGR
+  class Polygon
+    include OGR::Geometry
+    include GeometryTypes::Surface
+
+    # @param [FFI::Pointer] geometry_ptr
+    def initialize(geometry_ptr = nil)
+      geometry_ptr ||= OGR::Geometry.create(:wkbPolygon)
+      initialize_from_pointer(geometry_ptr)
+    end
+  end
+end

data/lib/ogr/geometries/unknown_geometry.rb

@@ -0,0 +1,10 @@
+module OGR
+  class UnknownGeometry
+    include OGR::Geometry
+
+    # @param geometry_ptr [FFI::Pointer]
+    def initialize(geometry_ptr)
+      initialize_from_pointer(geometry_ptr)
+    end
+  end
+end