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

ImportLocal to ImportData. Adjacencies are no more handle by ImportData, but 

by speficic functions in append.h (ImportPerxxxAdj(..))
This commit is contained in:
ganovelli 2010-06-16 16:24:26 +00:00
parent e8d3020714
commit 585f0462e8
11 changed files with 147 additions and 283 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -45,7 +45,7 @@ template <class UserTypes>
public:
template < class LeftV>
void ImportLocal(const LeftV & /* left */ ) { }
void ImportData(const LeftV & /* left */ ) { }
static void Name(std::vector<std::string> & name){}
};

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

@ -23,7 +23,7 @@
#ifndef __VCG_EDGE_PLUS_COMPONENT
#define __VCG_EDGE_PLUS_COMPONENT
//#include <vector>
#include <vector>
#include <string>
//#include <vcg/space/point3.h>
//#include <vcg/space/texcoord2.h>
@ -49,7 +49,7 @@ public:
inline const typename T::CoordType & P( const int j ) const { assert(0); static typename T::CoordType coord(0, 0, 0); return coord; }
inline const typename T::CoordType &cP( const int j ) const { assert(0); static typename T::CoordType coord(0, 0, 0); return coord; }
template <class LeftF>
void ImportLocal(const LeftF & leftF) {T::ImportLocal(leftF);}
void ImportData(const LeftF & leftF) {T::ImportData(leftF);}
static bool HasVertexRef() { return false; }
static void Name(std::vector<std::string> & name){T::Name(name);}
@ -91,7 +91,7 @@ public:
inline const typename T::VertexType * const & UberV( const int j ) const { assert(j>=0 && j<2); return v[j]; }
template <class LeftF>
void ImportLocal(const LeftF & leftF){ V(0) = NULL; V(1) = NULL; V(2) = NULL; T::ImportLocal(leftF);}
void ImportData(const LeftF & leftF){ T::ImportData(leftF);}
static bool HasVertexRef() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("VertexRef"));T::Name(name);}
@ -113,7 +113,7 @@ public:
inline int & IMark() { assert(0); static int tmp=-1; return tmp;}
inline const int & IMark() const {return 0;}
template < class LeftV>
void ImportLocal(const LeftV & left ) { T::ImportLocal( left); }
void ImportData(const LeftV & left ) { T::ImportData( left); }
static void Name(std::vector<std::string> & name){T::Name(name);}
};
@ -125,7 +125,7 @@ public:
inline int & IMark() { return _imark;}
inline const int & IMark() const {return _imark;}
template < class LeftV>
void ImportLocal(const LeftV & left ) { IMark() = left.IMark(); T::ImportLocal( left); }
void ImportData(const LeftV & left ) { IMark() = left.IMark(); T::ImportData( left); }
static void Name(std::vector<std::string> & name){name.push_back(std::string("Mark"));T::Name(name);}
private:
@ -140,7 +140,7 @@ public:
int &Flags() { static int dummyflags(0); assert(0); return dummyflags; }
int Flags() const { return 0; }
template < class LeftV>
void ImportLocal(const LeftV & left ) { T::ImportLocal( left); }
void ImportData(const LeftV & left ) { T::ImportData( left); }
static bool HasFlags() { return false; }
static void Name(std::vector<std::string> & name){T::Name(name);}
@ -153,7 +153,7 @@ public:
int &Flags() {return _flags; }
int Flags() const {return _flags; }
template < class LeftV>
void ImportLocal(const LeftV & left ) { Flags() = left.Flags(); T::ImportLocal( left); }
void ImportData(const LeftV & left ) { Flags() = left.Flags(); T::ImportData( left); }
static bool HasFlags() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("BitFlags"));T::Name(name);}
@ -172,7 +172,7 @@ public:
typedef vcg::Color4b ColorType;
ColorType &C() { static ColorType dumcolor(vcg::Color4b::White); assert(0); return dumcolor; }
template < class LeftV>
void ImportLocal(const LeftV & left ) { T::ImportLocal( left); }
void ImportData(const LeftV & left ) { T::ImportData( left); }
static bool HasColor() { return false; }
static void Name(std::vector<std::string> & name){T::Name(name);}
};
@ -187,7 +187,7 @@ public:
const ColorType &C() const { return _color; }
const ColorType &cC() const { return _color; }
template < class LeftV>
void ImportLocal(const LeftV & left ) { C() = left.cC(); T::ImportLocal( left); }
void ImportData(const LeftV & left ) { C() = left.cC(); T::ImportData( left); }
static bool HasColor() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("Color"));T::Name(name);}
@ -207,7 +207,7 @@ public:
QualityType &Q() { return _quality; }
const QualityType & cQ() const {return _quality; }
template < class LeftV>
void ImportLocal(const LeftV & left ) { Q() = left.cQ(); TT::ImportLocal( left); }
void ImportData(const LeftV & left ) { Q() = left.cQ(); TT::ImportData( left); }
static bool HasQuality() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("Quality"));TT::Name(name);}
@ -228,11 +228,12 @@ public: static void Name(std::vector<std::string> & name){name.push_back(std::st
/*----------------------------- EVADJ ------------------------------*/
template <class T> class EmptyEVAdj: public T {
public:
typename T::VertexPointer &V(const int &) { static typename T::VertexPointer ep=0; assert(0); return ep; }
typename T::VertexPointer cV(const int &) { static typename T::VertexPointer ep=0; assert(0); return ep; }
int &EVi(){static int z=0; return z;};
typename T::VertexPointer &EVp(const int &) { static typename T::VertexPointer ep=0; assert(0); return ep; }
typename T::VertexPointer const cEVp(const int &) const { static typename T::VertexPointer ep=0; assert(0); return ep; }
typename T::VertexPointer &V(const int &i) { return EVp(i);}
typename T::VertexPointer const cV(const int &i) const { return cEVp(i); }
template < class LeftV>
void ImportLocal(const LeftV & left ) { T::ImportLocal( left); }
void ImportData(const LeftV & left ) { T::ImportData( left); }
static bool HasEVAdjacency() { return false; }
static bool HasEVAdjacencyOcc() { return false; }
static void Name(std::vector<std::string> & name){ T::Name(name);}
@ -241,10 +242,13 @@ public:
template <class T> class EVAdj: public T {
public:
EVAdj(){_vp[0]= _vp[1] =0;}
typename T::VertexPointer & V(const int & i) {return _vp[i]; }
const typename T::VertexPointer cV(const int & i) const {return _vp[i]; }
typename T::VertexPointer & EVp(const int & i) {return _vp[i]; }
typename T::VertexPointer const cEVp(const int & i) const {return _vp[i]; }
typename T::VertexPointer &V(const int &i) { return EVp(i);}
typename T::VertexPointer const cV(const int &i) const { return cEVp(i); }
template < class LeftV>
void ImportLocal(const LeftV & left ) { V() = NULL; T::ImportLocal( left); }
void ImportData(const LeftV & left ) { T::ImportData( left); }
static bool HasEVAdjacency() { return true; }
static bool HasEVAdjacencyOcc() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("EVAdj"));T::Name(name);}
@ -258,10 +262,11 @@ private:
template <class T> class EmptyEEAdj: public T {
public:
typename T::EdgePointer &EEp(const int & ) { static typename T::EdgePointer ep=0; assert(0); return ep; }
typename T::EdgePointer cEEp(const int & ) { static typename T::EdgePointer ep=0; assert(0); return ep; }
int &EEi(){static int z=0; return z;};
const typename T::EdgePointer cEEp(const int & ) const { static typename T::EdgePointer ep=0; assert(0); return ep; }
int &EEi(const int &){static int z=0; assert(0); return z;};
const int &cEEi(const int &) const {static int z=0; assert(0); return z;};
template < class LeftV>
void ImportLocal(const LeftV & left ) { T::ImportLocal( left); }
void ImportData(const LeftV & left ) { T::ImportData( left); }
static bool HasEEAdjacency() { return false; }
static bool HasEEAdjacencyOcc() { return false; }
static void Name(std::vector<std::string> & name){ T::Name(name);}
@ -272,9 +277,11 @@ public:
EEAdj(){_ep=0;}
typename T::EdgePointer &EEp(const int & i) {return _ep[i]; }
typename T::EdgePointer cEEp(const int & i) {return _ep[i]; }
int &EEi(const int & i) {return _zp[i]; }
int &EEi(const int & i){ return _zp[i];};
const int &cEEi(const int &i ){return _zp[i];};
template < class LeftV>
void ImportLocal(const LeftV & left ) { EEp() = NULL; T::ImportLocal( left); }
void ImportData(const LeftV & left ) { T::ImportData( left); }
static bool HasEEAdjacency() { return true; }
static bool HasEEAdjacencyOcc() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("EEAdj"));T::Name(name);}
@ -289,10 +296,10 @@ private:
template <class T> class EmptyEHAdj: public T {
public:
typename T::HEdgePointer &EHp( ) { static typename T::HEdgePointer hp=0; assert(0); return hp; }
typename T::HEdgePointer cEHp( ) { static typename T::HEdgePointer hp=0; assert(0); return hp; }
const typename T::HEdgePointer cEHp( ) const { static typename T::HEdgePointer hp=0; assert(0); return hp; }
template < class LeftV>
void ImportLocal(const LeftV & left ) { T::ImportLocal( left); }
void ImportData(const LeftV & left ) { T::ImportData( left); }
static bool HasEHAdjacency() { return false; }
static bool HasEHAdjacencyOcc() { return false; }
static void Name(std::vector<std::string> & name){ T::Name(name);}
@ -302,10 +309,10 @@ template <class T> class EHAdj: public T {
public:
EHAdj(){_hp=0;}
typename T::HEdgePointer &EHp( ) {return _hp ; }
typename T::HEdgePointer cEHp( ) {return _hp ; }
const typename T::HEdgePointer cEHp( ) const {return _hp ; }
template < class LeftV>
void ImportLocal(const LeftV & left ) { EHp() = NULL; T::ImportLocal( left); }
void ImportData(const LeftV & left ) { T::ImportData( left); }
static bool HasEHAdjacency() { return true; }
static bool HasEHAdjacencyOcc() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("EHAdj"));T::Name(name);}
@ -349,10 +356,11 @@ private:
template <class T> class EmptyEFAdj: public T {
public:
typename T::FacePointer &EFp() { static typename T::FacePointer fp=0; assert(0); return fp; }
typename T::FacePointer cEFp() { static typename T::FacePointer fp=0; assert(0); return fp; }
int &EFi(){static int z=0; return z;};
const typename T::FacePointer cEFp() const { static typename T::FacePointer fp=0; assert(0); return fp; }
int &EFi() {static int z=0; return z;};
const int &cEFi() const {static int z=0; return z;};
template < class LeftV>
void ImportLocal(const LeftV & left ) { T::ImportLocal( left); }
void ImportData(const LeftV & left ) { T::ImportData( left); }
static bool HasEFAdjacency() { return false; }
static bool HasEFAdjacencyOcc() { return false; }
static void Name(std::vector<std::string> & name){ T::Name(name);}
@ -362,10 +370,11 @@ template <class T> class EFAdj: public T {
public:
EFAdj(){_fp=0;}
typename T::FacePointer &EFp() {return _fp; }
typename T::FacePointer cEFp() {return _fp; }
int &EFi() {return _zp; }
const typename T::FacePointer cEFp() const {return _fp; }
int &EFi() {static int z=0; return z;};
const int &cEFi() const {return _zp; }
template < class LeftV>
void ImportLocal(const LeftV & left ) { this->EFp() = NULL; T::ImportLocal( left); }
void ImportData(const LeftV & left ) { T::ImportData( left); }
static bool HasEFAdjacency() { return true; }
static bool HasEFAdjacencyOcc() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("EFAdj"));T::Name(name);}

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

@ -20,57 +20,7 @@
* for more details. *
* *
****************************************************************************/
/****************************************************************************
History
$Log: not supported by cvs2svn $
Revision 1.13 2008/02/03 23:49:42 cignoni
Important Change. Now GetBBox return a null bbox if called on a deleted face (instead of crashing)
Revision 1.12 2007/05/04 16:40:11 ganovelli
changes to comply "plus" types
Revision 1.11 2007/03/27 09:22:11 cignoni
Added Visited flags
Revision 1.10 2007/03/12 15:37:19 tarini
Texture coord name change! "TCoord" and "Texture" are BAD. "TexCoord" is GOOD.
Revision 1.9 2007/02/12 19:01:23 ganovelli
added Name(std:vector<std::string>& n) that fills n with the names of the attribute of the face type
Revision 1.8 2006/10/09 20:20:18 cignoni
Increased the maximum number of possible template args from 8 to 9
Revision 1.7 2006/02/27 17:58:11 ponchio
Added some documentation
Revision 1.6 2005/12/16 13:28:09 cignoni
Increased the maximum number of possible template args from 7 to 8
Revision 1.5 2005/12/02 00:41:38 cignoni
Added and removed typenames for gcc compiling.
Added this-> qualifier for referencing the elemntes of the templated base class
(e.g. to refer the possibly overridden flags()) it seems to be needed by the standard
Revision 1.4 2005/11/16 22:56:32 cignoni
Added EmptyMark to base class
Standardized name of flags. It is plural becouse each simplex has many flag.
Revision 1.3 2005/11/12 18:42:18 cignoni
Added ClearS and GetBBox
Revision 1.2 2005/10/14 13:26:57 cignoni
First Really Working version
Revision 1.2 2004/04/03 13:33:55 cignoni
Missing include
Revision 1.1 2004/03/29 08:36:26 cignoni
First working version!
****************************************************************************/
#ifndef __VCG_FACE_PLUS
#define __VCG_FACE_PLUS
@ -95,7 +45,7 @@ template <class UserTypes>
public:
template <class LeftF>
void ImportLocal(const LeftF & ){}
void ImportData(const LeftF & ){}
static void Name(std::vector<std::string> & /* name */){}

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

@ -25,7 +25,7 @@
$Log: not supported by cvs2svn $
Revision 1.21 2008/02/04 21:26:45 ganovelli
added ImportLocal which imports all local attributes into vertexplus and faceplus.
added ImportData which imports all local attributes into vertexplus and faceplus.
A local attribute is everything (N(), C(), Q()....) except pointers to other simplices
(i.e. FFAdj, VFAdj, VertexRef) which are set to NULL.
Added some function for const attributes
@ -119,14 +119,20 @@ public:
inline typename T::VertexType * & V( const int ) { assert(0); static typename T::VertexType *vp=0; return vp; }
inline typename T::VertexType * const & V( const int ) const { assert(0); static typename T::VertexType *vp=0; return vp; }
inline typename T::VertexType * cV( const int ) const { assert(0); static typename T::VertexType *vp=0; return vp; }
inline typename T::VertexType * & FVp( const int i ) { return this->V(i); }
inline typename T::VertexType * const & FVp( const int i) const { return this->V(i); }
inline typename T::VertexType * cFVp( const int i ) const { return this->cV(i); }
inline typename T::CoordType & P( const int ) { assert(0); static typename T::CoordType coord(0, 0, 0); return coord; }
inline const typename T::CoordType & P( const int ) const { assert(0); static typename T::CoordType coord(0, 0, 0); return coord; }
inline const typename T::CoordType &cP( const int ) const { assert(0); static typename T::CoordType coord(0, 0, 0); return coord; }
template <class RightF>
void ImportLocal(const RightF & rightF) {T::ImportLocal(rightF);}
void ImportData(const RightF & rightF) {T::ImportData(rightF);}
inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();}
static bool HasVertexRef() { return false; }
static bool HasFVAdjacency() { return false; }
static void Name(std::vector<std::string> & name){T::Name(name);}
};
@ -143,7 +149,7 @@ public:
inline typename T::VertexType * & V( const int j ) { assert(j>=0 && j<3); return v[j]; }
inline typename T::VertexType * const & V( const int j ) const { assert(j>=0 && j<3); return v[j]; }
inline typename T::VertexType * cV( const int j ) const { assert(j>=0 && j<3); return v[j]; }
inline typename T::VertexType * cV( const int j ) const { assert(j>=0 && j<3); return v[j]; }
// Shortcut per accedere ai punti delle facce
inline CoordType & P( const int j ) { assert(j>=0 && j<3); return v[j]->P(); }
@ -179,13 +185,15 @@ public:
// Small comment about the fact that the pointers are zero filled.
// The importLocal is meant for copyng stuff between very different meshes, so copying the pointers would be meaningless.
// if you are using ImportLocal for copying internally simplex you have to set up all the pointers by hand.
// if you are using ImportData for copying internally simplex you have to set up all the pointers by hand.
template <class RightF>
void ImportLocal(const RightF & rightF){ V(0) = NULL; V(1) = NULL; V(2) = NULL; T::ImportLocal(rightF);}
void ImportData(const RightF & rightF){ T::ImportData(rightF);}
inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();}
static bool HasVertexRef() { return true; }
static bool HasFVAdjacency() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("VertexRef"));T::Name(name);}
@ -207,7 +215,7 @@ public:
const NormalType cWN(int) const { static NormalType dummy_normal(0, 0, 0); return dummy_normal; }
template <class RightF>
void ImportLocal(const RightF & rightF){ T::ImportLocal(rightF);}
void ImportData(const RightF & rightF){ T::ImportData(rightF);}
static bool HasWedgeNormal() { return false; }
static bool HasFaceNormal() { return false; }
static bool HasWedgeNormalOcc() { return false; }
@ -225,7 +233,7 @@ public:
NormalType &N() { return _norm; }
NormalType &cN() const { return _norm; }
template <class RightF>
void ImportLocal(const RightF & rightF){ N() = rightF.cN(); T::ImportLocal(rightF);}
void ImportData(const RightF & rightF){ N() = rightF.cN(); T::ImportData(rightF);}
inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();}
static bool HasFaceNormal() { return true; }
@ -250,10 +258,10 @@ public:
NormalType &N() { return _norm; }
NormalType cN() const { return _norm; }
template <class RightF>
void ImportLocal(const RightF & rightF)
void ImportData(const RightF & rightF)
{
N().Import(rightF.cN());
T::ImportLocal( rightF);
T::ImportData( rightF);
}
inline void Alloc(const int & ns){T::Alloc(ns);}
@ -271,7 +279,7 @@ public:
NormalType &WN(const int j) { return _wnorm[j]; }
const NormalType cWN(const int j) const { return _wnorm[j]; }
template <class RightF>
void ImportLocal(const RightF & rightF){ for (int i=0; i<3; ++i) { WN(i) = rightF.cWN(i); } T::ImportLocal(rightF);}
void ImportData(const RightF & rightF){ for (int i=0; i<3; ++i) { WN(i) = rightF.cWN(i); } T::ImportData(rightF);}
inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();}
static bool HasWedgeNormal() { return true; }
@ -287,7 +295,7 @@ public:
NormalType &WN(const int i) { return _wn[i]; }
NormalType const &cWN(const int i) const { return _wn[i]; }
template <class RightF>
void ImportLocal(const RightF & rightF){ for (int i=0; i<3; ++i) { WN(i) = rightF.cWN(i); } T::ImportLocal(rightF);}
void ImportData(const RightF & rightF){ for (int i=0; i<3; ++i) { WN(i) = rightF.cWN(i); } T::ImportData(rightF);}
inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();}
static bool HasWedgeNormal() { return true; }
@ -327,7 +335,7 @@ public:
TexCoordType &WT(const int) { static TexCoordType dummy_texture; assert(0); return dummy_texture;}
TexCoordType const &cWT(const int) const { static TexCoordType dummy_texture; return dummy_texture;}
template <class RightF>
void ImportLocal(const RightF & rightF){ T::ImportLocal(rightF);}
void ImportData(const RightF & rightF){ T::ImportData(rightF);}
inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();}
static bool HasWedgeTexCoord() { return false; }
@ -342,7 +350,7 @@ public:
TexCoordType &WT(const int i) { return _wt[i]; }
TexCoordType const &cWT(const int i) const { return _wt[i]; }
template <class RightF>
void ImportLocal(const RightF & rightF){ for (int i=0; i<3; ++i) { WT(i) = rightF.cWT(i); } T::ImportLocal(rightF);}
void ImportData(const RightF & rightF){ for (int i=0; i<3; ++i) { WT(i) = rightF.cWT(i); } T::ImportData(rightF);}
inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();}
static bool HasWedgeTexCoord() { return true; }
@ -369,7 +377,7 @@ public:
int &Flags() { static int dummyflags(0); assert(0); return dummyflags; }
int Flags() const { return 0; }
template <class RightF>
void ImportLocal(const RightF & rightF){ T::ImportLocal(rightF);}
void ImportData(const RightF & rightF){ T::ImportData(rightF);}
inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();}
static bool HasFlags() { return false; }
@ -385,7 +393,7 @@ public:
int Flags() const {return _flags; }
const int & cFlags() const {return _flags; }
template <class RightF>
void ImportLocal(const RightF & rightF){ Flags() = rightF.cFlags();T::ImportLocal(rightF);}
void ImportData(const RightF & rightF){ Flags() = rightF.cFlags();T::ImportData(rightF);}
inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();}
static bool HasFlags() { return true; }
@ -432,7 +440,7 @@ public:
static void Name(std::vector<std::string> & name){T::Name(name);}
template <class RightF>
void ImportLocal(const RightF & rightF){ T::ImportLocal(rightF);}
void ImportData(const RightF & rightF){ T::ImportData(rightF);}
inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();}
@ -444,7 +452,7 @@ public:
ColorType &C() { return _color; }
const ColorType &cC() const { return _color; }
template <class RightF>
void ImportLocal(const RightF & rightF){ C() = rightF.cC();T::ImportLocal(rightF);}
void ImportData(const RightF & rightF){ C() = rightF.cC();T::ImportData(rightF);}
inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();}
static bool HasFaceColor() { return true; }
@ -462,7 +470,7 @@ public:
const ColorType &cWC(const int i) const { return _color[i]; }
template <class RightF>
void ImportLocal(const RightF & rightF){ if (RightF::HasWedgeColor()) { for (int i=0; i<3; ++i) { WC(i) = rightF.cWC(i); } T::ImportLocal(rightF); } }
void ImportData(const RightF & rightF){ if (RightF::HasWedgeColor()) { for (int i=0; i<3; ++i) { WC(i) = rightF.cWC(i); } T::ImportData(rightF); } }
static bool HasWedgeColor() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("WedgeColor"));T::Name(name);}
@ -490,7 +498,7 @@ public:
QualityType &Q() { return _quality; }
const QualityType &cQ() const { return _quality; }
template <class RightF>
void ImportLocal(const RightF & rightF){ if(RightF::HasFaceQuality()) Q() = rightF.cQ();T::ImportLocal(rightF);}
void ImportData(const RightF & rightF){ if(RightF::HasFaceQuality()) Q() = rightF.cQ();T::ImportData(rightF);}
inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();}
static bool HasFaceQuality() { return true; }
@ -519,7 +527,7 @@ public:
inline int & IMark() { return _imark;}
inline const int & IMark() const {return _imark;}
template <class RightF>
void ImportLocal(const RightF & rightF){ IMark() = rightF.IMark();T::ImportLocal(rightF);}
void ImportData(const RightF & rightF){ IMark() = rightF.IMark();T::ImportData(rightF);}
static void Name(std::vector<std::string> & name){name.push_back(std::string("Mark"));T::Name(name);}
private:
@ -539,14 +547,14 @@ public:
typename T::FacePointer const cFFp(const int) const { static typename T::FacePointer const fp=0; return fp; }
typename T::EdgePointer &FEp(const int) { static typename T::EdgePointer fp=0; assert(0); return fp; }
typename T::EdgePointer const cFEp(const int) const { static typename T::EdgePointer const fp=0; return fp; }
typename T::HEdgePointer &FHp(const int) { static typename T::HEdgePointer fp=0; assert(0); return fp; }
typename T::HEdgePointer const cFHp(const int) const { static typename T::HEdgePointer const fp=0; return fp; }
typename T::HEdgePointer &FHp() { static typename T::HEdgePointer fp=0; assert(0); return fp; }
typename T::HEdgePointer const cFHp() const { static typename T::HEdgePointer const fp=0; assert(0);return fp; }
char &VFi(const int j){(void)j; static char z=0; assert(0); return z;};
char &FFi(const int j){(void)j; static char z=0; assert(0); return z;};
const char &cVFi(const int j){(void)j; static char z=0; return z;};
const char &cFFi(const int j) const {(void)j; static char z=0; return z;};
template <class RightF>
void ImportLocal(const RightF & rightF){ T::ImportLocal(rightF);}
void ImportData(const RightF & rightF){ T::ImportData(rightF);}
inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();}
static bool HasVFAdjacency() { return false; }
@ -575,7 +583,7 @@ public:
typename T::FacePointer const cVFp(const int j) const { assert(j>=0 && j<3); return _vfp[j]; }
char &VFi(const int j) {return _vfi[j]; }
template <class RightF>
void ImportLocal(const RightF & rightF){T::ImportLocal(rightF);}
void ImportData(const RightF & rightF){T::ImportData(rightF);}
inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();}
static bool HasVFAdjacency() { return true; }
@ -608,7 +616,7 @@ public:
typename T::FacePointer const FFp2( const int j ) const { return FFp((j+2)%3);}
template <class RightF>
void ImportLocal(const RightF & rightF){T::ImportLocal(rightF);}
void ImportData(const RightF & rightF){T::ImportData(rightF);}
inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();}
static bool HasFFAdjacency() { return true; }
@ -642,7 +650,7 @@ public:
typename T::FacePointer const FEp2( const int j ) const { return FEp((j+2)%3);}
template <class RightF>
void ImportLocal(const RightF & rightF){T::ImportLocal(rightF);}
void ImportData(const RightF & rightF){T::ImportData(rightF);}
inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();}
static bool HasFEAdjacency() { return true; }
@ -663,7 +671,7 @@ public:
typename T::HEdgePointer const cFHp( ) const { return _fh; }
template <class RightF>
void ImportLocal(const RightF & rightF){T::ImportLocal(rightF);}
void ImportData(const RightF & rightF){T::ImportData(rightF);}
inline void Alloc(const int & ns){T::Alloc(ns);}
inline void Dealloc(){T::Dealloc();}
static bool HasFHAdjacency() { return true; }

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

@ -19,94 +19,6 @@
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
* for more details. *
* *
****************************************************************************/
/****************************************************************************
History
$Log: not supported by cvs2svn $
Revision 1.25 2008/03/11 09:22:07 cignoni
Completed the garbage collecting functions CompactVertexVector and CompactFaceVector.
Revision 1.24 2008/02/28 15:41:17 cignoni
Added FFpi methods and better init of texture coords
Revision 1.23 2008/02/05 10:11:34 cignoni
A small typo (a T:: instead of TT::)
Revision 1.22 2008/02/04 21:26:45 ganovelli
added ImportLocal which imports all local attributes into vertexplus and faceplus.
A local attribute is everything (N(), C(), Q()....) except pointers to other simplices
(i.e. FFAdj, VFAdj, VertexRef) which are set to NULL.
Added some function for const attributes
Revision 1.21 2007/10/09 12:03:13 corsini
remove signed/unsigned warning
Revision 1.20 2007/03/12 15:37:19 tarini
Texture coord name change! "TCoord" and "Texture" are BAD. "TexCoord" is GOOD.
Revision 1.19 2006/11/28 22:34:28 cignoni
Added default constructor with null initialization to adjacency members.
AddFaces and AddVertices NEED to know if the topology is correctly computed to update it.
Revision 1.18 2006/11/07 11:29:24 cignoni
Corrected some errors in the reflections Has*** functions
Revision 1.17 2006/10/31 16:02:18 ganovelli
vesione 2005 compliant
Revision 1.16 2006/10/27 14:15:10 ganovelli
added overrides to HasFFAddAdjacency and HasVFAddAdjacency
Revision 1.15 2006/10/16 08:49:29 cignoni
Better managment of resize overloading when reducing the size of a vector
Revision 1.14 2006/10/09 20:20:55 cignoni
Added some missing Add***Ocf() for the default case.
Revision 1.13 2006/05/25 09:39:09 cignoni
missing std and other gcc detected syntax errors
Revision 1.12 2006/05/03 21:37:02 cignoni
Added Optional Mark
Revision 1.11 2006/02/28 11:59:39 ponchio
g++ compliance:
begin() -> (*this).begin() and for end(), size(), Base(), Index()
Revision 1.10 2006/01/30 08:47:40 cignoni
Corrected HasPerWedgeTexture
Revision 1.9 2006/01/05 15:46:06 cignoni
Removed a syntax error (double >) in HasPerWedgeTexture/HasPerFaceColor
Revision 1.8 2006/01/04 18:46:25 cignoni
Corrected push_back (did not worked at all!)
added missing cFFi
Revision 1.7 2006/01/03 10:54:21 cignoni
Corrected HasPerFaceColor and HasPerWedgeTexture to comply gcc
Revision 1.6 2005/12/12 11:17:32 cignoni
Corrected update function, now only the needed simplexes should be updated.
Revision 1.5 2005/11/26 00:16:44 cignoni
Corrected a lot of bugs about the use of enabled entities
Revision 1.4 2005/11/21 21:46:20 cignoni
Changed HasColor -> HasFaceColor and HasNormal ->HasFaceNormal
Revision 1.3 2005/11/16 22:43:36 cignoni
Added WedgeTexture component
Revision 1.2 2005/10/22 13:16:46 cignoni
Added a missing ';' in FFAdjOcf (thanks to Mario Latronico).
Revision 1.1 2005/10/14 15:07:58 cignoni
First Really Working version
****************************************************************************/
/*
@ -486,13 +398,8 @@ public:
}
template <class LeftF>
void ImportLocal(const LeftF & leftF){
//if(leftF.Base().VFAdjacencyEnabled && this->Base().VFAdjacencyEnabled)// WRONG I do not know anything about leftV!
if(this->Base().VFAdjacencyEnabled){
VFp(0) = NULL; VFp(1) = NULL; VFp(2) = NULL;
VFi(0) = -1; VFi(1) = -1; VFi(2) = -1;
}
T::ImportLocal(leftF);
void ImportData(const LeftF & leftF){
T::ImportData(leftF);
}
static bool HasVFAdjacency() { return true; }
static bool HasVFAdjacencyOcf() { return true; }
@ -530,13 +437,8 @@ public:
typename T::FacePointer const FFp2( const int j ) const { return FFp((j+2)%3);}
template <class LeftF>
void ImportLocal(const LeftF & leftF){
// if(leftF.Base().FFAdjacencyEnabled && this->Base().FFAdjacencyEnabled) // WRONG I do not know anything about leftV!
if(this->Base().FFAdjacencyEnabled) {
FFp(0) = NULL; FFp(1) = NULL; FFp(2) = NULL;
FFi(0) = -1; FFi(1) = -1; FFi(2) = -1;
}
T::ImportLocal(leftF);
void ImportData(const LeftF & leftF){
T::ImportData(leftF);
}
static bool HasFFAdjacency() { return true; }
static bool HasFFAdjacencyOcf() { return true; }
@ -562,10 +464,10 @@ public:
return (*this).Base().NV[(*this).Index()]; }
template <class LeftF>
void ImportLocal(const LeftF & leftF){
void ImportData(const LeftF & leftF){
if((*this).Base().NormalEnabled && leftF.Base().NormalEnabled)
N() = leftF.cN();
T::ImportLocal(leftF);
T::ImportData(leftF);
}
};
@ -593,11 +495,11 @@ public:
}
template <class LeftF>
void ImportLocal(const LeftF & leftF){
void ImportData(const LeftF & leftF){
//if((*this).Base().QualityEnabled && leftF.Base().QualityEnabled)// WRONG I do not know anything about leftV!
if((*this).Base().QualityEnabled)
Q() = leftF.cQ();
T::ImportLocal(leftF);
T::ImportData(leftF);
}
static bool HasFaceQuality() { return true; }
static bool HasFaceQualityOcf() { return true; }
@ -624,11 +526,11 @@ public:
}
template <class LeftF>
void ImportLocal(const LeftF & leftF){
void ImportData(const LeftF & leftF){
//if((*this).Base().ColorEnabled && leftF.Base().ColorEnabled)// WRONG I do not know anything about leftV!
if((*this).Base().ColorEnabled )
C() = leftF.cC();
T::ImportLocal(leftF);
T::ImportData(leftF);
}
static bool HasFaceColor() { return true; }
static bool HasFaceColorOcf() { return true; }
@ -651,11 +553,11 @@ public:
} ;
template <class LeftF>
void ImportLocal(const LeftF & leftF){
void ImportData(const LeftF & leftF){
//if((*this).Base().MarkEnabled && leftF.Base().MarkEnabled)// WRONG I do not know anything about leftV!
if((*this).Base().MarkEnabled)
IMark() = leftF.IMark();
T::ImportLocal(leftF);
T::ImportData(leftF);
}
static bool HasFaceMark() { return true; }
static bool HasFaceMarkOcf() { return true; }
@ -671,11 +573,11 @@ public:
TexCoordType &WT(const int i) { assert((*this).Base().WedgeTexEnabled); return (*this).Base().WTV[(*this).Index()].wt[i]; }
TexCoordType const &cWT(const int i) const { assert((*this).Base().WedgeTexEnabled); return (*this).Base().WTV[(*this).Index()].wt[i]; }
template <class LeftF>
void ImportLocal(const LeftF & leftF){
void ImportData(const LeftF & leftF){
//if(this->Base().WedgeTexEnabled && leftF.Base().WedgeTexEnabled) // WRONG I do not know anything about leftV!
if(this->Base().WedgeTexEnabled)
{ WT(0) = leftF.cWT(0); WT(1) = leftF.cWT(1); WT(2) = leftF.cWT(2); }
TT::ImportLocal(leftF);
TT::ImportData(leftF);
}
static bool HasWedgeTexCoord() { return true; }
static bool HasWedgeTexCoordOcf() { return true; }
@ -692,11 +594,11 @@ public:
ColorType &WC(const int i) { assert((*this).Base().WedgeColorEnabled); return (*this).Base().WCV[(*this).Index()].wc[i]; }
const ColorType & cWC(const int i) const { assert((*this).Base().WedgeColorEnabled); return (*this).Base().WCV[(*this).Index()].wc[i]; }
template <class LeftF>
void ImportLocal(const LeftF & leftF){
void ImportData(const LeftF & leftF){
//if(this->Base().WedgeColorEnabled && leftF.Base().WedgeColorEnabled) // WRONG I do not know anything about leftV!
if(this->Base().WedgeColorEnabled)
{ WC(0) = leftF.cWC(0); WC(1) = leftF.cWC(1); WC(2) = leftF.cWC(2); }
TT::ImportLocal(leftF);
TT::ImportData(leftF);
}
static bool HasWedgeColor() { return true; }
static bool HasWedgeColorOcf() { return true; }
@ -713,11 +615,11 @@ public:
NormalType &WN(const int i) { assert((*this).Base().WedgeNormalEnabled); return (*this).Base().WNV[(*this).Index()].wn[i]; }
NormalType const &cWN(const int i) const { assert((*this).Base().WedgeNormalEnabled); return (*this).Base().WNV[(*this).Index()].wn[i]; }
template <class LeftF>
void ImportLocal(const LeftF & leftF){
void ImportData(const LeftF & leftF){
//if(this->Base().WedgeNormalEnabled && leftF.Base().WedgeNormalEnabled) // WRONG I do not know anything about leftV!
if(this->Base().WedgeNormalEnabled)
{ WN(0) = leftF.cWN(0); WN(1) = leftF.cWN(1); WN(2) = leftF.cWN(2); }
TT::ImportLocal(leftF);
TT::ImportData(leftF);
}
static bool HasWedgeNormal() { return true; }
static bool HasWedgeNormalOcf() { return true; }
@ -732,7 +634,7 @@ template <class T> class WedgeNormal3dOcf: public WedgeNormalOcf<vcg::Point3d, T
template < class T> class InfoOcf: public T {
public:
// You should never ever try to copy a vertex that has OCF stuff.
// use ImportLocal function.
// use ImportData function.
inline InfoOcf &operator=(const InfoOcf & /*other*/) {
assert(0); return *this;
}
@ -741,7 +643,7 @@ public:
vector_ocf<typename T::FaceType> &Base() const { return *_ovp;}
template <class LeftF>
void ImportLocal(const LeftF & leftF){T::ImportLocal(leftF);}
void ImportData(const LeftF & leftF){T::ImportData(leftF);}
static bool HasFaceColorOcf() { return false; }
static bool HasFaceNormalOcf() { return false; }

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

@ -54,8 +54,8 @@ public:
inline void Dealloc(){T::Dealloc();};// it should be useless
// EmptyPFHAdj
HEdgePointer &FHp(const int) { static typename T::HEdgePointer fp=0; assert(0); return fp; }
HEdgePointer const cFHp(const int) const { static typename T::HEdgePointer const fp=0; return fp; }
HEdgePointer &FHp( ) { static typename T::HEdgePointer fp=0; assert(0); return fp; }
HEdgePointer const cFHp( ) const { static typename T::HEdgePointer const fp=0; return fp; }
static bool HasFHAdjacency() { return false; }
};

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

@ -28,7 +28,7 @@ Revision 1.12 2008/03/17 11:39:14 ganovelli
added curvature and curvatruredir (compiled .net 2005 and gcc)
Revision 1.11 2008/02/04 21:26:49 ganovelli
added ImportLocal which imports all local attributes into vertexplus and faceplus.
added ImportData which imports all local attributes into vertexplus and faceplus.
A local attribute is everything (N(), C(), Q()....) except pointers to other simplices
(i.e. FFAdj, VFAdj, VertexRef) which are set to NULL.
Added some function for const attributes
@ -96,7 +96,7 @@ These typenames must be known form all the derived classes.
// typedef BFT *FacePointer;
// typedef BTT *TetraPointer;
// template < class LeftV>
// void ImportLocal(const LeftV & /* left */ ) { }
// void ImportData(const LeftV & /* left */ ) { }
// static void Name(std::vector<std::string> & /* name */){}
//
//};

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

@ -130,23 +130,23 @@ public:
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 cVTp() { static typename TT::TetraPointer tp = 0; assert(0); return tp; }
const typename TT::TetraPointer cVTp()const { static typename TT::TetraPointer tp = 0; assert(0); return tp; }
int &VTi() { static int z = 0; return z; };
static bool HasVTAdjacency() { return false; }
typename TT::FacePointer &VFp() { static typename TT::FacePointer fp=0; assert(0); return fp; }
typename TT::FacePointer cVFp() const { static typename TT::FacePointer fp=0; assert(0); return fp; }
const typename TT::FacePointer cVFp() const { static typename TT::FacePointer fp=0; assert(0); return fp; }
int &VFi(){static int z=0; return z;};
int cVFi() const {static int z=0; return z;};
static bool HasVFAdjacency() { return false; }
typename TT::EdgePointer &VEp() { static typename TT::EdgePointer ep=0; assert(0); return ep; }
typename TT::EdgePointer cVEp() { static typename TT::EdgePointer ep=0; assert(0); return ep; }
const typename TT::EdgePointer cVEp() const { static typename TT::EdgePointer ep=0; assert(0); return ep; }
int &VEi(){static int z=0; return z;};
static bool HasVEAdjacency() { return false; }
typename TT::HEdgePointer &VHp() { static typename TT::HEdgePointer ep=0; assert(0); return ep; }
typename TT::HEdgePointer cVHp() { static typename TT::HEdgePointer ep=0; assert(0); return ep; }
const typename TT::HEdgePointer cVHp() const { static typename TT::HEdgePointer ep=0; assert(0); return ep; }
int &VHi(){static int z=0; return z;};
static bool HasVHAdjacency() { return false; }
@ -176,8 +176,8 @@ public:
template < class LeftV>
void ImportLocal(const LeftV & left ) {
TT::ImportLocal( left);
void ImportData(const LeftV & left ) {
// TT::ImportData( left);
}
static void Name(std::vector<std::string> & name){TT::Name(name);}
};
@ -193,7 +193,7 @@ public:
const CoordType &cP() const { return _coord; }
template < class LeftV>
void ImportLocal(const LeftV & left ) { if(LeftV::HasCoord()) P().Import(left.cP()); T::ImportLocal( left); }
void ImportData(const LeftV & left ) { if(LeftV::HasCoord()) P().Import(left.cP()); T::ImportData( left); }
static bool HasCoord() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("Coord"));T::Name(name);}
@ -215,10 +215,10 @@ public:
NormalType &N() { return _norm; }
const NormalType &cN() const { return _norm; }
template < class LeftV>
void ImportLocal(const LeftV & left ){
void ImportData(const LeftV & left ){
if(LeftV::HasNormal())
N().Import(left.cN());
T::ImportLocal( left);
T::ImportData( left);
}
static bool HasNormal() { return true; }
// static bool HasNormalOcf() { return false; }
@ -250,7 +250,7 @@ public:
inline int & IMark() { return _imark;}
inline const int & IMark() const {return _imark;}
template < class LeftV>
void ImportLocal(const LeftV & left ) { if(LeftV::HasMark()) IMark() = left.IMark(); T::ImportLocal( left); }
void ImportData(const LeftV & left ) { if(LeftV::HasMark()) IMark() = left.IMark(); T::ImportData( left); }
static void Name(std::vector<std::string> & name){name.push_back(std::string("Mark"));T::Name(name);}
private:
@ -265,7 +265,7 @@ public:
TexCoordType &T() { return _t; }
const TexCoordType &cT() const { return _t; }
template < class LeftV>
void ImportLocal(const LeftV & left ) { if(LeftV::HasTexCoord()) T() = left.cT(); TT::ImportLocal( left); }
void ImportData(const LeftV & left ) { if(LeftV::HasTexCoord()) T() = left.cT(); TT::ImportData( left); }
static bool HasTexCoord() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("TexCoord"));TT::Name(name);}
@ -292,7 +292,7 @@ public:
int &Flags() {return _flags; }
int Flags() const {return _flags; }
template < class LeftV>
void ImportLocal(const LeftV & left ) { if(LeftV::HasFlags()) Flags() = left.Flags(); T::ImportLocal( left); }
void ImportData(const LeftV & left ) { if(LeftV::HasFlags()) Flags() = left.Flags(); T::ImportData( left); }
static bool HasFlags() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("BitFlags"));T::Name(name);}
@ -311,7 +311,7 @@ public:
const ColorType &C() const { return _color; }
const ColorType &cC() const { return _color; }
template < class LeftV>
void ImportLocal(const LeftV & left ) { if(LeftV::HasColor()) C() = left.cC(); T::ImportLocal( left); }
void ImportData(const LeftV & left ) { if(LeftV::HasColor()) C() = left.cC(); T::ImportData( left); }
static bool HasColor() { 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);}
@ -332,7 +332,7 @@ public:
QualityType &Q() { return _quality; }
const QualityType & cQ() const {return _quality; }
template < class LeftV>
void ImportLocal(const LeftV & left ) { if(LeftV::HasQuality()) Q() = left.cQ(); TT::ImportLocal( left); }
void ImportData(const LeftV & left ) { if(LeftV::HasQuality()) Q() = left.cQ(); TT::ImportData( left); }
static bool HasQuality() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("Quality"));TT::Name(name);}
@ -370,7 +370,7 @@ public:
static bool HasCurvatureDir() { return false; }
template < class LeftV>
void ImportLocal(const LeftV & left ) { TT::ImportLocal( left); }
void ImportData(const LeftV & left ) { TT::ImportData( left); }
static void Name(std::vector<std::string> & name){TT::Name(name);}
};
@ -413,7 +413,7 @@ public:
RadiusType &R() { return _radius; }
const RadiusType & cR() const {return _radius; }
template < class LeftV>
void ImportLocal(const LeftV & left ) { if(LeftV::HasRadius()) R() = left.cR(); TT::ImportLocal( left); }
void ImportData(const LeftV & left ) { if(LeftV::HasRadius()) R() = left.cR(); TT::ImportData( left); }
static bool HasRadius() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("Radius"));TT::Name(name);}
@ -432,10 +432,10 @@ template <class T> class VEAdj: public T {
public:
VEAdj(){_ep=0;}
typename T::EdgePointer &VEp() {return _ep; }
typename T::EdgePointer cVEp() {return _ep; }
typename T::EdgePointer const cVEp() const {return _ep; }
int &VEi() {return _zp; }
template < class LeftV>
void ImportLocal(const LeftV & left ) { VEp() = NULL; T::ImportLocal( left); }
void ImportData(const LeftV & left ) { T::ImportData( left); }
static bool HasVEAdjacency() { return true; }
static bool HasVEAdjacencyOcc() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("VEAdj"));T::Name(name);}
@ -451,10 +451,10 @@ template <class T> class VFAdj: public T {
public:
VFAdj(){_fp=0;}
typename T::FacePointer &VFp() {return _fp; }
typename T::FacePointer cVFp() {return _fp; }
typename T::FacePointer const cVFp() const {return _fp; }
int &VFi() {return _zp; }
template < class LeftV>
void ImportLocal(const LeftV & left ) { VFp() = NULL; T::ImportLocal( left); }
void ImportData(const LeftV & left ) { T::ImportData( left); }
static bool HasVFAdjacency() { return true; }
static bool HasVFAdjacencyOcc() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("VFAdj"));T::Name(name);}
@ -473,7 +473,7 @@ public:
typename T::HEdgePointer cVHp() {return _hp; }
int &VHi() {return _zp; }
template < class LeftV>
void ImportLocal(const LeftV & left ) { VHp() = NULL; T::ImportLocal( left); }
void ImportData(const LeftV & left ) { T::ImportData( left); }
static bool HasVHAdjacency() { return true; }
static bool HasVHAdjacencyOcc() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("VHAdj"));T::Name(name);}

4
vcg/simplex/vertex/component_occ.h
View File

@ -154,7 +154,7 @@ public:
const ScalarType &cK() const { return CAT< vector_occ<VertType>,CurvatureTypeOcc>::Instance()->Get((VertType*)this)[1];}
template <class LeftV>
void ImportLocal(const LeftV & leftV){
void ImportData(const LeftV & leftV){
CAT< vector_occ<VertType>,CurvatureTypeOcc>::Instance()->Get((VertType*)this)[0] = leftV.cH();
CAT< vector_occ<VertType>,CurvatureTypeOcc>::Instance()->Get((VertType*)this)[1] = leftV.cK();
TT::ImporLocal(leftV);
@ -230,7 +230,7 @@ public:
const RadiusType &cR() const { return CAT< vector_occ<VertType>,RadiusType>::Instance()->Get((VertType*)this);}
template <class LeftV>
void ImportLocal(const LeftV & leftV){
void ImportData(const LeftV & leftV){
CAT< vector_occ<VertType>,RadiusType>::Instance()->Get((VertType*)this) = leftV.cR();
TT::ImporLocal(leftV);
}

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

@ -37,7 +37,7 @@ Revision 1.13 2008/02/05 20:42:43 cignoni
Other small typos
Revision 1.12 2008/02/04 21:26:49 ganovelli
added ImportLocal which imports all local attributes into vertexplus and faceplus.
added ImportData which imports all local attributes into vertexplus and faceplus.
A local attribute is everything (N(), C(), Q()....) except pointers to other simplices
(i.e. FFAdj, VFAdj, VertexRef) which are set to NULL.
Added some function for const attributes
@ -391,14 +391,9 @@ public:
return (*this).Base().AV[(*this).Index()]._zp;
}
template <class LeftV>
void ImportLocal(const LeftV & leftV)
void ImportData(const LeftV & leftV)
{
if((*this).Base().VFAdjacencyEnabled) // init the data only if they are enabled!
{
VFp() = NULL;
VFi() = -1;
}
T::ImportLocal(leftV);
T::ImportData(leftV);
}
static bool HasVFAdjacency() { return true; }
@ -431,10 +426,10 @@ public:
return (*this).Base().NV[(*this).Index()]; }
template <class LeftV>
void ImportLocal(const LeftV & leftV){
void ImportData(const LeftV & leftV){
if((*this).Base().NormalEnabled && leftV.Base().NormalEnabled ) // copy the data only if they are enabled in both vertices
N().Import(leftV.cN());
T::ImportLocal(leftV);}
T::ImportData(leftV);}
};
template <class T> class Normal3sOcf: public NormalOcf<vcg::Point3s, T> {};
@ -449,11 +444,11 @@ public:
ColorType &C() { 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>
void ImportLocal(const LeftV & leftV)
void ImportData(const LeftV & leftV)
{
if((*this).Base().ColorEnabled && leftV.Base().ColorEnabled ) // copy the data only if they are enabled in both vertices
C() = leftV.cC();
T::ImportLocal(leftV);
T::ImportData(leftV);
}
static bool HasColor() { return true; }
@ -469,12 +464,12 @@ public:
typedef A QualityType;
QualityType &Q() { assert((*this).Base().QualityEnabled); return (*this).Base().QV[(*this).Index()]; }
template <class LeftV>
void ImportLocal(const LeftV & leftV)
void ImportData(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.HasQuality() ) // copy the data only if they are enabled in both vertices
Q() = leftV.cQ();
T::ImportLocal(leftV);
T::ImportData(leftV);
}
static bool HasQuality() { return true; }
static bool HasQualityOcf() { assert(!T::HasQualityOcf()); return true; }
@ -491,12 +486,12 @@ public:
TexCoordType &T() { assert((*this).Base().TexCoordEnabled); return (*this).Base().TV[(*this).Index()]; }
const TexCoordType &cT() const { assert((*this).Base().TexCoordEnabled); return (*this).Base().TV[(*this).Index()]; }
template < class LeftV>
void ImportLocal(const LeftV & leftV)
void ImportData(const LeftV & leftV)
{
//if((*this).Base().TexCoordEnabled && leftV.Base().TexCoordEnabled ) // WRONG I do not know anything about leftV!
if((*this).Base().TexCoordEnabled) // copy the data only if they are enabled in both vertices
T() = leftV.cT();
TT::ImportLocal(leftV);
TT::ImportData(leftV);
}
static bool HasTexCoord() { return true; }
static bool HasTexCoordOcf() { assert(!TT::HasTexCoordOcf()); return true; }
@ -520,12 +515,12 @@ public:
}
template <class LeftV>
void ImportLocal(const LeftV & leftV)
void ImportData(const LeftV & leftV)
{
//if((*this).Base().MarkEnabled && leftV.Base().MarkEnabled ) // WRONG I do not know anything about leftV!
if((*this).Base().MarkEnabled) // copy the data only if they are enabled in both vertices
IMark() = leftV.IMark();
T::ImportLocal(leftV);
T::ImportData(leftV);
}
static bool HasMark() { return true; }
static bool HasMarkOcf() { return true; }
@ -546,14 +541,14 @@ public:
const ScalarType &cKg() const { assert((*this).Base().CurvatureEnabled); return (*this).Base().CuV[(*this).Index()][1];}
template <class LeftV>
void ImportLocal(const LeftV & leftV){
void ImportData(const LeftV & leftV){
// if((*this).Base().CurvatureEnabled && leftV.Base().CurvatureEnabled ) // WRONG I do not know anything about leftV!
if((*this).Base().CurvatureEnabled && LeftV::IsCurvatureEnabled(&leftV))
{
(*this).Base().CuV[(*this).Index()][0] = leftV.cKh();
(*this).Base().CuV[(*this).Index()][1] = leftV.cKg();
}
TT::ImportLocal(leftV);
TT::ImportData(leftV);
}
static bool HasCurvature() { return true; }
@ -598,7 +593,7 @@ public:
const ScalarType &cK2()const {assert((*this).Base().CurvatureDirEnabled); return (*this).Base().CuDV[(*this).Index()].k2;}
template <class LeftV>
void ImportLocal(const LeftV & leftV){
void ImportData(const LeftV & leftV){
// if((*this).Base().CurvatureEnabled && leftV.Base().CurvatureEnabled ) // WRONG I do not know anything about leftV!
if((*this).Base().CurvatureDirEnabled && LeftV::IsCurvatureDirEnabled(&leftV))
{
@ -607,7 +602,7 @@ public:
(*this).K1() = leftV.cK1();
(*this).K2() = leftV.cK2();
}
TT::ImportLocal(leftV);
TT::ImportData(leftV);
}
static bool HasCurvatureDir() { return true; }
static bool HasCurvatureDirOcf() { return true; }
@ -636,12 +631,12 @@ public:
const RadiusType &cR() const { assert((*this).Base().RadiusEnabled); return (*this).Base().RadiusV[(*this).Index()];}
template <class LeftV>
void ImportLocal(const LeftV & leftV)
void ImportData(const LeftV & leftV)
{
//if ((*this).Base().RadiusEnabled && leftV.Base().RadiusEnabled ) // WRONG I do not know anything about leftV!
if ((*this).Base().RadiusEnabled)
(*this).Base().RadiusV[(*this).Index()] = leftV.cR();
TT::ImportLocal(leftV);
TT::ImportData(leftV);
}
static bool HasRadius() { return true; }
@ -660,7 +655,7 @@ template <class T> class RadiusdOcf: public RadiusOcf<double, T> {};
template < class T> class InfoOcf: public T {
public:
// You should never ever try to copy a vertex that has OCF stuff.
// use ImportLocal function.
// use ImportData function.
inline InfoOcf &operator=(const InfoOcf & /*other*/) {
assert(0); return *this;
}

4
vcg/simplex/vertex/component_sph.h
View File

@ -13,8 +13,8 @@ public:
SphType &SH() { return _harmonics; }
const SphType &cSH() const { return _harmonics; }
template < class LeftV>
// void ImportLocal(const LeftV & left ) { SH() = left.cSH(); T::ImportLocal( left); }
void ImportLocal(const LeftV & left ) { T::ImportLocal( left); }
// void ImportData(const LeftV & left ) { SH() = left.cSH(); T::ImportData( left); }
void ImportData(const LeftV & left ) { T::ImportData( left); }
static bool HasSH() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("Spherical Harmonics"));T::Name(name);}