ffi-gdal 0.0.4 → 1.0.0.beta1

data/lib/ogr/geometry_extensions.rb

@@ -0,0 +1,60 @@
+require 'json'
+
+module OGR
+  module GeometryExtensions
+
+    # @return [Hash]
+    def as_json
+      json = {
+        coordinate_dimension: coordinate_dimension,
+        count: 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.as_json,
+        type: type_to_name,
+        wkb_size: wkb_size
+      }
+
+      json.merge!(area: area) if respond_to? :area
+      json.merge!(length: length) if respond_to? :length
+      json.merge!(points: points) if respond_to? :points
+
+      json
+    end
+
+    # @return [String]
+    def to_json
+      as_json.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 = Field.create('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

data/lib/ogr/geometry_types/collection.rb

@@ -0,0 +1,45 @@
+module OGR
+  module GeometryTypes
+    module Collection
+      def collection?
+        true
+      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::GDAL.OGR_G_GetGeometryRef(ptr, sub_geometry_index)
+        end
+      end
+
+      # Build a ring from a bunch of arcs.
+      #
+      # @param tolerance [Float]
+      # @param auto_close [Boolean]
+      # @return [OGR::Geometry]
+      def polygon_from_edges(tolerance, auto_close)
+        best_effort = false
+        ogrerr_ptr = FFI::MemoryPointer.new(:pointer)
+
+        new_geometry_ptr = FFI::GDAL.OGRBuildPolygonFromEdges(@geometry_pointer,
+          best_effort,
+          auto_close,
+          tolerance,
+          ogrerr_ptr)
+
+        ogrerr_int = ogrerr_ptr.read_int
+        ogrerr = FFI::GDAL::OGRErr[ogrerr_int]
+
+        if ogrerr == :OGRERR_FAILURE
+          raise "Couldn't create polygon"
+        end
+
+        self.class._to_geometry_type(new_geometry_ptr)
+      end
+    end
+  end
+end

data/lib/ogr/geometry_types/curve.rb

@@ -0,0 +1,120 @@
+module OGR
+  module GeometryTypes
+    module Curve
+
+      # @return [Float]
+      def x(point_number)
+        FFI::GDAL.OGR_G_GetX(@geometry_pointer, point_number)
+      end
+
+      # @return [Float]
+      def y(point_number)
+        FFI::GDAL.OGR_G_GetY(@geometry_pointer, point_number)
+      end
+
+      # @return [Float]
+      def z(point_number)
+        FFI::GDAL.OGR_G_GetZ(@geometry_pointer, point_number)
+      end
+
+      # @return [Array<Float, Float, Float>] [x, y] if 2d or [x, y, z] if 3d.
+      def point(number)
+        x_ptr = FFI::MemoryPointer.new(:double)
+        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)
+
+        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
+
+      # 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)
+        if coordinate_dimension == 3
+          FFI::GDAL.OGR_G_AddPoint(@geometry_pointer, x, y, z)
+        else
+          FFI::GDAL.OGR_G_AddPoint_2D(@geometry_pointer, x, y)
+        end
+      end
+
+      def set_point(index, x, y, z=0)
+        FFI::GDAL.OGR_G_SetPoint(@geometry_pointer, index, x, y, z)
+      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
+
+        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)
+        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|
+          point(i)
+        end
+      end
+
+      # @param geo_transform [GDAL::GeoTransform]
+      # @return [Array<Array>]
+      def pixels(geo_transform)
+        log "points count: #{point_count}"
+        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]
+        end
+      end
+
+      # @param new_count [Fixnum]
+      def point_count=(new_count)
+        FFI::GDAL.OGR_G_SetPointCount(@geometry_pointer, new_count)
+      end
+
+      # Computes the length for this geometry.  Computes area for Curve or
+      # MultiCurve objects.
+      #
+      # @return [Float] 0.0 for unsupported geometry types.
+      def length
+        FFI::GDAL.OGR_G_Length(@geometry_pointer)
+      end
+
+      def start_point
+        point(0)
+      end
+
+      def end_point
+        point(point_count - 1)
+      end
+
+      def closed?
+        start_point == end_point
+      end
+    end
+  end
+end

data/lib/ogr/geometry_types/surface.rb

@@ -0,0 +1,20 @@
+module OGR
+  module GeometryTypes
+    module Surface
+
+      # Computes area for a LinearRing, Polygon, or MultiPolygon.
+      #
+      # @return [Float] 0.0 for unsupported geometry types.
+      def area
+        FFI::GDAL.OGR_G_Area(@geometry_pointer)
+      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) }
+      end
+    end
+  end
+end

data/lib/ogr/layer.rb

@@ -0,0 +1,226 @@
+require_relative '../ffi/ogr'
+require_relative 'layer_extensions'
+require_relative 'envelope'
+require_relative 'geometry'
+require_relative 'feature'
+require_relative 'feature_definition'
+require_relative 'spatial_reference'
+require_relative 'style_table'
+
+module OGR
+  class Layer
+    include GDAL::MajorObject
+    include LayerExtensions
+
+    def initialize(layer)
+      @ogr_layer_pointer = GDAL._pointer(OGR::Layer, layer)
+      @features = []
+    end
+
+    def c_pointer
+      @ogr_layer_pointer
+    end
+
+    # @return [String]
+    def name
+      FFI::GDAL.OGR_L_GetName(@ogr_layer_pointer)
+    end
+
+    # @return [Symbol] One of OGRwkbGeometryType.
+    def geometry_type
+      FFI::GDAL.OGR_L_GetGeomType(@ogr_layer_pointer)
+    end
+
+    # TODO: per the gdal docs: "The returned pointer is to an internally owned
+    # object, and should not be altered or deleted by the caller."
+    #
+    # @return [OGR::Geometry]
+    def spatial_filter
+      return @spatial_filter if @spatial_filter
+
+      filter_pointer = FFI::GDAL.OGR_L_GetSpatialFilter(@ogr_layer_pointer)
+      return nil if filter_pointer.null?
+
+      @spatial_filter = OGR::Geometry.new(filter_pointer)
+    end
+
+    # The number of features in this layer.  If +force+ is false and it would be
+    # expensive to determine the feature count, -1 may be returned.
+    #
+    # @param force [Boolean] Force the calculation even if it's
+    #   expensive.
+    # @return [Fixnum]
+    def feature_count(force=true)
+      FFI::GDAL.OGR_L_GetFeatureCount(@ogr_layer_pointer, force)
+    end
+
+    # @param index [Fixnum] The 0-based index of the feature to get.  It should
+    #   be <= +feature_count+, but not checking is done to ensure.
+    # @return [OGR::Feature, nil]
+    def feature(index)
+      @features.fetch(index) do
+        feature_pointer = FFI::GDAL.OGR_L_GetFeature(@ogr_layer_pointer, index)
+        return nil if feature_pointer.null?
+
+        feature = OGR::Feature.new(feature_pointer)
+        @features.insert(index, feature)
+
+        feature
+      end
+    end
+
+    # The next available feature in this layer.  Only features matching the
+    # current spatial filter will be returned.  Use +reset_reading+ to start at
+    # the beginning again.
+    #
+    # @return [OGR::Feature, nil]
+    def next_feature
+      feature_pointer = FFI::GDAL.OGR_L_GetNextFeature(@ogr_layer_pointer)
+      return nil if feature_pointer.null?
+
+      OGR::Feature.new(feature_pointer)
+    end
+
+    # @return [Fixnum]
+    def features_read
+      FFI::GDAL.OGR_L_GetFeaturesRead(@ogr_layer_pointer)
+    end
+
+    # Uses the already-defined FeatureDefinition to create then write a new feature
+    # to the layer.
+    #
+    # @return [OGR::Feature]
+    def create_feature
+      feature_def = feature_definition
+      feature = OGR::Feature.create(feature_def)
+      ogr_err = FFI::GDAL.OGR_L_CreateFeature(@ogr_layer_pointer, feature.c_pointer)
+      ogr_err.to_ruby
+
+      feature
+    end
+
+    # Deletes the feature from the layer.
+    #
+    # TODO: Use OGR_L_TestCapability before trying to delete.
+    # @return +true+ if successful, otherwise raises an OGR exception.
+    def delete_feature(feature_id)
+      ogr_err = FFI::GDAL.OGR_L_DeleteFeature(@ogr_layer_pointer, feature_id)
+
+      ogr_err.to_ruby
+    end
+
+    # Creates and writes a new field to the layer.
+    #
+    # @param name [String]
+    # @param type [FFI::GDAL::OGRFieldType]
+    # @param approx_ok [Boolean] If +true+ the field may be created in a slightly
+    #   different form, depending on the limitations of the format driver.
+    # @return [OGR::Field]
+    def create_field(name, type, approx_ok=false)
+      field = OGR::Field.create(name, type)
+      ogr_err = FFI::GDAL.OGR_L_CreateField(@ogr_layer_pointer, field.c_pointer, approx_ok)
+      ogr_err.to_ruby
+
+      field
+    end
+
+    # @param field [OGR::Field, FFI::Pointer]
+    # @param approx_ok [Boolean] If +true+ the field may be created in a slightly
+    #   different form, depending on the limitations of the format driver.
+    # @return +true+ if successful, otherwise raises an OGR exception.
+    def add_field(field, approx_ok=false)
+      field_ptr = GDAL._pointer(OGR::Field, field)
+      ogr_err = FFI::GDAL.OGR_L_CreateField(@ogr_layer_pointer, field_ptr, approx_ok)
+
+      ogr_err.to_ruby
+    end
+
+    # Deletes the field definition from the layer.
+    #
+    # TODO: Use OGR_L_TestCapability before trying to delete.
+    # @return +true+ if successful, otherwise raises an OGR exception.
+    def delete_field(field_id)
+      ogr_err = FFI::GDAL.OGR_L_DeleteField(@ogr_layer_pointer, field_id)
+
+      ogr_err.to_ruby
+    end
+
+    # # Creates and writes a new geometry to the layer.
+    # #
+    # # @return [OGR::GeometryField]
+    # def create_geometry_field(approx_ok=false)
+    #   geometry_field_definition_ptr = FFI::MemoryPointer.new(:OGRGeomFieldDefnH)
+    #   ogr_err = OGR_L_CreateGeomField(@ogr_layer_pointer, geometry_field_definition_ptr)
+    #
+    #   OGR::GeometryFieldDefinition.new(geometry_field_definition_ptr)
+    # end
+
+    # Resets the sequential reading of features for this layer.
+    def reset_reading
+      FFI::GDAL.OGR_L_ResetReading(@ogr_layer_pointer)
+    end
+
+    # The schema information for this layer.
+    #
+    # @return [OGR::FeatureDefinition,nil]
+    def feature_definition
+      return @feature_definition if @feature_definition
+
+      feature_defn_pointer = FFI::GDAL.OGR_L_GetLayerDefn(@ogr_layer_pointer)
+      return nil if feature_defn_pointer.null?
+
+      @feature_definition = OGR::FeatureDefinition.new(feature_defn_pointer)
+    end
+
+    # @return [OGR::SpatialReference]
+    def spatial_reference
+      return @spatial_reference if @spatial_reference
+
+      spatial_ref_pointer = FFI::GDAL.OGR_L_GetSpatialRef(@ogr_layer_pointer)
+      return nil if spatial_ref_pointer.null?
+
+      @spatial_reference = OGR::SpatialReference.new(spatial_ref_pointer)
+    end
+
+    # @return [OGR::Envelope]
+    def extent(force=true)
+      return @envelope if @envelope
+
+      envelope = FFI::GDAL::OGREnvelope.new
+      FFI::GDAL.OGR_L_GetExtent(@ogr_layer_pointer, envelope, force)
+      return nil if envelope.null?
+
+      @envelope = OGR::Envelope.new(envelope)
+    end
+
+    # @return [OGR::Envelope]
+    def extent_by_geometry(geometry_field_index, force=true)
+      envelope = FFI::GDAL::OGREnvelope.new
+      FFI::GDAL.OGR_L_GetExtentEx(@ogr_layer_pointer, geometry_field_index, envelope, force)
+      return nil if envelope.null?
+
+      OGR::Envelope.new(envelope)
+    end
+
+    # The name of the underlying database column.  '' if not supported.
+    # @return [String]
+    def fid_column
+      FFI::GDAL.OGR_L_GetFIDColumn(@ogr_layer_pointer)
+    end
+
+    # @return [String]
+    def geometry_column
+      FFI::GDAL.OGR_L_GetGeometryColumn(@ogr_layer_pointer)
+    end
+
+    # @return [OGR::StyleTable, nil]
+    def style_table
+      return @style_table if @style_table
+
+      style_table_pointer = FFI::GDAL.OGR_L_GetStyleTable(@ogr_layer_pointer)
+      return nil if style_table_pointer.null?
+
+      @style_table = OGR::StyleTable.new(style_table_pointer)
+    end
+  end
+end