gtsam
4.0.0
gtsam

►Ngtsam  Global functions in a separate testing namespace 
►NimuBias  All bias models live in the imuBias namespace 
CConstantBias  
►Ninternal  
►NlinearAlgorithms  
COptimizeClique  Preorder visitor for backsubstitution in a Bayes tree 
COptimizeData  
Capply_compose  
CAutoTicToc  Small class that calls internal::tic at construction, and internol::toc when destroyed 
CDynamicTraits  
CExecutionTrace  
CExpressionNode  
CFastDefaultAllocator  Default allocator for list, map, and set types 
CFastDefaultVectorAllocator  Default allocator for vector types (we never use boost pool for vectors) 
CFixedSizeMatrix  
Chandle  
Chandle< Eigen::Matrix< double, M, N > >  
Chandle_matrix  
Chandle_matrix< Eigen::Matrix< double, M, N >, false >  
Chandle_matrix< Eigen::Matrix< double, M, N >, true >  
CHasManifoldPrereqs  Requirements on type to pass it to Manifold template below 
CHasVectorSpacePrereqs  Requirements on type to pass it to Manifold template below 
CLieGroup  Both LieGroupTraits and Testable 
CLieGroupTraits  A helper class that implements the traits interface for GTSAM lie groups 
CManifold  Both ManifoldTraits and Testable 
CManifoldImpl  Extra manifold traits for fixeddimension types 
CManifoldImpl< Class, Eigen::Dynamic >  Extra manifold traits for variabledimension types 
CManifoldTraits  A helper that implements the traits interface for GTSAM manifolds 
CScalarTraits  A helper that implements the traits interface for scalar vector spaces 
CTimingOutline  Timing Entry, arranged in a tree 
CVectorSpace  VectorSpace provides both Testable and VectorSpaceTraits 
CVectorSpaceImpl  VectorSpaceTraits Implementation for Fixed sizes 
CVectorSpaceImpl< Class, Eigen::Dynamic >  VectorSpaceTraits implementation for dynamic types 
CVectorSpaceTraits  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 
►NnoiseModel  All noise models live in the noiseModel namespace 
►NmEstimator  The mEstimator name space contains all robust error functions 
CBase  
CCauchy  Cauchy implements the "Cauchy" robust error model (Lee2013IROS) 
CDCS  DCS implements the Dynamic Covariance Scaling robust error model from the paper Robust Map Optimization (Agarwal13icra) 
CFair  Fair implements the "Fair" robust error model (Zhang97ivc) 
CGemanMcClure  GemanMcClure implements the "GemanMcClure" robust error model (Zhang97ivc) 
CHuber  Huber implements the "Huber" robust error model (Zhang97ivc) 
CL2WithDeadZone  L2WithDeadZone implements a standard L2 penalty, but with a dead zone of width 2*k, centered at the origin 
CNull  Null class is not robust so is a Gaussian ? 
CTukey  Tukey implements the "Tukey" robust error model (Zhang97ivc) 
CWelsh  Welsh implements the "Welsh" robust error model (Zhang97ivc) 
CBase  NoiseModel::Base is the abstract base class for all noise models 
CConstrained  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 
CDiagonal  A diagonal noise model implements a diagonal covariance matrix, with the elements of the diagonal specified in a Vector 
CGaussian  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 
CIsotropic  An isotropic noise model corresponds to a scaled diagonal covariance To construct, use one of the static methods 
CRobust  Base class for robust error models The robust Mestimators above simply tell us how to reweight the residual, and are isotropic kernels, in that they do not allow for correlated noise 
CUnit  Unit: i.i.d 
►Nso3  
CDexpFunctor  Functor that implements Exponential map and its derivatives 
CExpmapFunctor  Functor implementing Exponential map 
C_ValuesConstKeyValuePair  
C_ValuesKeyValuePair  
CAcceleratingScenario  Accelerating from an arbitrary initial state, with optional rotation 
►CActiveSetSolver  This class implements the active set algorithm for solving convex Programming problems 
CState  This struct contains the state information for a single iteration 
CAdaptAutoDiff  The AdaptAutoDiff class uses ceresstyle autodiff to adapt a ceresstyle Function evaluation, i.e., a function FUNCTOR that defines an operator template<typename T> bool operator()(const T* const, const T* const, T* predicted) const; For now only binary operators are supported 
Cadditive_group_tag  
CAHRS  
CAHRSFactor  
►CAlgebraicDecisionTree  Algebraic Decision Trees fix the range to double Just has some nice constructors and some syntactic sugar TODO: consider eliminating this class altogether? 
CRing  The Real ring with addition and multiplication 
CAllDiff  General AllDiff constraint Returns 1 if values for all keys are different, 0 otherwise DiscreteFactors are all awkward in that they have to store two types of keys: for each variable we have a Key and an Key 
CAntiFactor  
CAssignment  An assignment from labels to value index (size_t) 
CAttitudeFactor  
CBatchFixedLagSmoother  
CBayesNet  A BayesNet is a tree of conditionals, stored in elimination order 
CBayesTree  
CBayesTreeCliqueBase  This is the base class for BayesTree cliques 
CBayesTreeCliqueData  Store all the sizes 
CBayesTreeCliqueStats  Clique statistics 
CBayesTreeOrphanWrapper  
CBearing  
CBearing< Pose2, T >  
CBearing< Pose3, Point3 >  
CBearing< Pose3, Pose3 >  
CBearingFactor  
CBearingRange  BearingRange 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> 
CBearingRangeFactor  
CBearingS2  
CBetweenConstraint  Binary between constraint  forces between to a given value This constraint requires the underlying type to a Lie type 
CBetweenFactor  
CBetweenFactorEM  
CBiasedGPSFactor  
CBinaryAllDiff  Binary AllDiff constraint Returns 1 if values for two keys are different, 0 otherwise DiscreteFactors are all awkward in that they have to store two types of keys: for each variable we have a Index and an Index 
CBinaryJacobianFactor  A binary JacobianFactor specialization that uses fixed matrix math for speed 
CBinarySumExpression  A BinarySumExpression is a specialization of Expression that adds two expressions together It optimizes the Jacobian calculation for this specific case 
CBlockJacobiPreconditioner  
CBlockJacobiPreconditionerParameters  
CBoundingConstraint1  
CBoundingConstraint2  Binary scalar inequality constraint, with a similar value() function to implement for specific systems 
►CBTree  
Cconst_iterator  Const iterator Not trivial: iterator keeps a stack to indicate current path from root_ 
CCal3_S2  
CCal3_S2Stereo  
CCal3Bundler  
CCal3DS2  
CCal3DS2_Base  
CCal3Unified  
CCalibratedCamera  
CCameraProjectionMatrix  Create a 3*4 camera projection matrix from calibration and pose 
CCameraSet  A set of cameras, all with their own calibration 
CCGState  
CCheiralityException  
CCholeskyFailed  Indicate Cholesky factorization failure 
►CClusterTree  A clustertree is associated with a factor graph and is defined as in KollerFriedman: 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 \) 
CCluster  A Cluster is just a collection of factors 
CCombinedImuFactor  
Ccompose_key_visitor  
►CConcurrentBatchFilter  A LevenbergMarquardt Batch Filter that implements the Concurrent Filtering and Smoother interface 
CResult  Meta information returned about the update 
CConcurrentBatchFilterResult  
►CConcurrentBatchSmoother  A LevenbergMarquardt Batch Smoother that implements the Concurrent Filtering and Smoother interface 
CResult  Meta information returned about the update 
CConcurrentBatchSmootherResult  
CConcurrentFilter  The interface for the 'Filter' portion of the Concurrent Filtering and Smoother architecture 
►CConcurrentIncrementalFilter  An iSAM2based Batch Filter that implements the Concurrent Filtering and Smoother interface 
CResult  Meta information returned about the update 
►CConcurrentIncrementalSmoother  A LevenbergMarquardt Batch Smoother that implements the Concurrent Filtering and Smoother interface 
CResult  Meta information returned about the update 
CConcurrentMap  
CConcurrentSmoother  The interface for the 'Smoother' portion of the Concurrent Filtering and Smoother architecture 
CConditional  TODO: Update comments 
CConjugateGradientParameters  Parameters for the conjugate gradient method 
Cconst_selector  Helper class that uses templates to select between two types based on whether TEST_TYPE is const or not 
Cconst_selector< BASIC_TYPE, BASIC_TYPE, AS_NON_CONST, AS_CONST >  Specialization for the nonconst version 
Cconst_selector< const BASIC_TYPE, BASIC_TYPE, AS_NON_CONST, AS_CONST >  Specialization for the const version 
CConstantTwistScenario  Scenario with constant twist 3D trajectory 
CConstraint  Base class for discrete probabilistic factors The most general one is the derived DecisionTreeFactor 
►CConstructorTraversalData  
CSymbolicFactors  
CCRefCallAddCopy  Helper 
CCRefCallPushBack  Helper 
CCSP  Constraint Satisfaction Problem class A specialization of a DiscreteFactorGraph 
CCyclic  Cyclic group of order N 
►CDecisionTree  Decision Tree L = label for variables Y = function range (any algebra), e.g., bool, int, double 
CChoice  
CLeaf  
CNode  — Node base class — 
CDecisionTreeFactor  A discrete probabilistic factor 
CDeltaFactor  DeltaFactor: relative 2D measurement between Pose2 and Point2 
CDeltaFactorBase  DeltaFactorBase: relative 2D measurement between Pose2 and Point2, with Basenodes 
CDGroundConstraint  Ground constraint: forces the robot to be upright (no roll, pitch), a fixed height, and no velocity in z direction Dim: 4 
CDHeightPrior  Forces the value of the height in a PoseRTV to a specific value Dim: 1 
CDirectProduct  
CDirectSum  Template to construct the direct sum of two additive groups Assumes existence of three additive operators for both groups 
CDiscreteBayesNet  A Bayes net made from linearDiscrete densities 
CDiscreteBayesTree  A Bayes tree representing a Discrete density 
CDiscreteBayesTreeClique  A clique in a DiscreteBayesTree 
CDiscreteConditional  Discrete Conditional Density Derives from DecisionTreeFactor 
CDiscreteEliminationTree  
CDiscreteEulerPoincareHelicopter  Implement the Discrete EulerPoincare' equation: 
CDiscreteFactor  Base class for discrete probabilistic factors The most general one is the derived DecisionTreeFactor 
CDiscreteFactorGraph  A Discrete Factor Graph is a factor graph where all factors are Discrete, i.e 
CDiscreteJunctionTree  
CDiscreteKeys  DiscreteKeys is a set of keys that can be assembled using the & operator 
CDiscreteMarginals  A class for computing marginals of variables in a DiscreteFactorGraph 
CDoglegOptimizer  This class performs Dogleg nonlinear optimization 
►CDoglegOptimizerImpl  This class contains the implementation of the Dogleg algorithm 
CIterationResult  
CDoglegParams  Parameters for LevenbergMarquardt optimization 
CDomain  Domain restriction constraint 
CDRollPrior  Forces the roll to a particular value  useful for flying robots Implied value is zero Dim: 1 
CDSF  
CDSFBase  
►CDSFMap  
CEntry  We store the forest in an STL map, but parents are done with pointers 
CDSFVector  
CDummy  
CDummyFactor  
CDummyPreconditioner  
CDummyPreconditionerParameters  
CDynamicValuesMismatched  
CEliminatableClusterTree  A clustertree that eliminates to a Bayes tree 
CEliminateableFactorGraph  EliminateableFactorGraph is a base class for factor graphs that contains elimination algorithms 
►CEliminationData  
CEliminationPostOrderVisitor  
CEliminationTraits  Traits class for eliminateable factor graphs, specifies the types that result from elimination, etc 
CEliminationTraits< DiscreteFactorGraph >  
CEliminationTraits< GaussianFactorGraph >  
CEliminationTraits< SymbolicFactorGraph >  
►CEliminationTree  An elimination tree is a data structure used intermediately during elimination 
CNode  
CEqualityFactorGraph  Collection of all Linear Equality constraints Ax=b of a Programming problem as a Factor Graph 
Cequals  Template to create a binary predicate 
Cequals_star  Binary predicate on shared pointers 
CEquivInertialNavFactor_GlobalVel  
CEquivInertialNavFactor_GlobalVel_NoBias  
CErrors  Vector of errors 
CEssentialMatrix  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 
CEssentialMatrixConstraint  
CEssentialMatrixFactor  Factor that evaluates epipolar error p'Ep for given essential matrix 
CEssentialMatrixFactor2  Binary factor that optimizes for E and inverse depth d: assumes measurement in image 2 is perfect, and returns reprojection error in image 1 
CEssentialMatrixFactor3  Binary factor that optimizes for E and inverse depth d: assumes measurement in image 2 is perfect, and returns reprojection error in image 1 This version takes an extrinsic rotation to allow for omnidirectional rigs 
►CExpression  Expression class that supports automatic differentiation 
CBinaryFunction  
CTernaryFunction  
CUnaryFunction  
CExpressionFactor  Factor that supports arbitrary expressions via AD 
CExpressionFactor2  Binary specialization of ExpressionFactor meant as a base class for binary factors 
CExpressionFactorGraph  Factor graph that supports adding ExpressionFactors directly 
CExtendedKalmanFilter  This is a generic Extended Kalman Filter class implemented using nonlinear factors 
CFactor  This is the base class for all factor types 
CFactorGraph  A factor graph is a bipartite graph with factor nodes connected to variable nodes 
CFastList  
CFastMap  
CFastSet  
CFixedDimension  Give fixed size dimension of a type, fails at compile time if dynamic 
►CFixedLagSmoother  
CResult  Meta information returned about the update 
CFixedLagSmootherKeyTimestampMap  
CFixedLagSmootherKeyTimestampMapValue  
CFixedLagSmootherResult  
CFixedVector  Fixed size vectors  compatible with boost vectors, but with compiletype size checking 
CFullIMUFactor  Class that represents integrating IMU measurements over time for dynamic systems This factor has dimension 9, with a builtin constraint for velocity modeling 
CG_x1  Helper class that computes the derivative of f w.r.t 
CGaussianBayesNet  A Bayes net made from linearGaussian densities 
CGaussianBayesTree  A Bayes tree representing a Gaussian density 
CGaussianBayesTreeClique  A clique in a GaussianBayesTree 
CGaussianConditional  A conditional Gaussian functions as the node in a Bayes network It has a set of parents y,z, etc 
CGaussianDensity  A Gaussian density 
CGaussianEliminationTree  
CGaussianFactor  An abstract virtual base class for JacobianFactor and HessianFactor 
CGaussianFactorGraph  A Linear Factor Graph is a factor graph where all factors are Gaussian, i.e 
CGaussianFactorGraphSystem  System class needed for calling preconditionedConjugateGradient 
CGaussianISAM  
CGaussianJunctionTree  
CGaussMarkov1stOrderFactor  
CGaussNewtonOptimizer  This class performs GaussNewton nonlinear optimization 
CGaussNewtonParams  Parameters for GaussNewton optimization, inherits from NonlinearOptimizationParams 
CGeneralSFMFactor  
CGeneralSFMFactor2  Nonlinear factor for a constraint derived from a 2D measurement 
CGenericProjectionFactor  
CGenericStereoFactor  
CGenericValue  Wraps any type T so it can play as a Value 
CGPSFactor  
CGPSFactor2  
CGraphvizFormatting  Formatting options when saving in GraphViz format using NonlinearFactorGraph::saveGraph 
Cgroup_tag  Tag to assert a type is a group 
CHasBearing  
CHasRange  
CHasTestablePrereqs  Requirements on type to pass it to Testable template below 
CHessianFactor  A Gaussian factor using the canonical parameters (information form) 
CIMUFactor  Class that represents integrating IMU measurements over time for dynamic systems Templated to allow for different key types, but variables all assumed to be PoseRTV 
CImuFactor  
CImuFactor2  
CInconsistentEliminationRequested  An inference algorithm was called with inconsistent arguments 
CIncrementalFixedLagSmoother  This is a base class for the various HMF2 implementations 
CIndeterminantLinearSystemException  Thrown when a linear system is illposed 
CIndexPair  Small utility class for representing a wrappable pairs of ints 
CInequalityFactorGraph  Collection of all Linear Inequality constraints Axb <= 0 of a Programming problem as a Factor Graph 
CInertialNavFactor_GlobalVelocity  
CInfeasibleInitialValues  An exception indicating that the provided initial value is infeasible Also used to inzdicatethat the noise model dimension passed into a JacobianFactor has a different dimensionality than the factor 
CInfeasibleOrUnboundedProblem  
CInitializePose3  
CInvalidArgumentThreadsafe  Threadsafe invalid argument exception 
CInvalidDenseElimination  
CInvalidMatrixBlock  An exception indicating that a matrix block passed into a JacobianFactor has a different dimensionality than the factor 
CInvalidNoiseModel  An exception indicating that the noise model dimension passed into a JacobianFactor has a different dimensionality than the factor 
CInvDepthFactor3  Ternary factor representing a visual measurement that includes inverse depth 
CInvDepthFactorVariant1  Binary factor representing a visual measurement using an inversedepth parameterization 
CInvDepthFactorVariant2  Binary factor representing a visual measurement using an inversedepth parameterization 
CInvDepthFactorVariant3a  Binary factor representing the first visual measurement using an inversedepth parameterization 
CInvDepthFactorVariant3b  Ternary factor representing a visual measurement using an inversedepth parameterization 
CISAM  A Bayes tree with an update methods that implements the iSAM algorithm 
►CISAM2  
CPartialSolveResult  
CReorderingMode  
CISAM2Clique  Specialized Clique structure for ISAM2, incorporating caching and gradient contribution TODO: more documentation 
CISAM2DoglegParams  
CISAM2GaussNewtonParams  
CISAM2Params  
►CISAM2Result  
►CDetailedResults  A struct holding detailed results, which must be enabled with ISAM2Params::enableDetailedResults 
CVariableStatus  The status of a single variable, this struct is stored in DetailedResults::variableStatus 
CIsGroup  Group Concept 
CIsLieGroup  Lie Group Concept 
CIsTestable  
CIsVectorSpace  Vector Space concept 
CIterativeOptimizationParameters  Parameters for iterative linear solvers 
CIterativeSolver  Base class for Iterative Solvers like SubgraphSolver 
CJacobianFactor  A Gaussian factor in the squarederror form 
CJacobianFactorQ  JacobianFactor for Schur complement that uses Q noise model 
CJacobianFactorQR  JacobianFactor for Schur complement that uses Q noise model 
CJacobianFactorSVD  JacobianFactor for Schur complement that uses the "Nullspace Trick" by Mourikis 
CJointMarginal  A class to store and access a joint marginal, returned from Marginals::jointMarginalCovariance and Marginals::jointMarginalInformation 
CJunctionTree  
CKalmanFilter  Kalman Filter class 
CKeyInfo  Handy data structure for iterative solvers 
CKeyInfoEntry  Handy data structure for iterative solvers key to (index, dimension, start) 
CLabeledSymbol  Customized version of gtsam::Symbol for multirobot use 
CLevenbergMarquardtOptimizer  This class performs LevenbergMarquardt nonlinear optimization 
CLevenbergMarquardtParams  Parameters for LevenbergMarquardt optimization 
Clie_group_tag  Tag to assert a type is a Lie group 
CLieGroup  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 
CLinearContainerFactor  Dummy version of a generic linear factor to be injected into a nonlinear factor graph 
CLinearCost  This class defines a linear cost function c'x which is a JacobianFactor with only one row 
CLinearEquality  This class defines a linear equality constraints, inheriting JacobianFactor with the special Constrained noise model 
CLinearInequality  This class defines a linear inequality constraint Axb <= 0, inheriting JacobianFactor with the special Constrained noise model 
CLinearizedGaussianFactor  A base factor class for the Jacobian and Hessian linearized factors 
CLinearizedHessianFactor  A factor that takes a linear, Hessian factor and inserts it into a nonlinear graph 
CLinearizedJacobianFactor  A factor that takes a linear, Jacobian factor and inserts it into a nonlinear graph 
CListOfOneContainer  A helper class that behaves as a container with one element, and works with boost::range 
CLP  Data structure of a Linear Program 
CLPInitSolver  This LPInitSolver implements the strategy in Matlab: http://www.mathworks.com/help/optim/ug/linearprogrammingalgorithms.html#brozyzb9 Solve for x and y: min y st Ax = b Cx  y <= d where y \in R, x \in R^n, and Ax = b and Cx <= d is the constraints of the original problem 
CLPPolicy  Policy for ActivetSetSolver to solve Linear Programming 
CMagFactor  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 
CMagFactor1  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 
CMagFactor2  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 
CMagFactor3  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 
CMakeJacobian  : metafunction to generate Jacobian 
CMakeOptionalJacobian  : metafunction to generate JacobianTA optional reference Used mainly by Expressions 
Cmanifold_tag  Tag to assert a type is a manifold 
CManifoldPreintegration  IMU preintegration on NavSatet manifold 
CMarginalizeNonleafException  Thrown when requesting to marginalize out variables from ISAM2 that are not leaves 
CMarginals  A class for computing Gaussian marginals of variables in a NonlinearFactorGraph 
CMechanization_bRn2  
CMetisIndex  Converts a factor graph into the Compressed Sparse Row format for use in METIS algorithms 
Cmultiplicative_group_tag  Group operator syntax flavors 
CMultiplyWithInverse  Functor that implements multiplication of a vector b with the inverse of a matrix A 
CMultiplyWithInverseFunction  Functor that implements multiplication with the inverse of a matrix, itself the result of a function f 
CMultiProjectionFactor  
CNavState  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 
CNoiseModelFactor  A nonlinear sumofsquares factor with a zeromean noise model implementing the density \( P(zx) \propto exp 0.5*zh(x)^2_C \) Templated on the parameter type X and the values structure Values There is no return type specified for h(x) 
CNoiseModelFactor1  A convenient base class for creating your own NoiseModelFactor with 1 variable 
CNoiseModelFactor2  A convenient base class for creating your own NoiseModelFactor with 2 variables 
CNoiseModelFactor3  A convenient base class for creating your own NoiseModelFactor with 3 variables 
CNoiseModelFactor4  A convenient base class for creating your own NoiseModelFactor with 4 variables 
CNoiseModelFactor5  A convenient base class for creating your own NoiseModelFactor with 5 variables 
CNoiseModelFactor6  A convenient base class for creating your own NoiseModelFactor with 6 variables 
CNoMatchFoundForFixed  
►CNonlinearClusterTree  
CNonlinearCluster  
CNonlinearConjugateGradientOptimizer  An implementation of the nonlinear CG method using the template below 
CNonlinearEquality  An equality factor that forces either one variable to a constant, or a set of variables to be equal to each other 
CNonlinearEquality1  Simple unary equality constraint  fixes a value for a variable 
CNonlinearEquality2  Simple binary equality constraint  this constraint forces two factors to be the same 
CNonlinearFactor  Nonlinear factor base class 
CNonlinearFactorGraph  A nonlinear factor graph is a graph of nonGaussian, i.e 
CNonlinearISAM  Wrapper class to manage ISAM in a nonlinear context 
CNonlinearOptimizer  This is the abstract interface for classes that can optimize for the maximumlikelihood estimate of a NonlinearFactorGraph 
CNonlinearOptimizerParams  The common parameters for Nonlinear optimizers 
COdometryFactorBase  OdometryFactorBase: Pose2 odometry, with Basenodes 
COptionalJacobian  OptionalJacobian is an Eigen::Ref like class that can take be constructed using either a fixed size or dynamic Eigen matrix 
COptionalJacobian< Eigen::Dynamic, Eigen::Dynamic >  
COrdering  
Cordering_key_visitor  
COrientedPlane3  Represents an infinite plane in 3D, which is composed of a planar normal and its perpendicular distance to the origin 
COrientedPlane3DirectionPrior  
COrientedPlane3Factor  Factor to measure a planar landmark from a given pose 
COutOfRangeThreadsafe  Threadsafe out of range exception 
CPartialPriorFactor  A class for a soft partial prior on any Lie type, with a mask over Expmap parameters 
CPCGSolver  A virtual base class for the preconditioned conjugate gradient solver 
CPCGSolverParameters  Parameters for PCG 
CPendulumFactor1  This class implements the first constraint 
CPendulumFactor2  This class implements the second constraint the 
CPendulumFactorPk  This class implements the first positionmomentum update rule p_k = D_1 L_d(q_k,q_{k+1},h) = \frac{1}{h}mr^{2}\left(q_{k+1}q_{k}\right)+mgrh(1\alpha)\,\sin\left((1\alpha)q_{k}+\alpha q_{k+1}\right) = (1/h)mr^2 (q_{k+1}q_k) + mgrh(1alpha) sin ((1alpha)q_k+\alpha q_{k+1}) 
CPendulumFactorPk1  This class implements the second positionmomentum update rule p_k1 = D_2 L_d(q_k,q_{k+1},h) = \frac{1}{h}mr^{2}\left(q_{k+1}q_{k}\right)mgrh\alpha\sin\left((1\alpha)q_{k}+\alpha q_{k+1}\right) = (1/h)mr^2 (q_{k+1}q_k)  mgrh alpha sin ((1alpha)q_k+\alpha q_{k+1}) 
CPinholeBase  
CPinholeBaseK  
CPinholeCamera  
CPinholePose  
CPinholeSet  PinholeSet: triangulates point and keeps an estimate of it around 
CPoint2  
CPoint3  
►CPose2  
CChartAtOrigin  
►CPose3  
CChartAtOrigin  
CPose3AttitudeFactor  
CPose3Upright  
CPoseBetweenFactor  
CPoseConcept  Pose Concept A must contain a translation and a rotation, with each structure accessable directly and a type provided for each 
CPosePriorFactor  
CPoseRotationPrior  
CPoseRTV  Robot state for use with IMU measurements 
CPoseTranslationPrior  A prior on the translation part of a pose 
CPotentials  A base class for both DiscreteFactor and DiscreteConditional 
CPreconditioner  
CPreconditionerParameters  
CPredecessorMap  Map from variable key to parent key 
CPreintegratedAhrsMeasurements  PreintegratedAHRSMeasurements accumulates (integrates) the Gyroscope measurements (rotation rates) and the corresponding covariance matrix 
►CPreintegratedCombinedMeasurements  
CParams  Parameters for preintegration: Usage: Create just a single Params and pass a shared pointer to the constructor 
CPreintegratedImuMeasurements  
CPreintegratedRotation  PreintegratedRotation is the base class for all PreintegratedMeasurements classes (in AHRSFactor, ImuFactor, and CombinedImuFactor) 
CPreintegratedRotationParams  Parameters for preintegration: Usage: Create just a single Params and pass a shared pointer to the constructor 
CPreintegrationBase  PreintegrationBase is the base class for PreintegratedMeasurements (in ImuFactor) and CombinedPreintegratedMeasurements (in CombinedImuFactor) 
CPreintegrationParams  Parameters for preintegration: Usage: Create just a single Params and pass a shared pointer to the constructor 
CPriorFactor  
CProductLieGroup  Template to construct the product Lie group of two other Lie groups Assumes Lie group structure for G and H 
CProjectionFactorPPP  
CProjectionFactorPPPC  
CQP  Struct contains factor graphs of a Quadratic Programming problem 
CQPInitSolver  This class finds a feasible solution for a QP problem 
CQPPolicy  Policy for ActivetSetSolver to solve Linear Programming 
CQPSParser  
CQPSParserException  
CRange  
CRange< CalibratedCamera, T >  
CRange< PinholeCamera< Calibration >, T >  
CRange< Point3, Point3 >  
CRange< Pose2, T >  
CRange< Pose3, T >  
CRange< PoseRTV, PoseRTV >  
CRange< SimpleCamera, T >  
CRangeFactor  
CRangeFactorWithTransform  
CReconstruction  Implement the Reconstruction equation: \( g_{k+1} = g_k \exp (h\xi_k) \), where \( h \): timestep (parameter) \( g_{k+1}, g_{k} \): poses at the current and the next timestep \( \xi_k \): the bodyfixed velocity (Lie algebra) It is somewhat similar to BetweenFactor, but treats the bodyfixed velocity \( \xi_k \) as a variable 
CRedirectCout  For Python str() 
CRefCallPushBack  Helper 
CReferenceFrameFactor  A constraint between two landmarks in separate maps Templated on: Point : Type of landmark Transform : Transform variable class 
CRegularHessianFactor  
CRegularImplicitSchurFactor  RegularImplicitSchurFactor 
CRegularJacobianFactor  JacobianFactor with constant sized blocks Provides raw memory access versions of linear operator 
CRelativeElevationFactor  Binary factor for a relative elevation 
CReshape  Reshape functor 
CReshape< 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) 
CReshape< M, N, InOptions, M, N, InOptions >  Reshape specialization that does nothing as shape stays the same 
CReshape< N, M, InOptions, M, N, InOptions >  Reshape specialization that does transpose 
►CRot2  
CChartAtOrigin  
►CRot3  
CCayleyChart  
CChartAtOrigin  
CRot3AttitudeFactor  
CRotateDirectionsFactor  Factor on unknown rotation iRc that relates two directions c Directions provide less constraints than a full rotation 
CRotateFactor  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 
CRuntimeErrorThreadsafe  Threadsafe runtime error exception 
CSampler  Sampling structure that keeps internal random number generators for diagonal distributions specified by NoiseModel 
CScalarMultiplyExpression  A ScalarMultiplyExpression is a specialization of Expression that multiplies with a scalar It optimizes the Jacobian calculation for this specific case 
CScatter  Scatter is an intermediate data structure used when building a HessianFactor incrementally, to get the keys in the right order 
CScenario  Simple trajectory simulator 
CScenarioRunner  
CScheduler  Scheduler class Creates one variable for each student, and three variables for each of the student's areas, for a total of 4*nrStudents variables 
CSDGraph  SDGraph is undirected graph with variable keys and double edge weights 
CSfM_data  Define the structure for SfM data 
CSfM_Track  Define the structure for the 3D points 
CSGraph  
CSignature  Signature for a discrete conditional density, used to construct conditionals 
CSimpleCamera  
CSimPolygon2D  
CSimPolygon2DVector  
CSimWall2D  
CSimWall2DVector  
CSingleValue  SingleValue constraint 
CSlotEntry  One SlotEntry stores the slot index for a variable, as well its dim 
CSmartFactorBase  Base class for smart factors This base class has no internal point, but it has a measurement, noise model and an optional sensor pose 
CSmartProjectionFactor  SmartProjectionFactor: triangulates point and keeps an estimate of it around 
CSmartProjectionParams  
CSmartProjectionPoseFactor  
►CSmartRangeFactor  
CCircle2  
CSmartStereoProjectionFactor  SmartStereoProjectionFactor: triangulates point and keeps an estimate of it around 
CSmartStereoProjectionPoseFactor  
►CSO3  True SO(3), i.e., 3*3 matrix subgroup We guarantee (all but first) constructors only generate from submanifold 
CChartAtOrigin  
CStereoCamera  
CStereoCheiralityException  
CStereoPoint2  
►CSubgraph  
CEdge  
CSubgraphBuilder  
CSubgraphBuilderParameters  
CSubgraphPreconditioner  Subgraph conditioner class, as explained in the RSS 2010 submission 
CSubgraphPreconditionerParameters  
CSubgraphSolver  This class implements the linear SPCG solver presented in Dellaert et al in IROS'10 
CSubgraphSolverParameters  
CSymbol  Character and index key used to refer to variables 
CSymbolicBayesNet  Symbolic Bayes Net 
CSymbolicBayesTree  A Bayes tree that represents the connectivity between variables but is not associated with any probability functions 
CSymbolicBayesTreeClique  A clique in a SymbolicBayesTree 
CSymbolicConditional  SymbolicConditional is a conditional with keys but no probability data, produced by symbolic elimination of SymbolicFactor 
CSymbolicEliminationTree  
CSymbolicFactor  SymbolicFactor represents a symbolic factor that specifies graph topology but is not associated with any numerical function 
CSymbolicFactorGraph  Symbolic Factor Graph 
CSymbolicISAM  
CSymbolicJunctionTree  
CSymmetricBlockMatrix  
CSystem  Helper class encapsulating the combined system Axb_^2 Needed to run Conjugate Gradients on matrices 
CTangentPreintegration  Integrate on the 9D tangent space of the NavState manifold 
CTbbOpenMPMixedScope  An object whose scope defines a block where TBB and OpenMP parallelism are mixed 
CTestable  A helper that implements the traits interface for GTSAM types 
CThreadsafeException  Base exception type that uses tbb_exception if GTSAM is compiled with TBB 
CTOAFactor  A "Time of Arrival" factor  so little code seems hardly worth it :) 
Ctraits  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 
Ctraits< BearingFactor< A1, A2, T > >  Traits 
Ctraits< BearingRange< A1, A2 > >  
Ctraits< BearingRangeFactor< A1, A2, B, R > >  Traits 
Ctraits< BetweenConstraint< VALUE > >  Traits 
Ctraits< BetweenFactor< VALUE > >  Traits 
Ctraits< BinaryJacobianFactor< M, N1, N2 > >  
Ctraits< Cal3_S2 >  
Ctraits< Cal3_S2Stereo >  
Ctraits< Cal3Bundler >  
Ctraits< Cal3DS2 >  
Ctraits< Cal3Unified >  
Ctraits< CalibratedCamera >  
Ctraits< CameraSet< CAMERA > >  
Ctraits< ConcurrentBatchFilter >  Traits 
Ctraits< ConcurrentBatchSmoother >  Traits 
Ctraits< ConcurrentIncrementalFilter >  Traits 
Ctraits< ConcurrentIncrementalSmoother >  Traits 
Ctraits< const Cal3_S2 >  
Ctraits< const Cal3_S2Stereo >  
Ctraits< const Cal3Bundler >  
Ctraits< const Cal3DS2 >  
Ctraits< const Cal3Unified >  
Ctraits< const CalibratedCamera >  
Ctraits< const CameraSet< CAMERA > >  
Ctraits< const EssentialMatrix >  
Ctraits< const OrientedPlane3 >  
Ctraits< const PinholeCamera< Calibration > >  
Ctraits< const PinholePose< CALIBRATION > >  
Ctraits< const PinholeSet< CAMERA > >  
Ctraits< const Point3 >  
Ctraits< const Pose2 >  
Ctraits< const Pose3 >  
Ctraits< const Rot2 >  
Ctraits< const Rot3 >  
Ctraits< const SimpleCamera >  
Ctraits< const SO3 >  
Ctraits< const StereoCamera >  
Ctraits< const StereoPoint2 >  
Ctraits< const Unit3 >  
Ctraits< Cyclic< N > >  Define cyclic group to be a model of the Additive Group concept 
Ctraits< DecisionTreeFactor >  
Ctraits< DirectProduct< G, H > >  
Ctraits< DirectSum< G, H > >  
Ctraits< DiscreteBayesNet >  
Ctraits< DiscreteConditional >  
Ctraits< DiscreteFactor >  
Ctraits< DiscreteFactor::Values >  
Ctraits< DiscreteFactorGraph >  Traits 
Ctraits< double >  Double 
Ctraits< Eigen::Matrix< double, 1, 1, Options, MaxRows, MaxCols > >  
Ctraits< Eigen::Matrix< double, 1, 1, Options, MaxRows, MaxCols > >  
Ctraits< Eigen::Matrix< double, 1, 1, Options, MaxRows, MaxCols > >  
Ctraits< Eigen::Matrix< double, M, N, Options, MaxRows, MaxCols > >  
Ctraits< EqualityFactorGraph >  Traits 
Ctraits< Errors >  Traits 
Ctraits< EssentialMatrix >  
Ctraits< ExpressionFactor< T > >  Traits 
Ctraits< float >  Float 
Ctraits< GaussianBayesNet >  Traits 
Ctraits< GaussianBayesTree >  Traits 
Ctraits< GaussianConditional >  Traits 
Ctraits< GaussianFactor >  Traits 
Ctraits< GaussianFactorGraph >  Traits 
Ctraits< GaussMarkov1stOrderFactor< VALUE > >  Traits 
Ctraits< GeneralSFMFactor2< CALIBRATION > >  
Ctraits< GeneralSFMFactor< CAMERA, LANDMARK > >  
Ctraits< GenericProjectionFactor< POSE, LANDMARK, CALIBRATION > >  Traits 
Ctraits< GenericStereoFactor< T1, T2 > >  Traits 
Ctraits< GenericValue< ValueType > >  
Ctraits< HessianFactor >  Traits 
Ctraits< imuBias::ConstantBias >  
Ctraits< ImuFactor >  
Ctraits< ImuFactor2 >  
Ctraits< InequalityFactorGraph >  Traits 
Ctraits< InertialNavFactor_GlobalVelocity< POSE, VELOCITY, IMUBIAS > >  Traits 
Ctraits< ISAM2 >  Traits 
Ctraits< JacobianFactor >  Traits 
Ctraits< JacobianFactorQ< D, ZDim > >  
Ctraits< Key >  
Ctraits< LabeledSymbol >  Traits 
Ctraits< LinearContainerFactor >  
Ctraits< LinearCost >  Traits 
Ctraits< LinearEquality >  Traits 
Ctraits< LinearInequality >  Traits 
Ctraits< LinearizedHessianFactor >  Traits 
Ctraits< LinearizedJacobianFactor >  Traits 
Ctraits< LP >  Traits 
Ctraits< NavState >  
Ctraits< noiseModel::Constrained >  
Ctraits< noiseModel::Diagonal >  
Ctraits< noiseModel::Gaussian >  Traits 
Ctraits< noiseModel::Isotropic >  
Ctraits< noiseModel::Unit >  
Ctraits< NonlinearEquality1< VALUE > >  
Ctraits< NonlinearEquality2< VALUE > >  
Ctraits< NonlinearEquality< VALUE > >  
Ctraits< NonlinearFactor >  Traits 
Ctraits< NonlinearFactorGraph >  Traits 
Ctraits< Ordering >  Traits 
Ctraits< OrientedPlane3 >  
Ctraits< PinholeCamera< Calibration > >  
Ctraits< PinholePose< CALIBRATION > >  
Ctraits< PinholeSet< CAMERA > >  
Ctraits< Point2 >  
Ctraits< Point3 >  
Ctraits< Pose2 >  
Ctraits< Pose3 >  
Ctraits< Pose3AttitudeFactor >  Traits 
Ctraits< PoseRTV >  
Ctraits< Potentials >  
Ctraits< Potentials::ADT >  
Ctraits< PreintegratedImuMeasurements >  
Ctraits< PreintegratedRotation >  
Ctraits< ProductLieGroup< G, H > >  
Ctraits< ProjectionFactorPPP< POSE, LANDMARK, CALIBRATION > >  Traits 
Ctraits< ProjectionFactorPPPC< POSE, LANDMARK, CALIBRATION > >  Traits 
Ctraits< QUATERNION_TYPE >  
Ctraits< RangeFactor< A1, A2, T > >  Traits 
Ctraits< RangeFactorWithTransform< A1, A2, T > >  Traits 
Ctraits< ReferenceFrameFactor< T1, T2 > >  Traits 
Ctraits< RegularHessianFactor< D > >  
Ctraits< RegularImplicitSchurFactor< CAMERA > >  
Ctraits< Rot2 >  
Ctraits< Rot3 >  
Ctraits< Rot3AttitudeFactor >  Traits 
Ctraits< SimpleCamera >  
Ctraits< SmartProjectionFactor< CAMERA > >  Traits 
Ctraits< SmartProjectionPoseFactor< CALIBRATION > >  Traits 
Ctraits< SmartStereoProjectionFactor >  Traits 
Ctraits< SmartStereoProjectionPoseFactor >  Traits 
Ctraits< SO3 >  
Ctraits< StereoCamera >  
Ctraits< StereoPoint2 >  
Ctraits< Symbol >  Traits 
Ctraits< SymbolicBayesNet >  Traits 
Ctraits< SymbolicBayesTree >  
Ctraits< SymbolicBayesTreeClique >  Traits 
Ctraits< SymbolicConditional >  Traits 
Ctraits< SymbolicEliminationTree >  Traits 
Ctraits< SymbolicFactor >  Traits 
Ctraits< SymbolicFactorGraph >  Traits 
Ctraits< TransformBtwRobotsUnaryFactor< VALUE > >  Traits 
Ctraits< TransformBtwRobotsUnaryFactorEM< VALUE > >  Traits 
Ctraits< Unit3 >  
Ctraits< Values >  Traits 
Ctraits< VariableIndex >  Traits 
Ctraits< VariableSlots >  Traits 
Ctraits< VectorValues >  Traits 
CTransformBtwRobotsUnaryFactor  
CTransformBtwRobotsUnaryFactorEM  
CTriangulationCheiralityException  Exception thrown by triangulateDLT when landmark is behind one or more of the cameras 
CTriangulationFactor  
CTriangulationParameters  
CTriangulationResult  TriangulationResult is an optional point, along with the reasons why it is invalid 
CTriangulationUnderconstrainedException  Exception thrown by triangulateDLT when SVD returns rank < 3 
CUnit3  Represents a 3D point on a unit sphere 
CValue  This is the base class for any type to be stored in Values 
CValueCloneAllocator  
►CValues  A nontemplated config holding any types of Manifoldgroup elements 
CConstFiltered  A filtered view of a const Values, returned from Values::filter 
CConstKeyValuePair  A keyvalue pair, which you get by dereferencing iterators 
CFiltered  A filtered view of a Values, returned from Values::filter 
CKeyValuePair  A keyvalue pair, which you get by dereferencing iterators 
CValuesCastHelper  
CValuesCastHelper< const Value, CastedKeyValuePairType, KeyValuePairType >  
CValuesCastHelper< Value, CastedKeyValuePairType, KeyValuePairType >  
CValuesIncorrectType  
CValuesKeyAlreadyExists  
CValuesKeyDoesNotExist  
CValueWithDefault  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 
CVariableIndex  Computes and stores the block column structure of a factor graph 
CVariableSlots  A combined factor is assembled as one block of rows for each component factor 
Cvector_space_tag  Tag to assert a type is a vector space 
CVectorValues  This class represents a collection of vectorvalued variables associated each with a unique integer index 
CVelocityConstraint  Constraint to enforce dynamics between the velocities and poses, using a prediction based on a numerical integration flag 
CVelocityConstraint3  
CVelocityPrior  Constrains the full velocity of a state to a particular value Useful for enforcing a stationary state Dim: 3 
CVerticalBlockMatrix  
CWhiteNoiseFactor  Binary factor to estimate parameters of zeromean Gaussian white noise 