speed up large polygon intersections using STRtrees.

.github/workflows/CI.yml

@@ -33,8 +33,8 @@ jobs:
           version: ${{ matrix.version }}
           arch: ${{ matrix.arch }}
       - uses: julia-actions/cache@v1
-      - name: Dev GeometryOpsCore`
-        run: julia --project=. -e 'using Pkg; Pkg.develop(; path = joinpath(".", "GeometryOpsCore"))'
+      - name: Dev GeometryOpsCore and add other packages
+        run: julia --project=. -e 'using Pkg; Pkg.develop(; path = joinpath(".", "GeometryOpsCore")); Pkg.add(; name = "SortTileRecursiveTree", rev = "main")'
       - uses: julia-actions/julia-buildpkg@v1
       - uses: julia-actions/julia-runtest@v1
       - uses: julia-actions/julia-processcoverage@v1
@@ -60,13 +60,28 @@ jobs:
         with:
           version: '1'
       - name: Build and add versions
-        run: julia --project=docs -e 'using Pkg; Pkg.develop([PackageSpec(path = "."), PackageSpec(path = joinpath(".", "GeometryOpsCore"))]); Pkg.add([PackageSpec(name = "GeoMakie", rev = "master"), PackageSpec(name="GeoInterface", rev="bugfix_vars")])'
+        run: julia --project=docs -e 'using Pkg; Pkg.develop([PackageSpec(path = "."), PackageSpec(path = joinpath(".", "GeometryOpsCore"))]); Pkg.add([PackageSpec(name = "GeoMakie", rev = "master")])'
       - uses: julia-actions/julia-docdeploy@v1
         with:
           install-package: false
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           DOCUMENTER_KEY: ${{ secrets.DOCUMENTER_KEY }}
+  doctests:
+    name: Doctests
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      statuses: write
+      actions: write
+    steps:
+      - uses: actions/checkout@v2
+      - uses: julia-actions/cache@v1
+      - uses: julia-actions/setup-julia@v1
+        with:
+          version: '1'
+      - name: Build and add versions
+        run: julia --project=docs -e 'using Pkg; Pkg.develop([PackageSpec(path = "."), PackageSpec(path = joinpath(".", "GeometryOpsCore"))]); Pkg.add([PackageSpec(name = "GeoMakie", rev = "master")])'
       - run: |
           julia --project=docs -e '
             using Documenter: DocMeta, doctest

GeometryOpsCore/src/types/algorithm.jl

@@ -16,6 +16,15 @@ Algorithms are:
 
 abstract type Algorithm{M <: Manifold} end
 
+struct AutoAlgorithm{T, M <: Manifold} <: Algorithm{M} 
+    manifold::M
+    x::T
+end
+
+AutoAlgorithm(m::Manifold; kwargs...) = AutoAlgorithm(m, kwargs)
+AutoAlgorithm(; kwargs...) = AutoAlgorithm(AutoManifold(), kwargs)
+
+
 abstract type ManifoldIndependentAlgorithm{M <: Manifold} <: Algorithm{M} end
 
 abstract type SingleManifoldAlgorithm{M <: Manifold} <: Algorithm{M} end

GeometryOpsCore/src/types/manifold.jl

@@ -13,12 +13,14 @@ In GeometryOps (and geodesy more generally), there are three manifolds we care a
 - [`Planar`](@ref): the 2d plane, a completely Euclidean manifold
 - [`Spherical`](@ref): the unit sphere, but one where areas are multiplied by the radius of the Earth.  This is not Euclidean globally, but all map projections attempt to represent the sphere on the Euclidean 2D plane to varying degrees of success.
 - [`Geodesic`](@ref): the ellipsoid, the closest we can come to representing the Earth by a simple geometric shape.  Parametrized by `semimajor_axis` and `inv_flattening`.
+- [`AutoManifold`](@ref): a special manifold that automatically selects the best manifold for the operation when it's executed.  Resolves to [`Planar`](@ref), [`Spherical`](@ref), or [`Geodesic`](@ref) depending on the input geometry.
 
 Generally, we aim to have `Linear` and `Spherical` be operable everywhere, whereas `Geodesic` will only apply in specific circumstances.
-Currently, those circumstances are `area` and `segmentize`, but this could be extended with time and https://github.com/JuliaGeo/SphericalGeodesics.jl.
+Currently, those circumstances are [`area`](@ref), [`arclength`](@ref), and [`segmentize`](@ref), but this could be extended with time and https://github.com/JuliaGeo/SphericalGeodesics.jl.
 =#
 
-export Manifold, Planar, Spherical, Geodesic
+export Manifold, AutoManifold, Planar, Spherical, Geodesic
+
 """
     abstract type Manifold
 
@@ -30,6 +32,16 @@ Currently we have [`Planar`](@ref), [`Spherical`](@ref), and [`Geodesic`](@ref)
 """
 abstract type Manifold end
 
+"""
+    AutoManifold()
+
+The `AutoManifold` is a special manifold that automatically selects the best manifold for the operation.
+It does not carry any parameters, nor does it indicate anything about the nature of the space.
+
+This gets resolved to a specific manifold when an operation is applied.  
+"""
+struct AutoManifold <: Manifold end
+
 """
     Planar()
 
@@ -57,7 +69,7 @@ A spherical manifold means that the geometry is on the 3-sphere (but is represen
     `-90` (south pole) and `90` (north pole).
 """
 Base.@kwdef struct Spherical{T} <: Manifold
-    radius::T = 6371008.8
+    radius::T = 6371008.8 # this should be theWGS84 defined mean radius
 end
 
 """
@@ -69,12 +81,13 @@ and `inv_flattening` (``1/f``).
 Usually, this is only relevant for area and segmentization calculations.  It becomes more relevant as one grows closer to the poles (or equator).
 """
 Base.@kwdef struct Geodesic{T} <: Manifold
-    semimajor_axis::T = 6378137.0
-    inv_flattening::T = 298.257223563
+    semimajor_axis::T = 6378137.0     # WGS84 by default
+    inv_flattening::T = 298.257223563 # WGS84 by default
 end
 
 
 # specifically for manifolds
+# not used now but will be used later
 abstract type EllipsoidParametrization end
 
 struct SemimajorAxisInvFlattening{T} <: EllipsoidParametrization

GeometryOpsCore/src/types/operation.jl

@@ -37,6 +37,18 @@ but if we ever implement e.g. RelateNG in GeometryOps, we can add that in.
 abstract type Operation{Alg <: Algorithm} end
 
 # example
-struct XPlusOneOperation <: Operation{NoAlgorithm}
-    x::Int
+# struct XPlusOneOperation{M <: Manifold} <: Operation{NoAlgorithm{M}}
+#     m::M # the manifold always needs to be stored, since it's not a singleton
+#     x::Int
+# end
+
+
+struct Area{Alg<: Algorithm} <: Operation{Alg}
+    alg::Alg
 end
+
+Area() = Area(NoAlgorithm(Planar()))
+
+function (op::Area{Alg})(data; threaded = _False(), init = 0.0) where {Alg <: Algorithm}
+    return GO.area(op.alg, data; threaded, init)
+end

Project.toml

@@ -4,6 +4,7 @@ authors = ["Anshul Singhvi <[email protected]>", "Rafael Schouten <rafaels
 version = "0.1.12"
 
 [deps]
+AbstractTrees = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"
 CoordinateTransformations = "150eb455-5306-5404-9cee-2592286d6298"
 DataAPI = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a"
 DelaunayTriangulation = "927a84f5-c5f4-47a5-9785-b46e178433df"
@@ -27,6 +28,7 @@ GeometryOpsLibGEOSExt = "LibGEOS"
 GeometryOpsProjExt = "Proj"
 
 [compat]
+AbstractTrees = "0.4.5"
 CoordinateTransformations = "0.5, 0.6"
 DataAPI = "1"
 DelaunayTriangulation = "1.0.4"

benchmarks/benchmark_plots.jl

@@ -73,6 +73,7 @@ function plot_trials(
         legend_orientation = :horizontal,
         legend_halign = 1.0,
         legend_valign = -0.25,
+        legend_kws = (;),
     )
 
     xs, ys, labels = [], [], []
@@ -118,7 +119,8 @@ function plot_trials(
             tellheight = legend_position isa Union{Tuple, Makie.Automatic} && (legend_position isa Makie.Automatic || length(legend_position) != 3) && legend_orientation == :horizontal, 
             halign = legend_halign, 
             valign = legend_valign, 
-            orientation = legend_orientation
+            orientation = legend_orientation,
+            legend_kws...,
         )
         ax.xtickcolor[] = ax.xgridcolor[]
         ax