add more dyadic trees

Author: maltezfaria

src/Trees/clustertree.jl

@@ -122,7 +122,7 @@ during the tree construction.
 """
 function ClusterTree{D}(elements,splitter=CardinalitySplitter();copy_elements=true, threads=false) where {D}
     copy_elements && (elements = deepcopy(elements))
-    if splitter isa DyadicSplitter
+    if splitter isa DyadicSplitter || splitter isa DyadicMinimalSplitter || splitter isa DyadicMaxDepthSplitter
         # make a cube for bounding box for quad/oct trees
         bbox         = HyperRectangle(elements,true)
     else
@@ -143,16 +143,16 @@ function ClusterTree{D}(elements,splitter=CardinalitySplitter();copy_elements=tr
 end
 ClusterTree(args...;kwargs...) = ClusterTree{Nothing}(args...;kwargs...)
 
-function _build_cluster_tree!(current_node,splitter,threads)
-    if should_split(current_node,splitter)
+function _build_cluster_tree!(current_node,splitter,threads,depth=0)
+    if should_split(current_node,depth,splitter)
         split!(current_node,splitter)
         if threads
             Threads.@threads for child in children(current_node)
-                _build_cluster_tree!(child,splitter,threads)
+                _build_cluster_tree!(child,splitter,threads,depth+1)
             end
         else
             for child in children(current_node)
-                _build_cluster_tree!(child,splitter,threads)
+                _build_cluster_tree!(child,splitter,threads,depth+1)
             end
         end
     end

src/Trees/splitter.jl

@@ -13,11 +13,11 @@ See [`GeometricSplitter`](@ref) for an example of an implementation.
 abstract type AbstractSplitter end
 
 """
-    should_split(clt::ClusterTree,splitter::AbstractSplitter)
+    should_split(clt::ClusterTree, depth, splitter::AbstractSplitter)
 
 Determine whether or not a `ClusterTree` should be further divided.
 """
-function should_split(clt, splitter::AbstractSplitter)
+function should_split(clt, depth, splitter::AbstractSplitter)
     abstractmethod(splitter)
 end
 
@@ -41,14 +41,15 @@ Used to split an `N` dimensional `ClusterTree` into `2^N` children until at most
 ## See also: [`AbstractSplitter`](@ref)
 """
 Base.@kwdef struct DyadicSplitter <: AbstractSplitter
-    nmax::Int = typemax(Int)
+    nmax::Int = 50
+    keep_empty::Bool = false
 end
 
-function should_split(node::ClusterTree, splitter::DyadicSplitter)
+function should_split(node::ClusterTree, depth, splitter::DyadicSplitter)
     return length(node) > splitter.nmax
 end
 
-function split!(parentcluster::ClusterTree, ::DyadicSplitter)
+function split!(parentcluster::ClusterTree, spl::DyadicSplitter)
     d = ambient_dimension(parentcluster)
     clusters = [parentcluster]
     rec = container(parentcluster)
@@ -61,10 +62,73 @@ function split!(parentcluster::ClusterTree, ::DyadicSplitter)
             append!(clusters, _binary_split!(clt, i, pos; parentcluster))
         end
     end
+    if !spl.keep_empty
+        iempty = Int[]
+        for (i,cluster) in enumerate(clusters)
+            irange = index_range(cluster)
+            isempty(irange) && (push!(iempty,i))
+        end
+        clusters = deleteat!(clusters,iempty)
+    end
     parentcluster.children = clusters
     return parentcluster
 end
 
+"""
+    struct DyadicMinimalSplitter <: AbstractSplitter
+
+Similar to [`DiadicSplitter`](@ref), but the boundin boxes are shrank to the
+minimal axis-aligned boxes at the end.
+
+## See also: [`AbstractSplitter`](@ref)
+"""
+Base.@kwdef struct DyadicMinimalSplitter <: AbstractSplitter
+    nmax::Int = 50
+    keep_empty::Bool = false
+end
+
+should_split(node::ClusterTree, depth, splitter::DyadicMinimalSplitter) = length(node) > splitter.nmax
+
+function split!(parentcluster::ClusterTree, spl::DyadicMinimalSplitter)
+    # split as a dyadic splitter, then shrink bounding boxes
+    split!(parentcluster,DyadicSplitter(spl.nmax,spl.keep_empty))
+    # shrink bounding boxes to minimal one
+    l2g = loc2glob(parentcluster)
+    root_els = root_elements(parentcluster)
+    clusters = children(parentcluster)
+    for (i,cluster) in enumerate(clusters)
+        irange = index_range(cluster)
+        isempty(irange) && continue
+        els    = (root_els[l2g[j]] for j in irange)
+        cluster.container = HyperRectangle(els,true)
+    end
+    return parentcluster
+end
+
+"""
+    struct DyadicMaxDepthSplitter <: AbstractSplitter
+
+Similar to [`DyadicSplitter`](@ref), but splits nodes until a maximum `depth` is reached.
+
+## See also: [`AbstractSplitter`](@ref)
+"""
+Base.@kwdef struct DyadicMaxDepthSplitter <: AbstractSplitter
+    depth::Int
+    keep_empty::Bool = false
+end
+
+function should_split(node::ClusterTree, depth, spl::DyadicMaxDepthSplitter)
+    if !spl.keep_empty
+        length(node) == 0 && (return false)
+    end
+    depth < spl.depth
+end
+
+function split!(parentcluster::ClusterTree, spl::DyadicMaxDepthSplitter)
+    # exactly like the dyadic splitter
+    split!(parentcluster, DyadicSplitter(-1,spl.keep_empty))
+end
+
 """
     struct GeometricSplitter <: AbstractSplitter
 
@@ -74,7 +138,7 @@ Base.@kwdef struct GeometricSplitter <: AbstractSplitter
     nmax::Int = 50
 end
 
-should_split(node::ClusterTree, splitter::GeometricSplitter) = length(node) > splitter.nmax
+should_split(node::ClusterTree, depth, splitter::GeometricSplitter) = length(node) > splitter.nmax
 
 function split!(cluster::ClusterTree, ::GeometricSplitter)
     rec = cluster.container
@@ -93,7 +157,7 @@ Base.@kwdef struct GeometricMinimalSplitter <: AbstractSplitter
     nmax::Int = 50
 end
 
-should_split(node::ClusterTree, splitter::GeometricMinimalSplitter) = length(node) > splitter.nmax
+should_split(node::ClusterTree, depth, splitter::GeometricMinimalSplitter) = length(node) > splitter.nmax
 
 function split!(cluster::ClusterTree, ::GeometricMinimalSplitter)
     rec = cluster.container
@@ -112,7 +176,7 @@ Base.@kwdef struct PrincipalComponentSplitter <: AbstractSplitter
     nmax::Int = 50
 end
 
-should_split(node::ClusterTree, splitter::PrincipalComponentSplitter) = length(node) > splitter.nmax
+should_split(node::ClusterTree, depth, splitter::PrincipalComponentSplitter) = length(node) > splitter.nmax
 
 function split!(cluster::ClusterTree, ::PrincipalComponentSplitter)
     pts = cluster._elements
@@ -157,7 +221,7 @@ Base.@kwdef struct CardinalitySplitter <: AbstractSplitter
     nmax::Int = 50
 end
 
-should_split(node::ClusterTree, splitter::CardinalitySplitter) = length(node) > splitter.nmax
+should_split(node::ClusterTree, depth, splitter::CardinalitySplitter) = length(node) > splitter.nmax
 
 function split!(cluster::ClusterTree, ::CardinalitySplitter)
     points = cluster._elements

test/Trees/clustertree_test.jl

@@ -38,6 +38,9 @@ end
         splitter  = WPB.DyadicSplitter(nmax=1)
         clt = WPB.ClusterTree(points,splitter)
         @test sortperm(points) == clt.loc2glob
+        splitter  = WPB.DyadicMinimalSplitter(nmax=1)
+        clt = WPB.ClusterTree(points,splitter)
+        @test sortperm(points) == clt.loc2glob
     end
 
     @testset "2d" begin
@@ -57,6 +60,9 @@ end
         splitter = WPB.DyadicSplitter(nmax=32)
         clt = WPB.ClusterTree(points,splitter)
         @test test_cluster_tree(clt)
+        splitter  = WPB.DyadicMinimalSplitter(nmax=1)
+        clt = WPB.ClusterTree(points,splitter)
+        @test test_cluster_tree(clt)
     end
 
     @testset "3d" begin
@@ -76,6 +82,9 @@ end
         splitter   = WPB.DyadicSplitter(nmax=32)
         clt = WPB.ClusterTree(points,splitter)
         @test test_cluster_tree(clt)
+        splitter  = WPB.DyadicMinimalSplitter(nmax=1)
+        clt = WPB.ClusterTree(points,splitter)
+        @test test_cluster_tree(clt)
     end
 
     @testset "3d + threads" begin
@@ -96,5 +105,8 @@ end
         splitter   = WPB.DyadicSplitter(nmax=32)
         clt = WPB.ClusterTree(points,splitter;threads)
         @test test_cluster_tree(clt)
+        splitter   = WPB.DyadicMinimalSplitter(nmax=32)
+        clt = WPB.ClusterTree(points,splitter;threads)
+        @test test_cluster_tree(clt)
     end
 end