ffi-ogr 0.0.1.pre → 0.0.1

data/README.md

@@ -6,33 +6,46 @@ 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 @ptr=#<FFI::AutoPointer address=0x007fba4c4cdc50>>
+
+shp.to_geojson '~/Desktop/output.geojson'
+# => Output GeoJSON to specified file
+```
+
+To reproject 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>>
+# => #<OGR::DataSource:0x007fba4d19c328 @ptr=#<FFI::AutoPointer address=0x007fba4c4cdc50>>
+
+shp.to_json
+# => Output GeoJSON string
+
+shp.to_json true
+# => Output GeoJSON string (pretty print)
 
-shp.to_geojson
-# => geojson feature collection from Shapefile
+# from_epsg(integer), from_proj4(string), from_wkt(string)
+new_sr = OGR::SpatialReference.from_epsg 3857
+# => #<OGR::SpatialReference:0x007fd859a0e6f8 @ptr=#<FFI::AutoPointer address=0x007fd85a11c100>>
 
-shp.to_geojson true
-# => "pretty print" geojson feature collection from Shapefile
+shp.to_shp '~/Desktop/reprojected_shp.shp', {spatial_ref: new_sr}
+# => Output reprojected SHP to specified file
 ```
 
 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
+shp = writer.ptr
 
 # add layer to shp : add_layer(name, geometry_type, spatial_reference)
 # currently does not handle spatial reference, will automatically be nil
@@ -58,15 +71,12 @@ 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/lib/ffi-ogr/coordinate_transformation.rb

@@ -0,0 +1,30 @@
+module OGR
+  class CoordinateTransformation
+    attr_accessor :ptr
+
+    def initialize(ptr)
+      @ptr = FFI::AutoPointer.new(ptr, self.class.method(:release))
+      @ptr.autorelease = false
+    end
+
+    def self.release(ptr);end
+
+    def free
+      FFIOGR.OCTDestroyCoordinateTransformation(@ptr)
+    end
+
+    def self.find_transformation(in_sr, out_sr)
+      bad_sr = []
+
+      if !in_sr.instance_of?(OGR::SpatialReference)
+        bad_sr << 'Input SR'
+      elsif !out_sr.instance_of?(OGR::SpatialReference)
+        bad_sr << 'Output SR'
+      end
+
+      raise RuntimeError.new("Invalid Spatial Reference(s): #{bad_sr.join(', ')}") if bad_sr.size > 0
+
+      FFIOGR.OCTNewCoordinateTransformation(in_sr.ptr, out_sr.ptr)
+    end
+  end
+end

data/lib/ffi-ogr/data_source.rb

@@ -2,31 +2,108 @@ module OGR
   class DataSource
     include FFIOGR
 
-    attr_accessor :ds
+    attr_accessor :ptr
 
-    def initialize(ptr=nil, auto_free=true)
-      @ds = FFI::AutoPointer.new(ptr, self.class.method(:release))
-      @ds.autorelease = auto_free
+    def initialize(ptr)
+      @ptr = FFI::AutoPointer.new(ptr, self.class.method(:release))
+      @ptr.autorelease = false
     end
 
-    def self.release(ptr)
-      FFIOGR.OGR_DS_Destroy(ptr)
+    def self.release(ptr);end
+
+    def free
+      FFIOGR.OGR_DS_Destroy(@ptr)
+    end
+
+    def copy(output_type, output_path, driver_options=nil)
+      driver = OGRGetDriverByName(OGR::DRIVER_TYPES[output_type.downcase])
+      new_ds = FFIOGR.OGR_Dr_CopyDataSource(driver, @ptr, File.expand_path(output_path), driver_options)
+      FFIOGR.OGR_DS_Destroy(new_ds)
+    end
+
+    def copy_with_transform(output_type, output_path, spatial_ref=nil, driver_options=nil)
+      writer = OGR::GenericWriter.new(OGR::DRIVER_TYPES[output_type.downcase])
+      writer.set_output(output_path)
+      out = writer.ptr
+
+      layers.each do |layer|
+        name = layer.name
+        geometry_type = layer.geometry_type
+        old_sr = layer.spatial_ref
+
+        ct = OGR::CoordinateTransformation.find_transformation(old_sr, spatial_ref) unless spatial_ref.nil? || (spatial_ref == old_sr)
+
+        sr = spatial_ref.nil? ? nil : spatial_ref.ptr
+
+        new_layer = out.add_layer name, geometry_type, sr, driver_options
+
+        ptr = layer.ptr
+
+        layer_definition = FFIOGR.OGR_L_GetLayerDefn(ptr)
+        field_count = FFIOGR.OGR_FD_GetFieldCount(layer_definition)
+
+        for i in (0...field_count)
+          fd = FFIOGR.OGR_FD_GetFieldDefn(layer_definition, i)
+          name = FFIOGR.OGR_Fld_GetNameRef(fd)
+          type = FFIOGR.OGR_Fld_GetType(fd)
+
+          opts = {}
+
+          opts[:precision] = FFIOGR.OGR_Fld_GetPrecision(fd) if type == :real
+          opts[:width] = FFIOGR.OGR_Fld_GetWidth(fd) if type == :string
+
+          new_layer.add_field name, type
+        end
+
+        layer.features.each do |feature|
+          geometry = OGR::Tools.cast_geometry(feature.geometry)
+          geometry.transform ct if ct
+
+          new_feature = new_layer.create_feature
+          new_feature.add_geometry geometry
+
+          ptr = feature.ptr
+          field_count = FFIOGR.OGR_F_GetFieldCount(ptr)
+
+          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
+
+            new_feature.set_field_value field_name, field_value, field_type
+          end
+
+          new_layer.add_feature new_feature
+        end
+
+        new_layer.sync
+      end
+      out.free
     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)
+    def add_layer(name, geometry_type, spatial_ref=nil, options=nil)
+      layer = FFIOGR.OGR_DS_CreateLayer(@ptr, name, spatial_ref, geometry_type.to_sym, options)
       OGR::Tools.cast_layer(layer)
     end
 
+    def num_layers
+      FFIOGR.OGR_DS_GetLayerCount(@ptr)
+    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))
+        layers << OGR::Tools.cast_layer(OGR_DS_GetLayer(@ptr, i))
       end
 
       layers
@@ -34,22 +111,84 @@ module OGR
     alias_method :layers, :get_layers
 
     def get_features
-      layers.map {|l| l.features}.first
+      layers.map {|l| l.features}
     end
     alias_method :features, :get_features
 
-    def get_geometries
-      features.map {|f| OGR::Tools.cast_geometry(f.geometry)}
+    def get_geometries(as_geojson=false)
+      unless as_geojson
+        features.map {|feature| feature.map {|f| OGR::Tools.cast_geometry(f.geometry)}}
+      else
+        features.map {|feature| feature.map {|f| OGR::Tools.cast_geometry(f.geometry).to_geojson}}
+      end
     end
     alias_method :geometries, :get_geometries
 
     def get_fields
-      features.map {|f| f.fields}
+      features.map {|feature| feature.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)
+    def to_shp(output_path, spatial_ref=nil)
+      raise RuntimeError.new("Output path not specified.") if output_path.nil?
+
+      # TODO: handle parsing of spatial_ref -> copy options
+
+      if spatial_ref.instance_of? OGR::SpatialReference
+        copy_with_transform('shapefile', output_path, spatial_ref)
+      elsif spatial_ref.nil?
+        copy('shapefile', output_path, spatial_ref)
+      end
+    end
+
+    def to_geojson(output_path, options=nil)
+      raise RuntimeError.new("Output path not specified.") if output_path.nil?
+
+      unless options.nil?
+        spatial_ref = options[:spatial_ref] ? options[:spatial_ref] : nil
+
+        if options[:bbox]
+          # this segfaults -- working on solution
+          bbox = FFI::MemoryPointer.from_string "WRITE_BBOX=YES"
+          driver_options = FFI::MemoryPointer.new :pointer, 1
+          driver_options[0].put_pointer 0, bbox
+        else
+          driver_options = nil
+        end
+
+        if spatial_ref
+          copy_with_transform('geojson', output_path, spatial_ref, driver_options)
+        else
+          copy('geojson', output_path, driver_options)
+        end
+      else
+        copy('geojson', output_path, nil)
+      end
+    end
+
+    def to_json(pretty=false)
+      h = {
+        type: 'FeatureCollection',
+        bbox: nil,
+        features: []
+      }
+
+      layers.each do |layer|
+        h[:bbox] = layer.envelope.to_a true
+        geometry_type = layer.geometry_type.to_s.capitalize
+
+        layer.features.each do |feature|
+          properties = feature.fields
+          geometry = OGR::Tools.cast_geometry(feature.geometry).to_geojson
+          h[:features] << {type: geometry_type, geometry: geometry, properties: properties}
+        end
+      end
+
+      unless pretty
+        MultiJson.dump(h)
+      else
+        MultiJson.dump(h, pretty: true)
+      end
     end
   end
 end

data/lib/ffi-ogr/envelope.rb

@@ -0,0 +1,33 @@
+module OGR
+  class Envelope
+    attr_accessor :min_x, :max_x, :min_y, :max_y
+
+    def initialize(env)
+      raise RuntimeError.new("Invalid envelope specified") unless env.size == 4
+
+      @min_x, @max_x = env[0], env[1]
+      @min_y, @max_y = env[2], env[3]
+    end
+
+    def to_a(se_nw=false)
+      unless se_nw
+        [@min_x, @max_x, @min_y, @max_y]
+      else
+        [@min_x, @min_y, @max_x, @max_y]
+      end
+    end
+
+    def to_hash
+      {min_x: @min_x, max_x: @max_x, min_y: @min_y, max_y: @max_y}
+    end
+
+    def to_json
+      MultiJson.dump(to_hash)
+    end
+
+    def to_polygon
+      coords = [[[@min_x, @min_y], [@min_x, @max_y], [@max_x, @max_y], [@max_x, @min_y], [@min_x, @min_y]]]
+      OGR::Polygon.create coords
+    end
+  end
+end

data/lib/ffi-ogr/feature.rb

@@ -2,13 +2,16 @@ module OGR
   class Feature
     attr_accessor :ptr
 
-    def initialize(ptr, auto_free=true)
+    def initialize(ptr)
       @ptr = FFI::AutoPointer.new(ptr, self.class.method(:release))
-      @ptr.autorelease = auto_free
+      #@ptr = FFI::AutoPointer.new(ptr)
+      @ptr.autorelease = false
     end
 
-    def self.release(ptr)
-      FFIOGR.OGR_F_Destroy(ptr)
+    def self.release(ptr);end
+
+    def free
+      FFIOGR.OGR_F_Destroy(@ptr)
     end
 
     def set_field_value(name, value, field_type=nil)
@@ -25,7 +28,10 @@ module OGR
       when :integer
         FFIOGR.OGR_F_SetFieldInteger(@ptr, field_index, Integer(value))
       when :real
-        FFIOGR.OGR_F_SetFieldDouble(@ptr, field_index, Float(value))
+        #dbl_ptr = FFI::MemoryPointer.new(:double, 1)
+        #dbl_ptr.write_double(Float(value))
+
+        FFIOGR.OGR_F_SetFieldDouble(@ptr, field_index, value)
       when :string
         FFIOGR.OGR_F_SetFieldString(@ptr, field_index, String(value))
       when :binary
@@ -34,8 +40,8 @@ module OGR
     end
 
     def add_geometry(geometry)
-      FFIOGR.OGR_F_SetGeometry(@ptr, geometry.ptr)
-      #FFIOGR.OGR_F_SetGeometryDirectly(@ptr, geometry.ptr)
+      #FFIOGR.OGR_F_SetGeometry(@ptr, geometry.ptr)
+      FFIOGR.OGR_F_SetGeometryDirectly(@ptr, geometry.ptr)
     end
 
     def get_geometry
@@ -72,6 +78,13 @@ module OGR
     end
     alias_method :fields, :get_fields
 
+    def transform_to(out_sr)
+      geom = OGR::Tools.cast_geometry(geometry)
+      geom.transform(out_sr)
+      p geom.ptr
+      add_geometry(geom)
+    end
+
     def to_geojson
       {type: 'Feature', geometry: OGR::Tools.cast_geometry(geometry).to_geojson, properties: fields}
     end

data/lib/ffi-ogr/geometry.rb

@@ -1,21 +1,46 @@
 module OGR
   class Geometry
-    attr_reader :ptr
+    attr_accessor :ptr
 
-    def initialize(ptr, auto_free=true)
+    def initialize(ptr)
       @ptr = FFI::AutoPointer.new(ptr, self.class.method(:release))
-      #@ptr.autorelease = auto_free
+      #@ptr = FFI::AutoPointer.new(ptr)
+      @ptr.autorelease = false
     end
 
     def self.release(ptr);end
 
+    def free
+      FFIOGR.OGR_G_DestroyGeometry(@ptr)
+    end
+
+    def self.from_geojson(geojson)
+      if geojson.instance_of? String
+        geojson = MultiJson.load(geojson)
+      end
+
+      coords = geojson['coordinates']
+
+      case geojson['type']
+      when 'Point'
+        OGR::Point.create coords
+      when 'LineString'
+        OGR::LineString.create coords
+      when 'Polygon'
+        OGR::Polygon.create coords
+      end
+    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_geometry_directly(geometry)
+      FFIOGR.OGR_G_AddGeometryDirectly(@ptr, geometry.ptr)
     end
 
     def add_point(coords)
@@ -44,6 +69,10 @@ module OGR
       end
     end
 
+    def is_3d?
+      !!(geometry_type.to_s =~ /_25d/)
+    end
+
     def flatten
       FFIOGR.OGR_G_FlattenTo2D(@ptr)
     end
@@ -53,6 +82,15 @@ module OGR
     end
     alias_method :geometry_type, :get_geometry_type
 
+    def get_spatial_ref
+      OGR::Tools.cast_spatial_reference(FFIOGR.OGR_G_GetSpatialReference(@ptr))
+    end
+    alias_method :spatial_ref, :get_spatial_ref
+
+    def transform(ct)
+      FFIOGR.OGR_G_Transform(@ptr, ct)
+    end
+
     def get_length
       FFIOGR.OGR_G_Length(@ptr)
     end
@@ -68,6 +106,13 @@ module OGR
     end
     alias_method :boundary, :get_boundary
 
+    def get_envelope
+      envelope = FFI::MemoryPointer.new :pointer, 4
+      FFIOGR.OGR_G_GetEnvelope(@ptr, envelope)
+      OGR::Envelope.new(envelope.read_array_of_double(4))
+    end
+    alias_method :envelope, :get_envelope
+
     def to_geojson
       MultiJson.load(FFIOGR.OGR_G_ExportToJson(@ptr))
     end

data/lib/ffi-ogr/layer.rb

@@ -2,22 +2,57 @@ module OGR
   class Layer
     attr_accessor :ptr, :name, :geometry_type
 
-    def initialize(ptr, auto_free=true)
+    def initialize(ptr)
       @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
+      #@ptr = FFI::AutoPointer.new(ptr)
+      @ptr.autorelease = false
     end
 
     def self.release(ptr);end
 
+    def free
+      @ptr.free
+    end
+
     def sync
       FFIOGR.OGR_L_SyncToDisk(@ptr)
     end
 
-    def add_field(name, field_type, field_width=32)
+    def get_envelope
+      envelope = FFI::MemoryPointer.new :pointer, 4
+      FFIOGR.OGR_L_GetExtent(@ptr, envelope, 0)
+      OGR::Envelope.new(envelope.read_array_of_double(4))
+    end
+    alias_method :envelope, :get_envelope
+
+    def get_name
+      FFIOGR.OGR_L_GetName(@ptr)
+    end
+    alias_method :name, :get_name
+
+    def get_geometry_type
+      FFIOGR.OGR_L_GetGeomType(@ptr)
+    end
+    alias_method :geometry_type, :get_geometry_type
+
+    def get_spatial_ref
+      OGR::Tools.cast_spatial_reference(FFIOGR.OGR_L_GetSpatialRef(@ptr))
+    end
+    alias_method :spatial_ref, :get_spatial_ref
+
+    def add_field(name, field_type, options={})
+      type = field_type.to_sym
+      precision = options[:precision] || 1
+      width = options[:width] || 32
+
       field = FFIOGR.OGR_Fld_Create(name, field_type.to_sym)
-      FFIOGR.OGR_Fld_SetWidth(field, field_width)
+
+      if type == :real
+        FFIOGR.OGR_Fld_SetPrecision(field, precision)
+      else
+        FFIOGR.OGR_Fld_SetWidth(field, width)
+      end
+
       FFIOGR.OGR_L_CreateField(@ptr, field, 1)
       FFIOGR.OGR_Fld_Destroy(field)
     end

data/lib/ffi-ogr/options_struct.rb

@@ -0,0 +1,10 @@
+module OGR
+  class OptionsStruct < FFI::Struct
+    layout :length, :size_t,
+           :options, :pointer
+
+    def to_a
+      self[:options].get_array_of_string 0, self[:length]
+    end
+  end
+end

data/lib/ffi-ogr/spatial_reference.rb

@@ -0,0 +1,81 @@
+module OGR
+  class SpatialReference
+    attr_accessor :ptr
+
+    def initialize(ptr)
+      @ptr = FFI::AutoPointer.new(ptr, self.class.method(:release))
+      @ptr.autorelease = false
+    end
+
+    def self.release(ptr);end
+
+    def free
+      FFIOGR.OSRDestroySpatialReference(@ptr)
+    end
+
+    def self.create
+      OGR::Tools.cast_spatial_reference(FFIOGR.OSRNewSpatialReference(nil))
+    end
+
+    def self.from_wkt(wkt)
+      sr = OGR::Tools.cast_spatial_reference(FFIOGR.OSRNewSpatialReference(nil))
+      sr.import_wkt(wkt)
+      sr
+    end
+
+    def self.from_proj4(proj4)
+      sr = OGR::Tools.cast_spatial_reference(FFIOGR.OSRNewSpatialReference(nil))
+      sr.import_proj4(proj4)
+      sr
+    end
+
+    def self.from_epsg(epsg_code)
+      sr = OGR::Tools.cast_spatial_reference(FFIOGR.OSRNewSpatialReference(nil))
+      sr.import_epsg(epsg_code)
+      sr
+    end
+
+    def import_wkt(wkt)
+      wkt_ptr = FFI::MemoryPointer.from_string wkt
+      wkt_ptr_ptr = FFI::MemoryPointer.new :pointer
+      wkt_ptr_ptr.put_pointer 0, wkt_ptr
+      FFIOGR.OSRImportFromWkt(@ptr, wkt_ptr_ptr)
+    end
+
+    def import_proj4(proj4)
+      FFIOGR.OSRImportFromProj4(@ptr, proj4)
+    end
+
+    def import_epsg(epsg_code)
+      FFIOGR.OSRImportFromEPSG(@ptr, epsg_code)
+    end
+
+    def to_wkt(pretty=false)
+      ptr = FFI::MemoryPointer.new :pointer
+
+      unless pretty
+        FFIOGR.OSRExportToWkt(@ptr, ptr)
+      else
+        FFIOGR.OSRExportToPrettyWkt(@ptr, ptr, 4)
+      end
+      str_ptr = ptr.read_pointer
+
+      return str_ptr.null? ? nil : str_ptr.read_string
+    end
+
+    def to_proj4
+      ptr = FFI::MemoryPointer.new :pointer
+      FFIOGR.OSRExportToProj4(@ptr, ptr)
+      str_ptr = ptr.read_pointer
+      return str_ptr.null? ? nil: str_ptr.read_string
+    end
+
+    def ==(other)
+      self.to_wkt == other.to_wkt
+    end
+
+    def find_transformation(out_sr)
+      CoordinateTransformation.find_transformation self, out_sr
+    end
+  end
+end

data/lib/ffi-ogr/tools.rb

@@ -1,26 +1,33 @@
 module OGR
   module Tools
     class << self
-      def cast_data_source(ds_ptr, options={})
-        options = {auto_free: true}.merge(options)
+      def cast_spatial_reference(sr_ptr, auto_free=true)
+        raise RuntimeError.new("Spatial Reference pointer is NULL") if sr_ptr.null?
+        SpatialReference.new sr_ptr
+      end
+
+      def cast_coordinate_transformation(ct_ptr, auto_free=true)
+        raise RuntimeError.new("Coordinate Transformation pointer is NULL") if ct_ptr.null?
+        CoordinateTransformation.new ct_ptr
+      end
+
+      def cast_data_source(ds_ptr, auto_free=true)
         raise RuntimeError.new("Data Source pointer is NULL") if ds_ptr.null?
-        DataSource.new ds_ptr, options[:auto_free]
+        DataSource.new ds_ptr
       end
 
-      def cast_layer(l_ptr, options={})
-        options = {auto_free: true}.merge(options)
+      def cast_layer(l_ptr, auto_free=true)
         raise RuntimeError.new("Layer pointer is NULL") if l_ptr.null?
-        Layer.new l_ptr, options[:aut_free]
+        Layer.new l_ptr
       end
 
-      def cast_feature(f_ptr, options={})
-        options = {auto_free: true}.merge(options)
+      def cast_feature(f_ptr, auto_free=true)
         raise RuntimeError.new("Feature pointer is NULL") if f_ptr.null?
-        Feature.new f_ptr, options[:auto_free]
+        Feature.new f_ptr
       end
 
-      def cast_geometry(geom_ptr, options={})
-        options = {auto_free: true}.merge(options)
+      def cast_geometry(geom_ptr, auto_free=true)
+        #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)
@@ -58,7 +65,7 @@ module OGR
           OGR::GeometryCollection25D
         end
 
-        klass.new(geom_ptr, options[:auto_free])
+        klass.new(geom_ptr)
       end
     end
   end

data/lib/ffi-ogr/version.rb

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

data/lib/ffi-ogr/writer.rb

@@ -2,15 +2,15 @@ module OGR
   class Writer
     include OGR::FFIOGR
 
-    attr_accessor :ds
+    attr_accessor :ptr
 
     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
+      @ptr = OGR::Tools.cast_data_source(ds)
+      @ptr
     end
 
     def self.from_file_type(path)
@@ -36,7 +36,7 @@ module OGR
       writer = Writer.from_file_type output_path
       data_source = writer.ds
 
-      # @ds -> data_source
+      # @ptr -> data_source
     end
   end
 end

data/lib/ffi-ogr.rb

@@ -4,6 +4,11 @@ require 'multi_json'
 module OGR
   OGR_BASE = File.join(File.dirname(__FILE__), 'ffi-ogr')
 
+  DRIVER_TYPES = {
+    'shapefile' => 'ESRI Shapefile',
+    'geojson' => 'GeoJSON'
+  }
+
   autoload :Reader, File.join(OGR_BASE, 'reader')
   autoload :GenericReader, File.join(OGR_BASE, 'generic_reader')
   autoload :ShpReader, File.join(OGR_BASE, 'shp_reader')
@@ -34,6 +39,10 @@ module OGR
   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')
+  autoload :Envelope, File.join(OGR_BASE, 'envelope')
+  autoload :SpatialReference, File.join(OGR_BASE, 'spatial_reference')
+  autoload :CoordinateTransformation, File.join(OGR_BASE, 'coordinate_transformation')
+  autoload :OptionsStruct, File.join(OGR_BASE, 'options_struct')
 
   module FFIOGR
     def self.search_paths
@@ -109,12 +118,17 @@ module OGR
       :right, 2
     ]
 
+    attach_function :GDALVersionInfo, [:string], :string
+
+    attach_function :CPLSetConfigOption, [:string, :string], :void
+    attach_function :CPLSetThreadLocalConfigOption, [:string, :string], :void
+
     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_CreateDataSource, [:pointer, :string, :pointer], :pointer
+    attach_function :OGR_Dr_CopyDataSource, [:pointer, :pointer, :string, :pointer], :pointer
     attach_function :OGR_Dr_DeleteDataSource, [:pointer, :string], :pointer
     attach_function :OGRGetDriverCount, [], :int
     attach_function :OGRGetDriver, [:int], :pointer
@@ -127,7 +141,7 @@ module OGR
     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_CreateLayer, [:pointer, :string, :pointer, :ogr_geometry_type, :pointer], :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
@@ -195,6 +209,7 @@ module OGR
     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_StealGeometry, [:pointer], :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
@@ -279,13 +294,36 @@ module OGR
     attach_function :OGR_G_AddGeometryDirectly, [:pointer, :pointer], :pointer
     attach_function :OGR_G_RemoveGeometry, [:pointer, :int, :int], :pointer
     attach_function :OGR_F_Destroy, [:pointer], :void
+
+    # SRS Functions
+
+    attach_function :OSRNewSpatialReference, [:pointer], :pointer
+    attach_function :OSRImportFromWkt, [:pointer, :pointer], :pointer
+    attach_function :OSRImportFromProj4, [:pointer, :string], :pointer
+    attach_function :OSRImportFromEPSG, [:pointer, :int], :pointer
+    attach_function :OSRExportToWkt, [:pointer, :pointer], :pointer
+    attach_function :OSRExportToPrettyWkt, [:pointer, :pointer, :int], :pointer
+    attach_function :OSRExportToProj4, [:pointer, :pointer], :pointer
+    attach_function :OSRDestroySpatialReference, [:pointer], :void
+    attach_function :OCTNewCoordinateTransformation, [:pointer, :pointer], :pointer
+    attach_function :OCTDestroyCoordinateTransformation, [:pointer], :void
+
+    OGRRegisterAll() # register all available OGR drivers
   end
 
   class << self
+    def gdal_version
+      FFIOGR.GDALVersionInfo('RELEASE_NAME')
+    end
+
     def to_binary(data)
       buf = FFI::MemoryPointer.new(:char, value.size)
       buf.put_bytes(0, data)
       buf
     end
+
+    def string_to_pointer(str)
+      FFI::MemoryPointer.from_string(str)
+    end
   end
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: ffi-ogr
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre
-  prerelease: 6
+  version: 0.0.1
+  prerelease: 
 platform: ruby
 authors:
 - Scooter Wadsworth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-28 00:00:00.000000000 Z
+date: 2013-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: 1.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,23 +26,23 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.5.0
+        version: 1.6.0
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.7.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.7.2
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -85,7 +85,9 @@ extra_rdoc_files: []
 files:
 - README.md
 - bin/ogr_console
+- lib/ffi-ogr/coordinate_transformation.rb
 - lib/ffi-ogr/data_source.rb
+- lib/ffi-ogr/envelope.rb
 - lib/ffi-ogr/feature.rb
 - lib/ffi-ogr/generic_reader.rb
 - lib/ffi-ogr/generic_writer.rb
@@ -105,6 +107,7 @@ files:
 - lib/ffi-ogr/multi_point_25d.rb
 - lib/ffi-ogr/multi_polygon.rb
 - lib/ffi-ogr/multi_polygon_25d.rb
+- lib/ffi-ogr/options_struct.rb
 - lib/ffi-ogr/point.rb
 - lib/ffi-ogr/point_25d.rb
 - lib/ffi-ogr/polygon.rb
@@ -113,6 +116,7 @@ files:
 - lib/ffi-ogr/shapefile.rb
 - lib/ffi-ogr/shp_reader.rb
 - lib/ffi-ogr/shp_writer.rb
+- lib/ffi-ogr/spatial_reference.rb
 - lib/ffi-ogr/tools.rb
 - lib/ffi-ogr/version.rb
 - lib/ffi-ogr/writer.rb