SE(2) EZ

se2ez is a library to support planning for kinematic trees in the plane. This library contains a set of tools for modeling and manipulating robots and robot states with the end goal of providing an efficient, modular interface for whatever robotic research goals you may have. In particular, this library is focused on supporting motion planning for general robots.

A Brief Overview

se2ez is split into a few high-level modules that separate different pieces of functionality. These modules so far are core, gui, and plan.

Core Module

The core module in se2ez provides all the modeling tools you might expect for kinematic robots. Currently, it has the tools to load or construct a se2ez::Robot (a kinematic tree) that is composed frames (se2ez::Frame), each which could be actuated by a joint (se2ez::Joint). Each frame can have multiple pieces of geometry (se2ez::Geometry) attached to it, which can be a box, circle, or polygon. From a se2ez::Robot, a se2ez::State can be constructed, which represents a configuration of the kinematic tree. Forward kinematics can be done using a se2ez::State. Inverse kinematics is provided through KDL in variations of a se2ez::TreeIK. Collision checking, along with signed distance computation, is provided through an se2ez::CollisionManager. Currently, there exists an implementation using Box2D, se2ez::Box2DCollisionManager. Using the collision checking manager, configuration space visualization is provided in se2ez::CSpaceGrid.

More features are coming soon (:tm:)! Many things are currently not "fully" documented, but Doxygen exists for most core classes.

Plan Module

The plan module offers OMPL constructs for motion planning using se2ez::Robots via the core modules kinematics.

More features are coming soon (:tm:)! Many things are currently not documented.

GUI Module

The gui modules in se2ez provide an interface to interactive visualization of a robot. The idea of the gui system is that there exist panels (se2ez::gui::Panel) that are held in main window (se2ez::gui::MainWindow). To craft a GUI for whatever your needs, it is simple to create a main window and add whatever panels you want. Currently, there exist the following panels:

  • se2ez::gui::JointPanel, for visualizing joint states and their component frames or geometry. Additionally, collisions, signed distance, and inverse kinematics are provided for interactive positioning and diagnostics of the robot.
  • se2ez::gui::PlanPanel, for interactive motion planning visualization through OMPL.
  • se2ez::gui::CSpacePanel, for interactive visualization of the configuration space of an existing robot.

Dependencies & Building

se2ez is dependent on the following libraries:

  • Eigen 3 or above (libeigen3-dev)
  • KDL 1.3 or above (liborocos-kdl-dev)
  • CGAL 3 or above (libcgal-dev and libcgal-qt5-dev)
  • Boost 1.58 or above (libboost-all-dev)
  • Qt 5.9.5 or above (qtdeclarative5-dev)
  • Box2D (libbox2d-dev)

You can install these all with the following command from apt if on and Ubuntu machine:

sudo apt-get install \
libeigen3-dev \
liborocos-kdl-dev \
libcgal-dev \
libcgal-qt5-dev \
libboost-all-dev \
qtdeclarative5-dev \

se2ez also uses OMPL and yaml-cpp as git submodules. Before building, make sure the submodule is updated, either at initial clone or with:

git submodule update --init --recursive

se2ez uses cmake. Simply run the following in the top-level directory to build the library and scripts:

mkdir -p build/release
cd build/release
cmake ../..

If you need debugging symbols, run the following in the top-level directory:

mkdir -p build/debug
cd build/debug
cmake -DCMAKE_BUILD_TYPE=Debug ../..

If you need the compile flags, use the following argument:



An example of the YAML file format that describes a se2ez::Robot is given in yaml/test.yml, and also below:

robot: # All files must begin with "robot"
- name: "base" # The name of the frame within the robot
joint: "fixed" # The joint type. Can be from the following:
# ["fixed", "float", "flying", "translate", "prismatic", "revolute", "continuous"]
parent: "root" # The frame's parent in the tree. "root" always exists and is the root of the tree.
tip: [0, 0, 0] # The transform to this frame's time, given as [x, y, theta]
- name: "link_1"
joint: "revolute"
parent: "base"
tip: [1, 0, 0]
limits: # If a joint is controllable, it must have limits (limits can be omitted if fixed)
upper: 1.57 # Revolute joints (and prismatic) are 1-d, so a single value can be given for upper and lower limits
lower: -1.57
geometry: # Geometry is attached to the frame at the tip, and is a list of all geometry attached
- type: "box" # The geometry type. Can be from the following:
# ["box", "circle", "convex", "simple"]
dimensions: [0.1, 0.1] # The dimensions of the geometry. Dimensions is type specific.
color: [0.5, 0.5, 0.5, 1] # Color of geometry. [r, g, b, a]
offset: [0, 0, 0] # Offset transfrom from frame's tip (optional)
- name: "block"
joint: "float"
parent: "root"
upper: [1, 1, 1.57] # As joint is floating, specify bounds on [x, y, theta]
lower: [-1, -1, -1.57]
allowed: ["link_1"] # Allowable collisions can be specified as a list.
- type: "convex"
points: # For polygon types, the points of the polygon are a list.
- [0.1, 0.1]
- [0.5, 0.1]
- [0.1, 0.5]
color: [0.5, 0.5, 0.5, 1]
states: # Files can also have named states that can be retrieved from the robot.
# This is a list of named states.
- name: "start" # Each state must have a name.
configuration: # Each state must also have its configuration, a list of per frame joint values dependent
# on joint type.
- frame: "link_1" # Name of the frame / joint
value: [0] # Value
- frame: "block"
value: [0, 0, 1.57]
constraints: # Files can also have named constraints that can be retrieved.
- name: "bar_1" # This is a list of named constraints.
type: "line" # Type can be ["point", "line"]
ee: "ee" # End-effector this line constraint is for. Must be in robot.
a: [-1.0, -1.0] # First end point of the constraint line.
b: [ 5.0, 4.0] # Second end point of the constraint line.
- name: "hold"
type: "point"
ee: "ee"
base: "root" # All constraints can have a different base frame specified.
point: [-1.0, -1.0] # First end point of the constraint line.

Named states can be loaded separately.


Some example scripts are provided within the scripts/ directory. More documentation is forthcoming.

  • test.cpp: A simple demonstration of how to construct and do forward kinematics within code.
  • yaml.cpp: A simple demonstration of how to load a robot do forward kinematics.
  • plan.cpp: A simple demonstration of motion planning with a robot.
  • plan_yaml.cpp: A simple demonstration of motion planning with a robot loaded from a YAML file.
  • gui.cpp: An example of how to use the built-in GUI.
  • collision.cpp: An example of how to do collision checking using Box2D.
  • geometry.cpp: An example of some polygon operations for geometry.
  • cspace.cpp: Example of how to generate a rendering of the configuration space.
  • ik.cpp: Example of how to use the IK solvers.