►NAI | |
CAStar | |
►CGeneralizedAStar | |
CNode | |
CGeneralizedAStarWithHashMap | |
CGeneralizedAStarWithMap | |
CIntegerAStar | |
►NAppUtils | |
CProgramSettings | |
►NCamera | |
CCamera | |
CCameraController_Free | |
CCameraController_Orbit | |
CCameraController_Target | |
CFrustum | |
CViewport | A class containing viewport / camera information. This uses OpenGL coordinate convention in which x is to the right of the image, y is upward in the image, and z is backward |
►NCommandLine | |
CCommandArg | |
CCommandAuto | |
CCommandBase | |
CCommandHelp | |
CCommandInputValue | |
CCommandSetValue | |
►NGeometry | Contains all definitions in the Geometry package |
CAngular2DOrdering | |
CAnyCollisionGeometry3D | An AnyGeometry with collision detection information |
CAnyCollisionQuery | A class that stores information regarding a collision query. May be slightly faster than running individual queries |
►CAnyContactsQueryResult | |
CContactPair | |
CAnyContactsQuerySettings | |
CAnyDistanceQueryResult | |
CAnyDistanceQuerySettings | |
CAnyGeometry3D | A class that stores any kind of geometry we've defined |
CApproximatePenetrationDepth | Uses a propagation method to calculate an approximate penetration distance of mesh m1 inside m2 |
►CArrangement1D | An arrangement of 1-D intervals. Intervals identified by an integer ID |
CLeftInterval | |
CBallTree | |
CBallTreeNode | A node of a ball-tree point location data structure |
►CClosestPointCallback | |
CActivePair | |
►CCollisionConvexHull3D | The collision data class for ConvexHull3D that contains the solid3 data structure moved by some rigid transform |
CObjectHandleContainer | |
CCollisionImplicitSurface | An implicit surface (usually signed-distance function) with a fast collision detection data structure |
CCollisionMesh | A triangle mesh along with PQP bounding volume structures that enable fast collision and other proximity queries |
CCollisionMeshQuery | A general-purpose distance querying class |
CCollisionMeshQueryEnhanced | |
CCollisionPointCloud | A point cloud with a fast collision detection data structure |
►CConvexHull3D | A 3D convex hull class |
CShapeHandleContainer | |
►CDenseTSDFReconstruction | Performs a kinect-fusion-like dense TSDF reconstruction |
CVoxelInfo | |
CGrid | A gridding of n-dimensional space |
CGridHash | An ND grid containing objects (referenced by void pointers) |
CGridHash3D | A grid containing objects (referenced by void pointers) |
CGridSubdivision | An ND grid with a list of arbitrary objects (given by void pointers) |
CGridSubdivision3D | A grid with a list of arbitrary objects (given by void pointers) |
CGridTable | A table with entry T on a gridding of n-dimensional space |
CICPParameters | |
CIndexHash | |
►CKDTree | A kd-tree or a node of one |
CPoint | |
CLPSolvePointCallback | Helper callback used in PolytopeProjection2D |
CMultiVolumeGrid | A 3D array over an axis-aligned 3D volume, containing one or more channels |
COctree | |
COctreeNode | |
COctreePointSet | 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 |
►COctreeScalarField | 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] |
CData | |
CPoint2DWithID | |
CPointPointCollider | |
CPointRay2D | A 2D point or infinite ray. Note: rays should be normalized unit vectors |
CPointRay2DWithID | |
CPointRay3D | A 3D point or infinite ray. Note: rays should be normalized unit vectors |
CPolytopeProjection2D | 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 |
CRayCastCallback | |
►CSegmentOverlay | Computes the overlay of a set of segments using a sweep line algorithm |
CIntersectionInfo | |
CSparseTSDFReconstruction | Performs a kinect-fusion-like sparse TSDF reconstruction. A hash grid is used to build multiple TSDFs across an infinite domain |
►CSparseVolumeGrid | A 3D array over a sparse, axis aligned 3D volume. Has a similar interface as VolumeGrid, but uses a hash grid data structure to achieve better performance in large grids with infinite domain |
CBlock | |
CUnboundedPolytope2D | A representation of a possibly unbounded polytope in the 2d plane |
CXMonotoneChain | A polyline with vertices ordered in nondecreasing order |
►NGLDraw | Contains all definitions in the GLDraw package |
CBoxWidget | |
CColorGradient | |
CGeometryAppearance | A class for coloring, texturing, and drawing meshes in OpenGL |
CGLColor | An rgba color |
CGLDisplayList | |
CGLFog | |
CGLLight | An OpenGL light |
CGLMaterial | An OpenGL material |
CGLOffscreenContext | A way to draw to an offscreen buffer. Currently only works with XWindows |
CGLRenderToImage | Allows for GL calls to draw to an image |
CGLScreenshotProgram | A plugin class that "automatically" saves a movie to disk in the form of PPM screenshots |
CGLTexture1D | 1D texture data for use in OpenGL |
CGLTexture2D | 2D texture data for use in OpenGL |
CGLTextureObject | 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 |
CGLView | |
CSphereWidget | |
CTransformWidget | |
CWidget | Base class for a visual widget |
CWidgetSet | A container of sub-widgets |
►NGraph | Namespace for all classes and functions in the Graph subdirectory |
CApproximateShortestPathProblem | 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 |
CCallbackBase | A template base class for a graph traversal |
CCoEdgeIterator | |
CComponentIntCallback | |
CConnectedComponents | |
CCountCallback | Count the number of nodes traversed |
CCycleCallback | Compute if the graph has a cycle |
CDepthIntCallback | Get the depth of all nodes (in an indexed graph, such as Graph) |
CDirectedGraph | A specialization of a Graph to be directed graph |
CEdgeIterator | |
CFindCallback | Find a particular node |
CGraph | Basic template graph structure |
CPathCallback | |
CPathIntCallback | Same as above, but for indexed graphs |
CShortestPathProblem | Single-source shortest paths (Dijkstra's algorithm) |
CShortestPathsIntCallback | |
CTimeCallback | Get the start/finish time of a traversal |
CTimeIntCallback | Same as above, but for indexed graphs |
CTopologicalSortCallback | Perform topological sort, when used with DFS |
CTraversalGraphCallback | Compute the traversal graph of a traversal |
CTraversalGraphIntCallback | Same as above, but for indexed graphs |
CTreeNode | A tree graph structure, represented directly at the node level |
CUndirectedEdgeIterator | |
CUndirectedGraph | A specialization of a Graph to be an undirected graph |
►NMath | Contains all definitions in the Math package |
CAddFunction | |
CAngleInterval | A contiguous range of angles |
CAngleSet | A set of AngleIntervals |
CBLASInterface | An interface to BLAS. Activated with the preprocessor flag HAVE_BLAS=1 |
CBlockPrinter | |
CBlockTridiagonalMatrix | |
CBlockVector | |
CCholeskyDecomposition | Performs the Cholesky decomposition |
CClosedInterval | A closed interval [a,b] |
CClosedIntervalSet | |
CComplex | Complex number class (x + iy) |
CComponentVectorFieldFunction | |
CCompose_SF_VF_Function | A scalar field function h(x) = f(g(x)) (g vector-valued) |
CCompose_VF_VF_Function | A vector field function h(x) = f(g(x)) (f,g vector fields) |
CComposeFunction | |
CComposeScalarFieldFunction | A scalar field h(x) = f(g(x)) |
CCompositeInequalityConstraint | |
CCompositeVectorFieldFunction | |
CConditioner_SymmDiag | A matrix conditioner that does a pre/postmultiply with a diagonal S |
CDiagonalMatrixTemplate | A templated diagonal matrix, represented by a vector of the entries on the diagonal |
CDiffEqFunction | |
CEquationTerm | |
CGaussian | Multivariate gaussian N(mu,K) of d dimensions |
CIndexAndPriority | |
CIndexedVectorFieldFunction | A vector field function f(x) = g(x[xindices])[findices] |
CInequalityConstraint | A vector field with constraints s.t. ci(x) >= 0 |
CInequalityConstraintAdaptor | A class that makes it easier to construct "plugin" classes to alter constraint behavior |
CInterval | A generic interval {a,b}, where { and } can be either (,[ or ),] |
CInverseFunction | |
CIterativeMethod | |
CJacobiPreconditioner | Jacobi preconditioning (inverse of diagonal) |
CLAPACKInterface | An interface to LAPACK. Activated with the preprocessor flag HAVE_CLAPACK=1 |
CLDLDecomposition | Performs the LDL^t decompositoin of a symmetric matrix A |
CLimitConstraint | |
CLinearConstraint | Constraint represented as A*x >= b i.e. constraint value is A*x-b |
CLinearFunction | |
CLinearScalarFieldFunction | |
CLinearVectorFieldFunction | |
CLUDecomposition | Forms the LU decomposition A=PLU |
CMatrixEquation | |
CMatrixEquationPrinter | |
CMatrixIterator | An iterator through MatrixTemplate elements |
CMatrixPrinter | |
CMatrixTemplate | A matrix over the field T |
CMaximumScalarFieldFunction | A scalar field max_i xi |
CMinimumScalarFieldFunction | A scalar field min_i xi |
CMulFunction | |
CNormAccumulator | |
CNormScalarFieldFunction | A scalar field for the L-d norm, where d is passed into the constructor |
CNormSquaredScalarFieldFunction | A scalar field ||x||^2 |
CNRQRDecomposition | The QR decomposition as computed by the algorithm in Numerical Recipes in C |
CNullPreconditioner | Identity precondtioner |
COpenInterval | An open interval (a,b) |
COpenIntervalSet | |
►CPiecewiseLinearFunction | |
CControlPoint | |
►CPiecewiseLinearPath | |
CControlPoint | |
CQNHessianUpdater | Maintains the Cholesky decomposition of the hessian H over Quasi-Newton steps |
CQRDecomposition | Calculates the QR decomposition |
CQuadraticScalarFieldFunction | |
CQuaternion | Complex quaternion class (w + ix + jy + kz) |
CRealFunction | A function from R to R |
CRealFunction2 | |
CRobustSVD | Performs a pre/postconditioned singular value decomposition |
CRowEchelon | Compute reduced row-eschelon form for a matrix A |
CScalarFieldDirectionalFunction | 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 |
CScalarFieldFunction | A function from R^n to R |
CScalarFieldProjectionFunction | |
CScaledOffsetConstraint | |
CSliceVectorFieldFunction | A vector field function f(x) = g(x0 | x0[xindices]=x) |
CSparseMatrixTemplate_CR | Row-major, compressed-row sparse matrix |
CSparseMatrixTemplate_RM | Row-major sparse matrix |
CSparseVectorAccessor | |
CSparseVectorCompressed | |
CSparseVectorFunction | A vector field function with a sparse jacobian. The Jacobian_Sparse and Jacobian_i_Sparse methods must be overridden |
CSparseVectorTemplate | |
CSVDecomposition | Performs the singular value decomposition |
CUniformScaledOffsetConstraint | |
CVector3FieldFunction | |
CVectorFieldFunction | A function from R^n to R^m |
CVectorFieldProjectionFunction | A function g(x) that returns the i'th component of vector field f(x) |
CVectorFunction | A function from R to R^n, identical to RealFunction except a vector is returned |
CVectorIterator | An iterator through VectorTemplate elements |
CVectorPrinter | |
CVectorTemplate | A vector over the field T |
►NMath3D | Contains all the definitions in the Math3D package |
CAABB2D | A 2D axis-aligned bounding box |
CAABB3D | A 3D axis-aligned bounding box |
CAABBTemplate | |
CAngleAxisRotation | Angle-axis 3D rotation parameterization |
CBox2D | 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} |
CBox3D | 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} |
CCircle2D | A 2D circle class |
CCircle3D | A 2D circle in 3D space class |
CConvexPolygon2D | A convex connected polygon such that the vertices are in ccw order |
CConvexPolyhedron3D | A convex polyhedron given in a dual representation, planes and vertices of convex hull |
CCylinder3D | A 3D cylinder |
CEllipsoid3D | 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} |
CEulerAngleRotation | Euler angle 3D rotation parameterization |
CGeometricPrimitive2D | A generic 2D geometric primitive class |
CGeometricPrimitive3D | A generic 3D geometric primitive class |
CLine2D | A 2D line class |
CLine3D | A 3D line class |
CLocalCoordinates2D | |
CLocalCoordinates3D | |
CMatrix2 | A 2x2 matrix class |
CMatrix3 | A 3x3 matrix class |
CMatrix4 | A 4x4 matrix class |
CMomentRotation | "Moment", a.k.a. exponential map, 3D rotation parameterization |
CPlane2D | A 2D plane classRepresents plane with a normal and offset such that x on the plane satisfy dot(normal,x) = offset |
CPlane3D | A 3D plane classRepresents plane with a normal and offset such that x on the plane satisfy dot(normal,x) = offset |
CPolygon2D | An arbitrary connected polygon given by a vertex list |
CPolygon3D | An arbitrary connected polygon in 3D space given by a vertex list |
CQuaternionRotation | Quaternion, a.k.a. Euler parameter, 3D rotation parameterization |
CRay3D | |
CRigidTransform | A rigid-body transformation |
CRigidTransform2D | Same as above, but in 2D |
CScaledLocalCoordinates2D | |
CScaledLocalCoordinates3D | |
CSegment2D | A 2D segment class |
CSegment3D | |
CSphere3D | A 3D sphere class |
CTriangle2D | A 2D triangle class |
CTriangle3D | A 3D triangle class |
CVector2 | A 2D vector class |
CVector3 | A 3D vector class |
CVector4 | A 4D vector class |
►NMeshing | The namespace for all classes/functions in the Meshing package |
CAddTriOffset | |
►CApproximateGeodesic | Computes an approximate geodesic distance over a mesh, from a single source |
CVirtualEdge | |
CAreaGridIterator | Iterator over a 2D area grid |
CAreaGridTemplate | A 2D array over an axis-aligned 2D box, containing Real values |
CBarycentricCoords | |
CFillRasterizer2D | A rasterizer that flat-fills elements of a grid |
CLSConformalMapping | An approximately-conformal parameterization a genus-0 mesh, found by a least-squares method |
CPointCloud3D | A 3D point cloud class |
CRasterizer2D | A base class that allows rasterizing of 2D triangles into a grid |
CSmoothFillRasterizer2D | A smooth-fill rasterizer |
CSplitCallback | |
CTriangleClosestPointData | |
CTriMesh | A basic triangle mesh |
CTriMeshAtlas | TODO: a non-genus 0 mesh partitioned into charts |
CTriMeshChart | A chart maps a genus 0 triangle mesh to a 2d disk |
CTriMeshEdge | |
CTrimeshFeature | |
CTriMeshTraversalCallback | A callback base class for traversing triangle mesh topology |
CTriMeshWithTopology | A triangle mesh that contains connectivity relations between vertices and triangles |
CTriSplitter | A class that allows incremental plane-splitting of a triangle mesh |
CVector3Hash | |
CVectorHash | |
CVolumeGridIterator | Iterator over a 3D volume grid |
CVolumeGridTemplate | A 3D array over an axis-aligned 3D volume, containing Real values |
►NOptimization | Namespace for classes and functions in the Optimization package |
CBCMinimizationProblem | A bound-constrained MinimizationProblem. Uses an active-set method to determine the components of the free search direction at x |
CBoundedLSQRSolver | Solve the bounded least-squares problem min||Ax-b||^2 s.t. l <= x <= b accepts infinite constraints too |
CConstrainedMinimizationProblem | Same as MinimizationProblem but with nonlinear constraints C(x)=0 and D(x)<=0, bound constraints bmin/bmax |
CConstrainedNewtonRoot | A globally convergent Newton's method with inequality constraints c(x) >= 0 |
CGLPKInterface | An interface to the GLPK linear program solver. Activated with the HAVE_GLPK preprocessor define |
CInequalityBarrierNLP | |
CLeastSquares | A least-squares problem definition |
CLemkeLCP | Solves a linear complementarity problem |
CLinearConstraints | Linear constraints for LP's and QP'sRepresents the constraints |
CLinearConstraints_Sparse | Sparse linear constraints for LP's and QP'sUnlike dense constraints, AddVariable/AddConstraint are relatively efficient |
CLinearProgram | Linear program definition.Represents the LP min/max c.x subject to
qi <= ai.x <= pi
lj <= xj <= uj |
CLinearProgram_Sparse | Linear program definition with sparse matrix A |
CLogarithmicBarrierFunction | |
CLP_InteriorPoint | Solves a general LP using LP_InteriorPointSolver |
CLP_InteriorPointSolver | An interior-point method for solving a LP |
CLPOptimizerFunction | 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 |
CLPOptimumFunction | 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 |
CLSQRInterface | An interface to a sparse least-squares solver (lsqr) |
CMinimizationProblem | An iterative solution to minimize f over multidimensional x. May only find a local minimum, depending on the initial point |
CMinNormProblem | Solves a linearly constrained minimum-norm problem |
CMinNormProblem_Sparse | Solves a sparse, linearly constrained minimum-norm problem |
CNewtonRoot | A globally convergent Newton's method for multidimensional root solving. Solves for func(x)=0 |
CNewtonSolver | A newton's-method style solver for a NLP |
CNonlinearProgram | A structure defining a nonlinear program |
CQuadProgPPInterface | An interface to the QuadProg++ quadratic programming solver. Enable with the HAVE_QUADPROGPP=1 preprocessor define |
CQuadraticProgram | Quadratic program definition |
CRegularizedLinearProgram | Solves a linear program with regularization |
CRobustLPSolver | A class that tries out as many available routines as possible to solve an LP |
CRosenbrockFunction | |
►NParabolicRamp | |
CParabolicRamp | |
CParabolicRamp1D | Stores optimal trajectores for an acceleration and velocity-bounded 1D system |
CParabolicRampND | Solves for optimal trajectores for a velocity-bounded ND system |
CPLPRamp | |
CPPRamp | |
►NRedBlack | |
CNode | |
►CTree | |
Citerator | |
CWalkCallback | |
►NSpline | |
CBSpline | |
CBSplineBasis | Defines the B-spline basis for a given knot vector, number of control points |
CMonotonicSpline | A b-spline based monotonic spline |
CPiecewisePolynomial | |
CPiecewisePolynomialND | |
CPolynomial | A simple polynomial class, p(x) = sum_{i=0}^n coef[i]*x^i |
CTimeSegmentation | Divides a real-valued range t[0],t[1],...,t[n-1] into segments |
►NStatistics | Contains all definitions in the statistics directory |
CBernoulliDistribution | |
CBernoulliMAPModel | |
CBetaDistribution | |
CBoxProbabilityDistribution | |
CCategoricalDistribution | |
CCategoricalMAPModel | |
CDataSet | |
CDiracDistribution | |
CDiracMultivariateDistribution | |
CDistributionCollector | Incrementally collects samples from a univariate distribution |
CDistributionCollectorND | Incrementally collects samples from a multivariate distribution |
CGaussianDistribution | |
CGaussianHMM | A model of a temporal sequence consisting of k discrete states each with a gaussian emission probability |
CGaussianHMMRegression | |
CGaussianMixtureModel | A model of a probability distribution consisting of k gaussians |
CGaussianMixtureModelRaw | A more ``raw'' model of a GMM that does not perform a cholesky decomposiition |
CGaussianMixtureRegression | |
CGaussianMultivariateDistribution | |
CGaussianRegression | |
►CHierarchicalClustering | |
CCmp | |
Cdistances | |
CHistogram | 1-D histogram class |
CHistogram2D | 2-D histogram class |
CHistogram3D | 3-D histogram class |
CHistogramND | N-D histogram class |
CIndexHash | |
CIntervalMap | Division of the real numbers into interval sets. Each interval is assigned data of type Data |
CIntervalMap2D | |
CKMeans | A simple clustering method to choose k clusters from a set of data |
CLeastSquares1D | 1-D least squares y = ax+b |
CLinearModel | A linear model of n-dimensional data |
CLinearProcess | |
CLinearProcessHMM | A model of a temporal sequence consisting of k discrete states each with a gaussian emission probability depending on the prior continuous state |
CLinearProcessHMMRegression | |
CLinearProcessHMMState | |
CLogisticModel | Models the probability of a boolean outcome using a logit |
CMultivariateProbabilityDistribution | |
COnlineLeastSquares | Online estimation of least-squares solution to y = A x |
COnlineMoments | Online calculation of mean, covariance, min/max of vectors |
CStochasticLeastSquares | Stochastic gradient descent estimation of least-squares solution to y = A x |
CStochasticPseudoLASSO | Stochastic estimation of solution to y = A x via a LASSO-like procedure min_x ||b-A x||^2 + alpha*||x||_1 |
CUniformProbabilityDistribution | |
CUnivariateProbabilityDistribution | |
►Nstd | |
Ccmp_func | A templated function class like strcmp: returns -1 if a<b, 0 if a==b, 1 if a>b |
Cpriority_queue2 | A better priority queue class than the STL version |
►CAdaptiveCSpace | A class that optimizes constraint testing order using empirical data |
CPredicateStats | |
CAddPointCallback | |
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 |
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 |
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 |
CArc3D | An arc segment of a circle in space |
►CArray2D | A two-dimensional m x n array |
Citerator | |
►CArray3D | A three-dimensional m x n x parray |
Citerator | |
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 | An N-D array class |
Citerator | |
CArrayNDRef | |
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) |
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 |
CAsyncWriterQueue | Asynchronous writer with queue |
CAxisRangeSet | |
CAxisSweptPoint | Parameterizes a circle in space by sweeping a point around a line |
CBallTreePointLocation | An accelerated point location algorithm that uses a ball tree |
CBasicArrayResource | A basic array data type |
CBasicResource | A basic data type |
CBezierCubicSplineBasis | |
►CBidirectionalRRTKP | A bidirectional RRT planner for kinodynamic systems |
CBridge | |
CBidirectionalRRTPlanner | A single-query RRT (Rapidly-Exploring Random Tree) planner |
CBiRRTInterface | |
►CBisectionEpsilonEdgePlanner | |
CSegment | |
CBoxCSpace | |
CBoxSet | |
CCardinalSplineBasis | |
CCartesianCSpace | |
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 |
CCartesianSpace | |
CChain | A tree-based chain structure |
CChangeTreeCallback | |
CClosestMilestoneCallback | |
CCombination | A class that enumerates combinations |
CCompositeObjective | An objective that merges contributions from multiple other objective functions |
CCompoundResourceBase | A resource that is composed of multiple sub-objects, which can themselves be considered resources |
CCondition | |
CConfigObjective | A cost that measures distance to a goal configuration qgoal |
CConnectedSeedCallback | |
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 |
CControlSpace | Encodes the dynamics of a system, including the dynamics function f(x,u), control bounds, and available steering functions |
CConvexVolume | |
CCostCSpace | |
CCostGoal | |
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 |
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 |
CCoverageLimitedPathCallback | |
CCSet | A subset of a CSpace, which establishes a constraint for a configuration must meet. Mathematically, this is a set S which imposes the constraint [q in S] |
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 |
►CCSpaceAnalysis | |
CSetCharacteristics | |
CCSpaceConstraintSet | |
CCSpaceInterpolator | An interpolator that uses a CSpace's Interpolate function |
CCubicSplineBasis | |
CCustomContactFormation | A more advanced ContactFormation that accepts custom contact points and custom constraints |
CCustomContactPoint | A contact point with custom force / wrench constraints |
CCustomContactPoint2D | |
CCVSpace | A C-space on configurations and velocities (q,v) that linear uses linear interpolation on velocities |
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 |
CDiffEq2Function | |
CDirectionCosines | 9-D rotation parameterization that lays out the columns of the rotation matrix in a single vector |
CDirtyData | |
CDiscountedEdgeDistance | |
►CDisplacementPlanner | A planner that minimizes the the displacement cost of violated constraints using a RRT-like strategy |
CDynamicShortestPathNode | |
CEdge | |
CMilestone | |
CPathSearchNode | |
CTestResult | Stores all values for a single obstacle displacement test |
CDisplayListManager | |
CDoubleIntegratorBoxBoundedSteeringFunction | |
CDoubleIntegratorControlSpace | |
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 |
CDynamicChain2D | |
CDynamicChain3D | |
CDynamicLink2D | |
CDynamicLink3D | |
CEdgeChecker | An EdgePlanner that just checks a given interpolator or straight line path between two configurations |
CEdgeCollision | |
CEdgeDistance | |
CEdgeLengthFunction | |
CEdgeObjectiveCost | |
CEdgePlanner | Abstract base class for an edge planner / edge checker (i.e., local planner) |
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: |
CEndpointEdgeChecker | Edge planner that only checks the endpoint |
CEpsilonEdgeChecker | Edge checker that divides the path until epsilon resolution is reached |
CEquilibriumTester | Testing COM equilibrium given some number of contacts |
CErrorAccumulator | |
CESTKinodynamicPlanner | The EST planner for kinodynamic systems |
CExplicitMMCSpace | |
CEZCallTrace | Helper class that eases function call tracing |
CEZTrace | A Trace that dumps on destruction. Only one may be active at any time |
CFace | |
CFalseEdgeChecker | Edge planner that is never visible |
CFastFindHeap | 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 | |
CFiniteSet | |
CFixedSizeHeap | 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 |
CFMMInterface | |
CFMMMotionPlanner | |
CFMTAStar | |
CFreeRLG | RLG that sets a virtual linkage of free dof's using analytic IK |
CFrictionConePolygon | Polygonal pyramid representation of the friction cone |
CFuseThreadData | |
CFuseThreadJob | |
CGeneralizedCubicBezierCurve | A generalized Bezier curve that uses the CSpace's Interpolate routine to generate the smooth interpolation |
CGeneralizedCubicBezierSpline | A Bezier spline with segment durations |
CGeodesicCSpace | |
CGeodesicCSpaceAdaptor | |
CGeodesicInterpolator | An interpolator that uses a GeodesicSpace's Interpolate function |
CGeodesicSpace | A space with geodesics and (optionally) geodesic derivatives |
CGeometric2DCollection | |
CGeometric2DCSpace | 2D cspace whose obstacles are geometric primitives |
CGeometric2DEdgeChecker | |
CGeometric2DObstacleFreeSet | |
CGLUINavigationProgram | A 3D navigation program based on GLUI |
CGLUIProgramBase | |
CGLUTNavigationProgram | A 3D navigation program based on GLUT |
CGLUTProgramBase | |
CGreedySubsetAStar | |
CGreedySubsetAStar2 | |
CGrid2DCSpace | A simple CSpace that lets you add geometric obstacles as blocked off grid cells |
►CGrid2Indices | A 2D lattice of irregular ranges |
Citerator | |
CGridDensityEstimator | A grid-based (n-d projected histogram) density estimator |
CHalfEdge | |
CHaltingCondition | A termination condition for a planner. Supports max iteration count, time limit, absolute cost, and cost improvement conditions |
Chash< AnyKeyable > | |
CHConditioner | |
CHeap | Implements a heap that stores objects of type type, with priority keys of type ptype |
CHermiteCSpace | A C-space on configurations and velocities (q,v) that uses Hermite interpolation to construct continuously differentiable curves |
CHermiteSplineBasis | |
CHollowBall | A 3-D annulus innerRadius <= |x-center| <= outerRadius |
CIKGoal | A structure defining a link's desired configuration for IK |
CIKGoalFunction | Function class that returns the position/rotation errors associated with a given IKGoal |
CImage | |
CImageMipmapped | |
CImageOperator | |
CIncrementalCostFunction | |
CIncrementalCostFunctionX | |
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 |
CIncrementalMMPRM_Explicit | |
CIncrementalMMPRM_Search | |
CIndexedPriorityQueue | Contains a priority queue with an associated index, allowing updates of the priority value. Priority defined with lowest value first |
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 |
CIntegratedControlSet | A cartesian-product control space in which groups of states are controlled by individual control spaces |
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 |
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 |
CIntegrationFunction | |
CIntegratorObjectiveFunctional | A cost functional of the form J[x,u] = int_0^T L(x(t),u(t)) dt + Phi(x(T)) |
CInterpolator | A base class for all 1D interpolators |
CInterprocessMessage | |
CInterprocessQueue | |
CIntersectionSet | |
CIntPair | A lightweight integer 2-tuple class |
CIntTriple | A lightweight integer 3-tuple class |
CIntTuple | An integer tuple class |
CJointStructure | Calculates workspace bounds for a robot with constrained links |
CKDTreePointLocation | An accelerated point location algorithm that uses a K-D tree |
CKernelDensityEstimator | Kernel Density Estimation density estimator |
CKeyBezierCubic | |
CKeyCardinal | |
CKeyHermite | |
CKeyTCB | |
CKinematicChain2DTemplate | |
CKinematicChain3DTemplate | |
CKinematicControlSet | |
CKinematicControlSpace | Adapts a kinematic cspace (given to the constructor) to a control space |
CKinematicCSpaceAdaptor | Adapts a kinematic cspace (given to the constructor) to a kinodynamic one |
CKinematicLink2D | |
CKinematicLink3D | |
CKinematicSteeringFunction | |
CKinodynamicLocalOptimizer | |
CKinodynamicMilestonePath | Stores a kinodynamic path with piecewise constant controls |
CKinodynamicPlannerBase | |
CKinodynamicSpace | A class used for kinodynamic planning. Combines a CSpace defining the state space, as well as a ControlSpace |
CKinodynamicSteeringCSpaceAdaptor | Adapts a kinodynamic space with steering function to a kinematic cspace where the steering function is used as the visibility function |
►CKinodynamicTree | Data structure for a kinodynamic planning tree |
CEdgeData | |
CLazyRRTKinodynamicPlanner | A lazy version of kinodynamic RRT |
CLeftPointLess | |
CLengthObjective | An objective that measures path length |
CLessEdgePriority | |
CLinearInterpolator | An interpolator that goes between two Configs |
CLinearSplineBasis | |
CLogitLikelihoodFunction | |
Clsqr_func | |
Clsqr_input | |
Clsqr_output | |
Clsqr_work | |
CMapIterator | |
►CMCRPlanner | A planner that minimizes the the number of violated constraints using a RRT-like strategy |
CEdge | |
CMilestone | |
CMode | |
CTransition | |
►CMCRPlannerGoalSet | A planner that minimizes the the number of violated constraints using a RRT-like strategy |
CEdge | |
CMilestone | |
CMode | |
CTransition | |
CMilestonePath | A sequence of locally planned paths between milestones |
CMotionPlannerFactory | A motion planner creator |
CMotionPlannerInterface | An abstract class for a sample-based motion planner |
CMotionPlanningProblem | A structure to specify the space, endpoints, and cost function of a motion planning problem |
CMultiCSpace | |
CMultiEdgePlanner | An edge planners that plans a stacked list of edges |
CMultiGridDensityEstimator | A multiple-grid based density estimator that attempts to avoid data fragmentation by collecting histograms on multiple axes and fusing them together |
CMultiInterpolator | A cartesian product of interpolators |
CMultiModalCSpace | Multi-modal configuration space base class |
►CMultiModalPRM | |
CModeInfo | |
CTransitionIndex | |
CTransitionInfo | |
CMultiRobot2DCSpace | One or more 2D robots translating and/or rotating in a 2D workspace |
CMutex | |
CNaivePointLocation | The Naive O(n) point location algorithm |
CNegativeVectorFieldFunction | |
CNeighborhoodSet | |
CNewtonEulerSolver | The Featherstone algorithm for O(n) computation of either joint torques from accelerations, or accelerations from torques |
CNodeWithPriority | |
CObjectiveFunctionalBase | A base class for objective functionals of the form J[x,u] = sum_0^N-1 L(xi,ui) dt + Phi(xN) |
CObstacleDisplacementCSpace | A class that needs to be subclassed in order to implement a minimum constraint displacement problem |
CObstacleDistanceEdgeChecker | Edge checker that divides the path until the segment distance is below CSpace.ObstacleDistance() |
COptimalSubsetAStar | |
COptimalSubsetAStar2 | |
COrientedSupportPolygon | Calculation of a support polygon with a non-vertical gravity vector |
CParamList | |
CPathCoordinate | |
CPathCostFunction | |
CPathDynamicEqualityFunction | |
CPathEdgeChecker | An edge checker that checks a sequence of edges |
CPathFeasibilityFunction | |
CPathInfo | |
CPathInterpolator | An interpolator that concatenates a list of other interpolators. The interpolators may have nonuniform duration |
CPathRotation | |
CPathTranslationBezier | |
CPathTranslationCardinal | |
CPathTranslationTCB | |
CPCLParser | |
CPermutation | A class that enumerates permutations |
CPerturbationCSpace | |
CPerturbationTreePlanner | A tree-based randomized planner that extends the roadmap by sampling the neighborhood of existing samples |
CPickCallback | |
CPiecewiseLinearCSpaceInterpolator | |
CPiecewiseLinearInterpolator | |
CPiecewisePolynomialInterpolator | |
CPiggybackCSpace | A helper class that assists with selective overriding of another cspace's methods (similar to "monkey-patching") |
CPiggybackEdgePlanner | |
CPiggybackMotionPlanner | Helper class for higher-order planners – passes all calls to another motion planner |
CPixel | |
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 |
CPointMeshCollider | |
CPointMeshDistance | |
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 |
CPointToSetMotionPlannerAdaptor | Tries to produce a path between a start node and a goal space. Does so via goal sampling / reinitializing |
CPQP_Results | |
CPrimitiveValue | A basic primitive value type, including integers, floats, and strings |
CPRMStarInterface | |
CPRMStarPlanner | Implements the asymptotically optimal kinematic motion planners PRM*, RRT* / RRG*, Lazy-PRM*, and Lazy-RRG*. Also allows the asymptotically sub-optimal method LBT-RRG* |
CProgressPrinter | Prints the progress of an iterative, long computation |
CPropertyMap | A simple map from keys to values |
►CPRTPlanner | The PRT (Probabilistic Roadmap of Trees) planner |
CTree | |
CTreeEdge | |
CPruneCallback | |
CPruneCallback2 | |
CQuadraticObjective | A cost that measures quadratic tracking error and control cost. Note that the time must exist in the state |
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 |
Cr5g6b5 | |
CRandomBestPointLocation | The approximate O(k) point location algorithm that returns the closest of k randomly chosen points |
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 |
CRandomPointLocation | The approximate O(1) point location algorithm that simply returns a random point |
►CRange2Indices | A 2D lattice of regular ranges |
Citerator | |
►CRange3Indices | A 3D lattice of regular ranges |
Citerator | |
►CRangeIndices | A regular range of indices ik = start+k*stride, for k=0 to size-1 |
Citerator | |
CRangeMap | Same as RangeSet, but a map rather than a set. O(1) find as well |
CRangeMap2D | 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 |
CRemoveTreeCallback | |
CResourceBase | A generic "resource" that can be saved/loaded to disk |
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 |
CResourceLibraryResource | A resource that contains a ResourceLibrary. Useful for hierarchical resource libraries |
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 |
CReverseInterpolator | An interpolator that reverses another one |
CReverseKinematicControlSpace | |
CReversibleControlSpace | |
CRigidBodyDynamics | A class for simulating a rigid body. Uses Euler integration |
CRigidBodyVelocity | |
CRigidRobot2DCSpace | Translating and rotating 2D robot in a 2D workspace |
CRigidRobot3DCSpace | Translating and rotating 3D robot in a 3D workspace |
CRLG | A sampler for closed-chain kinematics that takes joint workspace bounds into account |
CRNG48 | Uses the ANSI C rand48 functions |
CRoadmapEdgeInfo | |
CRoadmapPlanner | A base roadmap planner class |
CRoadmapPlannerInterface | |
CRobotCOMFunction | Function class that measures the difference between the robot's center of mass and a desired COM |
CRobotDynamics3D | Class defining kinematic and dynamic state of a robot, with commonly used functions. Inherits from RobotKinematics3D |
CRobotIKFunction | A vector field function class defining C(q)=0 for IK |
CRobotIKSolver | A Newton-Raphson robot IK solver |
CRobotKinematics3D | Class defining kinematics of a robot, and commonly used functions |
CRobotLink3D | Kinematic and physical parameters of a link |
CRobotWithGeometry | The base class for a robot definition |
CRotationAngleFunction | |
CRotationAxisFunction | |
CRRTInterface | |
CRRTKinodynamicPlanner | The RRT planner for kinodynamic systems |
CRRTPlanner | A basic RRT (Rapidly-Exploring Random Tree) planner |
CSawtoothAngleEnvelope | |
CSBLInterface | |
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 |
CSBLPRTInterface | |
►CSBLTree | A tree of configurations to be used in the SBL motion planner |
CEdgeInfo | |
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 |
CScopedLock | |
CSE2CSpace | The space of rigid body transforms SE(2). Still need to implement IsFeasible, PathChecker |
CSE3CSpace | The space of rigid body transforms SE(3). Still need to implement IsFeasible, PathChecker |
CSetComponentCallback | |
CShortcutMotionPlanner | Plans a path and then tries to shortcut it with the remaining time |
CSignalHandler | A base class for an object-oriented signal handler. Properly restores old signal handlers once the class is destroyed |
CSimFunction | |
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 |
CSimplexEnumerator | |
CSimulateFunction | |
CSimulateFunctionX | |
CSmartPointer | A smart pointer class. Performs automatic reference counting |
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 |
CSocketClientTransport | A transport protocol that connects as a client to the given address |
CSocketPipeWorker | Launches a thread for asynchronous bidirectional communication with a socket |
CSocketReadWorker | Launches a thread for asynchronous reading from a socket |
CSocketServerTransport | A transport protocol that hosts a client and sends messages to the clients after they connect |
CSpaceTimeCSpace | A cspace that prepends a time variable to the given CSpace. This is best used with perturbation-sampling planners, and/or SpaceTimeIntegratedKinodynamicCSpace |
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 |
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 |
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) |
CSparseArray | A sparse 1D array class |
CSparseMatrixMultiplier | |
CSpatialMatrix | |
CSpatialVector | |
CSplineBase | |
CSplineBasis | |
CSplineBezierCubic | |
CSplineCardinal | |
CSplineHermite | |
CSplineIterator | |
CSplineLinear | |
CSplineTCB | |
CSplineTimeBase | |
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 |
CData | |
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 |
CStateCostKinodynamicSpace | |
CStateCostSteeringFunction | |
CStatUpdatingEdgePlanner | |
CSteeringFunction | A function in a ControlSpace that attempts to connect two states with a sequence of one or more controls |
CStreamTransport | A transport protocol that uses STL streams |
►CStripe2Indices | A 2D lattice indexing into a linear sequence, in a striping pattern |
Citerator | |
►CStripe3Indices | A 3D lattice indexing into a linear sequence, in a striping pattern |
Citerator | |
CSubset | A finite subset of numbered items with convenient operators for union, intersection, difference, etc |
CSubsetConstraintCSpace | Converts an CSpace so that it only checks one or a subset of selected constraints |
CSubsetCost | |
CSubsetInterpolator | |
CSubspaceSet | Tests whether the range of values from x[imin:imax] is contained within base |
CSupportPolygon | Calculation of the support polygon given a number of contacts |
CSyncPipe | An synchronous reader/writer. User/subclass will initialize the transport protocol (usually blocking I/O) by setting the transport member |
CTable1D | A 1D tabular function interpolated over a grid |
CTabular1DLevelSet | A 1D level set f(x) <= threshold |
CTabular1DObjective | A cost that penalizes via a 1D table lookup of a single index |
CTabular1DSet | A 1D set that includes some marked regions on a grid |
CTabular2DLevelSet | A 2D level set f(x) <= threshold |
CTabular2DObjective | A cost that penalizes via a 2D table lookup of a single index |
CTabular2DSet | A 2D set that includes some marked regions on a grid |
CTabular3DLevelSet | A 3D level set f(x) <= threshold |
CTabular3DObjective | A cost that penalizes via a 3D table lookup of a single index |
CTabular3DSet | A 3D set that includes some marked regions on a grid |
CTerminalCostFunction | |
Ctga_file_header | |
CTimeControlSet | |
CTimeControlSpace | A 1D ControlSpace that simulates time |
CTimeCSpace | 1D cspace in the range [0,inf) but where Sample samples from the range [0,timeStepMax] |
CTimedMilestonePath | |
CTimeIndexCmp | |
CTimeObjective | An objective that measures path execution time. Accumulated time is assumed to be part of the state, specifically the element indexed by timeIndex |
CTimer | |
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 |
CTimerImpl | |
CTimeSteeringFunction | |
CTiXmlElement | |
CTrace | Allows detailed tracing of program execution |
CTraceFunction | |
CTraceFunctionCall | |
CTraceItem | |
CTranslatingRobot2DCSpace | Translating 2D robot in a 2D workspace |
CTransportBase | A base class for a transport protocol for unstructured data |
►CTreeRoadmapPlanner | A base class to be used for tree-based roadmap planners |
CMilestone | |
CTrueEdgeChecker | Edge planner that always is visible |
CUnionFind | From an indexed set of elments, allows fast unioning of the elements into sets |
CUnionSet | |
CUpdatePrioritySPP | |
CVectorizeCallback | |
CVertex | |
►CVisibilityGraphPlanner | |
CVertex | |
CVisibilitySet | |
CWeibullDistribution | |
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 |
CWorldPositionFunction | Function class that returns the world-space position of a point on the robot |
CWrench | |
Cx1r5g5b5 | |