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.

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.