simplify load!()

- one `load!()` instread of 2
- one `convertel` function to convert `data` elements into `V`
  instead of 3 `getxxx`

Author: alyst

examples/pareto.jl

@@ -58,7 +58,7 @@ open(joinpath(@__DIR__, "pareto3d_rtree_seq.html"), "w") do io
 end
 
 bulk_pareto_tree = RTree{Float64, 3}(Int, String, leaf_capacity = 8, branch_capacity = 8)
-SI.load!(bulk_pareto_tree, collect(pareto_tree))
+SI.load!(bulk_pareto_tree, pareto_tree)
 SI.check(bulk_pareto_tree)
 
 bulk_pareto_tree_plot = plot(bulk_pareto_tree);

examples/spiral.jl

@@ -20,7 +20,7 @@ for (i, br) in enumerate(mbrs)
 end
 SI.check(seq_tree)
 
-SI.load!(bulk_tree, enumerate(mbrs), getid=x->x[1], getmbr=x->x[2], getval=x->string(x[1]))
+SI.load!(bulk_tree, enumerate(mbrs), convertel -> eltype(bulk_tree)(x[2], x[1], string(x[1])))
 SI.check(bulk_tree)
 
 include(joinpath(@__DIR__, "dataframe_utils.jl"))

src/rtree/bulk.jl

@@ -10,12 +10,25 @@ function omt_branch_fill(tree::RTree; fill_factor::Number=1.0) where T<:Node
 end
 
 """
-Bulk-load the `data` into `tree`.
+    load!(tree::RTree{T,N,V}, data::Any;
+          convertel = identity, method = :OMT,
+          leaf_fill = capacity(Leaf, tree),
+          branch_fill::Tuple{Integer, Integer} = omt_branch_fill(tree)) where {T,N,V}
+
+Bulk-load `data` into `tree`.
+  * `tree`: an *empty* R-tree for storing elements of type `V`
+  * `data`: iterable container with the elements to put into `tree`
+  * `convertel`: function to convert elements of `data` to type `V`
+  * `method`: bulk-loading method
+  * `leaf_fill`: the average number of elements to store in R-tree leaves (1-level nodes)
+  * `branch_fill`: the tuple of the number of slices and the number of subtrees per slice
+    in the R-tree nodes (level ≥ 1).
+
+The supported bulk-loading methods are:
+  * `:OMT`: *Overlap Minimizing Top-down method* by Taewon Lee and Sukho Lee
 """
 function load!(tree::RTree{T,N,V}, data::Any;
-               getmbr = first,
-               getid = idtrait(V) === HasNoID ? x -> nothing : x -> x[2],
-               getval = idtrait(V) === HasNoID ? x -> x[2] : x -> x[3],
+               convertel = identity,
                method::Symbol = :OMT,
                leaf_fill::Integer = capacity(Leaf, tree),
                branch_fill::Tuple{Integer, Integer} = omt_branch_fill(tree)) where {T, N, V}
@@ -25,27 +38,14 @@ function load!(tree::RTree{T,N,V}, data::Any;
         @warn "No bulk-load data provided"
         return tree
     end
-    # FIXME kwargs... doesn't work for some reason
-    return load!(tree, V[V(getmbr(x), getid(x), getval(x)) for x in data],
-                 method=method, leaf_fill=leaf_fill, branch_fill=branch_fill)
-end
-
-function load!(tree::RTree{T,N,V}, data::AbstractVector{V};
-               method::Symbol = :OMT,
-               leaf_fill::Integer = capacity(Leaf, tree),
-               branch_fill::Tuple{Integer, Integer} = omt_branch_fill(tree)) where {T,N,V}
-    isempty(tree) || throw(ArgumentError("Cannot bulk-load into non-empty tree"))
-    if isempty(data)
-        @warn "No bulk-load data provided"
-        return tree
-    end
     0 < leaf_fill <= capacity(Leaf, tree) ||
         throw(ArgumentError("Leaf fill should be positive and not exceed leaf capacity"))
     prod(branch_fill) > 1 || throw(ArgumentError("Branch fill should be > 1"))
     if method == :OMT
-        return load_omt!(tree, data, leaf_fill=leaf_fill, branch_fill=branch_fill)
+        return load_omt!(tree, V[convertel(x) for x in data],
+                         leaf_fill=leaf_fill, branch_fill=branch_fill)
     else
-        throw(ArgumentError("Unsupported bulk-loadaing method $method"))
+        throw(ArgumentError("Unsupported bulk-loading method $method"))
     end
 end
 

test/rtree.jl

@@ -223,18 +223,22 @@ end
         end
     end
 
-    @testset "bulk load" begin
+    @testset "load!() (OMT bulk load)" begin
         tree = RTree{SI.dimtype(eltype(mbrs)), ndims(eltype(mbrs))}(Int, String,
                                 leaf_capacity = 20, branch_capacity = 20)
         @test tree === SI.load!(tree, enumerate(mbrs), method=:OMT,
-                                getid = x -> x[1], getmbr = x -> x[2], getval = x -> string(x[1]))
+                                convertel = x -> eltype(tree)(x[2], x[1], string(x[1])))
         @test SI.check(tree)
         @test length(tree) == length(mbrs)
         #@show SI.height(tree)
         #@show tree.nnodes_perlevel
         # cannot bulk-load into non-empty tree
         @test_throws ArgumentError SI.load!(tree, enumerate(mbrs), method=:OMT,
-                                            getid = x -> x[1], getmbr = x -> x[2], getval = x -> string(x[1]))
+                                            convertel = x -> eltype(tree)(x[2], x[1], string(x[1])))
+        tree2 = similar(tree)
+        # can load from tree into another tree
+        @test SI.load!(tree2, tree) == tree2
+        @test length(tree2) == length(tree)
 
         @testset "findfirst()" begin
             # check that the elements can be found
@@ -257,9 +261,7 @@ end
         tree = RTree{Int, 2}(Int, String, leaf_capacity = 5, branch_capacity = 5)
         pts = [(0, 0), (1, 0), (2, 2), (2, 0), (0, 1), (1, 1), (-1, -1)]
         SI.load!(tree, enumerate(pts),
-                 getid = x -> x[1],
-                 getmbr = x -> SI.Rect(x[2], x[2]),
-                 getval = x -> string(x[1]))
+                 convertel = x -> eltype(tree)(SI.Rect(x[2], x[2]), x[1], string(x[1])))
         @test length(tree) == length(pts)
         @test SI.check(tree)
         rect = SI.Rect((0, 0), (1, 1))
@@ -280,7 +282,7 @@ end
         pts = [ntuple(_ -> 5. * randn(), 3) for _ in 1:1000]
         tree = RTree{Float64, 3}(Int, String, leaf_capacity = 10, branch_capacity = 10)
         SI.load!(tree, enumerate(pts),
-                 getid = x -> x[1], getmbr = x -> SI.Rect(x[2], x[2]), getval = x -> string(x[1]))
+                 convertel = x -> eltype(tree)(SI.Rect(x[2], x[2]), x[1], string(x[1])))
         @test length(tree) == length(pts)
         #@show tree.nelems tree.nnodes_perlevel