Part of a 1-week project, together with a few of my colleagues, we programmed the PR2 robot to:

• navigate and find a refrigerator
• open its door by locating the fridge handle
• position the robot’s manipulators so that the door doesn’t close while grasping things inside the fridge
• automatically identify the types of beer available in the fridge (we trained models on about 9 beers - training involves simply storing a picture of the beer bottle you want to identify in a directory)
• determine the types of beer the user selected from a web page, compute grasping points, move the arms and grasp them, and then move the beers onto a storing rack that we installed on the robot
• close the fridge door
• navigate the the delivery point selected by the user on the web page
• identify people faces and perform delivery/hand-off beer + bottle opener
• wait for bottle opener and resume!

Optionally, the robot can open the beer too!

The entire source code is available at:
https://code.ros.org/svn/wg-ros-pkg/stacks/pr2_drinks/trunk/ .

If you find it useful, PLEASE let us know! Obviously this app is “powered by PCL”

You can read our entire blog entry here: http://www.willowgarage.com/blog/2010/07/06/beer-me-robot. Cheers!

Edit: I just noticed that we got picked by Slashdot. Some of the comments posted are pretty funny.

There are two main differences between the usual traditional workshops and this one:

• in the next few days, we will try to make available training and test datasets for two specific problems that the robotics community is now facing: 1) rigid object recognition and 2) people detection. We encourage submissions that can show results against these datasets. Submissions presenting similar problems using different data sources are obviously welcomed as well.
• validation of results: the organizing committee is eager to accept submissions that can show results that are reproducible. To do that, for the experimental datasets presented above, we will release a test set a few hours before the workshop. Participants are encouraged to try their algorithms/models on the test set (after have trained on the training set provided above). We aim at awarding the participants who manage to show accuracy results > 95% on the test set. We also encourage submissions that are willing to share their results as open source to the robotics community, and are willing to do a live demo on site.

We hope to see you all in Taiwan! With all these exciting workshops, we’re sure IROS will be awesome!

Because not a lot of people know why we are doing this or how this started, here’s a few random bits on PCL…

• PCL is a complete open source software package built as part of ROS, which stands for Robot Operating System/Robot Open Source. If you don’t know what ROS is yet, don’t worry, you will soon. We’re growing bigger everyday, and adding more functionality that will make your robots go “wheeeee” sooner than you think. Check out a few of them today to see them moving around, picking up objects, or simply just acting cool. ROS is a community driven open source effort (supported by Willow Garage) and the best way to think about it is a massive collection of tightly integrated software packages that enable robotics research and development. There’s probably over 100 useful packages in there, including OpenCV and OpenRave so don’t just take my word for it, go check it out yourself!
• PCL was created as a successor to an earlier attempt of designing PointCloud data types, structures and algorithms that proved to be inefficient. Those days are gone now, and we’re proud to announce PointCloud…2. Yes, our new underlying data type that represents point cloud data is _really_ called PointCloud2. Call it an uninspired day to name things if you wish. PointCloud2 was designed with PCL in mind (or vice versa - same thing ;), and supports alignment (e.g. SSE), has a compact data size, and has a lower computational overhead in general (especially when used with nodelets - more on that later).
• Because we want PCL to become for 3D and point cloud data processing what OpenCV is for 2D image processing, we are developing a large number of algorithms for operations such as: filtering, downsampling, 3D feature estimation, registration, surface reconstruction, segmentation, and many more, into PCL. To make things flexible and efficient on the long run, we designed PCL as a fully templated C++ library, with an Eigen backend, and lots of Boost goodies. Yes, porting it to an Android (or whatever) might be a bit of a challenge, but we’ll worry about that later. Right now, we just want robots to perceive and understand their surrounding environment better. The “robot sharing a cluster of cell phones” app will come naturally once we manage to correctly identify all the cell phones in a building
• We try to use explicit parallelization where possible in PCL, via OpenMP and TBB. We try to avoid parallelizing everything implicitly, because saving CPU cycles on those extra cores that your computer might have is a good thing ®. Basically you want to know when something is going all “parallel” and eating up all your resources on a robot. We ran into decent issues in the past, and learned a valuable lesson. I think.
• Because we know that learning something new is hard, we’re trying to help you out. There’s documentation, API documentation, tutorials, videos, and more. We already have examples for you on how to do object recognition, and environment modeling, to name a few. And you need to understand that we just started. PCL is roughly 3-4 months old, give or take.

There’s lots more to be said, but for now, just go check it out! If you’re asking yourselves why bother, well… why not? It’s open source, it’s fast, and it’s easy to use (or so we hope). If you don’t like it, just e-mail us and we’ll fix it for you. Yup, just like that!

Here’s a teaser for one of the many things that can be done as of today with PCL. Though the video was generated before PCL was conceived, all the algorithms that are needed to obtain these results are present in PCL. In fact, we’ll create a tutorial soon to show you how to do it too in case you get stuck.

Finally, don’t forget to check out the slides from our class at Stanford for more information about PCL and point clouds. I’ve also uploaded my ICRA 2010 PCL talk/presentation slides here.

Our RSS 2010 workshop proposal got accepted, so see you in Zaragoza! The proposal was a joint effort between Antonio Morales, Mario Prats, Siddhartha Srinivasa, and myself. We already set up the web page, so feel free to check it out at
RSS 2010 Workshop on Strategies and Evaluation for Mobile Manipulation in Household Environments

My Desktop Wallpaper

If you like what you see keep on reading.

The above is generated using Xplanet. However, to get everything to work perfectly you need to tweak a few things. If you wanna duplicate this, here’s what you need to do:

• download and install xplanet from http://xplanet.sourceforge.net or use apt-get install xplanet on Debian/Ubuntu systems;
• get the script from http://xplanet.sourceforge.net/FAQ.php#gnome2 (or use my modified copy here) if you have Gnome like I do. There’s also a KDE version available there if you still use _that_ (rolleyes). My changes account for a different projection type and some other small changes. Use their instructions to add it to your list of startup programs (Gnome2 menu -> System -> Preferences -> Sessions);
• get the script from http://xplanet.sourceforge.net/Extras/download_clouds.py (or use my modified copy here). My changes account for higher quality cloud maps (4096 instead of 2048);
• create a directory called .xplanet in your home directory;
• go to the NASA Blue Marble collection and download the monthly pictures from January - December and save them into $HOME/.xplanet/world/ (or change my modifications from the gnome2 script). You have two options there: 1) download the simpler maps showing only the topography of the continents (page 2 and 3) with the oceans in a single color; or 2) download the maps which show both the topography of the continents together with the bathymetry of the oceans. My choice was 2). Downsample and rename the maps as you wish to best fit your screen. I saved my copies as world.topo.bathy.2004{01-12}.1050.jpg. You need to save yours under the same name or change the gnome2 script;
• from the same page, download the BMNG Raw Topography picture and the BMNG Raw Bathymetry picture. You need to edit the second one to make it binary (black and white) with all continents black and all oceans (or other water spots) white. This can be easily done if you open it up in GIMP, do a select color on the continents, then invert selection, and cut. Save them under $HOME/.xplanet/bump.jpg and $HOME/.xplanet/specular.jpg respectively;
• get a night shot Earth scene from flatplanet (my favorite is night-electric.jpg) and save it under $HOME/.xplanet/night.jpg
• finally download my configuration script from here and place it into $HOME/.xplanet/config.

Let’s revise. You now should have the following files in your $HOME/.xplanet/ directory: bump.jpg, config, night.jpg, and specular.jpg. You should also have a subdirectory $HOME/.xplanet/world/, containing 12 files: from world.topo.bathy.200401.1050.jpg to world.topo.bathy.200412.1050.jpg. Now, you need to do one more thing, and you’re done: cloud maps. By default, the xplanet-download_clouds.py will download a high quality (4096) cloud map which you can use. However, I didn’t like the default too much because the clouds towards the poles are just mirrored from the data below them, due to the fact that there is no satellite data for the clouds around the poles. This mirroring artifact looked too weird for me, so I decided to crop the map instead (and then resize it). This results in a minor stretching artifact, but in my opinion it definitely provides a better visual aspect.

Final thoughts. The xplanet-gnome2.sh script will start Xplanet whenever you start your Gnome2 session, and will use all the images together with the current system time above to generate a new screenshot every 2 minutes for your desktop. I consider this an _extremely minor_ penalty performance. If you don’t want your changes that often on the desktop, simply change the sleep time in the script to something else.

The cloud maps are a bit trickier if you want to use _real satellite_ data. The Xplanet folks recommend using the xplanet-download_clouds.py script every 3 hours, because that’s the frequency they generate the new cloud maps with. So, together with my cropping/resizing changes, I made the following script (let’s call it xplanet_clouds.sh — note: my xplanet scripts are in $HOME/bin):

#!/bin/bash
$HOME/bin/xplanet-download_clouds.py /tmp/clouds_4096.jpg
/usr/bin/convert -crop 4096×1700+0+174 /tmp/clouds_4096.jpg /tmp/clouds_custom.jpg
/usr/bin/convert -resize 1680 /tmp/clouds_custom.jpg $HOME/.xplanet/clouds.jpg
rm -f /tmp/clouds_4096.jpg /tmp/clouds_custom.jpg

and then used crontab -e to add the following entry:

0 */3 * * *  path-to-your-xplanet_clouds.sh-script

Have fun.