Installation Instructions

  1. Install the dev branch of sbpl
    git clone https://github.com/sbpl/sbpl.git -b dev
    

    In the sbpl directory run this:
    mkdir build
    cd build
    cmake ..
    make
    sudo make install
    
  2. Get the ros install file:
    https://sbpl.pc.cs.cmu.edu/redmine/attachments/download/591/egraph_environments.rosinstall
  3. Make a new folder, put the rosinstall file in the folder, and run this command in it
    rosinstall . egraph_environments.rosinstall
    
  4. The rosinstall file should also create a setup.bash file which you should source to set up your environment variables, specifically, ROS_PACKAGE_PATH
    source setup.bash
    

Arm planning

  1. Build
    rosmake egraph_arm
    
  2. Be sure you have a roscore running.
  3. There are several environments you can use. Launch the planning node with ONE of the following:
    roslaunch egraph_arm industrial.launch
    roslaunch egraph_arm kitchen.launch
    roslaunch egraph_arm tabletop.launch
    roslaunch egraph_arm tunnel.launch
    
  4. You can use planner by sending a egraph_arm::GetArmPlan service to "/sbpl_planning/plan_path"

You can also send paths to the planner to add to the E-Graph (e.g. demonstrations) or clear the E-Graph by sending the egraph_arm::AddPathsToEGraph service to "/sbpl_planning/add_paths"

Sending plan requests using the interactive tool

After launching the node you can send goals with an interactive tool by running:

rosrun egraph_arm interactArmPlanner

You will have to bring up rviz as well. There are two interactive marker topics you need from rviz (one for interacting with the planner and one for seeing the E-Graph).
Other than that, you need to subscribe to visualization_marker.
You should be able to move the start and goal markers around (green for start and red for goal). Right click any interactive marker to plan (with and without E-Graphs and with and without saving the new path to the E-Graph). You also can interrupt the planner (in case it is taking too long) and write the start/goal trial to a test file (written to ~/.ros/arm_tests.yaml)

Sending plan requests using a test file

Tests written to file from the interactive tool (or by you) can be used to send many tests one right after the other to the planner node. To do this, first go to the egraph_arm package. Then run:

./bin/runTests path_to_your_test_file

In egraph_arm/tests directory there are test files for a few of the environments you can try out.

Collecting statistics

Using either the interactive tool or the runTests will write statistics to egraph_arm_stats.csv. Most of the stats are very detailed, however the main ones are:

  • total_time_without_feedback - The total planning time (in seconds) without counting the time it took to add the newly found path into the E-Graph (if you asked it to do that).
  • total_time - The total planning time (in seconds) plus the time it takes to add the newly found path in the E-Graph (if you asked it to do that).
  • solution_found - 1 if a solution was found and 0 if not.
  • solution_cost - The cost of the solution found.
  • expands - The number of expansions by the planner.

Expected performance.

With a few starter paths that visit the key areas of the workspace, planning times are typically between 0.04s-0.25s (on a 2.8GHz processor).
By running:

roslaunch egraph_arm kitchen.launch
./bin/runTests tests/kitchen.yaml

We see planning times in that range.

Navigation planning (x,y,theta)

This is almost the same as arm planning.

  1. Build
    rosmake egraph_xytheta
    
  2. Launching the planning node:
    roslaunch egraph_xytheta node.launch
    
  3. Launching the interactive tool
    rosrun egraph_xytheta interact.launch
    

Other than that it is the same as arm planning.

Navigation planning (x,y)

This is almost the same as arm planning.

  1. Build
    rosmake egraph_xy
    
  2. Launching the planning node:
    roslaunch egraph_xy node.launch
    
  3. Launching the interactive tool:
    rosrun egraph_xy interact.launch
    

Other than that it is the same as arm planning.