TAPsModelLaparoscopicAdjustableGastricBand.hpp

Go to the documentation of this file.

/******************************************************************************
TAPsModelLaparoscopicAdjustableGastricBand.hpp

A specific model for a laparoscopic adjustable gastric band.

SUKITTI PUNAK   (07/02/2008)
******************************************************************************/
#ifndef TAPs_MODEL_LAPAROSCOPIC_ADJUSTTABLE_GASTRIC_BAND_HPP
#define TAPs_MODEL_LAPAROSCOPIC_ADJUSTTABLE_GASTRIC_BAND_HPP

#include <TAPs/OpenGLModelFromFile/TAPsReadModels.hpp>
#include "../OpenGLModel/TAPsModelStrand.hpp"

BEGIN_NAMESPACE_TAPs__OpenGL
//=============================================================================
template <typename T>
class ModelLaparoscopicAdjustableGastricBand : public /*virtual*/ ModelStrand<T> {
    //-------------------------------------------------------------------------
    // (Friend Fn) put it through ostream
    friend std::ostream & operator<< ( std::ostream &output, 
        ModelLaparoscopicAdjustableGastricBand<T> const &o )
    {
        output  << "\n======================\n"
                <<   "TAPs::ModelLaparoscopicAdjustableGastricBand<"
                << typeid(T).name() << "> Class:\n"
                <<   "======================\n";
        //----------------------------------------------------------------
        output  << "\n# of Links " << o.m_iNoLinks
                << "\nEach link has length " << o.m_tLinkLength 
                << " and weight " << o.m_tPointWeight << "\n";
        return output;
    }
//-----------------------------------------------------------------------------
// Member Functions -----------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    // Constructor(s)
    ModelLaparoscopicAdjustableGastricBand ();
    ModelLaparoscopicAdjustableGastricBand ( 
        int iNoLinks,   // # of links/segments
        T tLength,      // the strand length
        T tWeight,      // the strand weight
        Vector3<T> & posOfVertex0 = Vector3<T>(),   // position of the 1st node
        T tRadius = 0.05
    );
    ModelLaparoscopicAdjustableGastricBand ( 
        int iNoLinks,   // # of links/segments
        T tLength,      // the strand length
        T tWeight,      // the strand weight
        Vector3<T> & posOfVertex0,  // position of the 1st node
        T tRadius,
        const char * head   // Head Type (read from file)
    );
    ModelLaparoscopicAdjustableGastricBand ( 
        int iNoLinks,   // # of links/segments
        T tLength,      // the strand length
        T tWeight,      // the strand weight
        Vector3<T> & posOfVertex0,  // position of the 1st node
        T tRadius,
        T tKRatioOfStretchingAllowed,
        T tKRatioOfCompressionAllowed,
        T tKStretching,
        T tKBending,
        T tKTwisting,
        T tKFriction,
        T tKContact,
        T tKGravity,
        const char * head   // Head Type (read from file)
    );
    //*/
    //-------------------------------------------------------------------------
    // Destructor
    virtual ~ModelLaparoscopicAdjustableGastricBand ();
    //-------------------------------------------------------------------------
    //-------------------------------------------------------------------------
    // Abstract Virtual Fn(s) from Model<T>
    virtual void Initialize () {};
    //-------------------------------------------------------------------------
    // Abstract Virtual Fn(s) from ColDetSupport<T>
    // Collision Detection Fn(s)
    virtual void CalBoundingAABB ()         {};
    virtual void CalBoundingEllipsoid ()    {};
    virtual void CalBoundingSphere ()       {};
    //-------------------------------------------------------------------------
    // Get/Set Fn(s)
    inline bool GetFixStatusOfPtNo ( int i ) 
    {
        if ( 0 <= i && i <= m_iNoLinks ) {
            return ModelStrand<T>::GetFixStatusOfPtNo( i );
        }
        else {
            return false;
        }
    }
    inline void SetFixStatusOfPtNo ( int i, bool b )
    {
        if ( 0 <= i && i <= m_iNoLinks ) {
            ModelStrand<T>::SetFixStatusOfPtNo( i, b );
            //m_prIsFixed[i] = b;
        }
        else {
            ModelStrand<T>::SetFixStatusOfPtNo( 0, b );
            //m_prIsFixed[0] = b;   // connected to head
        }
    }
    inline void ToggleFixStatusOfPtNo ( int i )
    {
        if ( 0 <= i && i <= m_iNoLinks ) {
            ModelStrand<T>::ToggleFixStatusOfPtNo( i );
            //m_prIsFixed[i] = !m_prIsFixed[i];
        }
        else    {};
    };
    inline virtual int  GetNumberOfLinks () 
        { return m_iNoLinks /*+ m_iNoPickPts*/; }
    inline virtual int  GetNumberOfLinksWithoutHeadAndTail ()   
        { return m_iNoLinks; }
    inline virtual Vector3<T> GetPointPosition ( int i ) const;
    inline virtual void SetPointPosition ( 
        int i, const Vector3<T> & position );
    inline virtual void SetPointPosition ( 
        int i, const Vector3<T> & position, Matrix3x3<T> & rotation, 
        //T tMoveDistanceLimit = 100, 
        MultiBoundingVolume<T> const * const pMBV = NULL, 
        TransformationSupport<T> const * const pTransform = NULL
    );
protected:
    inline virtual Vector3<T> GetHeadPosition ( int i ) const;
    inline virtual void SetHeadPosition ( 
        int i, const Vector3<T> & position, Matrix3x3<T> & rotation );
    //----------------------------------------------------------------
    // User adjustable parameters
    //----------------------------------------------------------------
    // Collision Detection
    //----------------------------------------------------------------
    //=========================================================================
    // Helper Fn(s)
    //================================================================
    // For Simulation
    //----------------------------------------------------------------
protected:
    //----------------------------------------------------------
    // REMARK:  DxDt has to be static so that we can pass it to 
    // ODESolver Fn.
    // But we don't want StateToArray and ArrayToState be static.
    // Therefore, we need to pass userData, i.e. this pointer
    // as a void pointer.
    static bool DxDt (  
        T dt,                           // i/p: time step
        Simulation::VectorSet<T> &x,    // i/p: array  x = {pos, vel}
        Simulation::VectorSet<T> &xdot, // o/p: array xdot = {vel, accel}
        void *userData                  // o/p: array of user data
    );
    //----------------------------------------------------------
    void StateToArray ( T *dst );       // copy Suture states to dst array
    void ArrayToState ( T *src );       // copy src array to Suture states
    void DdtStateToArray ( T *xdot, T dt ); // copy d/dt Suture states to dst (xdot) array
    //void ClearForces ();  // clear (all) forces (and maybe velocities too)
public:
    void AdvanceSimulation ( T tCurrent, T tNext );
    void AdvanceSimulation ( Simulation::SimClock<T> & simClock );
    //----------------------------------------------------------------
    /*
    // Move the vertex # i by vector u
    void MoveVertexNo ( int i, Vector3<T> & u );
    //----------------------------------------------------------------
    // Twist the vertex i for deg degrees
    void TwistVertexNo ( int i, Real deg );
    //----------------------------------------------------------------
    // Move and Twist the vertex # i by vector u and deg respectively
    void MoveAndTwistVertexNo ( int i, Vector3<T> & u, Real deg );
    */
    //----------------------------------------------------------------
    // Collision Detection
    virtual bool TestOverlapWith ( BVHTree<T> const * const that );
    //----------------------------------------------------------------
    // Collision Detection For Head and Tail
//  BVHTree<T> * GetBVHTreeHead () // use sphere node for BVHTree
//      { return m_pHead->GetBVHTree(); }
    //BVHTree<T> * GetBVHTreeTail () // use sphere node for BVHTree
    //  { return m_pTail->GetBVHTree(); }
protected:
    //----------------------------------------------------------------
    // Collision Detection For Head and Tail
    void RecordHeadBVHNodeCenters ();
    void RestoreHeadBVHNodeCenters ();
    void RotateHeadBVHNodeCenters ();
public:
    //-------------------------------------------------------------------------
    // Collided Nodes (DEBUG)
    virtual std::vector< BVHNode<T> * > & GetListOfCollidedNodes()      { return m_svCollidedNode; }
    virtual std::vector< BVHNode<T> * > & GetListOfCollidedNodesThat()  { return m_svCollidedNodeThat; }
protected:
    std::vector< BVHNode<T> * > m_svCollidedNode;       // DEBUG
    std::vector< BVHNode<T> * > m_svCollidedNodeThat;   // DEBUG
    //----------------------------------------------------------------
//=============================================================================
// Data Members ---------------------------------------------------------------
protected:
    //----------------------------------------------------------------
    // For Head Positions
    // Use Sphere Bounding Volume Center for the positions of pick points
    // With the current head model, recommend to use level 2 (4 spheres) 
    // thru level 4 (16 spheres).  We use level 4.
    //int               m_iLevel;       // level number
    //int               m_iNoPickPts;   // # of Pick Points (n * 2)
                                    // [0] index for head
                                    // [1] index for tail
                                    // odd  number for tail
    //Vector3<T> ** m_prPickPts;    // pointer to pick points
    //bool *            m_prbIsSharp;       // identify whether the (pickable) head pt is sharp
    //int               m_iHeadSharpPt;     // Head's sharp point is one of the pickable points
                                            // where m_prbIsSharp must be true
    //std::vector<int>  m_iSharpPts;        // sharp pts of head
    //Vector3<T>        m_vTransForHead;    // translation matrix for head
    //Matrix3x3<T>  m_mRotMatForHead;       // rotation matrix for head
public:
    TransformationSupport<T> &  GetHeadTransform()  { return m_pHead->GetTransform(); }
    //TransformationSupport<T> &    GetTailTransform()  { return m_pTail->GetTransform(); }
    //----------------------------------------------------------------
protected:
    MultiMeshModelWithMBV<T> *  m_pHead;
    //OpenGLHalfEdgeModel<T> *  m_pHead;
    //OpenGLHalfEdgeModel<T> *  m_pTail;
protected:
    void InitHead ();
    void InitHead ( const char * head );
    //void InitHeadPickPts ();
    //void InitHeadPickPts ( BVHNode<T> ** node, int level );
    //void SetHeadPickPts ();
    //void InitHeadSharpPts ();

    void SetHeadPosition ();

    //*/
    //----------------------------------------------------------------
    // Material Properties
    /*
    T               m_tKstretch;    // stretch allowed
    T               m_tKstiff;      // anti-bending
    T               m_tKfriction;   // surface friction/sticky
    T               m_tKfollow;     // how much follower follows leader
                                    // 0 means follow 100%
                                    // 1 means rigid follower
    //*/
protected:
    //----------------------------------------------------------------
public:
    void SetupShape ( Vector3<T> startPosition );
protected:
    //================================================================
    // For simulation
    //----------------------------------------------------------------
    Simulation::ODESolver<T> *  m_prODESolver;  // ODE solver
    Simulation::VectorSet<T> x0;                // #m_iStateSize
    Simulation::VectorSet<T> xEnd;              // #m_iStateSize
    int m_iStateSize;   // (#Links + 1) * 6
            // where 6 = 3 positions + 3 velocities (for x,y,z)
    int m_iLimitStepCount;
    //----------------------------------------------------------------
    // Physical Forces
    struct StructForce {
        Vector3<T> gravity;     // gravity force
        //Vector3<T> antiBending;   // anti-bending force
    };
    //----------------------------------------------------------------
    // Collision Detection
    struct CollisionNodePairID {
        int id1;
        int id2;
    };

public:
    T GetKfollow () { return 1; }
    T GetKstiff () { return 1; }
    void SetKfollow ( T v ) {}
    void SetKstiff ( T v ) {}
protected:
//-----------------------------------------------------------------------------
}; // CLASS END: ModelLaparoscopicAdjustableGastricBand ***********************
//=============================================================================
END_NAMESPACE_TAPs__OpenGL
//-----------------------------------------------------------------------------
#include "TAPsModelLaparoscopicAdjustableGastricBand.cpp"
//-----------------------------------------------------------------------------
#endif
//34567890123456789012345678901234567890123456789012345678901234567890123456789
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----