Revert "Changed name to namespace for motion planner tasks"

This reverts commit 88ef0b2.

tesseract_motion_planners/core/include/tesseract_motion_planners/core/planner.h

@@ -37,18 +37,18 @@ class MotionPlanner
   using ConstPtr = std::shared_ptr<const MotionPlanner>;
   /** @brief Construct a basic planner */
   MotionPlanner() = default;
-  MotionPlanner(std::string ns);
+  MotionPlanner(std::string name);
   virtual ~MotionPlanner() = default;
   MotionPlanner(const MotionPlanner&) = delete;
   MotionPlanner& operator=(const MotionPlanner&) = delete;
   MotionPlanner(MotionPlanner&&) = delete;
   MotionPlanner& operator=(MotionPlanner&&) = delete;
 
   /**
-   *  @brief Get the namespace of this planner
+   *  @brief Get the name of this planner
    *  @details This is also used as the namespace for the profiles in the profile dictionary
    */
-  const std::string& getNamespace() const;
+  const std::string& getName() const;
 
   /**
    * @brief Solve the planner request problem
@@ -79,7 +79,7 @@ class MotionPlanner
                              bool format_result_as_input);
 
 protected:
-  std::string ns_;
+  std::string name_;
 };
 }  // namespace tesseract_planning
 #endif  // TESSERACT_PLANNING_PLANNER_H

tesseract_motion_planners/core/src/planner.cpp

@@ -28,13 +28,13 @@
 
 namespace tesseract_planning
 {
-MotionPlanner::MotionPlanner(std::string ns) : ns_(std::move(ns))
+MotionPlanner::MotionPlanner(std::string name) : name_(std::move(name))
 {
-  if (ns_.empty())
-    throw std::runtime_error("MotionPlanner namespace is empty!");
+  if (name_.empty())
+    throw std::runtime_error("MotionPlanner name is empty!");
 }
 
-const std::string& MotionPlanner::getNamespace() const { return ns_; }
+const std::string& MotionPlanner::getName() const { return name_; }
 
 bool MotionPlanner::checkRequest(const PlannerRequest& request)
 {

tesseract_motion_planners/descartes/include/tesseract_motion_planners/descartes/descartes_motion_planner.h

@@ -19,7 +19,7 @@ class DescartesMotionPlanner : public MotionPlanner
 {
 public:
   /** @brief Construct a basic planner */
-  DescartesMotionPlanner(std::string ns);
+  DescartesMotionPlanner(std::string name);
   ~DescartesMotionPlanner() override = default;
   DescartesMotionPlanner(const DescartesMotionPlanner&) = delete;
   DescartesMotionPlanner& operator=(const DescartesMotionPlanner&) = delete;

tesseract_motion_planners/descartes/include/tesseract_motion_planners/descartes/impl/descartes_motion_planner.hpp

@@ -55,7 +55,7 @@ constexpr auto ERROR_FAILED_TO_FIND_VALID_SOLUTION{ "Failed to find valid soluti
 namespace tesseract_planning
 {
 template <typename FloatType>
-DescartesMotionPlanner<FloatType>::DescartesMotionPlanner(std::string ns) : MotionPlanner(std::move(ns))  // NOLINT
+DescartesMotionPlanner<FloatType>::DescartesMotionPlanner(std::string name) : MotionPlanner(std::move(name))  // NOLINT
 {
 }
 
@@ -213,7 +213,7 @@ void DescartesMotionPlanner<FloatType>::clear()
 template <typename FloatType>
 MotionPlanner::Ptr DescartesMotionPlanner<FloatType>::clone() const
 {
-  return std::make_shared<DescartesMotionPlanner<FloatType>>(ns_);
+  return std::make_shared<DescartesMotionPlanner<FloatType>>(name_);
 }
 
 template <typename FloatType>
@@ -284,10 +284,10 @@ DescartesMotionPlanner<FloatType>::createProblem(const PlannerRequest& request)
 
     // Get Plan Profile
     std::string profile = plan_instruction.getProfile();
-    profile = getProfileString(ns_, profile, request.plan_profile_remapping);
+    profile = getProfileString(name_, profile, request.plan_profile_remapping);
     auto cur_plan_profile = getProfile<DescartesPlanProfile<FloatType>>(
-        ns_, profile, *request.profiles, std::make_shared<DescartesDefaultPlanProfile<FloatType>>());
-    //      cur_plan_profile = applyProfileOverrides(ns_, profile, cur_plan_profile,
+        name_, profile, *request.profiles, std::make_shared<DescartesDefaultPlanProfile<FloatType>>());
+    //      cur_plan_profile = applyProfileOverrides(name_, profile, cur_plan_profile,
     //      plan_instruction.profile_overrides);
     if (!cur_plan_profile)
       throw std::runtime_error("DescartesMotionPlanner: Invalid profile");

tesseract_motion_planners/ompl/include/tesseract_motion_planners/ompl/ompl_motion_planner.h

@@ -56,7 +56,7 @@ class OMPLMotionPlanner : public MotionPlanner
 {
 public:
   /** @brief Construct a planner */
-  OMPLMotionPlanner(std::string ns);
+  OMPLMotionPlanner(std::string name);
 
   /**
    * @brief Sets up the OMPL problem then solves. It is intended to simplify setting up

tesseract_motion_planners/ompl/src/ompl_motion_planner.cpp

@@ -89,7 +89,7 @@ bool checkGoalState(const ompl::base::ProblemDefinitionPtr& prob_def,
 }
 
 /** @brief Construct a basic planner */
-OMPLMotionPlanner::OMPLMotionPlanner(std::string ns) : MotionPlanner(std::move(ns)) {}
+OMPLMotionPlanner::OMPLMotionPlanner(std::string name) : MotionPlanner(std::move(name)) {}
 
 bool OMPLMotionPlanner::terminate()
 {
@@ -307,7 +307,7 @@ PlannerResponse OMPLMotionPlanner::solve(const PlannerRequest& request) const
 
 void OMPLMotionPlanner::clear() { parallel_plan_ = nullptr; }
 
-MotionPlanner::Ptr OMPLMotionPlanner::clone() const { return std::make_shared<OMPLMotionPlanner>(ns_); }
+MotionPlanner::Ptr OMPLMotionPlanner::clone() const { return std::make_shared<OMPLMotionPlanner>(name_); }
 
 OMPLProblemConfig OMPLMotionPlanner::createSubProblem(const PlannerRequest& request,
                                                       const tesseract_common::ManipulatorInfo& composite_mi,
@@ -322,10 +322,10 @@ OMPLProblemConfig OMPLMotionPlanner::createSubProblem(const PlannerRequest& requ
 
   // Get Plan Profile
   std::string profile = end_instruction.getProfile();
-  profile = getProfileString(ns_, profile, request.plan_profile_remapping);
+  profile = getProfileString(name_, profile, request.plan_profile_remapping);
   auto cur_plan_profile =
-      getProfile<OMPLPlanProfile>(ns_, profile, *request.profiles, std::make_shared<OMPLDefaultPlanProfile>());
-  cur_plan_profile = applyProfileOverrides(ns_, profile, cur_plan_profile, end_instruction.getProfileOverrides());
+      getProfile<OMPLPlanProfile>(name_, profile, *request.profiles, std::make_shared<OMPLDefaultPlanProfile>());
+  cur_plan_profile = applyProfileOverrides(name_, profile, cur_plan_profile, end_instruction.getProfileOverrides());
   if (!cur_plan_profile)
     throw std::runtime_error("OMPLMotionPlanner: Invalid profile");
 

tesseract_motion_planners/simple/include/tesseract_motion_planners/simple/simple_motion_planner.h

@@ -52,7 +52,7 @@ class SimpleMotionPlanner : public MotionPlanner
   using ConstPtr = std::shared_ptr<const SimpleMotionPlanner>;
 
   /** @brief Construct a basic planner */
-  SimpleMotionPlanner(std::string ns);
+  SimpleMotionPlanner(std::string name);
   ~SimpleMotionPlanner() override = default;
   SimpleMotionPlanner(const SimpleMotionPlanner&) = delete;
   SimpleMotionPlanner& operator=(const SimpleMotionPlanner&) = delete;

tesseract_motion_planners/simple/src/interpolation.cpp

@@ -1302,11 +1302,11 @@ CompositeInstruction generateInterpolatedProgram(const CompositeInstruction& ins
 
   // Create profile dictionary
   auto profiles = std::make_shared<ProfileDictionary>();
-  profiles->addProfile<SimplePlannerPlanProfile>(planner.getNamespace(), instructions.getProfile(), profile);
+  profiles->addProfile<SimplePlannerPlanProfile>(planner.getName(), instructions.getProfile(), profile);
   auto flat = instructions.flatten(&moveFilter);
   for (const auto& i : flat)
     profiles->addProfile<SimplePlannerPlanProfile>(
-        planner.getNamespace(), i.get().as<MoveInstructionPoly>().getProfile(), profile);
+        planner.getName(), i.get().as<MoveInstructionPoly>().getProfile(), profile);
 
   // Assign profile dictionary
   request.profiles = profiles;

tesseract_motion_planners/simple/src/simple_motion_planner.cpp

@@ -46,7 +46,7 @@ constexpr auto FAILED_TO_FIND_VALID_SOLUTION{ "Failed to find valid solution" };
 
 namespace tesseract_planning
 {
-SimpleMotionPlanner::SimpleMotionPlanner(std::string ns) : MotionPlanner(std::move(ns)) {}
+SimpleMotionPlanner::SimpleMotionPlanner(std::string name) : MotionPlanner(std::move(name)) {}
 
 bool SimpleMotionPlanner::terminate()
 {
@@ -56,7 +56,7 @@ bool SimpleMotionPlanner::terminate()
 
 void SimpleMotionPlanner::clear() {}
 
-MotionPlanner::Ptr SimpleMotionPlanner::clone() const { return std::make_shared<SimpleMotionPlanner>(ns_); }
+MotionPlanner::Ptr SimpleMotionPlanner::clone() const { return std::make_shared<SimpleMotionPlanner>(name_); }
 
 PlannerResponse SimpleMotionPlanner::solve(const PlannerRequest& request) const
 {
@@ -196,17 +196,18 @@ CompositeInstruction SimpleMotionPlanner::processCompositeInstruction(const Comp
       SimplePlannerPlanProfile::ConstPtr plan_profile;
       if (base_instruction.getPathProfile().empty())
       {
-        std::string profile = getProfileString(ns_, base_instruction.getProfile(), request.plan_profile_remapping);
+        std::string profile = getProfileString(name_, base_instruction.getProfile(), request.plan_profile_remapping);
         plan_profile = getProfile<SimplePlannerPlanProfile>(
-            ns_, profile, *request.profiles, std::make_shared<SimplePlannerLVSNoIKPlanProfile>());
-        plan_profile = applyProfileOverrides(ns_, profile, plan_profile, base_instruction.getProfileOverrides());
+            name_, profile, *request.profiles, std::make_shared<SimplePlannerLVSNoIKPlanProfile>());
+        plan_profile = applyProfileOverrides(name_, profile, plan_profile, base_instruction.getProfileOverrides());
       }
       else
       {
-        std::string profile = getProfileString(ns_, base_instruction.getPathProfile(), request.plan_profile_remapping);
+        std::string profile =
+            getProfileString(name_, base_instruction.getPathProfile(), request.plan_profile_remapping);
         plan_profile = getProfile<SimplePlannerPlanProfile>(
-            ns_, profile, *request.profiles, std::make_shared<SimplePlannerLVSNoIKPlanProfile>());
-        plan_profile = applyProfileOverrides(ns_, profile, plan_profile, base_instruction.getProfileOverrides());
+            name_, profile, *request.profiles, std::make_shared<SimplePlannerLVSNoIKPlanProfile>());
+        plan_profile = applyProfileOverrides(name_, profile, plan_profile, base_instruction.getProfileOverrides());
       }
 
       if (!plan_profile)

tesseract_motion_planners/trajopt/include/tesseract_motion_planners/trajopt/trajopt_motion_planner.h

@@ -40,7 +40,7 @@ class TrajOptMotionPlanner : public MotionPlanner
 {
 public:
   /** @brief Construct a basic planner */
-  TrajOptMotionPlanner(std::string ns);
+  TrajOptMotionPlanner(std::string name);
 
   ~TrajOptMotionPlanner() override = default;
   TrajOptMotionPlanner(const TrajOptMotionPlanner&) = delete;

tesseract_motion_planners/trajopt/src/trajopt_motion_planner.cpp

@@ -52,7 +52,7 @@ using namespace trajopt;
 
 namespace tesseract_planning
 {
-TrajOptMotionPlanner::TrajOptMotionPlanner(std::string ns) : MotionPlanner(std::move(ns)) {}
+TrajOptMotionPlanner::TrajOptMotionPlanner(std::string name) : MotionPlanner(std::move(name)) {}
 
 bool TrajOptMotionPlanner::terminate()
 {
@@ -62,7 +62,7 @@ bool TrajOptMotionPlanner::terminate()
 
 void TrajOptMotionPlanner::clear() {}
 
-MotionPlanner::Ptr TrajOptMotionPlanner::clone() const { return std::make_shared<TrajOptMotionPlanner>(ns_); }
+MotionPlanner::Ptr TrajOptMotionPlanner::clone() const { return std::make_shared<TrajOptMotionPlanner>(name_); }
 
 PlannerResponse TrajOptMotionPlanner::solve(const PlannerRequest& request) const
 {
@@ -212,10 +212,10 @@ TrajOptMotionPlanner::createProblem(const PlannerRequest& request) const
   // Apply Solver parameters
   std::string profile = request.instructions.getProfile();
   ProfileDictionary::ConstPtr profile_overrides = request.instructions.getProfileOverrides();
-  profile = getProfileString(ns_, profile, request.plan_profile_remapping);
+  profile = getProfileString(name_, profile, request.plan_profile_remapping);
   TrajOptSolverProfile::ConstPtr solver_profile = getProfile<TrajOptSolverProfile>(
-      ns_, profile, *request.profiles, std::make_shared<TrajOptDefaultSolverProfile>());
-  solver_profile = applyProfileOverrides(ns_, profile, solver_profile, profile_overrides);
+      name_, profile, *request.profiles, std::make_shared<TrajOptDefaultSolverProfile>());
+  solver_profile = applyProfileOverrides(name_, profile, solver_profile, profile_overrides);
   if (!solver_profile)
     throw std::runtime_error("TrajOptMotionPlanner: Invalid profile");
 
@@ -250,10 +250,10 @@ TrajOptMotionPlanner::createProblem(const PlannerRequest& request) const
       throw std::runtime_error("TrajOpt, working_frame is empty!");
 
     // Get Plan Profile
-    std::string profile = getProfileString(ns_, move_instruction.getProfile(), request.plan_profile_remapping);
-    TrajOptPlanProfile::ConstPtr cur_plan_profile =
-        getProfile<TrajOptPlanProfile>(ns_, profile, *request.profiles, std::make_shared<TrajOptDefaultPlanProfile>());
-    cur_plan_profile = applyProfileOverrides(ns_, profile, cur_plan_profile, move_instruction.getProfileOverrides());
+    std::string profile = getProfileString(name_, move_instruction.getProfile(), request.plan_profile_remapping);
+    TrajOptPlanProfile::ConstPtr cur_plan_profile = getProfile<TrajOptPlanProfile>(
+        name_, profile, *request.profiles, std::make_shared<TrajOptDefaultPlanProfile>());
+    cur_plan_profile = applyProfileOverrides(name_, profile, cur_plan_profile, move_instruction.getProfileOverrides());
     if (!cur_plan_profile)
       throw std::runtime_error("TrajOptMotionPlanner: Invalid profile");
 
@@ -333,11 +333,11 @@ TrajOptMotionPlanner::createProblem(const PlannerRequest& request) const
   for (long i = 0; i < pci->basic_info.n_steps; ++i)
     pci->init_info.data.row(i) = seed_states[static_cast<std::size_t>(i)];
 
-  profile = getProfileString(ns_, request.instructions.getProfile(), request.composite_profile_remapping);
+  profile = getProfileString(name_, request.instructions.getProfile(), request.composite_profile_remapping);
   TrajOptCompositeProfile::ConstPtr cur_composite_profile = getProfile<TrajOptCompositeProfile>(
-      ns_, profile, *request.profiles, std::make_shared<TrajOptDefaultCompositeProfile>());
+      name_, profile, *request.profiles, std::make_shared<TrajOptDefaultCompositeProfile>());
   cur_composite_profile =
-      applyProfileOverrides(ns_, profile, cur_composite_profile, request.instructions.getProfileOverrides());
+      applyProfileOverrides(name_, profile, cur_composite_profile, request.instructions.getProfileOverrides());
   if (!cur_composite_profile)
     throw std::runtime_error("TrajOptMotionPlanner: Invalid profile");
 

tesseract_motion_planners/trajopt_ifopt/include/tesseract_motion_planners/trajopt_ifopt/trajopt_ifopt_motion_planner.h

@@ -41,7 +41,7 @@ class TrajOptIfoptMotionPlanner : public MotionPlanner
 {
 public:
   /** @brief Construct a basic planner */
-  TrajOptIfoptMotionPlanner(std::string ns);
+  TrajOptIfoptMotionPlanner(std::string name);
 
   ~TrajOptIfoptMotionPlanner() override = default;
   TrajOptIfoptMotionPlanner(const TrajOptIfoptMotionPlanner&) = delete;

tesseract_motion_planners/trajopt_ifopt/src/trajopt_ifopt_motion_planner.cpp

@@ -50,15 +50,18 @@ using namespace trajopt_ifopt;
 
 namespace tesseract_planning
 {
-TrajOptIfoptMotionPlanner::TrajOptIfoptMotionPlanner(std::string ns) : MotionPlanner(std::move(ns)) {}
+TrajOptIfoptMotionPlanner::TrajOptIfoptMotionPlanner(std::string name) : MotionPlanner(std::move(name)) {}
 
 bool TrajOptIfoptMotionPlanner::terminate()
 {
   CONSOLE_BRIDGE_logWarn("Termination of ongoing optimization is not implemented yet");
   return false;
 }
 
-MotionPlanner::Ptr TrajOptIfoptMotionPlanner::clone() const { return std::make_shared<TrajOptIfoptMotionPlanner>(ns_); }
+MotionPlanner::Ptr TrajOptIfoptMotionPlanner::clone() const
+{
+  return std::make_shared<TrajOptIfoptMotionPlanner>(name_);
+}
 
 PlannerResponse TrajOptIfoptMotionPlanner::solve(const PlannerRequest& request) const
 {
@@ -215,10 +218,10 @@ std::shared_ptr<TrajOptIfoptProblem> TrajOptIfoptMotionPlanner::createProblem(co
   // Apply Solver parameters
   std::string profile = request.instructions.getProfile();
   ProfileDictionary::ConstPtr profile_overrides = request.instructions.getProfileOverrides();
-  profile = getProfileString(ns_, profile, request.plan_profile_remapping);
+  profile = getProfileString(name_, profile, request.plan_profile_remapping);
   TrajOptIfoptSolverProfile::ConstPtr solver_profile = getProfile<TrajOptIfoptSolverProfile>(
-      ns_, profile, *request.profiles, std::make_shared<TrajOptIfoptDefaultSolverProfile>());
-  solver_profile = applyProfileOverrides(ns_, profile, solver_profile, profile_overrides);
+      name_, profile, *request.profiles, std::make_shared<TrajOptIfoptDefaultSolverProfile>());
+  solver_profile = applyProfileOverrides(name_, profile, solver_profile, profile_overrides);
   if (!solver_profile)
     throw std::runtime_error("TrajOptIfoptMotionPlanner: Invalid profile");
 
@@ -253,10 +256,10 @@ std::shared_ptr<TrajOptIfoptProblem> TrajOptIfoptMotionPlanner::createProblem(co
       throw std::runtime_error("TrajOpt, working_frame is empty!");
 
     // Get Plan Profile
-    std::string profile = getProfileString(ns_, move_instruction.getProfile(), request.plan_profile_remapping);
+    std::string profile = getProfileString(name_, move_instruction.getProfile(), request.plan_profile_remapping);
     TrajOptIfoptPlanProfile::ConstPtr cur_plan_profile = getProfile<TrajOptIfoptPlanProfile>(
-        ns_, profile, *request.profiles, std::make_shared<TrajOptIfoptDefaultPlanProfile>());
-    cur_plan_profile = applyProfileOverrides(ns_, profile, cur_plan_profile, move_instruction.getProfileOverrides());
+        name_, profile, *request.profiles, std::make_shared<TrajOptIfoptDefaultPlanProfile>());
+    cur_plan_profile = applyProfileOverrides(name_, profile, cur_plan_profile, move_instruction.getProfileOverrides());
     if (!cur_plan_profile)
       throw std::runtime_error("TrajOptMotionPlanner: Invalid profile");
 
@@ -341,11 +344,11 @@ std::shared_ptr<TrajOptIfoptProblem> TrajOptIfoptMotionPlanner::createProblem(co
   // ----------------
   // Translate TCL for CompositeInstructions
   // ----------------
-  profile = getProfileString(ns_, request.instructions.getProfile(), request.composite_profile_remapping);
+  profile = getProfileString(name_, request.instructions.getProfile(), request.composite_profile_remapping);
   TrajOptIfoptCompositeProfile::ConstPtr cur_composite_profile = getProfile<TrajOptIfoptCompositeProfile>(
-      ns_, profile, *request.profiles, std::make_shared<TrajOptIfoptDefaultCompositeProfile>());
+      name_, profile, *request.profiles, std::make_shared<TrajOptIfoptDefaultCompositeProfile>());
   cur_composite_profile =
-      applyProfileOverrides(ns_, profile, cur_composite_profile, request.instructions.getProfileOverrides());
+      applyProfileOverrides(name_, profile, cur_composite_profile, request.instructions.getProfileOverrides());
   if (!cur_composite_profile)
     throw std::runtime_error("DefaultTrajoptIfoptProblemGenerator: Invalid profile");
 

tesseract_task_composer/planning/include/tesseract_task_composer/planning/nodes/motion_planner_task.hpp

@@ -173,7 +173,7 @@ class MotionPlannerTask : public TaskComposerTask
     }
 
     CONSOLE_BRIDGE_logInform("%s motion planning failed (%s) for process input: %s",
-                             planner_->getNamespace().c_str(),
+                             planner_->getName().c_str(),
                              response.message.c_str(),
                              instructions.getDescription().c_str());