collisiondetectors/CD_Swiftpp.h

Go to the documentation of this file.

//=================================================================
// CD_Swiftpp.h
// Acts as the wrapper class to the collision detection package
// SWIFT++ which provides distances measurements as well as
// closest points calculations, both of which are needed in 
// IK_Jacobian
//=================================================================

#ifndef CD_SWIFTPP_H
#define CD_SWIFTPP_H

#pragma warning( disable : 4250 )

#include <set>
#include <vector>

// CD_BasicStyle
#include "CollisionDetectors\CD_BasicStyle.h"
#include "CollisionDetectors\CD_LinearDiscrete.h"
#include "CollisionDetectors\CD_LinearContinuous.h"
// Mesh
#include "geometry\Mesh.h"
#include "SWIFTpp\include\SWIFT.h"

// string lengths (pretty much arbitrary)
#define MAX_BUFFER_LENGTH       1024
#define MAX_FILENAME_LENGTH     256
#define MIN_FILENAME_LENGTH     11

class Facet;
class ObjectGroup;
class LinkBase;
class SWIFT_Scene;

class CD_Swiftpp 
: 
        public CD_BasicStyle,  
        public CD_LinearContinuous
{
public:
    CD_Swiftpp (const Universe& universe);
    CD_Swiftpp (const CD_Swiftpp& right);

    //## Destructor (generated)
    virtual ~CD_Swiftpp();

    //  this virtual function provides a copy of the object
    virtual CollisionDetectorBase* Clone () const;

    // returns -1 if error, else object id
    // bFixed indicates whether or not the object added is fixed or moving 
    // by default, they are moving.  If fixed, objects are not tested against 
    // each other for collision.  Also, once an object's status is set here
    // it cannot be changed, ie - an object cannot be declared fixed after it
    // was declared moving when it was first added here.
    int AddMeshToSwiftScene(const Mesh& mesh, const bool bFixed);                  
    bool AddEntityToSwiftScene(const Entity* entity);    
    
    // (De)Activate frames - if only one frame is given, then all pairs with that frame 
    // in it will be (de)activated
    void DeactivateFrames (const unsigned int frame1, const int frame2 = -1);
    void ActivateFrames (const unsigned int frame1, const int frame2 = -1);

    // QueryContactDetermination - Reports distance, nearest points and normals
    // of objects within the specified tolerance.  By default, nothing is reported.
    // Returns true if collision detected, false if none.
    // bEarlyExit - if true, function returns true when first intersection is detected
    //              and no information is reported.
    // tolerance  - specifies the distance within which the features must be to be reported.
    //              if SWIFT_INFINITY is used in the parameter, all features are reported
    // num_pairs  - number of object pairs reported. NOT the number of contacts, ie - one
    //              object pair can have more than one contacts.
    // oids       - array of object ids.  length = 2*num_pairs.  For example, if num_pairs is 
    //              2 then oids[0]&oids[1] is the first pair and oids[2]&oids[3] is the second
    //              pair
    // num_contacts-number of contacts reported per pair.  length = num_pairs.  For example, if 
    //              num_pairs = 2, and num_contacts is [9,4], then there are a total of 13 
    //              contacts reported: 9 for the pair oids[0]&oids[1], 4 for the pair
    //              oids[2]&oids[3]. If a pair is intersecting, the entry for that pair is -1.
    //              If a pair is intersecting, the number of contacts is considered 1 so the
    //              following arrays will need to be read appropriately according to this
    //              Entries are either -1, 1 or higher.  0 would be an invalid return.
    // distances  - distances between features.  length = sum of all the values in num_contacts
    //              In the above example, length of distances = 13.  The distances are ordered
    //              in descending order (farthest to closest) within one pair of objects. So
    //              to get the shortest distance between oids[0]&oids[1], read distances[8]
    //              and distances[12] for oids[2]&oids[3]. If a pair is intersecting, 
    //              only one distance entry (value of -1) is allocated for the pair.
    // nearest_pts- gives the coordinates of the points used to measure distances.  
    //              length = 6* length of distances.  for each distance given, the xyz of 
    //              the closest point on the first object in the pair is given before the xyz 
    //              of the closest point on the second object. (oids[0] would be the first 
    //              object and oids[1] would be the second and so forth). 
    // normals    - gives the normal vector pointing to object1 from object2 wrt world 
    //              coordinates, vectors returned are normalized.  
    //              length = 3*length of distance
    bool QueryContactDetermination( const Configuration& config, bool bEarlyExit, 
         SWIFT_Real tolerance, int& num_pairs, int** oids, int** num_contacts, 
         SWIFT_Real** distances = NO_DISTANCES, SWIFT_Real** nearest_pts = NO_NEAREST_PTS, 
         SWIFT_Real** normals = NO_NORMALS);
    bool IsInterfering (const Configuration& config);

    // returns the link number of the link the object belongs to
    int  GetRobotLinkBaseFrame(int objectId);

        // Set tolerance
        void SetObstacleTolerance(double tol) {m_dObsTol = tol;}
        
    // Data Members for Associations
    std::vector<Mesh*> m_vMeshes;
 
protected:

    void UpdateMovedLink (const unsigned int linkNum) const;

    // Data Members for Class Attributes
    mutable SWIFT_Scene* m_pSwiftScene;

    //  this tells us which swiftpp indexes are owned by which links
    std::vector< std::set< unsigned int > > m_vLinkSwiftpp;
    std::vector< int > m_vSwiftppIndexes;       // object ids

private:
    // Data Members for Class Attributes
        double                  m_dObsTol;
    Universe* m_pUniversePointer;

};


#endif

---