Merge branch 'master' into maint/20Q2/test_maint

Author: Affie

.travis.yml

@@ -11,7 +11,6 @@ services:
     - neo4j
 
 julia:
-    - 1.4
     - 1.5
     - nightly
 

src/Deprecated.jl

@@ -26,7 +26,8 @@ GraphsDFG{T}(args...; kwargs...) where T = GraphsDFG{T}()
 
 @deprecate getInternalId(args...) error("getInternalId is no longer in use")
 
-@deprecate loadDFG(source::String, iifModule::Module, dest::AbstractDFG) loadDFG!(dest, source)
+@deprecate loadDFG(source::AbstractString, iifModule::Module, dest::AbstractDFG) loadDFG!(dest, source)
+@deprecate loadDFG(dest::AbstractDFG, source::AbstractString) loadDFG!(dest, source)
 
 # leave a bit longer
 export buildSubgraphFromLabels!

src/DistributedFactorGraphs.jl

@@ -68,6 +68,7 @@ export exists,
        updateVariable!, updateFactor!,
        deleteVariable!, deleteFactor!,
        listVariables, listFactors,
+       listSolvekeys, listSupersolves,
        getVariables, getFactors,
        isVariable, isFactor
 

src/FileDFG/services/FileDFG.jl

@@ -17,7 +17,7 @@ v1 = addVariable!(dfg, :a, ContinuousScalar, labels = [:POSE], solvable=0)
 saveDFG(dfg, "/tmp/saveDFG.tar.gz")
 ```
 """
-function saveDFG( dfg::AbstractDFG, folder::String )
+function saveDFG( dfg::AbstractDFG, folder::AbstractString )
 
     # TODO: Deprecate the folder functionality in v0.6.1
 
@@ -82,7 +82,7 @@ loadDFG("/tmp/savedgraph.tar.gz", IncrementalInference, dfg)
 ls(dfg)
 ```
 """
-function loadDFG!(dfgLoadInto::AbstractDFG, dst::String)
+function loadDFG!(dfgLoadInto::AbstractDFG, dst::AbstractString)
 
 
     #
@@ -102,6 +102,8 @@ function loadDFG!(dfgLoadInto::AbstractDFG, dst::String)
             lastdirname *= ".tar.gz"
         end
     end
+    # check the file actually exists
+    @assert isfile(dstname) "cannot find file $dstname"
     # TODO -- what if it is not a tar.gz but classic folder instead?
     # do actual unzipping
     filename = lastdirname[1:(end-length(".tar.gz"))] |> string

src/entities/DFGFactor.jl

@@ -39,7 +39,7 @@ mutable struct GenericFunctionNodeData{T<:Union{PackedInferenceType, FunctorInfe
     potentialused::Bool
     edgeIDs::Vector{Int}
     fnc::T
-    multihypo::Vector{Float64} # likely to moved when GenericWrapParam is refactored
+    multihypo::Vector{Float64} # FIXME likely to moved when GenericWrapParam is refactored #477
     certainhypo::Vector{Int}
     solveInProgress::Int
 end

src/services/AbstractDFG.jl

@@ -480,6 +480,24 @@ function listFactors(dfg::G, regexFilter::Union{Nothing, Regex}=nothing; tags::V
     return map(f -> f.label, getFactors(dfg, regexFilter, tags=tags, solvable=solvable))
 end
 
+"""
+    $SIGNATURES
+List all the solvekeys used amongst all variables in the distributed factor graph object.
+
+Related
+
+listSupersolves, getSolverDataDict, listVariables
+"""
+function listSolvekeys(dfg::AbstractDFG)
+  skeys = Set{Symbol}()
+  for vs in listVariables(dfg), ky in keys(getSolverDataDict(getVariable(dfg, vs)))
+    push!(skeys, ky)
+  end
+  return skeys
+end
+const listSupersolves = listSolvekeys
+
+
 ##------------------------------------------------------------------------------
 ## Aliases and Other filtered lists
 ##------------------------------------------------------------------------------

src/services/CustomPrinting.jl

@@ -1,29 +1,3 @@
-##==============================================================================
-## 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", f::DFGFactor) = show(IOContext(io, :limit=>true, :compact=>true), f)
-
-function Base.show(io::IO, ::MIME"text/plain", dfg::AbstractDFG)
-    summary(io, dfg)
-    println("\n  UserId: ", dfg.userId)
-    println("  RobotId: ", dfg.robotId)
-    println("  SessionId: ", dfg.sessionId)
-    println("  Description: ", dfg.description)
-    println("  Nr variables: ", length(ls(dfg)))
-    println("  Nr factors: ",length(lsf(dfg)))
-    println("  User Data: ", keys(dfg.userData))
-    println("  Robot Data: ", keys(dfg.robotData))
-    println("  Session Data: ", keys(dfg.sessionData))
-end
-
-
-#default for Atom/Juno
-Base.show(io::IO, ::MIME"application/prs.juno.inline", x::Union{AbstractDFG, DFGVariable, DFGFactor}) = x
-
-
 ##==============================================================================
 ## Printing Variables and Factors
 ##==============================================================================
@@ -83,11 +57,23 @@ function printFactor(io::IO, vert::DFGFactor;
 
     if short
         printstyled(ioc, summary(vert),"\n", bold=true)
-        println(ioc, "label: ", vert.label)
-        println(ioc, "timestamp: ", vert.timestamp)
-        println(ioc, "tags: ", vert.tags)
-        println(ioc, "solvable: ", vert.solvable)
-        println(ioc, "VariableOrder: ", vert._variableOrderSymbols)
+        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: ", "see DFG #477")
+        println(ioc, "  timestamp: ", vert.timestamp)
+        println(ioc, "  nstime: ",vert.nstime)
+        println(ioc, "  tags: ", vert.tags)
+        fct = getFactorType(vert)
+        fctt = fct |> typeof
+        println(ioc, "  Type: ", fctt)
+        # show(ioc, fctt)
+        for f in setdiff(fieldnames(fctt), skipfields)
+            printstyled(ioc, f,":\n", color=:blue)
+            show(ioc, getproperty(fct, f))
+            println(ioc)
+        end
     else
 
         printstyled(ioc, summary(vert),"\n", bold=true, color=:blue)
@@ -125,3 +111,29 @@ Dev Notes
 printVariable(dfg::AbstractDFG, sym::Symbol; kwargs...) = printVariable(getVariable(dfg, sym); kwargs...)
 
 printNode(dfg::AbstractDFG, sym::Symbol; kwargs...) = isVariable(dfg,sym) ? printVariable(dfg, sym; kwargs...) : printFactor(dfg, sym; kwargs...)
+
+
+##==============================================================================
+## 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", f::DFGFactor) = printFactor(io, f, short=true, limit=false)
+
+function Base.show(io::IO, ::MIME"text/plain", dfg::AbstractDFG)
+    summary(io, dfg)
+    println(io, "\n  UserId: ", dfg.userId)
+    println(io, "  RobotId: ", dfg.robotId)
+    println(io, "  SessionId: ", dfg.sessionId)
+    println(io, "  Description: ", dfg.description)
+    println(io, "  Nr variables: ", length(ls(dfg)))
+    println(io, "  Nr factors: ",length(lsf(dfg)))
+    println(io, "  User Data: ", keys(dfg.userData))
+    println(io, "  Robot Data: ", keys(dfg.robotData))
+    println(io, "  Session Data: ", keys(dfg.sessionData))
+end
+
+
+#default for Atom/Juno
+Base.show(io::IO, ::MIME"application/prs.juno.inline", x::Union{AbstractDFG, DFGVariable, DFGFactor}) = x

test/fileDFGTests.jl

@@ -45,10 +45,14 @@ using Test
         saveDFG(dfg, filename)
 
         copyDfg = DistributedFactorGraphs._getDuplicatedEmptyDFG(dfg)
+        copyDf2 = DistributedFactorGraphs._getDuplicatedEmptyDFG(dfg)
         @info "Going to load $filename"
 
-        #FIXME loadDFG!(copyDfg, filename), but use this to test deprecation
-        retDFG = loadDFG(filename, Main, copyDfg) #, loaddir="/tmp")
+        @test_throws AssertionError loadDFG!(copyDf2,"badfilename")
+
+        retDFG = loadDFG!(copyDfg, filename)
+        # TODO REMOVE test deprecation
+        retDFG_ = loadDFG(filename, Main, copyDf2) #, loaddir="/tmp")
 
         @test issetequal(ls(dfg), ls(retDFG))
         @test issetequal(lsf(dfg), lsf(retDFG))

test/iifInterfaceTests.jl

@@ -13,6 +13,10 @@ end
     v1 = addVariable!(dfg, :a, ContinuousScalar, labels = [:POSE], solvable=0)
     v2 = addVariable!(dfg, :b, ContinuousScalar, labels = [:LANDMARK], solvable=1)
     f1 = addFactor!(dfg, [:a; :b], LinearConditional(Normal(50.0,2.0)), solvable=0)
+
+    @show dfg
+    @show f1
+    @show v1
 end
 
 #test before anything changes

test/interfaceTests.jl

@@ -62,7 +62,12 @@ end
     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 occursin(r"DFGFactor.*\nlabel.*\ntimestamp.*\ntags.*\nsolvable", String(take!(iobuf)))
+    @show teststr = String(take!(iobuf))
+    @test occursin(r"DFGFactor", teststr)
+    @test occursin(r"label", teststr)
+    @test occursin(r"timestamp", teststr)
+    @test occursin(r"tags", teststr)
+    @test occursin(r"solvable", teststr)
 
     # s = String(take!(iobuf))
 

test/testBlocks.jl

@@ -506,6 +506,11 @@ end
 @test ls(fg) == listVariables(fg)
 @test lsf(fg) == listFactors(fg)
 
+if getVariable(fg, ls(fg)[1]) isa DFGVariable
+  @test :default in listSolvekeys(fg)
+  @test :default in listSupersolves(fg)
+end
+
 # simple broadcast test
 if f0 isa DFGFactor
     @test issetequal(getFactorType.(fg, lsf(fg)),  [TestFunctorInferenceType1(), TestFunctorSingleton()])