Merge pull request #695 from JuliaRobotics/master

v0.10.11-rc1

Author: dehann

Project.toml

@@ -1,6 +1,6 @@
 name = "DistributedFactorGraphs"
 uuid = "b5cc3c7e-6572-11e9-2517-99fb8daf2f04"
-version = "0.10.10"
+version = "0.10.11"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"

src/DFGPlots/DFGPlots.jl

@@ -2,9 +2,9 @@ module DFGPlots
 
 using Colors
 using LightGraphs
-using GraphPlot
+using ..GraphPlot
 using DocStringExtensions
-import GraphPlot: gplot
+import ..GraphPlot: gplot
 
 using ...DistributedFactorGraphs
 

src/DistributedFactorGraphs.jl

@@ -317,7 +317,7 @@ function __init__()
     @warn("BREAKING CHANGE coming to DistributedFactorGraphs v0.12: deprecating AbstractRelativeFactorMinimize, use AbstractRelativeMinimize instead")
 
     @require GraphPlot = "a2cc645c-3eea-5389-862e-a155d0052231" begin
-        @info "Including Plots"
+        @info "DistributedFactorGraphs.jl is adding tools using GraphPlot.jl"
         include("DFGPlots/DFGPlots.jl")
         @reexport using .DFGPlots
     end

src/services/AbstractDFG.jl

@@ -495,23 +495,23 @@ listVariables(dfg, r"l", tags=[:APRILTAG;])
 Related:
 - ls
 """
-function listVariables(dfg::AbstractDFG, 
-                       regexFilter::Union{Nothing, Regex}=nothing; 
-                       tags::Vector{Symbol}=Symbol[], 
-                       solvable::Int=0 )
-  #
-  vars = getVariables(dfg, regexFilter, tags=tags, solvable=solvable)
-  return map(v -> v.label, vars)::Vector{Symbol}
+function listVariables( dfg::AbstractDFG, 
+                        regexFilter::Union{Nothing, Regex}=nothing; 
+                        tags::Vector{Symbol}=Symbol[], 
+                        solvable::Int=0 )
+    #
+    vars = getVariables(dfg, regexFilter, tags=tags, solvable=solvable)
+    return map(v -> v.label, vars)::Vector{Symbol}
 end
 
 # to be consolidated, see #612
-function listVariables(dfg::AbstractDFG, 
-                       typeFilter::Type{<:InferenceVariable}; 
-                       tags::Vector{Symbol}=Symbol[], 
-                       solvable::Int=0 )
-  #
-  retlist::Vector{Symbol} = ls(dfg, typeFilter)
-  0 < length(tags) || solvable != 0 ? intersect(retlist, ls(dfg, tags=tags, solvable=solvable)) : retlist
+function listVariables( dfg::AbstractDFG, 
+                        typeFilter::Type{<:InferenceVariable}; 
+                        tags::Vector{Symbol}=Symbol[], 
+                        solvable::Int=0 )
+    #
+    retlist::Vector{Symbol} = ls(dfg, typeFilter)
+    0 < length(tags) || solvable != 0 ? intersect(retlist, ls(dfg, tags=tags, solvable=solvable)) : retlist
 end
 
 """
@@ -520,31 +520,50 @@ Get a list of the IDs (labels) of the DFGFactors in the DFG.
 Optionally specify a label regular expression to retrieves a subset of the factors.
 """
 function listFactors(dfg::G, regexFilter::Union{Nothing, Regex}=nothing; tags::Vector{Symbol}=Symbol[], solvable::Int=0)::Vector{Symbol} where G <: AbstractDFG
-  return map(f -> f.label, getFactors(dfg, regexFilter, tags=tags, solvable=solvable))
+    return map(f -> f.label, getFactors(dfg, regexFilter, tags=tags, solvable=solvable))
 end
 
 """
-    $SIGNATURES
+    $TYPEDSIGNATURES
 List all the solvekeys used amongst all variables in the distributed factor graph object.
 
 Related
 
-listSupersolves, getSolverDataDict, listVariables
+[`listSupersolves`](@ref), [`getSolverDataDict`](@ref), [`listVariables`](@ref)
 """
-function listSolveKeys(dfg::AbstractDFG, 
-                       filterVariables::Union{Type{<:InferenceVariable},Regex, Nothing}=nothing;
-                       filterSolveKeys::Union{Regex,Nothing}=nothing,
-                       tags::Vector{Symbol}=Symbol[], 
-                       solvable::Int=0 )
-                       #
-    skeys = Set{Symbol}()
-    varList = listVariables(dfg, filterVariables, tags=tags, solvable=solvable)
-    for vs in varList, ky in keys(getSolverDataDict(getVariable(dfg, vs)))
+function listSolveKeys( variable::DFGVariable,
+                        filterSolveKeys::Union{Regex,Nothing}=nothing,
+                        skeys = Set{Symbol}() )
+    #
+    for ky in keys(getSolverDataDict(variable))
         push!(skeys, ky)
     end
 
     #filter the solveKey set with filterSolveKeys regex
     !isnothing(filterSolveKeys) && return filter!(k -> occursin(filterSolveKeys, string(k)), skeys)
+    return skeys
+end
+
+listSolveKeys(  dfg::AbstractDFG, lbl::Symbol,
+                filterSolveKeys::Union{Regex,Nothing}=nothing,
+                skeys = Set{Symbol}() ) = listSolveKeys(getVariable(dfg, lbl), filterSolveKeys, skeys)
+#
+
+function listSolveKeys( dfg::AbstractDFG, 
+                        filterVariables::Union{Type{<:InferenceVariable},Regex, Nothing}=nothing;
+                        filterSolveKeys::Union{Regex,Nothing}=nothing,
+                        tags::Vector{Symbol}=Symbol[], 
+                        solvable::Int=0  )
+    #
+    skeys = Set{Symbol}()
+    varList = listVariables(dfg, filterVariables, tags=tags, solvable=solvable)
+    for vs in varList  #, ky in keys(getSolverDataDict(getVariable(dfg, vs)))
+        listSolveKeys(dfg, vs, filterSolveKeys, skeys)
+    end
+
+    # done inside the loop
+    # #filter the solveKey set with filterSolveKeys regex
+    # !isnothing(filterSolveKeys) && return filter!(k -> occursin(filterSolveKeys, string(k)), skeys)
 
     return skeys
 end

src/services/CustomPrinting.jl

@@ -4,27 +4,44 @@
 
 printVariable(vert::DFGVariable; kwargs...) = printVariable(stdout::IO, vert; kwargs...)
 
-function printVariable(io::IO, vert::DFGVariable;
-                       short::Bool=false,
-                       compact::Bool=true,
-                       limit::Bool=true,
-                       skipfields::Vector{Symbol}=Symbol[],
-                       solveKeys::Vector{Symbol}=Symbol[])
+function printVariable( io::IO, vert::DFGVariable;
+                        short::Bool=false,
+                        compact::Bool=true,
+                        limit::Bool=true,
+                        skipfields::Vector{Symbol}=Symbol[],
+                        solveKeys::Vector{Symbol}=Symbol[])
 
     ioc = IOContext(io, :limit=>limit, :compact=>compact)
 
     if short
-        printstyled(ioc, summary(vert),"\n", bold=true)
+        # opmemt = (getSofttype(vert) |> typeof ).name
+        vari = getSofttype(vert) |> typeof
+        printstyled(ioc, typeof(vert).name, "{",vari.name,"...}","\n", bold=true)
+        # printstyled(ioc, summary(vert),"\n", bold=true)
+
         vnd = getSolverData(vert)
-        println(ioc, "label: $(vert.label)")
-        println(ioc, "tags: $(getTags(vert))")
-        println(ioc, "size marginal samples: $(size(vnd.val))")
-        println(ioc, "kde bandwidths: $((vnd.bw)[:,1])")
+        println(ioc, "  timestamp: ", vert.timestamp)
+        println(ioc, "  label: ", vert.label)
+        println(ioc, "  solvable: ", getSolvable(vert))
+        println(ioc, "  tags: ", getTags(vert))
+        try
+            println(ioc, "  manifold: ", getManifolds(vert))
+        catch e
+        end
+        solk = listSolveKeys(vert) |> collect
+        lsolk = length(solk)
+        smsk = (rand(1:lsolk,100) |> unique)[1:minimum([4,lsolk])]
+        println(ioc, "  Nr SolveKeys=$(lsolk): ", solk[smsk], 4<lsolk ? "..." : "")
+        printstyled(ioc, "    :default", "\n", bold=true)
+        println(ioc, "      size marginal samples: ", size(vnd.val))
+        println(ioc, "      kde bandwidths: ", round.((vnd.bw)[:,1], digits=4))
         if 0 < length(getPPEDict(vert))
-            println(ioc, "PPE.suggested: $(round.(getPPE(vert).suggested,digits=4))")
+            println(ioc, "      PPE.suggested: ", round.(getPPE(vert).suggested,digits=4) )
         else
-            println(ioc, "No PPEs")
+            println(ioc, "      No PPEs yet")
         end
+        printstyled(ioc, "  TYPE: ", bold=true, color=:blue)
+        println(ioc, vari)
         # println(ioc, "kde max: $(round.(getKDEMax(getKDE(vnd)),digits=4))")
         # println(ioc, "kde max: $(round.(getKDEMax(getKDE(vnd)),digits=4))")
     else
@@ -47,11 +64,11 @@ function printVariable(io::IO, vert::DFGVariable;
 end
 
 printFactor(vert::DFGFactor; kwargs...) = printFactor(stdout::IO, vert; kwargs...)
-function printFactor(io::IO, vert::DFGFactor;
-                     short::Bool=false,
-                     compact::Bool=true,
-                     limit::Bool=true,
-                     skipfields::Vector{Symbol}=Symbol[])
+function printFactor(   io::IO, vert::DFGFactor;
+                        short::Bool=false,
+                        compact::Bool=true,
+                        limit::Bool=true,
+                        skipfields::Vector{Symbol}=Symbol[])
 
     ioc = IOContext(io, :limit=>limit, :compact=>compact)
 
@@ -60,15 +77,16 @@ function printFactor(io::IO, vert::DFGFactor;
         fct = getFactorType(vert)
         fctt = fct |> typeof
         printstyled(ioc, typeof(vert).name, "{",opmemt,"{",fctt.name,"...}}","\n", bold=true)
+        println(ioc, "  timestamp: ", vert.timestamp)
+        println(ioc, "  nstime: ",vert.nstime)
         println(ioc, "  label: ", vert.label)
         println(ioc, "  solvable: ", vert.solvable)
         println(ioc, "  VariableOrder: ", vert._variableOrderSymbols)
         println(ioc, "  multihypo: ", getSolverData(vert).multihypo) # FIXME #477
         println(ioc, "  nullhypo: ", getSolverData(vert).nullhypo)
-        println(ioc, "  timestamp: ", vert.timestamp)
-        println(ioc, "  nstime: ",vert.nstime)
         println(ioc, "  tags: ", vert.tags)
-        println(ioc, "  TYPE: ", fctt)
+        printstyled(ioc, "  TYPE: ", bold=true, color=:blue)
+        println(ioc, fctt)
         # show(ioc, fctt)
         for f in setdiff(fieldnames(fctt), skipfields)
             printstyled(ioc, f,":\n", color=:blue)
@@ -118,7 +136,7 @@ printNode(dfg::AbstractDFG, sym::Symbol; kwargs...) = isVariable(dfg,sym) ? prin
 ## Overloading show
 ##==============================================================================
 # Base.show_default(io, v)
-Base.show(io::IO, ::MIME"text/plain", v::DFGVariable) = show(IOContext(io, :limit=>true, :compact=>true), v)
+Base.show(io::IO, ::MIME"text/plain", v::DFGVariable) = printVariable(io, v, short=true, limit=false)
 
 Base.show(io::IO, ::MIME"text/plain", f::DFGFactor) = printFactor(io, f, short=true, limit=false)
 

test/interfaceTests.jl

@@ -59,22 +59,27 @@ end
 
     iobuf = IOBuffer()
     # for now just test the interface and a bit of output
-    @test printVariable(var1) == nothing
-    @test printFactor(fac1) == nothing
+    @test printVariable(var1) === nothing
+    @test printFactor(fac1) === nothing
 
-    @test printVariable(iobuf, var1, skipfields=[:timestamp, :solver, :ppe, :nstime]) == nothing
+    @test printVariable(iobuf, var1, skipfields=[:timestamp, :solver, :ppe, :nstime]) === nothing
     @test String(take!(iobuf)) == "DFGVariable{TestSofttype1}\nlabel:\n:a\ntags:\nSet([:VARIABLE, :POSE])\nsmallData:\nDict{Symbol,Union{Bool, Float64, Int64, Array{Bool,1}, Array{Float64,1}, Array{Int64,1}, Array{String,1}, String}}(:small=>\"data\")\ndataDict:\nDict{Symbol,AbstractDataEntry}()\nsolvable:\n0\n"
 
-    @test printVariable(iobuf, var1, short=true) == nothing
-    @test String(take!(iobuf)) == "DFGVariable{TestSofttype1}\nlabel: a\ntags: Set([:VARIABLE, :POSE])\nsize marginal samples: (1, 1)\nkde bandwidths: [0.0]\nNo PPEs\n"
+    @test printVariable(iobuf, var1, short=true) === nothing
+    varstr = String(take!(iobuf))
+    @test occursin(r"DFGVariable", varstr)
+    @test occursin(r"timestamp", varstr)
+    @test occursin(r"label", varstr)
+    @test occursin(r"bandwidths", varstr)
+    #  == "DFGVariable{TestSofttype1}\nlabel: a\ntags: Set([:VARIABLE, :POSE])\nsize marginal samples: (1, 1)\nkde bandwidths: [0.0]\nNo PPEs\n"
 
 
-    @test printFactor(iobuf, fac1, skipfields=[:timestamp, :solver, :nstime]) == nothing
+    @test printFactor(iobuf, fac1, skipfields=[:timestamp, :solver, :nstime]) === nothing
     @test occursin(r"DFGFactor.*\nlabel:\n:abf1", String(take!(iobuf)))
 
     String(take!(iobuf)) == "DFGFactor{TestCCW{TestFunctorInferenceType1}}\nlabel:\n:abf1\ntags:\nSet([:tag1, :tag2])\nsolvable:\n0\nsolvable:\n1\n_variableOrderSymbols:\n[:a, :b]\n"
 
-    @test printFactor(iobuf, fac1, short=true) == nothing
+    @test printFactor(iobuf, fac1, short=true) === nothing
     @show teststr = String(take!(iobuf))
     @test occursin(r"DFGFactor", teststr)
     @test occursin(r"label", teststr)
@@ -84,19 +89,19 @@ end
 
     # s = String(take!(iobuf))
 
-    @test show(var1) == nothing
-    @test show(fac1) == nothing
+    @test show(var1) === nothing
+    @test show(fac1) === nothing
 
-    @test show(iobuf, MIME("text/plain"), var1) == nothing
+    @test show(iobuf, MIME("text/plain"), var1) === nothing
     isapprox(length(take!(iobuf)), 452, atol=10)
-    @test show(iobuf, MIME("text/plain"), fac1) == nothing
+    @test show(iobuf, MIME("text/plain"), fac1) === nothing
     isapprox(length(take!(iobuf)), 301, atol=10)
 
-    @test printVariable(fg1, :a) == nothing
-    @test printFactor(fg1, :abf1) == nothing
+    @test printVariable(fg1, :a) === nothing
+    @test printFactor(fg1, :abf1) === nothing
 
-    @test printNode(fg1, :a) == nothing
-    @test printNode(fg1, :abf1) == nothing
+    @test printNode(fg1, :a) === nothing
+    @test printNode(fg1, :abf1) === nothing
 
     show(stdout, MIME("application/prs.juno.inline"), var1) == var1
     show(stdout, MIME("application/prs.juno.inline"), fac1) == fac1

test/testBlocks.jl

@@ -397,13 +397,18 @@ function  VariablesandFactorsCRUD_SET!(fg, v1, v2, v3, f0, f1, f2)
 @test addVariable!(fg, v1) == v1
 @test addVariable!(fg, v2) == v2
 
+# test getindex
+@test getLabel(fg[getLabel(v1)]) == getLabel(v1)
+
 #TODO standardize this error and res also for that matter
 @test_throws Exception addFactor!(fg, [:a, :nope], f1)
 @test_throws Exception addFactor!(fg, [v1, v2, v3], f1)
 
 @test addFactor!(fg, [v1, v2], f1) == f1
 @test_throws ErrorException addFactor!(fg, [v1, v2], f1)
 
+@test getLabel(fg[getLabel(f1)]) == getLabel(f1)
+
 @test @test_logs (:warn, Regex("'$(v3.label)' does not exist")) match_mode=:any updateVariable!(fg, v3) == v3
 @test updateVariable!(fg, v3) == v3
 @test_throws ErrorException addVariable!(fg, v3)