Address review

Author: sjahr

moveit_core/collision_detection/include/moveit/collision_detection/collision_common.h

@@ -151,10 +151,10 @@ struct CollisionRequest
   std::string group_name = "";
 
   /** \brief If true, use padded collision environment */
-  bool use_padded_collision_environment = true;
+  bool pad_environment_collisions = true;
 
   /** \brief If true, do self collision check with padded robot links */
-  bool use_padded_self_collision = false;
+  bool pad_self_collisions = false;
 
   /** \brief If true, compute proximity distance */
   bool distance = false;

moveit_core/planning_scene/include/moveit/planning_scene/planning_scene.h

@@ -368,7 +368,7 @@ class MOVEIT_PLANNING_SCENE_EXPORT PlanningScene : public std::enable_shared_fro
                       const collision_detection::AllowedCollisionMatrix& acm) const;
 
   /** \brief Check whether a specified state (\e robot_state) is in collision, with respect to a given
-      allowed collision matrix (\e acm). */
+      allowed collision matrix (\e acm). If validate_transforms is set true, the given robot state is checked for dirty transforms. */
   void checkCollision(const collision_detection::CollisionRequest& req, collision_detection::CollisionResult& res,
                       const moveit::core::RobotState& robot_state,
                       const collision_detection::AllowedCollisionMatrix& acm, bool validate_transforms = true) const;

moveit_core/planning_scene/src/planning_scene.cpp

@@ -440,8 +440,8 @@ void PlanningScene::checkCollision(const collision_detection::CollisionRequest&
                              "transforms before checking collision.");
   }
   // check collision with the world using the padded version
-  req.use_padded_collision_environment ? getCollisionEnv()->checkRobotCollision(req, res, robot_state, acm) :
-                                         getCollisionEnvUnpadded()->checkRobotCollision(req, res, robot_state, acm);
+  req.pad_environment_collisions ? getCollisionEnv()->checkRobotCollision(req, res, robot_state, acm) :
+                                   getCollisionEnvUnpadded()->checkRobotCollision(req, res, robot_state, acm);
 
   // Return early if a collision was found or the maximum number of allowed contacts is exceeded
   if (res.collision || (req.contacts && res.contacts.size() >= req.max_contacts))
@@ -450,23 +450,23 @@ void PlanningScene::checkCollision(const collision_detection::CollisionRequest&
   }
 
   // do self-collision checking with the unpadded version of the robot
-  req.use_padded_self_collision ? getCollisionEnv()->checkSelfCollision(req, res, robot_state, acm) :
-                                  getCollisionEnvUnpadded()->checkSelfCollision(req, res, robot_state, acm);
+  req.pad_self_collisions ? getCollisionEnv()->checkSelfCollision(req, res, robot_state, acm) :
+                            getCollisionEnvUnpadded()->checkSelfCollision(req, res, robot_state, acm);
 }
 
 void PlanningScene::checkCollisionUnpadded(const collision_detection::CollisionRequest& req,
                                            collision_detection::CollisionResult& res)
 {
   collision_detection::CollisionRequest new_req = req;
-  new_req.use_padded_collision_environment = false;
+  new_req.pad_environment_collisions = false;
   checkCollision(req, res, getCurrentStateNonConst(), getAllowedCollisionMatrix());
 }
 
 void PlanningScene::checkCollisionUnpadded(const collision_detection::CollisionRequest& req,
                                            collision_detection::CollisionResult& res) const
 {
   collision_detection::CollisionRequest new_req = req;
-  new_req.use_padded_collision_environment = false;
+  new_req.pad_environment_collisions = false;
   checkCollision(new_req, res, getCurrentState(), getAllowedCollisionMatrix());
 }
 
@@ -475,7 +475,7 @@ void PlanningScene::checkCollisionUnpadded(const collision_detection::CollisionR
                                            const moveit::core::RobotState& robot_state) const
 {
   collision_detection::CollisionRequest new_req = req;
-  new_req.use_padded_collision_environment = false;
+  new_req.pad_environment_collisions = false;
   checkCollision(new_req, res, robot_state, getAllowedCollisionMatrix());
 }
 
@@ -484,7 +484,7 @@ void PlanningScene::checkCollisionUnpadded(const collision_detection::CollisionR
                                            moveit::core::RobotState& robot_state) const
 {
   collision_detection::CollisionRequest new_req = req;
-  new_req.use_padded_collision_environment = false;
+  new_req.pad_environment_collisions = false;
   checkCollision(new_req, res, static_cast<const moveit::core::RobotState&>(robot_state), getAllowedCollisionMatrix());
 }
 
@@ -495,7 +495,7 @@ void PlanningScene::checkCollisionUnpadded(const collision_detection::CollisionR
 {
   robot_state.updateCollisionBodyTransforms();
   collision_detection::CollisionRequest new_req = req;
-  new_req.use_padded_collision_environment = false;
+  new_req.pad_environment_collisions = false;
   checkCollision(new_req, res, static_cast<const moveit::core::RobotState&>(robot_state), acm);
 }
 
@@ -505,7 +505,7 @@ void PlanningScene::checkCollisionUnpadded(const collision_detection::CollisionR
                                            const collision_detection::AllowedCollisionMatrix& acm) const
 {
   collision_detection::CollisionRequest new_req = req;
-  new_req.use_padded_collision_environment = false;
+  new_req.pad_environment_collisions = false;
   checkCollision(req, res, robot_state, acm);
 }
 
@@ -515,7 +515,6 @@ void PlanningScene::checkSelfCollision(const collision_detection::CollisionReque
   checkSelfCollision(req, res, getCurrentStateNonConst());
 }
 
-/** \brief Check whether the current state is in self collision */
 void PlanningScene::checkSelfCollision(const collision_detection::CollisionRequest& req,
                                        collision_detection::CollisionResult& res) const
 {
@@ -556,8 +555,8 @@ void PlanningScene::checkSelfCollision(const collision_detection::CollisionReque
                                        const moveit::core::RobotState& robot_state,
                                        const collision_detection::AllowedCollisionMatrix& acm) const
 {
-  req.use_padded_self_collision ? getCollisionEnv()->checkSelfCollision(req, res, robot_state, acm) :
-                                  getCollisionEnvUnpadded()->checkSelfCollision(req, res, robot_state, acm);
+  req.pad_self_collisions ? getCollisionEnv()->checkSelfCollision(req, res, robot_state, acm) :
+                            getCollisionEnvUnpadded()->checkSelfCollision(req, res, robot_state, acm);
 }
 
 void PlanningScene::getCollidingPairs(collision_detection::CollisionResult::ContactMap& contacts)

moveit_ros/benchmarks/src/BenchmarkExecutor.cpp

@@ -1010,7 +1010,7 @@ void BenchmarkExecutor::collectMetrics(PlannerRunData& metrics,
 
       // compute correctness and clearance
       collision_detection::CollisionRequest req;
-      req.use_padded_collision_environment = false;
+      req.pad_environment_collisions = false;
       for (std::size_t k = 0; k < p.getWayPointCount(); ++k)
       {
         collision_detection::CollisionResult res;

moveit_ros/planning/plan_execution/src/plan_execution.cpp

@@ -282,7 +282,7 @@ bool plan_execution::PlanExecution::isRemainingPathValid(const ExecutableMotionP
     std::size_t wpc = t.getWayPointCount();
     collision_detection::CollisionRequest req;
     req.group_name = t.getGroupName();
-    req.use_padded_collision_environment = false;
+    req.pad_environment_collisions = false;
     for (std::size_t i = std::max(path_segment.second - 1, 0); i < wpc; ++i)
     {
       collision_detection::CollisionResult res;