SCAN-Planner: Spatial Collision-Aware Local Planning for Quadruped Robot Navigation

What SCAN-Planner Provides for Quadruped Navigation

Long-range navigation for legged robots involves two distinct problems. An upper-level task planner decides where to go, generating a global route or waypoints. A local planner decides how to get there step by step while avoiding obstacles it encounters in real time. SCAN-Planner fills the local planner role, providing what the README calls "a robust low-level planning foundation for various upper-level tasks, such as autonomous exploration and vision-language navigation."

The system is targeted at four-legged (quadruped) robots and was developed and tested on the Unitree Go2 platform. It accepts either lidar point-cloud input from sensors such as the MID360 or depth camera input from devices such as the RealSense D435. The planner connects to the robot's body pose and sensor pose topics and outputs motion commands that navigate around obstacles while following the route the upper-level system provides.

The project was authored by Han Zheng, Zhe Chen, Yiwen Fu, Ming Yang, and Tong Qin, and an arXiv preprint is available at arxiv.org/abs/2606.19555.

Installing SCAN-Planner on Ubuntu 20.04 with ROS Noetic

The README states the project was tested on Ubuntu 20.04 with ROS Noetic. Installation begins with the Armadillo linear algebra library, which the simulator requires:

sudo apt-get install libarmadillo-dev

Then clone the repository and compile with catkin:

git clone https://github.com/wuyi2121/SCAN-Planner.git
cd SCAN-Planner
catkin_make

The local sensing module has both CPU and GPU implementations. The CPU version builds by default. To enable the GPU backend, install the required graphics libraries first:

sudo apt-get install libglew-dev libglfw3-dev libgl1-mesa-dev libglu1-mesa-dev

Then rebuild with the GPU flag:

catkin_make -DUSE_GPU=ON

Which sensing node is launched is controlled by the `use_gpu` option in `simulator.xml`.

Quick Start: Launching the Planner with RViz

Running SCAN-Planner requires two terminals. The first launches RViz for visualisation:

source devel/setup.bash && roslaunch scan_planner rviz.launch

The second launches the planning algorithm:

source devel/setup.bash && roslaunch scan_planner run.launch

The main launch file at `src/planner/plan_manage/launch/run.launch` exposes three key parameters. `is_real_world` must be set to `true` when running on a real robot with live topics, and `false` when using the simulator. `sensor_type` selects `lidar` for point-cloud sensors or `depth` for depth cameras. `navi_mode` selects the navigation interface: mode 1 is an interactive 2D Nav Goal, mode 2 is keypoint-based multi-floor navigation described in `tools/README.md`, and mode 3 is reference-path tracking with local obstacle avoidance that connects to the TravExplorer project.

The README adds a note for multi-floor operation: if the robot cannot climb stairs, increasing the z height value of the body, keypoints, or initial path in the configuration resolves the issue. Additional algorithm parameters are in `advanced_param.xml` and are tuned by default for the Unitree Go2.

Architecture: Localization, Mapping, and Planning Stack

SCAN-Planner is not a standalone SLAM system. It builds on several upstream components that the README credits explicitly.

Localization uses Elevator-LIO, a multi-floor extension of FAST-LIO2 that handles elevation changes between floors. The framework builds on EGO-Planner, a local planning system developed for quadrotors, adapting its trajectory optimisation approach to quadruped motion. The map representation draws from ROG-Map, a robot-centric mapping framework. The simulator was adapted from MARSIM, with map generation from Mockamap and trotting motion from Leg-KILO.

This stack means SCAN-Planner inherits the capabilities and constraints of each upstream component. In particular, EGO-Planner was originally designed for aerial vehicles; the adaptation to quadruped robots is part of what this project contributes, along with the multi-floor and route-guided extensions.

For teams building cross-floor embodied exploration above SCAN-Planner, the README points to the TravExplorer project as a compatible upper-level system.

Hardware and ROS2 Support

To support reproducibility, the project provides CAD files for the sensor layout used in development, in `.SLDPRT` and `.STL` formats. These cover the physical mounting arrangement for the sensor suite on the Go2 platform and can be opened and modified in Solidworks. They are hosted at github.com/zhechen003/GO2-EDU-sensor_layout, referenced from the README.

ROS2 support is available through the `ros2-community` branch, contributed by community member xiaoqi371317. The README presents this as a community contribution rather than an official release, so teams adopting it should verify its behaviour against their platform before depending on it in production research.

The main algorithm was released on 2026-07-09. The CAD files became available on 2026-07-29, as noted in the project's news section. The last push to the repository was on 2026-07-29.

Limitations: Platform Defaults and Coverage Gaps

The default configuration in `advanced_param.xml` is tuned for the Unitree Go2. The README explicitly states these parameters must be adjusted when using a different robot platform. What those adjustments are is not documented in the top-level README; they are parameters in the XML file that require understanding the robot's kinematics and sensor placement.

Mode 3 (reference-path tracking) depends on TravExplorer, which is a separate project. Teams that want only local obstacle avoidance without reference-path inputs can use mode 1 or mode 2 without this dependency.

The project has no GitHub releases. There is no versioned changelog, so tracking what changed between updates requires reading git history.

SCAP-Planner covers local planning. It does not address global path planning, semantic understanding of the environment, or learning-based locomotion control. Those layers must come from upper-level systems the developer integrates.

Comparison with EGO-Planner

EGO-Planner is the upstream trajectory optimisation framework that SCAN-Planner builds on. EGO-Planner was developed for quadrotors and achieves trajectory optimisation in three-dimensional space with gradient-based obstacle avoidance. Using it directly on a quadruped requires handling ground contact, body height, and multi-floor transitions that EGO-Planner does not address.

SCAN-Planner extends EGO-Planner specifically for the quadruped context, adding multi-floor navigation with stair-climbing support, the `navi_mode` abstraction for connecting to different upper-level planners, and integration with Elevator-LIO for floor-level localisation. The cost is additional build dependencies and the need to configure the platform-specific parameters.

For a team whose application involves only single-floor flat-ground navigation, EGO-Planner adapted for ground robots may be a simpler starting point. SCAN-Planner adds value when multi-floor or route-guided navigation is a requirement. The Apache-2.0 licence applies to both.

Editorial conclusion

SCAN-Planner is a practical starting point for researchers building long-range quadruped navigation systems who need a tested local planning foundation on ROS Noetic. The default parameters target the Unitree Go2 and require adjustment for other platforms. Teams that need a ROS2 deployment should use the community-contributed ros2-community branch and verify its stability independently, as the main algorithm was released on the ROS1 branch. Check whether EGO-Planner, on which the framework builds, already fits the deployment constraints before adding SCAN-Planner's multi-floor and route-guided extensions.

Frequently asked questions

Official sources

1. Issues
2. License: Apache-2.0
3. Project website
4. README
5. wuyi2121/SCAN-Planner on GitHub