aikido::distance Namespace Reference

Namespaces
	detail

Classes
class	CartesianProductWeighted
	Implements a distance metric on a CartesianProduct. More...
class	ConfigurationRanker
	ConfigurationRanker is a base class for ranking configurations. More...
class	DistanceMetric
	Implements a distance metric defined on a StateSpace. More...
class	JointAvoidanceConfigurationRanker
	Ranks configurations by their distance from joint limits. More...
class	NominalConfigurationRanker
	Ranks configurations by their distance from a nominal configuration. More...
class	REuclidean
	Implements a Euclidean distance metric. More...
class	SE2
	Computes the shortest distance between two angles in SE2. More...
class	SE2Weighted
	Computes the shortest distance between two states in SE2. More...
class	SO2Angular
	Computes the shortest distance between two angles in SO(2) More...
class	SO3Angular
	Implements a distance metric on SO(3) More...

Typedefs
using	ConfigurationRankerPtr = std::shared_ptr< ConfigurationRanker >
using	ConstConfigurationRankerPtr = std::shared_ptr< const ConfigurationRanker >
using	WeakConfigurationRankerPtr = std::weak_ptr< ConfigurationRanker >
using	WeakConstConfigurationRankerPtr = std::weak_ptr< const ConfigurationRanker >
using	UniqueConfigurationRankerPtr = std::unique_ptr< ConfigurationRanker >
using	UniqueConstConfigurationRankerPtr = std::unique_ptr< const ConfigurationRanker >
using	DistanceMetricPtr = std::shared_ptr< DistanceMetric >
using	ConstDistanceMetricPtr = std::shared_ptr< const DistanceMetric >
using	WeakDistanceMetricPtr = std::weak_ptr< DistanceMetric >
using	WeakConstDistanceMetricPtr = std::weak_ptr< const DistanceMetric >
using	UniqueDistanceMetricPtr = std::unique_ptr< DistanceMetric >
using	UniqueConstDistanceMetricPtr = std::unique_ptr< const DistanceMetric >
using	NominalConfigurationRankerPtr = std::shared_ptr< NominalConfigurationRanker >
using	ConstNominalConfigurationRankerPtr = std::shared_ptr< const NominalConfigurationRanker >
using	WeakNominalConfigurationRankerPtr = std::weak_ptr< NominalConfigurationRanker >
using	WeakConstNominalConfigurationRankerPtr = std::weak_ptr< const NominalConfigurationRanker >
using	UniqueNominalConfigurationRankerPtr = std::unique_ptr< NominalConfigurationRanker >
using	UniqueConstNominalConfigurationRankerPtr = std::unique_ptr< const NominalConfigurationRanker >
using	R0Euclidean = REuclidean< 0 >
using	R1Euclidean = REuclidean< 1 >
using	R2Euclidean = REuclidean< 2 >
using	R3Euclidean = REuclidean< 3 >
using	R6Euclidean = REuclidean< 6 >
using	RnEuclidean = REuclidean< Eigen::Dynamic >
using	Weighted = CartesianProductWeighted

Functions
template<class Space >
std::unique_ptr< DistanceMetric >	createDistanceMetricFor (std::shared_ptr< Space > _sspace)
	Creates a DistanceMetric that is appropriate for the statespace of type Space. More...
std::unique_ptr< DistanceMetric >	createDistanceMetric (statespace::ConstStateSpacePtr _sspace)
	Creates a DistanceMetric that is appropriate for the statespace. More...

Typedef Documentation

ConfigurationRankerPtr

using aikido::distance::ConfigurationRankerPtr = typedef std::shared_ptr< ConfigurationRanker >

ConstConfigurationRankerPtr

using aikido::distance::ConstConfigurationRankerPtr = typedef std::shared_ptr< const ConfigurationRanker >

ConstDistanceMetricPtr

using aikido::distance::ConstDistanceMetricPtr = typedef std::shared_ptr< const DistanceMetric >

ConstNominalConfigurationRankerPtr

using aikido::distance::ConstNominalConfigurationRankerPtr = typedef std::shared_ptr< const NominalConfigurationRanker >

DistanceMetricPtr

using aikido::distance::DistanceMetricPtr = typedef std::shared_ptr< DistanceMetric >

NominalConfigurationRankerPtr

using aikido::distance::NominalConfigurationRankerPtr = typedef std::shared_ptr< NominalConfigurationRanker >

R0Euclidean

using aikido::distance::R0Euclidean = typedef REuclidean<0>

R1Euclidean

using aikido::distance::R1Euclidean = typedef REuclidean<1>

R2Euclidean

using aikido::distance::R2Euclidean = typedef REuclidean<2>

R3Euclidean

using aikido::distance::R3Euclidean = typedef REuclidean<3>

R6Euclidean

using aikido::distance::R6Euclidean = typedef REuclidean<6>

RnEuclidean

using aikido::distance::RnEuclidean = typedef REuclidean<Eigen::Dynamic>

UniqueConfigurationRankerPtr

using aikido::distance::UniqueConfigurationRankerPtr = typedef std::unique_ptr< ConfigurationRanker >

UniqueConstConfigurationRankerPtr

using aikido::distance::UniqueConstConfigurationRankerPtr = typedef std::unique_ptr< const ConfigurationRanker >

UniqueConstDistanceMetricPtr

using aikido::distance::UniqueConstDistanceMetricPtr = typedef std::unique_ptr< const DistanceMetric >

UniqueConstNominalConfigurationRankerPtr

using aikido::distance::UniqueConstNominalConfigurationRankerPtr = typedef std::unique_ptr< const NominalConfigurationRanker >

UniqueDistanceMetricPtr

using aikido::distance::UniqueDistanceMetricPtr = typedef std::unique_ptr< DistanceMetric >

UniqueNominalConfigurationRankerPtr

using aikido::distance::UniqueNominalConfigurationRankerPtr = typedef std::unique_ptr< NominalConfigurationRanker >

WeakConfigurationRankerPtr

using aikido::distance::WeakConfigurationRankerPtr = typedef std::weak_ptr< ConfigurationRanker >

WeakConstConfigurationRankerPtr

using aikido::distance::WeakConstConfigurationRankerPtr = typedef std::weak_ptr< const ConfigurationRanker >

WeakConstDistanceMetricPtr

using aikido::distance::WeakConstDistanceMetricPtr = typedef std::weak_ptr< const DistanceMetric >

WeakConstNominalConfigurationRankerPtr

using aikido::distance::WeakConstNominalConfigurationRankerPtr = typedef std::weak_ptr< const NominalConfigurationRanker >

WeakDistanceMetricPtr

using aikido::distance::WeakDistanceMetricPtr = typedef std::weak_ptr< DistanceMetric >

WeakNominalConfigurationRankerPtr

using aikido::distance::WeakNominalConfigurationRankerPtr = typedef std::weak_ptr< NominalConfigurationRanker >

Weighted

using aikido::distance::Weighted = typedef CartesianProductWeighted

Function Documentation

createDistanceMetric()

std::unique_ptr<DistanceMetric> aikido::distance::createDistanceMetric

(

statespace::ConstStateSpacePtr

_sspace

)

Creates a DistanceMetric that is appropriate for the statespace.

Parameters

_sspace

The StateSpace the distance metric will operator on

createDistanceMetricFor()

template<class Space >

std::unique_ptr< DistanceMetric > aikido::distance::createDistanceMetricFor

(

std::shared_ptr< Space >

_sspace

)

Creates a DistanceMetric that is appropriate for the statespace of type Space.

Parameters

_sspace

The StateSpace the distance metric will operator on