GTSAM  4.0.2
C++ library for smoothing and mapping (SAM)
Public Types | Protected Member Functions | Protected Attributes | List of all members
gtsam::FactorGraph< FACTOR > Class Template Reference

#include <FactorGraph.h>

Public Types

typedef FACTOR FactorType
 factor type
 
typedef std::shared_ptr< FACTOR > sharedFactor
 Shared pointer to a factor.
 
typedef sharedFactor value_type
 
typedef FastVector< sharedFactor >::iterator iterator
 
typedef FastVector< sharedFactor >::const_iterator const_iterator
 

Protected Member Functions

bool isEqual (const FactorGraph &other) const
 Check exact equality of the factor pointers. Useful for derived ==.
 

Protected Attributes

FastVector< sharedFactorfactors_
 

Standard Constructors

 FactorGraph ()
 
template<typename ITERATOR >
 FactorGraph (ITERATOR firstFactor, ITERATOR lastFactor)
 
template<class CONTAINER >
 FactorGraph (const CONTAINER &factors)
 

Constructors

virtual ~FactorGraph ()=default
 
template<class DERIVEDFACTOR , typename = IsDerived<DERIVEDFACTOR>>
 FactorGraph (std::initializer_list< std::shared_ptr< DERIVEDFACTOR >> sharedFactors)
 

Adding Single Factors

void reserve (size_t size)
 
template<class DERIVEDFACTOR >
IsDerived< DERIVEDFACTOR > push_back (std::shared_ptr< DERIVEDFACTOR > factor)
 Add a factor directly using a shared_ptr.
 
template<class DERIVEDFACTOR , class... Args>
IsDerived< DERIVEDFACTOR > emplace_shared (Args &&... args)
 Emplace a shared pointer to factor of given type.
 
template<class DERIVEDFACTOR >
IsDerived< DERIVEDFACTOR > push_back (const DERIVEDFACTOR &factor)
 
template<class DERIVEDFACTOR >
IsDerived< DERIVEDFACTOR > add (std::shared_ptr< DERIVEDFACTOR > factor)
 add is a synonym for push_back.
 

Adding via iterators

template<typename ITERATOR >
HasDerivedElementType< ITERATOR > push_back (ITERATOR firstFactor, ITERATOR lastFactor)
 
template<typename ITERATOR >
HasDerivedValueType< ITERATOR > push_back (ITERATOR firstFactor, ITERATOR lastFactor)
 Push back many factors with an iterator (factors are copied)
 

Adding via container

template<typename CONTAINER >
HasDerivedElementType< CONTAINER > push_back (const CONTAINER &container)
 
template<typename CONTAINER >
HasDerivedValueType< CONTAINER > push_back (const CONTAINER &container)
 Push back non-pointer objects in a container (factors are copied).
 
template<class FACTOR_OR_CONTAINER >
void add (const FACTOR_OR_CONTAINER &factorOrContainer)
 

Specialized versions

template<class CLIQUE >
std::enable_if< std::is_base_of< This, typename CLIQUE::FactorGraphType >::value >::type push_back (const BayesTree< CLIQUE > &bayesTree)
 
template<typename CONTAINER , typename = HasDerivedElementType<CONTAINER>>
FactorIndices add_factors (const CONTAINER &factors, bool useEmptySlots=false)
 

Testable

virtual void print (const std::string &s="FactorGraph", const KeyFormatter &formatter=DefaultKeyFormatter) const
 Print out graph to std::cout, with optional key formatter.
 
bool equals (const This &fg, double tol=1e-9) const
 Check equality up to tolerance.
 

Standard Interface

size_t size () const
 
bool empty () const
 
const sharedFactor at (size_t i) const
 
sharedFactorat (size_t i)
 
const sharedFactor operator[] (size_t i) const
 
sharedFactoroperator[] (size_t i)
 
const_iterator begin () const
 
const_iterator end () const
 
sharedFactor front () const
 
sharedFactor back () const
 
double error (const HybridValues &values) const
 

Modifying Factor Graphs (imperative, discouraged)

iterator begin ()
 
iterator end ()
 
virtual void resize (size_t size)
 
void remove (size_t i)
 
void replace (size_t index, sharedFactor factor)
 
iterator erase (iterator item)
 
iterator erase (iterator first, iterator last)
 

Graph Display

void dot (std::ostream &os, const KeyFormatter &keyFormatter=DefaultKeyFormatter, const DotWriter &writer=DotWriter()) const
 Output to graphviz format, stream version.
 
std::string dot (const KeyFormatter &keyFormatter=DefaultKeyFormatter, const DotWriter &writer=DotWriter()) const
 Output to graphviz format string.
 
void saveGraph (const std::string &filename, const KeyFormatter &keyFormatter=DefaultKeyFormatter, const DotWriter &writer=DotWriter()) const
 output to file with graphviz format.
 

Advanced Interface

size_t nrFactors () const
 
KeySet keys () const
 
KeyVector keyVector () const
 
bool exists (size_t idx) const
 

Detailed Description

template<class FACTOR>
class gtsam::FactorGraph< FACTOR >

A factor graph is a bipartite graph with factor nodes connected to variable nodes. In this class, however, only factor nodes are kept around.

Constructor & Destructor Documentation

◆ FactorGraph() [1/4]

template<class FACTOR>
gtsam::FactorGraph< FACTOR >::FactorGraph ( )
inlineprotected

Default constructor

◆ FactorGraph() [2/4]

template<class FACTOR>
template<typename ITERATOR >
gtsam::FactorGraph< FACTOR >::FactorGraph ( ITERATOR  firstFactor,
ITERATOR  lastFactor 
)
inlineprotected

Constructor from iterator over factors (shared_ptr or plain objects)

◆ FactorGraph() [3/4]

template<class FACTOR>
template<class CONTAINER >
gtsam::FactorGraph< FACTOR >::FactorGraph ( const CONTAINER &  factors)
inlineexplicitprotected

Construct from container of factors (shared_ptr or plain objects)

◆ ~FactorGraph()

template<class FACTOR>
virtual gtsam::FactorGraph< FACTOR >::~FactorGraph ( )
virtualdefault

Default destructor Public and virtual so boost serialization can call it.

◆ FactorGraph() [4/4]

template<class FACTOR>
template<class DERIVEDFACTOR , typename = IsDerived<DERIVEDFACTOR>>
gtsam::FactorGraph< FACTOR >::FactorGraph ( std::initializer_list< std::shared_ptr< DERIVEDFACTOR >>  sharedFactors)
inline

Constructor that takes an initializer list of shared pointers. FactorGraph fg = {make_shared<MyFactor>(), ...};

Member Function Documentation

◆ add()

template<class FACTOR>
template<class FACTOR_OR_CONTAINER >
void gtsam::FactorGraph< FACTOR >::add ( const FACTOR_OR_CONTAINER &  factorOrContainer)
inline

Add a factor or container of factors, including STL collections, BayesTrees, etc.

◆ add_factors()

template<class FACTOR >
template<typename CONTAINER , typename >
FactorIndices gtsam::FactorGraph< FACTOR >::add_factors ( const CONTAINER &  factors,
bool  useEmptySlots = false 
)

Add new factors to a factor graph and returns a list of new factor indices, optionally finding and reusing empty factor slots.

◆ at() [1/2]

template<class FACTOR>
const sharedFactor gtsam::FactorGraph< FACTOR >::at ( size_t  i) const
inline

Get a specific factor by index (this checks array bounds and may throw an exception, as opposed to operator[] which does not).

◆ at() [2/2]

template<class FACTOR>
sharedFactor& gtsam::FactorGraph< FACTOR >::at ( size_t  i)
inline

Get a specific factor by index (this checks array bounds and may throw an exception, as opposed to operator[] which does not).

◆ back()

template<class FACTOR>
sharedFactor gtsam::FactorGraph< FACTOR >::back ( ) const
inline

Get the last factor

◆ begin() [1/2]

template<class FACTOR>
const_iterator gtsam::FactorGraph< FACTOR >::begin ( ) const
inline

Iterator to beginning of factors.

◆ begin() [2/2]

template<class FACTOR>
iterator gtsam::FactorGraph< FACTOR >::begin ( )
inline

non-const STL-style begin()

◆ empty()

template<class FACTOR>
bool gtsam::FactorGraph< FACTOR >::empty ( ) const
inline

Check if the graph is empty (null factors set by remove() will cause this to return false).

◆ end() [1/2]

template<class FACTOR>
const_iterator gtsam::FactorGraph< FACTOR >::end ( ) const
inline

Iterator to end of factors.

◆ end() [2/2]

template<class FACTOR>
iterator gtsam::FactorGraph< FACTOR >::end ( )
inline

non-const STL-style end()

◆ erase() [1/2]

template<class FACTOR>
iterator gtsam::FactorGraph< FACTOR >::erase ( iterator  item)
inline

Erase factor and rearrange other factors to take up the empty space

◆ erase() [2/2]

template<class FACTOR>
iterator gtsam::FactorGraph< FACTOR >::erase ( iterator  first,
iterator  last 
)
inline

Erase factors and rearrange other factors to take up the empty space

◆ error()

template<class FACTOR >
double gtsam::FactorGraph< FACTOR >::error ( const HybridValues values) const

Add error for all factors.

◆ exists()

template<class FACTOR>
bool gtsam::FactorGraph< FACTOR >::exists ( size_t  idx) const
inline

MATLAB interface utility: Checks whether a factor index idx exists in the graph and is a live pointer

◆ front()

template<class FACTOR>
sharedFactor gtsam::FactorGraph< FACTOR >::front ( ) const
inline

Get the first factor

◆ keys()

template<class FACTOR >
KeySet gtsam::FactorGraph< FACTOR >::keys ( ) const

Potentially slow function to return all keys involved, sorted, as a set

◆ keyVector()

template<class FACTOR >
KeyVector gtsam::FactorGraph< FACTOR >::keyVector ( ) const

Potentially slow function to return all keys involved, sorted, as a vector

◆ nrFactors()

template<class FACTOR >
size_t gtsam::FactorGraph< FACTOR >::nrFactors ( ) const

return the number of non-null factors

◆ operator[]() [1/2]

template<class FACTOR>
const sharedFactor gtsam::FactorGraph< FACTOR >::operator[] ( size_t  i) const
inline

Get a specific factor by index (this does not check array bounds, as opposed to at() which does).

◆ operator[]() [2/2]

template<class FACTOR>
sharedFactor& gtsam::FactorGraph< FACTOR >::operator[] ( size_t  i)
inline

Get a specific factor by index (this does not check array bounds, as opposed to at() which does).

◆ push_back() [1/4]

template<class FACTOR>
template<class DERIVEDFACTOR >
IsDerived<DERIVEDFACTOR> gtsam::FactorGraph< FACTOR >::push_back ( const DERIVEDFACTOR &  factor)
inline

Add a factor by value, will be copy-constructed (use push_back with a shared_ptr to avoid the copy).

◆ push_back() [2/4]

template<class FACTOR>
template<typename ITERATOR >
HasDerivedElementType<ITERATOR> gtsam::FactorGraph< FACTOR >::push_back ( ITERATOR  firstFactor,
ITERATOR  lastFactor 
)
inline

Push back many factors with an iterator over shared_ptr (factors are not copied)

◆ push_back() [3/4]

template<class FACTOR>
template<typename CONTAINER >
HasDerivedElementType<CONTAINER> gtsam::FactorGraph< FACTOR >::push_back ( const CONTAINER &  container)
inline

Push back many factors as shared_ptr's in a container (factors are not copied)

◆ push_back() [4/4]

template<class FACTOR>
template<class CLIQUE >
std::enable_if< std::is_base_of<This, typename CLIQUE::FactorGraphType>::value>::type gtsam::FactorGraph< FACTOR >::push_back ( const BayesTree< CLIQUE > &  bayesTree)
inline

Push back a BayesTree as a collection of factors. NOTE: This should be hidden in derived classes in favor of a type-specialized version that calls this templated function.

◆ remove()

template<class FACTOR>
void gtsam::FactorGraph< FACTOR >::remove ( size_t  i)
inline

delete factor without re-arranging indexes by inserting a nullptr pointer

◆ replace()

template<class FACTOR>
void gtsam::FactorGraph< FACTOR >::replace ( size_t  index,
sharedFactor  factor 
)
inline

replace a factor by index

◆ reserve()

template<class FACTOR>
void gtsam::FactorGraph< FACTOR >::reserve ( size_t  size)
inline

Reserve space for the specified number of factors if you know in advance how many there will be (works like FastVector::reserve).

◆ resize()

template<class FACTOR>
virtual void gtsam::FactorGraph< FACTOR >::resize ( size_t  size)
inlinevirtual

Directly resize the number of factors in the graph. If the new size is less than the original, factors at the end will be removed. If the new size is larger than the original, null factors will be appended.

◆ size()

template<class FACTOR>
size_t gtsam::FactorGraph< FACTOR >::size ( ) const
inline

return the number of factors (including any null factors set by remove() ).

Member Data Documentation

◆ factors_

template<class FACTOR>
FastVector<sharedFactor> gtsam::FactorGraph< FACTOR >::factors_
protected

concept check, makes sure FACTOR defines print and equals Collection of factors


The documentation for this class was generated from the following files: