mitkMesh.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 __mitkMesh_h
#define __mitkMesh_h

#include "mitkDataObject.h"
#include "mitkGeometryTypes.h"

class MITK_COMMON_API mitkMesh : public mitkDataObject
{
public:
    MITK_TYPE(mitkMesh, mitkDataObject)

    virtual void PrintSelf(ostream &os);

    virtual void Initialize();

    virtual void ShallowCopy(mitkDataObject *src);

    virtual void DeepCopy(mitkDataObject *src);

    bool CopyMesh(mitkMesh *src);

    virtual int GetDataObjectType() const { return MITK_MESH; }

    virtual void SetVertexNumber(size_type number) = 0;

    virtual size_type GetVertexNumber() const = 0;

    virtual void SetFaceNumber(size_type number) = 0;

    virtual size_type GetFaceNumber() const = 0;

    virtual float* GetVertexData() = 0;

    virtual index_type* GetFaceData() = 0;

    float const * GetBoundingBox() { return m_BoundingBox; }

    void GetBoundingBox(float &minX, float &maxX, float &minY, float &maxY, float &minZ, float &maxZ);

    void GetBoundingBox(float bounds[6]);

    void SetBoundingBox(float minX, float maxX, float minY, float maxY, float minZ, float maxZ);

    void SetBoundingBox(float bounds[6]);

    bool IsNormalReversed() const { return m_IsNormalReversed; }

    bool IsClockwise() const { return m_IsClockwise; }

    void SetClockwise(bool isClockwise = true) { m_IsClockwise = isClockwise; }

    virtual bool TestClockwise() = 0;

    virtual void ReverseNormals() {};

    index_type AddVertex(Vertex3f &vert) { return this->_addVertex(vert); }
    
    template <typename IndexType, unsigned int indexNum>
    index_type AddFace(_face_type<IndexType, indexNum> &face) { return this->_addFace(face.vertNum, face.verts); }

    index_type AddFace(TriangleFace &face) { return this->_addFace(face.vertNum, face.verts); }

    bool GetVertex(index_type vertIdx, Vertex3f &vert)
    {
        if (vertIdx<0 || vertIdx>=this->GetVertexNumber()) return false;
        Vertex3f const *v = this->_getVertex(vertIdx);
        if (v==NULL) return false;
        vert = *v; return true;
    }

    size_type GetVertices(index_type startIdx, size_type num, Vertex3f *verts)
    {
        if (startIdx<0 || startIdx>=this->GetVertexNumber()) return 0;
        return this->_getVertices(startIdx, num, verts);
    }

    template <typename IndexType, unsigned int indexNum>
    bool GetFace(index_type faceIdx, _face_type<IndexType, indexNum> &face)
    {
        if (faceIdx<0 || faceIdx>=this->GetFaceNumber()) return false;
        index_type const *vi = this->_getFace(faceIdx);
        if (vi==NULL) return false;
        for (int i=0; i<face.vertNum; ++i) face.verts[i] = vi[i];
        return true;
    }

    bool GetFace(index_type faceIdx, TriangleFace &face)
    {
        if (faceIdx<0 || faceIdx>=this->GetFaceNumber()) return false;
        index_type const *vi = this->_getFace(faceIdx);
        if (vi==NULL) return false;
        face.verts[0] = vi[0];
        face.verts[1] = vi[1];
        face.verts[2] = vi[2];
        return true;
    }

    size_type GetTriangleFaces(index_type startIdx, size_type num, TriangleFace *faces)
    {
        if (startIdx<0 || startIdx>=this->GetFaceNumber()) return 0;
        return this->_getTriangleFaces(startIdx, num, faces);
    }

    size_type GetTriangleFaces(index_type startIdx, size_type num, Vertex3f *verts)
    {
        if (startIdx<0 || startIdx>=this->GetFaceNumber()) return 0;
        return this->_getTriangleFaces(startIdx, num, verts);
    }

    bool SetVertex(index_type vertIdx, Vertex3f const &vert)
    {
        if (vertIdx<0 || vertIdx>=this->GetVertexNumber()) return false;
        Vertex3f *v = this->_getVertexForWrite(vertIdx);
        if (v==NULL) return false;
        *v = vert; return true;
    }

    template <typename IndexType, unsigned int indexNum>
    bool SetFace(index_type faceIdx, _face_type<IndexType, indexNum> &face) 
    { 
        if (faceIdx<0 || faceIdx>=this->GetFaceNumber()) return false;
        return this->_setFace(faceIdx, face.vertNum, face.verts);
    }

    bool SetFace(index_type faceIdx, TriangleFace &face)
    {
        if (faceIdx<0 || faceIdx>=this->GetFaceNumber()) return false;
        return this->_setFace(faceIdx, face.vertNum, face.verts);
    }

protected:
    enum Orientation { CLOCKWISE, ANTICLOCKWISE, DEGENERATIVE };

    mitkMesh();
    virtual ~mitkMesh();

    virtual index_type _addVertex(Vertex3f &vert) = 0;
    virtual index_type _addFace(unsigned int num, index_type *verts) = 0;
    virtual Vertex3f const* _getVertex(index_type vertIdx) = 0;
    virtual index_type const* _getFace(index_type faceIdx) = 0;
    virtual Vertex3f* _getVertexForWrite(index_type vertIdx) = 0;
    virtual index_type* _getFaceForWrite(index_type faceIdx) = 0;

    // default version, should be overrided in out-of-core mesh
    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);
    virtual bool _setFace(index_type faceIdx, unsigned int num, index_type *verts);

    float m_BoundingBox[6];
    bool  m_IsClockwise;
    bool  m_IsNormalReversed;

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

};

inline void mitkMesh::GetBoundingBox(float &minX, float &maxX, float &minY, float &maxY, float &minZ, float &maxZ)
{
    minX = m_BoundingBox[0];
    maxX = m_BoundingBox[1];
    minY = m_BoundingBox[2];
    maxY = m_BoundingBox[3];
    minZ = m_BoundingBox[4];
    maxZ = m_BoundingBox[5];
}

inline void mitkMesh::GetBoundingBox(float bounds[6])
{ this->GetBoundingBox(bounds[0], bounds[1], bounds[2], bounds[3], bounds[4], bounds[5]); }

inline void mitkMesh::SetBoundingBox(float minX, float maxX, float minY, float maxY, float minZ, float maxZ)
{
    m_BoundingBox[0] = minX;
    m_BoundingBox[1] = maxX;
    m_BoundingBox[2] = minY;
    m_BoundingBox[3] = maxY;
    m_BoundingBox[4] = minZ;
    m_BoundingBox[5] = maxZ;
}

inline void mitkMesh::SetBoundingBox(float bounds[6])
{ this->SetBoundingBox(bounds[0], bounds[1], bounds[2], bounds[3], bounds[4], bounds[5]); }


//#define DEFINED_mitkMesh



#endif

---