|Tags||No category tags.|
|CI status||Continuous Integration|
|Package Tags||No category tags.|
Help Wanted (0)
Good First Issues (0)
Pull Requests to Review (0)
- Mikkel Rath Hansen
- Mads Vainoe Baatrup
- Mads Vainoe Baatrup, Mikkel Rath Hansen
This package implements a ROS package for defining, configuring, and working with patterns in robotics applications. This allows a robotics application developer to easily define a pattern, or group of patterns, for batch processing of structured parts, e.g. palletizing operations.
We have implemented the ROS package purely in Python, with the key components necessary for working with patterns throughout the rest of the FTP:
Structure and Behaviour
- All patterns and transforms are represented by a single class:
XForm(as in transform) class is implemented as a tree node. Each transform is contained within an
XFormclass contains all necessary functions to manage and configure the transform tree structure.
- Patterns of transforms consist of a parent
XFormobject with n child-
XFormobjects (hence a tree structure) positioned in the respective pattern shape, relative to the parent.
XFormnodes contain an attribute describing whether the node is “active”, or not. Setting this property allows choosing which transforms should be iterated and affords the functionality of iterating through transforms sequentially.
- Pattern classes are implemented as plugins, allowing for easy extensibility of the set of pattern types.
- A standard set of pattern plugins are implemented for generating some primitive pattern types (i.e. linear, rectangular, circular, and scatter).
- It is possible to group transforms and/or patterns by creating a new
XFormobject and assigning it as the parent of various patterns or sub-groups (see
XFormtree can be stored as a .yaml file, which in addition to allowing users to persistently store their configuration, also allows for editing of the tree by hand using a text editor.
- Saved (or manually constructed) .yaml files can also be loaded to generate a reflective
- All required functionality for creating and managing patterns and transforms is enabled through ROS services.
- Geometric information about the position and orientation of each transform is published and broadcasted to the frame and coordinate management tool, tf. The data broadcasted about the transforms from within the node can therefore be tracked and visualized at any time using tools such as the ROS 3D visualization tool, RViz.
- The node also publishes Marker Messages which are used to draw primitive, color-coded, markers in RViz at each transform position. These markers are used to indicate whether a transform is active and if it is the next transform in the iteration.
Graphical User Interface
- Additionally, a GUI (rqt_pattern_manager) has been developed to enable simple and intuitive interaction with the Pattern Manager node.
- As the GUI was designed as an RQT plugin it is easy to integrate into existing ROS software, which makes particularly good sense in the case of RViz, which accepts RQT plugins as extended program functionality. This means the GUI can be opened from within RViz as part of the editor’s environment.
- All the same functionalities available by interacting directly with the Pattern Manager ROS node, are available from within the RQT plugin.
- The GUI additionally allows for drag-and-drop functionality for reordering and re-parenting transforms (incl. patterns).
Documentation, testing, integration
- The source code has been documented with reStructuredText docstrings.
- API documentation has been generated using rosdoc_lite (utilizing Sphinx).
- Unit test have been created for source code modules (Python unittest library).
- Package added to ROS build farm.
- Documentation added to ROS documentation index.
- Tutorials added to the ROS wiki page.
Example tree structure
Patterns of transforms can be grouped with other patterns. Additionally, these groupings can also be sub-grouped. This enables the user to combine multiple (groups of) patterns, which in turn allows seamless iteration through multiple patterns, as if it was one pattern.
The following is an example of such a structure:
root [tf0] # <transform-name> [<transform-number>] ├── grp1 [tf1] # transform as pattern group/container │ ├── lin1 [tf2] # ex. linear pattern of transforms │ │ ├── lin1_1 [tf3] │ │ ├── lin1_2 [tf4] │ │ ├── lin1_3 [tf5] │ │ └── ... │ └── lin2 [tf11] │ ├── lin2_1 [tf12] │ ├── lin2_2 [tf13] │ └── lin2_3 [tf14] ├── grp2 [tf6] │ ├── grp3 [tf7] │ │ ├── rect1 [tf8] # ex. rectangular pattern of transforms │ │ │ ├── rect1_1 [tf9] │ │ │ ├── rect1_2 [tf10] │ │ │ └── ... │ │ └── ... │ └── ... └── ...
This project has received funding from the European Union’s Horizon 2020 research and innovation programme under grant agreement No. 732287.