crease_cut.h
Go to the documentation of this file.00001 /**************************************************************************** 00002 * VCGLib o o * 00003 * Visual and Computer Graphics Library o o * 00004 * _ O _ * 00005 * Copyright(C) 2008 \/)\/ * 00006 * Visual Computing Lab /\/| * 00007 * ISTI - Italian National Research Council | * 00008 * \ * 00009 * All rights reserved. * 00010 * * 00011 * This program is free software; you can redistribute it and/or modify * 00012 * it under the terms of the GNU General Public License as published by * 00013 * the Free Software Foundation; either version 2 of the License, or * 00014 * (at your option) any later version. * 00015 * * 00016 * This program is distributed in the hope that it will be useful, * 00017 * but WITHOUT ANY WARRANTY; without even the implied warranty of * 00018 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * 00019 * GNU General Public License (http://www.gnu.org/licenses/gpl.txt) * 00020 * for more details. * 00021 * * 00022 ****************************************************************************/ 00023 00024 #ifndef __VCG_CREASE_CUT 00025 #define __VCG_CREASE_CUT 00026 #include<vcg/simplex/face/jumping_pos.h> 00027 #include<vcg/complex/trimesh/append.h> 00028 #include<vcg/complex/trimesh/update/normal.h> 00029 namespace vcg { 00030 namespace tri { 00031 00032 /* 00033 Crease Angle 00034 Assume che: 00035 la mesh abbia la topologia ff 00036 la mesh non abbia complex (o se li aveva fossero stati detached) 00037 Abbia le normali per faccia normalizzate!! 00038 00039 00040 Prende una mesh e duplica tutti gli edge le cui normali nelle facce incidenti formano un angolo maggiore 00041 di <angle> (espresso in rad). 00042 foreach face 00043 foreach unvisited vert vi 00044 scan the star of triangles around vi duplicating vi each time we encounter a crease angle. 00045 00046 the new (and old) vertexes are put in a std::vector that is swapped with the original one at the end. 00047 00048 Si tiene un vettore di interi 3 *fn che dice l'indice del vertice puntato da ogni faccia. 00049 quando si scandisce la stella intorno ad un vertici, per ogni wedge si scrive l'indice del vertice corrsipondente. 00050 00051 00052 */ 00053 00054 template<class MESH_TYPE> 00055 void CreaseCut(MESH_TYPE &m, float angleRad) 00056 { 00057 typedef typename MESH_TYPE::CoordType CoordType; 00058 typedef typename MESH_TYPE::ScalarType ScalarType; 00059 typedef typename MESH_TYPE::VertexType VertexType; 00060 typedef typename MESH_TYPE::VertexPointer VertexPointer; 00061 typedef typename MESH_TYPE::VertexIterator VertexIterator; 00062 typedef typename MESH_TYPE::FaceIterator FaceIterator; 00063 typedef typename MESH_TYPE::FaceType FaceType; 00064 typedef typename MESH_TYPE::FacePointer FacePointer; 00065 00066 tri::Allocator<MESH_TYPE>::CompactVertexVector(m); 00067 tri::Allocator<MESH_TYPE>::CompactFaceVector(m); 00068 00069 tri::UpdateNormals<MESH_TYPE>::NormalizeFace(m); 00070 00071 assert(m.HasFFTopology()); 00072 typename MESH_TYPE::ScalarType cosangle=math::Cos(angleRad); 00073 00074 tri::UpdateFlags<MESH_TYPE>::VertexClearV(m); 00075 std::vector<int> indVec(m.fn*3,-1); 00076 int newVertexCounter=m.vn; 00077 int creaseCounter=0; 00078 int startVn=m.vn; 00079 FaceIterator fi; 00080 //const FaceType * nextf; 00081 for(fi=m.face.begin();fi!=m.face.end();++fi) 00082 for(int j=0;j<3;++j) 00083 if(!(*fi).V(j)->IsV() ) // foreach unvisited vertex we loop around it searching for creases. 00084 { 00085 (*fi).V(j)->SetV(); 00086 00087 face::JumpingPos<FaceType> iPos(&*fi,j,(*fi).V(j)); 00088 size_t vertInd = Index(m,iPos.v); // 00089 bool isBorderVertex = iPos.FindBorder(); // for border vertex we start from the border. 00090 face::JumpingPos<FaceType> startPos=iPos; 00091 if(!isBorderVertex) // for internal vertex we search the first crease and start from it 00092 { 00093 do { 00094 ScalarType dotProd = iPos.FFlip()->cN().dot(iPos.f->N()); 00095 iPos.NextFE(); 00096 if(dotProd<cosangle) break; 00097 } while (startPos!=iPos); 00098 startPos=iPos; // the found crease become the new starting pos. 00099 } 00100 00101 int locCreaseCounter=0; 00102 int curVertexCounter =vertInd; 00103 00104 do { // The real Loop 00105 ScalarType dotProd=iPos.FFlip()->cN().dot(iPos.f->N()); // test normal with the next face (fflip) 00106 size_t faceInd = Index(m,iPos.f); 00107 indVec[faceInd*3+ iPos.VInd()] = curVertexCounter; 00108 00109 if(dotProd<cosangle) 00110 { //qDebug(" Crease FOUND"); 00111 ++locCreaseCounter; 00112 curVertexCounter=newVertexCounter; 00113 newVertexCounter++; 00114 } 00115 iPos.NextFE(); 00116 } while (startPos!=iPos); 00117 if(locCreaseCounter>0 && (!isBorderVertex) ) newVertexCounter--; 00118 } 00119 00120 // A questo punto ho un vettore che mi direbbe per ogni faccia quale vertice devo mettere. Dopo che ho aggiunto i vertici necessari, 00121 // rifaccio il giro delle facce 00122 qDebug("adding %i vert for %i crease edges ",newVertexCounter-m.vn, creaseCounter); 00123 tri::Allocator<MESH_TYPE>::AddVertices(m,newVertexCounter-m.vn); 00124 00125 tri::UpdateFlags<MESH_TYPE>::VertexClearV(m); 00126 for(fi=m.face.begin();fi!=m.face.end();++fi) 00127 for(int j=0;j<3;++j) // foreach unvisited vertex 00128 { 00129 size_t faceInd = Index(m, *fi); 00130 size_t vertInd = Index(m, (*fi).V(j)); 00131 int curVertexInd = indVec[faceInd*3+ j]; 00132 assert(curVertexInd != -1); 00133 assert(curVertexInd < m.vn); 00134 if(curVertexInd < startVn) assert(size_t(curVertexInd) == vertInd); 00135 if(curVertexInd >= startVn) 00136 { 00137 m.vert[curVertexInd].ImportData(*((*fi).V(j))); 00138 (*fi).V(j) = & m.vert[curVertexInd]; 00139 } 00140 } 00141 tri::UpdateNormals<MESH_TYPE>::PerVertexFromCurrentFaceNormal(m); 00142 } 00143 00144 } // end namespace tri 00145 } // end namespace vcg 00146 #endif 00147 00148 /* 00149 face::Pos<FaceType> startPos=iPos; 00150 const FaceType * nextf; 00151 00152 do{ 00153 size_t faceInd = Index(m,iPos.f); 00154 assert(iPos.f->V(iPos.VInd()) ==iPos.v); 00155 qDebug("Face %2i:%i - v%2i -- %2i",faceInd,iPos.VInd(),Index(m,iPos.v),curVertexCounter); 00156 indVec[faceInd*3+ iPos.VInd()] = curVertexCounter; 00157 00158 nextf=iPos.FFlip(); 00159 ScalarType dotProd=nextf->cN() * iPos.f->N(); 00160 iPos.FlipF(); 00161 iPos.FlipE(); 00162 if(dotProd<cosangle) 00163 { 00164 ++creaseCounter; 00165 if(iPos!=startPos) 00166 { 00167 qDebug("Crease"); 00168 curVertexCounter=newVertexCounter; 00169 newVertexCounter++; 00170 } 00171 } 00172 } 00173 while((iPos!=startPos) && (!iPos.IsBorder()) ); 00174 qDebug("-- End Loop on v %i",Index(m,iPos.v)); 00175 } 00176 00177 // A questo punto ho un vettore che mi direbbe per ogni faccia quale vertice devo mettere. Dopo che ho aggiunto i vertici necessari, 00178 // rifaccio il giro delle facce 00179 qDebug("adding %i vert for %i crease edges ",newVertexCounter-m.vn, creaseCounter); 00180 tri::Allocator<MESH_TYPE>::AddVertices(m,newVertexCounter-m.vn); 00181 00182 tri::UpdateFlags<MESH_TYPE>::VertexClearV(m); 00183 for(fi=m.face.begin();fi!=m.face.end();++fi) 00184 for(int j=0;j<3;++j) // foreach unvisited vertex 00185 { 00186 size_t faceInd = Index(m, *fi); 00187 size_t vertInd = Index(m, (*fi).V(j)); 00188 int curVertexInd = indVec[faceInd*3+ j]; 00189 qDebug("Setting Face %2i vert %2i : %2i -> %2i",faceInd,j,vertInd,curVertexInd); 00190 assert(curVertexInd != -1); 00191 assert(curVertexInd < m.vn); 00192 if(curVertexInd < startVn) assert(curVertexInd == vertInd); 00193 if(curVertexInd >= startVn) 00194 { 00195 //m.vert[curVertexInd].ImportData(*((*fi).V(j))); 00196 tri::Append<CMeshO,CMeshO>::ImportVertex(m.vert[curVertexInd],*((*fi).V(j))); 00197 (*fi).V(j) = & m.vert[curVertexInd]; 00198 } 00199 } 00200 00201 */