SWIFT++ Features in Detail
Some of the features of SWIFT++ are explained more in detail here. The spirit of this page is to give a what and a why. It is designed to more or less describe what is possible with the system and give some motivation or reason for it. For a detailed description of how to use the system, refer to the user manual. We are always looking for ways to improve SWIFT++. If you have any ideas of things we could add to the system that we have not mentioned here or in the Future Versions section, please let us know.
objects accepted by SWIFT++ are general polyhedra with or without boundary
Models to be loaded into SWIFT++ must be run through a preprocessing program first. The models have their surfaces convex-decomposed and a bounding volume hierarchy built on the resulting pieces.
detecting whether a pair of objects intersect (penetrate)
Some applications simply require knowledge of the presence of intersection in the scene. Likely, they will reject any configuration that is intersecting. Other applications require knowledge of all the pairs of intersecting objects in the scene so that they can compute a reaction for these objects.
There are two possible ways that SWIFT++ allows for intersection detection. The first is to report true or false for the whole scene. The second reports a list of all the intersecting objects in the scene.
Currently, there is no measure of penetration depth given by SWIFT++. It simply returns the pairs that are penetrating or a negative distance if distance is being computed. In the future, it is likely that we will provide some additional queries that can determine the penetration depth of two objects.
detecting whether a pair of objects are closer than a given tolerance
This type of query is similar to the intersection detection query. It receives a tolerance from the application and determines if any pairs of objects in the scene are closer to each other than the given tolerance.
computing the minimum distance within an application specified (relative and/or absolute) error bound between a pair of objects
SWIFT++ allows the computation of the distance between two objects to be performed approximately. The application specifies a tolerance, an absolute error, and a relative error. Pairs of objects are reported along with the approximate distance between them if the computed approximate distance is less than the tolerance. The approximate distance that is computed is within the error bounds specified by the application.
SWIFT++ computes the approximate distance between any pair of objects if their bounding boxes are overlapping (if this is enabled). The boxes may be enlarged to handle any tolerance the application wishes. Negative distances represent intersections. The negative distance is not a measure of penetration, however. In addition, there is the option of stopping the entire scene test if intersection is found or of continuing and reporting all intersections as well (as negative distances).
computing the minimum distance between a pair of objects
SWIFT++ can compute the exact distance between pairs of objects. The application specifies a tolerance and SWIFT++ returns those pairs that are closer than the tolerance along with the distance that they are separated by.
SWIFT++ computes the exact distance between any pair of objects if their bounding boxes are overlapping (if this is enabled). The boxes may be enlarged to handle any tolerance the application wishes. Negative distances represent intersections. The negative distance is not a measure of penetration, however. In addition, there is the option of stopping if intersection is found or of continuing and reporting all intersections as well (as negative distances).
computing the set of closest features (vertex,edge,face) for a pair of objects when they are disjoint
Many times, an application is only interested in knowing when two objects come sufficiently close to warrant a response computation and which features are closest. The application gives a tolerance which SWIFT++ uses to report nearest features for any pair of objects that are closer than the tolerance. Various contact information may (optionally) be computed. Things that can be reported are: distance, nearest points, nearest feature ids, and contact normals. Only certain combinations of vertex, edge, and face are possible: v-v, v-e, v-f, e-e. Like the distance computations, computation can be stopped if there is an intersection detected, or the computation can continue and report all intersections as well as all applicable nearest features.
Other Key Features
query compares favorably to other packages (RAPID, PQP, QuickCD)
The SWIFT system was shown to be faster than other convex based packages. The performance of proximity queries is highly dependent on the type of scenarios and the motion of the objects. SWIFT++ was compared against other polygon soup based packages and found to perform well. For test results please see the publications.
as robust as or more robust than other packages
Since SWIFT++ uses the SWIFT core as one of its main subroutines, it does not have any tolerances in its main query subroutine. Thus, it is also very robust. Valid answers can be given for all but the most pathological cases (due to floating point computation). See the comments about SWIFT robustness.
efficient querying even if coherence is not present
Some applications exhibit high coherence but some do not. For those that do not, there may exist cases when coherence is very low. SWIFT++ uses a fast lookup scheme to provide a good initial starting point to the distance minimization routine. The additional cost of this lookup when coherence is high is small.
bounding boxes are placed around each object to prune unnecessary computation through a sweep and prune sorting algorithm
The sweep and prune algorithm that is used in I-Collide is also used in SWIFT and SWIFT++. When there are more than two or three objects, it is useful to use since it helps to "cull" away large amounts of computation.
bounding boxes types can be chosen automatically
For an object's bounding box, there are essentially two choices. A cube which bounds the object at any orientation or a dynamic bounding box that is updated at each frame may be used. SWIFT++ is able to make an intelligent choice when an object is added to a scene about which bounding box type to use (if the application so desires).
objects that are declared static (fixed or not moving) are automatically optimized for and any pair may be activated or deactivated
Pairs may be activated or deactivated. SWIFT++ supports objects which can be declared static. Pairs that comprise two static objects are always deactivated. The application still has control over the other (non-static) pairs. Pairs of objects that will never interact should be deactivated.
objects may be given in files of various formats
To import object geometry into SWIFT++ is simple. It must first be run through the preprocessor which can be configured to read model files of any format (the application provides format-specific methods). The files do not have to contain triangle specifications. Models are automatically triangulated when they are imported. The preprocessed files are then read into SWIFT++ by providing their filenames.
objects that are made of the same geometry can share that geometry
If multiple objects are described in the same way geometrically, it is wasteful to replicate the description. Since all the transformations are rigid, it is possible to share the geometry. SWIFT++ supports this type of sharing across objects.