add one arg methods for all geometric predicates (#304)

Author: asinghvi17

src/methods/geom_relations/contains.jl

@@ -62,4 +62,12 @@ GO.contains(line, point)
 true
 ```
 """
-contains(g1, g2) = GeometryOps.within(g2, g1)
+contains(g1, g2) = GeometryOps.within(g2, g1)
+
+"""
+    contains(g1)
+
+Return a function that checks if its input contains `g1`.
+This is equivalent to `x -> contains(x, g1)`.
+"""
+contains(g1) = Base.Fix2(contains, g1)

src/methods/geom_relations/coveredby.jl

@@ -79,6 +79,14 @@ true
 """
 coveredby(g1, g2) = _coveredby(trait(g1), g1, trait(g2), g2)
 
+"""
+    coveredby(g1)
+
+Return a function that checks if its input is covered by `g1`.
+This is equivalent to `x -> coveredby(x, g1)`.
+"""
+coveredby(g1) = Base.Fix2(coveredby, g1)
+
 # # Convert features to geometries
 _coveredby(::GI.FeatureTrait, g1, ::Any, g2) = coveredby(GI.geometry(g1), g2)
 _coveredby(::Any, g1, t2::GI.FeatureTrait, g2) = coveredby(g1, GI.geometry(g2))

src/methods/geom_relations/covers.jl

@@ -62,3 +62,11 @@ true
 ```
 """
 covers(g1, g2)::Bool = GeometryOps.coveredby(g2, g1)
+
+"""
+    covers(g1)
+
+Return a function that checks if its input covers `g1`.
+This is equivalent to `x -> covers(x, g1)`.
+"""
+covers(g1) = Base.Fix2(covers, g1)

src/methods/geom_relations/crosses.jl

@@ -26,7 +26,13 @@ crosses(::LineStringTrait, g1, ::LineStringTrait, g2)::Bool = line_crosses_line(
 crosses(::PolygonTrait, g1, ::MultiPointTrait, g2)::Bool = multipoint_crosses_poly(g2, g1)
 crosses(::PolygonTrait, g1, ::LineStringTrait, g2)::Bool = line_crosses_poly(g2, g1)
 
+"""
+    crosses(g1)
 
+Return a function that checks if its input crosses `g1`.
+This is equivalent to `x -> crosses(x, g1)`.
+"""
+crosses(g1) = Base.Fix2(crosses, g1)
 
 function crosses(t1::GI.AbstractGeometryTrait, g1, t2, e::Extents.Extent)
     return crosses(t1, g1, GI.PolygonTrait(), extent_to_polygon(e))

src/methods/geom_relations/disjoint.jl

@@ -75,6 +75,14 @@ true
 """
 disjoint(g1, g2) = _disjoint(trait(g1), g1, trait(g2), g2)
 
+"""
+    disjoint(g1)
+
+Return a function that checks if its input is disjoint from `g1`.
+This is equivalent to `x -> disjoint(x, g1)`.
+"""
+disjoint(g1) = Base.Fix2(disjoint, g1)
+
 # # Convert features to geometries
 _disjoint(::FeatureTrait, g1, ::Any, g2) = disjoint(GI.geometry(g1), g2)
 _disjoint(::Any, g1, ::FeatureTrait, g2) = disjoint(g1, geometry(g2))

src/methods/geom_relations/intersects.jl

@@ -56,3 +56,11 @@ true
 ```
 """
 intersects(geom1, geom2) = !disjoint(geom1, geom2)
+
+"""
+    intersects(g1)
+
+Return a function that checks if its input intersects `g1`.
+This is equivalent to `x -> intersects(x, g1)`.
+"""
+intersects(g1) = Base.Fix2(intersects, g1)

src/methods/geom_relations/overlaps.jl

@@ -76,6 +76,14 @@ overlaps(geom1, geom2)::Bool = overlaps(
     geom2,
 )
 
+"""
+    overlaps(g1)
+
+Return a function that checks if its input overlaps `g1`.
+This is equivalent to `x -> overlaps(x, g1)`.
+"""
+overlaps(g1) = Base.Fix2(overlaps, g1)
+
 """
     overlaps(::GI.AbstractTrait, geom1, ::GI.AbstractTrait, geom2)::Bool
 

src/methods/geom_relations/touches.jl

@@ -78,6 +78,14 @@ true
 """
 touches(g1, g2)::Bool = _touches(trait(g1), g1, trait(g2), g2)
 
+"""
+    touches(g1)
+
+Return a function that checks if its input touches `g1`.
+This is equivalent to `x -> touches(x, g1)`.
+"""
+touches(g1) = Base.Fix2(touches, g1)
+
 # # Convert features to geometries
 _touches(::GI.FeatureTrait, g1, ::Any, g2) = touches(GI.geometry(g1), g2)
 _touches(::Any, g1, t2::GI.FeatureTrait, g2) = touches(g1, GI.geometry(g2))

src/methods/geom_relations/within.jl

@@ -82,6 +82,14 @@ true
 """
 within(g1, g2) = _within(trait(g1), g1, trait(g2), g2)
 
+"""
+    within(g1)
+
+Return a function that checks if its input is within `g1`.
+This is equivalent to `x -> within(x, g1)`.
+"""
+within(g1) = Base.Fix2(within, g1)
+
 # # Convert features to geometries
 _within(::GI.FeatureTrait, g1, ::Any, g2) = within(GI.geometry(g1), g2)
 _within(::Any, g1, t2::GI.FeatureTrait, g2) = within(g1, GI.geometry(g2))

test/methods/geom_relations.jl

@@ -331,3 +331,15 @@ end
         @test GO.crosses(GI.LineString([(-2.0, 2.0), (-4.0, 2.0)]), $poly7) == false
     end
 end
+
+@testset "Single-argument methods" begin
+    @test GO.contains(p2)(p1) == GO.contains(p1, p2)
+    @test GO.coveredby(p2)(p1) == GO.coveredby(p1, p2)
+    @test GO.covers(p2)(p1) == GO.covers(p1, p2)
+    @test GO.crosses(l2)(l1) == GO.crosses(l1, l2)
+    @test GO.disjoint(p2)(p1) == GO.disjoint(p1, p2)
+    @test GO.intersects(p2)(p1) == GO.intersects(p1, p2)
+    @test GO.overlaps(p2)(p1) == GO.overlaps(p1, p2)
+    @test GO.touches(p2)(p1) == GO.touches(p1, p2)
+    @test GO.within(p2)(p1) == GO.within(p1, p2)
+end