mitkHEICTriangleMesh.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 __mitkHEICTriangleMesh_h
#define __mitkHEICTriangleMesh_h

#include "mitkHETriangleMesh.h"

class MITK_COMMON_API mitkHEICTriangleMesh : public mitkHETriangleMesh
{
public:
    MITK_TYPE(mitkHEICTriangleMesh, mitkHETriangleMesh)

    virtual void PrintSelf(ostream &os);

    mitkHEICTriangleMesh();

    virtual int GetDataObjectType() const { return MITK_HE_IC_TRIANGLE_MESH; }

    virtual void Initialize();

    virtual unsigned long long GetActualMemorySize() const;

    virtual void ShallowCopy(mitkDataObject *src);

    virtual void DeepCopy(mitkDataObject *src);

    virtual void SetVertexNumber(size_type number);

    virtual void SetFaceNumber(size_type number);

    virtual Vertex& GetVertex(VertexHandle v) const
    { assert(this->IsValid(v)); return m_Vertices[v.Idx()]; }

    virtual Edge& GetEdge(EdgeHandle e) const
    { assert(this->IsValid(e)); return m_Edges[e.Idx()]; }

    virtual Edge& GetEdge(HalfEdgeHandle he) const
    { assert(this->IsValid(he)); return m_Edges[(he.Idx()>>1)]; }

    virtual HalfEdge& GetHalfEdge(HalfEdgeHandle he) const
    { assert(this->IsValid(he)); return m_Edges[he.Idx()>>1].halfEdge[he.Idx()%2]; }

    virtual Face& GetFace(FaceHandle f) const
    { assert(this->IsValid(f)); return m_Faces[f.Idx()]; }

    virtual VertexHandle GetHandle(Vertex const &vert) const
    { return VertexHandle(&vert-m_Vertices); }

    virtual EdgeHandle GetHandle(Edge const &edge) const
    { return EdgeHandle(&edge-m_Edges); }

    virtual HalfEdgeHandle GetHandle(HalfEdge const &he) const
    { return this->PairHalfEdge(he.pairHalfEdge); }

    virtual FaceHandle GetHandle(Face const &face) const
    { return FaceHandle(&face-m_Faces); }

    virtual float* GetVertexData();

    virtual index_type* GetFaceData();

    void ClearTempVertArray();

    void ClearTempFaceArray();

protected:
    virtual ~mitkHEICTriangleMesh();
    
    virtual size_type _getVertices(index_type startIdx, size_type num, Vertex3f *verts);
    virtual size_type _getTriangleFaces(index_type startIdx, size_type num, TriangleFace *faces);
    virtual size_type _getTriangleFaces(index_type startIdx, size_type num, Vertex3f *verts);

    // Actual method for adding Vertex/Edge/Face.
    // Memory allocation will be done here.
    virtual VertexHandle   _addNewVertex(float x,         float y,         float z, 
                                         float nx = 0.0f, float ny = 0.0f, float nz = 0.0f,
                                         HalfEdgeHandle edge = HalfEdgeHandle());
    virtual HalfEdgeHandle _addNewEdge(VertexHandle start, VertexHandle end);
    virtual FaceHandle     _addNewFace(HalfEdgeHandle halfedge = HalfEdgeHandle());
    
    // Helper for clearing garbage.
    virtual void _clearDeletedVertices();
    virtual void _clearDeletedEdges();
    virtual void _clearDeletedFaces();

    
    size_type m_Increment;

    Vertex *m_Vertices;
    Edge *m_Edges;
    Face *m_Faces;

    // for compatible with mitkTriangleMesh which is used frequently
    Vertex3f *m_VertArray;
    TriangleFace *m_FaceArray;

private:
    mitkHEICTriangleMesh(const mitkHEICTriangleMesh&);
    void operator = (const mitkHEICTriangleMesh&);

};


#endif

---