Definition

Motion planning is the problem of computing a collision-free trajectory that moves a robot from an initial configuration to a goal configuration while respecting physical constraints — joint limits, velocity bounds, acceleration limits, and obstacle avoidance. It is one of the core capabilities in any robot system: without reliable motion planning, a robot cannot safely reach objects, move between workstations, or avoid collisions with its environment or human co-workers.

The problem is formulated in the robot's configuration space (C-space), where each point represents a complete set of joint values and obstacles are mapped into regions of C-space that cause collisions. A motion plan is a continuous path through the free C-space — the subset of configurations where the robot does not collide with anything. For a 6-DOF arm, C-space is 6-dimensional; for a humanoid, it can exceed 30 dimensions, making the planning problem computationally challenging.

Sampling-Based Planners

Sampling-based methods explore C-space by randomly sampling configurations and testing them for collisions. They are probabilistically complete: given enough time, they will find a path if one exists, but they do not guarantee optimality.

  • RRT (Rapidly-exploring Random Trees) — Grows a tree from the start configuration by repeatedly sampling a random configuration and extending the nearest tree node toward it. RRT explores space rapidly but produces jerky, suboptimal paths that require post-processing (shortcutting, smoothing).
  • RRT* — An asymptotically optimal variant that rewires the tree as new nodes are added, converging toward the shortest path over time. Slower than basic RRT but produces significantly better paths.
  • RRT-Connect — Grows two trees simultaneously — one from start, one from goal — and attempts to connect them. Typically the fastest variant for finding any feasible path, and the default planner in MoveIt.
  • PRM (Probabilistic Roadmap) — Pre-computes a graph of sampled configurations and connections in a preprocessing phase. Queries then search this graph for paths. PRM is efficient when many queries share the same environment (e.g., a fixed workcell), amortizing the roadmap construction cost.

Optimization-Based Planners

Optimization-based methods start with an initial trajectory (often a straight-line interpolation in C-space) and iteratively refine it by minimizing a cost function that penalizes collisions, path length, and smoothness violations.

  • CHOMP (Covariant Hamiltonian Optimization for Motion Planning) — Uses functional gradient descent on a cost that combines an obstacle penalty (based on signed distance fields) with a smoothness term. Fast convergence but can get stuck in local minima.
  • TrajOpt — Formulates motion planning as sequential convex optimization with collision avoidance as constraints rather than penalty terms. Typically produces higher-quality paths than CHOMP and handles narrow passages better.
  • STOMP (Stochastic Trajectory Optimization for Motion Planning) — Generates random trajectory perturbations and uses their costs to update the trajectory without computing gradients. Works with non-differentiable cost functions (e.g., binary collision checks) and naturally explores multiple homotopy classes.

Optimization-based planners excel at producing smooth, near-optimal trajectories but require a reasonable initial guess and can fail in highly cluttered environments where the initial trajectory is far from any feasible solution.

Comparison: Sampling vs Optimization

Sampling-based planners are better at finding paths in cluttered, high-dimensional spaces where the free C-space is complex. They are more robust to local minima and can handle environments with narrow passages (given enough samples). However, paths are often jerky and require smoothing.

Optimization-based planners produce smoother, more efficient trajectories and are faster when a good initial guess is available. They are preferred for repetitive tasks in known environments (e.g., pick-and-place in a structured workcell). However, they struggle with highly cluttered scenes and can converge to infeasible local minima.

In practice, many systems combine both: a sampling-based planner finds a feasible path, and an optimization-based method refines it for smoothness and time-optimality.

MoveIt 2: The Standard Framework

MoveIt 2 is the most widely used open-source motion planning framework for ROS2. It integrates planning, IK, collision checking, trajectory execution, and perception into a unified pipeline. Key components include:

  • OMPL (Open Motion Planning Library) — Provides the sampling-based planner implementations (RRT, RRT*, PRM, etc.) used as MoveIt's default planning backend.
  • Planning Scene — Maintains a collision model of the robot and its environment, updated in real time from point cloud or mesh data.
  • Trajectory processing — Time-parameterization (TOTG, iterative spline) converts geometric paths into time-optimal trajectories respecting velocity and acceleration limits.
  • MoveIt Servo — Real-time Cartesian and joint-space servoing for teleoperation and reactive control.

Challenges in Dynamic Environments

Classical motion planning assumes a static environment: obstacles do not move during planning and execution. Real-world scenarios — human-robot collaboration, bin picking from a conveyor, mobile manipulation — violate this assumption. Approaches to dynamic planning include:

Replanning: Run the planner continuously, updating the collision model with new sensor data and generating new trajectories at each cycle. Effective when planning is fast enough (sub-100ms).

Reactive methods: Potential fields, velocity obstacles, or learned reactive policies that adjust the trajectory in real time without full replanning. Faster but may produce suboptimal paths or get trapped in local minima.

Learned planners: Neural network-based planners (MPNets, MotionPolicyNetworks) that predict feasible paths directly from point cloud observations, bypassing explicit collision checking. These can run at high frequency but currently lack the reliability guarantees of classical methods.

Practical Requirements

Collision model: Accurate collision geometry is essential. Simplified meshes or primitive shapes (boxes, cylinders, spheres) are faster to check but may be overly conservative. Detailed meshes improve path quality but slow down planning.

Planning time budget: Industrial pick-and-place typically allows 50-200ms for planning. Complex multi-arm assembly may require 1-5 seconds. Teleoperation and reactive control require sub-10ms responses, favoring servo-based or reactive approaches over full planning.

Compute: Motion planning is CPU-intensive (collision checking dominates runtime). GPU-accelerated collision checking (e.g., cuRobo from NVIDIA) can reduce planning times by 10-100x, enabling real-time optimization-based planning.

Motion Planning and Learned Policies

Motion planning and learned policies serve complementary roles in modern robot systems:

  • Planning for gross motion, policy for fine manipulation — A common architecture uses MoveIt 2 to plan collision-free paths from the home position to a pre-grasp pose, then switches to a learned policy (ACT, Diffusion Policy) for the contact-rich manipulation phase. This hybrid approach leverages planning's reliability for obstacle avoidance and the policy's dexterity for manipulation.
  • Planning as a safety layer — Safety wrappers use real-time motion planning to check whether the policy's commanded trajectory will cause collisions. If the policy outputs an unsafe action, the planner modifies or replaces it. MoveIt Servo provides this capability at 100+ Hz.
  • Learning to plan — Neural motion planners (MPNets, MPPI, learned cost functions for STOMP) can accelerate planning by predicting good initial trajectories from point cloud observations. These learned planners are 10-100x faster than sampling-based methods but do not yet match their reliability.
  • cuRobo: GPU-accelerated planning — NVIDIA's cuRobo library performs trajectory optimization on the GPU, achieving planning times of 10-50ms for 7-DOF arms. This makes optimization-based planning feasible for real-time reactive control, closing the gap between planning and policy-based approaches.

See Also

  • Data Services — Pre-configured MoveIt 2 planning pipelines for SVRC robot cells
  • RL Environment — Robot cells with collision models ready for motion planning research
  • Hardware Catalog — Robot platforms with calibrated URDFs and collision meshes
  • Robot Leasing — Access to OpenArm 101, DK1, and Unitree G1 with MoveIt 2 integration
  • Data Platform — Trajectory recording and visualization for planning benchmarking

Key Papers

  • LaValle, S. (1998). "Rapidly-Exploring Random Trees: A New Tool for Path Planning." Technical Report, Iowa State University. The original RRT paper that launched the sampling-based planning revolution.
  • Karaman, S. & Frazzoli, E. (2011). "Sampling-based Algorithms for Optimal Motion Planning." IJRR. Introduces RRT* and proves asymptotic optimality guarantees.
  • Ratliff, N. et al. (2009). "CHOMP: Gradient Optimization Techniques for Efficient Motion Planning." ICRA 2009. Introduces covariant gradient descent for trajectory optimization.
  • Schulman, J. et al. (2014). "Motion Planning with Sequential Convex Optimization and Convex Collision Checking." IJRR. The TrajOpt paper, demonstrating superior performance in cluttered environments.

Related Terms

  • Joint Space — The configuration space where motion planning operates
  • Inverse Kinematics — Converts Cartesian goals to joint-space targets for the planner
  • Point Cloud — 3D sensor data used to build collision models for planning
  • Safety Constraints — Velocity and workspace limits enforced during trajectory execution
  • Workspace Analysis — Determines which regions the planner should target

Apply This at SVRC

Silicon Valley Robotics Center deploys MoveIt 2 across its robot fleet for collision-free manipulation. Our engineering team configures planning scenes, tunes planner parameters, and integrates GPU-accelerated collision checking for high-throughput applications. Whether you need a production-ready planning pipeline or custom planner benchmarking, we can help.

Explore Data Services   Contact Us