Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 1234567]

Cgtsam::detail::_merge_and_renumber< Sequence1, Sequence2 >
Cgtsam::detail::_merge_and_renumber< make_index_sequence< N/2 >::type, make_index_sequence< N - N/2 >::type >
Cgtsam::make_index_sequence< sizeof...(T)>
Cgtsam::make_index_sequence< 0 >
Cgtsam::make_index_sequence< 1 >
Cgtsam::make_index_sequence< N >
Cgtsam::_ValuesConstKeyValuePair< ValueType >
Cgtsam::_ValuesKeyValuePair< ValueType >
CAction
Cgtsam::group_action::Diffeomorphism< Action >	Diffeomorphism: The map m -> m, defined by fixing g0
Cgtsam::group_action::InducedVectorField< Action, VectorField >	Induced action on vector fields via push-forward
Cgtsam::group_action::Orbit< Action >	Orbit: The map g -> m, defined by fixing m0
Cgtsam::AdaptAutoDiff< FUNCTOR, M, N1, N2 >	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
Cgtsam::additive_group_tag
Cgtsam::internal::AdditiveGroupTraits< Class >	A helper class that implements the traits interface for additive groups
Cgtsam::internal::AdditiveGroup< Class >	Both additive group traits and Testable
Cgtsam::internal::AdditiveGroupTraits< Cyclic< N > >
Cgtsam::traits< Cyclic< N > >	Define cyclic group to be a model of the Additive Group concept
Cgtsam::internal::AdditiveGroupTraits< DirectSum< G, H > >
Cgtsam::traits< DirectSum< G, H > >
Cboost::adjacency_list
Cgtsam::SDGraph< KEY >	SDGraph is undirected graph with variable keys and double edge weights
Cgtsam::SGraph< KEY >
Cgtsam::internal::apply_compose< T >
Cgtsam::internal::apply_compose< double >
Cstd::array< T >	STL class
Cgtsam::PowerLieGroup< Rot3, static_cast< int >(N)>
Cgtsam::PowerLieGroup< G, Eigen::Dynamic >	Dynamic-count specialization of PowerLieGroup Represents G^N for runtime-sized N while keeping G fixed-size
Cgtsam::PowerLieGroup< G, N >	Template to construct the N-fold power of a Lie group Represents the group G^N = G x G x ... x G (N times) Assumes Lie group structure for fixed-size G and fixed N >= 1
Cgtsam::LeggedInvariantEKF::AutonomousFlow	Autonomous flow used by the left-linear prediction step
Cgtsam::NavState::AutonomousFlow
Cgtsam::internal::AutoTicToc	Small class that calls internal::tic at construction, and internol::toc when destroyed
Cgtsam::noiseModel::Base	NoiseModel::Base is the abstract base class for all noise models
Cgtsam::noiseModel::Gaussian	Gaussian implements the mathematical model |R*x|^2 = |y|^2 with R'*R=inv(Sigma) where y = whiten(x) = R*x x = unwhiten(x) = inv(R)*y as indeed |y|^2 = y'*y = x'*R'*R*x Various derived classes are available that are more efficient
Cgtsam::noiseModel::Diagonal	A diagonal noise model implements a diagonal covariance matrix, with the elements of the diagonal specified in a Vector
Cgtsam::noiseModel::Constrained	A Constrained constrained model is a specialization of Diagonal which allows some or all of the sigmas to be zero, forcing the error to be zero there
Cgtsam::noiseModel::Isotropic	An isotropic noise model corresponds to a scaled diagonal covariance To construct, use one of the static methods
Cgtsam::noiseModel::Unit	Unit: i.i.d
Cgtsam::noiseModel::Robust	Base class for robust error models The robust M-estimators above simply tell us how to re-weight the residual, and are isotropic kernels, in that they do not allow for correlated noise
Cgtsam::noiseModel::mEstimator::Base	Pure virtual class for all robust error function classes
Cgtsam::noiseModel::mEstimator::AsymmetricCauchy	Implementation of the "AsymmetricCauchy" robust error model
Cgtsam::noiseModel::mEstimator::AsymmetricTukey	Implementation of the "AsymmetricTukey" robust error model
Cgtsam::noiseModel::mEstimator::Cauchy	Implementation of the "Cauchy" robust error model (Lee2013IROS)
Cgtsam::noiseModel::mEstimator::Custom	Implementation of the "Custom" robust error model
Cgtsam::noiseModel::mEstimator::DCS	DCS implements the Dynamic Covariance Scaling robust error model from the paper Robust Map Optimization (Agarwal13icra)
Cgtsam::noiseModel::mEstimator::Fair	Implementation of the "Fair" robust error model (Zhang97ivc)
Cgtsam::noiseModel::mEstimator::GemanMcClure	Implementation of the "Geman-McClure" robust error model (Zhang97ivc)
Cgtsam::noiseModel::mEstimator::Huber	The "Huber" robust error model (Zhang97ivc)
Cgtsam::noiseModel::mEstimator::L2WithDeadZone	L2WithDeadZone implements a standard L2 penalty, but with a dead zone of width 2*k, centered at the origin
Cgtsam::noiseModel::mEstimator::Null	"Null" robust loss function, equivalent to a Gaussian pdf noise model, or plain least-squares (non-robust)
Cgtsam::noiseModel::mEstimator::TruncatedLeastSquares	Truncated Least Squares (TLS) robust error model
Cgtsam::noiseModel::mEstimator::Tukey	Implementation of the "Tukey" robust error model (Zhang97ivc)
Cgtsam::noiseModel::mEstimator::Welsch	Implementation of the "Welsch" robust error model (Zhang97ivc)
Cgtsam::Basis< DERIVED >	CRTP Base class for function bases
Cgtsam::Basis< CardinalSplineBasis >
Cgtsam::CardinalSplineBasis	Cubic cardinal-spline basis for scalar, vector, and manifold Basis functors
Cgtsam::Basis< Chebyshev1Basis >
Cgtsam::Chebyshev1Basis	Basis of Chebyshev polynomials of the first kind https://en.wikipedia.org/wiki/Chebyshev_polynomials#First_kind These are typically denoted with the symbol T_n, where n is the degree
Cgtsam::Basis< Chebyshev2 >
Cgtsam::Chebyshev2	Chebyshev Interpolation on Chebyshev points of the second kind Note that N here, the number of points, is one less than N from 'Approximation Theory and Approximation Practice by L
Cgtsam::Basis< Chebyshev2Basis >
Cgtsam::Chebyshev2Basis	Basis of Chebyshev polynomials of the second kind
Cgtsam::Basis< FourierBasis >
Cgtsam::FourierBasis	Fourier basis
CBAYESTREE
Cgtsam::ISAM< BAYESTREE >	A Bayes tree with an update methods that implements the iSAM algorithm
Cgtsam::BayesTree< CLIQUE >	Bayes tree
Cgtsam::BayesTree< DiscreteBayesTreeClique >
Cgtsam::DiscreteBayesTree	A Bayes tree representing a Discrete distribution
Cgtsam::BayesTree< GaussianBayesTreeClique >
Cgtsam::GaussianBayesTree	A Bayes tree representing a Gaussian density
Cgtsam::ISAM< GaussianBayesTree >
Cgtsam::GaussianISAM
Cgtsam::BayesTree< HybridBayesTreeClique >
Cgtsam::HybridBayesTree	A Bayes tree representing a Hybrid density
Cgtsam::ISAM< HybridBayesTree >
Cgtsam::HybridGaussianISAM	Incremental Smoothing and Mapping (ISAM) algorithm for hybrid factor graphs
Cgtsam::BayesTree< ISAM2Clique >
Cgtsam::ISAM2	Implementation of the full ISAM2 algorithm for incremental nonlinear optimization
Cgtsam::ISAM2BayesTree
Cgtsam::BayesTree< SymbolicBayesTreeClique >
Cgtsam::SymbolicBayesTree	A Bayes tree that represents the connectivity between variables but is not associated with any probability functions
Cgtsam::ISAM< SymbolicBayesTree >
Cgtsam::SymbolicISAM
Cgtsam::BayesTreeCliqueBase< DERIVED, FACTORGRAPH >	This is the base class for BayesTree cliques
Cgtsam::BayesTreeCliqueBase< DiscreteBayesTreeClique, DiscreteFactorGraph >
Cgtsam::DiscreteBayesTreeClique	A clique in a DiscreteBayesTree
Cgtsam::BayesTreeCliqueBase< GaussianBayesTreeClique, GaussianFactorGraph >
Cgtsam::GaussianBayesTreeClique	A clique in a GaussianBayesTree
Cgtsam::BayesTreeCliqueBase< HybridBayesTreeClique, HybridGaussianFactorGraph >
Cgtsam::HybridBayesTreeClique	A clique in a HybridBayesTree which is a HybridConditional internally
Cgtsam::BayesTreeCliqueBase< ISAM2Clique, GaussianFactorGraph >
Cgtsam::ISAM2Clique	Specialized Clique structure for ISAM2, incorporating caching and gradient contribution TODO: more documentation
Cgtsam::BayesTreeCliqueBase< SymbolicBayesTreeClique, SymbolicFactorGraph >
Cgtsam::SymbolicBayesTreeClique	A clique in a SymbolicBayesTree
Cgtsam::BayesTreeCliqueData	Store all the sizes
Cgtsam::BayesTreeCliqueStats	Clique statistics
Cgtsam::BayesTreeMarginalizationHelper< BayesTree >	This class provides helper functions for marginalizing variables from a Bayes Tree
Cgtsam::Bearing< A1, A2 >
Cgtsam::BearingRange< A1, A2, B, R >	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>
Cgtsam::Expression< T >::BinaryFunction< A1, A2 >
Cgtsam::internal::BlockColumnRange	Half-open range of physical upper-triangular block columns
Cstd::bool_constant
Cgtsam::internal::IsCompatibleSemidirectAction< Action, G, H, std::void_t< decltype(Action::type), decltype(Action::generator(std::declval< const typename traits< G >::TangentVector & >()))> >
Cgtsam::BTree< KEY, VALUE >	Binary tree
Cgtsam::DSF< int >
Cgtsam::BTree< KEY, KEY >
Cgtsam::DSF< KEY >	Disjoint Set Forest class
Cgtsam::BayesTreeMarginalizationHelper< BayesTree >::CachedSearch	A struct to cache the results of the below two functions
Cgtsam::Cal3	Common base class for all calibration models
Cgtsam::Cal3DS2_Base	Calibration of a camera with radial distortion
Cgtsam::Cal3DS2	Calibration of a camera with radial distortion that also supports Lie-group behaviors for optimization
Cgtsam::Cal3Unified	Calibration of a omni-directional camera with mirror + lens radial distortion
Cgtsam::Cal3Fisheye	Calibration of a fisheye camera
Cgtsam::Cal3_S2	The most common 5DOF 3D->2D calibration
Cgtsam::Cal3_S2Stereo	The most common 5DOF 3D->2D calibration, stereo version
Cgtsam::Cal3f	Calibration model with a single focal length and zero skew
Cgtsam::Cal3Bundler	Calibration used by Bundler
Cgtsam::Rot3::CayleyChart
Cgtsam::CGState< S, V, E >
Cgtsam::internal::ChartAtIdentity< Class, N >	Chart-at-origin adapter for LieGroup-derived classes with explicit instance retract/localCoordinates implementations
Cgtsam::ExtendedPose3< K_, Derived >::ChartAtOrigin	Chart operations at identity for LieGroup/Manifold compatibility
Cgtsam::Gal3::ChartAtOrigin	Chart at origin, uses Expmap/Logmap for Retract/Local
Cgtsam::Pose2::ChartAtOrigin
Cgtsam::Pose3::ChartAtOrigin
Cgtsam::PowerLieGroupBase< G, N, Derived >::ChartAtOrigin	Component-wise chart at the identity
Cgtsam::ProductLieGroup< G, H >::ChartAtOrigin	Component-wise chart at the product identity
Cgtsam::Rot2::ChartAtOrigin
Cgtsam::Rot3::ChartAtOrigin
Cgtsam::Similarity2::ChartAtOrigin	Chart at the origin
Cgtsam::Similarity3::ChartAtOrigin	Chart at the origin
Cgtsam::SL4::ChartAtOrigin
Cgtsam::SO< N >::ChartAtOrigin
Cgtsam::MultifrontalClique::ChildInfo
Cgtsam::SmartRangeFactor::Circle2
CClass
Cgtsam::AsVectorSpace< Class >	Opt-in adapter that equips a manifold class with additive vector-space operations
Cgtsam::ClusterTree< GRAPH >::Cluster	A Cluster is just a collection of factors
Cgtsam::ClusterTree< NonlinearFactorGraph >::Cluster
Cgtsam::NonlinearClusterTree::NonlinearCluster
Cgtsam::ClusterTree< GRAPH >	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 \)
Cgtsam::EliminatableClusterTree< BAYESTREE, GRAPH >	A cluster-tree that eliminates to a Bayes tree
Cgtsam::JunctionTree< DiscreteBayesTree, DiscreteFactorGraph >
Cgtsam::DiscreteJunctionTree	An EliminatableClusterTree, i.e., a set of variable clusters with factors, arranged in a tree, with the additional property that it represents the clique tree associated with a Bayes net
Cgtsam::sharedNode< HybridBayesTree, HybridGaussianFactorGraph >
Cgtsam::JunctionTree< HybridBayesTree, HybridGaussianFactorGraph >
Cgtsam::HybridJunctionTree	An EliminatableClusterTree, i.e., a set of variable clusters with factors, arranged in a tree, with the additional property that it represents the clique tree associated with a Bayes net
Cgtsam::Node< BAYESTREE, GRAPH >
Cgtsam::sharedNode< BAYESTREE, GRAPH >
Cgtsam::JunctionTree< GaussianBayesTree, GaussianFactorGraph >
Cgtsam::GaussianJunctionTree	A junction tree specialized to Gaussian factors, i.e., it is a cluster tree with Gaussian factors stored in each cluster
Cgtsam::JunctionTree< ISAM2BayesTree, GaussianFactorGraph >
Cgtsam::ISAM2JunctionTree
Cgtsam::JunctionTree< SymbolicBayesTree, SymbolicFactorGraph >
Cgtsam::SymbolicJunctionTree	A EliminatableClusterTree, i.e., a set of variable clusters with factors, arranged in a tree, with the additional property that it represents the clique tree associated with a Bayes net
Cgtsam::IndexedJunctionTree	A symbolic junction tree whose factors record the original factor indices from a corresponding (non-symbolic) factor graph
Cgtsam::JunctionTree< BAYESTREE, GRAPH >	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
Cgtsam::ClusterTree< NonlinearFactorGraph >
Cgtsam::NonlinearClusterTree
Cgtsam::detail::PrioritySchedulerPolicy::Compare< TaskPtr >
Cgtsam::ConcurrentFilter	The interface for the 'Filter' portion of the Concurrent Filtering and Smoother architecture
Cgtsam::ConcurrentBatchFilter	A Levenberg-Marquardt Batch Filter that implements the Concurrent Filtering and Smoother interface
Cgtsam::ConcurrentIncrementalFilter	An iSAM2-based Batch Filter that implements the Concurrent Filtering and Smoother interface
Cgtsam::ConcurrentSmoother	The interface for the 'Smoother' portion of the Concurrent Filtering and Smoother architecture
Cgtsam::ConcurrentBatchSmoother	A Levenberg-Marquardt Batch Smoother that implements the Concurrent Filtering and Smoother interface
Cgtsam::ConcurrentIncrementalSmoother	A Levenberg-Marquardt Batch Smoother that implements the Concurrent Filtering and Smoother interface
Cgtsam::Conditional< FACTOR, DERIVEDCONDITIONAL >
Cgtsam::Conditional< DecisionTreeFactor, DiscreteConditional >
Cgtsam::DiscreteConditional	Discrete Conditional Density Derives from DecisionTreeFactor
Cgtsam::DiscreteDistribution	A prior probability on a set of discrete variables
Cgtsam::DiscreteLookupTable	DiscreteLookupTable table for max-product
Cgtsam::TableDistribution	Distribution which uses a SparseVector as the internal representation, similar to the TableFactor
Cgtsam::Conditional< HybridFactor, HybridConditional >
Cgtsam::HybridConditional	Hybrid Conditional Density
Cgtsam::BayesTreeOrphanWrapper< HybridBayesTreeClique >	Class for Hybrid Bayes tree orphan subtrees
Cgtsam::Conditional< HybridGaussianFactor, HybridGaussianConditional >
Cgtsam::HybridGaussianConditional	A conditional of gaussian conditionals indexed by discrete variables, as part of a Bayes Network
Cgtsam::Conditional< JacobianFactor, GaussianConditional >
Cgtsam::GaussianConditional	A GaussianConditional functions as the node in a Bayes network
Cgtsam::GaussianDensity	A GaussianDensity is a GaussianConditional without parents
Cgtsam::Conditional< SymbolicFactor, SymbolicConditional >
Cgtsam::SymbolicConditional	SymbolicConditional is a conditional with keys but no probability data, produced by symbolic elimination of SymbolicFactor
CCLIQUE::ConditionalType
Cgtsam::BayesTreeOrphanWrapper< CLIQUE, typename >
CHybridBayesTree::Clique::ConditionalType
Cgtsam::BayesTreeOrphanWrapper< HybridBayesTree::Clique >
CHybridBayesTreeClique::ConditionalType
Cgtsam::BayesTreeOrphanWrapper< HybridBayesTreeClique >	Class for Hybrid Bayes tree orphan subtrees
Cgtsam::ConjugateGradientResult< V >	Solution and diagnostics returned by the detailed CG interface
Cgtsam::ConjugateGradientStats	Diagnostics collected during a conjugate-gradient solve
Cstd::conjunction
Cgtsam::LeftLinearEKF< G >::is_automorphism< Phi >	SFINAE template to check if a type satisfies the automorphism concept
Cgtsam::BTree< KEY, VALUE >::const_iterator	Const iterator Not trivial: iterator keeps a stack to indicate current path from root_
Cgtsam::vector< T >::const_iterator	STL iterator class
Cmap< K, T >::const_iterator	STL iterator class
Cstring::const_iterator	STL iterator class
Cunordered_map< K, T >::const_iterator	STL iterator class
Cunordered_set< K >::const_iterator	STL iterator class
Cvector< T >::const_iterator	STL iterator class
Cgtsam::vector< T >::const_reverse_iterator	STL iterator class
Cmap< K, T >::const_reverse_iterator	STL iterator class
Cstring::const_reverse_iterator	STL iterator class
Cunordered_map< K, T >::const_reverse_iterator	STL iterator class
Cunordered_set< K >::const_reverse_iterator	STL iterator class
Cvector< T >::const_reverse_iterator	STL iterator class
Cgtsam::imuBias::ConstantBias
Cgtsam::Conditional< FACTOR, DERIVEDCONDITIONAL >::ConstFactorRangeIterator
Cgtsam::Values::ConstKeyValuePair	A key-value pair, which you get by dereferencing iterators
Cgtsam::ConstructorTraversalData< BAYESTREE, GRAPH, ETREE_NODE >
Cgtsam::ContactMeasurement	Body-frame contact measurement for one foot
Cgtsam::CumulativeSplineTrajectory< T >	Factory for expressions that sample a cumulative spline on a Lie group
Cgtsam::partition::Cuts
Cgtsam::Cyclic< N >	Cyclic group of order N
Cgtsam::DCSAM	Class which implements Discrete-Continuous Smoothing And Mapping, as detailed in Doherty22ral (https://arxiv.org/abs/2204.11936)
Cgtsam::DecisionTree< L, Y >	Decision tree is a function from assignments to values
Cgtsam::AlgebraicDecisionTree< Key >
Cgtsam::DecisionTreeFactor	A discrete probabilistic factor
Cgtsam::DiscreteBoundaryFactor	A discrete probabilistic factor which computes its values from the continuous factors connected to it and a set of values
Cgtsam::DiscreteConditional	Discrete Conditional Density Derives from DecisionTreeFactor
Cgtsam::DecisionTree< Key, GaussianFactorGraphValuePair >
Cgtsam::HybridGaussianProductFactor	Alias for DecisionTree of GaussianFactorGraphs and their scalar sums
Cgtsam::DecisionTree< L, double >
Cgtsam::AlgebraicDecisionTree< L >	An algebraic decision tree fixes the range of a DecisionTree to double
Cgtsam::internal::DeducedOutput	Marker type used when the callable return type should be deduced
Cboost::default_bfs_visitor
Cgtsam::compose_key_visitor< V, POSE, KEY >
Cgtsam::ordering_key_visitor< KEY >
Cgtsam::DeltaImpl
Cgtsam::Values::deref_iterator
Cgtsam::Basis< DERIVED >::DerivativeFunctorBase	Base class for functors below that calculate derivative weights
Cgtsam::Basis< DERIVED >::ComponentDerivativeFunctor	Given a M*N Matrix of M-vectors at N polynomial points, an instance of ComponentDerivativeFunctor computes the N-vector derivative for a specific row component of the M-vectors at all the polynomial points
Cgtsam::Basis< DERIVED >::DerivativeFunctor	An instance of a DerivativeFunctor calculates f'(x;p) at a given x, applied to Parameters p
Cgtsam::Basis< DERIVED >::VectorDerivativeFunctor	VectorDerivativeFunctor at a given x, applied to a parameter Matrix
CDerived
Cgtsam::group_action::Diffeomorphism< Derived >
Cgtsam::group_action::InducedVectorField< Derived, VectorField >
Cgtsam::GroupAction< Derived, G, M >::InducedVectorField< VectorField >
Cgtsam::group_action::Orbit< Derived >
Cgtsam::ISAM2Result::DetailedResults	A struct holding detailed results, which must be enabled with ISAM2Params::enableDetailedResults
Cgtsam::DiscreteMarginals	A class for computing marginals of variables in a DiscreteFactorGraph
Cgtsam::DiscreteSearch	DiscreteSearch: Search for the K best solutions
CDiscreteValues	The Factor::error simply extracts the
Cgtsam::DoglegLineSearchImpl	This class contains an extension of the Dogleg Algorithm where a line search is performed across the Dogleg arc (interpolation of gradient and Gauss-Newton directions)
Cgtsam::DoglegOptimizerImpl	This class contains the implementation of the Dogleg algorithm
Cgtsam::DotWriter	DotWriter is a helper class for writing graphviz .dot files
Cgtsam::GraphvizFormatting	Formatting options and functions for saving a NonlinearFactorGraph instance in GraphViz format
Cgtsam::gnss::DoubleDifferenceData	Shared geometry data for double-difference factors
Cgtsam::DSFBase	A fast implementation of disjoint set forests that uses vector as underly data structure
Cgtsam::DSFVector	DSFVector additionally keeps a vector of keys to support more expensive operations
Cgtsam::DSFMap< KEY >	Disjoint set forest using an STL map data structure underneath Uses rank compression and union by rank, iterator version
Cgtsam::internal::DynamicTraits< M, N, Options, MaxRows, MaxCols >
Cgtsam::internal::DynamicTraits< 1, -1, Options, MaxRows, MaxCols >
Cgtsam::traits< Eigen::Matrix< double, 1, -1, Options, MaxRows, MaxCols > >
Cgtsam::internal::DynamicTraits<-1, -1, Options, MaxRows, MaxCols >
Cgtsam::traits< Eigen::Matrix< double, -1, -1, Options, MaxRows, MaxCols > >
Cgtsam::internal::DynamicTraits<-1, 1, Options, MaxRows, MaxCols >
Cgtsam::traits< Eigen::Matrix< double, -1, 1, Options, MaxRows, MaxCols > >
Cgtsam::Subgraph::Edge
Cgtsam::EdgeKey
Cgtsam::EliminateableFactorGraph< FACTOR_GRAPH >	EliminateableFactorGraph is a base class for factor graphs that contains elimination algorithms
Cgtsam::EliminateableFactorGraph< DiscreteFactorGraph >
Cgtsam::DiscreteFactorGraph	A Discrete Factor Graph is a factor graph where all factors are Discrete, i.e
Cgtsam::CSP	Constraint Satisfaction Problem class A specialization of a DiscreteFactorGraph
Cgtsam::Scheduler< Y, detail::PrioritySchedulerPolicy >
Cgtsam::Scheduler< Y, detail::TaskSchedulerPolicy >
Cgtsam::Scheduler< Y, Policy >	Thread pool scheduler parameterized by a queue Policy
Cgtsam::EliminateableFactorGraph< GaussianFactorGraph >
Cgtsam::GaussianFactorGraph	A Linear Factor Graph is a factor graph where all factors are Gaussian, i.e
Cgtsam::EliminateableFactorGraph< HybridGaussianFactorGraph >
Cgtsam::HybridGaussianFactorGraph
Cgtsam::EliminateableFactorGraph< SymbolicFactorGraph >
Cgtsam::SymbolicFactorGraph	Symbolic Factor Graph
Cgtsam::EliminationData< CLUSTERTREE >
Cgtsam::EliminationData< CLUSTERTREE >::EliminationPostOrderVisitor
Cgtsam::EliminationTraits< GRAPH >	Traits class for eliminateable factor graphs, specifies the types that result from elimination, etc
Cgtsam::EliminationTraits< DiscreteFactorGraph >
Cgtsam::EliminationTraits< GaussianFactorGraph >
Cgtsam::EliminationTraits< HybridGaussianFactorGraph >
Cgtsam::EliminationTraits< SymbolicFactorGraph >
Cgtsam::EliminationTree< BAYESNET, GRAPH >	An elimination tree is a data structure used intermediately during elimination
Cgtsam::EliminationTree< DiscreteBayesNet, DiscreteFactorGraph >
Cgtsam::DiscreteEliminationTree	Elimination tree for discrete factors
Cgtsam::EliminationTree< GaussianBayesNet, GaussianFactorGraph >
Cgtsam::GaussianEliminationTree
Cgtsam::EliminationTree< HybridBayesNet, HybridGaussianFactorGraph >
Cgtsam::HybridEliminationTree	Elimination Tree type for Hybrid Factor Graphs
Cgtsam::EliminationTree< SymbolicBayesNet, SymbolicFactorGraph >
Cgtsam::SymbolicEliminationTree
Cgtsam::EmptyCal	Empty calibration
Cgtsam::DSFMap< KEY >::Entry	We store the forest in an STL map, but parents are done with pointers
Cgtsam::EssentialMatrix	An essential matrix is like a Pose3, except with translation up to scale It is named after the 3*3 matrix aEb = [aTb]x aRb from computer vision, but here we choose instead to parameterize it as a (Rot3,Unit3) pair
Cgtsam::Basis< DERIVED >::EvaluationFunctor	An instance of an EvaluationFunctor calculates f(x;p) at a given x, applied to Parameters p
Cgtsam::Basis< DERIVED >::VectorComponentFunctor	Given a M*N Matrix of M-vectors at N polynomial points, an instance of VectorComponentFunctor computes the N-vector value for a specific row component of the M-vectors at all the polynomial points
Cgtsam::Basis< DERIVED >::VectorEvaluationFunctor	VectorEvaluationFunctor at a given x, applied to a parameter Matrix
Cgtsam::Basis< DERIVED >::ManifoldEvaluationFunctor< T >	Manifold EvaluationFunctor at a given x, applied to a parameter Matrix
Cgtsam::Event	A space-time event models an event that happens at a certain 3D location, at a certain time
Cstd::exception	STL class
Cgtsam::ThreadsafeException< CheiralityException >
Cgtsam::CheiralityException
Cgtsam::ThreadsafeException< CholeskyFailed >
Cgtsam::CholeskyFailed	Indicate Cholesky factorization failure
Cgtsam::ThreadsafeException< IndeterminateSystemException >
Cgtsam::IndeterminateSystemException	Thrown when a linear system is ill-posed
Cgtsam::ThreadsafeException< InvalidArgumentThreadsafe >
Cgtsam::InvalidArgumentThreadsafe	Thread-safe invalid argument exception
Cgtsam::ThreadsafeException< InvalidDenseElimination >
Cgtsam::InvalidDenseElimination
Cgtsam::ThreadsafeException< InvalidMatrixBlock >
Cgtsam::InvalidMatrixBlock	An exception indicating that a matrix block passed into a JacobianFactor has a different dimensionality than the factor
Cgtsam::ThreadsafeException< InvalidNoiseModel >
Cgtsam::InvalidNoiseModel	An exception indicating that the noise model dimension passed into a JacobianFactor has a different dimensionality than the factor
Cgtsam::ThreadsafeException< OutOfRangeThreadsafe >
Cgtsam::OutOfRangeThreadsafe	Thread-safe out of range exception
Cgtsam::ThreadsafeException< RuntimeErrorThreadsafe >
Cgtsam::RuntimeErrorThreadsafe	Thread-safe runtime error exception
Cgtsam::DynamicValuesMismatched
Cgtsam::InconsistentEliminationRequested	An inference algorithm was called with inconsistent arguments
Cgtsam::MarginalizeNonleafException	Thrown when requesting to marginalize out variables from ISAM2 that are not leaves
Cgtsam::NoMatchFoundForFixed
Cgtsam::ThreadsafeException< DERIVED >	Base exception type that uses tbb_allocator if GTSAM is compiled with TBB
Cgtsam::ValuesIncorrectType
Cgtsam::ValuesKeyAlreadyExists
Cgtsam::ValuesKeyDoesNotExist
Cstd::runtime_error	STL class
Cgtsam::MultifrontalSolverNotSupported	Exception for unsupported use of the new multifrontal solver
Cgtsam::StereoCheiralityException
Cgtsam::TriangulationCheiralityException	Exception thrown by triangulateDLT when landmark is behind one or more of the cameras
Cgtsam::TriangulationUnderconstrainedException	Exception thrown by triangulateDLT when SVD returns rank < 3
Cgtsam::internal::ExecutionTrace< T >
Cgtsam::so3::ExpmapFunctor	Opaque evaluation context at ω: caches Ω, Ω², θ, θ², nearZero/nearPi, Lazily computes C, D, E, dA, dB, dC, dE on demand
Cgtsam::so3::DexpFunctor	Functor that implements Exponential map and its derivatives Math extends Ethan theme of elegant I + aW + bWW expressions
Cgtsam::Expression< T >	Expression class that supports automatic differentiation
Cgtsam::BinarySumExpression< T >	A BinarySumExpression is a specialization of Expression that adds two expressions together It optimizes the Jacobian calculation for this specific case
Cgtsam::ScalarMultiplyExpression< T >	A ScalarMultiplyExpression is a specialization of Expression that multiplies with a scalar It optimizes the Jacobian calculation for this specific case
Cgtsam::ExpressionEqualityConstraint< T >
Cgtsam::internal::ExpressionNode< T >
Cgtsam::ExtendedKalmanFilter< VALUE >	This is a generic Extended Kalman Filter class implemented using nonlinear factors
Cgtsam::Factor
Cgtsam::BinaryMeasurement< Unit3 >
Cgtsam::BinaryMeasurement< T >
Cgtsam::DiscreteFactor	Base class for discrete probabilistic factors The most general one is the derived DecisionTreeFactor
Cgtsam::Constraint	Base class for constraint factors
Cgtsam::AllDiff	General AllDiff constraint
Cgtsam::BinaryAllDiff	Binary AllDiff constraint
Cgtsam::Domain	Constraint that restricts the possible values a particular variable, with given key, can take on
Cgtsam::SingleValue	SingleValue constraint: ensures a variable takes on a certain value
Cgtsam::DecisionTreeFactor	A discrete probabilistic factor
Cgtsam::TableFactor	A discrete probabilistic factor optimized for sparsity
Cgtsam::GaussianFactor	An abstract virtual base class for JacobianFactor and HessianFactor
Cgtsam::BatchJacobianFactorBase	Common interface for compact batch Jacobian factors
Cgtsam::BatchJacobianFactor< ErrorDim, BlockDims... >
Cgtsam::BatchJacobianFactor< ErrorDim, BlockDims >	Fixed-dimension row-sparse batch Jacobian factor
Cgtsam::HessianFactor	A Gaussian factor using the canonical parameters (information form)
Cgtsam::RegularHessianFactor< Base::Dim >
Cgtsam::RegularHessianFactor< D >	A HessianFactor where all variables have the same dimension D
Cgtsam::JacobianFactor	A Gaussian factor in the squared-error form
Cgtsam::FixedJacobianFactor< M, Ns >	A JacobianFactor whose residual and variable dimensions are known at compile time
Cgtsam::GaussianConditional	A GaussianConditional functions as the node in a Bayes network
Cgtsam::RegularJacobianFactor< D >	JacobianFactor with constant sized blocks Provides raw memory access versions of linear operator
Cgtsam::JacobianFactorQ< Base::Dim, 2 >
Cgtsam::JacobianFactorQ< D, ZDim >	JacobianFactor for Schur complement that uses Q noise model
Cgtsam::JacobianFactorQR< D, ZDim >	JacobianFactor for Schur complement that uses Q noise model
Cgtsam::JacobianFactorSVD< D, ZDim >	JacobianFactor for Schur complement that uses the "Nullspace Trick" by Mourikis et al
Cgtsam::RegularImplicitSchurFactor< CAMERA >	RegularImplicitSchurFactor
Cgtsam::HybridFactor	Base class for truly hybrid probabilistic factors
Cgtsam::HybridConditional	Hybrid Conditional Density
Cgtsam::HybridGaussianFactor	Implementation of a discrete-conditioned hybrid factor
Cgtsam::HybridGaussianConditional	A conditional of gaussian conditionals indexed by discrete variables, as part of a Bayes Network
Cgtsam::HybridNonlinearFactor	Implementation of a discrete-conditioned hybrid factor
Cgtsam::NonlinearFactor	Nonlinear factor base class
Cgtsam::SmartFactorBase< StereoCamera >
Cgtsam::SmartStereoProjectionFactor	SmartStereoProjectionFactor: triangulates point and keeps an estimate of it around
Cgtsam::SmartStereoProjectionFactorPP	If you are using the factor, please cite: L
Cgtsam::SmartStereoProjectionPoseFactor	If you are using the factor, please cite: L
Cgtsam::SmartFactorBase< PinholePose< CALIBRATION > >
Cgtsam::SmartProjectionFactorBase< PinholePose< CALIBRATION > >
Cgtsam::SmartProjectionPoseFactor< CALIBRATION >	If you are using the factor, please cite: L
Cgtsam::AntiFactor	A class for downdating an existing factor from a graph
Cgtsam::BatchFactor< FactorType, ErrorDim >	BatchFactor is a NonlinearFactor that wraps a collection of identical factors
Cgtsam::BetweenFactorEM< VALUE >	A class for a measurement predicted by "between(config[key1],config[key2])"
Cgtsam::KarcherMeanFactor< T >	The KarcherMeanFactor creates a constraint on all SO(n) variables with given keys that the Karcher mean (see above) will stay the same
Cgtsam::LinearContainerFactor	Dummy version of a generic linear factor to be injected into a nonlinear factor graph
Cgtsam::NoiseModelFactor	A nonlinear sum-of-squares factor with a zero-mean noise model implementing the density \( P(z|x) \propto exp -0.5*|z-h(x)|^2_C \) Templated on the parameter type X and the values structure Values There is no return type specified for h(x)
Cgtsam::ExpressionFactor< double >
Cgtsam::TOAFactor	A "Time of Arrival" factor - so little code seems hardly worth it :-)
Cgtsam::MultiProjectionFactor< POSE, LANDMARK, CALIBRATION >
Cgtsam::NoiseModelFactorT< Vector3, Rot3, Rot3, Vector3 >
Cgtsam::AHRSFactorT< PreintegratedAhrsMeasurements >
Cgtsam::AHRSFactorT< PIM >	An AHRSFactor is a three-way factor that is based on the preintegrated gyroscope measurements
Cgtsam::NoiseModelFactorT< Vector1, Pose3, double >
Cgtsam::BarometricFactor	Prior on height in a cartesian frame
Cgtsam::PseudorangeFactorArm	GNSS pseudorange factor with lever arm correction
Cgtsam::NoiseModelFactorT< Vector1, Point3, double, double >
Cgtsam::CarrierPhaseFactor	Undifferenced GNSS carrier phase factor for point positioning
Cgtsam::DifferentialPseudorangeFactor
Cgtsam::DoubleDifferenceCarrierPhaseFactor	Double-difference carrier phase factor
Cgtsam::NoiseModelFactorT< Vector1, Pose3, double, double >
Cgtsam::CarrierPhaseFactorArm	Carrier phase factor with lever arm correction
Cgtsam::DifferentialPseudorangeFactorArm	Differentially-corrected pseudorange factor with lever arm correction
Cgtsam::DoubleDifferenceCarrierPhaseFactorArm	Double-difference carrier phase factor with lever arm correction
Cgtsam::NoiseModelFactorT< Vector9, NavState, NavState >
Cgtsam::ConstantVelocityFactor	Binary factor for applying a constant velocity model to a moving body represented as a NavState
Cgtsam::NoiseModelFactorT< Vector1, Vector3, double, double >
Cgtsam::DopplerFactor	GNSS Doppler (range-rate) factor
Cgtsam::NoiseModelFactorT< Vector3, Pose3, Point3 >
Cgtsam::BiasedGPSFactor	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
Cgtsam::GPSFactorArmCalib	Version of GPSFactorArm (for Pose3) with unknown lever arm between GPS and Body frame
Cgtsam::Pose3PointContactFactor	Contact factor between a Pose3 and a foothold point variable
Cgtsam::NoiseModelFactorT< Vector3, NavState, Point3 >
Cgtsam::GPSFactor2ArmCalib	Version of GPSFactor2Arm for an unknown lever arm between GPS and Body frame
Cgtsam::NavStatePointContactFactor	Contact factor between a NavState and a foothold point variable
Cgtsam::NoiseModelFactorT< Vector9, Pose3, Vector3, Pose3, Vector3, imuBias::ConstantBias >
Cgtsam::ImuFactorT< PreintegratedImuMeasurementsG >
Cgtsam::ImuFactorT< PIM >
Cgtsam::ImuFactorT< PIM >	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
Cgtsam::NoiseModelFactorT< Vector9, NavState, NavState, imuBias::ConstantBias >
Cgtsam::ImuFactor2T< PreintegratedImuMeasurementsG >
Cgtsam::ImuFactor2T< PIM >
Cgtsam::ImuFactor2T< PIM >	ImuFactor2 is a ternary factor that uses NavStates rather than Pose/Velocity
Cgtsam::NoiseModelFactorT< Vector9, NavState, NavState, imuBias::ConstantBias, GRAVITY >
Cgtsam::ImuFactor2WithGravityT< PIM, GRAVITY >
Cgtsam::NoiseModelFactorT< Vector3, Point3, Point3 >
Cgtsam::MagFactor2	Factor to calibrate local Earth magnetic field as well as magnetometer bias This version uses model measured bM = bRn * nM + bias and optimizes for both nM and the bias, where nM is in units defined by magnetometer
Cgtsam::TranslationFactor	Binary factor for a relative translation direction measurement w_aZb
Cgtsam::NoiseModelFactorT< Vector3, double, Unit3, Point3 >
Cgtsam::MagFactor3	Factor to calibrate local Earth magnetic field as well as magnetometer bias This version uses model measured bM = scale * bRn * direction + bias and optimizes for both scale, direction, and the bias
Cgtsam::NoiseModelFactorT< Vector3, Pose2, Pose2, double >
Cgtsam::PlanarGyroFactor	A "between" factor for Pose2 rotation, with variable bias
Cgtsam::NoiseModelFactorT< Vector1, Point3, double >
Cgtsam::PseudorangeFactor	Simplified GNSS pseudorange model for basic positioning problems
Cgtsam::NoiseModelFactorT< OutputVec, ValueTypes... >
Cgtsam::NoiseModelFactorT< Vector, ValueTypes... >
Cgtsam::CombinedImuFactorT< PIM >
Cgtsam::CombinedImuFactorT< PreintegratedCombinedMeasurementsG >
Cgtsam::CombinedImuFactorWithGravityT< PIM, GRAVITY >
Cgtsam::CombinedImuFactorWithGravityT< PreintegratedCombinedMeasurements, Unit3 >
Cgtsam::CombinedImuFactorWithGravityT< PreintegratedCombinedMeasurements, Point3 >
Cgtsam::ExtendedPriorFactor< T >
Cgtsam::ConcentratedGaussian< T >	A nonlinear density, inherits from ExtendedPriorFactor
Cgtsam::FunctorizedFactor< double, Vector >
Cgtsam::EvaluationFactor< BASIS >	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
Cgtsam::FunctorizedFactor< Vector, Matrix >
Cgtsam::VectorDerivativeFactor< BASIS >	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
Cgtsam::VectorEvaluationFactor< BASIS >	Unary factor for enforcing BASIS polynomial evaluation on a parameter Matrix of size (M, N) is equal to a vector-valued measurement at the same point, when using a pseudo-spectral parameterization
Cgtsam::FunctorizedFactor< double, Matrix >
Cgtsam::ComponentDerivativeFactor< BASIS >	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
Cgtsam::VectorComponentFactor< BASIS >	Unary factor for enforcing BASIS polynomial evaluation on a parameter Matrix of size (P, N) is equal to specified measurement at the same point, when using a pseudo-spectral parameterization
Cgtsam::FunctorizedFactor< T, Matrix >
Cgtsam::ManifoldEvaluationFactor< BASIS, T >	For a measurement value of type T i.e
Cgtsam::FunctorizedFactor< double, typename BASIS::Parameters >
Cgtsam::FunctorizedFactor< double, BASIS::Parameters >
Cgtsam::DerivativeFactor< BASIS >	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
Cgtsam::ImuFactorWithGravityT< PIM, GRAVITY >
Cgtsam::ImuFactorWithGravityT< PreintegratedImuMeasurements, Unit3 >
Cgtsam::ImuFactorWithGravityT< PreintegratedImuMeasurements, Point3 >
Cgtsam::ProjectionFactorPPPC< POSE, LANDMARK, CALIBRATION >
Cgtsam::QuadraticRangeFactor< 2 >
Cgtsam::QuadraticRangeFactor< 3 >
Cgtsam::RelativeTranslationFactor< 2 >
Cgtsam::RelativeTranslationFactor< 3 >
Cgtsam::ShonanFactor< 2 >
Cgtsam::ShonanFactor< 3 >
Cgtsam::TransferFactor< EM >
Cgtsam::TransferFactor< EssentialMatrix >
Cgtsam::EssentialTransferFactor< K >	Transfers points between views using essential matrices with a shared calibration
Cgtsam::AttitudeFactor< VALUE >	Unary factor that constrains the rotation component of a value
Cgtsam::CombinedImuFactorT< PIM >	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)
Cgtsam::CombinedImuFactorWithGravityT< PIM, GRAVITY >	CombinedImuFactorWithGravityT is CombinedImuFactorT with an additional GRAVITY variable, so that gravity can be optimized instead of being fixed by the preintegration parameters
Cgtsam::DeltaFactorBase	DeltaFactorBase: relative 2D measurement between Pose2 and Point2, with Basenodes
Cgtsam::DopplerFactorArm	DopplerFactor with a kinematic lever-arm correction, keyed on a body Pose3
Cgtsam::DoubleDifferencePseudorangeFactor	Double-difference pseudorange factor
Cgtsam::DoubleDifferencePseudorangeFactorArm	Double-difference pseudorange factor with lever arm correction
Cgtsam::EssentialMatrixFactor	Factor that evaluates epipolar error p'Ep for given essential matrix
Cgtsam::EssentialTransferFactorK< K >	Transfers points between views using essential matrices, optimizes for calibrations of the views, as well
Cgtsam::ExtendedPoseContactFactor	Contact factor for the ExtendedPose3(2+k) graph-update variant
Cgtsam::ExtendedPoseHeightFactor	Height factor for the ExtendedPose3(2+k) graph-update variant
Cgtsam::ExtendedPriorFactor< VALUE >	A class for a soft prior on any Value type, but with a non-zero mean in the tangent space
Cgtsam::PriorFactor< Point2 >
Cgtsam::PriorFactor< StereoPoint2 >
Cgtsam::PriorFactor< Point3 >
Cgtsam::PriorFactor< Rot2 >
Cgtsam::PriorFactor< Rot3 >
Cgtsam::PriorFactor< Pose2 >
Cgtsam::PriorFactor< Pose3 >
Cgtsam::PriorFactor< SL4 >
Cgtsam::PriorFactor< Cal3_S2 >
Cgtsam::PriorFactor< Cal3DS2 >
Cgtsam::PriorFactor< CalibratedCamera >
Cgtsam::PriorFactor< PinholeCameraCal3_S2 >
Cgtsam::PriorFactor< StereoCamera >
Cgtsam::PriorFactor< VALUE >	A class for a soft prior on any Value type
Cgtsam::FrobeniusPrior< T >	FrobeniusPrior calculates the Frobenius norm between a given matrix and a fixed-size matrix Lie group element
Cgtsam::FunctorizedFactor< R, T >	Factor which evaluates provided unary functor and uses the result to compute error with respect to the provided measurement
Cgtsam::FunctorizedFactor2< R, T1, T2 >	Factor which evaluates provided binary functor and uses the result to compute error with respect to the provided measurement
Cgtsam::GPSFactor	Prior on position in a Cartesian frame
Cgtsam::GPSFactor2	Version of GPSFactor for NavState, assuming zero lever arm between body frame and GPS
Cgtsam::GPSFactor2Arm	Version of GPSFactor2 with lever arm between GPS and Body frame
Cgtsam::GPSFactorArm	Version of GPSFactor (for Pose3) with lever arm between GPS and Body frame
Cgtsam::ImuFactorWithGravityT< PIM, GRAVITY >	ImuFactorWithGravityT is a 6-ways factor: in addition to the previous and current states (pose and velocity) and the bias estimate of ImuFactorT, it involves a GRAVITY variable so that gravity can be optimized instead of being fixed by the preintegration parameters
Cgtsam::KnownLandmarkFactor< T >	A unary known-landmark factor using the conventional GTSAM state direction
Cgtsam::KnownLandmarkFactor2< T >	A unary known-landmark factor using a k-from-world state direction
Cgtsam::MagFactor	Factor to estimate rotation given magnetometer reading This version uses model measured bM = scale * bRn * direction + bias and assumes scale, direction, and the bias are given
Cgtsam::MagFactor1	Factor to estimate rotation given magnetometer reading This version uses model measured bM = scale * bRn * direction + bias and assumes scale, direction, and the bias are given
Cgtsam::MagPoseFactor< POSE >	Factor to estimate rotation of a Pose2 or Pose3 given a magnetometer reading
Cgtsam::OdometryFactorBase	OdometryFactorBase: Pose2 odometry, with Basenodes
Cgtsam::OrientedPlane3DirectionPrior
Cgtsam::PlanarProjectionFactor1	One variable: the pose
Cgtsam::PointHeightFactor	Height factor on a standalone foothold point variable
Cgtsam::PosePriorFactor< POSE >	A class for a soft prior on any Value type
Cgtsam::PoseRotationPrior< POSE >
Cgtsam::PoseTranslationPrior< POSE >	A prior on the translation part of a pose
Cgtsam::ProjectionFactorPPPC< POSE, LANDMARK, CALIBRATION >	Non-linear factor for a constraint derived from a 2D measurement
Cgtsam::QuadraticRangeFactor< d >
Cgtsam::RelativeTranslationFactor< d >
Cgtsam::RotateDirectionsFactor	Factor on unknown rotation iRc that relates two directions c Directions provide less constraints than a full rotation
Cgtsam::RotateFactor	Factor on unknown rotation iRC that relates two incremental rotations c1Rc2 = iRc' * i1Ri2 * iRc Which we can write (see doc/math.lyx) e^[z] = iRc' * e^[p] * iRc = e^([iRc'*p]) with z and p measured and predicted angular velocities, and hence p = iRc * z
Cgtsam::ShonanFactor< d >	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
Cgtsam::TransferFactor< F >	Binary factor in the context of Structure from Motion (SfM)
Cgtsam::TriangulationFactor< CAMERA >	Non-linear factor for a constraint derived from a 2D measurement
Cgtsam::UndifferencedCarrierPhaseFactor	Undifferenced (raw) PPP carrier phase factor
Cgtsam::UndifferencedCarrierPhaseFactorArm	Undifferenced (raw) PPP carrier phase factor with lever-arm correction
Cgtsam::UndifferencedPseudorangeFactor	Undifferenced (raw) PPP pseudorange factor
Cgtsam::UndifferencedPseudorangeFactorArm	Undifferenced (raw) PPP pseudorange factor with lever-arm correction
Cgtsam::VectorNormFactor< N >	Unary factor constraining the norm of an N-dimensional vector-space variable to a given value, with error = ||v|| - norm
Cgtsam::WahbaFactor	A chordal Wahba factor relating two directions through an unknown rotation
Cgtsam::WnoaMotionFactor< Pose >	WNOA (White Noise on Acceleration) motion prior factor
Cgtsam::NoiseModelFactorT< ErrorVector, A1, A2 >
Cgtsam::NoiseModelFactorT< typename traits< T >::TangentVector, A1, A2 >
Cgtsam::NoiseModelFactorT< typename traits< T >::TangentVector, A1, A2, T >
Cgtsam::NoiseModelFactorT< Vector5, Pose3, Pose3 >
Cgtsam::EssentialMatrixConstraint	Binary factor between two Pose3 variables induced by an EssentialMatrix measurement
Cgtsam::NoiseModelFactorT< Vector2, EssentialMatrix, double >
Cgtsam::EssentialMatrixFactor2	Binary factor that optimizes for E and inverse depth d: assumes measurement in image 2 is perfect, and returns re-projection error in image 1
Cgtsam::EssentialMatrixFactor3	Binary factor that optimizes for E and inverse depth d: assumes measurement in image 2 is perfect, and returns re-projection error in image 1 This version takes an extrinsic rotation to allow for omni-directional rigs
Cgtsam::NoiseModelFactorT< Vector1, EssentialMatrix, CALIBRATION >
Cgtsam::EssentialMatrixFactor4< CALIBRATION >	Binary factor that optimizes for E and calibration K using the algebraic epipolar error (K^-1 pA)'E (K^-1 pB)
Cgtsam::NoiseModelFactorT< Vector1, EssentialMatrix, CALIBRATION, CALIBRATION >
Cgtsam::EssentialMatrixFactor5< CALIBRATION >	Binary factor that optimizes for E and two calibrations Ka and Kb using the algebraic epipolar error (Ka^-1 pA)'E (Kb^-1 pB)
Cgtsam::NoiseModelFactorT< Vector2, double, double >
Cgtsam::SelfCalibrationFactor	Binary factor measuring how close a fundamental matrix is to admitting a valid essential matrix, as a function of the two cameras' focal lengths
Cgtsam::NoiseModelFactorT< Vector3, Point3, Point3, Vector1 >
Cgtsam::BilinearAngleTranslationFactor	Binary factor for a relative translation direction measurement w_aZb
Cgtsam::NoiseModelFactorT< ErrorVector, VALUE, VALUE >
Cgtsam::NoiseModelFactorT< FrobeniusErrorVector< T >, T, T >
Cgtsam::FrobeniusBetweenFactorNL< T >	FrobeniusBetweenFactorNL is a BetweenFactor that evaluates the Frobenius norm of the matrix error between measured and predicted (rather than the Logmap of the error)
Cgtsam::FrobeniusBetweenFactor< T >	FrobeniusBetweenFactor uses ||T2 - T1*T12_||_F, which only works if the Frobenius error is invariant to multiplying with an arbitrary element T
Cgtsam::FrobeniusLeftBetweenFactor< T >	FrobeniusLeftBetweenFactor uses ||iTw - iTj*jTw||_F, where measured iTj maps frame j into frame i
Cgtsam::FrobeniusFactor< T >	FrobeniusFactor calculates the Frobenius norm between matrix Lie group elements
Cgtsam::NoiseModelFactorT< VectorD, T, T >
Cgtsam::NoiseModelFactorT< ErrorVector, CAMERA, LANDMARK >
Cgtsam::NoiseModelFactorT< Vector2, Pose3, Point3, CALIBRATION >
Cgtsam::GeneralSFMFactor2< CALIBRATION >	Non-linear factor for a constraint derived from a 2D measurement
Cgtsam::NoiseModelFactorT< Vector3, Pose3, OrientedPlane3 >
Cgtsam::OrientedPlane3Factor	Factor to measure a planar landmark from a given pose
Cgtsam::NoiseModelFactorT< Vector2, Pose2, Point3 >
Cgtsam::PlanarProjectionFactor2	Two unknowns: the pose and the landmark
Cgtsam::NoiseModelFactorT< Vector2, Pose2, Pose3, Cal3DS2 >
Cgtsam::PlanarProjectionFactor3	Three unknowns: the pose, the camera offset, and the camera calibration
Cgtsam::NoiseModelFactorT< Vector2, POSE, LANDMARK >
Cgtsam::GenericProjectionFactor< POSE, LANDMARK, CALIBRATION >
Cgtsam::NoiseModelFactorT< typename traits< POINT >::TangentVector, POINT, TRANSFORM, POINT >
Cgtsam::NoiseModelFactorT< Vector3, POSE, LANDMARK >
Cgtsam::GenericStereoFactor< POSE, LANDMARK >	A Generic Stereo Factor
Cgtsam::NoiseModelFactorT< typename traits< VALUE >::TangentVector, VALUE, VALUE >
Cgtsam::NoiseModelFactorT< Vector2, POSE, LANDMARK, INVDEPTH >
Cgtsam::InvDepthFactor3< POSE, LANDMARK, INVDEPTH >	Ternary factor representing a visual measurement that includes inverse depth
Cgtsam::NoiseModelFactorT< Vector2, Pose3, Vector6 >
Cgtsam::InvDepthFactorVariant1	Binary factor representing a visual measurement using an inverse-depth parameterization
Cgtsam::NoiseModelFactorT< Vector2, Pose3, Vector3 >
Cgtsam::InvDepthFactorVariant2	Binary factor representing a visual measurement using an inverse-depth parameterization
Cgtsam::InvDepthFactorVariant3a	Binary factor representing the first visual measurement using an inverse-depth parameterization
Cgtsam::NoiseModelFactorT< Vector2, Pose3, Pose3, Vector3 >
Cgtsam::InvDepthFactorVariant3b	Ternary factor representing a visual measurement using an inverse-depth parameterization
Cgtsam::NoiseModelFactorT< Vector3, Pose3, Pose3, OrientedPlane3 >
Cgtsam::LocalOrientedPlane3Factor	Factor to measure a planar landmark from a given pose, with a given local linearization point
Cgtsam::NoiseModelFactorT< typename traits< POSE >::TangentVector, POSE, POSE >
Cgtsam::NoiseModelFactorT< typename traits< POINT >::TangentVector, POSE, POINT >
Cgtsam::NoiseModelFactorT< Vector2, POSE, POSE, LANDMARK >
Cgtsam::ProjectionFactorPPP< POSE, LANDMARK, CALIBRATION >
Cgtsam::ProjectionFactorPPP< POSE, LANDMARK, CALIBRATION >	Non-linear factor for a constraint derived from a 2D measurement
Cgtsam::NoiseModelFactorT< Vector2, Pose3, Pose3, Point3 >
Cgtsam::ProjectionFactorRollingShutter	Non-linear factor for 2D projection measurement obtained using a rolling shutter camera
Cgtsam::NoiseModelFactorT< Vector1, Pose3, Point3 >
Cgtsam::RelativeElevationFactor	Binary factor for a relative elevation
Cgtsam::NoiseModelFactorT< Vector2, Pose2, Point2 >
Cgtsam::DeltaFactor	DeltaFactor: relative 2D measurement between Pose2 and Point2
Cgtsam::NoiseModelFactorT< traits< typename Bearing< A1, A2 >::result_type >::TangentVector, A1, A2 >
Cgtsam::NoiseModelFactorT< traits< BearingRange< A1, A2, typename Bearing< A1, A2 >::result_type, typename Range< A1, A2 >::result_type > >::TangentVector, A1, A2 >
Cgtsam::NoiseModelFactorT< traits< VALUE >::TangentVector, VALUE, VALUE >
Cgtsam::BetweenFactor< VALUE >	A class for a measurement predicted by "between(config[key1],config[key2])"
Cgtsam::BetweenConstraint< VALUE >	Binary between constraint - forces between to a given value This constraint requires the underlying type to a Lie type
Cgtsam::GaussMarkov1stOrderFactor< VALUE >
Cgtsam::NoiseModelFactorT< traits< CAMERA::Measurement >::TangentVector, CAMERA, LANDMARK >
Cgtsam::GeneralSFMFactor< CAMERA, LANDMARK >	Non-linear factor for a constraint derived from a 2D measurement
Cgtsam::NoiseModelFactorT< Vector2, Pose3, Point3 >
Cgtsam::GenericProjectionFactor< Pose3, Point3, Cal3_S2 >
Cgtsam::GenericProjectionFactor< Pose3, Point3, Cal3DS2 >
Cgtsam::GenericProjectionFactor< POSE, LANDMARK, CALIBRATION >	Non-linear factor for a constraint derived from a 2D measurement
Cgtsam::NoiseModelFactorT< Vector9, NavState, NavState, imuBias::ConstantBias, Unit3 >
Cgtsam::ImuFactor2WithGravityT< PreintegratedImuMeasurements, Unit3 >
Cgtsam::ImuFactor2WithGravityT< PIM, GRAVITY >	ImuFactor2WithGravityT is the NavState version of ImuFactorWithGravityT, just as ImuFactor2T is the NavState version of ImuFactorT: a 4-ways factor involving the previous and current NavStates, the bias estimate, and a GRAVITY variable so that gravity can be optimized instead of being fixed by the preintegration parameters
Cgtsam::NoiseModelFactorT< traits< POSE >::TangentVector, POSE, POSE >
Cgtsam::PoseBetweenFactor< POSE >	A class for a measurement predicted by "between(config[key1],config[key2])"
Cgtsam::NoiseModelFactorT< traits< Point3 >::TangentVector, Pose3, Point3 >
Cgtsam::PoseToPointFactor< POSE, POINT >	A class for a measurement between a pose and a point
Cgtsam::NoiseModelFactorT< traits< double >::TangentVector, A1, A1 >
Cgtsam::RangeFactor< A1, A2, T >	Binary factor for a range measurement Works for any two types A1,A2 for which the functor Range<A1,A2>() is defined
Cgtsam::NoiseModelFactorT< traits< typename Range< A1, A1 >::result_type >::TangentVector, A1, A1 >
Cgtsam::NoiseModelFactorT< traits< typename Range< A1, A1 >::result_type >::TangentVector, A1, A1, typename Range< A1, A1 >::result_type >
Cgtsam::NoiseModelFactorT< traits< POINT >::TangentVector, POINT, TRANSFORM, POINT >
Cgtsam::ReferenceFrameFactor< POINT, TRANSFORM >	A constraint between two landmarks in separate maps Templated on: Point : Type of landmark Transform : Transform variable class
Cgtsam::CustomFactor
Cgtsam::ExpressionFactor< T >	Factor that supports arbitrary expressions via AD
Cgtsam::ExpressionFactorN< T, Args >	N-ary variadic template for ExpressionFactor meant as a base class for N-ary factors
Cgtsam::MultiProjectionFactor< POSE, LANDMARK, CALIBRATION >	Non-linear factor for a constraint derived from a 2D measurement
Cgtsam::NoiseModelFactorT< OutputVec, ValueTypes >	A convenient base class for creating your own NoiseModelFactor with n variables
Cgtsam::BearingFactor< A1, A2, T >
Cgtsam::BearingRangeFactor< A1, A2, B, R >
Cgtsam::BearingRangeFactor< Pose2, Point2 >
Cgtsam::BearingRangeFactor< Pose3, Point3 >
Cgtsam::BetweenFactor< double >
Cgtsam::PlanarGyroBiasFactor	Models the evolution of the bias itself as a random walk
Cgtsam::BetweenFactor< Point2 >
Cgtsam::BetweenFactor< Point3 >
Cgtsam::BetweenFactor< Rot2 >
Cgtsam::BetweenFactor< Rot3 >
Cgtsam::BetweenFactor< Pose2 >
Cgtsam::BetweenFactor< Pose3 >
Cgtsam::BetweenFactor< SL4 >
Cgtsam::GeneralSFMFactor< gtsam::PinholeCameraCal3_S2, gtsam::Point3 >
Cgtsam::GeneralSFMFactor< gtsam::PinholeCameraCal3DS2, gtsam::Point3 >
Cgtsam::GeneralSFMFactor< gtsam::SphericalCamera, gtsam::Point3 >
Cgtsam::GeneralSFMFactor2< gtsam::Cal3_S2 >
Cgtsam::GenericStereoFactor< gtsam::Pose3, gtsam::Point3 >
Cgtsam::ImuFactor2WithGravityT< PreintegratedImuMeasurements, Point3 >
Cgtsam::RangeFactor< A1, A2, T >
Cgtsam::RangeFactor< Pose2, Point2 >
Cgtsam::RangeFactor< Pose3, Point3 >
Cgtsam::RangeFactor< Pose2, Pose2 >
Cgtsam::RangeFactor< Pose3, Pose3 >
Cgtsam::RangeFactor< CalibratedCamera, Point3 >
Cgtsam::RangeFactor< PinholeCameraCal3_S2, Point3 >
Cgtsam::RangeFactor< CalibratedCamera, CalibratedCamera >
Cgtsam::RangeFactor< PinholeCameraCal3_S2, PinholeCameraCal3_S2 >
Cgtsam::RangeFactorWithTransform< A1, A2, T >
Cgtsam::RangeFactorWithTransformBias< A1, A2, T >
Cgtsam::BearingFactor< A1, A2, T >	Binary factor for a bearing measurement Works for any two types A1,A2 for which the functor Bearing<A1,A2>() is defined
Cgtsam::BearingRangeFactor< A1, A2, B, R >	Binary factor for a bearing/range measurement
Cgtsam::RangeFactorWithTransform< A1, A2, T >	Binary factor for a range measurement, with a transform applied
Cgtsam::RangeFactorWithTransformBias< A1, A2, T >	Ternary factor for a range measurement with a fixed sensor transform and an additive bias term
Cgtsam::SmartRangeFactor	Smart factor for range SLAM
Cgtsam::WnoaInterpFactor< PoseType >	Wrapper factor that evaluates an inner NoiseModelFactor on states interpolated from neighboring estimated states using a WNOA (white-noise-on-acceleration) Gaussian process interpolator
Cgtsam::ShonanGaugeFactor	The ShonanGaugeFactor creates a constraint on a single SO(n) to avoid moving in the stabilizer
Cgtsam::SmartFactorBase< CAMERA >	Base class for smart factors
Cgtsam::SmartProjectionFactorBase< Camera >
Cgtsam::SmartProjectionFactorBase< CAMERA >	Common base for monocular smart projection factors
Cgtsam::SmartProjectionFactor< CAMERA >	Smart factor for monocular cameras whose pose and calibration are variables
Cgtsam::SmartProjectionPoseFactorRollingShutter< CAMERA >	If you are using the factor, please cite: L
Cgtsam::SmartProjectionRigFactor< CAMERA >	If you are using the factor, please cite: L
Cgtsam::TransformBtwRobotsUnaryFactor< VALUE >	A class for a measurement predicted by "between(config[key1],config[key2])"
Cgtsam::TransformBtwRobotsUnaryFactorEM< VALUE >	A class for a measurement predicted by "between(config[key1],config[key2])"
Cgtsam::WhiteNoiseFactor	Binary factor to estimate parameters of zero-mean Gaussian white noise
Cgtsam::SymbolicFactor	SymbolicFactor represents a symbolic factor that specifies graph topology but is not associated with any numerical function
Cgtsam::SymbolicConditional	SymbolicConditional is a conditional with keys but no probability data, produced by symbolic elimination of SymbolicFactor
Cgtsam::internal::IndexedSymbolicFactor	A SymbolicFactor that stores the index of the originating factor
Cgtsam::UnaryMeasurement< T >	Unary measurement represents a measurement on a single key in a graph
CFACTOR_TYPE
Cgtsam::GenericGraduatedFactor< FACTOR_TYPE >	Instantiation of Graduated Factor wrapping any Nonlinear Factor
Cgtsam::FactorGraph< FACTOR >	A factor graph is a bipartite graph with factor nodes connected to variable nodes
Cgtsam::BayesNet< DiscreteConditional >
Cgtsam::DiscreteBayesNet	A Bayes net made from discrete conditional distributions
Cgtsam::BayesNet< DiscreteLookupTable >
Cgtsam::DiscreteLookupDAG	A DAG made from lookup tables, as defined above
Cgtsam::BayesNet< HybridConditional >
Cgtsam::HybridBayesNet	A hybrid Bayes net is a collection of HybridConditionals, which can have discrete conditionals, hybrid Gaussian conditionals, or pure Gaussian conditionals
Cgtsam::BayesNet< GaussianConditional >
Cgtsam::GaussianBayesNet	GaussianBayesNet is a Bayes net made from linear-Gaussian conditionals
Cgtsam::BayesNet< SymbolicConditional >
Cgtsam::SymbolicBayesNet	A SymbolicBayesNet is a Bayes Net of purely symbolic conditionals
Cgtsam::FactorGraph< CONDITIONAL >
Cgtsam::BayesNet< CONDITIONAL >	A BayesNet is a tree of conditionals, stored in elimination order
Cgtsam::FactorGraph< DiscreteFactor >
Cgtsam::DiscreteFactorGraph	A Discrete Factor Graph is a factor graph where all factors are Discrete, i.e
Cgtsam::FactorGraph< Factor >
Cgtsam::ConstructorTraversalData< BAYESTREE, GRAPH, ETREE_NODE >::SymbolicFactors
Cgtsam::HybridFactorGraph	Hybrid Factor Graph Factor graph with utilities for hybrid factors
Cgtsam::HybridGaussianFactorGraph
Cgtsam::HybridNonlinearFactorGraph
Cgtsam::FactorGraph< GaussianFactor >
Cgtsam::GaussianFactorGraph	A Linear Factor Graph is a factor graph where all factors are Gaussian, i.e
Cgtsam::FactorGraph< NonlinearFactor >
Cgtsam::NonlinearFactorGraph
Cgtsam::ExpressionFactorGraph	Factor graph that supports adding ExpressionFactors directly
Cgtsam::WnoaFactorGraph< PoseType >	Factor graph specialized for WNOA interpolation-aware computation
Cgtsam::FactorGraph< SymbolicFactor >
Cgtsam::SymbolicFactorGraph	Symbolic Factor Graph
Cstd::false_type
Cgtsam::detail::is_extended_pose3< gtsam::ExtendedPose3< K, Derived > >
Cgtsam::internal::HasLocalJacobians< T, std::void_t< decltype(traits< T >::Local(std::declval< const T & >(), std::declval< const T & >(), std::declval< typename traits< T >::ChartJacobian >(), std::declval< typename traits< T >::ChartJacobian >()))> >
Cgtsam::internal::IsCompatibleSemidirectAction< Action, G, H, std::void_t< decltype(Action::type), decltype(Action::generator(std::declval< const typename traits< G >::TangentVector & >()))> >
Cgtsam::internal::ProductLieGroupIsVector< Eigen::Matrix< double, N, 1 > >
Cgtsam::internal::SemidirectLieGroupHasAdjointMap< T, std::void_t< decltype(T::adjointMap(std::declval< const typename traits< T >::TangentVector & >()))> >
Cgtsam::internal::SemidirectLieGroupIsVector< Eigen::Matrix< double, N, 1 > >
Cgtsam::internal::TangentLieGroupHasAdjointMap< T, std::void_t< decltype(T::adjointMap(std::declval< const typename traits< T >::TangentVector & >()))> >
Cgtsam::detail::is_extended_pose3< T >
Cgtsam::internal::HasLocalJacobians< T, class >	Detect whether a traits type provides Local with Jacobians
Cgtsam::internal::IsCompatibleSemidirectAction< Action, G, H, typename >	Validates the action contract used by SemidirectLieGroup's group law and matrix-function kernels
Cgtsam::internal::ProductLieGroupIsVector< T >	Detects vector-space Lie groups (Eigen column vectors, group law = addition)
Cgtsam::internal::SemidirectLieGroupHasAdjointMap< T, typename >	Detects the optional static algebra adjoint on the base group
Cgtsam::internal::SemidirectLieGroupIsVector< T >	Recognizes the vector-space second factor required by SemidirectLieGroup
Cgtsam::internal::TangentLieGroupHasAdjointMap< T, typename >	Enforces the static algebra-adjoint requirement of TangentLieGroup and AdjointAction below
Cgtsam::internal::FastDefaultAllocator< T >	Default allocator for list, map, and set types
Cgtsam::internal::FastDefaultVectorAllocator< T >	Default allocator for vector types (we never use boost pool for vectors)
Cgtsam::FastSync< T >	Solver for the fixed-size ambient linear problem underlying FAST-Sync
Cgtsam::FastSyncProjection< T >	Projection customization point used by fastSync()
Cgtsam::FastSyncProjection< Pose2 >	Project an ambient 3-by-3 homogeneous matrix onto Pose2
Cgtsam::FastSyncProjection< Pose3 >	Project an ambient 4-by-4 homogeneous matrix onto Pose3
Cgtsam::FastSyncProjection< Rot2 >	Project an ambient 2-by-2 matrix onto Rot2
Cgtsam::FastSyncProjection< Rot3 >	Project an ambient 3-by-3 matrix onto Rot3
Cgtsam::FastSyncProjection< Similarity2 >	Project an ambient 3-by-3 matrix onto Similarity2
Cgtsam::FastSyncProjection< Similarity3 >	Project an ambient 4-by-4 matrix onto Similarity3
Cgtsam::FastSyncProjection< SL4 >	Project an ambient 4-by-4 matrix onto SL4
CFastVector
Cgtsam::Scatter	Scatter is an intermediate data structure used when building a HessianFactor incrementally, to get the keys in the right order
Cgtsam::FitBasis< Basis >	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();
Cgtsam::FixedDimension< T >	Give fixed size dimension of a type, fails at compile time if dynamic
Cgtsam::internal::FixedJacobianFactorFactory< M, Ns >	Construct the fixed-size Jacobian factor for a dimension pack
Cgtsam::FixedLagSmoother
Cgtsam::BatchFixedLagSmoother
Cgtsam::IncrementalFixedLagSmoother	This is a base class for the various HMF2 implementations
Cgtsam::internal::FixedSizeDimensions< OutputVec, ValueTypes >	Compile-time residual and variable dimensions for a factor of any arity
Cgtsam::internal::FixedSizeMatrix< Y, X >	Select the fixed-size Jacobian type associated with two manifold types
Cgtsam::FlatGaussianFactor	Optional preindexed kernels for matrix-free Gaussian factors
Cgtsam::BatchJacobianFactorBase	Common interface for compact batch Jacobian factors
Cgtsam::RegularImplicitSchurFactor< CAMERA >	RegularImplicitSchurFactor
Cgtsam::ForestTraversal< Forest, Node >	Mixin that provides depth-based top-down or bottom-up traversal
Cgtsam::ForestTraversal< MultifrontalSolver, MultifrontalClique >
Cgtsam::MultifrontalSolver	Imperative-style multifrontal solver for Gaussian factor graphs
Cgtsam::NonlinearMultifrontalSolver	Multifrontal solver for nonlinear factor graphs
Cstd::function
Cgtsam::equals< V >	Template to create a binary predicate
Cgtsam::equals_star< V >	Binary predicate on shared pointers
Cgtsam::FundamentalMatrix	Represents a fundamental matrix in computer vision, which encodes the epipolar geometry between two views
CGaussianConditional	Normalization constant
Cgtsam::GaussianFactorGraphSystem	Compiled flat-vector system used by preconditioned conjugate gradients
Cgtsam::partition::GenericFactor2D	Factor always involves two nodes/variables for now
Cgtsam::partition::GenericFactor3D	Factor always involves two nodes/variables for now
Cgtsam::partition::GenericNode2D	Index of the node and the type of the node
Cgtsam::partition::GenericNode3D	Index of the node and the type of the node
Cgtsam::partition::GenericUnaryFactor	Factor involves a single variable
Cgtsam::internal::GetDimensionImpl< Class, N >	Traits to get dimension, supporting both fixed and dynamic
Cgtsam::internal::GetDimensionImpl< abc::State< N >, abc::State< N >::dimension >
Cgtsam::internal::ManifoldTraits< abc::State< N > >
Cgtsam::internal::Manifold< abc::State< N > >
Cgtsam::traits< abc::State< N > >
Cgtsam::traits< const abc::State< N > >
Cgtsam::internal::GetDimensionImpl< BearingRange< A1, A2 >, BearingRange< A1, A2 >::dimension >
Cgtsam::internal::ManifoldTraits< BearingRange< A1, A2 > >
Cgtsam::traits< BearingRange< A1, A2 > >
Cgtsam::internal::GetDimensionImpl< Cal3_S2, Cal3_S2::dimension >
Cgtsam::internal::ManifoldTraits< Cal3_S2 >
Cgtsam::internal::Manifold< Cal3_S2 >
Cgtsam::traits< Cal3_S2 >
Cgtsam::traits< const Cal3_S2 >
Cgtsam::internal::GetDimensionImpl< Cal3_S2Stereo, Cal3_S2Stereo::dimension >
Cgtsam::internal::ManifoldTraits< Cal3_S2Stereo >
Cgtsam::internal::Manifold< Cal3_S2Stereo >
Cgtsam::traits< Cal3_S2Stereo >
Cgtsam::traits< const Cal3_S2Stereo >
Cgtsam::internal::GetDimensionImpl< Cal3Bundler, Cal3Bundler::dimension >
Cgtsam::internal::ManifoldTraits< Cal3Bundler >
Cgtsam::internal::Manifold< Cal3Bundler >
Cgtsam::traits< Cal3Bundler >
Cgtsam::traits< const Cal3Bundler >
Cgtsam::internal::GetDimensionImpl< Cal3DS2, Cal3DS2::dimension >
Cgtsam::internal::ManifoldTraits< Cal3DS2 >
Cgtsam::internal::Manifold< Cal3DS2 >
Cgtsam::traits< Cal3DS2 >
Cgtsam::traits< const Cal3DS2 >
Cgtsam::internal::GetDimensionImpl< Cal3f, Cal3f::dimension >
Cgtsam::internal::ManifoldTraits< Cal3f >
Cgtsam::internal::Manifold< Cal3f >
Cgtsam::traits< Cal3f >
Cgtsam::traits< const Cal3f >
Cgtsam::internal::GetDimensionImpl< Cal3Fisheye, Cal3Fisheye::dimension >
Cgtsam::internal::ManifoldTraits< Cal3Fisheye >
Cgtsam::internal::Manifold< Cal3Fisheye >
Cgtsam::traits< Cal3Fisheye >
Cgtsam::traits< const Cal3Fisheye >
Cgtsam::internal::GetDimensionImpl< Cal3Unified, Cal3Unified::dimension >
Cgtsam::internal::ManifoldTraits< Cal3Unified >
Cgtsam::internal::Manifold< Cal3Unified >
Cgtsam::traits< Cal3Unified >
Cgtsam::traits< const Cal3Unified >
Cgtsam::internal::GetDimensionImpl< CalibratedCamera, CalibratedCamera::dimension >
Cgtsam::internal::ManifoldTraits< CalibratedCamera >
Cgtsam::internal::Manifold< CalibratedCamera >
Cgtsam::traits< CalibratedCamera >
Cgtsam::traits< const CalibratedCamera >
Cgtsam::internal::GetDimensionImpl< Class, Class::dimension >
Cgtsam::internal::ManifoldTraits< Class >	A helper that implements the traits interface for GTSAM manifolds
Cgtsam::internal::LieGroupTraits< Class >	A helper class that implements the traits interface for GTSAM lie groups
Cgtsam::internal::LieGroup< Class >	Both LieGroupTraits and Testable
Cgtsam::internal::MatrixLieGroupTraits< Class, N >	Adds MatrixLieGroup methods to LieGroupTraits
Cgtsam::internal::MatrixLieGroup< Class, N >	Both LieGroupTraits and Testable
Cgtsam::internal::Manifold< Class >	Both ManifoldTraits and Testable
Cgtsam::internal::GetDimensionImpl< EssentialMatrix, EssentialMatrix::dimension >
Cgtsam::internal::ManifoldTraits< EssentialMatrix >
Cgtsam::internal::Manifold< EssentialMatrix >
Cgtsam::traits< EssentialMatrix >
Cgtsam::traits< const EssentialMatrix >
Cgtsam::internal::GetDimensionImpl< Event, Event::dimension >
Cgtsam::internal::ManifoldTraits< Event >
Cgtsam::internal::Manifold< Event >
Cgtsam::traits< Event >
Cgtsam::internal::GetDimensionImpl< ExtendedPose3< K, Derived >, ExtendedPose3< K, Derived >::dimension >
Cgtsam::internal::ManifoldTraits< ExtendedPose3< K, Derived > >
Cgtsam::internal::LieGroupTraits< ExtendedPose3< K, Derived > >
Cgtsam::internal::MatrixLieGroupTraits< ExtendedPose3< K, Derived >, N >
Cgtsam::internal::MatrixLieGroup< ExtendedPose3< K, Derived >, ExtendedPose3< K, Derived >::matrixDim >
Cgtsam::traits< ExtendedPose3< K, Derived > >
Cgtsam::traits< const ExtendedPose3< K, Derived > >
Cgtsam::internal::GetDimensionImpl< FundamentalMatrix, FundamentalMatrix::dimension >
Cgtsam::internal::ManifoldTraits< FundamentalMatrix >
Cgtsam::internal::Manifold< FundamentalMatrix >
Cgtsam::traits< FundamentalMatrix >
Cgtsam::internal::GetDimensionImpl< Gal3, Gal3::dimension >
Cgtsam::internal::ManifoldTraits< Gal3 >
Cgtsam::internal::LieGroupTraits< Gal3 >
Cgtsam::internal::MatrixLieGroupTraits< Gal3, N >
Cgtsam::internal::MatrixLieGroup< Gal3, 5 >
Cgtsam::traits< Gal3 >	Traits specialization for Gal3
Cgtsam::traits< const Gal3 >
Cgtsam::internal::GetDimensionImpl< Line3, Line3::dimension >
Cgtsam::internal::ManifoldTraits< Line3 >
Cgtsam::internal::Manifold< Line3 >
Cgtsam::traits< Line3 >
Cgtsam::traits< const Line3 >
Cgtsam::internal::GetDimensionImpl< NavState, NavState::dimension >
Cgtsam::internal::ManifoldTraits< NavState >
Cgtsam::internal::LieGroupTraits< NavState >
Cgtsam::internal::MatrixLieGroupTraits< NavState, N >
Cgtsam::internal::MatrixLieGroup< NavState, 5 >
Cgtsam::traits< NavState >
Cgtsam::traits< const NavState >
Cgtsam::internal::GetDimensionImpl< OrientedPlane3, OrientedPlane3::dimension >
Cgtsam::internal::ManifoldTraits< OrientedPlane3 >
Cgtsam::internal::Manifold< OrientedPlane3 >
Cgtsam::traits< OrientedPlane3 >
Cgtsam::traits< const OrientedPlane3 >
Cgtsam::internal::GetDimensionImpl< PinholeCamera< Calibration >, PinholeCamera< Calibration >::dimension >
Cgtsam::internal::ManifoldTraits< PinholeCamera< Calibration > >
Cgtsam::internal::Manifold< PinholeCamera< Calibration > >
Cgtsam::traits< PinholeCamera< Calibration > >
Cgtsam::traits< const PinholeCamera< Calibration > >
Cgtsam::internal::GetDimensionImpl< PinholePose< CALIBRATION >, PinholePose< CALIBRATION >::dimension >
Cgtsam::internal::ManifoldTraits< PinholePose< CALIBRATION > >
Cgtsam::internal::Manifold< PinholePose< CALIBRATION > >
Cgtsam::traits< PinholePose< CALIBRATION > >
Cgtsam::traits< const PinholePose< CALIBRATION > >
Cgtsam::internal::GetDimensionImpl< Pose2, Pose2::dimension >
Cgtsam::internal::ManifoldTraits< Pose2 >
Cgtsam::internal::LieGroupTraits< Pose2 >
Cgtsam::internal::MatrixLieGroupTraits< Pose2, N >
Cgtsam::internal::MatrixLieGroup< Pose2, 3 >
Cgtsam::traits< Pose2 >	Add the Pose2-specific operations used by the generic QCQP conversion code
Cgtsam::traits< const Pose2 >
Cgtsam::internal::GetDimensionImpl< Pose3, Pose3::dimension >
Cgtsam::internal::ManifoldTraits< Pose3 >
Cgtsam::internal::LieGroupTraits< Pose3 >
Cgtsam::internal::MatrixLieGroupTraits< Pose3, N >
Cgtsam::internal::MatrixLieGroup< Pose3, 4 >
Cgtsam::traits< Pose3 >	Add the Pose3-specific operations used by the generic QCQP conversion code
Cgtsam::traits< const Pose3 >
Cgtsam::internal::GetDimensionImpl< Pose3Upright, Pose3Upright::dimension >
Cgtsam::internal::ManifoldTraits< Pose3Upright >
Cgtsam::internal::Manifold< Pose3Upright >
Cgtsam::traits< Pose3Upright >
Cgtsam::internal::GetDimensionImpl< PowerLieGroup< G, N >, PowerLieGroup< G, N >::dimension >
Cgtsam::internal::ManifoldTraits< PowerLieGroup< G, N > >
Cgtsam::internal::LieGroupTraits< PowerLieGroup< G, N > >
Cgtsam::internal::LieGroup< PowerLieGroup< G, N > >
Cgtsam::traits< PowerLieGroup< G, N > >	Traits specialization for PowerLieGroup
Cgtsam::internal::GetDimensionImpl< ProductLieGroup< G, H >, ProductLieGroup< G, H >::dimension >
Cgtsam::internal::ManifoldTraits< ProductLieGroup< G, H > >
Cgtsam::internal::LieGroupTraits< ProductLieGroup< G, H > >
Cgtsam::internal::LieGroup< ProductLieGroup< G, H > >
Cgtsam::traits< ProductLieGroup< G, H > >	Traits specialization for ProductLieGroup
Cgtsam::internal::GetDimensionImpl< Rot2, Rot2::dimension >
Cgtsam::internal::ManifoldTraits< Rot2 >
Cgtsam::internal::LieGroupTraits< Rot2 >
Cgtsam::internal::MatrixLieGroupTraits< Rot2, N >
Cgtsam::internal::MatrixLieGroup< Rot2, 2 >
Cgtsam::traits< Rot2 >
Cgtsam::traits< const Rot2 >
Cgtsam::internal::GetDimensionImpl< Rot3, Rot3::dimension >
Cgtsam::internal::ManifoldTraits< Rot3 >
Cgtsam::internal::LieGroupTraits< Rot3 >
Cgtsam::internal::MatrixLieGroupTraits< Rot3, N >
Cgtsam::internal::MatrixLieGroup< Rot3, 3 >
Cgtsam::traits< Rot3 >
Cgtsam::traits< const Rot3 >
Cgtsam::internal::GetDimensionImpl< SemidirectLieGroup< G, H, Action >, SemidirectLieGroup< G, H, Action >::dimension >
Cgtsam::internal::ManifoldTraits< SemidirectLieGroup< G, H, Action > >
Cgtsam::internal::LieGroupTraits< SemidirectLieGroup< G, H, Action > >
Cgtsam::internal::LieGroup< SemidirectLieGroup< G, H, Action > >
Cgtsam::traits< SemidirectLieGroup< G, H, Action > >
Cgtsam::internal::GetDimensionImpl< Similarity2, Similarity2::dimension >
Cgtsam::internal::ManifoldTraits< Similarity2 >
Cgtsam::internal::LieGroupTraits< Similarity2 >
Cgtsam::internal::MatrixLieGroupTraits< Similarity2, N >
Cgtsam::internal::MatrixLieGroup< Similarity2, 3 >
Cgtsam::traits< Similarity2 >
Cgtsam::traits< const Similarity2 >
Cgtsam::internal::GetDimensionImpl< Similarity3, Similarity3::dimension >
Cgtsam::internal::ManifoldTraits< Similarity3 >
Cgtsam::internal::LieGroupTraits< Similarity3 >
Cgtsam::internal::MatrixLieGroupTraits< Similarity3, N >
Cgtsam::internal::MatrixLieGroup< Similarity3, 4 >
Cgtsam::traits< Similarity3 >
Cgtsam::traits< const Similarity3 >
Cgtsam::internal::GetDimensionImpl< SimpleFundamentalMatrix, SimpleFundamentalMatrix::dimension >
Cgtsam::internal::ManifoldTraits< SimpleFundamentalMatrix >
Cgtsam::internal::Manifold< SimpleFundamentalMatrix >
Cgtsam::traits< SimpleFundamentalMatrix >
Cgtsam::internal::GetDimensionImpl< SL4, SL4::dimension >
Cgtsam::internal::ManifoldTraits< SL4 >
Cgtsam::internal::LieGroupTraits< SL4 >
Cgtsam::internal::MatrixLieGroupTraits< SL4, N >
Cgtsam::internal::MatrixLieGroup< SL4, 4 >
Cgtsam::traits< SL4 >
Cgtsam::traits< const SL4 >
Cgtsam::internal::GetDimensionImpl< SO3, SO3::dimension >
Cgtsam::internal::ManifoldTraits< SO3 >
Cgtsam::internal::LieGroupTraits< SO3 >
Cgtsam::internal::MatrixLieGroupTraits< SO3, N >
Cgtsam::internal::MatrixLieGroup< SO3, 3 >
Cgtsam::traits< SO3 >
Cgtsam::traits< const SO3 >
Cgtsam::internal::GetDimensionImpl< SO4, SO4::dimension >
Cgtsam::internal::ManifoldTraits< SO4 >
Cgtsam::internal::LieGroupTraits< SO4 >
Cgtsam::internal::MatrixLieGroupTraits< SO4, N >
Cgtsam::internal::MatrixLieGroup< SO4, 4 >
Cgtsam::traits< SO4 >
Cgtsam::traits< const SO4 >
Cgtsam::internal::GetDimensionImpl< SO< N >, SO< N >::dimension >
Cgtsam::internal::ManifoldTraits< SO< N > >
Cgtsam::internal::LieGroupTraits< SO< N > >
Cgtsam::internal::MatrixLieGroupTraits< SO< N >, N >
Cgtsam::internal::MatrixLieGroup< SO< N >, N >
Cgtsam::traits< SO< N > >
Cgtsam::traits< const SO< N > >
Cgtsam::internal::GetDimensionImpl< SphericalCamera, SphericalCamera::dimension >
Cgtsam::internal::ManifoldTraits< SphericalCamera >
Cgtsam::internal::Manifold< SphericalCamera >
Cgtsam::traits< SphericalCamera >
Cgtsam::traits< const SphericalCamera >
Cgtsam::internal::GetDimensionImpl< StereoCamera, StereoCamera::dimension >
Cgtsam::internal::ManifoldTraits< StereoCamera >
Cgtsam::internal::Manifold< StereoCamera >
Cgtsam::traits< StereoCamera >
Cgtsam::traits< const StereoCamera >
Cgtsam::internal::GetDimensionImpl< TangentLieGroup< G >, TangentLieGroup< G >::dimension >
Cgtsam::internal::ManifoldTraits< TangentLieGroup< G > >
Cgtsam::internal::LieGroupTraits< TangentLieGroup< G > >
Cgtsam::internal::LieGroup< TangentLieGroup< G > >
Cgtsam::traits< TangentLieGroup< G > >
Cgtsam::internal::GetDimensionImpl< Unit3, Unit3::dimension >
Cgtsam::internal::ManifoldTraits< Unit3 >
Cgtsam::internal::Manifold< Unit3 >
Cgtsam::traits< Unit3 >	Define GTSAM traits
Cgtsam::traits< const Unit3 >
Cgtsam::GncIterationTiming	Timing of one GNC outer iteration (all in seconds)
Cgtsam::GncOptimizer< GncParameters >
Cgtsam::GncParams< BaseOptimizerParameters >
Cgtsam::GncTiming	Timing of a full GncOptimizer::optimize() call
Cgtsam::GnssMeasurementBase	Base class storing common members for GNSS measurement factors
Cgtsam::CarrierPhaseFactor	Undifferenced GNSS carrier phase factor for point positioning
Cgtsam::CarrierPhaseFactorArm	Carrier phase factor with lever arm correction
Cgtsam::DifferentialPseudorangeFactor
Cgtsam::DifferentialPseudorangeFactorArm	Differentially-corrected pseudorange factor with lever arm correction
Cgtsam::PseudorangeFactor	Simplified GNSS pseudorange model for basic positioning problems
Cgtsam::PseudorangeFactorArm	GNSS pseudorange factor with lever arm correction
Cgtsam::UndifferencedCarrierPhaseFactor	Undifferenced (raw) PPP carrier phase factor
Cgtsam::UndifferencedCarrierPhaseFactorArm	Undifferenced (raw) PPP carrier phase factor with lever-arm correction
Cgtsam::UndifferencedPseudorangeFactor	Undifferenced (raw) PPP pseudorange factor
Cgtsam::UndifferencedPseudorangeFactorArm	Undifferenced (raw) PPP pseudorange factor with lever-arm correction
Cgtsam::GraduatedFactor	Graduated Factor for riSAM base class
Cgtsam::GenericGraduatedFactor< FACTOR_TYPE >	Instantiation of Graduated Factor wrapping any Nonlinear Factor
Cgtsam::GraduationScheduler	Class for graduation scheduling for riSAM
Cgtsam::internal::GravityParametrization< GRAVITY >	Adapter mapping a gravity parametrization GRAVITY to the nav-frame gravity vector expected by PreintegrationBase, with the chain-rule Jacobian block
Cgtsam::internal::GravityParametrization< Point3 >
Cgtsam::internal::GravityParametrization< Unit3 >
Cgtsam::group_tag	Tag to assert a type is a group
Cgtsam::lie_group_tag	Tag to assert a type is a Lie group
Cgtsam::vector_space_tag	Tag to assert a type is a vector space
Cgtsam::GroupAction< Derived, G, M >	GroupAction CRTP base class
Cgtsam::GroupAction< AdjointAction< G >, G, traits< G >::TangentVector >
Cgtsam::AdjointAction< G >	The adjoint action phi(g,v) = Ad_g v, also useful independently
Cgtsam::GroupAction< InputAction< N >, Group< N >, Vector6 >
Cgtsam::abc::InputAction< N >	Encodes the partially applied input action ψ_u(X) = Aᵀ(ω − a), used to compute A(X,u) and Φ(X,u)
Cgtsam::GroupAction< OutputAction< N >, Group< N >, Vector3 >
Cgtsam::abc::OutputAction< N >	Functor encoding the right action ρ_y(X) on direction measurements y, parameterized by the sensor index
Cgtsam::GroupAction< Symmetry< N >, Group< N >, State< N > >
Cgtsam::abc::Symmetry< N >	Right action φ_ξ(X) = (R A, Aᵀ(b − a), Aᵀ C B) on the state manifold
Cgtsam::internal::handle< ValueType >
Cgtsam::internal::handle< Eigen::Matrix< double, M, N > >
Cgtsam::internal::handle_matrix< MatrixType, isDynamic >
Cgtsam::internal::handle_matrix< Eigen::Matrix< double, M, N >, false >
Cgtsam::internal::handle_matrix< Eigen::Matrix< double, M, N >, true >
Cgtsam::HasBearing< A1, A2, RT >
Cgtsam::HasBearing< Gal3, Point3, Unit3 >
Cgtsam::Bearing< Gal3, Point3 >
Cgtsam::HasBearing< NavState, Point3, Unit3 >
Cgtsam::Bearing< NavState, Point3 >
Cgtsam::HasBearing< Pose2, T, Rot2 >
Cgtsam::Bearing< Pose2, T >
Cgtsam::HasBearing< Pose3, Point3, Unit3 >
Cgtsam::Bearing< Pose3, Point3 >
Cgtsam::HasBearing< Pose3, Pose3, Unit3 >
Cgtsam::Bearing< Pose3, Pose3 >
Cstd::hash< gtsam::StateData >
Cgtsam::internal::HasManifoldPrereqs< Class >	Requirements on type to pass it to Manifold template below
Cgtsam::HasRange< A1, A2, RT >
Cgtsam::HasRange< CalibratedCamera, T, double >
Cgtsam::Range< CalibratedCamera, T >
Cgtsam::HasRange< Gal3, Point3, double >
Cgtsam::Range< Gal3, Point3 >
Cgtsam::HasRange< NavState, Point3, double >
Cgtsam::Range< NavState, Point3 >
Cgtsam::HasRange< PinholeCamera< Calibration >, T, double >
Cgtsam::Range< PinholeCamera< Calibration >, T >
Cgtsam::HasRange< Pose2, T, double >
Cgtsam::Range< Pose2, T >
Cgtsam::HasRange< Pose3, T, double >
Cgtsam::Range< Pose3, T >
Cgtsam::HasTestablePrereqs< T >	Requirements on type to pass it to Testable template below
Cgtsam::internal::HasVectorSpacePrereqs< Class >	Requirements on type to pass it to Manifold template below
Cgtsam::HybridNonlinearISAM	Wrapper class to manage ISAM in a nonlinear context
Cgtsam::HybridSmoother
Cgtsam::HybridValues	HybridValues represents a collection of DiscreteValues and VectorValues
CHybridValues	Error
Cgtsam::internal::IncrementalRotation	Function object for incremental rotation
Cgtsam::index_sequence< Ints >
Cgtsam::index_sequence< 0 >
Cgtsam::make_index_sequence< 1 >
Cgtsam::index_sequence< I1...,(sizeof...(I1)+I2)... >
Cgtsam::detail::_merge_and_renumber< index_sequence< I1... >, index_sequence< I2... > >
Cgtsam::index_sequence<>
Cgtsam::make_index_sequence< 0 >
Cgtsam::InitializePose3
Cgtsam::abc::Innovation< N >
Cstd::integral_constant
Cgtsam::internal::DimensionAt< I - 1, Default, Rest... >
Cgtsam::internal::DimensionAt< I, Default, First, Rest... >
Cgtsam::internal::DimensionAt< 0, Default, First, Rest... >
Cgtsam::internal::DimensionAt< I, Default, First, Rest... >
Cgtsam::internal::DimensionAt< I, Default, Dimensions >	Return the element at I in a compile-time integer pack, or Default
Cgtsam::internal::DimensionAt< 0, Default, First, Rest... >
Cgtsam::Interpolator< PoseType >	Interpolator for poses and velocities under a motion prior
Cgtsam::InvDepthCamera3< CALIBRATION >	A pinhole camera class that has a Pose3 and a Calibration
Cgtsam::so3::InvJKernel
Cgtsam::ISAM2DoglegLineSearchParams	Parameters for ISAM2 using Dogleg Line Search optimization
Cgtsam::ISAM2DoglegParams	Parameters for ISAM2 using Dogleg optimization
Cgtsam::ISAM2GaussNewtonParams	Parameters for ISAM2 using Gauss-Newton optimization
Cgtsam::ISAM2Params
Cgtsam::ISAM2Result	This struct is returned from ISAM2::update() and contains information about the update that is useful for determining whether the solution is converging, and about how much work was required for the update
Cgtsam::ISAM2UpdateParams	This struct is used by ISAM2::update() to pass additional parameters to give the user a fine-grained control on how factors and relinearized, etc
Cgtsam::IsGroup< G >	Group Concept
Cgtsam::IsGroup< T >
Cgtsam::IsLieGroup< T >	Lie Group Concept
Cgtsam::IsMatrixLieGroup< T >	Matrix Lie Group Concept
Cgtsam::IsVectorSpace< T >	Vector Space concept
Cgtsam::IsManifold< T >	Manifold concept
Cgtsam::IsLieGroup< T >	Lie Group Concept
Cgtsam::IsTestable< T >	A testable concept check that should be placed in applicable unit tests and in generic algorithms
Cgtsam::DoglegOptimizerImpl::IterationResult
Cgtsam::IterativeOptimizationParameters	Parameters for iterative linear solvers
Cgtsam::ConjugateGradientParameters	Parameters for the Conjugate Gradient method
Cgtsam::PCGSolverParameters	Parameters for Preconditioned Conjugate Gradient solver
Cgtsam::SubgraphSolverParameters
Cgtsam::IterativeSolver	Base class for Iterative Solvers like SubgraphSolver
Cgtsam::PCGSolver	A virtual base class for the preconditioned conjugate gradient solver
Cgtsam::SubgraphSolver	This class implements the linear SPCG solver presented in Dellaert et al in IROS'10
Cgtsam::vector< T >::iterator	STL iterator class
Cmap< K, T >::iterator	STL iterator class
Cstring::iterator	STL iterator class
Cunordered_map< K, T >::iterator	STL iterator class
Cunordered_set< K >::iterator	STL iterator class
Cvector< T >::iterator	STL iterator class
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
Cgtsam::JointMarginal	A class to store and access a joint marginal, returned from Gaussian and nonlinear covariance query APIs
Cgtsam::KalmanFilter	Kalman Filter class
Cgtsam::so3::Kernel	Kernel: M(ω) = a I + b Ω + c Ω² with radial derivatives db,dc for Fréchet
Cgtsam::KernelBase	Interface for a compactly supported continuous convolution kernel
Cgtsam::PiecewisePolynomial< Order, Pieces >	A one-dimensional piecewise polynomial kernel
Cgtsam::key_formatter	Output stream manipulator that will format gtsam::Keys according to the given KeyFormatter, as long as Key values are wrapped in a gtsam::StreamedKey
Cgtsam::KeyInfoEntry	Position, dimension, and scalar offset of one key in an ordered vector
Cgtsam::gtsfm::Keypoints
Cgtsam::Values::KeyValuePair	A key-value pair, which you get by dereferencing iterators
CKeyVector
Cgtsam::Ordering
Cgtsam::LabeledSymbol	Customized version of gtsam::Symbol for multi-robot use
Cgtsam::LeggedEstimator	Common runtime interface shared by all four legged estimator variants
Cgtsam::LeggedCombinedFixedLagSmoother	Fixed-lag smoother with CombinedImuFactor bias evolution
Cgtsam::LeggedFixedLagSmoother	Fixed-lag smoother over NavState and contact-episode footholds
Cgtsam::LeggedInvariantEKF	Invariant filter: LeftLinearEKF on ExtendedPose3(2+k)
Cgtsam::LeggedInvariantIEKF	Invariant filter with local graph fragment
Cgtsam::LeggedEstimatorParams	Common estimator parameters shared by all four variants
Cgtsam::gnss::LeverArm	Lever-arm helper for GNSS factors that key on a body Pose3
Cgtsam::LieGroup< Class, N >	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
Cgtsam::MatrixLieGroup< This, dimension, matrixDim >
Cgtsam::PowerLieGroupBase< G, N, PowerLieGroup >
Cgtsam::PowerLieGroupBase< G, Eigen::Dynamic, PowerLieGroup >
Cgtsam::ProductLieGroup< Pose3, Calibrations< n > >
Cgtsam::LieGroup< Class, D >
Cgtsam::MatrixLieGroup< Class, D, N >	A CRTP helper class that implements matrix Lie group methods
Cgtsam::ExtendedPose3< 1, Pose3 >
Cgtsam::Pose3	A 3D pose (R,t) : (Rot3,Point3)
Cgtsam::ExtendedPose3< 2, NavState >
Cgtsam::NavState	Navigation state: Pose (rotation, translation) + velocity Following Barrau20icra, this class belongs to the Lie group SE_2(3)
Cgtsam::LieGroup< Derived, internal::dimensionProduct(N, traits< G >::dimension)>
Cgtsam::PowerLieGroupBase< G, N, Derived >
Cgtsam::PowerLieGroup< Rot3, static_cast< int >(N)>
Cgtsam::LieGroup< Gal3, D >
Cgtsam::MatrixLieGroup< Gal3, 10, 5 >
Cgtsam::Gal3	Represents an element of the 3D Galilean group SGal(3)
Cgtsam::LieGroup< Pose2, D >
Cgtsam::MatrixLieGroup< Pose2, 3, 3 >
Cgtsam::Pose2	A 2D pose (Point2,Rot2)
Cgtsam::LieGroup< PowerLieGroup< G, Eigen::Dynamic >, internal::dimensionProduct(N, traits< G >::dimension)>
Cgtsam::PowerLieGroupBase< G, Eigen::Dynamic, PowerLieGroup< G, Eigen::Dynamic > >
Cgtsam::PowerLieGroup< G, Eigen::Dynamic >	Dynamic-count specialization of PowerLieGroup Represents G^N for runtime-sized N while keeping G fixed-size
Cgtsam::LieGroup< PowerLieGroup< G, N >, internal::dimensionProduct(N, traits< G >::dimension)>
Cgtsam::PowerLieGroupBase< G, N, PowerLieGroup< G, N > >
Cgtsam::PowerLieGroup< G, Eigen::Dynamic >	Dynamic-count specialization of PowerLieGroup Represents G^N for runtime-sized N while keeping G fixed-size
Cgtsam::PowerLieGroup< G, N >	Template to construct the N-fold power of a Lie group Represents the group G^N = G x G x ... x G (N times) Assumes Lie group structure for fixed-size G and fixed N >= 1
Cgtsam::LieGroup< ProductLieGroup< G, H >, internal::dimensionSum(traits< G >::dimension, traits< H >::dimension)>
Cgtsam::ProductLieGroup< G, H >	Direct product Lie group G × H
Cgtsam::LieGroup< Rot2, D >
Cgtsam::MatrixLieGroup< Rot2, 1, 2 >
Cgtsam::Rot2	Rotation matrix NOTE: the angle theta is in radians unless explicitly stated
Cgtsam::LieGroup< Rot3, D >
Cgtsam::MatrixLieGroup< Rot3, 3, 3 >
Cgtsam::Rot3	Rot3 is a 3D rotation represented as a rotation matrix if the preprocessor symbol GTSAM_USE_QUATERNIONS is not defined, or as a quaternion if it is defined
Cgtsam::LieGroup< SemidirectLieGroup< G, H, Action >, internal::dimensionSum(traits< G >::dimension, traits< H >::dimension)>
Cgtsam::SemidirectLieGroup< G, H, Action >	Left semidirect product G ⋉ H induced by Action
Cgtsam::LieGroup< Similarity2, D >
Cgtsam::MatrixLieGroup< Similarity2, 4, 3 >
Cgtsam::Similarity2	2D similarity transform
Cgtsam::LieGroup< Similarity3, D >
Cgtsam::MatrixLieGroup< Similarity3, 7, 4 >
Cgtsam::Similarity3	3D similarity transform
Cgtsam::LieGroup< SL4, D >
Cgtsam::MatrixLieGroup< SL4, 15, 4 >
Cgtsam::SL4
Cgtsam::LieGroup< SO< N >, D >
Cgtsam::MatrixLieGroup< SO< N >, internal::DimensionSO(N), N >
Cgtsam::SO< 3 >
Cgtsam::SO< 4 >
Cgtsam::SO< Eigen::Dynamic >
Cgtsam::SO< N >	Manifold of special orthogonal rotation matrices SO<N>
Cgtsam::LieGroup< std::conditional_t< std::is_void_v< Derived >, ExtendedPose3< K_, void >, Derived >, D >
Cgtsam::MatrixLieGroup< std::conditional_t< std::is_void_v< Derived >, ExtendedPose3< K_, void >, Derived >,(K_==Eigen::Dynamic) ? Eigen::Dynamic :3+3 *K_,(K_==Eigen::Dynamic) ? Eigen::Dynamic :3+K_ >
Cgtsam::ExtendedPose3< 2 >
Cgtsam::ExtendedPose3< Eigen::Dynamic >
Cgtsam::ExtendedPose3< K_, Derived >	Lie group SE_k(3): semidirect product of SO(3) with k copies of R^3
Cgtsam::LieGroup< TangentLieGroup< G >, internal::dimensionProduct(2, traits< G >::dimension)>
Cgtsam::TangentLieGroup< G >	Tangent Lie group TG = G ⋉ 𝔤, with dimension 2 dim(G)
Cgtsam::abc::Lift< N >	Implements the lift Λ(ξ,u) from the paper: Λ encodes the lifted dynamics on G induced by the biased gyroscope input u = (ω,0)
Cgtsam::Line3	A 3D line (R,a,b) : (Rot3,Scalar,Scalar)
Cstd::list< T >	STL class
Cgtsam::FastList< sharedClique >
Cgtsam::FastList< Key >
Cgtsam::FastList< Vector >
Cgtsam::FastList< VALUE >	FastList is a thin wrapper around std::list that uses the boost fast_pool_allocator instead of the default STL allocator
Cgtsam::LMDampingParams	Parameters controlling LM-style damping as applied by gtsam::NonlinearMultifrontalSolver
Cgtsam::LocationRecovery
Cgtsam::GlobalPositioner
Cgtsam::TranslationRecovery
Cgtsam::MakeJacobian< T, A >	: meta-function to generate Jacobian
Cgtsam::MakeOptionalJacobian< T, A >	: meta-function to generate JacobianTA optional reference Used mainly by Expressions
Cgtsam::manifold_tag	Tag to assert a type is a manifold
Cgtsam::lie_group_tag	Tag to assert a type is a Lie group
Cgtsam::ManifoldEKF< M >	Extended Kalman Filter on a generic manifold M
Cgtsam::EquivariantFilter< M, Symmetry >	Equivariant Filter (EqF) for state estimation on Lie groups
Cgtsam::ManifoldEKF< G >
Cgtsam::LieGroupEKF< G >	Extended Kalman Filter on a Lie group G, derived from ManifoldEKF
Cgtsam::LeftLinearEKF< ExtendedPose3d >
Cgtsam::LeggedInvariantEKF	Invariant filter: LeftLinearEKF on ExtendedPose3(2+k)
Cgtsam::LeftLinearEKF< NavState >
Cgtsam::NavStateImuEKF	Specialized EKF for IMU-driven NavState on SE_2(3)
Cgtsam::LeftLinearEKF< G >	EKF on a Lie group with a general left–linear prediction model
Cgtsam::InvariantEKF< Gal3 >
Cgtsam::Gal3ImuEKF	Specialized EKF for IMU-driven on Gal3
Cgtsam::InvariantEKF< G >	Left-Invariant Extended Kalman Filter on a Lie group G
Cgtsam::ManifoldEKF< State< N > >
Cgtsam::EquivariantFilter< State< N >, Symmetry< N > >
Cgtsam::abc::AbcEquivariantFilter< N >	Equivariant Filter for Attitude-Bias-Calibration (ABC) estimation
Cmap< K, T >	STL class
Cgtsam::Assignment< Key >
Cgtsam::DiscreteValues	A map from keys to values
Cgtsam::FastMap< size_t, std::shared_ptr< TimingOutline > >
Cgtsam::FastMap< const Cluster *, KeySet >
Cgtsam::FastMap< Key, int >
Cgtsam::FastMap< Key, FactorIndices >
Cgtsam::FastMap< Key, FastVector< size_t > >
Cgtsam::VariableSlots	A combined factor is assembled as one block of rows for each component factor
Cgtsam::FastMap< char, Vector >
Cgtsam::FastMap< Key, VariableStatus >
Cgtsam::FastMap< Key, size_t >
Cgtsam::FastMap< Key, VectorValues::const_iterator >
Cgtsam::Assignment< L >	An assignment from labels to value index (size_t)
Cgtsam::FastMap< KEY, VALUE >	FastMap is a thin wrapper around std::map that uses the boost fast_pool_allocator instead of the default STL allocator
Cgtsam::ConcurrentMap< Key, sharedClique >
Cgtsam::ConcurrentMap< Key, Vector >
Cgtsam::ConcurrentMap< KEY, VALUE >	FastMap is a thin wrapper around std::map that uses the boost fast_pool_allocator instead of the default STL allocator
Cgtsam::KeyInfo	Ordered key dimensions and offsets in one flattened variable vector
Cgtsam::PredecessorMap< KEY >	Map from variable key to parent key
Cstd::map< K, T >	STL class
Cgtsam::Assignment< Key >
Cgtsam::FastMap< size_t, std::shared_ptr< TimingOutline > >
Cgtsam::FastMap< const Cluster *, KeySet >
Cgtsam::FastMap< Key, int >
Cgtsam::FastMap< Key, FactorIndices >
Cgtsam::FastMap< Key, FastVector< size_t > >
Cgtsam::FastMap< char, Vector >
Cgtsam::FastMap< Key, VariableStatus >
Cgtsam::FastMap< Key, size_t >
Cgtsam::FastMap< Key, VectorValues::const_iterator >
Cgtsam::Assignment< L >	An assignment from labels to value index (size_t)
Cgtsam::FastMap< KEY, VALUE >	FastMap is a thin wrapper around std::map that uses the boost fast_pool_allocator instead of the default STL allocator
Cgtsam::KeyInfo	Ordered key dimensions and offsets in one flattened variable vector
Cgtsam::PredecessorMap< KEY >	Map from variable key to parent key
Cgtsam::Marginals	A class for computing Gaussian marginals of variables in a NonlinearFactorGraph
Cgtsam::internal::MatrixMN< M, N >	Select a fixed-size matrix from explicit row and column counts
Cgtsam::MetisIndex	Converts a factor graph into the Compressed Sparse Row format for use in METIS algorithms
Cgtsam::partition::MetisResult	Metis Nest dissection result
Cgtsam::MFAS	To solve a Minimum feedback arc set (MFAS) problem
Cgtsam::MultifrontalClique	Imperative multifrontal clique structure used by MultifrontalSolver
Cgtsam::MultifrontalParameters	Parameters for gtsam::MultifrontalSolver
Cgtsam::multiplicative_group_tag	Group operator syntax flavors
Cgtsam::internal::MultiplicativeGroupTraits< Class >	A helper class that implements the traits interface for multiplicative groups
Cgtsam::internal::MultiplicativeGroup< Class >	Both multiplicative group traits and Testable
Cgtsam::internal::MultiplicativeGroupTraits< DirectProduct< G, H > >
Cgtsam::traits< DirectProduct< G, H > >
Cgtsam::MultiplyWithInverse< N >	Functor that implements multiplication of a vector b with the inverse of a matrix A
Cgtsam::MultiplyWithInverseFunction< T, N >	Functor that implements multiplication with the inverse of a matrix, itself the result of a function f
Cgtsam::partition::NestedDissection< NLG, SubNLG, GenericGraph >	Apply nested dissection algorithm to nonlinear factor graphs
Cgtsam::DecisionTree< L, Y >::Node	---------------------— Node base class ------------------------—
Cgtsam::DecisionTree< L, Y >::Choice< L, Y >
Cgtsam::DecisionTree< L, Y >::Leaf< L, Y >
Cgtsam::EliminationTree< BAYESNET, GRAPH >::Node
CNoiseModelFactor	Noise model to the factor, and calculates the error by asking the user to implement the method
Cgtsam::detail::NoiseModelFactorAliases< typename,... >	Convenience base class to add aliases X1, X2, ..., X6 -> ValueType<N>
Cgtsam::detail::NoiseModelFactorAliases< T1 >
Cgtsam::detail::NoiseModelFactorAliases< T1, T2 >
Cgtsam::detail::NoiseModelFactorAliases< T1, T2, T3 >
Cgtsam::detail::NoiseModelFactorAliases< T1, T2, T3, T4 >
Cgtsam::detail::NoiseModelFactorAliases< T1, T2, T3, T4, T5 >
Cgtsam::detail::NoiseModelFactorAliases< T1, T2, T3, T4, T5, T6, TExtra... >
Cgtsam::detail::NoiseModelFactorAliases< ValueTypes... >
Cgtsam::NoiseModelFactorT< Vector3, Rot3, Rot3, Vector3 >
Cgtsam::NoiseModelFactorT< Vector1, Pose3, double >
Cgtsam::NoiseModelFactorT< Vector1, Point3, double, double >
Cgtsam::NoiseModelFactorT< Vector1, Pose3, double, double >
Cgtsam::NoiseModelFactorT< Vector9, NavState, NavState >
Cgtsam::NoiseModelFactorT< Vector1, Vector3, double, double >
Cgtsam::NoiseModelFactorT< Vector3, Pose3, Point3 >
Cgtsam::NoiseModelFactorT< Vector3, NavState, Point3 >
Cgtsam::NoiseModelFactorT< Vector9, Pose3, Vector3, Pose3, Vector3, imuBias::ConstantBias >
Cgtsam::NoiseModelFactorT< Vector9, NavState, NavState, imuBias::ConstantBias >
Cgtsam::NoiseModelFactorT< Vector9, NavState, NavState, imuBias::ConstantBias, GRAVITY >
Cgtsam::NoiseModelFactorT< Vector3, Point3, Point3 >
Cgtsam::NoiseModelFactorT< Vector3, double, Unit3, Point3 >
Cgtsam::NoiseModelFactorT< Vector3, Pose2, Pose2, double >
Cgtsam::NoiseModelFactorT< Vector1, Point3, double >
Cgtsam::NoiseModelFactorT< OutputVec, ValueTypes... >
Cgtsam::NoiseModelFactorT< Vector, ValueTypes... >
Cgtsam::NoiseModelFactorT< ErrorVector, A1, A2 >
Cgtsam::NoiseModelFactorT< typename traits< T >::TangentVector, A1, A2 >
Cgtsam::NoiseModelFactorT< typename traits< T >::TangentVector, A1, A2, T >
Cgtsam::NoiseModelFactorT< Vector5, Pose3, Pose3 >
Cgtsam::NoiseModelFactorT< Vector2, EssentialMatrix, double >
Cgtsam::NoiseModelFactorT< Vector1, EssentialMatrix, CALIBRATION >
Cgtsam::NoiseModelFactorT< Vector1, EssentialMatrix, CALIBRATION, CALIBRATION >
Cgtsam::NoiseModelFactorT< Vector2, double, double >
Cgtsam::NoiseModelFactorT< Vector3, Point3, Point3, Vector1 >
Cgtsam::NoiseModelFactorT< ErrorVector, VALUE, VALUE >
Cgtsam::NoiseModelFactorT< FrobeniusErrorVector< T >, T, T >
Cgtsam::NoiseModelFactorT< VectorD, T, T >
Cgtsam::NoiseModelFactorT< ErrorVector, CAMERA, LANDMARK >
Cgtsam::NoiseModelFactorT< Vector2, Pose3, Point3, CALIBRATION >
Cgtsam::NoiseModelFactorT< Vector3, Pose3, OrientedPlane3 >
Cgtsam::NoiseModelFactorT< Vector2, Pose2, Point3 >
Cgtsam::NoiseModelFactorT< Vector2, Pose2, Pose3, Cal3DS2 >
Cgtsam::NoiseModelFactorT< Vector2, POSE, LANDMARK >
Cgtsam::NoiseModelFactorT< typename traits< POINT >::TangentVector, POINT, TRANSFORM, POINT >
Cgtsam::NoiseModelFactorT< Vector3, POSE, LANDMARK >
Cgtsam::NoiseModelFactorT< typename traits< VALUE >::TangentVector, VALUE, VALUE >
Cgtsam::NoiseModelFactorT< Vector2, POSE, LANDMARK, INVDEPTH >
Cgtsam::NoiseModelFactorT< Vector2, Pose3, Vector6 >
Cgtsam::NoiseModelFactorT< Vector2, Pose3, Vector3 >
Cgtsam::NoiseModelFactorT< Vector2, Pose3, Pose3, Vector3 >
Cgtsam::NoiseModelFactorT< Vector3, Pose3, Pose3, OrientedPlane3 >
Cgtsam::NoiseModelFactorT< typename traits< POSE >::TangentVector, POSE, POSE >
Cgtsam::NoiseModelFactorT< typename traits< POINT >::TangentVector, POSE, POINT >
Cgtsam::NoiseModelFactorT< Vector2, POSE, POSE, LANDMARK >
Cgtsam::NoiseModelFactorT< Vector2, Pose3, Pose3, Point3 >
Cgtsam::NoiseModelFactorT< Vector1, Pose3, Point3 >
Cgtsam::NoiseModelFactorT< Vector2, Pose2, Point2 >
Cgtsam::NoiseModelFactorT< traits< typename Bearing< A1, A2 >::result_type >::TangentVector, A1, A2 >
Cgtsam::NoiseModelFactorT< traits< BearingRange< A1, A2, typename Bearing< A1, A2 >::result_type, typename Range< A1, A2 >::result_type > >::TangentVector, A1, A2 >
Cgtsam::NoiseModelFactorT< traits< VALUE >::TangentVector, VALUE, VALUE >
Cgtsam::NoiseModelFactorT< traits< CAMERA::Measurement >::TangentVector, CAMERA, LANDMARK >
Cgtsam::NoiseModelFactorT< Vector2, Pose3, Point3 >
Cgtsam::NoiseModelFactorT< Vector9, NavState, NavState, imuBias::ConstantBias, Unit3 >
Cgtsam::NoiseModelFactorT< traits< POSE >::TangentVector, POSE, POSE >
Cgtsam::NoiseModelFactorT< traits< Point3 >::TangentVector, Pose3, Point3 >
Cgtsam::NoiseModelFactorT< traits< double >::TangentVector, A1, A1 >
Cgtsam::NoiseModelFactorT< traits< typename Range< A1, A1 >::result_type >::TangentVector, A1, A1 >
Cgtsam::NoiseModelFactorT< traits< typename Range< A1, A1 >::result_type >::TangentVector, A1, A1, typename Range< A1, A1 >::result_type >
Cgtsam::NoiseModelFactorT< traits< POINT >::TangentVector, POINT, TRANSFORM, POINT >
Cgtsam::NoiseModelFactorT< OutputVec, ValueTypes >	A convenient base class for creating your own NoiseModelFactor with n variables
Cgtsam::NonlinearISAM	Wrapper class to manage ISAM in a nonlinear context
Cgtsam::NonlinearOptimizer	This is the abstract interface for classes that can optimize for the maximum-likelihood estimate of a NonlinearFactorGraph
Cgtsam::DoglegOptimizer	This class performs Dogleg nonlinear optimization
Cgtsam::GaussNewtonOptimizer	This class performs Gauss-Newton nonlinear optimization
Cgtsam::LevenbergMarquardtOptimizer	This class performs Levenberg-Marquardt nonlinear optimization
Cgtsam::SfmLevenbergMarquardtOptimizer	CPU SFM optimizer supporting either a joint solve or Schur elimination of Point3 and Unit3 variables
Cgtsam::NonlinearConjugateGradientOptimizer	An implementation of the nonlinear CG method using the template below
Cgtsam::NonlinearOptimizerParams	The common parameters for Nonlinear optimizers
Cgtsam::DoglegParams	Parameters for Levenberg-Marquardt optimization
Cgtsam::GaussNewtonParams	Parameters for Gauss-Newton optimization, inherits from NonlinearOptimizationParams
Cgtsam::LevenbergMarquardtParams	Parameters for Levenberg-Marquardt optimization
Cgtsam::SfmLevenbergMarquardtParams	Parameters for CPU SFM Levenberg-Marquardt optimization
COnly	Symbolic elimination etc
Cgtsam::internal::linearAlgorithms::OptimizeClique< CLIQUE >	Pre-order visitor for back-substitution in a Bayes tree
Cgtsam::internal::linearAlgorithms::OptimizeData
Cstd::optional
Cgtsam::TriangulationResult	TriangulationResult is an optional point, along with the reasons why it is invalid
Cgtsam::OptionalJacobian< Rows, Cols >	OptionalJacobian is an Eigen::Ref like class that can take be constructed using either a fixed size or dynamic Eigen matrix
Cgtsam::OptionalJacobian< Eigen::Dynamic, Eigen::Dynamic >
Cgtsam::OrientedPlane3	Represents an infinite plane in 3D, which is composed of a planar normal and its perpendicular distance to the origin
Costream	STL class
Cpair< T1, T2 >	STL class
Cgtsam::ProductLieGroup< Pose3, Calibrations< n > >
Cgtsam::DirectProduct< G, H >	Template to construct the direct product of two arbitrary groups Assumes nothing except group structure and Testable from G and H
Cgtsam::DirectSum< G, H >	Template to construct the direct sum of two additive groups Assumes existence of three additive operators for both groups
Cgtsam::IndexPair	Small utility class for representing a wrappable pairs of ints
Cgtsam::ProductLieGroup< G, H >	Direct product Lie group G × H
Cgtsam::SemidirectLieGroup< G, H, Action >	Left semidirect product G ⋉ H induced by Action
Cgtsam::TangentLieGroup< G >	Tangent Lie group TG = G ⋉ 𝔤, with dimension 2 dim(G)
Cstd::pair< T1, T2 >	STL class
Cgtsam::ProductLieGroup< Pose3, Calibrations< n > >
Cgtsam::DirectProduct< G, H >	Template to construct the direct product of two arbitrary groups Assumes nothing except group structure and Testable from G and H
Cgtsam::DirectSum< G, H >	Template to construct the direct sum of two additive groups Assumes existence of three additive operators for both groups
Cgtsam::IndexPair	Small utility class for representing a wrappable pairs of ints
Cgtsam::ProductLieGroup< G, H >	Direct product Lie group G × H
Cgtsam::SemidirectLieGroup< G, H, Action >	Left semidirect product G ⋉ H induced by Action
Cgtsam::TangentLieGroup< G >	Tangent Lie group TG = G ⋉ 𝔤, with dimension 2 dim(G)
Cgtsam::PiecewisePolynomial< Order, Pieces >::Parameters	Coefficients, interval boundaries, and center defining the kernel
Cgtsam::DoglegLineSearchImpl::Params
Cgtsam::DeltaImpl::PartialSolveResult
Cgtsam::WnoaInterpFactor< PoseType >::PassedInterpData	Container for externally-computed interpolation data
Cgtsam::PCGSolverResult	Solution, convergence diagnostics, and phase timings from PCGSolver
Cgtsam::PinholeBase	A pinhole camera class that has a Pose3, functions as base class for all pinhole cameras
Cgtsam::PinholeBaseK< Calibration >
Cgtsam::PinholeCamera< Calibration >	A pinhole camera class that has a Pose3 and a Calibration
Cgtsam::CalibratedCamera	A Calibrated camera class [R|-R't], calibration K=I
Cgtsam::PinholeBaseK< CALIBRATION >	A pinhole camera class that has a Pose3 and a fixed Calibration
Cgtsam::PinholeCamera< gtsam::Cal3_S2 >
Cgtsam::PinholeCamera< gtsam::Cal3Bundler >
Cgtsam::PinholeCamera< gtsam::Cal3DS2 >
Cgtsam::PinholeCamera< gtsam::Cal3Unified >
Cgtsam::PinholeCamera< gtsam::Cal3Fisheye >
Cgtsam::PinholeCamera< Cal3Bundler >
Cgtsam::PinholeCamera< CALIBRATION >
Cgtsam::PinholeCamera< Cal3_S2 >
Cgtsam::PinholePose< gtsam::Cal3_S2 >
Cgtsam::PinholePose< gtsam::Cal3Bundler >
Cgtsam::PinholePose< gtsam::Cal3DS2 >
Cgtsam::PinholePose< gtsam::Cal3Unified >
Cgtsam::PinholePose< gtsam::Cal3Fisheye >
Cgtsam::PinholePose< CALIBRATION >	A pinhole camera class that has a Pose3 and a fixed Calibration
Cgtsam::PlanarGyroParams	Modeled parameters of the gyro
Cgtsam::PlanarProjectionFactorBase	Camera projection for robot on the floor
Cgtsam::PlanarProjectionFactor1	One variable: the pose
Cgtsam::PlanarProjectionFactor2	Two unknowns: the pose and the landmark
Cgtsam::PlanarProjectionFactor3	Three unknowns: the pose, the camera offset, and the camera calibration
Cgtsam::Pose3Upright	A 3D Pose with fixed pitch and roll
Cgtsam::PoseConcept< POSE >	Pose Concept A must contain a translation and a rotation, with each structure accessable directly and a type provided for each
Cgtsam::gnss::LeverArm::PoseFrame	Intermediate quantities cached by antennaPosition() so antennaPoseJacobian can compute the pose Jacobian without recomputing the rotation/compose
Cgtsam::PoseVelocity< PoseType >	Simple container for a pose and its corresponding velocity
Cgtsam::PowerLieGroupJacobianStorage< T, N >	Shared implementation for fixed-size and dynamic-count PowerLieGroup
Cgtsam::PowerLieGroupJacobianStorage< T, Eigen::Dynamic >
Cgtsam::PowerMethod< Operator >	Compute maximum Eigenpair with power method
Cgtsam::AcceleratedPowerMethod< Operator >	Compute maximum Eigenpair with accelerated power method
Cgtsam::MultifrontalSolver::PrecomputedData	Precomputed symbolic and sizing data for multifrontal solver construction
Cgtsam::Preconditioner
Cgtsam::BlockJacobiPreconditioner
Cgtsam::DummyPreconditioner
Cgtsam::SubgraphPreconditioner	Subgraph conditioner class, as explained in the RSS 2010 submission
Cgtsam::PreconditionerParameters
Cgtsam::BlockJacobiPreconditionerParameters
Cgtsam::DummyPreconditionerParameters
Cgtsam::SubgraphPreconditionerParameters
Cgtsam::PreintegratedRotation	PreintegratedRotation is the base class for all PreintegratedMeasurements classes (in AHRSFactor, ImuFactor, and CombinedImuFactor)
Cgtsam::PreintegratedAhrsMeasurements	PreintegratedAHRSMeasurements accumulates (integrates) the gyroscope measurements (rotation rates) and the corresponding covariance matrix
Cgtsam::PreintegratedRotationParams	Parameters for pre-integration: Usage: Create just a single Params and pass a shared pointer to the constructor
Cgtsam::PreintegrationParams	Parameters for pre-integration: Usage: Create just a single Params and pass a shared pointer to the constructor
Cgtsam::PreintegrationCombinedParams	Parameters for pre-integration using PreintegratedCombinedMeasurements: Usage: Create just a single Params and pass a shared pointer to the constructor
Cgtsam::PreintegrationBase	PreintegrationBase is the base class for PreintegratedMeasurements (in ImuFactor) and CombinedPreintegratedMeasurements (in CombinedImuFactor)
Cgtsam::GalileanPreintegration	IMU preintegration on Gal(3) using GTSAM's left-invariant local error
Cgtsam::PreintegratedCombinedMeasurementsT< GalileanPreintegration >
Cgtsam::PreintegratedImuMeasurementsT< GalileanPreintegration >
Cgtsam::ManifoldPreintegration	IMU pre-integration on NavState manifold
Cgtsam::PreintegratedCombinedMeasurementsT< DefaultPreintegrationType >
Cgtsam::PreintegratedImuMeasurementsT< DefaultPreintegrationType >
Cgtsam::LieGroupPreintegration	IMU preintegration using the SE_2(3) Lie-group structure of NavState
Cgtsam::TangentPreintegration	Integrate on the 9D tangent space of the NavState manifold
CPreintegrationType
Cgtsam::PreintegratedCombinedMeasurementsT< PreintegrationType >	PreintegratedCombinedMeasurements integrates the IMU measurements (rotation rates and accelerations) and the corresponding covariance matrix
Cgtsam::PreintegratedImuMeasurementsT< PreintegrationType >	PreintegratedImuMeasurements accumulates (integrates) the IMU measurements (rotation rates and accelerations) and the corresponding covariance matrix
Cgtsam::detail::PrioritySchedulerPolicy	Queue policy for PriorityScheduler: min-heap priority_queue by task priority
Cgtsam::Range< A1, A2 >
Cgtsam::Range< Point1, Point1 >	Range functor between two Point1 values, using L1 distance
Cgtsam::Range< Point2, Point2 >
Cgtsam::Range< Point3, Point3 >
Cgtsam::RedirectCout	For Python str()
Cgtsam::DeltaImpl::ReorderingMode
Cgtsam::ConcurrentBatchFilter::Result	Meta information returned about the update
Cgtsam::ConcurrentBatchSmoother::Result	Meta information returned about the update
Cgtsam::ConcurrentIncrementalFilter::Result	Meta information returned about the update
Cgtsam::ConcurrentIncrementalSmoother::Result	Meta information returned about the update
Cgtsam::FixedLagSmoother::Result	Meta information returned about the update
Cgtsam::vector< T >::reverse_iterator	STL iterator class
Cmap< K, T >::reverse_iterator	STL iterator class
Cstring::reverse_iterator	STL iterator class
Cunordered_map< K, T >::reverse_iterator	STL iterator class
Cunordered_set< K >::reverse_iterator	STL iterator class
Cvector< T >::reverse_iterator	STL iterator class
CRing	The Real ring with addition and multiplication
Cgtsam::RISAM	Robust Incremental Smoothing and Mapping (riSAM) is a robust variant of iSAM2 for incremental factor-graph optimization
Cgtsam::RISAMParams	Struct Containing all configuration parameters for riSAM
Cgtsam::RISAMUpdateResult	Struct containing information about the riSAM update
Cgtsam::Sampler	Sampling structure that keeps internal random number generators for diagonal distributions specified by NoiseModel
Cgtsam::Scenario	Simple trajectory simulator
Cgtsam::AcceleratingScenario	Accelerating from an arbitrary initial state, with optional rotation
Cgtsam::ConstantTwistScenario	Scenario with constant twist 3D trajectory
Cgtsam::DiscreteScenario	A scenario defined by discrete ground-truth measurements over time
Cgtsam::ScenarioRunner
Cgtsam::AhrsScenarioRunner
Cgtsam::CombinedScenarioRunner
Cstd::set< K >	STL class
Cgtsam::FastSet< FactorIndex >
Cgtsam::FastSet< Key >
Cgtsam::FastSet< size_t >
Cgtsam::FastSet< VALUE >	FastSet is a thin wrapper around std::set that uses the boost fast_pool_allocator instead of the default STL allocator
Cgtsam::SfmData	SfmData stores a bunch of SfmTracks
Cgtsam::SfmTrack2d	Track containing 2D measurements associated with a single 3D point
Cgtsam::SfmTrack
Cgtsam::ShonanAveraging< d >	Class that implements Shonan Averaging from our ECCV'20 paper
Cgtsam::ShonanAveraging< 2 >
Cgtsam::ShonanAveraging2
Cgtsam::ShonanAveraging< 3 >
Cgtsam::ShonanAveraging3
Cgtsam::ShonanAveragingParameters< d >	Parameters governing optimization etc
Cgtsam::Signature	Signature for a discrete conditional distribution, used to construct conditionals
Cgtsam::SignatureParser	A simple parser that replaces the boost spirit parser
Cgtsam::SimpleFundamentalMatrix	Class for representing a simple fundamental matrix
Cgtsam::SimPolygon2D	General polygon class for convex polygons
Cgtsam::SimWall2D	General Wall class for walls defined around unordered endpoints Primarily to handle ray intersections
Cgtsam::DiscreteSearch::Slot	We structure the search as a set of slots, each with a factor and a set of variable assignments that need to be chosen
Cgtsam::SlotEntry	One SlotEntry stores the slot index for a variable, as well its dim
Cgtsam::SmartProjectionParams
Cgtsam::DiscreteSearch::Solution	A solution is a set of assignments, covering all the slots
Cgtsam::internal::SparseNormalAccumulator	Receives sparse normal-equation blocks from compact batch factors
Cgtsam::SphericalCamera	A spherical camera class that has a Pose3 and measures bearing vectors
Cgtsam::abc::State< N >	Minimal state manifold for the biased attitude system: ξ = (R, b, S)
Cgtsam::StateData	Lightweight container for states used for continuous-time estimation and interpolation
Cgtsam::Interpolator< PoseType >::StateJacobians
Cgtsam::StereoCamera	A stereo camera class, parameterize by left camera pose and stereo calibration
Cgtsam::StereoPoint2	A 2D stereo point, v will be same for rectified images
Cgtsam::StreamedKey	To use the key_formatter on Keys, they must be wrapped in a StreamedKey
Cstring	STL class
Cstringstream	STL class
Cgtsam::Subgraph
Cgtsam::SubgraphBuilder
Cgtsam::SubgraphBuilderParameters
Cgtsam::Symbol	Character and index key used to refer to variables
Cgtsam::SymbolGenerator	Generates symbol shorthands with alternative names different than the one-letter predefined ones
Cgtsam::SymmetricBlockMatrix	This class stores a dense matrix and allows it to be accessed as a collection of blocks
CSymmetry
Cgtsam::group_action::Orbit< Symmetry< N > >
Cgtsam::abc::Symmetry< N >::Orbit
Cgtsam::System	Helper class encapsulating the combined system |Ax-b_|^2 Needed to run Conjugate Gradients on matrices
Cgtsam::internal::TangentLieGroupJacobian< G >	Optional closed-form kernels used by TangentLieGroup::Expmap() and its private rightJacobian() helper
Cgtsam::internal::TangentLieGroupJacobian< Rot3 >	Closed-form right Jacobian for TSO(3) = SO(3) semidirect-product so(3)
Cgtsam::detail::TaskSchedulerPolicy	Queue policy for TaskScheduler: deque with local LIFO and stolen FIFO
Cgtsam::TbbOpenMPMixedScope	An object whose scope defines a block where TBB and OpenMP parallelism are mixed
Cgtsam::Expression< T >::TernaryFunction< A1, A2, A3 >
Cgtsam::Testable< T >	A helper that implements the traits interface for GTSAM types
Cgtsam::Testable< abc::State< N > >
Cgtsam::internal::Manifold< abc::State< N > >
Cgtsam::Testable< AHRSFactorT< PIM > >
Cgtsam::traits< AHRSFactorT< PIM > >
Cgtsam::Testable< AlgebraicDecisionTree< T > >
Cgtsam::traits< AlgebraicDecisionTree< T > >
Cgtsam::Testable< AsVectorSpace< Class > >
Cgtsam::traits< AsVectorSpace< Class > >	Traits that expose the adapter as a testable additive vector space
Cgtsam::traits< const AsVectorSpace< Class > >	Const-qualified traits forward to the mutable adapter traits
Cgtsam::Testable< AttitudeFactor< VALUE > >
Cgtsam::traits< AttitudeFactor< VALUE > >
Cgtsam::Testable< BearingFactor< A1, A2, T > >
Cgtsam::traits< BearingFactor< A1, A2, T > >	Traits
Cgtsam::Testable< BearingRange< A1, A2 > >
Cgtsam::traits< BearingRange< A1, A2 > >
Cgtsam::Testable< BearingRangeFactor< A1, A2, B, R > >
Cgtsam::traits< BearingRangeFactor< A1, A2, B, R > >	Traits
Cgtsam::Testable< BetweenConstraint< VALUE > >
Cgtsam::traits< BetweenConstraint< VALUE > >	Traits
Cgtsam::Testable< BetweenFactor< VALUE > >
Cgtsam::traits< BetweenFactor< VALUE > >	Traits
Cgtsam::Testable< BetweenFactorEM< VALUE > >
Cgtsam::traits< BetweenFactorEM< VALUE > >	Traits
Cgtsam::Testable< Cal3_S2 >
Cgtsam::internal::Manifold< Cal3_S2 >
Cgtsam::Testable< Cal3_S2Stereo >
Cgtsam::internal::Manifold< Cal3_S2Stereo >
Cgtsam::Testable< Cal3Bundler >
Cgtsam::internal::Manifold< Cal3Bundler >
Cgtsam::Testable< Cal3DS2 >
Cgtsam::internal::Manifold< Cal3DS2 >
Cgtsam::Testable< Cal3f >
Cgtsam::internal::Manifold< Cal3f >
Cgtsam::Testable< Cal3Fisheye >
Cgtsam::internal::Manifold< Cal3Fisheye >
Cgtsam::Testable< Cal3Unified >
Cgtsam::internal::Manifold< Cal3Unified >
Cgtsam::Testable< CalibratedCamera >
Cgtsam::internal::Manifold< CalibratedCamera >
Cgtsam::Testable< CameraSet< CAMERA > >
Cgtsam::traits< CameraSet< CAMERA > >
Cgtsam::traits< const CameraSet< CAMERA > >
Cgtsam::Testable< CarrierPhaseFactor >
Cgtsam::traits< CarrierPhaseFactor >	Traits
Cgtsam::Testable< CarrierPhaseFactorArm >
Cgtsam::traits< CarrierPhaseFactorArm >	Traits
Cgtsam::Testable< Class >
Cgtsam::internal::AdditiveGroup< Class >	Both additive group traits and Testable
Cgtsam::internal::LieGroup< Class >	Both LieGroupTraits and Testable
Cgtsam::internal::Manifold< Class >	Both ManifoldTraits and Testable
Cgtsam::internal::MatrixLieGroup< Class, N >	Both LieGroupTraits and Testable
Cgtsam::internal::MultiplicativeGroup< Class >	Both multiplicative group traits and Testable
Cgtsam::internal::VectorSpace< Class >	VectorSpace provides both Testable and VectorSpaceTraits
Cgtsam::Testable< CombinedImuFactorT< PIM > >
Cgtsam::traits< CombinedImuFactorT< PIM > >
Cgtsam::Testable< CombinedImuFactorWithGravityT< PIM, GRAVITY > >
Cgtsam::traits< CombinedImuFactorWithGravityT< PIM, GRAVITY > >
Cgtsam::Testable< ConcurrentBatchFilter >
Cgtsam::traits< ConcurrentBatchFilter >	Traits
Cgtsam::Testable< ConcurrentBatchSmoother >
Cgtsam::traits< ConcurrentBatchSmoother >	Traits
Cgtsam::Testable< ConcurrentIncrementalFilter >
Cgtsam::traits< ConcurrentIncrementalFilter >	Traits
Cgtsam::Testable< ConcurrentIncrementalSmoother >
Cgtsam::traits< ConcurrentIncrementalSmoother >	Traits
Cgtsam::Testable< Cyclic< N > >
Cgtsam::traits< Cyclic< N > >	Define cyclic group to be a model of the Additive Group concept
Cgtsam::Testable< DecisionTree< L, Y > >
Cgtsam::traits< DecisionTree< L, Y > >
Cgtsam::Testable< DecisionTreeFactor >
Cgtsam::traits< DecisionTreeFactor >
Cgtsam::Testable< DifferentialPseudorangeFactor >
Cgtsam::traits< DifferentialPseudorangeFactor >	Traits
Cgtsam::Testable< DifferentialPseudorangeFactorArm >
Cgtsam::traits< DifferentialPseudorangeFactorArm >	Traits
Cgtsam::Testable< DiscreteBayesNet >
Cgtsam::traits< DiscreteBayesNet >
Cgtsam::Testable< DiscreteBayesTree >
Cgtsam::traits< DiscreteBayesTree >
Cgtsam::Testable< DiscreteBayesTreeClique >
Cgtsam::traits< DiscreteBayesTreeClique >	Traits
Cgtsam::Testable< DiscreteBoundaryFactor >
Cgtsam::traits< DiscreteBoundaryFactor >
Cgtsam::Testable< DiscreteConditional >
Cgtsam::traits< DiscreteConditional >
Cgtsam::Testable< DiscreteDistribution >
Cgtsam::traits< DiscreteDistribution >
Cgtsam::Testable< DiscreteFactor >
Cgtsam::traits< DiscreteFactor >
Cgtsam::Testable< DiscreteFactorGraph >
Cgtsam::traits< DiscreteFactorGraph >
Cgtsam::Testable< DiscreteKeys >
Cgtsam::traits< DiscreteKeys >
Cgtsam::Testable< DiscreteLookupDAG >
Cgtsam::traits< DiscreteLookupDAG >
Cgtsam::Testable< DiscreteValues >
Cgtsam::traits< DiscreteValues >
Cgtsam::Testable< DopplerFactor >
Cgtsam::traits< DopplerFactor >	Traits
Cgtsam::Testable< DopplerFactorArm >
Cgtsam::traits< DopplerFactorArm >	Traits
Cgtsam::Testable< DoubleDifferenceCarrierPhaseFactor >
Cgtsam::traits< DoubleDifferenceCarrierPhaseFactor >
Cgtsam::Testable< DoubleDifferenceCarrierPhaseFactorArm >
Cgtsam::traits< DoubleDifferenceCarrierPhaseFactorArm >
Cgtsam::Testable< DoubleDifferencePseudorangeFactor >
Cgtsam::traits< DoubleDifferencePseudorangeFactor >
Cgtsam::Testable< DoubleDifferencePseudorangeFactorArm >
Cgtsam::traits< DoubleDifferencePseudorangeFactorArm >
Cgtsam::Testable< EdgeKey >
Cgtsam::traits< EdgeKey >	Traits
Cgtsam::Testable< EssentialMatrix >
Cgtsam::internal::Manifold< EssentialMatrix >
Cgtsam::Testable< Event >
Cgtsam::internal::Manifold< Event >
Cgtsam::Testable< ExpressionFactor< T > >
Cgtsam::traits< ExpressionFactor< T > >	Traits
Cgtsam::Testable< ExpressionFactorN< T, Args... > >
Cgtsam::traits< ExpressionFactorN< T, Args... > >	Traits
Cgtsam::Testable< ExtendedPose3< K, Derived > >
Cgtsam::internal::MatrixLieGroup< ExtendedPose3< K, Derived >, ExtendedPose3< K, Derived >::matrixDim >
Cgtsam::Testable< ExtendedPriorFactor< VALUE > >
Cgtsam::traits< ExtendedPriorFactor< VALUE > >	Traits
Cgtsam::Testable< FixedJacobianFactor< M, Ns... > >
Cgtsam::traits< FixedJacobianFactor< M, Ns... > >
Cgtsam::Testable< FunctorizedFactor2< R, T1, T2 > >
Cgtsam::traits< FunctorizedFactor2< R, T1, T2 > >	Traits
Cgtsam::Testable< FunctorizedFactor< R, T > >
Cgtsam::traits< FunctorizedFactor< R, T > >	Traits
Cgtsam::Testable< FundamentalMatrix >
Cgtsam::internal::Manifold< FundamentalMatrix >
Cgtsam::Testable< Gal3 >
Cgtsam::internal::MatrixLieGroup< Gal3, 5 >
Cgtsam::Testable< GaussianBayesNet >
Cgtsam::traits< GaussianBayesNet >	Traits
Cgtsam::Testable< GaussianBayesTree >
Cgtsam::traits< GaussianBayesTree >	Traits
Cgtsam::Testable< GaussianConditional >
Cgtsam::traits< GaussianConditional >	Traits
Cgtsam::Testable< GaussianFactor >
Cgtsam::traits< GaussianFactor >	Traits
Cgtsam::Testable< GaussianFactorGraph >
Cgtsam::traits< GaussianFactorGraph >	Traits
Cgtsam::Testable< GaussianISAM >
Cgtsam::traits< GaussianISAM >	Traits
Cgtsam::Testable< GaussMarkov1stOrderFactor< VALUE > >
Cgtsam::traits< GaussMarkov1stOrderFactor< VALUE > >	Traits
Cgtsam::Testable< GeneralSFMFactor2< CALIBRATION > >
Cgtsam::traits< GeneralSFMFactor2< CALIBRATION > >
Cgtsam::Testable< GeneralSFMFactor< CAMERA, LANDMARK > >
Cgtsam::traits< GeneralSFMFactor< CAMERA, LANDMARK > >
Cgtsam::Testable< GenericProjectionFactor< POSE, LANDMARK, CALIBRATION > >
Cgtsam::traits< GenericProjectionFactor< POSE, LANDMARK, CALIBRATION > >	Traits
Cgtsam::Testable< GenericStereoFactor< T1, T2 > >
Cgtsam::traits< GenericStereoFactor< T1, T2 > >	Traits
Cgtsam::Testable< GenericValue< ValueType > >
Cgtsam::traits< GenericValue< ValueType > >
Cgtsam::Testable< GPSFactor2Arm >
Cgtsam::traits< GPSFactor2Arm >	Traits
Cgtsam::Testable< GPSFactor2ArmCalib >
Cgtsam::traits< GPSFactor2ArmCalib >	Traits
Cgtsam::Testable< GPSFactorArm >
Cgtsam::traits< GPSFactorArm >	Traits
Cgtsam::Testable< GPSFactorArmCalib >
Cgtsam::traits< GPSFactorArmCalib >	Traits
Cgtsam::Testable< HessianFactor >
Cgtsam::traits< HessianFactor >	Traits
Cgtsam::Testable< HybridBayesNet >
Cgtsam::traits< HybridBayesNet >	Traits
Cgtsam::Testable< HybridBayesTree >
Cgtsam::traits< HybridBayesTree >
Cgtsam::Testable< HybridBayesTreeClique >
Cgtsam::traits< HybridBayesTreeClique >	Traits
Cgtsam::Testable< HybridConditional >
Cgtsam::traits< HybridConditional >
Cgtsam::Testable< HybridFactor >
Cgtsam::traits< HybridFactor >
Cgtsam::Testable< HybridGaussianConditional >
Cgtsam::traits< HybridGaussianConditional >
Cgtsam::Testable< HybridGaussianFactor >
Cgtsam::traits< HybridGaussianFactor >
Cgtsam::Testable< HybridGaussianFactorGraph >
Cgtsam::traits< HybridGaussianFactorGraph >
Cgtsam::Testable< HybridGaussianISAM >
Cgtsam::traits< HybridGaussianISAM >	Traits
Cgtsam::Testable< HybridGaussianProductFactor >
Cgtsam::traits< HybridGaussianProductFactor >
Cgtsam::Testable< HybridNonlinearFactor >
Cgtsam::traits< HybridNonlinearFactor >
Cgtsam::Testable< HybridNonlinearFactorGraph >
Cgtsam::traits< HybridNonlinearFactorGraph >
Cgtsam::Testable< HybridValues >
Cgtsam::traits< HybridValues >
Cgtsam::Testable< imuBias::ConstantBias >
Cgtsam::internal::VectorSpace< imuBias::ConstantBias >
Cgtsam::traits< imuBias::ConstantBias >
Cgtsam::Testable< ImuFactor2T< PIM > >
Cgtsam::traits< ImuFactor2T< PIM > >
Cgtsam::Testable< ImuFactor2WithGravityT< PIM, GRAVITY > >
Cgtsam::traits< ImuFactor2WithGravityT< PIM, GRAVITY > >
Cgtsam::Testable< ImuFactorT< PIM > >
Cgtsam::traits< ImuFactorT< PIM > >
Cgtsam::Testable< ImuFactorWithGravityT< PIM, GRAVITY > >
Cgtsam::traits< ImuFactorWithGravityT< PIM, GRAVITY > >
Cgtsam::Testable< ISAM2 >
Cgtsam::traits< ISAM2 >	Traits
Cgtsam::Testable< JacobianFactor >
Cgtsam::traits< JacobianFactor >	Traits
Cgtsam::Testable< JacobianFactorQ< D, ZDim > >
Cgtsam::traits< JacobianFactorQ< D, ZDim > >
Cgtsam::Testable< LabeledSymbol >
Cgtsam::traits< LabeledSymbol >	Traits
Cgtsam::Testable< Line3 >
Cgtsam::internal::Manifold< Line3 >
Cgtsam::Testable< LinearContainerFactor >
Cgtsam::traits< LinearContainerFactor >
Cgtsam::Testable< NavState >
Cgtsam::internal::MatrixLieGroup< NavState, 5 >
Cgtsam::Testable< noiseModel::Constrained >
Cgtsam::traits< noiseModel::Constrained >
Cgtsam::Testable< noiseModel::Diagonal >
Cgtsam::traits< noiseModel::Diagonal >
Cgtsam::Testable< noiseModel::Gaussian >
Cgtsam::traits< noiseModel::Gaussian >	Traits
Cgtsam::Testable< noiseModel::Isotropic >
Cgtsam::traits< noiseModel::Isotropic >
Cgtsam::Testable< noiseModel::Unit >
Cgtsam::traits< noiseModel::Unit >
Cgtsam::Testable< NonlinearFactor >
Cgtsam::traits< NonlinearFactor >	Traits
Cgtsam::Testable< NonlinearFactorGraph >
Cgtsam::traits< NonlinearFactorGraph >	Traits
Cgtsam::Testable< Ordering >
Cgtsam::traits< Ordering >	Traits
Cgtsam::Testable< OrientedPlane3 >
Cgtsam::internal::Manifold< OrientedPlane3 >
Cgtsam::Testable< PinholeCamera< Calibration > >
Cgtsam::internal::Manifold< PinholeCamera< Calibration > >
Cgtsam::Testable< PinholePose< CALIBRATION > >
Cgtsam::internal::Manifold< PinholePose< CALIBRATION > >
Cgtsam::Testable< PinholeSet< CAMERA > >
Cgtsam::traits< PinholeSet< CAMERA > >
Cgtsam::traits< const PinholeSet< CAMERA > >
Cgtsam::Testable< PlanarProjectionFactor1 >
Cgtsam::traits< PlanarProjectionFactor1 >
Cgtsam::Testable< PlanarProjectionFactor2 >
Cgtsam::traits< PlanarProjectionFactor2 >
Cgtsam::Testable< PlanarProjectionFactor3 >
Cgtsam::traits< PlanarProjectionFactor3 >
Cgtsam::Testable< Pose2 >
Cgtsam::internal::MatrixLieGroup< Pose2, 3 >
Cgtsam::Testable< Pose3 >
Cgtsam::internal::MatrixLieGroup< Pose3, 4 >
Cgtsam::Testable< Pose3Upright >
Cgtsam::internal::Manifold< Pose3Upright >
Cgtsam::Testable< PowerLieGroup< G, N > >
Cgtsam::internal::LieGroup< PowerLieGroup< G, N > >
Cgtsam::Testable< PreintegratedAhrsMeasurements >
Cgtsam::traits< PreintegratedAhrsMeasurements >
Cgtsam::Testable< PreintegratedCombinedMeasurementsT< PreintegrationType > >
Cgtsam::traits< PreintegratedCombinedMeasurementsT< PreintegrationType > >
Cgtsam::Testable< PreintegratedImuMeasurementsT< PreintegrationType > >
Cgtsam::traits< PreintegratedImuMeasurementsT< PreintegrationType > >
Cgtsam::Testable< PreintegratedRotation >
Cgtsam::traits< PreintegratedRotation >
Cgtsam::Testable< PreintegrationCombinedParams >
Cgtsam::traits< PreintegrationCombinedParams >
Cgtsam::Testable< PriorFactor< VALUE > >
Cgtsam::traits< PriorFactor< VALUE > >	Traits
Cgtsam::Testable< ProductLieGroup< G, H > >
Cgtsam::internal::LieGroup< ProductLieGroup< G, H > >
Cgtsam::Testable< ProjectionFactorPPP< POSE, LANDMARK, CALIBRATION > >
Cgtsam::traits< ProjectionFactorPPP< POSE, LANDMARK, CALIBRATION > >	Traits
Cgtsam::Testable< ProjectionFactorPPPC< POSE, LANDMARK, CALIBRATION > >
Cgtsam::traits< ProjectionFactorPPPC< POSE, LANDMARK, CALIBRATION > >	Traits
Cgtsam::Testable< ProjectionFactorRollingShutter >
Cgtsam::traits< ProjectionFactorRollingShutter >	Traits
Cgtsam::Testable< PseudorangeFactor >
Cgtsam::traits< PseudorangeFactor >	Traits
Cgtsam::Testable< PseudorangeFactorArm >
Cgtsam::traits< PseudorangeFactorArm >	Traits
Cgtsam::Testable< RangeFactor< A1, A2, T > >
Cgtsam::traits< RangeFactor< A1, A2, T > >	Traits
Cgtsam::Testable< RangeFactorWithTransform< A1, A2, T > >
Cgtsam::traits< RangeFactorWithTransform< A1, A2, T > >	Traits
Cgtsam::Testable< RangeFactorWithTransformBias< A1, A2, T > >
Cgtsam::traits< RangeFactorWithTransformBias< A1, A2, T > >	Traits
Cgtsam::Testable< ReferenceFrameFactor< T1, T2 > >
Cgtsam::traits< ReferenceFrameFactor< T1, T2 > >	Traits
Cgtsam::Testable< RegularHessianFactor< D > >
Cgtsam::traits< RegularHessianFactor< D > >
Cgtsam::Testable< RegularImplicitSchurFactor< CAMERA > >
Cgtsam::traits< RegularImplicitSchurFactor< CAMERA > >
Cgtsam::Testable< Rot2 >
Cgtsam::internal::MatrixLieGroup< Rot2, 2 >
Cgtsam::Testable< Rot3 >
Cgtsam::internal::MatrixLieGroup< Rot3, 3 >
Cgtsam::Testable< SemidirectLieGroup< G, H, Action > >
Cgtsam::internal::LieGroup< SemidirectLieGroup< G, H, Action > >
Cgtsam::Testable< SfmData >
Cgtsam::traits< SfmData >	Traits
Cgtsam::Testable< SfmTrack >
Cgtsam::traits< SfmTrack >
Cgtsam::Testable< Similarity2 >
Cgtsam::internal::MatrixLieGroup< Similarity2, 3 >
Cgtsam::Testable< Similarity3 >
Cgtsam::internal::MatrixLieGroup< Similarity3, 4 >
Cgtsam::Testable< SimpleFundamentalMatrix >
Cgtsam::internal::Manifold< SimpleFundamentalMatrix >
Cgtsam::Testable< SimWall2D >
Cgtsam::traits< SimWall2D >	Traits
Cgtsam::Testable< SL4 >
Cgtsam::internal::MatrixLieGroup< SL4, 4 >
Cgtsam::Testable< SmartProjectionFactor< CAMERA > >
Cgtsam::traits< SmartProjectionFactor< CAMERA > >	Testable traits for SmartProjectionFactor
Cgtsam::Testable< SmartProjectionFactorBase< CAMERA > >
Cgtsam::traits< SmartProjectionFactorBase< CAMERA > >	Traits
Cgtsam::Testable< SmartProjectionPoseFactor< CALIBRATION > >
Cgtsam::traits< SmartProjectionPoseFactor< CALIBRATION > >	Traits
Cgtsam::Testable< SmartProjectionPoseFactorRollingShutter< CAMERA > >
Cgtsam::traits< SmartProjectionPoseFactorRollingShutter< CAMERA > >	Traits
Cgtsam::Testable< SmartProjectionRigFactor< CAMERA > >
Cgtsam::traits< SmartProjectionRigFactor< CAMERA > >	Traits
Cgtsam::Testable< SmartStereoProjectionFactor >
Cgtsam::traits< SmartStereoProjectionFactor >	Traits
Cgtsam::Testable< SmartStereoProjectionFactorPP >
Cgtsam::traits< SmartStereoProjectionFactorPP >	Traits
Cgtsam::Testable< SmartStereoProjectionPoseFactor >
Cgtsam::traits< SmartStereoProjectionPoseFactor >	Traits
Cgtsam::Testable< SO3 >
Cgtsam::internal::MatrixLieGroup< SO3, 3 >
Cgtsam::Testable< SO4 >
Cgtsam::internal::MatrixLieGroup< SO4, 4 >
Cgtsam::Testable< SO< N > >
Cgtsam::internal::MatrixLieGroup< SO< N >, N >
Cgtsam::Testable< SphericalCamera >
Cgtsam::internal::Manifold< SphericalCamera >
Cgtsam::Testable< StereoCamera >
Cgtsam::internal::Manifold< StereoCamera >
Cgtsam::Testable< StereoPoint2 >
Cgtsam::internal::VectorSpace< StereoPoint2 >
Cgtsam::traits< StereoPoint2 >
Cgtsam::traits< const StereoPoint2 >
Cgtsam::Testable< Symbol >
Cgtsam::traits< Symbol >	Traits
Cgtsam::Testable< SymbolicBayesNet >
Cgtsam::traits< SymbolicBayesNet >	Traits
Cgtsam::Testable< SymbolicBayesTree >
Cgtsam::traits< SymbolicBayesTree >
Cgtsam::Testable< SymbolicBayesTreeClique >
Cgtsam::traits< SymbolicBayesTreeClique >	Traits
Cgtsam::Testable< SymbolicConditional >
Cgtsam::traits< SymbolicConditional >	Traits
Cgtsam::Testable< SymbolicEliminationTree >
Cgtsam::traits< SymbolicEliminationTree >	Traits
Cgtsam::Testable< SymbolicFactor >
Cgtsam::traits< SymbolicFactor >	Traits
Cgtsam::Testable< SymbolicFactorGraph >
Cgtsam::traits< SymbolicFactorGraph >	Traits
Cgtsam::Testable< TableDistribution >
Cgtsam::traits< TableDistribution >
Cgtsam::Testable< TableFactor >
Cgtsam::traits< TableFactor >
Cgtsam::Testable< TangentLieGroup< G > >
Cgtsam::internal::LieGroup< TangentLieGroup< G > >
Cgtsam::Testable< TransformBtwRobotsUnaryFactor< VALUE > >
Cgtsam::traits< TransformBtwRobotsUnaryFactor< VALUE > >	Traits
Cgtsam::Testable< TransformBtwRobotsUnaryFactorEM< VALUE > >
Cgtsam::traits< TransformBtwRobotsUnaryFactorEM< VALUE > >	Traits
Cgtsam::Testable< UndifferencedCarrierPhaseFactor >
Cgtsam::traits< UndifferencedCarrierPhaseFactor >	Traits
Cgtsam::Testable< UndifferencedCarrierPhaseFactorArm >
Cgtsam::traits< UndifferencedCarrierPhaseFactorArm >	Traits
Cgtsam::Testable< UndifferencedPseudorangeFactor >
Cgtsam::traits< UndifferencedPseudorangeFactor >	Traits
Cgtsam::Testable< UndifferencedPseudorangeFactorArm >
Cgtsam::traits< UndifferencedPseudorangeFactorArm >	Traits
Cgtsam::Testable< Unit3 >
Cgtsam::internal::Manifold< Unit3 >
Cgtsam::Testable< Values >
Cgtsam::traits< Values >	Traits
Cgtsam::Testable< VariableIndex >
Cgtsam::traits< VariableIndex >	Traits
Cgtsam::Testable< VariableSlots >
Cgtsam::traits< VariableSlots >	Traits
Cgtsam::Testable< VectorNormFactor< N > >
Cgtsam::traits< VectorNormFactor< N > >	Traits
Cgtsam::Testable< VectorValues >
Cgtsam::traits< VectorValues >	Traits
Cgtsam::Testable< WnoaInterpFactor< POSE > >
Cgtsam::traits< WnoaInterpFactor< POSE > >	Traits
Cgtsam::Testable< WnoaMotionFactor< Pose > >
Cgtsam::traits< WnoaMotionFactor< Pose > >
Cgtsam::TimeOfArrival	Time of arrival to given sensor
Cgtsam::TimestampedPoseVelocity< PoseType >	Timestamped pose and velocity container
Cgtsam::internal::TimingOutline	Timing Entry, arranged in a tree
Cgtsam::traits< T >	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
Cgtsam::traits< Errors >	Traits
Cgtsam::traits< Key >
Cgtsam::traits< QUATERNION_TYPE >
Cgtsam::TrajectoryAlignerSim3	Aligns Pose3 trajectories from multiple child coordinate frames to a parent reference frame using Sim3 (similarity) transformations
Cgtsam::TransferEdges< F >	Base class that holds the EdgeKeys and provides the getMatrices method
Cgtsam::TransferFactor< EM >
Cgtsam::TransferFactor< F >	Binary factor in the context of Structure from Motion (SfM)
Cgtsam::TransferEdges< EssentialMatrix >
Cgtsam::TransferFactor< EssentialMatrix >
Cgtsam::EssentialTransferFactorK< K >	Transfers points between views using essential matrices, optimizes for calibrations of the views, as well
Cgtsam::TransformCovariance< T >	Functor for transforming covariance of T
Cgtsam::TriangulationParameters
Cgtsam::TripleF< F >	Represents a set of three fundamental matrices for transferring points between three cameras
Cstd::true_type
Cgtsam::detail::is_extended_pose3< gtsam::ExtendedPose3< K, Derived > >
Cgtsam::internal::HasLocalJacobians< T, std::void_t< decltype(traits< T >::Local(std::declval< const T & >(), std::declval< const T & >(), std::declval< typename traits< T >::ChartJacobian >(), std::declval< typename traits< T >::ChartJacobian >()))> >
Cgtsam::internal::ProductLieGroupIsVector< Eigen::Matrix< double, N, 1 > >
Cgtsam::internal::SemidirectLieGroupHasAdjointMap< T, std::void_t< decltype(T::adjointMap(std::declval< const typename traits< T >::TangentVector & >()))> >
Cgtsam::internal::SemidirectLieGroupIsVector< Eigen::Matrix< double, N, 1 > >
Cgtsam::internal::TangentLieGroupHasAdjointMap< T, std::void_t< decltype(T::adjointMap(std::declval< const typename traits< T >::TangentVector & >()))> >
Cgtsam::Expression< T >::UnaryFunction< A1 >
Cgtsam::Unit3	Represents a 3D point on a unit sphere
Cunordered_map< K, T >	STL class
Cunordered_set< K >	STL class
Cgtsam::UpdateImpl	Implementation functions for update method All of the methods below have clear inputs and outputs, even if not functional: iSAM2 is inherintly imperative
Cgtsam::Value	This is the base class for any type to be stored in Values
Cgtsam::GenericValue< T >	Wraps any type T so it can play as a Value
Cgtsam::ValueCloneAllocator
Cgtsam::Values	A non-templated config holding any types of Manifold-group elements
CValues	In nonlinear factors, the error function returns the negative log-likelihood as a non-linear function of the values in a
Cgtsam::ValuesCastHelper< ValueType, CastedKeyValuePairType, KeyValuePairType >
Cgtsam::ValuesCastHelper< const Value, CastedKeyValuePairType, KeyValuePairType >
Cgtsam::ValuesCastHelper< Value, CastedKeyValuePairType, KeyValuePairType >
Cgtsam::ValueWithDefault< T, defaultValue >	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
Cgtsam::VariableIndex	Computes and stores the block column structure of a factor graph
Cgtsam::ISAM2Result::DetailedResults::VariableStatus	The status of a single variable, this struct is stored in DetailedResults::variableStatus
Cgtsam::vector< T >	STL class
Cgtsam::CameraSet< PinholePose< Cal3Bundler > >
Cgtsam::CameraSet< PinholePose< Cal3_S2 > >
Cgtsam::CameraSet< PinholePose< Cal3DS2 > >
Cgtsam::CameraSet< PinholePose< Cal3Fisheye > >
Cgtsam::CameraSet< PinholePose< Cal3Unified > >
Cgtsam::CameraSet< PinholeCamera< Cal3Bundler > >
Cgtsam::CameraSet< PinholeCamera< Cal3_S2 > >
Cgtsam::CameraSet< PinholeCamera< Cal3DS2 > >
Cgtsam::CameraSet< PinholeCamera< Cal3Fisheye > >
Cgtsam::CameraSet< PinholeCamera< Cal3Unified > >
Cgtsam::CameraSet< SphericalCamera >
Cgtsam::CameraSet< StereoCamera >
Cgtsam::CameraSet< MonoCamera >
Cgtsam::CameraSet< CAMERA >	A set of cameras, all with their own calibration
Cgtsam::PinholeSet< CAMERA >	PinholeSet: triangulates point and keeps an estimate of it around
Cgtsam::DiscreteKeys	DiscreteKeys is a set of keys that can be assembled using the & operator
Cgtsam::PowerLieGroup< G, Eigen::Dynamic >	Dynamic-count specialization of PowerLieGroup Represents G^N for runtime-sized N while keeping G fixed-size
Cstd::vector< T >	STL class
Cgtsam::CameraSet< PinholePose< Cal3Bundler > >
Cgtsam::CameraSet< PinholePose< Cal3_S2 > >
Cgtsam::CameraSet< PinholePose< Cal3DS2 > >
Cgtsam::CameraSet< PinholePose< Cal3Fisheye > >
Cgtsam::CameraSet< PinholePose< Cal3Unified > >
Cgtsam::CameraSet< PinholeCamera< Cal3Bundler > >
Cgtsam::CameraSet< PinholeCamera< Cal3_S2 > >
Cgtsam::CameraSet< PinholeCamera< Cal3DS2 > >
Cgtsam::CameraSet< PinholeCamera< Cal3Fisheye > >
Cgtsam::CameraSet< PinholeCamera< Cal3Unified > >
Cgtsam::CameraSet< SphericalCamera >
Cgtsam::CameraSet< StereoCamera >
Cgtsam::CameraSet< MonoCamera >
Cgtsam::CameraSet< CAMERA >	A set of cameras, all with their own calibration
Cgtsam::DiscreteKeys	DiscreteKeys is a set of keys that can be assembled using the & operator
Cgtsam::PowerLieGroup< G, Eigen::Dynamic >	Dynamic-count specialization of PowerLieGroup Represents G^N for runtime-sized N while keeping G fixed-size
Cvector< T >	STL class
Cgtsam::CameraSet< PinholePose< Cal3Bundler > >
Cgtsam::CameraSet< PinholePose< Cal3_S2 > >
Cgtsam::CameraSet< PinholePose< Cal3DS2 > >
Cgtsam::CameraSet< PinholePose< Cal3Fisheye > >
Cgtsam::CameraSet< PinholePose< Cal3Unified > >
Cgtsam::CameraSet< PinholeCamera< Cal3Bundler > >
Cgtsam::CameraSet< PinholeCamera< Cal3_S2 > >
Cgtsam::CameraSet< PinholeCamera< Cal3DS2 > >
Cgtsam::CameraSet< PinholeCamera< Cal3Fisheye > >
Cgtsam::CameraSet< PinholeCamera< Cal3Unified > >
Cgtsam::CameraSet< SphericalCamera >
Cgtsam::CameraSet< StereoCamera >
Cgtsam::CameraSet< MonoCamera >
Cgtsam::CameraSet< CAMERA >	A set of cameras, all with their own calibration
Cgtsam::DiscreteKeys	DiscreteKeys is a set of keys that can be assembled using the & operator
Cgtsam::PowerLieGroup< G, Eigen::Dynamic >	Dynamic-count specialization of PowerLieGroup Represents G^N for runtime-sized N while keeping G fixed-size
Cgtsam::internal::VectorSpaceImpl< Class, N >	VectorSpaceTraits Implementation for Fixed sizes
Cgtsam::internal::VectorSpaceImpl< Class, Class::dimension >
Cgtsam::internal::VectorSpaceTraits< AsVectorSpace< Class > >
Cgtsam::traits< AsVectorSpace< Class > >	Traits that expose the adapter as a testable additive vector space
Cgtsam::internal::VectorSpaceTraits< Class >	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
Cgtsam::internal::VectorSpace< Class >	VectorSpace provides both Testable and VectorSpaceTraits
Cgtsam::internal::VectorSpaceImpl< Class, Eigen::Dynamic >	VectorSpaceTraits implementation for dynamic types
Cgtsam::internal::VectorSpaceImpl< double, 1 >
Cgtsam::internal::ScalarTraits< double >
Cgtsam::traits< double >	Double
Cgtsam::internal::VectorSpaceImpl< Eigen::Matrix< double, M, N, Options, MaxRows, MaxCols >, M *N >
Cgtsam::traits< Eigen::Matrix< double, M, N, Options, MaxRows, MaxCols > >
Cgtsam::internal::VectorSpaceImpl< float, 1 >
Cgtsam::internal::ScalarTraits< float >
Cgtsam::traits< float >	Float
Cgtsam::internal::VectorSpaceImpl< imuBias::ConstantBias, imuBias::ConstantBias::dimension >
Cgtsam::internal::VectorSpaceTraits< imuBias::ConstantBias >
Cgtsam::internal::VectorSpace< imuBias::ConstantBias >
Cgtsam::internal::VectorSpaceImpl< Scalar, 1 >
Cgtsam::internal::ScalarTraits< Scalar >	A helper that implements the traits interface for scalar vector spaces
Cgtsam::internal::VectorSpaceImpl< StereoPoint2, StereoPoint2::dimension >
Cgtsam::internal::VectorSpaceTraits< StereoPoint2 >
Cgtsam::internal::VectorSpace< StereoPoint2 >
Cgtsam::VectorValues	VectorValues represents a collection of vector-valued variables associated each with a unique integer index
CVectorValues	The Factor::error simply extracts the
Cgtsam::VerticalBlockMatrix	This class stores a dense matrix and allows it to be accessed as a collection of vertical blocks
Cgtsam::Visit< L, Y >	Functor performing depth-first visit to each leaf with the leaf value as the argument
Cgtsam::VisitLeaf< L, Y >	Functor performing depth-first visit to each leaf with the Leaf object passed as an argument
Cgtsam::VisitWith< L, Y >	Functor performing depth-first visit to each leaf with the leaf's Assignment<L> and value passed as arguments
Cgtsam::WeightedSampler< Engine >
Cgtsam::partition::WorkSpace