Merge pull request #301 from JuliaRobotics/maint/20Q1/cleanup06

Maintenance Cleanup for v0.6

Author: dehann

src/CloudGraphsDFG/services/CloudGraphsDFG.jl

@@ -339,8 +339,9 @@ function getFactors(dfg::CloudGraphsDFG, regexFilter::Union{Nothing, Regex}=noth
     return map(vId->getFactor(dfg, vId), factorIds)
 end
 
-function listFactors(dfg::CloudGraphsDFG, regexFilter::Union{Nothing, Regex}=nothing; solvable::Int=0)::Vector{Symbol}
+function listFactors(dfg::CloudGraphsDFG, regexFilter::Union{Nothing, Regex}=nothing; tags::Vector{Symbol}=Symbol[], solvable::Int=0)::Vector{Symbol}
     # Optimized for DB call
+    length(tags) > 0 && (@error "Filter on tags not implemented for CloudGraphsDFG")
     if regexFilter == nothing
         return _getLabelsFromCyphonQuery(dfg.neo4jInstance, "(node:$(dfg.userId):$(dfg.robotId):$(dfg.sessionId):FACTOR) where node.solvable >= $solvable")
     else

src/Common.jl

@@ -64,82 +64,3 @@ ls, lsf
 """
 sortDFG(vars::Vector{<:DFGNode}; by=getTimestamp, kwargs...) = sort(vars; by=by, kwargs...)
 sortDFG(vars::Vector{Symbol}; lt=natural_lt, kwargs...)::Vector{Symbol} = sort(vars; lt=lt, kwargs...)
-
-
-
-#TODO confirm this is only used in sortVarNested, then delete
-# """
-#     $(SIGNATURES)
-# Test if all elements of the string is a number:  Ex, "123" is true, "1_2" is false.
-# """
-# allnums(str::S) where {S <: AbstractString} = occursin(Regex(string(["[0-9]" for j in 1:length(str)]...)), str)
-# occursin(r"_+|,+|-+", node_idx)
-
-# isnestednum(str::S; delim='_') where {S <: AbstractString} = occursin(Regex("[0-9]+$(delim)[0-9]+"), str)
-
-# function sortnestedperm(strs::Vector{<:AbstractString}; delim='_')
-#   str12 = split.(strs, delim)
-#   sp1 = sortperm(parse.(Int,getindex.(str12,2)))
-#   sp2 = sortperm(parse.(Int,getindex.(str12,1)[sp1]))
-#   return sp1[sp2]
-# end
-
-# function getFirstNumericalOffset(st::AS) where AS <: AbstractString
-#   i = 1
-#   while !allnums(st[i:i])  i+=1; end
-#   return i
-# end
-#
-# """
-#     $SIGNATURES
-#
-# Sort a variable list which may have nested structure such as `:x1_2` -- does not sort for alphabetic characters.
-# """
-# function sortVarNested(vars::Vector{Symbol})::Vector{Symbol}
-#     # whos nested and first numeric character offset
-#     sv = string.(vars)
-#     offsets = getFirstNumericalOffset.(sv)
-#     masknested = isnestednum.(sv)
-#     masknotnested = true .⊻ masknested
-#
-#     # strip alphabetic characters from front
-#     msv = sv[masknotnested]
-#     msvO = offsets[masknotnested]
-#     nsv = sv[masknested]
-#     nsvO = offsets[masknested]
-#
-#     # do nonnested list separately
-#     nnreducelist = map((s,o) -> s[o:end], msv, msvO)
-#     nnintlist = parse.(Int, nnreducelist)
-#     nnp = sortperm(nnintlist)
-#     nnNums = nnintlist[nnp] # used in mixing later
-#     nonnested = msv[nnp]
-#     smsv = vars[masknotnested][nnp]
-#
-#     # do nested list separately
-#     nestedreducelist = map((s,o) -> s[o:end], nsv, nsvO)
-#     nestedp = sortnestedperm(nestedreducelist)
-#     nesNums = parse.(Int, getindex.(split.(nestedreducelist[nestedp], '_'),1)) # used in mixing later
-#     nested = nsv[nestedp]
-#     snsv = vars[masknested][nestedp]
-#
-#     # mix back together, pick next sorted item from either pile
-#     retvars = Vector{Symbol}(undef, length(vars))
-#     nni = 1
-#     nesi = 1
-#     lsmsv = length(smsv)
-#     lsnsv = length(snsv)
-#     MAXMAX = 999999999999
-#     for i in 1:length(vars)
-#       # inner ifs to ensure bounds and correct sorting at end of each list
-#       if (nni<=lsmsv ? nnNums[nni] : MAXMAX) <= (nesi<=lsnsv ? nesNums[nesi] : MAXMAX)
-#         retvars[i] = smsv[nni]
-#         nni += 1
-#       else
-#         retvars[i] = snsv[nesi]
-#         nesi += 1
-#       end
-#     end
-#     return retvars
-# end
-#END TODO confirm this is only used in sortVarNested, then delete

src/Deprecated.jl

@@ -8,6 +8,8 @@
 ## Remove in 0.6.0 or 0.6.1?
 ##==============================================================================
 
+@deprecate getfnctype(args...) getFactorType(args...)
+
 @deprecate getEstimate(v::VariableDataLevel1, key::Symbol=:default) getVariablePPE(v, key)
 
 @deprecate estimate(v::VariableDataLevel1, key::Symbol=:default) getVariablePPE(v, key)
@@ -157,9 +159,6 @@ end
 
 @deprecate internalId(args...) getInternalId(args...)
 
-#FIXME TODO based on API definition of merge, in some cases the Noun is really not needed.
-# @deprecate mergeUpdateVariableSolverData!(args...) mergeVariableSolverData!(args...)
-
 @deprecate pack(dfg::AbstractDFG, d::VariableNodeData) packVariableNodeData(dfg, d)
 @deprecate unpack(dfg::AbstractDFG, d::PackedVariableNodeData) unpackVariableNodeData(dfg, d)
 
@@ -191,6 +190,3 @@ function buildSubgraphFromLabels(dfg::G,
 end
 
 @deprecate sortVarNested(vars::Vector{Symbol}) sortDFG(vars)
-
-#TODO Deprecated or obsolete?
-@deprecate getfnctype(args...) getFactorType(args...)

src/DistributedFactorGraphs.jl

@@ -71,8 +71,8 @@ export isFullyConnected, hasOrphans
 
 export getBiadjacencyMatrix
 
-#summary structure #TODO Abstract name here is confusing
-export AbstractDFGSummary
+#summary structure
+export DFGSummary
 
 export getSummary, getSummaryGraph
 
@@ -110,7 +110,7 @@ export InferenceVariable
 
 # accessors
 export getSolverDataDict, setSolverData!
-export getSofttype
+export getSofttype, getSofttypename
 
 export getSolverData
 

src/LightDFG/LightDFG.jl

@@ -3,7 +3,7 @@ module LightDFGs
 using LightGraphs
 using DocStringExtensions
 
-import ...DistributedFactorGraphs: AbstractDFG, DFGNode, AbstractDFGVariable, AbstractDFGFactor, AbstractDFGSummary, AbstractParams, NoSolverParams, DFGVariable, DFGFactor
+import ...DistributedFactorGraphs: AbstractDFG, DFGNode, AbstractDFGVariable, AbstractDFGFactor, DFGSummary, AbstractParams, NoSolverParams, DFGVariable, DFGFactor
 
 # import DFG functions to extend
 import ...DistributedFactorGraphs:  setSolverParams!,

src/LightDFG/services/LightDFG.jl

@@ -184,8 +184,11 @@ function getFactors(dfg::LightDFG, regexFilter::Union{Nothing, Regex}=nothing; t
     return factors
 end
 
-function listFactors(dfg::LightDFG, regexFilter::Union{Nothing, Regex}=nothing; solvable::Int=0)::Vector{Symbol}
+function listFactors(dfg::LightDFG, regexFilter::Union{Nothing, Regex}=nothing; tags::Vector{Symbol}=Symbol[], solvable::Int=0)::Vector{Symbol}
     # factors = map(v -> v.dfgNode, filter(n -> n.dfgNode isa DFGFactor, vertices(dfg.g)))
+    if length(tags) > 0
+        return map(v -> v.label, getFactor(dfg, regexFilter, tags=tags, solvable=solvable))
+    end
     factors = collect(keys(dfg.g.factors))
     if regexFilter != nothing
         factors = filter(f -> occursin(regexFilter, String(f)), factors)

src/entities/AbstractDFGSummary.jl

@@ -2,8 +2,8 @@
 $(TYPEDEF)
 Structure for a graph summary.
 """
-# TODO why is this called Abstract...
-struct AbstractDFGSummary
+
+struct DFGSummary
   variables::Dict{Symbol, DFGVariableSummary}
   factors::Dict{Symbol, DFGFactorSummary}
   userId::String

src/services/AbstractDFG.jl

@@ -292,22 +292,19 @@ end
     $(SIGNATURES)
 Checks if the graph is fully connected, returns true if so.
 """
-function isFullyConnected(dfg::G)::Bool where G <: AbstractDFG
+function isFullyConnected(dfg::AbstractDFG)::Bool
     error("isFullyConnected not implemented for $(typeof(dfg))")
 end
 
 """
     $(SIGNATURES)
 Retrieve a list of labels of the immediate neighbors around a given variable or factor specified by its label.
 """
-function getNeighbors(dfg::G, label::Symbol; solvable::Int=0)::Vector{Symbol} where G <: AbstractDFG
-    error("getNeighbors not implemented for $(typeof(dfg))")
-end
-##TODO reduce with  getNeighbors(dfg, node.label)
-function getNeighbors(dfg::G, node::T; solvable::Int=0)::Vector{Symbol}  where {G <: AbstractDFG, T <: DFGNode}
+function getNeighbors(dfg::AbstractDFG, label::Symbol; solvable::Int=0)::Vector{Symbol}
     error("getNeighbors not implemented for $(typeof(dfg))")
 end
 
+
 ##------------------------------------------------------------------------------
 ## copy and duplication
 ##------------------------------------------------------------------------------
@@ -416,6 +413,11 @@ end
 ##------------------------------------------------------------------------------
 ## Connectivity Alias
 ##------------------------------------------------------------------------------
+
+function getNeighbors(dfg::AbstractDFG, node::DFGNode; solvable::Int=0)::Vector{Symbol}
+    getNeighbors(dfg, node.label, solvable=solvable)
+end
+
 #Alias
 #TODO rather actually check if there are orphaned factors (factors without all variables)
 """
@@ -457,8 +459,8 @@ end
 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; solvable::Int=0)::Vector{Symbol} where G <: AbstractDFG
-    return map(f -> f.label, getFactors(dfg, regexFilter, solvable=solvable))
+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))
 end
 
 ##------------------------------------------------------------------------------
@@ -485,8 +487,8 @@ end
 List the DFGFactors in the DFG.
 Optionally specify a label regular expression to retrieves a subset of the factors.
 """
-function lsf(dfg::G, regexFilter::Union{Nothing, Regex}=nothing; solvable::Int=0)::Vector{Symbol} where G <: AbstractDFG
-    return listFactors(dfg, regexFilter, solvable=solvable)
+function lsf(dfg::G, regexFilter::Union{Nothing, Regex}=nothing; tags::Vector{Symbol}=Symbol[], solvable::Int=0)::Vector{Symbol} where G <: AbstractDFG
+    return listFactors(dfg, regexFilter, tags=tags, solvable=solvable)
 end
 
 
@@ -1036,12 +1038,12 @@ end
 """
     $(SIGNATURES)
 Get a summary of the graph (first-class citizens of variables and factors).
-Returns a AbstractDFGSummary.
+Returns a DFGSummary.
 """
-function getSummary(dfg::G)::AbstractDFGSummary where {G <: AbstractDFG}
+function getSummary(dfg::G)::DFGSummary where {G <: AbstractDFG}
     vars = map(v -> convert(DFGVariableSummary, v), getVariables(dfg))
     facts = map(f -> convert(DFGFactorSummary, f), getFactors(dfg))
-    return AbstractDFGSummary(
+    return DFGSummary(
         Dict(map(v->v.label, vars) .=> vars),
         Dict(map(f->f.label, facts) .=> facts),
         dfg.userId,

src/services/DFGVariable.jl

@@ -34,21 +34,16 @@ function getSofttype(vnd::VariableNodeData)
   return vnd.softtype
 end
 
-#TODO getSofttype(v::DFGVariable, solvekey::Symbol=:default) getSofttype(getSolverData(v, solvekey))
-function getSofttype(v::DFGVariable, solvekey::Symbol=:default)
-  return v.solverDataDict[solvekey].softtype # Get instantiated form of the parameter for the DFGVariable
-end
+getSofttype(v::DFGVariable, solvekey::Symbol=:default) = getSofttype(getSolverData(v, solvekey))
+
+getSofttype(dfg::AbstractDFG, lbl::Symbol, solvekey::Symbol=:default) = getSofttype(getVariable(dfg,lbl), solvekey)
 
-## TODO repeated function and broken as it does not pass in solvekey
 """
-    $SIGNATURES
+    getVariableType
 
-Return the DFGVariable softtype in factor graph `dfg<:AbstractDFG` and label `::Symbol`.
+Alias for [`getSofttype`](@ref).
 """
-getVariableType(var::DFGVariable) = getSofttype(var)
-function getVariableType(dfg::G, lbl::Symbol) where G <: AbstractDFG
-  getVariableType(getVariable(dfg, lbl))
-end
+getVariableType(params...) = getSofttype(params...)
 
 ##------------------------------------------------------------------------------
 ## solvedCount
@@ -284,16 +279,21 @@ end
 ## TODO this should return the softtype object, or try to. it should be getSofttypename for the accessor
 ## TODO Consider parameter N in softtype for dims, and storing constructor in softtypename
 ## TODO or just not having this function at all
+# getSofttype(v::DFGVariableSummary) = v.softypename()
 ##------------------------------------------------------------------------------
 
 """
     $SIGNATURES
 
 Retrieve the soft type name symbol for a DFGVariableSummary. ie :Point2, Pose2, etc.
-TODO, DO NOT USE v.softtypename in DFGVariableSummary
 """
-getSofttype(v::DFGVariableSummary)::Symbol = v.softtypename
+getSofttypename(v::DFGVariableSummary)::Symbol = v.softtypename
+
 
+function getSofttype(v::DFGVariableSummary)::InferenceVariable
+    @warn "Looking for type in `Main`. Only use if softtype has only one implementation,ie. Pose2. Otherwise use the full variable."
+    return getfield(Main, v.softtypename)()
+end
 
 ##==============================================================================
 ## Layer 2 CRUD and SET

test/LightDFGSummaryTypes.jl

@@ -42,7 +42,7 @@ end
         @test getTimestamp(v1) == v1.timestamp
         @test getVariablePPEs(v1) == v1.ppeDict
         @test_throws KeyError getVariablePPE(v1, :notfound)
-        @test getSofttype(v1) == :Pose2
+        @test getSofttypename(v1) == :Pose2
         @test getInternalId(v1) == v1._internalId
 
         # FACTYPE == DFGFactorSummary