From 89266673a14f7d06979a0131f4fe1163aafcc14e Mon Sep 17 00:00:00 2001
From: cnr-isti-vclab <paolo.cignoni@isti.cnr.it>
Date: Thu, 8 Jun 2006 16:20:52 +0000
Subject: [PATCH] fixed some bugs

---
 wrap/io_trimesh/import_ptx.h | 375 ++++++++++++++++++++++++++++++++---
 1 file changed, 351 insertions(+), 24 deletions(-)

diff --git a/wrap/io_trimesh/import_ptx.h b/wrap/io_trimesh/import_ptx.h
index 81885386..e63d506e 100644
--- a/wrap/io_trimesh/import_ptx.h
+++ b/wrap/io_trimesh/import_ptx.h
@@ -57,10 +57,30 @@ namespace vcg {
     typedef typename OpenMeshType::VertexIterator VertexIterator;
     typedef typename OpenMeshType::FaceIterator FaceIterator;
 
+    struct RANGEMAP_INFO
+    {
+        fpos_t pos;
+        int    vn;
+        int    fn;
+    };
 
+    typedef typename std::vector< RANGEMAP_INFO > RANGEMAP_INFO_TABLE;
+
+    struct PTX_HEAD_INFO
+    {
+        int    vn;
+        int    fn;
+        RANGEMAP_INFO_TABLE rmapInfo; 
+    };
 
     // skip a mesh 
-    static bool skipmesh(FILE* fp)
+
+    static bool skipmesh(FILE* fp, CallBackPos *cb=NULL)
+    {
+     PTX_HEAD_INFO tab;
+     return skipmesh(fp, cb);
+    }
+    static bool skipmesh(FILE* fp, PTX_HEAD_INFO & tab, CallBackPos *cb=NULL)
     {
      int colnum;
      int rownum;
@@ -68,18 +88,23 @@ namespace vcg {
      char linebuf;
 
      if(feof(fp))	return false;
+     RANGEMAP_INFO ptxInfo;
+     fgetpos(fp, &ptxInfo.pos );
 
      // getting mesh size;
      fscanf(fp,"%i\n",&colnum);
      fscanf(fp,"%i\n",&rownum);
+    
+     ptxInfo.vn = rownum*colnum;
+     ptxInfo.fn = (rownum-1) * (colnum-1) * 2;
 
+     char tmp[255];
+     sprintf(tmp, "PTX Mesh analysis... mesh %i  vert %i face %i", (int)tab.rmapInfo.size(), ptxInfo.vn, ptxInfo.fn);
+     
      if ( ( colnum <=0 ) || ( rownum <=0 ) ) return false;
 
-     //printf("\n %i x %i \n", rownum, colnum);
-     //printf(" expect V %i F %i\n",(rownum*colnum),((rownum-1)*(colnum-1)*2));
-
      if(feof(fp))	return false;
-
+     if(cb) cb( rand()%100, tmp);	
      skiplines = (colnum * rownum) + 8; // have to skip (col * row) lines plus 8 lines for the header
      for(int ii=0; ii<skiplines; ii++)
      {
@@ -87,22 +112,133 @@ namespace vcg {
       while(linebuf != '\n')  fread(&linebuf,1,1,fp);
      } 
 
+     if(cb) cb( 100, tmp);
+     tab.vn += ptxInfo.vn;
+     tab.fn += ptxInfo.fn;
+     tab.rmapInfo.push_back( ptxInfo );
      return true;
     }
 
 
+    static bool Analysis(const char * filename, PTX_HEAD_INFO &info, CallBackPos *cb=NULL)
+    {
+     info.fn = 0;
+     info.vn = 0;
+     info.rmapInfo.clear();
+     FILE *fp;
+     fp = fopen(filename, "rb");
+     if(fp == NULL) return false;
+     while ( skipmesh( fp, info, cb ) ) {}
+     return true;
+    };
+
+    static bool Open( OpenMeshType &m, const char * filename, int meshNumber, int mask = PTX_ONLY_POINTS, CallBackPos *cb=NULL)
+    {
+     FILE *fp;
+     fp = fopen(filename, "rb");
+     if(fp == NULL) return false;
+     m.Clear();
+     m.vn=0;
+     m.fn=0;
+    
+     PTX_HEAD_INFO ptxHead;
+     if ( meshNumber>0 ) for (int i=0; i!=meshNumber; ++i)  skipmesh(fp, ptxHead, cb);
+     if (!readPTX( m, fp, mask, meshNumber, cb))
+     {
+         m.Clear();
+         return false;
+     }
+     clearBadVertex(m, mask, cb);
+     return true;
+    }
+
+    static void clearBadVertex(OpenMeshType &m, int mask, CallBackPos *cb=NULL)
+    {
+     if(cb) cb(40,"PTX Mesh Loading - remove bad vertex!");	
+     for(VertexIterator vi = m.vert.begin(); vi != m.vert.end(); vi++)
+     {
+      if((*vi).P() == Point3f(0.0, 0.0, 0.0))
+      {
+       (*vi).SetD();
+       m.vn--;
+      }
+     }
+
+     if(cb) cb(60,"PTX Mesh Loading - remove bad face!");	
+     bool onlypoints  =  ((mask & PTX_ONLY_POINTS) != 0);
+     if(! onlypoints)
+     {
+      for(OpenMeshType::FaceIterator fi = m.face.begin(); fi != m.face.end(); fi++)
+      {
+       if( ((*fi).V(0)->IsD()) || ((*fi).V(1)->IsD()) || ((*fi).V(2)->IsD()) )
+       {
+        (*fi).SetD();
+         m.fn--;
+       }
+      }
+
+      // eliminate high angle triangles
+      int angle = 90;
+      
+      //printf(" culling by angle \n");
+      float limit = cos( angle*3.14159265358979323846/180.0 );
+      Point3f raggio;
+
+      if(cb) cb(85,"PTX Mesh Loading - remove bad face!");	
+      vcg::tri::UpdateNormals<OpenMeshType>::PerFaceNormalized(m);
+      for(OpenMeshType::FaceIterator fi = m.face.begin(); fi != m.face.end(); fi++)
+      if(!(*fi).IsD())
+      {
+      raggio = -((*fi).V(0)->P() + (*fi).V(1)->P() + (*fi).V(2)->P()) / 3.0;
+      raggio.Normalize();
+      if((raggio * (*fi).N()) < limit)
+      {
+      (*fi).SetD();
+      m.fn--;
+      }
+      }
+
+     }
+     /*if(cb) cb(60,"PTX Mesh Loading RemoveDuplicateVertex");	
+     tri::Clean<OpenMeshType>::RemoveDuplicateVertex(m);
+
+     if (!onlypoints) 
+     { 
+      if(cb) cb(60,"PTX Mesh Loading RemoveUnreferencedVertex");	
+      tri::Clean<OpenMeshType>::RemoveUnreferencedVertex(m);
+     }*/
+     if(cb) cb(100,"PTX Mesh Loading finish!");	
+
+
+    }
     
     //if numMesh == -1 load all mesh
-    static bool Open( OpenMeshType &m, const char * filename, int numMesh = -1, int mask = PTX_ONLY_POINTS, CallBackPos *cb=NULL)
+    static bool Open( OpenMeshType &m, const char * filename,  int mask = PTX_ONLY_POINTS, CallBackPos *cb=NULL)
     {
      FILE *fp;
      fp = fopen(filename, "rb");
      if(fp == NULL) return false;
 
      m.Clear();
+     m.vn=0;
+     m.fn=0;
+     int vn=0;
+     int fn=0;
+     //PTX_HEAD_INFO tab;
+     //tab.clear();
+     //while ( skipmesh( fp, tab, cb ) ) {}
+     /*if ( (vn<=0) && (fn<=0) ) return false;
+     //VertexIterator vi = Allocator<OpenMeshType>::AddVertices(m,vn); 
+     //OpenMeshType::FaceIterator fi= Allocator<OpenMeshType>::AddFaces(m,fn);
+
+     VertexIterator vi = Allocator<OpenMeshType>::AddVertices(m, tab[20].vn); 
+     FaceIterator fi   = Allocator<OpenMeshType>::AddFaces(m, tab[20].fn);
+     readPTX( m, fp, vi, fi, tab[20], mask, 20, cb);
+     fclose(fp);   
+    /* return true;
 
      if ( numMesh>0 )
-      for (int i=0; i!=numMesh; ++i)  if (!skipmesh(fp)) return false;
+      for (int i=0; i!=numMesh; ++i)  if (!skipmesh(fp, vn, fn, tab)) return false;
 
      int mn=0;
      if ( numMesh == -1 )
@@ -122,7 +258,7 @@ namespace vcg {
      }
 
      fclose(fp);
-
+*/
      // now i delete all points in (0,0,0) that are unsampled points
      for(VertexIterator vi = m.vert.begin(); vi != m.vert.end(); vi++)
      {
@@ -148,9 +284,8 @@ namespace vcg {
       }
 
       // eliminate high angle triangles
-      /*int angle =85;
-      if(angle != 90)
-      {
+      int angle = 90;
+      
       printf(" culling by angle \n");
       float limit = cos( angle*3.14159265358979323846/180.0 );
       Point3f raggio;
@@ -168,16 +303,15 @@ namespace vcg {
       }
       }
 
-      }*/
      }
-     if(cb) cb(60,"PTX Mesh Loading RemoveDuplicateVertex");	
+     /*if(cb) cb(60,"PTX Mesh Loading RemoveDuplicateVertex");	
      tri::Clean<OpenMeshType>::RemoveDuplicateVertex(m);
 
      if (!onlypoints) 
      { 
       if(cb) cb(60,"PTX Mesh Loading RemoveUnreferencedVertex");	
       tri::Clean<OpenMeshType>::RemoveUnreferencedVertex(m);
-     }
+     }*/
      if(cb) cb(100,"PTX Mesh Loading finish!");	
      return true;
     }
@@ -185,6 +319,7 @@ namespace vcg {
 
 
 
+   
     static bool readPTX( OpenMeshType &m, FILE *fp, int mask, int mn, CallBackPos *cb=NULL)
     {
      int colnum;
@@ -248,7 +383,7 @@ namespace vcg {
      int vn = rownum*colnum;
 
      VertexIterator vi = Allocator<OpenMeshType>::AddVertices(m,vn); 
-
+     m.vn = vn;
      // parse the first line....
      if(hascolor)
      {
@@ -264,6 +399,201 @@ namespace vcg {
      if (computeBbox) m.bbox.SetNull();
 
 
+     //addthefirstpoint
+     (*vi).P()[0]=xx;
+     (*vi).P()[1]=yy;
+     (*vi).P()[2]=zz;
+     (*vi).P() = currtrasf * (*vi).P();
+     if (computeBbox) m.bbox.Add( (*vi).P() );
+     if(hascolor && savecolor)
+     {
+      (*vi).C()[0]=rr;
+      (*vi).C()[1]=gg;
+      (*vi).C()[2]=bb;
+     }
+     vi++;
+
+     // now for each line until end of mesh (row*col)-1
+     for(ii=0; ii<((rownum*colnum)-1); ii++)
+     {
+      char tmp[255];
+      sprintf(tmp, "PTX Mesh Loading... mesh %i", mn);
+      if(cb) cb((ii*total)/vn, tmp);	
+
+      // read the stream
+      if(hascolor)   fscanf(fp,"%f %f %f %f %f %f %f", &xx, &yy, &zz, &rf, &rr, &gg, &bb);
+      else  fscanf(fp,"%f %f %f %f", &xx, &yy, &zz, &rf);
+
+      // add the point
+      (*vi).P()[0]=xx;
+      (*vi).P()[1]=yy;
+      (*vi).P()[2]=zz;
+      (*vi).P() = currtrasf * (*vi).P();
+      if (computeBbox) m.bbox.Add( (*vi).P() );
+      if(hascolor && savecolor)
+      {
+       (*vi).C()[0]=rr;
+       (*vi).C()[1]=gg;
+       (*vi).C()[2]=bb;
+      }
+      vi++;
+     }
+
+     if(! onlypoints)
+     {
+      // now i can triangulate
+      int trinum = (rownum-1) * (colnum-1) * 2;
+      OpenMeshType::FaceIterator fi= Allocator<OpenMeshType>::AddFaces(m,trinum);
+      m.fn = trinum;
+
+      int v0i,v1i,v2i, t;
+      t=0;
+      for(int rit=0; rit<rownum-1; rit++)
+       for(int cit=0; cit<colnum-1; cit++)
+       {
+        t++;
+        if(cb) cb(50 + (t*50)/(rownum*colnum),"PTX Mesh Loading");	
+
+        if(!switchside)
+        {
+         v0i = (rit  ) + ((cit  ) * rownum);
+         v1i = (rit+1) + ((cit  ) * rownum);
+         v2i = (rit  ) + ((cit+1) * rownum);
+        }
+        else
+        {
+         v0i = (cit  ) + ((rit  ) * colnum);
+         v1i = (cit+1) + ((rit  ) * colnum);
+         v2i = (cit  ) + ((rit+1) * colnum);
+        }
+
+
+        // upper tri
+        (*fi).V(2) = &(m.vert[v0i]);
+        (*fi).V(1) = &(m.vert[v1i]);
+        (*fi).V(0) = &(m.vert[v2i]);
+
+        if(flipfaces)
+        {
+         (*fi).V(2) = &(m.vert[v1i]);
+         (*fi).V(1) = &(m.vert[v0i]);
+        }
+
+        //m.fn++;
+        fi++;
+
+        if(!switchside)
+        {
+         v0i = (rit+1) + ((cit  ) * rownum);
+         v1i = (rit+1) + ((cit+1) * rownum);
+         v2i = (rit  ) + ((cit+1) * rownum);
+        }
+        else
+        {
+         v0i = (cit+1) + ((rit  ) * colnum);
+         v1i = (cit+1) + ((rit+1) * colnum);
+         v2i = (cit  ) + ((rit+1) * colnum);
+        }
+
+        // lower tri
+        (*fi).V(2) = &(m.vert[v0i]);
+        (*fi).V(1) = &(m.vert[v1i]);
+        (*fi).V(0) = &(m.vert[v2i]);
+
+        if(flipfaces)
+        {
+         (*fi).V(2) = &(m.vert[v1i]);
+         (*fi).V(1) = &(m.vert[v0i]);
+        }
+
+       // m.fn++;
+        fi++;
+       }
+     }
+     return true;
+    }
+
+    static bool readPTX( OpenMeshType &m, FILE *fp, VertexIterator &vi, FaceIterator &fi, const RANGEMAP_INFO &ptxInfo, int mask, int mn, CallBackPos *cb=NULL)
+    {
+     int colnum;
+     int rownum;
+     int numtokens;
+     char linebuf[256];
+     int ii;
+     float xx,yy,zz;	 // position
+     float rr,gg,bb;	 // color
+     float rf;		     // reflectance
+     Matrix44f		currtrasf;
+
+     bool hascolor;
+
+     bool savecolor   =  ((mask & PTX_COLOR) != 0) &&  VertexType::HasColor();
+     bool computeBbox =  ((mask & PTX_COMPUTE_AABBOX) != 0);
+     bool onlypoints  =  ((mask & PTX_ONLY_POINTS) != 0);
+     bool switchside  =  ((mask & PTX_SWITCHSIDE) != 0);
+     bool flipfaces   =  ((mask & PTX_FLIPFACES) != 0);
+     int total = 50;
+     if ( onlypoints ) total = 100;
+   
+     if (fsetpos(fp, &ptxInfo.pos)!=0) return false;
+     
+
+     // getting mesh size;
+     fscanf(fp,"%i\n",&colnum);
+     fscanf(fp,"%i\n",&rownum);
+
+     if ( ( colnum <=0 ) || ( rownum <=0 ) ) return false;
+
+     // initial 4 lines [still don't know what is this :) :)]
+     if ( !fscanf(fp,"%f %f %f\n", &xx, &yy, &zz) ) return false;
+     if ( !fscanf(fp,"%f %f %f\n", &xx, &yy, &zz) ) return false;
+     if ( !fscanf(fp,"%f %f %f\n", &xx, &yy, &zz) ) return false;
+     if ( !fscanf(fp,"%f %f %f\n", &xx, &yy, &zz) ) return false;
+
+     // now the transformation matrix
+     if ( !fscanf(fp,"%f %f %f %f\n", &(currtrasf.ElementAt(0,0)), &(currtrasf.ElementAt(0,1)), &(currtrasf.ElementAt(0,2)), &(currtrasf.ElementAt(0,3))) )return false;
+     if ( !fscanf(fp,"%f %f %f %f\n", &(currtrasf.ElementAt(1,0)), &(currtrasf.ElementAt(1,1)), &(currtrasf.ElementAt(1,2)), &(currtrasf.ElementAt(1,3))) )return false;
+     if ( !fscanf(fp,"%f %f %f %f\n", &(currtrasf.ElementAt(2,0)), &(currtrasf.ElementAt(2,1)), &(currtrasf.ElementAt(2,2)), &(currtrasf.ElementAt(2,3))) )return false;
+     if ( !fscanf(fp,"%f %f %f %f\n", &(currtrasf.ElementAt(3,0)), &(currtrasf.ElementAt(3,1)), &(currtrasf.ElementAt(3,2)), &(currtrasf.ElementAt(3,3))) )return false;
+
+     // now the real data begins
+
+     // first line, we should know if the format is
+     // XX YY ZZ RF
+     // or it is
+     // XX YY ZZ RF RR GG BB
+
+     // read the entire first line and then count the spaces. it's rude but it works :)
+     ii=0;
+     fread(&(linebuf[ii++]),1,1,fp);
+     while(linebuf[ii-1] != '\n')  if ( fread(&(linebuf[ii++]),1,1,fp)==0 ) return false;
+     linebuf[ii-1] = '\0'; // terminate the string
+     numtokens=1;
+     for(ii=0; ii<(int)strlen(linebuf); ii++) if(linebuf[ii] == ' ') numtokens++;
+     if(numtokens == 4)  hascolor = false;
+     else if(numtokens == 7)  hascolor = true;
+     else  return false;
+
+     Transpose(currtrasf);
+     int vn = rownum*colnum;
+
+     //VertexIterator vi = Allocator<OpenMeshType>::AddVertices(m,vn); 
+     //m.vn += vn;
+     // parse the first line....
+     if(hascolor)
+     {
+      printf("\n hascolor ");
+      sscanf(linebuf,"%f %f %f %f %f %f %f", &xx, &yy, &zz, &rf, &rr, &gg, &bb);
+     }
+     else
+     {
+      printf("\n no color ");
+      sscanf(linebuf,"%f %f %f %f", &xx, &yy, &zz, &rf);
+     }
+
+     //if (computeBbox) m.bbox.SetNull();
+
+
      //addthefirstpoint
      (*vi).P()[0]=xx;
      (*vi).P()[1]=yy;
@@ -311,10 +641,6 @@ namespace vcg {
 
      }
 
-
-     m.vn = m.vert.size();
-     m.fn = 0;
-
      if(! onlypoints)
      {
 
@@ -322,10 +648,10 @@ namespace vcg {
       int trinum = (rownum-1) * (colnum-1) * 2;
 
 
-      OpenMeshType::FaceIterator fi= Allocator<OpenMeshType>::AddFaces(m,trinum);
+      //OpenMeshType::FaceIterator fi= Allocator<OpenMeshType>::AddFaces(m,trinum);
 
-
-      m.fn = 0;
+     // m.fn += trinum;
+     
 
       int v0i,v1i,v2i, t;
       for(int rit=0; rit<rownum-1; rit++)
@@ -359,7 +685,7 @@ namespace vcg {
          (*fi).V(1) = &(m.vert[v0i]);
         }
 
-        m.fn++;
+        //m.fn++;
         fi++;
 
         if(!switchside)
@@ -386,7 +712,7 @@ namespace vcg {
          (*fi).V(1) = &(m.vert[v0i]);
         }
 
-        m.fn++;
+       // m.fn++;
         fi++;
        }
 
@@ -403,6 +729,7 @@ namespace vcg {
 
 
 
+
    }; // end class