Pixyco-XYZ/openmesh
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

First checkin for OpenMesh 2.0

Browse Source 
git-svn-id: http://www.openmesh.org/svnrepo/OpenMesh/trunk@2 fdac6126-5c0c-442c-9429-916003d36597
This commit is contained in:
Jan Möbius
2009-02-06 13:37:46 +00:00
parent c3321ebdd9
commit 97f515985d
417 changed files with 76182 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

188
Doc/Concepts/MeshItems.hh Normal file
View File

@@ -0,0 +1,188 @@
//=============================================================================
//
// OpenMesh
// Copyright (C) 2001-2005 by Computer Graphics Group, RWTH Aachen
// www.openmesh.org
//
//-----------------------------------------------------------------------------
//
// License
//
// This library is free software; you can redistribute it and/or modify it
// under the terms of the GNU Library General Public License as published
// by the Free Software Foundation, version 2.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//
//-----------------------------------------------------------------------------
//
// $Revision: 1.2 $
// $Date: 2005-12-21 14:05:27 $
//
//=============================================================================
//=============================================================================
//
// Mesh Items Concept
//
//=============================================================================
#error this file is for documentation purposes only
//== NAMESPACES ===============================================================
namespace OpenMesh {
namespace Concepts {
//== CLASS DEFINITION =========================================================
/** \ingroup mesh_concepts_group
The mesh items class encapsulates the types VertexT, HalfedgeT,
EdgeT, and FaceT.
\see VertexT, HalfedgeT, EdgeT, FaceT
*/
struct MeshItems {
/** Interface for the internal vertex type. This minimal interface
must be provided by every vertex. It's up to the mesh kernel (or
the items used by the mesh kernel) to implement it.
All methods marked as internal should only be used by the mesh
kernel.
*/
template <class Refs_> class VertexT
{
public:
/// Re-export the template argument Refs. This \b must be done!
typedef Refs_ Refs;
/// Default constructor
VertexT();
/// Get an outgoing halfedge
HalfedgeHandle halfedge_handle() const;
/// Set the outgoing halfedge link
void set_halfedge_handle(HalfedgeHandle _eh);
};
/** Interface for the internal halfedge type. This minimal interface
must be provided by every halfedge. It's up to the mesh kernel (or
the items used by the mesh kernel) to implement it.
All methods marked as internal should only be used by the mesh
kernel.
*/
template <class Refs_> class HalfedgeT
{
public:
/// Re-export the template argument Refs. This \b must be done!
typedef Refs_ Refs;
/** Get the vertex the halfedge point to.
\internal */
VertexHandle vertex_handle() const;
/** Set the vertex the halfedge point to.
\internal */
void set_vertex_handle(VertexHandle _vh);
/** Get the face this halfedge belongs to.
\internal */
FaceHandle face_handle() const;
/** Set the face this halfedge belongs to.
\internal */
void set_face_handle(FaceHandle _fh);
/** Get the next halfedge inside this face.
\internal */
HalfedgeHandle next_halfedge_handle() const;
/** Set the next halfedge inside this face.
\internal */
void set_next_halfedge_handle(HalfedgeHandle _eh);
};
/** Interface for the internal edge type. This minimal interface must
be provided by every edge. It's up to the mesh kernel (or the
items used by the mesh kernel) to implement it.
All methods marked as internal should only be used by the mesh
kernel.
*/
template <class Refs_> class EdgeT
{
public:
/// Re-export the template argument Refs. This \b must be done!
typedef Refs_ Refs;
/** Store two halfedges.
\internal */
Halfedge halfedges[2];
};
/** Interface for the internal face type. This minimal interface must
be provided by every face. It's up to the mesh kernel (or the
items used by the mesh kernel) to implement it.
All methods marked as internal should only be used by the mesh
kernel.
*/
template <class Refs_> class FaceT
{
public:
/// Re-export the template argument Refs. This \b must be done!
typedef Refs_ Refs;
/** Compile-time-tag: is this face a triangle? Should be typedef'ed
to either GenProg::TagTrue or GenProg::TagFalse */
typedef GenProg::TagTrue IsTriangle;
/// Run-time test: is this face a triangle?
static bool is_triangle();
/// Get the number of vertices of this face.
unsigned char n_vertices() const;
/** Set the number of vertices of this face.
\internal */
void set_n_vertices(unsigned char _n);
/// Get a halfedge that belongs to this face.
HalfedgeHandle halfedge_handle() const;
/** Set a halfedge that belongs this face.
\internal */
void set_halfedge_handle(HalfedgeHandle _eh);
};
};
//=============================================================================
} // namespace Concepts
} // namespace OpenMesh
//=============================================================================

510
Doc/Concepts/MeshKernel.hh Normal file
View File

@@ -0,0 +1,510 @@
//=============================================================================
//
// OpenMesh
// Copyright (C) 2001-2005 by Computer Graphics Group, RWTH Aachen
// www.openmesh.org
//
//-----------------------------------------------------------------------------
//
// License
//
// This library is free software; you can redistribute it and/or modify it
// under the terms of the GNU Library General Public License as published
// by the Free Software Foundation, version 2.
//
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//
//-----------------------------------------------------------------------------
//
// $Revision: 1.2 $
// $Date: 2005-12-21 14:05:27 $
//
//=============================================================================
//=============================================================================
//
// Kernel Concept
//
//=============================================================================
#error this file is for documentation purposes only
//== NAMESPACES ===============================================================
namespace OpenMesh {
namespace Concepts {
//== CLASS DEFINITION =========================================================
/** \ingroup mesh_concepts_group
This class describes the minimum interface a mesh kernel
has to implement (because the resulting mesh will rely on
this interface).
This is the template class the actually holds the mesh kernel
implementation. All functions marked as internal should only be used
by the mesh class (that inherits the kernel). The mesh may then
provide wrapper functions that provide the same functionality.
\todo Check, if the member list is complete.
*/
template <class FinalMeshItems> class KernelT
{
public:
/// \name Mesh Items
//@{
/// Derive this type from the FinalMeshItems
typedef typename FinalMeshItems::Vertex Vertex;
typedef typename FinalMeshItems::Halfedge Halfedge;
typedef typename FinalMeshItems::Edge Edge;
typedef typename FinalMeshItems::Face Face;
typedef typename FinalMeshItems::Point Point;
typedef typename FinalMeshItems::Scalar Scalar;
typedef typename FinalMeshItems::Normal Normal;
typedef typename FinalMeshItems::Color Color;
typedef typename FinalMeshItems::TexCoord TexCoord;
typedef typename FinalMeshItems::VertexHandle VertexHandle;
typedef typename FinalMeshItems::HalfedgeHandle HalfedgeHandle;
typedef typename FinalMeshItems::EdgeHandle EdgeHandle;
typedef typename FinalMeshItems::FaceHandle FaceHandle;
//@}
/// \name Kernel Iterators
//@{
/// This type depends on the container type in use.
typedef SomeIterator KernelVertexIter;
typedef SomeIterator KernelConstVertexIter;
typedef SomeIterator KernelEdgeIter;
typedef SomeIterator KernelConstEdgeIter;
typedef SomeIterator KernelFaceIter;
typedef SomeIterator KernelConstFaceIter;
//@}
/// \name Constructor/Destructor
//@{
/// Default constructor
KernelT() {}
/// Destructor
~KernelT();
//@}
/// Assignment operator
KernelT& operator=(const KernelT& _rhs);
/** Reserve memory for vertices, edges, faces.
*
* Reserve memory for the mesh items vertices, edges, faces. Use
* this method if you can estimate the memory consumption, for
* instance in algorithm expanding the mesh. Depending on the
* underlying array type you might be better of using this method,
* then letting the array type decide when to increase the
* capacity. For instance the STL vector class \c std::vector (used
* in the supplied ArrayKernelT) doubles the capacity if it is
* exhausted. This might lead to an memory allocation exception,
* though an smaller increment would be enough.
*/
void reserve( unsigned int _n_vertices,
unsigned int _n_edges,
unsigned int _n_faces );
/// \name Handle -> Item.
//@{
/// Translate handle to item (see also OpenMesh::PolyMeshT::deref())
const Vertex& vertex(VertexHandle _h) const { return deref(_h); }
Vertex& vertex(VertexHandle _h) { return deref(_h); }
const Halfedge& halfedge(HalfedgeHandle _h) const { return deref(_h); }
Halfedge& halfedge(HalfedgeHandle _h) { return deref(_h); }
const Edge& edge(EdgeHandle _h) const { return deref(_h); }
Edge& edge(EdgeHandle _h) { return deref(_h); }
const Face& face(FaceHandle _h) const { return deref(_h); }
Face& face(FaceHandle _h) { return deref(_h); }
//@}
/// \name Item -> Handle
//@{
/// Translate item to handle
VertexHandle handle(const Vertex& _v) const;
HalfedgeHandle handle(const Halfedge& _he) const;
EdgeHandle handle(const Edge& _e) const;
FaceHandle handle(const Face& _f) const;
//@}
/// \name Get the i'th item
//@{
/// Get the i'th item
VertexHandle vertex_handle(unsigned int _i) const;
HalfedgeHandle halfedge_handle(unsigned int _i) const;
EdgeHandle edge_handle(unsigned int _i) const;
FaceHandle face_handle(unsigned int _i) const;
//@}
/// \name Delete items
//@{
/// Delete all items, i.e. clear all item containers.
void clear();
/** Remove all items that are marked as deleted from the
corresponding containers.
\note Needs the Attributes::Status attribute
\note This function may not be implemented for all kernels.
*/
void garbage_collection();
/** Remove the last vertex imidiately, i.e. call pop_back() for the
VertexContainer.
*/
void remove_last_vertex() { vertices_.pop_back(); }
/** Remove the last edge imidiately, i.e. call pop_back() for the
EdgeContainer. Used e.g. by the add_face() method of PolyMeshT
*/
void remove_last_edge() { edges_.pop_back(); }
/** Remove the last face imidiately, i.e. call pop_back() for the
FaceContainer. Used e.g. by the add_face() method of PolyMeshT
*/
void remove_last_face() { faces_.pop_back(); }
//@}
/// \name Number of elements
//@{
/// Returns number of vertices
unsigned int n_vertices() const;
/// Returns number of halfedges (should be 2*n_edges())
unsigned int n_halfedges() const;
/// Returns number of edges
unsigned int n_edges() const;
/// Returns number of faces
unsigned int n_faces() const;
/// Is the vertex container empty?
bool vertices_empty() const;
/// Is the halfedge container empty (should be the same as edges_empty()).
bool halfedges_empty() const;
/// Is the edge container empty?
bool edges_empty() const;
/// Is the face container empty?
bool faces_empty() const;
//@}
/// \name Vertex connectivity
//@{
/// Get an outgoing halfedge of a given vertex
HalfedgeHandle halfedge_handle(VertexHandle _vh) const;
/// Set the outgoing halfedge handle of a given vertex
void set_halfedge_handle(VertexHandle _vh, HalfedgeHandle _heh);
/// Get the coordinate of a vertex
const Point& point(VertexHandle _vh) const;
/// Get the coordinate of a vertex
const Point& point(const Vertex& _v) const;
/// Set the coordinate of a vertex
void set_point(VertexHandle _vh, const Point& _p);
/// Set the coordinate of a vertex
void set_point(Vertex& _v, const Point& _p);
//@}
/// \name Halfedge connectivity
//@{
/// Get the vertex the halfedge points to
VertexHandle to_vertex_handle(HalfedgeHandle _heh) const;
/** Get the vertex the halfedge starts from (implemented as to-handle
of the opposite halfedge, provided for convenience) */
VertexHandle from_vertex_handle(HalfedgeHandle _heh) const;
/// Set the to-vertex-handle of the halfedge
void set_vertex_handle(HalfedgeHandle _heh, VertexHandle _vh);
/** Get the face the halfedge belongs to.
\note The handle is invalid if the halfedge is a boundary halfedge */
FaceHandle face_handle(HalfedgeHandle _heh) const;
/// Set the face the halfedge belongs to
void set_face_handle(HalfedgeHandle _heh, FaceHandle _fh);
/// Get the next halfedge handle
HalfedgeHandle next_halfedge_handle(HalfedgeHandle _heh) const;
/** Set the next halfedge handle. \note If the previous halfedge is
also stored (see OpenMesh::Attributes::PrevHalfedge) then this
method also has to set this link) */
void set_next_halfedge_handle(HalfedgeHandle _heh, HalfedgeHandle _nheh);
/** Get the previous halfedge of the given halfedge. The
implementation should take care of an existing
OpenMesh::Attributes::PrevHalfedge attribute. */
HalfedgeHandle prev_halfedge_handle(HalfedgeHandle _heh) const;
/// Get the opposite halfedge
HalfedgeHandle opposite_halfedge_handle(HalfedgeHandle _heh) const;
/// Counter-clockwise rotate the given halfedge around its from vertex
HalfedgeHandle ccw_rotated_halfedge_handle(HalfedgeHandle _heh) const;
/// Clockwise rotate the given halfedge around its from vertex
HalfedgeHandle cw_rotated_halfedge_handle(HalfedgeHandle _heh) const;
/// Get the edge the current halfedge it contained in
EdgeHandle edge_handle(HalfedgeHandle _heh) const;
//@}
/// \name Edge connectivity
//@{
/// Get the first or second halfedge of the given edge
HalfedgeHandle halfedge_handle(EdgeHandle _eh, unsigned int _i) const;
//@}
/// \name Face connectivity
//@{
/// Get a halfedge belonging to the face
HalfedgeHandle halfedge_handle(FaceHandle _fh) const;
/// Set one halfedge of the face
void set_halfedge_handle(FaceHandle _fh, HalfedgeHandle _heh);
//@}
public: // Standard Property Management
/// \name set/get value of a standard property
//@{
// vertex
const Point& point(VertexHandle _vh) const; ///< Get position
void set_point(VertexHandle _vh, const Point& _p); ///< Set position
Point& point(VertexHandle _vh); ///< Convenience function
const Normal& normal(VertexHandle _vh) const; ///< Get normal
void set_normal(VertexHandle _vh, const Normal& _n); ///< Set normal
const Color& color(VertexHandle _vh) const; ///< Get color
void set_color(VertexHandle _vh, const Color& _c) ///< Set color
const TexCoord& texcoord(VertexHandle _vh) const; ///< Get texture coordinate.
void set_texcoord(VertexHandle _vh, const TexCoord& _t); ///< Set texture coordinate.
const StatusInfo& status(VertexHandle _vh) const; ///< Get status
StatusInfo& status(VertexHandle _vh); ///< Get status
// halfedge
const StatusInfo& status(HalfedgeHandle _vh) const; ///< Get status
StatusInfo& status(HalfedgeHandle _vh); ///< Get status
// edge
const StatusInfo& status(EdgeHandle _vh) const; ///< Get status
StatusInfo& status(EdgeHandle _vh); ///< Get status
// face
const Normal& normal(FaceHandle _fh) const; ///< Get normal
void set_normal(FaceHandle _fh, const Normal& _n); ///< Set normal
const Color& color(FaceHandle _fh) const; ///< Get color
void set_color(FaceHandle _fh, const Color& _c); ///< Set color
const StatusInfo& status(FaceHandle _vh) const; ///< Get status
StatusInfo& status(FaceHandle _vh); ///< Get status
//@}
/// \name Dynamically add standard properties
//@{
/// Request property
void request_vertex_normals();
void request_vertex_colors();
void request_vertex_texcoords();
void request_vertex_status();
void request_halfedge_status();
void request_edge_status();
void request_face_normals();
void request_face_colors();
void request_face_status();
//@}
/// \name Remove standard properties
//@{
/// Remove property
void release_vertex_normals();
void release_vertex_colors();
void release_vertex_texcoords();
void release_vertex_status();
void release_halfedge_status();
void release_edge_status();
void release_face_normals();
void release_face_colors();
void release_face_status();
//@}
/// \name Check availability of standard properties
//@{
/// Is property available?
bool has_vertex_normals() const;
bool has_vertex_colors() const;
bool has_vertex_texcoords() const;
bool has_vertex_status() const;
bool has_edge_status() const;
bool has_halfedge_status() const;
bool has_face_normals() const;
bool has_face_colors() const;
bool has_face_status() const;
//@}
public: // Property Management
/// \anchor concepts_kernelt_property_management
/// \name Property management - add property
//@{
/// Add property.
/// @copydoc OpenMesh::BaseKernel::add_property()
template <typename T> bool add_property( [VEHFM]PropHandleT<T>& _ph,
const std::string& _name = "" );
//@}
/// \name Property management - remove property
//@{
/// Remove property
template <typename T> void remove_property( [VEHFM]PropHandleT<T>& );
//@}
/// \name Property management - get property by name
//@{
/// Get property handle by name
template <typename T>
bool get_property_handle( [VEHFM]PropHandleT<T>& ph, const std::string& _n ) const;
//@}
/// \name Property management - get property
//@{
/// Get property
template <typename T> PropertyT<T>& property( [VEHF]PropHandleT<T> _ph );
template <typename T> const PropertyT<T>& property( [VEHF]PropHandleT<T> _ph ) const;
template <typename T> PropertyT<T>& mproperty( MPropHandleT<T> _ph );
template <typename T> const PropertyT<T>& mproperty( MPropHandleT<T> _ph ) const;
//@}
/// \name Property management - get property value for an item
//@{
/// Get value for item represented by the handle.
template <typename T>
T& property( VPropHandleT<T> _ph, VertexHandle _vh );
template <typename T>
const T& property( VPropHandleT<T> _ph, VertexHandle _vh ) const;
template <typename T>
T& property( EPropHandleT<T> _ph, EdgeHandle _vh );
template <typename T>
const T& property( EPropHandleT<T> _ph, EdgeHandle _vh ) const;
template <typename T>
T& property( HPropHandleT<T> _ph, HalfedgeHandle _vh );
template <typename T>
const T& property( HPropHandleT<T> _ph, HalfedgeHandle _vh ) const;
template <typename T>
T& property( FPropHandleT<T> _ph, FaceHandle _vh );
template <typename T>
const T& property( FPropHandleT<T> _ph, FaceHandle _vh ) const;
template <typename T>
T& property( MPropHandleT<T> _ph );
template <typename T>
const T& property( MPropHandleT<T> _ph ) const;
//@}
public:
/// \name Low-level adding new items
//@{
/** Add a new (default) vertex.
\internal */
VertexHandle new_vertex();
/** Add a new vertex with a given point coordinate.
\internal */
VertexHandle new_vertex(const Point& _p);
/** Add a new vertex (copied from the given one).
\internal */
VertexHandle new_vertex(const Vertex& _v);
/** Add a new edge from \c _start_vertex_handle to \c _end_vertex_handle.
This method should add an edge (i.e. two opposite halfedges) and set
the corresponding vertex handles of these halfedges.
\internal
*/
HalfedgeHandle new_edge(VertexHandle _start_vertex_handle,
VertexHandle _end_vertex_handle);
/** Adding a new face
\internal
*/
FaceHandle new_face();
/** Adding a new face (copied from a \c _f).
\internal */
FaceHandle new_face(const Face& _f);
//@}
// --- iterators ---
/// \name Kernel item iterators
//@{
/** Kernel item iterator
\internal */
KernelVertexIter vertices_begin();
KernelConstVertexIter vertices_begin() const;
KernelVertexIter vertices_end();
KernelConstVertexIter vertices_end() const;
KernelEdgeIter edges_begin();
KernelConstEdgeIter edges_begin() const;
KernelEdgeIter edges_end();
KernelConstEdgeIter edges_end() const;
KernelFaceIter faces_begin();
KernelConstFaceIter faces_begin() const;
KernelFaceIter faces_end();
KernelConstFaceIter faces_end() const;
//@}
private:
// --- private functions ---
/// copy constructor: not used
KernelT(const KernelT& _rhs);
};
};
//=============================================================================
} // namespace Concepts
} // namespace OpenMesh
//=============================================================================