- Generated on for gtsam by
1.16.1
|
gtsam 4.2
gtsam
|
| Nboost | |
| Nmp11 | |
| Ndetail | |
| C_merge_and_renumber | |
| C_merge_and_renumber< index_sequence< I1... >, index_sequence< I2... > > | |
| Cindex_sequence | |
| Cmake_index_sequence | |
| Cmake_index_sequence< 0 > | |
| Cmake_index_sequence< 1 > | |
| Ngtsam | Global functions in a separate testing namespace |
| Ninternal | |
| NlinearAlgorithms | |
| COptimizeData | |
| COptimizeClique | Pre-order visitor for back-substitution in a Bayes tree |
| CFastDefaultAllocator | Default allocator for list, map, and set types |
| CFastDefaultVectorAllocator | Default allocator for vector types (we never use boost pool for vectors) |
| CLieGroupTraits | A helper class that implements the traits interface for GTSAM lie groups |
| CLieGroup | Both LieGroupTraits and Testable |
| CHasManifoldPrereqs | Requirements on type to pass it to Manifold template below |
| CGetDimensionImpl | Extra manifold traits for fixed-dimension types |
| CGetDimensionImpl< Class, Eigen::Dynamic > | Extra manifold traits for variable-dimension types |
| CManifoldTraits | A helper that implements the traits interface for GTSAM manifolds |
| CManifold | Both ManifoldTraits and Testable |
| CFixedSizeMatrix | |
| CTimingOutline | Timing Entry, arranged in a tree |
| CAutoTicToc | Small class that calls internal::tic at construction, and internol::toc when destroyed |
| CVectorSpaceImpl | VectorSpaceTraits Implementation for Fixed sizes |
| CVectorSpaceImpl< Class, Eigen::Dynamic > | VectorSpaceTraits implementation for dynamic types |
| CHasVectorSpacePrereqs | Requirements on type to pass it to Manifold template below |
| 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 |
| CVectorSpace | VectorSpace provides both Testable and VectorSpaceTraits |
| CScalarTraits | A helper that implements the traits interface for scalar vector spaces |
| CDynamicTraits | |
| Capply_compose | |
| Capply_compose< double > | |
| CExecutionTrace | |
| CExpressionNode | |
| Chandle | |
| Chandle_matrix | |
| Chandle_matrix< Eigen::Matrix< double, M, N >, true > | |
| Chandle_matrix< Eigen::Matrix< double, M, N >, false > | |
| Chandle< Eigen::Matrix< double, M, N > > | |
| Nso3 | |
| CExpmapFunctor | Functor implementing Exponential map |
| CDexpFunctor | Functor that implements Exponential map and its derivatives |
| NnoiseModel | All noise models live in the noiseModel namespace |
| NmEstimator | The mEstimator name space contains all robust error functions |
| CBase | Pure virtual class for all robust error function classes |
| CNull | "Null" robust loss function, equivalent to a Gaussian pdf noise model, or plain least-squares (non-robust) |
| CFair | Implementation of the "Fair" robust error model (Zhang97ivc) |
| CHuber | The "Huber" robust error model (Zhang97ivc) |
| CCauchy | Implementation of the "Cauchy" robust error model (Lee2013IROS) |
| CTukey | Implementation of the "Tukey" robust error model (Zhang97ivc) |
| CWelsch | Implementation of the "Welsch" robust error model (Zhang97ivc) |
| CGemanMcClure | Implementation of the "Geman-McClure" robust error model (Zhang97ivc) |
| CDCS | DCS implements the Dynamic Covariance Scaling robust error model from the paper Robust Map Optimization (Agarwal13icra) |
| CL2WithDeadZone | L2WithDeadZone implements a standard L2 penalty, but with a dead zone of width 2*k, centered at the origin |
| CBase | NoiseModel::Base is the abstract base class for all noise models |
| 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 |
| CDiagonal | A diagonal noise model implements a diagonal covariance matrix, with the elements of the diagonal specified in a Vector |
| 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 |
| CIsotropic | An isotropic noise model corresponds to a scaled diagonal covariance To construct, use one of the static methods |
| CUnit | Unit: i.i.d |
| 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 |
| NimuBias | All bias models live in the imuBias namespace |
| CConstantBias | |
| Ndetail | |
| CNoiseModelFactorAliases | Convenience base class to add aliases X1, X2, ..., X6 -> ValueType<N> |
| CNoiseModelFactorAliases< T1 > | |
| CNoiseModelFactorAliases< T1, T2 > | |
| CNoiseModelFactorAliases< T1, T2, T3 > | |
| CNoiseModelFactorAliases< T1, T2, T3, T4 > | |
| CNoiseModelFactorAliases< T1, T2, T3, T4, T5 > | |
| CNoiseModelFactorAliases< T1, T2, T3, T4, T5, T6, TExtra... > | |
| Ngtsfm | |
| CKeypoints | |
| Npartition | |
| CMetisResult | Metis Nest dissection result |
| CGenericNode2D | Index of the node and the type of the node |
| CGenericFactor2D | Factor always involves two nodes/variables for now |
| CGenericNode3D | Index of the node and the type of the node |
| CGenericFactor3D | Factor always involves two nodes/variables for now |
| CGenericUnaryFactor | Factor involves a single variable |
| CNestedDissection | Apply nested dissection algorithm to nonlinear factor graphs |
| CWorkSpace | |
| CCuts | |
| 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 |
| CConcurrentMap | FastMap is a thin wrapper around std::map that uses the boost fast_pool_allocator instead of the default STL allocator |
| CDSFMap | Disjoint set forest using an STL map data structure underneath Uses rank compression and union by rank, iterator version |
| CEntry | We store the forest in an STL map, but parents are done with pointers |
| CIndexPair | Small utility class for representing a wrappable pairs of ints |
| CDSFBase | A fast implementation of disjoint set forests that uses vector as underly data structure |
| CDSFVector | DSFVector additionally keeps a vector of keys to support more expensive operations |
| CFastList | FastList is a thin wrapper around std::list that uses the boost fast_pool_allocator instead of the default STL allocator |
| CFastMap | FastMap is a thin wrapper around std::map that uses the boost fast_pool_allocator instead of the default STL allocator |
| CFastSet | FastSet is a thin wrapper around std::set that uses the boost fast_pool_allocator instead of the default STL allocator |
| CGenericValue | Wraps any type T so it can play as a Value |
| Ctraits< GenericValue< ValueType > > | |
| Cgroup_tag | Tag to assert a type is a group |
| Cmultiplicative_group_tag | Group operator syntax flavors |
| Cadditive_group_tag | |
| CIsGroup | Group Concept |
| CDirectProduct | |
| Ctraits< DirectProduct< G, H > > | |
| CDirectSum | Template to construct the direct sum of two additive groups Assumes existence of three additive operators for both groups |
| Ctraits< DirectSum< G, H > > | |
| 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 |
| Clie_group_tag | Tag to assert a type is a Lie group |
| CIsLieGroup | Lie Group Concept |
| CTransformCovariance | Functor for transforming covariance of T |
| Cmanifold_tag | Tag to assert a type is a manifold |
| CFixedDimension | Give fixed size dimension of a type, fails at compile time if dynamic |
| 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 |
| 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 |
| CG_x1 | Helper class that computes the derivative of f w.r.t |
| 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 > | |
| CMakeJacobian | : meta-function to generate Jacobian |
| CMakeOptionalJacobian | : meta-function to generate JacobianTA optional reference Used mainly by Expressions |
| CProductLieGroup | Template to construct the product Lie group of two other Lie groups Assumes Lie group structure for G and H |
| Ctraits< ProductLieGroup< G, H > > | |
| CSymmetricBlockMatrix | This class stores a dense matrix and allows it to be accessed as a collection of blocks |
| CIsTestable | A testable concept check that should be placed in applicable unit tests and in generic algorithms |
| Cequals | Template to create a binary predicate |
| Cequals_star | Binary predicate on shared pointers |
| CHasTestablePrereqs | Requirements on type to pass it to Testable template below |
| 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 |
| CRuntimeErrorThreadsafe | Thread-safe runtime error exception |
| COutOfRangeThreadsafe | Thread-safe out of range exception |
| CInvalidArgumentThreadsafe | Thread-safe invalid argument exception |
| CCholeskyFailed | Indicate Cholesky factorization failure |
| 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 |
| 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 |
| CListOfOneContainer | A helper class that behaves as a container with one element, and works with boost::range |
| CTbbOpenMPMixedScope | An object whose scope defines a block where TBB and OpenMP parallelism are mixed |
| 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 > > | |
| CRedirectCout | For Python str() |
| CValue | This is the base class for any type to be stored in Values |
| Cvector_space_tag | Tag to assert a type is a vector space |
| Ctraits< double > | Double |
| Ctraits< float > | Float |
| Ctraits< Eigen::Matrix< double, M, N, 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, 1, -1, Options, MaxRows, MaxCols > > | |
| CIsVectorSpace | Vector Space concept |
| CVerticalBlockMatrix | This class stores a dense matrix and allows it to be accessed as a collection of vertical blocks |
| CWeightedSampler | |
| CBasis | CRTP Base class for function bases |
| CEvaluationFunctor | An instance of an EvaluationFunctor calculates f(x;p) at a given x, applied to Parameters p |
| CVectorEvaluationFunctor | VectorEvaluationFunctor at a given x, applied to ParameterMatrix<M> |
| CVectorComponentFunctor | Given a M*N Matrix of M-vectors at N polynomial points, an instance of VectorComponentFunctor computes the N-vector value for a specific row component of the M-vectors at all the polynomial points |
| CManifoldEvaluationFunctor | Manifold EvaluationFunctor at a given x, applied to ParameterMatrix<M> |
| CDerivativeFunctorBase | Base class for functors below that calculate derivative weights |
| CDerivativeFunctor | An instance of a DerivativeFunctor calculates f'(x;p) at a given x, applied to Parameters p |
| CVectorDerivativeFunctor | VectorDerivativeFunctor at a given x, applied to ParameterMatrix<M> |
| CComponentDerivativeFunctor | Given a M*N Matrix of M-vectors at N polynomial points, an instance of ComponentDerivativeFunctor computes the N-vector derivative for a specific row component of the M-vectors at all the polynomial points |
| CEvaluationFactor | Factor for enforcing the scalar value of the polynomial BASIS representation at x is the same as the measurement z when using a pseudo-spectral parameterization |
| CVectorEvaluationFactor | Unary factor for enforcing BASIS polynomial evaluation on a ParameterMatrix of size (M, N) is equal to a vector-valued measurement at the same point, when using a pseudo-spectral parameterization |
| 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 pseudo-spectral parameterization |
| CManifoldEvaluationFactor | For a measurement value of type T i.e |
| 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 |
| 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 |
| 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 vector-valued measurement z |
| 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 |
| CChebyshev2Basis | Basis of Chebyshev polynomials of the second kind |
| 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 |
| 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(); |
| CFourierBasis | Fourier basis |
| CParameterMatrix | A matrix abstraction of MxN values at the Basis points |
| Ctraits< ParameterMatrix< M > > | |
| CAlgebraicDecisionTree | An algebraic decision tree fixes the range of a DecisionTree to double |
| CRing | The Real ring with addition and multiplication |
| Ctraits< AlgebraicDecisionTree< T > > | |
| CAssignment | An assignment from labels to value index (size_t) |
| CVisit | Functor performing depth-first visit to each leaf with the leaf value as the argument |
| CVisitLeaf | Functor performing depth-first visit to each leaf with the Leaf object passed as an argument |
| CVisitWith | Functor performing depth-first visit to each leaf with the leaf's Assignment<L> and value passed as arguments |
| CDecisionTree | Decision tree is a function from assignments to values |
| CNode | ---------------------— Node base class ------------------------— |
| CLeaf | |
| CChoice | |
| Ctraits< DecisionTree< L, Y > > | |
| CDecisionTreeFactor | A discrete probabilistic factor |
| Ctraits< DecisionTreeFactor > | |
| CDiscreteBayesNet | A Bayes net made from discrete conditional distributions |
| Ctraits< DiscreteBayesNet > | |
| CDiscreteBayesTreeClique | A clique in a DiscreteBayesTree |
| CDiscreteBayesTree | A Bayes tree representing a Discrete density |
| CDiscreteConditional | Discrete Conditional Density Derives from DecisionTreeFactor |
| Ctraits< DiscreteConditional > | |
| CDiscreteDistribution | A prior probability on a set of discrete variables |
| Ctraits< DiscreteDistribution > | |
| CDiscreteEliminationTree | Elimination tree for discrete factors |
| CDiscreteFactor | Base class for discrete probabilistic factors The most general one is the derived DecisionTreeFactor |
| Ctraits< DiscreteFactor > | |
| CEliminationTraits< DiscreteFactorGraph > | |
| CDiscreteFactorGraph | A Discrete Factor Graph is a factor graph where all factors are Discrete, i.e |
| Ctraits< DiscreteFactorGraph > | |
| CDiscreteJunctionTree | An EliminatableClusterTree, i.e., a set of variable clusters with factors, arranged in a tree, with the additional property that it represents the clique tree associated with a Bayes net |
| CDiscreteKeys | DiscreteKeys is a set of keys that can be assembled using the & operator |
| Ctraits< DiscreteKeys > | |
| CDiscreteLookupTable | DiscreteLookupTable table for max-product |
| CDiscreteLookupDAG | A DAG made from lookup tables, as defined above |
| Ctraits< DiscreteLookupDAG > | |
| CDiscreteMarginals | A class for computing marginals of variables in a DiscreteFactorGraph |
| CDiscreteValues | A map from keys to values |
| Ctraits< DiscreteValues > | |
| CSignature | Signature for a discrete conditional density, used to construct conditionals |
| CBearing | |
| CRange | |
| 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> |
| Ctraits< BearingRange< A1, A2 > > | |
| CHasBearing | |
| CHasRange | |
| CCal3 | Common base class for all calibration models |
| CCal3_S2 | The most common 5DOF 3D->2D calibration |
| Ctraits< Cal3_S2 > | |
| Ctraits< const Cal3_S2 > | |
| CCal3_S2Stereo | The most common 5DOF 3D->2D calibration, stereo version |
| Ctraits< Cal3_S2Stereo > | |
| Ctraits< const Cal3_S2Stereo > | |
| CCal3Bundler | Calibration used by Bundler |
| Ctraits< Cal3Bundler > | |
| Ctraits< const Cal3Bundler > | |
| CCal3DS2 | Calibration of a camera with radial distortion that also supports Lie-group behaviors for optimization |
| Ctraits< Cal3DS2 > | |
| Ctraits< const Cal3DS2 > | |
| CCal3DS2_Base | Calibration of a camera with radial distortion |
| CCal3Fisheye | Calibration of a fisheye camera |
| Ctraits< Cal3Fisheye > | |
| Ctraits< const Cal3Fisheye > | |
| CCal3Unified | Calibration of a omni-directional camera with mirror + lens radial distortion |
| Ctraits< Cal3Unified > | |
| Ctraits< const Cal3Unified > | |
| CCheiralityException | |
| CPinholeBase | A pinhole camera class that has a Pose3, functions as base class for all pinhole cameras |
| CCalibratedCamera | A Calibrated camera class [R|-R't], calibration K=I |
| Ctraits< CalibratedCamera > | |
| Ctraits< const CalibratedCamera > | |
| CRange< CalibratedCamera, T > | |
| CCameraSet | A set of cameras, all with their own calibration |
| Ctraits< CameraSet< CAMERA > > | |
| Ctraits< const CameraSet< CAMERA > > | |
| CPoseConcept | Pose Concept A must contain a translation and a rotation, with each structure accessable directly and a type provided for each |
| CCyclic | Cyclic group of order N |
| Ctraits< Cyclic< N > > | Define cyclic group to be a model of the Additive Group concept |
| 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 |
| Ctraits< EssentialMatrix > | |
| Ctraits< const EssentialMatrix > | |
| CLine3 | A 3D line (R,a,b) : (Rot3,Scalar,Scalar) |
| Ctraits< Line3 > | |
| Ctraits< const Line3 > | |
| COrientedPlane3 | Represents an infinite plane in 3D, which is composed of a planar normal and its perpendicular distance to the origin |
| Ctraits< OrientedPlane3 > | |
| Ctraits< const OrientedPlane3 > | |
| CPinholeCamera | A pinhole camera class that has a Pose3 and a Calibration |
| Ctraits< PinholeCamera< Calibration > > | |
| Ctraits< const PinholeCamera< Calibration > > | |
| CRange< PinholeCamera< Calibration >, T > | |
| CPinholeBaseK | A pinhole camera class that has a Pose3 and a fixed Calibration |
| CPinholePose | A pinhole camera class that has a Pose3 and a fixed Calibration |
| Ctraits< PinholePose< CALIBRATION > > | |
| Ctraits< const PinholePose< CALIBRATION > > | |
| CPinholeSet | PinholeSet: triangulates point and keeps an estimate of it around |
| Ctraits< PinholeSet< CAMERA > > | |
| Ctraits< const PinholeSet< CAMERA > > | |
| CRange< Point2, Point2 > | |
| CRange< Point3, Point3 > | |
| CPose2 | A 2D pose (Point2,Rot2) |
| CChartAtOrigin | |
| Ctraits< Pose2 > | |
| Ctraits< const Pose2 > | |
| CBearing< Pose2, T > | |
| CRange< Pose2, T > | |
| CPose3 | A 3D pose (R,t) : (Rot3,Point3) |
| CChartAtOrigin | |
| Ctraits< Pose3 > | |
| Ctraits< const Pose3 > | |
| CBearing< Pose3, Point3 > | |
| CBearing< Pose3, Pose3 > | |
| CRange< Pose3, T > | |
| Ctraits< QUATERNION_TYPE > | |
| CRot2 | Rotation matrix NOTE: the angle theta is in radians unless explicitly stated |
| CChartAtOrigin | |
| Ctraits< Rot2 > | |
| Ctraits< const Rot2 > | |
| CRot3 | Rot3 is a 3D rotation represented as a rotation matrix if the preprocessor symbol GTSAM_USE_QUATERNIONS is not defined, or as a quaternion if it is defined |
| CCayleyChart | |
| CChartAtOrigin | |
| Ctraits< Rot3 > | |
| Ctraits< const Rot3 > | |
| CSimilarity2 | 2D similarity transform |
| CChartAtOrigin | Chart at the origin |
| Ctraits< Similarity2 > | |
| Ctraits< const Similarity2 > | |
| CSimilarity3 | 3D similarity transform |
| CChartAtOrigin | Chart at the origin |
| Ctraits< Similarity3 > | |
| Ctraits< const Similarity3 > | |
| Ctraits< SO3 > | |
| Ctraits< const SO3 > | |
| Ctraits< SO4 > | |
| Ctraits< const SO4 > | |
| CSO | Manifold of special orthogonal rotation matrices SO<N> |
| CChartAtOrigin | |
| Ctraits< SO< N > > | |
| Ctraits< const SO< N > > | |
| CEmptyCal | Empty calibration |
| CSphericalCamera | A spherical camera class that has a Pose3 and measures bearing vectors |
| Ctraits< SphericalCamera > | |
| Ctraits< const SphericalCamera > | |
| CStereoCheiralityException | |
| CStereoCamera | A stereo camera class, parameterize by left camera pose and stereo calibration |
| Ctraits< StereoCamera > | |
| Ctraits< const StereoCamera > | |
| CStereoPoint2 | A 2D stereo point, v will be same for rectified images |
| Ctraits< StereoPoint2 > | |
| Ctraits< const StereoPoint2 > | |
| CTriangulationUnderconstrainedException | Exception thrown by triangulateDLT when SVD returns rank < 3 |
| CTriangulationCheiralityException | Exception thrown by triangulateDLT when landmark is behind one or more of the cameras |
| CTriangulationParameters | |
| CTriangulationResult | TriangulationResult is an optional point, along with the reasons why it is invalid |
| CUnit3 | Represents a 3D point on a unit sphere |
| Ctraits< Unit3 > | |
| Ctraits< const Unit3 > | |
| CGaussianMixture | A conditional of gaussian mixtures indexed by discrete variables, as part of a Bayes Network |
| Ctraits< GaussianMixture > | |
| CGaussianMixtureFactor | Implementation of a discrete conditional mixture factor |
| Ctraits< GaussianMixtureFactor > | |
| CHybridBayesNet | A hybrid Bayes net is a collection of HybridConditionals, which can have discrete conditionals, Gaussian mixtures, or pure Gaussian conditionals |
| Ctraits< HybridBayesNet > | Traits |
| CHybridBayesTreeClique | A clique in a HybridBayesTree which is a HybridConditional internally |
| CHybridBayesTree | A Bayes tree representing a Hybrid density |
| Ctraits< HybridBayesTree > | Traits |
| CBayesTreeOrphanWrapper< HybridBayesTreeClique > | Class for Hybrid Bayes tree orphan subtrees |
| CHybridConditional | Hybrid Conditional Density |
| Ctraits< HybridConditional > | |
| CHybridEliminationTree | Elimination Tree type for Hybrid Factor Graphs |
| CHybridFactor | Base class for truly hybrid probabilistic factors |
| Ctraits< HybridFactor > | |
| CHybridFactorGraph | Hybrid Factor Graph Factor graph with utilities for hybrid factors |
| CEliminationTraits< HybridGaussianFactorGraph > | |
| CHybridGaussianFactorGraph | |
| CHybridGaussianISAM | |
| Ctraits< HybridGaussianISAM > | Traits |
| CHybridJunctionTree | An EliminatableClusterTree, i.e., a set of variable clusters with factors, arranged in a tree, with the additional property that it represents the clique tree associated with a Bayes net |
| CHybridNonlinearFactorGraph | |
| Ctraits< HybridNonlinearFactorGraph > | |
| CHybridNonlinearISAM | Wrapper class to manage ISAM in a nonlinear context |
| CHybridSmoother | |
| CHybridValues | HybridValues represents a collection of DiscreteValues and VectorValues |
| Ctraits< HybridValues > | |
| CMixtureFactor | Implementation of a discrete conditional mixture factor |
| CBayesNet | A BayesNet is a tree of conditionals, stored in elimination order |
| CFactorGraph | A factor graph is a bipartite graph with factor nodes connected to variable nodes |
| CEliminatableClusterTree | A cluster-tree that eliminates to a Bayes tree |
| CBayesTreeCliqueStats | Clique statistics |
| CBayesTreeCliqueData | Store all the sizes |
| CBayesTree | Bayes tree |
| CBayesTreeOrphanWrapper | |
| CEliminationTraits | Traits class for eliminateable factor graphs, specifies the types that result from elimination, etc |
| CBayesTreeCliqueBase | This is the base class for BayesTree cliques |
| CEliminationData | |
| CEliminationPostOrderVisitor | |
| 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 |
| CConditional | |
| CDotWriter | DotWriter is a helper class for writing graphviz .dot files |
| CEliminateableFactorGraph | EliminateableFactorGraph is a base class for factor graphs that contains elimination algorithms |
| CEliminationTree | An elimination tree is a data structure used intermediately during elimination |
| CNode | |
| CFactor | |
| CCRefCallPushBack | Helper |
| CRefCallPushBack | Helper |
| CCRefCallAddCopy | Helper |
| Cordering_key_visitor | |
| Ccompose_key_visitor | |
| CSDGraph | SDGraph is undirected graph with variable keys and double edge weights |
| CSGraph | |
| CPredecessorMap | Map from variable key to parent key |
| CInconsistentEliminationRequested | An inference algorithm was called with inconsistent arguments |
| CISAM | A Bayes tree with an update methods that implements the iSAM algorithm |
| CConstructorTraversalData | |
| CSymbolicFactors | |
| CJunctionTree | A JunctionTree is a cluster tree, a set of variable clusters with factors, arranged in a tree, with the additional property that it represents the clique tree associated with a Bayes Net |
| CStreamedKey | To use the key_formatter on Keys, they must be wrapped in a StreamedKey |
| 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 |
| Ctraits< Key > | |
| CLabeledSymbol | Customized version of gtsam::Symbol for multi-robot use |
| Ctraits< LabeledSymbol > | Traits |
| CMetisIndex | Converts a factor graph into the Compressed Sparse Row format for use in METIS algorithms |
| COrdering | |
| Ctraits< Ordering > | Traits |
| CSymbol | Character and index key used to refer to variables |
| CSymbolGenerator | Generates symbol shorthands with alternative names different than the one-letter predefined ones |
| Ctraits< Symbol > | Traits |
| CVariableIndex | Computes and stores the block column structure of a factor graph |
| Ctraits< VariableIndex > | Traits |
| CVariableSlots | A combined factor is assembled as one block of rows for each component factor |
| Ctraits< VariableSlots > | Traits |
| CAcceleratedPowerMethod | Compute maximum Eigenpair with accelerated power method |
| CBinaryJacobianFactor | A binary JacobianFactor specialization that uses fixed matrix math for speed |
| Ctraits< BinaryJacobianFactor< M, N1, N2 > > | |
| CConjugateGradientParameters | Parameters for the conjugate gradient method |
| Ctraits< Errors > | Traits |
| CGaussianBayesNet | GaussianBayesNet is a Bayes net made from linear-Gaussian conditionals |
| Ctraits< GaussianBayesNet > | Traits |
| CGaussianBayesTreeClique | A clique in a GaussianBayesTree |
| CGaussianBayesTree | A Bayes tree representing a Gaussian density |
| Ctraits< GaussianBayesTree > | Traits |
| CGaussianConditional | A GaussianConditional functions as the node in a Bayes network |
| Ctraits< GaussianConditional > | Traits |
| CGaussianDensity | A GaussianDensity is a GaussianConditional without parents |
| CGaussianEliminationTree | |
| CGaussianFactor | An abstract virtual base class for JacobianFactor and HessianFactor |
| Ctraits< GaussianFactor > | Traits |
| CEliminationTraits< GaussianFactorGraph > | |
| CGaussianFactorGraph | A Linear Factor Graph is a factor graph where all factors are Gaussian, i.e |
| Ctraits< GaussianFactorGraph > | Traits |
| CGaussianISAM | |
| Ctraits< GaussianISAM > | Traits |
| CGaussianJunctionTree | A junction tree specialized to Gaussian factors, i.e., it is a cluster tree with Gaussian factors stored in each cluster |
| CHessianFactor | A Gaussian factor using the canonical parameters (information form) |
| Ctraits< HessianFactor > | Traits |
| CCGState | |
| CSystem | Helper class encapsulating the combined system |Ax-b_|^2 Needed to run Conjugate Gradients on matrices |
| CIterativeOptimizationParameters | Parameters for iterative linear solvers |
| CIterativeSolver | Base class for Iterative Solvers like SubgraphSolver |
| CKeyInfoEntry | Handy data structure for iterative solvers key to (index, dimension, start) |
| CKeyInfo | Handy data structure for iterative solvers |
| CJacobianFactor | A Gaussian factor in the squared-error form |
| Ctraits< JacobianFactor > | Traits |
| CKalmanFilter | Kalman Filter class |
| CIndeterminantLinearSystemException | Thrown when a linear system is ill-posed |
| CInvalidNoiseModel | An exception indicating that the noise model dimension passed into a JacobianFactor has a different dimensionality than the factor |
| CInvalidMatrixBlock | An exception indicating that a matrix block passed into a JacobianFactor has a different dimensionality than the factor |
| CInvalidDenseElimination | |
| Ctraits< noiseModel::Gaussian > | Traits |
| Ctraits< noiseModel::Diagonal > | |
| Ctraits< noiseModel::Constrained > | |
| Ctraits< noiseModel::Isotropic > | |
| Ctraits< noiseModel::Unit > | |
| CPCGSolverParameters | Parameters for PCG |
| CPCGSolver | A virtual base class for the preconditioned conjugate gradient solver |
| CGaussianFactorGraphSystem | System class needed for calling preconditionedConjugateGradient |
| CPowerMethod | Compute maximum Eigenpair with power method |
| CPreconditionerParameters | |
| CPreconditioner | |
| CDummyPreconditionerParameters | |
| CDummyPreconditioner | |
| CBlockJacobiPreconditionerParameters | |
| CBlockJacobiPreconditioner | |
| CRegularHessianFactor | |
| Ctraits< RegularHessianFactor< D > > | |
| CRegularJacobianFactor | JacobianFactor with constant sized blocks Provides raw memory access versions of linear operator |
| CSampler | Sampling structure that keeps internal random number generators for diagonal distributions specified by NoiseModel |
| CSlotEntry | One SlotEntry stores the slot index for a variable, as well its dim |
| CScatter | Scatter is an intermediate data structure used when building a HessianFactor incrementally, to get the keys in the right order |
| CSubgraph | |
| CEdge | |
| CSubgraphBuilderParameters | |
| CSubgraphBuilder | |
| CSubgraphPreconditionerParameters | |
| CSubgraphPreconditioner | Subgraph conditioner class, as explained in the RSS 2010 submission |
| CSubgraphSolverParameters | |
| CSubgraphSolver | This class implements the linear SPCG solver presented in Dellaert et al in IROS'10 |
| CVectorValues | VectorValues represents a collection of vector-valued variables associated each with a unique integer index |
| Ctraits< VectorValues > | Traits |
| CPreintegratedAhrsMeasurements | PreintegratedAHRSMeasurements accumulates (integrates) the Gyroscope measurements (rotation rates) and the corresponding covariance matrix |
| CAHRSFactor | |
| CAttitudeFactor | Base class for prior on attitude Example: |
| CRot3AttitudeFactor | Version of AttitudeFactor for Rot3 |
| Ctraits< Rot3AttitudeFactor > | Traits |
| CPose3AttitudeFactor | Version of AttitudeFactor for Pose3 |
| Ctraits< Pose3AttitudeFactor > | Traits |
| CBarometricFactor | Prior on height in a cartesian frame |
| CPreintegrationCombinedParams | Parameters for pre-integration using PreintegratedCombinedMeasurements: Usage: Create just a single Params and pass a shared pointer to the constructor |
| CPreintegratedCombinedMeasurements | PreintegratedCombinedMeasurements integrates the IMU measurements (rotation rates and accelerations) and the corresponding covariance matrix |
| CCombinedImuFactor | CombinedImuFactor is a 6-ways factor involving previous state (pose and velocity of the vehicle, as well as bias at previous time step), and current state (pose, velocity, bias at current time step) |
| Ctraits< PreintegrationCombinedParams > | |
| Ctraits< PreintegratedCombinedMeasurements > | |
| Ctraits< CombinedImuFactor > | |
| CConstantVelocityFactor | Binary factor for applying a constant velocity model to a moving body represented as a NavState |
| CGPSFactor | Prior on position in a Cartesian frame |
| CGPSFactor2 | Version of GPSFactor for NavState |
| Ctraits< imuBias::ConstantBias > | |
| CPreintegratedImuMeasurements | PreintegratedImuMeasurements accumulates (integrates) the IMU measurements (rotation rates and accelerations) and the corresponding covariance matrix |
| CImuFactor | ImuFactor is a 5-ways factor involving previous state (pose and velocity of the vehicle at previous time step), current state (pose and velocity at current time step), and the bias estimate |
| CImuFactor2 | ImuFactor2 is a ternary factor that uses NavStates rather than Pose/Velocity |
| Ctraits< PreintegratedImuMeasurements > | |
| Ctraits< ImuFactor > | |
| Ctraits< ImuFactor2 > | |
| 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 |
| CManifoldPreintegration | IMU pre-integration on NavSatet manifold |
| 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 |
| Ctraits< NavState > | |
| CPreintegratedRotationParams | Parameters for pre-integration: Usage: Create just a single Params and pass a shared pointer to the constructor |
| CPreintegratedRotation | PreintegratedRotation is the base class for all PreintegratedMeasurements classes (in AHRSFactor, ImuFactor, and CombinedImuFactor) |
| Ctraits< PreintegratedRotation > | |
| 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 |
| CScenario | Simple trajectory simulator |
| CConstantTwistScenario | Scenario with constant twist 3D trajectory |
| CAcceleratingScenario | Accelerating from an arbitrary initial state, with optional rotation |
| CScenarioRunner | |
| CCombinedScenarioRunner | |
| CTangentPreintegration | Integrate on the 9D tangent space of the NavState manifold |
| 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 |
| CCustomFactor | |
| CDoglegParams | Parameters for Levenberg-Marquardt optimization |
| CDoglegOptimizer | This class performs Dogleg nonlinear optimization |
| CDoglegOptimizerImpl | This class contains the implementation of the Dogleg algorithm |
| CIterationResult | |
| CExpressionFactor | Factor that supports arbitrary expressions via AD |
| CExpression | Expression class that supports automatic differentiation |
| CUnaryFunction | |
| CBinaryFunction | |
| CTernaryFunction | |
| CScalarMultiplyExpression | A ScalarMultiplyExpression is a specialization of Expression that multiplies with a scalar It optimizes the Jacobian calculation for this specific case |
| CBinarySumExpression | A BinarySumExpression is a specialization of Expression that adds two expressions together It optimizes the Jacobian calculation for this specific case |
| Ctraits< ExpressionFactor< T > > | Traits |
| CExpressionFactorN | N-ary variadic template for ExpressionFactor meant as a base class for N-ary factors |
| Ctraits< ExpressionFactorN< T, Args... > > | Traits |
| CExpressionFactorGraph | Factor graph that supports adding ExpressionFactors directly |
| CExtendedKalmanFilter | This is a generic Extended Kalman Filter class implemented using nonlinear factors |
| CFunctorizedFactor | Factor which evaluates provided unary functor and uses the result to compute error with respect to the provided measurement |
| Ctraits< FunctorizedFactor< R, T > > | Traits |
| CFunctorizedFactor2 | Factor which evaluates provided binary functor and uses the result to compute error with respect to the provided measurement |
| Ctraits< FunctorizedFactor2< R, T1, T2 > > | Traits |
| CGaussNewtonParams | Parameters for Gauss-Newton optimization, inherits from NonlinearOptimizationParams |
| CGaussNewtonOptimizer | This class performs Gauss-Newton nonlinear optimization |
| CGncOptimizer | |
| CGncParams | |
| CGraphvizFormatting | Formatting options and functions for saving a NonlinearFactorGraph instance in GraphViz format |
| CISAM2BayesTree | |
| CISAM2JunctionTree | |
| CDeltaImpl | |
| CPartialSolveResult | |
| CReorderingMode | |
| CUpdateImpl | Implementation functions for update method All of the methods below have clear inputs and outputs, even if not functional: iSAM2 is inherintly imperative |
| CISAM2 | Implementation of the full ISAM2 algorithm for incremental nonlinear optimization |
| Ctraits< ISAM2 > | Traits |
| CISAM2Clique | Specialized Clique structure for ISAM2, incorporating caching and gradient contribution TODO: more documentation |
| CISAM2GaussNewtonParams | Parameters for ISAM2 using Gauss-Newton optimization |
| CISAM2DoglegParams | Parameters for ISAM2 using Dogleg optimization |
| CISAM2Params | |
| CISAM2Result | This struct is returned from ISAM2::update() and contains information about the update that is useful for determining whether the solution is converging, and about how much work was required for the update |
| 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 | This struct is used by ISAM2::update() to pass additional parameters to give the user a fine-grained control on how factors and relinearized, etc |
| CLevenbergMarquardtOptimizer | This class performs Levenberg-Marquardt nonlinear optimization |
| CLevenbergMarquardtParams | Parameters for Levenberg-Marquardt optimization |
| CLinearContainerFactor | Dummy version of a generic linear factor to be injected into a nonlinear factor graph |
| Ctraits< LinearContainerFactor > | |
| CMarginals | A class for computing Gaussian marginals of variables in a NonlinearFactorGraph |
| CJointMarginal | A class to store and access a joint marginal, returned from Marginals::jointMarginalCovariance and Marginals::jointMarginalInformation |
| 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 |
| Ctraits< NonlinearEquality< VALUE > > | |
| CNonlinearEquality1 | Simple unary equality constraint - fixes a value for a variable |
| Ctraits< NonlinearEquality1< VALUE > > | |
| CNonlinearEquality2 | Simple binary equality constraint - this constraint forces two variables to be the same |
| Ctraits< NonlinearEquality2< VALUE > > | |
| CMarginalizeNonleafException | Thrown when requesting to marginalize out variables from ISAM2 that are not leaves |
| CNonlinearFactor | Nonlinear factor base class |
| Ctraits< NonlinearFactor > | Traits |
| 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) |
| CNoiseModelFactorN | A convenient base class for creating your own NoiseModelFactor with n variables |
| CNonlinearFactorGraph | |
| Ctraits< NonlinearFactorGraph > | Traits |
| 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 |
| CPriorFactor | A class for a soft prior on any Value type |
| Ctraits< PriorFactor< VALUE > > | Traits |
| C_ValuesKeyValuePair | |
| C_ValuesConstKeyValuePair | |
| CValuesCastHelper | |
| CValuesCastHelper< Value, CastedKeyValuePairType, KeyValuePairType > | |
| CValuesCastHelper< const Value, CastedKeyValuePairType, KeyValuePairType > | |
| CValueCloneAllocator | |
| CValues | A non-templated config holding any types of Manifold-group elements |
| CKeyValuePair | A key-value pair, which you get by dereferencing iterators |
| CConstKeyValuePair | A key-value pair, which you get by dereferencing iterators |
| Cderef_iterator | |
| CValuesKeyAlreadyExists | |
| CValuesKeyDoesNotExist | |
| CValuesIncorrectType | |
| CDynamicValuesMismatched | |
| CNoMatchFoundForFixed | |
| Ctraits< Values > | Traits |
| CWhiteNoiseFactor | Binary factor to estimate parameters of zero-mean Gaussian white noise |
| CBearingFactor | Binary factor for a bearing measurement Works for any two types A1,A2 for which the functor Bearing<A1,A2>() is defined |
| Ctraits< BearingFactor< A1, A2, T > > | Traits |
| CBearingRangeFactor | Binary factor for a bearing/range measurement |
| Ctraits< BearingRangeFactor< A1, A2, B, R > > | Traits |
| CRangeFactor | Binary factor for a range measurement Works for any two types A1,A2 for which the functor Range<A1,A2>() is defined |
| Ctraits< RangeFactor< A1, A2, T > > | Traits |
| CRangeFactorWithTransform | Binary factor for a range measurement, with a transform applied |
| Ctraits< RangeFactorWithTransform< A1, A2, T > > | Traits |
| CBinaryMeasurement | |
| CMFAS | To solve a Minimum feedback arc set (MFAS) problem |
| CSfmData | SfmData stores a bunch of SfmTracks |
| Ctraits< SfmData > | Traits |
| CSfmTrack2d | Track containing 2D measurements associated with a single 3D point |
| CSfmTrack | |
| Ctraits< SfmTrack > | |
| CShonanAveragingParameters | Parameters governing optimization etc |
| CShonanAveraging | Class that implements Shonan Averaging from our ECCV'20 paper |
| CShonanAveraging2 | |
| CShonanAveraging3 | |
| CShonanFactor | ShonanFactor is a BetweenFactor that moves in SO(p), but will land on the SO(d) sub-manifold of SO(p) at the global minimum |
| CShonanGaugeFactor | The ShonanGaugeFactor creates a constraint on a single SO(n) to avoid moving in the stabilizer |
| CTranslationFactor | Binary factor for a relative translation direction measurement w_aZb |
| CTranslationRecovery | |
| CAntiFactor | A class for downdating an existing factor from a graph |
| CBetweenFactor | A class for a measurement predicted by "between(config[key1],config[key2])" |
| Ctraits< BetweenFactor< VALUE > > | Traits |
| CBetweenConstraint | Binary between constraint - forces between to a given value This constraint requires the underlying type to a Lie type |
| Ctraits< BetweenConstraint< VALUE > > | Traits |
| CBoundingConstraint1 | Unary inequality constraint forcing a scalar to be greater/less than a fixed threshold |
| CBoundingConstraint2 | Binary scalar inequality constraint, with a similar value() function to implement for specific systems |
| CEssentialMatrixConstraint | Binary factor between two Pose3 variables induced by an EssentialMatrix measurement |
| 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 |
| CEssentialMatrixFactor4 | Binary factor that optimizes for E and calibration K using the algebraic epipolar error (K^-1 pA)'E (K^-1 pB) |
| CFrobeniusPrior | FrobeniusPrior calculates the Frobenius norm between a given matrix and an element of SO(3) or SO(4) |
| CFrobeniusFactor | FrobeniusFactor calculates the Frobenius norm between rotation matrices |
| 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) |
| CGeneralSFMFactor | Non-linear factor for a constraint derived from a 2D measurement |
| Ctraits< GeneralSFMFactor< CAMERA, LANDMARK > > | |
| CGeneralSFMFactor2 | Non-linear factor for a constraint derived from a 2D measurement |
| Ctraits< GeneralSFMFactor2< CALIBRATION > > | |
| CInitializePose3 | |
| CJacobianFactorQ | JacobianFactor for Schur complement that uses Q noise model |
| Ctraits< JacobianFactorQ< D, ZDim > > | |
| CJacobianFactorQR | JacobianFactor for Schur complement that uses Q noise model |
| CJacobianFactorSVD | JacobianFactor for Schur complement that uses the "Nullspace Trick" by Mourikis et al |
| CKarcherMeanFactor | The KarcherMeanFactor creates a constraint on all SO(n) variables with given keys that the Karcher mean (see above) will stay the same |
| COrientedPlane3Factor | Factor to measure a planar landmark from a given pose |
| COrientedPlane3DirectionPrior | |
| CPoseRotationPrior | |
| CPoseTranslationPrior | A prior on the translation part of a pose |
| CGenericProjectionFactor | Non-linear factor for a constraint derived from a 2D measurement |
| Ctraits< GenericProjectionFactor< POSE, LANDMARK, CALIBRATION > > | Traits |
| CReferenceFrameFactor | A constraint between two landmarks in separate maps Templated on: Point : Type of landmark Transform : Transform variable class |
| Ctraits< ReferenceFrameFactor< T1, T2 > > | Traits |
| CRegularImplicitSchurFactor | RegularImplicitSchurFactor |
| Ctraits< RegularImplicitSchurFactor< CAMERA > > | |
| 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 |
| CRotateDirectionsFactor | Factor on unknown rotation iRc that relates two directions c Directions provide less constraints than a full rotation |
| CSmartFactorBase | Base class for smart factors |
| CSmartProjectionParams | |
| CSmartProjectionFactor | SmartProjectionFactor: triangulates point and keeps an estimate of it around |
| Ctraits< SmartProjectionFactor< CAMERA > > | Traits |
| CSmartProjectionPoseFactor | If you are using the factor, please cite: L |
| Ctraits< SmartProjectionPoseFactor< CALIBRATION > > | Traits |
| CSmartProjectionRigFactor | If you are using the factor, please cite: L |
| Ctraits< SmartProjectionRigFactor< CAMERA > > | Traits |
| CGenericStereoFactor | A Generic Stereo Factor |
| Ctraits< GenericStereoFactor< T1, T2 > > | Traits |
| CTriangulationFactor | Non-linear factor for a constraint derived from a 2D measurement |
| CSymbolicBayesNet | A SymbolicBayesNet is a Bayes Net of purely symbolic conditionals |
| Ctraits< SymbolicBayesNet > | Traits |
| CSymbolicBayesTreeClique | A clique in a SymbolicBayesTree |
| CSymbolicBayesTree | A Bayes tree that represents the connectivity between variables but is not associated with any probability functions |
| Ctraits< SymbolicBayesTreeClique > | Traits |
| Ctraits< SymbolicBayesTree > | |
| CSymbolicConditional | SymbolicConditional is a conditional with keys but no probability data, produced by symbolic elimination of SymbolicFactor |
| Ctraits< SymbolicConditional > | Traits |
| CSymbolicEliminationTree | |
| Ctraits< SymbolicEliminationTree > | Traits |
| CSymbolicFactor | SymbolicFactor represents a symbolic factor that specifies graph topology but is not associated with any numerical function |
| Ctraits< SymbolicFactor > | Traits |
| CEliminationTraits< SymbolicFactorGraph > | |
| CSymbolicFactorGraph | Symbolic Factor Graph |
| Ctraits< SymbolicFactorGraph > | Traits |
| CSymbolicISAM | |
| CSymbolicJunctionTree | A EliminatableClusterTree, i.e., a set of variable clusters with factors, arranged in a tree, with the additional property that it represents the clique tree associated with a Bayes net |
| CBTree | Binary tree |
| Cconst_iterator | Const iterator Not trivial: iterator keeps a stack to indicate current path from root_ |
| CDSF | Disjoint Set Forest class |
| CDummy | |
| CFixedVector | Fixed size vectors - compatible with boost vectors, but with compile-type size checking |
| CAllDiff | General AllDiff constraint |
| CBinaryAllDiff | Binary AllDiff constraint Returns 1 if values for two keys are different, 0 otherwise |
| CConstraint | Base class for constraint factors Derived classes include SingleValue, BinaryAllDiff, and AllDiff |
| CCSP | Constraint Satisfaction Problem class A specialization of a DiscreteFactorGraph |
| CDomain | Constraint that restricts the possible values a particular variable, with given key, can take on |
| 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 |
| CSingleValue | SingleValue constraint: ensures a variable takes on a certain value |
| CDHeightPrior | Forces the value of the height (z) in a PoseRTV to a specific value |
| CDRollPrior | Forces the roll to a particular value - useful for flying robots Implied value is zero Dim: 1 |
| CVelocityPrior | Constrains the full velocity of a state to a particular value Useful for enforcing a stationary state Dim: 3 |
| CDGroundConstraint | Ground constraint: forces the robot to be upright (no roll, pitch), a fixed height, and no velocity in z direction Dim: 4 |
| 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 |
| 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 |
| 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}) \) |
| CPoseRTV | Robot state for use with IMU measurements |
| Ctraits< PoseRTV > | |
| CRange< PoseRTV, PoseRTV > | |
| 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 |
| CDiscreteEulerPoincareHelicopter | Implement the Discrete Euler-Poincare' equation: |
| CVelocityConstraint | Constraint to enforce dynamics between the velocities and poses, using a prediction based on a numerical integration flag |
| CVelocityConstraint3 | |
| CBearingS2 | |
| Ctraits< BearingS2 > | Traits |
| CEvent | A space-time event models an event that happens at a certain 3D location, at a certain time |
| Ctraits< Event > | |
| CTimeOfArrival | Time of arrival to given sensor |
| CInvDepthCamera3 | A pinhole camera class that has a Pose3 and a Calibration |
| CPose3Upright | A 3D Pose with fixed pitch and roll |
| Ctraits< Pose3Upright > | |
| CSimPolygon2D | General polygon class for convex polygons |
| CSimWall2D | General Wall class for walls defined around unordered endpoints Primarily to handle ray intersections |
| Ctraits< SimWall2D > | Traits |
| CActiveSetSolver | This class implements the active set algorithm for solving convex Programming problems |
| CState | This struct contains the state information for a single iteration |
| CEqualityFactorGraph | Collection of all Linear Equality constraints Ax=b of a Programming problem as a Factor Graph |
| Ctraits< EqualityFactorGraph > | Traits |
| CInequalityFactorGraph | Collection of all Linear Inequality constraints Ax-b <= 0 of a Programming problem as a Factor Graph |
| Ctraits< InequalityFactorGraph > | Traits |
| 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 | |
| CLinearCost | This class defines a linear cost function c'x which is a JacobianFactor with only one row |
| Ctraits< LinearCost > | Traits |
| CLinearEquality | This class defines a linear equality constraints, inheriting JacobianFactor with the special Constrained noise model |
| Ctraits< LinearEquality > | Traits |
| CLinearInequality | This class defines a linear inequality constraint Ax-b <= 0, inheriting JacobianFactor with the special Constrained noise model |
| Ctraits< LinearInequality > | Traits |
| CLP | Data structure of a Linear Program |
| Ctraits< LP > | Traits |
| 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 |
| 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 | |
| CBatchFixedLagSmoother | |
| CConcurrentBatchFilter | A Levenberg-Marquardt Batch Filter that implements the Concurrent Filtering and Smoother interface |
| CResult | Meta information returned about the update |
| Ctraits< ConcurrentBatchFilter > | Traits |
| CConcurrentBatchSmoother | A Levenberg-Marquardt Batch Smoother that implements the Concurrent Filtering and Smoother interface |
| CResult | Meta information returned about the update |
| Ctraits< ConcurrentBatchSmoother > | Traits |
| CConcurrentFilter | The interface for the 'Filter' portion of the Concurrent Filtering and Smoother architecture |
| CConcurrentSmoother | The interface for the 'Smoother' 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 |
| Ctraits< ConcurrentIncrementalFilter > | Traits |
| CConcurrentIncrementalSmoother | A Levenberg-Marquardt Batch Smoother that implements the Concurrent Filtering and Smoother interface |
| CResult | Meta information returned about the update |
| Ctraits< ConcurrentIncrementalSmoother > | Traits |
| CFixedLagSmoother | |
| CResult | Meta information returned about the update |
| CIncrementalFixedLagSmoother | This is a base class for the various HMF2 implementations |
| CLinearizedGaussianFactor | A base factor class for the Jacobian and Hessian linearized factors |
| CLinearizedJacobianFactor | A factor that takes a linear, Jacobian factor and inserts it into a nonlinear graph |
| Ctraits< LinearizedJacobianFactor > | Traits |
| CLinearizedHessianFactor | A factor that takes a linear, Hessian factor and inserts it into a nonlinear graph |
| Ctraits< LinearizedHessianFactor > | Traits |
| CNonlinearClusterTree | |
| CNonlinearCluster | |
| CAHRS | |
| CBetweenFactorEM | A class for a measurement predicted by "between(config[key1],config[key2])" |
| Ctraits< BetweenFactorEM< VALUE > > | Traits |
| CBiasedGPSFactor | A class to model GPS measurements, including a bias term which models common-mode errors and that can be partially corrected if other sensors are used |
| CDummyFactor | |
| CEquivInertialNavFactor_GlobalVel | |
| CEquivInertialNavFactor_GlobalVel_NoBias | |
| CGaussMarkov1stOrderFactor | |
| Ctraits< GaussMarkov1stOrderFactor< VALUE > > | Traits |
| CInertialNavFactor_GlobalVelocity | |
| Ctraits< InertialNavFactor_GlobalVelocity< POSE, VELOCITY, IMUBIAS > > | Traits |
| 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 |
| CLocalOrientedPlane3Factor | Factor to measure a planar landmark from a given pose, with a given local linearization point |
| CMechanization_bRn2 | |
| CMultiProjectionFactor | Non-linear factor for a constraint derived from a 2D measurement |
| CPartialPriorFactor | A class for a soft partial prior on any Lie type, with a mask over Expmap parameters |
| CPoseBetweenFactor | A class for a measurement predicted by "between(config[key1],config[key2])" |
| CPosePriorFactor | A class for a soft prior on any Value type |
| CPoseToPointFactor | A class for a measurement between a pose and a point |
| CProjectionFactorPPP | Non-linear factor for a constraint derived from a 2D measurement |
| Ctraits< ProjectionFactorPPP< POSE, LANDMARK, CALIBRATION > > | Traits |
| CProjectionFactorPPPC | Non-linear factor for a constraint derived from a 2D measurement |
| Ctraits< ProjectionFactorPPPC< POSE, LANDMARK, CALIBRATION > > | Traits |
| CProjectionFactorRollingShutter | Non-linear factor for 2D projection measurement obtained using a rolling shutter camera |
| Ctraits< ProjectionFactorRollingShutter > | Traits |
| CRelativeElevationFactor | Binary factor for a relative elevation |
| CSmartProjectionPoseFactorRollingShutter | If you are using the factor, please cite: L |
| Ctraits< SmartProjectionPoseFactorRollingShutter< CAMERA > > | Traits |
| CSmartRangeFactor | Smart factor for range SLAM |
| CCircle2 | |
| CSmartStereoProjectionFactor | SmartStereoProjectionFactor: triangulates point and keeps an estimate of it around |
| Ctraits< SmartStereoProjectionFactor > | Traits |
| CSmartStereoProjectionFactorPP | If you are using the factor, please cite: L |
| Ctraits< SmartStereoProjectionFactorPP > | Traits |
| CSmartStereoProjectionPoseFactor | If you are using the factor, please cite: L |
| Ctraits< SmartStereoProjectionPoseFactor > | Traits |
| CTOAFactor | A "Time of Arrival" factor - so little code seems hardly worth it :-) |
| CTransformBtwRobotsUnaryFactor | A class for a measurement predicted by "between(config[key1],config[key2])" |
| Ctraits< TransformBtwRobotsUnaryFactor< VALUE > > | Traits |
| CTransformBtwRobotsUnaryFactorEM | A class for a measurement predicted by "between(config[key1],config[key2])" |
| Ctraits< TransformBtwRobotsUnaryFactorEM< VALUE > > | Traits |
| CDeltaFactor | DeltaFactor: relative 2D measurement between Pose2 and Point2 |
| CDeltaFactorBase | DeltaFactorBase: relative 2D measurement between Pose2 and Point2, with Basenodes |
| COdometryFactorBase | OdometryFactorBase: Pose2 odometry, with Basenodes |
| Cvector | STL class |
| Citerator | STL iterator class |
| Cconst_iterator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| CDiscreteValues | The Factor::error simply extracts the |
| CGaussianConditional | Normalization constant |
| CHybridValues | Error |
| CJacobianFactor | In Gaussian factors, the error function returns either the negative log-likelihood, e.g., 0.5*(A*x-b)'D(A*x-b) for a negative log-density, e.g., 0.5*(A*x-b)'D(A*x-b) - log(k) for a |
| Cmap | STL class |
| Citerator | STL iterator class |
| Cconst_iterator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| CNoiseModelFactor | Noise model to the factor, and calculates the error by asking the user to implement the method |
| COnly | Symbolic elimination etc |
| Costream | STL class |
| Cpair | STL class |
| CPose2 | A 2D pose (Point2,Rot2) |
| CChartAtOrigin | |
| Cstring | STL class |
| Citerator | STL iterator class |
| Cconst_iterator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| Cstringstream | STL class |
| CSymbol | Character and index key used to refer to variables |
| Cunordered_map | STL class |
| Citerator | STL iterator class |
| Cconst_iterator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| Cunordered_set | STL class |
| Citerator | STL iterator class |
| Cconst_iterator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| CValues | In nonlinear factors, the error function returns the negative log-likelihood as a non-linear function of the values in a |
| Cvector | STL class |
| Citerator | STL iterator class |
| Cconst_iterator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| CVectorValues | The Factor::error simply extracts the |
1.16.1