---

CollisionDetection.h

Go to the documentation of this file.

//
//       Title           : CollisionDetection.h
//       Project         : OSCAR
//       Created         : April 14, 2007
//       Author          : Jonathan Knoll
//       Platforms       :
//       Copyright       : Copyright The University of Texas at Austin, 2002. All rights reserved.
//                 
//          This software and documentation constitute an unpublished work
//          and contain valuable trade secrets and proprietary information
//          belonging to the University. None of the foregoing material may be
//          copied or duplicated or disclosed without the express, written
//          permission of University. THE UNIVERSITY EXPRESSLY DISCLAIMS ANY
//          AND ALL WARRANTIES CONCERNING THIS SOFTWARE AND DOCUMENTATION,
//          INCLUDING ANY WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
//          PARTICULAR PURPOSE, AND WARRANTIES OF PERFORMANCE, AND ANY WARRANTY
//          THAT MIGHT OTHERWISE ARISE FROM COURSE OF DEALING OR USAGE OF TRADE.
//          NO WARRANTY IS EITHER EXPRESS OR IMPLIED WITH RESPECT TO THE USE OF
//          THE SOFTWARE OR DOCUMENTATION. Under no circumstances shall the
//          University be liable for incidental, special, indirect, direct or
//          consequential damages or loss of profits, interruption of business,
//          or related expenses which may arise from use of software or documentation,
//          including but not limited to those resulting from defects in software
//          and/or documentation, or loss or inaccuracy of data of any kind.
//       Purpose         : Class to provide collision detection capabilities to an OSCAR Workcell.
//
//
//----------------------------------------------------------------------------
//
//       $Revisions$
//
//       $Log: CollisionDetection.h,v $
//       
//
//

#ifndef CollisionDetection_h
#define CollisionDetection_h

#include "Workcell.hpp"
//#include <utility>
//#include <vector>

#if defined _SOLID
#include "solid-3.5/include/SOLID.h"
DT_Bool CollisionCallback(void *client_data, void *object1, void *object2, const DT_CollData *coll_data);
#endif

namespace OSCAR {

  class CollisionPoint;

  class CollisionDetection : public Base {
  public:

    enum ResponseType { WITNESSED, DEPTH };
    CollisionDetection(WorkCell* workcell, ResponseType type=WITNESSED, OSCARError& err=DUMMY_ERROR(noError), const String& name= String());

    virtual ~CollisionDetection();

    std::vector<CollisionPoint*>& GetCollisionPoints() { return collisionpoints; }


    void OutputCollisionPoints();

   
        
        
        bool CheckManipulatorSelfCollisions( String manip );

        bool CheckWorkcellCollisions();

        bool RemoveWorkcellCollisionPair( Polytope* obj1, Polytope* obj2 );


    bool AddWorkcellCollisionPair( Polytope* obj1, Polytope* obj2 );

    bool RemoveManipulatorCollisionPair( Polytope* obj1, Polytope* obj2, Node* manip );

    bool AddManipulatorCollisionPair( Polytope* obj1, Polytope* obj2, Node* manip );

    bool GetDistance( const Polytope& obj1, const Polytope& obj2, 
                      Vector3& obj1Wit, Vector3& obj2Wit, 
                      Vector3& unitVec, double& dist );

    ResponseType GetResponseType() {return resptype;}

private:

  WorkCell*                                cell;
  std::vector< CollisionPoint* >           collisionpoints;
  DistanceCalculator                       distancecalculator;
  ResponseType                             resptype;
#ifdef _SOLID
  DT_SceneHandle                           scene;
  DT_RespTableHandle                       globalRespTable;   // This response table tracks global collisions
  std::vector< std::pair<Node*,DT_RespTableHandle> > manipRespTables;   // These response tables track the manipulator self-collisions

  CollisionDetection(const CollisionDetection& cd);

  CollisionDetection& operator= (const CollisionDetection& cd);

  void AddEnvironmentPolytopes(Node* node);

  void AddManipulatorPolytopes(Node* node);

  bool RemoveManipulatorAttachmentCollisions(Node* currentnode, 
                                               Node* previousnode, 
                                               DT_RespTableHandle resptable);

   void RemoveNodePolytopes(Node* node);
#endif

};


        class CollisionPoint {
        public:
    CollisionPoint() {}
    CollisionPoint( const String& obj1, const String& obj2, const Vector3& pnt1, const Vector3& pnt2=Vector3() );
    ~CollisionPoint()   {}
    String GetObject1() const { return objname1; }
    String GetObject2() const { return objname2; }
    Vector3 GetPoint1() { return point1; }
    Vector3 GetPoint2() { return point2; }
    //the following are defined so we can use this class with STL algorithms
    bool operator<(const CollisionPoint& pt) const;
    bool IsSame(const CollisionPoint& pt) const;

        private:
                String         objname1;
                String         objname2;
                Vector3        point1;
    Vector3        point2;  // note: point2 - point1 = normal, where point1 and point2 are penetration points
        };


}  //namespace OSCAR
#endif //CollisionDetection_h

RRG Homepage

OSCAR Overview

OSCAR Tutorials

Simulations