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

Added Standard exception throwing functions to claim requirements in the mesh algorithmic functions (Te Deum!) 

for example, now at the beginning of a function requiring FFAdjacency you should just write:

RequireFFAdjacency(mesh); 

No more assert please.
This commit is contained in:
Paolo Cignoni 2012-12-06 10:34:08 +00:00
parent b9406fad93
commit 3b466514b3
4 changed files with 104 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
vcg/complex/complex.h
View File

@ -593,6 +593,40 @@ bool HasPerMeshAttribute(const MESH_TYPE &m, std::string name){
return (ai!= m.mesh_attr.end() ) ; return (ai!= m.mesh_attr.end() ) ;
} }
template <class MeshType> void RequireVFAdjacency (MeshType &m) { if(!tri::HasVFAdjacency (m)) throw vcg::MissingComponentException("VFAdjacency"); }
template <class MeshType> void RequireFFAdjacency (MeshType &m) { if(!tri::HasVFAdjacency (m)) throw vcg::MissingComponentException("VFAdjacency"); }
template <class MeshType> void RequireFEAdjacency (MeshType &m) { if(!tri::HasVFAdjacency (m)) throw vcg::MissingComponentException("VFAdjacency"); }
template <class MeshType> void RequireFHAdjacency (MeshType &m) { if(!tri::HasVFAdjacency (m)) throw vcg::MissingComponentException("VFAdjacency"); }
template <class MeshType> void RequirePerVertexQuality (MeshType &m) { if(!tri::HasPerVertexQuality (m)) throw vcg::MissingComponentException("PerVertexQuality "); }
template <class MeshType> void RequirePerVertexNormal (MeshType &m) { if(!tri::HasPerVertexNormal (m)) throw vcg::MissingComponentException("PerVertexNormal "); }
template <class MeshType> void RequirePerVertexColor (MeshType &m) { if(!tri::HasPerVertexColor (m)) throw vcg::MissingComponentException("PerVertexColor "); }
template <class MeshType> void RequirePerVertexMark (MeshType &m) { if(!tri::HasPerVertexMark (m)) throw vcg::MissingComponentException("PerVertexMark "); }
template <class MeshType> void RequirePerVertexFlags (MeshType &m) { if(!tri::HasPerVertexFlags (m)) throw vcg::MissingComponentException("PerVertexFlags "); }
template <class MeshType> void RequirePerVertexRadius (MeshType &m) { if(!tri::HasPerVertexRadius (m)) throw vcg::MissingComponentException("PerVertexRadius "); }
template <class MeshType> void RequirePerVertexCurvature (MeshType &m) { if(!tri::HasPerVertexCurvature (m)) throw vcg::MissingComponentException("PerVertexCurvature "); }
template <class MeshType> void RequirePerVertexCurvatureDir(MeshType &m) { if(!tri::HasPerVertexCurvatureDir(m)) throw vcg::MissingComponentException("PerVertexCurvatureDir"); }
template <class MeshType> void RequirePerVertexTexCoord (MeshType &m) { if(!tri::HasPerVertexTexCoord (m)) throw vcg::MissingComponentException("PerVertexTexCoord "); }
template <class MeshType> void RequirePerEdgeQuality (MeshType &m) { if(!tri::HasPerEdgeQuality (m)) throw vcg::MissingComponentException("PerEdgeQuality "); }
template <class MeshType> void RequirePerEdgeNormal (MeshType &m) { if(!tri::HasPerEdgeNormal (m)) throw vcg::MissingComponentException("PerEdgeNormal "); }
template <class MeshType> void RequirePerEdgeColor (MeshType &m) { if(!tri::HasPerEdgeColor (m)) throw vcg::MissingComponentException("PerEdgeColor "); }
template <class MeshType> void RequirePerEdgeMark (MeshType &m) { if(!tri::HasPerEdgeMark (m)) throw vcg::MissingComponentException("PerEdgeMark "); }
template <class MeshType> void RequirePerEdgeFlags (MeshType &m) { if(!tri::HasPerEdgeFlags (m)) throw vcg::MissingComponentException("PerEdgeFlags "); }
template <class MeshType> void RequirePerFaceFlags (MeshType &m) { if(!tri::HasPerFaceFlags (m)) throw vcg::MissingComponentException("PerFaceFlags "); }
template <class MeshType> void RequirePerFaceNormal (MeshType &m) { if(!tri::HasPerFaceNormal (m)) throw vcg::MissingComponentException("PerFaceNormal "); }
template <class MeshType> void RequirePerFaceColor (MeshType &m) { if(!tri::HasPerFaceColor (m)) throw vcg::MissingComponentException("PerFaceColor "); }
template <class MeshType> void RequirePerFaceMark (MeshType &m) { if(!tri::HasPerFaceMark (m)) throw vcg::MissingComponentException("PerFaceMark "); }
template <class MeshType> void RequirePerFaceQuality (MeshType &m) { if(!tri::HasPerFaceQuality (m)) throw vcg::MissingComponentException("PerFaceQuality "); }
template <class MeshType> void RequirePerFaceCurvatureDir(MeshType &m) { if(!tri::HasPerFaceCurvatureDir(m)) throw vcg::MissingComponentException("PerFaceCurvatureDir"); }
template <class MeshType> void RequirePerFaceWedgeColor (MeshType &m) { if(!tri::HasPerWedgeColor (m)) throw vcg::MissingComponentException("PerFaceWedgeColor "); }
template <class MeshType> void RequirePerFaceWedgeNormal (MeshType &m) { if(!tri::HasPerWedgeNormal (m)) throw vcg::MissingComponentException("PerFaceWedgeNormal "); }
template <class MeshType> void RequirePerFaceWedgeTexCoord(MeshType &m) { if(!tri::HasPerWedgeTexCoord(m)) throw vcg::MissingComponentException("PerFaceWedgeTexCoord"); }
/*@}*/ /*@}*/
/*@}*/ /*@}*/
} // end namespace } // end namespace

63
vcg/simplex/face/component.h
View File

@ -54,7 +54,6 @@ public:
static bool HasNormal() { return false; } static bool HasNormal() { return false; }
static bool HasWedgeNormal() { return false; } static bool HasWedgeNormal() { return false; }
static bool HasFaceNormal() { return false; }
typedef int WedgeTexCoordType; typedef int WedgeTexCoordType;
typedef vcg::TexCoord2<float,1> TexCoordType; typedef vcg::TexCoord2<float,1> TexCoordType;
@ -69,7 +68,7 @@ public:
inline void InitIMark() { } inline void InitIMark() { }
inline int &IMark() { assert(0); static int tmp=-1; return tmp;} inline int &IMark() { assert(0); static int tmp=-1; return tmp;}
inline int cIMark() const {return 0;} inline int cIMark() const { return 0;}
typedef int MarkType; typedef int MarkType;
typedef float QualityType; typedef float QualityType;
@ -85,25 +84,25 @@ public:
Quality3Type &Q3() { static Quality3Type dummyQuality3(0,0,0); assert(0); return dummyQuality3; } Quality3Type &Q3() { static Quality3Type dummyQuality3(0,0,0); assert(0); return dummyQuality3; }
Quality3Type cQ3() const { static Quality3Type dummyQuality3(0,0,0); assert(0); return dummyQuality3; } Quality3Type cQ3() const { static Quality3Type dummyQuality3(0,0,0); assert(0); return dummyQuality3; }
static bool HasFaceColor() { return false; } static bool HasColor() { return false; }
static bool HasWedgeColor() { return false; } static bool HasWedgeColor() { return false; }
static bool HasFaceQuality() { return false; } static bool HasQuality() { return false; }
static bool HasFaceQuality3() { return false; } static bool HasQuality3() { return false; }
static bool HasFaceMark() { return false; } static bool HasMark() { return false; }
typedef int VFAdjType; typedef int VFAdjType;
typename T::FacePointer &VFp(int) { static typename T::FacePointer fp=0; assert(0); return fp; } typename T::FacePointer &VFp(int) { static typename T::FacePointer fp=0; assert(0); return fp; }
typename T::FacePointer cVFp(int) const { static typename T::FacePointer fp=0; return fp; } typename T::FacePointer cVFp(int) const { static typename T::FacePointer fp=0; assert(0); return fp; }
typename T::FacePointer &FFp(int) { static typename T::FacePointer fp=0; assert(0); return fp; } typename T::FacePointer &FFp(int) { static typename T::FacePointer fp=0; assert(0); return fp; }
typename T::FacePointer cFFp(int) const { static typename T::FacePointer fp=0; return fp; } typename T::FacePointer cFFp(int) const { static typename T::FacePointer fp=0; assert(0); return fp; }
typename T::EdgePointer &FEp(int) { static typename T::EdgePointer fp=0; assert(0); return fp; } typename T::EdgePointer &FEp(int) { static typename T::EdgePointer fp=0; assert(0); return fp; }
typename T::EdgePointer cFEp(int) const { static typename T::EdgePointer fp=0; return fp; } typename T::EdgePointer cFEp(int) const { static typename T::EdgePointer fp=0; assert(0); return fp; }
typename T::HEdgePointer &FHp() { static typename T::HEdgePointer fp=0; assert(0); return fp; } typename T::HEdgePointer &FHp() { static typename T::HEdgePointer fp=0; assert(0); return fp; }
typename T::HEdgePointer cFHp() const { static typename T::HEdgePointer fp=0; assert(0);return fp; } typename T::HEdgePointer cFHp() const { static typename T::HEdgePointer fp=0; assert(0); return fp; }
char &VFi(int) { static char z=0; assert(0); return z;} char &VFi(int) { static char z=0; assert(0); return z;}
char &FFi(int) { static char z=0; assert(0); return z;} char &FFi(int) { static char z=0; assert(0); return z;}
char cVFi(int) const { static char z=0; return z;} char cVFi(int) const { static char z=0; assert(0); return z;}
char cFFi(int) const { static char z=0; return z;} char cFFi(int) const { static char z=0; assert(0); return z;}
static bool HasVFAdjacency() { return false; } static bool HasVFAdjacency() { return false; }
static bool HasFFAdjacency() { return false; } static bool HasFFAdjacency() { return false; }
@ -112,10 +111,10 @@ public:
typedef int CurvatureDirType; typedef int CurvatureDirType;
Point3f &PD1() { static Point3f dummy(0,0,0); return dummy;} Point3f &PD1() { static Point3f dummy(0,0,0); assert(0); return dummy;}
Point3f &PD2() { static Point3f dummy(0,0,0); return dummy;} Point3f &PD2() { static Point3f dummy(0,0,0); assert(0); return dummy;}
Point3f cPD1() const { static Point3f dummy(0,0,0); return dummy;} Point3f cPD1() const { static Point3f dummy(0,0,0); assert(0); return dummy;}
Point3f cPD2() const { static Point3f dummy(0,0,0); return dummy;} Point3f cPD2() const { static Point3f dummy(0,0,0); assert(0); return dummy;}
float &K1() { static float dummy(0); assert(0); return dummy;} float &K1() { static float dummy(0); assert(0); return dummy;}
float &K2() { static float dummy(0); assert(0); return dummy;} float &K2() { static float dummy(0); assert(0); return dummy;}
@ -204,13 +203,13 @@ public:
template <class RightValueType> template <class RightValueType>
void ImportData(const RightValueType & rightF) void ImportData(const RightValueType & rightF)
{ {
if(RightValueType::HasFaceNormal()) N().Import(rightF.cN()); if(RightValueType::HasNormal()) N().Import(rightF.cN());
T::ImportData( rightF); T::ImportData( rightF);
} }
inline void Alloc(const int & ns){T::Alloc(ns);} inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();} inline void Dealloc(){T::Dealloc();}
static bool HasFaceNormal() { return true; } static bool HasNormal() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("NormalAbs"));T::Name(name);} static void Name(std::vector<std::string> & name){name.push_back(std::string("NormalAbs"));T::Name(name);}
private: private:
@ -334,13 +333,13 @@ public:
ColorType cC() const { return _color; } ColorType cC() const { return _color; }
template <class RightValueType> template <class RightValueType>
void ImportData(const RightValueType & rightF){ void ImportData(const RightValueType & rightF){
if(RightValueType::HasFaceColor()) if(RightValueType::HasColor())
C() = rightF.cC(); C() = rightF.cC();
T::ImportData(rightF); T::ImportData(rightF);
} }
inline void Alloc(const int & ns){T::Alloc(ns);} inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();} inline void Dealloc(){T::Dealloc();}
static bool HasFaceColor() { return true; } static bool HasColor() { 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:
@ -387,13 +386,13 @@ public:
QualityType cQ() const { return _quality; } QualityType cQ() const { return _quality; }
template <class RightValueType> template <class RightValueType>
void ImportData(const RightValueType & rightF){ void ImportData(const RightValueType & rightF){
if(RightValueType::HasFaceQuality()) if(RightValueType::HasQuality())
Q() = rightF.cQ(); Q() = rightF.cQ();
T::ImportData(rightF); T::ImportData(rightF);
} }
inline void Alloc(const int & ns){T::Alloc(ns);} inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();} inline void Dealloc(){T::Dealloc();}
static bool HasFaceQuality() { return true; } static bool HasQuality() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("Quality"));T::Name(name);} static void Name(std::vector<std::string> & name){name.push_back(std::string("Quality"));T::Name(name);}
private: private:
QualityType _quality; QualityType _quality;
@ -417,12 +416,12 @@ public:
Quality3Type cQ3() const { return _quality; } Quality3Type cQ3() const { return _quality; }
template <class RightValueType> template <class RightValueType>
void ImportData(const RightValueType & rightF){ void ImportData(const RightValueType & rightF){
if(RightValueType::HasFaceQuality3()) Q3() = rightF.cQ3(); if(RightValueType::HasQuality3()) Q3() = rightF.cQ3();
T::ImportData(rightF); T::ImportData(rightF);
} }
inline void Alloc(const int & ns){T::Alloc(ns);} inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();} inline void Dealloc(){T::Dealloc();}
static bool HasFaceQuality3() { return true; } static bool HasQuality3() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("Quality3"));T::Name(name);} static void Name(std::vector<std::string> & name){name.push_back(std::string("Quality3"));T::Name(name);}
private: private:
Quality3Type _quality; Quality3Type _quality;
@ -449,10 +448,10 @@ public:
inline int &IMark() { return _imark;} inline int &IMark() { return _imark;}
inline int cIMark() const { return _imark;} inline int cIMark() const { return _imark;}
inline void InitIMark() { _imark = 0; } inline void InitIMark() { _imark = 0; }
static bool HasFaceMark() { return true; } static bool HasMark() { return true; }
template <class RightValueType> template <class RightValueType>
void ImportData(const RightValueType & rightF){ void ImportData(const RightValueType & rightF){
if(RightValueType::HasFaceMark()) if(RightValueType::HasMark())
IMark() = rightF.cIMark(); IMark() = rightF.cIMark();
T::ImportData(rightF); T::ImportData(rightF);
} }

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

@ -235,52 +235,52 @@ void ReorderFace(std::vector<size_t> &newFaceIndex )
bool IsQualityEnabled() const {return QualityEnabled;} bool IsQualityEnabled() const {return QualityEnabled;}
void EnableQuality() { void EnableQuality() {
assert(VALUE_TYPE::HasFaceQualityOcf()); assert(VALUE_TYPE::HasQualityOcf());
QualityEnabled=true; QualityEnabled=true;
QV.resize((*this).size()); QV.resize((*this).size());
} }
void DisableQuality() { void DisableQuality() {
assert(VALUE_TYPE::HasFaceQualityOcf()); assert(VALUE_TYPE::HasQualityOcf());
QualityEnabled=false; QualityEnabled=false;
QV.clear(); QV.clear();
} }
bool IsColorEnabled() const {return ColorEnabled;} bool IsColorEnabled() const {return ColorEnabled;}
void EnableColor() { void EnableColor() {
assert(VALUE_TYPE::HasFaceColorOcf()); assert(VALUE_TYPE::HasColorOcf());
ColorEnabled=true; ColorEnabled=true;
CV.resize((*this).size()); CV.resize((*this).size());
} }
void DisableColor() { void DisableColor() {
assert(VALUE_TYPE::HasFaceColorOcf()); assert(VALUE_TYPE::HasColorOcf());
ColorEnabled=false; ColorEnabled=false;
CV.clear(); CV.clear();
} }
bool IsMarkEnabled() const {return MarkEnabled;} bool IsMarkEnabled() const {return MarkEnabled;}
void EnableMark() { void EnableMark() {
assert(VALUE_TYPE::HasFaceMarkOcf()); assert(VALUE_TYPE::HasMarkOcf());
MarkEnabled=true; MarkEnabled=true;
MV.resize((*this).size()); MV.resize((*this).size());
} }
void DisableMark() { void DisableMark() {
assert(VALUE_TYPE::HasFaceMarkOcf()); assert(VALUE_TYPE::HasMarkOcf());
MarkEnabled=false; MarkEnabled=false;
MV.clear(); MV.clear();
} }
bool IsNormalEnabled() const {return NormalEnabled;} bool IsNormalEnabled() const {return NormalEnabled;}
void EnableNormal() { void EnableNormal() {
assert(VALUE_TYPE::HasFaceNormalOcf()); assert(VALUE_TYPE::HasNormalOcf());
NormalEnabled=true; NormalEnabled=true;
NV.resize((*this).size()); NV.resize((*this).size());
} }
void DisableNormal() { void DisableNormal() {
assert(VALUE_TYPE::HasFaceNormalOcf()); assert(VALUE_TYPE::HasNormalOcf());
NormalEnabled=false; NormalEnabled=false;
NV.clear(); NV.clear();
} }
@ -461,8 +461,8 @@ public:
template <class A, class T> class NormalOcf: public T { template <class A, class T> class NormalOcf: public T {
public: public:
typedef A NormalType; typedef A NormalType;
static bool HasFaceNormal() { return true; } static bool HasNormal() { return true; }
static bool HasFaceNormalOcf() { return true; } static bool HasNormalOcf() { return true; }
NormalType &N() { NormalType &N() {
// you cannot use Normals before enabling them with: yourmesh.face.EnableNormal() // you cannot use Normals before enabling them with: yourmesh.face.EnableNormal()
@ -580,12 +580,12 @@ public:
template <class LeftF> template <class LeftF>
void ImportData(const LeftF & leftF){ void ImportData(const LeftF & leftF){
if((*this).Base().QualityEnabled && LeftF::HasFaceQuality()) if((*this).Base().QualityEnabled && LeftF::HasQuality())
Q() = leftF.cQ(); Q() = leftF.cQ();
T::ImportData(leftF); T::ImportData(leftF);
} }
static bool HasFaceQuality() { return true; } static bool HasQuality() { return true; }
static bool HasFaceQualityOcf() { return true; } static bool HasQualityOcf() { return true; }
}; };
template <class T> class QualityfOcf: public QualityOcf<float, T> {}; template <class T> class QualityfOcf: public QualityOcf<float, T> {};
@ -605,12 +605,12 @@ public:
template <class LeftF> template <class LeftF>
void ImportData(const LeftF & leftF){ void ImportData(const LeftF & leftF){
if((*this).Base().ColorEnabled && LeftF::HasFaceColor()) if((*this).Base().ColorEnabled && LeftF::HasColor())
C() = leftF.cC(); C() = leftF.cC();
T::ImportData(leftF); T::ImportData(leftF);
} }
static bool HasFaceColor() { return true; } static bool HasColor() { return true; }
static bool HasFaceColorOcf() { return true; } static bool HasColorOcf() { return true; }
}; };
template <class T> class Color4bOcf: public ColorOcf<vcg::Color4b, T> {}; template <class T> class Color4bOcf: public ColorOcf<vcg::Color4b, T> {};
@ -629,12 +629,12 @@ public:
template <class LeftF> template <class LeftF>
void ImportData(const LeftF & leftF){ void ImportData(const LeftF & leftF){
if((*this).Base().MarkEnabled && LeftF::HasFaceMark()) if((*this).Base().MarkEnabled && LeftF::HasMark())
IMark() = leftF.cIMark(); IMark() = leftF.cIMark();
T::ImportData(leftF); T::ImportData(leftF);
} }
static bool HasFaceMark() { return true; } static bool HasMark() { return true; }
static bool HasFaceMarkOcf() { return true; } static bool HasMarkOcf() { return true; }
inline void InitIMark() { IMark() = 0; } inline void InitIMark() { IMark() = 0; }
}; };
@ -713,11 +713,11 @@ public:
template <class LeftF> template <class LeftF>
void ImportData(const LeftF & leftF){T::ImportData(leftF);} void ImportData(const LeftF & leftF){T::ImportData(leftF);}
static bool HasFaceColorOcf() { return false; } static bool HasColorOcf() { return false; }
static bool HasFaceQualityOcf() { return false; } static bool HasQualityOcf() { return false; }
static bool HasFaceNormalOcf() { return false; } static bool HasNormalOcf() { return false; }
static bool HasFaceCurvatureDirOcf() { return false; } static bool HasCurvatureDirOcf() { return false; }
static bool HasFaceMarkOcf() { return false; } static bool HasMarkOcf() { return false; }
static bool HasWedgeTexCoordOcf() { return false; } static bool HasWedgeTexCoordOcf() { return false; }
static bool HasWedgeColorOcf() { return false; } static bool HasWedgeColorOcf() { return false; }
static bool HasWedgeNormalOcf() { return false; } static bool HasWedgeNormalOcf() { return false; }
@ -763,20 +763,20 @@ public:
template < class FaceType > template < class FaceType >
bool FaceVectorHasPerFaceColor(const face::vector_ocf<FaceType> &fv) bool FaceVectorHasPerFaceColor(const face::vector_ocf<FaceType> &fv)
{ {
if(FaceType::HasFaceColorOcf()) return fv.IsColorEnabled(); if(FaceType::HasColorOcf()) return fv.IsColorEnabled();
else return FaceType::HasFaceColor(); else return FaceType::HasColor();
} }
template < class FaceType > template < class FaceType >
bool FaceVectorHasPerFaceQuality(const face::vector_ocf<FaceType> &fv) bool FaceVectorHasPerFaceQuality(const face::vector_ocf<FaceType> &fv)
{ {
if(FaceType::HasFaceQualityOcf()) return fv.IsQualityEnabled(); if(FaceType::HasQualityOcf()) return fv.IsQualityEnabled();
else return FaceType::HasFaceQuality(); else return FaceType::HasQuality();
} }
template < class FaceType > template < class FaceType >
bool FaceVectorHasPerFaceMark(const face::vector_ocf<FaceType> &fv) bool FaceVectorHasPerFaceMark(const face::vector_ocf<FaceType> &fv)
{ {
if(FaceType::HasFaceMarkOcf()) return fv.IsMarkEnabled(); if(FaceType::HasMarkOcf()) return fv.IsMarkEnabled();
else return FaceType::HasFaceMark(); else return FaceType::HasMark();
} }
template < class FaceType > template < class FaceType >
bool FaceVectorHasPerFaceCurvatureDir(const face::vector_ocf<FaceType> &fv) bool FaceVectorHasPerFaceCurvatureDir(const face::vector_ocf<FaceType> &fv)
@ -787,8 +787,8 @@ public:
template < class FaceType > template < class FaceType >
bool FaceVectorHasPerFaceNormal(const face::vector_ocf<FaceType> &fv) bool FaceVectorHasPerFaceNormal(const face::vector_ocf<FaceType> &fv)
{ {
if(FaceType::HasFaceNormalOcf()) return fv.IsNormalEnabled(); if(FaceType::HasNormalOcf()) return fv.IsNormalEnabled();
else return FaceType::HasFaceNormal(); else return FaceType::HasNormal();
} }
template < class FaceType > template < class FaceType >
void ReorderFace( std::vector<size_t> &newFaceIndex, face::vector_ocf< FaceType > &faceVec) void ReorderFace( std::vector<size_t> &newFaceIndex, face::vector_ocf< FaceType > &faceVec)

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

@ -377,12 +377,12 @@ public: static void Name(std::vector<std::string> & name){name.push_back(std::st
public: public:
typedef CurvatureDirBaseType<float> CurvatureDirType; typedef CurvatureDirBaseType<float> CurvatureDirType;
const Point3f &PD1() const { static Point3f dummy(0,0,0); return dummy;} const Point3f &PD1() const { static Point3f dummy(0,0,0);assert(0); return dummy;}
const Point3f &PD2() const { static Point3f dummy(0,0,0); return dummy;} const Point3f &PD2() const { static Point3f dummy(0,0,0);assert(0); return dummy;}
Point3f &PD1() { static Point3f dummy(0,0,0); return dummy;} Point3f &PD1() { static Point3f dummy(0,0,0);assert(0); return dummy;}
Point3f &PD2() { static Point3f dummy(0,0,0); return dummy;} Point3f &PD2() { static Point3f dummy(0,0,0);assert(0); return dummy;}
Point3f cPD1() const { static Point3f dummy(0,0,0); return dummy;} Point3f cPD1() const { static Point3f dummy(0,0,0);assert(0); return dummy;}
Point3f cPD2() const { static Point3f dummy(0,0,0); return dummy;} Point3f cPD2() const { static Point3f dummy(0,0,0);assert(0); return dummy;}
float &K1() { static float dummy(0);assert(0);return dummy;} float &K1() { static float dummy(0);assert(0);return dummy;}
float &K2() { static float dummy(0);assert(0);return dummy;} float &K2() { static float dummy(0);assert(0);return dummy;}
@ -413,7 +413,7 @@ public:
ScalarType &K1(){ return _curv.k1;} ScalarType &K1(){ return _curv.k1;}
ScalarType &K2(){ return _curv.k2;} ScalarType &K2(){ return _curv.k2;}
const ScalarType &cK1() const {return _curv.k1;} const ScalarType &cK1() const {return _curv.k1;}
const ScalarType &cK2()const {return _curv.k2;} const ScalarType &cK2() const {return _curv.k2;}
template < class RightValueType> template < class RightValueType>
void ImportData(const RightValueType & rVert ) { void ImportData(const RightValueType & rVert ) {
if(RightValueType::HasCurvatureDir()) { if(RightValueType::HasCurvatureDir()) {