gtsam 4.1.1
gtsam

►Ngtsam  Global functions in a separate testing namespace 
Ndynamics  
►NimuBias  All bias models live in the imuBias namespace 
CConstantBias  
Ninference  
►Ninternal  
►NlinearAlgorithms  
COptimizeClique  Preorder visitor for backsubstitution in a Bayes tree 
COptimizeData  
Capply_compose  
Capply_compose< double >  
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  
CGetDimensionImpl  Extra manifold traits for fixeddimension types 
CGetDimensionImpl< Class, Eigen::Dynamic >  Extra manifold traits for variabledimension types 
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 
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 should behave as Gaussian 
CTukey  Tukey implements the "Tukey" robust error model (Zhang97ivc) 
CWelsch  Welsch implements the "Welsch" 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 
Ntesting  
NtreeTraversal  Internal functions used for traversing trees 
Nutilities  
C_ValuesConstKeyValuePair  
C_ValuesKeyValuePair  
CAcceleratedPowerMethod  Compute maximum Eigenpair with accelerated power method 
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  
►CBasis  CRTP Base class for function bases 
CComponentDerivativeFunctor  Given a M*N Matrix of Mvectors at N polynomial points, an instance of ComponentDerivativeFunctor computes the Nvector derivative for a specific row component of the Mvectors at all the polynomial points 
CDerivativeFunctor  An instance of a DerivativeFunctor calculates f'(x;p) at a given x , applied to Parameters p 
CDerivativeFunctorBase  Base class for functors below that calculate derivative weights 
CEvaluationFunctor  An instance of an EvaluationFunctor calculates f(x;p) at a given x , applied to Parameters p 
CManifoldEvaluationFunctor  Manifold EvaluationFunctor at a given x, applied to ParameterMatrix<M> 
CVectorComponentFunctor  Given a M*N Matrix of Mvectors at N polynomial points, an instance of VectorComponentFunctor computes the Nvector value for a specific row component of the Mvectors at all the polynomial points 
CVectorDerivativeFunctor  VectorDerivativeFunctor at a given x, applied to ParameterMatrix<M> 
CVectorEvaluationFunctor  VectorEvaluationFunctor at a given x, applied to ParameterMatrix<M> 
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  
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 
CBinaryMeasurement  
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  
CCal3_S2  
CCal3_S2Stereo  
CCal3Bundler  
CCal3DS2  
CCal3DS2_Base  
CCal3Fisheye  
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  
CChebyshev1Basis  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 
CChebyshev2  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 
CChebyshev2Basis  Basis of Chebyshev polynomials of the second kind 
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  
CComponentDerivativeFactor  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 vectorvalued measurement z 
Ccompose_key_visitor  
►CConcurrentBatchFilter  A LevenbergMarquardt Batch Filter that implements the Concurrent Filtering and Smoother interface 
CResult  Meta information returned about the update 
►CConcurrentBatchSmoother  A LevenbergMarquardt Batch Smoother that implements the Concurrent Filtering and Smoother interface 
CResult  Meta information returned about the update 
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 
CConstantVelocityFactor  Binary factor for applying a constant velocity model to a moving body represented as a NavState 
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 
CCustomFactor  
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 
►CDeltaImpl  
CPartialSolveResult  
CReorderingMode  
CDerivativeFactor  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 
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 (z) in a PoseRTV to a specific value 
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 
CEssentialMatrixFactor4  Binary factor that optimizes for E and calibration K using the algebraic epipolar error (K^1 pA)'E (K^1 pB) 
CEvaluationFactor  Factor for enforcing the scalar value of the polynomial BASIS representation at x is the same as the measurement z when using a pseudospectral parameterization 
►CExpression  Expression class that supports automatic differentiation 
CBinaryFunction  
CTernaryFunction  
CUnaryFunction  
CExpressionFactor  Factor that supports arbitrary expressions via AD 
CExpressionFactorGraph  Factor graph that supports adding ExpressionFactors directly 
CExpressionFactorN  Nary variadic template for ExpressionFactor meant as a base class for Nary factors 
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  
CFitBasis  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(); 
CFixedDimension  Give fixed size dimension of a type, fails at compile time if dynamic 
►CFixedLagSmoother  
CResult  Meta information returned about the update 
CFixedVector  Fixed size vectors  compatible with boost vectors, but with compiletype size checking 
CFourierBasis  Fourier basis 
CFrobeniusBetweenFactor  FrobeniusBetweenFactor is a BetweenFactor that evaluates the Frobenius norm of the rotation error between measured and predicted (rather than the Logmap of the error) 
CFrobeniusFactor  FrobeniusFactor calculates the Frobenius norm between rotation matrices 
CFrobeniusPrior  FrobeniusPrior calculates the Frobenius norm between a given matrix and an element of SO(3) or SO(4) 
CFullIMUFactor  Class that represents integrating IMU measurements over time for dynamic systems This factor has dimension 9, with a builtin constraint for velocity modeling 
CFunctorizedFactor  Factor which evaluates provided unary functor and uses the result to compute error with respect to the provided measurement 
CFunctorizedFactor2  Factor which evaluates provided binary functor and uses the result to compute error with respect to the provided measurement 
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 
CGncOptimizer  
CGncParams  
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  
CISAM2BayesTree  
CISAM2Clique  Specialized Clique structure for ISAM2, incorporating caching and gradient contribution TODO: more documentation 
CISAM2DoglegParams  
CISAM2GaussNewtonParams  
CISAM2JunctionTree  
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 
CISAM2UpdateParams  
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 et al 
CJointMarginal  A class to store and access a joint marginal, returned from Marginals::jointMarginalCovariance and Marginals::jointMarginalInformation 
CJunctionTree  
CKalmanFilter  Kalman Filter class 
CKarcherMeanFactor  The KarcherMeanFactor creates a constraint on all SO(n) variables with given keys that the Karcher mean (see above) will stay the same 
Ckey_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 
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 
CLine3  
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 
CLocalOrientedPlane3Factor  Factor to measure a planar landmark from a given pose, with a given local linearization point 
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 
CMagPoseFactor  Factor to estimate rotation of a Pose2 or Pose3 given a magnetometer reading 
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 
CManifoldEvaluationFactor  For a measurement value of type T i.e 
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 
CMFAS  
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 
Cneeds_eigen_aligned_allocator  A SFINAE trait to mark classes that need special alignment 
Cneeds_eigen_aligned_allocator< T, void_t< typename T::_eigen_aligned_allocator_trait > >  
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 variables 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 
CParameterMatrix  A matrix abstraction of MxN values at the Basis points 
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 
►CPose2  
CChartAtOrigin  
►CPose3  
CChartAtOrigin  
CPose3AttitudeFactor  
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 
CPoseToPointFactor  
CPoseTranslationPrior  A prior on the translation part of a pose 
CPotentials  A base class for both DiscreteFactor and DiscreteConditional 
CPowerMethod  Compute maximum Eigenpair with power method 
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  
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) 
CPreintegrationCombinedParams  Parameters for preintegration using PreintegratedCombinedMeasurements: Usage: Create just a single Params and pass a shared pointer to the constructor 
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  
CProjectionFactorRollingShutter  
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< Point2, Point2 >  
CRange< Point3, Point3 >  
CRange< Pose2, T >  
CRange< Pose3, T >  
CRange< PoseRTV, PoseRTV >  
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 
CSfmData  Define the structure for SfM data 
CSfmTrack  Define the structure for the 3D points 
CSGraph  
CShonanAveraging  Class that implements Shonan Averaging from our ECCV'20 paper 
CShonanAveraging2  
CShonanAveraging3  
CShonanAveragingParameters  Parameters governing optimization etc 
CShonanFactor  ShonanFactor is a BetweenFactor that moves in SO(p), but will land on the SO(d) submanifold of SO(p) at the global minimum 
CShonanGaugeFactor  The ShonanGaugeFactor creates a constraint on a single SO(n) to avoid moving in the stabilizer 
CSignature  Signature for a discrete conditional density, used to construct conditionals 
►CSimilarity3  3D similarity transform 
CChartAtOrigin  Chart at the origin 
CSingleValue  SingleValue constraint 
CSlotEntry  One SlotEntry stores the slot index for a variable, as well its dim 
CSmartFactorBase  Base class for smart factors 
CSmartProjectionFactor  SmartProjectionFactor: triangulates point and keeps an estimate of it around 
CSmartProjectionParams  
CSmartProjectionPoseFactor  
CSmartProjectionPoseFactorRollingShutter  
CSmartProjectionRigFactor  
►CSmartRangeFactor  
CCircle2  
CSmartStereoProjectionFactor  SmartStereoProjectionFactor: triangulates point and keeps an estimate of it around 
CSmartStereoProjectionFactorPP  
CSmartStereoProjectionPoseFactor  
►CSO  Manifold of special orthogonal rotation matrices SO<N> 
CChartAtOrigin  
CStereoCamera  
CStereoCheiralityException  
CStereoPoint2  
CStreamedKey  To use the key_formatter on Keys, they must be wrapped in a StreamedKey 
►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 
CSymbolGenerator  Generates symbol shorthands with alternative names different than the oneletter predefined ones 
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_allocator 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< Cal3Fisheye >  
Ctraits< Cal3Unified >  
Ctraits< CalibratedCamera >  
Ctraits< CameraSet< CAMERA > >  
Ctraits< CombinedImuFactor >  
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 Cal3Fisheye >  
Ctraits< const Cal3Unified >  
Ctraits< const CalibratedCamera >  
Ctraits< const CameraSet< CAMERA > >  
Ctraits< const EssentialMatrix >  
Ctraits< const Line3 >  
Ctraits< const OrientedPlane3 >  
Ctraits< const PinholeCamera< Calibration > >  
Ctraits< const PinholePose< CALIBRATION > >  
Ctraits< const PinholeSet< CAMERA > >  
Ctraits< const Pose2 >  
Ctraits< const Pose3 >  
Ctraits< const Rot2 >  
Ctraits< const Rot3 >  
Ctraits< const Similarity3 >  
Ctraits< const SO3 >  
Ctraits< const SO4 >  
Ctraits< const SO< N > >  
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< ExpressionFactorN< T, Args... > >  Traits 
Ctraits< float >  Float 
Ctraits< FunctorizedFactor2< R, T1, T2 > >  Traits 
Ctraits< FunctorizedFactor< R, T > >  Traits 
Ctraits< GaussianBayesNet >  Traits 
Ctraits< GaussianBayesTree >  Traits 
Ctraits< GaussianConditional >  Traits 
Ctraits< GaussianFactor >  Traits 
Ctraits< GaussianFactorGraph >  Traits 
Ctraits< GaussianISAM >  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< Line3 >  
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< ParameterMatrix< M > >  
Ctraits< PinholeCamera< Calibration > >  
Ctraits< PinholePose< CALIBRATION > >  
Ctraits< PinholeSet< CAMERA > >  
Ctraits< Pose2 >  
Ctraits< Pose3 >  
Ctraits< Pose3AttitudeFactor >  Traits 
Ctraits< PoseRTV >  
Ctraits< Potentials >  
Ctraits< Potentials::ADT >  
Ctraits< PreintegratedCombinedMeasurements >  
Ctraits< PreintegratedImuMeasurements >  
Ctraits< PreintegratedRotation >  
Ctraits< PreintegrationCombinedParams >  
Ctraits< PriorFactor< VALUE > >  Traits 
Ctraits< ProductLieGroup< G, H > >  
Ctraits< ProjectionFactorPPP< POSE, LANDMARK, CALIBRATION > >  Traits 
Ctraits< ProjectionFactorPPPC< POSE, LANDMARK, CALIBRATION > >  Traits 
Ctraits< ProjectionFactorRollingShutter >  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< SfmData >  Traits 
Ctraits< SfmTrack >  Traits 
Ctraits< Similarity3 >  
Ctraits< SmartProjectionFactor< CAMERA > >  Traits 
Ctraits< SmartProjectionPoseFactor< CALIBRATION > >  Traits 
Ctraits< SmartProjectionPoseFactorRollingShutter< CAMERA > >  Traits 
Ctraits< SmartProjectionRigFactor< CAMERA > >  Traits 
Ctraits< SmartStereoProjectionFactor >  Traits 
Ctraits< SmartStereoProjectionFactorPP >  Traits 
Ctraits< SmartStereoProjectionPoseFactor >  Traits 
Ctraits< SO3 >  
Ctraits< SO4 >  
Ctraits< SO< N > >  
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  
CTransformCovariance  Functor for transforming covariance of T 
CTranslationFactor  
CTranslationRecovery  
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 
CUpdateImpl  Implementation functions for update method All of the methods below have clear inputs and outputs, even if not functional: iSAM2 is inherintly imperative 
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 
CVectorComponentFactor  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 pseudospectral parameterization 
CVectorDerivativeFactor  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 
CVectorEvaluationFactor  Unary factor for enforcing BASIS polynomial evaluation on a ParameterMatrix of size (M, N) is equal to a vectorvalued measurement at the same point, when using a pseudospectral parameterization 
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  
CWeightedSampler  
CWhiteNoiseFactor  Binary factor to estimate parameters of zeromean Gaussian white noise 