Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

►NConstrainedPlanningCommon
CConstrainedProblem
►NConstrainedPlanningImplicitChain
►CChainConstraint
CWall
►NConstrainedPlanningSphere
CSphereConstraint
CSphereProjection
►NConstrainedPlanningTorus
CTorusConstraint
►NConstraintGeneration
CConstraint
►Nompl	Main namespace. Contains everything in this library
►Napp	Namespace containing code specific to OMPL.app
CAppBase
CAppTypeSelector
CAppTypeSelector< AppType::CONTROL >
CBlimpPlanning	A class to facilitate planning for a simple blimp model
CDynamicCarPlanning	A class to facilitate planning for a generic second-order car model
CFCLContinuousMotionValidator	A motion validator that utilizes FCL's continuous collision checking
CFCLMethodWrapper	Wrapper for FCL discrete and continuous collision checking and distance queries
CFCLStateValidityChecker	Wrapper for FCL collision and distance checking
CGBlimpPlanning
CGDynamicCarPlanning
CGeometrySpecification
CGKinematicCarPlanning
CGQuadrotorPlanning
CGSE2RigidBodyPlanning
CGSE3RigidBodyPlanning
CKinematicCarPlanning	A class to facilitate planning for a generic kinematic car model
CPQPStateValidityChecker	Define an ompl::base::StateValidityChecker that can construct PQP models internally. The instance is still abstract however, as the isValid() function is not implemented (knowledge of the state space is needed for this function to be implemented)
CQuadrotorPlanning	A class to facilitate planning for a simple quadrotor model
CRenderGeometry
CRigidBodyGeometry
CSE2MultiRigidBodyPlanning	Wrapper for ompl::app::RigidBodyPlanning that plans for multiple rigid bodies in SE2
CSE2RigidBodyPlanning	Wrapper for ompl::app::RigidBodyPlanning that plans for rigid bodies in SE2
CSE3MultiRigidBodyPlanning	Wrapper for ompl::app::RigidBodyPlanning that plans for multiple rigid bodies in SE3
CSE3RigidBodyPlanning	Wrapper for ompl::app::RigidBodyPlanning that plans for rigid bodies in SE3
►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
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
CConstraintIntersection	Definition of a constraint composed of multiple constraints that all must be satisfied simultaneously. This class ‘stacks’ the constraint functions together
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
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
CDubinsPath	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
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]
CMorseEnvironment	This class contains the MORSE constructs OMPL needs to know about when planning
CMorseGoal	This is a goal class that is more amenable to Python
CMorseProjection	This class implements a generic projection for the MorseStateSpace, namely, the subspace representing the x and y positions of every rigid body
►CMorseStateSpace	State space representing MORSE states
CStateType	MORSE State. This is a compound state that allows accessing the properties of the bodies the state space is constructed for
CMorseStateValidityChecker	The simplest state validity checker: all states are valid if they are within bounds
CMorseTerminationCondition	This class represents a termination condition for the planner that only terminates if the user shuts down the MORSE simulation
CMotion	Representation of a motion
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
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
CPlannerDataEdgeData	The object containing all edge data that will be stored
CPlannerDataVertexData	The object containing all vertex 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
CReedsSheppMotionValidator	A Reeds-Shepp motion validator that only uses the state validity checker. Motions are checked for validity at a specified resolution
►CReedsSheppStateSpace	An SE(2) state space where distance is measured by the length of Reeds-Shepp curves
CReedsSheppPath	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
CTypedSpaceInformation
CTypedStateValidityChecker
CUniformValidStateSampler	A state sampler that only samples valid states, uniformly
CValidStateSampler	Abstract definition of a state sampler
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
►CKPIECE1	Kinodynamic Planning by Interior-Exterior Cell Exploration
CCellData	The data held by a cell in the grid of motions
CCloseSample	Information about a known good sample (closer to the goal than others)
CCloseSamples	Bounded set of good samples
CMotion	Representation of a motion for this algorithm
COrderCellsByImportance	Definintion of an operator passed to the Grid structure, to order cells by importance
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
CMorseControlSpace	Representation of controls applied in MORSE environments. This is an array of double values
CMorseSimpleSetup	Create the set of classes typically needed to solve a control problem when forward propagation is computed with MORSE
CMorseStatePropagator	State propagation with MORSE. Only forward propagation is possible
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
COpenDEControlSpace	Representation of controls applied in OpenDE environments. This is an array of double values
COpenDEEnvironment	This class contains the OpenDE constructs OMPL needs to know about when planning
COpenDESimpleSetup	Create the set of classes typically needed to solve a control problem when forward propagation is computed with OpenDE
COpenDEStatePropagator	State propagation with OpenDE. Only forward propagation is possible
►COpenDEStateSpace	State space representing OpenDE states
CStateType	OpenDE State. This is a compound state that allows accessing the properties of the bodies the state space is constructed for
COpenDEStateValidityChecker	The simplest state validity checker: all states are valid
CPathControl	Definition of a control path
►CPDST	Path-Directed Subdivision Tree
CCell	Cell is a Binary Space Partition
CMotion	Class representing the tree of motions exploring the state space
CMotionCompare	Comparator used to order motions in the priority queue
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
CEdge
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
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
CAdjacency	Representation of an adjacency (a directed edge) between two regions in the Decomposition assigned to Syclop
CDefaults	Contains default values for Syclop parameters
CMotion	Representation of a motion
CRegion	Representation of a region 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
CPolygon
CTriangle
CVertex
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
CABITstar	Advanced Batch Informed Trees (ABIT*)
CAITstar	Adaptively Informed Trees (AIT*)
CAnytimePathShortening
►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
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
►CEST	Expansive Space Trees
CMotion	The definition of a motion
►CFMT	Asymptotically Optimal Fast Marching Tree algorithm developed by L. Janson and M. Pavone
CCostIndexCompare
CMotion	Representation of a motion
CMotionCompare	Comparator used to order motions in a binary heap
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
CCostEstimatorApx
CCostEstimatorLb
CMotion	Representation of a motion
►CLazyPRM	Lazy Probabilistic RoadMap planner
Cedge_flags_t
Cvertex_component_t
Cvertex_flags_t
Cvertex_state_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
CIsLessThan	Comparator - metric is the cost to reach state via a specific state
CIsLessThanLB	Comparator - metric is the lower bound cost
CMotion	Representation of a motion
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
CCell	Cell is a Binary Space Partition
CMotion	Class representing the tree of motions exploring the state space
CMotionCompare	Comparator used to order motions in the priority queue
►CPRM	Probabilistic RoadMap planner
Cvertex_state_t
Cvertex_successful_connection_attempts_t
Cvertex_total_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
CMotionsToBeRemoved
CPendingRemoveMotion
CSolutionInfo
CTreeData
►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
CCostIndexCompare
CMotion	Representation of a motion
►CRRTXstatic	Optimal Rapidly-exploring Random Trees Maintaining A Pseudo Optimal Tree
CMotion	Representation of a motion (node of the tree)
CMotionCompare	Defines the operator to compare motions
►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_color_t
Cvertex_interface_list_t
Cvertex_list_t
Cvertex_representative_t
Cvertex_state_t
►CSPARSdb	SPArse Roadmap Spanner Version 2.0
CCandidateSolution	Struct for passing around partially solved solutions
CCustomVisitor
Cedge_collision_state_t
CedgeWeightMap
CfoundGoalException
CInterfaceData	Interface information storage class, which does bookkeeping for criterion four
CInterfaceHashStruct
Cvertex_color_t
Cvertex_interface_data_t
Cvertex_state_t
►CSPARStwo	SPArse Roadmap Spanner Version 2.0
CInterfaceData	Interface information storage class, which does bookkeeping for criterion four
Cvertex_color_t
Cvertex_interface_data_t
Cvertex_state_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
►CTSRRT	Task-space Rapidly-exploring Random Trees
CMotion	Representation of a motion
CVFRRT
►CXXL
CLayer
CMotion
CPerfectSet
CRegion
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
COutputHandlerFile	Implementation of OutputHandler that saves messages in a file
COutputHandlerSTD	Default implementation of OutputHandler. This sends the information to the console
►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
CCompleteExperiment	This structure holds experimental data for a set of planners
CPlannerExperiment	The data collected after running a planner multiple times
CRequest	Representation of a benchmark request
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
CDynamicTimeWarp
►CExperienceSetup	Create the set of classes typically needed to solve a geometric problem
CExperienceLog	Single entry for the csv data logging file
CExperienceStats	Simple logging functionality encapsled in a struct
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
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
CEqualCoordPtr	Equality operator for coordinate pointers
CHashFunCoordPtr
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.
CLessThanExternalCell	Define order for external cells
CLessThanInternalCell	Define order for internal 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
►Nstd	STL namespace
Chash< std::pair< U, V > >
Chash< std::vector< T > >
CAtlasOptions
CConstrainedOptions
CConstrainedProblem
CConvexPolygon
CHyperCubeValidityChecker
CKinematicChainProjector
CKinematicChainSpace
CKinematicChainValidityChecker
CKoulesControlSampler
CKoulesControlSpace
CKoulesDecomposition
CKoulesDirectedControlSampler
CKoulesGoal
CKoulesProjection
CKoulesSimulator
CKoulesStatePropagator
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
CMorseEnvironmentPtr	A shared pointer wrapper for ompl::base::MorseEnvironment
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
COpenDEEnvironmentPtr	A shared pointer wrapper for ompl::control::OpenDEEnvironment
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
CPMXXLDecomposition
CPolyWorld
CR2CollisionChecker
CSE2CollisionChecker
CSegment