Cleaned up documentation of components (new doxygroup for them, written something for most of them...).
Cleaned Edge components (Added adjacency stuff, implemented the single emptycore)
This commit is contained in:
parent
302e8130b0
commit
7bc4277fcd
|
|
@ -9,13 +9,16 @@ This module contains the documentation for the types and the functions used for.
|
|||
This module contains the documentation for the types and the functions used for representing and managing mathematical entities.
|
||||
*/
|
||||
|
||||
/** \defgroup vertex Vertexes
|
||||
Vertex of edge, triangular and tetrahedral meshes
|
||||
This module contains the documentation for the types and the functions used for representing and managing vertexes of meshes.
|
||||
/** \defgroup VertexComponentGroup Vertex Components
|
||||
\brief Components that you can use to compose your Vertex type
|
||||
*/
|
||||
|
||||
/** \defgroup face Faces
|
||||
Face of a triangular or a tetrahedral mesh
|
||||
/** \defgroup EdgeComponentGroup Edge Components
|
||||
\brief Components that you can use to compose your Edge type
|
||||
*/
|
||||
|
||||
/** \defgroup FaceComponentGroup Face Components
|
||||
\brief Components that you can use to compose your Face type
|
||||
*/
|
||||
|
||||
/** \defgroup trimesh Triangular Meshes
|
||||
|
|
|
|||
|
|
@ -35,7 +35,10 @@ It can be annoying when you see it but it is useful that every entity involved k
|
|||
- MyVertex1 also store a color value specified as 4 bytes
|
||||
- MyVertex2 store a long list of different components.
|
||||
|
||||
Many other compenents are implemented in VCG, their complete list can be found in the vcg::vertex and vcg::face page. You can place any combination of them as a template parameters of your vertex (your entity) type (order is unimportant). Now we have all it takes for a working definition of MyMesh type:
|
||||
Many other compenents are implemented in the library for the simplexes, the complete list can be found
|
||||
in the \ref VertexComponentGroup, \ref EdgeComponentGroup and \ref FaceComponentGroup pages. You can place any combination of them as
|
||||
a template parameters of your vertex/edge/face type (note that order is rather unimportant).
|
||||
Now we have all it takes for a working definition of MyMesh type:
|
||||
|
||||
\dontinclude trimesh_base.cpp
|
||||
\skip complex.h
|
||||
|
|
|
|||
|
|
@ -54,14 +54,14 @@ we have to build the type a step a time (deriving from a single ancestor at a ti
|
|||
|
||||
|
||||
*/
|
||||
template <class UserTypes>
|
||||
class EdgeBase: public edge::EmptyEFAdj<
|
||||
edge::EmptyVEAdj<
|
||||
edge::EmptyEEAdj<
|
||||
edge::EmptyEHAdj<
|
||||
edge::EmptyBitFlags<
|
||||
edge::EmptyVertexRef<
|
||||
EdgeTypeHolder < UserTypes> > > > > > >{};
|
||||
//template <class UserTypes>
|
||||
// class EdgeBase: public edge::EmptyCore<
|
||||
// edge::EmptyVEAdj<
|
||||
// edge::EmptyCore<
|
||||
// edge::EmptyEHAdj<
|
||||
// edge::EmptyBitFlags<
|
||||
// edge::EmptyVertexRef<
|
||||
// EdgeTypeHolder < UserTypes> > > > > > >{};
|
||||
|
||||
|
||||
/* The Real Big Edge class;
|
||||
|
|
@ -81,9 +81,8 @@ template <class UserTypes,
|
|||
template <typename> class C, template <typename> class D,
|
||||
template <typename> class E, template <typename> class F,
|
||||
template <typename> class G, template <typename> class H,
|
||||
template <typename> class I, template <typename> class J,
|
||||
template <typename> class K>
|
||||
class EdgeArityMax: public K<Arity10<EdgeBase<UserTypes>, A, B, C, D, E, F, G, H, I, J> > {
|
||||
template <typename> class I, template <typename> class J >
|
||||
class EdgeArityMax: public Arity10<edge::EmptyCore<UserTypes>, A, B, C, D, E, F, G, H, I, J> {
|
||||
|
||||
// ----- Flags stuff -----
|
||||
public:
|
||||
|
|
@ -212,9 +211,8 @@ template <class UserTypes,
|
|||
template <typename> class C = DefaultDeriver, template <typename> class D = DefaultDeriver,
|
||||
template <typename> class E = DefaultDeriver, template <typename> class F = DefaultDeriver,
|
||||
template <typename> class G = DefaultDeriver, template <typename> class H = DefaultDeriver,
|
||||
template <typename> class I = DefaultDeriver, template <typename> class J = DefaultDeriver,
|
||||
template <typename> class K = DefaultDeriver>
|
||||
class Edge: public EdgeArityMax<UserTypes, A, B, C, D, E, F, G, H, I, J, K> {
|
||||
template <typename> class I = DefaultDeriver, template <typename> class J = DefaultDeriver >
|
||||
class Edge: public EdgeArityMax<UserTypes, A, B, C, D, E, F, G, H, I, J> {
|
||||
public: typedef AllTypes::AEdgeType IAm; typedef UserTypes TypesPool;};
|
||||
|
||||
}// end namespace
|
||||
|
|
|
|||
|
|
@ -28,31 +28,84 @@
|
|||
|
||||
namespace vcg {
|
||||
namespace edge {
|
||||
|
||||
/** \addtogroup EdgeComponentGroup
|
||||
@{
|
||||
*/
|
||||
|
||||
/*
|
||||
Some naming Rules
|
||||
All the Components that can be added to a vertex should be defined in the namespace edge:
|
||||
|
||||
*/
|
||||
/*------------------------- EMPTY CORE COMPONENTS -----------------------------------------*/
|
||||
|
||||
/*-------------------------- VERTEX ----------------------------------------*/
|
||||
template <class T> class EmptyVertexRef: public T {
|
||||
template <class T> class EmptyCore: public T
|
||||
{
|
||||
public:
|
||||
// typedef typename T::VertexType VertexType;
|
||||
// typedef typename T::CoordType CoordType;
|
||||
inline typename T::VertexType * & V( const int j ) { (void)j; assert(0); static typename T::VertexType *vp=0; return vp; }
|
||||
inline typename T::VertexType * const & V( const int j ) const { (void)j; assert(0); static typename T::VertexType *vp=0; return vp; }
|
||||
inline typename T::VertexType * cV( const int j ) const { (void)j; assert(0); static typename T::VertexType *vp=0; return vp; }
|
||||
inline typename T::CoordType & P( const int j ) { (void)j; assert(0); static typename T::CoordType coord(0, 0, 0); return coord; }
|
||||
inline const typename T::CoordType & P( const int j ) const { (void)j; assert(0); static typename T::CoordType coord(0, 0, 0); return coord; }
|
||||
inline const typename T::CoordType & cP( const int j ) const { (void)j; assert(0); static typename T::CoordType coord(0, 0, 0); return coord; }
|
||||
|
||||
template <class LeftF>
|
||||
void ImportData(const LeftF & leftF) {T::ImportData(leftF);}
|
||||
|
||||
static bool HasEVAdjacency() { return false; }
|
||||
static bool HasVertexRef() { return false; }
|
||||
static void Name(std::vector<std::string> & name){T::Name(name);}
|
||||
};
|
||||
|
||||
typedef vcg::Color4b ColorType;
|
||||
ColorType &C() { static ColorType dumcolor(vcg::Color4b::White); assert(0); return dumcolor; }
|
||||
ColorType cC() const { static ColorType dumcolor(vcg::Color4b::White); assert(0); return dumcolor; }
|
||||
static bool HasColor() { return false; }
|
||||
|
||||
typedef float QualityType;
|
||||
QualityType &Q() { static QualityType dummyQuality(0); assert(0); return dummyQuality; }
|
||||
QualityType cQ() const { static QualityType dummyQuality(0); assert(0); return dummyQuality; }
|
||||
static bool HasQuality() { return false; }
|
||||
|
||||
typedef int MarkType;
|
||||
inline void InitIMark() { }
|
||||
inline int cIMark() const { assert(0); static int tmp=-1; return tmp;}
|
||||
inline int &IMark() { assert(0); static int tmp=-1; return tmp;}
|
||||
static bool HasMark() { return false; }
|
||||
|
||||
typedef int FlagType;
|
||||
int &Flags() { static int dummyflags(0); assert(0); return dummyflags; }
|
||||
int Flags() const { return 0; }
|
||||
static bool HasFlags() { return false; }
|
||||
|
||||
typename T::EdgePointer &VEp(const int & ) { static typename T::EdgePointer ep=0; assert(0); return ep; }
|
||||
typename T::EdgePointer cVEp(const int & ) const { static typename T::EdgePointer ep=0; assert(0); return ep; }
|
||||
int &VEi(const int &){static int z=0; assert(0); return z;}
|
||||
int cVEi(const int &) const {static int z=0; assert(0); return z;}
|
||||
static bool HasVEAdjacency() { return false; }
|
||||
|
||||
typename T::EdgePointer &EEp(const int & ) { static typename T::EdgePointer ep=0; assert(0); return ep; }
|
||||
typename T::EdgePointer cEEp(const int & ) const { static typename T::EdgePointer ep=0; assert(0); return ep; }
|
||||
int &EEi(const int &){static int z=0; assert(0); return z;}
|
||||
int cEEi(const int &) const {static int z=0; assert(0); return z;}
|
||||
static bool HasEEAdjacency() { return false; }
|
||||
|
||||
typename T::HEdgePointer &EHp( ) { static typename T::HEdgePointer hp=0; assert(0); return hp; }
|
||||
typename T::HEdgePointer cEHp( ) const { static typename T::HEdgePointer hp=0; assert(0); return hp; }
|
||||
static bool HasEHAdjacency() { return false; }
|
||||
|
||||
typename T::FacePointer &EFp() { static typename T::FacePointer fp=0; assert(0); return fp; }
|
||||
typename T::FacePointer cEFp() const { static typename T::FacePointer fp=0; assert(0); return fp; }
|
||||
int &EFi() {static int z=0; return z;}
|
||||
int &cEFi() const {static int z=0; return z;}
|
||||
static bool HasEFAdjacency() { return false; }
|
||||
|
||||
template <class LeftF>
|
||||
void ImportData(const LeftF & leftF) {T::ImportData(leftF);}
|
||||
static void Name(std::vector<std::string> & name){T::Name(name);}
|
||||
};
|
||||
|
||||
/*-------------------------- VertexRef ----------------------------------------*/
|
||||
/*! \brief The references to the two vertexes of a edge
|
||||
*
|
||||
* Stored as pointers to the VertexType
|
||||
*/
|
||||
|
||||
template <class T> class VertexRef: public T {
|
||||
public:
|
||||
VertexRef(){
|
||||
|
|
@ -103,18 +156,10 @@ template <class T> class EVAdj : public VertexRef<T>{};
|
|||
|
||||
/*-------------------------- INCREMENTAL MARK ----------------------------------------*/
|
||||
|
||||
template <class T> class EmptyMark: public T {
|
||||
public:
|
||||
static bool HasMark() { return false; }
|
||||
static bool HasMarkOcc() { return false; }
|
||||
inline void InitIMark() { }
|
||||
inline int & IMark() { assert(0); static int tmp=-1; return tmp;}
|
||||
inline int IMark() const {return 0;}
|
||||
template < class LeftV>
|
||||
void ImportData(const LeftV & left ) { T::ImportData( left); }
|
||||
static void Name(std::vector<std::string> & name){T::Name(name);}
|
||||
|
||||
};
|
||||
/*! \brief \em Component: Per edge \b Incremental \b Mark
|
||||
*
|
||||
* An int that allows to efficently un-mark the whole mesh. \sa UnmarkAll
|
||||
*/
|
||||
template <class T> class Mark: public T {
|
||||
public:
|
||||
static bool HasMark() { return true; }
|
||||
|
|
@ -131,19 +176,10 @@ public:
|
|||
};
|
||||
|
||||
/*------------------------- FLAGS -----------------------------------------*/
|
||||
template <class T> class EmptyBitFlags: public T {
|
||||
public:
|
||||
typedef int FlagType;
|
||||
/// Return the vector of Flags(), senza effettuare controlli sui bit
|
||||
int &Flags() { static int dummyflags(0); assert(0); return dummyflags; }
|
||||
int Flags() const { return 0; }
|
||||
template < class LeftV>
|
||||
void ImportData(const LeftV & left ) { T::ImportData( left); }
|
||||
static bool HasFlags() { return false; }
|
||||
static void Name(std::vector<std::string> & name){T::Name(name);}
|
||||
|
||||
};
|
||||
|
||||
/*! \brief \em Component: Per edge \b Flags
|
||||
*
|
||||
* This component stores a 32 bit array of bit flags. These bit flags are used for keeping track of selection, deletion, visiting etc. \sa \ref flags for more details on common uses of flags.
|
||||
*/
|
||||
template <class T> class BitFlags: public T {
|
||||
public:
|
||||
BitFlags(){_flags=0;}
|
||||
|
|
@ -159,24 +195,12 @@ private:
|
|||
int _flags;
|
||||
};
|
||||
|
||||
/*-------------------------- EMPTY COLOR & QUALITY ----------------------------------*/
|
||||
|
||||
template <class T> class EmptyColorQuality: public T {
|
||||
public:
|
||||
typedef float QualityType;
|
||||
QualityType &Q() { static QualityType dummyQuality(0); assert(0); return dummyQuality; }
|
||||
static bool HasQuality() { return false; }
|
||||
|
||||
typedef vcg::Color4b ColorType;
|
||||
ColorType &C() { static ColorType dumcolor(vcg::Color4b::White); assert(0); return dumcolor; }
|
||||
template < class LeftV>
|
||||
void ImportData(const LeftV & left ) { T::ImportData( left); }
|
||||
static bool HasColor() { return false; }
|
||||
static void Name(std::vector<std::string> & name){T::Name(name);}
|
||||
};
|
||||
|
||||
/*-------------------------- Color ----------------------------------*/
|
||||
|
||||
/*! \brief \em Component: Per edge \b Color
|
||||
*
|
||||
* Usually most of the library expects a color stored as 4 unsigned chars (so the component you use is a \c vertex::Color4b)
|
||||
* but you can also use float for the color components.
|
||||
*/
|
||||
template <class A, class T> class Color: public T {
|
||||
public:
|
||||
Color():_color(vcg::Color4b::White) {}
|
||||
|
|
@ -198,7 +222,12 @@ template <class TT> class Color4b: public edge::Color<vcg::Color4b, TT> {
|
|||
};
|
||||
|
||||
/*-------------------------- Quality ----------------------------------*/
|
||||
|
||||
/*! \brief \em Component: Per edge \b quality
|
||||
*
|
||||
* The Quality Component is a generic place for storing a float. The term 'quality' is a bit misleading and it is due to its original storic meaning. You should intend it as a general purpose container.
|
||||
* \sa vcg::tri::UpdateColor for methods transforming quality into colors
|
||||
* \sa vcg::tri::UpdateQuality for methods to manage it
|
||||
*/
|
||||
template <class A, class TT> class Quality: public TT {
|
||||
public:
|
||||
typedef A QualityType;
|
||||
|
|
@ -224,19 +253,13 @@ public: static void Name(std::vector<std::string> & name){name.push_back(std::st
|
|||
};
|
||||
|
||||
/*----------------------------- VEADJ ------------------------------*/
|
||||
template <class T> class EmptyVEAdj: public T {
|
||||
public:
|
||||
typename T::EdgePointer &VEp(const int & ) { static typename T::EdgePointer ep=0; assert(0); return ep; }
|
||||
const typename T::EdgePointer cVEp(const int & ) const { static typename T::EdgePointer ep=0; assert(0); return ep; }
|
||||
int &VEi(const int &){static int z=0; assert(0); return z;}
|
||||
int cVEi(const int &) const {static int z=0; assert(0); return z;}
|
||||
template < class LeftV>
|
||||
void ImportData(const LeftV & left ) { T::ImportData( left); }
|
||||
static bool HasVEAdjacency() { return false; }
|
||||
static bool HasVEAdjacencyOcc() { return false; }
|
||||
static void Name(std::vector<std::string> & name){ T::Name(name);}
|
||||
};
|
||||
/*! \brief \em Component: Per vertex \b Vertex-Edge adjacency relation companion component
|
||||
This component implement one element of the list of edges incident on a vertex.
|
||||
You must use this component only toghether with the corresponding \ref vcg::vertex::VEAdj component in the vertex type
|
||||
|
||||
\sa vcg::tri::UpdateTopology for functions that compute this relation
|
||||
\sa iterators
|
||||
*/
|
||||
template <class T> class VEAdj: public T {
|
||||
public:
|
||||
VEAdj(){_ep[0]=0;_ep[1]=0;_zp[0]=-1;_zp[1]=-1;}
|
||||
|
|
@ -256,20 +279,19 @@ public: static void Name(std::vector<std::string> & name){name.push_back(std::st
|
|||
int _zp[2] ;
|
||||
};
|
||||
|
||||
|
||||
/*----------------------------- EEADJ ------------------------------*/
|
||||
template <class T> class EmptyEEAdj: public T {
|
||||
public:
|
||||
typename T::EdgePointer &EEp(const int & ) { static typename T::EdgePointer ep=0; assert(0); return ep; }
|
||||
const typename T::EdgePointer cEEp(const int & ) const { static typename T::EdgePointer ep=0; assert(0); return ep; }
|
||||
int &EEi(const int &){static int z=0; assert(0); return z;}
|
||||
int cEEi(const int &) const {static int z=0; assert(0); return z;}
|
||||
template < class LeftV>
|
||||
void ImportData(const LeftV & left ) { T::ImportData( left); }
|
||||
static bool HasEEAdjacency() { return false; }
|
||||
static bool HasEEAdjacencyOcc() { return false; }
|
||||
static void Name(std::vector<std::string> & name){ T::Name(name);}
|
||||
};
|
||||
/*! \brief \em Component: \b Edge-Edge adjacency relation
|
||||
This component implement store the pointer (and index) of the adjacent edges.
|
||||
If the vertex is 1-manifold (as in a classical polyline)
|
||||
it holds that:
|
||||
\code
|
||||
e->EEp(i)->EEp(e->EEi(i)) == e
|
||||
\endcode
|
||||
otherwise the edges are connected in a unordered chain (quite similar to how Face-Face adjacency relation is stored);
|
||||
|
||||
\sa vcg::tri::UpdateTopology for functions that compute this relation
|
||||
\sa iterators
|
||||
*/
|
||||
|
||||
template <class T> class EEAdj: public T {
|
||||
public:
|
||||
|
|
@ -290,20 +312,7 @@ private:
|
|||
int _zp[2] ;
|
||||
};
|
||||
|
||||
|
||||
/*----------------------------- EHADJ ------------------------------*/
|
||||
template <class T> class EmptyEHAdj: public T {
|
||||
public:
|
||||
typename T::HEdgePointer &EHp( ) { static typename T::HEdgePointer hp=0; assert(0); return hp; }
|
||||
const typename T::HEdgePointer cEHp( ) const { static typename T::HEdgePointer hp=0; assert(0); return hp; }
|
||||
|
||||
template < class LeftV>
|
||||
void ImportData(const LeftV & left ) { T::ImportData( left); }
|
||||
static bool HasEHAdjacency() { return false; }
|
||||
static bool HasEHAdjacencyOcc() { return false; }
|
||||
static void Name(std::vector<std::string> & name){ T::Name(name);}
|
||||
};
|
||||
|
||||
template <class T> class EHAdj: public T {
|
||||
public:
|
||||
EHAdj(){_hp=0;}
|
||||
|
|
@ -320,70 +329,33 @@ private:
|
|||
typename T::HEdgePointer _hp ;
|
||||
};
|
||||
|
||||
/*----------------------------- ETADJ ------------------------------*/
|
||||
|
||||
|
||||
template <class T> class EmptyETAdj: public T {
|
||||
public:
|
||||
typename T::TetraPointer &ETp() { static typename T::TetraPointer tp = 0; assert(0); return tp; }
|
||||
typename T::TetraPointer cETp() { static typename T::TetraPointer tp = 0; assert(0); return tp; }
|
||||
int &VTi() { static int z = 0; return z; };
|
||||
static bool HasETAdjacency() { return false; }
|
||||
static bool HasETAdjacencyOcc() { return false; }
|
||||
static void Name( std::vector< std::string > & name ) { T::Name(name); }
|
||||
};
|
||||
|
||||
template <class T> class ETAdj: public T {
|
||||
public:
|
||||
ETAdj() { _tp = 0; }
|
||||
typename T::TetraPointer &ETp() { return _tp; }
|
||||
typename T::TetraPointer cETp() { return _tp; }
|
||||
int &ETi() {return _zp; }
|
||||
static bool HasETAdjacency() { return true; }
|
||||
static bool HasETAdjacencyOcc() { return true; }
|
||||
static void Name( std::vector< std::string > & name ) { name.push_back( std::string("ETAdj") ); T::Name(name); }
|
||||
|
||||
private:
|
||||
typename T::TetraPointer _tp ;
|
||||
int _zp ;
|
||||
};
|
||||
|
||||
|
||||
|
||||
/*----------------------------- EFADJ ------------------------------*/
|
||||
/*! \brief \em Component: \b Edge-Face adjacency relation
|
||||
This component implement store the pointer to a face sharing this edge.
|
||||
|
||||
template <class T> class EmptyEFAdj: public T {
|
||||
public:
|
||||
typename T::FacePointer &EFp() { static typename T::FacePointer fp=0; assert(0); return fp; }
|
||||
const typename T::FacePointer cEFp() const { static typename T::FacePointer fp=0; assert(0); return fp; }
|
||||
int &EFi() {static int z=0; return z;};
|
||||
const int &cEFi() const {static int z=0; return z;};
|
||||
template < class LeftV>
|
||||
void ImportData(const LeftV & left ) { T::ImportData( left); }
|
||||
static bool HasEFAdjacency() { return false; }
|
||||
static bool HasEFAdjacencyOcc() { return false; }
|
||||
static void Name(std::vector<std::string> & name){ T::Name(name);}
|
||||
};
|
||||
\sa vcg::tri::UpdateTopology for functions that compute this relation
|
||||
\sa iterators
|
||||
*/
|
||||
|
||||
template <class T> class EFAdj: public T {
|
||||
public:
|
||||
EFAdj(){_fp=0;}
|
||||
typename T::FacePointer &EFp() {return _fp; }
|
||||
const typename T::FacePointer cEFp() const {return _fp; }
|
||||
int &EFi() {static int z=0; return z;};
|
||||
const int &cEFi() const {return _zp; }
|
||||
template < class LeftV>
|
||||
void ImportData(const LeftV & left ) { T::ImportData( left); }
|
||||
typename T::FacePointer cEFp() const {return _fp; }
|
||||
int &EFi() {static int z=0; return z;}
|
||||
int cEFi() const {return _zp; }
|
||||
template < class LeftV>
|
||||
void ImportData(const LeftV & left ) { T::ImportData( left); }
|
||||
static bool HasEFAdjacency() { return true; }
|
||||
static bool HasEFAdjacencyOcc() { return true; }
|
||||
static void Name(std::vector<std::string> & name){name.push_back(std::string("EFAdj"));T::Name(name);}
|
||||
static void Name(std::vector<std::string> & name){name.push_back(std::string("EFAdj"));T::Name(name);}
|
||||
|
||||
private:
|
||||
typename T::FacePointer _fp ;
|
||||
int _zp ;
|
||||
};
|
||||
|
||||
|
||||
/** @} */ // End Doxygen EdgeComponentGroup
|
||||
} // end namespace edge
|
||||
}// end namespace vcg
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@
|
|||
|
||||
namespace vcg {
|
||||
namespace face {
|
||||
/** \addtogroup face
|
||||
/** \addtogroup FaceComponentGroup
|
||||
@{
|
||||
*/
|
||||
/*------------------------- EMPTY CORE COMPONENTS -----------------------------------------*/
|
||||
|
|
@ -154,11 +154,11 @@ public:
|
|||
static void Name(std::vector<std::string> & name){T::Name(name);}
|
||||
};
|
||||
|
||||
/*-------------------------- VertexRef ----------------------------------------*/
|
||||
/*-------------------------- VertexRef ----------------------------------------*/
|
||||
/*! \brief The references to the vertexes of a triangular face
|
||||
|
||||
Stored as three pointers to the VertexType
|
||||
*/
|
||||
*
|
||||
* Stored as three pointers to the VertexType
|
||||
*/
|
||||
|
||||
|
||||
template <class T> class VertexRef: public T {
|
||||
|
|
@ -442,6 +442,11 @@ public: static void Name(std::vector<std::string> & name){name.push_back(std::s
|
|||
};
|
||||
|
||||
/*-------------------------- INCREMENTAL MARK ----------------------------------------*/
|
||||
/*! \brief Per vertex \b Incremental \b Mark
|
||||
|
||||
It is just an int that allows to efficently un-mark the whole mesh. \sa UnmarkAll
|
||||
*/
|
||||
|
||||
template <class T> class Mark: public T {
|
||||
public:
|
||||
static bool HasMark() { return true; }
|
||||
|
|
@ -530,6 +535,35 @@ private:
|
|||
char _vfi[3] ;
|
||||
};
|
||||
|
||||
/*----------------------------- EFADJ ------------------------------*/
|
||||
template <class T> class EFAdj: public T {
|
||||
public:
|
||||
EFAdj(){
|
||||
_efp[0]=0;
|
||||
_efp[1]=0;
|
||||
_efp[2]=0;
|
||||
_efi[0]=-1;
|
||||
_efi[1]=-1;
|
||||
_efi[2]=-1;
|
||||
}
|
||||
typename T::FacePointer &EFp(const int j) { assert(j>=0 && j<3); return _efp[j]; }
|
||||
typename T::FacePointer const EFp(const int j) const { assert(j>=0 && j<3); return _efp[j]; }
|
||||
typename T::FacePointer const cEFp(const int j) const { assert(j>=0 && j<3); return _efp[j]; }
|
||||
char &VFi(const int j) {return _efi[j]; }
|
||||
template <class RightF>
|
||||
void ImportData(const RightF & rightF){T::ImportData(rightF);}
|
||||
inline void Alloc(const int & ns){T::Alloc(ns);}
|
||||
inline void Dealloc(){T::Dealloc();}
|
||||
static bool HasEFAdjacency() { return true; }
|
||||
static bool HasEFAdjacencyOcc() { return false; }
|
||||
static void Name(std::vector<std::string> & name){name.push_back(std::string("EFAdj"));T::Name(name);}
|
||||
|
||||
private:
|
||||
typename T::FacePointer _efp[3] ;
|
||||
char _efi[3] ;
|
||||
};
|
||||
|
||||
|
||||
/*----------------------------- FFADJ ------------------------------*/
|
||||
template <class T> class FFAdj: public T {
|
||||
public:
|
||||
|
|
@ -564,6 +598,7 @@ private:
|
|||
|
||||
|
||||
/*----------------------------- FEADJ ------------------------------*/
|
||||
|
||||
template <class T> class FEAdj: public T {
|
||||
public:
|
||||
FEAdj(){
|
||||
|
|
@ -574,10 +609,8 @@ public:
|
|||
typename T::EdgePointer &FEp(const int j) { assert(j>=0 && j<3); return _fep[j]; }
|
||||
typename T::EdgePointer const FEp(const int j) const { assert(j>=0 && j<3); return _fep[j]; }
|
||||
typename T::EdgePointer const cFEp(const int j) const { assert(j>=0 && j<3); return _fep[j]; }
|
||||
char &FEi(const int j) { return _fei[j]; }
|
||||
const char &cFEi(const int j) const { return _fei[j]; }
|
||||
|
||||
typename T::EdgePointer &FEp1( const int j ) { return FEp((j+1)%3);}
|
||||
typename T::EdgePointer &FEp1( const int j ) { return FEp((j+1)%3);}
|
||||
typename T::EdgePointer &FEp2( const int j ) { return FEp((j+2)%3);}
|
||||
typename T::EdgePointer const FEp1( const int j ) const { return FEp((j+1)%3);}
|
||||
typename T::EdgePointer const FEp2( const int j ) const { return FEp((j+2)%3);}
|
||||
|
|
@ -612,6 +645,7 @@ public:
|
|||
private:
|
||||
typename T::HEdgePointer _fh ;
|
||||
};
|
||||
/** @} */ // End Doxygen FaceComponentGroup
|
||||
} // end namespace face
|
||||
}// end namespace vcg
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -56,8 +56,8 @@ template <class UserTypes,
|
|||
template <typename> class C, template <typename> class D,
|
||||
template <typename> class E, template <typename> class F,
|
||||
template <typename> class G, template <typename> class H,
|
||||
template <typename> class I, template <typename> class J,
|
||||
template <typename> class K, template <typename> class L>
|
||||
template <typename> class I, template <typename> class J,
|
||||
template <typename> class K, template <typename> class L>
|
||||
class VertexArityMax: public Arity12<vertex::EmptyCore<UserTypes>, A, B, C, D, E, F, G, H, I, J, K, L> {
|
||||
|
||||
// ----- Flags stuff -----
|
||||
|
|
@ -77,13 +77,13 @@ public:
|
|||
USER0 = 0x0200 // First user bit
|
||||
};
|
||||
|
||||
bool IsD() const {return (this->Flags() & DELETED) != 0;} /// checks if the vertex is deleted
|
||||
bool IsR() const {return (this->Flags() & NOTREAD) == 0;} /// checks if the vertex is readable
|
||||
bool IsW() const {return (this->Flags() & NOTWRITE)== 0;}/// checks if the vertex is modifiable
|
||||
bool IsRW() const {return (this->Flags() & (NOTREAD | NOTWRITE)) == 0;}/// This funcion checks whether the vertex is both readable and modifiable
|
||||
bool IsS() const {return (this->Flags() & SELECTED) != 0;}/// checks if the vertex is Selected
|
||||
bool IsB() const {return (this->Flags() & BORDER) != 0;}/// checks if the vertex is a border one
|
||||
bool IsV() const {return (this->Flags() & VISITED) != 0;}/// checks if the vertex Has been visited
|
||||
bool IsD() const {return (this->cFlags() & DELETED) != 0;} /// checks if the vertex is deleted
|
||||
bool IsR() const {return (this->cFlags() & NOTREAD) == 0;} /// checks if the vertex is readable
|
||||
bool IsW() const {return (this->cFlags() & NOTWRITE)== 0;}/// checks if the vertex is modifiable
|
||||
bool IsRW() const {return (this->cFlags() & (NOTREAD | NOTWRITE)) == 0;}/// This funcion checks whether the vertex is both readable and modifiable
|
||||
bool IsS() const {return (this->cFlags() & SELECTED) != 0;}/// checks if the vertex is Selected
|
||||
bool IsB() const {return (this->cFlags() & BORDER) != 0;}/// checks if the vertex is a border one
|
||||
bool IsV() const {return (this->cFlags() & VISITED) != 0;}/// checks if the vertex Has been visited
|
||||
|
||||
|
||||
/** Set the flag value
|
||||
|
|
|
|||
|
|
@ -27,7 +27,7 @@
|
|||
#define __VCG_VERTEX_PLUS_COMPONENT
|
||||
namespace vcg {
|
||||
namespace vertex {
|
||||
/** \addtogroup vertex
|
||||
/** \addtogroup VertexComponentGroup
|
||||
@{
|
||||
*/
|
||||
/*------------------------- Base Classes -----------------------------------------*/
|
||||
|
|
@ -47,19 +47,18 @@ template <class TT> class EmptyCore: public TT {
|
|||
public:
|
||||
typedef int FlagType;
|
||||
int &Flags() { static int dummyflags(0); assert(0); return dummyflags; }
|
||||
int Flags() const { return 0; }
|
||||
int cFlags() const { return 0; }
|
||||
static bool HasFlags() { return false; }
|
||||
|
||||
typedef vcg::Point3f CoordType;
|
||||
typedef CoordType::ScalarType ScalarType;
|
||||
CoordType &P() { static CoordType coord(0, 0, 0); return coord; }
|
||||
const CoordType &P() const { static CoordType coord(0, 0, 0); assert(0); return coord; }
|
||||
const CoordType &cP() const { static CoordType coord(0, 0, 0); assert(0); return coord; }
|
||||
CoordType cP() const { static CoordType coord(0, 0, 0); assert(0); return coord; }
|
||||
static bool HasCoord() { return false; }
|
||||
|
||||
typedef vcg::Point3s NormalType;
|
||||
NormalType &N() { static NormalType dummy_normal(0, 0, 0); assert(0); return dummy_normal; }
|
||||
const NormalType cN()const { static NormalType dummy_normal(0, 0, 0); assert(0); return dummy_normal; }
|
||||
NormalType cN() const { static NormalType dummy_normal(0, 0, 0); assert(0); return dummy_normal; }
|
||||
static bool HasNormal() { return false; }
|
||||
static bool HasNormalOcf() { return false; }
|
||||
|
||||
|
|
@ -79,16 +78,15 @@ public:
|
|||
|
||||
typedef int MarkType;
|
||||
inline void InitIMark() { }
|
||||
inline const int & cIMark() const { assert(0); static int tmp=-1; return tmp;}
|
||||
inline int & IMark() { assert(0); static int tmp=-1; return tmp;}
|
||||
inline int IMark() const {return 0;}
|
||||
inline int cIMark() const { assert(0); static int tmp=-1; return tmp;}
|
||||
inline int &IMark() { assert(0); static int tmp=-1; return tmp;}
|
||||
static bool HasMark() { return false; }
|
||||
static bool HasMarkOcf() { return false; }
|
||||
static bool IsMarkEnabled(const typename TT::VertexType *) { return false; }
|
||||
static bool IsMarkEnabled(const typename TT::VertexType *) { return false; }
|
||||
|
||||
typedef ScalarType RadiusType;
|
||||
RadiusType &R(){ static ScalarType v = 0.0; assert(0 && "the radius component is not available"); return v; }
|
||||
const RadiusType &cR() const { static const ScalarType v = 0.0; assert(0 && "the radius component is not available"); return v; }
|
||||
RadiusType &R() { static ScalarType v = 0.0; assert(0 && "the radius component is not available"); return v; }
|
||||
RadiusType cR() const { static const ScalarType v = 0.0; assert(0 && "the radius component is not available"); return v; }
|
||||
static bool HasRadius() { return false; }
|
||||
static bool HasRadiusOcf() { return false; }
|
||||
static bool IsRadiusEnabled(const typename TT::VertexType *) { return false; }
|
||||
|
|
@ -100,18 +98,18 @@ public:
|
|||
static bool IsTexCoordEnabled(const typename TT::VertexType *) { return false; }
|
||||
|
||||
typename TT::TetraPointer &VTp() { static typename TT::TetraPointer tp = 0; assert(0); return tp; }
|
||||
const typename TT::TetraPointer cVTp()const { static typename TT::TetraPointer tp = 0; assert(0); return tp; }
|
||||
typename TT::TetraPointer cVTp() const { static typename TT::TetraPointer tp = 0; assert(0); return tp; }
|
||||
int &VTi() { static int z = 0; return z; }
|
||||
static bool HasVTAdjacency() { return false; }
|
||||
|
||||
typename TT::FacePointer &VFp() { static typename TT::FacePointer fp=0; assert(0); return fp; }
|
||||
const typename TT::FacePointer cVFp() const { static typename TT::FacePointer fp=0; assert(0); return fp; }
|
||||
int &VFi(){static int z=0; assert(0); return z;}
|
||||
int &VFi() {static int z=0; assert(0); return z;}
|
||||
int cVFi() const {static int z=0; assert(0); return z;}
|
||||
static bool HasVFAdjacency() { return false; }
|
||||
|
||||
typename TT::EdgePointer &VEp() { static typename TT::EdgePointer ep=0; assert(0); return ep; }
|
||||
const typename TT::EdgePointer cVEp() const { static typename TT::EdgePointer ep=0; assert(0); return ep; }
|
||||
const typename TT::EdgePointer cVEp() const { static typename TT::EdgePointer ep=0; assert(0); return ep; }
|
||||
int &VEi(){static int z=0; return z;}
|
||||
static bool HasVEAdjacency() { return false; }
|
||||
|
||||
|
|
@ -221,7 +219,7 @@ public: static void Name(std::vector<std::string> & name){name.push_back(std::st
|
|||
/*-------------------------- INCREMENTAL MARK ----------------------------------------*/
|
||||
/*! \brief Per vertex \b Incremental \b Mark
|
||||
|
||||
It is just an int that allow to efficent un-marking of the whole mesh. \sa UnmarkAll
|
||||
It is just an int that allows to efficently un-mark the whole mesh. \sa UnmarkAll
|
||||
*/
|
||||
|
||||
template <class T> class Mark: public T {
|
||||
|
|
@ -296,11 +294,10 @@ private:
|
|||
|
||||
/*-------------------------- Color ----------------------------------*/
|
||||
/*! \brief \em Component: Per vertex \b Color
|
||||
|
||||
Usually most of the library expects a color stored as 4 unsigned chars (so the component you use is a \c vertex::Color4b)
|
||||
but you can also use float for the color components.
|
||||
*/
|
||||
|
||||
*
|
||||
* Usually most of the library expects a color stored as 4 unsigned chars (so the component you use is a \c vertex::Color4b)
|
||||
* but you can also use float for the color components.
|
||||
*/
|
||||
template <class A, class T> class Color: public T {
|
||||
public:
|
||||
Color():_color(vcg::Color4b::White) {}
|
||||
|
|
@ -563,11 +560,7 @@ private:
|
|||
int _zp ;
|
||||
};
|
||||
|
||||
/**
|
||||
@}
|
||||
*/
|
||||
|
||||
|
||||
/** @} */ // End Doxygen VertexComponentGroup
|
||||
} // end namespace vert
|
||||
}// end namespace vcg
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -431,7 +431,7 @@ public:
|
|||
{
|
||||
//if((*this).Base().MarkEnabled && leftV.Base().MarkEnabled ) // WRONG I do not know anything about leftV!
|
||||
if((*this).Base().MarkEnabled) // copy the data only if they are enabled in both vertices
|
||||
IMark() = leftV.IMark();
|
||||
IMark() = leftV.cIMark();
|
||||
T::ImportData(leftV);
|
||||
}
|
||||
static bool HasMark() { return true; }
|
||||
|
|
|
|||
Loading…
Reference in New Issue