Update to use filters for DFG v1 (#1899)

Author: Affie

IncrementalInference/src/CliqueStateMachine/services/CliqueStateMachine.jl

@@ -287,7 +287,7 @@ function preUpSolve_StateMachine(csmc::CliqStateMachineContainer)
   logCSM(
     csmc,
     "CSM-2a messages for up";
-    upmsg = lsf(csmc.cliqSubFg; tags = [:__LIKELIHOODMESSAGE__]),
+    upmsg = lsf(csmc.cliqSubFg; tagsFilter = ⊇([:__LIKELIHOODMESSAGE__])),
   )
 
   # store the cliqSubFg for later debugging
@@ -762,7 +762,7 @@ function tryDownInit_StateMachine(csmc::CliqStateMachineContainer)
   # structure for all up message densities computed during this initialization procedure.
   # XXX
   dwnkeys_ =
-    lsf(csmc.cliqSubFg; tags = [:__DOWNWARD_COMMON__;]) .|> x -> ls(csmc.cliqSubFg, x)[1]
+    lsf(csmc.cliqSubFg; tagsFilter = ⊇([:__DOWNWARD_COMMON__;])) .|> x -> ls(csmc.cliqSubFg, x)[1]
   initorder = getCliqInitVarOrderDown(csmc.cliqSubFg, csmc.cliq, dwnkeys_)
   # initorder = getCliqVarInitOrderUp(csmc.tree, csmc.cliq)
 

IncrementalInference/src/ExportAPI.jl

@@ -20,7 +20,7 @@ export AbstractDFG,
   isSolved,
   setSolvedCount!,
   listSupersolves,
-  listSolveKeys,
+  listStates,
   diagm,
   listBlobEntries,
   FolderStore,

IncrementalInference/src/services/AnalysisTools.jl

@@ -19,7 +19,7 @@ function shrinkFactorGraph(fg; upto::Int = 6)
   fgs = deepcopy(fg)
 
   delVars = filter(x -> isSolvable(getVariable(fgs, x)) == 0, ls(fgs))
-  todel = setdiff(lsf(fgs; solvable = 0), lsf(fgs; solvable = 1))
+  todel = setdiff(lsf(fgs; solvableFilter = >=(0)), lsf(fgs; solvableFilter = >=(1)))
   delFcts = intersect(lsf(fgs), todel)
   allMags = filter(x -> :MAGNETOMETER in listTags(getFactor(fgs, x)), lsfPriors(fgs))
   union!(delFcts, filter(x -> length(ls(fgs, x)) == 0, allMags))

IncrementalInference/src/services/BayesNet.jl

@@ -149,11 +149,11 @@ function buildBayesNet!(dfg::AbstractDFG, elimorder::Vector{Symbol}; solvable::I
     gm = FactorCompute[]
 
     vert = DFG.getVariable(dfg, v)
-    for fctId in listNeighbors(dfg, vert; solvable = solvable)
+    for fctId in listNeighbors(dfg, vert; solvableFilter = >=(solvable))
       fct = DFG.getFactor(dfg, fctId)
       if (fct.state.eliminated != true)
         push!(fi, fctId)
-        for sepNode in listNeighbors(dfg, fct; solvable = solvable)
+        for sepNode in listNeighbors(dfg, fct; solvableFilter = >=(solvable))
           # TODO -- validate !(sepNode.index in Si) vs. older !(sepNode in Si)
           if sepNode != v && !(sepNode in Si) # Symbol comparison!
             push!(Si, sepNode)

IncrementalInference/src/services/DeconvUtils.jl

@@ -120,14 +120,7 @@ function approxDeconv(
   ccw::CommonConvWrapper = _getCCW(fcto);
   N::Int = 100,
   measurement::AbstractVector = sampleFactor(ccw, N),
-  retries=nothing,
 )
-  if !isnothing(retries)
-    Base.depwarn(
-      "approxDeconv kwarg retries is not used",
-      :approxDeconv,
-    )
-  end
   # but what if this is a partial factor -- is that important for general cases in deconv?
   _setCCWDecisionDimsConv!(ccw, 0)
 
@@ -188,15 +181,12 @@ function approxDeconv(
   dfg::AbstractDFG,
   fctsym::Symbol,
   solveKey::Symbol = :default;
-  retries::Int = 3,
 )
-  #
-
   # which factor
   fct = getFactor(dfg, fctsym)
   pts = getPoints(getBelief(dfg, getVariableOrder(fct)[1], solveKey))
   N = length(pts)
-  pts = approxDeconv(fct; N = N, retries = retries)
+  pts = approxDeconv(fct; N = N)
   return pts
 end
 
@@ -206,10 +196,7 @@ function approxDeconv(
   factorType::AbstractRelativeObservation,
   solveKey::Symbol = :default;
   tfg::AbstractDFG = initfg(),
-  retries::Int = 3,
 )
-  #
-
   # build a local temporary graph copy containing the same values but user requested factor type.
   fct = getFactor(dfg, fctlbl)
   fctT = getObservation(fct)
@@ -223,7 +210,7 @@ function approxDeconv(
   f_ = addFactor!(tfg, lbls, factorType; graphinit = false)
 
   # peform the deconvolution operation on the temporary graph with user desired factor instead.
-  return approxDeconv(tfg, getLabel(f_); retries = retries)
+  return approxDeconv(tfg, getLabel(f_))
 end
 
 # try default constructor

IncrementalInference/src/services/GraphInit.jl

@@ -21,7 +21,7 @@ See also: [`doautoinit!`](@ref), [`initAll!`](@ref)
 function makeSolverData!(
   dfg::AbstractDFG;
   solvable = 1,
-  varList::AbstractVector{Symbol} = ls(dfg; solvable),
+  varList::AbstractVector{Symbol} = ls(dfg; solvableFilter = >=(solvable)),
   solveKey::Symbol=:default
 )
   count = 0
@@ -475,8 +475,8 @@ function ensureSolvable!(
   solvableFallback::Int = 0,
 )
   # workaround in case isolated variables occur
-  solvVars = ls(dfg; solvable = solvableTarget)
-  varHasFact = (x -> length(ls(dfg, x; solvable = solvableTarget)) == 0).(solvVars)
+  solvVars = ls(dfg; solvableFilter = >=(solvableTarget))
+  varHasFact = (x -> length(listNeighbors(dfg, x; solvableFilter = >=(solvableTarget))) == 0).(solvVars)
   blankVars = solvVars[findall(varHasFact)]
   if 0 < length(blankVars)
     @warn(
@@ -504,7 +504,7 @@ function initAll!(
 )
   #
   # allvarnodes = getVariables(dfg)
-  syms = intersect(DFG.getAddHistory(dfg), ls(dfg; solvable = solvable))
+  syms = intersect(DFG.getAddHistory(dfg), ls(dfg; solvableFilter = >=(solvable)))
   # syms = ls(dfg, solvable=solvable) # |> sortDFG
 
   # May have to first add the solveKey VNDs if they are not yet available

IncrementalInference/src/services/JunctionTreeUtils.jl

@@ -778,7 +778,7 @@ function buildTreeFromOrdering!(
   # copy required for both remote and local graphs
   DFG.deepcopyGraph!(fge, dfg)
 
-  println("Building Bayes net...")
+  @info "Building Bayes net..."
   buildBayesNet!(fge, elimOrder; solvable = solvable)
 
   tree = BayesTree()
@@ -793,7 +793,7 @@ function buildTreeFromOrdering!(
     close(fid)
   end
 
-  println("Find potential functions for each clique")
+  @info "Find potential functions for each clique"
   for cliqIds in getCliqueIds(tree)
     # start at the root, of which there could be multiple disconnected trees
     if isRoot(tree, cliqIds)
@@ -999,7 +999,7 @@ function getCliqFactorsFromFrontals(
     for fctid in ls(fgl, frsym)
       fct = getFactor(fgl, fctid)
       if !unused || !fct.state.potentialused
-        loutn = ls(fgl, fctid; solvable = solvable)
+        loutn = listNeighbors(fgl, fctid; solvableFilter = >=(solvable))
         # deal with unary factors
         if length(loutn) == 1
           union!(usefcts, Symbol[Symbol(fct.label);])
@@ -1194,9 +1194,9 @@ function getCliqVarsWithFrontalNeighbors(
   union!(syms, Symbol.(cond))
 
   # TODO Can we trust factors are frontal connected?
-  ffcs = union(map(x -> ls(fgl, x; solvable = solvable), frtl)...)
+  ffcs = union(map(x -> listNeighbors(fgl, x; solvableFilter = >=(solvable)), frtl)...)
   # @show ffcs = getCliqueData(cliq).potentials
-  neig = union(map(x -> ls(fgl, x; solvable = solvable), ffcs)...)
+  neig = union(map(x -> listNeighbors(fgl, x; solvableFilter = >=(solvable)), ffcs)...)
   union!(syms, Symbol.(neig))
   return syms
 end

IncrementalInference/src/services/SolverAPI.jl

@@ -43,7 +43,7 @@ function taskSolveTree!(
 
   approx_iters = getNumCliqs(treel) * 24
   solve_progressbar =
-    verbose ? nothing : ProgressUnknown("Solve Progress: approx max $approx_iters, at iter")
+    verbose ? nothing : ProgressUnknown(; desc = "Solve Progress: approx max $approx_iters, at iter")
 
   # queue all the tasks/threads
   if !isTreeSolved(treel; skipinitialized = true)
@@ -387,13 +387,16 @@ function solveTree!(
 
   # perhaps duplicate current value
   if storeOld || opt.dbg
-    ss = listSolveKeys(dfgl) .|> string
+    ss = listStates(dfgl) .|> string
     ss_ = ss[occursin.(r"default_", ss)] .|> x -> x[9:end]
     filter!(x -> occursin(r"^\d+$", x), ss_)  # ss_ = ss_[occursin.(r"^\d$",ss_)]
     allk = parse.(Int, ss_)
     nextk = length(allk) == 0 ? 0 : maximum(allk) + 1
     newKey = Symbol(:default_, nextk)
-    DFG.cloneSolveKey!(dfgl, newKey, :default; solvable = 1)
+    # DFG.cloneStates!(dfgl, newKey, :default; solvableFilter = >=(1))
+    for vlabel in ls(dfgl; solvableFilter = >=(1))
+        DFG.copytoState!(dfgl, vlabel, newKey, getState(dfgl, vlabel, :default))
+    end
     # foreach(x->updateVariableSolverData!(dfgl, x, getState(getVariable(dfgl,x), :default), newKey, true, Symbol[]), ls(dfgl, solvable=1))
     @info "storeOld=true, previous :default deepcopied into $newKey for solvable==1 variables."
   end

IncrementalInference/src/services/SolverUtilities.jl

@@ -157,7 +157,7 @@ function _buildGraphByFactorAndTypes!(
   newFactor::Bool = true,
   destPattern::Regex = r"x\d+",
   destPrefix::Symbol = match(r"[a-zA-Z_]+", destPattern.pattern).match |> Symbol,
-  _allVars::AbstractVector{Symbol} = sortDFG(ls(dfg, destPattern)),
+  _allVars::AbstractVector{Symbol} = sortDFG(ls(dfg; labelFilter=contains(destPattern))),
   currLabel::Symbol = 0 < length(_allVars) ? _allVars[end] : Symbol(destPrefix, 0),
   currNumber::Integer = reverse(match(r"\d+", reverse(string(currLabel))).match) |>
                         x -> parse(Int, x),

IncrementalInference/src/services/TreeMessageUtils.jl

@@ -618,7 +618,7 @@ function deleteMsgFactors!(
   tags::Vector{Symbol} = [:__LIKELIHOODMESSAGE__],
 )
   # remove msg factors that were added to the subfg
-  facs = lsf(subfg; tags = tags)
+  facs = lsf(subfg; tagsFilter = !isdisjoint(tags))
   deleteFactor!.(subfg, facs)
   return facs
 end