Loading...
Searching...
No Matches
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
| NCommonMath | |
| CBoundary | A struct defining the properties of a plane |
| CConvexObj | An abstract class that defines the required properties of convex objects |
| CRectPrism | A rectangular prism |
| CRotation | |
| CTrajectory | Represents a qunitic polynomial in 3D |
| CVec3 | 3D vector class with common vector operations |
| NConstrainedPlanningCommon | |
| CConstrainedProblem | |
| NConstrainedPlanningSphere | |
| CSphereConstraint | |
| CSphereProjection | |
| Nompl | Main namespace. Contains everything in this library |
| Nbase | This namespace contains sampling based planning routines shared by both planning under geometric constraints (geometric) and planning under differential constraints (dynamic) |
| CAllValidStateValidityChecker | The simplest state validity checker: all states are valid |
| CAtlasChart | Tangent space and bounding polytope approximating some patch of the manifold |
| CAtlasStateSampler | StateSampler for use on an atlas |
| CAtlasStateSpace | ConstrainedStateSpace encapsulating a planner-agnostic atlas algorithm for planning on a constraint manifold |
| CStateType | A state in an atlas represented as a real vector in ambient space and a chart that it belongs to |
| CBridgeTestValidStateSampler | Generate valid samples using bridge test. First sample an invalid state, then sample another invalid state. Take the midpoint of those samples. If midpoint is valid, return. If midpoint is invalid continue |
| CCForestStateSampler | Extended state sampler to use with the CForest planning algorithm. It wraps the user-specified state sampler |
| CCForestStateSpaceWrapper | State space wrapper to use together with CForest. It adds some functionalities to the regular state spaces necessary to CForest |
| CCompoundState | Definition of a compound state |
| CCompoundStateSampler | Definition of a compound state sampler. This is useful to construct samplers for compound states |
| CCompoundStateSpace | A space to allow the composition of state spaces |
| CConditionalStateSampler | The Conditional Sampler samples feasible Space-Time States. First, a space configuration is sampled. Then, a feasible time conditioned on the start and goal states is sampled for the space configuration |
| CMotion | Representation of a motion |
| CConstrainedMotionValidator | Constrained configuration space specific implementation of checkMotion() that uses discreteGeodesic() |
| CConstrainedSpaceInformation | Space information for a constrained state space. Implements more direct for getting motion states |
| CConstrainedStateSpace | A StateSpace that has a Constraint imposed upon it. Underlying space functions are passed to the ambient space, and the constraint is used to inform any manifold related operations. setSpaceInformation() must be called in order for collision checking to be done in tandem with manifold traversal |
| CStateType | A State in a ConstrainedStateSpace, represented as a dense real vector of values. For convenience and efficiency of various Constraint related operations, this State inherits from Eigen::Map<Eigen::VectorXd>, mapping the underlying dense double vector into an Eigen::VectorXd. Note that this state type inherits from WrapperStateSpace::StateType, and as such the underlying state can be accessed by getState() |
| CConstrainedValidStateSampler | Valid state sampler for constrained state spaces |
| CConstraint | Definition of a differentiable holonomic constraint on a configuration space. See Constrained Planning for more details |
| CConstraintObjective | Wrapper around ompl::base::Constraint to use as an optimization objective |
| CControlDurationObjective | Defines optimization objectives where the total time of a control action is summed. This cost function is specified by implementing the controlCost() method |
| CCost | Definition of a cost value. Can represent the cost of a motion or the cost of a state |
| CCostConvergenceTerminationCondition | : A termination condition for stopping an optimizing planner based on cost convergence |
| CDeterministicSequence | An abstract class for deterministic sequences in arbitrary dimensions |
| CDeterministicStateSampler | An abstract class for the concept of using deterministic sampling sequences to decrease the dispersion of the samples |
| CDiscreteMotionValidator | A motion validator that only uses the state validity checker. Motions are checked for validity at a specified resolution |
| CDiscreteStateSampler | State space sampler for discrete states |
| CDiscreteStateSpace | A space representing discrete states; i.e. there are a small number of discrete states the system can be in. States are represented as integers [lowerBound, upperBound], where lowerBound and upperBound are inclusive. States do not wrap around; i.e. the distance between state lowerBound and state upperBound is upperBound-lowerBound. The dimension of the space is 1 |
| CStateType | The definition of a discrete state |
| CDubins3DMotionValidator | A 3D Dubins plane motion validator that only uses the state validity checker. Motions are checked for validity at a specified resolution |
| CDubinsMotionValidator | A Dubins motion validator that only uses the state validity checker. Motions are checked for validity at a specified resolution |
| CDubinsStateSpace | An SE(2) state space where distance is measured by the length of Dubins curves |
| CPathType | Complete description of a Dubins path |
| CEmptyStateSpace | A state space representing an empty state space. This is useful for multilevel representations, where some projections might project onto an empty state space |
| CGaussianValidStateSampler | Generate valid samples using the Gaussian sampling strategy |
| CGenericParam | Motion planning algorithms often employ parameters to guide their exploration process. (e.g., goal biasing). Motion planners (and some of their components) use this class to declare what the parameters are, in a generic way, so that they can be set externally |
| CGoal | Abstract definition of goals |
| CGoalLazySamples | Definition of a goal region that can be sampled, but the sampling process can be slow. This class allows sampling to happen in a separate thread, and the number of goals may increase, as the planner is running, in a thread-safe manner |
| CGoalRegion | Definition of a goal region |
| CGoalSampleableRegion | Abstract definition of a goal region that can be sampled |
| CGoalSpace | Definition of a goal space, i.e., a subspace of the problem state space that defines the goal |
| CGoalState | Definition of a goal state |
| CGoalStates | Definition of a set of goal states |
| CHaltonSequence | Realization of the Halton sequence for the generation of arbitrary dimensional, low-dispersion sequences |
| CHaltonSequence1D | Realization of the Halton sequence for the generation of arbitrary dimensional, low-dispersion sequences |
| CHybridStateSpace | A state space consisting of a space and a time component |
| CHybridTimeStateSampler | State space sampler for time |
| CHybridTimeStateSpace | A state space representing time. The time can be unbounded, in which case enforceBounds() is a no-op, satisfiesBounds() always returns true, sampling uniform time states always produces time 0 and getMaximumExtent() returns 1. If time is bounded (setBounds() has been previously called), the state space behaves as expected. After construction, the state space is unbounded. isBounded() can be used to check if the state space is bounded or not |
| CStateType | The definition of a time state |
| CInformedSampler | An abstract class for the concept of using information about the state space and the current solution cost to limit future search to a planning subproblem that contains all possibly better solutions |
| CInformedStateSampler | A wrapper class that allows an InformedSampler to be used as a StateSampler |
| CIterationTerminationCondition | A class to run a planner for a specific number of iterations. Casts to a PTC for use with Planner::solve |
| CKleinBottleStateSampler | State sampler for the Klein bottle state space |
| CKleinBottleStateSpace | The Klein bottle is a 2-dimensional non-orientable surface. In this class, we implement a 3-dimensional immersion of the Bottle |
| CStateType | The definition of a state (u,v) in the Klein bottle state space. A state is represented as a cylinder with height u in the interval [0, Pi] and angle v in the interval [-Pi, Pi] as in the discussion here: https://en.wikipedia.org/wiki/Klein_bottle#Construction |
| CMaximizeClearanceValidStateSampler | Generate valid samples randomly, but with a bias towards higher clearance |
| CMaximizeMinClearanceObjective | Objective for attempting to maximize the minimum clearance along a path |
| CMechanicalWorkOptimizationObjective | An optimization objective which defines path cost using the idea of mechanical work. To be used in conjunction with TRRT |
| CMinimaxObjective | The cost of a path is defined as the worst state cost over the entire path. This objective attempts to find the path with the "best worst cost" over all paths |
| CMinimizeArrivalTime | The cost of a path is defined as the highest time value along its states. This objective attempts to optimize for the minimum arrival time |
| CMinimumClearanceValidStateSampler | Generate valid samples randomly with extra requirement of min for clearance to nearest obstacle |
| CMobiusStateSpace | The Mobius strip is a 2-dimensional non-orientable surface |
| CStateType | The definition of a state (u,v) in the Mobius strip state space. The variable u is the position on the center circle in the interval [-Pi, Pi] The variable v is the position along the width in the interval [-intervalMax, intervalMax] |
| CMotionValidator | Abstract definition for a class checking the validity of motions – path segments between states. This is often called a local planner. The implementation of this class must be thread safe |
| CMultiOptimizationObjective | This class allows for the definition of multiobjective optimal planning problems. Objectives are added to this compound object, and motion costs are computed by taking a weighted sum of the individual objective costs |
| CComponent | Defines a pairing of an objective and its weight |
| CObstacleBasedValidStateSampler | Generate valid samples using obstacle based sampling. First sample an invalid state, then sample a valid state. Then, interpolate from the invalid state to the valid state, returning the first valid state encountered |
| COptimizationObjective | Abstract definition of optimization objectives |
| COrderedInfSampler | An informed sampler wrapper that generates m samples and then returns them in order of the heuristic |
| COwenStateSpace | An R^3 x SO(2) state space where distance is measured by the length of a type Dubins airplane curves |
| CPathType | |
| CStateType | |
| CParamSet | Maintain a set of parameters |
| CPath | Abstract definition of a path |
| CPathLengthDirectInfSampler | An informed sampler for problems seeking to minimize path length |
| CPathLengthOptimizationObjective | An optimization objective which corresponds to optimizing path length |
| CPlanner | Base class for a planner |
| CPlannerData | Object containing planner generated vertex and edge data. It is assumed that all vertices are unique, and only a single directed edge connects two vertices |
| CGraph | Wrapper class for the Boost.Graph representation of the PlannerData. This class inherits from a boost::adjacency_list Graph structure |
| CPlannerDataEdge | Base class for a PlannerData edge |
| CPlannerDataStorage | Object that handles loading/storing a PlannerData object to/from a binary stream. Serialization of vertices and edges is performed using the Boost archive method serialize. Derived vertex/edge classes are handled, presuming those classes implement the serialize method |
| CHeader | Information stored at the beginning of the PlannerData archive |
| CPlannerDataVertexData | The object containing all vertex data that will be stored |
| CPlannerDataEdgeData | The object containing all edge data that will be stored |
| CPlannerDataVertex | Base class for a vertex in the PlannerData structure. All derived classes must implement the clone and equivalence operators. It is assumed that each vertex in the PlannerData structure is unique (i.e. no duplicates allowed) |
| CPlannerInputStates | Helper class to extract valid start & goal states. Usually used internally by planners |
| CPlannerSolution | Representation of a solution to a planning problem |
| CPlannerSpecs | Properties that planners may have |
| CPlannerStatus | A class to store the exit status of Planner::solve() |
| CPlannerTerminationCondition | Encapsulate a termination condition for a motion planner. Planners will call operator() to decide whether they should terminate before a solution is found or not. operator() will return true if either the implemented condition is met (the call to eval() returns true) or if the user called terminate(true) |
| CPrecomputedSequence | General realization for a sampler of precomputed sequences or sets |
| CPrecomputedStateSampler | State space sampler for discrete states |
| CProblemDefinition | Definition of a problem to be solved. This includes the start state(s) for the system and a goal specification. Will contain solutions, if found |
| CProjectedStateSampler | StateSampler for use for a projection-based state space |
| CProjectedStateSpace | ConstrainedStateSpace encapsulating a projection-based methodology for planning with constraints |
| CProjectionEvaluator | Abstract definition for a class computing projections to Rn. Implicit integer grids are imposed on this projection space by setting cell sizes. Before use, the user must supply cell sizes for the integer grid (setCellSizes()). The implementation of this class is thread safe |
| CProjectionMatrix | A projection matrix – it allows multiplication of real vectors by a specified matrix. The matrix can also be randomly generated |
| CRealVectorBounds | The lower and upper bounds for an Rn space |
| CRealVectorDeterministicStateSampler | Deterministic state sampler for the Rn state space |
| CRealVectorIdentityProjectionEvaluator | Define the identity projection |
| CRealVectorLinearProjectionEvaluator | Definition for a class computing linear projections (multiplication of a k-by-n matrix to the the Rn vector state to produce an Rk projection. The multiplication matrix needs to be supplied as input |
| CRealVectorOrthogonalProjectionEvaluator | Definition for a class computing orthogonal projections |
| CRealVectorRandomLinearProjectionEvaluator | Definition for a class computing a random linear projections |
| CRealVectorStateSampler | State sampler for the Rn state space |
| CRealVectorStateSpace | A state space representing Rn. The distance function is the L2 norm |
| CStateType | The definition of a state in Rn |
| CReedsSheppStateSpace | An SE(2) state space where distance is measured by the length of Reeds-Shepp curves |
| CPathType | Complete description of a ReedsShepp path |
| CRejectionInfSampler | A default rejection sampling scheme that samples uniformly from the entire planning domain. Samples are rejected until one is found that has a heuristic solution estimate that is less than the current solution. In general, direct sampling of the informed subset is much better, but this is a general default |
| CSamplerSelector | Depending on the type of state sampler, we have different allocation routines |
| CScopedState | Definition of a scoped state |
| CSE2DeterministicStateSampler | Deterministic state sampler for the Rn state space |
| CSE2StateSpace | A state space representing SE(2) |
| CStateType | A state in SE(2): (x, y, yaw) |
| CSE3StateSpace | A state space representing SE(3) |
| CStateType | A state in SE(3): position = (x, y, z), quaternion = (x, y, z, w) |
| CSO2DeterministicStateSampler | Deterministic state space sampler for SO(2) |
| CSO2StateSampler | State space sampler for SO(2) |
| CSO2StateSpace | A state space representing SO(2). The distance function and interpolation take into account angle wrapping |
| CStateType | The definition of a state in SO(2) |
| CSO3StateSampler | State space sampler for SO(3), using quaternion representation |
| CSO3StateSpace | A state space representing SO(3). The internal representation is done with quaternions. The distance between states is the angle between quaternions and interpolation is done with slerp |
| CStateType | The definition of a state in SO(3) represented as a unit quaternion |
| CSolutionNonExistenceProof | Abstract definition of a proof for the non-existence of a solution to a problem |
| CSpaceInformation | The base class for space information. This contains all the information about the space planning is done in. setup() needs to be called as well, before use |
| CSpaceTimeStateSpace | A state space consisting of a space and a time component |
| CSpecificParam | This is a helper class that instantiates parameters with different data types |
| CSphereStateSampler | State sampler for the sphere state space |
| CSphereStateSpace | |
| CStateType | |
| CState | Definition of an abstract state |
| CStateCostIntegralObjective | Defines optimization objectives where path cost can be represented as a path integral over a cost function defined over the state space. This cost function is specified by implementing the stateCost() method |
| CStateSampler | Abstract definition of a state space sampler |
| CStateSamplerArray | Class to ease the creation of a set of samplers. This is especially useful for multi-threaded planners |
| CStateSpace | Representation of a space in which planning can be performed. Topology specific sampling, interpolation and distance are defined |
| CSubstateLocation | Representation of the address of a substate in a state. This structure stores the indexing information needed to access a particular substate of a state |
| CValueLocation | Representation of the address of a value in a state. This structure stores the indexing information needed to access elements of a state (no pointer values are stored) |
| CStateStorage | Manage loading and storing for a set of states of a specified state space |
| CHeader | Information stored at the beginning of the archive |
| CStateStorageWithMetadata | State storage that allows storing state metadata as well |
| CStateValidityChecker | Abstract definition for a class checking the validity of states. The implementation of this class must be thread safe |
| CStateValidityCheckerSpecs | Properties that a state validity checker may have |
| CSubspaceProjectionEvaluator | If the projection for a CompoundStateSpace is supposed to be the same as the one for one of its included subspaces, this class facilitates selecting a projection of that subspace |
| CSubspaceStateSampler | Construct a sampler that samples only within a subspace of the space |
| CTangentBundleSpaceInformation | Space information for a tangent bundle-based state space. Implements more direct for getting motion states and checking motion, as the lazy approach requires post-processing |
| CTangentBundleStateSpace | ConstrainedStateSpace encapsulating a planner-agnostic lazy atlas algorithm for planning on a constraint manifold |
| CTimeStateSampler | State space sampler for time |
| CTimeStateSpace | A state space representing time. The time can be unbounded, in which case enforceBounds() is a no-op, satisfiesBounds() always returns true, sampling uniform time states always produces time 0 and getMaximumExtent() returns 1. If time is bounded (setBounds() has been previously called), the state space behaves as expected. After construction, the state space is unbounded. isBounded() can be used to check if the state space is bounded or not |
| CStateType | The definition of a time state |
| CTorusStateSampler | State sampler for the torus state space |
| CTorusStateSpace | |
| CStateType | |
| CTrochoidStateSpace | An SE(2) state space where distance is measured by the length of Trochoid shortest paths curves |
| CPathType | Complete description of a Dubins path |
| CTypedSpaceInformation | |
| CTypedStateValidityChecker | |
| CUniformValidStateSampler | A state sampler that only samples valid states, uniformly |
| CValidStateSampler | Abstract definition of a state sampler |
| CVanaOwenStateSpace | An R^4 x SO(2) state space where distance is measured by the length of a type of Dubins airplane curves |
| CPathType | |
| CStateType | |
| CVanaStateSpace | An R^4 x SO(2) state space where distance is measured by the length of a type Dubins airplane curves |
| CPathType | |
| CStateType | |
| CVFMechanicalWorkOptimizationObjective | |
| CVFUpstreamCriterionOptimizationObjective | |
| CWrapperProjectionEvaluator | A projection evaluator that wraps around another projection evaluator |
| CWrapperStateSampler | A state sampler that wraps around another state sampler |
| CWrapperStateSpace | State space wrapper that transparently passes state space operations through to the underlying space. Allows augmentation of state spaces with additional information |
| CStateType | Wrapper state type. Contains a reference to an underlying state |
| Ncontrol | This namespace contains sampling based planning routines used by planning under differential constraints |
| CAutomaton | A class to represent a deterministic finite automaton, each edge of which corresponds to a World. A system trajectory, by way of project() and worldAtRegion() in PropositionalDecomposition, determines a sequence of Worlds, which are read by an Automaton to determine whether a trajectory satisfies a given specification |
| CTransitionMap | Each automaton state has a transition map, which maps from a World to another automaton state. A set \(P\) of true propositions correponds to the formula \(\bigwedge_{p\in P} p\) |
| CCompoundControl | Definition of a compound control |
| CCompoundControlSampler | Definition of a compound control sampler. This is useful to construct samplers for compound controls |
| CCompoundControlSpace | A control space to allow the composition of control spaces |
| CControl | Definition of an abstract control |
| CControlSampler | Abstract definition of a control sampler. Motion planners that need to sample controls will call functions from this class. Planners should call the versions of sample() and sampleNext() with most arguments, whenever this information is available |
| CControlSpace | A control space representing the space of applicable controls |
| CDecomposition | A Decomposition is a partition of a bounded Euclidean space into a fixed number of regions which are denoted by integers |
| CDirectedControlSampler | Abstract definition of a directed control sampler. Motion planners that need to sample controls that take the system to a desired direction will call functions from this class. Planners should call the versions of sampleTo() with most arguments, whenever this information is available. If no direction information is available, the use of a ControlSampler is perhaps more appropriate |
| CDiscreteControlSampler | Control space sampler for discrete controls |
| CDiscreteControlSpace | A space representing discrete controls; i.e. there are a small number of discrete controls the system can react to. Controls are represented as integers [lowerBound, upperBound], where lowerBound and upperBound are inclusive |
| CControlType | The definition of a discrete control |
| CEST | Expansive Space Trees |
| CMotion | Representation of a motion |
| CMotionInfo | A struct containing an array of motions and a corresponding PDF element |
| CTreeData | The data contained by a tree of exploration |
| CGridDecomposition | A GridDecomposition is a Decomposition implemented using a grid |
| CHyRRT | Hybrid Rapidly-exploring Random Trees |
| CMotion | Representation of a motion in the search tree |
| CHySST | |
| CMotion | Representation of a motion |
| CWitness | Representation of a witness vertex in the search tree |
| CKPIECE1 | Kinodynamic Planning by Interior-Exterior Cell Exploration |
| CMotion | Representation of a motion for this algorithm |
| CCellData | The data held by a cell in the grid of motions |
| COrderCellsByImportance | Definintion of an operator passed to the Grid structure, to order cells by importance |
| CCloseSample | Information about a known good sample (closer to the goal than others) |
| CCloseSamples | Bounded set of good samples |
| CTreeData | The data defining a tree of motions for this algorithm |
| CLTLPlanner | A planner for generating system trajectories to satisfy a logical specification given by an automaton, the propositions of which are defined over a decomposition of the system's state space |
| CMotion | Representation of a motion |
| CProductGraphStateInfo | A structure to hold measurement information for a high-level state, as well as the set of tree motions belonging to that high-level state. Exactly one ProductGraphStateInfo will exist for each ProductGraph::State |
| CLTLProblemDefinition | |
| CLTLSpaceInformation | |
| CODEAdaptiveSolver | Adaptive step size solver for ordinary differential equations of the type q' = f(q, u), where q is the current state of the system and u is a control applied to the system. The maximum integration error is bounded in this approach. Solver is the numerical integration method used to solve the equations, and must implement the error stepper concept from boost::numeric::odeint. The default is a fifth order Runge-Kutta Cash-Karp method with a fourth order error bound |
| CODEBasicSolver | Basic solver for ordinary differential equations of the type q' = f(q, u), where q is the current state of the system and u is a control applied to the system. StateType defines the container object describing the state of the system. Solver is the numerical integration method used to solve the equations. The default is a fourth order Runge-Kutta method. This class wraps around the simple stepper concept from boost::numeric::odeint |
| CODEErrorSolver | Solver for ordinary differential equations of the type q' = f(q, u), where q is the current state of the system and u is a control applied to the system. StateType defines the container object describing the state of the system. Solver is the numerical integration method used to solve the equations. The default is a fifth order Runge-Kutta Cash-Karp method with a fourth order error bound. This class wraps around the error stepper concept from boost::numeric::odeint |
| CODESolver | Abstract base class for an object that can solve ordinary differential equations (ODE) of the type q' = f(q,u) using numerical integration. Classes deriving from this must implement the solve method. The user must supply the ODE to solve |
| CPathControl | Definition of a control path |
| CPDST | Path-Directed Subdivision Tree |
| CMotionCompare | Comparator used to order motions in the priority queue |
| CMotion | Class representing the tree of motions exploring the state space |
| CCell | Cell is a Binary Space Partition |
| CPlannerData | Object containing planner generated vertex and edge data. It is assumed that all vertices are unique, and only a single directed edge connects two vertices. |
| CPlannerDataEdgeControl | Representation of an edge in PlannerData for planning with controls. This structure encodes a specific control and a duration to apply the control |
| CPlannerDataStorage | Object that handles loading/storing a PlannerData object to/from a binary stream. Serialization of vertices and edges is performed using the Boost archive method serialize. Derived vertex/edge classes are handled, presuming those classes implement the serialize method. |
| CProductGraph | A ProductGraph represents the weighted, directed, graph-based Cartesian product of a PropositionalDecomposition object, an Automaton corresponding to a co-safe LTL specification, and an Automaton corresponding to a safe LTL specification |
| CState | A State of a ProductGraph represents a vertex in the graph-based Cartesian product represented by the ProductGraph. A State is simply a tuple consisting of a PropositionalDecomposition region, a co-safe Automaton state, and a safe Automaton state |
| CEdge | |
| CPropositionalDecomposition | A propositional decomposition wraps a given Decomposition with a region-to-proposition assignment operator. Each region in the decomposition has a corresponding World |
| CPropositionalTriangularDecomposition | A PropositionalTriangularDecomposition is a triangulation that ignores obstacles and respects propositional regions of interest. Practically speaking, it is both a TriangularDecomposition and a PropositionalDecomposition, but it is implemented without using multiple inheritance |
| CRealVectorControlSpace | A control space representing Rn |
| CControlType | The definition of a control in Rn |
| CRealVectorControlUniformSampler | Uniform sampler for the Rn state space |
| CRRT | Rapidly-exploring Random Tree |
| CMotion | Representation of a motion |
| CSimpleDirectedControlSampler | Implementation of a simple directed control sampler. This is a basic implementation that does not actually take direction into account and builds upon ControlSampler. Instead, a set of k random controls are sampled, and the control that gets the system closest to the target state is returned |
| CSimpleSetup | Create the set of classes typically needed to solve a control problem |
| CSpaceInformation | Space information containing necessary information for planning with controls. setup() needs to be called before use |
| CSST | |
| CMotion | Representation of a motion |
| CWitness | |
| CStatePropagator | Model the effect of controls on system states |
| CSteeredControlSampler | Abstract definition of a steered control sampler. It uses the steering function in a state propagator to find the controls that drive from one state to another |
| CSyclop | Synergistic Combination of Layers of Planning |
| CDefaults | Contains default values for Syclop parameters |
| CMotion | Representation of a motion |
| CRegion | Representation of a region in the Decomposition assigned to Syclop |
| CAdjacency | Representation of an adjacency (a directed edge) between two regions in the Decomposition assigned to Syclop |
| CSyclopEST | SyclopEST is Syclop with EST as its low-level tree planner. |
| CSyclopRRT | SyclopRRT is Syclop with RRT as its low-level tree planner. |
| CTriangularDecomposition | A TriangularDecomposition is a triangulation that ignores obstacles |
| CVertex | |
| CPolygon | |
| CTriangle | |
| CWorld | A class to represent an assignment of boolean values to propositions. A World can be partially restrictive, i.e., some propositions do not have to be assigned a value, in which case it can take on any value. Our notion of a World is similar to a set of truth assignments in propositional logic |
| Ngeometric | This namespace contains code that is specific to planning under geometric constraints |
| Naitstar | |
| CEdge | |
| CImplicitGraph | |
| CVertex | |
| Nblitstar | |
| CImplicitGraph | |
| CVertex | |
| Neitstar | |
| CEdge | A struct for basic edge data |
| CForwardQueue | |
| Cpair_hash | |
| CRandomGeometricGraph | |
| CReverseQueue | |
| CState | A wrapper class for OMPL's state |
| CVertex | The vertex class for both the forward and reverse search |
| CABITstar | Advanced Batch Informed Trees (ABIT*) |
| CAITstar | Adaptively Informed Trees (AIT*) |
| CAnytimePathShortening | |
| CAORRTC | Asymptotically Optimal RRT-Connect |
| CAOXRRTConnect | Modified RRT-Connect for AORRTC (AOXRRTConnect) |
| CMotion | Representation of a motion |
| CTreeGrowingInfo | Information attached to growing a tree of motions (used internally) |
| CATRRT | Transition-based Rapidly-exploring Random Trees |
| CMotion | Representation of a motion |
| CMotionCostComparator | Bool stating which motion cost is better |
| CBFMT | Bidirectional Asymptotically Optimal Fast Marching Tree algorithm developed by J. Starek, J.V. Gomez, et al |
| CBiDirMotion | Representation of a bidirectional motion |
| CBiDirMotionCompare | Comparator used to order motions in a binary heap |
| CCostIndexCompare | |
| CBiEST | Bi-directional Expansive Space Trees |
| CMotion | The definition of a motion |
| CBiRLRT | Bi-directional Range-Limited Random Tree (Ryan Luna's Random Tree) |
| CMotion | A motion (tree node) with parent pointer |
| CBiTRRT | Bi-directional Transition-based Rapidly-exploring Random Trees |
| CMotion | Representation of a motion in the search tree |
| CBITstar | Batch Informed Trees (BIT*) |
| CCostHelper | A helper class to handle the various heuristic functions in one place |
| CIdGenerator | An ID generator class for vertex IDs |
| CImplicitGraph | A conceptual representation of samples as an edge-implicit random geometric graph |
| CSearchQueue | A queue of edges, sorted according to a sort key |
| CVertex | The vertex of the underlying graphs in gBITstar BIT* |
| CBKPIECE1 | Bi-directional KPIECE with one level of discretization |
| CMotion | Representation of a motion for this algorithm |
| CBLITstar | |
| CCForest | Coupled Forest of Random Engrafting Search Trees |
| CDiscretization | One-level discretization used for KPIECE |
| CCellData | The data held by a cell in the grid of motions |
| COrderCellsByImportance | Definintion of an operator passed to the Grid structure, to order cells by importance |
| CEIRMstar | Effort Informed Roadmaps (EIRM*) |
| CEITstar | Effort Informed Trees (EIT*) |
| CEST | Expansive Space Trees |
| CMotion | The definition of a motion |
| CFMT | Asymptotically Optimal Fast Marching Tree algorithm developed by L. Janson and M. Pavone |
| CMotion | Representation of a motion |
| CMotionCompare | Comparator used to order motions in a binary heap |
| CCostIndexCompare | |
| CGeneticSearch | Genetic Algorithm for searching valid states |
| CHillClimbing | Hill Climbing search |
| CInformedRRTstar | Informed RRT* |
| CKBoundedStrategy | Return at most k neighbors, as long as they are also within a specified bound |
| CKPIECE1 | Kinematic Planning by Interior-Exterior Cell Exploration |
| CMotion | Representation of a motion for this algorithm |
| CKStarStrategy | Make the minimal number of connections required to ensure asymptotic optimality |
| CKStrategy | |
| CLazyLBTRRT | Rapidly-exploring Random Trees |
| CMotion | Representation of a motion |
| CCostEstimatorApx | |
| CCostEstimatorLb | |
| CLazyPRM | Lazy Probabilistic RoadMap planner |
| Cvertex_state_t | |
| Cvertex_flags_t | |
| Cvertex_component_t | |
| Cedge_flags_t | |
| CLazyPRMstar | PRM* planner |
| CLazyRRT | Lazy RRT |
| CMotion | Representation of a motion |
| CLBKPIECE1 | Lazy Bi-directional KPIECE with one level of discretization |
| CMotion | Representation of a motion for this algorithm |
| CLBTRRT | Lower Bound Tree Rapidly-exploring Random Trees |
| CMotion | Representation of a motion |
| CIsLessThan | Comparator - metric is the cost to reach state via a specific state |
| CIsLessThanLB | Comparator - metric is the lower bound cost |
| CLightningRetrieveRepair | The Lightning Framework's Retrieve-Repair component |
| CPathGeometric | Definition of a geometric path |
| CPathHybridization | Given multiple geometric paths, attempt to combine them in order to obtain a shorter solution |
| CPathSimplifier | This class contains routines that attempt to simplify geometric paths |
| CPDST | Path-Directed Subdivision Tree |
| CMotionCompare | Comparator used to order motions in the priority queue |
| CMotion | Class representing the tree of motions exploring the state space |
| CCell | Cell is a Binary Space Partition |
| CPRM | Probabilistic RoadMap planner |
| Cvertex_state_t | |
| Cvertex_total_connection_attempts_t | |
| Cvertex_successful_connection_attempts_t | |
| CPRMstar | PRM* planner |
| CProjEST | Expansive Space Trees |
| CMotion | The definition of a motion |
| CMotionInfo | A struct containing an array of motions and a corresponding PDF element |
| CTreeData | The data contained by a tree of exploration |
| CpRRT | Parallel RRT |
| CMotion | |
| CSolutionInfo | |
| CpSBL | Parallel Single-query Bi-directional Lazy collision checking planner |
| CMotion | |
| CMotionInfo | A struct containing an array of motions and a corresponding PDF element |
| CTreeData | |
| CSolutionInfo | |
| CPendingRemoveMotion | |
| CMotionsToBeRemoved | |
| CRLRT | Range-Limited Random Tree (Ryan Luna's Random Tree) |
| CMotion | A motion (tree node) with parent pointer |
| CRRT | Rapidly-exploring Random Trees |
| CMotion | Representation of a motion |
| CRRTConnect | RRT-Connect (RRTConnect) |
| CMotion | Representation of a motion |
| CTreeGrowingInfo | Information attached to growing a tree of motions (used internally) |
| CRRTsharp | Optimal Rapidly-exploring Random Trees Maintaining An Optimal Tree |
| CRRTstar | Optimal Rapidly-exploring Random Trees |
| CMotion | Representation of a motion |
| CCostIndexCompare | |
| CRRTXstatic | Optimal Rapidly-exploring Random Trees Maintaining A Pseudo Optimal Tree |
| CMotionCompare | Defines the operator to compare motions |
| CMotion | Representation of a motion (node of the tree) |
| CSBL | Single-Query Bi-Directional Probabilistic Roadmap Planner with Lazy Collision Checking |
| CMotion | Representation of a motion |
| CMotionInfo | A struct containing an array of motions and a corresponding PDF element |
| CTreeData | Representation of a search tree. Two instances will be used. One for start and one for goal |
| CSimpleSetup | Create the set of classes typically needed to solve a geometric problem |
| CSORRTstar | SORRT* |
| CSPARS | SPArse Roadmap Spanner technique. |
| Cvertex_state_t | |
| Cvertex_representative_t | |
| Cvertex_color_t | |
| Cvertex_list_t | |
| Cvertex_interface_list_t | |
| CSPARSdb | SPArse Roadmap Spanner Version 2.0 |
| CInterfaceData | Interface information storage class, which does bookkeeping for criterion four |
| CInterfaceHashStruct | |
| Cvertex_state_t | |
| Cvertex_color_t | |
| Cvertex_interface_data_t | |
| Cedge_collision_state_t | |
| CCandidateSolution | Struct for passing around partially solved solutions |
| CedgeWeightMap | |
| CfoundGoalException | |
| CCustomVisitor | |
| CSPARStwo | SPArse Roadmap Spanner Version 2.0 |
| CInterfaceData | Interface information storage class, which does bookkeeping for criterion four |
| Cvertex_state_t | |
| Cvertex_color_t | |
| Cvertex_interface_data_t | |
| CSST | |
| CMotion | Representation of a motion |
| CWitness | |
| CSTRIDE | Search Tree with Resolution Independent Density Estimation |
| CMotion | The definition of a motion |
| CSTRRTstar | Space-Time RRT* (STRRTstar) |
| CTreeGrowingInfo | Information attached to growing a tree of motions (used internally) |
| CTaskSpaceConfig | |
| CThunderRetrieveRepair | The Thunder Framework's Retrieve-Repair component |
| CTRRT | Transition-based Rapidly-exploring Random Trees |
| CMotion | Representation of a motion |
| CTRRTstar | Optimal Transition-based Rapidly-exploring Random Trees |
| CMotion | Representation of a motion |
| CCostIndexCompare | |
| CTSRRT | Task-space Rapidly-exploring Random Trees |
| CMotion | Representation of a motion |
| CVFRRT | |
| CXXL | |
| CPerfectSet | |
| CMotion | |
| CRegion | |
| CLayer | |
| CXXLDecomposition | |
| CXXLPlanarDecomposition | |
| CXXLPositionDecomposition | |
| Nmsg | Message namespace. This contains classes needed to output error messages (or logging) from within the library. Message logging can be performed with logging macros |
| COutputHandler | Generic class to handle output from a piece of code |
| COutputHandlerSTD | Default implementation of OutputHandler. This sends the information to the console |
| COutputHandlerFile | Implementation of OutputHandler that saves messages in a file |
| Nmultilevel | This namespace contains datastructures and planners to exploit multilevel abstractions, which you have to specify using a sequence of SpaceInformationPtr (each with their own StateValidityChecker) |
| CBundleSpace | A single Bundle-space |
| CBundleSpaceGraph | A graph on a Bundle-space |
| CConfiguration | A configuration in Bundle-space |
| CEdgeInternalState | An edge in Bundle-space |
| CGraphMetaData | |
| CBundleSpaceGraphSampler | |
| CBundleSpaceGraphSamplerRandomDegreeVertex | |
| CBundleSpaceGraphSamplerRandomEdge | |
| CBundleSpaceGraphSamplerRandomVertex | |
| CBundleSpaceImportance | |
| CBundleSpaceImportanceExponential | |
| CBundleSpaceImportanceGreedy | |
| CBundleSpaceImportanceUniform | |
| CBundleSpaceMetric | |
| CBundleSpaceMetricGeodesic | |
| CBundleSpacePropagator | |
| CBundleSpacePropagatorGeometric | |
| CBundleSpaceSequence | A planner for a sequence of BundleSpaces |
| CCmpBundleSpacePtrs | Compare function for priority queue |
| CCompoundProjection | |
| CFiberedProjection | |
| CFindSection | |
| CFindSectionSideStep | |
| CHead | A pointer to a specific location on the base path of the path restriction |
| CHeadAnalyzer | |
| CPathRestriction | Representation of path restriction (union of fibers over a base path) |
| CPathSection | Representation of a path section (not necessarily feasible) |
| CPlannerDataVertexAnnotated | An annotated vertex, adding information about its level in the multilevel hierarchy. Class has two modes: Mode 1 (baseMode), we store a reference to its base state element. In Mode 2 (totalMode), we store a deep copy of the lift of the base state into the total space (NOTE: required for PlannerData functions like decoupleFromPlanner()) |
| CPlannerMultiLevel | MultiLevel Planner Interface. Extends base::Planner by allowing sequences of base::SpaceInformationPtr |
| CProjection | |
| CProjection_EmptySet | |
| CProjection_Identity | |
| CProjection_None | |
| CProjection_Relaxation | |
| CProjection_RN_RM | |
| CProjection_RNSO2_RN | |
| CProjection_SE2_R2 | |
| CProjection_SE2RN_R2 | |
| CProjection_SE2RN_SE2 | |
| CProjection_SE2RN_SE2RM | |
| CProjection_SE3_R3 | |
| CProjection_SE3RN_R3 | |
| CProjection_SE3RN_SE3 | |
| CProjection_SE3RN_SE3RM | |
| CProjection_SO2N_SO2M | |
| CProjection_SO2RN_SO2 | |
| CProjection_SO2RN_SO2RM | |
| CProjection_SO3RN_SO3 | |
| CProjection_SO3RN_SO3RM | |
| CProjection_XRN_X | |
| CProjection_XRN_XRM | |
| CProjectionFactory | |
| CQMPImpl | Implementation of the Quotient space roadMap Planner |
| CQMPStarImpl | |
| CQRRTImpl | Implementation of BundleSpace Rapidly-Exploring Random Trees Algorithm |
| CQRRTStarImpl | Implementation of BundleSpace Rapidly-Exploring Random Tree Star Algorithm |
| Ntime | Namespace containing time datatypes and time operations |
| CProgressDisplay | |
| Ntools | Includes various tools such as self config, benchmarking, etc |
| CBenchmark | Benchmark a set of planners on a problem instance |
| CStatus | This structure contains information about the activity of a benchmark instance. If the instance is running, it is possible to find out information such as which planner is currently being tested or how much |
| CRunProperties | The data collected from a run of a planner is stored as key-value pairs |
| CPlannerExperiment | The data collected after running a planner multiple times |
| CCompleteExperiment | This structure holds experimental data for a set of planners |
| CRequest | Representation of a benchmark request |
| CDynamicTimeWarp | |
| CExperienceSetup | Create the set of classes typically needed to solve a geometric problem |
| CExperienceStats | Simple logging functionality encapsled in a struct |
| CExperienceLog | Single entry for the csv data logging file |
| CLightning | Built off of SimpleSetup but provides support for planning from experience |
| CLightningDB | Save and load entire paths from file |
| COptimizePlan | Run one or more motion planners repeatedly (using a specified number of threads), and hybridize solutions, trying to optimize solutions |
| CParallelPlan | This is a utility that allows executing multiple planners in parallel, until one or more find a solution. Optionally, the results are automatically hybridized using ompl::geometric::PathHybridization. Between calls to solve(), the set of known solutions (maintained by ompl::base::Goal) are not cleared, and neither is the hybridization datastructure |
| CPlannerMonitor | Monitor the properties a planner exposes, as the planner is running. Dump the planner properties to a stream, periodically |
| CProfiler | This is a simple thread-safe tool for counting time spent in various chunks of code. This is different from external profiling tools in that it allows the user to count time spent in various bits of code (sub-function granularity) or count how many times certain pieces of code are executed |
| CScopedBlock | This instance will call Profiler::begin() when constructed and Profiler::end() when it goes out of scope |
| CScopedStart | This instance will call Profiler::start() when constructed and Profiler::stop() when it goes out of scope. If the profiler was already started, this block's constructor and destructor take no action |
| CSelfConfig | This class contains methods that automatically configure various parameters for motion planning. If expensive computation is performed, the results are cached |
| CThunder | Built off of SimpleSetup but provides support for planning from experience |
| CThunderDB | Save and load entire paths from file |
| Nvamp | |
| CVampMotionValidator | |
| CVampStateSpace | |
| CVampStateValidityChecker | |
| CAdjacencyList | |
| CBinaryHeap | This class provides an implementation of an updatable min-heap. Using it is a bit cumbersome, as it requires keeping track of the BinaryHeap::Element* type, however, it should be as fast as it gets with an updatable heap |
| CElement | When an element is added to the heap, an instance of Element* is created. This instance contains the data that was added and internal information about the position of the data in the heap's internal storage |
| CDynamicSSSP | |
| CException | The exception type for ompl |
| CFLANNDistance | Wrapper class to allow FLANN access to the NearestNeighbors::distFun_ callback function |
| CGreedyKCenters | An instance of this class can be used to greedily select a given number of representatives from a set of data points that are all far apart from each other |
| CGrid | Representation of a simple grid |
| CCell | Definition of a cell in this grid |
| CHashFunCoordPtr | |
| CEqualCoordPtr | Equality operator for coordinate pointers |
| CSortComponents | Helper to sort components by size |
| CGridB | This class defines a grid that keeps track of its boundary: it distinguishes between interior and exterior cells |
| CLessThanInternalCell | Define order for internal cells |
| CLessThanExternalCell | Define order for external cells |
| CGridN | Representation of a grid where cells keep track of how many neighbors they have |
| CCell | Definition of a cell in this grid |
| CLPAstarOnGraph | |
| CNearestNeighbors | Abstract representation of a container that can perform nearest neighbors queries |
| CNearestNeighborsFLANN | Wrapper class for nearest neighbor data structures in the FLANN library |
| CNearestNeighborsFLANNHierarchicalClustering | |
| CNearestNeighborsFLANNLinear | |
| CNearestNeighborsGNAT | Geometric Near-neighbor Access Tree (GNAT), a data structure for nearest neighbor search |
| CNode | The class used internally to define the GNAT |
| CNearestNeighborsGNATNoThreadSafety | Geometric Near-neighbor Access Tree (GNAT), a data structure for nearest neighbor search |
| CNode | The class used internally to define the GNAT |
| CNearestNeighborsLinear | A nearest neighbors datastructure that uses linear search |
| CNearestNeighborsSqrtApprox | A nearest neighbors datastructure that uses linear search. The linear search is done over sqrt(n) elements only. (Every sqrt(n) elements are skipped) |
| CParameter | Parameter represents a smooth interpolation between two parameter values, namely valueInit and valueTarget. The default class keeps a counter to track how often it was called. Starting at counterInit we then count towards counterTarget and smoothly interpolate parameter values inbetween |
| CParameterExponentialDecay | ParameterExponentialDecay represents a smooth interpolation between two parameter values using an exponential decay as interpolation. This decay depends on a paramter lambda, which can be tuned to either converge slow or fast to valueTarget |
| CParameterSmoothStep | ParameterSmoothStep represents a smooth interpolation between two parameter values using a hermite polynomial interpolation |
| CPDF | A container that supports probabilistic sampling over weighted data |
| CElement | A class that will hold data contained in the PDF |
| CPermutation | A permutation of indices into an array |
| CPPM | Load and save .ppm files - "portable pixmap format" an image file formats designed to be easily exchanged between platforms |
| CColor | |
| CProlateHyperspheroid | A class describing a prolate hyperspheroid, a special symmetric type of n-dimensional ellipse, for use in direct informed sampling for problems seeking to minimize path length |
| CRNG | Random number generation. An instance of this class cannot be used by multiple threads at once (member functions are not const). However, the constructor is thread safe and different instances can be used safely in any number of threads. It is also guaranteed that all created instances will have a different random seed |
| NPoint2DPlanning | |
| CPlane2DEnvironment | |
| NRandomWalkPlanner | |
| CRandomWalkPlanner | |
| Nstd | STL namespace |
| Chash< std::pair< U, V > > | |
| Chash< std::vector< T > > | |
| Nvamp_state_space | |
| CVampMotionValidator | |
| CVampStateValidityChecker | |
| CVampStateSpace | |
| Nviser_visualizer | |
| Nviser_visualizer | |
| CViserVisualizer | |
| CAtlasOptions | |
| CConstrainedOptions | |
| CConstrainedProblem | |
| CConvexPolygon | |
| CHyperCubeValidityChecker | |
| CKinematicChainProjector | |
| CKinematicChainSpace | |
| CKinematicChainValidityChecker | |
| CKoulesControlSampler | |
| CKoulesControlSpace | |
| CKoulesDecomposition | |
| CKoulesDirectedControlSampler | |
| CKoulesGoal | |
| CKoulesProjection | |
| CKoulesSimulator | |
| CKoulesStatePropagator | |
| CMotionBenchmakerDemo | Configuration for running Motion Benchmark Maker benchmarks with OMPL and VAMP |
| CConstraintPtr | A shared pointer wrapper for ompl::base::Constraint |
| CGoalPtr | A shared pointer wrapper for ompl::base::Goal |
| CLightningRetrieveRepairPtr | A shared pointer wrapper for ompl::base::LightningRetrieveRepair |
| CMotionValidatorPtr | A shared pointer wrapper for ompl::base::MotionValidator |
| COptimizationObjectivePtr | A shared pointer wrapper for ompl::base::OptimizationObjective |
| CPathPtr | A shared pointer wrapper for ompl::base::Path |
| CPlannerDataPtr | A shared pointer wrapper for ompl::base::PlannerData |
| CPlannerPtr | A shared pointer wrapper for ompl::base::Planner |
| CProblemDefinitionPtr | A shared pointer wrapper for ompl::base::ProblemDefinition |
| CProjectionEvaluatorPtr | A shared pointer wrapper for ompl::base::ProjectionEvaluator |
| CSolutionNonExistenceProofPtr | A shared pointer wrapper for ompl::base::SolutionNonExistenceProof |
| CSpaceInformationPtr | A shared pointer wrapper for ompl::base::SpaceInformation |
| CStatePropagatorPtr | A shared pointer wrapper for ompl::control::StatePropagator |
| CStateSamplerPtr | A shared pointer wrapper for ompl::base::StateSampler |
| CStateSpacePtr | A shared pointer wrapper for ompl::base::StateSpace |
| CStateValidityCheckerPtr | A shared pointer wrapper for ompl::base::StateValidityChecker |
| CThunderRetrieveRepairPtr | A shared pointer wrapper for ompl::base::ThunderRetrieveRepair |
| CValidStateSamplerPtr | A shared pointer wrapper for ompl::base::ValidStateSampler |
| CAutomatonPtr | A shared pointer wrapper for ompl::control::Automaton |
| CControlSamplerPtr | A shared pointer wrapper for ompl::control::ControlSampler |
| CControlSpacePtr | A shared pointer wrapper for ompl::control::ControlSpace |
| CDecompositionPtr | A shared pointer wrapper for ompl::control::Decomposition |
| CDirectedControlSamplerPtr | A shared pointer wrapper for ompl::control::DirectedControlSampler |
| CLTLProblemDefinitionPtr | A shared pointer wrapper for ompl::control::LTLProblemDefinition |
| CLTLSpaceInformationPtr | A shared pointer wrapper for ompl::control::LTLSpaceInformation |
| CODESolverPtr | A shared pointer wrapper for ompl::control::ODESolver |
| CProductGraphPtr | A shared pointer wrapper for ompl::control::ProductGraph |
| CPropositionalDecompositionPtr | A shared pointer wrapper for ompl::control::PropositionalDecomposition |
| CSimpleSetupPtr | A shared pointer wrapper for ompl::control::SimpleSetup |
| CSpaceInformationPtr | A shared pointer wrapper for ompl::control::SpaceInformation |
| CDynamicTimeWarpPtr | A shared pointer wrapper for ompl::tools::DynamicTimeWarp |
| CExperienceSetupPtr | A shared pointer wrapper for ompl::geometric::ExperienceSetup |
| CLightningDBPtr | A shared pointer wrapper for ompl::tools::LightningDB |
| CLightningPtr | A shared pointer wrapper for ompl::tools::Lightning |
| CPathHybridizationPtr | A shared pointer wrapper for ompl::geometric::PathHybridization |
| CPathSimplifierPtr | A shared pointer wrapper for ompl::geometric::PathSimplifier |
| CSimpleSetupPtr | A shared pointer wrapper for ompl::geometric::SimpleSetup |
| CThunderDBPtr | A shared pointer wrapper for ompl::tools::ThunderDB |
| CThunderPtr | A shared pointer wrapper for ompl::tools::Thunder |
| CXXLDecompositionPtr | A shared pointer wrapper for ompl::geometric::XXLDecomposition |
| CPlanarManipTaskSpaceConfig | |
| CPlanarManipulator | |
| CPlanarManipulatorCollisionChecker | |
| CPlanarManipulatorIKGoal | |
| CPlanarManipulatorStateSpace | |
| CPlanningResult | Results from a single planning trial |
| CPMXXLDecomposition | |
| CPolyWorld | |
| CR2CollisionChecker | |
| CSE2CollisionChecker | |
| CSegment |