mitkTetra.h

/*=========================================================================

  Program:   3DMed
  Date:      $Date: 2014-02-25 18:30:00 +0800 $
  Version:   $Version: 4.6.0 $
  Copyright: MIPG, Institute of Automation, Chinese Academy of Sciences

=========================================================================*/


#ifndef _mitkTetra_h
#define _mitkTetra_h

#include "mitkDataObject.h"
//ÐèÒªÔÚmitkGlobal.hÖÐÌí¼Ó  #define MITK_TETRA                      4000

//ÖØж¨ÒåÀàÐÍ£¬¸ÃÀàÐÍΪ±äÁ¿ËùÖ¸ÏòµÄÄÚÈݲ»Äܸü¸Ä
typedef  const float (*TetraVertex)[3];
typedef  const int (*TetraTet)[4];
typedef  const int (*TetraQtet)[6];
typedef  const int (*TetraTetNei)[4];

//ÔÚÀàÃûÇ°¼ÓÉÏMITK_COMMON_API
class  mitkTetra : public mitkDataObject
{
public:

   MITK_TYPE(mitkTetra,mitkDataObject);

   virtual void PrintSelf(ostream& os);

    virtual void Initialize();

    virtual int GetDataObjectType() const {return MITK_TETRA;}

  virtual unsigned long long GetActualMemorySize() const;

  virtual void ShallowCopy(mitkDataObject *src);

  virtual void DeepCopy(mitkDataObject *src);

  mitkTetra();
  

  bool SetVertexN(int vN)   
  { 
      if(vN < 1)
          return false;//²ÎÊý·Ç·¨
      m_VertexN = vN; 
      m_Vertex = new float[vN][3]; 
      return true;
  }

   int GetVertexN() const   {   return m_VertexN; }

  bool SetTetN(int tN);
  int GetTetN() const { return m_TetN; }

  bool SetQtetN(int tN);

  void SetVertex(int i, float v[3]);
  TetraVertex GetVertex() const { return m_Vertex; }
  void GetVertex( int i,float v[3] ) const;

  void SetTet(int i, int t[4]);
  TetraTet GetTet() const { return m_Tet;}
  void GetTet(int i, int t[4] );
  
  void SetQtet(int i, int qt[6]);
  TetraQtet GetQtet() const { return m_Qtet; }
  void GetQtet(int i, int qt[6])  const;
  
  bool SetMaxId(int n);
  unsigned char GetMaxId() const { return m_MaxId; }
  void GetVisId(bool visid[]) const;
   
  void GetVisible(bool vis[]) const;

  TetraTetNei GetTetNei() const { return m_TetNei; }
  void GetTetNei( int i, int tn[4] ) const;
  
  void SetId(int i, int m)      {   m_Id[i] = m;    }
  void GetId(unsigned char m_Id[]) const;

  inline int CountId(int t) {   return m_IdN[t];        }
  void GetIdN(int m_IdN[]) const;

  void DoneSetting()        {   ComputeNeighbor();  }
  
  void NormalizeBox(float max_size);
  
  void UpdateVisible();
  
  float VolDiff(int i);
  static  inline void AreaNormal(float n[3],float p0[3], float p1[3], float p2[3])
 {
    float a[3], b[3];
    Vector(a, p0, p1);
    Vector(b, p0, p2);
    n[0] = a[1]*b[2] - a[2]*b[1];
    n[1] = a[2]*b[0] - a[0]*b[2];
    n[2] = a[0]*b[1] - a[1]*b[0];
  };
  
  static inline bool Normalize(float e[3], float a[3])
{
    double l = sqrt(a[0]*a[0] + a[1]*a[1] + a[2]*a[2]);
    if((float)l != 0)
    {
      e[0] = (float)(a[0]/l);
      e[1] = (float)(a[1]/l);
      e[2] = (float)(a[2]/l);
      return true;
    }
    else
      return false;
  }
  //vector pq
  static inline void Vector(float v[3], float p[3], float q[3])
{
    v[0] = q[0] - p[0];
    v[1] = q[1] - p[1];
    v[2] = q[2] - p[2];
  }

  float GetClipX1 () const { return m_ClipX1; }
  float GetClipX2 () const { return m_ClipX2; }
  float GetClipY1 () const { return m_ClipY1; }
  float GetClipY2 () const { return m_ClipY2; }
  float GetClipZ1 () const { return m_ClipZ1; }
  float GetClipZ2 () const { return m_ClipZ2; }

  void GetMinB (float min_b[]) const
  {
      min_b[0] = m_MinB[0];
      min_b[1] = m_MinB[1];
      min_b[2] = m_MinB[2];
  }

  void GetMaxB (float max_b[]) const
  {
      max_b[0] = m_MaxB[0];
      max_b[1] = m_MaxB[1];
      max_b[2] = m_MaxB[2];
  }

protected:
    
    virtual ~mitkTetra();
    //the number of vertices
  int m_VertexN;
  //the coordinates of vertices
  float (*m_Vertex)[3];
  //the number of elements
  int m_TetN;
  //indecies of elements
  int (*m_Tet)[4];
  int (*m_Qtet)[6];
  //the number of materials
  unsigned char m_MaxId;
  int* m_IdN;
  //material ID for elements
  unsigned char *m_Id;
  //neighbor for each face of an element
  int (*m_TetNei)[4];
  //visible or not by clipping
  bool *m_Visible;
  //visible material ID
  bool *m_VisId;
  //Bounding box
  float m_ClipX1, m_ClipX2;
  float m_ClipY1, m_ClipY2;
  float m_ClipZ1, m_ClipZ2;
  float m_MinB[3], m_MaxB[3];

  void ComputeNeighbor();
  inline float Volume(int i);

 private:
  mitkTetra(const mitkTetra&);
  void operator=(const mitkTetra&);
};

#endif

---