395 lines
9.9 KiB
C++
395 lines
9.9 KiB
C++
/****************************************************************************
|
|
* 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. *
|
|
* *
|
|
****************************************************************************/
|
|
/****************************************************************************
|
|
Acknowlegments
|
|
Portions of this file were based on the original code of the Ply library
|
|
of Greg Turk and on the work of Claudio Rocchini
|
|
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
History
|
|
|
|
$Log: not supported by cvs2svn $
|
|
Revision 1.6 2007/06/25 15:24:00 cignoni
|
|
removed a possibly useless static kw
|
|
|
|
Revision 1.5 2006/04/11 09:48:04 zifnab1974
|
|
changes needed for compilation on linux 64b with gcc 3.4.5
|
|
|
|
Revision 1.4 2005/12/02 00:00:53 cignoni
|
|
Moved and corrected interpret_texture_name from plystuff.h to plylib.cpp
|
|
|
|
Revision 1.3 2005/03/18 00:14:40 cignoni
|
|
removed small gcc compiling issues
|
|
|
|
Revision 1.2 2005/03/15 11:46:52 cignoni
|
|
Cleaning of the automatic bbox caching support for ply files. First working version.
|
|
|
|
|
|
*/
|
|
|
|
//****************** Gestione cache *****************
|
|
|
|
#ifndef __VCG_PLYLIB_STUFF
|
|
#define __VCG_PLYLIB_STUFF
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#ifdef WIN32
|
|
#include <io.h>
|
|
#endif
|
|
|
|
#include <vcg/space/box3.h>
|
|
#include <wrap/ply/plylib.h>
|
|
using namespace vcg;
|
|
|
|
#ifdef WIN32
|
|
#include <direct.h>
|
|
#define pb_mkdir(n) _mkdir(n)
|
|
#define pb_access _access
|
|
#define pb_stat _stat
|
|
#define pb_fstat _fstat
|
|
#define pb_open _open
|
|
#define pb_close _close
|
|
#define DIR_SEP "\\"
|
|
#else
|
|
#define pb_mkdir(n) mkdir(n,0755)
|
|
#define pb_access access
|
|
#define pb_stat stat
|
|
#define pb_fstat fstat
|
|
#define pb_open open
|
|
#define pb_close close
|
|
#define _O_BINARY 0 // Does not exist on Unix
|
|
#define _O_RDONLY O_RDONLY
|
|
#define DIR_SEP "/"
|
|
#endif
|
|
|
|
|
|
namespace vcg {
|
|
namespace ply {
|
|
|
|
const int MAXBPATH = 256;
|
|
|
|
// Stringhe per la cache
|
|
const char * cachedir = "vcg_cache";
|
|
const char * bboxcacheext = ".bbox_cache";
|
|
const char * bboxheader = "BBOXCACH";
|
|
|
|
bool GetDirFromPath( const char * path, char * dir, char * name )
|
|
{
|
|
strcpy(dir,path);
|
|
char * p;
|
|
|
|
p = strrchr(dir,'\\');
|
|
if(p==0) p=strrchr(dir,'/');
|
|
if(p==0)
|
|
{
|
|
dir[0] = 0;
|
|
strcpy(name,path);
|
|
}
|
|
else
|
|
{
|
|
strcpy(name,p+1);
|
|
*p = 0;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
static bool CheckCacheDirectory( const char * dir )
|
|
{
|
|
if( pb_access(dir,0)!=0 )
|
|
{
|
|
if( pb_mkdir(dir)==-1 )
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CheckCacheTime( const char * fname, const char * cname )
|
|
{
|
|
|
|
if( pb_access(fname,4)==-1 ) return false;
|
|
if( pb_access(cname,4)==-1 ) return false;
|
|
|
|
int h,r;
|
|
struct pb_stat st;
|
|
time_t ft,bt;
|
|
|
|
h = pb_open(fname,_O_BINARY|_O_RDONLY);
|
|
if(h==0) return false;
|
|
r = pb_fstat(h,&st);
|
|
pb_close(h);
|
|
if(r==-1) return false;
|
|
ft = st.st_mtime;
|
|
|
|
h = pb_open(cname,_O_BINARY|_O_RDONLY);
|
|
if(h==0) return false;
|
|
r = pb_fstat(h,&st);
|
|
//_read(h,&box,sizeof(box));
|
|
pb_close(h);
|
|
if(r==-1) return false;
|
|
bt = st.st_mtime;
|
|
|
|
if( difftime(bt,ft)>=0 ) return true;
|
|
else return false;
|
|
}
|
|
|
|
// restituisce true se il file con la cache del bbox della mesh e' piu' recente del file ply
|
|
// se fname2 != 0, allora deve essere piu recente anche di fname2.
|
|
static bool CheckBBoxCache( const char * fname, Box3d & box, const char *fname2=0 )
|
|
{
|
|
char d[MAXBPATH];
|
|
char n[MAXBPATH];
|
|
char h[8];
|
|
|
|
// Estrazione dati
|
|
if( ! GetDirFromPath(fname,d,n) ) return false;
|
|
|
|
// Controllo esistenza directory delle cache
|
|
if(d[0]!=0)
|
|
strcat(d,DIR_SEP);
|
|
strcat(d,cachedir);
|
|
if( !CheckCacheDirectory(d) ) return false;
|
|
|
|
// Controllo esistenza e data file cache
|
|
strcat(d,DIR_SEP);
|
|
strcat(d,n);
|
|
strcat(d,bboxcacheext);
|
|
if( CheckCacheTime(fname,d) &&
|
|
(fname2==0 || CheckCacheTime(fname2,d)) )
|
|
{
|
|
// Lettura bbox e controllo
|
|
FILE * fp = fopen(d,"rb");
|
|
if(fp==0) return false;
|
|
if( fread(h,1,8,fp)!=8 )
|
|
{
|
|
fclose(fp);
|
|
return false;
|
|
}
|
|
if( fread(&box,sizeof(Box3d),1,fp)!=1 )
|
|
{
|
|
fclose(fp);
|
|
return false;
|
|
}
|
|
fclose(fp);
|
|
if( strncmp(h,bboxheader,8) )
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
|
|
bool GetCacheName( const char * fname, const char * ext_name, char * cname )
|
|
{
|
|
static char n[MAXBPATH];
|
|
|
|
// Estrazione dati
|
|
if( ! GetDirFromPath(fname,cname,n) ) return false;
|
|
|
|
// Controllo esistenza directory delle cache
|
|
if(cname[0]!=0)
|
|
strcat(cname,DIR_SEP);
|
|
strcat(cname,cachedir);
|
|
if( !CheckCacheDirectory(cname) ) return false;
|
|
|
|
strcat(cname,DIR_SEP);
|
|
strcat(cname,n);
|
|
strcat(cname,ext_name);
|
|
return true;
|
|
}
|
|
|
|
|
|
static bool SaveBBoxCache( const char * fname, const Box3d & box )
|
|
{
|
|
char d[MAXBPATH];
|
|
|
|
if( !GetCacheName(fname,bboxcacheext,d) )
|
|
return false;
|
|
|
|
// Lettura bbox e controllo
|
|
FILE * fp = fopen(d,"wb");
|
|
if(fp==0) return false;
|
|
if( fwrite(bboxheader,1,8,fp)!=8 )
|
|
{
|
|
fclose(fp);
|
|
return false;
|
|
}
|
|
if( fwrite(&box,sizeof(Box3d),1,fp)!=1 )
|
|
{
|
|
fclose(fp);
|
|
return false;
|
|
}
|
|
fclose(fp);
|
|
return true;
|
|
}
|
|
|
|
struct PlyPoint3d
|
|
{
|
|
double x;
|
|
double y;
|
|
double z;
|
|
};
|
|
|
|
|
|
// Calcola il bbox di un file ply
|
|
|
|
bool ScanBBox( const char * fname, Box3d & box, bool use_cache=true )
|
|
{
|
|
|
|
if(use_cache)
|
|
{
|
|
if( CheckBBoxCache(fname,box) )
|
|
return true;
|
|
}
|
|
|
|
static const PropDescriptor pv[3]=
|
|
{
|
|
{"vertex","x",T_FLOAT,T_DOUBLE,offsetof(PlyPoint3d,x),0,0,0,0,0 ,0}, // TO GET RID OF COMPILER WARNING I ADDED 0 TO INITIALIZE format (MV)
|
|
{"vertex","y",T_FLOAT,T_DOUBLE,offsetof(PlyPoint3d,y),0,0,0,0,0 ,0}, // TO GET RID OF COMPILER WARNING I ADDED 0 TO INITIALIZE format (MV)
|
|
{"vertex","z",T_FLOAT,T_DOUBLE,offsetof(PlyPoint3d,z),0,0,0,0,0, 0},// TO GET RID OF COMPILER WARNING I ADDED 0 TO INITIALIZE format (MV)
|
|
};
|
|
|
|
|
|
PlyFile pf;
|
|
|
|
if( pf.Open(fname,PlyFile::MODE_READ)==-1 )
|
|
{
|
|
fprintf(stderr,"Warning: File %s not found\n",fname);
|
|
return false;
|
|
}
|
|
|
|
if( pf.AddToRead(pv[0])==-1 ) { fprintf(stderr,"Warning: Read error\n"); return false; }
|
|
if( pf.AddToRead(pv[1])==-1 ) { fprintf(stderr,"Warning: Read error\n"); return false; }
|
|
if( pf.AddToRead(pv[2])==-1 ) { fprintf(stderr,"Warning: Read error\n"); return false; }
|
|
|
|
box.SetNull();
|
|
char dummyspace[1024]; // sperando basti...
|
|
|
|
for(int i=0;i<int(pf.elements.size());++i)
|
|
{
|
|
int n = pf.ElemNumber(i);
|
|
pf.SetCurElement(i);
|
|
|
|
if( !strcmp( pf.ElemName(i),"vertex" ) )
|
|
{
|
|
for(int j=0;j<n;++j)
|
|
{
|
|
PlyPoint3d t;
|
|
|
|
pf.Read( (void *)(&t) );
|
|
box.Add( Point3d(t.x,t.y,t.z) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(int j=0;j<n;++j)
|
|
//pf.Read( 0 ); // prima era cosi' e faceva un'assert e scrivema plausibilimente a caso in mem
|
|
pf.Read( dummyspace );
|
|
}
|
|
}
|
|
|
|
if(use_cache)
|
|
{
|
|
SaveBBoxCache(fname,box);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Come la precedente ma applica la matrice m ai punti prima di calcolare il bbox.
|
|
// Visto che la matrice di solito e' tenuta in un qualche file, se si vuole usare la cache
|
|
// si puo' passare anche un'altro filename da controllare
|
|
bool ScanBBox( const char * fname, Box3d & box, const Matrix44d & m, bool use_cache, const char *matrixfname)
|
|
{
|
|
|
|
if(use_cache)
|
|
{
|
|
if ( CheckBBoxCache(fname,box,matrixfname) ) return true;
|
|
}
|
|
|
|
static const PropDescriptor pv[3]=
|
|
{
|
|
{"vertex","x",T_FLOAT,T_DOUBLE,offsetof(PlyPoint3d,x),0,0,0,0,0, 0},// TO GET RID OF COMPILER WARNING I ADDED 0 TO INITIALIZE format (MV)
|
|
{"vertex","y",T_FLOAT,T_DOUBLE,offsetof(PlyPoint3d,y),0,0,0,0,0, 0},// TO GET RID OF COMPILER WARNING I ADDED 0 TO INITIALIZE format (MV)
|
|
{"vertex","z",T_FLOAT,T_DOUBLE,offsetof(PlyPoint3d,z),0,0,0,0,0, 0},// TO GET RID OF COMPILER WARNING I ADDED 0 TO INITIALIZE format (MV)
|
|
};
|
|
|
|
|
|
PlyFile pf;
|
|
|
|
if( pf.Open(fname,PlyFile::MODE_READ)==-1 )
|
|
{
|
|
fprintf(stderr,"Warning: File %s not found\n",fname);
|
|
return false;
|
|
}
|
|
|
|
if( pf.AddToRead(pv[0])==-1 ) { fprintf(stderr,"Warning: Read error\n"); return false; }
|
|
if( pf.AddToRead(pv[1])==-1 ) { fprintf(stderr,"Warning: Read error\n"); return false; }
|
|
if( pf.AddToRead(pv[2])==-1 ) { fprintf(stderr,"Warning: Read error\n"); return false; }
|
|
|
|
box.SetNull();
|
|
char dummyspace[1024]; // sperando basti...
|
|
|
|
for(int i=0;i<int(pf.elements.size());++i)
|
|
{
|
|
int n = pf.ElemNumber(i);
|
|
pf.SetCurElement(i);
|
|
|
|
if( !strcmp( pf.ElemName(i),"vertex" ) )
|
|
{
|
|
for(int j=0;j<n;++j)
|
|
{
|
|
PlyPoint3d t;
|
|
|
|
pf.Read( (void *)(&t) );
|
|
box.Add( m*Point3d(t.x,t.y,t.z) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for(int j=0;j<n;++j)
|
|
//pf.Read( 0 ); // prima era cosi' e faceva un'assert e scrivema plausibilimente a caso in mem
|
|
pf.Read( dummyspace );
|
|
}
|
|
}
|
|
|
|
if(use_cache)
|
|
{
|
|
SaveBBoxCache(fname,box);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
} // end namespace ply
|
|
} // end namespace vcg
|
|
#endif
|
|
|