Merge pull request #724 from JuliaRobotics/master

v0.11.3-rc1

Author: dehann

Project.toml

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

src/DistributedFactorGraphs.jl

@@ -193,7 +193,8 @@ export addData!
 ##------------------------------------------------------------------------------
 # Factor Data
 export GenericFunctionNodeData, PackedFunctionNodeData, FunctionNodeData
-export FunctorInferenceType, PackedInferenceType
+export AbstractFactor, AbstractPackedFactor
+export FunctorInferenceType, PackedInferenceType # NOTE might be deprecated in the future (const aliases)
 export AbstractPrior, AbstractRelative, AbstractRelativeRoots, AbstractRelativeMinimize
 export FactorOperationalMemory
 

src/LightDFG/services/LightDFG.jl

@@ -336,7 +336,7 @@ function savedot_attributes(io::IO, dfg::LightDFG)
         write(io, "$vl [color=red, shape=ellipse];\n")
     end
     for fl in listFactors(dfg)
-        write(io, "$fl [color=blue, shape=box];\n")
+        write(io, "$fl [color=blue, shape=box, fontsize=8, fixedsize=false, height=0.1, width=0.1];\n")
     end
 
     for e in edges(dfg.g)
@@ -407,7 +407,6 @@ function findShortestPathDijkstra(  dfg::LightDFG,
         for type_ in typeList
             union!(thelist_, listfnc(type_))
         end
-        @show thelist_
         intersect( thelist, thelist_ )
     end
 
@@ -439,11 +438,11 @@ function findShortestPathDijkstra(  dfg::LightDFG,
         dfg
     end
 
-    # LightDFG internally uses Integers 
-    if !haskey(dfg_.g.labels, from) || !haskey(dfg_.g.labels, from)
+    if !exists(dfg_, from) || !exists(dfg_, to)
         # assume filters excluded either `to` or `from` and hence no shortest path
         return Symbol[]
     end
+    # LightDFG internally uses Integers 
     frI = dfg_.g.labels[from]
     toI = dfg_.g.labels[to]
 

src/entities/DFGFactor.jl

@@ -3,16 +3,19 @@
 ##==============================================================================
 
 # TODO consider changing this to AbstractFactor
-abstract type FunctorInferenceType <: Function end
-abstract type PackedInferenceType end
+abstract type AbstractFactor end
+const FunctorInferenceType = AbstractFactor
+abstract type AbstractPackedFactor end
+const PackedInferenceType = AbstractPackedFactor
 
-abstract type AbstractPrior <: FunctorInferenceType end
-abstract type AbstractRelative <: FunctorInferenceType end
+abstract type AbstractPrior <: AbstractFactor end
+abstract type AbstractRelative <: AbstractFactor end
 abstract type AbstractRelativeRoots <: AbstractRelative end
 abstract type AbstractRelativeMinimize <: AbstractRelative end
 
 # NOTE DF, Convolution is IIF idea, but DFG should know about "FactorOperationalMemory"
 # DF, IIF.CommonConvWrapper <: FactorOperationalMemory #
+# TODO resolve whether `<: Function` is really needed here
 abstract type FactorOperationalMemory <: Function end
 # TODO to be removed from DFG,
 # we can add to IIF or have IIF.CommonConvWrapper <: FactorOperationalMemory directly
@@ -31,8 +34,8 @@ Notes
 Designing (WIP)
 - T <: Union{FactorOperationalMemory, PackedInferenceType}
 - in IIF.CCW{T <: DFG.FunctorInferenceType}
-- in DFG.AbstractRelativeFactorMinimize <: FunctorInferenceType
-- in Main.SomeFactor <: AbstractRelativeFactorMinimize
+- in DFG.AbstractRelativeMinimize <: FunctorInferenceType
+- in Main.SomeFactor <: AbstractRelativeMinimize
 """
 mutable struct GenericFunctionNodeData{T<:Union{PackedInferenceType, FunctorInferenceType, FactorOperationalMemory}}
     eliminated::Bool

src/services/AbstractDFG.jl

@@ -632,7 +632,7 @@ end
 
 function ls(dfg::G, ::Type{T}) where {G <: AbstractDFG, T <: FunctorInferenceType}
   xx = getFactors(dfg)
-  names = getfield.(typeof.(getFactorType.(xx)), :name) .|> Symbol
+  names = typeof.(getFactorType.(xx)) .|> nameof
   vxx = view(xx, names .== Symbol(T))
   map(x->x.label, vxx)
 end
@@ -694,7 +694,7 @@ function lsWho(dfg::AbstractDFG, type::Symbol)
     vars = getVariables(dfg)
     labels = Symbol[]
     for v in vars
-        varType = typeof(getVariableType(v)).name |> Symbol
+        varType = typeof(getVariableType(v)) |> nameof
         varType == type && push!(labels, v.label)
     end
     return labels
@@ -721,7 +721,7 @@ function lsfWho(dfg::AbstractDFG, type::Symbol)
     facs = getFactors(dfg)
     labels = Symbol[]
     for f in facs
-        facType = typeof(getFactorType(f)).name |> Symbol
+        facType = typeof(getFactorType(f)) |> nameof
         facType == type && push!(labels, f.label)
     end
     return labels
@@ -740,7 +740,7 @@ function lsTypes(dfg::AbstractDFG)
     vars = getVariables(dfg)
     alltypes = Set{Symbol}()
     for v in vars
-        varType = typeof(getVariableType(v)).name |> Symbol
+        varType = typeof(getVariableType(v)) |> nameof
         push!(alltypes, varType)
     end
     return collect(alltypes)
@@ -756,7 +756,7 @@ function lsTypesDict(dfg::AbstractDFG)
     vars = getVariables(dfg)
     alltypes = Dict{Symbol,Vector{Symbol}}()
     for v in vars
-        varType = typeof(getVariableType(v)).name |> Symbol
+        varType = typeof(getVariableType(v)) |> nameof
         d = get!(alltypes, varType, Symbol[])
         push!(d, v.label)
     end
@@ -772,7 +772,7 @@ function lsfTypes(dfg::AbstractDFG)
     facs = getFactors(dfg)
     alltypes = Set{Symbol}()
     for f in facs
-        facType = typeof(getFactorType(f)).name |> Symbol
+        facType = typeof(getFactorType(f)) |> nameof
         push!(alltypes, facType)
     end
     return collect(alltypes)
@@ -787,7 +787,7 @@ function lsfTypesDict(dfg::AbstractDFG)
     facs = getFactors(dfg)
     alltypes = Dict{Symbol,Vector{Symbol}}()
     for f in facs
-        facType = typeof(getFactorType(f)).name |> Symbol
+        facType = typeof(getFactorType(f)) |> nameof
         d = get!(alltypes, facType, Symbol[])
         push!(d, f.label)
     end
@@ -1099,7 +1099,7 @@ Related
 function isPathFactorsHomogeneous(dfg::AbstractDFG, from::Symbol, to::Symbol)
     # FIXME, must consider all paths, not just shortest...
     pth = intersect(findShortestPathDijkstra(dfg, from, to), lsf(dfg))
-    types = getFactorType.(dfg, pth) .|> typeof .|> x->(x).name
+    types = getFactorType.(dfg, pth) .|> typeof .|> x->(x).name #TODO this might not be correct in julia 1.6
     utyp = unique(types)
     (length(utyp) == 1), utyp
 end

test/iifCompareTests.jl

@@ -56,7 +56,7 @@ using Test
     # fg2 has been solved, so it should fail on the estimate dictionary
     @test !compareSimilarVariables(fg, fg2, skipsamples=true, skip=Symbol[:initialized;:inferdim])
 
-    tree = resetBuildTree!(fg2)
+    tree = buildTreeReset!(fg2)
 
     @test compareSimilarFactors(fg, fg2, skipsamples=true, skipcompute=true)
 

test/iifInterfaceTests.jl

@@ -22,14 +22,15 @@ end
 #test before anything changes
 @testset "Producing Dot Files" begin
     global dfg
-    todotstr = toDot(dfg)
+    @show todotstr = toDot(dfg)
     #TODO consider using a regex, but for now test all orders
     todota = todotstr == "graph graphname {\n2 [\"label\"=\"a\",\"shape\"=\"ellipse\",\"fillcolor\"=\"red\",\"color\"=\"red\"]\n2 -- 3\n3 [\"label\"=\"abf1\",\"shape\"=\"box\",\"fillcolor\"=\"blue\",\"color\"=\"blue\"]\n1 [\"label\"=\"b\",\"shape\"=\"ellipse\",\"fillcolor\"=\"red\",\"color\"=\"red\"]\n1 -- 3\n}\n"
     todotb = todotstr == "graph graphname {\n2 [\"label\"=\"b\",\"shape\"=\"ellipse\",\"fillcolor\"=\"red\",\"color\"=\"red\"]\n2 -- 3\n3 [\"label\"=\"abf1\",\"shape\"=\"box\",\"fillcolor\"=\"blue\",\"color\"=\"blue\"]\n1 [\"label\"=\"a\",\"shape\"=\"ellipse\",\"fillcolor\"=\"red\",\"color\"=\"red\"]\n1 -- 3\n}\n"
     todotc = todotstr == "graph G {\na [color=red, shape=ellipse];\nb [color=red, shape=ellipse];\nabf1 [color=blue, shape=box];\na -- abf1\nb -- abf1\n}\n"
     todotd = todotstr == "graph G {\na [color=red, shape=ellipse];\nb [color=red, shape=ellipse];\nabf1 [color=blue, shape=box];\nb -- abf1\na -- abf1\n}\n"
-    @test (todota || todotb || todotc || todotd)
-    @test toDotFile(dfg, "something.dot") == nothing
+    todote = todotstr == "graph G {\na [color=red, shape=ellipse];\nb [color=red, shape=ellipse];\nabf1 [color=blue, shape=box, fontsize=8, fixedsize=false, height=0.1, width=0.1];\na -- abf1\nb -- abf1\n}\n"
+    @test (todota || todotb || todotc || todotd || todote)
+    @test toDotFile(dfg, "something.dot") === nothing
     Base.rm("something.dot")
 end
 

test/interfaceTests.jl

@@ -63,7 +63,14 @@ end
     @test printFactor(fac1) === nothing
 
     @test printVariable(iobuf, var1, skipfields=[:timestamp, :solver, :ppe, :nstime]) === nothing
-    @test String(take!(iobuf)) == "DFGVariable{TestVariableType1}\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"
+    
+    if VERSION < v"1.6.0-beta1"
+        # for julia < v1.6
+        @test String(take!(iobuf)) == "DFGVariable{TestVariableType1}\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"
+    else
+        # for julia v1.6
+        @test String(take!(iobuf)) == "DFGVariable{TestVariableType1}\nlabel:\n:a\ntags:\nSet([:VARIABLE, :POSE])\nsmallData:\nDict{Symbol, Union{Bool, Float64, Int64, Vector{Bool}, Vector{Float64}, Vector{Int64}, Vector{String}, String}}(:small=>\"data\")\ndataDict:\nDict{Symbol, AbstractDataEntry}()\nsolvable:\n0\n"   
+    end
 
     @test printVariable(iobuf, var1, short=true) === nothing
     varstr = String(take!(iobuf))

test/testBlocks.jl

@@ -24,8 +24,8 @@ struct TestFunctorInferenceType1 <: AbstractRelative end
 struct TestFunctorInferenceType2 <: AbstractRelative end
 
 struct TestAbstractPrior <: AbstractPrior end
-struct TestAbstractRelativeFactor <: AbstractRelativeFactor end
-struct TestAbstractRelativeFactorMinimize <: AbstractRelativeFactorMinimize end
+struct TestAbstractRelativeFactor <: AbstractRelativeRoots end
+struct TestAbstractRelativeFactorMinimize <: AbstractRelativeMinimize end
 
 struct PackedTestFunctorInferenceType1 <: PackedInferenceType
     s::String
@@ -1409,8 +1409,8 @@ function ProducingDotFiles(testDFGAPI,
     #NOTE hardcoded toDot will have different results so test LightGraphs seperately
     if testDFGAPI <: LightDFG || testDFGAPI <: CloudGraphsDFG
         todotstr = toDot(dotdfg)
-        todota = todotstr == "graph G {\na [color=red, shape=ellipse];\nb [color=red, shape=ellipse];\nabf1 [color=blue, shape=box];\na -- abf1\nb -- abf1\n}\n"
-        todotb = todotstr == "graph G {\na [color=red, shape=ellipse];\nb [color=red, shape=ellipse];\nabf1 [color=blue, shape=box];\nb -- abf1\na -- abf1\n}\n"
+        todota = todotstr == "graph G {\na [color=red, shape=ellipse];\nb [color=red, shape=ellipse];\nabf1 [color=blue, shape=box, fontsize=8, fixedsize=false, height=0.1, width=0.1];\na -- abf1\nb -- abf1\n}\n"
+        todotb = todotstr == "graph G {\na [color=red, shape=ellipse];\nb [color=red, shape=ellipse];\nabf1 [color=blue, shape=box, fontsize=8, fixedsize=false, height=0.1, width=0.1];\nb -- abf1\na -- abf1\n}\n"
         @test (todota || todotb)
     else
         @test toDot(dotdfg) == "graph graphname {\n2 [\"label\"=\"b\",\"shape\"=\"ellipse\",\"fillcolor\"=\"red\",\"color\"=\"red\"]\n2 -- 3\n3 [\"label\"=\"abf1\",\"shape\"=\"box\",\"fillcolor\"=\"blue\",\"color\"=\"blue\"]\n1 [\"label\"=\"a\",\"shape\"=\"ellipse\",\"fillcolor\"=\"red\",\"color\"=\"red\"]\n1 -- 3\n}\n"