## Function Reference

**WORK IN PROGRESS** Not all functions have been added to this directory yet.

### Caesar

`Caesar.appendvertbigdata!`

— Function.```
appendvertbigdata!(cloudGraph::CloudGraphs.CloudGraph, cv::CloudGraphs.CloudVertex, description::Any, data::Array{UInt8,1})
```

Append big data element into current blob store and update associated global vertex information.

```
appendvertbigdata!(fgl::FactorGraph, vert::ExVertex, description::AbstractString, data::Array{UInt8,1})
```

Append big data element into current blob store and update associated global vertex information.

`appendvertbigdata!(fg, sym, descr, data)`

Append big data element into current blob store using parent appendvertbigdata!, but here specified by symbol of variable node in the FactorGraph. Note the default data layer api definition. User must define dlapi to refetching the vertex from the data layer. localapi avoids repeated network database fetches.

`Caesar.consoleaskuserfordb`

— Function.```
consoleaskuserfordb(; nparticles, drawdepth, clearslamindb, multisession, drawedges) -> Dict{AbstractString,Any}
```

Obtain database addresses and login credientials from STDIN, as well as a few case dependent options.

`Caesar.db2jld`

— Function.`db2jld(cgl::CloudGraph, session::AbstractString, filename::AbstractString)`

Fetch and save a FactorGraph session to a jld, using CloudGraph object and session definition.

`db2jld(filename::AbstractString; addrdict::NothingUnion{Dict{AbstractString, AbstractString}}=nothing )`

Fetch and save a FactorGraph session to a jld, using or asking STDIN for credentials in the addrdict field.

`Caesar.executeQuery`

— Function.```
executeQuery(connection::AS<:AbstractString, query::AS<:AbstractString)
```

Run Neo4j Cypher queries on the cloudGraph database, and return Tuple with the unparsed (results, loadresponse). Throws an error if the query fails.

`Caesar.fetchrobotdatafirstpose`

— Function.`fetchrobotdatafirstpose(cg::CloudGraph, session::AbstractString, robot::AbstractString, user::AbstractString)`

Return dict of JSON parsed "robot_description" field as was inserted by counterpart `insertrobotdatafirstpose!`

function. Used for storing general robot specific data in easily accessible manner.

`Caesar.fetchsubgraph!`

— Function.```
fetchsubgraph!(fgl::FactorGraph, cvs::Array{CloudGraphs.CloudVertex,1}; numneighbors)
```

Fetch and insert list of CloudVertices into FactorGraph object, up to neighbor depth.

```
fetchsubgraph!(fgl, neoids; numneighbors)
```

Fetch and insert list of Neo4j IDs into FactorGraph object, up to neighbor depth.

`Caesar.findExistingMSConstraints`

— Function.`findExistingMSConstraints(fgl::FactorGraph)`

Return Dict{Symbol, Int} of vertex symbol to Neo4j node ID of MULTISESSION constraints in this `fgl.sessionname`

.

`Caesar.getAllLandmarkNeoIDs`

— Function.`getAllLandmarkNeoIDs(::Dict{Symbol, Dict{Symbol, Int}}, ::Symbol)`

Return Vector{Int} of Neo4j vertex IDs relating to symbol, as listed in lm2others.

`Caesar.getBigDataElement`

— Function.```
getBigDataElement(vertex::CloudGraphs.CloudVertex, description::AbstractString) -> Union{Nothing, BigDataElement}
```

Walk through vertex bigDataElements and return the last matching description.

`Caesar.getExVertexNeoIDs`

— Function.```
getExVertexNeoIDs(conn::Neo4j.Connection; label, ready, backendset, session, robot, user, reqbackendset) -> Array{Tuple{Int64,Int64,Symbol},1}
```

Return array of tuples with ExVertex IDs and Neo4j IDs for vertices with label in session.

`Caesar.getLandmOtherSessNeoIDs`

— Function.`getLandmOtherSessNeoIDs{T <: AbstractString}(::CloudGraph, session::T="", robot::T="", user::T="", multisessions=Vector{T}())`

Return dict of dict of Neo4j vertex IDs by session and landmark symbols.

`Caesar.getLocalSubGraphMultisession`

— Function.```
getLocalSubGraphMultisession(cg::T<:AbstractString, lm2others::T<:AbstractString; session, robot, user, numneighbors)
```

Return subgraph copy of type FactorGraph contaning values from session in lm2others, and Vector{Symbol} of primary key symbols used for graph exstraction.

`Caesar.getPoseExVertexNeoIDs`

— Function.```
getPoseExVertexNeoIDs(conn::Neo4j.Connection; ready, backendset, session, reqbackendset)
```

Return array of tuples with ExVertex IDs and Neo4j IDs for all poses.

`Caesar.getVertNeoIDs!`

— Function.`getVertNeoIDs!(::CloudGraph, res::Dict{Symbol, Int}; session::AbstractString="NA", robot::AbstractString="NA", user::AbstractString="NA")`

Insert into and return dict `res`

with Neo4j IDs of ExVertex labels as stored per session in Neo4j database.

`Caesar.getfirstpose`

— Function.`getfirstpose(cg::CloudGraph, session::AbstractString, robot::AbstractString, user::AbstractString)`

Return Tuple{Symbol, Int} of first pose symbol and Neo4j node ID.

`Caesar.getnewvertdict`

— Function.`getnewvertdict(conn, session::AbstractString, robot::AbstractString, user::AbstractString)`

Return a dictionary with frtend and mongo_keys json string information for :NEWDATA elements in Neo4j database.

`Caesar.getprpt2kde`

— Function.`getprp2kde(::CloudGraph, neoids::Vector{Int}; N::Int=100)`

Return PriorPoint2DensityNH with N points based on beliefs of neoids, and equal share null hypothesis between length(neoids)+1 beliefs.

`Caesar.hasBigDataElement`

— Function.```
hasBigDataElement(vertex::CloudGraphs.CloudVertex, description::AbstractString) -> Bool
```

Return true if vertex has bigDataElements with matching description.

`Caesar.insertrobotdatafirstpose!`

— Function.`insertrobotdatafirstpose!(cg::CloudGraph, session::AbstractString, robot::AbstractString, user::AbstractString, robotdict::Dict)`

Saves robotdict via JSON to first pose in a SESSION in the database. Used for storing general robot specific data in easily accessible manner. Can fetch later retrieve same dict with counterpart `fetchrobotdatafirstpose`

function.

`Caesar.removeNeo4jID`

— Function.`removeNeo4jID(cg::CloudGraph, neoid=-1)`

Remove node from Neo4j according to Neo4j Node ID. Big data elements that may be associated with this node are not removed.

`Caesar.resetentireremotesession`

— Function.`resetentireremotesession(conn, session, robot, user)`

match (n:session) remove n.backendset, n.ready, n.data, n.bigData, n.label, n.packedType, n.exVertexId, n.shape, n.width set n :NEWDATA return n

`Caesar.rmInstMultisessionPriors!`

— Function.`rmInstMultisessionPriors!(::CloudGraph; session<:AbstractString=, multisessions::Vector{<:AbstractString}= )`

`Caesar.standardcloudgraphsetup`

— Function.```
standardcloudgraphsetup(; addrdict, nparticles, drawdepth, drawedges, clearslamindb, multisession) -> Tuple{CloudGraphs.CloudGraph,Dict{AbstractString,Any}}
```

Connect to databases via network according to addrdict, or ask user for credentials and return active cloudGraph object, as well as addrdict.

`Caesar.updatenewverts!`

— Function.`updatenewverts!(fgl::FactorGraph; N::Int)`

Convert vertices of session in Neo4j DB with Caesar.jl's required data elements in preparation for MM-iSAMCloudSolve process.

`Caesar.whosNear2D`

— Function.```
whosNear2D(cg::CloudGraphs.CloudGraph, session::AbstractString, robot::AbstractString, user::AbstractString; x, y, yaw, dist, angle)
```

Find vertices near the point specified and return dictionary of symbol to Neo4j ID pairs.

`Caesar.whosNear3D`

— Function.```
whosNear3D(cg::CloudGraphs.CloudGraph, session::AbstractString, robot::AbstractString, user::AbstractString; x, y, z, roll, pitch, yaw, dist, angle)
```

Find vertices near the point specified and return dictionary of symbol to Neo4j ID pairs.

### RoME

`RoME.getRangeKDEMax2D`

— Function.```
getRangeKDEMax2D(fgl, vsym1, vsym2)
```

Calculate the cartesian distance between two vertices in the graph using their symbol name, and by maximum belief point.

`getRangeKDEMax2D(cgl::CloudGraph, session::AbstractString, vsym1::Symbol, vsym2::Symbol)`

Calculate the cartesian distange between two vertices in the graph, by session and symbol names, and by maximum belief point.

`RoME.initFactorGraph!`

— Function.```
initFactorGraph!(fg; P0, init, N, lbl, ready, firstPoseType, labels)
```

Initialize a factor graph object as Pose2, Pose3, or neither and returns variable and factor symbols as array.

`RoME.addOdoFG!`

— Function.```
addOdoFG!(fg, n, DX, cov; N, ready, labels)
```

Create a new variable node and insert odometry constraint factor between which will automatically increment latest pose symbol x<k+1> for new node new node and constraint factor are returned as a tuple.

```
addOdoFG!(fgl, odo; N, ready, labels)
```

Create a new variable node and insert odometry constraint factor between which will automatically increment latest pose symbol x<k+1> for new node new node and constraint factor are returned as a tuple.

### IncrementalInference

`IncrementalInference.addVariable!`

— Function.```
addVariable!(fg, lbl, softtype; N, autoinit, ready, dontmargin, labels, api, uid, smalldata, checkduplicates)
```

Add a variable node `lbl::Symbol`

to `fg::FactorGraph`

, as `softtype<:InferenceVariable`

.

**Example**

```
fg = initfg()
addVariable!(fg, :x0, Pose2)
```

`IncrementalInference.addFactor!`

— Function.```
addFactor!(fgl, Xi, usrfnc; multihypo, ready, api, labels, uid, autoinit, threadmodel)
```

Add factor with user defined type <: FunctorInferenceType to the factor graph object. Define whether the automatic initialization of variables should be performed. Use order sensitive `multihypo`

keyword argument to define if any variables are related to data association uncertainty.

`IncrementalInference.allnums`

— Function.Test if all elements of the string is a number: Ex, "123" is true, "1_2" is false.

`IncrementalInference.approxCliqMarginalUp!`

— Function.```
approxCliqMarginalUp!(fgl, treel, csym)
approxCliqMarginalUp!(fgl, treel, csym, onduplicate; N, dbg, iters, drawpdf, multiproc)
```

Approximate Chapman-Kolmogorov transit integral and return separator marginals as messages to pass up the Bayes (Junction) tree, along with additional clique operation values for debugging.

**Notes**

`onduplicate=true`

by default internally uses deepcopy of factor graph and Bayes tree, and does**not**update the given objects. Set false to update`fgl`

and`treel`

during compute.

`IncrementalInference.approxConv`

— Function.```
approxConv(fgl, fct, towards; api, N)
```

Draw samples from the approximate convolution of `towards`

symbol using factor `fct`

relative to the other variables. In addition the `api`

can be adjusted to recover the data from elsewhere (likely to be replaced/removed in the future).

`IncrementalInference.areCliqChildrenNeedDownMsg`

— Function.```
areCliqChildrenNeedDownMsg(children)
```

Return `true`

if any of the children cliques have status `:needdownmsg`

.

```
areCliqVariablesAllMarginalized(subfg, cliq)
```

Return true if all variables in clique are considered marginalized (and initialized).

`IncrementalInference.batchSolve!`

— Function.```
batchSolve!(fgl; upsolve, downsolve, drawpdf, show, N, recursive, dbg, treeinit, limititers, skipcliqids, recordcliqs, returntasks)
```

Perform multimodal incremental smoothing and mapping (mm-iSAM) computations over given factor graph `fgl::FactorGraph`

on the local computer. A pdf of the Bayes (Junction) tree will be generated in the working folder with `drawpdf=true`

```
blockCliqUntilChildrenHaveUpStatus(tree, prnt)
```

Block the thread until child cliques of `prnt::Graphs.ExVertex`

have finished attempting upward initialization – i.e. have status result. Return `::Dict{Symbol}`

indicating whether next action that should be taken for each child clique.

Notes:

- See status options at
`getCliqStatusUp(..)`

. - Can be called multiple times

`IncrementalInference.buildSubgraphFromLabels`

— Function.```
buildSubgraphFromLabels(fgl, syms)
```

Construct a new factor graph object as a subgraph of `fgl::FactorGraph`

based on the variable labels `syms::Vector{Symbols}`

.

`IncrementalInference.buildTreeFromOrdering!`

— Function.```
buildTreeFromOrdering!(fgl, p; drawbayesnet)
```

Build Bayes/Junction/Elimination tree from a given variable ordering.

`IncrementalInference.buildCliqSubgraphDown`

— Function.```
buildCliqSubgraphDown(fgl, treel, cliqsym)
buildCliqSubgraphDown(fgl, treel, cliqsym, varsym)
```

Build a new subgraph from `fgl::FactorGraph`

containing all variables and factors associated with `cliq`

. Additionally add the upward message prior factors as needed for belief propagation (inference).

Notes

`cliqsym::Symbol`

defines the cliq where variable appears as a frontal variable.`varsym::Symbol`

defaults to the cliq frontal variable definition but can in case a separator variable is required instead.

`IncrementalInference.buildCliqSubgraphUp`

— Function.```
buildCliqSubgraphUp(fgl, treel, cliqsym)
buildCliqSubgraphUp(fgl, treel, cliqsym, varsym)
```

Build a new subgraph from `fgl::FactorGraph`

containing all variables and factors associated with `cliq`

. Additionally add the upward message prior factors as needed for belief propagation (inference).

Notes

`cliqsym::Symbol`

defines the cliq where variable appears as a frontal variable.`varsym::Symbol`

defaults to the cliq frontal variable definition but can in case a separator variable is required instead.

`IncrementalInference.childCliqs`

— Function.```
childCliqs(treel, cliq)
```

Return a vector of child cliques to `cliq`

.

`IncrementalInference.cliqGibbs`

— Function.```
cliqGibbs(fg, cliq, vertid, inmsgs, N, dbg, manis)
```

Perform one step of the minibatch clique Gibbs operation for solving the Chapman-Kolmogov trasit integral – here involving separate approximate functional convolution and product operations.

`IncrementalInference.cliqHistFilterTransitions`

— Function.```
cliqHistFilterTransitions(hist, nextfnc)
```

Return state machine transition steps from history such that the `nextfnc::Function`

.

Related:

getCliqSolveHistory, printCliqHistorySummary, filterHistAllToArray, sandboxCliqResolveStep

Missing docstring for `cliqInitSolveUp!`

. Check Documenter's build log for details.

`IncrementalInference.compareAllVariables`

— Function.```
compareAllVariables(fgA, fgB; show, api, skipsamples)
```

Compare all variables in both `::FactorGraph`

s A and B.

Notes

- A and B should all the same variables and factors.

Related:

`compareFactorGraphs`

, `compareSimilarVariables`

, `compareVariable`

, `ls`

`IncrementalInference.compareFactorGraphs`

— Function.```
compareFactorGraphs(fgA, fgB; api, skipsamples, skipcompute, skip, show)
```

Compare and return if two factor graph objects are the same, by comparing similar variables and factors.

Notes:

- Default items to skip with
`skipsamples`

,`skipcompute`

. - User defined fields to skip can be specified with
`skip::Vector{Symbol}`

.

Related:

`compareSimilarVariables`

, `compareSimilarFactors`

, `compareAllVariables`

, `ls`

.

`IncrementalInference.compareSimilarFactors`

— Function.```
compareSimilarFactors(fgA, fgB; api, skipsamples, skipcompute, show)
```

Compare similar factors between `::FactorGraph`

s A and B.

Related:

`compareFactorGraphs`

, `compareSimilarVariables`

, `compareAllVariables`

, `ls`

.

`IncrementalInference.compareSimilarVariables`

— Function.```
compareSimilarVariables(fgA, fgB; show, api, skipsamples)
```

Compare similar labels between `::FactorGraph`

s A and B.

Notes

- At least one variable label should exist in both A and B.

Related:

`compareFactorGraphs`

, `compareAllVariables`

, `compareSimilarFactors`

, `compareVariable`

, `ls`

.

`IncrementalInference.compareSubsetFactorGraph`

— Function.```
compareSubsetFactorGraph(fgS, fgA; api)
```

Determine if and compare `fgS::FactorGraph`

is a subset with similar content to `fgA`

.

Notes

`fgS`

⊆`fgA`

.

Related:

`compareFactorGraphs`

, `compareSimilarVariables`

, `compareSimilarFactors`

, `ls`

.

`IncrementalInference.compareVariable`

— Function.```
compareVariable(A, B; show, skipsamples)
```

Compare that all fields are the same in a `::FactorGraph`

variable.

`IncrementalInference.convert2packedfunctionnode`

— Function.```
convert2packedfunctionnode(fgl, fsym)
convert2packedfunctionnode(fgl, fsym, api)
```

Encode complicated function node type to related 'Packed<type>' format assuming a user supplied convert function .

`IncrementalInference.cycleInitByVarOrder!`

— Function.```
cycleInitByVarOrder!(subfg, varorder)
```

Cycle through var order and initialize variables as possible in `subfg::FactorGraph`

. Return true if something was updated.

Notes:

- assumed
`subfg`

is a subgraph containing only the factors that can be used.- including the required up or down messages

- intended for both up and down initialization operations.

`IncrementalInference.decodefg`

— Function.```
decodefg(fgs; api)
```

Unpack PackedFunctionNodeData formats back to regular FunctonNodeData.

`IncrementalInference.deleteFactor!`

— Function.```
deleteFactor!(fgl, fsym)
```

Delete factor and its edges.

`IncrementalInference.deleteVariable!`

— Function.```
deleteVariable!(fgl, vsym; andfactors)
```

Delete variables, and also the factors+edges if `andfactors=true`

(default).

`IncrementalInference.doautoinit!`

— Function.```
doautoinit!(fgl, xi; api, singles, N)
```

EXPERIMENTAL: initialize target variable `xi`

based on connceted factors in the factor graph `fgl`

. Possibly called from `addFactor!`

, or `doCliqAutoInitUp!`

.

Development Notes:

Target factor is first (singletons) or second (dim 2 pairwise) variable vertex in

`xi`

.

- TODO use DFG properly with local operations and DB update at end.
- TODO get faster version of
`isInitialized`

for database version.

`IncrementalInference.doCliqAutoInitUp!`

— Function.```
doCliqAutoInitUp!(subfg, tree, cliq; up_solve_if_able, multiprocess)
```

Perform cliq initalization calculation based on current state of the tree and factor graph, using upward message passing logic.

NOTE WORK IN PROGRESS

Notes

- Return either of (:initialized, :upsolved, :needdownmsg, :badinit)
- must use factors in cliq only, ensured by using subgraph – TODO general case.

`IncrementalInference.doCliqUpSolve!`

— Function.```
doCliqUpSolve!(subfg, tree, cliq)
```

Update `subfg::FactorGraph`

according to internal computations for a full upsolve.

Missing docstring for `downGibbsCliqueDensity`

. Check Documenter's build log for details.

`IncrementalInference.downMsgPassingRecursive`

— Function.Pass NBPMessages back down the tree – pre order tree traversal.

`IncrementalInference.drawCliqSubgraphUp`

— Function.```
drawCliqSubgraphUp(fgl, treel, frontalSym; show, filepath, engine, viewerapp)
```

Construct and draw the subgraph associated with clique `frontalSym::Symbol`

.

Notes

- See
`writeGraphPdf`

for details on keyword options.

Related

writeGraphPdf, buildCliqSubgraphUp, buildSubgraphFromLabels, spyCliqMat, drawTree

`IncrementalInference.dwnMsg`

— Function.```
dwnMsg(cliq)
```

Return the last down message stored in `cliq`

of Bayes (Junction) tree.

`IncrementalInference.encodefg`

— Function.```
encodefg(fgl; api)
```

Make a full memory copy of the graph and encode all composite function node types – assuming that convert methods for 'Packed<type>' formats exist. The same converters are used for database persistence with CloudGraphs.jl.

`IncrementalInference.fifoFreeze!`

— Function.```
fifoFreeze!(fgl)
```

Freeze nodes that are older than the quasi fixed-lag length defined by `fg.qfl`

, according to `fg.fifo`

ordering.

Future:

- Allow different freezing strategies beyond fifo.

`IncrementalInference.filterHistAllToArray`

— Function.```
filterHistAllToArray(tree, frontals, nextfnc)
```

Return state machine transition steps from all cliq histories with transition `nextfnc::Function`

.

Related:

getCliqSolveHistory, printCliqHistorySummary, cliqHistFilterTransitions, sandboxCliqResolveStep

`IncrementalInference.findRelatedFromPotential`

— Function.```
findRelatedFromPotential(fg, idfct, vertid, N)
findRelatedFromPotential(fg, idfct, vertid, N, dbg; api)
```

Compute proposal belief on `vertid`

through `idfct`

representing some constraint in factor graph. Always full dimension variable node – partial constraints will only influence subset of variable dimensions. The remaining dimensions will keep pre-existing variable values.

`IncrementalInference.fmcmc!`

— Function.```
fmcmc!(fgl, cliq, fmsgs, IDs, N, MCMCIter)
fmcmc!(fgl, cliq, fmsgs, IDs, N, MCMCIter, dbg)
fmcmc!(fgl, cliq, fmsgs, IDs, N, MCMCIter, dbg, api)
```

Iterate successive approximations of clique marginal beliefs by means of the stipulated proposal convolutions and products of the functional objects for tree clique `cliq`

.

`IncrementalInference.getCliq`

— Function.```
getCliq(bt, frt)
```

Return the Graphs.ExVertex node object that represents a clique in the Bayes (Junction) tree, as defined by one of the frontal variables `frt::Symbol`

.

`IncrementalInference.getCliqChildMsgsUp`

— Function.```
getCliqChildMsgsUp(fg_, treel, cliq, ?)
```

Get and return upward belief messages as stored in child cliques from `treel::BayesTree`

.

Notes

- Use last parameter to select the return format.

`IncrementalInference.getCliqMsgsDown`

— Function.```
getCliqMsgsDown(cliql)
```

Return the last down message stored in `cliq`

of Bayes (Junction) tree.

`IncrementalInference.getCliqMsgsUp`

— Function.```
getCliqMsgsUp(cliql)
```

Return the last up message stored in `cliq`

of Bayes (Junction) tree.

`IncrementalInference.getCliqParentMsgDown`

— Function.```
getCliqParentMsgDown(treel, cliq)
```

Get the latest down message from the parent node (without calculating anything).

Notes

- Different from down initialization messages that do calculate new values – see
`prepCliqInitMsgsDown!`

. - Basically converts function
`getDwnMsgs`

from`Dict{Symbol,BallTreeDensity}`

to`Dict{Symbol,Vector{BallTreeDensity}}`

.

`IncrementalInference.getCliqSolveHistory`

— Function.```
getCliqSolveHistory(cliq)
```

Return clique state machine history from `tree`

if it was solved with `recordcliqs`

.

Notes

- Cliques are identified by front variable
`::Symbol`

which are always unique across the cliques.

`IncrementalInference.getCurrentWorkspaceFactors`

— Function.```
getCurrentWorkspaceFactors()
```

Return all factors currently registered in the workspace.

```
getCurrentWorkspaceVariables()
```

Return all variables currently registered in the workspace.

Missing docstring for `getCliq`

. Check Documenter's build log for details.

`IncrementalInference.getCliqOrderUpSolve`

— Function.```
getCliqOrderUpSolve(treel)
getCliqOrderUpSolve(treel, startcliq)
```

Return clique pointers for the given order in which they will be solved (sequentially).

`IncrementalInference.getCliqAllVarIds`

— Function.```
getCliqAllVarIds(cliq)
```

Get all `cliq`

variable ids`::Int`

.

`IncrementalInference.getCliqAllVarSyms`

— Function.```
getCliqAllVarSyms(fgl, cliq)
```

Get all `cliq`

variable labels as `::Symbol`

.

`IncrementalInference.getCliqAssocMat`

— Function.```
getCliqAssocMat(cliq)
```

Return boolean matrix of factor by variable (row by column) associations within clique, corresponds to order presented by `getCliqFactorIds`

and `getCliqAllVarIds`

.

Missing docstring for `getCliqChildMsgsUp`

. Check Documenter's build log for details.

`IncrementalInference.getCliqFrontalVarIds`

— Function.```
getCliqFrontalVarIds(cliq)
```

Get the frontal variable IDs `::Int`

for a given clique in a Bayes (Junction) tree.

`IncrementalInference.getCliqInitVarOrderUp`

— Function.```
getCliqInitVarOrderUp(cliq)
```

Return the most likely ordering for initializing factor (assuming up solve sequence).

Notes:

- sorts id for increasing number of connected factors.

`IncrementalInference.getCliqMat`

— Function.```
getCliqMat(cliq; showmsg)
```

Return boolean matrix of factor variable associations for a clique, optionally including (`showmsg::Bool=true`

) the upward message singletons. Variable order corresponds to `getCliqAllVarIds`

.

Missing docstring for `getCliqOrderUpSolve`

. Check Documenter's build log for details.

`IncrementalInference.getCliqSeparatorVarIds`

— Function.```
getCliqSeparatorVarIds(cliq)
```

Get `cliq`

separator (a.k.a. conditional) variable ids`::Int`

.

`IncrementalInference.getCliqStatusUp`

— Function.```
getCliqStatusUp(cliq)
```

Return `::Symbol`

status a particular clique is in, with specific regard to solution or numerical initialization status:

- :needdownmsg
- :upsolved
- :downsolved
- :initialized
- :marginalized
- :null

Notes:

`:null`

represents the first uninitialized state of a cliq.

`IncrementalInference.getCliqVarIdsPriors`

— Function.```
getCliqVarIdsPriors(cliq)
getCliqVarIdsPriors(cliq, allids)
getCliqVarIdsPriors(cliq, allids, partials)
```

Get variable ids`::Int`

with prior factors associated with this `cliq`

.

Notes:

- does not include any singleton messages from upward or downward message passing.

`IncrementalInference.getCliqVars`

— Function.```
getCliqVars(subfg, cliq)
```

Return array of all variable vertices in a clique.

`IncrementalInference.getCliqVarSingletons`

— Function.```
getCliqVarSingletons(cliq)
getCliqVarSingletons(cliq, allids)
getCliqVarSingletons(cliq, allids, partials)
```

Get `cliq`

variable IDs with singleton factors – i.e. both in clique priors and up messages.

`IncrementalInference.getData`

— Function.```
getData(v)
```

Retrieve data structure stored in a node.

`IncrementalInference.getFactor`

— Function.```
getFactor(fvert)
```

Return reference to the user factor in `::FactorGraph`

identified by `::Symbol`

.

`IncrementalInference.getKDE`

— Function.```
getKDE(v)
```

Get KernelDensityEstimate kde estimate stored in variable node.

`IncrementalInference.getManifolds`

— Function.```
getManifolds(vert)
```

Return the manifolds on which variable `sym::Symbol`

is defined.

`IncrementalInference.getMaxVertId`

— Function.```
getMaxVertId(fgl)
```

Return the current maximum vertex ID number in the factor graph fragment `fgl`

.

`IncrementalInference.getParent`

— Function.```
getParent(treel, afrontal)
```

Return `cliq`

's parent clique.

`IncrementalInference.getSofttype`

— Function.```
getSofttype(vnd)
```

Variable nodes softtype information holding a variety of meta data associated with the type of variable stored in that node of the factor graph.

`IncrementalInference.getTreeAllFrontalSyms`

— Function.```
getTreeAllFrontalSyms(fgl, tree)
```

Return one symbol (a frontal variable) from each clique in the `::BayesTree`

.

Notes

- Frontal variables only occur once in a clique per tree, therefore is a unique identifier.

Related:

whichCliq, printCliqHistorySummary

`IncrementalInference.getTreeCliqSolveOrderUp`

— Function.```
getTreeCliqSolveOrderUp(treel)
getTreeCliqSolveOrderUp(treel, startcliq)
```

Return clique pointers for the given order in which they will be solved (sequentially).

`IncrementalInference.getVal`

— Function.```
getVal(vnd)
```

Convenience function to get point values sampled i.i.d from marginal of `lbl`

variable in the current factor graph.

```
getVal(vA)
```

Fetch the variable marginal sample points without the KDE bandwidth parameter. Use getVertKDE to retrieve the full KDE object.

`IncrementalInference.getVariable`

— Function.```
getVariable(fgl, lbl)
getVariable(fgl, lbl, api)
```

Return reference to a variable in `::FactorGraph`

identified by `::Symbol`

.

`IncrementalInference.getVertKDE`

— Function.```
getVertKDE(v)
```

Get KernelDensityEstimate kde estimate stored in variable node.

`IncrementalInference.getUpMsgs`

— Function.```
getUpMsgs(btl, sym)
```

Return the last up message stored in `cliq`

of Bayes (Junction) tree.

`IncrementalInference.getDwnMsgs`

— Function.```
getDwnMsgs(btl, sym)
```

Return the last down message stored in `cliq`

of Bayes (Junction) tree.

`IncrementalInference.hasOrphans`

— Function.```
hasOrphans(fg)
```

Return `::Bool`

on whether `fg::FactorGraph`

has orphaned nodes or graph fragments.

`IncrementalInference.inferOverTree!`

— Function.```
inferOverTree!(fgl, bt; N, upsolve, downsolve, dbg, drawpdf, treeinit, limititers, skipcliqids, recordcliqs)
```

Perform up and down message passing (multi-process) algorithm for full sum-product solution of all continuous marginal beliefs.

`IncrementalInference.inferOverTreeR!`

— Function.```
inferOverTreeR!(fgl, bt; N, dbg, drawpdf, treeinit)
```

Perform up and down message passing (single process, recursive) algorithm for full sum-product solution of all continuous marginal beliefs.

`IncrementalInference.initfg`

— Function.Initialize an empty `::FactorGraph`

object while initializing `sessionname`

, `robotname`

, and `cloudgraph`

.

`IncrementalInference.initInferTreeUp!`

— Function.```
initInferTreeUp!(fgl, treel; drawtree, N, limititers, skipcliqids, recordcliqs)
```

Perform tree based initialization of all variables not yet initialized in factor graph.

Missing docstring for `initOnTree!`

. Check Documenter's build log for details.

`IncrementalInference.isCliqMarginalizedFromVars`

— Function.```
isCliqMarginalizedFromVars(subfg, cliq)
```

Return `::Bool`

on whether all variables in this `cliq`

are marginalzed.

`IncrementalInference.isCliqReadyInferenceUp`

— Function.```
isCliqReadyInferenceUp(fgl, tree, cliq)
```

Determine if this `cliq`

has been fully initialized and child cliques have completed their full upward inference.

`IncrementalInference.isFactor`

— Function.```
isFactor(fgl, sym)
```

Return whether `sym::Symbol`

represents a factor vertex in the graph.

`IncrementalInference.isInitialized`

— Function.```
isInitialized(vert)
```

Returns state of vertex data `.initialized`

flag.

Notes:

- used by both factor graph variable and Bayes tree clique logic.

`IncrementalInference.isMarginalized`

— Function.```
isMarginalized(vert)
```

Return `::Bool`

on whether this variable has been marginalized.

`IncrementalInference.isTreeSolved`

— Function.```
isTreeSolved(treel; skipinitialized)
```

Return true or false depending on whether the tree has been fully initialized/solved/marginalized.

`IncrementalInference.isPartial`

— Function.```
isPartial(fcf)
```

Return `::Bool`

on whether factor `fct<:FunctorInferenceType`

is a partial constraint.

`IncrementalInference.isVariable`

— Function.```
isVariable(fgl, sym)
```

Return whether `sym::Symbol`

represents a variable vertex in the graph.

`IncrementalInference.landmarks`

— Function.```
landmarks(fgl, vsym)
```

Return `Vector{Symbol}`

of landmarks attached to vertex vsym in `fgl::FactorGraph`

.

`IncrementalInference.loadjld`

— Function.```
loadjld(; file)
```

Opposite of savejld(fg, gt=gt, file="tempfg.jl") to load data from file. This function uses the unpacking converters for converting all PackedInferenceType to FunctorInferenceType.

`IncrementalInference.localProduct`

— Function.```
localProduct(fgl, sym; N, dbg, api)
```

Using factor graph object `fg`

, project belief through connected factors (convolution with conditional) to variable `sym`

followed by a approximate functional product.

Return: product belief, full proposals, partial dimension proposals, labels

`IncrementalInference.ls`

— Function.```
ls(cgl::CloudGraphs.CloudGraph, session::AbstractString, robot::AbstractString, user::AbstractString; sym, neoid, exvid) -> Dict{Symbol,Tuple{Int64,Int64,Array{Symbol,1}}}
```

List neighbors to node in cgl::CloudGraph by returning Dict{Sym}=(exvid, neoid, Symbol[labels]), and can take any of the three as input node identifier. Not specifying an identifier will result in all Variable nodes being returned.

```
ls(fgl, lbl; api, ring)
```

Return all elements `ls(fg)`

as tuples, or nodes connected to the a specific element, eg. `ls(fg, :x1)

```
ls(fgl, lbls; api, ring)
```

Experimental union of elements version of ls(::FactorGraph, ::Symbol). Not mean't to replace broadcasting `ls.(fg, [:x1;:x2])`

```
ls(fgl; key1, key2)
```

List the nodes in a factor graph.

**Examples**

`ls(fg)`

`IncrementalInference.lsf`

— Function.```
lsf(fgl, lbl; api)
```

List factors in a factor graph.

**Examples**

`lsf(fg, :x1)`

```
lsf(fgl, lbl)
```

List factors in a factor graph.

**Examples**

`lsf(fg)`

`IncrementalInference.lsRear`

— Function.```
lsRear(fgl)
lsRear(fgl, n)
```

Return array of all variable nodes connected to the last `n`

many poses (`:x*`

).

Example:

```
# Shallow copy the tail end of poses from a factor graph `fg1`
vars = lsRear(fg1, 5)
fg1_r5 = subgraphFromVerts(fg1, vars)
```

`IncrementalInference.manualinit!`

— Function.```
manualinit!(fgl, vert, pX)
```

Workaround function when first-version (factor graph based) auto initialization fails. Usually occurs when using factors that have high connectivity to multiple variables.

`IncrementalInference.parentCliq`

— Function.```
parentCliq(treel, cliq)
```

Return `cliq`

's parent clique.

`IncrementalInference.packFromLocalPotentials!`

— Function.```
packFromLocalPotentials!(fgl, dens, wfac, cliq, vertid, N)
packFromLocalPotentials!(fgl, dens, wfac, cliq, vertid, N, dbg)
```

Add all potentials associated with this clique and vertid to dens.

`IncrementalInference.prepBatchTree!`

— Function.```
prepBatchTree!(fg; ordering, drawpdf, show, filepath, viewerapp, imgs, drawbayesnet)
```

Build Bayes/Junction/Elimination tree.

Notes

- Default to free qr factorization for variable elimination order.

`IncrementalInference.prepCliqInitMsgsDown!`

— Function.```
prepCliqInitMsgsDown!(fgl, tree, cliq)
```

Initialization downward message passing is different from regular inference since it is possible that none of the child cliq variables have been initialized.

Notes

- init msgs from child upward passes are individually stored in this
`cliq`

. - fresh product of overlapping beliefs are calculated on each function call.

Missing docstring for `prepCliqInitMsgsUp!`

. Check Documenter's build log for details.

`IncrementalInference.printCliqHistorySummary`

— Function.```
printCliqHistorySummary(hist)
```

Print a short summary of state machine history for a clique solve.

Related:

getTreeAllFrontalSyms, getCliqSolveHistory, animateCliqStateMachines

`IncrementalInference.printgraphmax`

— Function.```
printgraphmax(fgl)
```

Print the maximum point values form all variables approximate marginals in the factor graph. The full marginal can be recovered for example `X0 = getVertKDE(fg, :x0)`

.

`IncrementalInference.productpartials!`

— Function.```
productpartials!(pGM, dummy, partials, manis)
```

Multiply different dimensions from partial constraints individually.

`IncrementalInference.prodmultiplefullpartials`

— Function.```
prodmultiplefullpartials(dens, partials, Ndims, N, manis)
```

Multiply various full and partial dimension constraints.

`IncrementalInference.prodmultipleonefullpartials`

— Function.Multiply a single full and several partial dimension constraints.

`IncrementalInference.resetBuildTreeFromOrder!`

— Function.```
resetBuildTreeFromOrder!(fgl, p)
```

Reset factor graph and build a new tree from the provided variable ordering `p`

.

`IncrementalInference.resetData!`

— Function.```
resetData!(vdata)
```

Partial reset of basic data fields in `::VariableNodeData`

of `::FunctionNode`

structures.

`IncrementalInference.resetTreeCliquesForUpSolve!`

— Function.```
resetTreeCliquesForUpSolve!(treel)
```

Reset the Bayes (Junction) tree so that a new upsolve can be performed.

Notes

- Will change previous clique status from
`:downsolved`

to`:initialized`

only. - Sets the color of tree clique to
`lightgreen`

.

Missing docstring for `sandboxStateMachineStep`

. Check Documenter's build log for details.

`IncrementalInference.sandboxCliqResolveStep`

— Function.```
sandboxCliqResolveStep(tree, frontal, step)
```

Repeat a solver state machine step without changing history or primary values.

printCliqHistorySummary, getCliqSolveHistory, cliqHistFilterTransitions

`IncrementalInference.savejld`

— Function.```
savejld(fgl; file, groundtruth)
```

Save mostly complete Factor Graph type by converting complicated FunctionNodeData types to 'Packed' types using user supplied converters. Ground truth can also be saved and recovered by the associated loadjld(file="tempfg.jld2") method.

Notes:

- Must use
`.jld2`

since Julia 1.0 (previous version was deprecated).

`IncrementalInference.setCliqAsMarginalized!`

— Function.```
setCliqAsMarginalized!(cliq, status)
```

Set the marginalized status of a clique.

`IncrementalInference.setCliqStatus!`

— Function.```
setCliqStatus!(cliq, status)
```

Set up initialization or solve status of this `cliq`

.

`IncrementalInference.setDwnMsg!`

— Function.```
setDwnMsg!(cliql, msgs)
```

Set the downward passing message for Bayes (Junction) tree clique `cliql`

.

`IncrementalInference.setfreeze!`

— Function.```
setfreeze!(fgl, sym)
```

Set variable(s) `sym`

of factor graph to be marginalized – i.e. not be updated by inference computation.

`IncrementalInference.setTreeCliquesMarginalized!`

— Function.```
setTreeCliquesMarginalized!(fgl, tree)
```

Set all Bayes (Junction) tree cliques that have all marginalized and initialized variables.

`IncrementalInference.setValKDE!`

— Function.```
setValKDE!(v, val)
setValKDE!(v, val, setinit)
setValKDE!(v, val, setinit, partialinit)
```

Set the point centers and bandwidth parameters of a variable node, also set `isInitialized=true`

if `setinit::Bool=true`

(as per default).

Notes

`initialized`

is used for initial solve of factor graph where variables are not yet initialized.`partialinit`

is used to identify if the initialized was only partial.

`IncrementalInference.setUpMsg!`

— Function.```
setUpMsg!(cliql, msgs)
```

Set the upward passing message for Bayes (Junction) tree clique `cliql`

.

`IncrementalInference.showVariable`

— Function.```
showVariable(fgl, vsym; api)
```

Display the content of `VariableNodeData`

to console for a given factor graph and variable tag`::Symbol`

.

`IncrementalInference.solveCliqWithStateMachine!`

— Function.```
solveCliqWithStateMachine!(fg, tree, frontal; iters, recordhistory, verbose)
```

Standalone state machine solution for a single clique.

Related:

initInferTreeUp!

Missing docstring for `subgraphFromVerts`

. Check Documenter's build log for details.

`IncrementalInference.transferUpdateSubGraph!`

— Function.```
transferUpdateSubGraph!(dest, src)
transferUpdateSubGraph!(dest, src, syms; srcapi, destapi)
```

Transfer contents of `src::FactorGraph`

variables `syms::Vector{Symbol}`

to `dest::FactorGraph`

.

Notes

- Approximately like
`dest`

=`src`

, for all`syms`

`IncrementalInference.treeProductDwn`

— Function.```
treeProductDwn(fg, tree, cliq, sym; N, dbg)
```

Calculate a fresh–-single step–-approximation to the variable `sym`

in clique `cliq`

as though during the downward message passing. The full inference algorithm may repeatedly calculate successive apprimxations to the variable based on the structure of variables, factors, and incoming messages to this clique. Which clique to be used is defined by frontal variable symbols (`cliq`

in this case) – see `whichCliq(...)`

for more details. The `sym`

symbol indicates which symbol of this clique to be calculated. **Note** that the `sym`

variable must appear in the clique where `cliq`

is a frontal variable.

`IncrementalInference.treeProductUp`

— Function.```
treeProductUp(fg, tree, cliq, sym; N, dbg)
```

Calculate a fresh (single step) approximation to the variable `sym`

in clique `cliq`

as though during the upward message passing. The full inference algorithm may repeatedly calculate successive apprimxations to the variables based on the structure of the clique, factors, and incoming messages. Which clique to be used is defined by frontal variable symbols (`cliq`

in this case) – see `whichCliq(...)`

for more details. The `sym`

symbol indicates which symbol of this clique to be calculated. **Note** that the `sym`

variable must appear in the clique where `cliq`

is a frontal variable.

`IncrementalInference.unfreezeVariablesAll!`

— Function.```
unfreezeVariablesAll!(fgl)
```

Free all variables from marginalization.

Related

unmarginalizeVariablesAll!

`IncrementalInference.unmarginalizeVariablesAll!`

— Function.```
unmarginalizeVariablesAll!(fgl)
```

Free all variables from marginalization.

`IncrementalInference.updateFGBT!`

— Function.```
updateFGBT!(fg, bt, cliqID, ddt; dbg, fillcolor)
```

Update cliq `cliqID`

in Bayes (Juction) tree `bt`

according to contents of `ddt`

– intended use is to update main clique after a downward belief propagation computation has been completed per clique.

```
updateFGBT!(fg, cliq, urt; dbg, fillcolor, api)
```

Update cliq `cliqID`

in Bayes (Juction) tree `bt`

according to contents of `urt`

– intended use is to update main clique after a upward belief propagation computation has been completed per clique.

```
updateTreeCliquesAsMarginalizedFromVars!(fgl, tree)
```

Run through entire tree and set cliques as marginalized if all clique variables are marginalized.

Notes:

- TODO can be made fully parallel, consider converting for use with
`@threads`

`for`

.

`IncrementalInference.upGibbsCliqueDensity`

— Function.```
upGibbsCliqueDensity(inp)
upGibbsCliqueDensity(inp, N)
upGibbsCliqueDensity(inp, N, dbg)
upGibbsCliqueDensity(inp, N, dbg, iters)
```

Perform computations required for the upward message passing during belief propation on the Bayes (Junction) tree. This function is usually called as via remote_call for multiprocess dispatch.

Example

```
inp = ExploreTreeType(fg,tree,cliq,parent,childmsgs)
urt = upGibbsCliqueDensity(inp)
```

`fg`

factor graph,`tree`

Bayes tree,`cliq`

which cliq to perform the computation on,`parent`

the parent clique to where the upward message will be sent,`childmsgs`

is for any incoming messages from child cliques.

`IncrementalInference.upMsg`

— Function.```
upMsg(cliq)
```

Return the last up message stored in `cliq`

of Bayes (Junction) tree.

`IncrementalInference.wipeBuildNewTree!`

— Function.```
wipeBuildNewTree!(fg; ordering, drawpdf, show, filepath, viewerapp, imgs)
```

Build a completely new Bayes (Junction) tree, after first wiping clean all temporary state in fg from a possibly pre-existing tree.

Related:

buildTreeFromOrdering!

`IncrementalInference.writeGraphPdf`

— Function.```
writeGraphPdf(fgl; viewerapp, filepath, engine, show)
```

Export a dot and pdf file drawn by Graphviz showing the factor graph.

Related

drawCliqSubgraphUp, drawTree

```
resetVariableAllInitializations!(fgl)
```

Reset initialization flag on all variables in `::FactorGraphs`

.

Notes

- Numerical values remain, but inference will overwrite since init flags are now
`false`

.

`IncrementalInference.showFactor`

— Function.```
showFactor(fgl, fsym; api)
```

Display and return to console the user factor identified by tag name.

Missing docstring for `showVariable`

. Check Documenter's build log for details.