vcglib: stat.h Source File

00001 /****************************************************************************
00002 * VCGLib                                                            o o     *
00003 * Visual and Computer Graphics Library                            o     o   *
00004 *                                                                _   O  _   *
00005 * Copyright(C) 2006                                                \/)\/    *
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 History
00025 
00026 $Log: not supported by cvs2svn $
00027 Revision 1.3  2007/01/11 10:12:19  cignoni
00028 Removed useless and conflicting inclusion of face.h
00029 
00030 Revision 1.2  2006/05/25 09:39:09  cignoni
00031 missing std and other gcc detected syntax errors
00032 
00033 Revision 1.1  2006/05/21 06:59:13  cignoni
00034 Initial Commit
00035 
00036 ****************************************************************************/
00037 
00038 #ifndef __VCGLIB_TRIMESH_STAT
00039 #define __VCGLIB_TRIMESH_STAT
00040 
00041 // Standard headers
00042 // VCG headers
00043 
00044 #include <vcg/math/histogram.h>
00045 #include <vcg/simplex/face/pos.h>
00046 #include <vcg/simplex/face/topology.h>
00047 #include <vcg/complex/trimesh/base.h>
00048 #include <vcg/complex/trimesh/closest.h>
00049 #include <vcg/space/index/grid_static_ptr.h>
00050 #include <vcg/complex/trimesh/allocate.h>
00051 
00052 
00053 namespace vcg {
00054         namespace tri{
00055 template <class StatMeshType>
00056 class Stat
00057 {
00058   public:
00059         typedef StatMeshType MeshType; 
00060         typedef typename MeshType::VertexType     VertexType;
00061         typedef typename MeshType::VertexPointer  VertexPointer;
00062         typedef typename MeshType::VertexIterator VertexIterator;
00063         typedef typename MeshType::ScalarType                   ScalarType;
00064         typedef typename MeshType::FaceType       FaceType;
00065         typedef typename MeshType::FacePointer    FacePointer;
00066         typedef typename MeshType::FaceIterator   FaceIterator;
00067         typedef typename MeshType::FaceContainer  FaceContainer;
00068         typedef typename vcg::Box3<ScalarType>  Box3Type;
00069         
00070         static std::pair<float,float> ComputePerVertexQualityMinMax( MeshType & m)    // V1.0
00071         {
00072         std::pair<float,float> minmax = std::make_pair(std::numeric_limits<float>::max(),-std::numeric_limits<float>::max());
00073                  
00074                 VertexIterator vi;
00075                 for(vi = m.vert.begin(); vi != m.vert.end(); ++vi)
00076                         if(!(*vi).IsD()) 
00077                         {
00078                                 if( (*vi).Q() < minmax.first) minmax.first=(*vi).Q();
00079                                 if( (*vi).Q() > minmax.second) minmax.second=(*vi).Q();
00080                         }
00081                 return minmax;
00082         }
00083 
00084         static std::pair<float,float> ComputePerFaceQualityMinMax( MeshType & m)    // V1.0
00085         {
00086                 std::pair<float,float> minmax = std::make_pair(std::numeric_limits<float>::max(),-std::numeric_limits<float>::max());
00087                 
00088                 FaceIterator fi;
00089                 for(fi = m.face.begin(); fi != m.face.end(); ++fi)
00090                         if(!(*fi).IsD()) 
00091                         {
00092                                 if( (*fi).Q() < minmax.first)  minmax.first =(*fi).Q();
00093                                 if( (*fi).Q() > minmax.second) minmax.second=(*fi).Q();
00094                         }
00095                 return minmax;
00096         }
00097         
00098                         static ScalarType ComputeMeshArea(MeshType & m)
00099                         {
00100                                 ScalarType area=0;
00101                                 
00102                                 FaceIterator fi;
00103         for(fi = m.face.begin(); fi != m.face.end(); ++fi)
00104                                                 if(!(*fi).IsD()) 
00105                                                                 area += DoubleArea(*fi);
00106                                                 
00107                                 return area/ScalarType(2.0);
00108                         }
00109                         
00110       static void ComputePerVertexQualityDistribution( MeshType & m, Distribution<float> &h, bool selectionOnly = false)    // V1.0
00111       {
00112         VertexIterator vi;
00113         for(vi = m.vert.begin(); vi != m.vert.end(); ++vi)
00114             if(!(*vi).IsD() &&  ((!selectionOnly) || (*vi).IsS()) )
00115               {
00116                 assert(!math::IsNAN((*vi).Q()) && "You should never try to compute Histogram with Invalid Floating points numbers (NaN)");
00117                 h.Add((*vi).Q());
00118               }
00119       }
00120 
00121       static void ComputePerFaceQualityDistribution( MeshType & m, Distribution<float> &h, bool selectionOnly = false)    // V1.0
00122       {
00123         FaceIterator fi;
00124         for(fi = m.face.begin(); fi != m.face.end(); ++fi)
00125             if(!(*fi).IsD() &&  ((!selectionOnly) || (*fi).IsS()) )
00126               {
00127                 assert(!math::IsNAN((*fi).Q()) && "You should never try to compute Histogram with Invalid Floating points numbers (NaN)");
00128                 h.Add((*fi).Q());
00129               }
00130       }
00131 
00132       static void ComputePerFaceQualityHistogram( MeshType & m, Histogramf &h, bool selectionOnly=false )
00133       {
00134         FaceIterator fi;
00135         int HistSize=10000;
00136         std::pair<float,float> minmax = tri::Stat<MeshType>::ComputePerFaceQualityMinMax(m);
00137         h.Clear();
00138         h.SetRange( minmax.first,minmax.second, HistSize );
00139         for(fi = m.face.begin(); fi != m.face.end(); ++fi)
00140           if(!(*fi).IsD() &&  ((!selectionOnly) || (*fi).IsS()) ){
00141             assert(!math::IsNAN((*fi).Q()) && "You should never try to compute Histogram with Invalid Floating points numbers (NaN)");
00142           h.Add((*fi).Q());
00143         }
00144       }
00145 
00146       static void ComputePerVertexQualityHistogram( MeshType & m, Histogramf &h, bool selectionOnly = false)    // V1.0
00147       {
00148                                 VertexIterator vi;
00149                                 int HistSize=10000;
00150                                 std::pair<float,float> minmax = ComputePerVertexQualityMinMax(m);
00151                                         
00152                                 h.Clear();
00153                                 h.SetRange( minmax.first,minmax.second, HistSize);
00154                                 for(vi = m.vert.begin(); vi != m.vert.end(); ++vi)
00155                                                 if(!(*vi).IsD() &&  ((!selectionOnly) || (*vi).IsS()) )
00156                                                         {
00157                                                                 assert(!math::IsNAN((*vi).Q()) && "You should never try to compute Histogram with Invalid Floating points numbers (NaN)");
00158                                                                 h.Add((*vi).Q());
00159                                                         }                                               
00160                                 // Sanity check; If some very wrong value has happened in the Q value, 
00161                                 // the histogram is messed. If a significant percentage (20% )of the values are all in a single bin
00162                                 // we should try to solve the problem. No easy solution here.
00163                                 // We choose to compute the get the 1percentile and 99 percentile values as new mixmax ranges 
00164                                 // and just to be sure enlarge the Histogram.
00165                                 
00166                                 if(h.MaxCount() > HistSize/5)
00167                                         {
00168                                                 std::vector<float> QV;
00169                                                 QV.reserve(m.vn);
00170                                                 for(vi = m.vert.begin(); vi != m.vert.end(); ++vi)
00171                                                         if(!(*vi).IsD()) QV.push_back((*vi).Q());
00172 
00173                                                 std::nth_element(QV.begin(),QV.begin()+m.vn/100,QV.end());
00174                                                 float newmin=*(QV.begin()+m.vn/100);
00175                                                 std::nth_element(QV.begin(),QV.begin()+m.vn-m.vn/100,QV.end());
00176                                                 float newmax=*(QV.begin()+m.vn-m.vn/100);
00177                                                 
00178                                                 h.Clear();
00179                                                 h.SetRange(newmin, newmax, HistSize*50);
00180                                                 for(vi = m.vert.begin(); vi != m.vert.end(); ++vi)
00181                                                                 if(!(*vi).IsD() && ((!selectionOnly) || (*vi).IsS()) )
00182                                                                     h.Add((*vi).Q());
00183                                         }
00184       }
00185 
00186                         static int ComputeEdgeHistogram( MeshType & m, Histogramf &h)    // V1.0
00187       {
00188         ScalarType Diag = m.bbox.Diag();
00189         h.Clear();
00190         h.SetRange( 0, Diag, 10000);
00191         FaceIterator fi;
00192         for(fi = m.face.begin(); fi != m.face.end(); ++fi)
00193         {
00194           if(!(*fi).IsD())
00195           {
00196             if( !(*fi).V(0)->IsS() && !(*fi).V(1)->IsS()  )
00197             {
00198               h.Add(Distance<float>((*fi).V(0)->P(),(*fi).V(1)->P()));
00199               (*fi).V(0)->SetS();
00200               (*fi).V(1)->SetS();
00201             }
00202             if( !(*fi).V(1)->IsS() && !(*fi).V(2)->IsS())
00203             {
00204               h.Add(Distance<float>((*fi).V(1)->P(),(*fi).V(2)->P()));
00205               (*fi).V(2)->SetS();
00206               (*fi).V(1)->SetS();
00207             }
00208             if( !(*fi).V(2)->IsS() && !(*fi).V(0)->IsS())
00209             {
00210               h.Add(Distance<float>((*fi).V(2)->P(),(*fi).V(0)->P()));
00211               (*fi).V(0)->SetS();
00212               (*fi).V(2)->SetS();
00213             }
00214           }
00215         }
00216         VertexIterator vi;
00217         for(vi = m.vert.begin(); vi != m.vert.end(); ++vi)
00218           (*vi).ClearS();
00219       return 0;
00220           }
00221 }; // end class
00222         
00223         } //End Namespace tri
00224 } // End Namespace vcg
00225 
00226 #endif
00227