sdurw_pathoptimization module

class sdurw_pathoptimization.sdurw_pathoptimization.ClearanceCalculator(*args, **kwargs)

Bases: object

Interface for ClearanceCalculator

A ClearanceCalculator provides a mean for calculating the clearance of for a state. While the concept of clearance usually refers to the distance between a device and obstacle, not such assumption should be made based on the interface, as other fitness criteria may be implemented.

Only convention is that a high clearance value is better than a low.

clearance(state)

Calculates Clearance for the state

Parameters: state (State) – [in] State for which to calculate the clearance
Return type: float
Returns: The clearance.

property thisown: The membership flag

class sdurw_pathoptimization.sdurw_pathoptimization.ClearanceCalculatorCPtr(*args)

Bases: object

Ptr stores a pointer and optionally takes ownership of the value.

clearance(state)

Calculates Clearance for the state

Parameters: state (State) – [in] State for which to calculate the clearance
Return type: float
Returns: The clearance.

deref(): The pointer stored in the object.

getDeref(): Member access operator.

isNull(): checks if the pointer is null :rtype: boolean :return: Returns true if the pointer is null

isShared(): check if this Ptr has shared ownership or none ownership :rtype: boolean :return: true if Ptr has shared ownership, false if it has no ownership.

property thisown: The membership flag

class sdurw_pathoptimization.sdurw_pathoptimization.ClearanceCalculatorPtr(*args)

Bases: object

Ptr stores a pointer and optionally takes ownership of the value.

clearance(state)

Calculates Clearance for the state

Parameters: state (State) – [in] State for which to calculate the clearance
Return type: float
Returns: The clearance.

cptr()

deref(): The pointer stored in the object.

getDeref(): Member access operator.

isNull(): checks if the pointer is null :rtype: boolean :return: Returns true if the pointer is null

isShared(): check if this Ptr has shared ownership or none ownership :rtype: boolean :return: true if Ptr has shared ownership, false if it has no ownership.

property thisown: The membership flag

class sdurw_pathoptimization.sdurw_pathoptimization.ClearanceOptimizer(device, state, metric, clearanceCalculator)

Bases: object

The ClearanceOptimizer implements the C-Retraction algorithms from [1]

[1]: R. Geraerts and M.H. Overmars, Creating High-Quality Paths for Motion Planning, The International Journal of Robotics Research, Vol. 26, No. 8, 845-863 (2007)

The algorithms work by first subdividing the path, to give a dense and even distribution of nodes along the path. Nodes are then tried moved in a random direction to improve the clearance. After having iterated through the entire path some nodes will be moved, thus a validation step is used to insert extra nodes where the density is not high enough. This is then followed by a method for removing undesired branches.

PROP_LOOPCOUNT = 'LoopCount'

PROP_MAXTIME = 'MaxTime'

PROP_STEPSIZE = 'StepSize'

getClearanceCalculator()

Returns the ClearanceCalculator associated with the optimizer.

Return type: rw::core::Ptr< rwlibs::pathoptimization::ClearanceCalculator const >
Returns: Const reference to the ClearanceCalculator.

getMinimumClearance(): Returns the minimum clearance optimized for. :rtype: float :return: The minimum clearance.

getPropertyMap()

Returns the PropertyMap associated with the optimizer.

The PropertyMap defines the following parameters used by the optimizer:

Property Name | Type | Default value ———————————- | —— | ————- ClearanceOptimizer::PROP_LOOPCOUNT | int | 20 ClearanceOptimizer::PROP_MAXTIME | double | 200 ClearanceOptimizer::PROP_STEPSIZE | double | 0.1

Return type: PropertyMap
Returns: The PropertyMap

optimize(*args)

Overload 1:

Runs optimization algorithm

Calling this method runs the path optimization algorithm. This call blocks until the optimized path is ready. This may take quite a while, depending on the maxcount specified and the amount of geometry in the scene.

Parameters

path (rw::trajectory::QPath) – [in] Path to optimize
stepsize (float) – [in] Maximum size between configurations in the dense path
maxcount (int) – [in] Number of time to attempt optimizing the path using the random direction. If maxcount=0 only the maxtime will be used.
maxtime (float) – [in] The maximal time allowed to optimize. If maxtime**<=0 only the **maxcount will be used

Return type

rw::trajectory::QPath

Returns

The optimized path with node no further than stepsize apart

Overload 2:

Runs optimization algorithm

Runs the optimization algorithm using the parameters specified in the property map

Parameters: path (rw::trajectory::QPath) – [in] Path to optimize
Return type: rw::trajectory::QPath
Returns: The optimized path

setMinimumClearance(dist)

Sets the minimum clearance optimized for. Points on the path with clearance greater than _minClearance are not optimized further. Class default value is 0.1 meters. Value must be equal to or greater than zero.

Parameters: dist (float) – [in] Minimum clearance.

setQConstraint(qConstraint)

Set a configuration constraint in the clearance optimizer.

The optimizer will not generate a path with configurations that is in collision according to the constraint.

Parameters: qConstraint (rw::core::Ptr< rw::pathplanning::QConstraint const >) – [in] the constraint.

setStateConstraint(stateConstraint)

Set a state constraint in the clearance optimizer.

The optimizer will not generate a path with configurations that is in collision according to the state constraint.

Parameters: stateConstraint (rw::core::Ptr< rw::pathplanning::StateConstraint const >) – [in] the constraint.

property thisown: The membership flag

class sdurw_pathoptimization.sdurw_pathoptimization.ClearanceOptimizerCPtr(*args)

Bases: object

Ptr stores a pointer and optionally takes ownership of the value.

property PROP_LOOPCOUNT: Property key for the maximal number of loops. Set LOOPCOUNT=0 to deactivate it

property PROP_MAXTIME: Property key for max time. Set MAXTIME=0 to deactivate it

property PROP_STEPSIZE: Property key for step size

deref(): The pointer stored in the object.

getClearanceCalculator()

Returns the ClearanceCalculator associated with the optimizer.

Return type: rw::core::Ptr< rwlibs::pathoptimization::ClearanceCalculator const >
Returns: Const reference to the ClearanceCalculator.

getDeref(): Member access operator.

getMinimumClearance(): Returns the minimum clearance optimized for. :rtype: float :return: The minimum clearance.

isNull(): checks if the pointer is null :rtype: boolean :return: Returns true if the pointer is null

isShared(): check if this Ptr has shared ownership or none ownership :rtype: boolean :return: true if Ptr has shared ownership, false if it has no ownership.

property thisown: The membership flag

class sdurw_pathoptimization.sdurw_pathoptimization.ClearanceOptimizerPtr(*args)

Bases: object

Ptr stores a pointer and optionally takes ownership of the value.

property PROP_LOOPCOUNT: Property key for the maximal number of loops. Set LOOPCOUNT=0 to deactivate it

property PROP_MAXTIME: Property key for max time. Set MAXTIME=0 to deactivate it

property PROP_STEPSIZE: Property key for step size

cptr()

deref(): The pointer stored in the object.

getClearanceCalculator()

Returns the ClearanceCalculator associated with the optimizer.

Return type: rw::core::Ptr< rwlibs::pathoptimization::ClearanceCalculator const >
Returns: Const reference to the ClearanceCalculator.

getDeref(): Member access operator.

getMinimumClearance(): Returns the minimum clearance optimized for. :rtype: float :return: The minimum clearance.

getPropertyMap()

Returns the PropertyMap associated with the optimizer.

The PropertyMap defines the following parameters used by the optimizer:

Property Name | Type | Default value ———————————- | —— | ————- ClearanceOptimizer::PROP_LOOPCOUNT | int | 20 ClearanceOptimizer::PROP_MAXTIME | double | 200 ClearanceOptimizer::PROP_STEPSIZE | double | 0.1

Return type: PropertyMap
Returns: The PropertyMap

isNull(): checks if the pointer is null :rtype: boolean :return: Returns true if the pointer is null

isShared(): check if this Ptr has shared ownership or none ownership :rtype: boolean :return: true if Ptr has shared ownership, false if it has no ownership.

optimize(*args)

Overload 1:

Runs optimization algorithm

Calling this method runs the path optimization algorithm. This call blocks until the optimized path is ready. This may take quite a while, depending on the maxcount specified and the amount of geometry in the scene.

Parameters

path (rw::trajectory::QPath) – [in] Path to optimize
stepsize (float) – [in] Maximum size between configurations in the dense path
maxcount (int) – [in] Number of time to attempt optimizing the path using the random direction. If maxcount=0 only the maxtime will be used.
maxtime (float) – [in] The maximal time allowed to optimize. If maxtime**<=0 only the **maxcount will be used

Return type

rw::trajectory::QPath

Returns

The optimized path with node no further than stepsize apart

Overload 2:

Runs optimization algorithm

Runs the optimization algorithm using the parameters specified in the property map

Parameters: path (rw::trajectory::QPath) – [in] Path to optimize
Return type: rw::trajectory::QPath
Returns: The optimized path

setMinimumClearance(dist)

Sets the minimum clearance optimized for. Points on the path with clearance greater than _minClearance are not optimized further. Class default value is 0.1 meters. Value must be equal to or greater than zero.

Parameters: dist (float) – [in] Minimum clearance.

setQConstraint(qConstraint)

Set a configuration constraint in the clearance optimizer.

The optimizer will not generate a path with configurations that is in collision according to the constraint.

Parameters: qConstraint (rw::core::Ptr< rw::pathplanning::QConstraint const >) – [in] the constraint.

setStateConstraint(stateConstraint)

Set a state constraint in the clearance optimizer.

The optimizer will not generate a path with configurations that is in collision according to the state constraint.

Parameters: stateConstraint (rw::core::Ptr< rw::pathplanning::StateConstraint const >) – [in] the constraint.

property thisown: The membership flag

class sdurw_pathoptimization.sdurw_pathoptimization.MinimumClearanceCalculator(*args)

Bases: ClearanceCalculator

Implements a MinimumClearanceCalculator

The minimum clearance is defined as the minimal distance between any two geometries, which are not excluded by the collision setup.

clearance(state)

Calculates Clearance for the state

Parameters: state (State) – [in] State for which to calculate the clearance
Return type: float
Returns: The clearance.

property thisown: The membership flag

class sdurw_pathoptimization.sdurw_pathoptimization.MinimumClearanceCalculatorCPtr(*args)

Bases: object

Ptr stores a pointer and optionally takes ownership of the value.

clearance(state)

deref(): The pointer stored in the object.

getDeref(): Member access operator.

isNull(): checks if the pointer is null :rtype: boolean :return: Returns true if the pointer is null

isShared(): check if this Ptr has shared ownership or none ownership :rtype: boolean :return: true if Ptr has shared ownership, false if it has no ownership.

property thisown: The membership flag

class sdurw_pathoptimization.sdurw_pathoptimization.MinimumClearanceCalculatorPtr(*args)

Bases: object

Ptr stores a pointer and optionally takes ownership of the value.

clearance(state)

cptr()

deref(): The pointer stored in the object.

getDeref(): Member access operator.

isNull(): checks if the pointer is null :rtype: boolean :return: Returns true if the pointer is null

isShared(): check if this Ptr has shared ownership or none ownership :rtype: boolean :return: true if Ptr has shared ownership, false if it has no ownership.

property thisown: The membership flag

class sdurw_pathoptimization.sdurw_pathoptimization.PathLengthOptimizer(constraint, metric)

Bases: object

The PathLengthOptimizer implements the 3 different path length optimizers presented in [1].

[1]: R. Geraerts and M.H. Overmars, Creating High-Quality Paths for Motion Planning, The International Journal of Robotics Research, Vol. 26, No. 8, 845-863 (2007)

The simplest algorithm pathPruning runs through the path an tests if nodes with index i and i+2 can be directly connected. If so it removed node i+1.

The shortCut algorithm works similary except that it takes two random indices i and j and tries to connect those. This algorithm is non-deterministic but more powerful than pathPruning.

The partialShortCut algorithm select two random node indices i and j and a random position in the configuration vector. A shortcut is then only tried between the values corresponding to the random position. This algorithm is generally more powerful than shortCut but may in some cases be more computational expensive.

PROP_LOOPCOUNT = 'LoopCount'

PROP_MAXTIME = 'MaxTime'

PROP_SUBDIVLENGTH = 'SubDivideLength'

getPropertyMap(): Returns the propertymap :rtype: PropertyMap :return: Reference to the property map

partialShortCut(*args)

Overload 1:

Optimizes using the partial shortcut technique

The partialShortCut algorithm select two random node indices i and j and a random position in the configuration vector. A shortcut is then only tried between the values corresponding to the random position.

The algorithm will loop until either the specified cnt is of met or the specified time is reached.

Parameters

path (rw::trajectory::QPath) – [inout] Path to optimize
cnt (int) – [in] Max count to use. If cnt=0, only the time limit will be used
time (float) – [in] Max time to use (in seconds). If time=0, only the cnt limit will be used
subDivideLength (float) – [in] The length into which the path is subdivided

Overload 2:

Optimizes using the partial shortcut technique

Works similar to partialShortCut(const rw::pathplanning::Path&, size_t, double, double) except that parameters are read from the propertymap.

Parameters: path (rw::trajectory::QPath) – [inout] Path to optimize
Return type: rw::trajectory::QPath
Returns: The optimized path

pathPruning(path)

Optimizes using path pruning.

pathPruning runs through the path an tests if nodes with index i and i+2 can be directly connected. If so it removes node i+1.

Parameters: path (rw::trajectory::QPath) – [in] Path to optimize

shortCut(*args)

Overload 1:

Optimizes using the shortcut technique

The shortCut algorithm works by selecting two random indices i and j and try to connect those.

The algorithm will loop until either the specified cnt is of met or the specified time is reached.

Parameters

path (rw::trajectory::QPath) – [inout] Path to optimize
cnt (int) – [in] Max count to use. If cnt=0, only the time limit will be used
time (float) – [in] Max time to use (in seconds). If time=0, only the cnt limit will be used
subDivideLength (float) – [in] The length into which the path is subdivided

Overload 2:

Optimizes using the shortcut technique

Works similar to shortCut(const rw::pathplanning::Path&, size_t, double, double) except that parameters are read from the propertymap.

Parameters: path (rw::trajectory::QPath) – [inout] Path to optimize

property thisown: The membership flag

class sdurw_pathoptimization.sdurw_pathoptimization.PathLengthOptimizerCPtr(*args)

Bases: object

Ptr stores a pointer and optionally takes ownership of the value.

property PROP_LOOPCOUNT: Property key for the maximal number of loops

property PROP_MAXTIME: Property key for max time

property PROP_SUBDIVLENGTH: Property key for length of segment in when subdividing

deref(): The pointer stored in the object.

getDeref(): Member access operator.

isNull(): checks if the pointer is null :rtype: boolean :return: Returns true if the pointer is null

isShared(): check if this Ptr has shared ownership or none ownership :rtype: boolean :return: true if Ptr has shared ownership, false if it has no ownership.

partialShortCut(*args)

Overload 1:

Optimizes using the partial shortcut technique

The partialShortCut algorithm select two random node indices i and j and a random position in the configuration vector. A shortcut is then only tried between the values corresponding to the random position.

The algorithm will loop until either the specified cnt is of met or the specified time is reached.

Parameters

path (rw::trajectory::QPath) – [inout] Path to optimize
cnt (int) – [in] Max count to use. If cnt=0, only the time limit will be used
time (float) – [in] Max time to use (in seconds). If time=0, only the cnt limit will be used
subDivideLength (float) – [in] The length into which the path is subdivided

Overload 2:

Optimizes using the partial shortcut technique

Works similar to partialShortCut(const rw::pathplanning::Path&, size_t, double, double) except that parameters are read from the propertymap.

Parameters: path (rw::trajectory::QPath) – [inout] Path to optimize
Return type: rw::trajectory::QPath
Returns: The optimized path

pathPruning(path)

Optimizes using path pruning.

pathPruning runs through the path an tests if nodes with index i and i+2 can be directly connected. If so it removes node i+1.

Parameters: path (rw::trajectory::QPath) – [in] Path to optimize

shortCut(*args)

Overload 1:

Optimizes using the shortcut technique

The shortCut algorithm works by selecting two random indices i and j and try to connect those.

The algorithm will loop until either the specified cnt is of met or the specified time is reached.

Parameters

path (rw::trajectory::QPath) – [inout] Path to optimize
cnt (int) – [in] Max count to use. If cnt=0, only the time limit will be used
time (float) – [in] Max time to use (in seconds). If time=0, only the cnt limit will be used
subDivideLength (float) – [in] The length into which the path is subdivided

Overload 2:

Optimizes using the shortcut technique

Works similar to shortCut(const rw::pathplanning::Path&, size_t, double, double) except that parameters are read from the propertymap.

Parameters: path (rw::trajectory::QPath) – [inout] Path to optimize

property thisown: The membership flag

class sdurw_pathoptimization.sdurw_pathoptimization.PathLengthOptimizerPtr(*args)

Bases: object

Ptr stores a pointer and optionally takes ownership of the value.

property PROP_LOOPCOUNT: Property key for the maximal number of loops

property PROP_MAXTIME: Property key for max time

property PROP_SUBDIVLENGTH: Property key for length of segment in when subdividing

cptr()

deref(): The pointer stored in the object.

getDeref(): Member access operator.

getPropertyMap(): Returns the propertymap :rtype: PropertyMap :return: Reference to the property map

isNull(): checks if the pointer is null :rtype: boolean :return: Returns true if the pointer is null

isShared(): check if this Ptr has shared ownership or none ownership :rtype: boolean :return: true if Ptr has shared ownership, false if it has no ownership.

partialShortCut(*args)

Overload 1:

Optimizes using the partial shortcut technique

The partialShortCut algorithm select two random node indices i and j and a random position in the configuration vector. A shortcut is then only tried between the values corresponding to the random position.

The algorithm will loop until either the specified cnt is of met or the specified time is reached.

Parameters

path (rw::trajectory::QPath) – [inout] Path to optimize
cnt (int) – [in] Max count to use. If cnt=0, only the time limit will be used
time (float) – [in] Max time to use (in seconds). If time=0, only the cnt limit will be used
subDivideLength (float) – [in] The length into which the path is subdivided

Overload 2:

Optimizes using the partial shortcut technique

Works similar to partialShortCut(const rw::pathplanning::Path&, size_t, double, double) except that parameters are read from the propertymap.

Parameters: path (rw::trajectory::QPath) – [inout] Path to optimize
Return type: rw::trajectory::QPath
Returns: The optimized path

pathPruning(path)

Optimizes using path pruning.

pathPruning runs through the path an tests if nodes with index i and i+2 can be directly connected. If so it removes node i+1.

Parameters: path (rw::trajectory::QPath) – [in] Path to optimize

shortCut(*args)

Overload 1:

Optimizes using the shortcut technique

The shortCut algorithm works by selecting two random indices i and j and try to connect those.

The algorithm will loop until either the specified cnt is of met or the specified time is reached.

Parameters

path (rw::trajectory::QPath) – [inout] Path to optimize
cnt (int) – [in] Max count to use. If cnt=0, only the time limit will be used
time (float) – [in] Max time to use (in seconds). If time=0, only the cnt limit will be used
subDivideLength (float) – [in] The length into which the path is subdivided

Overload 2:

Optimizes using the shortcut technique

Works similar to shortCut(const rw::pathplanning::Path&, size_t, double, double) except that parameters are read from the propertymap.

Parameters: path (rw::trajectory::QPath) – [inout] Path to optimize

property thisown: The membership flag

sdurw_pathoptimization.sdurw_pathoptimization.ownedPtr(*args)

Overload 1: