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

moved PointerToAttribute outside mesh definition to avoid type mismatches in append with two different mesh types.

This commit is contained in:
Marco Di Benedetto 2011-06-14 14:52:38 +00:00
parent 6ade8d7dfb
commit ddb4e72887
4 changed files with 78 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
vcg/complex/allocate.h
View File

@ -33,7 +33,23 @@
#include <vcg/container/simple_temporary_data.h>
namespace vcg {
namespace tri {
class PointerToAttribute
{
public:
SimpleTempDataBase * _handle; // pointer to the SimpleTempData that stores the attribute
std::string _name; // name of the attribute
int _sizeof; // size of the attribute type (used only with VMI loading)
int _padding; // padding (used only with VMI loading)
int n_attr; // unique ID of the attribute
void Resize(const int & sz){((SimpleTempDataBase *)_handle)->Resize(sz);}
void Reorder(std::vector<size_t> & newVertIndex){((SimpleTempDataBase *)_handle)->Reorder(newVertIndex);}
bool operator<(const PointerToAttribute b) const { return(_name.empty()&&b._name.empty())?(_handle < b._handle):( _name < b._name);}
};
namespace tri {
/** \addtogroup trimesh */
template<class MeshType>

2
vcg/complex/append.h
View File

@ -302,7 +302,7 @@ static void Mesh(MeshLeft& ml, MeshRight& mr, const bool selected = false){
// of the right mesh will be uninitialized
unsigned int id_r;
typename std::set< typename MeshRight::PointerToAttribute >::iterator al,ar;
typename std::set< PointerToAttribute >::iterator al, ar;
// per vertex attributes
for(al = ml.vert_attr.begin(); al != ml.vert_attr.end(); ++al)

14
vcg/complex/complex.h
View File

@ -191,6 +191,8 @@ class TriMesh
typedef typename TriMesh::HEdgeContainer HEdgeContainer;
typedef typename TriMesh::ConstHEdgeIterator ConstHEdgeIterator;
typedef vcg::PointerToAttribute PointerToAttribute;
typedef TriMesh<Container0, Container1,Container2,Container3> MeshType;
typedef Box3<ScalarType> BoxType;
@ -222,18 +224,6 @@ class TriMesh
int attrn; // total numer of attribute created
class PointerToAttribute{
public:
SimpleTempDataBase * _handle; // pointer to the SimpleTempData that stores the attribute
std::string _name; // name of the attribute
int _sizeof; // size of the attribute type (used only with VMI loading)
int _padding; // padding (used only with VMI loading)
int n_attr; // unique ID of the attribute
void Resize(const int & sz){((SimpleTempDataBase *)_handle)->Resize(sz);}
void Reorder(std::vector<size_t> & newVertIndex){((SimpleTempDataBase *)_handle)->Reorder(newVertIndex);}
bool operator<(const PointerToAttribute b) const { return(_name.empty()&&b._name.empty())?(_handle < b._handle):( _name < b._name);}
};
std::set< PointerToAttribute > vert_attr;
std::set< PointerToAttribute > edge_attr;

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

@ -40,20 +40,21 @@ All the Components that can be added to a vertex should be defined in the namesp
/*-------------------------- VERTEX ----------------------------------------*/
template <class T> class EmptyVertexRef: public T {
public:
// typedef typename T::VertexType VertexType;
// typedef typename T::CoordType CoordType;
inline typename T::VertexType * & V( const int j ) { assert(0); static typename T::VertexType *vp=0; return vp; }
inline typename T::VertexType * const & V( const int j ) const { assert(0); static typename T::VertexType *vp=0; return vp; }
inline typename T::VertexType * cV( const int j ) const { assert(0); static typename T::VertexType *vp=0; return vp; }
inline typename T::CoordType & P( const int j ) { assert(0); static typename T::CoordType coord(0, 0, 0); return coord; }
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; }
// typedef typename T::VertexType VertexType;
// typedef typename T::CoordType CoordType;
inline typename T::VertexType * & V( const int j ) { (void)j; assert(0); static typename T::VertexType *vp=0; return vp; }
inline typename T::VertexType * const & V( const int j ) const { (void)j; assert(0); static typename T::VertexType *vp=0; return vp; }
inline typename T::VertexType * cV( const int j ) const { (void)j; assert(0); static typename T::VertexType *vp=0; return vp; }
inline typename T::CoordType & P( const int j ) { (void)j; assert(0); static typename T::CoordType coord(0, 0, 0); return coord; }
inline const typename T::CoordType & P( const int j ) const { (void)j; assert(0); static typename T::CoordType coord(0, 0, 0); return coord; }
inline const typename T::CoordType & cP( const int j ) const { (void)j; assert(0); static typename T::CoordType coord(0, 0, 0); return coord; }
template <class LeftF>
void ImportData(const LeftF & leftF) {T::ImportData(leftF);}
static bool HasEVAdjacency() { return false; }
static bool HasVertexRef() { return false; }
static void Name(std::vector<std::string> & name){T::Name(name);}
static bool HasEVAdjacency() { return false; }
static bool HasVertexRef() { return false; }
static void Name(std::vector<std::string> & name){T::Name(name);}
};
template <class T> class VertexRef: public T {
public:
@ -64,7 +65,7 @@ public:
inline typename T::VertexType * & V( const int j ) { assert(j>=0 && j<2); return v[j]; }
inline typename T::VertexType * const & V( const int j ) const { assert(j>=0 && j<2); return v[j]; }
inline typename T::VertexType * cV( const int j ) const { assert(j>=0 && j<2); return v[j]; }
inline typename T::VertexType * cV( const int j ) const { assert(j>=0 && j<2); return v[j]; }
// Shortcut per accedere ai punti delle facce
inline typename T::CoordType & P( const int j ) { assert(j>=0 && j<2); return v[j]->P(); }
@ -231,34 +232,34 @@ public: static void Name(std::vector<std::string> & name){name.push_back(std::st
/*----------------------------- VEADJ ------------------------------*/
template <class T> class EmptyVEAdj: public T {
public:
typename T::EdgePointer &VEp(const int & ) { static typename T::EdgePointer ep=0; assert(0); return ep; }
const typename T::EdgePointer cVEp(const int & ) const { static typename T::EdgePointer ep=0; assert(0); return ep; }
int &VEi(const int &){static int z=0; assert(0); return z;}
int cVEi(const int &) const {static int z=0; assert(0); return z;}
template < class LeftV>
void ImportData(const LeftV & left ) { T::ImportData( left); }
static bool HasVEAdjacency() { return false; }
static bool HasVEAdjacencyOcc() { return false; }
static void Name(std::vector<std::string> & name){ T::Name(name);}
typename T::EdgePointer &VEp(const int & ) { static typename T::EdgePointer ep=0; assert(0); return ep; }
const typename T::EdgePointer cVEp(const int & ) const { static typename T::EdgePointer ep=0; assert(0); return ep; }
int &VEi(const int &){static int z=0; assert(0); return z;}
int cVEi(const int &) const {static int z=0; assert(0); return z;}
template < class LeftV>
void ImportData(const LeftV & left ) { T::ImportData( left); }
static bool HasVEAdjacency() { return false; }
static bool HasVEAdjacencyOcc() { return false; }
static void Name(std::vector<std::string> & name){ T::Name(name);}
};
template <class T> class VEAdj: public T {
public:
VEAdj(){_ep[0]=0;_ep[1]=0;_zp[0]=-1;_zp[1]=-1;}
typename T::EdgePointer &VEp(const int & i) {return _ep[i]; }
typename T::EdgePointer cVEp(const int & i) const {return _ep[i]; }
int &EEi(const int & i){ return _zp[i];}
int cEEi(const int &i )const {return _zp[i];}
VEAdj(){_ep[0]=0;_ep[1]=0;_zp[0]=-1;_zp[1]=-1;}
typename T::EdgePointer &VEp(const int & i) {return _ep[i]; }
typename T::EdgePointer cVEp(const int & i) const {return _ep[i]; }
int &EEi(const int & i){ return _zp[i];}
int cEEi(const int &i )const {return _zp[i];}
template < class LeftV>
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);}
template < class LeftV>
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);}
private:
typename T::EdgePointer _ep[2] ;
int _zp[2] ;
typename T::EdgePointer _ep[2] ;
int _zp[2] ;
};