MoveIt

MoveIt orchestrates the end-to-end planning workflow by interfacing with OMPL (Open Motion Planning Library) as its default backend. The pipeline receives a motion planning request, invokes a planner like RRTConnect or PRM*, and outputs a collision-free trajectory. The architecture is planner-agnostic, allowing integration with custom planners such as STOMP or CHOMP for trajectory optimization. Key stages include:

• Planning Scene: Maintains an internal world model of the robot and environment
• Collision Checking: Uses the FCL (Flexible Collision Library) for geometric queries
• Trajectory Execution: Communicates with ros_control hardware interfaces

MoveIt provides a plugin-based architecture for Inverse Kinematics (IK) computation, translating desired end-effector poses into joint configurations. The default solver is KDL (Kinematics and Dynamics Library), a numerical solver using the Jacobian pseudoinverse. For redundant manipulators with 7+ DOF, MoveIt supports TRAC-IK, which simultaneously runs two IK methods and returns the better solution, significantly improving solve rates near singularities. IKFast is also supported for analytical closed-form solutions that guarantee millisecond-level solve times for specific robot geometries.

MoveIt employs a two-phase collision detection system. The broad phase uses axis-aligned bounding boxes (AABB) to rapidly eliminate non-intersecting object pairs. The narrow phase invokes the GJK (Gilbert-Johnson-Keerthi) algorithm for precise distance computation between convex hulls. The framework supports continuous collision detection (CCD) to prevent tunneling artifacts during high-speed motions. Collision objects can be added programmatically or via the Planning Scene ROS API, with support for primitive shapes, meshes, and octree-based representations from depth sensors.

MoveIt includes a trajectory processing pipeline that post-processes raw planner output before execution. This includes time parameterization to assign timestamps respecting velocity and acceleration limits, and trajectory filtering to smooth jerky motions. The MoveGroup interface acts as the primary user-facing node, providing ROS actions and services for planning and execution. Trajectories are streamed to hardware via the FollowJointTrajectory action interface, which is the standard ros_control protocol for position-controlled manipulators.

MoveIt integrates with 3D perception sensors to populate the planning scene with real-world obstacles. The Occupancy Map Updater plugin subscribes to point cloud or depth image topics and constructs an OctoMap—a probabilistic 3D occupancy grid using octree data structures. This enables dynamic collision avoidance against unmodeled objects. The framework supports self-filtering to remove robot links from sensor data, preventing the robot from seeing itself as an obstacle.

MoveIt provides a grasp generation and execution framework for pick-and-place tasks. The MoveIt Grasps library generates candidate grasp poses relative to object geometry, filters them for kinematic feasibility, and ranks them by quality metrics. The Pick and Place Pipeline sequences the full manipulation workflow: approach, grasp, lift, transport, and place. Integration with Grasp Pose Detection (GPD) and deep learning-based grasp synthesis enables model-free grasping from partial point clouds.

The foundational mathematical space where MoveIt performs its search. A robot with n Degrees of Freedom (DOF) is represented as a single point in an n-dimensional C-Space. Obstacles are mapped into this space, transforming the complex planning problem into finding a continuous, collision-free path for a point.

• C-Obstacle: The region of C-Space causing a collision
• C-Free: The collision-free subset where planning occurs

MoveIt uses IK solvers to convert a desired end-effector pose (position and orientation) into a valid set of joint angles. This is a critical step in translating task-space goals into the C-Space for planning.

• Default solver: KDL (Kinematics and Dynamics Library)
• Also supports TRAC-IK for improved success rates
• Numerical methods often use the Jacobian pseudoinverse

MoveIt's CollisionWorld uses the FCL (Flexible Collision Library) to perform geometric queries. It manages both the robot's collision model and the environment's representation, typically using meshes or primitive shapes.

• Broad-phase: Quickly identifies potential pairs of colliding objects
• Narrow-phase: Uses the GJK algorithm to compute exact distance between convex shapes
• ACD (Allowed Collision Detection) disables checks for adjacent, always-in-contact links

After a geometric path is found, MoveIt's Trajectory Processing pipeline refines it. This stage applies time parameterization to respect velocity and acceleration limits and can smooth the path using techniques like STOMP (Stochastic Trajectory Optimization).

• Converts a kinematic path into a time-stamped trajectory
• Ensures adherence to joint limits and dynamic constraints
• Can optimize for criteria like minimum time or smoothness

An alternative environment representation used by some planners like CHOMP. An SDF is a voxel grid where each cell stores the shortest distance to the nearest obstacle surface, with negative values inside objects. This provides a continuous, differentiable cost function for gradient-based trajectory optimization, enabling smooth paths that maximize clearance.