Add codespell to .precommit and fix spelling errors (#689)

Author: DLu

.pre-commit-config.yaml

@@ -53,3 +53,9 @@ repos:
         language: system
         always_run: true
         pass_filenames: false
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.0.0
+    hooks:
+      - id: codespell
+        args: ['--write-changes', '-L', 'debians']
+        exclude: _themes

doc/bullet_collision_checker/src/bullet_collision_checker_tutorial.cpp

@@ -124,7 +124,7 @@ void computeCollisionContactPoints(InteractiveRobot& robot)
       color.a = 0.5;
       visualization_msgs::MarkerArray markers;
 
-      /* Get the contact ponts and display them as markers */
+      /* Get the contact points and display them as markers */
       collision_detection::getCollisionMarkersFromContacts(markers, "panda_link0", c_res.contacts, color,
                                                            ros::Duration(),  // remain until deleted
                                                            0.01);            // radius
@@ -310,7 +310,7 @@ int main(int argc, char** argv)
   color.g = 0.0;
   color.b = 1.0;
   color.a = 0.5;
-  /* Get the contact ponts and display them as markers */
+  /* Get the contact points and display them as markers */
   collision_detection::getCollisionMarkersFromContacts(markers, "panda_link0", res.contacts, color, ros::Duration(),
                                                        0.01);
   publishMarkers(markers);

doc/chomp_planner/chomp_planner_tutorial.rst

@@ -34,7 +34,7 @@ If you have the ``panda_moveit_config`` from the `ros-planning/panda_moveit_conf
 
 Running CHOMP with Obstacles in the Scene
 +++++++++++++++++++++++++++++++++++++++++
-To run CHOMP in an evironment with obstacles, you can run the sample python script:
+To run CHOMP in an environment with obstacles, you can run the sample python script:
 
   :codedir:`collision_scene_example.py<collision_environments/scripts/collision_scene_example.py>`.
 
@@ -52,7 +52,7 @@ or: ::
 
   rosrun moveit_tutorials collision_scene_example.py sparse
 
-Next, in RViz, select CHOMP in the MotionPlanning pannel under the Context tab. Set the desired start and goal states by moving the end-effector around with the imarker and then click on the Plan button under the Planning tab in the MotionPlanning pannel to start planning. The planner will now attempt to find a feasible solution between the given start and end position.
+Next, in RViz, select CHOMP in the MotionPlanning panel under the Context tab. Set the desired start and goal states by moving the end-effector around with the imarker and then click on the Plan button under the Planning tab in the MotionPlanning panel to start planning. The planner will now attempt to find a feasible solution between the given start and end position.
 
 Tweaking some of the parameters for CHOMP
 -----------------------------------------
@@ -101,7 +101,7 @@ CHOMP has some optimization parameters associated with it. These can be modified
   Set this to true/false if you want to use stochastic descent while optimizing the cost. In stochastic descent, a random point from the trajectory is used, rather than all the trajectory points. This is faster and guaranteed to converge, but it may take more iterations in the worst case.
 
 - **enable failure recovery**: ::
-  If this is set to true, CHOMP tweaks ceratin parameters in the hope to find a solution when one does not exist with the default paramters specified in the ``chomp_planning.yaml`` file.
+  If this is set to true, CHOMP tweaks certain parameters in the hope to find a solution when one does not exist with the default parameters specified in the ``chomp_planning.yaml`` file.
 
 - **max_recovery_attempts**: ::
   This is the maximum times that CHOMP is run with a varied set of parameters after the first attempt with the default parameters.
@@ -159,7 +159,7 @@ To achieve this, follow the steps:
     </launch>
 
 #. This launch file defines the new planning pipeline ``ompl-chomp``, deriving from the ``ompl`` pipeline,
-   but adding the CHOMP post-processor as a planning adapter. Also, the ``trajectory_initialization_method`` is overriden to use the OMPL-generated trajectory.
+   but adding the CHOMP post-processor as a planning adapter. Also, the ``trajectory_initialization_method`` is overridden to use the OMPL-generated trajectory.
 
 #. Now you can launch the newly configure planning pipeline as follows: ::
 

doc/controller_configuration/controller_configuration_tutorial.rst

@@ -170,6 +170,6 @@ All controller names get prefixed by the namespace of their ros_control node. Fo
 Controllers for Multiple Nodes
 ------------------------------
 
-MoveItMultiControllerManager can be used for more than one ros_control nodes. It works by creating several MoveItControllerManagers, one for each node. It instantiates them with their respecitve namespace and takes care of proper delegation. To use it must be added to the launch file. ::
+MoveItMultiControllerManager can be used for more than one ros_control nodes. It works by creating several MoveItControllerManagers, one for each node. It instantiates them with their respective namespace and takes care of proper delegation. To use it must be added to the launch file. ::
 
   <param name="moveit_controller_manager" value="moveit_ros_control_interface::MoveItMultiControllerManager" />

doc/move_group_interface/src/move_group_interface_tutorial.cpp

@@ -66,7 +66,7 @@ int main(int argc, char** argv)
   //
   // MoveIt operates on sets of joints called "planning groups" and stores them in an object called
   // the `JointModelGroup`. Throughout MoveIt the terms "planning group" and "joint model group"
-  // are used interchangably.
+  // are used interchangeably.
   static const std::string PLANNING_GROUP = "panda_arm";
 
   // The :planning_interface:`MoveGroupInterface` class can be easily
@@ -304,7 +304,7 @@ int main(int argc, char** argv)
   const double jump_threshold = 0.0;
   const double eef_step = 0.01;
   double fraction = move_group_interface.computeCartesianPath(waypoints, eef_step, jump_threshold, trajectory);
-  ROS_INFO_NAMED("tutorial", "Visualizing plan 4 (Cartesian path) (%.2f%% acheived)", fraction * 100.0);
+  ROS_INFO_NAMED("tutorial", "Visualizing plan 4 (Cartesian path) (%.2f%% achieved)", fraction * 100.0);
 
   // Visualize the plan in RViz
   visual_tools.deleteAllMarkers();
@@ -479,7 +479,7 @@ int main(int argc, char** argv)
   visual_tools.trigger();
 
   /* Wait for MoveGroup to receive and process the attached collision object message */
-  visual_tools.prompt("Press 'next' in the RvizVisualToolsGui window to once the collision object disapears");
+  visual_tools.prompt("Press 'next' in the RvizVisualToolsGui window to once the collision object disappears");
 
   // END_TUTORIAL
 

doc/moveit_cpp/src/moveit_cpp_tutorial.cpp

@@ -42,7 +42,7 @@ int main(int argc, char** argv)
   // Visualization
   // ^^^^^^^^^^^^^
   //
-  // The package MoveItVisualTools provides many capabilties for visualizing objects, robots,
+  // The package MoveItVisualTools provides many capabilities for visualizing objects, robots,
   // and trajectories in RViz as well as debugging tools such as step-by-step introspection of a script
   moveit_visual_tools::MoveItVisualTools visual_tools("panda_link0", rvt::RVIZ_MARKER_TOPIC,
                                                       moveit_cpp_ptr->getPlanningSceneMonitor());

doc/moveit_grasps/moveit_grasps_tutorial.rst

@@ -214,7 +214,7 @@ The ``setIdealGraspPoseRPY()`` and ``setIdealGraspPose()`` methods in GraspGener
 
 These methods is used to score grasp candidates favoring grasps that are closer to the desired orientation.
 
-This is useful in applications such as bin and shelf picking where you would want to pick the objects from a bin with a grasp that is vertically alligned and you would want to pick obejects from a shelf with a grasp that is horozontally alligned.
+This is useful in applications such as bin and shelf picking where you would want to pick the objects from a bin with a grasp that is vertically aligned and you would want to pick obejects from a shelf with a grasp that is horozontally aligned.
 
 Tested Robots
 -------------

doc/ompl_interface/ompl_interface_tutorial.rst

@@ -13,7 +13,7 @@ Longest Valid Segment Fraction
 
 The ``longest_valid_segment_fraction`` defines the discretization of robot motions used for collision checking and greatly affects the performance and reliability of OMPL-based solutions. A ``motion`` in this context can be thought of as an edge between two nodes in a graph, where nodes are waypoints along a trajectory. The default motion collision checker in OMPL simply discretizes the edge into a number of sub-states to collision check. No continuous collision checking is currently available in OMPL/MoveIt, though this is an area of current `discussion <https://github.com/ros-planning/moveit/issues/29>`_.
 
-Specifically, ``longest_valid_segment_fraction`` is the fraction of the robot's state space that, given the robot isn't currently in collision, we assume the robot can travel while remaining collision free. For example, if ``longest_valid_segment_fraction = 0.01``, then we assume that if an edge between two nodes is less than 1/100th of the state space, then we don't need to explicity check any sub-states along that edge, just the two nodes it connects.
+Specifically, ``longest_valid_segment_fraction`` is the fraction of the robot's state space that, given the robot isn't currently in collision, we assume the robot can travel while remaining collision free. For example, if ``longest_valid_segment_fraction = 0.01``, then we assume that if an edge between two nodes is less than 1/100th of the state space, then we don't need to explicitly check any sub-states along that edge, just the two nodes it connects.
 
 In addition to the ``longest_valid_segment_fraction`` parameter in the ``ompl_planning.yaml`` file, there is also the ``maximum_waypoint_distance``, found in the :moveit_codedir:`dynamic reconfigure file <moveit_planners/ompl/ompl_interface/cfg/OMPLDynamicReconfigure.cfg#L9>`. ``maximum_waypoint_distance`` defines the same discretization of robot motions for collision checking, but it does so at an absolute level instead of using fractions of the state space. For example, if ``maximum_waypoint_distance = 0.1``, then if an edge is shorter than ``0.1`` in state space distance, then we don't explicitly check any sub-states along that edge.
 

doc/planning_adapters/planning_adapters_tutorial.rst

@@ -185,7 +185,7 @@ This will launch RViz, select CHOMP in the Motion Planning panel under the Conte
 Planning Insights for different motion planners and planners with planning adapters
 -----------------------------------------------------------------------------------
 
-This section has insights as to when to use which planner and how using certain planning request adapters in a certain pipeline can lead to producing robust paths overall. Here we consider using OMPL, STOMP, CHOMP seperately and together to produce robust smooth optimized paths obtained from the planner. For each planner, a basic insight is provided which gives the user an intuition to use a particular planner in a specific situation.
+This section has insights as to when to use which planner and how using certain planning request adapters in a certain pipeline can lead to producing robust paths overall. Here we consider using OMPL, STOMP, CHOMP separately and together to produce robust smooth optimized paths obtained from the planner. For each planner, a basic insight is provided which gives the user an intuition to use a particular planner in a specific situation.
 
 - **CHOMP**: CHOMP is an optimization algorithm which optimizes a given initial trajectory. Based on the environment CHOMP rapidly tries to pull the initial trajectory out of collisions. However an important point to pay attention here is that the parameter ``ridge_factor`` needs to be more than or equal to 0.001 for avoiding obstacles. Doing this CHOMP is able to find paths while avoiding obstacles. It should be noted here even though CHOMP can avoid obstacles successfully but it fails to provide smooth paths often leading to jerky paths in the presence of obstacles. For CHOMP collision avoidance comes at the cost of the trajectory's velocity smoothness.
 

doc/robot_model_and_robot_state/src/robot_model_and_robot_state_tutorial.cpp

@@ -86,7 +86,7 @@ int main(int argc, char** argv)
 
   // Get Joint Values
   // ^^^^^^^^^^^^^^^^
-  // We can retreive the current set of joint values stored in the state for the Panda arm.
+  // We can retrieve the current set of joint values stored in the state for the Panda arm.
   std::vector<double> joint_values;
   kinematic_state->copyJointGroupPositions(joint_model_group, joint_values);
   for (std::size_t i = 0; i < joint_names.size(); ++i)