ffi-ogr 0.0.1.pre

data/README.md

@@ -0,0 +1,72 @@
+ffi-ogr
+... for convenient access to OGR functionality from Ruby
+
+To run: `bin/ogr_console`
+
+To read a shapefile:
+
+```ruby
+
+shp = OGR::ShpReader.new.read './spec/data/ne_110m_coastline/ne_110m_coastline.shp'
+# => #<OGR::DataSource:0x007fba4d19c328 @ds=#<FFI::AutoPointer address=0x007fba4c4cdc50>>
+
+shp.to_geojson
+# => geojson feature collection from Shapefile
+
+shp.to_geojson true
+# => "pretty print" geojson feature collection from Shapefile
+```
+
+A reader may also be inferred by file extension (currently works for shp and json/geojson):
+
+```ruby
+
+shp = OGR::Reader.from_file_type './spec/data/ne_110m_coastline/ne_110m_coastline.shp'
+
+```
+
+To create a shapefile:
+
+```ruby
+
+writer = OGR::ShpWriter.new
+writer.set_output '~/Documents/shapefiles/my_new.shp'
+
+shp = writer.ds
+
+# add layer to shp : add_layer(name, geometry_type, spatial_reference)
+# currently does not handle spatial reference, will automatically be nil
+layer = shp.add_layer 'first_layer', :point
+
+# add field to layer : add_field(name, field_type, width) NOTE: width defaults to 32
+layer.add_field 'name', :string
+
+# create feature on layer
+feature = layer.create_feature
+
+# add field value to feature : set_field_value(field_name, field_value, field_type) NOTE: type can be inferred
+feature.set_field_value 'name', 'my_feature'
+
+# create point
+point = OGR::Point.create [-104.789322, 38.992961]
+
+# add point to first_feature
+feature.add_geometry point
+
+# add feature to first_layer
+layer.add_feature feature
+
+# sync to disk
+layer.sync
+
+```
+
+A writer may also be inferred by file extension (currently works for shp and json/geojson):
+
+```ruby
+
+writer = OGR::Writer.from_file_type '~/Documents/shapefiles/my_new.shp'
+
+```
+
+Tested on: MRI 1.9.3-p392 and JRuby 1.7.3

data/bin/ogr_console

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'ffi-ogr'))
+require 'irb'
+
+IRB.start

data/lib/ffi-ogr/data_source.rb

@@ -0,0 +1,55 @@
+module OGR
+  class DataSource
+    include FFIOGR
+
+    attr_accessor :ds
+
+    def initialize(ptr=nil, auto_free=true)
+      @ds = FFI::AutoPointer.new(ptr, self.class.method(:release))
+      @ds.autorelease = auto_free
+    end
+
+    def self.release(ptr)
+      FFIOGR.OGR_DS_Destroy(ptr)
+    end
+
+    def add_layer(name, geometry_type, spatial_ref=nil, options={})
+      # need to add spatial reference mapping
+      # need to add options as StringList ...
+      layer = FFIOGR.OGR_DS_CreateLayer(@ds, name, spatial_ref, geometry_type.to_sym, nil)
+      OGR::Tools.cast_layer(layer)
+    end
+
+    def get_layers
+      layers = []
+
+      num_layers = OGR_DS_GetLayerCount(@ds)
+
+      for i in (0...num_layers) do
+        layers << OGR::Tools.cast_layer(OGR_DS_GetLayer(@ds, i))
+      end
+
+      layers
+    end
+    alias_method :layers, :get_layers
+
+    def get_features
+      layers.map {|l| l.features}.first
+    end
+    alias_method :features, :get_features
+
+    def get_geometries
+      features.map {|f| OGR::Tools.cast_geometry(f.geometry)}
+    end
+    alias_method :geometries, :get_geometries
+
+    def get_fields
+      features.map {|f| f.fields}
+    end
+    alias_method :fields, :get_fields
+
+    def to_geojson(pretty=false)
+      MultiJson.dump({type: 'FeatureCollection', features: features.map {|f| f.to_geojson}}, pretty: pretty)
+    end
+  end
+end

data/lib/ffi-ogr/feature.rb

@@ -0,0 +1,79 @@
+module OGR
+  class Feature
+    attr_accessor :ptr
+
+    def initialize(ptr, auto_free=true)
+      @ptr = FFI::AutoPointer.new(ptr, self.class.method(:release))
+      @ptr.autorelease = auto_free
+    end
+
+    def self.release(ptr)
+      FFIOGR.OGR_F_Destroy(ptr)
+    end
+
+    def set_field_value(name, value, field_type=nil)
+      field_index = FFIOGR.OGR_F_GetFieldIndex(@ptr, name)
+
+      unless field_type.nil?
+        field_type = field_type.to_sym
+      else
+        field_definition = FFIOGR.OGR_F_GetFieldDefnRef(@ptr, field_index)
+        field_type = FFIOGR.OGR_Fld_GetType(field_definition)
+      end
+
+      case field_type
+      when :integer
+        FFIOGR.OGR_F_SetFieldInteger(@ptr, field_index, Integer(value))
+      when :real
+        FFIOGR.OGR_F_SetFieldDouble(@ptr, field_index, Float(value))
+      when :string
+        FFIOGR.OGR_F_SetFieldString(@ptr, field_index, String(value))
+      when :binary
+        FFIOGR.OGR_F_SetFieldBinary(@ptr, field_index, to_binary(value))
+      end
+    end
+
+    def add_geometry(geometry)
+      FFIOGR.OGR_F_SetGeometry(@ptr, geometry.ptr)
+      #FFIOGR.OGR_F_SetGeometryDirectly(@ptr, geometry.ptr)
+    end
+
+    def get_geometry
+      FFIOGR.OGR_F_GetGeometryRef(@ptr)
+    end
+    alias_method :geometry, :get_geometry
+
+    def get_field_count
+      FFIOGR.OGR_F_GetFieldCount(@ptr)
+    end
+    alias_method :field_count, :get_field_count
+
+    def get_fields
+      fields = {}
+
+      for i in (0...field_count)
+        fd = FFIOGR.OGR_F_GetFieldDefnRef(@ptr, i)
+        field_name = FFIOGR.OGR_Fld_GetNameRef(fd)
+        field_type = FFIOGR.OGR_Fld_GetType(fd)
+
+        case field_type
+        when :integer
+          field_value = FFIOGR.OGR_F_GetFieldAsInteger(@ptr, i)
+        when :real
+          field_value = FFIOGR.OGR_F_GetFieldAsDouble(@ptr, i)
+        else
+          field_value = FFIOGR.OGR_F_GetFieldAsString(@ptr, i)
+        end
+
+        fields[field_name] = field_value
+      end
+
+      fields
+    end
+    alias_method :fields, :get_fields
+
+    def to_geojson
+      {type: 'Feature', geometry: OGR::Tools.cast_geometry(geometry).to_geojson, properties: fields}
+    end
+  end
+end

data/lib/ffi-ogr/generic_reader.rb

@@ -0,0 +1,9 @@
+module OGR
+  class GenericReader < Reader
+    def initialize(driver_name)
+      OGRRegisterAll()
+      @driver = OGRGetDriverByName(driver_name)
+      raise RuntimeError.new("Invalid driver name") if @driver.null?
+    end
+  end
+end

data/lib/ffi-ogr/generic_writer.rb

@@ -0,0 +1,9 @@
+module OGR
+  class GenericWriter < Writer
+    def initialize(driver_name)
+      OGRRegisterAll()
+      @driver = OGRGetDriverByName(driver_name)
+      raise RuntimeError.new("Invalid driver name") if @driver.null?
+    end
+  end
+end

data/lib/ffi-ogr/geo_json.rb

@@ -0,0 +1,5 @@
+module OGR
+  class GeoJSON < DataSource
+    # GeoJSON
+  end
+end

data/lib/ffi-ogr/geo_json_reader.rb

@@ -0,0 +1,8 @@
+module OGR
+  class GeoJSONReader < Reader
+    def initialize
+      OGRRegisterAll()
+      @driver = OGRGetDriverByName("GeoJSON")
+    end
+  end
+end

data/lib/ffi-ogr/geo_json_writer.rb

@@ -0,0 +1,8 @@
+module OGR
+  class GeoJSONWriter < Writer
+    def initialize
+      OGRRegisterAll()
+      @driver = OGRGetDriverByName("GeoJSON")
+    end
+  end
+end

data/lib/ffi-ogr/geometry.rb

@@ -0,0 +1,84 @@
+module OGR
+  class Geometry
+    attr_reader :ptr
+
+    def initialize(ptr, auto_free=true)
+      @ptr = FFI::AutoPointer.new(ptr, self.class.method(:release))
+      #@ptr.autorelease = auto_free
+    end
+
+    def self.release(ptr);end
+
+    def self.create_empty(geometry_type)
+      OGR::Tools.cast_geometry(FFIOGR.OGR_G_CreateGeometry(geometry_type))
+    end
+
+    def add_geometry(geometry)
+      FFIOGR.OGR_G_AddGeometry(@ptr, geometry.ptr)
+      #FFIOGR.OGR_G_AddGeometryDirectly(@ptr, geometry.ptr)
+    end
+
+    def add_point(coords)
+      raise RuntimeError.new("Invalid coordinate(s) specified") unless coords.size >= 2
+      x = Float(coords[0])
+      y = Float(coords[1])
+      z = Float(coords[2]) if coords.size >= 3
+
+      unless z
+        FFIOGR.OGR_G_AddPoint_2D(@ptr, x, y)
+      else
+        FFIOGR.OGR_G_AddPoint(@ptr, x, y, z)
+      end
+    end
+
+    def set_point(coords, idx)
+      raise RuntimeError.new("Invalid coordinate(s) specified") unless coords.size >= 2
+      x = Float(coords[0])
+      y = Float(coords[1])
+      z = Float(coords[2]) if coords.size >= 3
+
+      unless z
+        FFIOGR.OGR_G_SetPoint_2D(@ptr, idx, x, y)
+      else
+        FFIOGR.OGR_G_SetPoint(@ptr, idx, x, y, z)
+      end
+    end
+
+    def flatten
+      FFIOGR.OGR_G_FlattenTo2D(@ptr)
+    end
+
+    def get_geometry_type
+      FFIOGR.OGR_G_GetGeometryType(@ptr)
+    end
+    alias_method :geometry_type, :get_geometry_type
+
+    def get_length
+      FFIOGR.OGR_G_Length(@ptr)
+    end
+    alias_method :length, :get_length
+
+    def get_area
+      FFIOGR.OGR_G_Area(@ptr)
+    end
+    alias_method :area, :get_area
+
+    def get_boundary
+      FFIOGR.OGR_G_Boundary(@ptr)
+    end
+    alias_method :boundary, :get_boundary
+
+    def to_geojson
+      MultiJson.load(FFIOGR.OGR_G_ExportToJson(@ptr))
+    end
+
+    def to_kml(elevation=nil)
+      elevation = String(elevation) unless elevation.nil?
+      FFIOGR.OGR_G_ExportToKML(@ptr, elevation)
+    end
+
+    def to_gml
+      FFIOGR.OGR_G_ExportToGML(@ptr)
+    end
+  end
+end

data/lib/ffi-ogr/geometry_collection.rb

@@ -0,0 +1,15 @@
+module OGR
+  class GeometryCollection < Geometry
+    def self.create(geometries)
+      geometry_collection = OGR::Tools.cast_geometry(FFIOGR.OGR_G_CreateGeometry(:geometry_collection))
+
+      if geometries.size > 0
+        geometries.each do |geometry|
+          geometry_collection.add_geometry(geometry)
+        end
+      end
+
+      geometry_collection
+    end
+  end
+end

data/lib/ffi-ogr/geometry_collection_25d.rb

@@ -0,0 +1,15 @@
+module OGR
+  class GeometryCollection25D < Geometry
+    def self.create(geometries)
+      geometry_collection = OGR::Tools.cast_geometry(FFIOGR.OGR_G_CreateGeometry(:geometry_collection_25d))
+
+      if geometries.size > 0
+        geometries.each do |geometry|
+          geometry_collection.add_geometry(geometry)
+        end
+      end
+
+      geometry_collection
+    end
+  end
+end

data/lib/ffi-ogr/layer.rb

@@ -0,0 +1,48 @@
+module OGR
+  class Layer
+    attr_accessor :ptr, :name, :geometry_type
+
+    def initialize(ptr, auto_free=true)
+      @ptr = FFI::AutoPointer.new(ptr, self.class.method(:release))
+      @name = FFIOGR.OGR_L_GetName(@ptr)
+      @geometry_type = FFIOGR.OGR_L_GetGeomType(@ptr)
+      #@ptr.autorelease = auto_free
+    end
+
+    def self.release(ptr);end
+
+    def sync
+      FFIOGR.OGR_L_SyncToDisk(@ptr)
+    end
+
+    def add_field(name, field_type, field_width=32)
+      field = FFIOGR.OGR_Fld_Create(name, field_type.to_sym)
+      FFIOGR.OGR_Fld_SetWidth(field, field_width)
+      FFIOGR.OGR_L_CreateField(@ptr, field, 1)
+      FFIOGR.OGR_Fld_Destroy(field)
+    end
+
+    def create_feature
+      feature = FFIOGR.OGR_F_Create(FFIOGR.OGR_L_GetLayerDefn(@ptr))
+      OGR::Tools.cast_feature(feature)
+    end
+
+    def add_feature(feature)
+      FFIOGR.OGR_L_CreateFeature(@ptr, feature.ptr)
+    end
+
+    def get_features
+      features = []
+
+      FFIOGR.OGR_L_ResetReading(@ptr)
+      num_features = FFIOGR.OGR_L_GetFeatureCount(@ptr, 0)
+
+      for i in (0...num_features) do
+        features << OGR::Tools.cast_feature(FFIOGR.OGR_L_GetNextFeature(@ptr))
+      end
+
+      features
+    end
+    alias_method :features, :get_features
+  end
+end

data/lib/ffi-ogr/line_string.rb

@@ -0,0 +1,13 @@
+module OGR
+  class LineString < Geometry
+    def self.create(points)
+      ls = OGR::Tools.cast_geometry(FFIOGR.OGR_G_CreateGeometry(:line_string))
+
+      points.each do |point|
+        ls.add_point(point)
+      end
+
+      ls
+    end
+  end
+end

data/lib/ffi-ogr/line_string_25d.rb

@@ -0,0 +1,13 @@
+module OGR
+  class LineString25D < Geometry
+    def self.create(points)
+      ls = OGR::Tools.cast_geometry(FFIOGR.OGR_G_CreateGeometry(:line_string_25d))
+
+      points.each do |point|
+        ls.add_point(point)
+      end
+
+      ls
+    end
+  end
+end

data/lib/ffi-ogr/linear_ring.rb

@@ -0,0 +1,15 @@
+module OGR
+  class LinearRing < Geometry
+    def self.create(points)
+      points << points.first unless points.first == points.last
+
+      lr = OGR::Tools.cast_geometry(FFIOGR.OGR_G_CreateGeometry(:linear_ring))
+
+      points.each do |point|
+        lr.add_point(point)
+      end
+
+      lr
+    end
+  end
+end

data/lib/ffi-ogr/multi_line_string.rb

@@ -0,0 +1,14 @@
+module OGR
+  class MultiLineString < Geometry
+    def self.create(line_strings)
+      multi_line_string = OGR::Tools.cast_geometry(FFIOGR.OGR_G_CreateGeometry(:multi_line_string))
+
+      line_strings.each do |line_string|
+        ls = OGR::LineString.create(line_string)
+        multi_line_string.add_geometry(ls)
+      end
+
+      multi_line_string
+    end
+  end
+end

data/lib/ffi-ogr/multi_line_string_25d.rb

@@ -0,0 +1,14 @@
+module OGR
+  class MultiLineString25D < Geometry
+    def self.create(line_strings)
+      multi_line_string = OGR::Tools.cast_geometry(FFIOGR.OGR_G_CreateGeometry(:multi_line_string_25d))
+
+      line_strings.each do |line_string|
+        ls = OGR::LineString.create(line_string)
+        multi_line_string.add_geometry(ls)
+      end
+
+      multi_line_string
+    end
+  end
+end

data/lib/ffi-ogr/multi_point.rb

@@ -0,0 +1,14 @@
+module OGR
+  class MultiPoint < Geometry
+    def self.create(points)
+      multi_point = OGR::Tools.cast_geometry(FFIOGR.OGR_G_CreateGeometry(:multi_point))
+
+      points.each do |point|
+        pt = OGR::Point.create(point)
+        multi_point.add_geometry(pt)
+      end
+
+      multi_point
+    end
+  end
+end

data/lib/ffi-ogr/multi_point_25d.rb

@@ -0,0 +1,14 @@
+module OGR
+  class MultiPoint25D < Geometry
+    def self.create(points)
+      multi_point = OGR::Tools.cast_geometry(FFIOGR.OGR_G_CreateGeometry(:multi_point_25d))
+
+      points.each do |point|
+        pt = OGR::Point.create(point)
+        multi_point.add_geometry(pt)
+      end
+
+      multi_point
+    end
+  end
+end

data/lib/ffi-ogr/multi_polygon.rb

@@ -0,0 +1,14 @@
+module OGR
+  class MultiPolygon < Geometry
+    def self.create(polygons)
+      multi_polygon = OGR::Tools.cast_geometry(FFIOGR.OGR_G_CreateGeometry(:multi_polygon))
+
+      polygons.each do |polygon|
+        poly = OGR::Polygon.create(polygon)
+        multi_polygon.add_geometry(poly)
+      end
+
+      multi_polygon
+    end
+  end
+end

data/lib/ffi-ogr/multi_polygon_25d.rb

@@ -0,0 +1,14 @@
+module OGR
+  class MultiPolygon25D < Geometry
+    def self.create(polygons)
+      multi_polygon = OGR::Tools.cast_geometry(FFIOGR.OGR_G_CreateGeometry(:multi_polygon_25d))
+
+      polygons.each do |polygon|
+        poly = OGR::Polygon.create(polygon)
+        multi_polygon.add_geometry(poly)
+      end
+
+      multi_polygon
+    end
+  end
+end

data/lib/ffi-ogr/point.rb

@@ -0,0 +1,24 @@
+module OGR
+  class Point < Geometry
+    def self.create(coords)
+      point = OGR::Tools.cast_geometry(FFIOGR.OGR_G_CreateGeometry(:point))
+      point.add_point(coords)
+      point
+    end
+
+    def get_x
+      FFIOGR.OGR_G_GetX(@ptr, 0)
+    end
+    alias_method :x, :get_x
+
+    def get_y
+      FFIOGR.OGR_G_GetY(@ptr, 0)
+    end
+    alias_method :y, :get_y
+
+    def get_z
+      FFIOGR.OGR_G_GetZ(@ptr, 0)
+    end
+    alias_method :z, :get_z
+  end
+end

data/lib/ffi-ogr/point_25d.rb

@@ -0,0 +1,9 @@
+module OGR
+  class Point25D < Geometry
+    def self.create(coords)
+      point = OGR::Tools.cast_geometry(FFIOGR.OGR_G_CreateGeometry(:point_25d))
+      point.add_point(coords)
+      point
+    end
+  end
+end

data/lib/ffi-ogr/polygon.rb

@@ -0,0 +1,14 @@
+module OGR
+  class Polygon < Geometry
+    def self.create(rings)
+      polygon = OGR::Tools.cast_geometry(FFIOGR.OGR_G_CreateGeometry(:polygon))
+
+      rings.each do |ring|
+        lr = LinearRing.create(ring)
+        polygon.add_geometry(lr)
+      end
+
+      polygon
+    end
+  end
+end

data/lib/ffi-ogr/polygon_25d.rb

@@ -0,0 +1,14 @@
+module OGR
+  class Polygon25D < Geometry
+    def self.create(rings)
+      polygon = OGR::Tools.cast_geometry(FFIOGR.OGR_G_CreateGeometry(:polygon_25d))
+
+      rings.each do |ring|
+        lr = LinearRing.create(ring)
+        polygon.add_geometry(lr)
+      end
+
+      polygon
+    end
+  end
+end

data/lib/ffi-ogr/reader.rb

@@ -0,0 +1,33 @@
+module OGR
+  class Reader
+    include OGR::FFIOGR
+
+    TF_MAP = {
+      true => 1,
+      false => 0,
+      1 => true,
+      0 => false
+    }
+
+    # Reader Class NOT to be used directly
+    # Use subclasses e.g. ShpReader
+    def initialize;end
+
+    def self.from_file_type(path)
+      path = File.expand_path(path)
+
+      if path =~ /.shp/
+        ShpReader.new
+      elsif path =~ /.geojson|.json/
+        GeoJSONReader.new
+      else
+        raise RuntimeError.new("Could not determine appropriate reader for this file type")
+      end
+    end
+
+    def read(file_path, writeable=false)
+      ds = OGR_Dr_Open(@driver, File.expand_path(file_path), TF_MAP[writeable])
+      OGR::Tools.cast_data_source(ds)
+    end
+  end
+end

data/lib/ffi-ogr/shapefile.rb

@@ -0,0 +1,5 @@
+module OGR
+  class Shapefile < DataSource
+    # Shapefile
+  end
+end

data/lib/ffi-ogr/shp_reader.rb

@@ -0,0 +1,8 @@
+module OGR
+  class ShpReader < Reader
+    def initialize
+      OGRRegisterAll()
+      @driver = OGRGetDriverByName("ESRI Shapefile")
+    end
+  end
+end

data/lib/ffi-ogr/shp_writer.rb

@@ -0,0 +1,8 @@
+module OGR
+  class ShpWriter < Writer
+    def initialize
+      OGRRegisterAll()
+      @driver = OGRGetDriverByName("ESRI Shapefile")
+    end
+  end
+end

data/lib/ffi-ogr/tools.rb

@@ -0,0 +1,65 @@
+module OGR
+  module Tools
+    class << self
+      def cast_data_source(ds_ptr, options={})
+        options = {auto_free: true}.merge(options)
+        raise RuntimeError.new("Data Source pointer is NULL") if ds_ptr.null?
+        DataSource.new ds_ptr, options[:auto_free]
+      end
+
+      def cast_layer(l_ptr, options={})
+        options = {auto_free: true}.merge(options)
+        raise RuntimeError.new("Layer pointer is NULL") if l_ptr.null?
+        Layer.new l_ptr, options[:aut_free]
+      end
+
+      def cast_feature(f_ptr, options={})
+        options = {auto_free: true}.merge(options)
+        raise RuntimeError.new("Feature pointer is NULL") if f_ptr.null?
+        Feature.new f_ptr, options[:auto_free]
+      end
+
+      def cast_geometry(geom_ptr, options={})
+        options = {auto_free: true}.merge(options)
+        raise RuntimeError.new("Geometry pointer is NULL") if geom_ptr.null?
+
+        geom_type = FFIOGR.OGR_G_GetGeometryType(geom_ptr)
+
+        klass = case geom_type
+        when :point
+          OGR::Point
+        when :line_string
+          OGR::LineString
+        when :polygon
+          OGR::Polygon
+        when :multi_point
+          OGR::MultiPoint
+        when :multi_line_string
+          OGR::MultiLineString
+        when :multi_polygon
+          OGR::MultiPolygon
+        when :geometry_collection
+          OGR::GeometryCollection
+        when :linear_ring
+          OGR::LinearRing
+        when :point_25d
+          OGR::Point25D
+        when :line_string_25d
+          OGR::LineString25D
+        when :polygon_25d
+          OGR::Polygon25D
+        when :multi_point_25d
+          OGR::MultiPoint25D
+        when :multi_line_string_25d
+          OGR::MultiLineString25D
+        when :multi_polygon_25d
+          OGR::MultiPolygon25D
+        when :geometry_collection_25d
+          OGR::GeometryCollection25D
+        end
+
+        klass.new(geom_ptr, options[:auto_free])
+      end
+    end
+  end
+end

data/lib/ffi-ogr/version.rb

@@ -0,0 +1,3 @@
+module OGR
+  VERSION = '0.0.1.pre'
+end

data/lib/ffi-ogr/writer.rb

@@ -0,0 +1,42 @@
+module OGR
+  class Writer
+    include OGR::FFIOGR
+
+    attr_accessor :ds
+
+    def initialize;end
+
+    def set_output(path, options={})
+      path = File.expand_path(path)
+      ds = OGR_Dr_CreateDataSource(@driver, path, nil)
+      @ds = OGR::Tools.cast_data_source(ds)
+      @ds
+    end
+
+    def self.from_file_type(path)
+      path = File.expand_path(path)
+
+      unless File.exists? path
+        if path =~ /.shp/
+          writer = ShpWriter.new
+        elsif path =~ /.geojson|.json/
+          writer = GeoJSONWriter.new
+        else
+          raise RuntimeError.new("Could not determine appropriate writer for this file type")
+        end
+
+        writer.set_output(path)
+        writer
+      else
+        raise RuntimeError.new("Path already exists: #{path}")
+      end
+    end
+
+    def export(output_path)
+      writer = Writer.from_file_type output_path
+      data_source = writer.ds
+
+      # @ds -> data_source
+    end
+  end
+end

data/lib/ffi-ogr.rb

@@ -0,0 +1,291 @@
+require 'ffi'
+require 'multi_json'
+
+module OGR
+  OGR_BASE = File.join(File.dirname(__FILE__), 'ffi-ogr')
+
+  autoload :Reader, File.join(OGR_BASE, 'reader')
+  autoload :GenericReader, File.join(OGR_BASE, 'generic_reader')
+  autoload :ShpReader, File.join(OGR_BASE, 'shp_reader')
+  autoload :GeoJSONReader, File.join(OGR_BASE, 'geo_json_reader')
+  autoload :Writer, File.join(OGR_BASE, 'writer')
+  autoload :GenericWriter, File.join(OGR_BASE, 'generic_writer')
+  autoload :ShpWriter, File.join(OGR_BASE, 'shp_writer')
+  autoload :GeoJSONWriter, File.join(OGR_BASE, 'geo_json_writer')
+  autoload :DataSource, File.join(OGR_BASE, 'data_source')
+  autoload :Shapefile, File.join(OGR_BASE, 'shapefile')
+  autoload :GeoJSON, File.join(OGR_BASE, 'geo_json')
+  autoload :Tools, File.join(OGR_BASE, 'tools')
+  autoload :Layer, File.join(OGR_BASE, 'layer')
+  autoload :Feature, File.join(OGR_BASE, 'feature')
+  autoload :Geometry, File.join(OGR_BASE, 'geometry')
+  autoload :Point, File.join(OGR_BASE, 'point')
+  autoload :LineString, File.join(OGR_BASE, 'line_string')
+  autoload :Polygon, File.join(OGR_BASE, 'polygon')
+  autoload :MultiPoint, File.join(OGR_BASE, 'multi_point')
+  autoload :MultiLineString, File.join(OGR_BASE, 'multi_line_string')
+  autoload :MultiPolygon, File.join(OGR_BASE, 'multi_polygon')
+  autoload :GeometryCollection, File.join(OGR_BASE, 'geometry_collection')
+  autoload :LinearRing, File.join(OGR_BASE, 'linear_ring')
+  autoload :Point25D, File.join(OGR_BASE, 'point_25d')
+  autoload :LineString25D, File.join(OGR_BASE, 'line_string_25d')
+  autoload :Polygon25D, File.join(OGR_BASE, 'polygon_25d')
+  autoload :MultiPoint25D, File.join(OGR_BASE, 'multi_point_25d')
+  autoload :MultiLineString25D, File.join(OGR_BASE, 'multi_line_string_25d')
+  autoload :MultiPolygon25D, File.join(OGR_BASE, 'multi_polygon_25d')
+  autoload :GeometryCollection25D, File.join(OGR_BASE, 'geometry_collection_25d')
+
+  module FFIOGR
+    def self.search_paths
+      @search_paths ||= begin
+        if ENV['GDAL_LIBRARY_PATH']
+        elsif FFI::Platform.windows?
+          ENV['PATH'].split(File::PATH_SEPARATOR)
+        else
+          ['/usr/local/{lib64,lib}', '/opt/local/{lib64,lib}', '/usr/{lib64,lib}']
+          ['/usr/local/{lib64,lib}', '/opt/local/{lib64,lib}', '/usr/{lib64,lib}', '/usr/lib/{x86_64,i386}-linux-gnu']
+        end
+      end
+    end
+
+    def self.find_lib(lib)
+      if ENV['GDAL_LIBRARY_PATH'] && File.file?(ENV['GDAL_LIBRARY_PATH'])
+        ENV['GDAL_LIBRARY_PATH']
+      else
+        Dir.glob(search_paths.map {|path|
+          File.expand_path(File.join(path, "#{lib}.#{FFI::Platform::LIBSUFFIX}"))
+        }).first
+      end
+    end
+
+    def self.gdal_library_path
+      @gdal_library_path ||= begin
+        find_lib('{lib,}gdal{,-?}')
+      end
+    end
+
+    extend ::FFI::Library
+
+    ffi_lib(gdal_library_path)
+
+    enum :ogr_field_type, [
+      :integer, 0,
+      :integer_list, 1,
+      :real, 2,
+      :real_list, 3,
+      :string, 4,
+      :string_list, 5,
+      :wide_string, 6,
+      :wide_string_list, 7,
+      :binary, 8,
+      :date, 9,
+      :time, 10,
+      :date_time, 11
+    ]
+
+    enum :ogr_geometry_type, [
+      :unknown, 0,
+      :point, 1,
+      :line_string, 2,
+      :polygon, 3,
+      :multi_point, 4,
+      :multi_line_string, 5,
+      :multi_polygon, 6,
+      :geometry_collection, 7,
+      :none, 100,
+      :linear_ring, 101,
+      :point_25d, 0x80000001,
+      :line_string_25d, 0x80000002,
+      :polygon_25d, 0x80000003,
+      :multi_point_25d, 0x80000004,
+      :multi_line_string_25d, 0x80000005,
+      :multi_polygon_25d, 0x80000006,
+      :geometry_collection_25d, 0x80000007
+    ]
+
+    enum :ogr_justification, [
+      :undefined, 0,
+      :left, 1,
+      :right, 2
+    ]
+
+    attach_function :OGRRegisterAll, [], :void
+    attach_function :OGR_Dr_GetName, [:pointer], :string
+    attach_function :OGR_Dr_Open, [:pointer, :string, :int], :pointer
+    attach_function :OGR_Dr_TestCapability, [:pointer, :string], :int
+    attach_function :OGR_Dr_CreateDataSource, [:pointer, :string, :string], :pointer
+    attach_function :OGR_Dr_CopyDataSource, [:pointer, :pointer, :string, :string], :pointer
+    attach_function :OGR_Dr_DeleteDataSource, [:pointer, :string], :pointer
+    attach_function :OGRGetDriverCount, [], :int
+    attach_function :OGRGetDriver, [:int], :pointer
+    attach_function :OGRGetDriverByName, [:string], :pointer
+    attach_function :OGROpen, [:string, :int, :pointer], :pointer
+    attach_function :OGR_DS_Destroy, [:pointer], :void
+    attach_function :OGR_DS_GetName, [:pointer], :string
+    attach_function :OGR_DS_GetLayerCount, [:pointer], :int
+    attach_function :OGR_DS_GetLayer, [:pointer, :int], :pointer
+    attach_function :OGR_DS_GetLayerByName, [:pointer, :string], :pointer
+    attach_function :OGR_DS_DeleteLayer, [:pointer, :int], :pointer
+    attach_function :OGR_DS_GetDriver, [:pointer], :pointer
+    attach_function :OGR_DS_CreateLayer, [:pointer, :string, :pointer, :ogr_geometry_type, :string], :pointer
+    attach_function :OGR_DS_CopyLayer, [:pointer, :pointer, :string, :string], :pointer
+    attach_function :OGR_DS_TestCapability, [:pointer, :string], :int
+    attach_function :OGR_DS_ExecuteSQL, [:pointer, :string, :pointer, :string], :pointer
+    attach_function :OGR_DS_ReleaseResultSet, [:pointer, :pointer], :void
+    attach_function :OGR_DS_SyncToDisk, [:pointer], :pointer
+    attach_function :OGR_L_GetGeomType, [:pointer], :ogr_geometry_type
+    attach_function :OGR_L_GetName, [:pointer], :string
+    attach_function :OGR_L_GetSpatialFilter, [:pointer], :pointer
+    attach_function :OGR_L_SetSpatialFilter, [:pointer, :pointer], :void
+    attach_function :OGR_L_SetSpatialFilterRect, [:pointer, :double, :double, :double, :double], :void
+    attach_function :OGR_L_SetAttributeFilter, [:pointer, :string], :pointer
+    attach_function :OGR_L_ResetReading, [:pointer], :void
+    attach_function :OGR_L_GetNextFeature, [:pointer], :pointer
+    attach_function :OGR_L_SetNextByIndex, [:pointer, :long], :pointer
+    attach_function :OGR_L_GetFeature, [:pointer, :long], :pointer
+    attach_function :OGR_L_SetFeature, [:pointer, :pointer], :pointer
+    attach_function :OGR_L_CreateFeature, [:pointer, :pointer], :pointer
+    attach_function :OGR_L_DeleteFeature, [:pointer, :long], :pointer
+    attach_function :OGR_L_GetLayerDefn, [:pointer], :pointer
+    attach_function :OGR_L_GetSpatialRef, [:pointer], :pointer
+    attach_function :OGR_L_GetFeatureCount, [:pointer, :int], :int
+    attach_function :OGR_L_GetExtent, [:pointer, :pointer, :int], :pointer
+    attach_function :OGR_L_CreateField, [:pointer, :pointer, :int], :pointer
+    attach_function :OGR_L_SyncToDisk, [:pointer], :pointer
+    attach_function :OGR_FD_GetFieldCount, [:pointer], :int
+    attach_function :OGR_FD_GetFieldDefn, [:pointer, :int], :pointer
+    attach_function :OGR_Fld_Create, [:string, :ogr_field_type], :pointer
+    attach_function :OGR_Fld_Destroy, [:pointer], :void
+    attach_function :OGR_Fld_SetName, [:pointer, :string], :void
+    attach_function :OGR_Fld_GetNameRef, [:pointer], :string
+    attach_function :OGR_Fld_GetType, [:pointer], :ogr_field_type
+    attach_function :OGR_Fld_SetType, [:pointer, :ogr_field_type], :void
+    attach_function :OGR_Fld_GetJustify, [:pointer], :ogr_justification
+    attach_function :OGR_Fld_SetJustify, [:pointer, :ogr_justification], :void
+    attach_function :OGR_Fld_GetWidth, [:pointer], :int
+    attach_function :OGR_Fld_SetWidth, [:pointer, :int], :void
+    attach_function :OGR_Fld_GetPrecision, [:pointer], :int
+    attach_function :OGR_Fld_SetPrecision, [:pointer, :int], :void
+    attach_function :OGR_Fld_Set, [:pointer, :string, :ogr_field_type, :int, :int, :ogr_justification], :void
+    attach_function :OGR_Fld_IsIgnored, [:pointer], :int
+    attach_function :OGR_Fld_SetIgnored, [:pointer, :int], :void
+    attach_function :OGR_F_Create, [:pointer], :pointer
+    attach_function :OGR_F_GetFieldAsInteger, [:pointer, :int], :int
+    attach_function :OGR_F_GetFieldAsDouble, [:pointer, :int], :double
+    attach_function :OGR_F_GetFieldAsString, [:pointer, :int], :string
+    attach_function :OGR_F_GetFieldAsIntegerList, [:pointer, :int, :pointer], :pointer
+    attach_function :OGR_F_GetFieldAsDoubleList, [:pointer, :int, :pointer], :pointer
+    attach_function :OGR_F_GetFieldAsStringList, [:pointer, :int], :pointer
+    attach_function :OGR_F_GetFieldAsBinary, [:pointer, :int, :pointer], :pointer
+    attach_function :OGR_F_GetFieldAsDateTime, [:pointer, :int, :pointer, :pointer, :pointer, :pointer, :pointer, :pointer, :pointer], :pointer
+    attach_function :OGR_F_SetFieldInteger, [:pointer, :int, :int], :void
+    attach_function :OGR_F_SetFieldDouble, [:pointer, :int, :double], :void
+    attach_function :OGR_F_SetFieldString, [:pointer, :int, :string], :void
+    attach_function :OGR_F_SetFieldIntegerList, [:pointer, :int, :int, :pointer], :void
+    attach_function :OGR_F_SetFieldDoubleList, [:pointer, :int, :int, :pointer], :void
+    attach_function :OGR_F_SetFieldStringList, [:pointer, :int, :int, :pointer], :void
+    attach_function :OGR_F_SetFieldRaw, [:pointer, :int, :pointer], :void
+    attach_function :OGR_F_SetFieldBinary, [:pointer, :int, :int, :pointer], :void
+    attach_function :OGR_F_SetFieldDateTime, [:pointer, :int, :int, :int, :int, :int, :int, :int, :int], :void
+    attach_function :OGR_F_GetDefnRef, [:pointer], :pointer
+    attach_function :OGR_F_GetFieldCount, [:pointer], :int
+    attach_function :OGR_F_GetFieldDefnRef, [:pointer, :int], :pointer
+    attach_function :OGR_F_GetFieldIndex, [:pointer, :string], :int
+    attach_function :OGR_F_IsFieldSet, [:pointer, :int], :int
+    attach_function :OGR_F_GetGeometryRef, [:pointer], :pointer
+    attach_function :OGR_F_GetFID, [:pointer], :long
+    attach_function :OGR_F_SetFID, [:pointer, :long], :pointer
+    attach_function :OGR_F_SetGeometry, [:pointer, :pointer], :pointer
+    attach_function :OGR_F_SetGeometryDirectly, [:pointer, :pointer], :pointer
+    attach_function :OGR_G_CreateFromWkb, [:pointer, :pointer, :pointer, :int], :pointer
+    attach_function :OGR_G_CreateFromWkt, [:pointer, :pointer, :pointer], :pointer
+    attach_function :OGR_G_DestroyGeometry, [:pointer], :void
+    attach_function :OGR_G_CreateGeometry, [:ogr_geometry_type], :pointer
+    attach_function :OGR_G_ApproximateArcAngles, [:double, :double, :double, :double, :double, :double, :double, :double, :double], :pointer
+    attach_function :OGR_G_ForceToPolygon, [:pointer], :pointer
+    #attach_function :OGR_G_ForceToLineString, [:pointer], :pointer
+    attach_function :OGR_G_ForceToMultiPolygon, [:pointer], :pointer
+    attach_function :OGR_G_ForceToMultiPoint, [:pointer], :pointer
+    attach_function :OGR_G_ForceToMultiLineString, [:pointer], :pointer
+    attach_function :OGR_G_GetDimension, [:pointer], :int
+    attach_function :OGR_G_GetCoordinateDimension, [:pointer], :int
+    attach_function :OGR_G_SetCoordinateDimension, [:pointer, :int], :void
+    attach_function :OGR_G_Clone, [:pointer], :pointer
+    attach_function :OGR_G_GetEnvelope, [:pointer, :pointer], :void
+    attach_function :OGR_G_GetEnvelope3D, [:pointer, :pointer], :void
+    attach_function :OGR_G_ImportFromWkb, [:pointer, :pointer, :int], :pointer
+    attach_function :OGR_G_ExportToWkb, [:pointer, :pointer, :pointer], :pointer
+    attach_function :OGR_G_WkbSize, [:pointer], :int
+    attach_function :OGR_G_ImportFromWkt, [:pointer, :string], :pointer
+    attach_function :OGR_G_ExportToWkt, [:pointer, :pointer], :pointer
+    attach_function :OGR_G_GetGeometryType, [:pointer], :ogr_geometry_type
+    attach_function :OGR_G_GetGeometryName, [:pointer], :string
+    attach_function :OGR_G_DumpReadable, [:pointer, :pointer, :string], :void
+    attach_function :OGR_G_FlattenTo2D, [:pointer], :void
+    attach_function :OGR_G_CloseRings, [:pointer], :void
+    attach_function :OGR_G_CreateFromGML, [:string], :pointer
+    attach_function :OGR_G_ExportToGML, [:pointer], :string
+    #attach_function :OGR_G_ExportToGMLEx, [:pointer, :pointer], :string
+    attach_function :OGR_G_ExportToKML, [:pointer, :string], :string
+    attach_function :OGR_G_ExportToJson, [:pointer], :string
+    attach_function :OGR_G_ExportToJsonEx, [:pointer, :string], :string
+    attach_function :OGR_G_AssignSpatialReference, [:pointer, :pointer], :void
+    attach_function :OGR_G_GetSpatialReference, [:pointer], :pointer
+    attach_function :OGR_G_Transform, [:pointer, :pointer], :pointer
+    attach_function :OGR_G_TransformTo, [:pointer, :pointer], :pointer
+    attach_function :OGR_G_Simplify, [:pointer, :double], :pointer
+    attach_function :OGR_G_SimplifyPreserveTopology, [:pointer, :double], :pointer
+    attach_function :OGR_G_Segmentize, [:pointer, :double], :pointer
+    attach_function :OGR_G_Intersects, [:pointer, :pointer], :int
+    attach_function :OGR_G_Equals, [:pointer, :pointer], :int
+    attach_function :OGR_G_Disjoint, [:pointer, :pointer], :int
+    attach_function :OGR_G_Touches, [:pointer, :pointer], :int
+    attach_function :OGR_G_Crosses, [:pointer, :pointer], :int
+    attach_function :OGR_G_Within, [:pointer, :pointer], :int
+    attach_function :OGR_G_Contains, [:pointer, :pointer], :int
+    attach_function :OGR_G_Overlaps, [:pointer, :pointer], :int
+    attach_function :OGR_G_Boundary, [:pointer], :pointer
+    attach_function :OGR_G_ConvexHull, [:pointer], :pointer
+    attach_function :OGR_G_Buffer, [:pointer, :double, :int], :pointer
+    attach_function :OGR_G_Intersection, [:pointer, :pointer], :pointer
+    attach_function :OGR_G_Union, [:pointer, :pointer], :pointer
+    attach_function :OGR_G_UnionCascaded, [:pointer], :pointer
+    #attach_function :OGR_G_PointOnSurface, [:pointer], :pointer
+    attach_function :OGR_G_Difference, [:pointer, :pointer], :pointer
+    attach_function :OGR_G_SymDifference, [:pointer, :pointer], :pointer
+    attach_function :OGR_G_Distance, [:pointer, :pointer], :double
+    attach_function :OGR_G_Length, [:pointer], :double
+    attach_function :OGR_G_Area, [:pointer], :double
+    attach_function :OGR_G_Centroid, [:pointer, :pointer], :int
+    attach_function :OGR_G_Empty, [:pointer], :void
+    attach_function :OGR_G_IsEmpty, [:pointer], :int
+    attach_function :OGR_G_IsValid, [:pointer], :int
+    attach_function :OGR_G_IsSimple, [:pointer], :int
+    attach_function :OGR_G_IsRing, [:pointer], :int
+    attach_function :OGR_G_Polygonize, [:pointer], :pointer
+    attach_function :OGR_G_GetPointCount, [:pointer], :int
+    attach_function :OGR_G_GetPoints, [:pointer, :pointer, :int, :pointer, :int, :pointer, :int], :int
+    attach_function :OGR_G_GetX, [:pointer, :int], :double
+    attach_function :OGR_G_GetY, [:pointer, :int], :double
+    attach_function :OGR_G_GetZ, [:pointer, :int], :double
+    attach_function :OGR_G_GetPoint, [:pointer, :int, :pointer, :pointer, :pointer], :void
+    attach_function :OGR_G_SetPoint, [:pointer, :int, :double, :double, :double], :void
+    attach_function :OGR_G_SetPoint_2D, [:pointer, :int, :double, :double], :void
+    attach_function :OGR_G_AddPoint, [:pointer, :double, :double, :double], :void
+    attach_function :OGR_G_AddPoint_2D, [:pointer, :double, :double], :void
+    attach_function :OGR_G_GetGeometryCount, [:pointer], :int
+    attach_function :OGR_G_GetGeometryRef, [:pointer, :int], :pointer
+    attach_function :OGR_G_AddGeometry, [:pointer, :pointer], :pointer
+    attach_function :OGR_G_AddGeometryDirectly, [:pointer, :pointer], :pointer
+    attach_function :OGR_G_RemoveGeometry, [:pointer, :int, :int], :pointer
+    attach_function :OGR_F_Destroy, [:pointer], :void
+  end
+
+  class << self
+    def to_binary(data)
+      buf = FFI::MemoryPointer.new(:char, value.size)
+      buf.put_bytes(0, data)
+      buf
+    end
+  end
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: ffi-ogr
+version: !ruby/object:Gem::Version
+  version: 0.0.1.pre
+  prerelease: 6
+platform: ruby
+authors:
+- Scooter Wadsworth
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: FFI wrapper for OGR
+email:
+- scooterwadsworth@gmail.com
+executables:
+- ogr_console
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/ogr_console
+- lib/ffi-ogr/data_source.rb
+- lib/ffi-ogr/feature.rb
+- lib/ffi-ogr/generic_reader.rb
+- lib/ffi-ogr/generic_writer.rb
+- lib/ffi-ogr/geo_json.rb
+- lib/ffi-ogr/geo_json_reader.rb
+- lib/ffi-ogr/geo_json_writer.rb
+- lib/ffi-ogr/geometry.rb
+- lib/ffi-ogr/geometry_collection.rb
+- lib/ffi-ogr/geometry_collection_25d.rb
+- lib/ffi-ogr/layer.rb
+- lib/ffi-ogr/line_string.rb
+- lib/ffi-ogr/line_string_25d.rb
+- lib/ffi-ogr/linear_ring.rb
+- lib/ffi-ogr/multi_line_string.rb
+- lib/ffi-ogr/multi_line_string_25d.rb
+- lib/ffi-ogr/multi_point.rb
+- lib/ffi-ogr/multi_point_25d.rb
+- lib/ffi-ogr/multi_polygon.rb
+- lib/ffi-ogr/multi_polygon_25d.rb
+- lib/ffi-ogr/point.rb
+- lib/ffi-ogr/point_25d.rb
+- lib/ffi-ogr/polygon.rb
+- lib/ffi-ogr/polygon_25d.rb
+- lib/ffi-ogr/reader.rb
+- lib/ffi-ogr/shapefile.rb
+- lib/ffi-ogr/shp_reader.rb
+- lib/ffi-ogr/shp_writer.rb
+- lib/ffi-ogr/tools.rb
+- lib/ffi-ogr/version.rb
+- lib/ffi-ogr/writer.rb
+- lib/ffi-ogr.rb
+homepage: https://github.com/scooterw/ffi-ogr
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Convenient access to OGR functionality from Ruby
+test_files: []