manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[ Changes in definition of TriMesh: PART I ] 

Note for the developers: the change to make to existing projects is very little 
but strictly necessary to compile. This change IS NOT backward compliant.


==== OLD ==== way to define a TriMesh:

// forward declarations
class MyVertex;
class MyEdge;
class MyFace;

class MyVertex: public VertexSimp2 < MyVertex, MyEdge, MyFace, vertex::Coord3f,...other components>{};
class MyFace: public FaceSimp2 < MyVertex, MyEdge, MyFace, face::VertexRef,...other components>{};
class MyMesh: public TriMesh<vector<MyVertex>,vector<MyFace> >{};


==== NEW ==== way to define a TriMesh:
// forward declarations
class MyVertex;
class MyEdge;
class MyFace;

// declaration of which types is used as VertexType, which type is used as FaceType and so on...
class MyUsedTypes: public vcg::UsedType < vcg::Use<MyVertex>::AsVertexType,
                                          vcg::Use<MyFace>::AsFaceType>{};

class MyVertex: public Vertex < MyUsedTypes, vertex::Coord3f,...other components>{};
class MyFace: public Face < MyUsedTypes, face::VertexRef,...other components>{};
class MyMesh: public TriMesh<vector<MyVertex>,vector<MyFace> >{};

                                 
===== classes introduced          
[vcg::UsedType] : it is a class containing all the types that must be passed to the definition of Vertex, Face, Edge... This
class replaces the list of typenames to pass as first templates and the need to specify the maximal simplicial. So 

<MyVertex, MyEdge, MyFace  becomes <MyUsedTypes<

and 

VertexSimp2 becomes Vertex

[vcg::Use] : an auxiliary class to give a simple way to specify the role of a type

Note 2: the order of templates parameters to vcg::UsedTypes is unimportant, e.g:

class MyUsedTypes: public vcg::UsedType <vcg::Use<MyVertex>::AsVertexType,
                                         vcg::Use<MyEdge>::AsEdgeType,
                                         vcg::Use<MyFace>::AsFaceType>{};

is the same as:
class MyUsedTypes: public vcg::UsedType <vcg::Use<MyFace>::AsFaceType,
                                         vcg::Use<MyEdge>::AsEdgeType,
                                         vcg::Use<MyVertex>::AsVertexType>{};

Note 3: you only need to specify the type  you use. If you do not have edges you do not need 
to include vcg::Use<MyEdge>::AsEdgeType in the template list of UsedTypes.
==== the Part II will be a tiny change to the class TriMesh it self.
This commit is contained in:
ganovelli 2010-03-15 10:42:52 +00:00
parent cdfed059d3
commit c40a6c3d97
9 changed files with 115 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
vcg/complex/trimesh/base.h
View File

@ -142,6 +142,8 @@ Initial commit
#include <vcg/container/simple_temporary_data.h> #include <vcg/container/simple_temporary_data.h>
#include <vcg/simplex/edge/base.h> #include <vcg/simplex/edge/base.h>
#include <vcg/complex/used_types.h>
/* /*
People should subclass his vertex class from these one... People should subclass his vertex class from these one...
*/ */
@ -175,18 +177,24 @@ class TriMeshEdgeHolder{
}; };
// a dummy class is used to provide the interface of a stl container // a dummy class is used to provide the interface of a stl container
class DummyClass:public std::vector<int>{}; class DummyClass:public std::vector<int>{
};
// If the DummyClass is passed it provides the interfaces to compile // If the DummyClass is passed it provides the interfaces to compile
template < class VertContainerType, class FaceContainerType > template < class VertContainerType, class FaceContainerType >
class TriMeshEdgeHolder<VertContainerType,FaceContainerType,DummyClass>{ class TriMeshEdgeHolder<VertContainerType,FaceContainerType,DummyClass>{
public: public:
class EdgeType: public EdgeSimp2< typename VertContainerType::value_type,EdgeType,typename FaceContainerType::value_type >{};
typedef typename FaceContainerType::value_type::EdgeType EdgeTypeExternal; struct OthersTypes : public UsedTypes< Use<typename VertContainerType::value_type>::template AsVertexType,
struct EdgePointer {}; Use<typename FaceContainerType::value_type>::template AsFaceType
struct ConstEdgePointer {}; >{};
class EdgeType: public Edge< OthersTypes >{};
struct EdgePointer {};
struct ConstEdgePointer {};
typedef std::vector< EdgeType > EdgeContainerType; typedef std::vector< EdgeType > EdgeContainerType;
typedef typename std::vector< EdgeType > EdgeContainer; typedef typename std::vector< EdgeType > EdgeContainer;
}; };

45
vcg/simplex/edge/base.h
View File

@ -38,19 +38,10 @@ The base class of all the recusive definition chain. It is just a container of t
These typenames must be known form all the derived classes. These typenames must be known form all the derived classes.
*/ */
template <class BVT, class BET, class BFT, class BTT> template <class UserTypes>
class EdgeTypeHolder{ class EdgeTypeHolder: public UserTypes{
public: public:
typedef BVT VertexType;
typedef typename VertexType::CoordType CoordType;
typedef typename VertexType::ScalarType ScalarType;
typedef BET EdgeType;
typedef BFT FaceType;
typedef BTT TetraType;
typedef BVT *VertexPointer;
typedef BET *EdgePointer;
typedef BFT *FacePointer;
typedef BTT *TetraPointer;
template < class LeftV> template < class LeftV>
void ImportLocal(const LeftV & /* left */ ) { } void ImportLocal(const LeftV & /* left */ ) { }
static void Name(std::vector<std::string> & name){} static void Name(std::vector<std::string> & name){}
@ -69,12 +60,12 @@ we have to build the type a step a time (deriving from a single ancestor at a ti
*/ */
template <class BVT, class BET=DumClass, class BFT=DumClass, class BTT=DumClass> template <class UserTypes>
class EdgeBase: public edge::EmptyEVAdj< class EdgeBase: public edge::EmptyEVAdj<
edge::EmptyEEAdj< edge::EmptyEEAdj<
edge::EmptyHEdgeData< edge::EmptyHEdgeData<
edge::EmptyBitFlags< edge::EmptyBitFlags<
EdgeTypeHolder <BVT, BET, BFT, BTT> > > > > { EdgeTypeHolder < UserTypes> > > > > {
}; };
@ -90,14 +81,14 @@ I.e. IsD() that uses the overridden Flags() member must be defined here.
*/ */
template <class BVT, class BET, typename BFT,class BTT, template <class UserTypes,
template <typename> class A, template <typename> class B, template <typename> class A, template <typename> class B,
template <typename> class C, template <typename> class D, template <typename> class C, template <typename> class D,
template <typename> class E, template <typename> class F, template <typename> class E, template <typename> class F,
template <typename> class G, template <typename> class H, template <typename> class G, template <typename> class H,
template <typename> class I, template <typename> class J, template <typename> class I, template <typename> class J,
template <typename> class K> template <typename> class K>
class EdgeArityMax: public K<Arity10<EdgeBase,BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I, J> > { class EdgeArityMax: public K<Arity10<EdgeBase<UserTypes>, A, B, C, D, E, F, G, H, I, J> > {
// ----- Flags stuff ----- // ----- Flags stuff -----
public: public:
@ -218,32 +209,14 @@ Qualitys, Qualityf, Qualityd
VFAdj //topology (vertex->face adjacency) VFAdj //topology (vertex->face adjacency)
*/ */
template <class BVT, class BET, class BFT, class BTT, template <class UserTypes,
template <typename> class A = DefaultDeriver, template <typename> class B = DefaultDeriver, template <typename> class A = DefaultDeriver, template <typename> class B = DefaultDeriver,
template <typename> class C = DefaultDeriver, template <typename> class D = DefaultDeriver, template <typename> class C = DefaultDeriver, template <typename> class D = DefaultDeriver,
template <typename> class E = DefaultDeriver, template <typename> class F = DefaultDeriver, template <typename> class E = DefaultDeriver, template <typename> class F = DefaultDeriver,
template <typename> class G = DefaultDeriver, template <typename> class H = DefaultDeriver, template <typename> class G = DefaultDeriver, template <typename> class H = DefaultDeriver,
template <typename> class I = DefaultDeriver, template <typename> class J = DefaultDeriver, template <typename> class I = DefaultDeriver, template <typename> class J = DefaultDeriver,
template <typename> class K = DefaultDeriver> template <typename> class K = DefaultDeriver>
class EdgeSimp3: public EdgeArityMax<BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I, J, K> {}; class Edge: public EdgeArityMax<UserTypes, A, B, C, D, E, F, G, H, I, J, K> {};
template <class BVT, class BET, class BFT,
template <typename> class A = DefaultDeriver, template <typename> class B = DefaultDeriver,
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 EdgeSimp2: public EdgeArityMax<BVT,BET,BFT,DumClass, A, B, C, D, E, F, G, H, I, J, K> {};
template <class BVT, class BET,
template <typename> class A = DefaultDeriver, template <typename> class B = DefaultDeriver,
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 EdgeSimp1: public EdgeArityMax<BVT,BET,DumClass,DumClass, A, B, C, D, E, F, G, H, I, J, K> {};
}// end namespace }// end namespace
#endif #endif

2
vcg/simplex/edge/component.h
View File

@ -24,7 +24,7 @@
#ifndef __VCG_EDGE_PLUS_COMPONENT #ifndef __VCG_EDGE_PLUS_COMPONENT
#define __VCG_EDGE_PLUS_COMPONENT #define __VCG_EDGE_PLUS_COMPONENT
//#include <vector> //#include <vector>
//#include <string> #include <string>
//#include <vcg/space/point3.h> //#include <vcg/space/point3.h>
//#include <vcg/space/texcoord2.h> //#include <vcg/space/texcoord2.h>
#include <vcg/space/color4.h> #include <vcg/space/color4.h>

35
vcg/simplex/face/base.h
View File

@ -89,19 +89,10 @@ The base class of all the recusive definition chain. It is just a container of t
These typenames must be known form all the derived classes. These typenames must be known form all the derived classes.
*/ */
template <class BVT, class BET, class BFT, class BTT> template <class UserTypes>
class FaceTypeHolder{ class FaceTypeHolder: public UserTypes {
public: public:
typedef BVT VertexType;
typedef typename VertexType::CoordType CoordType;
typedef typename VertexType::ScalarType ScalarType;
typedef BET EdgeType;
typedef BFT FaceType;
typedef BTT TetraType;
typedef BVT *VertPointer;
typedef BET *EdgePointer;
typedef BFT *FacePointer;
typedef BTT *TetraPointer;
template <class LeftF> template <class LeftF>
void ImportLocal(const LeftF & ){} void ImportLocal(const LeftF & ){}
static void Name(std::vector<std::string> & /* name */){} static void Name(std::vector<std::string> & /* name */){}
@ -127,7 +118,7 @@ we have to build the type a step a time (deriving from a single ancestor at a ti
*/ */
template <class BVT, class BET=DumClass, class BFT=DumClass, class BTT=DumClass> template <class UserTypes>
class FaceBase: public face::EmptyPolyInfo< class FaceBase: public face::EmptyPolyInfo<
face::EmptyVertexRef< face::EmptyVertexRef<
face::EmptyAdj< face::EmptyAdj<
@ -135,7 +126,7 @@ class FaceBase: public face::EmptyPolyInfo<
face::EmptyNormal< face::EmptyNormal<
face::EmptyBitFlags< face::EmptyBitFlags<
face::EmptyWedgeTexCoord< face::EmptyWedgeTexCoord<
FaceTypeHolder <BVT, BET, BFT, BTT> > > > > > > > { FaceTypeHolder <UserTypes> > > > > > > > {
}; };
@ -152,13 +143,13 @@ I.e. IsD() that uses the overridden Flags() member must be defined here.
*/ */
template <class BVT, class BET, typename BFT,class BTT, template < class UserTypes,
template <typename> class A, template <typename> class B, template <typename> class A, template <typename> class B,
template <typename> class C, template <typename> class D, template <typename> class C, template <typename> class D,
template <typename> class E, template <typename> class F, template <typename> class E, template <typename> class F,
template <typename> class G, template <typename> class H, template <typename> class G, template <typename> class H,
template <typename> class I, template <typename> class J > template <typename> class I, template <typename> class J >
class FaceArityMax: public I<Arity9<FaceBase,BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, J> > { class FaceArityMax: public J<Arity9<FaceBase<UserTypes>, A, B, C, D, E, F, G, H, I> > {
// ----- Flags stuff ----- // ----- Flags stuff -----
public: public:
@ -346,21 +337,13 @@ FFAdj //topology: face face adj
*/ */
template <class BVT, class BET, class BFT, class BTT, template <class UserTypes,
template <typename> class A = FaceDefaultDeriver, template <typename> class B = FaceDefaultDeriver, template <typename> class A = FaceDefaultDeriver, template <typename> class B = FaceDefaultDeriver,
template <typename> class C = FaceDefaultDeriver, template <typename> class D = FaceDefaultDeriver, template <typename> class C = FaceDefaultDeriver, template <typename> class D = FaceDefaultDeriver,
template <typename> class E = FaceDefaultDeriver, template <typename> class F = FaceDefaultDeriver, template <typename> class E = FaceDefaultDeriver, template <typename> class F = FaceDefaultDeriver,
template <typename> class G = FaceDefaultDeriver, template <typename> class H = FaceDefaultDeriver, template <typename> class G = FaceDefaultDeriver, template <typename> class H = FaceDefaultDeriver,
template <typename> class I = FaceDefaultDeriver, template <typename> class J = FaceDefaultDeriver > template <typename> class I = FaceDefaultDeriver, template <typename> class J = FaceDefaultDeriver >
class FaceSimp3: public FaceArityMax<BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I, J> {}; class Face: public FaceArityMax<UserTypes, A, B, C, D, E, F, G, H, I, J> {};
class DumTT;
template <class BVT, class BET, class BFT,
template <typename> class A = FaceDefaultDeriver, template <typename> class B = FaceDefaultDeriver,
template <typename> class C = FaceDefaultDeriver, template <typename> class D = FaceDefaultDeriver,
template <typename> class E = FaceDefaultDeriver, template <typename> class F = FaceDefaultDeriver,
template <typename> class G = FaceDefaultDeriver, template <typename> class H = FaceDefaultDeriver,
template <typename> class I = FaceDefaultDeriver, template <typename> class J = FaceDefaultDeriver >
class FaceSimp2: public FaceArityMax<BVT,BET,BFT,DumTT, A, B, C, D, E, F, G, H, I, J> {};
}// end namespace }// end namespace

2
vcg/simplex/face/component_ocf.h
View File

@ -519,7 +519,7 @@ public:
assert((*this).Base().FFAdjacencyEnabled); assert((*this).Base().FFAdjacencyEnabled);
return (*this).Base().AF[(*this).Index()]._zp[j]; return (*this).Base().AF[(*this).Index()]._zp[j];
} }
const char cFFi(const int j) const { char cFFi(const int j) const {
assert((*this).Base().FFAdjacencyEnabled); assert((*this).Base().FFAdjacencyEnabled);
return (*this).Base().AF[(*this).Index()]._zp[j]; return (*this).Base().AF[(*this).Index()]._zp[j];
} }

2
vcg/simplex/face/component_polygon.h
View File

@ -147,7 +147,7 @@ public:
static void Name(std::vector<std::string> & name){name.push_back(std::string("PFVAdj"));T::Name(name);} static void Name(std::vector<std::string> & name){name.push_back(std::string("PFVAdj"));T::Name(name);}
private: private:
typename T::VertPointer *_vpoly; typename T::VertexPointer *_vpoly;
}; };
/*----------------------------- PVFADJ ------------------------------*/ /*----------------------------- PVFADJ ------------------------------*/

66
vcg/simplex/vertex/base.h
View File

@ -81,23 +81,23 @@ namespace vcg {
The base class of all the recusive definition chain. It is just a container of the typenames of the various simplexes. The base class of all the recusive definition chain. It is just a container of the typenames of the various simplexes.
These typenames must be known form all the derived classes. These typenames must be known form all the derived classes.
*/ */
//
template <class BVT, class BET, class BFT, class BTT> //template <class BVT, class BET, class BFT, class BTT>
class VertexTypeHolder{ //class VertexTypeHolder{
public: // public:
typedef BVT VertType; // typedef BVT VertType;
typedef BET EdgeType; // typedef BET EdgeType;
typedef BFT FaceType; // typedef BFT FaceType;
typedef BTT TetraType; // typedef BTT TetraType;
typedef BVT *VertPointer; // typedef BVT *VertPointer;
typedef BET *EdgePointer; // typedef BET *EdgePointer;
typedef BFT *FacePointer; // typedef BFT *FacePointer;
typedef BTT *TetraPointer; // typedef BTT *TetraPointer;
template < class LeftV> // template < class LeftV>
void ImportLocal(const LeftV & /* left */ ) { } // void ImportLocal(const LeftV & /* left */ ) { }
static void Name(std::vector<std::string> & /* name */){} // static void Name(std::vector<std::string> & /* name */){}
//
}; //};
/* The base class form which we start to add our components. /* The base class form which we start to add our components.
it has the empty definition for all the standard members (coords, color flags) it has the empty definition for all the standard members (coords, color flags)
@ -111,9 +111,9 @@ we have to build the type a step a time (deriving from a single ancestor at a ti
*/ */
template <class BVT, class BET=DumClass, class BFT=DumClass, class BTT=DumClass> //template <class UserUsedTypes>
class VertexBase: public vertex::EmptyCore< VertexTypeHolder <BVT, BET, BFT, BTT> >{ //class VertexBase: public vertex::EmptyCore< UserUsedTypes >{
}; //};
/* The Real Big Vertex class; /* The Real Big Vertex class;
@ -128,14 +128,14 @@ I.e. IsD() that uses the overridden Flags() member must be defined here.
*/ */
template <class BVT, class BET, typename BFT,class BTT, template <class UserTypes,
template <typename> class A, template <typename> class B, template <typename> class A, template <typename> class B,
template <typename> class C, template <typename> class D, template <typename> class C, template <typename> class D,
template <typename> class E, template <typename> class F, template <typename> class E, template <typename> class F,
template <typename> class G, template <typename> class H, template <typename> class G, template <typename> class H,
template <typename> class I, template <typename> class J, template <typename> class I, template <typename> class J,
template <typename> class K, template <typename> class L> template <typename> class K, template <typename> class L>
class VertexArityMax: public Arity12<VertexBase,BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I, J, K, L> { class VertexArityMax: public Arity12<vertex::EmptyCore<UserTypes>, A, B, C, D, E, F, G, H, I, J, K, L> {
// ----- Flags stuff ----- // ----- Flags stuff -----
public: public:
@ -253,32 +253,14 @@ Qualitys, Qualityf, Qualityd
VFAdj //topology (vertex->face adjacency) VFAdj //topology (vertex->face adjacency)
*/ */
template <class BVT, class BET, class BFT, class BTT, template <class UserTypes,
template <typename> class A = DefaultDeriver, template <typename> class B = DefaultDeriver, template <typename> class A = DefaultDeriver, template <typename> class B = DefaultDeriver,
template <typename> class C = DefaultDeriver, template <typename> class D = DefaultDeriver, template <typename> class C = DefaultDeriver, template <typename> class D = DefaultDeriver,
template <typename> class E = DefaultDeriver, template <typename> class F = DefaultDeriver, template <typename> class E = DefaultDeriver, template <typename> class F = DefaultDeriver,
template <typename> class G = DefaultDeriver, template <typename> class H = DefaultDeriver, template <typename> class G = DefaultDeriver, template <typename> class H = DefaultDeriver,
template <typename> class I = DefaultDeriver, template <typename> class J = DefaultDeriver, template <typename> class I = DefaultDeriver, template <typename> class J = DefaultDeriver,
template <typename> class K = DefaultDeriver, template <typename> class L = DefaultDeriver> template <typename> class K = DefaultDeriver, template <typename> class L = DefaultDeriver>
class VertexSimp3: public VertexArityMax<BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I, J, K, L> {}; class Vertex: public VertexArityMax<UserTypes, A, B, C, D, E, F, G, H, I, J, K, L> {};
template <class BVT, class BET, class BFT,
template <typename> class A = DefaultDeriver, template <typename> class B = DefaultDeriver,
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, template <typename> class L = DefaultDeriver>
class VertexSimp2: public VertexArityMax<BVT,BET,BFT,DumClass, A, B, C, D, E, F, G, H, I, J, K, L> {};
template <class BVT, class BET,
template <typename> class A = DefaultDeriver, template <typename> class B = DefaultDeriver,
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, template <typename> class L = DefaultDeriver>
class VertexSimp1: public VertexArityMax<BVT,BET,DumClass,DumClass, A, B, C, D, E, F, G, H, I, J, K, L> {};
}// end namespace }// end namespace
#endif #endif

92
vcg/simplex/vertex/component.h
View File

@ -36,6 +36,42 @@ All the Components that can be added to a vertex should be defined in the namesp
*/ */
/*-------------------------- Curvature ----------------------------------*/
template <class S>
struct CurvatureDirBaseType{
typedef Point3<S> VecType;
typedef S ScalarType;
CurvatureDirBaseType () {}
Point3<S>max_dir,min_dir; // max and min curvature direction
S k1,k2;// max and min curvature values
};
template <class A, class TT> class Curvature: public TT {
public:
typedef Point2<A> CurvatureType;
typedef typename CurvatureType::ScalarType ScalarType;
ScalarType &Kh(){ return _hk[0];}
ScalarType &Kg(){ return _hk[1];}
const ScalarType &cKh() const { return _hk[0];}
const ScalarType &cKg() const { return _hk[1];}
static bool HasCurvature() { return true; }
static bool IsCurvatureEnabled(typename TT::VertexType *) { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("Curvature"));TT::Name(name);}
private:
Point2<A> _hk;
};
template <class T> class Curvaturef: public Curvature< float, T> {
public: static void Name(std::vector<std::string> & name){name.push_back(std::string("Curvaturef"));T::Name(name);}
};
template <class T> class Curvatured: public Curvature<double , T> {
public: static void Name(std::vector<std::string> & name){name.push_back(std::string("Curvatured"));T::Name(name);}
};
/*------------------------- EMPTY CORE COMPONENTS -----------------------------------------*/ /*------------------------- EMPTY CORE COMPONENTS -----------------------------------------*/
template <class TT> class EmptyCore: public TT { template <class TT> class EmptyCore: public TT {
@ -63,14 +99,14 @@ public:
const QualityType &cQ() const { static QualityType dummyQuality(0); assert(0); return dummyQuality; } const QualityType &cQ() const { static QualityType dummyQuality(0); assert(0); return dummyQuality; }
static bool HasQuality() { return false; } static bool HasQuality() { return false; }
static bool HasQualityOcf() { return false; } static bool HasQualityOcf() { return false; }
static bool IsQualityEnabled(const typename TT::VertType *) { return false; } static bool IsQualityEnabled(const typename TT::VertexType *) { return false; }
typedef vcg::Color4b ColorType; typedef vcg::Color4b ColorType;
ColorType &C() { static ColorType dumcolor(vcg::Color4b::White); assert(0); return dumcolor; } ColorType &C() { static ColorType dumcolor(vcg::Color4b::White); assert(0); return dumcolor; }
const ColorType &cC() const { static ColorType dumcolor(vcg::Color4b::White); assert(0); return dumcolor; } const ColorType &cC() const { static ColorType dumcolor(vcg::Color4b::White); assert(0); return dumcolor; }
static bool HasColor() { return false; } static bool HasColor() { return false; }
static bool HasColorOcf() { return false; } static bool HasColorOcf() { return false; }
static bool IsColorEnabled(const typename TT::VertType *) { return false; } static bool IsColorEnabled(const typename TT::VertexType *) { return false; }
inline void InitIMark() { } inline void InitIMark() { }
inline const int & cIMark() const { assert(0); static int tmp=-1; return tmp;} inline const int & cIMark() const { assert(0); static int tmp=-1; return tmp;}
@ -78,20 +114,20 @@ public:
inline int IMark() const {return 0;} inline int IMark() const {return 0;}
static bool HasMark() { return false; } static bool HasMark() { return false; }
static bool HasMarkOcf() { return false; } static bool HasMarkOcf() { return false; }
static bool IsMarkEnabled(const typename TT::VertType *) { return false; } static bool IsMarkEnabled(const typename TT::VertexType *) { return false; }
typedef ScalarType RadiusType; typedef ScalarType RadiusType;
RadiusType &R(){ static 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; }
const RadiusType &cR() const { static const 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; }
static bool HasRadius() { return false; } static bool HasRadius() { return false; }
static bool HasRadiusOcf() { return false; } static bool HasRadiusOcf() { return false; }
static bool IsRadiusEnabled(const typename TT::VertType *) { return false; } static bool IsRadiusEnabled(const typename TT::VertexType *) { return false; }
typedef vcg::TexCoord2<float,1> TexCoordType; typedef vcg::TexCoord2<float,1> TexCoordType;
TexCoordType &T() { static TexCoordType dummy_texcoord; assert(0); return dummy_texcoord; } TexCoordType &T() { static TexCoordType dummy_texcoord; assert(0); return dummy_texcoord; }
const TexCoordType &cT() const { static TexCoordType dummy_texcoord; assert(0); return dummy_texcoord; } const TexCoordType &cT() const { static TexCoordType dummy_texcoord; assert(0); return dummy_texcoord; }
static bool HasTexCoord() { return false; } static bool HasTexCoord() { return false; }
static bool IsTexCoordEnabled(const typename TT::VertType *) { return false; } static bool IsTexCoordEnabled(const typename TT::VertexType *) { return false; }
typename TT::TetraPointer &VTp() { static typename TT::TetraPointer tp = 0; assert(0); return tp; } typename TT::TetraPointer &VTp() { static typename TT::TetraPointer tp = 0; assert(0); return tp; }
typename TT::TetraPointer cVTp() { static typename TT::TetraPointer tp = 0; assert(0); return tp; } typename TT::TetraPointer cVTp() { static typename TT::TetraPointer tp = 0; assert(0); return tp; }
@ -109,12 +145,15 @@ public:
int &VEi(){static int z=0; return z;}; int &VEi(){static int z=0; return z;};
static bool HasVEAdjacency() { return false; } static bool HasVEAdjacency() { return false; }
typedef Point3f VecType; typedef Point3f VecType;
float &Kh() { static float dummy = 0.f; assert(0);return dummy;} typedef Point2f CurvatureType;
float &Kh() { static float dummy = 0.f; assert(0);return dummy;}
float &Kg() { static float dummy = 0.f; assert(0);return dummy;} float &Kg() { static float dummy = 0.f; assert(0);return dummy;}
const float &cKh() const { static float dummy = 0.f; assert(0); return dummy;} const float &cKh() const { static float dummy = 0.f; assert(0); return dummy;}
const float &cKg() const { static float dummy = 0.f; assert(0); return dummy;} const float &cKg() const { static float dummy = 0.f; assert(0); return dummy;}
typedef CurvatureDirBaseType<float> CurvatureDirType;
VecType &PD1(){static VecType v(0,0,0); assert(0);return v;} VecType &PD1(){static VecType v(0,0,0); assert(0);return v;}
VecType &PD2(){static VecType v(0,0,0); assert(0);return v;} VecType &PD2(){static VecType v(0,0,0); assert(0);return v;}
const VecType &cPD1() const {static VecType v(0,0,0); assert(0);return v;} const VecType &cPD1() const {static VecType v(0,0,0); assert(0);return v;}
@ -126,9 +165,9 @@ public:
const ScalarType &cK2()const {static ScalarType v = 0.0;assert(0);return v;} const ScalarType &cK2()const {static ScalarType v = 0.0;assert(0);return v;}
static bool HasCurvature() { return false; } static bool HasCurvature() { return false; }
static bool IsCurvatureEnabled(const typename TT::VertType *) { return false; } static bool IsCurvatureEnabled(const typename TT::VertexType *) { return false; }
static bool HasCurvatureDir() { return false; } static bool HasCurvatureDir() { return false; }
static bool IsCurvatureDirEnabled(const typename TT::VertType *) { return false; } static bool IsCurvatureDirEnabled(const typename TT::VertexType *) { return false; }
template < class LeftV> template < class LeftV>
@ -269,7 +308,7 @@ public:
template < class LeftV> template < class LeftV>
void ImportLocal(const LeftV & left ) { if(LeftV::HasColor()) C() = left.cC(); T::ImportLocal( left); } void ImportLocal(const LeftV & left ) { if(LeftV::HasColor()) C() = left.cC(); T::ImportLocal( left); }
static bool HasColor() { return true; } static bool HasColor() { return true; }
static bool IsColorEnabled(typename T::VertType *) { return true; } static bool IsColorEnabled(typename T::VertexType *) { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("Color"));T::Name(name);} static void Name(std::vector<std::string> & name){name.push_back(std::string("Color"));T::Name(name);}
private: private:
@ -307,41 +346,6 @@ public: static void Name(std::vector<std::string> & name){name.push_back(std::st
}; };
template <class S>
struct CurvatureDirBaseType{
typedef Point3<S> VecType;
typedef S ScalarType;
CurvatureDirBaseType () {}
Point3<S>max_dir,min_dir; // max and min curvature direction
S k1,k2;// max and min curvature values
};
template <class A, class TT> class Curvature: public TT {
public:
typedef Point2<A> CurvatureType;
typedef typename CurvatureType::ScalarType ScalarType;
ScalarType &Kh(){ return _hk[0];}
ScalarType &Kg(){ return _hk[1];}
const ScalarType &cKh() const { return _hk[0];}
const ScalarType &cKg() const { return _hk[1];}
static bool HasCurvature() { return true; }
static bool IsCurvatureEnabled(typename TT::VertType *) { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("Curvature"));TT::Name(name);}
private:
Point2<A> _hk;
};
template <class T> class Curvaturef: public Curvature< float, T> {
public: static void Name(std::vector<std::string> & name){name.push_back(std::string("Curvaturef"));T::Name(name);}
};
template <class T> class Curvatured: public Curvature<double , T> {
public: static void Name(std::vector<std::string> & name){name.push_back(std::string("Curvatured"));T::Name(name);}
};
/*-------------------------- Curvature Direction ----------------------------------*/ /*-------------------------- Curvature Direction ----------------------------------*/

10
vcg/simplex/vertex/component_ocf.h
View File

@ -404,7 +404,7 @@ public:
static bool HasVFAdjacency() { return true; } static bool HasVFAdjacency() { return true; }
static bool HasVFAdjacencyOcf() { return true; } static bool HasVFAdjacencyOcf() { return true; }
static bool IsVFAdjacencyEnabled(const typename T::VertType *vp) {return vp->Base().VFAdjacencyEnabled;} static bool IsVFAdjacencyEnabled(const typename T::VertexType *vp) {return vp->Base().VFAdjacencyEnabled;}
private: private:
}; };
@ -558,7 +558,7 @@ public:
} }
static bool HasCurvature() { return true; } static bool HasCurvature() { return true; }
static bool IsCurvatureEnabled(const typename TT::VertType *v) { return v->Base().CurvatureEnabled; } static bool IsCurvatureEnabled(const typename TT::VertexType *v) { return v->Base().CurvatureEnabled; }
static bool HasCurvatureOcf() { return true; } static bool HasCurvatureOcf() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("CurvatureOcf"));TT::Name(name);} static void Name(std::vector<std::string> & name){name.push_back(std::string("CurvatureOcf"));TT::Name(name);}
@ -666,15 +666,15 @@ public:
assert(0); return *this; assert(0); return *this;
} }
vector_ocf<typename T::VertType> &Base() const { return *_ovp;} vector_ocf<typename T::VertexType> &Base() const { return *_ovp;}
inline int Index() const { inline int Index() const {
typename T::VertType const *tp=static_cast<typename T::VertType const*>(this); typename T::VertexType const *tp=static_cast<typename T::VertexType const*>(this);
int tt2=tp- &*(_ovp->begin()); int tt2=tp- &*(_ovp->begin());
return tt2; return tt2;
} }
public: public:
vector_ocf<typename T::VertType> *_ovp; vector_ocf<typename T::VertexType> *_ovp;
static bool HasQualityOcf() { return false; } static bool HasQualityOcf() { return false; }
static bool HasTexCoordOcf() { return false; } static bool HasTexCoordOcf() { return false; }