|
gtsam
4.0.0
gtsam
|
|
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 | Pre-order visitor for back-substitution 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 fixed-dimension types |
| CManifoldImpl< Class, Eigen::Dynamic > | Extra manifold traits for variable-dimension 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 "Geman-McClure" 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 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 |
| 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 ceres-style autodiff to adapt a ceres-style 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 | 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> |
| 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 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 \) |
| CCluster | A Cluster is just a collection of factors |
| CCombinedImuFactor | |
| Ccompose_key_visitor | |
| ►CConcurrentBatchFilter | A Levenberg-Marquardt Batch Filter that implements the Concurrent Filtering and Smoother interface |
| CResult | Meta information returned about the update |
| CConcurrentBatchFilterResult | |
| ►CConcurrentBatchSmoother | A Levenberg-Marquardt 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 iSAM2-based Batch Filter that implements the Concurrent Filtering and Smoother interface |
| CResult | Meta information returned about the update |
| ►CConcurrentIncrementalSmoother | A Levenberg-Marquardt 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 non-const 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 linear-Discrete 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 Euler-Poincare' 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 Levenberg-Marquardt 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 cluster-tree 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 re-projection error in image 1 |
| CEssentialMatrixFactor3 | 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 |
| ►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 compile-type size checking |
| CFullIMUFactor | Class that represents integrating IMU measurements over time for dynamic systems This factor has dimension 9, with a built-in constraint for velocity modeling |
| CG_x1 | Helper class that computes the derivative of f w.r.t |
| CGaussianBayesNet | A Bayes net made from linear-Gaussian 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 Gauss-Newton nonlinear optimization |
| CGaussNewtonParams | Parameters for Gauss-Newton optimization, inherits from NonlinearOptimizationParams |
| CGeneralSFMFactor | |
| CGeneralSFMFactor2 | Non-linear 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 ill-posed |
| CIndexPair | Small utility class for representing a wrappable pairs of ints |
| CInequalityFactorGraph | Collection of all Linear Inequality constraints Ax-b <= 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 | Thread-safe 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 inverse-depth parameterization |
| CInvDepthFactorVariant2 | Binary factor representing a visual measurement using an inverse-depth parameterization |
| CInvDepthFactorVariant3a | Binary factor representing the first visual measurement using an inverse-depth parameterization |
| CInvDepthFactorVariant3b | Ternary factor representing a visual measurement using an inverse-depth 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 squared-error 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 multi-robot use |
| CLevenbergMarquardtOptimizer | This class performs Levenberg-Marquardt nonlinear optimization |
| CLevenbergMarquardtParams | Parameters for Levenberg-Marquardt 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 Ax-b <= 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/linear-programming-algorithms.html#brozyzb-9 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 | : meta-function to generate Jacobian |
| CMakeOptionalJacobian | : meta-function to generate JacobianTA optional reference Used mainly by Expressions |
| Cmanifold_tag | Tag to assert a type is a manifold |
| CManifoldPreintegration | IMU pre-integration 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 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) |
| 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 non-linear factor graph is a graph of non-Gaussian, 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 maximum-likelihood 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 | Thread-safe 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 position-momentum 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(1-alpha) sin ((1-alpha)q_k+\alpha q_{k+1}) |
| CPendulumFactorPk1 | This class implements the second position-momentum 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 ((1-alpha)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 pre-integration: 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 pre-integration: 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 pre-integration: 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 body-fixed velocity (Lie algebra) It is somewhat similar to BetweenFactor, but treats the body-fixed 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 | Thread-safe 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 sub-manifold |
| 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 |Ax-b_|^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 non-templated config holding any types of Manifold-group elements |
| CConstFiltered | A filtered view of a const Values, returned from Values::filter |
| CConstKeyValuePair | A key-value pair, which you get by dereferencing iterators |
| CFiltered | A filtered view of a Values, returned from Values::filter |
| CKeyValuePair | A key-value 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 vector-valued 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 zero-mean Gaussian white noise |
1.8.15 
