Basic utilities for PyBullet, including collision detection, ghost (i.e. visual-only) objects, and cameras.
Project description
pyb_utils: utilities for PyBullet
This is a collection of utilities I've found useful for working with PyBullet, including:
- Collision detection: conveniently set up shortest distance computations and collision checking between arbitrary objects in arbitrary configurations with PyBullet. See the accompanying blog post.
- Ghost objects: add purely visual objects to the simulation, optionally attached to another body.
- Camera: virtual camera from which to get RGBA, depth, segmentation, and point cloud data. Also provides video recording using OpenCV.
- Convenience class for easily creating rigid bodies.
- Versions of some PyBullet functions that return named tuples, for easy field access.
- Basic quaternion functions.
Install and run
This package supports Python 3.8–3.11. It has been tested on Ubuntu 16.04, 18.04, and 20.04.
From pip
pip install pyb_utils
From source
Clone the repository:
git clone https://github.com/adamheins/pyb_utils
cd pyb_utils
Install using poetry:
poetry install
poetry run python examples/collision_detection_example.py # for example
Or using pip:
python -m pip install .
Documentation
The project's documentation is available here.
Usage and examples
This package provides a few basic quality-of-life utilities. First, PyBullet
represents rotations using quaternions (in [x, y, z, w]
order). We provide a
few helper routines to create quaternions about the principal axes, convert
quaternions to rotation matrices, and to rotate points (using
scipy
under the hood):
>>> import pyb_utils
>>> q = pyb_utils.quatz(np.pi / 2) # 90 deg rotation about z-axis
>>> q
array([0., 0., 0.70710678, 0.70710678])
>>> pyb_utils.quaternion_to_matrix(q) # convert to rotation matrix
array([[-0., -1., 0.],
[ 1., -0., 0.],
[ 0., 0., 1.]])
>>> pyb_utils.quaternion_multiply(q, q) # rotate two quaternions together
array([0, 0, 1, 0]) # 180 deg rotate about z
>>> pyb_utils.quaternion_rotate(q, [1, 0, 0]) # rotate a point
array([0, 1, 0])
Second, we provide a simple class to quickly create rigid bodies programmatically, which is useful for adding basic objects to manipulate or act as obstacles:
>>> import pybullet as pyb
>>> import pyb_utils
>>> pyb.connect(pyb.GUI)
# create a 1x1x1 cube at the origin
>>> box = pyb_utils.BulletBody.box(position=[0, 0, 0], half_extents=[0.5, 0.5, 0.5])
# put a ball on top
>>> ball = pyb_utils.BulletBody.sphere(position=[0, 0, 1.5], radius=0.5)
# now put it somewhere else
>>> ball.set_pose(position=[2, 0, 0.5])
Third, we wrap some PyBullet functions to return named tuples, rather than normal tuples. When the tuples have 10+ fields in them, it is rather helpful to have names! The names and arguments of these functions are the same as the underlying PyBullet ones, to make swapping effortless. Continuing our previous example:
# built-in PyBullet method
# the output is not easy to read!
>>> pyb.getDynamicsInfo(box.uid, -1)
(1.0,
0.5,
(0.16666666666666666, 0.16666666666666666, 0.16666666666666666),
(0.0, 0.0, 0.0),
(0.0, 0.0, 0.0, 1.0),
0.0,
0.0,
0.0,
-1.0,
-1.0,
2,
0.001)
# switch to the pyb_utils version
# now we can access fields by name
>>> info = pyb_utils.getDynamicsInfo(box.uid, -1)
>>> info.mass
1.0
>>> info.localInertiaDiagonal
(0.16666666666666666, 0.16666666666666666, 0.16666666666666666),
The functions we've wrapped in this way are getClosestPoints
,
getConstraintInfo
, getContactPoints
, getDynamicsInfo
, getJointInfo
,
getJointState(s)
, and getLinkState(s)
. There are two differences from the
vanilla PyBullet API. The first is that in pyb_utils getJointInfo
also
accepts an optional argument decode
, which will convert the byte strings
returned by PyBullet to the specified encoding. For example, decode="utf8"
.
The second difference is that in pyb_utils getLinkState(s)
will always return
LinkState
tuples with 8 fields, even if computeLinkVelocity=False
. When
computeLinkVelocity=False
, then worldLinkLinearVelocity
and
worldLinkAngularVelocity
are both set to None
.
And there's more! You can find example scripts of all of this package's
utilities in the examples/
directory:
Video Output
Writing a video with the VideoRecorder
defaults to using the mp4v
codec,
which is widely supported but (at least on my computer running Ubuntu 20.04)
does not play natively in web browsers. The availability of codecs depends on
what is compiled into the version of OpenCV you have installed (i.e., the one
backing the cv2
Python module); using an alternative codec may require a
different version of OpenCV.
Known issues
Feel free to open issues (or better yet, a pull request!) if you find a problem. Currently known issues:
- Ghost objects sometimes flicker (spooky, but undesirable). This is probably because they are updated by directly changing the object pose; we cannot have them updated automatically by, e.g., constraints since they are not dynamic objects (and we wouldn't want them to be; then they would influence the simulation).
- The field name
localInerialPos
in theDynamicsInfo
named tuple is spelled incorrectly. This will be fixed in a future major version. - The deprecated
GhostSphere
class will be removed in a future major version. UseGhostObject.sphere
instead.
Development
- Run
tox
to run the tests. - Sphinx is used to build the documentation. With Sphinx installed, run
make html
in thedocs
directory.
License
Project details
Release history Release notifications | RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
Built Distribution
Hashes for pyb_utils-2.2.1-py3-none-any.whl
Algorithm | Hash digest | |
---|---|---|
SHA256 | af690695dd2162058385f809da4f55117c18c23db0e59e43d32d77901ac6aa5a |
|
MD5 | a92e17b8e8083e971f985ab7a0bd99eb |
|
BLAKE2b-256 | 202616dd4139403a86e25cb063386c8316e588ed32cd182d4bbc3e2bac8e635b |