ffi-geos 0.0.6 → 0.1.0

data/lib/ffi-geos/geometry_collection.rb

@@ -21,13 +21,17 @@ module Geos
       if n < 0 || n >= self.num_geometries
         nil
       else
-        cast_geometry_ptr(FFIGeos.GEOSGetGeometryN_r(Geos.current_handle, self.ptr, n), false)
+        cast_geometry_ptr(FFIGeos.GEOSGetGeometryN_r(Geos.current_handle, self.ptr, n), :auto_free => false)
       end
     end
     alias :geometry_n :get_geometry_n
 
     def [](*args)
-      self.to_a[*args]
+      if args.length == 1 && args.first.is_a?(Numeric) && args.first >= 0
+        self.get_geometry_n(args.first)
+      else
+        self.to_a[*args]
+      end
     end
     alias :slice :[]
     alias :at :[]

data/lib/ffi-geos/line_string.rb

@@ -30,12 +30,20 @@ module Geos
       if n < 0 || n >= self.num_points
         raise RuntimeError.new("Index out of bounds")
       else
-        cast_geometry_ptr(FFIGeos.GEOSGeomGetPointN_r(Geos.current_handle, self.ptr, n))
+        cast_geometry_ptr(
+          FFIGeos.GEOSGeomGetPointN_r(Geos.current_handle, self.ptr, n), {
+            :srid_copy => self.srid
+          }
+        )
       end
     end
 
     def [](*args)
-      self.to_a[*args]
+      if args.length == 1 && args.first.is_a?(Numeric) && args.first >= 0
+        self.point_n(args.first)
+      else
+        self.to_a[*args]
+      end
     end
     alias :slice :[]
 
@@ -49,7 +57,9 @@ module Geos
           options[:quad_segs],
           options[:join],
           options[:mitre_limit]
-      ))
+      ), {
+        :srid_copy => self.srid
+      })
     end
 
     if FFIGeos.respond_to?(:GEOSisClosed_r)

data/lib/ffi-geos/linear_ring.rb

@@ -1,5 +1,8 @@
 
 module Geos
   class LinearRing < LineString
+    def to_polygon
+      Geos.create_polygon(self, :srid => pick_srid_according_to_policy(self.srid))
+    end
   end
 end

data/lib/ffi-geos/point.rb

@@ -7,8 +7,12 @@ module Geos
           FFIGeos.GEOSGeomGetX_r(Geos.current_handle, self.ptr, ret)
         }.read_double
       end
-      alias :x :get_x
+    else
+      def get_x
+        self.coord_seq.get_x(0)
+      end
     end
+    alias :x :get_x
 
     if FFIGeos.respond_to?(:GEOSGeomGetY_r)
       def get_y
@@ -16,7 +20,61 @@ module Geos
           FFIGeos.GEOSGeomGetY_r(Geos.current_handle, self.ptr, ret)
         }.read_double
       end
-      alias :y :get_y
+    else
+      def get_y
+        self.coord_seq.get_y(0)
+      end
+    end
+    alias :y :get_y
+
+    if FFIGeos.respond_to?(:GEOSGeomGetZ_r)
+      def get_z
+        FFI::MemoryPointer.new(:double).tap { |ret|
+          FFIGeos.GEOSGeomGetZ_r(Geos.current_handle, self.ptr, ret)
+        }.read_double
+      end
+    else
+      def get_z
+        self.coord_seq.get_z(0)
+      end
+    end
+    alias :z :get_z
+
+    def area
+      0
+    end
+
+    def length
+      0
+    end
+
+    def num_geometries
+      1
+    end
+
+    def num_coordinates
+      1
+    end
+
+    def normalize!
+      self
+    end
+    alias :normalize :normalize!
+
+    %w{
+      convex_hull
+      point_on_surface
+      centroid
+      envelope
+      topology_preserve_simplify
+    }.each do |method|
+      self.class_eval(<<-EOF)
+        def #{method}(*args)
+          self.dup.tap { |ret|
+            ret.srid = pick_srid_according_to_policy(ret.srid)
+          }
+        end
+      EOF
     end
   end
 end

data/lib/ffi-geos/polygon.rb

@@ -9,12 +9,23 @@ module Geos
       if n < 0 || n >= self.num_interior_rings
         raise RuntimeError.new("Index out of bounds")
       else
-        cast_geometry_ptr(FFIGeos.GEOSGetInteriorRingN_r(Geos.current_handle, self.ptr, n), false)
+        cast_geometry_ptr(
+          FFIGeos.GEOSGetInteriorRingN_r(Geos.current_handle, self.ptr, n), {
+            :auto_free => false,
+            :srid_copy => self.srid
+          }
+        )
       end
     end
+    alias :interior_ring :interior_ring_n
 
     def exterior_ring
-      cast_geometry_ptr(FFIGeos.GEOSGetExteriorRing_r(Geos.current_handle, self.ptr), false)
+      cast_geometry_ptr(
+        FFIGeos.GEOSGetExteriorRing_r(Geos.current_handle, self.ptr), {
+          :auto_free => false,
+          :srid_copy => self.srid
+        }
+      )
     end
 
     def interior_rings

data/lib/ffi-geos/tools.rb

@@ -3,7 +3,11 @@ module Geos
   module Tools
     include GeomTypes
 
-    def cast_geometry_ptr(geom_ptr, auto_free = true)
+    def cast_geometry_ptr(geom_ptr, options = {})
+      options = {
+        :auto_free => true
+      }.merge(options)
+
       if geom_ptr.null?
         raise RuntimeError.new("Tried to create a Geometry from a NULL pointer!")
       end
@@ -29,13 +33,42 @@ module Geos
           raise RuntimeError.new("Invalid geometry type")
       end
 
-      klass.new(geom_ptr, auto_free)
+      klass.new(geom_ptr, options[:auto_free]).tap { |ret|
+        if options[:srid]
+          ret.srid = options[:srid] || 0
+        elsif options[:srid_copy]
+          ret.srid = if Geos.srid_copy_policy == :zero
+            0
+          else
+            options[:srid_copy] || 0
+          end
+        end
+      }
     end
 
     def check_geometry(geom)
       raise TypeError.new("Expected Geos::Geometry") unless geom.is_a?(Geos::Geometry)
     end
 
+    def pick_srid_from_geoms(srid_a, srid_b, policy = Geos.srid_copy_policy)
+      case policy
+        when :zero
+          0
+        when :lenient
+          srid_a
+        when :strict
+          raise Geos::MixedSRIDsError.new(srid_a, srid_b)
+      end
+    end
+
+    def pick_srid_according_to_policy(srid, policy = Geos.srid_copy_policy)
+      if srid != 0 && Geos.srid_copy_policy != :zero
+        self.srid
+      else
+        0
+      end
+    end
+
     def bool_result(r)
       case r
       when 1

data/lib/ffi-geos/utils.rb

@@ -26,98 +26,140 @@ module Geos
         end
       end
 
-      def create_point(cs)
+      def create_point(*args)
+        options = if args.last.is_a?(Hash)
+          args.pop
+        else
+          {}
+        end
+
+        if args.length == 1
+          cs = args.first
+        elsif args.length == 2
+          cs = CoordinateSequence.new(1, 2)
+          cs.x[0], cs.y[0] = args[0], args[1]
+        elsif args.length == 3
+          cs = CoordinateSequence.new(1, 3)
+          cs.x[0], cs.y[0], cs.z[0] = args
+        else
+          raise ArgumentError.new("Wrong number of arguments (#{args.length} for 1-3)")
+        end
+
         if cs.length != 1
           raise RuntimeError.new("IllegalArgumentException: Point coordinate list must contain a single element")
         end
 
-        cs_clone = cs.clone
+        cs_dup = cs.dup
+        cs_dup.ptr.autorelease = false
 
-        cast_geometry_ptr(FFIGeos.GEOSGeom_createPoint_r(Geos.current_handle, cs_clone.ptr)).tap {
-          cs_clone.ptr.autorelease = false
-        }
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createPoint_r(Geos.current_handle, cs_dup.ptr), {
+          :srid => options[:srid]
+        })
       end
 
-      def create_line_string(cs)
+      def create_line_string(cs, options = {})
+        cs = cs_from_cs_or_geom(cs)
+
         if cs.length <= 1 && cs.length != 0
           raise RuntimeError.new("IllegalArgumentException: point array must contain 0 or >1 elements")
         end
 
-        cs_clone = cs.clone
+        cs_dup = cs.dup
+        cs_dup.ptr.autorelease = false
 
-        cast_geometry_ptr(FFIGeos.GEOSGeom_createLineString_r(Geos.current_handle, cs_clone.ptr)).tap {
-          cs_clone.ptr.autorelease = false
-        }
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createLineString_r(Geos.current_handle, cs_dup.ptr), {
+          :srid => options[:srid]
+        })
       end
 
-      def create_linear_ring(cs)
+      def create_linear_ring(cs, options = {})
+        cs = cs_from_cs_or_geom(cs)
+
         if cs.length <= 1 && cs.length != 0
           raise RuntimeError.new("IllegalArgumentException: point array must contain 0 or >1 elements")
         end
 
-        cs_clone = cs.clone
+        cs.ptr.autorelease = false
 
-        cast_geometry_ptr(FFIGeos.GEOSGeom_createLinearRing_r(Geos.current_handle, cs_clone.ptr)).tap {
-          cs_clone.ptr.autorelease = false
-        }
+        ret = cast_geometry_ptr(FFIGeos.GEOSGeom_createLinearRing_r(Geos.current_handle, cs.ptr), {
+          :srid => options[:srid]
+        })
       end
 
-      def create_polygon(outer, *inner)
-        inner_clones = Array(inner).flatten.collect { |i|
+      def create_polygon(outer, *args)
+        options = if args.last.is_a?(Hash)
+          args.pop
+        else
+          {}
+        end
+
+        inner_dups = Array(args).flatten.collect { |i|
           force_to_linear_ring(i) or
             raise TypeError.new("Expected inner Array to contain Geos::LinearRing or Geos::CoordinateSequence objects")
         }
 
-        outer_clone = force_to_linear_ring(outer) or
+        outer_dup = force_to_linear_ring(outer) or
           raise TypeError.new("Expected outer shell to be a Geos::LinearRing or Geos::CoordinateSequence")
 
-        ary = FFI::MemoryPointer.new(:pointer, inner_clones.length)
-        ary.write_array_of_pointer(inner_clones.map(&:ptr))
+        ary = FFI::MemoryPointer.new(:pointer, inner_dups.length)
+        ary.write_array_of_pointer(inner_dups.map(&:ptr))
 
-        cast_geometry_ptr(FFIGeos.GEOSGeom_createPolygon_r(Geos.current_handle, outer_clone.ptr, ary, inner_clones.length)).tap {
-          outer_clone.ptr.autorelease = false
-          inner_clones.each { |i| i.ptr.autorelease = false }
+        outer_dup.ptr.autorelease = false
+        inner_dups.each { |i|
+          i.ptr.autorelease = false
         }
+
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createPolygon_r(Geos.current_handle, outer_dup.ptr, ary, inner_dups.length), {
+          :srid => options[:srid]
+        })
       end
 
-      def create_empty_point
-        cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyPoint_r(Geos.current_handle))
+      def create_empty_point(options = {})
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyPoint_r(Geos.current_handle), {
+          :srid => options[:srid]
+        })
       end
 
-      def create_empty_line_string
-        cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyLineString_r(Geos.current_handle))
+      def create_empty_line_string(options = {})
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyLineString_r(Geos.current_handle), {
+          :srid => options[:srid]
+        })
       end
 
-      def create_empty_polygon
-        cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyPolygon_r(Geos.current_handle))
+      def create_empty_polygon(options = {})
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyPolygon_r(Geos.current_handle), {
+          :srid => options[:srid]
+        })
       end
 
-      def create_empty_collection(t)
+      def create_empty_collection(t, options = {})
         check_enum_value(Geos::GeometryTypes, t)
-        cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyCollection_r(Geos.current_handle, t))
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyCollection_r(Geos.current_handle, t), {
+          :srid => options[:srid]
+        })
       end
 
-      def create_empty_multi_point
-        create_empty_collection(:multi_point)
+      def create_empty_multi_point(options = {})
+        create_empty_collection(:multi_point, options)
       end
 
-      def create_empty_multi_line_string
-        create_empty_collection(:multi_line_string)
+      def create_empty_multi_line_string(options = {})
+        create_empty_collection(:multi_line_string, options)
       end
 
-      def create_empty_multi_polygon
-        create_empty_collection(:multi_polygon)
+      def create_empty_multi_polygon(options = {})
+        create_empty_collection(:multi_polygon, options)
       end
 
-      def create_empty_geometry_collection
-        create_empty_collection(:geometry_collection)
+      def create_empty_geometry_collection(options = {})
+        create_empty_collection(:geometry_collection, options)
       end
 
-      def create_empty_linear_ring
-        Geos::WktReader.new.read('LINEARRING EMPTY')
+      def create_empty_linear_ring(options = {})
+        Geos::WktReader.new.read('LINEARRING EMPTY', options)
       end
 
-      def create_collection(t, *geoms)
+      def create_collection(t, *args)
         check_enum_value(Geos::GeometryTypes, t)
 
         klass = case t
@@ -131,47 +173,63 @@ module Geos
             Geos::Geometry
         end
 
-        geoms = Array(geoms).flatten.tap { |i|
+        options = if args.last.is_a?(Hash)
+          args.pop
+        else
+          {}
+        end
+
+        geoms = Array(args).flatten.tap { |i|
           if i.detect { |g| !g.is_a?(klass) }
             raise TypeError.new("Expected geoms Array to contain #{klass} objects")
           end
         }
 
-        geoms_clones = geoms.map(&:clone)
+        geoms_dups = geoms.map(&:dup)
+        geoms_dups.each { |i|
+          i.ptr.autorelease = false
+        }
 
         ary = FFI::MemoryPointer.new(:pointer, geoms.length)
-        ary.write_array_of_pointer(geoms_clones.map(&:ptr))
+        ary.write_array_of_pointer(geoms_dups.map(&:ptr))
 
-        cast_geometry_ptr(FFIGeos.GEOSGeom_createCollection_r(Geos.current_handle, t, ary, geoms_clones.length)).tap {
-          geoms_clones.each { |i|
-            i.ptr.autorelease = false
-          }
-        }
+        cast_geometry_ptr(FFIGeos.GEOSGeom_createCollection_r(Geos.current_handle, t, ary, geoms_dups.length), {
+          :srid => options[:srid]
+        })
       end
 
-      def create_multi_point(*geoms)
-        create_collection(:multi_point, *geoms)
+      def create_multi_point(*args)
+        create_collection(:multi_point, *args)
       end
 
-      def create_multi_line_string(*geoms)
-        create_collection(:multi_line_string, *geoms)
+      def create_multi_line_string(*args)
+        create_collection(:multi_line_string, *args)
       end
 
-      def create_multi_polygon(*geoms)
-        create_collection(:multi_polygon, *geoms)
+      def create_multi_polygon(*args)
+        create_collection(:multi_polygon, *args)
       end
 
-      def create_geometry_collection(*geoms)
-        create_collection(:geometry_collection, *geoms)
+      def create_geometry_collection(*args)
+        create_collection(:geometry_collection, *args)
       end
 
       private
-        def force_to_linear_ring(geom)
-          case geom
+        def cs_from_cs_or_geom(geom_or_cs)
+          case geom_or_cs
+            when Array
+              Geos::CoordinateSequence.new(geom_or_cs)
+            when Geos::CoordinateSequence
+              geom_or_cs.dup
+          end
+        end
+
+        def force_to_linear_ring(geom_or_cs)
+          case geom_or_cs
             when Geos::CoordinateSequence
-              geom.to_linear_ring
+              geom_or_cs.to_linear_ring
             when Geos::LinearRing
-              geom.clone
+              geom_or_cs.dup
           end
         end
     end