Merge pull request #670 from JuliaRobotics/21Q1/maint/deprmaxparallel

some cleanup and depr maxparallel -> .maxincidence

Project.toml

@@ -2,7 +2,7 @@ name = "Caesar"
 uuid = "62eebf14-49bc-5f46-9df9-f7b7ef379406"
 keywords = ["SLAM", "state-estimation", "MM-iSAM", "MM-iSAMv2", "inference", "robotics", "ROS"]
 desc = "Non-Gaussian simultaneous localization and mapping"
-version = "0.7.1"
+version = "0.8.0"
 
 [deps]
 ApproxManifoldProducts = "9bbbb610-88a1-53cd-9763-118ce10c1f89"
@@ -54,7 +54,7 @@ FFTW = "1"
 FileIO = "1"
 ImageCore = "0.7, 0.8, 0.9"
 ImageMagick = "0.7, 1.0, 1.1"
-IncrementalInference = "0.16, 0.17, 0.18, 0.19"
+IncrementalInference = "0.20.1"
 JLD2 = "0.1, 0.2, 0.3"
 JSON = "0.18, 0.19, 0.20, 0.21, 0.22, 0.23"
 JSON2 = "0.3, 0.4"
@@ -64,7 +64,7 @@ Optim = "1"
 ProgressMeter = "0.9, 1"
 Reexport = "0.2, 1.0"
 Requires = "0.5, 0.6, 0.7, 0.8, 0.9, 0.10, 1"
-RoME = "0.9, 0.10, 0.11"
+RoME = "0.10, 0.11, 0.12"
 Rotations = "0.13, 1"
 TensorCast = "0.2, 0.3"
 TimeZones = "1.3.1, 1.4"

docs/src/concepts/adding_variables_factors.md

@@ -94,20 +94,20 @@ In a trivial example of Pose2:
 All factors inherit from one of the following types, depending on their function:
 * AbstractPrior: AbstractPrior are priors (unary factors) that provide an absolute constraint for a single variable. A simple example of this is an absolute GPS prior, or equivalently a (0, 0, 0) starting location in a [`Pose2`](@ref) scenario.
   * Requires: A getSample function
-* AbstractRelativeFactorMinimize: AbstractRelativeFactorMinimize are relative factors that introduce an algebraic relationship between two or more variables. A simple example of this is an odometry factor between two pose variables, or a range factor indicating the range between a pose and another variable.
+* AbstractRelativeMinimize: AbstractRelativeMinimize are relative factors that introduce an algebraic relationship between two or more variables. A simple example of this is an odometry factor between two pose variables, or a range factor indicating the range between a pose and another variable.
   * Requires: A getSample function and a residual function definition
   * The minimize suffix specifies that the residual function of this factor will be enforced by numerical minimization (find me the minimum of this function)
-* AbstractRelativeFactor: AbstractRelativeFactor are relative factors that introduce algebraic relationships between two or more variables. They are the same as AbstractRelativeFactorMinimize, however they use root finding to find the zero crossings (rather than numerical minimization).
+* AbstractRelativeRoots: AbstractRelativeRoots are relative factors that introduce algebraic relationships between two or more variables. They are the same as AbstractRelativeMinimize, however they use root finding to find the zero crossings (rather than numerical minimization).
   * Requires: A getSample function and a residual function definition
 
 How do you decide which to use?
 * If you are creating factors for world-frame information that will be tied to a single variable, inherit from AbstractPrior
   * GPS coordinates should be priors
-* If you are creating factors for local-frame relationships between variables, inherit from AbstractRelativeFactorMinimize
+* If you are creating factors for local-frame relationships between variables, inherit from AbstractRelativeMinimize
   * Odometry and bearing deltas should be introduced as pairwise factors and should be local frame
-TBD: sUsers **should** start with AbstractRelativeFactorMinimize, discuss why and when they should promote their factors to AbstractRelativeFactor.
+TBD: sUsers **should** start with AbstractRelativeMinimize, discuss why and when they should promote their factors to AbstractRelativeRoots.
 
-> Note: AbstractRelativeFactorMinimize does not imply that the overall inference algorithm only minimizes an objective function. The Multi-model iSAM algorithm is built around fixed-point analysis. Minimization is used here to locally enforce the residual function.
+> Note: AbstractRelativeMinimize does not imply that the overall inference algorithm only minimizes an objective function. The Multi-model iSAM algorithm is built around fixed-point analysis. Minimization is used here to locally enforce the residual function.
 
 What you need to build in the new factor:
 * A struct for the factor itself
@@ -131,7 +131,7 @@ AbstractRelativeRoots
 ### Pose2Point2BearingRange Struct
 
 ```julia
-mutable struct Pose2Point2BearingRange{B <: IIF.SamplableBelief, R <: IIF.SamplableBelief} <: IncrementalInference.AbstractRelativeFactor
+mutable struct Pose2Point2BearingRange{B <: IIF.SamplableBelief, R <: IIF.SamplableBelief} <: IncrementalInference.AbstractRelativeRoots
     bearing::B
     range::R
     Pose2Point2BearingRange{B,R}() where {B,R} = new{B,R}()

docs/src/concepts/available_varfacs.md

@@ -46,11 +46,11 @@ You can check for the latest factor types by running the following in your termi
 ```julia
 using RoME, Caesar
 println("- Singletons (priors): ")
-println.(sort(string.(subtypes(IncrementalInference.AbstractPrior))));
+println.(sort(string.(subtypes(IIF.AbstractPrior))));
 println("- Pairwise (variable constraints): ")
-println.(sort(string.(subtypes(IncrementalInference.AbstractRelativeFactor))));
+println.(sort(string.(subtypes(IIF.AbstractRelativeRoots))));
 println("- Pairwise (variable minimization constraints): ")
-println.(sort(string.(subtypes(IncrementalInference.AbstractRelativeFactorMinimize))));
+println.(sort(string.(subtypes(IIF.AbstractRelativeMinimize))));
 ```
 
 ### Priors (Absolute Data)

docs/src/examples/basic_definingfactors.md

@@ -21,7 +21,7 @@ Prior(t::T) where {T <: SamplableBelief} = Prior{T}(t)
 # sampling function
 getSample(s::Prior, N::Int=1) = (reshape(rand(s.z,N),1,:), )
 
-struct LinearOffset{T} <: IncrementalInference.AbstractRelativeFactor where T <: SamplableBelief
+struct LinearOffset{T <: SamplableBelief} <: IncrementalInference.AbstractRelativeRoots
   z::T
 end
 getSample(s::LinearOffset, N::Int=1) = (reshape(rand(s.z,N),1,:), )

docs/src/examples/interm_dynpose.md

@@ -52,6 +52,9 @@ getSample(dp2v::DynPoint2VelocityPrior, N::Int=1) = (rand(dp2v.z,N), )
 
 ### `DynPoint2DynPoint2` (preintegration)
 
+!!! warning
+    `::IIF.FactorMetadata` is being refactored and improved.  Some of the content below is out of date.  See IIF #1025 for details. (1Q2021)
+
 The basic idea is that change in position is composed of three components (originating from double integration of Newton's second law):
 
 ![deltapositionplus](https://user-images.githubusercontent.com/6412556/40951449-05bdfed8-6845-11e8-8c4f-31fd92523819.gif)

docs/src/principles/bayestreePrinciples.md

@@ -34,13 +34,13 @@ fg = generateCanonicalFG_Kaess()
 # ...
 
 ## build the tree
-tree = resetBuildTree!(fg)
+tree = buildTreeReset!(fg)
 ```
 
-The temporary values are `reset` from the distributed factor graph object `fg<:AbstractDFG` and a new tree is constructed.  This `resetBuildTree!` call can be repeated as many times the user desires and results should be consistent for the same factor graph structure (regardless of numerical values contained within).
+The temporary values are `reset` from the distributed factor graph object `fg<:AbstractDFG` and a new tree is constructed.  This `buildTreeReset!` call can be repeated as many times the user desires and results should be consistent for the same factor graph structure (regardless of numerical values contained within).
 
 ```@docs
-resetBuildTree!
+buildTreeReset!
 ```
 
 ## Variable Ordering
@@ -60,11 +60,7 @@ vo = [:x1; :l3; :x2; ...]
 
 And then reset the factor graph and build a new tree
 ```julia
-resetBuildTreeFromOrder!(fg, vo)
-```
-
-```@docs
-resetBuildTreeFromOrder!
+buildTreeReset!(fg, vo)
 ```
 
 !!! note
@@ -87,7 +83,7 @@ tree, smt, hist = solveTree!(fg)
 
 ### Get the Elimination Order Used
 
-The solver internally uses [`resetBuildTree!`](@ref) which sometimes requires the user extract the variable elimination order after the fact.  This can be done with:
+The solver internally uses [`buildTreeReset!`](@ref) which sometimes requires the user extract the variable elimination order after the fact.  This can be done with:
 ```@docs
 getEliminationOrder
 ```

examples/basic/quickBatchSolve.jl

@@ -23,7 +23,9 @@ factrs = setdiff(lsf(fg), lsf(fg, r"drt"))
 ensureAllInitialized!(fg)
 
 getSolverParams(fg).drawtree = true
-@time solveTree!(fg, maxparallel=1000);
+getSolverParams(fg).maxincidence = 1000
+
+@time solveTree!(fg);
 
 savepath = splitpath(ARGS[1])
 savename = split(savepath[end], '.')[1]

examples/marine/asv/kayaks/PointSource_script.jl

@@ -102,8 +102,9 @@ writeGraphPdf(fg,viewerapp="", engine="neato", filepath = "/tmp/test.pdf")
 # getSolverParams(fg).drawtree = true
 getSolverParams(fg).limititers=500
 #getSolverParams(fg).showtree = true
+getSolverParams(fg).maxincidence = 200
 
-tree, smt, hist = solveTree!(fg,maxparallel=200)
+tree, smt, hist = solveTree!(fg)
 
 # Some Debuggging
 # @time L1 = approxConv(fg,:l1x1x2x3x4x5x6x7x8f1,:l1)

examples/marine/asv/kayaks/dynsas.jl

@@ -52,6 +52,7 @@ cfgFile = joinpath(ENV["HOME"],"data","sas","SAS2D.yaml")
 cfgd=loadConfigFile(cfgFile)
 
 fg = initfg();
+getSolverParams(fg).maxincidence = 400
 beacon = :l1
 addVariable!(fg, beacon, Point2 )
 tree = emptyBayesTree();
@@ -124,9 +125,9 @@ while pose_counter < totalposes-2
            setValKDE!(fg,lstpose,XXkde);
 
            if sas_counter > 1
-               tree, smt, hist = solveTree!(fg,tree, maxparallel=400)
+               tree, smt, hist = solveTree!(fg,tree)
            else
-               tree, smt, hist = solveTree!(fg, maxparallel=400)
+               tree, smt, hist = solveTree!(fg)
            end
 
            writeGraphPdf(fg,viewerapp="", engine="neato", filepath=scriptHeader*"fg.pdf")

examples/marine/asv/kayaks/dynsas_ljscript.jl

@@ -46,9 +46,11 @@ function main(expID::String, datastart::Int, dataend::Int, fgap::Int, gps_gap::I
     cfgd=loadConfigFile(cfgFile)
 
     fg = initfg();
+    getSolverParams(fg).maxincidence = 1000
+
     beacon = :l1
     addVariable!(fg, beacon, Point2 )
-    tree = emptyBayesTree();
+    tree = BayesTree();
 
     pose_counter = 1
     sas_counter = 1
@@ -114,9 +116,9 @@ function main(expID::String, datastart::Int, dataend::Int, fgap::Int, gps_gap::I
                setValKDE!(fg,lstpose,XXkde);
 
                if sas_counter > 1
-                   tree, smt, hist = solveTree!(fg,tree, maxparallel=400)
+                   tree, smt, hist = solveTree!(fg,tree)
                else
-                   tree, smt, hist = solveTree!(fg, maxparallel=400)
+                   tree, smt, hist = solveTree!(fg)
                end
 
                writeGraphPdf(fg,viewerapp="", engine="neato", filepath=scriptHeader*"fg.pdf")

examples/marine/asv/kayaks/dynsas_timed.jl

@@ -52,9 +52,11 @@ function main(expID::String, datastart::Int, dataend::Int, fgap::Int, gps_gap::I
     cfgd=loadConfigFile(cfgFile)
 
     fg = initfg();
+    getSolverParams(fg).maxincidence = 400
+
     beacon = :l1
     addVariable!(fg, beacon, Point2 )
-    tree = emptyBayesTree();
+    tree = BayesTree();
 
     pose_counter = 1
     sas_counter = 1
@@ -123,9 +125,9 @@ function main(expID::String, datastart::Int, dataend::Int, fgap::Int, gps_gap::I
 
                println("Solving at SAS-F: $(sas_counter), Pos: $(pose_counter) \n");
                if sas_counter > 1
-                   @time tree, smt, hist = solveTree!(fg,tree, maxparallel=400)
+                   @time tree, smt, hist = solveTree!(fg,tree)
                else
-                   @time tree, smt, hist = solveTree!(fg, maxparallel=400)
+                   @time tree, smt, hist = solveTree!(fg)
                end
 
                # writeGraphPdf(fg,viewerapp="", engine="neato", filepath=scriptHeader*"fg.pdf")

examples/marine/asv/kayaks/rangeOnlySLAM.jl

@@ -76,12 +76,12 @@ getSolverParams(fg).showtree = false
 getSolverParams(fg).async = true
 getSolverParams(fg).multiproc = true
 getSolverParams(fg).downsolve = true
+getSolverParams(fg).maxincidence = 100
 
-
-tree, smt, hist = solveTree!(fg, maxparallel=100)
+tree, smt, hist = solveTree!(fg)
 drawTree(tree,filepath = "/tmp/test.pdf")
 # fg2 = deepcopy(fg)
-# tree, smt, hist = solveTree!(fg,tree,maxparallel=100)
+# tree, smt, hist = solveTree!(fg,tree)
 
 # plotSASDefault(fg,expID, posData,igt,datadir=allpaths[1],savedir=scriptHeader*"SASdefault.pdf")
 plotSASDefault(fg,expID, posData,igt,dposData, datadir=allpaths[1], savedir="/tmp/caesar/test.pdf")

examples/marine/asv/kayaks/rangeOnlySLAM_dbg.jl

@@ -81,16 +81,17 @@ getSolverParams(fg).async = true
 getSolverParams(fg).multiproc = false
 getSolverParams(fg).upsolve = true
 getSolverParams(fg).downsolve = false
+getSolverParams(fg).maxincidence = 100
 
 
 # writeGraphPdf(fg, show=true)
 
 ensureAllInitialized!(fg)
 
-tree, smt, hist = solveTree!(fg, maxparallel=100)
+tree, smt, hist = solveTree!(fg0)
 drawTree(tree,filepath = "/tmp/caesar/bt.pdf", show=true, imgs=false)
 # fg2 = deepcopy(fg)
-# tree, smt, hist = solveTree!(fg,tree,maxparallel=100)
+# tree, smt, hist = solveTree!(fg,tree)
 
 # plotSASDefault(fg,expID, posData, igt, dposData, datadir=allpaths[1],savedir="/tmp/caesar/plotsas.pdf");
 # # plotSASDefault(fg,expID, posData,igt,dposData, datadir=allpaths[1], savedir="/tmp/caesar/test.pdf")
@@ -312,21 +313,22 @@ getSolverParams(fg).async = true
 getSolverParams(fg).multiproc = false
 getSolverParams(fg).upsolve = true
 getSolverParams(fg).downsolve = false
+getSolverParams(fg).maxincidence = 100
 
 
 # writeGraphPdf(fg, show=true)
 
 # ensureAllInitialized!(fg)
 
-tree, smt, hist = solveTree!(fg, maxparallel=100)
+tree, smt, hist = solveTree!(fg)
 
 
-plotKDE(fg, reverse(sortVarNested(ls(fg, r"x"))), levels=1)
+plotKDE(fg, reverse(sortDFG(ls(fg, r"x"))), levels=1)
 
 getSolverParams(fg).upsolve = false
 getSolverParams(fg).downsolve = true
 
-tree, smt, hist = solveTree!(fg, maxparallel=100)
+tree, smt, hist = solveTree!(fg)
 
 
 

examples/marine/asv/kayaks/rangeOnlySLAM_ljscript.jl

@@ -68,10 +68,11 @@ function main(expID::String, rangegap::Int, wstart::Int, wend::Int, trialID::Int
     getSolverParams(fg).drawtree = false
     getSolverParams(fg).showtree = false
     getSolverParams(fg).limititers=500
+    getSolverParams(fg).maxincidence = 400
 
 
-    tree, smt, hist = solveTree!(fg, maxparallel=400)
-    tree, smt, hist = solveTree!(fg, maxparallel=400)
+    tree, smt, hist = solveTree!(fg)
+    tree, smt, hist = solveTree!(fg)
     drawTree(tree, filepath=scriptHeader*"bt.pdf")
 
     plotSASDefault(fg,expID, posData,igt,dposData,datadir=allpaths[1],savedir=scriptHeader*"SASdefault.pdf")

examples/marine/asv/kayaks/rangeOnlySLAM_timed.jl

@@ -70,12 +70,13 @@ function main(expID::String, rangegap::Int, wstart::Int, wend::Int, trialID::Int
     getSolverParams(fg).drawtree = false
     getSolverParams(fg).showtree = false
     getSolverParams(fg).limititers=500
+    getSolverParams(fg).maxincidence = 400
 
 
-    tree, smt, hist = solveTree!(fg, maxparallel=400)
+    tree, smt, hist = solveTree!(fg)
     println("Ended Script with $(rangecounter) range factors \n")
 
-    # tree, smt, hist = solveTree!(fg, maxparallel=400)
+    # tree, smt, hist = solveTree!(fg)
     # drawTree(tree, filepath=scriptHeader*"bt.pdf")
 
     # plotSASDefault(fg,expID, posData,igt,dposData,datadir=allpaths[1],savedir=scriptHeader*"SASdefault.pdf")

examples/marine/asv/kayaks/testRangeOnlyOdo.jl

@@ -70,10 +70,11 @@ end
 getSolverParams(fg).drawtree = true
 getSolverParams(fg).showtree = false
 getSolverParams(fg).dbg = true
+getSolverParams(fg).maxincidence = 200
 
 
 ensureAllInitialized!(fg)
-tree, smt, hist = solveTree!(fg, maxparallel=200, recordcliqs=[:x19;:x169;:x166;:x134;:x171])
+tree, smt, hist = solveTree!(fg, recordcliqs=[:x19;:x169;:x166;:x134;:x171])
 
 
 fetchCliqTaskHistoryAll!(smt, hist)
@@ -137,8 +138,6 @@ Gadfly.plot(x=out,Geom.histogram,Coord.cartesian(xmin=0, xmax=100, ymin=0, ymax=
 
 using RoMEPlotting
 
-# tree = wipeBuildNewTree!(fg, maxparallel=200)
-# spyCliqMat(tree, :x169)
 
 drawTree(tree, show=true)
 

examples/marine/auv/Sandshark/LCM_SLAM_client.jl

@@ -256,7 +256,8 @@ end
 
 dontMarginalizeVariablesAll!(fg)
 setSolvable!(getVariable(fg, :drt_ref), 0)
-tree, smt, hist = solveTree!(fg, maxparallel=1000)
+getSolverParams(fg).maxincidence = 1000
+tree, smt, hist = solveTree!(fg)
 
 saveDFG(fg, joinpath(getLogPath(fg),"fg_batchsolve") )
 

examples/marine/auv/Sandshark/SandsharkUtils.jl

@@ -274,6 +274,7 @@ end
 #   getSolverParams(dfg).qfl = dashboard[:SOLVESTRIDE]
 #   getSolverParams(dfg).isfixedlag = true
 #   getSolverParams(dfg).limitfixeddown = limitfixeddown
+#   getSolverParams(dfg).maxincidence = 1000
 #
 #   # allow async process
 #   # getSolverParams(dfg).async = true
@@ -337,7 +338,7 @@ end
 #         dt_save1 = (time_ns()-t0)/1e9
 #         # constrain solve with the latest pose at the top
 #         # @show latestPose = intersect(getLastPoses(dfg, filterLabel=r"x\d", number=12), ls(dfg, r"x\d", solvable=1))[end]
-#         tree, smt, hist = solveTree!(dfg, tree, maxparallel=1000) # , variableConstraints=[latestPose;]
+#         tree, smt, hist = solveTree!(dfg, tree) # , variableConstraints=[latestPose;]
 #         dt_solve = (time_ns()-t0)/1e9
 #         !dbg ? nothing : saveDFG(dfg, joinpath(getLogPath(dfg), "fg_after_$(lasp)"))
 #

examples/marine/auv/Sandshark/Sandshark_script_pieces.jl

@@ -203,6 +203,8 @@ tree1 = wipeBuildNewTree!(fg1)
 # getSolverParams(fg1).isfixedlag = true
 # getSolverParams(fg1).qfl = 20
 
+getSolverParams(fg1).maxincidence = 200
+
 # first solve and initialization
 getSolverParams(fg1).drawtree = true
 # getSolverParams(fg).showtree = false
@@ -226,7 +228,7 @@ for STEP in 0:10:50
     global storeLast
 
     runEpochs!(fg1, epochs, STEP, index1, acousticRate=3)
-    poses = sortVarNested(ls(fg1, r"x"))
+    poses = sortDFG(ls(fg1, r"x"))
 
     if STEP-laglength >= 0
         @show poses[1], poses[end], poses[end-laglength]
@@ -239,7 +241,7 @@ for STEP in 0:10:50
 
     drawGraph(fg1, filepath=joinpath(getSolverParams(fg1).logpath, "graphs", "fg_$(STEP)_.pdf"))
     saveDFG(fg1, joinpath(getSolverParams(fg1).logpath, "graphs", "fg_$(STEP)_before"))
-    @time tree1, smt, hist = solveTree!(fg1, tree1, maxparallel=200)
+    @time tree1, smt, hist = solveTree!(fg1, tree1)
     saveDFG(fg1, joinpath(getSolverParams(fg1).logpath, "graphs", "fg_$(STEP)_after"))
 
     pla = drawPosesLandmarksAndOdo(fg1, ppbrDict, navkeys, X, Y, lblkeys, lblX, lblY)