From 75a7b0a8465b62b3320aa7cd776e4fabf078a303 Mon Sep 17 00:00:00 2001 From: ganovelli Date: Wed, 8 Oct 2008 10:19:07 +0000 Subject: [PATCH] [Polygon modification] Added components to the face to handle generic polygons. (compiled with .net and gcc) This commit includes the following files: vcg/complex/trimesh/base.h Added deallocation of polygon data in the destructor vcg/complex/trimesh/allocate.h generalization from 3 to VN() vertices vcg/complex/trimesh/update/topology.h generalization from 3 to VN() vertices vcg/complex/trimesh/update/flags.h generalization from 3 to VN() vertices vcg/simplex/face/pos.h generalization from 3 to VN() vertices vcg/simplex/faceplus/base.h Added the method VN() to query the number of vertices of the polygon (deafult 3) and methods Prev and Next vcg/simplex/faceplus/component.h added Alloc and Dealloc calls along the hierarchies --- vcg/simplex/faceplus/component_polygon.h | 256 +++++++++++++++++++++++ 1 file changed, 256 insertions(+) create mode 100644 vcg/simplex/faceplus/component_polygon.h diff --git a/vcg/simplex/faceplus/component_polygon.h b/vcg/simplex/faceplus/component_polygon.h new file mode 100644 index 00000000..e6b5a910 --- /dev/null +++ b/vcg/simplex/faceplus/component_polygon.h @@ -0,0 +1,256 @@ +/**************************************************************************** +* VCGLib o o * +* Visual and Computer Graphics Library o o * +* _ O _ * +* Copyright(C) 2004 \/)\/ * +* 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 + +//#include +//#include +//#include +//#include + +namespace vcg { + namespace face { +/* +Some naming Rules +All the Components that can be added to a vertex should be defined in the namespace vert: + +*/ + +/*-------------------------- PolInfo -------------------------------------------*/ +template class EmptyPolyInfo: public T { +protected: + inline void SetVN(const int & n) {assert(0);} +public: + /* 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 bu the edge allocator. + This destructor is only done for those who istance a face alone (outside a mesh) + */ + static bool HasPolyInfo() { return false; } + inline void Alloc(const int & ns){T::Alloc(ns);};// it should be useless + inline void Dealloc(){T::Dealloc();};// it should be useless +}; + + +template class PolyInfo: public T { +protected: + inline void SetVN(const int & n) {_ns = n;} +public: + PolyInfo(){ _ns = -1; } + /* 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 bu the face allocator. + This destructor is only done for those who istance a face alone (outside a mesh) + */ + static bool HasPolyInfo() { return true; } + inline const int & VN() const { return _ns;} + inline void Alloc(const int & ns){}; + inline void Dealloc(){}; +private: + int _ns; +}; + +/*-------------------------- VERTEX ----------------------------------------*/ +template class PEmptyFVAdj: 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 * const 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; } + template + void ImportLocal(const LeftF & leftF) {T::ImportLocal(leftF);} + static bool HasFVAdjN() { return false; } + static void Name(std::vector & name){T::Name(name);} + inline void Alloc(const int & ns){T::Alloc();}; + inline void Dealloc(){T::Dealloc();} + +}; +template class PFVAdj: public T { +public: + PFVAdj(){_vpoly = NULL;} + inline typename T::VertexType * & V( const int j ) { assert(j>=0 && jVN()); return _vpoly[j]; } + inline typename T::VertexType * const & V( const int j ) const { assert(j>=0 && jVN()); return _vpoly[j]; } + inline typename T::VertexType * const cV( const int j ) const { assert(j>=0 && jVN()); return _vpoly[j]; } + + + /** Return the pointer to the ((j+1)%3)-th vertex of the face. + @param j Index of the face vertex. + */ + inline typename T::VertexType * & V0( const int j ) { return V(j);} + inline typename T::VertexType * & V1( const int j ) { return V((j+1)%this->VN());} + inline typename T::VertexType * & V2( const int j ) { return V((j+2)%this->VN());} + inline const typename T::VertexType * const & V0( const int j ) const { return V(j);} + inline const typename T::VertexType * const & V1( const int j ) const { return V((j+1)%this->VN());} + inline const typename T::VertexType * const & V2( const int j ) const { return V((j+2)%this->VN());} + inline const typename T::VertexType * const & cV0( const int j ) const { return cV(j);} + inline const typename T::VertexType * const & cV1( const int j ) const { return cV((j+1)%this->VN());} + inline const typename T::VertexType * const & cV2( const int j ) const { return cV((j+2)%this->VN());} + + // Shortcut per accedere ai punti delle facce + inline typename T::CoordType & P( const int j ) { assert(j>=0 && jVN()); return _vpoly[j]->P(); } + inline const typename T::CoordType & P( const int j ) const { assert(j>=0 && jVN()); return _vpoly[j]->cP(); } + inline const typename T::CoordType &cP( const int j ) const { assert(j>=0 && jVN()); return _vpoly[j]->cP(); } + + /// Shortcut per accedere ai punti delle facce + inline typename T::CoordType & P0( const int j ) { return V(j)->P();} + inline typename T::CoordType & P1( const int j ) { return V((j+1)%this->VN())->P();} + inline typename T::CoordType & P2( const int j ) { return V((j+2)%this->VN())->P();} + inline const typename T::CoordType & P0( const int j ) const { return V(j)->P();} + inline const typename T::CoordType & P1( const int j ) const { return V((j+1)%this->VN())->P();} + inline const typename T::CoordType & P2( const int j ) const { return V((j+2)%this->VN())->P();} + inline const typename T::CoordType & cP0( const int j ) const { return cV(j)->P();} + inline const typename T::CoordType & cP1( const int j ) const { return cV((j+1)%this->VN())->P();} + inline const typename T::CoordType & cP2( const int j ) const { return cV((j+2)%this->VN())->P();} + + template + void ImportLocal(const LeftF & leftF){ for(int i =0; i < this->VN(); ++i) V(i) = NULL; T::ImportLocal(leftF);} + inline void Alloc(const int & ns) { + if(_vpoly == NULL){this->SetVN(ns); + _vpoly = new typename T::VertexType*[this->VN()]; + for(int i = 0; i < this->VN(); ++i) _vpoly[i] = 0; + T::Alloc(ns);} + } + inline void Dealloc() { if(_vpoly!=NULL){ + delete [] _vpoly; + _vpoly = NULL; + } + T::Dealloc(); + } + + static bool HasFVAdj() { return true; } + static void Name(std::vector & name){name.push_back(std::string("PFVAdj"));T::Name(name);} + + private: + typename T::VertPointer *_vpoly; +}; + +/*----------------------------- PVFADJ ------------------------------*/ +template class EmptyPVFAdj: public T { +public: + typedef typename T::VertexType VertexType; + typedef int VFAdjType; + typename T::FacePointer &VFp(const int) { static typename T::FacePointer fp=0; assert(0); return fp; } + typename T::FacePointer const cVFp(const int) const { static typename T::FacePointer const fp=0; return fp; } + typename T::FacePointer &FFp(const int) { static typename T::FacePointer fp=0; assert(0); return fp; } + typename T::FacePointer const cFFp(const int) const { static typename T::FacePointer const fp=0; return fp; } + char &VFi(const int j){static char z=0; assert(0); return z;}; + char &FFi(const int j){static char z=0; assert(0); return z;}; + const char &cVFi(const int j){static char z=0; return z;}; + const char &cFFi(const int j){static char z=0; return z;}; + template + void ImportLocal(const LeftF & leftF){ T::ImportLocal(leftF);} + void Alloc(const int & ns){T::Alloc(ns);} + void Dealloc(){T::Dealloc();} + static bool HasVFAdjacency() { return false; } + static bool HasFFAdjacency() { return false; } + static bool HasFFAdjacencyOcc() { return false; } + static bool HasVFAdjacencyOcc() { return false; } + static void Name(std::vector & name){T::Name(name);} + +}; + +template 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 bu the edge allocator. + This destructor is only done for those who istance a face alone (outside a mesh) + */ + typedef typename T::VertexType VertexType; + typedef typename T::FaceType FaceType; + typename T::FacePointer &VFp(const int j) { assert(j>=0 && jVN()); return _vfpP[j]; } + typename T::FacePointer const VFp(const int j) const { assert(j>=0 && jVN()); return _vfpP[j]; } + typename T::FacePointer const cVFp(const int j) const { assert(j>=0 && jVN()); return _vfpP[j]; } + char &VFi(const int j) {return _vfiP[j]; } + template + void ImportLocal(const LeftF & leftF){T::ImportLocal(leftF);} + inline void Alloc(const int & ns) { + if(_vfpP == NULL){ + this->SetVN(ns); + _vfpP = new FaceType*[this->VN()]; + _vfiP = new char[this->VN()]; + for(int i = 0; i < this->VN(); ++i) {_vfpP[i] = 0;_vfiP = -1;} + T::Alloc(ns); + } + } + inline void Dealloc() { if(_vfpP!=NULL){ + delete [] _vfpP; + delete [] _vfpP; + } + T::Dealloc(); + } + + static bool HasVFAdjacency() { return true; } + static bool HasVFAdjacencyOcc() { return false; } + static void Name(std::vector & name){name.push_back(std::string("PVFAdj"));T::Name(name);} + +private: + typename T::FacePointer *_vfpP ; + char *_vfiP ; +}; +/*----------------------------- FFADJ ------------------------------*/ + + +template class PFFAdj: public T { +public: + typedef typename T::FaceType FaceType; + PFFAdj(){_ffpP = NULL; _ffiP = NULL; } + typename T::FacePointer &FFp(const int j) { assert(j>=0 && jVN()); return _ffpP[j]; } + typename T::FacePointer const FFp(const int j) const { assert(j>=0 && jVN()); return _ffpP[j]; } + typename T::FacePointer const cFFp(const int j) const { assert(j>=0 && jVN()); return _ffpP[j]; } + char &FFi(const int j) { return _ffiP[j]; } + const char &cFFi(const int j) const { return _ffiP[j]; } + + template + void ImportLocal(const LeftF & leftF){T::ImportLocal(leftF);} + inline void Alloc(const int & ns) { + if( _ffpP == NULL){ + this->SetNV(ns); + _ffpP = new FaceType*[this->VN()]; + _ffiP = new char[this->VN()]; + for(int i = 0; i < this->VN(); ++i) {_ffpP[i] = 0;_ffiP[i] = 0;} + T::Alloc(ns); } + } + inline void Dealloc() { if(_ffpP!=NULL){ + delete [] _ffpP; + delete [] _ffiP; + } + T::Dealloc(); + } + + static bool HasFFAdjacency() { return true; } + static bool HasFFAdjacencyOcc() { return false; } + static void Name(std::vector & name){name.push_back(std::string("PFFAdj"));T::Name(name);} + +//private: + typename T::FacePointer *_ffpP ; + char *_ffiP ; +}; + + } // end namespace vert +}// end namespace vcg +#endif