mitkHEMesh Class Reference

mitkHEMesh - a concrete class for polygon meshes represented by Half Edges More...

#include <mitkHEMesh.h>

Inherits mitkMesh.

Inherited by mitkHETriangleMesh.

Inheritance diagram for mitkHEMesh:

[legend]Collaboration diagram for mitkHEMesh:

[legend]List of all members.

Public Types
typedef VertexVertexIterT< mitkHEMesh >	VertexVertexIterator
typedef VertexOHalfedgeIterT< mitkHEMesh >	VertexOHalfedgeIterator
typedef VertexIHalfedgeIterT< mitkHEMesh >	VertexIHalfedgeIterator
typedef VertexEdgeIterT< mitkHEMesh >	VertexEdgeIterator
typedef VertexFaceIterT< mitkHEMesh >	VertexFaceIterator
typedef FaceVertexIterT< mitkHEMesh >	FaceVertexIterator
typedef FaceHalfedgeIterT< mitkHEMesh >	FaceHalfedgeIterator
typedef FaceEdgeIterT< mitkHEMesh >	FaceEdgeIterator
typedef FaceFaceIterT< mitkHEMesh >	FaceFaceIterator
typedef VertexIterT< mitkHEMesh >	VertexIterator
typedef EdgeIterT< mitkHEMesh >	EdgeIterator
typedef FaceIterT< mitkHEMesh >	FaceIterator
Public Member Functions
virtual void	PrintSelf (ostream &os)
	mitkHEMesh ()
virtual int	GetDataObjectType () const
virtual void	Initialize ()
virtual void	ShallowCopy (mitkDataObject *src)
virtual void	DeepCopy (mitkDataObject *src)
virtual size_type	GetVertexNumber () const
virtual size_type	GetFaceNumber () const
size_type	GetEdgeNumber () const
void	ClearGarbage ()
VertexHandle	AddVertex (Vertex const &vert)
VertexHandle	AddVertex (Point3f const &point, Point3f const &normal)
VertexHandle	AddVertex (float x, float y, float z, float nx=0.0f, float ny=0.0f, float nz=0.0f)
VertexHandle	AddVertex (float v[6])
FaceHandle	AddFace (unsigned int n, VertexHandle *vertices)
void	DeleteVertex (VertexHandle vert)
void	DeleteEdge (EdgeHandle edge, bool deleteIsolatedVertices)
void	DeleteFace (FaceHandle face, bool deleteIsolatedVertices)
HalfEdgeHandle	FindHalfEdge (VertexHandle vert0, VertexHandle vert1)
bool	IsBoundary (HalfEdgeHandle halfedge) const
bool	IsBoundary (VertexHandle vert) const
bool	IsBoundary (EdgeHandle edge) const
bool	IsManifold (VertexHandle vert)
virtual Vertex &	GetVertex (VertexHandle v) const =0
virtual Edge &	GetEdge (EdgeHandle e) const =0
virtual Edge &	GetEdge (HalfEdgeHandle he) const =0
virtual HalfEdge &	GetHalfEdge (HalfEdgeHandle he) const =0
virtual Face &	GetFace (FaceHandle f) const =0
virtual VertexHandle	GetHandle (Vertex const &vert) const =0
virtual EdgeHandle	GetHandle (Edge const &edge) const =0
virtual HalfEdgeHandle	GetHandle (HalfEdge const &he) const =0
virtual FaceHandle	GetHandle (Face const &face) const =0
EdgeHandle	GetEdgeHandle (HalfEdgeHandle he) const
HalfEdgeHandle	PairHalfEdge (HalfEdgeHandle he) const
HalfEdgeHandle	NextHalfEdge (HalfEdgeHandle he) const
HalfEdgeHandle	PrevHalfEdge (HalfEdgeHandle he) const
VertexHandle	EndVertex (HalfEdgeHandle he) const
FaceHandle	AdjFace (HalfEdgeHandle he) const
HalfEdgeHandle	OutHalfEdge (VertexHandle v) const
HalfEdgeHandle	OneHalfEdge (FaceHandle f) const
bool	IsValid (VertexHandle v) const
bool	IsValid (EdgeHandle e) const
bool	IsValid (HalfEdgeHandle he) const
bool	IsValid (FaceHandle f) const
size_type	GetValidVertexNumber () const
size_type	GetValidEdgeNumber () const
size_type	GetValidFaceNumber () const
virtual bool	TestClockwise ()
void	ClearFlags ()

---

Detailed Description

mitkHEMesh - a concrete class for polygon meshes represented by Half Edges

mitkHEMesh is a concrete class for polygon meshes which are represented by Half Edge Type. This implementation of half edge references to OpenMesh written by Computer Graphics Group, RWTH Aachen.

Some Structs Used in this Class

HEVertex

Besides the point coordinates and normal of the vertex, Vertex struct also contains the handle of outgoing half edge. It is defined as follows:

    struct HEVertex : public _flag_base
    {
        union
        {
            Vertex3f vert;
            struct 
            {
                Point3f point;
                Point3f normal;
            };
        };
        HEHalfEdgeHandle outHalfEdge; // handle of outgoing half edge   
    };

HEHalfEdge

It contains the handles of its end vertex, opposite half edge, next half edge, previous half edge and adjacent face. It is defined as follows:

    struct HEHalfEdge
    {
        HEVertexHandle endVertex;      // handle of end vertex
        HEHalfEdgeHandle pairHalfEdge; // handle of opposite half edge
        HEHalfEdgeHandle nextHalfEdge; // handle of next half edge
        HEHalfEdgeHandle prevHalfEdge; // handle of previous half edge
        HEFaceHandle face;
    };

HEEdge

It contains two opposite half edges, defined as follows:

    struct HEEdge : public _flag_base
    {
        HEHalfEdge halfEdge[2];
    };

HEFace

It contains the handle of one of its half edges, defined as follows:

    struct _face : public _flag_base
    {
        HEHalfEdgeHandle oneHalfEdge; // handle of one half edge
    };

Furthermore, HEVertex, HEEdge and HEFace are all derived from _flag_base, which provides a set of methods to make some special marks on these items when processing a mitkHEMesh in your algorithm. You can make and unmake 31 different marks from ``flag0'' to ``flag30'' through the methods _flag_base::SetFlag(FLAGS f) and _flag_base::UnSetFlag(FLAGS f), and test these flags through the method _flag_base::GetFlag(FLAGS f). _flag_base::SetDeleted(bool del=true) is reserved by MITK, which means some procedures inside MITK will make ``delete'' marks after deleting some items. You can test if an item is deleted by MITK through the method _flag_base::IsDeleted().

Handles

Handles including HEVertexHandle, HEHalfEdgeHandle, HEEdgeHandle and HEFaceHandle are encapsulations of index. Methods in mitkHEMesh use handles to deal with items instead of using indices directly. You can get index from a handle through the method *HandleIdx(), and test a handle's validation through the method *HandleIsValid().

The detailed definition can be found in mitkHalfEdgeStructures.h and mitkGeometryTypes.h.

---

Member Typedef Documentation

typedef EdgeIterT<mitkHEMesh> mitkHEMesh::EdgeIterator

EdgeIterator is an iterator class for iterating over all edges of a mitkHEMesh object. The code snippet for using this class: // mesh is a pointer to an object of mitkHEMesh mitkHEMesh::EdgeIterator iter(mesh); for ( ; iter; ++iter) { // iter is the pointer to current edge // *iter is the reference to current edge // iter.Handle() returns the handle of current edge do something with iter, *iter or iter.Handle(); }

typedef FaceEdgeIterT<mitkHEMesh> mitkHEMesh::FaceEdgeIterator

FaceEdgeIterator is an iterator class for iterating over a face's edges. The code snippet for using this class: // mesh is a pointer to an object of mitkHEMesh // center is the handle of the face mitkHEMesh::FaceEdgeIterator iter(mesh, center); for ( ; iter; ++iter) { // iter is the pointer to current edge // *iter is the reference to current edge // iter.Handle() returns the handle of current edge do something with iter, *iter or iter.Handle(); }

typedef FaceFaceIterT<mitkHEMesh> mitkHEMesh::FaceFaceIterator

FaceFaceIterator is an iterator class for iterating over a face's all edge-neighboring faces. The code snippet for using this class: // mesh is a pointer to an object of mitkHEMesh // center is the handle of the face mitkHEMesh::FaceFaceIterator iter(mesh, center); for ( ; iter; ++iter) { // iter is the pointer to current edge-neighboring face // *iter is the reference to current edge-neighboring face // iter.Handle() returns the handle of current edge-neighboring face do something with iter, *iter or iter.Handle(); }

typedef FaceHalfedgeIterT<mitkHEMesh> mitkHEMesh::FaceHalfedgeIterator

FaceHalfedgeIterator is an iterator class for iterating over a face's half edges. The code snippet for using this class: // mesh is a pointer to an object of mitkHEMesh // center is the handle of the face mitkHEMesh::FaceHalfedgeIterator iter(mesh, center); for ( ; iter; ++iter) { // iter is the pointer to current half edge // *iter is the reference to current half edge // iter.Handle() returns the handle of current half edge do something with iter, *iter or iter.Handle(); }

typedef FaceIterT<mitkHEMesh> mitkHEMesh::FaceIterator

FaceIterator is an iterator class for iterating over all faces of a mitkHEMesh object. The code snippet for using this class: // mesh is a pointer to an object of mitkHEMesh mitkHEMesh::FaceIterator iter(mesh); for ( ; iter; ++iter) { // iter is the pointer to current face // *iter is the reference to current face // iter.Handle() returns the handle of current face do something with iter, *iter or iter.Handle(); }

typedef FaceVertexIterT<mitkHEMesh> mitkHEMesh::FaceVertexIterator

FaceVertexIterator is an iterator class for iterating over a face's vertices. The code snippet for using this class: // mesh is a pointer to an object of mitkHEMesh // center is the handle of the face mitkHEMesh::FaceVertexIterator iter(mesh, center); for ( ; iter; ++iter) { // iter is the pointer to current vertex // *iter is the reference to current vertex // iter.Handle() returns the handle of current vertex do something with iter, *iter or iter.Handle(); }

typedef VertexEdgeIterT<mitkHEMesh> mitkHEMesh::VertexEdgeIterator

VertexEdgeIterator is an iterator class for iterating over all incident edges around a vertex. The code snippet for using this class: // mesh is a pointer to an object of mitkHEMesh // center is the handle of the center vertex mitkHEMesh::VertexEdgeIterator iter(mesh, center); for ( ; iter; ++iter) { // iter is the pointer to current incident edge // *iter is the reference to current incident edge // iter.Handle() returns the handle of current incident edge do something with iter, *iter or iter.Handle(); }

typedef VertexFaceIterT<mitkHEMesh> mitkHEMesh::VertexFaceIterator

VertexFaceIterator is an iterator class for iterating over all adjacent faces around a vertex. The code snippet for using this class: // mesh is a pointer to an object of mitkHEMesh // center is the handle of the center vertex mitkHEMesh::VertexFaceIterator iter(mesh, center); for ( ; iter; ++iter) { // iter is the pointer to current adjacent face // *iter is the reference to current adjacent face // iter.Handle() returns the handle of current adjacent face do something with iter, *iter or iter.Handle(); }

typedef VertexIHalfedgeIterT<mitkHEMesh> mitkHEMesh::VertexIHalfedgeIterator

VertexIHalfedgeIterator is an iterator class for iterating over all incoming half edges around a vertex. The code snippet for using this class: // mesh is a pointer to an object of mitkHEMesh // center is the handle of the center vertex mitkHEMesh::VertexIHalfedgeIterator iter(mesh, center); for ( ; iter; ++iter) { // iter is the pointer to current incoming half edge // *iter is the reference to current incoming half edge // iter.Handle() returns the handle of current incoming half edge do something with iter, *iter or iter.Handle(); }

typedef VertexIterT<mitkHEMesh> mitkHEMesh::VertexIterator

VertexIterator is an iterator class for iterating over all vertices of a mitkHEMesh object. The code snippet for using this class: // mesh is a pointer to an object of mitkHEMesh mitkHEMesh::VertexIterator iter(mesh); for ( ; iter; ++iter) { // iter is the pointer to current vertex // *iter is the reference to current vertex // iter.Handle() returns the handle of current vertex do something with iter, *iter or iter.Handle(); }

typedef VertexOHalfedgeIterT<mitkHEMesh> mitkHEMesh::VertexOHalfedgeIterator

VertexOHalfedgeIterator is an iterator class for iterating over all outgoing half edges around a vertex. The code snippet for using this class: // mesh is a pointer to an object of mitkHEMesh // center is the handle of the center vertex mitkHEMesh::VertexOHalfedgeIterator iter(mesh, center); for ( ; iter; ++iter) { // iter is the pointer to current outgoing half edge // *iter is the reference to current outgoing half edge // iter.Handle() returns the handle of current outgoing half edge do something with iter, *iter or iter.Handle(); }

typedef VertexVertexIterT<mitkHEMesh> mitkHEMesh::VertexVertexIterator

VertexVertexIterator is an iterator class for iterating over all neighboring vertices around a vertex. The code snippet for using this class: // mesh is a pointer to an object of mitkHEMesh // center is the handle of the center vertex mitkHEMesh::VertexVertexIterator iter(mesh, center); for ( ; iter; ++iter) { // iter is the pointer to current neighboring vertex // *iter is the reference to current neighboring vertex // iter.Handle() returns the handle of current neighboring vertex do something with iter, *iter or \e r.Handle(); }

---

Constructor & Destructor Documentation

mitkHEMesh::mitkHEMesh (   )

Default constructor.

---

Member Function Documentation

FaceHandle mitkHEMesh::AddFace (  unsigned int  n, VertexHandle *  vertices )

Add Face. Parameters: n  the number of vertices of the face to add vertices  array of the VertexHandle which compose the face Returns: Return the handle of the face added. Warning: Each VertexHandle in the array must be valid, i.e. represents a existent vertex in the mesh (has been ``Add*''ed before).

VertexHandle mitkHEMesh::AddVertex (  float  v[6]  )  [inline]

Add vertex. Parameters: v[0]  the x-coordinate of the vertex to add v[1]  the y-coordinate of the vertex to add v[2]  the z-coordinate of the vertex to add v[3]  the x-coordinate of the vertex's normal v[4]  the y-coordinate of the vertex's normal v[5]  the z-coordinate of the vertex's normal Returns: Return the handle of the vertex added.

VertexHandle mitkHEMesh::AddVertex (  float  x, float  y, float  z, float  nx = 0.0f, float  ny = 0.0f, float  nz = 0.0f )  [inline]

Add vertex. Parameters: x  the x-coordinate of the vertex to add y  the y-coordinate of the vertex to add z  the z-coordinate of the vertex to add nx  the x-coordinate of the vertex's normal, the default value is 0.0f ny  the y-coordinate of the vertex's normal, the default value is 0.0f nz  the z-coordinate of the vertex's normal, the default value is 0.0f Returns: Return the handle of the vertex added.

VertexHandle mitkHEMesh::AddVertex (  Point3f const &  point, Point3f const &  normal )  [inline]

Add vertex. Parameters: point  the coordinates of the vertex to add normal  the normal of the vertex to add Returns: Return the handle of the vertex added.

VertexHandle mitkHEMesh::AddVertex (  Vertex const &  vert  )  [inline]

Add vertex. Parameters: vert  the vertex to add Returns: Return the handle of the vertex added.

FaceHandle mitkHEMesh::AdjFace (  HalfEdgeHandle  he  )  const [inline]

Get the handle of one half edge's adjacent face. Parameters: he  the handle of the half edge Returns: Return the handle of the face. Note: A face is made up of an inner loop of half edges.

void mitkHEMesh::ClearFlags (   )

Clear all the user-set flags except MITK_FLAG_DELETED.

void mitkHEMesh::ClearGarbage (   )

Clear the garbage generated by deletion. Note: Call this function before any kinds of iteration.

virtual void mitkHEMesh::DeepCopy (  mitkDataObject *  src  )  [virtual]

Deep copy. Parameters: src  pointer to the source mitkDataObject Reimplemented from mitkMesh. Reimplemented in mitkHEICTriangleMesh, and mitkHEOoCTriangleMesh.

void mitkHEMesh::DeleteEdge (  EdgeHandle  edge, bool  deleteIsolatedVertices )

Delete edge. Parameters: edge  the handle of the edge to be deleted deleteIsolatedVertices  whether to delete the isolated vertices after deleting the edge

void mitkHEMesh::DeleteFace (  FaceHandle  face, bool  deleteIsolatedVertices )

Delete face. Parameters: face  the handle of the face to be deleted deleteIsolatedVertices  whether to delete the isolated vertices after deleting the face

void mitkHEMesh::DeleteVertex (  VertexHandle  vert  )

Delete vertex. Parameters: vert  the handle of the vertex to be deleted

VertexHandle mitkHEMesh::EndVertex (  HalfEdgeHandle  he  )  const [inline]

Get the handle of one half edge's end vertex. Parameters: he  the handle of the half edge Returns: Return the handle of the end vertex.

HalfEdgeHandle mitkHEMesh::FindHalfEdge (  VertexHandle  vert0, VertexHandle  vert1 )

Find halfedge from vert0 to vert1. Parameters: vert0  the handle of the start vertex vert1  the handle of the end vertex Returns: Return the handle of the half edge between vert0 and vert1. If no half edge is found, the returned handle will be invalid. Use HalfEdgeHandle::IsValid() to test it.

virtual int mitkHEMesh::GetDataObjectType (   )  const [inline, virtual]

Return what type of data object this is. Returns: Return the type of this data object. Reimplemented from mitkMesh. Reimplemented in mitkHEICTriangleMesh, and mitkHEOoCTriangleMesh.

virtual Edge& mitkHEMesh::GetEdge (  HalfEdgeHandle  he  )  const [pure virtual]

Get edge by half edge handle. Parameters: he  one half edge handle of the required edge Returns: Return the reference to the required edge. Note: An edge is composed by two opposite half edges.

virtual Edge& mitkHEMesh::GetEdge (  EdgeHandle  e  )  const [pure virtual]

Get edge by handle. Parameters: e  the handle of the required edge Returns: Return the reference to the required edge.

EdgeHandle mitkHEMesh::GetEdgeHandle (  HalfEdgeHandle  he  )  const [inline]

Get the handle of an edge by one of its half edge's handle. Parameters: he  one half edge's handle of the edge Returns: Return the handle of the edge. Note: An edge is composed by two opposite half edges.

size_type mitkHEMesh::GetEdgeNumber (   )  const [inline]

Get edge number. Returns: Return the number of edges.

virtual Face& mitkHEMesh::GetFace (  FaceHandle  f  )  const [pure virtual]

Get face by handle. Parameters: f  the handle of the required face Returns: Return the reference to the required face.

virtual size_type mitkHEMesh::GetFaceNumber (   )  const [inline, virtual]

Get face number. Returns: Return the number of faces. Implements mitkMesh.

virtual HalfEdge& mitkHEMesh::GetHalfEdge (  HalfEdgeHandle  he  )  const [pure virtual]

Get half edge by handle. Parameters: he  the handle of the required half edge Returns: Return the reference to the required half edge.

virtual FaceHandle mitkHEMesh::GetHandle (  Face const &  face  )  const [pure virtual]

Get the handle of a face. Parameters: face  the reference to the face Returns: Return the handle of the face.

virtual HalfEdgeHandle mitkHEMesh::GetHandle (  HalfEdge const &  he  )  const [pure virtual]

Get the handle of a half edge. Parameters: he  the reference to the half edge Returns: Return the handle of the half edge.

virtual EdgeHandle mitkHEMesh::GetHandle (  Edge const &  edge  )  const [pure virtual]

Get the handle of an edge. Parameters: edge  the reference to the edge Returns: Return the handle of the edge.

virtual VertexHandle mitkHEMesh::GetHandle (  Vertex const &  vert  )  const [pure virtual]

Get the handle of a vertex. Parameters: vert  the reference to the vertex Returns: Return the handle of the vertex.

size_type mitkHEMesh::GetValidEdgeNumber (   )  const [inline]

Get the number of current valid edges in this mesh. Returns: Return the number of the valid edges. Note: For some reasons of efficiency, deleting some components from the mesh does not really remove the components from the memory, but just make marks on them. Therefore, after the delete operations, the total number of the components in the memory does not equal to the number of the valid ones. So, use this function to get the right number. Furthermore, ClearGarbage() will remove the deleted components from the memory at last.

size_type mitkHEMesh::GetValidFaceNumber (   )  const [inline]

Get the number of current valid faces in this mesh. Returns: Return the number of the valid faces. Note: For some reasons of efficiency, deleting some components from the mesh does not really remove the components from the memory, but just make marks on them. Therefore, after the delete operations, the total number of the components in the memory does not equal to the number of the valid ones. So, use this function to get the right number. Furthermore, ClearGarbage() will remove the deleted components from the memory at last.

size_type mitkHEMesh::GetValidVertexNumber (   )  const [inline]

Get the number of current valid vertices in this mesh. Returns: Return the number of the valid vertices. Note: For some reasons of efficiency, deleting some components from the mesh does not really remove the components from the memory but just make marks on them. Therefore, after the delete operations, the total number of the components in the memory does not equal to the number of the valid ones. So, use this function to get the right number. Furthermore, ClearGarbage() will remove the deleted components from the memory at last.

virtual Vertex& mitkHEMesh::GetVertex (  VertexHandle  v  )  const [pure virtual]

Get vertex by handle. Parameters: v  the handle of the required vertex Returns: Return the reference to the required vertex.

virtual size_type mitkHEMesh::GetVertexNumber (   )  const [inline, virtual]

Get vertex number. Returns: Return the number of vertices. Implements mitkMesh.

virtual void mitkHEMesh::Initialize (   )  [virtual]

Make the output data ready for new data to be inserted. Reimplemented from mitkMesh. Reimplemented in mitkHEICTriangleMesh, mitkHEOoCTriangleMesh, and mitkHETriangleMesh.

bool mitkHEMesh::IsBoundary (  EdgeHandle  edge  )  const [inline]

Boundary test for edge. Parameters: edge  the handle of the edge to be tested Returns: Return true if edge is a boundary edge, otherwise return false.

bool mitkHEMesh::IsBoundary (  VertexHandle  vert  )  const [inline]

Boundary test for vertex. Parameters: vert  the handle of the vertex to be tested Returns: Return true if vert is a boundary vertex, otherwise return false.

bool mitkHEMesh::IsBoundary (  HalfEdgeHandle  halfedge  )  const [inline]

Boundary test for half edge. Parameters: halfedge  the handle of the half edge to be tested Returns: Return true if halfedge is a boundary half edge, otherwise return false.

bool mitkHEMesh::IsManifold (  VertexHandle  vert  )  [inline]

Manifold test for vertex. The vertex is non-manifold if more than one gap exists, i.e. more than one outgoing boundary halfedge. If one boundary halfedge exists, the vertex' halfedge must be a boundary halfedge. If iterating around the vertex finds another boundary halfedge, the vertex is non-manifold. Parameters: vert  the handle of the vertex to be tested Returns: Return true if the vertex is manifold, otherwise return false.

bool mitkHEMesh::IsValid (  FaceHandle  f  )  const [inline]

Test the validity of one face handle. Parameters: f  the handle of the face to be tested Returns: Return true if this handle is valid, otherwise return false.

bool mitkHEMesh::IsValid (  HalfEdgeHandle  he  )  const [inline]

Test the validity of one half edge handle. Parameters: he  the handle of the half edge to be tested Returns: Return true if this handle is valid, otherwise return false.

bool mitkHEMesh::IsValid (  EdgeHandle  e  )  const [inline]

Test the validity of one edge handle. Parameters: e  the handle of the edge to be tested Returns: Return true if this handle is valid, otherwise return false.

bool mitkHEMesh::IsValid (  VertexHandle  v  )  const [inline]

Test the validity of one vertex handle. Parameters: v  the handle of the vertex to be tested Returns: Return true if this handle is valid, otherwise return false.

HalfEdgeHandle mitkHEMesh::NextHalfEdge (  HalfEdgeHandle  he  )  const [inline]

Get the handle of one half edge's next half edge. Parameters: he  the handle of the half edge Returns: Return the handle of the next half edge.

HalfEdgeHandle mitkHEMesh::OneHalfEdge (  FaceHandle  f  )  const [inline]

Get the handle of one half edge in one face. Parameters: f  the handle of the face Returns: Return the handle of one of the face's half edges. Note: A face is made up of an inner loop of half edges.

HalfEdgeHandle mitkHEMesh::OutHalfEdge (  VertexHandle  v  )  const [inline]

Get the handle of one vertex's out half edge. Parameters: v  the handle of the vertex Returns: Return the handle of the out half edge.

HalfEdgeHandle mitkHEMesh::PairHalfEdge (  HalfEdgeHandle  he  )  const [inline]

Get the handle of one half edge's opposite. Parameters: he  the handle of the half edge Returns: Return the handle of the opposite half edge.

HalfEdgeHandle mitkHEMesh::PrevHalfEdge (  HalfEdgeHandle  he  )  const [inline]

Get the handle of one half edge's previous half edge. Parameters: he  the handle of the half edge Returns: Return the handle of the previous half edge.

virtual void mitkHEMesh::PrintSelf (  ostream &  os  )  [virtual]

Print the necessary information about this object for the debugging purpose. Parameters: os  The specified ostream to output information. Reimplemented from mitkMesh. Reimplemented in mitkHEICTriangleMesh, mitkHEOoCTriangleMesh, and mitkHETriangleMesh.

virtual void mitkHEMesh::ShallowCopy (  mitkDataObject *  src  )  [virtual]

Shallowcopy. Parameters: src  pointer to the source mitkDataObject Reimplemented from mitkMesh. Reimplemented in mitkHEICTriangleMesh, and mitkHEOoCTriangleMesh.

virtual bool mitkHEMesh::TestClockwise (   )  [virtual]

Test the orientation of front-facing polygons. Returns: Return true if the orientation of front-facing polygons is clockwise, otherwise return false. Implements mitkMesh.

---

The documentation for this class was generated from the following file:

• mitkHEMesh.h

---