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 |
CAppUtils::ProgramSettings | |
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 | |
COptimization::BlackBoxConstraintOptimizer | Solves a nonlinear program along with black-box boolean constraint test, constraintFunc. constraintFunc is assumed to be the positive level set of a smooth function, but otherwise no assumptions are made about its form |
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 |
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 | |
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 | |
CRemoveTreeCallback | |
CSetComponentCallback | |
CVectorizeCallback | |
►CGraph::CallbackBase< CostSpaceESTPlanner::Node * > | |
CPruneCallback2 | |
►CGraph::CallbackBase< CostSpaceRRTPlanner::Node * > | |
CPruneCallback | |
►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 | A class containing viewport / camera information. This uses OpenGL coordinate convention in which x is to the right of the image, y is downward in the image, and z is backward |
CCamera::CameraController_Free | |
CCamera::CameraController_Orbit | |
CCamera::CameraController_Target | |
CCartesianDriveSolver | Simultaneously moves joints on the robot to achieve one or more Cartesian velocity goals. A highly configurable and reliable solver suitable for long-duration, precise cartesian motions |
CStatistics::CategoricalMAPModel | |
►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 | |
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 | |
►CControlSpace | Encodes the dynamics of a system, including the dynamics function f(x,u), control bounds, and available steering functions |
►CIntegratedControlSpace | Base class for adapting a simulation function by integrating forward dynamics into a ControlSpace. The "base" control set does not contain timing information, while the control set for this space also includes a timestep |
CDoubleIntegratorControlSpace | |
CSpaceTimeIntegratedControlSpace | Given an IntegratedControlSpace on a certain state space, this will produce a control space for the t-c state space that has time prepended to state |
CReverseKinematicControlSpace | |
►CReversibleControlSpace | |
CKinematicControlSpace | Adapts a kinematic cspace (given to the constructor) to a control space |
CStateCostControlSpace | A control space that adapts a state-space control space to a state-cost space. The new state space is (x,c) where c is accumulated cost |
CTimeControlSpace | A 1D ControlSpace that simulates time |
CMath3D::ConvexPolyhedron3D | A convex polyhedron given in a dual representation, planes and vertices of convex hull |
►CConvexVolume | |
CCamera::Frustum | |
►CCSet | A subset of a CSpace, which establishes a constraint for a configuration to be feasible |
CAxisRangeSet | |
►CBoxSet | |
CTimeControlSet | |
CCostGoal | |
CFiniteSet | |
CGeometric2DObstacleFreeSet | |
CIntegratedControlSet | A cartesian-product control space in which groups of states are controlled by individual control spaces |
CIntersectionSet | |
►CNeighborhoodSet | |
CKinematicControlSet | |
CSubspaceSet | Tests whether the range of values from x[imin:imax] is contained within base |
CUnionSet | |
CVisibilitySet | |
►CCSpace | Motion planning configuration space base class. The configuration space implements an interpolation space with obstacles. To implement obstacles, the user will create some CSets (or predicates) and add them via the AddConstraint method |
►CGeodesicCSpace | |
►CCartesianCSpace | |
►CBoxCSpace | |
CR2CSpace | An axis-aligned subset of the space R^2 with convenient casts from Math3d::Vector2, and with variable names x,y |
CR3CSpace | An axis-aligned subset of the space R^3 with convenient casts from Math3d::Vector3, and with variable names x,y,z |
►CTimeCSpace | 1D cspace in the range [0,inf) but where Sample samples from the range [0,timeStepMax] |
CCostCSpace | |
CTranslatingRobot2DCSpace | Translating 2D robot in a 2D workspace |
CGeodesicCSpaceAdaptor | |
►CMultiCSpace | |
►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 |
►CSE2CSpace | The space of rigid body transforms SE(2). Still need to implement IsFeasible, PathChecker |
CRigidRobot2DCSpace | Translating and rotating 2D robot in a 2D workspace |
►CSE3CSpace | The space of rigid body transforms SE(3). Still need to implement IsFeasible, PathChecker |
CRigidRobot3DCSpace | Translating and rotating 2D robot in a 2D workspace |
CSpaceTimeCSpace | A cspace that prepends a time variable to the given CSpace. This is best used with perturbation-sampling planners, and/or SpaceTimeIntegratedKinodynamicCSpace |
CSO2CSpace | The space of rotations SO(2). The representation is a single angle. Still need to implement IsFeasible, PathChecker |
CSO3CSpace | The space of rotations S0(3). The representation is a MomentRotation. Still need to implement IsFeasible, PathChecker |
CGeometric2DCSpace | 2D cspace whose obstacles are geometric primitives |
CGrid2DCSpace | |
CMultiRobot2DCSpace | One or more 2D robots translating and/or rotating in a 2D workspace |
CObstacleDisplacementCSpace | A class that needs to be subclassed in order to implement a minimum constraint displacement problem |
CPerturbationCSpace | |
►CPiggybackCSpace | A helper class that assists with selective overriding of another cspace's methods (similar to "monkey-patching") |
CAdaptiveCSpace | A class that optimizes constraint testing order using empirical data |
CKinodynamicSteeringCSpaceAdaptor | Adapts a kinodynamic space with steering function to a kinematic cspace where the steering function is used as the visibility function |
CSubsetConstraintCSpace | Converts an CSpace so that it only checks one or a subset of selected constraints |
CCSpaceAnalysis | |
CCustomContactFormation | A more advanced ContactFormation that accepts custom contact points and custom constraints |
CCustomContactPoint | A contact point with custom force / wrench constraints |
CCustomContactPoint2D | |
CMath3D::Cylinder3D | A 3D cylinder |
CGeometry::OctreeScalarField::Data | |
CStatDatabase::Data | |
CDataDatabase | A heirarchical database of arbitrary values |
CStatistics::DataSet | |
CDDimensionCmp | |
►CDensityEstimatorBase | A base class for density estimators. Each point in an N dimensional space is attached to some data pointer. Density in the space is measured by the Density() function, and only matters in a relative sense |
CGridDensityEstimator | A grid-based (n-d projected histogram) density estimator |
CKernelDensityEstimator | Kernel Density Estimation density estimator |
CMultiGridDensityEstimator | A multiple-grid based density estimator that attempts to avoid data fragmentation by collecting histograms on multiple axes and fusing them together |
►CDiffEqFunction | |
►CDiffEq2Function | |
CSimFunction< Robot, NVector > | |
►CMath::DiffEqFunction | |
CIntegrationFunction | |
CDiscountedEdgeDistance | |
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 | |
CMCRPlannerGoalSet::Edge | |
CMCRPlanner::Edge | |
CDisplacementPlanner::Edge | |
CEdgeCollision | |
CKinodynamicTree::EdgeData | |
CEdgeDistance | |
CSBLTree::EdgeInfo | |
CGraph::EdgeIterator< Data > | |
CEdgeLengthFunction | |
CMath::EquationTerm | |
CEquilibriumTester | Testing COM equilibrium given some number of contacts |
CErrorAccumulator | |
►CExplicitCSpace | |
CRigidRobot3DCSpace | Translating and rotating 2D robot in a 2D workspace |
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 |
CFileImpl | |
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 |
►CGeodesicSpace | A space with geodesics and (optionally) geodesic derivatives |
CCartesianSpace | |
CGeodesicCSpace | |
►CGeometric2DCollection | |
CGeometric2DCSpace | 2D cspace whose obstacles are geometric primitives |
CMath3D::GeometricPrimitive2D | |
CMath3D::GeometricPrimitive3D | A generic geometric primitive class |
CGLDraw::GeometryAppearance | A class for coloring, texturing, and drawing meshes in OpenGL |
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< Node, Edge > | 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 | |
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 > | |
CGeometry::IndexHash | |
CStatistics::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 |
►CInterpolator | A base class for all 1D interpolators |
CCSpaceInterpolator | An interpolator that uses a CSpace's Interpolate function |
►CEdgePlanner | Abstract base class for an edge planner / edge checker (i.e., local planner) |
CBisectionEpsilonEdgePlanner | |
►CEdgeChecker | An EdgePlanner that just checks a given interpolator or straight line path between two configurations |
CEndpointEdgeChecker | Edge planner that only checks the endpoint |
CEpsilonEdgeChecker | Edge checker that divides the path until epsilon resolution is reached |
CFalseEdgeChecker | Edge planner that is never visible |
CGeometric2DEdgeChecker | |
CObstacleDistanceEdgeChecker | Edge checker that divides the path until the segment distance is below CSpace.ObstacleDistance() |
►CPiggybackEdgePlanner | |
CEdgePlannerWithCSpaceContainer | Convenience class for edge planner that holds a smart pointer to a CSpace so that the temporary CSpace is destroyed when the edge is destroyed. Typically used for single-constraint edge checkers as follows: |
CIncrementalizedEdgePlanner | An incremental edge planner that calls a non-incremental edge planner. This adapts one-shot edge planners to be used in lazy motion planners |
CMultiEdgePlanner | An edge planners that plans a stacked list of edges |
CStatUpdatingEdgePlanner | |
CTrueEdgeChecker | Edge planner that always is visible |
CPathEdgeChecker | An edge checker that checks a sequence of edges |
CGeodesicInterpolator | An interpolator that uses a GeodesicSpace's Interpolate function |
CKinodynamicMilestonePath | Stores a kinodynamic path with piecewise constant controls |
CLinearInterpolator | An interpolator that goes between two Configs |
CMilestonePath | A sequence of locally planned paths between milestones |
CMultiInterpolator | A cartesian product of interpolators |
CPathInterpolator | An interpolator that concatenates a list of other interpolators. The interpolators may have nonuniform duration |
►CPiecewiseLinearInterpolator | |
CPiecewiseLinearCSpaceInterpolator | |
CPiecewisePolynomialInterpolator | |
CReverseInterpolator | An interpolator that reverses another one |
CSubsetInterpolator | |
CTimedMilestonePath | |
CTimeRemappedInterpolator | An interpolator that remaps a time interval of another interpolator. Maps the parameter range [pstart,pend] (by default [0,1]) to the range [a,b] on the base interpolator |
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 | |
CStripe3Indices::iterator | |
CRangeIndices::iterator | |
►CRange2Indices::iterator | |
CGrid2Indices::iterator | |
CRange3Indices::iterator | |
CStripe2Indices::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 kd-tree or a node of one |
CKeyBezierCubic< Point > | |
CKeyCardinal< Point > | |
CKeyHermite< Point > | |
CKeyTCB< Point > | |
►CKinematicLink2D | |
CDynamicLink2D | |
►CKinematicLink3D | |
CDynamicLink3D | |
►CKinodynamicPlannerBase | |
CBidirectionalRRTKP | A bidirectional RRT planner for kinodynamic systems |
►CESTKinodynamicPlanner | The EST planner for kinodynamic systems |
CCostSpaceESTPlanner | An optimizing planner that progressively produces better paths using state-cost space. Plan() returns true only if a better path was found in the last maxIters iterations. Done() and GetPath() return true if there ANY solution has been found |
CKinodynamicLocalOptimizer | |
►CRRTKinodynamicPlanner | The RRT planner for kinodynamic systems |
►CLazyRRTKinodynamicPlanner | A lazy version of kinodynamic RRT |
CCostSpaceRRTPlanner | An optimizing planner that progressively produces better paths using state-cost space. Plan() returns true only if a better path was found in the last maxIters iterations. Done() and GetPath() return true if there ANY solution has been found |
►CKinodynamicSpace | A class used for kinodynamic planning. Combines a CSpace defining the state space, as well as a ControlSpace |
CDoubleIntegratorKinodynamicSpace | Space that combines configuration and velocity in the state x=(q,v), and is controlled by acceleration v' = a. The control u = (dt,a) is composed of a time step and acceleration |
►CIntegratedKinodynamicSpace | A class that produces a KinodynamicCSpace from a dynamics function subclassed from IntegratedControlSpace. Collision checking is performed at the integration resolution given in the dynamics function |
CSpaceTimeIntegratedKinodynamicSpace | This KinodynamicCSpace prefixes time onto the state of the given CSpace instance and automatically increments the time state variable as the dynamics are integrated forward |
CKinematicCSpaceAdaptor | Adapts a kinematic cspace (given to the constructor) to a kinodynamic one |
CStateCostKinodynamicSpace | |
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 |
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 |
►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 |
CTreeRoadmapPlanner::Milestone | |
CMCRPlannerGoalSet::Milestone | |
CMCRPlanner::Milestone | |
CDisplacementPlanner::Milestone | |
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. NOTE: only works on base motion planners that accept dynamic goal insertion, such as PRM or SBLPRT. For other motion planners, need to use the PointToSetMotionPlannerAdaptor |
►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 |
CPointToSetMotionPlannerAdaptor | Tries to produce a path between a start node and a goal space. Does so via goal sampling / reinitializing |
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::NewtonSolver | A newton's-method style solver for a NLP |
CAI::GeneralizedAStar< S, C >::Node | |
CRedBlack::Node< T > | |
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 |
►CObjectiveFunctionalBase | A base class for objective functionals of the form J[x,u] = sum_0^N-1 L(xi,ui) dt + Phi(xN) |
CCompositeObjective | An objective that merges contributions from multiple other objective functions |
CConfigObjective | A goal that measures distance to a goal configuration qgoal |
►CIntegratorObjectiveFunctional | A cost functional of the form J[x,u] = int_0^T L(x(t),u(t)) dt + Phi(x(T)) |
CQuadraticObjective | A goal that measures quadratic tracking error and control cost. Note that the time must exist in the state |
CLengthObjective | An objective that measures path length |
CTimeObjective | An objective that measures path execution time. Accumulated time is assumed to be part of the state, specifically the element indexed by timeIndex |
►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 |
CParabolicRamp::ParabolicRamp | |
CParabolicRamp::ParabolicRamp1D | Stores optimal trajectores for an acceleration and velocity-bounded 1D system |
CParabolicRamp::ParabolicRampND | Solves for optimal trajectores for a velocity-bounded ND system |
CParamList | |
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 |
CParabolicRamp::PLPRamp | |
CGeometry::KDTree::Point | |
►CMeshing::PointCloud3D | A 3D point cloud class |
CGeometry::CollisionPointCloud | A point cloud with a fast collision detection data structure |
►CPointLocationBase | A uniform abstract interface to point location data structures. The point locator operators in-place on a vector of Vectors and does not allocate any extra memory unless this is desired |
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 |
CParabolicRamp::PPRamp | |
CPQP_Results | |
CAdaptiveCSpace::PredicateStats | |
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 | A function g(t) that returns f(x+tn) for a scalar field f(x) If ref is true, then x,n are set to refer to the x,n provided in the constructor, rather than to copy |
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 |
►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 |
►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 |
CBooleanScalarField | |
CIncrementalCostFunction | |
CIncrementalCostFunctionX | |
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 | |
CPathCostFunction | |
CPathFeasibilityFunction | |
CTerminalCostFunction | |
CScopedLock | |
CBisectionEpsilonEdgePlanner::Segment | |
CMath3D::Segment2D | A 2D segment class |
CMath3D::Segment3D | |
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< ControlSpace > | |
CSmartPointer< CSet > | |
CSmartPointer< CSpace > | |
CSmartPointer< DensityEstimatorBase > | |
CSmartPointer< EdgePlanner > | |
CSmartPointer< GeodesicSpace > | |
CSmartPointer< Geometry::OctreePointSet > | |
CSmartPointer< Image > | |
CSmartPointer< int > | |
CSmartPointer< IntegratedControlSpace > | |
CSmartPointer< Interpolator > | |
CSmartPointer< KinodynamicSpace > | |
CSmartPointer< Math::RealFunction > | |
CSmartPointer< Math::ScalarFieldFunction > | |
CSmartPointer< Math::VectorFieldFunction > | |
CSmartPointer< Meshing::TriMesh > | |
CSmartPointer< MotionPlannerInterface > | |
CSmartPointer< ObjectiveFunctionalBase > | |
CSmartPointer< PointLocationBase > | |
CSmartPointer< SBLPlanner > | |
CSmartPointer< SteeringFunction > | |
CSmartPointer< TransportBase > | |
CSmartPointer< unsigned int > | |
CSmartPointer< VectorFieldFunction > | |
►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 |
►CSteeringFunction | A function in a ControlSpace that attempts to connect two states with a sequence of one or more controls |
CDoubleIntegratorBoxBoundedSteeringFunction | |
CKinematicSteeringFunction | |
CRandomBiasReverseSteeringFunction | A simple approximate steering function that simply draws several samples and picks the closest one in terms of CSpace distance |
CRandomBiasSteeringFunction | A simple approximate steering function that simply draws several samples and picks the closest one in terms of CSpace distance |
CSpaceTimeSteeringFunction | Given a steering function on a base space q' = f(q,ubase), adapts it to the proper steering function on a SpaceTimeIntegratedControlSpace where the state component is x=(t,q) and the control is u=(dt,ubase) |
CStateCostSteeringFunction | |
CTimeSteeringFunction | |
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 |
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 | |
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 | |
CTimeIndexCmp | |
CTimer | |
CTimerImpl | |
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 |
CRedBlack::Tree< T, Cmp > | |
CPRTPlanner::Tree | |
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 | |
►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 |
►CVector3 | |
CDirtyData< Vector3 > | |
CMeshing::Vector3Hash | |
CMath3D::Vector4 | A 4D vector class |
►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 | |
CNegativeVectorFieldFunction | |
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 |
CPathDynamicEqualityFunction | |
CSimulateFunction | |
CSimulateFunctionX | |
►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::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 > | |
CVisibilityGraphPlanner::Vertex | |
CVertex | |
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 > | |