aikido::planner Namespace Reference

Namespaces
	dart
	kunzretimer
	ompl
	parabolic
	vectorfield

Classes
class	CompositePlanner
	CompositePlanner is a base class for concrete planner classes that contain multiple planners. More...
class	ConfigurationToConfiguration
	Planning problem to plan to a single goal configuration. More...
class	ConfigurationToConfigurationPlanner
	Base planner class for ConfigurationToConfiguration planning problem. More...
class	ConfigurationToConfigurations
	Planning problem to plan to multiple goal configurations. More...
class	FirstSupportedMetaPlanner
class	Planner
	Base class for a meta-planner. More...
class	PlanningResult
class	Problem
	Base class for various planning problems. More...
class	RankedMetaPlanner
class	SequenceMetaPlanner
	A meta planner that solves a problem using the sub planners one-by-one sequentially and returns the first successfully planned trajectory. More...
class	SingleProblemPlanner
	SingleProblemPlanner is a base class for any concrete planner that are not a CompositePlanner. More...
class	SnapConfigurationToConfigurationPlanner
	Planner that plans the straight-line trajectory to the goal. More...
class	TrajectoryPostProcessor
class	World
	A Kinematic world that contains a set of skeletons. More...
class	WorldStateSaver
	RAII class to save and restore a World's state. More...

Typedefs
using	CompositePlannerPtr = std::shared_ptr< CompositePlanner >
using	ConstCompositePlannerPtr = std::shared_ptr< const CompositePlanner >
using	WeakCompositePlannerPtr = std::weak_ptr< CompositePlanner >
using	WeakConstCompositePlannerPtr = std::weak_ptr< const CompositePlanner >
using	UniqueCompositePlannerPtr = std::unique_ptr< CompositePlanner >
using	UniqueConstCompositePlannerPtr = std::unique_ptr< const CompositePlanner >
using	PlannerPtr = std::shared_ptr< Planner >
using	ConstPlannerPtr = std::shared_ptr< const Planner >
using	WeakPlannerPtr = std::weak_ptr< Planner >
using	WeakConstPlannerPtr = std::weak_ptr< const Planner >
using	UniquePlannerPtr = std::unique_ptr< Planner >
using	UniqueConstPlannerPtr = std::unique_ptr< const Planner >
using	WorldPtr = std::shared_ptr< World >
using	ConstWorldPtr = std::shared_ptr< const World >
using	WeakWorldPtr = std::weak_ptr< World >
using	WeakConstWorldPtr = std::weak_ptr< const World >
using	UniqueWorldPtr = std::unique_ptr< World >
using	UniqueConstWorldPtr = std::unique_ptr< const World >

Functions
trajectory::InterpolatedPtr	planSnap (const statespace::ConstStateSpacePtr &stateSpace, const statespace::StateSpace::State *startState, const statespace::StateSpace::State *goalState, const std::shared_ptr< statespace::Interpolator > &interpolator, const std::shared_ptr< constraint::Testable > &constraint, planner::PlanningResult &planningResult)
	Plan a trajectory from startState to goalState by using interpolator to interpolate between them. More...

Typedef Documentation

CompositePlannerPtr

using aikido::planner::CompositePlannerPtr = typedef std::shared_ptr< CompositePlanner >

ConstCompositePlannerPtr

using aikido::planner::ConstCompositePlannerPtr = typedef std::shared_ptr< const CompositePlanner >

ConstPlannerPtr

using aikido::planner::ConstPlannerPtr = typedef std::shared_ptr< const Planner >

ConstWorldPtr

using aikido::planner::ConstWorldPtr = typedef std::shared_ptr< const World >

PlannerPtr

using aikido::planner::PlannerPtr = typedef std::shared_ptr< Planner >

UniqueCompositePlannerPtr

using aikido::planner::UniqueCompositePlannerPtr = typedef std::unique_ptr< CompositePlanner >

UniqueConstCompositePlannerPtr

using aikido::planner::UniqueConstCompositePlannerPtr = typedef std::unique_ptr< const CompositePlanner >

UniqueConstPlannerPtr

using aikido::planner::UniqueConstPlannerPtr = typedef std::unique_ptr< const Planner >

UniqueConstWorldPtr

using aikido::planner::UniqueConstWorldPtr = typedef std::unique_ptr< const World >

UniquePlannerPtr

using aikido::planner::UniquePlannerPtr = typedef std::unique_ptr< Planner >

UniqueWorldPtr

using aikido::planner::UniqueWorldPtr = typedef std::unique_ptr< World >

WeakCompositePlannerPtr

using aikido::planner::WeakCompositePlannerPtr = typedef std::weak_ptr< CompositePlanner >

WeakConstCompositePlannerPtr

using aikido::planner::WeakConstCompositePlannerPtr = typedef std::weak_ptr< const CompositePlanner >

WeakConstPlannerPtr

using aikido::planner::WeakConstPlannerPtr = typedef std::weak_ptr< const Planner >

WeakConstWorldPtr

using aikido::planner::WeakConstWorldPtr = typedef std::weak_ptr< const World >

WeakPlannerPtr

using aikido::planner::WeakPlannerPtr = typedef std::weak_ptr< Planner >

WeakWorldPtr

using aikido::planner::WeakWorldPtr = typedef std::weak_ptr< World >

WorldPtr

using aikido::planner::WorldPtr = typedef std::shared_ptr< World >

Function Documentation

planSnap()

trajectory::InterpolatedPtr aikido::planner::planSnap	(	const statespace::ConstStateSpacePtr &	stateSpace,
		const statespace::StateSpace::State *	startState,
		const statespace::StateSpace::State *	goalState,
		const std::shared_ptr< statespace::Interpolator > &	interpolator,
		const std::shared_ptr< constraint::Testable > &	constraint,
		planner::PlanningResult &	planningResult
	)

Plan a trajectory from startState to goalState by using interpolator to interpolate between them.

The planner returns success if the resulting trajectory satisfies constraint at some resolution and failure (returning nullptr) otherwise. The reason for the failure is stored in the planningResult output parameter.

Parameters

	stateSpace	state space
	startState	start state
	goalState	goal state
	interpolator	interpolator used to produce the output trajectory
	constraint	trajectory-wide constraint that must be satisfied
[out]	planningResult	information about success or failure

Returns

trajectory or nullptr if planning failed

Deprecated:

Deprecated in 0.3. Please use SnapConfigurationToConfigurationPlanner instead.