Merge pull request #19 in OSHC/syropod_highlevel_controller from feature/namespace_directives to master

* commit '5d7594abb86a9ab19983ea76d2c8e53ae9c1ab5f':
  Various whitespace changes to fit lines within 120 chars
  Removed vscode folder
  Fixed line lengths to 120 characters and aligned inline comments
  Removed std namespace from standard includes header
  Removed ros namespace from standard includes header
  Removed tf2_ros namespace from standard includes header
  Removed Eigen namespace from standard includes header

Author: Jayasinghe, Oshada (Data61, Pullenvale)

include/syropod_highlevel_controller/admittance_controller.h

@@ -33,7 +33,7 @@ class AdmittanceController
   /// and calls initialisation.
   /// @param[in] model Pointer to the robot model class object
   /// @param[in] params Pointer to the parameter struct object  
-  AdmittanceController(shared_ptr<Model> model, const Parameters& params);
+  AdmittanceController(std::shared_ptr<Model> model, const Parameters& params);
 
   /// Iterates through legs in the robot model and updates the tip position offset value for each.
   /// The calculation is achieved through the use of a classical Runge-Kutta ODE solver with a force input
@@ -48,7 +48,7 @@ class AdmittanceController
   /// adjacent legs.
   /// @param[in] leg A pointer to the leg object associated with the stiffness value to be updated
   /// @param[in] scale_reference A double ranging from 0.0->1.0 which controls the scaling of the stiffnesses
-  void updateStiffness(shared_ptr<Leg> leg, const double& scale_reference);
+  void updateStiffness(std::shared_ptr<Leg> leg, const double& scale_reference);
 
   /// Scales virtual stiffness of swinging leg and adjacent legs according to the walk cycle of the walk controller.
   /// The percentage vertical position difference of the swinging leg tip from it's default position is used as a
@@ -58,11 +58,11 @@ class AdmittanceController
   /// load stiffness value applied to the two adjacent legs. The reseting and addition of stiffness allows overlapping
   /// step cycles to JOINTLY add stiffness to simultaneously adjacent legs.
   /// @param[in] walker A pointer to the walk controller
-  void updateStiffness(shared_ptr<WalkController> walker);
+  void updateStiffness(std::shared_ptr<WalkController> walker);
 
 private:
-  shared_ptr<Model> model_;  ///< Pointer to the robot model object
-  const Parameters& params_; ///< Pointer to parameter data structure for storing parameter variables
+  std::shared_ptr<Model> model_;  ///< Pointer to the robot model object
+  const Parameters& params_;      ///< Pointer to parameter data structure for storing parameter variables
 
 public:
   EIGEN_MAKE_ALIGNED_OPERATOR_NEW

include/syropod_highlevel_controller/debug_visualiser.h

@@ -32,59 +32,59 @@ class DebugVisualiser
   /// Publishes visualisation markers which represent the robot model for display in RVIZ. Consists of line segments.
   /// linking the origin points of each joint and tip of each leg.
   /// @param[in] model A pointer to the robot model object
-  void generateRobotModel(shared_ptr<Model> model);
+  void generateRobotModel(std::shared_ptr<Model> model);
 
   /// Publishes visualisation markers which represent the estimated walking plane.
   /// @param[in] walk_plane A Vector representing the walk plane
   /// @param[in] walk_plane_normal A Vector of the normal to the walk plane
-  void generateWalkPlane(const Vector3d& walk_plane, const Vector3d& walk_plane_normal);
+  void generateWalkPlane(const Eigen::Vector3d& walk_plane, const Eigen::Vector3d& walk_plane_normal);
 
   /// Publishes visualisation markers which represent the trajectory of the tip of the input leg.
   /// @param[in] leg A pointer to the leg associated with the tip trajectory that is to be published
-  void generateTipTrajectory(shared_ptr<Leg> leg);
+  void generateTipTrajectory(std::shared_ptr<Leg> leg);
 
   /// Publishes visualisation markers which represent an estimate of the terrain being traversed.
   /// @param[in] model A pointer to the robot model object
-  void generateTerrainEstimate(shared_ptr<Model> model);
+  void generateTerrainEstimate(std::shared_ptr<Model> model);
 
   /// Publishes visualisation markers which represent the control nodes of the three bezier curves used to control tip.
   /// trajectory of the input leg.
   /// @param[in] leg A pointer to the leg associated with the tip trajectory that is to be published
-  void generateBezierCurves(shared_ptr<Leg> leg);
+  void generateBezierCurves(std::shared_ptr<Leg> leg);
 
   /// Publishes visualisation markers which represent the default tip position of the leg.
   /// @param[in] leg A pointer to a leg of the robot model object
-  void generateDefaultTipPositions(shared_ptr<Leg> leg);
+  void generateDefaultTipPositions(std::shared_ptr<Leg> leg);
 
   /// Publises visualisation markers which represent the target tip position of the leg.
   /// @param[in] leg A pointer to a leg of the robot model object
-  void generateTargetTipPositions(shared_ptr<Leg> leg);
+  void generateTargetTipPositions(std::shared_ptr<Leg> leg);
 
   /// Publishes visualisation markers which represent the 2D walkspace for each leg.
   /// @param[in] leg A pointer to a leg of the robot model object
   /// @param[in] walkspace  A map of walkspace radii for a range of bearings to be visualised
-  void generateWalkspace(shared_ptr<Leg> leg, const LimitMap& walkspace);
+  void generateWalkspace(std::shared_ptr<Leg> leg, const LimitMap& walkspace);
 
   /// Publishes visualisation markers which represent the 3D workspace for each leg.
   /// @param[in] leg A pointer to a leg of the robot model object
   /// @param[in] body_clearance The vertical offset of the body above the walk plane
-  void generateWorkspace(shared_ptr<Leg> leg, const double& body_clearance);
+  void generateWorkspace(std::shared_ptr<Leg> leg, const double& body_clearance);
 
   /// Publishes visualisation markers which represent requested stride vector for each leg.
   /// @param[in] leg A pointer to the leg associated with the tip trajectory that is to be published
-  void generateStride(shared_ptr<Leg> leg);
+  void generateStride(std::shared_ptr<Leg> leg);
 
   /// Publishes visualisation markers which represent the estimated tip force vector for input leg.
   /// @param[in] leg A pointer to the leg associated with the tip trajectory that is to be published
-  void generateTipForce(shared_ptr<Leg> leg);
+  void generateTipForce(std::shared_ptr<Leg> leg);
 
   /// Publishes visualisation markers which represent the estimated percentage of max torque in each joint.
   /// @param[in] leg A pointer to the leg associated with the tip trajectory that is to be published
-  void generateJointTorques(shared_ptr<Leg> leg);
+  void generateJointTorques(std::shared_ptr<Leg> leg);
 
   /// Publishes visualisation markers which represent the estimate of the gravitational acceleration vector.
   /// @param[in] gravity_estimate An estimate of the gravitational acceleration vector
-  void generateGravity(const Vector3d& gravity_estimate);
+  void generateGravity(const Eigen::Vector3d& gravity_estimate);
 
 private:
   ros::Publisher robot_model_publisher_;          ///< Publisher for topic "/shc/visualisation/robot_model"