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

Add an optional per vertex radius property in occ, ocf, and IO mask. 

Extend derivation_chain from 10 to 12
This commit is contained in:
Paolo Cignoni 2008-10-14 14:58:09 +00:00
parent c5ec73d0f7
commit fc98a34972
5 changed files with 353 additions and 251 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
vcg/container/derivation_chain.h
View File

@ -99,6 +99,27 @@ template <template <typename,typename,typename,typename>
template <typename> class I, template <typename> class J> template <typename> class I, template <typename> class J>
class Arity10: public J<Arity9<Base,BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I > > {}; class Arity10: public J<Arity9<Base,BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I > > {};
template <template <typename,typename,typename,typename>
class Base,class BVT, class BET, typename BFT,class BTT,
template <typename> class A, template <typename> class B,
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 Arity11: public K<Arity10<Base,BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I, J> > {};
template <template <typename,typename,typename,typename>
class Base,class BVT, class BET, typename BFT,class BTT,
template <typename> class A, template <typename> class B,
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>
class Arity12: public L<Arity11<Base,BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I, J, K> > {};
template < typename T=int> template < typename T=int>
class DefaultDeriver : public T {}; class DefaultDeriver : public T {};
class DumClass {}; class DumClass {};

24
vcg/simplex/vertexplus/base.h
View File

@ -137,13 +137,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 BVT, class BET, typename BFT,class BTT,
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, template <typename> class L>
class VertexArityMax: public K<Arity10<VertexBase,BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I, J> > { class VertexArityMax: public Arity12<VertexBase,BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I, J, K, L> {
// ----- Flags stuff ----- // ----- Flags stuff -----
public: public:
@ -159,7 +159,7 @@ public:
SELECTED = 0x0020, // This bit can be used to select SELECTED = 0x0020, // This bit can be used to select
BORDER = 0x0100, // Border Flag BORDER = 0x0100, // Border Flag
USER0 = 0x0200 // First user bit USER0 = 0x0200 // First user bit
}; };
inline int & UberFlags () { return this->Flags(); } inline int & UberFlags () { return this->Flags(); }
inline const int UberFlags() const { return this->Flags(); } inline const int UberFlags() const { return this->Flags(); }
@ -267,8 +267,8 @@ template <class BVT, class BET, class BFT, class BTT,
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, template <typename> class L = DefaultDeriver>
class VertexSimp3: public VertexArityMax<BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I, J, K> {}; class VertexSimp3: public VertexArityMax<BVT,BET,BFT,BTT, A, B, C, D, E, F, G, H, I, J, K, L> {};
template <class BVT, class BET, class BFT, template <class BVT, class BET, class BFT,
template <typename> class A = DefaultDeriver, template <typename> class B = DefaultDeriver, template <typename> class A = DefaultDeriver, template <typename> class B = DefaultDeriver,
@ -276,8 +276,8 @@ template <class BVT, class BET, class BFT,
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, template <typename> class L = DefaultDeriver>
class VertexSimp2: public VertexArityMax<BVT,BET,BFT,DumClass, A, B, C, D, E, F, G, H, I, J, K> {}; 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 <class BVT, class BET,
template <typename> class A = DefaultDeriver, template <typename> class B = DefaultDeriver, template <typename> class A = DefaultDeriver, template <typename> class B = DefaultDeriver,
@ -285,8 +285,8 @@ template <class BVT, class BET,
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, template <typename> class L = DefaultDeriver>
class VertexSimp1: public VertexArityMax<BVT,BET,DumClass,DumClass, A, B, C, D, E, F, G, H, I, J, K> {}; 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

31
vcg/simplex/vertexplus/component_occ.h
View File

@ -218,6 +218,37 @@ template <class T> class CurvatureDirdOcc: public CurvatureDirOcc<CurvatureDirTy
public: static void Name(std::vector<std::string> & name){name.push_back(std::string("CurvatureDird"));T::Name(name);} public: static void Name(std::vector<std::string> & name){name.push_back(std::string("CurvatureDird"));T::Name(name);}
}; };
/*-------------------------- RADIUS ----------------------------------*/
template <class A, class TT> class RadiusOcc: public TT {
public:
typedef A RadiusType;
typedef A ScalarType;
typedef typename TT::VertType VertType;
RadiusType &R(){ return CAT< vector_occ<VertType>,RadiusType>::Instance()->Get((VertType*)this);}
const RadiusType &cR() const { return CAT< vector_occ<VertType>,RadiusType>::Instance()->Get((VertType*)this);}
template <class LeftV>
void ImportLocal(const LeftV & leftV){
CAT< vector_occ<VertType>,RadiusType>::Instance()->Get((VertType*)this) = leftV.cR();
TT::ImporLocal(leftV);
}
static bool HasRadius() { return true; }
static bool HasRadiusOcc() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("RadiusOcc"));TT::Name(name);}
private:
};
template <class T> class RadiusfOcc: public RadiusOcc<float, T> {
static void Name(std::vector<std::string> & name){name.push_back(std::string("RadiusfOcc"));T::Name(name);}
};
template <class T> class RadiusdOcc: public RadiusOcc<double, T> {
static void Name(std::vector<std::string> & name){name.push_back(std::string("RadiusdOcc"));T::Name(name);}
};
///*----------------------------- VFADJ ------------------------------*/ ///*----------------------------- VFADJ ------------------------------*/
template <class T> class VFAdjOcc: public T { template <class T> class VFAdjOcc: public T {

476
vcg/simplex/vertexplus/component_ocf.h
View File

@ -8,7 +8,7 @@
* \ * * \ *
* All rights reserved. * * All rights reserved. *
* * * *
* This program is free software; you can redistribute it and/or modify * * This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by * * it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or * * the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. * * (at your option) any later version. *
@ -21,7 +21,7 @@
* * * *
****************************************************************************/ ****************************************************************************/
/**************************************************************************** /****************************************************************************
History History
$Log: not supported by cvs2svn $ $Log: not supported by cvs2svn $
Revision 1.16 2008/04/03 23:15:40 cignoni Revision 1.16 2008/04/03 23:15:40 cignoni
@ -80,7 +80,7 @@ First Really Working version
****************************************************************************/ ****************************************************************************/
/* /*
Note Note
OCF = Optional Component Fast (hopefully) OCF = Optional Component Fast (hopefully)
compare with OCC(Optional Component Compact) compare with OCC(Optional Component Compact)
@ -97,77 +97,81 @@ Mainly the trick here is to store a base pointer in each simplex...
#include <limits> #include <limits>
namespace vcg { namespace vcg {
namespace vertex { namespace vertex {
/* /*
All the Components that can be added to a vertex should be defined in the namespace vert: All the Components that can be added to a vertex should be defined in the namespace vert:
*/ */
template <class VALUE_TYPE> template <class VALUE_TYPE>
class vector_ocf: public std::vector<VALUE_TYPE> { class vector_ocf: public std::vector<VALUE_TYPE> {
typedef std::vector<VALUE_TYPE> BaseType; typedef std::vector<VALUE_TYPE> BaseType;
typedef typename vector_ocf<VALUE_TYPE>::iterator ThisTypeIterator; typedef typename vector_ocf<VALUE_TYPE>::iterator ThisTypeIterator;
public: public:
vector_ocf():std::vector<VALUE_TYPE>(){ vector_ocf():std::vector<VALUE_TYPE>(){
QualityEnabled=false; QualityEnabled = false;
ColorEnabled=false; ColorEnabled = false;
MarkEnabled = false; MarkEnabled = false;
NormalEnabled=false; NormalEnabled = false;
VFAdjacencyEnabled=false; VFAdjacencyEnabled = false;
CurvatureEnabled = false; CurvatureEnabled = false;
CurvatureEnabled= false; CurvatureEnabled = false;
CurvatureDirEnabled= false; CurvatureDirEnabled = false;
RadiusEnabled = false;
} }
// override di tutte le funzioni che possono spostare // override di tutte le funzioni che possono spostare
// l'allocazione in memoria del container // l'allocazione in memoria del container
void push_back(const VALUE_TYPE & v) void push_back(const VALUE_TYPE & v)
{ {
BaseType::push_back(v); BaseType::push_back(v);
BaseType::back()._ovp = this; BaseType::back()._ovp = this;
if (ColorEnabled) CV.push_back(vcg::Color4b(vcg::Color4b::White)); if (ColorEnabled) CV.push_back(vcg::Color4b(vcg::Color4b::White));
if (MarkEnabled) MV.push_back(0); if (MarkEnabled) MV.push_back(0);
if (NormalEnabled) NV.push_back(typename VALUE_TYPE::NormalType()); if (NormalEnabled) NV.push_back(typename VALUE_TYPE::NormalType());
if (VFAdjacencyEnabled) AV.push_back(VFAdjType()); if (VFAdjacencyEnabled) AV.push_back(VFAdjType());
if (CurvatureEnabled) CuV.push_back(typename VALUE_TYPE::CurvatureType()); if (CurvatureEnabled) CuV.push_back(typename VALUE_TYPE::CurvatureType());
if (CurvatureDirEnabled) CuDV.push_back(typename VALUE_TYPE::CurvatureDirType()); if (CurvatureDirEnabled) CuDV.push_back(typename VALUE_TYPE::CurvatureDirType());
} if (RadiusEnabled) RadiusV.push_back(typename VALUE_TYPE::RadiusType());
}
void pop_back(); void pop_back();
void resize(const unsigned int & _size) void resize(const unsigned int & _size)
{ {
const unsigned int oldsize = BaseType::size(); const unsigned int oldsize = BaseType::size();
BaseType::resize(_size); BaseType::resize(_size);
if(oldsize<_size){ if(oldsize<_size){
ThisTypeIterator firstnew = BaseType::begin(); ThisTypeIterator firstnew = BaseType::begin();
advance(firstnew,oldsize); advance(firstnew,oldsize);
_updateOVP(firstnew,(*this).end()); _updateOVP(firstnew,(*this).end());
} }
if (ColorEnabled) CV.resize(_size); if (ColorEnabled) CV.resize(_size);
if (MarkEnabled) MV.resize(_size); if (MarkEnabled) MV.resize(_size);
if (NormalEnabled) NV.resize(_size); if (NormalEnabled) NV.resize(_size);
if (VFAdjacencyEnabled) AV.resize(_size); if (VFAdjacencyEnabled) AV.resize(_size);
if (CurvatureEnabled) CuV.resize(_size); if (CurvatureEnabled) CuV.resize(_size);
if (CurvatureDirEnabled) CuDV.resize(_size); if (CurvatureDirEnabled) CuDV.resize(_size);
} if (RadiusEnabled) RadiusV.resize(_size);
}
void reserve(const unsigned int & _size) void reserve(const unsigned int & _size)
{ {
BaseType::reserve(_size); BaseType::reserve(_size);
if (ColorEnabled) CV.reserve(_size); if (ColorEnabled) CV.reserve(_size);
if (MarkEnabled) MV.reserve(_size); if (MarkEnabled) MV.reserve(_size);
if (NormalEnabled) NV.reserve(_size); if (NormalEnabled) NV.reserve(_size);
if (VFAdjacencyEnabled) AV.reserve(_size); if (VFAdjacencyEnabled) AV.reserve(_size);
if (CurvatureEnabled) CuV.reserve(_size); if (CurvatureEnabled) CuV.reserve(_size);
if (CurvatureDirEnabled) CuDV.reserve(_size); if (CurvatureDirEnabled) CuDV.reserve(_size);
} if (RadiusEnabled) RadiusV.reserve(_size);
}
void _updateOVP(ThisTypeIterator lbegin, ThisTypeIterator lend) void _updateOVP(ThisTypeIterator lbegin, ThisTypeIterator lend)
{ {
ThisTypeIterator vi; ThisTypeIterator vi;
for(vi=lbegin;vi!=lend;++vi) for(vi=lbegin;vi!=lend;++vi)
(*vi)._ovp=this; (*vi)._ovp=this;
} }
// this function is called by the specialized Reorder function, that is called whenever someone call the allocator::CompactVertVector // this function is called by the specialized Reorder function, that is called whenever someone call the allocator::CompactVertVector
void ReorderVert(std::vector<size_t> &newVertIndex ) void ReorderVert(std::vector<size_t> &newVertIndex )
{ {
@ -178,27 +182,30 @@ void ReorderVert(std::vector<size_t> &newVertIndex )
if (VFAdjacencyEnabled) assert( AV.size() == newVertIndex.size() ); if (VFAdjacencyEnabled) assert( AV.size() == newVertIndex.size() );
if (CurvatureEnabled) assert(CuV.size() == newVertIndex.size() ); if (CurvatureEnabled) assert(CuV.size() == newVertIndex.size() );
if (CurvatureDirEnabled)assert(CuDV.size() == newVertIndex.size() ); if (CurvatureDirEnabled)assert(CuDV.size() == newVertIndex.size() );
assert( (!RadiusEnabled) || RadiusV.size() == newVertIndex.size() );
for(i=0;i<newVertIndex.size();++i) for(i=0;i<newVertIndex.size();++i)
{ {
if(newVertIndex[i] != std::numeric_limits<size_t>::max() ) if(newVertIndex[i] != std::numeric_limits<size_t>::max() )
{ {
assert(newVertIndex[i] <= i); assert(newVertIndex[i] <= i);
if (ColorEnabled) CV[newVertIndex[i]] = CV[i]; if (ColorEnabled) CV[newVertIndex[i]] = CV[i];
if (MarkEnabled) MV[newVertIndex[i]] = MV[i]; if (MarkEnabled) MV[newVertIndex[i]] = MV[i];
if (NormalEnabled) NV[newVertIndex[i]] = NV[i]; if (NormalEnabled) NV[newVertIndex[i]] = NV[i];
if (VFAdjacencyEnabled) AV[newVertIndex[i]] = AV[i]; if (VFAdjacencyEnabled) AV[newVertIndex[i]] = AV[i];
if (CurvatureEnabled) CuV[newVertIndex[i]] = CuV[i]; if (CurvatureEnabled) CuV[newVertIndex[i]] = CuV[i];
if (CurvatureDirEnabled) CuDV[newVertIndex[i]] =CuDV[i]; if (CurvatureDirEnabled) CuDV[newVertIndex[i]] =CuDV[i];
if (RadiusEnabled) RadiusV[newVertIndex[i]] = RadiusV[i];
} }
} }
if (ColorEnabled) CV.resize(BaseType::size()); if (ColorEnabled) CV.resize(BaseType::size());
if (MarkEnabled) MV.resize(BaseType::size()); if (MarkEnabled) MV.resize(BaseType::size());
if (NormalEnabled) NV.resize(BaseType::size()); if (NormalEnabled) NV.resize(BaseType::size());
if (VFAdjacencyEnabled) AV.resize(BaseType::size()); if (VFAdjacencyEnabled) AV.resize(BaseType::size());
if (CurvatureEnabled) CuV.resize(BaseType::size()); if (CurvatureEnabled) CuV.resize(BaseType::size());
if (CurvatureDirEnabled) CuDV.resize(BaseType::size()); if (CurvatureDirEnabled) CuDV.resize(BaseType::size());
if (RadiusEnabled) RadiusV.resize(BaseType::size());
} }
@ -208,177 +215,189 @@ void ReorderVert(std::vector<size_t> &newVertIndex )
bool IsQualityEnabled() const {return QualityEnabled;} bool IsQualityEnabled() const {return QualityEnabled;}
void EnableQuality() { void EnableQuality() {
assert(VALUE_TYPE::HasQualityOcf()); assert(VALUE_TYPE::HasQualityOcf());
QualityEnabled=true; QualityEnabled=true;
QV.resize((*this).size()); QV.resize((*this).size());
} }
void DisableQuality() { void DisableQuality() {
assert(VALUE_TYPE::HasQualityOcf()); 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::HasColorOcf()); assert(VALUE_TYPE::HasColorOcf());
ColorEnabled=true; ColorEnabled=true;
CV.resize((*this).size()); CV.resize((*this).size());
} }
void DisableColor() { void DisableColor() {
assert(VALUE_TYPE::HasColorOcf()); 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::HasFaceMarkOcf());
MarkEnabled=true; MarkEnabled=true;
MV.resize((*this).size()); MV.resize((*this).size());
} }
void DisableMark() { void DisableMark() {
assert(VALUE_TYPE::HasFaceMarkOcf()); assert(VALUE_TYPE::HasFaceMarkOcf());
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::HasNormalOcf()); assert(VALUE_TYPE::HasNormalOcf());
NormalEnabled=true; NormalEnabled=true;
NV.resize((*this).size()); NV.resize((*this).size());
} }
void DisableNormal() { void DisableNormal() {
assert(VALUE_TYPE::HasNormalOcf()); assert(VALUE_TYPE::HasNormalOcf());
NormalEnabled=false; NormalEnabled=false;
NV.clear(); NV.clear();
} }
void EnableVFAdjacency() { void EnableVFAdjacency() {
assert(VALUE_TYPE::HasVFAdjacencyOcf()); assert(VALUE_TYPE::HasVFAdjacencyOcf());
VFAdjacencyEnabled=true; VFAdjacencyEnabled=true;
AV.resize((*this).size()); AV.resize((*this).size());
} }
void DisableVFAdjacency() { void DisableVFAdjacency() {
assert(VALUE_TYPE::HasVFAdjacencyOcf()); assert(VALUE_TYPE::HasVFAdjacencyOcf());
VFAdjacencyEnabled=false; VFAdjacencyEnabled=false;
AV.clear(); AV.clear();
} }
void EnableCurvature() { void EnableCurvature() {
assert(VALUE_TYPE::HasCurvatureOcf()); assert(VALUE_TYPE::HasCurvatureOcf());
CurvatureEnabled=true; CurvatureEnabled=true;
CuV.resize((*this).size()); CuV.resize((*this).size());
} }
void DisableCurvature() { void DisableCurvature() {
assert(VALUE_TYPE::HasCurvatureOcf()); assert(VALUE_TYPE::HasCurvatureOcf());
CurvatureEnabled=false; CurvatureEnabled=false;
CuV.clear(); CuV.clear();
} }
void EnableCurvatureDir() { void EnableCurvatureDir() {
assert(VALUE_TYPE::HasCurvatureDirOcf()); assert(VALUE_TYPE::HasCurvatureDirOcf());
CurvatureDirEnabled=true; CurvatureDirEnabled=true;
CuDV.resize((*this).size()); CuDV.resize((*this).size());
} }
void DisableCurvatureDir() { void DisableCurvatureDir() {
assert(VALUE_TYPE::HasCurvatureDirOcf()); assert(VALUE_TYPE::HasCurvatureDirOcf());
CurvatureDirEnabled=false; CurvatureDirEnabled=false;
CuDV.clear(); CuDV.clear();
} }
void EnableRadius() {
assert(VALUE_TYPE::HasRadiusOcf());
RadiusEnabled=true;
RadiusV.resize((*this).size());
}
void DisableRadius() {
assert(VALUE_TYPE::HasRadiusOcf());
RadiusEnabled=false;
RadiusV.clear();
}
struct VFAdjType { struct VFAdjType {
typename VALUE_TYPE::FacePointer _fp ; typename VALUE_TYPE::FacePointer _fp ;
int _zp ; int _zp ;
}; };
public: public:
std::vector<typename VALUE_TYPE::QualityType> QV; std::vector<typename VALUE_TYPE::QualityType> QV;
std::vector<typename VALUE_TYPE::CurvatureType> CuV; std::vector<typename VALUE_TYPE::CurvatureType> CuV;
std::vector<typename VALUE_TYPE::CurvatureDirType> CuDV; std::vector<typename VALUE_TYPE::CurvatureDirType> CuDV;
std::vector<typename VALUE_TYPE::ColorType> CV; std::vector<typename VALUE_TYPE::RadiusType> RadiusV;
std::vector<typename VALUE_TYPE::NormalType> NV; std::vector<typename VALUE_TYPE::ColorType> CV;
std::vector<struct VFAdjType> AV; std::vector<typename VALUE_TYPE::NormalType> NV;
std::vector<int> MV; std::vector<struct VFAdjType> AV;
std::vector<int> MV;
bool QualityEnabled;
bool ColorEnabled; bool QualityEnabled;
bool NormalEnabled; bool ColorEnabled;
bool VFAdjacencyEnabled; bool NormalEnabled;
bool CurvatureEnabled; bool VFAdjacencyEnabled;
bool CurvatureDirEnabled; bool CurvatureEnabled;
bool CurvatureDirEnabled;
bool MarkEnabled; bool MarkEnabled;
bool RadiusEnabled;
}; };
//template<> void EnableAttribute<typename VALUE_TYPE::NormalType>(){ NormalEnabled=true;} //template<> void EnableAttribute<typename VALUE_TYPE::NormalType>(){ NormalEnabled=true;}
/*------------------------- COORD -----------------------------------------*/ /*------------------------- COORD -----------------------------------------*/
/*----------------------------- VFADJ ------------------------------*/ /*----------------------------- VFADJ ------------------------------*/
template <class T> class VFAdjOcf: public T { template <class T> class VFAdjOcf: public T {
public: public:
typename T::FacePointer &VFp() { typename T::FacePointer &VFp() {
assert((*this).Base().VFAdjacencyEnabled); assert((*this).Base().VFAdjacencyEnabled);
return (*this).Base().AV[(*this).Index()]._fp; return (*this).Base().AV[(*this).Index()]._fp;
} }
typename T::FacePointer cVFp() const { typename T::FacePointer cVFp() const {
if(! (*this).Base().VFAdjacencyEnabled ) return 0; if(! (*this).Base().VFAdjacencyEnabled ) return 0;
else return (*this).Base().AV[(*this).Index()]._fp; else return (*this).Base().AV[(*this).Index()]._fp;
} }
int &VFi() { int &VFi() {
assert((*this).Base().VFAdjacencyEnabled); assert((*this).Base().VFAdjacencyEnabled);
return (*this).Base().AV[(*this).Index()]._zp; return (*this).Base().AV[(*this).Index()]._zp;
} }
template <class LeftV> template <class LeftV>
void ImportLocal(const LeftV & leftV) void ImportLocal(const LeftV & leftV)
{ {
if((*this).Base().VFAdjacencyEnabled) // init the data only if they are enabled! if((*this).Base().VFAdjacencyEnabled) // init the data only if they are enabled!
{ {
VFp() = NULL; VFp() = NULL;
VFi() = -1; VFi() = -1;
} }
T::ImportLocal(leftV); T::ImportLocal(leftV);
} }
static bool HasVFAdjacency() { return true; } static bool HasVFAdjacency() { return true; }
static bool HasVFAdjacencyOcf() {assert(!T::HasVFAdjacencyOcf()); return true; } static bool HasVFAdjacencyOcf() {assert(!T::HasVFAdjacencyOcf()); return true; }
private: private:
}; };
/*------------------------- Normal -----------------------------------------*/ /*------------------------- Normal -----------------------------------------*/
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 HasNormal() { return true; } static bool HasNormal() { return true; }
static bool HasNormalOcf() { return true; } static bool HasNormalOcf() { return true; }
NormalType &N() { NormalType &N() {
// you cannot use Normals before enabling them with: yourmesh.vert.EnableNormal() // you cannot use Normals before enabling them with: yourmesh.vert.EnableNormal()
assert((*this).Base().NormalEnabled); assert((*this).Base().NormalEnabled);
return (*this).Base().NV[(*this).Index()]; } return (*this).Base().NV[(*this).Index()]; }
const NormalType &N() const { const NormalType &N() const {
// you cannot use Normals before enabling them with: yourmesh.vert.EnableNormal() // you cannot use Normals before enabling them with: yourmesh.vert.EnableNormal()
assert((*this).Base().NormalEnabled); assert((*this).Base().NormalEnabled);
return (*this).Base().NV[(*this).Index()]; } return (*this).Base().NV[(*this).Index()]; }
template <class LeftV> template <class LeftV>
void ImportLocal(const LeftV & leftV){ void ImportLocal(const LeftV & leftV){
if((*this).Base().NormalEnabled && leftV.Base().NormalEnabled ) // copy the data only if they are enabled in both vertices if((*this).Base().NormalEnabled && leftV.Base().NormalEnabled ) // copy the data only if they are enabled in both vertices
N().Import(leftV.cN()); N().Import(leftV.cN());
T::ImporLocal(leftV);} T::ImporLocal(leftV);}
@ -388,78 +407,78 @@ template <class T> class Normal3sOcf: public NormalOcf<vcg::Point3s, T> {};
template <class T> class Normal3fOcf: public NormalOcf<vcg::Point3f, T> {}; template <class T> class Normal3fOcf: public NormalOcf<vcg::Point3f, T> {};
template <class T> class Normal3dOcf: public NormalOcf<vcg::Point3d, T> {}; template <class T> class Normal3dOcf: public NormalOcf<vcg::Point3d, T> {};
///*-------------------------- COLOR ----------------------------------*/ ///*-------------------------- COLOR ----------------------------------*/
template <class A, class T> class ColorOcf: public T { template <class A, class T> class ColorOcf: public T {
public: public:
typedef A ColorType; typedef A ColorType;
ColorType &C() { assert((*this).Base().NormalEnabled); return (*this).Base().CV[(*this).Index()]; } ColorType &C() { assert((*this).Base().NormalEnabled); return (*this).Base().CV[(*this).Index()]; }
const ColorType &cC() const { assert((*this).Base().ColorEnabled); return (*this).Base().CV[(*this).Index()]; } const ColorType &cC() const { assert((*this).Base().ColorEnabled); return (*this).Base().CV[(*this).Index()]; }
template <class LeftV> template <class LeftV>
void ImportLocal(const LeftV & leftV) void ImportLocal(const LeftV & leftV)
{ {
if((*this).Base().ColorEnabled && leftV.Base().ColorEnabled ) // copy the data only if they are enabled in both vertices if((*this).Base().ColorEnabled && leftV.Base().ColorEnabled ) // copy the data only if they are enabled in both vertices
C() = leftV.cC(); C() = leftV.cC();
T::ImporLocal(leftV); T::ImporLocal(leftV);
} }
static bool HasColor() { return true; } static bool HasColor() { return true; }
static bool HasColorOcf() { assert(!T::HasColorOcf()); return true; } static bool HasColorOcf() { assert(!T::HasColorOcf()); return true; }
}; };
template <class T> class Color4bOcf: public ColorOcf<vcg::Color4b, T> {}; template <class T> class Color4bOcf: public ColorOcf<vcg::Color4b, T> {};
///*-------------------------- QUALITY ----------------------------------*/ ///*-------------------------- QUALITY ----------------------------------*/
template <class A, class T> class QualityOcf: public T { template <class A, class T> class QualityOcf: public T {
public: public:
typedef A QualityType; typedef A QualityType;
QualityType &Q() { assert((*this).Base().QualityEnabled); return (*this).Base().QV[(*this).Index()]; } QualityType &Q() { assert((*this).Base().QualityEnabled); return (*this).Base().QV[(*this).Index()]; }
template <class LeftV> template <class LeftV>
void ImportLocal(const LeftV & leftV) void ImportLocal(const LeftV & leftV)
{ {
if((*this).Base().QualityEnabled && leftV.Base().QualityEnabled ) // copy the data only if they are enabled in both vertices if((*this).Base().QualityEnabled && leftV.Base().QualityEnabled ) // copy the data only if they are enabled in both vertices
Q() = leftV.cQ(); Q() = leftV.cQ();
T::ImporLocal(leftV); T::ImporLocal(leftV);
} }
static bool HasQuality() { return true; } static bool HasQuality() { return true; }
static bool HasQualityOcf() { assert(!T::HasQualityOcf()); return true; } static bool HasQualityOcf() { assert(!T::HasQualityOcf()); return true; }
}; };
template <class T> class QualityfOcf: public QualityOcf<float, T> {}; template <class T> class QualityfOcf: public QualityOcf<float, T> {};
///*-------------------------- MARK ----------------------------------*/ ///*-------------------------- MARK ----------------------------------*/
template <class T> class MarkOcf: public T { template <class T> class MarkOcf: public T {
public: public:
inline int & IMark() { inline int & IMark() {
assert((*this).Base().MarkEnabled); assert((*this).Base().MarkEnabled);
return (*this).Base().MV[(*this).Index()]; return (*this).Base().MV[(*this).Index()];
} }
inline int IMark() const { inline int IMark() const {
assert((*this).Base().MarkEnabled); assert((*this).Base().MarkEnabled);
return (*this).Base().MV[(*this).Index()]; return (*this).Base().MV[(*this).Index()];
} ; }
template <class LeftV> template <class LeftV>
void ImportLocal(const LeftV & leftV) void ImportLocal(const LeftV & leftV)
{ {
if((*this).Base().MarkEnabled && leftV.Base().MarkEnabled ) // copy the data only if they are enabled in both vertices if((*this).Base().MarkEnabled && leftV.Base().MarkEnabled ) // copy the data only if they are enabled in both vertices
IMark() = leftV.IMark(); IMark() = leftV.IMark();
T::ImportLocal(leftV); T::ImportLocal(leftV);
} }
static bool HasFaceMark() { return true; } static bool HasFaceMark() { return true; }
static bool HasFaceMarkOcf() { return true; } static bool HasFaceMarkOcf() { return true; }
inline void InitIMark() { IMark() = 0; } inline void InitIMark() { IMark() = 0; }
}; };
///*-------------------------- CURVATURE ----------------------------------*/ ///*-------------------------- CURVATURE ----------------------------------*/
template <class A, class TT> class CurvatureOcf: public TT { template <class A, class TT> class CurvatureOcf: public TT {
public: public:
typedef Point2<A> CurvatureType; typedef Point2<A> CurvatureType;
typedef typename CurvatureType::ScalarType ScalarType; typedef typename CurvatureType::ScalarType ScalarType;
ScalarType &Kh(){ assert((*this).Base().CurvatureEnabled); return (*this).Base().CuV[(*this).Index()][0];} ScalarType &Kh(){ assert((*this).Base().CurvatureEnabled); return (*this).Base().CuV[(*this).Index()][0];}
@ -467,41 +486,41 @@ public:
const ScalarType &cKh() const { assert((*this).Base().CurvatureEnabled); return (*this).Base().CuV[(*this).Index()][0];} const ScalarType &cKh() const { assert((*this).Base().CurvatureEnabled); return (*this).Base().CuV[(*this).Index()][0];}
const ScalarType &cKg() const { assert((*this).Base().CurvatureEnabled); return (*this).Base().CuV[(*this).Index()][1];} const ScalarType &cKg() const { assert((*this).Base().CurvatureEnabled); return (*this).Base().CuV[(*this).Index()][1];}
template <class LeftV> template <class LeftV>
void ImportLocal(const LeftV & leftV){ void ImportLocal(const LeftV & leftV){
if((*this).Base().CurvatureEnabled && leftV.Base().CurvatureEnabled ) // copy the data only if they are enabled in both vertices if((*this).Base().CurvatureEnabled && leftV.Base().CurvatureEnabled ) // copy the data only if they are enabled in both vertices
{ {
(*this).Base().CuV[(*this).Index()][0] = leftV.cKh(); (*this).Base().CuV[(*this).Index()][0] = leftV.cKh();
(*this).Base().CuV[(*this).Index()][1] = leftV.cKg(); (*this).Base().CuV[(*this).Index()][1] = leftV.cKg();
} }
TT::ImportLocal(leftV); TT::ImportLocal(leftV);
} }
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);}
private: private:
}; };
template <class T> class CurvaturefOcf: public CurvatureOcf<float, T> {}; template <class T> class CurvaturefOcf: public CurvatureOcf<float, T> {};
template <class T> class CurvaturedOcf: public CurvatureOcf<double, T> {}; template <class T> class CurvaturedOcf: public CurvatureOcf<double, T> {};
///*-------------------------- CURVATURE DIR ----------------------------------*/ ///*-------------------------- CURVATURE DIR ----------------------------------*/
template <class S> template <class S>
struct CurvatureDirTypeOcf{ struct CurvatureDirTypeOcf{
typedef Point3<S> VecType; typedef Point3<S> VecType;
typedef S ScalarType; typedef S ScalarType;
CurvatureDirTypeOcf () {} CurvatureDirTypeOcf () {}
Point3<S>max_dir,min_dir; Point3<S>max_dir,min_dir;
S k1,k2; S k1,k2;
}; };
template <class A, class TT> class CurvatureDirOcf: public TT { template <class A, class TT> class CurvatureDirOcf: public TT {
public: public:
typedef A CurvatureDirType; typedef A CurvatureDirType;
typedef typename CurvatureDirType::VecType VecType; typedef typename CurvatureDirType::VecType VecType;
typedef typename CurvatureDirType::ScalarType ScalarType; typedef typename CurvatureDirType::ScalarType ScalarType;
@ -515,11 +534,11 @@ public:
const ScalarType &cK1() const {assert((*this).Base().CurvatureDirEnabled); return (*this).Base().CuDV[(*this).Index()].k1;} const ScalarType &cK1() const {assert((*this).Base().CurvatureDirEnabled); return (*this).Base().CuDV[(*this).Index()].k1;}
const ScalarType &cK2()const {assert((*this).Base().CurvatureDirEnabled); return (*this).Base().CuDV[(*this).Index()].k2;} const ScalarType &cK2()const {assert((*this).Base().CurvatureDirEnabled); return (*this).Base().CuDV[(*this).Index()].k2;}
static bool HasCurvatureDirOcf() { return true; } static bool HasCurvatureDirOcf() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("CurvatureDirOcf"));TT::Name(name);} static void Name(std::vector<std::string> & name){name.push_back(std::string("CurvatureDirOcf"));TT::Name(name);}
private: private:
CurvatureDirType _curv; CurvatureDirType _curv;
}; };
@ -529,19 +548,50 @@ public: static void Name(std::vector<std::string> & name){name.push_back(std::st
template <class T> class CurvatureDirdOcf: public CurvatureDirOcf<CurvatureDirTypeOcf<double>, T> { template <class T> class CurvatureDirdOcf: public CurvatureDirOcf<CurvatureDirTypeOcf<double>, T> {
public: static void Name(std::vector<std::string> & name){name.push_back(std::string("CurvatureDirdOcf"));T::Name(name);} public: static void Name(std::vector<std::string> & name){name.push_back(std::string("CurvatureDirdOcf"));T::Name(name);}
}; };
///*-------------------------- InfoOpt ----------------------------------*/
///*-------------------------- RADIUS ----------------------------------*/
template <class A, class TT> class RadiusOcf: public TT {
public:
typedef A RadiusType;
typedef RadiusType ScalarType;
RadiusType &R(){ assert((*this).Base().RadiusEnabled); return (*this).Base().RadiusV[(*this).Index()];}
const RadiusType &cR() const { assert((*this).Base().RadiusEnabled); return (*this).Base().RadiusV[(*this).Index()];}
template <class LeftV>
void ImportLocal(const LeftV & leftV)
{
if ((*this).Base().RadiusEnabled && leftV.Base().RadiusEnabled )
(*this).Base().RadiusV[(*this).Index()] = leftV.cR();
TT::ImportLocal(leftV);
}
static bool HasRadius() { return true; }
static bool HasRadiusOcf() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("RadiusOcf")); TT::Name(name);}
private:
};
template <class T> class RadiusfOcf: public RadiusOcf<float, T> {};
template <class T> class RadiusdOcf: public RadiusOcf<double, T> {};
///*-------------------------- InfoOpt ----------------------------------*/
template < class T> class InfoOcf: public T { template < class T> class InfoOcf: public T {
public: public:
vector_ocf<typename T::VertType> &Base() const { return *_ovp;} vector_ocf<typename T::VertType> &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::VertType const *tp=static_cast<typename T::VertType 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::VertType> *_ovp;
static bool HasQualityOcf() { return false; } static bool HasQualityOcf() { return false; }
static bool HasVFAdjacencyOcf() { return false; } static bool HasVFAdjacencyOcf() { return false; }
@ -557,10 +607,10 @@ namespace tri
template < class, class > class TriMesh; template < class, class > class TriMesh;
template < class VertexType, class FaceContainerType > template < class VertexType, class FaceContainerType >
bool HasPerVertexQuality (const TriMesh < vertex::vector_ocf< VertexType > , FaceContainerType > & m) bool HasPerVertexQuality (const TriMesh < vertex::vector_ocf< VertexType > , FaceContainerType > & m)
{ {
if(VertexType::HasQualityOcf()) return m.vert.IsQualityEnabled(); if(VertexType::HasQualityOcf()) return m.vert.IsQualityEnabled();
else return VertexType::HasQuality(); else return VertexType::HasQuality();
} }
template < class VertexType > template < class VertexType >

52
wrap/io_trimesh/io_mask.h
View File

@ -46,14 +46,12 @@ Initial commit
#ifndef __VCGLIB_IOTRIMESH_IO_MASK #ifndef __VCGLIB_IOTRIMESH_IO_MASK
#define __VCGLIB_IOTRIMESH_IO_MASK #define __VCGLIB_IOTRIMESH_IO_MASK
//#include<wrap/callback.h>
namespace vcg { namespace vcg {
namespace tri { namespace tri {
namespace io { namespace io {
/** /**
@name Load and Save in Ply format @name Input/output data mask
*/ */
//@{ //@{
@ -66,30 +64,32 @@ public:
*/ */
enum { enum {
IOM_NONE = 0x0000, IOM_NONE = 0x00000,
IOM_VERTCOORD = 0x0001, IOM_VERTCOORD = 0x00001,
IOM_VERTFLAGS = 0x0002, IOM_VERTFLAGS = 0x00002,
IOM_VERTCOLOR = 0x0004, IOM_VERTCOLOR = 0x00004,
IOM_VERTQUALITY = 0x0008, IOM_VERTQUALITY = 0x00008,
IOM_VERTNORMAL = 0x0010, IOM_VERTNORMAL = 0x00010,
IOM_VERTTEXCOORD = 0x0020, IOM_VERTTEXCOORD = 0x00020,
IOM_VERTRADIUS = 0x10000,
IOM_FACEINDEX = 0x0040, IOM_FACEINDEX = 0x00040,
IOM_FACEFLAGS = 0x0080, IOM_FACEFLAGS = 0x00080,
IOM_FACECOLOR = 0x0100, IOM_FACECOLOR = 0x00100,
IOM_FACEQUALITY = 0x0200, IOM_FACEQUALITY = 0x00200,
IOM_FACENORMAL = 0x0400, IOM_FACENORMAL = 0x00400,
IOM_WEDGCOLOR = 0x0800,
IOM_WEDGTEXCOORD = 0x1000,
IOM_WEDGTEXMULTI = 0x2000, // Se ha anche l'indice di texture esplicito
IOM_WEDGNORMAL = 0x4000,
IOM_CAMERA = 0x8000, IOM_WEDGCOLOR = 0x00800,
IOM_WEDGTEXCOORD = 0x01000,
IOM_WEDGTEXMULTI = 0x02000, // Se ha anche l'indice di texture esplicito
IOM_WEDGNORMAL = 0x04000,
IOM_CAMERA = 0x08000,
IOM_FLAGS = IOM_VERTFLAGS + IOM_FACEFLAGS, IOM_FLAGS = IOM_VERTFLAGS + IOM_FACEFLAGS,
IOM_ALL = 0xFFFF IOM_ALL = 0xFFFFF
}; };
// //
// //
@ -117,13 +117,13 @@ enum {
// //
// if( mask & IOM_CAMERA ) strcat(str," camera"); // if( mask & IOM_CAMERA ) strcat(str," camera");
//} //}
template <class MeshType> template <class MeshType>
static void ClampMask(MeshType &m, int &mask) static void ClampMask(MeshType &m, int &mask)
{ {
if( (mask & IOM_FACECOLOR) && !HasPerFaceColor(m) ) mask = mask & (~IOM_FACECOLOR); if( (mask & IOM_FACECOLOR) && !HasPerFaceColor(m) ) mask = mask & (~IOM_FACECOLOR);
if( (mask & IOM_WEDGTEXCOORD) && !HasPerWedgeTexCoord(m) ) mask = mask & (~IOM_WEDGTEXCOORD); if( (mask & IOM_WEDGTEXCOORD) && !HasPerWedgeTexCoord(m) ) mask = mask & (~IOM_WEDGTEXCOORD);
if( (mask & IOM_WEDGNORMAL) && !m.HasPerWedgeNormal() ) mask = mask & (~IOM_WEDGNORMAL); if( (mask & IOM_WEDGNORMAL) && !m.HasPerWedgeNormal() ) mask = mask & (~IOM_WEDGNORMAL);
if( (mask & IOM_VERTCOLOR) && !m.HasPerVertexColor() ) mask = mask & (~IOM_VERTCOLOR); if( (mask & IOM_VERTCOLOR) && !m.HasPerVertexColor() ) mask = mask & (~IOM_VERTCOLOR);
} }
}; // end class }; // end class