manolas
/
vcglib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
vcglib/vcg/simplex/face/component_polygon.h

272 lines
11 KiB
C++
Raw Blame History

/****************************************************************************
* VCGLib o o *
* Visual and Computer Graphics Library o o *
* _ O _ *
* Copyright(C) 2004-2016 \/)\/ *
* Visual Computing Lab /\/| *
* ISTI - Italian National Research Council | *
* \ *
* All rights reserved. *
* *
* 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 *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License (http://www.gnu.org/licenses/gpl.txt) *
* for more details. *
* *
****************************************************************************/
#ifndef __VCG_POLYGON_COMPONENT
#define __VCG_POLYGON_COMPONENT
namespace vcg {
namespace face {
/*-------------------------- PolInfo -------------------------------------------*/
template <class T> class PolyInfo: public T {
protected:
inline void __SetVN(const int & n) {
assert((_ns==-1) || (_ns==n) || (n==-1));
_ns = n;
}
public:
PolyInfo(){ _ns = -1; }
static bool HasPolyInfo() { return true; }
inline const int & VN() const { return _ns;}
inline int Prev(const int & i){ return (i+(VN()-1))%VN();}
inline int Next(const int & i){ return (i+1)%VN();}
inline void Alloc(const int & ns){
T::Alloc(ns);
__SetVN(ns);
}
inline void Dealloc(){
T::Dealloc();
__SetVN(-1);
}
private:
int _ns;
};
template <class T> class PFVAdj: public T {
public:
typedef typename T::VertexType::CoordType CoordType;
typedef typename T::VertexType::ScalarType ScalarType;
typedef typename T::VertexType VertexType;
PFVAdj(){ _vpoly = NULL; }
/* Note: the destructor will not be called in general because there are no virtual destructors.
* Instead, the job of deallocating the memory will be done by the face allocator.
* This destructor is only done for those who istance a face alone (outside a mesh)
*/
// ~PFVAdj(){ __Dealloc(); }
inline typename T::VertexType * & V( const int j ) { assert(j>=0 && j<this->VN()); return _vpoly[j]; }
inline typename T::VertexType * const & V( const int j ) const { assert(j>=0 && j<this->VN()); return _vpoly[j]; }
inline typename T::VertexType * cV( const int j ) const { assert(j>=0 && j<this->VN()); return _vpoly[j]; }
/** Return the pointer to the ((j+1)%3)-th vertex of the face.
@param j Index of the face vertex.
*/
inline VertexType * & V0( const int j ) { return V(j);}
inline VertexType * & V1( const int j ) { return V((j+1)%this->VN());}
inline VertexType * & V2( const int j ) { return V((j+2)%this->VN());}
inline const VertexType * const & V0( const int j ) const { return V(j);}
inline const VertexType * const & V1( const int j ) const { return V((j+1)%this->VN());}
inline const VertexType * const & V2( const int j ) const { return V((j+2)%this->VN());}
inline const VertexType * const & cV0( const int j ) const { return cV(j);}
inline const VertexType * const & cV1( const int j ) const { return cV((j+1)%this->VN());}
inline const VertexType * const & cV2( const int j ) const { return cV((j+2)%this->VN());}
inline CoordType &P( const int j ) { assert(j>=0 && j<this->VN()); return _vpoly[j]->P(); }
inline CoordType cP( const int j ) const { assert(j>=0 && j<this->VN()); return _vpoly[j]->cP(); }
inline CoordType & P0( const int j ) { return V(j)->P();}
inline CoordType & P1( const int j ) { return V((j+1)%this->VN())->P();}
inline CoordType & P2( const int j ) { return V((j+2)%this->VN())->P();}
inline CoordType cP0( const int j ) const { return cV(j)->P();}
inline CoordType cP1( const int j ) const { return cV((j+1)%this->VN())->P();}
inline CoordType cP2( const int j ) const { return cV((j+2)%this->VN())->P();}
template <class LeftF>
void ImportData(const LeftF & leftF){ T::ImportData(leftF);}
inline void Alloc(const int & ns) {
__Dealloc();
_vpoly = new typename T::VertexType*[ns];
for(int i = 0; i < ns; ++i) _vpoly[i] = 0;
T::Alloc(ns);
}
inline void Dealloc() {
__Dealloc();
T::Dealloc();
}
static bool HasFVAdjacency() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("PFVAdj"));T::Name(name);}
private:
inline void __Dealloc(){
delete [] _vpoly;
_vpoly = NULL;
}
typename T::VertexPointer *_vpoly;
};
template <class T> class PVFAdj: public T {
public:
PVFAdj(){ _vfiP = NULL; _vfiP = NULL; }
/* Note: the destructor will not be called in general because there are no virtual destructors.
* Instead, the job of deallocating the memory will be done by the face allocator.
* This destructor is only done for those who istance a face alone (outside a mesh)
*/
// ~PVFAdj(){ __Dealloc(); }
typedef typename T::VertexType VertexType;
typedef typename T::FaceType FaceType;
typename T::FacePointer &VFp(const int j) { assert(j>=0 && j<this->VN()); return _vfpP[j]; }
typename T::FacePointer const VFp(const int j) const { assert(j>=0 && j<this->VN()); return _vfpP[j]; }
typename T::FacePointer const cVFp(const int j) const { assert(j>=0 && j<this->VN()); return _vfpP[j]; }
char &VFi(const int j) {return _vfiP[j]; }
template <class LeftF>
void ImportData(const LeftF & leftF){T::ImportData(leftF);}
inline void Alloc(const int & ns) {
_vfpP = new FaceType*[ns];
_vfiP = new char[ns];
for(int i = 0; i < ns; ++i) {_vfpP[i] = 0;_vfiP[i] = -1;}
T::Alloc(ns);
}
unsigned int SizeNeigh(){ return this->VN();}
inline void Dealloc() {
__Dealloc();
T::Dealloc();
}
static bool HasVFAdjacency() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("PVFAdj"));T::Name(name);}
private:
inline void __Dealloc(){
delete [] _vfpP; _vfpP = NULL;
delete [] _vfiP; _vfiP = NULL;
}
typename T::FacePointer *_vfpP ;
char *_vfiP ;
};
/*----------------------------- FFADJ ------------------------------*/
template <class T> class PFFAdj: public T {
public:
typedef typename T::FaceType FaceType;
PFFAdj(){ _ffpP = NULL; _ffiP = NULL; }
/* Note: the destructor will not be called in general because there are no virtual destructors.
* Instead, the job of deallocating the memory will be done by the face allocator.
* This destructor is only done for those who istance a face alone (outside a mesh)
*/
// ~PFFAdj(){ __Dealloc(); }
typename T::FacePointer &FFp(const int j) { assert(j>=0 && j<this->VN()); return _ffpP[j]; }
typename T::FacePointer FFp(const int j) const { assert(j>=0 && j<this->VN()); return _ffpP[j]; }
typename T::FacePointer cFFp(const int j) const { assert(j>=0 && j<this->VN()); return _ffpP[j]; }
char &FFi(const int j) { return _ffiP[j]; }
char cFFi(const int j) const { return _ffiP[j]; }
template <class LeftF>
void ImportData(const LeftF & leftF){T::ImportData(leftF);}
inline void Alloc(const int & ns) {
_ffpP = new FaceType*[ns];
_ffiP = new char[ns];
for(int i = 0; i < ns; ++i) {_ffpP[i] = 0;_ffiP[i] = 0;}
T::Alloc(ns);
}
inline void Dealloc() {
__Dealloc();
T::Dealloc();
}
static bool HasFFAdjacency() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("PFFAdj"));T::Name(name);}
private:
inline void __Dealloc(){
delete [] _ffpP; _ffpP = NULL;
delete [] _ffiP; _ffiP = NULL;
}
typename T::FacePointer *_ffpP ;
char *_ffiP ;
};
/*----------------------------- PFEADJ ------------------------------*/
template <class T> class PFEAdj: public T {
public:
typedef typename T::EdgeType EdgeType;
PFEAdj(){ _fepP = NULL; }
/* Note: the destructor will not be called in general because there are no virtual destructors.
* Instead, the job of deallocating the memory will be done by the face allocator.
* This destructor is only done for those who istance a face alone (outside a mesh)
*/
// ~PFEAdj(){ __Dealloc(); }
typename T::EdgePointer &FEp(const int j) { assert(j>=0 && j<this->VN()); return _fepP[j]; }
typename T::EdgePointer const FEp(const int j) const { assert(j>=0 && j<this->VN()); return _fepP[j]; }
typename T::EdgePointer const cFEp(const int j) const { assert(j>=0 && j<this->VN()); return _fepP[j]; }
template <class LeftF>
void ImportData(const LeftF & leftF){T::ImportData(leftF);}
inline void Alloc(const int & ns) {
_fepP = new EdgeType *[ns];
for(int i = 0; i < ns; ++i) {_fepP[i] = 0;}
T::Alloc(ns);
}
inline void Dealloc() {
T::Dealloc();
}
static bool HasFEAdjacency() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("PFEAdj"));T::Name(name);}
private:
inline void __Dealloc(){
delete [] _fepP; _fepP = NULL;
}
typename T::EdgePointer *_fepP ;
};
/*----------------------------- PFHADJ ------------------------------*/
template <class T> class PFHAdj: public T {
public:
typedef typename T::HEdgeType HEdgeType;
typedef typename T::HEdgePointer HEdgePointer;
PFHAdj(){ _fhP = NULL; }
typename T::HEdgePointer &FHp() { return _fhP; }
typename T::HEdgePointer const cFHp() const { return _fhP; }
template <class LeftF>
void ImportData(const LeftF & leftF){T::ImportData(leftF);}
inline void Alloc(const int & ns) {T::Alloc(ns);}
inline void Dealloc() { T::Dealloc();}
static bool HasFHAdjacency() { return true; }
static void Name(std::vector<std::string> & name){name.push_back(std::string("PFHAdj"));T::Name(name);}
private:
typename T::HEdgePointer _fhP ;
};
} // end namespace face
} // end namespace vcg
#endif
Reference in New Issue View Git Blame Copy Permalink