Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?

State lattice-based planning

tl;dr

The kinodynamics constraints of the robot are encoded in the state lattice graph and any path in this graph is feasible. After constructing the graph, any graph search algorithm can be used for planning.

Algorithm

A robot's configuration space is usually discretized to reduce computational complexity of planning at the expense of completeness. However, it is difficult to search this space while satisfying the robot's differential constraints. State lattices are a special way of discretization of robot state space that ensures (by construction) that any path in the graph complies with the robot's constraints, thereby eliminating the need to consider them explicitly during planning.

The state lattice is specified by a regular sampling of nodes in the state space and edges between them. Edges correspond to feasible and local paths between nodes (also called motion primitives or control set). Since the state lattice is a directed graph, any graph search algorithm is appropriate for finding a path in it.

Example State Lattice

State Space

Each lattice node represents a state in the configuration space of the robot. For example, we can consider a 3-dimensional state that includes 2D position and heading for a mobile robot.

Additional dimensions can be added to impose continuity constraints on the path. For example, we can add the robot's curvature as the 4th dimension to ensure that its curvature never changes suddenly at nodes. In this case, the curvature will slowly change along the edges.

Generating the Set of Motion Primitives

The state lattice based planner is resolution complete only if any path between two nodes in the lattice can be constructed using edges present in the graph. An important property is that we can achieve this using only a finite (and small in practise) set of motion primitives.

Outline of proof: Assume that two paths with indentical endpoints which are "sufficiently" close together to be equivalent. This equivalence is motivated by practical applications where there is certain error in path following and so close paths are same in practise. Now, any path between two nodes (which may be infinetely far away) can be decomposed into an equivalent path that is composed using a finite set of motion primitives.

Additional Implementation details

See paper for details on generting motion primitives, sampling heading direction and computing more informed heuristic for chosen primitive set.

References

  1. Efficient contrained path planning via search in state lattices - Pivtoraiko and Kelly
  2. Differentially Constrained Mobile Robot Motion Planning in State Lattices - Pivtoraiko, Knepper and Kelly
  3. SBPL slides - Likachev
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.