ffi-geos 0.0.1.beta1 → 0.0.1.beta2

data/lib/geometry.rb

@@ -71,60 +71,27 @@ module Geos
     # :call-seq:
     #   buffer(width)
     #   buffer(width, options)
+    #   buffer(width, buffer_params)
     #   buffer(width, quad_segs)
     #
-    # Calls buffer on the Geometry. Calling with an options Hash is equivalent
-    # to calling buffer_with_style.
-    #
-    # By default, quad_segs is set to 8.
-    def buffer(width, *args)
-      quad_segs, options = if args.length <= 0
-        [ 8, nil ]
-      else
-        if args.first.is_a?(Hash)
-          [ args.first[:quad_segs] || 8, args.first ]
-        else
-          [ args.first, args[1] ]
-        end
-      end
-
-      if options
-        if options.is_a?(Hash)
-          self.buffer_with_style(width, options)
+    # Calls buffer on the Geometry. Options can be passed as either a
+    # BufferParams object, as an equivalent Hash or as a quad_segs value. By
+    # default, the default values found in Geos::Constants::BUFFER_PARAMS_DEFAULTS
+    # are used.
+    def buffer(width, options = nil)
+      options ||= {}
+      params = case options
+        when Hash
+          Geos::BufferParams.new(options)
+        when Geos::BufferParams
+          options
+        when Numeric
+          Geos::BufferParams.new(:quad_segs => options)
         else
-          raise RuntimeError.new("Expected an options Hash")
-        end
-      else
-        cast_geometry_ptr(FFIGeos.GEOSBuffer_r(Geos.current_handle, self.ptr, width, quad_segs))
+          raise ArgumentError.new("Expected Geos::BufferParams, a Hash or a Numeric")
       end
-    end
 
-    # Options:
-    #
-    # * :quad_segs - defaults to 8.
-    # * :endcap - defaults :round.
-    # * :join - defaults to :round.
-    # * :mitre_limit - defaults to 5.0.
-    def buffer_with_style(width, options = {})
-      options = {
-        :quad_segs => 8,
-        :endcap => :round,
-        :join => :round,
-        :mitre_limit => 5.0
-      }.merge(options)
-
-      check_enum_value(Geos::BufferCapStyles, options[:endcap]) if options[:endcap]
-      check_enum_value(Geos::BufferJoinStyles, options[:join]) if options[:join]
-
-      cast_geometry_ptr(FFIGeos.GEOSBufferWithStyle_r(
-          Geos.current_handle,
-          self.ptr,
-          width,
-          options[:quad_segs],
-          options[:endcap],
-          options[:join],
-          options[:mitre_limit]
-      ))
+      cast_geometry_ptr(FFIGeos.GEOSBufferWithParams_r(Geos.current_handle, self.ptr, params.ptr, width))
     end
 
     def convex_hull
@@ -426,10 +393,14 @@ module Geos
       }.read_double
     end
 
-    def hausdorff_distance(geom)
+    def hausdorff_distance(geom, densify_frac = nil)
       check_geometry(geom)
       FFI::MemoryPointer.new(:double).tap { |ret|
-        FFIGeos.GEOSHausdorffDistance_r(Geos.current_handle, self.ptr, geom.ptr, ret)
+        if densify_frac
+          FFIGeos.GEOSHausdorffDistanceDensify_r(Geos.current_handle, self.ptr, geom.ptr, densify_frac, ret)
+        else
+          FFIGeos.GEOSHausdorffDistance_r(Geos.current_handle, self.ptr, geom.ptr, ret)
+        end
       }.read_double
     end
 

data/lib/line_string.rb

@@ -33,22 +33,16 @@ module Geos
     end
     alias :slice :[]
 
-    def buffer_single_sided(width, options = {})
-      options = {
-        :quad_segs => 8,
-        :join => :round,
-        :mitre_limit => 5.0,
-        :left_side => false
-      }.merge(options)
-
-      cast_geometry_ptr(FFIGeos.GEOSSingleSidedBuffer_r(
+    def offset_curve(width, options = {})
+      options = Constants::BUFFER_PARAM_DEFAULTS.merge(options)
+
+      cast_geometry_ptr(FFIGeos.GEOSOffsetCurve_r(
           Geos.current_handle,
           self.ptr,
           width,
           options[:quad_segs],
           options[:join],
-          options[:mitre_limit],
-          options[:left_side] ? 1 : 0
+          options[:mitre_limit]
       ))
     end
 

data/lib/prepared_geometry.rb

@@ -29,14 +29,44 @@ module Geos
       bool_result(FFIGeos.GEOSPreparedContainsProperly_r(Geos.current_handle, self.ptr, geom.ptr))
     end
 
+    def covered_by?(geom)
+      check_geometry(geom)
+      bool_result(FFIGeos.GEOSPreparedCoveredBy_r(Geos.current_handle, self.ptr, geom.ptr))
+    end
+
     def covers?(geom)
       check_geometry(geom)
       bool_result(FFIGeos.GEOSPreparedCovers_r(Geos.current_handle, self.ptr, geom.ptr))
     end
 
+    def crosses?(geom)
+      check_geometry(geom)
+      bool_result(FFIGeos.GEOSPreparedCrosses_r(Geos.current_handle, self.ptr, geom.ptr))
+    end
+
+    def disjoint?(geom)
+      check_geometry(geom)
+      bool_result(FFIGeos.GEOSPreparedDisjoint_r(Geos.current_handle, self.ptr, geom.ptr))
+    end
+
     def intersects?(geom)
       check_geometry(geom)
       bool_result(FFIGeos.GEOSPreparedIntersects_r(Geos.current_handle, self.ptr, geom.ptr))
     end
+
+    def overlaps?(geom)
+      check_geometry(geom)
+      bool_result(FFIGeos.GEOSPreparedOverlaps_r(Geos.current_handle, self.ptr, geom.ptr))
+    end
+
+    def touches?(geom)
+      check_geometry(geom)
+      bool_result(FFIGeos.GEOSPreparedTouches_r(Geos.current_handle, self.ptr, geom.ptr))
+    end
+
+    def within?(geom)
+      check_geometry(geom)
+      bool_result(FFIGeos.GEOSPreparedWithin_r(Geos.current_handle, self.ptr, geom.ptr))
+    end
   end
 end

data/lib/tools.rb

@@ -50,5 +50,13 @@ module Geos
     def check_enum_value(enum, value)
       raise TypeError.new("Couldn't find valid #{enum.tag} value: #{value}") unless enum[value]
     end
+
+    def symbol_for_enum(enum, value)
+      if value.is_a?(Symbol)
+        value
+      else
+        enum[value]
+      end
+    end
   end
 end

data/lib/utils.rb

@@ -3,9 +3,14 @@ module Geos
   module Utils
     class << self
       include Geos::Tools
+      include Geos::GeomTypes
 
       if FFIGeos.respond_to?(:GEOSOrientationIndex_r)
-        # Available in GEOS 3.3+.
+        # * -1 if reaching P takes a counter-clockwise (left) turn
+        # * 1 if reaching P takes a clockwise (right) turn
+        # * 0 if P is collinear with A-B
+        #
+        # Available in GEOS 3.3.0+.
         def orientation_index(ax, ay, bx, by, px, py)
           FFIGeos.GEOSOrientationIndex_r(
             Geos.current_handle,
@@ -15,7 +20,7 @@ module Geos
       end
 
       if FFIGeos.respond_to?(:GEOSRelatePatternMatch_r)
-        # Available in GEOS 3.3+.
+        # Available in GEOS 3.3.0+.
         def relate_match(mat, pat)
           bool_result(FFIGeos.GEOSRelatePatternMatch_r(Geos.current_handle, mat, pat))
         end
@@ -80,34 +85,37 @@ module Geos
       end
 
       def create_empty_collection(t)
+        check_enum_value(Geos::GeometryTypes, t)
         cast_geometry_ptr(FFIGeos.GEOSGeom_createEmptyCollection_r(Geos.current_handle, t))
       end
 
       def create_empty_multi_point
-        create_empty_collection(Geos::GeomTypes::GEOS_MULTIPOINT)
+        create_empty_collection(:multi_point)
       end
 
       def create_empty_multi_line_string
-        create_empty_collection(Geos::GeomTypes::GEOS_MULTILINESTRING)
+        create_empty_collection(:multi_line_string)
       end
 
       def create_empty_multi_polygon
-        create_empty_collection(Geos::GeomTypes::GEOS_MULTIPOLYGON)
+        create_empty_collection(:multi_polygon)
       end
 
       def create_empty_geometry_collection
-        create_empty_collection(Geos::GeomTypes::GEOS_GEOMETRYCOLLECTION)
+        create_empty_collection(:geometry_collection)
       end
 
       def create_collection(t, *geoms)
+        check_enum_value(Geos::GeometryTypes, t)
+
         klass = case t
-          when Geos::GeomTypes::GEOS_MULTIPOINT
+          when GEOS_MULTIPOINT, :multi_point
             Geos::Point
-          when Geos::GeomTypes::GEOS_MULTILINESTRING
+          when GEOS_MULTILINESTRING, :multi_line_string
             Geos::LineString
-          when Geos::GeomTypes::GEOS_MULTIPOLYGON
+          when GEOS_MULTIPOLYGON, :multi_polygon
             Geos::Polygon
-          when Geos::GeomTypes::GEOS_GEOMETRYCOLLECTION
+          when GEOS_GEOMETRYCOLLECTION, :geometry_collection
             Geos::Geometry
         end
 
@@ -126,19 +134,19 @@ module Geos
       end
 
       def create_multi_point(*geoms)
-        create_collection(Geos::GeomTypes::GEOS_MULTIPOINT, *geoms)
+        create_collection(:multi_point, *geoms)
       end
 
       def create_multi_line_string(*geoms)
-        create_collection(Geos::GeomTypes::GEOS_MULTILINESTRING, *geoms)
+        create_collection(:multi_line_string, *geoms)
       end
 
       def create_multi_polygon(*geoms)
-        create_collection(Geos::GeomTypes::GEOS_MULTIPOLYGON, *geoms)
+        create_collection(:multi_polygon, *geoms)
       end
 
       def create_geometry_collection(*geoms)
-        create_collection(Geos::GeomTypes::GEOS_GEOMETRYCOLLECTION, *geoms)
+        create_collection(:geometry_collection, *geoms)
       end
     end
   end

data/test/geometry_tests.rb

@@ -33,142 +33,148 @@ class GeometryTests < Test::Unit::TestCase
   end
 
   def test_buffer
-    geom = read('POINT(0 0)')
-    assert_equal('POLYGON EMPTY', write(geom.buffer(0)))
-
-    assert(read('POLYGON ((
-      10.0000000000000000 0.0000000000000000, 9.8078528040323043 -1.9509032201612808,
-      9.2387953251128696 -3.8268343236508939, 8.3146961230254561 -5.5557023301960173,
-      7.0710678118654808 -7.0710678118654702, 5.5557023301960315 -8.3146961230254472,
-      3.8268343236509086 -9.2387953251128625, 1.9509032201612964 -9.8078528040323025,
-      0.0000000000000162 -10.0000000000000000, -1.9509032201612646 -9.8078528040323079,
-      -3.8268343236508784 -9.2387953251128749, -5.5557023301960040 -8.3146961230254650,
-      -7.0710678118654595 -7.0710678118654924, -8.3146961230254384 -5.5557023301960431,
-      -9.2387953251128572 -3.8268343236509232, -9.8078528040322990 -1.9509032201613119,
-      -10.0000000000000000 -0.0000000000000323, -9.8078528040323114 1.9509032201612488,
-      -9.2387953251128820 3.8268343236508642, -8.3146961230254739 5.5557023301959898,
-      -7.0710678118655048 7.0710678118654453, -5.5557023301960591 8.3146961230254277,
-      -3.8268343236509361 9.2387953251128518, -1.9509032201613217 9.8078528040322972,
-      -0.0000000000000374 10.0000000000000000, 1.9509032201612482 9.8078528040323114,
-      3.8268343236508673 9.2387953251128803, 5.5557023301959960 8.3146961230254686,
-      7.0710678118654542 7.0710678118654959, 8.3146961230254384 5.5557023301960440,
-      9.2387953251128589 3.8268343236509201, 9.8078528040323008 1.9509032201613046,
-      10.0000000000000000 0.0000000000000000
-    ))').eql_exact?(geom.buffer(10), TOLERANCE))
-
-    assert(read("POLYGON ((
-      1.0000000000000000 0.0000000000000000, 0.0000000000000016 -1.0000000000000000,
-      -1.0000000000000000 -0.0000000000000032, -0.0000000000000046 1.0000000000000000,
-      1.0000000000000000 0.0000000000000000
-    ))").eql_exact?(geom.buffer(1, 1), TOLERANCE))
-  end
+    tester = lambda { |expected, geom, *args|
+      width, params = args
+      assert_equal(expected, write(read(geom).buffer(width, params)))
+    }
 
-  if ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:buffer_with_style)
-    def test_buffer_with_style
-      tester = lambda { |expected, g, width, style|
-        geom = read(g)
-        buffered = geom.buffer(width, style)
+    @writer.rounding_precision = 0
 
-        assert_equal(expected, write(buffered))
-      }
+    tester['POLYGON EMPTY', 'POINT(0 0)', 0]
 
-      @writer.rounding_precision = 0
+    tester[
+      'POLYGON ((10 0, 10 -2, 9 -4, 8 -6, 7 -7, 6 -8, 4 -9, 2 -10, 0 -10, -2 -10, -4 -9, -6 -8, -7 -7, -8 -6, -9 -4, -10 -2, -10 -0, -10 2, -9 4, -8 6, -7 7, -6 8, -4 9, -2 10, -0 10, 2 10, 4 9, 6 8, 7 7, 8 6, 9 4, 10 2, 10 0))',
+      'POINT(0 0)',
+      10
+    ]
 
-      tester[
-        'POLYGON ((100 10, 110 0, 100 -10, 0 -10, -10 0, 0 10, 100 10))',
-        'LINESTRING(0 0, 100 0)',
-        10, {
-          :quad_segs => 1,
-          :endcap => :round
-        }
-      ]
+    # One segment per quadrant
+    tester[
+      'POLYGON ((10 0, 0 -10, -10 -0, -0 10, 10 0))',
+      'POINT(0 0)',
+      10,
+      { :quad_segs => 1 }
+    ]
 
-      tester[
-        'POLYGON ((100 10, 100 -10, 0 -10, 0 10, 100 10))',
-        'LINESTRING(0 0, 100 0)',
-        10, {
-          :quad_segs => 1,
-          :endcap => :flat
-        }
-      ]
+    # End cap styles
+    tester[
+      'POLYGON ((100 10, 110 0, 100 -10, 0 -10, -10 0, 0 10, 100 10))',
+      'LINESTRING(0 0, 100 0)',
+      10,
+      { :quad_segs => 1, :endcap => :round }
+    ]
 
-      tester[
-        'POLYGON ((100 10, 110 10, 110 -10, 0 -10, -10 -10, -10 10, 100 10))',
-        'LINESTRING(0 0, 100 0)',
-        10, {
-          :quad_segs => 1,
-          :endcap => :square
-        }
-      ]
+    tester[
+      'POLYGON ((100 10, 100 -10, 0 -10, 0 10, 100 10))',
+      'LINESTRING(0 0, 100 0)',
+      10,
+      { :quad_segs => 1, :endcap => :flat }
+    ]
 
-      tester[
-        'POLYGON ((90 10, 90 100, 93 107, 100 110, 107 107, 110 100, 110 0, 107 -7, 100 -10, 0 -10, -7 -7, -10 0, -7 7, 0 10, 90 10))',
-        'LINESTRING(0 0, 100 0, 100 100)',
-        10, {
-          :quad_segs => 2,
-          :join => :round
-        }
-      ]
+    tester[
+      'POLYGON ((100 10, 110 10, 110 -10, 0 -10, -10 -10, -10 10, 100 10))',
+      'LINESTRING(0 0, 100 0)',
+      10,
+      { :quad_segs => 1, :endcap => :square }
+    ]
 
-      tester[
-        'POLYGON ((90 10, 90 100, 93 107, 100 110, 107 107, 110 100, 110 0, 100 -10, 0 -10, -7 -7, -10 0, -7 7, 0 10, 90 10))',
-        'LINESTRING(0 0, 100 0, 100 100)',
-        10, {
-          :quad_segs => 2,
-          :join => :bevel
-        }
-      ]
+    # Join styles
+    tester[
+      'POLYGON ((90 10, 90 100, 93 107, 100 110, 107 107, 110 100, 110 0, 107 -7, 100 -10, 0 -10, -7 -7, -10 0, -7 7, 0 10, 90 10))',
+      'LINESTRING(0 0, 100 0, 100 100)',
+      10,
+      { :quad_segs => 2, :join => :round }
+    ]
 
-      tester[
-        'POLYGON ((90 10, 90 100, 93 107, 100 110, 107 107, 110 100, 110 -10, 0 -10, -7 -7, -10 0, -7 7, 0 10, 90 10))',
-        'LINESTRING(0 0, 100 0, 100 100)',
-        10, {
-          :quad_segs => 2,
-          :join => :mitre
-        }
-      ]
+    tester[
+      'POLYGON ((90 10, 90 100, 93 107, 100 110, 107 107, 110 100, 110 0, 100 -10, 0 -10, -7 -7, -10 0, -7 7, 0 10, 90 10))',
+      'LINESTRING(0 0, 100 0, 100 100)',
+      10,
+      { :quad_segs => 2, :join => :bevel }
+    ]
 
-      tester[
-        'POLYGON ((90 10, 90 100, 93 107, 100 110, 107 107, 110 100, 109 -5, 105 -9, 0 -10, -7 -7, -10 0, -7 7, 0 10, 90 10))',
-        'LINESTRING(0 0, 100 0, 100 100)',
-        10, {
-          :quad_segs => 2,
-          :join => :mitre,
-          :mitre_limit => 1.0
-        }
-      ]
-    end
+    tester[
+      'POLYGON ((90 10, 90 100, 93 107, 100 110, 107 107, 110 100, 110 -10, 0 -10, -7 -7, -10 0, -7 7, 0 10, 90 10))',
+      'LINESTRING(0 0, 100 0, 100 100)',
+      10,
+      { :quad_segs => 2, :join => :mitre }
+    ]
+
+    tester[
+      'POLYGON ((90 10, 90 100, 93 107, 100 110, 107 107, 110 100, 109 -5, 105 -9, 0 -10, -7 -7, -10 0, -7 7, 0 10, 90 10))',
+      'LINESTRING(0 0, 100 0, 100 100)',
+      10,
+      { :quad_segs => 2, :join => :mitre, :mitre_limit => 1.0 }
+    ]
+
+    # Single-sided buffering
+    tester[
+      'POLYGON ((100 0, 0 0, 0 10, 100 10, 100 0))',
+      'LINESTRING(0 0, 100 0)',
+      10,
+      { :single_sided => true }
+    ]
+
+    tester[
+      'POLYGON ((0 0, 100 0, 100 -10, 0 -10, 0 0))',
+      'LINESTRING(0 0, 100 0)',
+      -10,
+      { :single_sided => true }
+    ]
   end
 
-  if ENV['FORCE_TESTS'] || Geos::LineString.method_defined?(:buffer_single_sided)
-    def test_buffer_single_sided
+  if ENV['FORCE_TESTS'] || Geos::LineString.method_defined?(:offset_curve)
+    def test_offset_curve
       tester = lambda { |expected, g, width, style|
         geom = read(g)
-        buffered = geom.buffer_single_sided(width, style)
+        buffered = geom.offset_curve(width, style)
 
         assert_equal(expected, write(buffered))
       }
 
       @writer.rounding_precision = 0
 
+      # straight left
       tester[
         'LINESTRING (0 2, 10 2)',
-        'LINESTRING(0 0, 10 0)',
+        'LINESTRING (0 0, 10 0)',
         2, {
-          :quad_segs => 2,
+          :quad_segs => 0,
           :join => :round,
-          :mitre_limit => 2.0,
-          :left_side => true
+          :mitre_limit => 2
         }
       ]
 
+      # straight right
       tester[
         'LINESTRING (10 -2, 0 -2)',
-        'LINESTRING(0 0, 10 0)',
+        'LINESTRING (0 0, 10 0)',
+        -2, {
+          :quad_segs => 0,
+          :join => :round,
+          :mitre_limit => 2
+        }
+      ]
+
+      # outside curve
+      tester[
+        'LINESTRING (12 10, 12 0, 10 -2, 0 -2)',
+        'LINESTRING (0 0, 10 0, 10 10)',
+        -2, {
+          :quad_segs => 1,
+          :join => :round,
+          :mitre_limit => 2
+        }
+      ]
+
+      # inside curve
+      tester[
+        'LINESTRING (0 2, 8 2, 8 10)',
+        'LINESTRING (0 0, 10 0, 10 10)',
         2, {
-          :quad_segs => 2,
+          :quad_segs => 1,
           :join => :round,
-          :mitre_limit => 2.0
+          :mitre_limit => 2
         }
       ]
     end
@@ -1267,6 +1273,20 @@ class GeometryTests < Test::Unit::TestCase
       tester[2.23606797749979, geom_a, 'POINT(-1 0)']
       tester[9.0, geom_a, 'LINESTRING (3 0 , 10 0)']
     end
+
+    def test_hausdorff_distance_with_densify_fract
+      tester = lambda { |expected, g1, g2|
+        geom_1 = read(g1)
+        geom_2 = read(g2)
+        assert_in_delta(expected, geom_1.hausdorff_distance(geom_2, 0.001), TOLERANCE)
+      }
+
+      geom_a = 'POLYGON ((0 0, 1 0, 1 1, 0 1, 0 0))'
+
+      tester[10.0498756211209, geom_a, 'POINT(0 10)']
+      tester[2.23606797749979, geom_a, 'POINT(-1 0)']
+      tester[9.0, geom_a, 'LINESTRING (3 0 , 10 0)']
+    end
   end
 
   if ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:snap)