TAPsModelSutureMath.hpp

Go to the documentation of this file.

/*******************************************************************************
TAPsModelSutureMath.hpp

A two-headed needle suture

SUKITTI PUNAK   (01/30/2006)
UPDATE          (06/15/2006)
*******************************************************************************/
#ifndef TAPs_SUTURE_MATH_MODEL_HPP
#define TAPs_SUTURE_MATH_MODEL_HPP

#include <TAPs/OpenGLModelFromFile/TAPsReadModels.hpp>
#include "TAPsModelStrandMath.hpp"

BEGIN_NAMESPACE_TAPs__OpenGL
//==============================================================================
template <typename T>
class ModelSutureMath : public /*virtual*/ ModelStrandMath<T> {
    //-------------------------------------------------------------------------
    // (Friend Fn) put it through ostream
    friend std::ostream & operator<< ( std::ostream &output, ModelSutureMath<T> const &o )
    {
        output  << "\n======================\n"
                <<   "TAPs::ModelSutureMath<"
                << 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)
    ModelSutureMath ();
    ModelSutureMath ( 
        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
    );
    ModelSutureMath ( 
        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 * needle1    // Needle Type (read from file)
    );
    ModelSutureMath ( 
        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 * needle1    // Needle Type (read from file)
    );
    //-------------------------------------------------------------------------
    // Destructor
    virtual ~ModelSutureMath ();
    //-------------------------------------------------------------------------
    //-------------------------------------------------------------------------
    // 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 ModelStrandMath<T>::GetFixStatusOfPtNo( i );
        }
        else {
            return false;
        }
    }
    inline void SetFixStatusOfPtNo ( int i, bool b )
    {
        if ( 0 <= i && i <= m_iNoLinks ) {
            ModelStrandMath<T>::SetFixStatusOfPtNo( i, b );
            //m_prIsFixed[i] = b;
        }
        else {
            ModelStrandMath<T>::SetFixStatusOfPtNo( 0, b );
            //m_prIsFixed[0] = b;   // connected to head needle
        }
    }
    inline void ToggleFixStatusOfPtNo ( int i )
    {
        if ( 0 <= i && i <= m_iNoLinks ) {
            ModelStrandMath<T>::ToggleFixStatusOfPtNo( i );
            //m_prIsFixed[i] = !m_prIsFixed[i];
        }
        else    {};
    };
    inline virtual int  GetNumberOfLinks () 
        { return m_iNoLinks + m_iNoPickPts; }
    inline virtual int  GetNumberOfLinksWithoutHeadNeedle ()    
        { 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> GetNeedlesPosition ( int i ) const;
    inline virtual void SetNeedlesPosition ( 
        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 Needle(s)
    BVHTree<T> * GetBVHTreeNeedleLeft () // use sphere node for BVHTree
        { return m_pNeedleLeft->GetBVHTree(); }
    //BVHTree<T> * GetBVHTreeNeedleRight () // use sphere node for BVHTree
    //  { return m_pNeedleRight->GetBVHTree(); }
protected:
    //----------------------------------------------------------------
    // Collision Detection For Needle(s)
    void RecordNeedleBVHNodeCenters ();
    void RestoreNeedleBVHNodeCenters ();
    void RotateNeedleBVHNodeCenters ();
//==============================================================================
// Data Members ----------------------------------------------------------------
protected:
    //----------------------------------------------------------------
    // For Needles Positions
    // Use Sphere Bounding Volume Center for the positions of pick points
    // With the current needle 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) for 2 needles
                                    // even number for left  needle
                                    // odd  number for right needle
    Vector3<T> **   m_prPickPts;    // pointer to pick points
    bool *          m_prbIsSharp;   // identify whether the (pickable) needle pt is sharp
    int             m_iNeedleSharpPt;   // Needle sharp point is one of the pickable points
                                        // where m_prbIsSharp must be true
    //std::vector<int>  m_iSharpPts;    // sharp pts of needle
    //Vector3<T>        m_vTransForLeftNeedle;      // translation matrix for left needle
    //Matrix3x3<T>  m_mRotMatForLeftNeedle;     // rotation matrix for left needle
public:
    TransformationSupport<T> &  GetLeftNeedleTransform()    { return m_pNeedleLeft->GetTransform(); }
    //----------------------------------------------------------------
protected:
    OpenGLHalfEdgeModel<T> *    m_pNeedleLeft;
    //OpenGLHalfEdgeModel<T> *  m_pNeedleRight;
protected:
    void InitNeedles ();
    void InitNeedles ( const char * needle1 );
    void InitNeedlesPickPts ();
    void InitNeedlesPickPts ( BVHNode<T> ** node, int level );
    void SetNeedlesPickPts ();
    void InitNeedlesSharpPts ();
    //*/
    //----------------------------------------------------------------
    // 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
    //*/
    /*
    //----------------------------------------------------------------
    // Shape memory by cubic Bezier control points
    // -------------------------------------------
    // p^i_0, p^i_1, p^i_2, p^i_3 = p^(i+1)_0, p^(i+1)_1, ... 
    // Contain points that define the strand shape
    //
    //                             P7_________P8
    //                              /         \
    //     P1________P2            /           \ 
    //      /        \          P6/             \P9
    //     /          \P3        /               \
    //    /            \________/                 \
    //   /             P4      P5                  \_________...
    //  P0                                        P10
    std::set< Vector3<T> > m_setvD3BezierMemShape;
    std::set< int > m_setiD3BezierMemShape;
    void InitShapeMemory ();
    void ConformToShapeMemory ();
    //*/
protected:
    //----------------------------------------------------------------
    // Shape Memory
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: ModelSutureMath  **************************************************
//==============================================================================
END_NAMESPACE_TAPs__OpenGL
//------------------------------------------------------------------------------
// Include definition if TAPs_USE_EXPORT is not defined
//#if !defined( TAPs_USE_EXPORT )
    #include "TAPsModelSutureMath.cpp"
//#endif
//------------------------------------------------------------------------------
#endif
//345678901234567890123456789012345678901234567890123456789012345678901234567890
//--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8