CMath3D::AABB2D | A 2D axis-aligned bounding box |
CMath3D::AABB3D | A 3D axis-aligned bounding box |
CMath3D::AABBTemplate< T > | |
CGeometry::ClosestPointCallback::ActivePair | |
CMeshing::AddTriOffset | |
CAnalyticalIKSolver | Hook for an analytic inverse kinematics solver. The Solve method must be defined by the subclass |
CAnalyticIKMap | |
CAnalyticIKSolution | A structure containing computed analytic IK solutions |
CMath3D::AngleAxisRotation | Angle-axis 3D rotation parameterization |
CMath::AngleInterval | A contiguous range of angles |
CGeometry::Angular2DOrdering | |
CAnyCollection | A flexible hierarchical collection of AnyValues, which can be easily initialized to contain primitive values, arrays, or maps. Arrays and maps can be nested as well |
CGeometry::AnyCollisionQuery | A class that stores information regarding a collision query. May be slightly faster than running individual queries |
►CAnyData | A helper class that points to any kind of data |
CDataDatabase::Entry | |
►CGeometry::AnyGeometry3D | A class that stores any kind of geometry we've defined |
CGeometry::AnyCollisionGeometry3D | An AnyGeometry with collision detection information |
CAnyKeyable | Any primitive value (bool, char, unsigned char, int, unsigned int, float, double, string) that we know how to make into a hashable object |
CAnyValue | A polymorphic container class that can contain data of any type |
CMeshing::ApproximateGeodesic | Computes an approximate geodesic distance over a mesh, from a single source |
CGeometry::ApproximatePenetrationDepth | Uses a propagation method to calculate an approximate penetration distance of mesh m1 inside m2 |
CGraph::ApproximateShortestPathProblem< Node, Edge > | Approximate single-source shortest paths, whose output is at most (1+epsilon)^d times the true shortest path, where d is the depth of the node. This can be somewhat faster than running true shortest paths |
CGeometry::Arrangement1D | An arrangement of 1-D intervals. Intervals identified by an integer ID |
CArray2D< T > | A two-dimensional m x n array |
CArray2D< bool > | |
CArray2D< Data > | |
CArray2D< Geometry::AnyCollisionQuery * > | |
CArray2D< iterator > | |
CArray2D< Real > | |
CArray2D< Vector2 > | |
CArray2D< Vector3 > | |
CArray3D< T > | A three-dimensional m x n x parray |
CArray3D< Real > | |
CArrayMapping | An invertible mapping from indices in [0,imax), which operates in two modes: offset mode adds an offset, and mapping mode stores an explicit mapping |
CArrayND< T > | |
CArrayND< int > | |
CArrayND< Real > | |
CArrayNDRef< T > | |
►CAsyncPipeQueue | Asynchronous reader/writer with queues |
►CAsyncPipeThread | An asynchronous read/writer that uses multithreading. Subclass will define the transport protocol by setting the transport member (usually blocking I/O) |
CSocketPipeWorker | Launches a thread for asynchronous bidirectional communication with a socket |
CSyncPipe | An synchronous reader/writer. User/subclass will initialize the transport protocol (usually blocking I/O) by setting the transport member |
►CAsyncReaderQueue | Asynchronous reader with queue |
►CAsyncReaderThread | An asynchronous reader that uses multithreading. User/subclass will initialize the transport protocol (usually blocking I/O) by setting the transport member |
CSocketReadWorker | Launches a thread for asynchronous reading from a socket |
CAsyncWriterQueue | Asynchronous writer with queue |
►CAxisSweptPoint | Parameterizes a circle in space by sweeping a point around a line |
CArc3D | An arc segment of a circle in space |
CMeshing::BarycentricCoords | |
►CBaseGUI | |
CGLDraw::GLScreenshotProgram< BaseGUI > | A plugin class that "automatically" saves a movie to disk in the form of PPM screenshots |
COptimization::BCMinimizationProblem | A bound-constrained MinimizationProblem. Uses an active-set method to determine the components of the free search direction at x |
CStatistics::BernoulliMAPModel | |
CBidirectionalRRTKP | A bidirectional RRT planner for kinodynamic systems |
CMath::BLASInterface | An interface to BLAS. Activated with the preprocessor flag HAVE_BLAS=1 |
CMath::BlockPrinter | |
CMath::BlockTridiagonalMatrix | |
COptimization::BoundedLSQRSolver | Solve the bounded least-squares problem min||Ax-b||^2 s.t. l <= x <= b accepts infinite constraints too |
CGeometry::BoxCmp< Box > | |
CGeometry::BoxTraits< Box > | |
CBidirectionalRRTKP::Bridge | |
CSpline::BSpline | |
CSpline::BSplineBasis | Defines the B-spline basis for a given knot vector, number of control points |
►CGraph::CallbackBase< Node > | A template base class for a graph traversal |
CAddPointCallback | |
CChangeTreeCallback | |
CClosestMilestoneCallback | |
CClosestMilestoneCallback | |
CClosestMilestoneCallback | |
CGraph::CountCallback< Node > | Count the number of nodes traversed |
CGraph::CycleCallback< Node > | Compute if the graph has a cycle |
CGraph::FindCallback< Node > | Find a particular node |
CGraph::PathCallback< Node > | |
CGraph::TimeCallback< Node > | Get the start/finish time of a traversal |
CGraph::TopologicalSortCallback< Node > | Perform topological sort, when used with DFS |
CGraph::TraversalGraphCallback< Node > | Compute the traversal graph of a traversal |
CPickCallback | |
CPickCallback | |
CRemoveTreeCallback | |
CSetComponentCallback | |
CVectorizeCallback | |
►CGraph::CallbackBase< int > | |
CGraph::ComponentIntCallback | |
CGraph::DepthIntCallback | Get the depth of all nodes (in an indexed graph, such as Graph) |
►CGraph::PathIntCallback | Same as above, but for indexed graphs |
CConnectedSeedCallback | |
CCoverageLimitedPathCallback | |
CCoverageLimitedPathCallback | |
CGraph::ShortestPathsIntCallback | |
CGraph::TimeIntCallback | Same as above, but for indexed graphs |
CGraph::TraversalGraphIntCallback | Same as above, but for indexed graphs |
►CCamera::Camera | |
CCamera::Viewport | |
CCamera::CameraController_Free | |
CCamera::CameraController_Orbit | |
CCamera::CameraController_Target | |
CStatistics::CategoricalMAPModel | |
CGeometry::FixedResolutionPointCloud::Cell | |
►CChain | A tree-based chain structure |
CKinematicChain2DTemplate< Link > | |
►CKinematicChain2DTemplate< DynamicLink2D > | |
CDynamicChain2D | |
CKinematicChain3DTemplate< Link > | |
►CKinematicChain3DTemplate< DynamicLink3D > | |
CDynamicChain3D | |
►CRobotKinematics3D | Class defining kinematics of a robot, and commonly used functions |
►CRobotDynamics3D | Class defining kinematic and dynamic state of a robot, with commonly used functions. Inherits from RobotKinematics3D |
CRobotWithGeometry | The base class for a robot definition |
CMath::CholeskyDecomposition< T > | Performs the Cholesky decomposition |
CMath3D::Circle2D | A 2D circle class |
CMath3D::Circle3D | A 2D circle in 3D space class |
CGeometry::ClosestPointCallback | |
CStatistics::HierarchicalClustering::Cmp | |
Cstd::cmp_func< T, Less > | A templated function class like strcmp: returns -1 if a<b, 0 if a==b, 1 if a>b |
CGraph::CoEdgeIterator< Data > | |
►CGeometry::CollisionMeshQuery | A general-purpose distance querying class |
CGeometry::CollisionMeshQueryEnhanced | |
CGLDraw::ColorGradient | |
CCombination | A class that enumerates combinations |
CCommandLine::CommandArg | |
►CCommandLine::CommandBase | |
►CCommandLine::CommandAuto | |
CCommandLine::CommandInputValue< T > | |
CCommandLine::CommandSetValue< T > | |
CCommandLine::CommandHelp | |
CMath::Complex | Complex number class (x + iy) |
►CCompositeVectorFieldFunction | |
CRobotIKFunction | A vector field function class defining C(q)=0 for IK |
CCondition | |
►CConditioner_SymmDiag | |
CHConditioner | |
CHConditioner | |
CGraph::ConnectedComponents | |
CConstMappedAccessor< T, Key > | A helper class that allows a const vector to be accessed by either indexes or some other keys, given a map from keys to indexes |
COptimization::ConstrainedMinimizationProblem | Same as MinimizationProblem but with nonlinear constraints C(x)=0 and D(x)<=0, bound constraints bmin/bmax |
CContactFormation | A robot-environment contact formation. The list of contacts contacts[i] is associated with links[i] (pointing from the opposing body into the robot). Usually the opposing body is the environment, but if targets is non-empty, it gives the index of the body for which contact is made |
CContactPoint | A single contact point, i.e. a position, normal, and friction coefficient |
CContactPoint2D | A 2D contact point, i.e. a position, normal, and friction coefficient |
CContextStack | A helper for maintaining and printing context |
CMath::PiecewiseLinearFunction::ControlPoint | |
CMath::PiecewiseLinearPath::ControlPoint | |
CMath3D::ConvexPolyhedron3D | A convex polyhedron given in a dual representation, planes and vertices of convex hull |
►CConvexVolume | |
CCamera::Frustum | |
CCrossEntropyPlanner | |
►CCSpace | Motion planning configuration space base class |
►CCVSpace | A C-space on configurations and velocities (q,v) that linear uses linear interpolation on velocities |
CHermiteCSpace | A C-space on configurations and velocities (q,v) that uses Hermite interpolation to construct continuously differentiable curves |
►CExplicitCSpace | Configuration space that exposes N obstacle checks. This functionality can be used in a motion planner to speed up planning by delaying certain expensive obstacle checks, or to provide reasons for infeasibility |
CGeometric2DCSpace | 2D cspace whose obstacles are geometric primitives |
CModularCSpace | An ExplicitCSpace that holds a list of obstacles |
CObstacleDisplacementCSpace | A class that needs to be subclassed in order to implement a minimum constraint displacement problem |
CPerturbationCSpace | |
CRigidRobot2DCSpace | Translating and rotating 2D robot in a 2D workspace |
CRigidRobot3DCSpace | Translating and rotating 3D robot in a 3D workspace |
CSubgroupExplicitCSpace | Groups together multiple obstacles from an ExplicitCSpace into a smaller number of obstacles |
CSubsetExplicitCSpace | Extracts a subset of obstacles from an ExplicitCSpace |
CTranslatingRobot2DCSpace | Translating 2D robot in a 2D workspace |
CGrid2DCSpace | |
►CKinodynamicCSpace | A CSpace used for kinodynamic planning |
CIntegratedKinodynamicCSpace | Implements a simulation function by integrating forward dynamics |
CKinematicCSpaceAdaptor | Adapts a kinematic cspace (given in the constructor) to a kinodynamic one |
CSpaceTimeCSpace | A kinodynamic space that sets x=(t,q), u=(dt,u0) with dt > 0. Based on an existing kinodynamic cspace, provided upon input |
CTimeCSpace | |
CMultiRobot2DCSpace | One or more 2D robots translating and/or rotating in a 2D workspace |
►CPiggybackCSpace | A helper class that assists with selective overriding of another cspace's methods |
CNeighborhoodCSpace | A helper class that defines a feasible set around the 'radius' neighborhood of 'center'. Often used for endgame regions |
CVisibilityCSpace | A helper class that defines a feasible set as the visible set of a given set of points |
CSingleObstacleCSpace | Converges an ExplicitCSpace to a regular CSpace based on one selected obstacle |
CCSpaceAnalysis | |
CCSVTable | A table read from a CSV file |
CMath3D::Cylinder3D | A 3D cylinder |
CStatDatabase::Data | |
CGeometry::OctreeScalarField::Data | |
CDataDatabase | A heirarchical database of arbitrary values |
CStatistics::DataSet | |
CDDimensionCmp | |
►CDiffEq2Function | |
CSimFunction< Robot, NVector > | |
►CMath::DiffEqFunction | |
CIntegrationFunction | |
CMath::DiffEq2Function | |
CDisplacementPlanner | A planner that minimizes the the displacement cost of violated constraints using a RRT-like strategy |
CStatistics::HierarchicalClustering::distances | |
CStatistics::DistributionCollector | Incrementally collects samples from a univariate distribution |
CStatistics::DistributionCollectorND | Incrementally collects samples from a multivariate distribution |
CDisplacementPlanner::DynamicShortestPathNode | |
CDynamicStructureDelta | A change to a DynamicStructure |
►CDynamicStructureView | The partner class for DynamicStructure that allows accessing members via [key] syntax and setting values using the = operator |
CDynamicStructure | A loggable structure that changes over time. Useful for monitoring / storing system state |
►CDynamicStructureWatcherBase | A base class that captures changes to a DynamicStructure |
CDynamicStructureAutoCopy | A watcher that automatically copies changes from one path to another |
CDynamicStructureLogger | A watcher that logs all changes to disk |
CDynamicTrajectory | |
CDynamicValue< T > | Convenience class for accessing primitive members of DynamicStructures. Can treat like an object of type T (references are not allowed) |
CMCRPlanner::Edge | |
CMCRPlannerGoalSet::Edge | |
CDisplacementPlanner::Edge | |
CEdgeCollision | |
CKinodynamicTree::EdgeData | |
CEdgeDistance | |
CSBLTree::EdgeInfo | |
CGraph::EdgeIterator< Data > | |
CEdgeLengthFunction | |
►CEdgePlanner | Abstract base class for an edge planner |
CBisectionEpsilonEdgePlanner | |
►CExplicitEdgePlanner | Default edge planner: checks each constraint sequentially using the space's LocalPlanner(a,b,i) method |
CBisectionEpsilonExplicitEdgePlanner | |
CGeometric2DEdgePlanner | |
CFalseEdgePlanner | Edge planner that is never visible |
CGivenPathEdgePlanner | An edge planner that connects two feasible milestones with a specified path |
►CPiggybackEdgePlanner | |
CEdgePlannerWithCSpaceContainer | Convenience class for edge planner that holds a smart pointer to a CSpace. Typically used for single-obstacle edge checkers as follows: |
CStraightLineEpsilonPlanner | Straight-line edge planner that divides the segment until epsilon is reached |
CStraightLineObstacleDistancePlanner | Straight-line edge planner that divides the segment until the segment distance is below CSpace.ObstacleDistance() |
CTrueEdgePlanner | Edge planner that always is visible |
CMath::EquationTerm | |
CEquilibriumTester | Testing COM equilibrium given some number of contacts |
CEZCallTrace | Helper class that eases function call tracing |
CEZTrace | A Trace that dumps on destruction. Only one may be active at any time |
CFace | |
CFastFindHeap< type, ptype > | Implements a heap that stores objects of type type, with priority keys of type ptype |
CFastSampler | Samples from a weighted discrete set in O(log(n)) time after an O(n) initialization |
CFile | A cross-platform class for reading/writing binary data |
CGeometry::FixedResolutionPointCloud | |
CFixedSizeHeap< ptype > | A heap of fixed maximum size N. Each element is indexed by an integer 0...N-1. The priority key of each element is of type ptype |
CFixedSizeHeap< Real > | |
CFMMMotionPlanner | |
CFrictionConePolygon | Polygonal pyramid representation of the friction cone |
CMath::Gaussian< T > | Multivariate gaussian N(mu,K) of d dimensions |
CMath::Gaussian< Real > | |
CStatistics::GaussianHMM | A model of a temporal sequence consisting of k discrete states each with a gaussian emission probability |
CStatistics::GaussianHMMRegression | |
CStatistics::GaussianMixtureModel | A model of a probability distribution consisting of k gaussians |
CStatistics::GaussianMixtureModelRaw | A more ``raw'' model of a GMM that does not perform a cholesky decomposiition |
CStatistics::GaussianMixtureRegression | |
CStatistics::GaussianRegression | |
►CAI::GeneralizedAStar< S, C > | |
CAI::GeneralizedAStarWithHashMap< S, C > | |
CAI::GeneralizedAStarWithMap< S, C > | |
►CAI::GeneralizedAStar< int, double > | |
CFMTAStar | |
►CAI::GeneralizedAStar< int, SubsetCost > | |
CGreedySubsetAStar | |
CGreedySubsetAStar2 | |
►CAI::GeneralizedAStar< pair< int, Subset >, SubsetCost > | |
COptimalSubsetAStar | |
COptimalSubsetAStar2 | |
►CAI::GeneralizedAStar< S, double > | |
CAI::AStar< S > | |
►CAI::GeneralizedAStar< S, int > | |
CAI::IntegerAStar< S > | |
CGeneralizedCubicBezierCurve | A generalized Bezier curve that uses the CSpace's Interpolate routine to generate the smooth interpolation |
CGeneralizedCubicBezierSpline | A Bezier spline with segment durations |
►CGeodesicManifold | Extra information for a CSpace about manifold derivatives |
CCVGeodesicManifold | |
CHermiteGeodesicManifold | |
►CGeometric2DCollection | |
CGeometric2DCSpace | 2D cspace whose obstacles are geometric primitives |
CGeometric3DCollection | |
CMath3D::GeometricPrimitive2D | |
CMath3D::GeometricPrimitive3D | A generic geometric primitive class |
CGLDraw::GeometryAppearance | |
CGLDraw::GLColor | An rgba color |
CGLDraw::GLDisplayList | |
CGLDraw::GLFog | |
CGLDraw::GLLight | An OpenGL light |
CGLDraw::GLMaterial | An OpenGL material |
COptimization::GLPKInterface | An interface to the GLPK linear program solver. Activated with the HAVE_GLPK preprocessor define |
CGLDraw::GLTexture1D | 1D texture data for use in OpenGL |
CGLDraw::GLTexture2D | 2D texture data for use in OpenGL |
CGLDraw::GLTextureObject | A GL texture object class. Simplifies allocating and cleaning up texture objects. Usually you only need to interact with GLTexture[X]D and the texture management is handled for you |
►CGLUIProgramBase | |
CGLUINavigationProgram | A 3D navigation program based on GLUI |
►CGLUTProgramBase | |
CGLUTNavigationProgram | A 3D navigation program based on GLUT |
CGLDraw::GLView | |
CGraph::Graph< NodeData, EdgeData > | Basic template graph structure |
►CGraph::Graph< Config, SmartPointer< EdgePlanner > > | |
CGraph::UndirectedGraph< Config, SmartPointer< EdgePlanner > > | |
►CGraph::Graph< CSpace *, CSpace * > | |
CGraph::UndirectedGraph< CSpace *, CSpace * > | |
CGraph::Graph< Graph::TreeNode, EdgePlanner > | |
►CGraph::Graph< int, MultiModalPRM::TransitionInfo * > | |
CGraph::UndirectedGraph< int, MultiModalPRM::TransitionInfo * > | |
►CGraph::Graph< Milestone, Edge > | |
CGraph::UndirectedGraph< Milestone, Edge > | |
►CGraph::Graph< Mode, Transition > | |
CGraph::UndirectedGraph< Mode, Transition > | |
►CGraph::Graph< ModeInfo, TransitionInfo > | |
CGraph::UndirectedGraph< ModeInfo, TransitionInfo > | |
►CGraph::Graph< Node, Edge > | |
CGraph::DirectedGraph | A specialization of a Graph to be directed graph |
CGraph::UndirectedGraph< Node, Edge > | A specialization of a Graph to be an undirected graph |
CGraph::Graph< PRTPlanner::Tree, PRTPlanner::TreeEdge > | |
►CGraph::Graph< SBLTree *, MilestonePath > | |
CGraph::UndirectedGraph< SBLTree *, MilestonePath > | |
►CGraph::Graph< VisibilityGraphPlanner::Vertex, SmartPointer< EdgePlanner > > | |
CGraph::UndirectedGraph< VisibilityGraphPlanner::Vertex, SmartPointer< EdgePlanner > > | |
CGeometry::Grid | A gridding of n-dimensional space |
CGrid2Indices | A 2D lattice of irregular ranges |
CGeometry::GridHash | A grid containing objects (referenced by void pointers) |
CGeometry::GridSubdivision | A grid with a list of arbitrary objects (given by void pointers) |
CGeometry::GridTable< T > | A table with entry T on a gridding of n-dimensional space |
CHalfEdge | |
CHaltingCondition | A termination condition for a planner. Supports max iteration count, time limit, absolute cost, and cost improvement conditions |
CHeap< type, ptype > | Implements a heap that stores objects of type type, with priority keys of type ptype |
CStatistics::HierarchicalClustering | |
CGeometry::HiGreater< Box > | |
CStatistics::Histogram | 1-D histogram class |
CStatistics::Histogram2D | 2-D histogram class |
CStatistics::Histogram3D | 3-D histogram class |
CStatistics::HistogramND | N-D histogram class |
CHollowBall | A 3-D annulus innerRadius <= |x-center| <= outerRadius |
CIKGoal | A structure defining a link's desired configuration for IK |
►CImage | |
CImageMipmapped | |
CImageOperator | |
CIncrementalMMPRM_Explicit | |
CIncrementalMMPRM_Search | |
CMath::IndexAndPriority | |
Cstd::IndexedPriorityQueue< IT, PT > | Contains a priority queue with an associated index, allowing updates of the priority value. Priority defined with lowest value first |
Cstd::IndexedPriorityQueue< int, double > | |
CStatistics::IndexHash | |
CGeometry::IndexHash | |
CIndexSet | A generic set of indices, either listed explicitly or in a range. If imax < imin, this indicates that the indices should be used instead |
CGeometry::SegmentOverlay::IntersectionInfo | |
►CMath::Interval | A generic interval {a,b}, where { and } can be either (,[ or ),] |
CMath::ClosedInterval | A closed interval [a,b] |
CMath::OpenInterval | An open interval (a,b) |
CStatistics::IntervalMap< Data > | Division of the real numbers into interval sets. Each interval is assigned data of type Data |
CStatistics::IntervalMap2D< Data > | |
CIntPair | A lightweight integer 2-tuple class |
CIntTriple | A lightweight integer 3-tuple class |
CIntTuple | An integer tuple class |
CMath::IterativeMethod | |
CArray2D< T >::iterator | |
CArray3D< T >::iterator | |
CArrayND< T >::iterator | |
CRedBlack::Tree< T, Cmp >::iterator | |
CRangeIndices::iterator | |
►CRange2Indices::iterator | |
CGrid2Indices::iterator | |
CRange3Indices::iterator | |
CStripe2Indices::iterator | |
CStripe3Indices::iterator | |
►CIterT | |
CMapIterator< T, IterT, MapT > | |
CMath::JacobiPreconditioner< Matrix > | Jacobi preconditioning (inverse of diagonal) |
CJointStructure | Calculates workspace bounds for a robot with constrained links |
CGeometry::KDTree | A node of a kd-tree |
CKeyBezierCubic< Point > | |
CKeyCardinal< Point > | |
CKeyHermite< Point > | |
CKeyTCB< Point > | |
►CKinematicLink2D | |
CDynamicLink2D | |
►CKinematicLink3D | |
CDynamicLink3D | |
CKinodynamicMilestonePath | Stores a kinodynamic path with piecewise constant controls |
CKinodynamicTree | Data structure for a kinodynamic planning tree |
CStatistics::KMeans | A simple clustering method to choose k clusters from a set of data |
CMath::LAPACKInterface | An interface to LAPACK. Activated with the preprocessor flag HAVE_CLAPACK=1 |
CLazyLoader< T > | A utility that allows objects from files to be loaded from and saved to disk on demand |
CMath::LDLDecomposition< T > | Performs the LDL^t decompositoin of a symmetric matrix A |
CMath::LDLDecomposition< Real > | |
COptimization::LeastSquares | A least-squares problem definition |
CStatistics::LeastSquares1D | 1-D least squares y = ax+b |
CGeometry::Arrangement1D::LeftInterval | |
CLeftPointLess | |
COptimization::LemkeLCP | Solves a linear complementarity problem |
CLessEdgePriority | |
CMath3D::Line2D | A 2D line class |
►CMath3D::Line3D | A 3D line class |
CMath3D::Ray3D | |
►COptimization::LinearConstraints | Linear constraints for LP's and QP'sRepresents the constraints |
►COptimization::LinearProgram | Linear program definition.Represents the LP min/max c.x subject to
qi <= ai.x <= pi
lj <= xj <= uj |
COptimization::LP_InteriorPointSolver | An interior-point method for solving a LP |
COptimization::MinNormProblem | Solves a linearly constrained minimum-norm problem |
COptimization::QuadraticProgram | Quadratic program definition |
COptimization::RegularizedLinearProgram | Solves a linear program with regularization |
►COptimization::LinearConstraints_Sparse | Sparse linear constraints for LP's and QP'sUnlike dense constraints, AddVariable/AddConstraint are relatively efficient |
COptimization::LinearProgram_Sparse | Linear program definition with sparse matrix A |
COptimization::MinNormProblem_Sparse | Solves a sparse, linearly constrained minimum-norm problem |
CStatistics::LinearModel | A linear model of n-dimensional data |
CStatistics::LinearProcess | |
CStatistics::LinearProcessHMM | A model of a temporal sequence consisting of k discrete states each with a gaussian emission probability depending on the prior continuous state |
CStatistics::LinearProcessHMMRegression | |
CStatistics::LinearProcessHMMState | |
►CMath3D::LocalCoordinates2D | |
►CMath3D::ScaledLocalCoordinates2D | |
CMath3D::Box2D | A 2D boxThe box is the unit square [0,1]^2 set in the scaled local coordinate system. That is, one corner is at the origin, and it has dimensions [dims.x,dims.y] in the coordinates given by {xbasis,ybasis} |
►CMath3D::LocalCoordinates3D | |
►CMath3D::ScaledLocalCoordinates3D | |
CMath3D::Box3D | A 3D boxThe box is the unit cube [0,1]^3 set in the scaled local coordinate system. That is, one corner is at the origin, and it has dimensions [dims.x,dims.y,dims.z] in the coordinates given by {xbasis,ybasis,zbasis} |
CMath3D::Ellipsoid3D | A 3D ellipsoidThe ellipsoid is the centered unit sphere [-1,1]^3 set in the scaled local coordinate system. That is, the center is at the origin, and its major axes are {xbasis,ybasis,zbasis} with radii {dims.x,dims.y,dims.z} |
CStatistics::LogisticModel | Models the probability of a boolean outcome using a logit |
CGeometry::LoLess< Box > | |
COptimization::LP_InteriorPoint | Solves a general LP using LP_InteriorPointSolver |
CGeometry::LPSolvePointCallback | Helper callback used in PolytopeProjection2D |
CMeshing::LSConformalMapping | An approximately-conformal parameterization a genus-0 mesh, found by a least-squares method |
►Clsqr_func | |
CSparseMatrixMultiplier | |
Clsqr_input | |
Clsqr_output | |
Clsqr_work | |
COptimization::LSQRInterface | An interface to a sparse least-squares solver (lsqr) |
CMath::LUDecomposition< T > | Forms the LU decomposition A=PLU |
►Cmap | |
CPropertyMap | A simple map from keys to values |
CMappedAccessor< T, Key > | A helper class that allows a vector to be accessed by either indexes or some other keys, given a map from keys to indexes |
►CMatrix | |
CDirtyData< Matrix > | |
CMath3D::Matrix2 | A 2x2 matrix class |
CMath3D::Matrix3 | A 3x3 matrix class |
►CMatrix3 | |
CDirtyData< Matrix3 > | |
CMath3D::Matrix4 | A 4x4 matrix class |
►CMath::MatrixEquation | |
CMath::Conditioner_SymmDiag | A matrix conditioner that does a pre/postmultiply with a diagonal S |
CMath::MatrixEquationPrinter | |
CMath::MatrixIterator< T > | An iterator through MatrixTemplate elements |
CMath::MatrixPrinter | |
CMath::MatrixTemplate< T > | A matrix over the field T |
►CMath::MatrixTemplate< Real > | |
CSpatialMatrix | |
CMCRPlanner | A planner that minimizes the the number of violated constraints using a RRT-like strategy |
CMCRPlannerGoalSet | A planner that minimizes the the number of violated constraints using a RRT-like strategy |
CMCRPlanner::Milestone | |
CMCRPlannerGoalSet::Milestone | |
CTreeRoadmapPlanner::Milestone | |
CDisplacementPlanner::Milestone | |
CMilestonePath | A sequence of locally planned paths between milestones |
COptimization::MinimizationProblem | An iterative solution to minimize f over multidimensional x. May only find a local minimum, depending on the initial point |
CMCRPlanner::Mode | |
CMCRPlannerGoalSet::Mode | |
CMultiModalPRM::ModeInfo | |
CSpline::MonotonicSpline | A b-spline based monotonic spline |
CMotionPlannerFactory | A motion planner creator |
►CMotionPlannerInterface | An abstract class for a sample-based motion planner |
CBiRRTInterface | |
CFMMInterface | |
►CPiggybackMotionPlanner | Helper class for higher-order planners – passes all calls to another motion planner |
CPointToSetMotionPlanner | Tries to produce a path between a start node and a goal space. Does so via goal sampling |
►CRestartMotionPlanner | A multiple-restart motion planner that turns a feasible motion planner into an anytime optimal motion planner by keeping the best path found so far |
CRestartShortcutMotionPlanner | A multiple-restart motion planner that turns a feasible motion planner into an anytime optimal motion planner by keeping the best path found so far and shortcutting the best path |
CShortcutMotionPlanner | Plans a path and then tries to shortcut it with the remaining time |
CPRMStarInterface | |
CRoadmapPlannerInterface | |
CRRTInterface | |
CSBLInterface | |
CSBLPRTInterface | |
CMotionPlanningProblem | A structure to specify the space, endpoints, and cost function of a motion planning problem |
CMultiModalCSpace< Mode > | Multi-modal configuration space base class |
►CMultiModalCSpace< int > | |
CExplicitMMCSpace | |
CMultiModalPRM | |
►CStatistics::MultivariateProbabilityDistribution | |
CStatistics::BoxProbabilityDistribution | |
CStatistics::DiracMultivariateDistribution | |
CStatistics::GaussianMultivariateDistribution | |
CMutex | |
Cmyarray< type > | |
Cmyhashtable< type > | |
►Cmylist< type > | |
Cmyindexedlist< type > | |
►Cmyqueue< type > | |
Cmypriorityqueue< type > | |
CNewtonEulerSolver | The Featherstone algorithm for O(n) computation of either joint torques from accelerations, or accelerations from torques |
►COptimization::NewtonRoot | A globally convergent Newton's method for multidimensional root solving. Solves for func(x)=0 |
COptimization::ConstrainedNewtonRoot | A globally convergent Newton's method with inequality constraints c(x) >= 0 |
COptimization::LSQRNewtonRoot | Solves the problem min ||x-xc||^2 s.t. f(x)=0 for some center point xc |
COptimization::NewtonSolver | A newton's-method style solver for a NLP |
CRedBlack::Node< T > | |
CAI::GeneralizedAStar< S, C >::Node | |
CNodeWithPriority | |
►COptimization::NonlinearProgram | A structure defining a nonlinear program |
COptimization::InequalityBarrierNLP | |
CMath::NormAccumulator< T > | |
CMath::NRQRDecomposition< T > | The QR decomposition as computed by the algorithm in Numerical Recipes in C |
CMath::NullPreconditioner< Matrix > | Identity precondtioner |
CObjectPrinter< T > | Provides a unified interface to "pretty print" objects to the console, or other ostreams |
CObstacleCheckerBase | Abstract base class for an obstacle |
►CGeometry::Octree | |
CGeometry::OctreePointSet | Stores a point set P on an octree grid. Allows for O(d) adding, O(d h) range queries and pseudo-O(d) nearest neighbor queries |
CGeometry::OctreeScalarField | Stores a function f(x) on an octree grid. Allows for O(d) setting, sub O(d) testing of f(x) in range [a,b], O(d h) selection of nodes with values in range [a,b] |
CGeometry::OctreeNode | |
CStatistics::OnlineLeastSquares | Online estimation of least-squares solution to y = A x |
CStatistics::OnlineMoments | Online calculation of mean, covariance, min/max of vectors |
COrientedSupportPolygon | Calculation of a support polygon with a non-vertical gravity vector |
CParamList | |
CGivenPathEdgePlanner::PathBisector | |
CPathCoordinate< PathRot, PathTrans > | |
CPathInfo | |
CDisplacementPlanner::PathSearchNode | |
CPermutation | A class that enumerates permutations |
CSpline::PiecewisePolynomial | |
CSpline::PiecewisePolynomialND | |
CPixel | |
CMath3D::Plane2D | A 2D plane classRepresents plane with a normal and offset such that x on the plane satisfy dot(normal,x) = offset |
CMath3D::Plane3D | A 3D plane classRepresents plane with a normal and offset such that x on the plane satisfy dot(normal,x) = offset |
CGeometry::KDTree::Point | |
►CMeshing::PointCloud3D | A 3D point cloud class |
CGeometry::CollisionPointCloud | A point cloud with a fast collision detection data structure |
CGeometry::PointCloudKMeansSegmentation | Uses KMeans + connected components to segment a point cloud. Good for getting "superpixels" |
CGeometry::PointCloudNeighborGraphSegmentation | Uses a neighbor-graph in XYZ space + connected components to segment a point cloud. Good for separating well-separated components |
►CPointLocationBase | A uniform abstract interface to point location data structures |
CKDTreePointLocation | An accelerated point location algorithm that uses a K-D tree |
CNaivePointLocation | The Naive O(n) point location algorithm |
CRandomBestPointLocation | The approximate O(k) point location algorithm that returns the closest of k randomly chosen points |
CRandomPointLocation | The approximate O(1) point location algorithm that simply returns a random point |
CPointMeshCollider | |
CPointPointCollider | |
►CMath3D::Polygon2D | An arbitrary connected polygon given by a vertex list |
CMath3D::ConvexPolygon2D | A convex connected polygon such that the vertices are in ccw order |
CMath3D::Polygon3D | An arbitrary connected polygon in 3D space given by a vertex list |
CSpline::Polynomial< T > | A simple polynomial class, p(x) = sum_{i=0}^n coef[i]*x^i |
CGeometry::PolytopeProjection2D | A method for projecting a polytope defined by the feasible set of a linear program lp onto a 2D subspace. Handles unbounded and infeasible problems |
CPQP_Results | |
CPrimitiveValue | A basic primitive value type, including integers, floats, and strings |
CProgressPrinter | Prints the progress of an iterative, long computation |
CPRTPlanner | The PRT (Probabilistic Roadmap of Trees) planner |
CMath::QNHessianUpdater | Maintains the Cholesky decomposition of the hessian H over Quasi-Newton steps |
CMath::QRDecomposition< T > | Calculates the QR decomposition |
COptimization::QuadProgPPInterface | An interface to the QuadProg++ quadratic programming solver. Enable with the HAVE_QUADPROGPP=1 preprocessor define |
►CMath::Quaternion | Complex quaternion class (w + ix + jy + kz) |
CMath3D::QuaternionRotation | Quaternion, a.k.a. Euler parameter, 3D rotation parameterization |
Cr5g6b5 | |
CRange2Indices | A 2D lattice of regular ranges |
CRange3Indices | A 3D lattice of regular ranges |
CRangeIndices | A regular range of indices ik = start+k*stride, for k=0 to size-1 |
CRangeMap< T > | Same as RangeSet, but a map rather than a set. O(1) find as well |
CRangeMap2D< T > | Same as RangeSet2D but a map. O(1) find as well as count |
CRangeSet | A set of integers within a range. Operates in two modes, set or bit vector mode. In bit-vector mode, allows O(1) membership testing (but the range is fixed). Set mode is just like a regular set |
CRangeSet2D | A set of 2d indices within a range. Operates in two modes, set or bit matrix mode. In bit-matrix mode, allows O(1) membership testing (but the range is fixed). Set mode is just like a regular set |
►CMeshing::Rasterizer2D | A base class that allows rasterizing of 2D triangles into a grid |
►CMeshing::FillRasterizer2D< T > | A rasterizer that flat-fills elements of a grid |
CMeshing::SmoothFillRasterizer2D< T > | A smooth-fill rasterizer |
CGeometry::RayCastCallback | |
►CMath::RealFunction | A function from R to R |
CMath::AddFunction | |
CMath::ComposeFunction | |
CMath::InverseFunction | |
CMath::LinearFunction | |
CMath::MulFunction | |
CMath::ScalarFieldDirectionalFunction | |
CMath::ScalarFieldProjectionFunction | |
CRotationAngleFunction | |
CMath::RealFunction2 | |
CRefObjectBase | |
CRefPointer< obj > | |
CRefStorage< obj > | |
►CResourceBase | A generic "resource" that can be saved/loaded to disk |
CBasicResource< T > | A basic data type |
►CCompoundResourceBase | A resource that is composed of multiple sub-objects, which can themselves be considered resources |
CBasicArrayResource< T > | A basic array data type |
CResourceLibraryResource | A resource that contains a ResourceLibrary. Useful for hierarchical resource libraries |
CResourceLibrary | A collection of resources, which may be loaded/saved as separate files in a directory or inlined into a single XML file. Helps with managing subdirectories of data |
CRigidBodyDynamics | A class for simulating a rigid body. Uses Euler integration |
CRigidBodyVelocity | |
CMath3D::RigidTransform | A rigid-body transformation |
CMath3D::RigidTransform2D | Same as above, but in 2D |
►CRLG | A sampler for closed-chain kinematics that takes joint workspace bounds into account |
CFreeRLG | RLG that sets a virtual linkage of free dof's using analytic IK |
CRNG48 | Uses the ANSI C rand48 functions |
CRoadmapEdgeInfo | |
►CRoadmapPlanner | A base roadmap planner class |
CPRMStarPlanner | |
CRobotIKSolver | A Newton-Raphson robot IK solver |
CRobotLink3D | Kinematic and physical parameters of a link |
COptimization::RobustLPSolver | A class that tries out as many available routines as possible to solve an LP |
CMath::RobustSVD< T > | Performs a pre/postconditioned singular value decomposition |
CMath::RobustSVD< Real > | |
CMath::RowEchelon< T > | Compute reduced row-eschelon form for a matrix A |
►CRRTKinodynamicPlanner | The RRT planner for kinodynamic systems |
CLazyRRTKinodynamicPlanner | A lazy version of kinodynamic RRT |
►CSBLPlanner | The SBL motion planner |
CSBLPlannerWithGrid | An SBL planner whose trees use grids for point location |
CSBLPRT | A probabilistic roadmap of trees, where SBL is used for local planning |
CSBLSubdivision | A grid-based subdivision to be used for SBL |
►CSBLTree | A tree of configurations to be used in the SBL motion planner |
CSBLTreeWithGrid | An SBL motion planner that uses a SBLSubdivision to pick the next node to expand, and nodes to connect |
CSBLTreeWithIndex | An SBLTree with a node index |
►CScalarFieldFunction | |
CLogitLikelihoodFunction | |
►CMath::ScalarFieldFunction | A function from R^n to R |
CMath::Compose_SF_VF_Function | A scalar field function h(x) = f(g(x)) (g vector-valued) |
CMath::Compose_VF_VF_Function | A vector field function h(x) = f(g(x)) (f,g vector fields) |
CMath::ComposeScalarFieldFunction | A scalar field h(x) = f(g(x)) |
CMath::LinearScalarFieldFunction | |
CMath::MaximumScalarFieldFunction | A scalar field max_i xi |
CMath::MinimumScalarFieldFunction | A scalar field min_i xi |
CMath::NormScalarFieldFunction | A scalar field for the L-d norm, where d is passed into the constructor |
CMath::NormSquaredScalarFieldFunction | A scalar field ||x||^2 |
CMath::QuadraticScalarFieldFunction | |
CMath::VectorFieldProjectionFunction | A function g(x) that returns the i'th component of vector field f(x) |
COptimization::LogarithmicBarrierFunction | |
COptimization::LPOptimumFunction | A scalar field v(x) = min_y c(x)^T y s.t. q(x) <= A(x)y <= p(x), l(x) <= y <= u(x) where c,A,q,p,l, and u are smooth functions |
COptimization::RosenbrockFunction | |
CScopedLock | |
CBisectionEpsilonEdgePlanner::Segment | |
CMath3D::Segment2D | A 2D segment class |
CMath3D::Segment3D | |
►CMeshing::SegmentMesh | A basic 2D segment mesh (i.e. collection of polylines) |
CMeshing::SegmentMeshWithTopology | |
CGeometry::SegmentOverlay | Computes the overlay of a set of segments using a sweep line algorithm |
CCSpaceAnalysis::SetCharacteristics | |
CGraph::ShortestPathProblem< Node, Edge > | Single-source shortest paths (Dijkstra's algorithm) |
CGraph::ShortestPathProblem< Config, SmartPointer< EdgePlanner > > | |
►CGraph::ShortestPathProblem< int, MultiModalPRM::TransitionInfo * > | |
CUpdatePrioritySPP | |
CSignalHandler | A base class for an object-oriented signal handler. Properly restores old signal handlers once the class is destroyed |
CSimpleFile | A simple file format that has named items and whitespace-delimited values |
►CSimpleParser | A simple class to break files into tokens, punctuation, comments, and whitespace |
CPCLParser | |
CSimplexEnumerator | |
CSmartPointer< T > | A smart pointer class. Performs automatic reference counting |
CSmartPointer< AnyCollection > | |
CSmartPointer< CSpace > | |
CSmartPointer< EdgePlanner > | |
CSmartPointer< Geometry::OctreePointSet > | |
CSmartPointer< Image > | |
CSmartPointer< int > | |
CSmartPointer< Math::RealFunction > | |
CSmartPointer< Math::ScalarFieldFunction > | |
CSmartPointer< Math::VectorFieldFunction > | |
CSmartPointer< Meshing::TriMesh > | |
CSmartPointer< MotionPlannerInterface > | |
CSmartPointer< PointLocationBase > | |
CSmartPointer< SBLPlanner > | |
CSmartPointer< TransportBase > | |
CSmartPointer< unsigned int > | |
CGeometry::Spanning< Box > | |
►CSparseArray< T > | A sparse 1D array class |
CMath::SparseVectorTemplate< T > | |
CMath::SparseMatrixTemplate_CR< T > | Row-major, compressed-row sparse matrix |
CMath::SparseMatrixTemplate_RM< T > | Row-major sparse matrix |
CMath::SparseMatrixTemplate_RM< Real > | |
CMath::SparseVectorAccessor< T > | |
CMath::SparseVectorCompressed< T > | |
CMath3D::Sphere3D | A 3D sphere class |
►CSplineBasis | |
►CCubicSplineBasis | |
CBezierCubicSplineBasis | |
CCardinalSplineBasis | |
CHermiteSplineBasis | |
CLinearSplineBasis | |
CSplineIterator | |
►CSplineTimeBase | |
CSplineBase< Key, Point > | |
►CSplineBase< KeyBezierCubic< Point >, Point > | |
CSplineBezierCubic< Point > | |
►CSplineBase< KeyBezierCubic< Quaternion >, Quaternion > | |
►CSplineBezierCubic< Quaternion > | |
CPathRotation | |
►CSplineBase< KeyBezierCubic< Vector3 >, Vector3 > | |
►CSplineBezierCubic< Vector3 > | |
CPathTranslationBezier | |
►CSplineBase< KeyCardinal< Point >, Point > | |
CSplineCardinal< Point > | |
►CSplineBase< KeyCardinal< Vector3 >, Vector3 > | |
►CSplineCardinal< Vector3 > | |
CPathTranslationCardinal | |
►CSplineBase< KeyHermite< Point >, Point > | |
CSplineHermite< Point > | |
►CSplineBase< KeyTCB< Point >, Point > | |
CSplineTCB< Point > | |
►CSplineBase< KeyTCB< Vector3 >, Vector3 > | |
►CSplineTCB< Vector3 > | |
CPathTranslationTCB | |
►CSplineBase< Point, Point > | |
CSplineLinear< Point > | |
CStandardRNG | Interface for a random number generator |
CStatCollector | Collects statistics (min,max,mean,stddev,etc) on floating-point data |
CStatDatabase | A heirarchical database of statistical data (counts and StatCollectors). Useful for performance testing |
CStatistics::StochasticLeastSquares | Stochastic gradient descent estimation of least-squares solution to y = A x |
CStatistics::StochasticPseudoLASSO | Stochastic estimation of solution to y = A x via a LASSO-like procedure min_x ||b-A x||^2 + alpha*||x||_1 |
CStringSerializer | A helper class that automatically serializes data to a string and deserializes data using the as<T>() function |
CStripe2Indices | A 2D lattice indexing into a linear sequence, in a striping pattern |
CStripe3Indices | A 3D lattice indexing into a linear sequence, in a striping pattern |
CSubset | A finite subset of numbered items with convenient operators for union, intersection, difference, etc |
CSubsetCost | |
►CSubsetProjector | A subset of a configuration space equipped with a projection mechanism |
CSingletonSetProjector | A single-element subset |
CMath::SVDecomposition< T > | Performs the singular value decomposition |
CMath::SVDecomposition< Real > | |
►CT | |
CGraph::TreeNode< T, E > | A tree graph structure, represented directly at the node level |
CDisplacementPlanner::TestResult | Stores all values for a single obstacle displacement test |
Ctga_file_header | |
CTimedMilestonePath | |
CTimeIndexCmp | |
CTimer | |
CTiXmlElement | |
CTrace | Allows detailed tracing of program execution |
CTraceFunction | |
CTraceFunctionCall | |
CTraceItem | |
CMCRPlanner::Transition | |
CMCRPlannerGoalSet::Transition | |
CMultiModalPRM::TransitionIndex | |
CMultiModalPRM::TransitionInfo | |
►CTransportBase | A base class for a transport protocol for unstructured data |
CSocketClientTransport | A transport protocol that connects as a client to the given address |
CSocketServerTransport | A transport protocol that hosts a client and sends messages to the clients after they connect |
CStreamTransport | A transport protocol that uses STL streams |
CPRTPlanner::Tree | |
CRedBlack::Tree< T, Cmp > | |
CRedBlack::Tree< Event, EventCmp > | |
CRedBlack::Tree< int, StatusCmp > | |
CPRTPlanner::TreeEdge | |
►CTreeRoadmapPlanner | A base class to be used for tree-based roadmap planners |
CPerturbationTreePlanner | A tree-based randomized planner that extends the roadmap by sampling the neighborhood of existing samples |
►CRRTPlanner | A basic RRT (Rapidly-Exploring Random Tree) planner |
CBidirectionalRRTPlanner | A single-query RRT (Rapidly-Exploring Random Tree) planner |
CMath3D::Triangle2D | A 2D triangle class |
CMath3D::Triangle3D | A 3D triangle class |
CMeshing::TriangleClosestPointData | |
►CMeshing::TriMesh | A basic triangle mesh |
►CMeshing::TriMeshWithTopology | A triangle mesh that contains connectivity relations between vertices and triangles |
CGeometry::CollisionMesh | A triangle mesh along with PQP bounding volume structures that enable fast collision and other proximity queries |
CMeshing::TriMeshAtlas | TODO: a non-genus 0 mesh partitioned into charts |
CMeshing::TriMeshChart | A chart maps a genus 0 triangle mesh to a 2d disk |
CMeshing::TriMeshEdge | |
►CMeshing::TriMeshTraversalCallback | A callback base class for traversing triangle mesh topology |
CMeshing::SplitCallback | |
CMeshing::TriSplitter | A class that allows incremental plane-splitting of a triangle mesh |
Cmylist< type >::type_node | |
►Cunary_function | |
Chash< AnyKeyable > | |
►CGeometry::UnboundedPolytope2D | A representation of a possibly unbounded polytope in the 2d plane |
CSupportPolygon | Calculation of the support polygon given a number of contacts |
CGraph::UndirectedEdgeIterator< Data > | |
CUnionFind | From an indexed set of elments, allows fast unioning of the elements into sets |
CUniquePointer< T > | A unique pointer class that duplicates on non-const access. It's used to implement non-conflicting writes to data stored in multiple locations, for example in sparse state representations |
►CStatistics::UnivariateProbabilityDistribution | |
CStatistics::BernoulliDistribution | |
CStatistics::BetaDistribution | |
CStatistics::CategoricalDistribution | |
CStatistics::DiracDistribution | |
CStatistics::GaussianDistribution | |
CStatistics::UniformProbabilityDistribution | |
►CUnivariateProbabilityDistribution | |
CWeibullDistribution | |
►Cvector | |
CDirtyData< std::vector< Matrix > > | |
CMath::AngleSet | A set of AngleIntervals |
CMath::BlockVector | |
CMath::ClosedIntervalSet | |
CMath::OpenIntervalSet | |
CSpline::TimeSegmentation | Divides a real-valued range t[0],t[1],...,t[n-1] into segments |
Cstd::priority_queue2< T, Cmp > | A better priority queue class than the STL version |
►CVector | |
CDirectionCosines | 9-D rotation parameterization that lays out the columns of the rotation matrix in a single vector |
►CMath3D::Vector2 | A 2D vector class |
CGeometry::Point2DWithID | |
►CGeometry::PointRay2D | A 2D point or infinite ray. Note: rays should be normalized unit vectors |
CGeometry::PointRay2DWithID | |
►CVector3 | |
CDirtyData< Vector3 > | |
►CMath3D::Vector3 | A 3D vector class |
CGeometry::PointRay3D | A 3D point or infinite ray. Note: rays should be normalized unit vectors |
CMath3D::EulerAngleRotation | Euler angle 3D rotation parameterization |
CMath3D::MomentRotation | "Moment", a.k.a. exponential map, 3D rotation parameterization |
CMeshing::Vector3Hash | |
CMath3D::Vector4 | A 4D vector class |
►CVectorFieldFunction | |
CIKGoalFunction | Function class that returns the position/rotation errors associated with a given IKGoal |
CRobotCOMFunction | Function class that measures the difference between the robot's center of mass and a desired COM |
CWorldPositionFunction | Function class that returns the world-space position of a point on the robot |
►CMath::VectorFieldFunction | A function from R^n to R^m |
CMath::ComponentVectorFieldFunction | |
CMath::CompositeVectorFieldFunction | |
CMath::IndexedVectorFieldFunction | A vector field function f(x) = g(x[xindices])[findices] |
►CMath::InequalityConstraint | A vector field with constraints s.t. ci(x) >= 0 |
CMath::CompositeInequalityConstraint | |
►CMath::InequalityConstraintAdaptor | A class that makes it easier to construct "plugin" classes to alter constraint behavior |
CMath::ScaledOffsetConstraint | |
CMath::UniformScaledOffsetConstraint | |
CMath::LimitConstraint | |
CMath::LinearConstraint | Constraint represented as A*x >= b i.e. constraint value is A*x-b |
CMath::LinearVectorFieldFunction | |
CMath::SliceVectorFieldFunction | A vector field function f(x) = g(x0 | x0[xindices]=x) |
CMath::SparseVectorFunction | A vector field function with a sparse jacobian. The Jacobian_Sparse and Jacobian_i_Sparse methods must be overridden |
CMath::Vector3FieldFunction | |
COptimization::LPOptimizerFunction | A vector field v(x) = arg min_y c(x)^T y s.t. q(x) <= A(x)y <= p(x), l(x) <= y <= u(x) where c,A,q,p,l, and u are smooth functions |
►CMath::VectorFunction | A function from R to R^n, identical to RealFunction except a vector is returned |
CMath::PiecewiseLinearFunction | |
CMath::PiecewiseLinearPath | |
CRotationAxisFunction | |
CMeshing::VectorHash | |
CMath::VectorIterator< T > | An iterator through VectorTemplate elements |
CMath::VectorPrinter | |
►CMath::VectorTemplate< T > | A vector over the field T |
CMath::DiagonalMatrixTemplate< T > | A templated diagonal matrix, represented by a vector of the entries on the diagonal |
CSpatialVector | |
►CMath::VectorTemplate< Real > | |
CMath::DiagonalMatrixTemplate< Real > | |
CVertex | |
CVisibilityGraphPlanner::Vertex | |
CMeshing::ApproximateGeodesic::VirtualEdge | |
CVisibilityGraphPlanner | |
CMeshing::VolumeGrid | A 3D array over a 3D volume, containing Real values |
CMeshing::VolumeGridIterator< T > | Iterator over a 3D volume grid |
CRedBlack::WalkCallback< T > | |
►CGLDraw::Widget | Base class for a visual widget |
CGLDraw::TransformWidget | |
CGLDraw::WidgetSet | A container of sub-widgets |
CWildcard | An any-schema is a simple validation and mapping scheme for AnyCollections. The keys in the document must match up with the schema |
CWorkspaceBound | Bounds the workspace of a robot linkage with a simple bound |
CWrench | |
Cx1r5g5b5 | |
►CGeometry::XMonotoneChain | A polyline with vertices ordered in nondecreasing order |
CSawtoothAngleEnvelope | |
►Ctype | |
CDirtyData< type > | |