I have also contributed to various other projects, including:

apriltags , prpy , pr-ordata , herbpy , herb_description , or_ompl , or_urdf , reem_description

# Popular open-source software

**OpenCV catkin package**

Catkin wrappers for OpenCV (Open-source Computer Vision) version 2.4, 3.4 and 4.1

to download and compile the source code within a catkin workspace.

**PCL catkin package**

Catkin wrappers for PCL (PointCloud Library) version 1.7, 1.8 and 1.9

to download and compile the source code within your catkin workspace.

**OMPL catkin package**

Catkin wrapper for OMPL (Open Motion Planning Library).

**rviz_tools_py**

Some useful tools for using ROS Rviz with python. This makes it easier to publish Rviz Markers in a more pythonic way.

**Minimum-area Bounding Rectangle**

An algorithm I wrote to find the minimum-area bounding box around a set of 2D points.

Applications include:

– Defining grasps for cuboid-shaped objects.

– Box fitting for point-based perception algorithms.

Written in 2013, this was one of the first open-source python implementations. The method is similar to “rotating calipers”. First, the qhull (QuickHull) algorithm is used to find the points that represent the convex hull. For each edge of the convex hull polygon, calculate the angle. Keep the angles that are in the first quadrant (90 degrees) of rotation. For each angle, compute the area of the enclosing rectangle. Keep the rectangle with the smallest area.

**PCL binvox converter**

Command-line tools to convert between .binvox and .pcd file formats.

– binvox is a binary format for a 3D voxel grid.

– pcd is Point Cloud Data from PCL (PointCloud Library).

**PCAP to PCD**

A tool to convert a .pcap (packet capture) file from a Velodyne VLP-16 LiDAR sensor into multiple .pcd PointCloud files.

This stand-alone VLP Grabber can save you time by not compiling the entire PCL (PointCloud Library) from source.

**NXT-ROS**

A software stack containing tools to interface LEGO Mindstorms NXT with ROS.M. Wise.

In 2016 I ported and updated the code to work with ROS Fuerte, Groovy and Indigo.

# Other code

**NXT++**

NXT++ is an interface written in C++ that allows the user to control Lego Mindstorms NXT robots directly through a USB or Bluetooth connection.

This is useful because it means you can use more than 3 motors in total, which is great for building big robots!

Or you can write a distributed robotics application in C++ and test it on a swarm of robots connected via Bluetooth.

**PMB2 mobile robot simulation**

A simulation of the PMB2 mobile robot from PAL Robotics, using ROS Melodic and Gazebo 9.

This repository includes various bug fixes and changes to the simulation parameters.

**MOPED (Multiple Object Pose Estimation and Detection)**

A software framework for detecting the 3D pose of multiple objects using a 2D camera. It can be used with ROS and has optional support for NVidia GPU and 3D depth sensors.

In 2016 I fixed the code, gathered all the components required to compile and run the framework, and updated the documentation. I also added nodes to make it work with ROS.

See installation instructions here:

github.com/DavidB-CMU/moped/tree/master/moped2

github.com/DavidB-CMU/moped/tree/master/moped_example

**VTK Examples**

Sample code for VTK (The Visualization Toolkit).

and render using either: a solid color, a gradient based on distance along the radius, or a gradient based on angle around the circumference (a color wheel). Also, the Cxx examples included with VTK do not compile out-of-the-box. I fixed the CMake configuration so that each example will only compile if you have the correct version of C++ and VTK.

See this branch:

github.com/dbworth/VTKExamples/commits/fix/Compilation-issues-with-Cxx-Examples

**or_taskspace_planners**

Some task-space manipulator motion planners, implemented using OpenRAVE.

– Recursive Bounded Deviation using Matching Function and Distance Metric e.g. Frechet distance, Hausdorff distance, mid-point distance.

– Russell’s Bounded-deviation Joint Paths.

– Workspace trajectory sampling, based on Whitney’s Resolved Rate Motion Control.

**WAMpy**

WAMpy is a python library for interacting with a simulated model of the Barrett WAM manipulator within OpenRAVE.

**comparing_geometric_paths**

Methods for comparing the similarity of geometric paths.

Currently this package contains both matlab and python implementations for various distance metrics, including: the discrete Frechet distance between two 2D paths and the discrete Hausdorff distance.**ROS Tabletop Grasping**

I developed and contributed to various ROS packages for the perception and manipulation of objects on a table.

The system was tested using PAL Robotics’ REEM-H mobile service robot. The open-source packages are:

arm_kinematics_constraint_aware

fake_controllers_list

household_objects_database

interpolated_ik_motion_planner

move_arm

pointcloud_snapshotter

tabletop_collision_map_processing

tabletop_object_detector reem_arm_navigation

reem_common

reem_hand_grasp_controller

reem_head_scan_action

reem_kinematics

reem_manipulation_worlds

reem_move_arm_action

reem_perception_launch

reem_simulation

reem_tabletop_manipulation_launch

reem_teleop_general

**Numerical algorithms for solving equations**

Various numerical methods written in python:

– Solving differential equations (ODEs) for initial value problems and boundary value problems using Runge-Kutta methods.

– The Crank Nicolson Finite Difference method for solving partial differential equations (PDEs).

– Numerical integration using trapezoid rule, Romberg’s rule, Simpson’s rule, Gauss-Legendre m-point quadrature and adaptive Gaussian integration.

– Finding roots of equations using bisection and Brent’s method.

**RobotC examples**

Some example solutions to typical robotics problems, written in RobotC for Lego Mindstorms NXT:

– Drive forward in a straight line, using wheel-encoders.

– Gradual motor start, using bell-shaped velocity profile.

– RGB Color Sensor test.

– Using RGB Color Sensor as a Light Sensor.

– State Machine template.

**arm_kinematics_tools**

Some useful tools for creating and testing your own ‘arm_kinematics’ package for ROS.

You can test and compare various kinematics solvers: Newton-Raphson, KDL and IKFast.

This work was featured in the book *“Mastering ROS for Robotics Programming”*, written by L. Joseph in 2015.

See page 602: PDF

It was also referenced in the SDK for the Rethink Robotics “Baxter” robot:

http://sdk.rethinkrobotics.com/wiki/Custom_IKFast_for_your_Baxter (offline)

Discussion on ROS Answers:

answers.ros.org/question/53066/using-real-robot-data-in-warehouse-scene-planning/

answers.ros.org/question/53542/ikfastdemo-does-not-compile/

answers.ros.org/question/217130/ikfast-computation-time/

Discussion on OpenRAVE Mailing List:

[OpenRAVE-users] iktests and computation time

[OpenRAVE-users] Is it possible to create DLL-suitable source code with IKsolver?

[OpenRAVE-users] IKFast for 7dof Arm

**ROS interface to the Webots simulator**

Various packages to use the Webots robot simulator with ROS:

webots_run – start Webots directly from a ROS launch file.

webots_joy_demo – joystick tele-operation.

webots_controllers – a Controller Manager compatible with GazeboRosControllerManager.

Announcement on ROS-Users Mailing List:

ros-users.nabble.com/New-packages-and-tutorials-for-Webots-simulator.html

Discussion on ROS Answers:

answers.ros.org/question/51474/can-i-run-a-bash-script-using-roslaunch/

answers.ros.org/question/54640/roslaunch-external-program/

answers.ros.org/question/44742/tutorial-controlling-simulated-robot-in-webots-with-ros-using-joystick/

answers.ros.org/question/72787/webots-version-712-problem-with-image_raw-nao-robots-ros/

**New ROS repository: kaist-ros-pkg**

In 2012, Microsoft Windows was still the dominant operating system used by researchers at KAIST (Korea Advanced Institute of Science and Technology). I started a ROS package repository for the University and advocated for using Linux and ROS.