ffi-gdal 1.0.0.beta5 → 1.0.0.beta6

data/lib/ogr/geometry_field_definition.rb

@@ -21,7 +21,7 @@ module OGR
         end
 
       unless @c_pointer.is_a?(FFI::Pointer) && !@c_pointer.null?
-        fail OGR::InvalidGeometryFieldDefinition,
+        raise OGR::InvalidGeometryFieldDefinition,
           "Unable to create #{self.class.name} from #{name_or_pointer}"
       end
 
@@ -34,6 +34,8 @@ module OGR
     end
 
     def destroy!
+      return unless @c_pointer
+
       FFI::OGR::API.OGR_GFld_Destroy(@c_pointer)
       @c_pointer = nil
     end
@@ -45,7 +47,7 @@ module OGR
 
     # @param new_name [String]
     def name=(new_name)
-      fail OGR::ReadOnlyObject if @read_only
+      raise OGR::ReadOnlyObject if @read_only
 
       FFI::OGR::API.OGR_GFld_SetName(@c_pointer, new_name)
     end
@@ -57,7 +59,7 @@ module OGR
 
     # @param new_type [FFI::OGR::API::WKBGeometryType]
     def type=(new_type)
-      fail OGR::ReadOnlyObject if @read_only
+      raise OGR::ReadOnlyObject if @read_only
 
       FFI::OGR::API.OGR_GFld_SetType(@c_pointer, new_type)
     end
@@ -75,7 +77,7 @@ module OGR
 
     # @param new_spatial_reference [OGR::SpatialReference, FFI::Pointer]
     def spatial_reference=(new_spatial_reference)
-      fail OGR::ReadOnlyObject if @read_only
+      raise OGR::ReadOnlyObject if @read_only
 
       spatial_ref_ptr = GDAL._pointer(OGR::SpatialReference, new_spatial_reference)
 
@@ -91,7 +93,7 @@ module OGR
 
     # @param value [Boolean]
     def ignore=(value)
-      fail OGR::ReadOnlyObject if @read_only
+      raise OGR::ReadOnlyObject if @read_only
 
       FFI::OGR::API.OGR_GFld_SetIgnored(@c_pointer, value)
     end

data/lib/ogr/geometry_mixins/container_mixins.rb

@@ -0,0 +1,23 @@
+module OGR
+  module GeometryMixins
+    module ContainerMixins
+      include Enumerable
+
+      # Iterates over each geometry in the container geometry. Per OGR docs, the
+      # yielded geometry should not be modified; if you need to do something to
+      # that geometry, you should {{#clone}} it. Additionally, the yielded
+      # geometry is only valid until the containing changes.
+      #
+      # @yieldparam [OGR::Geometry]
+      # @return [Enumerator]
+      # @see http://gdal.org/1.11/ogr/ogr__api_8h.html#a6bac93150529a5c98811db29e289dd66
+      def each
+        return enum_for(:each) unless block_given?
+
+        geometry_count.times do |i|
+          yield geometry_at(i)
+        end
+      end
+    end
+  end
+end

data/lib/ogr/geometry_mixins/extensions.rb

@@ -0,0 +1,111 @@
+require 'json'
+
+module OGR
+  module GeometryMixins
+    module Extensions
+      # @return [Fixnum] The number of the UTM zone this geometry belongs to.
+      def utm_zone
+        return unless spatial_reference
+
+        if spatial_reference.authority_code == '4326'.freeze
+          self_as_4326 = self
+        else
+          self_as_4326 = dup
+          self_as_4326.transform_to!(OGR::SpatialReference.new_from_epsg(4326))
+        end
+
+        self_as_4326 = self_as_4326.buffer(0) unless self_as_4326.valid?
+
+        return unless self_as_4326.point_on_surface.x
+
+        ((self_as_4326.point_on_surface.x + 180) / 6.to_f).floor + 1
+      end
+
+      # @return [Boolean]
+      def container?
+        self.class.ancestors.include? OGR::GeometryTypes::Container
+      end
+
+      # @return [Boolean]
+      def curve?
+        self.class.ancestors.include? OGR::GeometryTypes::Curve
+      end
+
+      # @return [Boolean]
+      def surface?
+        self.class.ancestors.include? OGR::GeometryTypes::Surface
+      end
+
+      def !=(other)
+        !equals?(other)
+      end
+
+      def is_2d?
+        coordinate_dimension == 2
+      end
+
+      def is_3d?
+        coordinate_dimension == 3
+      end
+
+      # @return [Boolean]
+      def invalid?
+        !valid?
+      end
+
+      # @return [Hash]
+      def as_json(options = nil)
+        json = {
+          coordinate_dimension: coordinate_dimension,
+          geometry_count: geometry_count,
+          dimension: dimension,
+          is_empty: empty?,
+          is_ring: ring?,
+          is_simple: simple?,
+          is_valid: valid?,
+          name: name,
+          point_count: point_count,
+          spatial_reference: spatial_reference.nil? ? nil : spatial_reference.as_json(options),
+          type: type_to_name,
+          wkb_size: wkb_size
+        }
+
+        json[:area] = area if respond_to? :area
+        json[:length] = length if respond_to? :length
+        json[:points] = points if respond_to? :points
+
+        json
+      end
+
+      # @return [String]
+      def to_json(options = nil)
+        as_json(options).to_json
+      end
+
+      def collection?
+        false
+      end
+
+      def to_vector(file_name, driver, layer_name: 'vectorized_geometry', spatial_reference: nil)
+        driver = OGR::Driver.by_name(driver)
+
+        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)
+
+        # field = FieldDefinition.new('Name', :OFTString)
+        # field.width = 32
+
+        unless layer
+          raise OGR::InvalidLayer, "Unable to create layer '#{layer_name}'."
+        end
+
+        feature = layer.create_feature(layer_name)
+        feature.geometry = self
+
+        data_source
+      end
+    end
+  end
+end

data/lib/ogr/geometry_types/container.rb

@@ -1,6 +1,10 @@
+require_relative '../geometry_mixins/container_mixins'
+
 module OGR
   module GeometryTypes
     module Container
+      include OGR::GeometryMixins::ContainerMixins
+
       def collection?
         true
       end
@@ -21,7 +25,7 @@ module OGR
 
       # @param sub_geometry [OGR::Geometry, FFI::Pointer]
       # @return +true+ if successful, otherwise raises an OGR exception.
-      def add_directly(sub_geometry)
+      def add_geometry_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)
 
@@ -43,10 +47,13 @@ module OGR
       # @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)
+        build_geometry do
+          tmp_ptr = FFI::OGR::API.OGR_G_GetGeometryRef(@c_pointer, sub_geometry_index)
+          tmp_ptr.autorelease = false
+          tmp_ptr.null? ? nil : FFI::OGR::API.OGR_G_Clone(tmp_ptr)
         end
       end
+      alias geometry_ref geometry_at
 
       # Build a ring from a bunch of arcs.  The collection must be
       # a MultiLineString or GeometryCollection.

data/lib/ogr/geometry_types/curve.rb

@@ -16,6 +16,7 @@ module OGR
         FFI::OGR::API.OGR_G_GetZ(@c_pointer, point_number)
       end
 
+      # @param [Fixnum] Index of the point to get.
       # @return [Array<Float, Float, Float>] [x, y] if 2d or [x, y, z] if 3d.
       def point(number)
         x_ptr = FFI::MemoryPointer.new(:double)
@@ -30,6 +31,22 @@ module OGR
           [x_ptr.read_double, y_ptr.read_double, z_ptr.read_double]
         end
       end
+      alias get_point point
+
+      # It seems as if {{#point}} should return an OGR::Point, but since OGR's
+      # OGR_G_GetPoint only returns coordinates, this allows getting the point
+      # as an OGR::Point.
+      #
+      # @param [Fixnum] Index of the point to get.
+      # @return [OGR::Point]
+      # TODO: Move to an extension.
+      def point_geometry(number)
+        coords = point(number)
+        point = OGR::Point.new
+        point.set_point(0, *coords)
+
+        point
+      end
 
       # Adds a point to a LineString or Point geometry.
       #
@@ -44,38 +61,66 @@ module OGR
         end
       end
 
-      def set_point(index, x, y, z = 0)
-        FFI::OGR::API.OGR_G_SetPoint(@c_pointer, index, x, y, z)
+      # @param index [Fixnum] The index of the vertex to assign.
+      # @param x [Number]
+      # @param y [Number]
+      # @param z [Number]
+      def set_point(index, x, y, z = nil)
+        if is_3d?
+          FFI::OGR::API.OGR_G_SetPoint(@c_pointer, index, x, y, z)
+        else
+          FFI::OGR::API.OGR_G_SetPoint_2D(@c_pointer, index, x, y)
+        end
       end
 
-      # @return [Array<Array>] An array of (x, y) or (x, y, z) points.
-      def points
-        x_stride = 2
-        y_stride = 2
-        z_stride = coordinate_dimension == 3 ? 1 : 0
+      # @return [Enumerator]
+      # @yieldparam [OGR::Point]
+      # TODO: Move to an extension.
+      def each_point_geometry
+        return enum_for(:each_point_as_geometry) unless block_given?
 
-        buffer_size = FFI::Type::DOUBLE.size * 2 * point_count
+        point_count.times do |point_num|
+          yield point_as_geometry(point_num)
+        end
+      end
 
+      # @return [Array<OGR::Point>]
+      # @see {{#each_point_geometry}}, {{#point_geometry}}
+      # TODO: Move to an extension.
+      def point_geometries
+        each_point_geometry.to_a
+      end
+
+      # @return [Array<Array<Float>>] An array of (x, y) or (x, y, z) points.
+      def points
+        x_stride = FFI::Type::DOUBLE.size
+        y_stride = FFI::Type::DOUBLE.size
+        z_stride = coordinate_dimension == 3 ? FFI::Type::DOUBLE.size : 0
+
+        buffer_size = point_count
         x_buffer = FFI::MemoryPointer.new(:buffer_out, buffer_size)
         y_buffer = FFI::MemoryPointer.new(:buffer_out, buffer_size)
+        z_buffer = FFI::MemoryPointer.new(:buffer_out, buffer_size) if coordinate_dimension == 3
+
+        FFI::OGR::API.OGR_G_GetPoints(@c_pointer,
+          x_buffer, x_stride, y_buffer,
+          y_stride, z_buffer, z_stride)
 
-        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)
-
-        num_points.times.map do |i|
-          point(i)
+        log 'Got different number of points than point_count in #point_values' unless num_points == point_count
+
+        x_array = x_buffer.read_array_of_double(buffer_size)
+        y_array = y_buffer.read_array_of_double(buffer_size)
+
+        if z_buffer
+          z_array = z_buffer.read_array_of_double(buffer_size)
+
+          [x_array, y_array, z_array].transpose
+        else
+          [x_array, y_array].transpose
         end
       end
+      alias get_points points
+      alias point_values points
 
       # @param geo_transform [GDAL::GeoTransform]
       # @return [Array<Array>]

data/lib/ogr/geometry_types/surface.rb

@@ -1,5 +1,3 @@
-require_relative '../../ffi/ogr/api'
-
 module OGR
   module GeometryTypes
     module Surface
@@ -17,13 +15,6 @@ module OGR
       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::OGR::API.OGR_G_PointOnSurface(ptr) }
-      end
     end
   end
 end

data/lib/ogr/internal_helpers.rb

@@ -15,7 +15,7 @@ module OGR
         case flag
         when 'w' then true
         when 'r' then false
-        else fail "Invalid access_flag '#{flag}'.  Use 'r' or 'w'."
+        else raise "Invalid access_flag '#{flag}'.  Use 'r' or 'w'."
         end
       end
 
@@ -32,7 +32,7 @@ module OGR
         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}"
+        else raise "Unable to process time zone: #{time_zone}"
         end
       end
 
@@ -45,7 +45,7 @@ module OGR
       #
       # @param time_zone [String]
       def _format_time_zone_for_ogr(time_zone)
-        if time_zone =~ /GMT/
+        if time_zone =~ /(00:00|GMT)\z/
           100
         elsif time_zone
           1

data/lib/ogr/layer.rb

@@ -1,6 +1,5 @@
-require_relative '../ffi/ogr'
-require_relative '../gdal/major_object'
-require_relative 'envelope'
+require_relative '../ogr'
+require_relative '../gdal'
 require_relative 'layer_mixins/extensions'
 require_relative 'layer_mixins/capability_methods'
 require_relative 'layer_mixins/ogr_feature_methods'
@@ -12,6 +11,7 @@ require_relative 'layer_mixins/ogr_sql_methods'
 module OGR
   class Layer
     include GDAL::MajorObject
+    include GDAL::Logger
     include LayerMixins::Extensions
     include LayerMixins::CapabilityMethods
     include LayerMixins::OGRFeatureMethods
@@ -28,7 +28,6 @@ module OGR
     # @param layer_ptr [FFI::Pointer]
     def initialize(layer_ptr)
       @c_pointer = layer_ptr
-      @features = []
     end
 
     # @return [String]
@@ -97,7 +96,7 @@ module OGR
     # @param new_style_table [OGR::StyleTable, FFI::pointer]
     def style_table=(new_style_table)
       style_table_ptr = GDAL._pointer(OGR::StyleTable, new_style_table)
-      fail OGR::Failure if style_table_ptr.nil? || style_table_ptr.null?
+      raise OGR::Failure if style_table_ptr.nil? || style_table_ptr.null?
 
       FFI::OGR::API.OGR_L_SetStyleTable(@c_pointer, style_table_ptr)
     end