allow table rows in relations, and reorganise boilerplate (#347)

* allow table rows in relations, and reorganise boilerplate

* tweaks

* forward more keywords

* add tests and bugfix

* remove AG

Co-authored-by: Anshul Singhvi <[email protected]>

* Actually remove AG

---------

Co-authored-by: Anshul Singhvi <[email protected]>

Author: rafaqz

src/GeometryOps.jl

@@ -82,6 +82,7 @@ include("methods/geom_relations/intersects.jl")
 include("methods/geom_relations/overlaps.jl")
 include("methods/geom_relations/touches.jl")
 include("methods/geom_relations/within.jl")
+include("methods/geom_relations/common.jl")
 include("methods/orientation.jl")
 include("methods/polygonize.jl")
 

src/methods/geom_relations/common.jl

@@ -0,0 +1,32 @@
+# Identical boilerplate methods for geom relations live here
+
+for f in (:coveredby, :crosses, :disjoint, :overlaps, :touches, :within)
+    _f = Symbol(:_, f)
+
+    @eval begin
+        # Features
+        $_f(::GI.FeatureTrait, g1, ::GI.AbstractGeometryTrait, g2; kw...) = $f(GI.geometry(g1), g2; kw...)
+        $_f(::GI.AbstractGeometryTrait, g1, ::GI.FeatureTrait, g2; kw...) = $f(g1, GI.geometry(g2); kw...)
+        $_f(::GI.FeatureTrait, g1, ::GI.FeatureTrait, g2; kw...) = $f(GI.geometry(g1), GI.geometry(g2); kw...)
+
+        # Extent forwarding
+        $_f(t1::GI.FeatureTrait, f1, ::Nothing, e::Extents.Extent; kw...) =
+            $_f(t1, f1, GI.PolygonTrait(), extent_to_polygon(e); kw...)
+        $_f(::Nothing, e1::Extents.Extent, t2::GI.FeatureTrait, f2; kw...) =
+            $_f(GI.PolygonTrait(), extent_to_polygon(e1), t2, f2; kw...)
+        $_f(t1::GI.AbstractGeometryTrait, g1, ::Nothing, e::Extents.Extent; kw...) =
+            $_f(t1, g1, GI.PolygonTrait(), extent_to_polygon(e); kw...)
+        $_f(::Nothing, e1::Extents.Extent, t2::GI.AbstractGeometryTrait, g2; kw...) =
+            $_f(GI.PolygonTrait(), extent_to_polygon(e1), t2, g2; kw...)
+        $_f(::Nothing, e1::Extents.Extent, ::Nothing, e2::Extents.Extent; kw...) =          
+            Extents.$f(e1, e2)                                                              
+                                                                                                    
+        # Table rows ? or error                                                             
+        $_f(::Nothing, g1, ::GI.FeatureTrait, f2; kw...) = $f(_geometry_or_error(g1; kw...), f2)                                                                                         
+        $_f(::GI.FeatureTrait, f1, ::Nothing, g2; kw...) = $f(f1, _geometry_or_error(g2; kw...))
+        $_f(::Nothing, g1, ::GI.AbstractGeometryTrait, g2; kw...) = $f(_geometry_or_error(g1; kw...), g2)
+        $_f(::GI.AbstractGeometryTrait, g1, ::Nothing, g2; kw...) = $f(g1, _geometry_or_error(g2; kw...))
+        $_f(::Nothing, g1, ::Nothing, g2; kw...) =                                          
+            $f(_geometry_or_error(g1; kw...), _geometry_or_error(g2; kw...))    
+        end
+end

src/methods/geom_relations/coveredby.jl

@@ -87,11 +87,6 @@ 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))
-_coveredby(::FeatureTrait, g1, ::FeatureTrait, g2) = coveredby(GI.geometry(g1), GI.geometry(g2))
-
 # # Points coveredby geometries
 
 # Point is coveredby another point if those points are equal
@@ -279,16 +274,3 @@ function _coveredby(
     end
     return true
 end
-
-# Extent forwarding
-function _coveredby(t1::GI.AbstractGeometryTrait, g1, t2, e::Extents.Extent)
-    return _coveredby(t1, g1, GI.PolygonTrait(), extent_to_polygon(e))
-end
-function _coveredby(t1, e1::Extents.Extent, t2, g2)
-    return _coveredby(GI.PolygonTrait(), extent_to_polygon(e1), t2, g2)
-end
-function _coveredby(t1, e1::Extents.Extent, t2, e2::Extents.Extent)
-    return Extents.coveredby(e1, e2)
-end
-
-

src/methods/geom_relations/crosses.jl

@@ -16,8 +16,7 @@ import GeoInterface as GI, GeometryOps as GO
 ```
 """
 crosses(g1, g2)::Bool = crosses(trait(g1), g1, trait(g2), g2)::Bool
-crosses(t1::FeatureTrait, g1, t2, g2)::Bool = crosses(GI.geometry(g1), g2)
-crosses(t1, g1, t2::FeatureTrait, g2)::Bool = crosses(g1, geometry(g2))
+
 crosses(::MultiPointTrait, g1, ::LineStringTrait, g2)::Bool = multipoint_crosses_line(g1, g2)
 crosses(::MultiPointTrait, g1, ::PolygonTrait, g2)::Bool = multipoint_crosses_poly(g1, g2)
 crosses(::LineStringTrait, g1, ::MultiPointTrait, g2)::Bool = multipoint_crosses_lines(g2, g1)
@@ -34,21 +33,6 @@ 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))
-end
-function crosses(t1, e1::Extents.Extent, t2, g2)
-    return crosses(GI.PolygonTrait(), extent_to_polygon(e1), t2, g2)
-end
-function crosses(t1, e1::Extents.Extent, t2, e2::Extents.Extent)
-    return false # two extents can never cross!
-    # TODO that's not quite true, if one extent is a line...
-end
-
-
-
-
-
 
 
 function multipoint_crosses_line(geom1, geom2)

src/methods/geom_relations/disjoint.jl

@@ -83,11 +83,6 @@ 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))
-_disjoint(::FeatureTrait, g1, ::FeatureTrait, g2) = disjoint(GI.geometry(g1), GI.geometry(g2))
-
 # # Point disjoint geometries
 
 # Point is disjoint from another point if the points are not equal.
@@ -263,17 +258,3 @@ function _disjoint(
     end
     return true
 end
-
-
-# Extent forwarding
-function _disjoint(t1::GI.AbstractGeometryTrait, g1, t2, e::Extents.Extent)
-    return _disjoint(t1, g1, GI.PolygonTrait(), extent_to_polygon(e))
-end
-function _disjoint(t1, e1::Extents.Extent, t2, g2)
-    return _disjoint(GI.PolygonTrait(), extent_to_polygon(e1), t2, g2)
-end
-function _disjoint(t1, e1::Extents.Extent, t2, e2::Extents.Extent)
-    return Extents.disjoint(e1, e2)
-end
-
-

src/methods/geom_relations/overlaps.jl

@@ -4,7 +4,6 @@ export overlaps
 
 #=
 ## What is overlaps?
-
 The overlaps function checks if two geometries overlap. Two geometries can only
 overlap if they have the same dimension, and if they overlap, but one is not
 contained, within, or equal to the other.
@@ -235,18 +234,6 @@ function _overlaps(
     return seg_val == line_over && (!a_fully_within && !b_fully_within)
 end
 
-# Extent forwarding
-
-function _overlaps(t1::GI.AbstractGeometryTrait, g1, t2, e::Extents.Extent)
-    return _overlaps(t1, g1, GI.PolygonTrait(), extent_to_polygon(e))
-end
-function _overlaps(t1, e1::Extents.Extent, t2, g2)
-    return _overlaps(GI.PolygonTrait(), extent_to_polygon(e1), t2, g2)
-end
-function _overlaps(t1, e1::Extents.Extent, t2, e2::Extents.Extent)
-    return Extents.overlaps(e1, e2)
-end
-
 #= TODO: Once overlaps is swapped over to use the geom relations workflow, can
 delete these helpers. =#
 

src/methods/geom_relations/touches.jl

@@ -86,11 +86,6 @@ 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))
-_touches(::FeatureTrait, g1, ::FeatureTrait, g2) = touches(GI.geometry(g1), GI.geometry(g2))
-
 # # Point touches geometries
 
 # Point cannot touch another point as if they are equal, interiors interact
@@ -302,18 +297,3 @@ function _touches(
     end
     return has_touched
 end
-
-# Extent forwarding
-
-
-function _touches(t1::GI.AbstractGeometryTrait, g1, t2, e::Extents.Extent)
-    return _touches(t1, g1, GI.PolygonTrait(), extent_to_polygon(e))
-end
-function _touches(t1, e1::Extents.Extent, t2::GI.AbstractGeometryTrait, g2)
-    return _touches(GI.PolygonTrait(), extent_to_polygon(e1), t2, g2)
-end
-function _touches(t1, e1::Extents.Extent, t2, e2::Extents.Extent)
-    return Extents.touches(e1, e2)
-end
-
-

src/methods/geom_relations/within.jl

@@ -90,11 +90,6 @@ 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))
-_within(::FeatureTrait, g1, ::FeatureTrait, g2) = within(GI.geometry(g1), GI.geometry(g2))
-
 
 # # Points within geometries
 
@@ -286,19 +281,3 @@ function _within(
     end
     return true
 end
-
-
-# Extent forwarding
-
-
-function _within(t1::GI.AbstractGeometryTrait, g1, t2, e::Extents.Extent)
-    return _within(t1, g1, GI.PolygonTrait(), extent_to_polygon(e))
-end
-function _within(t1, e1::Extents.Extent, t2, g2)
-    return _within(GI.PolygonTrait(), extent_to_polygon(e1), t2, g2)
-end
-function _within(t1, e1::Extents.Extent, t2, e2::Extents.Extent)
-    return Extents.within(e1, e2)
-end
-
-

src/utils/utils.jl

@@ -287,7 +287,12 @@ function extent_to_polygon(ext::Extents.Extent{(:Y, :X)})
     return GI.Polygon(StaticArrays.@SVector[GI.LinearRing(StaticArrays.@SVector[(x1, y1), (x2, y1), (x2, y2), (x1, y2), (x1, y1)])])
 end
 
-
-
+# This will accept table rows etc
+# TODO can rows have metadata to detectg the geometry column name?
+function _geometry_or_error(g; geometrycolumn=:geometry)
+    hasproperty(g, geometrycolumn) || throw(ArgumentError("Objects that return no geometry or feature traits must at least have property matching `geometrycolumn: `:$geometrycolumn`"))
+    return getproperty(g, geometrycolumn)
+end
+_geometry_or_error(g::Extents.Extent; kw...) = g
 
 

test/methods/geom_relations.jl

@@ -2,6 +2,7 @@ import GeometryOps as GO
 import GeoInterface as GI
 import LibGEOS as LG
 using Extents
+using DataFrames
 using ..TestHelpers
 
 # Tests of DE-9IM Methods
@@ -343,3 +344,37 @@ end
     @test GO.touches(p2)(p1) == GO.touches(p1, p2)
     @test GO.within(p2)(p1) == GO.within(p1, p2)
 end
+
+@testset "Features, Table rows and Extents" begin
+    feature1 = GI.Feature(pt1; properties=Dict{Symbol, Any}())
+    feature2 = GI.Feature(pt2; properties=Dict{Symbol, Any}())
+    
+    # Test NamedTuple
+    named_tuple1 = (; geometry=pt1)
+    named_tuple2 = (; geometry=pt2)
+    @test GO.disjoint(named_tuple1, named_tuple2) == GO.disjoint(pt1, pt2)
+    @test GO.coveredby(named_tuple1, ext1) == GO.coveredby(pt1, ext1)
+    @test GO.within(named_tuple1, ext1) == GO.within(pt1, ext1)
+
+    # Test DataFrame row
+    df = DataFrame(geometry=[pt1, pt2])
+    df_row1 = df[1, :]
+    df_row2 = df[2, :]
+    @test GO.disjoint(df_row1, df_row2) == GO.disjoint(pt1, pt2)
+    @test GO.coveredby(df_row1, ext1) == GO.coveredby(pt1, ext1)
+    @test GO.within(df_row1, ext1) == GO.within(pt1, ext1)
+
+    # Test features
+    @test GO.disjoint(feature1, feature2) == GO.disjoint(pt1, pt2)
+    @test GO.coveredby(feature1, ext1) == GO.coveredby(pt1, ext1)
+    @test GO.within(feature1, ext1) == GO.within(pt1, ext1)
+    
+    # Test mixed types
+    @test GO.disjoint(feature1, named_tuple2) == GO.disjoint(pt1, pt2)
+    @test GO.coveredby(feature1, ext1) == GO.coveredby(pt1, ext1)
+    @test GO.within(df_row1, ext1) == GO.within(pt1, ext1)
+
+    # Test extents
+    @test GO.disjoint(ext1, ext3) == Extents.disjoint(ext1, ext3)
+    @test GO.coveredby(ext1, ext1) == Extents.coveredby(ext1, ext1)
+end