/****************************************************************************
* 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 __VCGLIB_IMPORT_PTX
#define __VCGLIB_IMPORT_PTX
#include <stdio.h>
#include <wrap/callback.h>
#include <vcg/complex/algorithms/clean.h>
#include <vcg/complex/algorithms/update/normal.h>
#include <vcg/complex/algorithms/update/position.h>
#include <vcg/complex/algorithms/update/bounding.h>
namespace vcg {
namespace tri {
namespace io {
/**
This class encapsulate a filter for importing ptx meshes.
*/
template <class OpenMeshType>
class ImporterPTX
{
public:
typedef typename OpenMeshType::VertexPointer VertexPointer;
typedef typename OpenMeshType::ScalarType ScalarType;
typedef typename OpenMeshType::VertexType VertexType;
typedef typename OpenMeshType::FaceType FaceType;
typedef typename OpenMeshType::VertexIterator VertexIterator;
typedef typename OpenMeshType::FaceIterator FaceIterator;
typedef typename OpenMeshType::CoordType CoordType;
typedef typename vcg::Matrix44<ScalarType> Matrix44x;
class Info //ptx file info
{
public:
Info()
{
mask = 0;
meshnum = 0;
anglecull = true;
angle = 89;
savecolor = true;
pointcull = true;
pointsonly = false;
switchside = false;
flipfaces = false;
}
/// a bit mask describing the field preesnt in the ply file
int mask;
/// index of mesh to be imported
int meshnum;
/// if true use angle cull
bool anglecull;
/// culling angle, if angle culling is selected
float angle;
/// if true, remove invalid points
bool pointcull;
/// if true, only keeps points
bool pointsonly;
/// if true, color if saved. if no color is present, reflectancy is used instead
bool savecolor;
/// switch row-columns
bool switchside;
/// flip faces
bool flipfaces;
}; // end ptx file info class
/// Standard call for knowing the meaning of an error code
static const char *ErrorMsg(int error)
{
static const char * ptx_error_msg[] =
{
"No errors",
"Can't open file",
"Header not found",
"Eof in header",
"Format not found",
"Syntax error on header",
};
if(error>6 || error<0) return "Unknown error";
else return ptx_error_msg[error];
};
/// skip ONE range map inside the ptx file, starting from current position
/// returns true if skipped, false if failed/eof
static bool skipmesh(FILE* fp, CallBackPos *cb=NULL)
{
int colnum;
int rownum;
int skiplines;
char linebuf;
if(feof(fp)) return false;
// getting mesh size;
fscanf(fp,"%i\n",&colnum);
fscanf(fp,"%i\n",&rownum);
if ( ( colnum <=0 ) || ( rownum <=0 ) ) return false;
if(feof(fp)) return false;
// have to skip (col * row) lines plus 8 lines for the header
skiplines = (colnum * rownum) + 8;
for(int ii=0; ii<skiplines; ii++)
{
fread(&linebuf,1,1,fp);
while(linebuf != '\n') fread(&linebuf,1,1,fp);
}
if(cb) cb( 100, "Skipped preamble");
return true;
}
///Standard call that reading a mesh
static int Open( OpenMeshType &m, const char * filename, Info importparams, CallBackPos *cb=NULL)
{
FILE *fp;
fp = fopen(filename, "rb");
if(fp == NULL) return false;
m.Clear();
m.vn=0;
m.fn=0;
// if not exporting first one, skip meshes until desired one
if (importparams.meshnum>0)
for (int i=0; i!=importparams.meshnum; ++i)
if(!skipmesh(fp, cb))
return 1;
if (!readPTX( m, fp, importparams, cb))
{
m.Clear();
return 1;
}
return 0;
}
///Call that load a mesh
static bool readPTX( OpenMeshType &m, FILE *fp, Info importparams, CallBackPos *cb=NULL)
{
int numtokens;
int colnum;
int rownum;
double xx,yy,zz; // position
float rr,gg,bb; // color
float rf; // reflectance
Matrix44d currtrasf;
bool hascolor;
bool savecolor = importparams.savecolor && VertexType::HasColor();
bool switchside = importparams.switchside;
int total = 50;
if (importparams.pointsonly) total = 100;
char linebuf[256];
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,"%lf %lf %lf\n", &xx, &yy, &zz) ) return false;
if ( !fscanf(fp,"%lf %lf %lf\n", &xx, &yy, &zz) ) return false;
if ( !fscanf(fp,"%lf %lf %lf\n", &xx, &yy, &zz) ) return false;
if ( !fscanf(fp,"%lf %lf %lf\n", &xx, &yy, &zz) ) return false;
// now the transformation matrix
if ( !fscanf(fp,"%lf %lf %lf %lf\n", &(currtrasf.ElementAt(0,0)), &(currtrasf.ElementAt(0,1)), &(currtrasf.ElementAt(0,2)), &(currtrasf.ElementAt(0,3))) )return false;
if ( !fscanf(fp,"%lf %lf %lf %lf\n", &(currtrasf.ElementAt(1,0)), &(currtrasf.ElementAt(1,1)), &(currtrasf.ElementAt(1,2)), &(currtrasf.ElementAt(1,3))) )return false;
if ( !fscanf(fp,"%lf %lf %lf %lf\n", &(currtrasf.ElementAt(2,0)), &(currtrasf.ElementAt(2,1)), &(currtrasf.ElementAt(2,2)), &(currtrasf.ElementAt(2,3))) )return false;
if ( !fscanf(fp,"%lf %lf %lf %lf\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 :)
int 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;
// PTX transformation matrix is transposed
currtrasf.transposeInPlace();
// allocating vertex space
int vn = rownum*colnum;
VertexIterator vi = Allocator<OpenMeshType>::AddVertices(m,vn);
m.vn = vn;
m.bbox.SetNull();
// parse the first line....
if(hascolor)
{
printf("\n hascolor ");
sscanf(linebuf,"%lf %lf %lf %f %f %f %f", &xx, &yy, &zz, &rf, &rr, &gg, &bb);
}
else
{
printf("\n no color ");
sscanf(linebuf,"%lf %lf %lf %f", &xx, &yy, &zz, &rf);
}
//addthefirstpoint
(*vi).P()[0]=xx;
(*vi).P()[1]=yy;
(*vi).P()[2]=zz;
if(VertexType::HasQuality())
{
(*vi).Q()=rf;
}
if(savecolor)
{
if(hascolor)
{
(*vi).C()[0]=rr;
(*vi).C()[1]=gg;
(*vi).C()[2]=bb;
} else {
(*vi).C()[0]=rf*255;
(*vi).C()[1]=rf*255;
(*vi).C()[2]=rf*255;
}
}
vi++;
if(switchside) std::swap(rownum,colnum);
// now for each line until end of mesh (row*col)-1
for(ii=0; ii<((rownum*colnum)-1); ii++)
{
if(cb && (ii%100)==0) cb((ii*total)/vn, "Vertex Loading");
// read the stream
if(hascolor)
fscanf(fp,"%lf %lf %lf %f %f %f %f", &xx, &yy, &zz, &rf, &rr, &gg, &bb);
else
fscanf(fp,"%lf %lf %lf %f", &xx, &yy, &zz, &rf);
// add the point
(*vi).P()[0]=xx;
(*vi).P()[1]=yy;
(*vi).P()[2]=zz;
if(tri::HasPerVertexQuality(m)) (*vi).Q()=rf;
if(hascolor && savecolor)
{
(*vi).C()[0]=rr;
(*vi).C()[1]=gg;
(*vi).C()[2]=bb;
}
else if(!hascolor && savecolor)
{
(*vi).C()[0]=rf*255;
(*vi).C()[1]=rf*255;
(*vi).C()[2]=rf*255;
}
vi++;
}
if(! importparams.pointsonly)
{
// now i can triangulate
int trinum = (rownum-1) * (colnum-1) * 2;
typename OpenMeshType::FaceIterator fi= Allocator<OpenMeshType>::AddFaces(m,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");
v0i = (rit ) + ((cit ) * rownum);
v1i = (rit+1) + ((cit ) * rownum);
v2i = (rit ) + ((cit+1) * rownum);
// upper tri
(*fi).V(2) = &(m.vert[v0i]);
(*fi).V(1) = &(m.vert[v1i]);
(*fi).V(0) = &(m.vert[v2i]);
fi++;
v0i = (rit+1) + ((cit ) * rownum);
v1i = (rit+1) + ((cit+1) * rownum);
v2i = (rit ) + ((cit+1) * rownum);
// lower tri
(*fi).V(2) = &(m.vert[v0i]);
(*fi).V(1) = &(m.vert[v1i]);
(*fi).V(0) = &(m.vert[v2i]);
fi++;
}
}
printf("Loaded %i vert\n",m.vn);
// remove unsampled points
if(importparams.pointcull)
{
if(cb) cb(40,"PTX Mesh Loading - remove invalid vertices");
for(VertexIterator vi = m.vert.begin(); vi != m.vert.end(); vi++)
{
if((*vi).P() == CoordType(0.0, 0.0, 0.0))
Allocator<OpenMeshType>::DeleteVertex(m,*vi);
}
if(! importparams.pointsonly)
{
if(cb) cb(60,"PTX Mesh Loading - remove invalid faces");
for(typename OpenMeshType::FaceIterator fi = m.face.begin(); fi != m.face.end(); fi++)
{
if( ((*fi).V(0)->IsD()) || ((*fi).V(1)->IsD()) || ((*fi).V(2)->IsD()) )
Allocator<OpenMeshType>::DeleteFace(m,*fi);
}
}
}
float limitCos = cos( math::ToRad(importparams.angle) );
printf("Loaded %i vert\n",m.vn);
if(importparams.pointsonly)
{ // Compute Normals and radius for points
// Compute the four edges around each point
// Some edges can be null (boundary and invalid samples)
if(cb) cb(85,"PTX Mesh Loading - computing vert normals");
for(int rit=0; rit<rownum; rit++)
{
int ritL = std::max(rit-1,0);
int ritR = std::min(rit+1,rownum-1);
for(int cit=0; cit<colnum; cit++)
{
int citT = std::max(cit-1,0);
int citB = std::min(cit+1,colnum-1);
int v0 = (rit ) + ((cit ) * rownum);
if(m.vert[v0].IsD()) continue;
int vL = (ritL) + ((cit ) * rownum);
int vR = (ritR) + ((cit) * rownum);
int vT = (rit ) + ((citT ) * rownum);
int vB = (rit ) + ((citB) * rownum);
CoordType v0p=m.vert[v0].P();
CoordType vLp(0,0,0),vRp(0,0,0),vTp(0,0,0),vBp(0,0,0); // Compute the 4 edges around the vertex.
if(!m.vert[vL].IsD()) vLp=(m.vert[vL].P()-v0p).Normalize();
if(!m.vert[vR].IsD()) vRp=(m.vert[vR].P()-v0p).Normalize();
if(!m.vert[vT].IsD()) vTp=(m.vert[vT].P()-v0p).Normalize();
if(!m.vert[vB].IsD()) vBp=(m.vert[vB].P()-v0p).Normalize();
float r=0;
int rc=0; CoordType v0pn = Normalize(v0p);
// Skip edges that are too steep
// Compute the four normalized vector orthogonal to each pair of consecutive edges.
CoordType vLTn = (vLp ^ vTp).Normalize();
CoordType vTRn = (vTp ^ vRp).Normalize();
CoordType vRBn = (vRp ^ vBp).Normalize();
CoordType vBLn = (vBp ^ vLp).Normalize();
// Compute an average Normal skipping null normals and normals that are too steep.
// Compute also the sum of non null edge lenght to compute the radius
CoordType N(0,0,0);
if((vLTn*v0pn)>limitCos) { N+=vLTn; r += Distance(m.vert[vL].P(),v0p)+Distance(m.vert[vT].P(),v0p); rc++; }
if((vTRn*v0pn)>limitCos) { N+=vTRn; r += Distance(m.vert[vT].P(),v0p)+Distance(m.vert[vR].P(),v0p); rc++; }
if((vRBn*v0pn)>limitCos) { N+=vRBn; r += Distance(m.vert[vR].P(),v0p)+Distance(m.vert[vB].P(),v0p); rc++; }
if((vBLn*v0pn)>limitCos) { N+=vBLn; r += Distance(m.vert[vB].P(),v0p)+Distance(m.vert[vL].P(),v0p); rc++; }
m.vert[v0].N()=-N;
if(tri::HasPerVertexRadius(m)) m.vert[v0].R() = r/(rc*2.0f);
// Isolated points has null normal. Delete them please.
if(m.vert[v0].N() == CoordType(0,0,0)) Allocator<OpenMeshType>::DeleteVertex(m,m.vert[v0]);
}
}
}
else
// eliminate high angle triangles
{
if(importparams.flipfaces)
tri::Clean<OpenMeshType>::FlipMesh(m);
if(importparams.anglecull)
{
if(cb) cb(85,"PTX Mesh Loading - remove steep faces");
tri::UpdateNormal<OpenMeshType>::PerFaceNormalized(m);
for(FaceIterator fi = m.face.begin(); fi != m.face.end(); fi++)
if(!(*fi).IsD())
{
CoordType raggio = -((*fi).P(0) + (*fi).P(1) + (*fi).P(2)) / 3.0;
raggio.Normalize();
if((raggio.dot((*fi).N())) < limitCos)
Allocator<OpenMeshType>::DeleteFace(m,*fi);
}
// deleting unreferenced vertices only if we are interested in faces...
tri::Clean<OpenMeshType>::RemoveUnreferencedVertex(m);
}
}
Matrix44x tr; tr.Import(currtrasf);
tri::UpdatePosition<OpenMeshType>::Matrix(m,currtrasf,true);
tri::Allocator<OpenMeshType>::CompactVertexVector(m);
tri::UpdateBounding<OpenMeshType>::Box(m);
if(cb) cb(100,"PTX Mesh Loading finished!");
return true;
}
}; // end class
} // end Namespace tri
} // end Namespace io
} // end Namespace vcg
#endif