| Cgtsam::_ValuesConstKeyValuePair< ValueType > | |
| Cgtsam::_ValuesKeyValuePair< ValueType > | |
| Cgtsam::ActiveSetSolver< PROBLEM, POLICY, INITSOLVER > | This class implements the active set algorithm for solving convex Programming problems |
| 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 | |
| ►CAdditiveGroupTraits | |
| Cgtsam::traits< Cyclic< N > > | Define cyclic group to be a model of the Additive Group concept |
| Cgtsam::traits< DirectSum< G, H > > | |
| ►Cadjacency_list | |
| Cgtsam::SDGraph< KEY > | SDGraph is undirected graph with variable keys and double edge weights |
| Cgtsam::SGraph< KEY > | |
| Cgtsam::AHRS | |
| Cgtsam::internal::apply_compose< T > | |
| ►Cgtsam::AttitudeFactor | |
| Cgtsam::Pose3AttitudeFactor | |
| Cgtsam::Rot3AttitudeFactor | |
| 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 | |
| Cgtsam::noiseModel::mEstimator::Cauchy | Cauchy implements the "Cauchy" robust error model (Lee2013IROS) |
| Cgtsam::noiseModel::mEstimator::DCS | DCS implements the Dynamic Covariance Scaling robust error model from the paper Robust Map Optimization (Agarwal13icra) |
| Cgtsam::noiseModel::mEstimator::Fair | Fair implements the "Fair" robust error model (Zhang97ivc) |
| Cgtsam::noiseModel::mEstimator::GemanMcClure | GemanMcClure implements the "Geman-McClure" robust error model (Zhang97ivc) |
| Cgtsam::noiseModel::mEstimator::Huber | Huber implements 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 class is not robust so is a Gaussian ? |
| Cgtsam::noiseModel::mEstimator::Tukey | Tukey implements the "Tukey" robust error model (Zhang97ivc) |
| Cgtsam::noiseModel::mEstimator::Welsh | Welsh implements the "Welsh" robust error model (Zhang97ivc) |
| Cgtsam::BayesTree< CLIQUE > | |
| ►Cgtsam::BayesTree< DiscreteBayesTreeClique > | |
| Cgtsam::DiscreteBayesTree | A Bayes tree representing a Discrete density |
| ►Cgtsam::BayesTree< GaussianBayesTreeClique > | |
| ►Cgtsam::GaussianBayesTree | A Bayes tree representing a Gaussian density |
| ►Cgtsam::ISAM< GaussianBayesTree > | |
| Cgtsam::GaussianISAM | |
| ►Cgtsam::BayesTree< ISAM2Clique > | |
| Cgtsam::ISAM2 | |
| ►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< 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::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::BearingRange< A1, A2 > | |
| Cgtsam::BearingS2 | |
| ►Cbinary_function | |
| Cgtsam::equals< V > | Template to create a binary predicate |
| Cgtsam::equals_star< V > | Binary predicate on shared pointers |
| Cgtsam::Expression< T >::BinaryFunction< A1, A2 > | |
| Cgtsam::BTree< KEY, VALUE > | |
| ►Cgtsam::BTree< KEY, KEY > | |
| Cgtsam::DSF< KEY > | |
| Cgtsam::Cal3_S2 | |
| Cgtsam::Cal3_S2Stereo | |
| Cgtsam::Cal3Bundler | |
| ►Cgtsam::Cal3DS2_Base | |
| Cgtsam::Cal3DS2 | |
| Cgtsam::Cal3Unified | |
| Cgtsam::CameraProjectionMatrix< CALIBRATION > | Create a 3*4 camera projection matrix from calibration and pose |
| Cgtsam::Rot3::CayleyChart | |
| Cgtsam::CGState< S, V, E > | |
| Cgtsam::Pose2::ChartAtOrigin | |
| Cgtsam::Pose3::ChartAtOrigin | |
| Cgtsam::Rot2::ChartAtOrigin | |
| Cgtsam::Rot3::ChartAtOrigin | |
| Cgtsam::SO3::ChartAtOrigin | |
| Cgtsam::SmartRangeFactor::Circle2 | |
| ►CCluster | |
| Cgtsam::NonlinearClusterTree::NonlinearCluster | |
| Cgtsam::ClusterTree< GRAPH >::Cluster | A Cluster is just a collection of factors |
| ►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< BAYESTREE, GRAPH > | |
| ►Cgtsam::ClusterTree< DiscreteFactorGraph > | |
| ►Cgtsam::EliminatableClusterTree< DiscreteBayesTree, DiscreteFactorGraph > | |
| ►Cgtsam::JunctionTree< DiscreteBayesTree, DiscreteFactorGraph > | |
| Cgtsam::DiscreteJunctionTree | |
| ►Cgtsam::ClusterTree< GaussianFactorGraph > | |
| ►Cgtsam::EliminatableClusterTree< GaussianBayesTree, GaussianFactorGraph > | |
| ►Cgtsam::JunctionTree< GaussianBayesTree, GaussianFactorGraph > | |
| Cgtsam::GaussianJunctionTree | |
| ►Cgtsam::EliminatableClusterTree< ISAM2BayesTree, GaussianFactorGraph > | |
| Cgtsam::JunctionTree< ISAM2BayesTree, GaussianFactorGraph > | |
| ►Cgtsam::ClusterTree< NonlinearFactorGraph > | |
| Cgtsam::NonlinearClusterTree | |
| ►Cgtsam::ClusterTree< SymbolicFactorGraph > | |
| ►Cgtsam::EliminatableClusterTree< SymbolicBayesTree, SymbolicFactorGraph > | |
| ►Cgtsam::JunctionTree< SymbolicBayesTree, SymbolicFactorGraph > | |
| Cgtsam::SymbolicJunctionTree | |
| ►CCONCURRENT_MAP_BASE | |
| Cgtsam::ConcurrentMap< Key, sharedClique > | |
| Cgtsam::ConcurrentMap< Key, Vector > | |
| Cgtsam::ConcurrentMap< KEY, VALUE > | |
| Cgtsam::ConcurrentBatchFilterResult | |
| Cgtsam::ConcurrentBatchSmootherResult | |
| ►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::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::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 > | TODO: Update comments |
| ►Cgtsam::Conditional< DecisionTreeFactor, DiscreteConditional > | |
| Cgtsam::DiscreteConditional | Discrete Conditional Density Derives from DecisionTreeFactor |
| ►Cgtsam::Conditional< JacobianFactor, GaussianConditional > | |
| ►Cgtsam::GaussianConditional | A conditional Gaussian functions as the node in a Bayes network It has a set of parents y,z, etc |
| Cgtsam::GaussianDensity | A Gaussian density |
| ►Cgtsam::Conditional< SymbolicFactor, SymbolicConditional > | |
| Cgtsam::SymbolicConditional | SymbolicConditional is a conditional with keys but no probability data, produced by symbolic elimination of SymbolicFactor |
| ►CConditionalType | |
| Cgtsam::BayesTreeOrphanWrapper< CLIQUE > | |
| Cgtsam::BTree< KEY, VALUE >::const_iterator | Const iterator Not trivial: iterator keeps a stack to indicate current path from root_ |
| Cgtsam::const_selector< TEST_TYPE, BASIC_TYPE, AS_NON_CONST, AS_CONST > | Helper class that uses templates to select between two types based on whether TEST_TYPE is const or not |
| Cgtsam::const_selector< BASIC_TYPE, BASIC_TYPE, AS_NON_CONST, AS_CONST > | Specialization for the non-const version |
| Cgtsam::const_selector< const BASIC_TYPE, BASIC_TYPE, AS_NON_CONST, AS_CONST > | Specialization for the const version |
| Cgtsam::imuBias::ConstantBias | |
| Cgtsam::Values::ConstFiltered< ValueType > | A filtered view of a const Values, returned from Values::filter |
| Cgtsam::Values::ConstKeyValuePair | A key-value pair, which you get by dereferencing iterators |
| Cgtsam::ConstructorTraversalData< BAYESTREE, GRAPH, ETREE_NODE > | |
| Cgtsam::CRefCallAddCopy< C > | Helper |
| Cgtsam::CRefCallPushBack< C > | Helper |
| Cgtsam::Cyclic< N > | Cyclic group of order N |
| Cgtsam::DecisionTree< L, Y > | Decision Tree L = label for variables Y = function range (any algebra), e.g., bool, int, double |
| ►Cgtsam::DecisionTree< Key, double > | |
| ►Cgtsam::AlgebraicDecisionTree< Key > | |
| ►Cgtsam::Potentials | A base class for both DiscreteFactor and DiscreteConditional |
| ►Cgtsam::DecisionTreeFactor | A discrete probabilistic factor |
| Cgtsam::DiscreteConditional | Discrete Conditional Density Derives from DecisionTreeFactor |
| ►Cgtsam::DecisionTree< L, double > | |
| Cgtsam::AlgebraicDecisionTree< L > | Algebraic Decision Trees fix the range to double Just has some nice constructors and some syntactic sugar TODO: consider eliminating this class altogether? |
| ►Cdefault_bfs_visitor | |
| Cgtsam::compose_key_visitor< V, POSE, KEY > | |
| Cgtsam::ordering_key_visitor< KEY > | |
| 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::DoglegOptimizerImpl | This class contains the implementation of the Dogleg algorithm |
| ►Cgtsam::DSFBase | |
| Cgtsam::DSFVector | |
| Cgtsam::DSFMap< KEY > | |
| Cgtsam::Dummy | |
| 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::EliminateableFactorGraph< FACTORGRAPH > | 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 | Scheduler class Creates one variable for each student, and three variables for each of the student's areas, for a total of 4*nrStudents variables |
| ►Cgtsam::EliminateableFactorGraph< GaussianFactorGraph > | |
| Cgtsam::GaussianFactorGraph | A Linear Factor Graph is a factor graph where all factors are Gaussian, i.e |
| ►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< SymbolicFactorGraph > | |
| Cgtsam::EliminationTree< BAYESNET, GRAPH > | An elimination tree is a data structure used intermediately during elimination |
| ►Cgtsam::EliminationTree< DiscreteBayesNet, DiscreteFactorGraph > | |
| Cgtsam::DiscreteEliminationTree | |
| ►Cgtsam::EliminationTree< GaussianBayesNet, GaussianFactorGraph > | |
| Cgtsam::GaussianEliminationTree | |
| ►Cgtsam::EliminationTree< SymbolicBayesNet, SymbolicFactorGraph > | |
| Cgtsam::SymbolicEliminationTree | |
| 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 |
| ►Cstd::exception | STL class |
| 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_exception if GTSAM is compiled with TBB |
| Cgtsam::ValuesIncorrectType | |
| Cgtsam::ValuesKeyAlreadyExists | |
| Cgtsam::ValuesKeyDoesNotExist | |
| ►Cstd::runtime_error | STL class |
| 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::ThreadsafeException< CheiralityException > | |
| Cgtsam::CheiralityException | |
| ►Cgtsam::ThreadsafeException< CholeskyFailed > | |
| Cgtsam::CholeskyFailed | Indicate Cholesky factorization failure |
| ►Cgtsam::ThreadsafeException< IndeterminantLinearSystemException > | |
| Cgtsam::IndeterminantLinearSystemException | Thrown when a linear system is ill-posed |
| ►Cgtsam::ThreadsafeException< InfeasibleInitialValues > | |
| Cgtsam::InfeasibleInitialValues | An exception indicating that the provided initial value is infeasible Also used to inzdicatethat the noise model dimension passed into a JacobianFactor has a different dimensionality than the factor |
| ►Cgtsam::ThreadsafeException< InfeasibleOrUnboundedProblem > | |
| Cgtsam::InfeasibleOrUnboundedProblem | |
| ►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< QPSParserException > | |
| Cgtsam::QPSParserException | |
| ►Cgtsam::ThreadsafeException< RuntimeErrorThreadsafe > | |
| Cgtsam::RuntimeErrorThreadsafe | Thread-safe runtime error exception |
| Cgtsam::internal::ExecutionTrace< T > | |
| ►Cgtsam::so3::ExpmapFunctor | Functor implementing Exponential map |
| Cgtsam::so3::DexpFunctor | Functor that implements Exponential map and its derivatives |
| ►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::Expression< BearingRange< A1, A2 > > | |
| Cgtsam::Expression< double > | |
| Cgtsam::internal::ExpressionNode< T > | |
| Cgtsam::ExtendedKalmanFilter< VALUE > | This is a generic Extended Kalman Filter class implemented using nonlinear factors |
| ►Cgtsam::Factor | This is the base class for all factor types |
| ►Cgtsam::DiscreteFactor | Base class for discrete probabilistic factors The most general one is the derived DecisionTreeFactor |
| ►Cgtsam::Constraint | Base class for discrete probabilistic factors The most general one is the derived DecisionTreeFactor |
| Cgtsam::AllDiff | General AllDiff constraint Returns 1 if values for all keys are different, 0 otherwise DiscreteFactors are all awkward in that they have to store two types of keys: for each variable we have a Key and an Key |
| Cgtsam::BinaryAllDiff | Binary AllDiff constraint Returns 1 if values for two keys are different, 0 otherwise DiscreteFactors are all awkward in that they have to store two types of keys: for each variable we have a Index and an Index |
| Cgtsam::Domain | Domain restriction constraint |
| Cgtsam::SingleValue | SingleValue constraint |
| Cgtsam::DecisionTreeFactor | A discrete probabilistic factor |
| ►Cgtsam::GaussianFactor | An abstract virtual base class for JacobianFactor and HessianFactor |
| ►Cgtsam::HessianFactor | A Gaussian factor using the canonical parameters (information form) |
| Cgtsam::RegularHessianFactor< D > | |
| ►Cgtsam::JacobianFactor | A Gaussian factor in the squared-error form |
| Cgtsam::BinaryJacobianFactor< M, N1, N2 > | A binary JacobianFactor specialization that uses fixed matrix math for speed |
| Cgtsam::GaussianConditional | A conditional Gaussian functions as the node in a Bayes network It has a set of parents y,z, etc |
| Cgtsam::LinearCost | This class defines a linear cost function c'x which is a JacobianFactor with only one row |
| Cgtsam::LinearEquality | This class defines a linear equality constraints, inheriting JacobianFactor with the special Constrained noise model |
| Cgtsam::LinearInequality | This class defines a linear inequality constraint Ax-b <= 0, inheriting JacobianFactor with the special Constrained noise model |
| ►Cgtsam::RegularJacobianFactor< D > | JacobianFactor with constant sized blocks Provides raw memory access versions of linear operator |
| 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 |
| Cgtsam::RegularImplicitSchurFactor< CAMERA > | RegularImplicitSchurFactor |
| ►Cgtsam::NonlinearFactor | Nonlinear factor base class |
| Cgtsam::AntiFactor | |
| Cgtsam::BetweenFactorEM< VALUE > | |
| Cgtsam::BetweenFactorEM< VALUE > | |
| Cgtsam::DGroundConstraint | Ground constraint: forces the robot to be upright (no roll, pitch), a fixed height, and no velocity in z direction Dim: 4 |
| Cgtsam::DHeightPrior | Forces the value of the height in a PoseRTV to a specific value Dim: 1 |
| Cgtsam::DRollPrior | Forces the roll to a particular value - useful for flying robots Implied value is zero Dim: 1 |
| Cgtsam::DummyFactor | |
| Cgtsam::DummyFactor | |
| Cgtsam::LinearContainerFactor | Dummy version of a generic linear factor to be injected into a nonlinear factor graph |
| ►Cgtsam::LinearizedGaussianFactor | A base factor class for the Jacobian and Hessian linearized factors |
| Cgtsam::LinearizedHessianFactor | A factor that takes a linear, Hessian factor and inserts it into a nonlinear graph |
| Cgtsam::LinearizedJacobianFactor | A factor that takes a linear, Jacobian factor and inserts it into a nonlinear 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< BearingRange< A1, A2 > > | |
| ►Cgtsam::ExpressionFactor2< BearingRange< A1, A2 >, A1, A2 > | |
| Cgtsam::BearingRangeFactor< A1, A2, B, R > | |
| ►Cgtsam::ExpressionFactor< double > | |
| Cgtsam::TOAFactor | A "Time of Arrival" factor - so little code seems hardly worth it :-) |
| ►Cgtsam::BetweenFactor< VALUE > | |
| Cgtsam::BetweenConstraint< VALUE > | Binary between constraint - forces between to a given value This constraint requires the underlying type to a Lie type |
| Cgtsam::DeltaFactor | DeltaFactor: relative 2D measurement between Pose2 and Point2 |
| Cgtsam::DeltaFactorBase | DeltaFactorBase: relative 2D measurement between Pose2 and Point2, with Basenodes |
| Cgtsam::DiscreteEulerPoincareHelicopter | Implement the Discrete Euler-Poincare' equation: |
| ►Cgtsam::ExpressionFactor< T > | Factor that supports arbitrary expressions via AD |
| ►Cgtsam::ExpressionFactor2< T, A1, A2 > | Binary specialization of ExpressionFactor meant as a base class for binary factors |
| Cgtsam::BearingFactor< A1, A2, T > | |
| Cgtsam::RangeFactor< A1, A2, T > | |
| Cgtsam::RangeFactorWithTransform< A1, A2, T > | |
| Cgtsam::FullIMUFactor< POSE > | Class that represents integrating IMU measurements over time for dynamic systems This factor has dimension 9, with a built-in constraint for velocity modeling |
| Cgtsam::IMUFactor< POSE > | Class that represents integrating IMU measurements over time for dynamic systems Templated to allow for different key types, but variables all assumed to be PoseRTV |
| Cgtsam::InvDepthFactorVariant1 | Binary factor representing a visual measurement using an inverse-depth parameterization |
| 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::InvDepthFactorVariant3b | Ternary factor representing a visual measurement using an inverse-depth parameterization |
| Cgtsam::MultiProjectionFactor< POSE, LANDMARK, CALIBRATION > | |
| ►Cgtsam::NoiseModelFactor1< VALUE > | A convenient base class for creating your own NoiseModelFactor with 1 variable |
| Cgtsam::BoundingConstraint1< VALUE > | |
| Cgtsam::NonlinearEquality< VALUE > | An equality factor that forces either one variable to a constant, or a set of variables to be equal to each other |
| Cgtsam::NonlinearEquality1< VALUE > | Simple unary equality constraint - fixes a value for a variable |
| Cgtsam::PartialPriorFactor< VALUE > | A class for a soft partial prior on any Lie type, with a mask over Expmap parameters |
| Cgtsam::PriorFactor< VALUE > | |
| ►Cgtsam::NoiseModelFactor2< VALUE1, VALUE2 > | A convenient base class for creating your own NoiseModelFactor with 2 variables |
| Cgtsam::BoundingConstraint2< VALUE1, VALUE2 > | Binary scalar inequality constraint, with a similar value() function to implement for specific systems |
| Cgtsam::NoiseModelFactor3< VALUE1, VALUE2, VALUE3 > | A convenient base class for creating your own NoiseModelFactor with 3 variables |
| Cgtsam::NoiseModelFactor4< VALUE1, VALUE2, VALUE3, VALUE4 > | A convenient base class for creating your own NoiseModelFactor with 4 variables |
| Cgtsam::NoiseModelFactor5< VALUE1, VALUE2, VALUE3, VALUE4, VALUE5 > | A convenient base class for creating your own NoiseModelFactor with 5 variables |
| Cgtsam::NoiseModelFactor6< VALUE1, VALUE2, VALUE3, VALUE4, VALUE5, VALUE6 > | A convenient base class for creating your own NoiseModelFactor with 6 variables |
| Cgtsam::NonlinearEquality< VALUE > | An equality factor that forces either one variable to a constant, or a set of variables to be equal to each other |
| Cgtsam::OdometryFactorBase | OdometryFactorBase: Pose2 odometry, with Basenodes |
| Cgtsam::PriorFactor< VALUE > | |
| Cgtsam::ProjectionFactorPPP< POSE, LANDMARK, CALIBRATION > | |
| Cgtsam::ProjectionFactorPPPC< POSE, LANDMARK, CALIBRATION > | |
| Cgtsam::RangeFactor< A1, A2, T > | |
| Cgtsam::Reconstruction | Implement the Reconstruction equation: \( g_{k+1} = g_k \exp (h\xi_k) \), where \( h \): timestep (parameter) \( g_{k+1}, g_{k} \): poses at the current and the next timestep \( \xi_k \): the body-fixed velocity (Lie algebra) It is somewhat similar to BetweenFactor, but treats the body-fixed velocity \( \xi_k \) as a variable |
| Cgtsam::RelativeElevationFactor | Binary factor for a relative elevation |
| Cgtsam::SmartRangeFactor | |
| Cgtsam::SmartRangeFactor | |
| ►Cgtsam::NoiseModelFactor1< EssentialMatrix > | |
| Cgtsam::EssentialMatrixFactor | Factor that evaluates epipolar error p'Ep for given essential matrix |
| ►Cgtsam::NoiseModelFactor1< NavState > | |
| Cgtsam::GPSFactor2 | |
| ►Cgtsam::NoiseModelFactor1< OrientedPlane3 > | |
| Cgtsam::OrientedPlane3DirectionPrior | |
| ►Cgtsam::NoiseModelFactor1< Point3 > | |
| Cgtsam::TriangulationFactor< CAMERA > | |
| ►Cgtsam::NoiseModelFactor1< POSE > | |
| Cgtsam::PosePriorFactor< POSE > | |
| Cgtsam::PoseRotationPrior< POSE > | |
| Cgtsam::PoseTranslationPrior< POSE > | A prior on the translation part of a pose |
| ►Cgtsam::NoiseModelFactor1< Pose3 > | |
| Cgtsam::GPSFactor | |
| Cgtsam::Pose3AttitudeFactor | |
| ►Cgtsam::NoiseModelFactor1< PoseRTV > | |
| ►Cgtsam::PartialPriorFactor< PoseRTV > | |
| Cgtsam::DGroundConstraint | Ground constraint: forces the robot to be upright (no roll, pitch), a fixed height, and no velocity in z direction Dim: 4 |
| Cgtsam::DHeightPrior | Forces the value of the height in a PoseRTV to a specific value Dim: 1 |
| Cgtsam::DRollPrior | Forces the roll to a particular value - useful for flying robots Implied value is zero Dim: 1 |
| Cgtsam::VelocityPrior | Constrains the full velocity of a state to a particular value Useful for enforcing a stationary state Dim: 3 |
| ►Cgtsam::NoiseModelFactor1< Rot2 > | |
| 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::NoiseModelFactor1< Rot3 > | |
| 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::Rot3AttitudeFactor | |
| 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::NoiseModelFactor2< CAMERA, LANDMARK > | |
| Cgtsam::GeneralSFMFactor< CAMERA, LANDMARK > | |
| ►Cgtsam::NoiseModelFactor2< 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::NoiseModelFactor2< 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::NoiseModelFactor2< POSE, LANDMARK > | |
| Cgtsam::GenericProjectionFactor< POSE, LANDMARK, CALIBRATION > | |
| Cgtsam::GenericStereoFactor< POSE, LANDMARK > | |
| ►Cgtsam::NoiseModelFactor2< POSE, POSE > | |
| Cgtsam::FullIMUFactor< POSE > | Class that represents integrating IMU measurements over time for dynamic systems This factor has dimension 9, with a built-in constraint for velocity modeling |
| Cgtsam::IMUFactor< POSE > | Class that represents integrating IMU measurements over time for dynamic systems Templated to allow for different key types, but variables all assumed to be PoseRTV |
| Cgtsam::PoseBetweenFactor< POSE > | |
| ►Cgtsam::NoiseModelFactor2< Pose2, Point2 > | |
| Cgtsam::DeltaFactor | DeltaFactor: relative 2D measurement between Pose2 and Point2 |
| ►Cgtsam::NoiseModelFactor2< Pose3, OrientedPlane3 > | |
| Cgtsam::OrientedPlane3Factor | Factor to measure a planar landmark from a given pose |
| ►Cgtsam::NoiseModelFactor2< Pose3, Point3 > | |
| Cgtsam::BiasedGPSFactor | |
| Cgtsam::RelativeElevationFactor | Binary factor for a relative elevation |
| ►Cgtsam::NoiseModelFactor2< Pose3, Pose3 > | |
| Cgtsam::EssentialMatrixConstraint | |
| ►Cgtsam::NoiseModelFactor2< 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::NoiseModelFactor2< Pose3, Vector6 > | |
| Cgtsam::InvDepthFactorVariant1 | Binary factor representing a visual measurement using an inverse-depth parameterization |
| ►Cgtsam::NoiseModelFactor2< PoseRTV, PoseRTV > | |
| Cgtsam::VelocityConstraint | Constraint to enforce dynamics between the velocities and poses, using a prediction based on a numerical integration flag |
| ►Cgtsam::NoiseModelFactor2< VALUE, VALUE > | |
| Cgtsam::BetweenFactor< VALUE > | |
| Cgtsam::GaussMarkov1stOrderFactor< VALUE > | |
| Cgtsam::NonlinearEquality2< VALUE > | Simple binary equality constraint - this constraint forces two factors to be the same |
| ►Cgtsam::NoiseModelFactor3< double, double, double > | |
| Cgtsam::PendulumFactor1 | This class implements the first constraint |
| Cgtsam::PendulumFactor2 | This class implements the second constraint the |
| Cgtsam::PendulumFactorPk | This class implements the first position-momentum update rule p_k = -D_1 L_d(q_k,q_{k+1},h) = \frac{1}{h}mr^{2}\left(q_{k+1}-q_{k}\right)+mgrh(1-\alpha)\,\sin\left((1-\alpha)q_{k}+\alpha q_{k+1}\right) = (1/h)mr^2 (q_{k+1}-q_k) + mgrh(1-alpha) sin ((1-alpha)q_k+\alpha q_{k+1}) |
| Cgtsam::PendulumFactorPk1 | This class implements the second position-momentum update rule p_k1 = D_2 L_d(q_k,q_{k+1},h) = \frac{1}{h}mr^{2}\left(q_{k+1}-q_{k}\right)-mgrh\alpha\sin\left((1-\alpha)q_{k}+\alpha q_{k+1}\right) = (1/h)mr^2 (q_{k+1}-q_k) - mgrh alpha sin ((1-alpha)q_k+\alpha q_{k+1}) |
| Cgtsam::VelocityConstraint3 | |
| ►Cgtsam::NoiseModelFactor3< 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::NoiseModelFactor3< NavState, NavState, imuBias::ConstantBias > | |
| Cgtsam::ImuFactor2 | |
| ►Cgtsam::NoiseModelFactor3< 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::NoiseModelFactor3< POSE, LANDMARK, INVDEPTH > | |
| Cgtsam::InvDepthFactor3< POSE, LANDMARK, INVDEPTH > | Ternary factor representing a visual measurement that includes inverse depth |
| ►Cgtsam::NoiseModelFactor3< POSE, POSE, LANDMARK > | |
| Cgtsam::ProjectionFactorPPP< POSE, LANDMARK, CALIBRATION > | |
| ►Cgtsam::NoiseModelFactor3< Pose3, Point3, CALIBRATION > | |
| Cgtsam::GeneralSFMFactor2< CALIBRATION > | Non-linear factor for a constraint derived from a 2D measurement |
| ►Cgtsam::NoiseModelFactor3< Pose3, Pose3, Vector3 > | |
| Cgtsam::InvDepthFactorVariant3b | Ternary factor representing a visual measurement using an inverse-depth parameterization |
| ►Cgtsam::NoiseModelFactor3< Pose3, Pose3, Vector6 > | |
| Cgtsam::Reconstruction | Implement the Reconstruction equation: \( g_{k+1} = g_k \exp (h\xi_k) \), where \( h \): timestep (parameter) \( g_{k+1}, g_{k} \): poses at the current and the next timestep \( \xi_k \): the body-fixed velocity (Lie algebra) It is somewhat similar to BetweenFactor, but treats the body-fixed velocity \( \xi_k \) as a variable |
| ►Cgtsam::NoiseModelFactor3< Rot3, Rot3, Vector3 > | |
| Cgtsam::AHRSFactor | |
| ►Cgtsam::NoiseModelFactor3< Vector6, Vector6, Pose3 > | |
| Cgtsam::DiscreteEulerPoincareHelicopter | Implement the Discrete Euler-Poincare' equation: |
| ►Cgtsam::NoiseModelFactor4< POSE, POSE, LANDMARK, CALIBRATION > | |
| Cgtsam::ProjectionFactorPPPC< POSE, LANDMARK, CALIBRATION > | |
| ►Cgtsam::NoiseModelFactor4< POSE, VELOCITY, POSE, VELOCITY > | |
| Cgtsam::EquivInertialNavFactor_GlobalVel_NoBias< POSE, VELOCITY > | |
| ►Cgtsam::NoiseModelFactor4< Pose2, Pose2, Pose2, Point2 > | |
| Cgtsam::DeltaFactorBase | DeltaFactorBase: relative 2D measurement between Pose2 and Point2, with Basenodes |
| ►Cgtsam::NoiseModelFactor4< Pose2, Pose2, Pose2, Pose2 > | |
| Cgtsam::OdometryFactorBase | OdometryFactorBase: Pose2 odometry, with Basenodes |
| ►Cgtsam::NoiseModelFactor5< POSE, VELOCITY, IMUBIAS, POSE, VELOCITY > | |
| Cgtsam::EquivInertialNavFactor_GlobalVel< POSE, VELOCITY, IMUBIAS > | |
| Cgtsam::InertialNavFactor_GlobalVelocity< POSE, VELOCITY, IMUBIAS > | |
| ►Cgtsam::NoiseModelFactor5< Pose3, Vector3, Pose3, Vector3, imuBias::ConstantBias > | |
| Cgtsam::ImuFactor | |
| ►Cgtsam::NoiseModelFactor6< Pose3, Vector3, Pose3, Vector3, imuBias::ConstantBias, imuBias::ConstantBias > | |
| Cgtsam::CombinedImuFactor | |
| Cgtsam::PendulumFactor1 | This class implements the first constraint |
| Cgtsam::PendulumFactor2 | This class implements the second constraint the |
| Cgtsam::PendulumFactorPk | This class implements the first position-momentum update rule p_k = -D_1 L_d(q_k,q_{k+1},h) = \frac{1}{h}mr^{2}\left(q_{k+1}-q_{k}\right)+mgrh(1-\alpha)\,\sin\left((1-\alpha)q_{k}+\alpha q_{k+1}\right) = (1/h)mr^2 (q_{k+1}-q_k) + mgrh(1-alpha) sin ((1-alpha)q_k+\alpha q_{k+1}) |
| Cgtsam::PendulumFactorPk1 | This class implements the second position-momentum update rule p_k1 = D_2 L_d(q_k,q_{k+1},h) = \frac{1}{h}mr^{2}\left(q_{k+1}-q_{k}\right)-mgrh\alpha\sin\left((1-\alpha)q_{k}+\alpha q_{k+1}\right) = (1/h)mr^2 (q_{k+1}-q_k) - mgrh alpha sin ((1-alpha)q_k+\alpha q_{k+1}) |
| ►Cgtsam::SmartFactorBase< CAMERA > | Base class for smart factors This base class has no internal point, but it has a measurement, noise model and an optional sensor pose |
| Cgtsam::SmartProjectionFactor< CAMERA > | SmartProjectionFactor: triangulates point and keeps an estimate of it around |
| Cgtsam::TransformBtwRobotsUnaryFactor< VALUE > | |
| Cgtsam::TransformBtwRobotsUnaryFactor< VALUE > | |
| Cgtsam::TransformBtwRobotsUnaryFactorEM< VALUE > | |
| Cgtsam::TransformBtwRobotsUnaryFactorEM< VALUE > | |
| Cgtsam::VelocityConstraint3 | |
| Cgtsam::VelocityPrior | Constrains the full velocity of a state to a particular value Useful for enforcing a stationary state Dim: 3 |
| Cgtsam::WhiteNoiseFactor | Binary factor to estimate parameters of zero-mean Gaussian white noise |
| ►Cgtsam::SmartFactorBase< PinholePose< CALIBRATION > > | |
| ►Cgtsam::SmartProjectionFactor< PinholePose< CALIBRATION > > | |
| Cgtsam::SmartProjectionPoseFactor< CALIBRATION > | |
| ►Cgtsam::SmartFactorBase< StereoCamera > | |
| ►Cgtsam::SmartStereoProjectionFactor | SmartStereoProjectionFactor: triangulates point and keeps an estimate of it around |
| Cgtsam::SmartStereoProjectionPoseFactor | |
| ►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::FactorGraph< FACTOR > | A factor graph is a bipartite graph with factor nodes connected to variable nodes |
| ►Cgtsam::FactorGraph< CONDITIONAL > | |
| Cgtsam::BayesNet< CONDITIONAL > | A BayesNet is a tree of conditionals, stored in elimination order |
| ►Cgtsam::FactorGraph< DiscreteConditional > | |
| Cgtsam::DiscreteBayesNet | A Bayes net made from linear-Discrete densities |
| ►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::FactorGraph< GaussianConditional > | |
| Cgtsam::GaussianBayesNet | A Bayes net made from linear-Gaussian densities |
| ►Cgtsam::FactorGraph< GaussianFactor > | |
| Cgtsam::GaussianFactorGraph | A Linear Factor Graph is a factor graph where all factors are Gaussian, i.e |
| ►Cgtsam::FactorGraph< LinearEquality > | |
| Cgtsam::EqualityFactorGraph | Collection of all Linear Equality constraints Ax=b of a Programming problem as a Factor Graph |
| ►Cgtsam::FactorGraph< LinearInequality > | |
| Cgtsam::InequalityFactorGraph | Collection of all Linear Inequality constraints Ax-b <= 0 of a Programming problem as a Factor Graph |
| ►Cgtsam::FactorGraph< NonlinearFactor > | |
| ►Cgtsam::NonlinearFactorGraph | A non-linear factor graph is a graph of non-Gaussian, i.e |
| Cgtsam::ExpressionFactorGraph | Factor graph that supports adding ExpressionFactors directly |
| ►Cgtsam::FactorGraph< SymbolicConditional > | |
| Cgtsam::SymbolicBayesNet | Symbolic Bayes Net |
| ►Cgtsam::FactorGraph< SymbolicFactor > | |
| Cgtsam::SymbolicFactorGraph | Symbolic Factor Graph |
| 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::Values::Filtered< ValueType > | A filtered view of a Values, returned from Values::filter |
| Cgtsam::FixedDimension< T > | Give fixed size dimension of a type, fails at compile time if dynamic |
| ►Cgtsam::FixedLagSmoother | |
| Cgtsam::BatchFixedLagSmoother | |
| Cgtsam::BatchFixedLagSmoother | |
| Cgtsam::IncrementalFixedLagSmoother | This is a base class for the various HMF2 implementations |
| Cgtsam::IncrementalFixedLagSmoother | This is a base class for the various HMF2 implementations |
| Cgtsam::FixedLagSmootherKeyTimestampMap | |
| Cgtsam::FixedLagSmootherKeyTimestampMapValue | |
| Cgtsam::FixedLagSmootherResult | |
| Cgtsam::internal::FixedSizeMatrix< Y, X > | |
| Cgtsam::G_x1< X1, X2 > | Helper class that computes the derivative of f w.r.t |
| Cgtsam::GaussianFactorGraphSystem | System class needed for calling preconditionedConjugateGradient |
| Cgtsam::GraphvizFormatting | Formatting options when saving in GraphViz format using NonlinearFactorGraph::saveGraph |
| ►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::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< 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 > | |
| 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< 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::HasRange< PoseRTV, PoseRTV, double > | |
| Cgtsam::Range< PoseRTV, PoseRTV > | |
| ►Cgtsam::HasRange< SimpleCamera, T, double > | |
| Cgtsam::Range< SimpleCamera, 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 |
| ►CImpl | |
| Cgtsam::ISAM2 | |
| Cgtsam::InitializePose3 | |
| Cgtsam::ISAM2DoglegParams | |
| Cgtsam::ISAM2GaussNewtonParams | |
| Cgtsam::ISAM2Params | |
| Cgtsam::ISAM2Result | |
| Cgtsam::IsGroup< G > | Group Concept |
| ►Cgtsam::IsGroup< T > | |
| ►Cgtsam::IsLieGroup< T > | Lie Group Concept |
| Cgtsam::IsVectorSpace< T > | Vector Space concept |
| ►CIsManifold | |
| Cgtsam::IsLieGroup< T > | Lie Group Concept |
| Cgtsam::IsTestable< T > | |
| Cgtsam::DoglegOptimizerImpl::IterationResult | |
| ►Cgtsam::IterativeOptimizationParameters | Parameters for iterative linear solvers |
| ►Cgtsam::ConjugateGradientParameters | Parameters for the conjugate gradient method |
| Cgtsam::PCGSolverParameters | Parameters for PCG |
| 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::JointMarginal | A class to store and access a joint marginal, returned from Marginals::jointMarginalCovariance and Marginals::jointMarginalInformation |
| Cgtsam::KalmanFilter | Kalman Filter class |
| Cgtsam::KeyInfoEntry | Handy data structure for iterative solvers key to (index, dimension, start) |
| Cgtsam::Values::KeyValuePair | A key-value pair, which you get by dereferencing iterators |
| Cgtsam::LabeledSymbol | Customized version of gtsam::Symbol for multi-robot use |
| 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::LieGroup< Pose2, 3 > | |
| Cgtsam::Pose2 | |
| ►Cgtsam::LieGroup< Pose3, 6 > | |
| Cgtsam::Pose3 | |
| ►Cgtsam::LieGroup< Rot2, 1 > | |
| Cgtsam::Rot2 | |
| ►Cgtsam::LieGroup< Rot3, 3 > | |
| Cgtsam::Rot3 | |
| ►Cgtsam::LieGroup< SO3, 3 > | |
| Cgtsam::SO3 | True SO(3), i.e., 3*3 matrix subgroup We guarantee (all but first) constructors only generate from sub-manifold |
| ►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::LieGroupTraits< Pose2 > | |
| ►Cgtsam::internal::LieGroup< Pose2 > | |
| Cgtsam::traits< const Pose2 > | |
| Cgtsam::traits< Pose2 > | |
| ►Cgtsam::internal::LieGroupTraits< Pose3 > | |
| ►Cgtsam::internal::LieGroup< Pose3 > | |
| Cgtsam::traits< const Pose3 > | |
| Cgtsam::traits< Pose3 > | |
| ►Cgtsam::internal::LieGroupTraits< PoseRTV > | |
| ►Cgtsam::internal::LieGroup< PoseRTV > | |
| Cgtsam::traits< PoseRTV > | |
| ►Cgtsam::internal::LieGroupTraits< ProductLieGroup< G, H > > | |
| Cgtsam::traits< ProductLieGroup< G, H > > | |
| ►Cgtsam::internal::LieGroupTraits< Rot2 > | |
| ►Cgtsam::internal::LieGroup< Rot2 > | |
| Cgtsam::traits< const Rot2 > | |
| Cgtsam::traits< Rot2 > | |
| ►Cgtsam::internal::LieGroupTraits< Rot3 > | |
| ►Cgtsam::internal::LieGroup< Rot3 > | |
| Cgtsam::traits< const Rot3 > | |
| Cgtsam::traits< Rot3 > | |
| ►Cgtsam::internal::LieGroupTraits< SO3 > | |
| ►Cgtsam::internal::LieGroup< SO3 > | |
| Cgtsam::traits< const SO3 > | |
| Cgtsam::traits< SO3 > | |
| ►Cstd::list< T > | STL class |
| ►Cgtsam::FastList< Vector > | |
| Cgtsam::Errors | Vector of errors |
| Cgtsam::FastList< VALUE > | |
| Cgtsam::ListOfOneContainer< T > | A helper class that behaves as a container with one element, and works with boost::range |
| Cgtsam::LP | Data structure of a Linear Program |
| Cgtsam::LPInitSolver | This LPInitSolver implements the strategy in Matlab: http://www.mathworks.com/help/optim/ug/linear-programming-algorithms.html#brozyzb-9 Solve for x and y: min y st Ax = b Cx - y <= d where y \in R, x \in R^n, and Ax = b and Cx <= d is the constraints of the original problem |
| Cgtsam::LPPolicy | Policy for ActivetSetSolver to solve Linear Programming |
| 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::internal::ManifoldImpl< Class, N > | Extra manifold traits for fixed-dimension types |
| ►Cgtsam::internal::ManifoldImpl< BearingRange< A1, A2 >, BearingRange< A1, A2 > ::dimension > | |
| ►Cgtsam::internal::ManifoldTraits< BearingRange< A1, A2 > > | |
| Cgtsam::traits< BearingRange< A1, A2 > > | |
| ►Cgtsam::internal::ManifoldImpl< 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::ManifoldImpl< 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::ManifoldImpl< Cal3Bundler, Cal3Bundler ::dimension > | |
| ►Cgtsam::internal::ManifoldTraits< Cal3Bundler > | |
| ►Cgtsam::internal::Manifold< Cal3Bundler > | |
| Cgtsam::traits< Cal3Bundler > | |
| Cgtsam::traits< const Cal3Bundler > | |
| ►Cgtsam::internal::ManifoldImpl< Cal3DS2, Cal3DS2 ::dimension > | |
| ►Cgtsam::internal::ManifoldTraits< Cal3DS2 > | |
| ►Cgtsam::internal::Manifold< Cal3DS2 > | |
| Cgtsam::traits< Cal3DS2 > | |
| Cgtsam::traits< const Cal3DS2 > | |
| ►Cgtsam::internal::ManifoldImpl< Cal3Unified, Cal3Unified ::dimension > | |
| ►Cgtsam::internal::ManifoldTraits< Cal3Unified > | |
| ►Cgtsam::internal::Manifold< Cal3Unified > | |
| Cgtsam::traits< Cal3Unified > | |
| Cgtsam::traits< const Cal3Unified > | |
| ►Cgtsam::internal::ManifoldImpl< CalibratedCamera, CalibratedCamera ::dimension > | |
| ►Cgtsam::internal::ManifoldTraits< CalibratedCamera > | |
| ►Cgtsam::internal::Manifold< CalibratedCamera > | |
| Cgtsam::traits< CalibratedCamera > | |
| Cgtsam::traits< const CalibratedCamera > | |
| ►Cgtsam::internal::ManifoldImpl< Class, Class::dimension > | |
| ►Cgtsam::internal::ManifoldTraits< Class > | A helper that implements the traits interface for GTSAM manifolds |
| Cgtsam::internal::Manifold< Class > | Both ManifoldTraits and Testable |
| Cgtsam::internal::ManifoldImpl< Class, Eigen::Dynamic > | Extra manifold traits for variable-dimension types |
| ►Cgtsam::internal::ManifoldImpl< EssentialMatrix, EssentialMatrix ::dimension > | |
| ►Cgtsam::internal::ManifoldTraits< EssentialMatrix > | |
| ►Cgtsam::internal::Manifold< EssentialMatrix > | |
| Cgtsam::traits< const EssentialMatrix > | |
| Cgtsam::traits< EssentialMatrix > | |
| ►Cgtsam::internal::ManifoldImpl< NavState, NavState ::dimension > | |
| ►Cgtsam::internal::ManifoldTraits< NavState > | |
| ►Cgtsam::internal::Manifold< NavState > | |
| Cgtsam::traits< NavState > | |
| ►Cgtsam::internal::ManifoldImpl< OrientedPlane3, OrientedPlane3 ::dimension > | |
| ►Cgtsam::internal::ManifoldTraits< OrientedPlane3 > | |
| ►Cgtsam::internal::Manifold< OrientedPlane3 > | |
| Cgtsam::traits< const OrientedPlane3 > | |
| Cgtsam::traits< OrientedPlane3 > | |
| ►Cgtsam::internal::ManifoldImpl< PinholeCamera< Calibration >, PinholeCamera< Calibration > ::dimension > | |
| ►Cgtsam::internal::ManifoldTraits< PinholeCamera< Calibration > > | |
| ►Cgtsam::internal::Manifold< PinholeCamera< Calibration > > | |
| Cgtsam::traits< const PinholeCamera< Calibration > > | |
| Cgtsam::traits< PinholeCamera< Calibration > > | |
| ►Cgtsam::internal::ManifoldImpl< PinholePose< CALIBRATION >, PinholePose< CALIBRATION > ::dimension > | |
| ►Cgtsam::internal::ManifoldTraits< PinholePose< CALIBRATION > > | |
| ►Cgtsam::internal::Manifold< PinholePose< CALIBRATION > > | |
| Cgtsam::traits< const PinholePose< CALIBRATION > > | |
| Cgtsam::traits< PinholePose< CALIBRATION > > | |
| ►Cgtsam::internal::ManifoldImpl< SimpleCamera, SimpleCamera ::dimension > | |
| ►Cgtsam::internal::ManifoldTraits< SimpleCamera > | |
| ►Cgtsam::internal::Manifold< SimpleCamera > | |
| Cgtsam::traits< const SimpleCamera > | |
| Cgtsam::traits< SimpleCamera > | |
| ►Cgtsam::internal::ManifoldImpl< StereoCamera, StereoCamera ::dimension > | |
| ►Cgtsam::internal::ManifoldTraits< StereoCamera > | |
| ►Cgtsam::internal::Manifold< StereoCamera > | |
| Cgtsam::traits< const StereoCamera > | |
| Cgtsam::traits< StereoCamera > | |
| ►Cgtsam::internal::ManifoldImpl< Unit3, Unit3 ::dimension > | |
| ►Cgtsam::internal::ManifoldTraits< Unit3 > | |
| ►Cgtsam::internal::Manifold< Unit3 > | |
| Cgtsam::traits< const Unit3 > | |
| Cgtsam::traits< Unit3 > | |
| ►Cstd::map< K, T > | STL class |
| Cgtsam::FastMap< Key, Factors > | |
| ►Cgtsam::FastMap< Key, FastVector< size_t > > | |
| Cgtsam::VariableSlots | A combined factor is assembled as one block of rows for each component factor |
| Cgtsam::FastMap< Key, gtsam::ISAM2Result::DetailedResults::VariableStatus > | |
| Cgtsam::FastMap< Key, size_t > | |
| Cgtsam::FastMap< Key, VectorValues::const_iterator > | |
| Cgtsam::FastMap< size_t, boost::shared_ptr< TimingOutline > > | |
| Cgtsam::Assignment< L > | An assignment from labels to value index (size_t) |
| Cgtsam::FastMap< KEY, VALUE > | |
| Cgtsam::KeyInfo | Handy data structure for iterative solvers |
| Cgtsam::PredecessorMap< KEY > | Map from variable key to parent key |
| Cgtsam::Marginals | A class for computing Gaussian marginals of variables in a NonlinearFactorGraph |
| ►CMatrix | |
| Cgtsam::FixedVector< N > | Fixed size vectors - compatible with boost vectors, but with compile-type size checking |
| ►CMatrix3 | |
| Cgtsam::SO3 | True SO(3), i.e., 3*3 matrix subgroup We guarantee (all but first) constructors only generate from sub-manifold |
| Cgtsam::Mechanization_bRn2 | |
| Cgtsam::MetisIndex | Converts a factor graph into the Compressed Sparse Row format for use in METIS algorithms |
| Cgtsam::multiplicative_group_tag | Group operator syntax flavors |
| ►CMultiplicativeGroupTraits | |
| 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::NavState | Navigation state: Pose (rotation, translation) + velocity NOTE(frank): it does not make sense to make this a Lie group, but it is a 9D manifold |
| Cgtsam::EliminationTree< BAYESNET, GRAPH >::Node | |
| ►Cgtsam::DecisionTree< L, Y >::Node | ---------------------— Node base class ------------------------— |
| Cgtsam::DecisionTree< L, Y >::Choice< L, Y > | |
| Cgtsam::DecisionTree< L, Y >::Leaf< L, Y > | |
| 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::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::internal::linearAlgorithms::OptimizeClique< CLIQUE > | Pre-order visitor for back-substitution in a Bayes tree |
| Cgtsam::internal::linearAlgorithms::OptimizeData | |
| ►Coptional | |
| 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< dim, dim > | |
| 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 |
| ►Cpair | |
| Cgtsam::DirectProduct | |
| 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 > | Template to construct the product Lie group of two other Lie groups Assumes Lie group structure for G and H |
| ►Cgtsam::ProductLieGroup< Pose3, Velocity3 > | |
| Cgtsam::PoseRTV | Robot state for use with IMU measurements |
| Cgtsam::ISAM2::PartialSolveResult | |
| ►Cgtsam::PinholeBase | |
| Cgtsam::CalibratedCamera | |
| ►Cgtsam::PinholeBaseK< CALIBRATION > | |
| Cgtsam::PinholePose< CALIBRATION > | |
| ►Cgtsam::PinholeBaseK< Calibration > | |
| ►Cgtsam::PinholeCamera< Calibration > | |
| Cgtsam::SimpleCamera | |
| Cgtsam::Pose3Upright | |
| 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::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::PreintegratedCombinedMeasurements::Params | Parameters for pre-integration: 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::ManifoldPreintegration | IMU pre-integration on NavSatet manifold |
| Cgtsam::PreintegratedCombinedMeasurements | |
| Cgtsam::PreintegratedImuMeasurements | |
| Cgtsam::TangentPreintegration | Integrate on the 9D tangent space of the NavState manifold |
| Cgtsam::QP | Struct contains factor graphs of a Quadratic Programming problem |
| Cgtsam::QPInitSolver | This class finds a feasible solution for a QP problem |
| Cgtsam::QPPolicy | Policy for ActivetSetSolver to solve Linear Programming |
| Cgtsam::QPSParser | |
| Cgtsam::Range< A1, A2 > | |
| Cgtsam::Range< Point3, Point3 > | |
| Cgtsam::RedirectCout | For Python str() |
| Cgtsam::RefCallPushBack< C > | Helper |
| Cgtsam::ISAM2::ReorderingMode | |
| Cgtsam::Reshape< OutM, OutN, OutOptions, InM, InN, InOptions > | Reshape functor |
| Cgtsam::Reshape< M, M, InOptions, M, M, InOptions > | Reshape specialization that does nothing as shape stays the same (needed to not be ambiguous for square input equals square output) |
| Cgtsam::Reshape< M, N, InOptions, M, N, InOptions > | Reshape specialization that does nothing as shape stays the same |
| Cgtsam::Reshape< N, M, InOptions, M, N, InOptions > | Reshape specialization that does transpose |
| Cgtsam::ConcurrentBatchFilter::Result | Meta information returned about the update |
| Cgtsam::ConcurrentBatchSmoother::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::ConcurrentIncrementalFilter::Result | Meta information returned about the update |
| Cgtsam::AlgebraicDecisionTree< L >::Ring | The Real ring with addition and multiplication |
| 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::ScenarioRunner | |
| ►Cstd::set< K > | STL class |
| Cgtsam::FastSet< Key > | |
| Cgtsam::FastSet< VALUE > | |
| Cgtsam::SfM_data | Define the structure for SfM data |
| Cgtsam::SfM_Track | Define the structure for the 3D points |
| Cgtsam::Signature | Signature for a discrete conditional density, used to construct conditionals |
| Cgtsam::SimPolygon2D | |
| Cgtsam::SimPolygon2DVector | |
| Cgtsam::SimWall2D | |
| Cgtsam::SimWall2DVector | |
| Cgtsam::SlotEntry | One SlotEntry stores the slot index for a variable, as well its dim |
| Cgtsam::SmartProjectionParams | |
| Cgtsam::ActiveSetSolver< PROBLEM, POLICY, INITSOLVER >::State | This struct contains the state information for a single iteration |
| Cgtsam::StereoCamera | |
| Cgtsam::StereoPoint2 | |
| Cgtsam::Subgraph | |
| Cgtsam::SubgraphBuilder | |
| Cgtsam::SubgraphBuilderParameters | |
| Cgtsam::Symbol | Character and index key used to refer to variables |
| Cgtsam::SymmetricBlockMatrix | |
| Cgtsam::System | Helper class encapsulating the combined system |Ax-b_|^2 Needed to run Conjugate Gradients on matrices |
| 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< 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< BinaryJacobianFactor< M, N1, N2 > > | |
| Cgtsam::traits< BinaryJacobianFactor< M, N1, N2 > > | |
| ►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< 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< Class > | |
| Cgtsam::internal::LieGroup< Class > | Both LieGroupTraits and Testable |
| Cgtsam::internal::Manifold< Class > | Both ManifoldTraits and Testable |
| Cgtsam::internal::VectorSpace< Class > | VectorSpace provides both Testable and VectorSpaceTraits |
| ►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< DecisionTreeFactor > | |
| Cgtsam::traits< DecisionTreeFactor > | |
| ►Cgtsam::Testable< DiscreteBayesNet > | |
| Cgtsam::traits< DiscreteBayesNet > | |
| ►Cgtsam::Testable< DiscreteConditional > | |
| Cgtsam::traits< DiscreteConditional > | |
| ►Cgtsam::Testable< DiscreteFactor > | |
| Cgtsam::traits< DiscreteFactor > | |
| ►Cgtsam::Testable< DiscreteFactor::Values > | |
| Cgtsam::traits< DiscreteFactor::Values > | |
| ►Cgtsam::Testable< DiscreteFactorGraph > | |
| Cgtsam::traits< DiscreteFactorGraph > | Traits |
| ►Cgtsam::Testable< EqualityFactorGraph > | |
| Cgtsam::traits< EqualityFactorGraph > | Traits |
| ►Cgtsam::Testable< Errors > | |
| Cgtsam::traits< Errors > | Traits |
| ►Cgtsam::Testable< EssentialMatrix > | |
| Cgtsam::internal::Manifold< EssentialMatrix > | |
| ►Cgtsam::Testable< ExpressionFactor< T > > | |
| Cgtsam::traits< ExpressionFactor< T > > | Traits |
| ►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< 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< HessianFactor > | |
| Cgtsam::traits< HessianFactor > | Traits |
| ►Cgtsam::Testable< imuBias::ConstantBias > | |
| ►Cgtsam::internal::VectorSpace< imuBias::ConstantBias > | |
| Cgtsam::traits< imuBias::ConstantBias > | |
| ►Cgtsam::Testable< ImuFactor > | |
| Cgtsam::traits< ImuFactor > | |
| ►Cgtsam::Testable< ImuFactor2 > | |
| Cgtsam::traits< ImuFactor2 > | |
| ►Cgtsam::Testable< InequalityFactorGraph > | |
| Cgtsam::traits< InequalityFactorGraph > | Traits |
| ►Cgtsam::Testable< InertialNavFactor_GlobalVelocity< POSE, VELOCITY, IMUBIAS > > | |
| Cgtsam::traits< InertialNavFactor_GlobalVelocity< POSE, VELOCITY, IMUBIAS > > | Traits |
| ►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< LinearContainerFactor > | |
| Cgtsam::traits< LinearContainerFactor > | |
| ►Cgtsam::Testable< LinearCost > | |
| Cgtsam::traits< LinearCost > | Traits |
| ►Cgtsam::Testable< LinearEquality > | |
| Cgtsam::traits< LinearEquality > | Traits |
| ►Cgtsam::Testable< LinearInequality > | |
| Cgtsam::traits< LinearInequality > | Traits |
| ►Cgtsam::Testable< LinearizedHessianFactor > | |
| Cgtsam::traits< LinearizedHessianFactor > | Traits |
| ►Cgtsam::Testable< LinearizedJacobianFactor > | |
| Cgtsam::traits< LinearizedJacobianFactor > | Traits |
| ►Cgtsam::Testable< LP > | |
| Cgtsam::traits< LP > | Traits |
| ►Cgtsam::Testable< NavState > | |
| Cgtsam::internal::Manifold< NavState > | |
| ►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< NonlinearEquality1< VALUE > > | |
| Cgtsam::traits< NonlinearEquality1< VALUE > > | |
| ►Cgtsam::Testable< NonlinearEquality2< VALUE > > | |
| Cgtsam::traits< NonlinearEquality2< VALUE > > | |
| ►Cgtsam::Testable< NonlinearEquality< VALUE > > | |
| Cgtsam::traits< NonlinearEquality< VALUE > > | |
| ►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< const PinholeSet< CAMERA > > | |
| Cgtsam::traits< PinholeSet< CAMERA > > | |
| ►Cgtsam::Testable< Point2 > | |
| ►Cgtsam::internal::VectorSpace< Point2 > | |
| Cgtsam::traits< Point2 > | |
| ►Cgtsam::Testable< Point3 > | |
| ►Cgtsam::internal::VectorSpace< Point3 > | |
| Cgtsam::traits< const Point3 > | |
| Cgtsam::traits< Point3 > | |
| ►Cgtsam::Testable< Pose2 > | |
| Cgtsam::internal::LieGroup< Pose2 > | |
| ►Cgtsam::Testable< Pose3 > | |
| Cgtsam::internal::LieGroup< Pose3 > | |
| ►Cgtsam::Testable< Pose3AttitudeFactor > | |
| Cgtsam::traits< Pose3AttitudeFactor > | Traits |
| ►Cgtsam::Testable< PoseRTV > | |
| Cgtsam::internal::LieGroup< PoseRTV > | |
| ►Cgtsam::Testable< Potentials > | |
| Cgtsam::traits< Potentials > | |
| ►Cgtsam::Testable< Potentials::ADT > | |
| Cgtsam::traits< Potentials::ADT > | |
| ►Cgtsam::Testable< PreintegratedImuMeasurements > | |
| Cgtsam::traits< PreintegratedImuMeasurements > | |
| ►Cgtsam::Testable< PreintegratedRotation > | |
| Cgtsam::traits< PreintegratedRotation > | |
| ►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< 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< 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::LieGroup< Rot2 > | |
| ►Cgtsam::Testable< Rot3 > | |
| Cgtsam::internal::LieGroup< Rot3 > | |
| ►Cgtsam::Testable< Rot3AttitudeFactor > | |
| Cgtsam::traits< Rot3AttitudeFactor > | Traits |
| ►Cgtsam::Testable< SimpleCamera > | |
| Cgtsam::internal::Manifold< SimpleCamera > | |
| ►Cgtsam::Testable< SmartProjectionFactor< CAMERA > > | |
| Cgtsam::traits< SmartProjectionFactor< CAMERA > > | Traits |
| ►Cgtsam::Testable< SmartProjectionPoseFactor< CALIBRATION > > | |
| Cgtsam::traits< SmartProjectionPoseFactor< CALIBRATION > > | Traits |
| ►Cgtsam::Testable< SmartStereoProjectionFactor > | |
| Cgtsam::traits< SmartStereoProjectionFactor > | Traits |
| ►Cgtsam::Testable< SmartStereoProjectionPoseFactor > | |
| Cgtsam::traits< SmartStereoProjectionPoseFactor > | Traits |
| ►Cgtsam::Testable< SO3 > | |
| Cgtsam::internal::LieGroup< SO3 > | |
| ►Cgtsam::Testable< StereoCamera > | |
| Cgtsam::internal::Manifold< StereoCamera > | |
| ►Cgtsam::Testable< StereoPoint2 > | |
| ►Cgtsam::internal::VectorSpace< StereoPoint2 > | |
| Cgtsam::traits< const StereoPoint2 > | |
| Cgtsam::traits< 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< TransformBtwRobotsUnaryFactor< VALUE > > | |
| Cgtsam::traits< TransformBtwRobotsUnaryFactor< VALUE > > | Traits |
| ►Cgtsam::Testable< TransformBtwRobotsUnaryFactorEM< VALUE > > | |
| Cgtsam::traits< TransformBtwRobotsUnaryFactorEM< VALUE > > | 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< VectorValues > | |
| Cgtsam::traits< VectorValues > | Traits |
| 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< G > | |
| Cgtsam::traits< Key > | |
| Cgtsam::traits< QUATERNION_TYPE > | |
| Cgtsam::TriangulationParameters | |
| Cgtsam::Expression< T >::UnaryFunction< A1 > | |
| Cgtsam::Unit3 | Represents a 3D point on a unit sphere |
| ►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 |
| 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::ValueWithDefault< bool, false > | |
| 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 |
| ►Cstd::vector< T > | STL class |
| ►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::Ordering | |
| Cgtsam::Scatter | Scatter is an intermediate data structure used when building a HessianFactor incrementally, to get the keys in the right order |
| ►CVector2 | |
| Cgtsam::Point2 | |
| ►CVector3 | |
| Cgtsam::Point3 | |
| Cgtsam::internal::VectorSpaceImpl< Class, N > | VectorSpaceTraits Implementation for Fixed sizes |
| ►Cgtsam::internal::VectorSpaceImpl< Class, Class::dimension > | |
| ►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< Point2, Point2 ::dimension > | |
| ►Cgtsam::internal::VectorSpaceTraits< Point2 > | |
| Cgtsam::internal::VectorSpace< Point2 > | |
| ►Cgtsam::internal::VectorSpaceImpl< Point3, Point3 ::dimension > | |
| ►Cgtsam::internal::VectorSpaceTraits< Point3 > | |
| Cgtsam::internal::VectorSpace< Point3 > | |
| ►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 | This class represents a collection of vector-valued variables associated each with a unique integer index |
| Cgtsam::VerticalBlockMatrix | |
| ►CBAYESTREE | |
| Cgtsam::ISAM< BAYESTREE > | A Bayes tree with an update methods that implements the iSAM algorithm |
1.8.15