Rename NonColliding to CollisionFree (#256)

CHANGELOG.md

@@ -4,7 +4,8 @@
 
 * Constraint
 
-  * Added methods for removing groups from NonColliding constraints. [#247](https://github.com/personalrobotics/aikido/pull/247)
+  * Added methods for removing groups from NonColliding constraints: [#247](https://github.com/personalrobotics/aikido/pull/247)
+  * Renamed NonColliding to CollisionFree: [#256](https://github.com/personalrobotics/aikido/pull/256)
 
 * Planner
 

include/aikido/constraint.hpp

@@ -1,6 +1,7 @@
 #include "constraint/CartesianProductProjectable.hpp"
 #include "constraint/CartesianProductSampleable.hpp"
 #include "constraint/CartesianProductTestable.hpp"
+#include "constraint/CollisionFree.hpp"
 #include "constraint/CyclicSampleable.hpp"
 #include "constraint/Differentiable.hpp"
 #include "constraint/DifferentiableIntersection.hpp"
@@ -12,7 +13,6 @@
 #include "constraint/InverseKinematicsSampleable.hpp"
 #include "constraint/JointStateSpaceHelpers.hpp"
 #include "constraint/NewtonsMethodProjectable.hpp"
-#include "constraint/NonColliding.hpp"
 #include "constraint/Projectable.hpp"
 #include "constraint/RejectionSampleable.hpp"
 #include "constraint/Sampleable.hpp"

include/aikido/constraint/NonColliding.hpp → include/aikido/constraint/CollisionFree.hpp

@@ -1,5 +1,5 @@
-#ifndef AIKIDO_CONSTRAINT_NONCOLLIDING_HPP_
-#define AIKIDO_CONSTRAINT_NONCOLLIDING_HPP_
+#ifndef AIKIDO_CONSTRAINT_COLLISIONFREE_HPP_
+#define AIKIDO_CONSTRAINT_COLLISIONFREE_HPP_
 
 #include <memory>
 #include <tuple>
@@ -17,7 +17,7 @@ namespace constraint {
 /// A testable that uses a collision detector to check whether
 /// a metakeleton state (configuration) results in collision between and within
 /// specified collision groups.
-class NonColliding : public Testable
+class CollisionFree : public Testable
 {
 public:
   /// Constructs an empty constraint that uses \c _collisionDetector to test
@@ -27,7 +27,7 @@ class NonColliding : public Testable
   /// \param _statespace state space on which the constraint operates
   /// \param _collisionDetector collision detector used to test for collision
   /// \param _collisionOptions options passed to \c _collisionDetector
-  NonColliding(
+  CollisionFree(
       statespace::dart::MetaSkeletonStateSpacePtr _statespace,
       std::shared_ptr<dart::collision::CollisionDetector> _collisionDetector,
       dart::collision::CollisionOption _collisionOptions
@@ -77,9 +77,9 @@ class NonColliding : public Testable
   std::vector<std::shared_ptr<CollisionGroup>> mGroupsToSelfCheck;
 };
 
-using NonCollidingPtr = std::shared_ptr<NonColliding>;
+using CollisionFreePtr = std::shared_ptr<CollisionFree>;
 
 } // namespace constraint
 } // namespace aikido
 
-#endif // AIKIDO_CONSTRAINT_NONCOLLIDING_HPP_
+#endif // AIKIDO_CONSTRAINT_COLLISIONFREE_HPP_

src/constraint/CMakeLists.txt

@@ -18,7 +18,7 @@ set(sources
   InverseKinematicsSampleable.cpp
   JointStateSpaceHelpers.cpp
   NewtonsMethodProjectable.cpp
-  NonColliding.cpp
+  CollisionFree.cpp
   Projectable.cpp
   RejectionSampleable.cpp
   Sampleable.cpp

src/constraint/NonColliding.cpp → src/constraint/CollisionFree.cpp

@@ -1,10 +1,10 @@
-#include <aikido/constraint/NonColliding.hpp>
+#include <aikido/constraint/CollisionFree.hpp>
 
 namespace aikido {
 namespace constraint {
 
 //==============================================================================
-NonColliding::NonColliding(
+CollisionFree::CollisionFree(
     statespace::dart::MetaSkeletonStateSpacePtr _statespace,
     std::shared_ptr<dart::collision::CollisionDetector> _collisionDetector,
     dart::collision::CollisionOption _collisionOptions)
@@ -20,13 +20,13 @@ NonColliding::NonColliding(
 }
 
 //==============================================================================
-statespace::StateSpacePtr NonColliding::getStateSpace() const
+statespace::StateSpacePtr CollisionFree::getStateSpace() const
 {
   return mStatespace;
 }
 
 //==============================================================================
-bool NonColliding::isSatisfied(
+bool CollisionFree::isSatisfied(
     const aikido::statespace::StateSpace::State* _state) const
 {
   auto skelStatePtr = static_cast<const aikido::statespace::dart::
@@ -57,7 +57,7 @@ bool NonColliding::isSatisfied(
 }
 
 //==============================================================================
-void NonColliding::addPairwiseCheck(
+void CollisionFree::addPairwiseCheck(
     std::shared_ptr<dart::collision::CollisionGroup> _group1,
     std::shared_ptr<dart::collision::CollisionGroup> _group2)
 {
@@ -68,7 +68,7 @@ void NonColliding::addPairwiseCheck(
 }
 
 //==============================================================================
-void NonColliding::removePairwiseCheck(
+void CollisionFree::removePairwiseCheck(
     std::shared_ptr<dart::collision::CollisionGroup> _group1,
     std::shared_ptr<dart::collision::CollisionGroup> _group2)
 {
@@ -89,14 +89,14 @@ void NonColliding::removePairwiseCheck(
 }
 
 //==============================================================================
-void NonColliding::addSelfCheck(
+void CollisionFree::addSelfCheck(
     std::shared_ptr<dart::collision::CollisionGroup> _group)
 {
   mGroupsToSelfCheck.emplace_back(std::move(_group));
 }
 
 //==============================================================================
-void NonColliding::removeSelfCheck(
+void CollisionFree::removeSelfCheck(
     std::shared_ptr<dart::collision::CollisionGroup> _group)
 {
   mGroupsToSelfCheck.erase(

tests/constraint/CMakeLists.txt

@@ -118,9 +118,9 @@ aikido_add_test(test_Projectable
 target_link_libraries(test_Projectable
   "${PROJECT_NAME}_constraint")
 
-aikido_add_test(test_NonColliding
-  test_NonColliding.cpp)
-target_link_libraries(test_NonColliding
+aikido_add_test(test_CollisionFree
+  test_CollisionFree.cpp)
+target_link_libraries(test_CollisionFree
   "${PROJECT_NAME}_constraint")
 
 aikido_add_test(test_Differentiable

tests/constraint/test_NonColliding.cpp → tests/constraint/test_CollisionFree.cpp

@@ -1,21 +1,21 @@
 #include <dart/dart.hpp>
 #include <gtest/gtest.h>
-#include <aikido/constraint/NonColliding.hpp>
+#include <aikido/constraint/CollisionFree.hpp>
 #include <aikido/statespace/Rn.hpp>
 #include <aikido/statespace/SE3.hpp>
 #include <aikido/statespace/SO2.hpp>
 #include <aikido/statespace/dart/MetaSkeletonStateSpace.hpp>
 
 using aikido::statespace::dart::MetaSkeletonStateSpace;
 using aikido::statespace::dart::MetaSkeletonStateSpacePtr;
-using aikido::constraint::NonColliding;
+using aikido::constraint::CollisionFree;
 using aikido::statespace::SO2;
 using aikido::statespace::SE3;
 
 using namespace dart::dynamics;
 using namespace dart::collision;
 
-class NonCollidingTest : public ::testing::Test
+class CollisionFreeTest : public ::testing::Test
 {
 protected:
   void SetUp() override
@@ -80,36 +80,36 @@ class NonCollidingTest : public ::testing::Test
   MetaSkeletonStateSpacePtr mStateSpace;
 };
 
-TEST_F(NonCollidingTest, ConstructorThrowsOnNullStateSpace)
+TEST_F(CollisionFreeTest, ConstructorThrowsOnNullStateSpace)
 {
   EXPECT_THROW(
-      NonColliding(nullptr, mCollisionDetector), std::invalid_argument);
+      CollisionFree(nullptr, mCollisionDetector), std::invalid_argument);
 }
 
-TEST_F(NonCollidingTest, ConstructorThrowsOnNullCollisionDetector)
+TEST_F(CollisionFreeTest, ConstructorThrowsOnNullCollisionDetector)
 {
-  EXPECT_THROW(NonColliding(mStateSpace, nullptr), std::invalid_argument);
+  EXPECT_THROW(CollisionFree(mStateSpace, nullptr), std::invalid_argument);
 }
 
-TEST_F(NonCollidingTest, GetStateSpaceMatchStateSpace)
+TEST_F(CollisionFreeTest, GetStateSpaceMatchStateSpace)
 {
-  NonColliding constraint(mStateSpace, mCollisionDetector);
+  CollisionFree constraint(mStateSpace, mCollisionDetector);
   EXPECT_EQ(mStateSpace, constraint.getStateSpace());
 }
 
-TEST_F(NonCollidingTest, EmptyCollisionGroup_IsSatisfiedReturnsTrue)
+TEST_F(CollisionFreeTest, EmptyCollisionGroup_IsSatisfiedReturnsTrue)
 {
-  NonColliding constraint(mStateSpace, mCollisionDetector);
+  CollisionFree constraint(mStateSpace, mCollisionDetector);
 
   auto state = mStateSpace->getScopedStateFromMetaSkeleton();
   mStateSpace->setState(state);
 
   EXPECT_TRUE(constraint.isSatisfied(state));
 }
 
-TEST_F(NonCollidingTest, AddPairwiseCheckPasses_IsSatisfied)
+TEST_F(CollisionFreeTest, AddPairwiseCheckPasses_IsSatisfied)
 {
-  NonColliding constraint(mStateSpace, mCollisionDetector);
+  CollisionFree constraint(mStateSpace, mCollisionDetector);
   constraint.addPairwiseCheck(mCollisionGroup1, mCollisionGroup2);
 
   auto state = mStateSpace->getScopedStateFromMetaSkeleton();
@@ -122,19 +122,19 @@ TEST_F(NonCollidingTest, AddPairwiseCheckPasses_IsSatisfied)
   EXPECT_TRUE(constraint.isSatisfied(state));
 }
 
-TEST_F(NonCollidingTest, AddPairwiseCheckFails_IsSatisfied)
+TEST_F(CollisionFreeTest, AddPairwiseCheckFails_IsSatisfied)
 {
-  NonColliding constraint(mStateSpace, mCollisionDetector);
+  CollisionFree constraint(mStateSpace, mCollisionDetector);
 
   auto state = mStateSpace->getScopedStateFromMetaSkeleton();
 
   constraint.addPairwiseCheck(mCollisionGroup1, mCollisionGroup3);
   EXPECT_FALSE(constraint.isSatisfied(state));
 }
 
-TEST_F(NonCollidingTest, AddAndRemovePairwiseCheckFails_IsSatisfied)
+TEST_F(CollisionFreeTest, AddAndRemovePairwiseCheckFails_IsSatisfied)
 {
-  NonColliding constraint(mStateSpace, mCollisionDetector);
+  CollisionFree constraint(mStateSpace, mCollisionDetector);
 
   auto state = mStateSpace->getScopedStateFromMetaSkeleton();
 
@@ -151,28 +151,28 @@ TEST_F(NonCollidingTest, AddAndRemovePairwiseCheckFails_IsSatisfied)
   EXPECT_TRUE(constraint.isSatisfied(state));
 }
 
-TEST_F(NonCollidingTest, AddSelfCheckPasses_IsSatisfied)
+TEST_F(CollisionFreeTest, AddSelfCheckPasses_IsSatisfied)
 {
-  NonColliding constraint(mStateSpace, mCollisionDetector);
+  CollisionFree constraint(mStateSpace, mCollisionDetector);
 
   auto state = mStateSpace->getScopedStateFromMetaSkeleton();
   constraint.addSelfCheck(mCollisionGroup1);
   EXPECT_TRUE(constraint.isSatisfied(state));
 }
 
-TEST_F(NonCollidingTest, AddSelfCheckFails_IsSatisfied)
+TEST_F(CollisionFreeTest, AddSelfCheckFails_IsSatisfied)
 {
-  NonColliding constraint(mStateSpace, mCollisionDetector);
+  CollisionFree constraint(mStateSpace, mCollisionDetector);
 
   auto state = mStateSpace->getScopedStateFromMetaSkeleton();
 
   constraint.addSelfCheck(mCollisionGroup3);
   EXPECT_FALSE(constraint.isSatisfied(state));
 }
 
-TEST_F(NonCollidingTest, AddAndRemoveSelfCheckFails_IsSatisfied)
+TEST_F(CollisionFreeTest, AddAndRemoveSelfCheckFails_IsSatisfied)
 {
-  NonColliding constraint(mStateSpace, mCollisionDetector);
+  CollisionFree constraint(mStateSpace, mCollisionDetector);
 
   auto state = mStateSpace->getScopedStateFromMetaSkeleton();
 

tests/planner/test_SnapPlanner.cpp

@@ -1,7 +1,7 @@
 #include <tuple>
 #include <dart/dart.hpp>
 #include <gtest/gtest.h>
-#include <aikido/constraint/NonColliding.hpp>
+#include <aikido/constraint/CollisionFree.hpp>
 #include <aikido/constraint/Testable.hpp>
 #include <aikido/distance/defaults.hpp>
 #include <aikido/planner/PlanningResult.hpp>
@@ -19,7 +19,7 @@ class SnapPlannerTest : public ::testing::Test
 public:
   using FCLCollisionDetector = dart::collision::FCLCollisionDetector;
   using StateSpace = aikido::statespace::dart::MetaSkeletonStateSpace;
-  using NonColliding = aikido::constraint::NonColliding;
+  using CollisionFree = aikido::constraint::CollisionFree;
   using DistanceMetric = aikido::distance::DistanceMetric;
   using MetaSkeletonStateSpace
       = aikido::statespace::dart::MetaSkeletonStateSpace;

tests/planner/vectorfield/test_VectorFieldPlanner.cpp

@@ -1,7 +1,7 @@
 #include <gtest/gtest.h>
 #include <tuple>
 #include <dart/dart.hpp>
-#include <aikido/constraint/NonColliding.hpp>
+#include <aikido/constraint/CollisionFree.hpp>
 #include <aikido/constraint/Testable.hpp>
 #include <aikido/distance/defaults.hpp>
 #include <aikido/planner/PlanningResult.hpp>
@@ -20,7 +20,7 @@ class VectorFieldPlannerTest : public ::testing::Test
 public:
   using FCLCollisionDetector = dart::collision::FCLCollisionDetector;
   using StateSpace = aikido::statespace::dart::MetaSkeletonStateSpace;
-  using NonColliding = aikido::constraint::NonColliding;
+  using CollisionFree = aikido::constraint::CollisionFree;
   using DistanceMetric = aikido::distance::DistanceMetric;
   using MetaSkeletonStateSpacePtr
       = aikido::statespace::dart::MetaSkeletonStateSpacePtr;