• Stars
    star
    155
  • Rank 240,864 (Top 5 %)
  • Language
    Python
  • License
    BSD 3-Clause "New...
  • Created about 1 year ago
  • Updated 5 months ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Motion Planning around Obstacles with Convex Optimization by Marcucci et al, 2023

Motion Planning around Obstacles with Convex Optimization

This repository contains the code to reproduce the examples in the paper Motion Planning around Obstacles with Convex Optimization by Tobia Marcucci, Mark Petersen, David von Wrangel, and Russ Tedrake.

To use Graphs of Convex Sets (GCS) Trajectory Optimization in your own code, we recommend that you use the version in Drake, which is being actively developed and improved.

Running via Deepnote

Most of the examples and reproductions can be run on Deepnote.

After duplicating the project into your own account, be sure to run the MosekLicenseUpload.ipynb notebook to make your Mosek License available for solving the optimization problems.

Note: The Bimanual reproductions do not yet work on Deepnote and the UAV and Maze reproductions have been shrunk in size to avoid hitting memory limits on Deepnote.

Running locally

Option 1: Docker

We provide a dockerfile with a custom build of Drake that entails sampling based planners for the comparison. Note that the docker does not include a build of Gurobi, which has been only used in the Iris region generation.

Pull the docker:

docker pull wrangelvid/drake:gcs-science-robotics

Run the docker:

docker run -i -p 7000:7000 -p 8888:8888 -w /gcs-science-robotics -t wrangelvid/drake:gcs-science-robotics

In another shell, copy over your mosek license:

docker cp [PATH_TO_MOSEK.lic] [container_id]:/tmp/mosek.lic

Once the docker has been build and run, you can run the examples with jupyter notebooks:

In the docker run the jupyter server:

jupyter notebook --ip 0.0.0.0 --no-browser --allow-root --NotebookApp.token=''

On your machine go to http://localhost:8888/ You will find the reproduction notebooks in the reproduction folder.

Note: The instructions here use port 7000 for meshcat (robot visualization) and 8888 for jupyter. If these ports are already in use on your machine, you can change the -p flag in the docker run command above; for instance use -p 7001:7000 to map the docker port 7000 to your localhost 7001 for meshcat.

Option 2: Local Installation

If you want to compare GCS to sampling based planners (such as PRM), you'll need to install a custom fork of Drake that includes bindings for sampling based planners. To do this run the following, including any of the proprietary solvers you have access to. You may build it with Gurobi.

git clone -b gcs-science-robotics [email protected]:wrangelvid/drake.git
mkdir drake-build
cd drake-build
cmake -DWITH_MOSEK=ON [-DWITH_GUROBI=ON -DWITH_ROBOTLOCOMOTION_SNOPT=ON] ../drake
make -j

Then add the built bindings to your Python Path using

For Ubuntu 20.04:

cd drake-build
export PYTHONPATH=${PWD}/install/lib/python3.8/site-packages:$PYTHONPATH

For macOS:

cd drake-build
export PYTHONPATH=${PWD}/install/lib/python3.9/site-packages:$PYTHONPATH

We have used Mosek to solve most of the examples. To solve using Mosek, you'll need to give Drake access to a Mosek license file as described here. Mosek provides a personal academic license for free.

You will also need to install gcs-science-robotics and its dependencies. From inside this repository, run the following:

pip install -e .

Once all the dependencies have been installed, you can run the examples with jupyter notebooks which can be launched by calling

jupyter-notebook

from inside this repository.

More Repositories

1

drake

Model-based design and verification for robotics.
C++
3,265
star
2

pytorch-dense-correspondence

Code for "Dense Object Nets: Learning Dense Visual Object Descriptors By and For Robotic Manipulation"
Python
557
star
3

LabelFusion

LabelFusion: A Pipeline for Generating Ground Truth Labels for Real RGBD Data of Cluttered Scenes
Python
385
star
4

director

A robotics interface and visualization framework, with extensive applications for working with http://drake.mit.edu
Python
178
star
5

drake-external-examples

Examples of how to use Drake in your own project.
C++
101
star
6

drake-ros

Experimental prototyping (for now)
Python
89
star
7

LittleDog

Example of quadruped planning and control in drake using LittleDog -- a small quadruped robot from Boston Dynamics.
MATLAB
67
star
8

spartan

A project repo for robotics research and applications using drake and director.
Python
31
star
9

models

Shareable model files (urdf/sdf + meshes, etc) for our robotics projects
Starlark
25
star
10

drake-iiwa-driver

C++
24
star
11

xfoil

Fork of Mark Drela's XFOIL software (http://raphael.mit.edu/xfoil) which builds using cmake.
Fortran
24
star
12

libbot

Deprecated git mirror of the svn repository formerly located at https://code.google.com/p/libbot. Please use the upstream https://github.com/libbot2/libbot2 or new fork https://github.com/RobotLocomotion/libbot2 instead.
C
23
star
13

drake-blender

Drake glTF Render Client-Server API using Blender
Python
14
star
14

meshConverters

simple wrapper on vcg to give small platform independent mesh converters
C++
12
star
15

RobotLocomotion.github.io

Automatically generated documentation for Drake.
HTML
11
star
16

Hubo

Humanoid robot from KAIST
MATLAB
11
star
17

avl

Fork of Mark Drela's AVL software (http://raphael.mit.edu/avl) which builds using cmake.
Fortran
10
star
18

robot-plan-runner

C++
10
star
19

6-881-examples

Python
7
star
20

realsense2-lcm-driver

Publishes RealSense data to LCM
C++
6
star
21

drake-ci

Continuous integration scripts for Drake.
CMake
6
star
22

cmake

some useful shared cmake utilities
CMake
5
star
23

manip_dataset

Repo with instructions on how to download the dataset
Python
5
star
24

drake-franka-driver

Driver software for the Franka robots.
C++
4
star
25

homebrew-director

Homebrew formulae for Drake.
Ruby
3
star
26

ros_drake

CMake
2
star
27

drake-schunk-driver

Driver software for the Schunk gripper.
C++
2
star
28

bazel-external-data

Handle external large files for use with Bazel.
Python
2
star
29

drake-python3.7

Work in progress. A fork of the Drake toolbox for model-based design and verification for robotics that uses Python 3.7 on Ubuntu 18.04 (Bionic Beaver) and pip to manage Python dependencies.
C++
2
star
30

ros-drake-vendor

Maintainer scripts that package Drake in the ROS build farm
CMake
1
star
31

ipopt-mirror

Fortran
1
star
32

eigen-mirror

C++
1
star
33

ros_drake-release

1
star
34

Pigeon

Full pigeon model w/ Harvard
MATLAB
1
star
35

pdc-ros

Simple wrapper for Kuka pytorch tools + ROS
Python
1
star