| Ngtsam | Global functions in a separate testing namespace |
| Ninternal | |
| NlinearAlgorithms | |
| COptimizeData | |
| COptimizeClique | Pre-order visitor for back-substitution in a Bayes tree |
| CFastDefaultAllocator | Default allocator for list, map, and set types |
| CFastDefaultVectorAllocator | Default allocator for vector types (we never use boost pool for vectors) |
| CMultiplicativeGroupTraits | A helper class that implements the traits interface for multiplicative groups |
| CMultiplicativeGroup | Both multiplicative group traits and Testable |
| CAdditiveGroupTraits | A helper class that implements the traits interface for additive groups |
| CAdditiveGroup | Both additive group traits and Testable |
| CChartAtIdentity | Chart-at-origin adapter for LieGroup-derived classes with explicit instance retract/localCoordinates implementations |
| CLieGroupTraits | A helper class that implements the traits interface for GTSAM lie groups |
| CLieGroup | Both LieGroupTraits and Testable |
| CHasManifoldPrereqs | Requirements on type to pass it to Manifold template below |
| CGetDimensionImpl | Traits to get dimension, supporting both fixed and dynamic |
| CManifoldTraits | A helper that implements the traits interface for GTSAM manifolds |
| CHasLocalJacobians | Detect whether a traits type provides Local with Jacobians |
| CHasLocalJacobians< 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 >()))> > | |
| CManifold | Both ManifoldTraits and Testable |
| CMatrixLieGroupTraits | Adds MatrixLieGroup methods to LieGroupTraits |
| CMatrixLieGroup | Both LieGroupTraits and Testable |
| CFixedSizeMatrix | Select the fixed-size Jacobian type associated with two manifold types |
| CMatrixMN | Select a fixed-size matrix from explicit row and column counts |
| CDeducedOutput | Marker type used when the callable return type should be deduced |
| CProductLieGroupIsVector | Detects vector-space Lie groups (Eigen column vectors, group law = addition) |
| CProductLieGroupIsVector< Eigen::Matrix< double, N, 1 > > | |
| CSemidirectLieGroupIsVector | Recognizes the vector-space second factor required by SemidirectLieGroup |
| CSemidirectLieGroupIsVector< Eigen::Matrix< double, N, 1 > > | |
| CSemidirectLieGroupHasAdjointMap | Detects the optional static algebra adjoint on the base group |
| CSemidirectLieGroupHasAdjointMap< T, std::void_t< decltype(T::adjointMap(std::declval< const typename traits< T >::TangentVector & >()))> > | |
| CIsCompatibleSemidirectAction | Validates the action contract used by SemidirectLieGroup's group law and matrix-function kernels |
| CIsCompatibleSemidirectAction< Action, G, H, std::void_t< decltype(Action::type), decltype(Action::generator(std::declval< const typename traits< G >::TangentVector & >()))> > | |
| CBlockColumnRange | Half-open range of physical upper-triangular block columns |
| CTangentLieGroupHasAdjointMap | Enforces the static algebra-adjoint requirement of TangentLieGroup and AdjointAction below |
| CTangentLieGroupHasAdjointMap< T, std::void_t< decltype(T::adjointMap(std::declval< const typename traits< T >::TangentVector & >()))> > | |
| CTangentLieGroupJacobian | Optional closed-form kernels used by TangentLieGroup::Expmap() and its private rightJacobian() helper |
| CTimingOutline | Timing Entry, arranged in a tree |
| CAutoTicToc | Small class that calls internal::tic at construction, and internol::toc when destroyed |
| CVectorSpaceImpl | VectorSpaceTraits Implementation for Fixed sizes |
| CVectorSpaceImpl< Class, Eigen::Dynamic > | VectorSpaceTraits implementation for dynamic types |
| CHasVectorSpacePrereqs | Requirements on type to pass it to Manifold template below |
| CVectorSpaceTraits | A helper that implements the traits interface for classes that define vector spaces To use this for your class, define: template<> struct traits<Class> : public VectorSpaceTraits<Class> {}; The class needs to support the requirements defined by HasVectorSpacePrereqs above |
| CVectorSpace | VectorSpace provides both Testable and VectorSpaceTraits |
| CScalarTraits | A helper that implements the traits interface for scalar vector spaces |
| CDynamicTraits | |
| CTangentLieGroupJacobian< Rot3 > | Closed-form right Jacobian for TSO(3) = SO(3) semidirect-product so(3) |
| CSparseNormalAccumulator | Receives sparse normal-equation blocks from compact batch factors |
| CDimensionAt | Return the element at I in a compile-time integer pack, or Default |
| CDimensionAt< I, Default, First, Rest... > | |
| CDimensionAt< 0, Default, First, Rest... > | |
| CFixedSizeDimensions | Compile-time residual and variable dimensions for a factor of any arity |
| CFixedJacobianFactorFactory | Construct the fixed-size Jacobian factor for a dimension pack |
| CIncrementalRotation | Function object for incremental rotation |
| CGravityParametrization | Adapter mapping a gravity parametrization GRAVITY to the nav-frame gravity vector expected by PreintegrationBase, with the chain-rule Jacobian block |
| CGravityParametrization< Unit3 > | |
| CGravityParametrization< Point3 > | |
| Capply_compose | |
| Capply_compose< double > | |
| CExecutionTrace | |
| CExpressionNode | |
| Chandle | |
| Chandle_matrix | |
| Chandle_matrix< Eigen::Matrix< double, M, N >, true > | |
| Chandle_matrix< Eigen::Matrix< double, M, N >, false > | |
| Chandle< Eigen::Matrix< double, M, N > > | |
| CIndexedSymbolicFactor | A SymbolicFactor that stores the index of the originating factor |
| Ngroup_action | |
| COrbit | Orbit: The map g -> m, defined by fixing m0 |
| CDiffeomorphism | Diffeomorphism: The map m -> m, defined by fixing g0 |
| CInducedVectorField | Induced action on vector fields via push-forward |
| Ndetail | |
| CPrioritySchedulerPolicy | Queue policy for PriorityScheduler: min-heap priority_queue by task priority |
| CCompare | |
| CTaskSchedulerPolicy | Queue policy for TaskScheduler: deque with local LIFO and stolen FIFO |
| C_merge_and_renumber | |
| C_merge_and_renumber< index_sequence< I1... >, index_sequence< I2... > > | |
| Cis_extended_pose3 | |
| Cis_extended_pose3< gtsam::ExtendedPose3< K, Derived > > | |
| CNoiseModelFactorAliases | Convenience base class to add aliases X1, X2, ..., X6 -> ValueType<N> |
| CNoiseModelFactorAliases< T1 > | |
| CNoiseModelFactorAliases< T1, T2 > | |
| CNoiseModelFactorAliases< T1, T2, T3 > | |
| CNoiseModelFactorAliases< T1, T2, T3, T4 > | |
| CNoiseModelFactorAliases< T1, T2, T3, T4, T5 > | |
| CNoiseModelFactorAliases< T1, T2, T3, T4, T5, T6, TExtra... > | |
| Nso3 | |
| CKernel | Kernel: M(ω) = a I + b Ω + c Ω² with radial derivatives db,dc for Fréchet |
| CInvJKernel | |
| CExpmapFunctor | Opaque evaluation context at ω: caches Ω, Ω², θ, θ², nearZero/nearPi, Lazily computes C, D, E, dA, dB, dC, dE on demand |
| CDexpFunctor | Functor that implements Exponential map and its derivatives Math extends Ethan theme of elegant I + aW + bWW expressions |
| NnoiseModel | All noise models live in the noiseModel namespace |
| NmEstimator | The mEstimator name space contains all robust error functions |
| CBase | Pure virtual class for all robust error function classes |
| CNull | "Null" robust loss function, equivalent to a Gaussian pdf noise model, or plain least-squares (non-robust) |
| CFair | Implementation of the "Fair" robust error model (Zhang97ivc) |
| CHuber | The "Huber" robust error model (Zhang97ivc) |
| CCauchy | Implementation of the "Cauchy" robust error model (Lee2013IROS) |
| CTukey | Implementation of the "Tukey" robust error model (Zhang97ivc) |
| CWelsch | Implementation of the "Welsch" robust error model (Zhang97ivc) |
| CGemanMcClure | Implementation of the "Geman-McClure" robust error model (Zhang97ivc) |
| CTruncatedLeastSquares | Truncated Least Squares (TLS) robust error model |
| CDCS | DCS implements the Dynamic Covariance Scaling robust error model from the paper Robust Map Optimization (Agarwal13icra) |
| CL2WithDeadZone | L2WithDeadZone implements a standard L2 penalty, but with a dead zone of width 2*k, centered at the origin |
| CAsymmetricTukey | Implementation of the "AsymmetricTukey" robust error model |
| CAsymmetricCauchy | Implementation of the "AsymmetricCauchy" robust error model |
| CCustom | Implementation of the "Custom" robust error model |
| CBase | NoiseModel::Base is the abstract base class for all noise models |
| CGaussian | Gaussian implements the mathematical model |R*x|^2 = |y|^2 with R'*R=inv(Sigma) where y = whiten(x) = R*x x = unwhiten(x) = inv(R)*y as indeed |y|^2 = y'*y = x'*R'*R*x Various derived classes are available that are more efficient |
| CDiagonal | A diagonal noise model implements a diagonal covariance matrix, with the elements of the diagonal specified in a Vector |
| CConstrained | A Constrained constrained model is a specialization of Diagonal which allows some or all of the sigmas to be zero, forcing the error to be zero there |
| CIsotropic | An isotropic noise model corresponds to a scaled diagonal covariance To construct, use one of the static methods |
| CUnit | Unit: i.i.d |
| CRobust | Base class for robust error models The robust M-estimators above simply tell us how to re-weight the residual, and are isotropic kernels, in that they do not allow for correlated noise |
| Ngnss | |
| CDoubleDifferenceData | Shared geometry data for double-difference factors |
| CLeverArm | Lever-arm helper for GNSS factors that key on a body Pose3 |
| CPoseFrame | Intermediate quantities cached by antennaPosition() so antennaPoseJacobian can compute the pose Jacobian without recomputing the rotation/compose |
| NimuBias | All bias models live in the imuBias namespace |
| CConstantBias | |
| Ngtsfm | |
| CKeypoints | |
| Nabc | |
| CState | Minimal state manifold for the biased attitude system: ξ = (R, b, S) |
| CSymmetry | Right action φ_ξ(X) = (R A, Aᵀ(b − a), Aᵀ C B) on the state manifold |
| COrbit | |
| CLift | Implements the lift Λ(ξ,u) from the paper: Λ encodes the lifted dynamics on G induced by the biased gyroscope input u = (ω,0) |
| CInputAction | Encodes the partially applied input action ψ_u(X) = Aᵀ(ω − a), used to compute A(X,u) and Φ(X,u) |
| COutputAction | Functor encoding the right action ρ_y(X) on direction measurements y, parameterized by the sensor index |
| CInnovation | |
| CAbcEquivariantFilter | Equivariant Filter for Attitude-Bias-Calibration (ABC) estimation |
| Npartition | |
| CMetisResult | Metis Nest dissection result |
| CGenericNode2D | Index of the node and the type of the node |
| CGenericFactor2D | Factor always involves two nodes/variables for now |
| CGenericNode3D | Index of the node and the type of the node |
| CGenericFactor3D | Factor always involves two nodes/variables for now |
| CGenericUnaryFactor | Factor involves a single variable |
| CNestedDissection | Apply nested dissection algorithm to nonlinear factor graphs |
| CWorkSpace | |
| CCuts | |
| CConcurrentMap | FastMap is a thin wrapper around std::map that uses the boost fast_pool_allocator instead of the default STL allocator |
| CDSFMap | Disjoint set forest using an STL map data structure underneath Uses rank compression and union by rank, iterator version |
| CEntry | We store the forest in an STL map, but parents are done with pointers |
| CIndexPair | Small utility class for representing a wrappable pairs of ints |
| CDSFBase | A fast implementation of disjoint set forests that uses vector as underly data structure |
| CDSFVector | DSFVector additionally keeps a vector of keys to support more expensive operations |
| CFastList | FastList is a thin wrapper around std::list that uses the boost fast_pool_allocator instead of the default STL allocator |
| CFastMap | FastMap is a thin wrapper around std::map that uses the boost fast_pool_allocator instead of the default STL allocator |
| CFastSet | FastSet is a thin wrapper around std::set that uses the boost fast_pool_allocator instead of the default STL allocator |
| CForestTraversal | Mixin that provides depth-based top-down or bottom-up traversal |
| CGenericValue | Wraps any type T so it can play as a Value |
| Ctraits< GenericValue< ValueType > > | |
| Cgroup_tag | Tag to assert a type is a group |
| Cmultiplicative_group_tag | Group operator syntax flavors |
| Cadditive_group_tag | |
| Ctraits | A manifold defines a space in which there is a notion of a linear tangent space that can be centered around a given point on the manifold |
| CIsGroup | Group Concept |
| CDirectProduct | Template to construct the direct product of two arbitrary groups Assumes nothing except group structure and Testable from G and H |
| Ctraits< DirectProduct< G, H > > | |
| CDirectSum | Template to construct the direct sum of two additive groups Assumes existence of three additive operators for both groups |
| Ctraits< DirectSum< G, H > > | |
| CGroupAction | GroupAction CRTP base class |
| CInducedVectorField | |
| CLieGroup | A CRTP helper class that implements Lie group methods Prerequisites: methods operator*, inverse, and AdjointMap, as well as a ChartAtOrigin struct that will be used to define the manifold Chart To use, simply derive, but also say "using LieGroup<Class,N>::inverse" For derivative math, see doc/math.pdf |
| Clie_group_tag | Tag to assert a type is a Lie group |
| CIsLieGroup | Lie Group Concept |
| CTransformCovariance | Functor for transforming covariance of T |
| Cmanifold_tag | Tag to assert a type is a manifold |
| CIsManifold | Manifold concept |
| CFixedDimension | Give fixed size dimension of a type, fails at compile time if dynamic |
| CMultiplyWithInverse | Functor that implements multiplication of a vector b with the inverse of a matrix A |
| CMultiplyWithInverseFunction | Functor that implements multiplication with the inverse of a matrix, itself the result of a function f |
| CMatrixLieGroup | A CRTP helper class that implements matrix Lie group methods |
| CIsMatrixLieGroup | Matrix Lie Group Concept |
| COptionalJacobian | OptionalJacobian is an Eigen::Ref like class that can take be constructed using either a fixed size or dynamic Eigen matrix |
| COptionalJacobian< Eigen::Dynamic, Eigen::Dynamic > | |
| CMakeJacobian | : meta-function to generate Jacobian |
| CMakeOptionalJacobian | : meta-function to generate JacobianTA optional reference Used mainly by Expressions |
| CProductLieGroup | Direct product Lie group G × H |
| CChartAtOrigin | Component-wise chart at the product identity |
| CPowerLieGroupJacobianStorage | Shared implementation for fixed-size and dynamic-count PowerLieGroup |
| CPowerLieGroupJacobianStorage< T, Eigen::Dynamic > | |
| CPowerLieGroupBase | |
| CChartAtOrigin | Component-wise chart at the identity |
| CPowerLieGroup | 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 |
| CPowerLieGroup< G, Eigen::Dynamic > | Dynamic-count specialization of PowerLieGroup Represents G^N for runtime-sized N while keeping G fixed-size |
| Ctraits< ProductLieGroup< G, H > > | Traits specialization for ProductLieGroup |
| Ctraits< PowerLieGroup< G, N > > | Traits specialization for PowerLieGroup |
| CScheduler | Thread pool scheduler parameterized by a queue Policy |
| CSemidirectLieGroup | Left semidirect product G ⋉ H induced by Action |
| Ctraits< SemidirectLieGroup< G, H, Action > > | |
| CSymmetricBlockMatrix | This class stores a dense matrix and allows it to be accessed as a collection of blocks |
| CAdjointAction | The adjoint action phi(g,v) = Ad_g v, also useful independently |
| CTangentLieGroup | Tangent Lie group TG = G ⋉ 𝔤, with dimension 2 dim(G) |
| Ctraits< TangentLieGroup< G > > | |
| CIsTestable | A testable concept check that should be placed in applicable unit tests and in generic algorithms |
| Cequals | Template to create a binary predicate |
| Cequals_star | Binary predicate on shared pointers |
| CHasTestablePrereqs | Requirements on type to pass it to Testable template below |
| CTestable | A helper that implements the traits interface for GTSAM types |
| CThreadsafeException | Base exception type that uses tbb_allocator if GTSAM is compiled with TBB |
| CRuntimeErrorThreadsafe | Thread-safe runtime error exception |
| COutOfRangeThreadsafe | Thread-safe out of range exception |
| CInvalidArgumentThreadsafe | Thread-safe invalid argument exception |
| CCholeskyFailed | Indicate Cholesky factorization failure |
| CValueWithDefault | Helper struct that encapsulates a value with a default, this is just used as a member object so you don't have to specify defaults in the class constructor |
| CTbbOpenMPMixedScope | An object whose scope defines a block where TBB and OpenMP parallelism are mixed |
| CRedirectCout | For Python str() |
| Cindex_sequence | |
| Cmake_index_sequence | |
| Cmake_index_sequence< 0 > | |
| Cmake_index_sequence< 1 > | |
| CValue | This is the base class for any type to be stored in Values |
| Cvector_space_tag | Tag to assert a type is a vector space |
| Ctraits< double > | Double |
| Ctraits< float > | Float |
| Ctraits< Eigen::Matrix< double, M, N, Options, MaxRows, MaxCols > > | |
| Ctraits< Eigen::Matrix< double, -1, -1, Options, MaxRows, MaxCols > > | |
| Ctraits< Eigen::Matrix< double, -1, 1, Options, MaxRows, MaxCols > > | |
| Ctraits< Eigen::Matrix< double, 1, -1, Options, MaxRows, MaxCols > > | |
| CIsVectorSpace | Vector Space concept |
| CVerticalBlockMatrix | This class stores a dense matrix and allows it to be accessed as a collection of vertical blocks |
| CWeightedSampler | |
| CBasis | CRTP Base class for function bases |
| CEvaluationFunctor | An instance of an EvaluationFunctor calculates f(x;p) at a given x, applied to Parameters p |
| CVectorEvaluationFunctor | VectorEvaluationFunctor at a given x, applied to a parameter Matrix |
| CVectorComponentFunctor | Given a M*N Matrix of M-vectors at N polynomial points, an instance of VectorComponentFunctor computes the N-vector value for a specific row component of the M-vectors at all the polynomial points |
| CManifoldEvaluationFunctor | Manifold EvaluationFunctor at a given x, applied to a parameter Matrix |
| CDerivativeFunctorBase | Base class for functors below that calculate derivative weights |
| CDerivativeFunctor | An instance of a DerivativeFunctor calculates f'(x;p) at a given x, applied to Parameters p |
| CVectorDerivativeFunctor | VectorDerivativeFunctor at a given x, applied to a parameter Matrix |
| CComponentDerivativeFunctor | Given a M*N Matrix of M-vectors at N polynomial points, an instance of ComponentDerivativeFunctor computes the N-vector derivative for a specific row component of the M-vectors at all the polynomial points |
| CEvaluationFactor | Factor for enforcing the scalar value of the polynomial BASIS representation at x is the same as the measurement z when using a pseudo-spectral parameterization |
| CVectorEvaluationFactor | Unary factor for enforcing BASIS polynomial evaluation on a parameter Matrix of size (M, N) is equal to a vector-valued measurement at the same point, when using a pseudo-spectral parameterization |
| CVectorComponentFactor | Unary factor for enforcing BASIS polynomial evaluation on a parameter Matrix of size (P, N) is equal to specified measurement at the same point, when using a pseudo-spectral parameterization |
| CManifoldEvaluationFactor | For a measurement value of type T i.e |
| CDerivativeFactor | A unary factor which enforces the evaluation of the derivative of a BASIS polynomial at a specified pointx is equal to the scalar measurement z |
| CVectorDerivativeFactor | A unary factor which enforces the evaluation of the derivative of a BASIS polynomial at a specified point x is equal to the vector value z |
| CComponentDerivativeFactor | A unary factor which enforces the evaluation of the derivative of a BASIS polynomial is equal to the scalar value at a specific index i of a vector-valued measurement z |
| CCardinalSplineBasis | Cubic cardinal-spline basis for scalar, vector, and manifold Basis functors |
| CChebyshev1Basis | Basis of Chebyshev polynomials of the first kind https://en.wikipedia.org/wiki/Chebyshev_polynomials#First_kind These are typically denoted with the symbol T_n, where n is the degree |
| CChebyshev2Basis | Basis of Chebyshev polynomials of the second kind |
| CChebyshev2 | Chebyshev Interpolation on Chebyshev points of the second kind Note that N here, the number of points, is one less than N from 'Approximation Theory and Approximation Practice by L |
| CCumulativeSplineTrajectory | Factory for expressions that sample a cumulative spline on a Lie group |
| CFitBasis | Class that does regression via least squares Example usage: size_t N = 3; auto fit = FitBasis<Chebyshev2>(data_points, noise_model, N); Vector coefficients = fit.parameters(); |
| CFourierBasis | Fourier basis |
| CKernelBase | Interface for a compactly supported continuous convolution kernel |
| CPiecewisePolynomial | A one-dimensional piecewise polynomial kernel |
| CParameters | Coefficients, interval boundaries, and center defining the kernel |
| CAlgebraicDecisionTree | An algebraic decision tree fixes the range of a DecisionTree to double |
| Ctraits< AlgebraicDecisionTree< T > > | |
| CAllDiff | General AllDiff constraint |
| CAssignment | An assignment from labels to value index (size_t) |
| CBinaryAllDiff | Binary AllDiff constraint |
| CConstraint | Base class for constraint factors |
| CVisit | Functor performing depth-first visit to each leaf with the leaf value as the argument |
| CVisitLeaf | Functor performing depth-first visit to each leaf with the Leaf object passed as an argument |
| CVisitWith | Functor performing depth-first visit to each leaf with the leaf's Assignment<L> and value passed as arguments |
| CDecisionTree | Decision tree is a function from assignments to values |
| CNode | ---------------------— Node base class ------------------------— |
| CLeaf | |
| CChoice | |
| Ctraits< DecisionTree< L, Y > > | |
| CDecisionTreeFactor | A discrete probabilistic factor |
| Ctraits< DecisionTreeFactor > | |
| CDiscreteBayesNet | A Bayes net made from discrete conditional distributions |
| Ctraits< DiscreteBayesNet > | |
| CDiscreteBayesTreeClique | A clique in a DiscreteBayesTree |
| CDiscreteBayesTree | A Bayes tree representing a Discrete distribution |
| Ctraits< DiscreteBayesTreeClique > | Traits |
| Ctraits< DiscreteBayesTree > | |
| CDiscreteConditional | Discrete Conditional Density Derives from DecisionTreeFactor |
| Ctraits< DiscreteConditional > | |
| CDiscreteDistribution | A prior probability on a set of discrete variables |
| Ctraits< DiscreteDistribution > | |
| CDiscreteEliminationTree | Elimination tree for discrete factors |
| CDiscreteFactor | Base class for discrete probabilistic factors The most general one is the derived DecisionTreeFactor |
| Ctraits< DiscreteFactor > | |
| CEliminationTraits< DiscreteFactorGraph > | |
| CDiscreteFactorGraph | A Discrete Factor Graph is a factor graph where all factors are Discrete, i.e |
| Ctraits< DiscreteFactorGraph > | |
| CDiscreteJunctionTree | An EliminatableClusterTree, i.e., a set of variable clusters with factors, arranged in a tree, with the additional property that it represents the clique tree associated with a Bayes net |
| CDiscreteKeys | DiscreteKeys is a set of keys that can be assembled using the & operator |
| Ctraits< DiscreteKeys > | |
| CDiscreteLookupTable | DiscreteLookupTable table for max-product |
| CDiscreteLookupDAG | A DAG made from lookup tables, as defined above |
| Ctraits< DiscreteLookupDAG > | |
| CDiscreteMarginals | A class for computing marginals of variables in a DiscreteFactorGraph |
| CDiscreteSearch | DiscreteSearch: Search for the K best solutions |
| CSlot | We structure the search as a set of slots, each with a factor and a set of variable assignments that need to be chosen |
| CSolution | A solution is a set of assignments, covering all the slots |
| CDiscreteValues | A map from keys to values |
| Ctraits< DiscreteValues > | |
| CDomain | Constraint that restricts the possible values a particular variable, with given key, can take on |
| CSignature | Signature for a discrete conditional distribution, used to construct conditionals |
| CSignatureParser | A simple parser that replaces the boost spirit parser |
| CSingleValue | SingleValue constraint: ensures a variable takes on a certain value |
| CTableDistribution | Distribution which uses a SparseVector as the internal representation, similar to the TableFactor |
| Ctraits< TableDistribution > | |
| CTableFactor | A discrete probabilistic factor optimized for sparsity |
| Ctraits< TableFactor > | |
| CAsVectorSpace | Opt-in adapter that equips a manifold class with additive vector-space operations |
| Ctraits< AsVectorSpace< Class > > | Traits that expose the adapter as a testable additive vector space |
| Ctraits< const AsVectorSpace< Class > > | Const-qualified traits forward to the mutable adapter traits |
| CBearing | |
| CRange | |
| CBearingRange | Bearing-Range product for a particular A1,A2 combination will use the functors above to create a similar functor of type A1*A2 -> pair<Bearing::return_type,Range::return_type> For example BearingRange<Pose2,Point2>(pose,point) will return pair<Rot2,double> and BearingRange<Pose3,Point3>(pose,point) will return pair<Unit3,double> |
| Ctraits< BearingRange< A1, A2 > > | |
| CHasBearing | |
| CHasRange | |
| CCal3 | Common base class for all calibration models |
| CCal3_S2 | The most common 5DOF 3D->2D calibration |
| Ctraits< Cal3_S2 > | |
| Ctraits< const Cal3_S2 > | |
| CCal3_S2Stereo | The most common 5DOF 3D->2D calibration, stereo version |
| Ctraits< Cal3_S2Stereo > | |
| Ctraits< const Cal3_S2Stereo > | |
| CCal3Bundler | Calibration used by Bundler |
| Ctraits< Cal3Bundler > | |
| Ctraits< const Cal3Bundler > | |
| CCal3DS2 | Calibration of a camera with radial distortion that also supports Lie-group behaviors for optimization |
| Ctraits< Cal3DS2 > | |
| Ctraits< const Cal3DS2 > | |
| CCal3DS2_Base | Calibration of a camera with radial distortion |
| CCal3f | Calibration model with a single focal length and zero skew |
| Ctraits< Cal3f > | |
| Ctraits< const Cal3f > | |
| CCal3Fisheye | Calibration of a fisheye camera |
| Ctraits< Cal3Fisheye > | |
| Ctraits< const Cal3Fisheye > | |
| CCal3Unified | Calibration of a omni-directional camera with mirror + lens radial distortion |
| Ctraits< Cal3Unified > | |
| Ctraits< const Cal3Unified > | |
| CCheiralityException | |
| CPinholeBase | A pinhole camera class that has a Pose3, functions as base class for all pinhole cameras |
| CCalibratedCamera | A Calibrated camera class [R|-R't], calibration K=I |
| Ctraits< CalibratedCamera > | |
| Ctraits< const CalibratedCamera > | |
| CRange< CalibratedCamera, T > | |
| CCameraSet | A set of cameras, all with their own calibration |
| Ctraits< CameraSet< CAMERA > > | |
| Ctraits< const CameraSet< CAMERA > > | |
| CPoseConcept | Pose Concept A must contain a translation and a rotation, with each structure accessable directly and a type provided for each |
| CCyclic | Cyclic group of order N |
| Ctraits< Cyclic< N > > | Define cyclic group to be a model of the Additive Group concept |
| CEssentialMatrix | An essential matrix is like a Pose3, except with translation up to scale It is named after the 3*3 matrix aEb = [aTb]x aRb from computer vision, but here we choose instead to parameterize it as a (Rot3,Unit3) pair |
| Ctraits< EssentialMatrix > | |
| Ctraits< const EssentialMatrix > | |
| CEvent | A space-time event models an event that happens at a certain 3D location, at a certain time |
| Ctraits< Event > | |
| CTimeOfArrival | Time of arrival to given sensor |
| CExtendedPose3 | Lie group SE_k(3): semidirect product of SO(3) with k copies of R^3 |
| CChartAtOrigin | Chart operations at identity for LieGroup/Manifold compatibility |
| Ctraits< ExtendedPose3< K, Derived > > | |
| Ctraits< const ExtendedPose3< K, Derived > > | |
| CFundamentalMatrix | Represents a fundamental matrix in computer vision, which encodes the epipolar geometry between two views |
| CSimpleFundamentalMatrix | Class for representing a simple fundamental matrix |
| CTripleF | Represents a set of three fundamental matrices for transferring points between three cameras |
| Ctraits< FundamentalMatrix > | |
| Ctraits< SimpleFundamentalMatrix > | |
| CGal3 | Represents an element of the 3D Galilean group SGal(3) |
| CChartAtOrigin | Chart at origin, uses Expmap/Logmap for Retract/Local |
| Ctraits< Gal3 > | Traits specialization for Gal3 |
| Ctraits< const Gal3 > | |
| CBearing< Gal3, Point3 > | |
| CRange< Gal3, Point3 > | |
| CLine3 | A 3D line (R,a,b) : (Rot3,Scalar,Scalar) |
| Ctraits< Line3 > | |
| Ctraits< const Line3 > | |
| COrientedPlane3 | Represents an infinite plane in 3D, which is composed of a planar normal and its perpendicular distance to the origin |
| Ctraits< OrientedPlane3 > | |
| Ctraits< const OrientedPlane3 > | |
| CPinholeCamera | A pinhole camera class that has a Pose3 and a Calibration |
| Ctraits< PinholeCamera< Calibration > > | |
| Ctraits< const PinholeCamera< Calibration > > | |
| CRange< PinholeCamera< Calibration >, T > | |
| CPinholeBaseK | A pinhole camera class that has a Pose3 and a fixed Calibration |
| CPinholePose | A pinhole camera class that has a Pose3 and a fixed Calibration |
| Ctraits< PinholePose< CALIBRATION > > | |
| Ctraits< const PinholePose< CALIBRATION > > | |
| CPinholeSet | PinholeSet: triangulates point and keeps an estimate of it around |
| Ctraits< PinholeSet< CAMERA > > | |
| Ctraits< const PinholeSet< CAMERA > > | |
| CRange< Point1, Point1 > | Range functor between two Point1 values, using L1 distance |
| CRange< Point2, Point2 > | |
| CRange< Point3, Point3 > | |
| CPose2 | A 2D pose (Point2,Rot2) |
| CChartAtOrigin | |
| Ctraits< Pose2 > | Add the Pose2-specific operations used by the generic QCQP conversion code |
| Ctraits< const Pose2 > | |
| CBearing< Pose2, T > | |
| CRange< Pose2, T > | |
| CPose3 | A 3D pose (R,t) : (Rot3,Point3) |
| CChartAtOrigin | |
| Ctraits< Pose3 > | Add the Pose3-specific operations used by the generic QCQP conversion code |
| Ctraits< const Pose3 > | |
| CBearing< Pose3, Point3 > | |
| CBearing< Pose3, Pose3 > | |
| CRange< Pose3, T > | |
| Ctraits< QUATERNION_TYPE > | |
| CRot2 | Rotation matrix NOTE: the angle theta is in radians unless explicitly stated |
| CChartAtOrigin | |
| Ctraits< Rot2 > | |
| Ctraits< const Rot2 > | |
| CRot3 | Rot3 is a 3D rotation represented as a rotation matrix if the preprocessor symbol GTSAM_USE_QUATERNIONS is not defined, or as a quaternion if it is defined |
| CCayleyChart | |
| CChartAtOrigin | |
| Ctraits< Rot3 > | |
| Ctraits< const Rot3 > | |
| CSimilarity2 | 2D similarity transform |
| CChartAtOrigin | Chart at the origin |
| Ctraits< Similarity2 > | |
| Ctraits< const Similarity2 > | |
| CSimilarity3 | 3D similarity transform |
| CChartAtOrigin | Chart at the origin |
| Ctraits< Similarity3 > | |
| Ctraits< const Similarity3 > | |
| CSL4 | |
| CChartAtOrigin | |
| Ctraits< SL4 > | |
| Ctraits< const SL4 > | |
| Ctraits< SO3 > | |
| Ctraits< const SO3 > | |
| Ctraits< SO4 > | |
| Ctraits< const SO4 > | |
| CSO | Manifold of special orthogonal rotation matrices SO<N> |
| CChartAtOrigin | |
| Ctraits< SO< N > > | |
| Ctraits< const SO< N > > | |
| CEmptyCal | Empty calibration |
| CSphericalCamera | A spherical camera class that has a Pose3 and measures bearing vectors |
| Ctraits< SphericalCamera > | |
| Ctraits< const SphericalCamera > | |
| CStereoCheiralityException | |
| CStereoCamera | A stereo camera class, parameterize by left camera pose and stereo calibration |
| Ctraits< StereoCamera > | |
| Ctraits< const StereoCamera > | |
| CStereoPoint2 | A 2D stereo point, v will be same for rectified images |
| Ctraits< StereoPoint2 > | |
| Ctraits< const StereoPoint2 > | |
| CTriangulationUnderconstrainedException | Exception thrown by triangulateDLT when SVD returns rank < 3 |
| CTriangulationCheiralityException | Exception thrown by triangulateDLT when landmark is behind one or more of the cameras |
| CTriangulationParameters | |
| CTriangulationResult | TriangulationResult is an optional point, along with the reasons why it is invalid |
| CUnit3 | Represents a 3D point on a unit sphere |
| Ctraits< Unit3 > | Define GTSAM traits |
| Ctraits< const Unit3 > | |
| CDCSAM | Class which implements Discrete-Continuous Smoothing And Mapping, as detailed in Doherty22ral (https://arxiv.org/abs/2204.11936) |
| CDiscreteBoundaryFactor | A discrete probabilistic factor which computes its values from the continuous factors connected to it and a set of values |
| Ctraits< DiscreteBoundaryFactor > | |
| CHybridBayesNet | A hybrid Bayes net is a collection of HybridConditionals, which can have discrete conditionals, hybrid Gaussian conditionals, or pure Gaussian conditionals |
| Ctraits< HybridBayesNet > | Traits |
| CHybridBayesTreeClique | A clique in a HybridBayesTree which is a HybridConditional internally |
| CHybridBayesTree | A Bayes tree representing a Hybrid density |
| Ctraits< HybridBayesTreeClique > | Traits |
| Ctraits< HybridBayesTree > | |
| CBayesTreeOrphanWrapper< HybridBayesTreeClique > | Class for Hybrid Bayes tree orphan subtrees |
| CHybridConditional | Hybrid Conditional Density |
| Ctraits< HybridConditional > | |
| CHybridEliminationTree | Elimination Tree type for Hybrid Factor Graphs |
| CHybridFactor | Base class for truly hybrid probabilistic factors |
| Ctraits< HybridFactor > | |
| CHybridFactorGraph | Hybrid Factor Graph Factor graph with utilities for hybrid factors |
| CHybridGaussianConditional | A conditional of gaussian conditionals indexed by discrete variables, as part of a Bayes Network |
| Ctraits< HybridGaussianConditional > | |
| CHybridGaussianFactor | Implementation of a discrete-conditioned hybrid factor |
| Ctraits< HybridGaussianFactor > | |
| CEliminationTraits< HybridGaussianFactorGraph > | |
| CHybridGaussianFactorGraph | |
| Ctraits< HybridGaussianFactorGraph > | |
| CHybridGaussianISAM | Incremental Smoothing and Mapping (ISAM) algorithm for hybrid factor graphs |
| Ctraits< HybridGaussianISAM > | Traits |
| CHybridGaussianProductFactor | Alias for DecisionTree of GaussianFactorGraphs and their scalar sums |
| Ctraits< HybridGaussianProductFactor > | |
| CHybridJunctionTree | An EliminatableClusterTree, i.e., a set of variable clusters with factors, arranged in a tree, with the additional property that it represents the clique tree associated with a Bayes net |
| CHybridNonlinearFactor | Implementation of a discrete-conditioned hybrid factor |
| Ctraits< HybridNonlinearFactor > | |
| CHybridNonlinearFactorGraph | |
| Ctraits< HybridNonlinearFactorGraph > | |
| CHybridNonlinearISAM | Wrapper class to manage ISAM in a nonlinear context |
| CHybridSmoother | |
| CHybridValues | HybridValues represents a collection of DiscreteValues and VectorValues |
| Ctraits< HybridValues > | |
| CBayesNet | A BayesNet is a tree of conditionals, stored in elimination order |
| CFactorGraph | A factor graph is a bipartite graph with factor nodes connected to variable nodes |
| CEliminatableClusterTree | A cluster-tree that eliminates to a Bayes tree |
| CBayesTreeCliqueStats | Clique statistics |
| CBayesTreeCliqueData | Store all the sizes |
| CBayesTree | Bayes tree |
| CBayesTreeOrphanWrapper | |
| CEliminationTraits | Traits class for eliminateable factor graphs, specifies the types that result from elimination, etc |
| CBayesTreeCliqueBase | This is the base class for BayesTree cliques |
| CEliminationData | |
| CEliminationPostOrderVisitor | |
| CClusterTree | A cluster-tree is associated with a factor graph and is defined as in Koller-Friedman: each node k represents a subset \( C_k \sub X \), and the tree is family preserving, in that each factor \( f_i \) is associated with a single cluster and \( scope(f_i) \sub C_k \) |
| CCluster | A Cluster is just a collection of factors |
| CConditional | |
| CConstFactorRangeIterator | |
| CDotWriter | DotWriter is a helper class for writing graphviz .dot files |
| CEdgeKey | |
| Ctraits< EdgeKey > | Traits |
| CEliminateableFactorGraph | EliminateableFactorGraph is a base class for factor graphs that contains elimination algorithms |
| CEliminationTree | An elimination tree is a data structure used intermediately during elimination |
| CNode | |
| CFactor | |
| Cordering_key_visitor | |
| Ccompose_key_visitor | |
| CSDGraph | SDGraph is undirected graph with variable keys and double edge weights |
| CSGraph | |
| CPredecessorMap | Map from variable key to parent key |
| CInconsistentEliminationRequested | An inference algorithm was called with inconsistent arguments |
| CISAM | A Bayes tree with an update methods that implements the iSAM algorithm |
| CConstructorTraversalData | |
| CSymbolicFactors | |
| CJunctionTree | A JunctionTree is a cluster tree, a set of variable clusters with factors, arranged in a tree, with the additional property that it represents the clique tree associated with a Bayes Net |
| CStreamedKey | To use the key_formatter on Keys, they must be wrapped in a StreamedKey |
| Ckey_formatter | Output stream manipulator that will format gtsam::Keys according to the given KeyFormatter, as long as Key values are wrapped in a gtsam::StreamedKey |
| Ctraits< Key > | |
| CLabeledSymbol | Customized version of gtsam::Symbol for multi-robot use |
| Ctraits< LabeledSymbol > | Traits |
| CMetisIndex | Converts a factor graph into the Compressed Sparse Row format for use in METIS algorithms |
| COrdering | |
| Ctraits< Ordering > | Traits |
| CSymbol | Character and index key used to refer to variables |
| CSymbolGenerator | Generates symbol shorthands with alternative names different than the one-letter predefined ones |
| Ctraits< Symbol > | Traits |
| CVariableIndex | Computes and stores the block column structure of a factor graph |
| Ctraits< VariableIndex > | Traits |
| CVariableSlots | A combined factor is assembled as one block of rows for each component factor |
| Ctraits< VariableSlots > | Traits |
| CAcceleratedPowerMethod | Compute maximum Eigenpair with accelerated power method |
| CBatchJacobianFactorBase | Common interface for compact batch Jacobian factors |
| CBatchJacobianFactor | Fixed-dimension row-sparse batch Jacobian factor |
| CConjugateGradientParameters | Parameters for the Conjugate Gradient method |
| CConjugateGradientStats | Diagnostics collected during a conjugate-gradient solve |
| CConjugateGradientResult | Solution and diagnostics returned by the detailed CG interface |
| Ctraits< Errors > | Traits |
| CFixedJacobianFactor | A JacobianFactor whose residual and variable dimensions are known at compile time |
| Ctraits< FixedJacobianFactor< M, Ns... > > | |
| CFlatGaussianFactor | Optional preindexed kernels for matrix-free Gaussian factors |
| CGaussianBayesNet | GaussianBayesNet is a Bayes net made from linear-Gaussian conditionals |
| Ctraits< GaussianBayesNet > | Traits |
| CGaussianBayesTreeClique | A clique in a GaussianBayesTree |
| CGaussianBayesTree | A Bayes tree representing a Gaussian density |
| Ctraits< GaussianBayesTree > | Traits |
| CGaussianConditional | A GaussianConditional functions as the node in a Bayes network |
| Ctraits< GaussianConditional > | Traits |
| CGaussianDensity | A GaussianDensity is a GaussianConditional without parents |
| CGaussianEliminationTree | |
| CGaussianFactor | An abstract virtual base class for JacobianFactor and HessianFactor |
| Ctraits< GaussianFactor > | Traits |
| CEliminationTraits< GaussianFactorGraph > | |
| CGaussianFactorGraph | A Linear Factor Graph is a factor graph where all factors are Gaussian, i.e |
| Ctraits< GaussianFactorGraph > | Traits |
| CGaussianISAM | |
| Ctraits< GaussianISAM > | Traits |
| CGaussianJunctionTree | A junction tree specialized to Gaussian factors, i.e., it is a cluster tree with Gaussian factors stored in each cluster |
| CHessianFactor | A Gaussian factor using the canonical parameters (information form) |
| Ctraits< HessianFactor > | Traits |
| CCGState | |
| CSystem | Helper class encapsulating the combined system |Ax-b_|^2 Needed to run Conjugate Gradients on matrices |
| CIterativeOptimizationParameters | Parameters for iterative linear solvers |
| CIterativeSolver | Base class for Iterative Solvers like SubgraphSolver |
| CJacobianFactor | A Gaussian factor in the squared-error form |
| Ctraits< JacobianFactor > | Traits |
| CJointMarginal | A class to store and access a joint marginal, returned from Gaussian and nonlinear covariance query APIs |
| CKalmanFilter | Kalman Filter class |
| CKeyInfoEntry | Position, dimension, and scalar offset of one key in an ordered vector |
| CKeyInfo | Ordered key dimensions and offsets in one flattened variable vector |
| CIndeterminateSystemException | Thrown when a linear system is ill-posed |
| CInvalidNoiseModel | An exception indicating that the noise model dimension passed into a JacobianFactor has a different dimensionality than the factor |
| CInvalidMatrixBlock | An exception indicating that a matrix block passed into a JacobianFactor has a different dimensionality than the factor |
| CInvalidDenseElimination | |
| CMultifrontalClique | Imperative multifrontal clique structure used by MultifrontalSolver |
| CChildInfo | |
| CMultifrontalParameters | Parameters for gtsam::MultifrontalSolver |
| CMultifrontalSolverNotSupported | Exception for unsupported use of the new multifrontal solver |
| CMultifrontalSolver | Imperative-style multifrontal solver for Gaussian factor graphs |
| CPrecomputedData | Precomputed symbolic and sizing data for multifrontal solver construction |
| Ctraits< noiseModel::Gaussian > | Traits |
| Ctraits< noiseModel::Diagonal > | |
| Ctraits< noiseModel::Constrained > | |
| Ctraits< noiseModel::Isotropic > | |
| Ctraits< noiseModel::Unit > | |
| CPCGSolverParameters | Parameters for Preconditioned Conjugate Gradient solver |
| CPCGSolverResult | Solution, convergence diagnostics, and phase timings from PCGSolver |
| CPCGSolver | A virtual base class for the preconditioned conjugate gradient solver |
| CGaussianFactorGraphSystem | Compiled flat-vector system used by preconditioned conjugate gradients |
| CPowerMethod | Compute maximum Eigenpair with power method |
| CPreconditionerParameters | |
| CPreconditioner | |
| CDummyPreconditionerParameters | |
| CDummyPreconditioner | |
| CBlockJacobiPreconditionerParameters | |
| CBlockJacobiPreconditioner | |
| CRegularHessianFactor | A HessianFactor where all variables have the same dimension D |
| Ctraits< RegularHessianFactor< D > > | |
| CRegularJacobianFactor | JacobianFactor with constant sized blocks Provides raw memory access versions of linear operator |
| CSampler | Sampling structure that keeps internal random number generators for diagonal distributions specified by NoiseModel |
| CSlotEntry | One SlotEntry stores the slot index for a variable, as well its dim |
| CScatter | Scatter is an intermediate data structure used when building a HessianFactor incrementally, to get the keys in the right order |
| CSubgraph | |
| CEdge | |
| CSubgraphBuilderParameters | |
| CSubgraphBuilder | |
| CSubgraphPreconditionerParameters | |
| CSubgraphPreconditioner | Subgraph conditioner class, as explained in the RSS 2010 submission |
| CSubgraphSolverParameters | |
| CSubgraphSolver | This class implements the linear SPCG solver presented in Dellaert et al in IROS'10 |
| CVectorValues | VectorValues represents a collection of vector-valued variables associated each with a unique integer index |
| Ctraits< VectorValues > | Traits |
| CPreintegratedAhrsMeasurements | PreintegratedAHRSMeasurements accumulates (integrates) the gyroscope measurements (rotation rates) and the corresponding covariance matrix |
| CAHRSFactorT | An AHRSFactor is a three-way factor that is based on the preintegrated gyroscope measurements |
| Ctraits< PreintegratedAhrsMeasurements > | |
| Ctraits< AHRSFactorT< PIM > > | |
| CAttitudeFactor | Unary factor that constrains the rotation component of a value |
| Ctraits< AttitudeFactor< VALUE > > | |
| CBarometricFactor | Prior on height in a cartesian frame |
| CCarrierPhaseFactor | Undifferenced GNSS carrier phase factor for point positioning |
| Ctraits< CarrierPhaseFactor > | Traits |
| CUndifferencedCarrierPhaseFactor | Undifferenced (raw) PPP carrier phase factor |
| Ctraits< UndifferencedCarrierPhaseFactor > | Traits |
| CUndifferencedCarrierPhaseFactorArm | Undifferenced (raw) PPP carrier phase factor with lever-arm correction |
| Ctraits< UndifferencedCarrierPhaseFactorArm > | Traits |
| CCarrierPhaseFactorArm | Carrier phase factor with lever arm correction |
| Ctraits< CarrierPhaseFactorArm > | Traits |
| CDoubleDifferenceCarrierPhaseFactor | Double-difference carrier phase factor |
| Ctraits< DoubleDifferenceCarrierPhaseFactor > | |
| CDoubleDifferenceCarrierPhaseFactorArm | Double-difference carrier phase factor with lever arm correction |
| Ctraits< DoubleDifferenceCarrierPhaseFactorArm > | |
| CPreintegratedCombinedMeasurementsT | PreintegratedCombinedMeasurements integrates the IMU measurements (rotation rates and accelerations) and the corresponding covariance matrix |
| CCombinedImuFactorT | CombinedImuFactor is a 6-ways factor involving previous state (pose and velocity of the vehicle, as well as bias at previous time step), and current state (pose, velocity, bias at current time step) |
| Ctraits< PreintegrationCombinedParams > | |
| Ctraits< PreintegratedCombinedMeasurementsT< PreintegrationType > > | |
| Ctraits< CombinedImuFactorT< PIM > > | |
| CCombinedImuFactorWithGravityT | CombinedImuFactorWithGravityT is CombinedImuFactorT with an additional GRAVITY variable, so that gravity can be optimized instead of being fixed by the preintegration parameters |
| Ctraits< CombinedImuFactorWithGravityT< PIM, GRAVITY > > | |
| CConstantVelocityFactor | Binary factor for applying a constant velocity model to a moving body represented as a NavState |
| CDopplerFactor | GNSS Doppler (range-rate) factor |
| Ctraits< DopplerFactor > | Traits |
| CDopplerFactorArm | DopplerFactor with a kinematic lever-arm correction, keyed on a body Pose3 |
| Ctraits< DopplerFactorArm > | Traits |
| CEquivariantFilter | Equivariant Filter (EqF) for state estimation on Lie groups |
| CGal3ImuEKF | Specialized EKF for IMU-driven on Gal3 |
| CGalileanPreintegration | IMU preintegration on Gal(3) using GTSAM's left-invariant local error |
| CGnssMeasurementBase | Base class storing common members for GNSS measurement factors |
| CGPSFactor | Prior on position in a Cartesian frame |
| CGPSFactorArm | Version of GPSFactor (for Pose3) with lever arm between GPS and Body frame |
| Ctraits< GPSFactorArm > | Traits |
| CGPSFactorArmCalib | Version of GPSFactorArm (for Pose3) with unknown lever arm between GPS and Body frame |
| Ctraits< GPSFactorArmCalib > | Traits |
| CGPSFactor2 | Version of GPSFactor for NavState, assuming zero lever arm between body frame and GPS |
| CGPSFactor2Arm | Version of GPSFactor2 with lever arm between GPS and Body frame |
| Ctraits< GPSFactor2Arm > | Traits |
| CGPSFactor2ArmCalib | Version of GPSFactor2Arm for an unknown lever arm between GPS and Body frame |
| Ctraits< GPSFactor2ArmCalib > | Traits |
| Ctraits< imuBias::ConstantBias > | |
| CPreintegratedImuMeasurementsT | PreintegratedImuMeasurements accumulates (integrates) the IMU measurements (rotation rates and accelerations) and the corresponding covariance matrix |
| CImuFactorT | 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 |
| CImuFactor2T | ImuFactor2 is a ternary factor that uses NavStates rather than Pose/Velocity |
| Ctraits< PreintegratedImuMeasurementsT< PreintegrationType > > | |
| Ctraits< ImuFactorT< PIM > > | |
| Ctraits< ImuFactor2T< PIM > > | |
| CImuFactorWithGravityT | 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 |
| Ctraits< ImuFactorWithGravityT< PIM, GRAVITY > > | |
| CImuFactor2WithGravityT | 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 |
| Ctraits< ImuFactor2WithGravityT< PIM, GRAVITY > > | |
| CInvariantEKF | Left-Invariant Extended Kalman Filter on a Lie group G |
| CLeftLinearEKF | EKF on a Lie group with a general left–linear prediction model |
| Cis_automorphism | SFINAE template to check if a type satisfies the automorphism concept |
| CContactMeasurement | Body-frame contact measurement for one foot |
| CLeggedEstimatorParams | Common estimator parameters shared by all four variants |
| CLeggedEstimator | Common runtime interface shared by all four legged estimator variants |
| CLeggedInvariantEKF | Invariant filter: LeftLinearEKF on ExtendedPose3(2+k) |
| CAutonomousFlow | Autonomous flow used by the left-linear prediction step |
| CLeggedInvariantIEKF | Invariant filter with local graph fragment |
| CLeggedFixedLagSmoother | Fixed-lag smoother over NavState and contact-episode footholds |
| CLeggedCombinedFixedLagSmoother | Fixed-lag smoother with CombinedImuFactor bias evolution |
| CExtendedPoseContactFactor | Contact factor for the ExtendedPose3(2+k) graph-update variant |
| CExtendedPoseHeightFactor | Height factor for the ExtendedPose3(2+k) graph-update variant |
| CNavStatePointContactFactor | Contact factor between a NavState and a foothold point variable |
| CPose3PointContactFactor | Contact factor between a Pose3 and a foothold point variable |
| CPointHeightFactor | Height factor on a standalone foothold point variable |
| CLieGroupEKF | Extended Kalman Filter on a Lie group G, derived from ManifoldEKF |
| CLieGroupPreintegration | IMU preintegration using the SE_2(3) Lie-group structure of NavState |
| CMagFactor | Factor to estimate rotation given magnetometer reading This version uses model measured bM = scale * bRn * direction + bias and assumes scale, direction, and the bias are given |
| CMagFactor1 | Factor to estimate rotation given magnetometer reading This version uses model measured bM = scale * bRn * direction + bias and assumes scale, direction, and the bias are given |
| CMagFactor2 | Factor to calibrate local Earth magnetic field as well as magnetometer bias This version uses model measured bM = bRn * nM + bias and optimizes for both nM and the bias, where nM is in units defined by magnetometer |
| CMagFactor3 | Factor to calibrate local Earth magnetic field as well as magnetometer bias This version uses model measured bM = scale * bRn * direction + bias and optimizes for both scale, direction, and the bias |
| CMagPoseFactor | Factor to estimate rotation of a Pose2 or Pose3 given a magnetometer reading |
| CManifoldEKF | Extended Kalman Filter on a generic manifold M |
| CManifoldPreintegration | IMU pre-integration on NavState manifold |
| CNavState | Navigation state: Pose (rotation, translation) + velocity Following Barrau20icra, this class belongs to the Lie group SE_2(3) |
| CAutonomousFlow | |
| Ctraits< NavState > | |
| Ctraits< const NavState > | |
| CBearing< NavState, Point3 > | |
| CRange< NavState, Point3 > | |
| CNavStateImuEKF | Specialized EKF for IMU-driven NavState on SE_2(3) |
| CPlanarGyroParams | Modeled parameters of the gyro |
| CPlanarGyroBiasFactor | Models the evolution of the bias itself as a random walk |
| CPlanarGyroFactor | A "between" factor for Pose2 rotation, with variable bias |
| CPreintegratedRotationParams | Parameters for pre-integration: Usage: Create just a single Params and pass a shared pointer to the constructor |
| CPreintegratedRotation | PreintegratedRotation is the base class for all PreintegratedMeasurements classes (in AHRSFactor, ImuFactor, and CombinedImuFactor) |
| Ctraits< PreintegratedRotation > | |
| CPreintegrationBase | PreintegrationBase is the base class for PreintegratedMeasurements (in ImuFactor) and CombinedPreintegratedMeasurements (in CombinedImuFactor) |
| CPreintegrationCombinedParams | Parameters for pre-integration using PreintegratedCombinedMeasurements: Usage: Create just a single Params and pass a shared pointer to the constructor |
| CPreintegrationParams | Parameters for pre-integration: Usage: Create just a single Params and pass a shared pointer to the constructor |
| CPseudorangeFactor | Simplified GNSS pseudorange model for basic positioning problems |
| Ctraits< PseudorangeFactor > | Traits |
| CUndifferencedPseudorangeFactor | Undifferenced (raw) PPP pseudorange factor |
| Ctraits< UndifferencedPseudorangeFactor > | Traits |
| CUndifferencedPseudorangeFactorArm | Undifferenced (raw) PPP pseudorange factor with lever-arm correction |
| Ctraits< UndifferencedPseudorangeFactorArm > | Traits |
| CDifferentialPseudorangeFactor | |
| Ctraits< DifferentialPseudorangeFactor > | Traits |
| CPseudorangeFactorArm | GNSS pseudorange factor with lever arm correction |
| Ctraits< PseudorangeFactorArm > | Traits |
| CDifferentialPseudorangeFactorArm | Differentially-corrected pseudorange factor with lever arm correction |
| Ctraits< DifferentialPseudorangeFactorArm > | Traits |
| CDoubleDifferencePseudorangeFactor | Double-difference pseudorange factor |
| Ctraits< DoubleDifferencePseudorangeFactor > | |
| CDoubleDifferencePseudorangeFactorArm | Double-difference pseudorange factor with lever arm correction |
| Ctraits< DoubleDifferencePseudorangeFactorArm > | |
| CScenario | Simple trajectory simulator |
| CConstantTwistScenario | Scenario with constant twist 3D trajectory |
| CAcceleratingScenario | Accelerating from an arbitrary initial state, with optional rotation |
| CDiscreteScenario | A scenario defined by discrete ground-truth measurements over time |
| CScenarioRunner | |
| CCombinedScenarioRunner | |
| CAhrsScenarioRunner | |
| CTangentPreintegration | Integrate on the 9D tangent space of the NavState manifold |
| CAdaptAutoDiff | The AdaptAutoDiff class uses ceres-style autodiff to adapt a ceres-style Function evaluation, i.e., a function FUNCTOR that defines an operator template<typename T> bool operator()(const T* const, const T* const, T*
predicted) const; For now only binary operators are supported |
| CAntiFactor | A class for downdating an existing factor from a graph |
| CBatchFactor | BatchFactor is a NonlinearFactor that wraps a collection of identical factors |
| CBatchFixedLagSmoother | |
| CBayesTreeMarginalizationHelper | This class provides helper functions for marginalizing variables from a Bayes Tree |
| CCachedSearch | A struct to cache the results of the below two functions |
| CConcentratedGaussian | A nonlinear density, inherits from ExtendedPriorFactor |
| CCustomFactor | |
| CDoglegParams | Parameters for Levenberg-Marquardt optimization |
| CDoglegOptimizer | This class performs Dogleg nonlinear optimization |
| CDoglegOptimizerImpl | This class contains the implementation of the Dogleg algorithm |
| CIterationResult | |
| CDoglegLineSearchImpl | 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) |
| CParams | |
| CExpressionFactor | Factor that supports arbitrary expressions via AD |
| CExpressionEqualityConstraint | |
| CExpression | Expression class that supports automatic differentiation |
| CUnaryFunction | |
| CBinaryFunction | |
| CTernaryFunction | |
| CScalarMultiplyExpression | A ScalarMultiplyExpression is a specialization of Expression that multiplies with a scalar It optimizes the Jacobian calculation for this specific case |
| CBinarySumExpression | A BinarySumExpression is a specialization of Expression that adds two expressions together It optimizes the Jacobian calculation for this specific case |
| Ctraits< ExpressionFactor< T > > | Traits |
| CExpressionFactorN | N-ary variadic template for ExpressionFactor meant as a base class for N-ary factors |
| Ctraits< ExpressionFactorN< T, Args... > > | Traits |
| CExpressionFactorGraph | Factor graph that supports adding ExpressionFactors directly |
| CExtendedKalmanFilter | This is a generic Extended Kalman Filter class implemented using nonlinear factors |
| CExtendedPriorFactor | A class for a soft prior on any Value type, but with a non-zero mean in the tangent space |
| Ctraits< ExtendedPriorFactor< VALUE > > | Traits |
| CFixedLagSmoother | |
| CResult | Meta information returned about the update |
| CFunctorizedFactor | Factor which evaluates provided unary functor and uses the result to compute error with respect to the provided measurement |
| Ctraits< FunctorizedFactor< R, T > > | Traits |
| CFunctorizedFactor2 | Factor which evaluates provided binary functor and uses the result to compute error with respect to the provided measurement |
| Ctraits< FunctorizedFactor2< R, T1, T2 > > | Traits |
| CGaussNewtonParams | Parameters for Gauss-Newton optimization, inherits from NonlinearOptimizationParams |
| CGaussNewtonOptimizer | This class performs Gauss-Newton nonlinear optimization |
| CGncIterationTiming | Timing of one GNC outer iteration (all in seconds) |
| CGncTiming | Timing of a full GncOptimizer::optimize() call |
| CGncOptimizer | |
| CGncParams | |
| CGraphvizFormatting | Formatting options and functions for saving a NonlinearFactorGraph instance in GraphViz format |
| CIncrementalFixedLagSmoother | This is a base class for the various HMF2 implementations |
| CISAM2BayesTree | |
| CISAM2JunctionTree | |
| CDeltaImpl | |
| CPartialSolveResult | |
| CReorderingMode | |
| CUpdateImpl | Implementation functions for update method All of the methods below have clear inputs and outputs, even if not functional: iSAM2 is inherintly imperative |
| CISAM2 | Implementation of the full ISAM2 algorithm for incremental nonlinear optimization |
| Ctraits< ISAM2 > | Traits |
| CISAM2Clique | Specialized Clique structure for ISAM2, incorporating caching and gradient contribution TODO: more documentation |
| CISAM2GaussNewtonParams | Parameters for ISAM2 using Gauss-Newton optimization |
| CISAM2DoglegParams | Parameters for ISAM2 using Dogleg optimization |
| CISAM2DoglegLineSearchParams | Parameters for ISAM2 using Dogleg Line Search optimization |
| CISAM2Params | |
| CISAM2Result | This struct is returned from ISAM2::update() and contains information about the update that is useful for determining whether the solution is converging, and about how much work was required for the update |
| CDetailedResults | A struct holding detailed results, which must be enabled with ISAM2Params::enableDetailedResults |
| CVariableStatus | The status of a single variable, this struct is stored in DetailedResults::variableStatus |
| CISAM2UpdateParams | This struct is used by ISAM2::update() to pass additional parameters to give the user a fine-grained control on how factors and relinearized, etc |
| CLevenbergMarquardtOptimizer | This class performs Levenberg-Marquardt nonlinear optimization |
| CLevenbergMarquardtParams | Parameters for Levenberg-Marquardt optimization |
| CLinearContainerFactor | Dummy version of a generic linear factor to be injected into a nonlinear factor graph |
| Ctraits< LinearContainerFactor > | |
| CLMDampingParams | Parameters controlling LM-style damping as applied by gtsam::NonlinearMultifrontalSolver |
| CMarginals | A class for computing Gaussian marginals of variables in a NonlinearFactorGraph |
| CNoiseModelFactorT | A convenient base class for creating your own NoiseModelFactor with n variables |
| CNonlinearConjugateGradientOptimizer | An implementation of the nonlinear CG method using the template below |
| CMarginalizeNonleafException | Thrown when requesting to marginalize out variables from ISAM2 that are not leaves |
| CNonlinearFactor | Nonlinear factor base class |
| Ctraits< NonlinearFactor > | Traits |
| CNoiseModelFactor | A nonlinear sum-of-squares factor with a zero-mean noise model implementing the density \( P(z|x) \propto exp -0.5*|z-h(x)|^2_C \) Templated on the parameter type X and the values structure Values There is no return type specified for h(x) |
| CNonlinearFactorGraph | |
| Ctraits< NonlinearFactorGraph > | Traits |
| CNonlinearISAM | Wrapper class to manage ISAM in a nonlinear context |
| CNonlinearMultifrontalSolver | Multifrontal solver for nonlinear factor graphs |
| CNonlinearOptimizer | This is the abstract interface for classes that can optimize for the maximum-likelihood estimate of a NonlinearFactorGraph |
| CNonlinearOptimizerParams | The common parameters for Nonlinear optimizers |
| CPriorFactor | A class for a soft prior on any Value type |
| Ctraits< PriorFactor< VALUE > > | Traits |
| C_ValuesKeyValuePair | |
| C_ValuesConstKeyValuePair | |
| CValuesCastHelper | |
| CValuesCastHelper< Value, CastedKeyValuePairType, KeyValuePairType > | |
| CValuesCastHelper< const Value, CastedKeyValuePairType, KeyValuePairType > | |
| CValueCloneAllocator | |
| CValues | A non-templated config holding any types of Manifold-group elements |
| CKeyValuePair | A key-value pair, which you get by dereferencing iterators |
| CConstKeyValuePair | A key-value pair, which you get by dereferencing iterators |
| Cderef_iterator | |
| CValuesKeyAlreadyExists | |
| CValuesKeyDoesNotExist | |
| CValuesIncorrectType | |
| CDynamicValuesMismatched | |
| CNoMatchFoundForFixed | |
| Ctraits< Values > | Traits |
| CVectorNormFactor | Unary factor constraining the norm of an N-dimensional vector-space variable to a given value, with error = ||v|| - norm |
| Ctraits< VectorNormFactor< N > > | Traits |
| CWhiteNoiseFactor | Binary factor to estimate parameters of zero-mean Gaussian white noise |
| CWnoaMotionFactor | WNOA (White Noise on Acceleration) motion prior factor |
| Ctraits< WnoaMotionFactor< Pose > > | |
| CWnoaFactorGraph | Factor graph specialized for WNOA interpolation-aware computation |
| CWnoaInterpFactor | Wrapper factor that evaluates an inner NoiseModelFactor on states interpolated from neighboring estimated states using a WNOA (white-noise-on-acceleration) Gaussian process interpolator |
| CPassedInterpData | Container for externally-computed interpolation data |
| Ctraits< WnoaInterpFactor< POSE > > | Traits |
| CPoseVelocity | Simple container for a pose and its corresponding velocity |
| CTimestampedPoseVelocity | Timestamped pose and velocity container |
| CInterpolator | Interpolator for poses and velocities under a motion prior |
| CStateJacobians | |
| CStateData | Lightweight container for states used for continuous-time estimation and interpolation |
| CBearingFactor | Binary factor for a bearing measurement Works for any two types A1,A2 for which the functor Bearing<A1,A2>() is defined |
| Ctraits< BearingFactor< A1, A2, T > > | Traits |
| CBearingRangeFactor | Binary factor for a bearing/range measurement |
| Ctraits< BearingRangeFactor< A1, A2, B, R > > | Traits |
| CQuadraticRangeFactor | |
| CRangeFactor | Binary factor for a range measurement Works for any two types A1,A2 for which the functor Range<A1,A2>() is defined |
| Ctraits< RangeFactor< A1, A2, T > > | Traits |
| CRangeFactorWithTransform | Binary factor for a range measurement, with a transform applied |
| Ctraits< RangeFactorWithTransform< A1, A2, T > > | Traits |
| CRangeFactorWithTransformBias | Ternary factor for a range measurement with a fixed sensor transform and an additive bias term |
| Ctraits< RangeFactorWithTransformBias< A1, A2, T > > | Traits |
| CRISAMParams | Struct Containing all configuration parameters for riSAM |
| CRISAMUpdateResult | Struct containing information about the riSAM update |
| CRISAM | Robust Incremental Smoothing and Mapping (riSAM) is a robust variant of iSAM2 for incremental factor-graph optimization |
| CGraduatedFactor | Graduated Factor for riSAM base class |
| CGenericGraduatedFactor | Instantiation of Graduated Factor wrapping any Nonlinear Factor |
| CGraduationScheduler | Class for graduation scheduling for riSAM |
| CBinaryMeasurement | |
| CEssentialMatrixConstraint | Binary factor between two Pose3 variables induced by an EssentialMatrix measurement |
| CEssentialMatrixFactor | Factor that evaluates epipolar error p'Ep for given essential matrix |
| CEssentialMatrixFactor2 | Binary factor that optimizes for E and inverse depth d: assumes measurement in image 2 is perfect, and returns re-projection error in image 1 |
| CEssentialMatrixFactor3 | Binary factor that optimizes for E and inverse depth d: assumes measurement in image 2 is perfect, and returns re-projection error in image 1 This version takes an extrinsic rotation to allow for omni-directional rigs |
| CEssentialMatrixFactor4 | Binary factor that optimizes for E and calibration K using the algebraic epipolar error (K^-1 pA)'E (K^-1 pB) |
| CEssentialMatrixFactor5 | Binary factor that optimizes for E and two calibrations Ka and Kb using the algebraic epipolar error (Ka^-1 pA)'E (Kb^-1 pB) |
| CGlobalPositioner | |
| CLocationRecovery | |
| CMFAS | To solve a Minimum feedback arc set (MFAS) problem |
| CSelfCalibrationFactor | Binary factor measuring how close a fundamental matrix is to admitting a valid essential matrix, as a function of the two cameras' focal lengths |
| CSfmData | SfmData stores a bunch of SfmTracks |
| Ctraits< SfmData > | Traits |
| CSfmLevenbergMarquardtParams | Parameters for CPU SFM Levenberg-Marquardt optimization |
| CSfmLevenbergMarquardtOptimizer | CPU SFM optimizer supporting either a joint solve or Schur elimination of Point3 and Unit3 variables |
| CSfmTrack2d | Track containing 2D measurements associated with a single 3D point |
| CSfmTrack | |
| Ctraits< SfmTrack > | |
| CShonanAveragingParameters | Parameters governing optimization etc |
| CShonanAveraging | Class that implements Shonan Averaging from our ECCV'20 paper |
| CShonanAveraging2 | |
| CShonanAveraging3 | |
| CShonanFactor | ShonanFactor is a BetweenFactor that moves in SO(p), but will land on the SO(d) sub-manifold of SO(p) at the global minimum |
| CShonanGaugeFactor | The ShonanGaugeFactor creates a constraint on a single SO(n) to avoid moving in the stabilizer |
| CTrajectoryAlignerSim3 | Aligns Pose3 trajectories from multiple child coordinate frames to a parent reference frame using Sim3 (similarity) transformations |
| CTransferEdges | Base class that holds the EdgeKeys and provides the getMatrices method |
| CTransferFactor | Binary factor in the context of Structure from Motion (SfM) |
| CEssentialTransferFactor | Transfers points between views using essential matrices with a shared calibration |
| CEssentialTransferFactorK | Transfers points between views using essential matrices, optimizes for calibrations of the views, as well |
| CTranslationFactor | Binary factor for a relative translation direction measurement w_aZb |
| CBilinearAngleTranslationFactor | Binary factor for a relative translation direction measurement w_aZb |
| CTranslationRecovery | |
| CUnaryMeasurement | Unary measurement represents a measurement on a single key in a graph |
| CBetweenFactor | A class for a measurement predicted by "between(config[key1],config[key2])" |
| Ctraits< BetweenFactor< VALUE > > | Traits |
| CBetweenConstraint | Binary between constraint - forces between to a given value This constraint requires the underlying type to a Lie type |
| Ctraits< BetweenConstraint< VALUE > > | Traits |
| CFastSyncProjection | Projection customization point used by fastSync() |
| CFastSyncProjection< Rot2 > | Project an ambient 2-by-2 matrix onto Rot2 |
| CFastSyncProjection< Rot3 > | Project an ambient 3-by-3 matrix onto Rot3 |
| CFastSyncProjection< Pose2 > | Project an ambient 3-by-3 homogeneous matrix onto Pose2 |
| CFastSyncProjection< Pose3 > | Project an ambient 4-by-4 homogeneous matrix onto Pose3 |
| CFastSyncProjection< Similarity2 > | Project an ambient 3-by-3 matrix onto Similarity2 |
| CFastSyncProjection< Similarity3 > | Project an ambient 4-by-4 matrix onto Similarity3 |
| CFastSyncProjection< SL4 > | Project an ambient 4-by-4 matrix onto SL4 |
| CFastSync | Solver for the fixed-size ambient linear problem underlying FAST-Sync |
| CFrobeniusPrior | FrobeniusPrior calculates the Frobenius norm between a given matrix and a fixed-size matrix Lie group element |
| CFrobeniusFactor | FrobeniusFactor calculates the Frobenius norm between matrix Lie group elements |
| CFrobeniusBetweenFactorNL | FrobeniusBetweenFactorNL is a BetweenFactor that evaluates the Frobenius norm of the matrix error between measured and predicted (rather than the Logmap of the error) |
| CFrobeniusBetweenFactor | FrobeniusBetweenFactor uses ||T2 - T1*T12_||_F, which only works if the Frobenius error is invariant to multiplying with an arbitrary element T |
| CFrobeniusLeftBetweenFactor | FrobeniusLeftBetweenFactor uses ||iTw - iTj*jTw||_F, where measured iTj maps frame j into frame i |
| CGeneralSFMFactor | Non-linear factor for a constraint derived from a 2D measurement |
| Ctraits< GeneralSFMFactor< CAMERA, LANDMARK > > | |
| CGeneralSFMFactor2 | Non-linear factor for a constraint derived from a 2D measurement |
| Ctraits< GeneralSFMFactor2< CALIBRATION > > | |
| CInitializePose3 | |
| CJacobianFactorQ | JacobianFactor for Schur complement that uses Q noise model |
| Ctraits< JacobianFactorQ< D, ZDim > > | |
| CJacobianFactorQR | JacobianFactor for Schur complement that uses Q noise model |
| CJacobianFactorSVD | JacobianFactor for Schur complement that uses the "Nullspace Trick" by Mourikis et al |
| CKarcherMeanFactor | The KarcherMeanFactor creates a constraint on all SO(n) variables with given keys that the Karcher mean (see above) will stay the same |
| CKnownLandmarkFactor | A unary known-landmark factor using the conventional GTSAM state direction |
| CKnownLandmarkFactor2 | A unary known-landmark factor using a k-from-world state direction |
| COrientedPlane3Factor | Factor to measure a planar landmark from a given pose |
| COrientedPlane3DirectionPrior | |
| CPlanarProjectionFactorBase | Camera projection for robot on the floor |
| CPlanarProjectionFactor1 | One variable: the pose |
| Ctraits< PlanarProjectionFactor1 > | |
| CPlanarProjectionFactor2 | Two unknowns: the pose and the landmark |
| Ctraits< PlanarProjectionFactor2 > | |
| CPlanarProjectionFactor3 | Three unknowns: the pose, the camera offset, and the camera calibration |
| Ctraits< PlanarProjectionFactor3 > | |
| CPoseRotationPrior | |
| CPoseTranslationPrior | A prior on the translation part of a pose |
| CGenericProjectionFactor | Non-linear factor for a constraint derived from a 2D measurement |
| Ctraits< GenericProjectionFactor< POSE, LANDMARK, CALIBRATION > > | Traits |
| CReferenceFrameFactor | A constraint between two landmarks in separate maps Templated on: Point : Type of landmark Transform : Transform variable class |
| Ctraits< ReferenceFrameFactor< T1, T2 > > | Traits |
| CRegularImplicitSchurFactor | RegularImplicitSchurFactor |
| Ctraits< RegularImplicitSchurFactor< CAMERA > > | |
| CRelativeTranslationFactor | |
| CRotateFactor | Factor on unknown rotation iRC that relates two incremental rotations c1Rc2 = iRc' * i1Ri2 * iRc Which we can write (see doc/math.lyx) e^[z] = iRc' * e^[p] * iRc = e^([iRc'*p]) with z and p measured and predicted angular velocities, and hence p = iRc * z |
| CRotateDirectionsFactor | Factor on unknown rotation iRc that relates two directions c Directions provide less constraints than a full rotation |
| CSmartFactorBase | Base class for smart factors |
| CSmartProjectionParams | |
| CSmartProjectionFactor | Smart factor for monocular cameras whose pose and calibration are variables |
| Ctraits< SmartProjectionFactor< CAMERA > > | Testable traits for SmartProjectionFactor |
| CSmartProjectionFactorBase | Common base for monocular smart projection factors |
| Ctraits< SmartProjectionFactorBase< CAMERA > > | Traits |
| CSmartProjectionPoseFactor | If you are using the factor, please cite: L |
| Ctraits< SmartProjectionPoseFactor< CALIBRATION > > | Traits |
| CSmartProjectionRigFactor | If you are using the factor, please cite: L |
| Ctraits< SmartProjectionRigFactor< CAMERA > > | Traits |
| CGenericStereoFactor | A Generic Stereo Factor |
| Ctraits< GenericStereoFactor< T1, T2 > > | Traits |
| CTriangulationFactor | Non-linear factor for a constraint derived from a 2D measurement |
| CWahbaFactor | A chordal Wahba factor relating two directions through an unknown rotation |
| CIndexedJunctionTree | A symbolic junction tree whose factors record the original factor indices from a corresponding (non-symbolic) factor graph |
| CSymbolicBayesNet | A SymbolicBayesNet is a Bayes Net of purely symbolic conditionals |
| Ctraits< SymbolicBayesNet > | Traits |
| CSymbolicBayesTreeClique | A clique in a SymbolicBayesTree |
| CSymbolicBayesTree | A Bayes tree that represents the connectivity between variables but is not associated with any probability functions |
| Ctraits< SymbolicBayesTreeClique > | Traits |
| Ctraits< SymbolicBayesTree > | |
| CSymbolicConditional | SymbolicConditional is a conditional with keys but no probability data, produced by symbolic elimination of SymbolicFactor |
| Ctraits< SymbolicConditional > | Traits |
| CSymbolicEliminationTree | |
| Ctraits< SymbolicEliminationTree > | Traits |
| CSymbolicFactor | SymbolicFactor represents a symbolic factor that specifies graph topology but is not associated with any numerical function |
| Ctraits< SymbolicFactor > | Traits |
| CEliminationTraits< SymbolicFactorGraph > | |
| CSymbolicFactorGraph | Symbolic Factor Graph |
| Ctraits< SymbolicFactorGraph > | Traits |
| CSymbolicISAM | |
| CSymbolicJunctionTree | A EliminatableClusterTree, i.e., a set of variable clusters with factors, arranged in a tree, with the additional property that it represents the clique tree associated with a Bayes net |
| CBTree | Binary tree |
| Cconst_iterator | Const iterator Not trivial: iterator keeps a stack to indicate current path from root_ |
| CDSF | Disjoint Set Forest class |
| CCSP | Constraint Satisfaction Problem class A specialization of a DiscreteFactorGraph |
| Ctraits< abc::State< N > > | |
| Ctraits< const abc::State< N > > | |
| CInvDepthCamera3 | A pinhole camera class that has a Pose3 and a Calibration |
| CPose3Upright | A 3D Pose with fixed pitch and roll |
| Ctraits< Pose3Upright > | |
| CSimPolygon2D | General polygon class for convex polygons |
| CSimWall2D | General Wall class for walls defined around unordered endpoints Primarily to handle ray intersections |
| Ctraits< SimWall2D > | Traits |
| CConcurrentBatchFilter | A Levenberg-Marquardt Batch Filter that implements the Concurrent Filtering and Smoother interface |
| CResult | Meta information returned about the update |
| Ctraits< ConcurrentBatchFilter > | Traits |
| CConcurrentBatchSmoother | A Levenberg-Marquardt Batch Smoother that implements the Concurrent Filtering and Smoother interface |
| CResult | Meta information returned about the update |
| Ctraits< ConcurrentBatchSmoother > | Traits |
| CConcurrentFilter | The interface for the 'Filter' portion of the Concurrent Filtering and Smoother architecture |
| CConcurrentSmoother | The interface for the 'Smoother' portion of the Concurrent Filtering and Smoother architecture |
| CConcurrentIncrementalFilter | An iSAM2-based Batch Filter that implements the Concurrent Filtering and Smoother interface |
| CResult | Meta information returned about the update |
| Ctraits< ConcurrentIncrementalFilter > | Traits |
| CConcurrentIncrementalSmoother | A Levenberg-Marquardt Batch Smoother that implements the Concurrent Filtering and Smoother interface |
| CResult | Meta information returned about the update |
| Ctraits< ConcurrentIncrementalSmoother > | Traits |
| CNonlinearClusterTree | |
| CNonlinearCluster | |
| CBetweenFactorEM | A class for a measurement predicted by "between(config[key1],config[key2])" |
| Ctraits< BetweenFactorEM< VALUE > > | Traits |
| CBiasedGPSFactor | A class to model GPS measurements, including a bias term which models common-mode errors and that can be partially corrected if other sensors are used |
| CGaussMarkov1stOrderFactor | |
| Ctraits< GaussMarkov1stOrderFactor< VALUE > > | Traits |
| CInvDepthFactor3 | Ternary factor representing a visual measurement that includes inverse depth |
| CInvDepthFactorVariant1 | Binary factor representing a visual measurement using an inverse-depth parameterization |
| CInvDepthFactorVariant2 | Binary factor representing a visual measurement using an inverse-depth parameterization |
| CInvDepthFactorVariant3a | Binary factor representing the first visual measurement using an inverse-depth parameterization |
| CInvDepthFactorVariant3b | Ternary factor representing a visual measurement using an inverse-depth parameterization |
| CLocalOrientedPlane3Factor | Factor to measure a planar landmark from a given pose, with a given local linearization point |
| CMultiProjectionFactor | Non-linear factor for a constraint derived from a 2D measurement |
| CPoseBetweenFactor | A class for a measurement predicted by "between(config[key1],config[key2])" |
| CPosePriorFactor | A class for a soft prior on any Value type |
| CPoseToPointFactor | A class for a measurement between a pose and a point |
| CProjectionFactorPPP | Non-linear factor for a constraint derived from a 2D measurement |
| Ctraits< ProjectionFactorPPP< POSE, LANDMARK, CALIBRATION > > | Traits |
| CProjectionFactorPPPC | Non-linear factor for a constraint derived from a 2D measurement |
| Ctraits< ProjectionFactorPPPC< POSE, LANDMARK, CALIBRATION > > | Traits |
| CProjectionFactorRollingShutter | Non-linear factor for 2D projection measurement obtained using a rolling shutter camera |
| Ctraits< ProjectionFactorRollingShutter > | Traits |
| CRelativeElevationFactor | Binary factor for a relative elevation |
| CSmartProjectionPoseFactorRollingShutter | If you are using the factor, please cite: L |
| Ctraits< SmartProjectionPoseFactorRollingShutter< CAMERA > > | Traits |
| CSmartRangeFactor | Smart factor for range SLAM |
| CCircle2 | |
| CSmartStereoProjectionFactor | SmartStereoProjectionFactor: triangulates point and keeps an estimate of it around |
| Ctraits< SmartStereoProjectionFactor > | Traits |
| CSmartStereoProjectionFactorPP | If you are using the factor, please cite: L |
| Ctraits< SmartStereoProjectionFactorPP > | Traits |
| CSmartStereoProjectionPoseFactor | If you are using the factor, please cite: L |
| Ctraits< SmartStereoProjectionPoseFactor > | Traits |
| CTOAFactor | A "Time of Arrival" factor - so little code seems hardly worth it :-) |
| CTransformBtwRobotsUnaryFactor | A class for a measurement predicted by "between(config[key1],config[key2])" |
| Ctraits< TransformBtwRobotsUnaryFactor< VALUE > > | Traits |
| CTransformBtwRobotsUnaryFactorEM | A class for a measurement predicted by "between(config[key1],config[key2])" |
| Ctraits< TransformBtwRobotsUnaryFactorEM< VALUE > > | Traits |
| CDeltaFactor | DeltaFactor: relative 2D measurement between Pose2 and Point2 |
| CDeltaFactorBase | DeltaFactorBase: relative 2D measurement between Pose2 and Point2, with Basenodes |
| COdometryFactorBase | OdometryFactorBase: Pose2 odometry, with Basenodes |
| Cvector | STL class |
| Citerator | STL iterator class |
| Cconst_iterator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| CDiagonal | A diagonal noise model implements a diagonal covariance matrix, with the elements of the diagonal specified in a Vector |
| CGaussian | Gaussian implements the mathematical model |R*x|^2 = |y|^2 with R'*R=inv(Sigma) where y = whiten(x) = R*x x = unwhiten(x) = inv(R)*y as indeed |y|^2 = y'*y = x'*R'*R*x Various derived classes are available that are more efficient |
| CIsotropic | An isotropic noise model corresponds to a scaled diagonal covariance To construct, use one of the static methods |
| CConstrained | A Constrained constrained model is a specialization of Diagonal which allows some or all of the sigmas to be zero, forcing the error to be zero there |
| Nstd | STL namespace |
| Chash< gtsam::StateData > | |
| CDiscreteValues | The Factor::error simply extracts the |
| CGaussianConditional | Normalization constant |
| CHybridValues | Error |
| CJacobianFactor | In Gaussian factors, the error function returns either the negative log-likelihood, e.g., 0.5*(A*x-b)'D(A*x-b) for a negative log-density, e.g., 0.5*(A*x-b)'D(A*x-b) - log(k) for a |
| Cmap | STL class |
| Citerator | STL iterator class |
| Cconst_iterator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| CNoiseModelFactor | Noise model to the factor, and calculates the error by asking the user to implement the method |
| COnly | Symbolic elimination etc |
| Costream | STL class |
| Cpair | STL class |
| CRing | The Real ring with addition and multiplication |
| Cstring | STL class |
| Citerator | STL iterator class |
| Cconst_iterator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| Cstringstream | STL class |
| Cunordered_map | STL class |
| Citerator | STL iterator class |
| Cconst_iterator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| Cunordered_set | STL class |
| Citerator | STL iterator class |
| Cconst_iterator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| CValues | In nonlinear factors, the error function returns the negative log-likelihood as a non-linear function of the values in a |
| Cvector | STL class |
| Citerator | STL iterator class |
| Cconst_iterator | STL iterator class |
| Creverse_iterator | STL iterator class |
| Cconst_reverse_iterator | STL iterator class |
| CVectorValues | The Factor::error simply extracts the |
1.16.1