Callisto is a library designed for visualization and collision checking of 3D environments. It is designed to take away the hassle of setting up a 3D engine and collision checker from the user.
In just a few lines of codes, a 3D environment can be created. Callisto is originally created to allow researchers/developers to concentrate on their primary task instead of spending days to learn libraries and creating a framework.
Callisto allows users to set-up scenes using primitives and/or VRML/XML. Its visualization environment is based on Ogre. For collision checking SOLID is used.
Callisto has the following key features:
- Simple creation of an environment by using primitives: box, sphere, cylinder, cone, tetrahedron, triangle meshes, poly lines and elevation grids.
- Collision checks can be performed for a point, a line and between groups of objects.
- Objects can be translated, rotated and scaled using Euler angles, matrices and/or quaternions.
- Advanced GUI that allows users to easily view the scene and change settings.
- Multiple views on the scene.
- Group structure allows interaction on multiple objects at once.
- Groups can be recursively added to other groups as well.
- Object/group clearance can be added.
- Penetration depth and closest pairs can be calculated.
- Textures can be added to the visualisation of objects.
- Scenes can be loaded from disk using XML.
- Support for loading and exporting VRML scenes.
- Animation support for objects and the camera.
- Many features are also available using the GUI in addition to function calls.
Callisto is provided as a Dynamic Link Library (DLL). If Callisto is linked with your own project, you are able to use the more than 90 different functions in our own code. These range from simply creating primitives to complicated collision checks. Knowing only a small subset of these functions is already enough to start using Callisto and to create a 3D environment.
Although all functions of Callisto can be used through function calls, when Callisto is run, an interface pops up with which certain settings can be changed at run time. These functions are mainly for supporting the navigation of the user and changing basic properties of the scene (like showing/hiding objects). Callisto supports up to four views of the same scene all with their own properties in a Multiple Document Interface (MDI).
Objects in Callisto are organized in groups. This means that an object belongs to exactly one group. A group can also contain another group etc.. Every object and every group has properties like position, orientation and scaling. When these are changed for a group, then every object and every subgroup in the group are also affected. In this way it is very easy to give a group of objects a common behavior, or to construct for example a robot consisting of multiple objects.
After a simple initialization, Callisto can be used to visualize environments. Since every object is contained within a group, first a group has to be created. Callisto always returns IDís for groups and objects in order to allow the user to manipulate them later. Objects and groups can be created using functions calls or by loading a scene from disk. The file format used is our own XML format, but standard VRML 2.0 files can also be read. The following primitives are supported:
Collision functions are executed on groups. If, for example, we have a group "robot" and a group "scene", we can check whether robot and scene are in collision. The following collision routines are supported
- triangle meshes
- elevation grid
All these functions can either report one result or multiple, depending on the users needs. For every object and every group, a clearance can be defined in order to make sure that, for example, a robot maintains enough clearance from the obstacles.
- point collision: is a point inside or outside a certain group?
- line collision: is a line in collision with a group?
- group collision: are two groups in collision with each other?
- closest pairs: which two obstacles of the two groups are closest to each other. This function yields witnesses of the closest distance.
- penetration depths: how fare are two colliding groups penetrated. This function also yields witnesses.
The most important parameters that can be changed are the properties of the groups and objects. Their properties can be changed by sending an new position, orientation or scaling to Callisto. For setting the orientation, quaternions are also supported. If group parameters are changes, all subgroups and objects are affected. Using these functions, animations can be created. In addition, Callisto provides animation functions that ease the process of creating animations.
The camera can be steered by the user using the mouse. The camera can also be fully controlled using function calls in order to create an animation.
When experiments are run, the visualization can be suspended, so that it does not take any CPU cycles away from the experiments.
Development of Callisto started in 2004 and currently Callisto consists of more than 90 functions. For version 4 some changes have been made to the interface.
The main changes since version 3 can be read here.