Loading...
Searching...
No Matches
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:

boost |
mp11 |
detail |
_merge_and_renumber |
_merge_and_renumber< index_sequence< I1... >, index_sequence< I2... > > |
index_sequence |
make_index_sequence |
make_index_sequence< 0 > |
make_index_sequence< 1 > |
gtsam | Global functions in a separate testing namespace
internal |
linearAlgorithms |
OptimizeData |
OptimizeClique | Pre-order visitor for back-substitution in a Bayes tree
FastDefaultAllocator | Default allocator for list, map, and set types
FastDefaultVectorAllocator | Default allocator for vector types (we never use boost pool for vectors)
LieGroupTraits | A helper class that implements the traits interface for GTSAM lie groups
LieGroup | Both LieGroupTraits and Testable
HasManifoldPrereqs | Requirements on type to pass it to Manifold template below
GetDimensionImpl | Extra manifold traits for fixed-dimension types
GetDimensionImpl< Class, Eigen::Dynamic > | Extra manifold traits for variable-dimension types
ManifoldTraits | A helper that implements the traits interface for GTSAM manifolds
Manifold | Both ManifoldTraits and Testable
FixedSizeMatrix |
TimingOutline | Timing Entry, arranged in a tree
AutoTicToc | Small class that calls internal::tic at construction, and internol::toc when destroyed
VectorSpaceImpl | VectorSpaceTraits Implementation for Fixed sizes
VectorSpaceImpl< Class, Eigen::Dynamic > | VectorSpaceTraits implementation for dynamic types
HasVectorSpacePrereqs | Requirements on type to pass it to Manifold template below
VectorSpaceTraits | A helper that implements the traits interface for classes that define vector spaces To use this for your class, define: template<> struct traits<Class> : public VectorSpaceTraits<Class> {}; The class needs to support the requirements defined by HasVectorSpacePrereqs above
VectorSpace | VectorSpace provides both Testable and VectorSpaceTraits
ScalarTraits | A helper that implements the traits interface for scalar vector spaces
DynamicTraits |
apply_compose |
apply_compose< double > |
ExecutionTrace |
ExpressionNode |
handle |
handle_matrix |
handle_matrix< Eigen::Matrix< double, M, N >, true > |
handle_matrix< Eigen::Matrix< double, M, N >, false > |
handle< Eigen::Matrix< double, M, N > > |
so3 |
ExpmapFunctor | Functor implementing Exponential map
DexpFunctor | Functor that implements Exponential map and its derivatives
noiseModel | All noise models live in the noiseModel namespace
mEstimator | The mEstimator name space contains all robust error functions
Base | Pure virtual class for all robust error function classes
Null | "Null" robust loss function, equivalent to a Gaussian pdf noise model, or plain least-squares (non-robust)
Fair | Implementation of the "Fair" robust error model (Zhang97ivc)
Huber | The "Huber" robust error model (Zhang97ivc)
Cauchy | Implementation of the "Cauchy" robust error model (Lee2013IROS)
Tukey | Implementation of the "Tukey" robust error model (Zhang97ivc)
Welsch | Implementation of the "Welsch" robust error model (Zhang97ivc)
GemanMcClure | Implementation of the "Geman-McClure" robust error model (Zhang97ivc)
DCS | DCS implements the Dynamic Covariance Scaling robust error model from the paper Robust Map Optimization (Agarwal13icra)
L2WithDeadZone | L2WithDeadZone implements a standard L2 penalty, but with a dead zone of width 2*k, centered at the origin
Base | NoiseModel::Base is the abstract base class for all noise models
Gaussian | Gaussian implements the mathematical model |R*x|^2 = |y|^2 with R'*R=inv(Sigma) where y = whiten(x) = R*x x = unwhiten(x) = inv(R)*y as indeed |y|^2 = y'*y = x'*R'*R*x Various derived classes are available that are more efficient
Diagonal | A diagonal noise model implements a diagonal covariance matrix, with the elements of the diagonal specified in a Vector
Constrained | A Constrained constrained model is a specialization of Diagonal which allows some or all of the sigmas to be zero, forcing the error to be zero there
Isotropic | An isotropic noise model corresponds to a scaled diagonal covariance To construct, use one of the static methods
Unit | Unit: i.i.d
Robust | Base class for robust error models The robust M-estimators above simply tell us how to re-weight the residual, and are isotropic kernels, in that they do not allow for correlated noise
imuBias | All bias models live in the imuBias namespace
ConstantBias |
detail |
NoiseModelFactorAliases | Convenience base class to add aliases X1, X2, ..., X6 -> ValueType<N>
NoiseModelFactorAliases< T1 > |
NoiseModelFactorAliases< T1, T2 > |
NoiseModelFactorAliases< T1, T2, T3 > |
NoiseModelFactorAliases< T1, T2, T3, T4 > |
NoiseModelFactorAliases< T1, T2, T3, T4, T5 > |
NoiseModelFactorAliases< T1, T2, T3, T4, T5, T6, TExtra... > |
gtsfm |
Keypoints |
traits | A manifold defines a space in which there is a notion of a linear tangent space that can be centered around a given point on the manifold
ConcurrentMap | FastMap is a thin wrapper around std::map that uses the boost fast_pool_allocator instead of the default STL allocator
DSFMap | Disjoint set forest using an STL map data structure underneath Uses rank compression and union by rank, iterator version
Entry | We store the forest in an STL map, but parents are done with pointers
IndexPair | Small utility class for representing a wrappable pairs of ints
DSFBase | A fast implementation of disjoint set forests that uses vector as underly data structure
DSFVector | DSFVector additionally keeps a vector of keys to support more expensive operations
FastList | FastList is a thin wrapper around std::list that uses the boost fast_pool_allocator instead of the default STL allocator
FastMap | FastMap is a thin wrapper around std::map that uses the boost fast_pool_allocator instead of the default STL allocator
FastSet | FastSet is a thin wrapper around std::set that uses the boost fast_pool_allocator instead of the default STL allocator
GenericValue | Wraps any type T so it can play as a Value
traits< GenericValue< ValueType > > |
group_tag | Tag to assert a type is a group
multiplicative_group_tag | Group operator syntax flavors
additive_group_tag |
IsGroup | Group Concept
DirectProduct |
traits< DirectProduct< G, H > > |
DirectSum | Template to construct the direct sum of two additive groups Assumes existence of three additive operators for both groups
traits< DirectSum< G, H > > |
LieGroup | A CRTP helper class that implements Lie group methods Prerequisites: methods operator*, inverse, and AdjointMap, as well as a ChartAtOrigin struct that will be used to define the manifold Chart To use, simply derive, but also say "using LieGroup<Class,N>::inverse" For derivative math, see doc/math.pdf
lie_group_tag | Tag to assert a type is a Lie group
IsLieGroup | Lie Group Concept
TransformCovariance | Functor for transforming covariance of T
manifold_tag | Tag to assert a type is a manifold
FixedDimension | Give fixed size dimension of a type, fails at compile time if dynamic
Reshape | Reshape functor
Reshape< M, M, InOptions, M, M, InOptions > | Reshape specialization that does nothing as shape stays the same (needed to not be ambiguous for square input equals square output)
Reshape< M, N, InOptions, M, N, InOptions > | Reshape specialization that does nothing as shape stays the same
Reshape< N, M, InOptions, M, N, InOptions > | Reshape specialization that does transpose
MultiplyWithInverse | Functor that implements multiplication of a vector b with the inverse of a matrix A
MultiplyWithInverseFunction | Functor that implements multiplication with the inverse of a matrix, itself the result of a function f
G_x1 | Helper class that computes the derivative of f w.r.t
OptionalJacobian | OptionalJacobian is an Eigen::Ref like class that can take be constructed using either a fixed size or dynamic Eigen matrix
OptionalJacobian< Eigen::Dynamic, Eigen::Dynamic > |
MakeJacobian | : meta-function to generate Jacobian
MakeOptionalJacobian | : meta-function to generate JacobianTA optional reference Used mainly by Expressions
ProductLieGroup | Template to construct the product Lie group of two other Lie groups Assumes Lie group structure for G and H
traits< ProductLieGroup< G, H > > |
SymmetricBlockMatrix | This class stores a dense matrix and allows it to be accessed as a collection of blocks
IsTestable | A testable concept check that should be placed in applicable unit tests and in generic algorithms
equals | Template to create a binary predicate
equals_star | Binary predicate on shared pointers
HasTestablePrereqs | Requirements on type to pass it to Testable template below
Testable | A helper that implements the traits interface for GTSAM types
ThreadsafeException | Base exception type that uses tbb_allocator if GTSAM is compiled with TBB
RuntimeErrorThreadsafe | Thread-safe runtime error exception
OutOfRangeThreadsafe | Thread-safe out of range exception
InvalidArgumentThreadsafe | Thread-safe invalid argument exception
CholeskyFailed | Indicate Cholesky factorization failure
const_selector | Helper class that uses templates to select between two types based on whether TEST_TYPE is const or not
const_selector< BASIC_TYPE, BASIC_TYPE, AS_NON_CONST, AS_CONST > | Specialization for the non-const version
const_selector< const BASIC_TYPE, BASIC_TYPE, AS_NON_CONST, AS_CONST > | Specialization for the const version
ValueWithDefault | Helper struct that encapsulates a value with a default, this is just used as a member object so you don't have to specify defaults in the class constructor
ListOfOneContainer | A helper class that behaves as a container with one element, and works with boost::range
TbbOpenMPMixedScope | An object whose scope defines a block where TBB and OpenMP parallelism are mixed
needs_eigen_aligned_allocator | A SFINAE trait to mark classes that need special alignment
needs_eigen_aligned_allocator< T, void_t< typename T::_eigen_aligned_allocator_trait > > |
RedirectCout | For Python str()
Value | This is the base class for any type to be stored in Values
vector_space_tag | Tag to assert a type is a vector space
traits< double > | Double
traits< float > | Float
traits< Eigen::Matrix< double, M, N, Options, MaxRows, MaxCols > > |
traits< Eigen::Matrix< double, -1, -1, Options, MaxRows, MaxCols > > |
traits< Eigen::Matrix< double, -1, 1, Options, MaxRows, MaxCols > > |
traits< Eigen::Matrix< double, 1, -1, Options, MaxRows, MaxCols > > |
IsVectorSpace | Vector Space concept
VerticalBlockMatrix | This class stores a dense matrix and allows it to be accessed as a collection of vertical blocks
WeightedSampler |
Basis | CRTP Base class for function bases
EvaluationFunctor | An instance of an EvaluationFunctor calculates f(x;p) at a given x, applied to Parameters p
VectorEvaluationFunctor | VectorEvaluationFunctor at a given x, applied to ParameterMatrix<M>
VectorComponentFunctor | Given a M*N Matrix of M-vectors at N polynomial points, an instance of VectorComponentFunctor computes the N-vector value for a specific row component of the M-vectors at all the polynomial points
ManifoldEvaluationFunctor | Manifold EvaluationFunctor at a given x, applied to ParameterMatrix<M>
DerivativeFunctorBase | Base class for functors below that calculate derivative weights
DerivativeFunctor | An instance of a DerivativeFunctor calculates f'(x;p) at a given x, applied to Parameters p
VectorDerivativeFunctor | VectorDerivativeFunctor at a given x, applied to ParameterMatrix<M>
ComponentDerivativeFunctor | Given a M*N Matrix of M-vectors at N polynomial points, an instance of ComponentDerivativeFunctor computes the N-vector derivative for a specific row component of the M-vectors at all the polynomial points
EvaluationFactor | Factor for enforcing the scalar value of the polynomial BASIS representation at x is the same as the measurement z when using a pseudo-spectral parameterization
VectorEvaluationFactor | Unary factor for enforcing BASIS polynomial evaluation on a ParameterMatrix of size (M, N) is equal to a vector-valued measurement at the same point, when using a pseudo-spectral parameterization
VectorComponentFactor | Unary factor for enforcing BASIS polynomial evaluation on a ParameterMatrix of size (P, N) is equal to specified measurement at the same point, when using a pseudo-spectral parameterization
ManifoldEvaluationFactor | For a measurement value of type T i.e
DerivativeFactor | A unary factor which enforces the evaluation of the derivative of a BASIS polynomial at a specified pointx is equal to the scalar measurement z
VectorDerivativeFactor | A unary factor which enforces the evaluation of the derivative of a BASIS polynomial at a specified point x is equal to the vector value z
ComponentDerivativeFactor | A unary factor which enforces the evaluation of the derivative of a BASIS polynomial is equal to the scalar value at a specific index i of a vector-valued measurement z
Chebyshev1Basis | Basis of Chebyshev polynomials of the first kind https://en.wikipedia.org/wiki/Chebyshev_polynomials#First_kind These are typically denoted with the symbol T_n, where n is the degree
Chebyshev2Basis | Basis of Chebyshev polynomials of the second kind
Chebyshev2 | Chebyshev Interpolation on Chebyshev points of the second kind Note that N here, the number of points, is one less than N from 'Approximation Theory and Approximation Practice by L
FitBasis | Class that does regression via least squares Example usage: size_t N = 3; auto fit = FitBasis<Chebyshev2>(data_points, noise_model, N); Vector coefficients = fit.parameters();
FourierBasis | Fourier basis
ParameterMatrix | A matrix abstraction of MxN values at the Basis points
traits< ParameterMatrix< M > > |
AlgebraicDecisionTree | An algebraic decision tree fixes the range of a DecisionTree to double
Ring | The Real ring with addition and multiplication
traits< AlgebraicDecisionTree< T > > |
Assignment | An assignment from labels to value index (size_t)
Visit | Functor performing depth-first visit to each leaf with the leaf value as the argument
VisitLeaf | Functor performing depth-first visit to each leaf with the Leaf object passed as an argument
VisitWith | Functor performing depth-first visit to each leaf with the leaf's Assignment<L> and value passed as arguments
DecisionTree | Decision tree is a function from assignments to values
Node | ---------------------— Node base class ------------------------—
Leaf |
Choice |
traits< DecisionTree< L, Y > > |
DecisionTreeFactor | A discrete probabilistic factor
traits< DecisionTreeFactor > |
DiscreteBayesNet | A Bayes net made from discrete conditional distributions
traits< DiscreteBayesNet > |
DiscreteBayesTreeClique | A clique in a DiscreteBayesTree
DiscreteBayesTree | A Bayes tree representing a Discrete density
DiscreteConditional | Discrete Conditional Density Derives from DecisionTreeFactor
traits< DiscreteConditional > |
DiscreteDistribution | A prior probability on a set of discrete variables
traits< DiscreteDistribution > |
DiscreteEliminationTree | Elimination tree for discrete factors
DiscreteFactor | Base class for discrete probabilistic factors The most general one is the derived DecisionTreeFactor
traits< DiscreteFactor > |
EliminationTraits< DiscreteFactorGraph > |
DiscreteFactorGraph | A Discrete Factor Graph is a factor graph where all factors are Discrete, i.e
traits< DiscreteFactorGraph > |
DiscreteJunctionTree | An EliminatableClusterTree, i.e., a set of variable clusters with factors, arranged in a tree, with the additional property that it represents the clique tree associated with a Bayes net
DiscreteKeys | DiscreteKeys is a set of keys that can be assembled using the & operator
traits< DiscreteKeys > |
DiscreteLookupTable | DiscreteLookupTable table for max-product
DiscreteLookupDAG | A DAG made from lookup tables, as defined above
traits< DiscreteLookupDAG > |
DiscreteMarginals | A class for computing marginals of variables in a DiscreteFactorGraph
DiscreteValues | A map from keys to values
traits< DiscreteValues > |
Signature | Signature for a discrete conditional density, used to construct conditionals
Bearing |
Range |
BearingRange | Bearing-Range product for a particular A1,A2 combination will use the functors above to create a similar functor of type A1*A2 -> pair<Bearing::return_type,Range::return_type> For example BearingRange<Pose2,Point2>(pose,point) will return pair<Rot2,double> and BearingRange<Pose3,Point3>(pose,point) will return pair<Unit3,double>
traits< BearingRange< A1, A2 > > |
HasBearing |
HasRange |
Cal3 | Common base class for all calibration models
Cal3_S2 | The most common 5DOF 3D->2D calibration
traits< Cal3_S2 > |
traits< const Cal3_S2 > |
Cal3_S2Stereo | The most common 5DOF 3D->2D calibration, stereo version
traits< Cal3_S2Stereo > |
traits< const Cal3_S2Stereo > |
Cal3Bundler | Calibration used by Bundler
traits< Cal3Bundler > |
traits< const Cal3Bundler > |
Cal3DS2 | Calibration of a camera with radial distortion that also supports Lie-group behaviors for optimization
traits< Cal3DS2 > |
traits< const Cal3DS2 > |
Cal3DS2_Base | Calibration of a camera with radial distortion
Cal3Fisheye | Calibration of a fisheye camera
traits< Cal3Fisheye > |
traits< const Cal3Fisheye > |
Cal3Unified | Calibration of a omni-directional camera with mirror + lens radial distortion
traits< Cal3Unified > |
traits< const Cal3Unified > |
CheiralityException |
PinholeBase | A pinhole camera class that has a Pose3, functions as base class for all pinhole cameras
CalibratedCamera | A Calibrated camera class [R|-R't], calibration K=I
traits< CalibratedCamera > |
traits< const CalibratedCamera > |
Range< CalibratedCamera, T > |
CameraSet | A set of cameras, all with their own calibration
traits< CameraSet< CAMERA > > |
traits< const CameraSet< CAMERA > > |
PoseConcept | Pose Concept A must contain a translation and a rotation, with each structure accessable directly and a type provided for each
Cyclic | Cyclic group of order N
traits< Cyclic< N > > | Define cyclic group to be a model of the Additive Group concept
EssentialMatrix | An essential matrix is like a Pose3, except with translation up to scale It is named after the 3*3 matrix aEb = [aTb]x aRb from computer vision, but here we choose instead to parameterize it as a (Rot3,Unit3) pair
traits< EssentialMatrix > |
traits< const EssentialMatrix > |
Line3 | A 3D line (R,a,b) : (Rot3,Scalar,Scalar)
traits< Line3 > |
traits< const Line3 > |
OrientedPlane3 | Represents an infinite plane in 3D, which is composed of a planar normal and its perpendicular distance to the origin
traits< OrientedPlane3 > |
traits< const OrientedPlane3 > |
PinholeCamera | A pinhole camera class that has a Pose3 and a Calibration
traits< PinholeCamera< Calibration > > |
traits< const PinholeCamera< Calibration > > |
Range< PinholeCamera< Calibration >, T > |
PinholeBaseK | A pinhole camera class that has a Pose3 and a fixed Calibration
PinholePose | A pinhole camera class that has a Pose3 and a fixed Calibration
traits< PinholePose< CALIBRATION > > |
traits< const PinholePose< CALIBRATION > > |
PinholeSet | PinholeSet: triangulates point and keeps an estimate of it around
traits< PinholeSet< CAMERA > > |
traits< const PinholeSet< CAMERA > > |
Range< Point2, Point2 > |
Range< Point3, Point3 > |
Pose2 | A 2D pose (Point2,Rot2)
ChartAtOrigin |
traits< Pose2 > |
traits< const Pose2 > |
Bearing< Pose2, T > |
Range< Pose2, T > |
Pose3 | A 3D pose (R,t) : (Rot3,Point3)
ChartAtOrigin |
traits< Pose3 > |
traits< const Pose3 > |
Bearing< Pose3, Point3 > |
Bearing< Pose3, Pose3 > |
Range< Pose3, T > |
traits< QUATERNION_TYPE > |
Rot2 | Rotation matrix NOTE: the angle theta is in radians unless explicitly stated
ChartAtOrigin |
traits< Rot2 > |
traits< const Rot2 > |
Rot3 | Rot3 is a 3D rotation represented as a rotation matrix if the preprocessor symbol GTSAM_USE_QUATERNIONS is not defined, or as a quaternion if it is defined
CayleyChart |
ChartAtOrigin |
traits< Rot3 > |
traits< const Rot3 > |
Similarity2 | 2D similarity transform
ChartAtOrigin | Chart at the origin
traits< Similarity2 > |
traits< const Similarity2 > |
Similarity3 | 3D similarity transform
ChartAtOrigin | Chart at the origin
traits< Similarity3 > |
traits< const Similarity3 > |
traits< SO3 > |
traits< const SO3 > |
traits< SO4 > |
traits< const SO4 > |
SO | Manifold of special orthogonal rotation matrices SO<N>
ChartAtOrigin |
traits< SO< N > > |
traits< const SO< N > > |
EmptyCal | Empty calibration
SphericalCamera | A spherical camera class that has a Pose3 and measures bearing vectors
traits< SphericalCamera > |
traits< const SphericalCamera > |
StereoCheiralityException |
StereoCamera | A stereo camera class, parameterize by left camera pose and stereo calibration
traits< StereoCamera > |
traits< const StereoCamera > |
StereoPoint2 | A 2D stereo point, v will be same for rectified images
traits< StereoPoint2 > |
traits< const StereoPoint2 > |
TriangulationUnderconstrainedException | Exception thrown by triangulateDLT when SVD returns rank < 3
TriangulationCheiralityException | Exception thrown by triangulateDLT when landmark is behind one or more of the cameras
TriangulationParameters |
TriangulationResult | TriangulationResult is an optional point, along with the reasons why it is invalid
Unit3 | Represents a 3D point on a unit sphere
traits< Unit3 > |
traits< const Unit3 > |
GaussianMixture | A conditional of gaussian mixtures indexed by discrete variables, as part of a Bayes Network
traits< GaussianMixture > |
GaussianMixtureFactor | Implementation of a discrete conditional mixture factor
traits< GaussianMixtureFactor > |
HybridBayesNet | A hybrid Bayes net is a collection of HybridConditionals, which can have discrete conditionals, Gaussian mixtures, or pure Gaussian conditionals
traits< HybridBayesNet > | Traits
HybridBayesTreeClique | A clique in a HybridBayesTree which is a HybridConditional internally
HybridBayesTree | A Bayes tree representing a Hybrid density
traits< HybridBayesTree > | Traits
BayesTreeOrphanWrapper< HybridBayesTreeClique > | Class for Hybrid Bayes tree orphan subtrees
HybridConditional | Hybrid Conditional Density
traits< HybridConditional > |
HybridEliminationTree | Elimination Tree type for Hybrid Factor Graphs
HybridFactor | Base class for truly hybrid probabilistic factors
traits< HybridFactor > |
HybridFactorGraph | Hybrid Factor Graph Factor graph with utilities for hybrid factors
EliminationTraits< HybridGaussianFactorGraph > |
HybridGaussianFactorGraph |
HybridGaussianISAM |
traits< HybridGaussianISAM > | Traits
HybridJunctionTree | An EliminatableClusterTree, i.e., a set of variable clusters with factors, arranged in a tree, with the additional property that it represents the clique tree associated with a Bayes net
HybridNonlinearFactorGraph |
traits< HybridNonlinearFactorGraph > |
HybridNonlinearISAM | Wrapper class to manage ISAM in a nonlinear context
HybridSmoother |
HybridValues | HybridValues represents a collection of DiscreteValues and VectorValues
traits< HybridValues > |
MixtureFactor | Implementation of a discrete conditional mixture factor
BayesNet | A BayesNet is a tree of conditionals, stored in elimination order
FactorGraph | A factor graph is a bipartite graph with factor nodes connected to variable nodes
EliminatableClusterTree | A cluster-tree that eliminates to a Bayes tree
BayesTreeCliqueStats | Clique statistics
BayesTreeCliqueData | Store all the sizes
BayesTree | Bayes tree
BayesTreeOrphanWrapper |
EliminationTraits | Traits class for eliminateable factor graphs, specifies the types that result from elimination, etc
BayesTreeCliqueBase | This is the base class for BayesTree cliques
EliminationData |
EliminationPostOrderVisitor |
ClusterTree | A cluster-tree is associated with a factor graph and is defined as in Koller-Friedman: each node k represents a subset \( C_k \sub X \), and the tree is family preserving, in that each factor \( f_i \) is associated with a single cluster and \( scope(f_i) \sub C_k \)
Cluster | A Cluster is just a collection of factors
Conditional |
DotWriter | DotWriter is a helper class for writing graphviz .dot files
EliminateableFactorGraph | EliminateableFactorGraph is a base class for factor graphs that contains elimination algorithms
EliminationTree | An elimination tree is a data structure used intermediately during elimination
Node |
Factor |
CRefCallPushBack | Helper
RefCallPushBack | Helper
CRefCallAddCopy | Helper
ordering_key_visitor |
compose_key_visitor |
SDGraph | SDGraph is undirected graph with variable keys and double edge weights
SGraph |
PredecessorMap | Map from variable key to parent key
InconsistentEliminationRequested | An inference algorithm was called with inconsistent arguments
ISAM | A Bayes tree with an update methods that implements the iSAM algorithm
ConstructorTraversalData |
SymbolicFactors |
JunctionTree | A JunctionTree is a cluster tree, a set of variable clusters with factors, arranged in a tree, with the additional property that it represents the clique tree associated with a Bayes Net
StreamedKey | To use the key_formatter on Keys, they must be wrapped in a StreamedKey
key_formatter | Output stream manipulator that will format gtsam::Keys according to the given KeyFormatter, as long as Key values are wrapped in a gtsam::StreamedKey
traits< Key > |
LabeledSymbol | Customized version of gtsam::Symbol for multi-robot use
traits< LabeledSymbol > | Traits
MetisIndex | Converts a factor graph into the Compressed Sparse Row format for use in METIS algorithms
Ordering |
traits< Ordering > | Traits
Symbol | Character and index key used to refer to variables
SymbolGenerator | Generates symbol shorthands with alternative names different than the one-letter predefined ones
traits< Symbol > | Traits
VariableIndex | Computes and stores the block column structure of a factor graph
traits< VariableIndex > | Traits
VariableSlots | A combined factor is assembled as one block of rows for each component factor
traits< VariableSlots > | Traits
AcceleratedPowerMethod | Compute maximum Eigenpair with accelerated power method
BinaryJacobianFactor | A binary JacobianFactor specialization that uses fixed matrix math for speed
traits< BinaryJacobianFactor< M, N1, N2 > > |
ConjugateGradientParameters | Parameters for the conjugate gradient method
traits< Errors > | Traits
GaussianBayesNet | GaussianBayesNet is a Bayes net made from linear-Gaussian conditionals
traits< GaussianBayesNet > | Traits
GaussianBayesTreeClique | A clique in a GaussianBayesTree
GaussianBayesTree | A Bayes tree representing a Gaussian density
traits< GaussianBayesTree > | Traits
GaussianConditional | A GaussianConditional functions as the node in a Bayes network
traits< GaussianConditional > | Traits
GaussianDensity | A GaussianDensity is a GaussianConditional without parents
GaussianEliminationTree |
GaussianFactor | An abstract virtual base class for JacobianFactor and HessianFactor
traits< GaussianFactor > | Traits
EliminationTraits< GaussianFactorGraph > |
GaussianFactorGraph | A Linear Factor Graph is a factor graph where all factors are Gaussian, i.e
traits< GaussianFactorGraph > | Traits
GaussianISAM |
traits< GaussianISAM > | Traits
GaussianJunctionTree | A junction tree specialized to Gaussian factors, i.e., it is a cluster tree with Gaussian factors stored in each cluster
HessianFactor | A Gaussian factor using the canonical parameters (information form)
traits< HessianFactor > | Traits
CGState |
System | Helper class encapsulating the combined system |Ax-b_|^2 Needed to run Conjugate Gradients on matrices
IterativeOptimizationParameters | Parameters for iterative linear solvers
IterativeSolver | Base class for Iterative Solvers like SubgraphSolver
KeyInfoEntry | Handy data structure for iterative solvers key to (index, dimension, start)
KeyInfo | Handy data structure for iterative solvers
JacobianFactor | A Gaussian factor in the squared-error form
traits< JacobianFactor > | Traits
KalmanFilter | Kalman Filter class
IndeterminantLinearSystemException | Thrown when a linear system is ill-posed
InvalidNoiseModel | An exception indicating that the noise model dimension passed into a JacobianFactor has a different dimensionality than the factor
InvalidMatrixBlock | An exception indicating that a matrix block passed into a JacobianFactor has a different dimensionality than the factor
InvalidDenseElimination |
traits< noiseModel::Gaussian > | Traits
traits< noiseModel::Diagonal > |
traits< noiseModel::Constrained > |
traits< noiseModel::Isotropic > |
traits< noiseModel::Unit > |
PCGSolverParameters | Parameters for PCG
PCGSolver | A virtual base class for the preconditioned conjugate gradient solver
GaussianFactorGraphSystem | System class needed for calling preconditionedConjugateGradient
PowerMethod | Compute maximum Eigenpair with power method
PreconditionerParameters |
Preconditioner |
DummyPreconditionerParameters |
DummyPreconditioner |
BlockJacobiPreconditionerParameters |
BlockJacobiPreconditioner |
RegularHessianFactor |
traits< RegularHessianFactor< D > > |
RegularJacobianFactor | JacobianFactor with constant sized blocks Provides raw memory access versions of linear operator
Sampler | Sampling structure that keeps internal random number generators for diagonal distributions specified by NoiseModel
SlotEntry | One SlotEntry stores the slot index for a variable, as well its dim
Scatter | Scatter is an intermediate data structure used when building a HessianFactor incrementally, to get the keys in the right order
Subgraph |
Edge |
SubgraphBuilderParameters |
SubgraphBuilder |
SubgraphPreconditionerParameters |
SubgraphPreconditioner | Subgraph conditioner class, as explained in the RSS 2010 submission
SubgraphSolverParameters |
SubgraphSolver | This class implements the linear SPCG solver presented in Dellaert et al in IROS'10
VectorValues | VectorValues represents a collection of vector-valued variables associated each with a unique integer index
traits< VectorValues > | Traits
PreintegratedAhrsMeasurements | PreintegratedAHRSMeasurements accumulates (integrates) the Gyroscope measurements (rotation rates) and the corresponding covariance matrix
AHRSFactor |
AttitudeFactor | Base class for prior on attitude Example:
Rot3AttitudeFactor | Version of AttitudeFactor for Rot3
traits< Rot3AttitudeFactor > | Traits
Pose3AttitudeFactor | Version of AttitudeFactor for Pose3
traits< Pose3AttitudeFactor > | Traits
BarometricFactor | Prior on height in a cartesian frame
PreintegrationCombinedParams | Parameters for pre-integration using PreintegratedCombinedMeasurements: Usage: Create just a single Params and pass a shared pointer to the constructor
PreintegratedCombinedMeasurements | PreintegratedCombinedMeasurements integrates the IMU measurements (rotation rates and accelerations) and the corresponding covariance matrix
CombinedImuFactor | CombinedImuFactor is a 6-ways factor involving previous state (pose and velocity of the vehicle, as well as bias at previous time step), and current state (pose, velocity, bias at current time step)
traits< PreintegrationCombinedParams > |
traits< PreintegratedCombinedMeasurements > |
traits< CombinedImuFactor > |
ConstantVelocityFactor | Binary factor for applying a constant velocity model to a moving body represented as a NavState
GPSFactor | Prior on position in a Cartesian frame
GPSFactor2 | Version of GPSFactor for NavState
traits< imuBias::ConstantBias > |
PreintegratedImuMeasurements | PreintegratedImuMeasurements accumulates (integrates) the IMU measurements (rotation rates and accelerations) and the corresponding covariance matrix
ImuFactor | ImuFactor is a 5-ways factor involving previous state (pose and velocity of the vehicle at previous time step), current state (pose and velocity at current time step), and the bias estimate
ImuFactor2 | ImuFactor2 is a ternary factor that uses NavStates rather than Pose/Velocity
traits< PreintegratedImuMeasurements > |
traits< ImuFactor > |
traits< ImuFactor2 > |
MagFactor | Factor to estimate rotation given magnetometer reading This version uses model measured bM = scale * bRn * direction + bias and assumes scale, direction, and the bias are given
MagFactor1 | Factor to estimate rotation given magnetometer reading This version uses model measured bM = scale * bRn * direction + bias and assumes scale, direction, and the bias are given
MagFactor2 | Factor to calibrate local Earth magnetic field as well as magnetometer bias This version uses model measured bM = bRn * nM + bias and optimizes for both nM and the bias, where nM is in units defined by magnetometer
MagFactor3 | Factor to calibrate local Earth magnetic field as well as magnetometer bias This version uses model measured bM = scale * bRn * direction + bias and optimizes for both scale, direction, and the bias
MagPoseFactor | Factor to estimate rotation of a Pose2 or Pose3 given a magnetometer reading
ManifoldPreintegration | IMU pre-integration on NavSatet manifold
NavState | Navigation state: Pose (rotation, translation) + velocity NOTE(frank): it does not make sense to make this a Lie group, but it is a 9D manifold
traits< NavState > |
PreintegratedRotationParams | Parameters for pre-integration: Usage: Create just a single Params and pass a shared pointer to the constructor
PreintegratedRotation | PreintegratedRotation is the base class for all PreintegratedMeasurements classes (in AHRSFactor, ImuFactor, and CombinedImuFactor)
traits< PreintegratedRotation > |
PreintegrationBase | PreintegrationBase is the base class for PreintegratedMeasurements (in ImuFactor) and CombinedPreintegratedMeasurements (in CombinedImuFactor)
PreintegrationParams | Parameters for pre-integration: Usage: Create just a single Params and pass a shared pointer to the constructor
Scenario | Simple trajectory simulator
ConstantTwistScenario | Scenario with constant twist 3D trajectory
AcceleratingScenario | Accelerating from an arbitrary initial state, with optional rotation
ScenarioRunner |
CombinedScenarioRunner |
TangentPreintegration | Integrate on the 9D tangent space of the NavState manifold
CustomFactor |
DoglegParams | Parameters for Levenberg-Marquardt optimization
DoglegOptimizer | This class performs Dogleg nonlinear optimization
DoglegOptimizerImpl | This class contains the implementation of the Dogleg algorithm
IterationResult |
ExpressionFactor | Factor that supports arbitrary expressions via AD
Expression | Expression class that supports automatic differentiation
UnaryFunction |
BinaryFunction |
TernaryFunction |
ScalarMultiplyExpression | A ScalarMultiplyExpression is a specialization of Expression that multiplies with a scalar It optimizes the Jacobian calculation for this specific case
BinarySumExpression | A BinarySumExpression is a specialization of Expression that adds two expressions together It optimizes the Jacobian calculation for this specific case
traits< ExpressionFactor< T > > | Traits
ExpressionFactorN | N-ary variadic template for ExpressionFactor meant as a base class for N-ary factors
traits< ExpressionFactorN< T, Args... > > | Traits
ExpressionFactorGraph | Factor graph that supports adding ExpressionFactors directly
ExtendedKalmanFilter | This is a generic Extended Kalman Filter class implemented using nonlinear factors
FunctorizedFactor | Factor which evaluates provided unary functor and uses the result to compute error with respect to the provided measurement
traits< FunctorizedFactor< R, T > > | Traits
FunctorizedFactor2 | Factor which evaluates provided binary functor and uses the result to compute error with respect to the provided measurement
traits< FunctorizedFactor2< R, T1, T2 > > | Traits
GaussNewtonParams | Parameters for Gauss-Newton optimization, inherits from NonlinearOptimizationParams
GaussNewtonOptimizer | This class performs Gauss-Newton nonlinear optimization
GncOptimizer |
GncParams |
GraphvizFormatting | Formatting options and functions for saving a NonlinearFactorGraph instance in GraphViz format
ISAM2BayesTree |
ISAM2JunctionTree |
DeltaImpl |
PartialSolveResult |
ReorderingMode |
UpdateImpl | Implementation functions for update method All of the methods below have clear inputs and outputs, even if not functional: iSAM2 is inherintly imperative
ISAM2 | Implementation of the full ISAM2 algorithm for incremental nonlinear optimization
traits< ISAM2 > | Traits
ISAM2Clique | Specialized Clique structure for ISAM2, incorporating caching and gradient contribution TODO: more documentation
ISAM2GaussNewtonParams | Parameters for ISAM2 using Gauss-Newton optimization
ISAM2DoglegParams | Parameters for ISAM2 using Dogleg optimization
ISAM2Params |
ISAM2Result | This struct is returned from ISAM2::update() and contains information about the update that is useful for determining whether the solution is converging, and about how much work was required for the update
DetailedResults | A struct holding detailed results, which must be enabled with ISAM2Params::enableDetailedResults
VariableStatus | The status of a single variable, this struct is stored in DetailedResults::variableStatus
ISAM2UpdateParams | This struct is used by ISAM2::update() to pass additional parameters to give the user a fine-grained control on how factors and relinearized, etc
LevenbergMarquardtOptimizer | This class performs Levenberg-Marquardt nonlinear optimization
LevenbergMarquardtParams | Parameters for Levenberg-Marquardt optimization
LinearContainerFactor | Dummy version of a generic linear factor to be injected into a nonlinear factor graph
traits< LinearContainerFactor > |
Marginals | A class for computing Gaussian marginals of variables in a NonlinearFactorGraph
JointMarginal | A class to store and access a joint marginal, returned from Marginals::jointMarginalCovariance and Marginals::jointMarginalInformation
NonlinearConjugateGradientOptimizer | An implementation of the nonlinear CG method using the template below
NonlinearEquality | An equality factor that forces either one variable to a constant, or a set of variables to be equal to each other
traits< NonlinearEquality< VALUE > > |
NonlinearEquality1 | Simple unary equality constraint - fixes a value for a variable
traits< NonlinearEquality1< VALUE > > |
NonlinearEquality2 | Simple binary equality constraint - this constraint forces two variables to be the same
traits< NonlinearEquality2< VALUE > > |
MarginalizeNonleafException | Thrown when requesting to marginalize out variables from ISAM2 that are not leaves
NonlinearFactor | Nonlinear factor base class
traits< NonlinearFactor > | Traits
NoiseModelFactor | A nonlinear sum-of-squares factor with a zero-mean noise model implementing the density \( P(z|x) \propto exp -0.5*|z-h(x)|^2_C \) Templated on the parameter type X and the values structure Values There is no return type specified for h(x)
NoiseModelFactorN | A convenient base class for creating your own NoiseModelFactor with n variables
NonlinearFactorGraph |
traits< NonlinearFactorGraph > | Traits
NonlinearISAM | Wrapper class to manage ISAM in a nonlinear context
NonlinearOptimizer | This is the abstract interface for classes that can optimize for the maximum-likelihood estimate of a NonlinearFactorGraph
NonlinearOptimizerParams | The common parameters for Nonlinear optimizers
PriorFactor | A class for a soft prior on any Value type
traits< PriorFactor< VALUE > > | Traits
_ValuesKeyValuePair |
_ValuesConstKeyValuePair |
ValuesCastHelper |
ValuesCastHelper< Value, CastedKeyValuePairType, KeyValuePairType > |
ValuesCastHelper< const Value, CastedKeyValuePairType, KeyValuePairType > |
ValueCloneAllocator |
Values | A non-templated config holding any types of Manifold-group elements
KeyValuePair | A key-value pair, which you get by dereferencing iterators
ConstKeyValuePair | A key-value pair, which you get by dereferencing iterators
deref_iterator |
ValuesKeyAlreadyExists |
ValuesKeyDoesNotExist |
ValuesIncorrectType |
DynamicValuesMismatched |
NoMatchFoundForFixed |
traits< Values > | Traits
WhiteNoiseFactor | Binary factor to estimate parameters of zero-mean Gaussian white noise
BearingFactor | Binary factor for a bearing measurement Works for any two types A1,A2 for which the functor Bearing<A1,A2>() is defined
traits< BearingFactor< A1, A2, T > > | Traits
BearingRangeFactor | Binary factor for a bearing/range measurement
traits< BearingRangeFactor< A1, A2, B, R > > | Traits
RangeFactor | Binary factor for a range measurement Works for any two types A1,A2 for which the functor Range<A1,A2>() is defined
traits< RangeFactor< A1, A2, T > > | Traits
RangeFactorWithTransform | Binary factor for a range measurement, with a transform applied
traits< RangeFactorWithTransform< A1, A2, T > > | Traits
BinaryMeasurement |
MFAS | To solve a Minimum feedback arc set (MFAS) problem
SfmData | SfmData stores a bunch of SfmTracks
traits< SfmData > | Traits
SfmTrack2d | Track containing 2D measurements associated with a single 3D point
SfmTrack |
traits< SfmTrack > |
ShonanAveragingParameters | Parameters governing optimization etc
ShonanAveraging | Class that implements Shonan Averaging from our ECCV'20 paper
ShonanAveraging2 |
ShonanAveraging3 |
ShonanFactor | ShonanFactor is a BetweenFactor that moves in SO(p), but will land on the SO(d) sub-manifold of SO(p) at the global minimum
ShonanGaugeFactor | The ShonanGaugeFactor creates a constraint on a single SO(n) to avoid moving in the stabilizer
TranslationFactor | Binary factor for a relative translation direction measurement w_aZb
TranslationRecovery |
AntiFactor | A class for downdating an existing factor from a graph
BetweenFactor | A class for a measurement predicted by "between(config[key1],config[key2])"
traits< BetweenFactor< VALUE > > | Traits
BetweenConstraint | Binary between constraint - forces between to a given value This constraint requires the underlying type to a Lie type
traits< BetweenConstraint< VALUE > > | Traits
BoundingConstraint1 | Unary inequality constraint forcing a scalar to be greater/less than a fixed threshold
BoundingConstraint2 | Binary scalar inequality constraint, with a similar value() function to implement for specific systems
EssentialMatrixConstraint | Binary factor between two Pose3 variables induced by an EssentialMatrix measurement
EssentialMatrixFactor | Factor that evaluates epipolar error p'Ep for given essential matrix
EssentialMatrixFactor2 | Binary factor that optimizes for E and inverse depth d: assumes measurement in image 2 is perfect, and returns re-projection error in image 1
EssentialMatrixFactor3 | Binary factor that optimizes for E and inverse depth d: assumes measurement in image 2 is perfect, and returns re-projection error in image 1 This version takes an extrinsic rotation to allow for omni-directional rigs
EssentialMatrixFactor4 | Binary factor that optimizes for E and calibration K using the algebraic epipolar error (K^-1 pA)'E (K^-1 pB)
FrobeniusPrior | FrobeniusPrior calculates the Frobenius norm between a given matrix and an element of SO(3) or SO(4)
FrobeniusFactor | FrobeniusFactor calculates the Frobenius norm between rotation matrices
FrobeniusBetweenFactor | FrobeniusBetweenFactor is a BetweenFactor that evaluates the Frobenius norm of the rotation error between measured and predicted (rather than the Logmap of the error)
GeneralSFMFactor | Non-linear factor for a constraint derived from a 2D measurement
traits< GeneralSFMFactor< CAMERA, LANDMARK > > |
GeneralSFMFactor2 | Non-linear factor for a constraint derived from a 2D measurement
traits< GeneralSFMFactor2< CALIBRATION > > |
InitializePose3 |
JacobianFactorQ | JacobianFactor for Schur complement that uses Q noise model
traits< JacobianFactorQ< D, ZDim > > |
JacobianFactorQR | JacobianFactor for Schur complement that uses Q noise model
JacobianFactorSVD | JacobianFactor for Schur complement that uses the "Nullspace Trick" by Mourikis et al
KarcherMeanFactor | The KarcherMeanFactor creates a constraint on all SO(n) variables with given keys that the Karcher mean (see above) will stay the same
OrientedPlane3Factor | Factor to measure a planar landmark from a given pose
OrientedPlane3DirectionPrior |
PoseRotationPrior |
PoseTranslationPrior | A prior on the translation part of a pose
GenericProjectionFactor | Non-linear factor for a constraint derived from a 2D measurement
traits< GenericProjectionFactor< POSE, LANDMARK, CALIBRATION > > | Traits
ReferenceFrameFactor | A constraint between two landmarks in separate maps Templated on: Point : Type of landmark Transform : Transform variable class
traits< ReferenceFrameFactor< T1, T2 > > | Traits
RegularImplicitSchurFactor | RegularImplicitSchurFactor
traits< RegularImplicitSchurFactor< CAMERA > > |
RotateFactor | Factor on unknown rotation iRC that relates two incremental rotations c1Rc2 = iRc' * i1Ri2 * iRc Which we can write (see doc/math.lyx) e^[z] = iRc' * e^[p] * iRc = e^([iRc'*p]) with z and p measured and predicted angular velocities, and hence p = iRc * z
RotateDirectionsFactor | Factor on unknown rotation iRc that relates two directions c Directions provide less constraints than a full rotation
SmartFactorBase | Base class for smart factors
SmartProjectionParams |
SmartProjectionFactor | SmartProjectionFactor: triangulates point and keeps an estimate of it around
traits< SmartProjectionFactor< CAMERA > > | Traits
SmartProjectionPoseFactor | If you are using the factor, please cite: L
traits< SmartProjectionPoseFactor< CALIBRATION > > | Traits
SmartProjectionRigFactor | If you are using the factor, please cite: L
traits< SmartProjectionRigFactor< CAMERA > > | Traits
GenericStereoFactor | A Generic Stereo Factor
traits< GenericStereoFactor< T1, T2 > > | Traits
TriangulationFactor | Non-linear factor for a constraint derived from a 2D measurement
SymbolicBayesNet | A SymbolicBayesNet is a Bayes Net of purely symbolic conditionals
traits< SymbolicBayesNet > | Traits
SymbolicBayesTreeClique | A clique in a SymbolicBayesTree
SymbolicBayesTree | A Bayes tree that represents the connectivity between variables but is not associated with any probability functions
traits< SymbolicBayesTreeClique > | Traits
traits< SymbolicBayesTree > |
SymbolicConditional | SymbolicConditional is a conditional with keys but no probability data, produced by symbolic elimination of SymbolicFactor
traits< SymbolicConditional > | Traits
SymbolicEliminationTree |
traits< SymbolicEliminationTree > | Traits
SymbolicFactor | SymbolicFactor represents a symbolic factor that specifies graph topology but is not associated with any numerical function
traits< SymbolicFactor > | Traits
EliminationTraits< SymbolicFactorGraph > |
SymbolicFactorGraph | Symbolic Factor Graph
traits< SymbolicFactorGraph > | Traits
SymbolicISAM |
SymbolicJunctionTree | A EliminatableClusterTree, i.e., a set of variable clusters with factors, arranged in a tree, with the additional property that it represents the clique tree associated with a Bayes net
vector | STL class
iterator | STL iterator class
const_iterator | STL iterator class
reverse_iterator | STL iterator class
const_reverse_iterator | STL iterator class
DiscreteValues | The Factor::error simply extracts the
GaussianConditional | Normalization constant
HybridValues | Error
JacobianFactor | In Gaussian factors, the error function returns either the negative log-likelihood, e.g., 0.5*(A*x-b)'D(A*x-b) for a negative log-density, e.g., 0.5*(A*x-b)'D(A*x-b) - log(k) for a
map | STL class
iterator | STL iterator class
const_iterator | STL iterator class
reverse_iterator | STL iterator class
const_reverse_iterator | STL iterator class
NoiseModelFactor | Noise model to the factor, and calculates the error by asking the user to implement the method
Only | Symbolic elimination etc
ostream | STL class
pair | STL class
string | STL class
iterator | STL iterator class
const_iterator | STL iterator class
reverse_iterator | STL iterator class
const_reverse_iterator | STL iterator class
stringstream | STL class
unordered_map | STL class
iterator | STL iterator class
const_iterator | STL iterator class
reverse_iterator | STL iterator class
const_reverse_iterator | STL iterator class
unordered_set | STL class
iterator | STL iterator class
const_iterator | STL iterator class
reverse_iterator | STL iterator class
const_reverse_iterator | STL iterator class
Values | In nonlinear factors, the error function returns the negative log-likelihood as a non-linear function of the values in a
vector | STL class
iterator | STL iterator class
const_iterator | STL iterator class
reverse_iterator | STL iterator class
const_reverse_iterator | STL iterator class
VectorValues | The Factor::error simply extracts the