Drake
UnusableModel Class Reference

An unusable model, used when no collision detection backend is available. More...

#include <multibody/collision/unusable_model.h>

Inheritance diagram for UnusableModel:
[legend]
Collaboration diagram for UnusableModel:
[legend]

Public Member Functions

 UnusableModel ()
 
virtual ~UnusableModel ()
 
void UpdateModel () override
 Updates the collision model. More...
 
bool UpdateElementWorldTransform (ElementId, const Eigen::Isometry3d &T_local_to_world) override
 Updates the stored transformation from a collision element's canonical space to world space (X_WE), where X_WE = X_WL * X_LE. More...
 
bool ClosestPointsAllToAll (const std::vector< ElementId > &ids_to_check, bool use_margins, std::vector< PointPair > *closest_points) override
 Computes the points of closest approach between all eligible pairs of collision elements drawn from a specified set of elements. More...
 
bool ComputeMaximumDepthCollisionPoints (bool use_margins, std::vector< PointPair > *points) override
 Computes the point of closest approach between collision elements that are in contact. More...
 
bool ClosestPointsPairwise (const std::vector< ElementIdPair > &id_pairs, bool use_margins, std::vector< PointPair > *closest_points) override
 Computes the points of closest approach between specified pairs of collision elements. More...
 
void CollisionDetectFromPoints (const Eigen::Matrix3Xd &points, bool use_margins, std::vector< PointPair > *closest_points) override
 Computes the closest distance from each point to any surface in the collision model utilizing Bullet's collision detection code. More...
 
void ClearCachedResults (bool use_margins) override
 Clears possibly cached results so that a fresh computation can be performed. More...
 
bool CollisionRaycast (const Eigen::Matrix3Xd &origins, const Eigen::Matrix3Xd &ray_endpoints, bool use_margins, Eigen::VectorXd *distances, Eigen::Matrix3Xd *normals) override
 Performs a raycast intersection test (like a LIDAR / laser range finder). More...
 
bool CollidingPointsCheckOnly (const std::vector< Eigen::Vector3d > &input_points, double collision_threshold) override
 Given a vector of points in the world coordinate frame, reports if any of those points lie within a specified distance of any collision geometry in the model. More...
 
std::vector< size_t > CollidingPoints (const std::vector< Eigen::Vector3d > &input_points, double collision_threshold) override
 Given a vector of points in the world coordinate frame, returns the indices of those points that are within the provided collision_threshold distance of any collision geometry in the model. More...
 
Does not allow copy, move, or assignment
 UnusableModel (const UnusableModel &)=delete
 
UnusableModeloperator= (const UnusableModel &)=delete
 
 UnusableModel (UnusableModel &&)=delete
 
UnusableModeloperator= (UnusableModel &&)=delete
 
- Public Member Functions inherited from Model
 Model ()
 
virtual ~Model ()
 
ElementAddElement (std::unique_ptr< Element > element)
 Adds a collision element to this model. More...
 
bool RemoveElement (ElementId id)
 Removes a collision element from this model. More...
 
virtual const ElementFindElement (ElementId id) const
 Gets a read-only pointer to a collision element in this model. More...
 
virtual ElementFindMutableElement (ElementId id)
 Gets a pointer to a mutable collision element in this model. More...
 
void GetTerrainContactPoints (ElementId id0, Eigen::Matrix3Xd *terrain_points)
 
virtual bool TransformCollisionFrame (const drake::multibody::collision::ElementId &eid, const Eigen::Isometry3d &transform_body_to_joint)
 Modifies a collision element's local transform to be relative to a joint's frame rather than a link's frame. More...
 
 Model (const Model &)=delete
 
Modeloperator= (const Model &)=delete
 
 Model (Model &&)=delete
 
Modeloperator= (Model &&)=delete
 

Additional Inherited Members

- Protected Member Functions inherited from Model
virtual void DoAddElement (const Element &element)
 Allows sub-classes to do additional processing on elements added to the collision model. More...
 
virtual void DoRemoveElement (ElementId id)
 Allows sub-classes to do additional processing when elements are removed from the collision model. More...
 
- Protected Attributes inherited from Model
std::unordered_map< ElementId, std::unique_ptr< Element > > elements
 

Detailed Description

An unusable model, used when no collision detection backend is available.

Constructor & Destructor Documentation

UnusableModel ( const UnusableModel )
delete
UnusableModel ( UnusableModel &&  )
delete
UnusableModel ( )
inline
virtual ~UnusableModel ( )
inlinevirtual

Here is the call graph for this function:

Member Function Documentation

void ClearCachedResults ( bool  use_margins)
overridevirtual

Clears possibly cached results so that a fresh computation can be performed.

Parameters
[in]use_marginsIf true, the cache of the model with margins is cleared. If false, the cache of the model without margins is cleared.

Depending on the implementation, the collision model may cache results on each dispatch. For instance, Bullet uses cached results to warm-start its LCP solvers.

Clearing cached results allows the collision model to perform a fresh computation without any coupling with previous history.

See also
drake/multibody/collision/test/model_test.cc.

Implements Model.

Here is the caller graph for this function:

bool ClosestPointsAllToAll ( const std::vector< ElementId > &  ids_to_check,
bool  use_margins,
std::vector< PointPair > *  closest_points 
)
overridevirtual

Computes the points of closest approach between all eligible pairs of collision elements drawn from a specified set of elements.

Parameters
ids_to_checkThe vector of ElementId for which the all-to-all collision detection should be performed
use_marginsA flag indicating whether or not to use the version of this model with collision margins
[out]closest_pointsA reference to a vector of PointPair objects that contains the closest point information after this method is called
Returns
Whether this method successfully ran.

Implements Model.

Here is the caller graph for this function:

bool ClosestPointsPairwise ( const std::vector< ElementIdPair > &  id_pairs,
bool  use_margins,
std::vector< PointPair > *  closest_points 
)
overridevirtual

Computes the points of closest approach between specified pairs of collision elements.

Parameters
id_pairsA vector of ElementIdPair specifying which pairs of elements to consider
use_marginsA flag indicating whether or not to use the version of this model with collision margins
[out]closest_pointsA reference to a vector of PointPair objects that contains the closest point information after this method is called
Returns
Whether this method successfully ran.

Implements Model.

Here is the caller graph for this function:

std::vector< size_t > CollidingPoints ( const std::vector< Eigen::Vector3d > &  input_points,
double  collision_threshold 
)
overridevirtual

Given a vector of points in the world coordinate frame, returns the indices of those points that are within the provided collision_threshold distance of any collision geometry in the model.

In other words, the index i is included in the returned vector of indices iff a sphere of radius collision_threshold, located at input_points[i] collides with any collision element in the model.

Parameters
input_pointsThe list of points to check for collisions against the model.
collision_thresholdThe radius of a control sphere around each point used to check for collisions with the model.
Returns
A vector with indexes in input_points of all those points that do collide with the model within the specified threshold.
See also
drake/matlab/systems/plants/test/collidingPointsTest.m for a MATLAB test.

Implements Model.

Here is the caller graph for this function:

bool CollidingPointsCheckOnly ( const std::vector< Eigen::Vector3d > &  input_points,
double  collision_threshold 
)
overridevirtual

Given a vector of points in the world coordinate frame, reports if any of those points lie within a specified distance of any collision geometry in the model.

In other words, this method tests if any of the spheres of radius collision_threshold located at input_points[i] collides with any part of the model. This method returns as soon as any of these spheres collides with the model. Points are not checked against one another but only against the existing model.

Parameters
input_pointsThe list of points to check for collisions against the model.
collision_thresholdThe radius of a control sphere around each point used to check for collisions with the model.
Returns
Whether any of the points positively checks for collision.

Implements Model.

Here is the caller graph for this function:

void CollisionDetectFromPoints ( const Eigen::Matrix3Xd &  points,
bool  use_margins,
std::vector< PointPair > *  closest_points 
)
overridevirtual

Computes the closest distance from each point to any surface in the collision model utilizing Bullet's collision detection code.

Parameters
pointsAn ordered list of N points represented column-wise by a 3 x N Matrix.
use_marginsA flag indicating whether to use the version of this model with collision margins.
[out]closest_pointsA vector of N PointPair instances such that the i'th instance reports the query result for the i'th input point.

Implements Model.

Here is the caller graph for this function:

bool CollisionRaycast ( const Eigen::Matrix3Xd &  origin,
const Eigen::Matrix3Xd &  ray_endpoint,
bool  use_margins,
Eigen::VectorXd *  distances,
Eigen::Matrix3Xd *  normals 
)
overridevirtual

Performs a raycast intersection test (like a LIDAR / laser range finder).

Parameters
originA 3 x N matrix where each column specifies the position of a ray's origin in the world coordinate frame. If origin has dimensions of 3 x 1, the same origin is used for all rays.
ray_endpointA 3 x N matrix where each column specifies a second point on the corresponding ray.
use_marginsA flag indicating whether or not to use the version of this model with collision margins.
[out]distanceThe distance to the first collision, or -1 if no collision occurs.
Returns
Whether this method successfully ran.

Implements Model.

Here is the caller graph for this function:

bool ComputeMaximumDepthCollisionPoints ( bool  use_margins,
std::vector< PointPair > *  closest_points 
)
overridevirtual

Computes the point of closest approach between collision elements that are in contact.

Parameters
[in]use_marginsIf true the model uses the representation with margins. If false, the representation without margins is used instead.
[out]closest_pointsA reference to a vector of PointPair objects that contains the closest point information after this method is called.
Returns
Whether this method successfully ran.

Implements Model.

Here is the caller graph for this function:

UnusableModel& operator= ( UnusableModel &&  )
delete
UnusableModel& operator= ( const UnusableModel )
delete
bool UpdateElementWorldTransform ( ElementId  id,
const Eigen::Isometry3d &  X_WL 
)
overridevirtual

Updates the stored transformation from a collision element's canonical space to world space (X_WE), where X_WE = X_WL * X_LE.

X_LE is the transform that maps the element to its parent body's space, referred to as "local". X_WL maps the body/local space to the world.

Parameters
idThe ID of the element being updated.
X_WLThe new value for the local-to-world transform. It reflects the current world pose of the parent body in a given context.
Returns
Whether the update was successful.

Reimplemented from Model.

Here is the caller graph for this function:

void UpdateModel ( )
overridevirtual

Updates the collision model.

This method is typically called after changes are made to its collision elements.

Implements Model.

Here is the caller graph for this function:


The documentation for this class was generated from the following files: