You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
830 lines
19 KiB
830 lines
19 KiB
#include <stdio.h> |
|
#include <vector> |
|
#include<vcg/math/base.h> |
|
#include<vcg/space/point3.h> |
|
#include<vcg/space/point4.h> |
|
#include<vcg/space/color4.h> |
|
#include<vcg/math/matrix44.h> |
|
|
|
#include <vcg/simplex/vertex/base.h> |
|
#include <vcg/simplex/vertex/component.h> |
|
#include <vcg/simplex/face/base.h> |
|
#include <vcg/simplex/face/component.h> |
|
#include <vcg/simplex/face/component_rt.h> |
|
|
|
#include<vcg/complex/complex.h> |
|
#include<vcg/complex/algorithms/create/platonic.h> |
|
#include<vcg/complex/algorithms/update/flag.h> |
|
#include<vcg/complex/algorithms/update/normal.h> |
|
#include<vcg/complex/algorithms/update/color.h> |
|
#include<vcg/complex/algorithms/clean.h> |
|
|
|
#include<wrap/io_trimesh/import_ply.h> |
|
#include<wrap/io_trimesh/export_ply.h> |
|
|
|
using namespace vcg; |
|
|
|
class MyEdge; |
|
class MyFaceC; |
|
class MyFace; |
|
class MyVertexC : public VertexSimp2<MyVertexC,MyEdge,MyFaceC,vert::Coord3f,vert::Color4b,vert::Qualityf,vert::Normal3f,vert::BitFlags> {}; |
|
class MyFaceC : public FaceSimp2< MyVertexC,MyEdge,MyFaceC,face::VertexRef, face::Normal3f,face::BitFlags> {}; |
|
class MyMeshC : public tri::TriMesh< std::vector<MyVertexC>, std::vector<MyFaceC> > {}; |
|
|
|
class MyVertex : public VertexSimp2<MyVertex,MyEdge,MyFace,vert::Coord3f,vert::Normal3f,vert::BitFlags> {}; |
|
class MyFace : public FaceSimp2< MyVertex,MyEdge,MyFace,face::VertexRef, face::Normal3f,face::BitFlags> {}; |
|
class MyMesh : public tri::TriMesh< std::vector<MyVertex>, std::vector<MyFace> > {}; |
|
|
|
using namespace std; |
|
using namespace tri; |
|
|
|
/* |
|
class MyEdge; |
|
class MyFace; |
|
class MyEdgeC; |
|
class MyFaceC; |
|
|
|
class MyVertexC:public VertexVCVN<float,MyEdgeC,MyFace>{}; |
|
class MyFaceC :public FaceFN<MyVertexC,MyEdgeC,MyFaceC>{}; |
|
class MyMeshC: public tri::TriMesh< std::vector<MyVertexC>, std::vector<MyFaceC > >{}; |
|
|
|
class MyVertex:public VertexVN<float,MyEdge,MyFace>{}; |
|
class MyFace :public FaceFN<MyVertex,MyEdge,MyFace>{}; |
|
class MyMesh: public tri::TriMesh< std::vector<MyVertex>, std::vector<MyFace > >{}; |
|
*/ |
|
|
|
//------------------------------------------------------- |
|
|
|
int nummeshes; // number of meshes extracted so far |
|
MyMesh currentmesh; // current mesh, read from stream and saved one completed |
|
MyMeshC currentmeshC; // current mesh, read from stream and saved one completed |
|
Matrix44f currtrasf; |
|
float angle; // angle treshold for face deletion |
|
int singlemap; // single map mode, which map is to be saved. if -1 then all map are saved |
|
int frommap; // skip all maps BEFORE this index |
|
int tomap; // skip all maps AFTER this index |
|
bool savecolor; // if has color, save it on 3dmesh |
|
bool hascolor; // true if the current mesh has color |
|
bool saveall; // all elements are keeped (even invalids) |
|
bool flipfaces; // flip all faces |
|
int todump; |
|
bool dumpit; |
|
bool unpack; |
|
bool onlypoints; // store only points |
|
bool switchside; // inverse triangulation order (swaping row->cols) |
|
|
|
|
|
|
|
|
|
// read the current mesh from the stream |
|
int readmesh(FILE* fp) |
|
{ |
|
int colnum; |
|
int rownum; |
|
int trinum; |
|
int numtokens; |
|
int rit,cit; |
|
char linebuf[256]; |
|
int ii; |
|
float xx,yy,zz; // position |
|
float rr,gg,bb; // color |
|
float rf; // reflectance |
|
MyMesh::FaceIterator fi; |
|
MyMesh::VertexIterator vi; |
|
MyMeshC::FaceIterator fiC; |
|
MyMeshC::VertexIterator viC; |
|
|
|
// cleaning mesh |
|
currentmesh.Clear(); |
|
currentmeshC.Clear(); |
|
|
|
// getting mesh size; |
|
fscanf(fp,"%i\n",&colnum); |
|
fscanf(fp,"%i\n",&rownum); |
|
|
|
// initial 4 lines [still don't know what is this :) :)] |
|
fscanf(fp,"%f %f %f\n", &xx, &yy, &zz); |
|
fscanf(fp,"%f %f %f\n", &xx, &yy, &zz); |
|
fscanf(fp,"%f %f %f\n", &xx, &yy, &zz); |
|
fscanf(fp,"%f %f %f\n", &xx, &yy, &zz); |
|
|
|
// now the transformation matrix |
|
fscanf(fp,"%f %f %f %f\n", &(currtrasf.ElementAt(0,0)), &(currtrasf.ElementAt(0,1)), &(currtrasf.ElementAt(0,2)), &(currtrasf.ElementAt(0,3))); |
|
fscanf(fp,"%f %f %f %f\n", &(currtrasf.ElementAt(1,0)), &(currtrasf.ElementAt(1,1)), &(currtrasf.ElementAt(1,2)), &(currtrasf.ElementAt(1,3))); |
|
fscanf(fp,"%f %f %f %f\n", &(currtrasf.ElementAt(2,0)), &(currtrasf.ElementAt(2,1)), &(currtrasf.ElementAt(2,2)), &(currtrasf.ElementAt(2,3))); |
|
fscanf(fp,"%f %f %f %f\n", &(currtrasf.ElementAt(3,0)), &(currtrasf.ElementAt(3,1)), &(currtrasf.ElementAt(3,2)), &(currtrasf.ElementAt(3,3))); |
|
|
|
// 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') |
|
fread(&(linebuf[ii++]),1,1,fp); |
|
linebuf[ii-1] = '\0'; // terminate the string |
|
|
|
numtokens=1; |
|
for(ii=0; ii<strlen(linebuf); ii++) |
|
{ |
|
if(linebuf[ii] == ' ') |
|
numtokens++; |
|
} |
|
|
|
if(numtokens == 4) |
|
hascolor = false; |
|
else if(numtokens == 7) |
|
hascolor = true; |
|
else |
|
return -1; |
|
|
|
// allocate all points |
|
printf("\n %i x %i \n", rownum, colnum); |
|
printf(" expect V %i F %i",(rownum*colnum),((rownum-1)*(colnum-1)*2)); |
|
|
|
if(hascolor && savecolor) |
|
{ |
|
viC = Allocator<MyMeshC>::AddVertices(currentmeshC,(rownum*colnum)); |
|
} |
|
else |
|
{ |
|
vi = Allocator<MyMesh>::AddVertices(currentmesh,(rownum*colnum)); |
|
} |
|
|
|
// 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); |
|
} |
|
|
|
//addthefirstpoint |
|
if(hascolor && savecolor) |
|
{ |
|
(*viC).P()[0]=xx; |
|
(*viC).P()[1]=yy; |
|
(*viC).P()[2]=zz; |
|
(*viC).Q()=rf; |
|
(*viC).C()[0]=rr; |
|
(*viC).C()[1]=gg; |
|
(*viC).C()[2]=bb; |
|
viC++; |
|
} |
|
else |
|
{ |
|
(*vi).P()[0]=xx; |
|
(*vi).P()[1]=yy; |
|
(*vi).P()[2]=zz; |
|
vi++; |
|
} |
|
|
|
// now for each line until end of mesh (row*col)-1 |
|
for(ii=0; ii<((rownum*colnum)-1); ii++) |
|
{ |
|
// 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 |
|
if(hascolor && savecolor) |
|
{ |
|
(*viC).P()[0]=xx; |
|
(*viC).P()[1]=yy; |
|
(*viC).P()[2]=zz; |
|
(*viC).Q()=rf; |
|
(*viC).C()[0]=rr; |
|
(*viC).C()[1]=gg; |
|
(*viC).C()[2]=bb; |
|
viC++; |
|
} |
|
else |
|
{ |
|
(*vi).P()[0]=xx; |
|
(*vi).P()[1]=yy; |
|
(*vi).P()[2]=zz; |
|
vi++; |
|
} |
|
|
|
} |
|
|
|
currentmesh.vn = currentmesh.vert.size(); |
|
|
|
|
|
if(! onlypoints) |
|
{ |
|
|
|
// now i can triangulate |
|
trinum = (rownum-1) * (colnum-1) * 2; |
|
|
|
if(hascolor && savecolor) |
|
{ |
|
fiC= Allocator<MyMeshC>::AddFaces(currentmeshC,trinum); |
|
} |
|
else |
|
{ |
|
fi= Allocator<MyMesh>::AddFaces(currentmesh,trinum); |
|
} |
|
|
|
|
|
currentmesh.fn = 0; |
|
currentmeshC.fn = 0; |
|
int v0i,v1i,v2i; |
|
for(rit=0; rit<rownum-1; rit++) |
|
for(cit=0; cit<colnum-1; cit++) |
|
if(hascolor && savecolor) |
|
{ |
|
|
|
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 |
|
(*fiC).V(2) = &(currentmeshC.vert[v0i]); |
|
(*fiC).V(1) = &(currentmeshC.vert[v1i]); |
|
(*fiC).V(0) = &(currentmeshC.vert[v2i]); |
|
|
|
if(flipfaces) |
|
{ |
|
(*fiC).V(2) = &(currentmeshC.vert[v1i]); |
|
(*fiC).V(1) = &(currentmeshC.vert[v0i]); |
|
} |
|
|
|
currentmeshC.fn++; |
|
fiC++; |
|
|
|
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 |
|
(*fiC).V(2) = &(currentmeshC.vert[v0i]); |
|
(*fiC).V(1) = &(currentmeshC.vert[v1i]); |
|
(*fiC).V(0) = &(currentmeshC.vert[v2i]); |
|
|
|
if(flipfaces) |
|
{ |
|
(*fiC).V(2) = &(currentmeshC.vert[v1i]); |
|
(*fiC).V(1) = &(currentmeshC.vert[v0i]); |
|
} |
|
|
|
currentmeshC.fn++; |
|
fiC++; |
|
} |
|
else |
|
{ |
|
// upper tri |
|
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); |
|
} |
|
|
|
(*fi).V(2) = &(currentmesh.vert[v0i]); |
|
(*fi).V(1) = &(currentmesh.vert[v1i]); |
|
(*fi).V(0) = &(currentmesh.vert[v2i]); |
|
|
|
if(flipfaces) |
|
{ |
|
(*fi).V(2) = &(currentmesh.vert[v1i]); |
|
(*fi).V(1) = &(currentmesh.vert[v0i]); |
|
} |
|
|
|
currentmesh.fn++; |
|
fi++; |
|
|
|
// lower tri |
|
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); |
|
} |
|
|
|
(*fi).V(2) = &(currentmesh.vert[v0i]); |
|
(*fi).V(1) = &(currentmesh.vert[v1i]); |
|
(*fi).V(0) = &(currentmesh.vert[v2i]); |
|
|
|
if(flipfaces) |
|
{ |
|
(*fi).V(2) = &(currentmesh.vert[v1i]); |
|
(*fi).V(1) = &(currentmesh.vert[v0i]); |
|
} |
|
|
|
currentmesh.fn++; |
|
fi++; |
|
} |
|
|
|
|
|
if(hascolor && savecolor) |
|
printf("\nV: %8i F: %8i \n", currentmeshC.vn, currentmeshC.fn); |
|
else |
|
printf("\nV: %8i F: %8i \n", currentmesh.vn, currentmesh.fn); |
|
} |
|
|
|
|
|
if(! saveall) |
|
{ |
|
printf("deleting unsampled points \n"); |
|
// now i delete all points in (0,0,0) that are unsampled points |
|
if(hascolor && savecolor) |
|
for(viC = currentmeshC.vert.begin(); viC != currentmeshC.vert.end(); viC++) |
|
{ |
|
if((*viC).P() == Point3f(0.0, 0.0, 0.0)) |
|
{ |
|
(*viC).SetD(); |
|
currentmeshC.vn--; |
|
} |
|
} |
|
else |
|
for(vi = currentmesh.vert.begin(); vi != currentmesh.vert.end(); vi++) |
|
{ |
|
if((*vi).P() == Point3f(0.0, 0.0, 0.0)) |
|
{ |
|
(*vi).SetD(); |
|
currentmesh.vn--; |
|
} |
|
} |
|
} |
|
|
|
|
|
if(! onlypoints) |
|
{ |
|
|
|
if(! saveall) |
|
{ |
|
printf("deleting invalid faces \n"); |
|
// and then i delete all faces with null vertices |
|
if(hascolor && savecolor) |
|
for(fiC = currentmeshC.face.begin(); fiC != currentmeshC.face.end(); fiC++) |
|
{ |
|
if( ((*fiC).V(0)->IsD()) || ((*fiC).V(1)->IsD()) || ((*fiC).V(2)->IsD()) ) |
|
{ |
|
(*fiC).SetD(); |
|
currentmeshC.fn--; |
|
} |
|
} |
|
else |
|
for(fi = currentmesh.face.begin(); fi != currentmesh.face.end(); fi++) |
|
{ |
|
if( ((*fi).V(0)->IsD()) || ((*fi).V(1)->IsD()) || ((*fi).V(2)->IsD()) ) |
|
{ |
|
(*fi).SetD(); |
|
currentmesh.fn--; |
|
} |
|
} |
|
} |
|
|
|
if(hascolor && savecolor) |
|
printf("V: %8i F: %8i \n", currentmeshC.vn, currentmeshC.fn); |
|
else |
|
printf("V: %8i F: %8i \n", currentmesh.vn, currentmesh.fn); |
|
|
|
|
|
// eliminate high angle triangles |
|
if((angle != 90)&&(!saveall)) |
|
{ |
|
printf(" culling by angle \n"); |
|
float limit = cos( angle*3.14159265358979323846/180.0 ); |
|
Point3f raggio; |
|
|
|
if(hascolor && savecolor) |
|
{ |
|
tri::UpdateNormals<MyMeshC>::PerFaceNormalized(currentmeshC); |
|
for(fiC = currentmeshC.face.begin(); fiC != currentmeshC.face.end(); fiC++) |
|
if(!(*fiC).IsD()) |
|
{ |
|
raggio = -((*fiC).V(0)->P() + (*fiC).V(1)->P() + (*fiC).V(2)->P()) / 3.0; |
|
raggio.Normalize(); |
|
if(((*fiC).N() * raggio) < limit) |
|
{ |
|
(*fiC).SetD(); |
|
currentmeshC.fn--; |
|
} |
|
} |
|
} |
|
else |
|
{ |
|
vcg::tri::UpdateNormals<MyMesh>::PerFaceNormalized(currentmesh); |
|
for(fi = currentmesh.face.begin(); fi != currentmesh.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(); |
|
currentmesh.fn--; |
|
} |
|
} |
|
} |
|
|
|
} |
|
} |
|
|
|
currtrasf.transposeInPlace(); |
|
|
|
// apply tranformation |
|
if(hascolor && savecolor) |
|
{ |
|
for(viC = currentmeshC.vert.begin(); viC != currentmeshC.vert.end(); viC++) |
|
if(!(*viC).IsD()) |
|
{ |
|
(*viC).P() = currtrasf * (*viC).P(); |
|
} |
|
} |
|
else |
|
{ |
|
for(vi = currentmesh.vert.begin(); vi != currentmesh.vert.end(); vi++) |
|
if(!(*vi).IsD()) |
|
{ |
|
(*vi).P() = currtrasf * (*vi).P(); |
|
} |
|
} |
|
|
|
if(hascolor && savecolor) |
|
{ |
|
int dup = tri::Clean<MyMeshC>::RemoveDuplicateVertex(currentmeshC); |
|
if(! onlypoints) |
|
int unref = tri::Clean<MyMeshC>::RemoveUnreferencedVertex(currentmeshC); |
|
} |
|
else |
|
{ |
|
int dup = tri::Clean<MyMesh>::RemoveDuplicateVertex(currentmesh); |
|
if(! onlypoints) |
|
int unref = tri::Clean<MyMesh>::RemoveUnreferencedVertex(currentmesh); |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
// save each mesh in a separate file |
|
void dounpack(FILE* fp) |
|
{ |
|
FILE* outf; |
|
char namef[128]; |
|
int rnum; |
|
char linebuf[256]; |
|
int ii; |
|
bool trovato; |
|
|
|
rnum=1; |
|
|
|
trovato = false; |
|
|
|
// search for the first integer |
|
while(!trovato) |
|
{ |
|
// 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') |
|
fread(&(linebuf[ii++]),1,1,fp); |
|
linebuf[ii-1] = '\0'; // terminate the string |
|
|
|
//check the string |
|
if(strchr(linebuf,' ') == NULL) |
|
trovato = true; |
|
} |
|
|
|
while(!feof(fp)) |
|
{ |
|
|
|
sprintf(namef,"range%03i.ptx",rnum++); |
|
outf = fopen(namef,"w"); |
|
|
|
// write first integer |
|
fprintf(outf,"%s\n",linebuf); |
|
|
|
// read and write next int |
|
ii=0; |
|
fread(&(linebuf[ii++]),1,1,fp); |
|
while(linebuf[ii-1] != '\n') |
|
fread(&(linebuf[ii++]),1,1,fp); |
|
linebuf[ii-1] = '\0'; // terminate the string |
|
fprintf(outf,"%s\n",linebuf); |
|
|
|
// search for the next integer |
|
while(!trovato) |
|
{ |
|
// 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') |
|
fread(&(linebuf[ii++]),1,1,fp); |
|
linebuf[ii-1] = '\0'; // terminate the string |
|
|
|
//if not an integer then write it, otherwise close and remember for next step |
|
if(strchr(linebuf,' ') == NULL) |
|
trovato = true; |
|
else |
|
fprintf(outf,"%s\n",linebuf); |
|
} |
|
|
|
fclose(outf); |
|
} |
|
|
|
} |
|
|
|
// skip a mesh |
|
int skipmesh(FILE* fp) |
|
{ |
|
int colnum; |
|
int rownum; |
|
int skiplines; |
|
char linebuf; |
|
|
|
if(feof(fp)) |
|
return -1; |
|
|
|
// getting mesh size; |
|
fscanf(fp,"%i\n",&colnum); |
|
fscanf(fp,"%i\n",&rownum); |
|
|
|
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 -1; |
|
|
|
skiplines = (colnum * rownum) + 8; // have to skip (col * row) lines plus 8 lines for the header |
|
for(int ii=0; ii<skiplines; ii++) |
|
{ |
|
fread(&linebuf,1,1,fp); |
|
while(linebuf != '\n') |
|
fread(&linebuf,1,1,fp); |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
|
|
void parseparams(int argn, char** argvect) |
|
{ |
|
int pit; |
|
|
|
for(pit = 2; pit<argn; pit++) |
|
{ |
|
if(argvect[pit][0] != '-') // invalid param |
|
{ |
|
printf("invalid parameter\n"); |
|
} |
|
else // valid param |
|
{ |
|
if(argvect[pit][1] == 'a') // angle |
|
{ |
|
angle = atof(&(argvect[pit][2])); |
|
printf("cutoff angle = %f \n",angle); |
|
} |
|
if(argvect[pit][1] == 'm') // single map |
|
{ |
|
singlemap = atoi(&(argvect[pit][2])); |
|
frommap = 0; |
|
tomap = singlemap; |
|
printf("single map # %i \n",singlemap); |
|
} |
|
if(argvect[pit][1] == 'f') // from map |
|
{ |
|
frommap = atoi(&(argvect[pit][2])); |
|
singlemap = -1; |
|
printf("start from map # %i \n",frommap); |
|
} |
|
if(argvect[pit][1] == 't') // from map |
|
{ |
|
tomap = atoi(&(argvect[pit][2])); |
|
singlemap = -1; |
|
printf("end with map # %i \n",tomap); |
|
} |
|
if(argvect[pit][1] == 'd') // dump to file |
|
{ |
|
todump = atoi(&(argvect[pit][2])); |
|
dumpit = true; |
|
printf("dumping # %i chars\n",todump); |
|
} |
|
if(argvect[pit][1] == 'u') // unpack the file in different |
|
{ |
|
unpack = true; |
|
printf("UNPACKING \n"); |
|
} |
|
if(argvect[pit][1] == 'c') // save color if present |
|
{ |
|
savecolor = true; |
|
printf("saving color \n"); |
|
} |
|
if(argvect[pit][1] == 'k') // keep all |
|
{ |
|
saveall = true; |
|
printf("keeping all elements \n"); |
|
} |
|
if(argvect[pit][1] == 'f') // flip all tris |
|
{ |
|
flipfaces = true; |
|
printf("keeping all elements \n"); |
|
} |
|
if(argvect[pit][1] == 'p') // points only, do not triangulate |
|
{ |
|
onlypoints = true; |
|
printf("points only, do not triangulate \n"); |
|
} |
|
if(argvect[pit][1] == 'r') // points only, do not triangulate |
|
{ |
|
switchside = true; |
|
printf("swapped triangulation \n"); |
|
} |
|
|
|
|
|
} |
|
} |
|
|
|
} |
|
|
|
void printhelp() |
|
{ |
|
printf("-------------------------------------------------------------\n"); |
|
printf("multiple PLY files will be extracted from the PTX \n"); |
|
printf("\n"); |
|
printf("USAGE: ptx2ply filename.ptx [options]"); |
|
printf("\n"); |
|
printf("each map contained in the file will be saved in a PLY \n"); |
|
printf("\n"); |
|
printf("-aAA angle threshold for face elimination, glazing faces with\n"); |
|
printf(" angle between normal and viewdirection > AA are removed \n"); |
|
printf(" default is no cut. \n"); |
|
printf(" beware! this only works for range maps that still need \n"); |
|
printf(" to be tranformed in the final reference system \n"); |
|
printf(" (in this case the viewpoint is the origin) \n"); |
|
printf("\n"); |
|
printf("-c save color if present \n"); |
|
printf("\n"); |
|
printf("-mNN extract just the map NN, skip all the rest of the file \n"); |
|
printf("\n"); |
|
printf("-fNN extract maps starting FROM index NN \n"); |
|
printf("\n"); |
|
printf("-tNN extract maps UP TO index NN \n"); |
|
printf("\n"); |
|
printf("-u unpack the file generating a ptx for each map \n"); |
|
printf("\n"); |
|
printf("-k keep all elements (no points/tris discarded) \n"); |
|
printf(" only useful for debug \n"); |
|
printf("\n"); |
|
printf("-f flip all faces \n"); |
|
printf("\n"); |
|
printf("-p store points only \n"); |
|
printf("\n"); |
|
printf("-r during triangulation, swap rows->columns \n"); |
|
printf("\n"); |
|
printf("MESH INDICES STARTS FROM 1 \n"); |
|
printf("parameters -f and -t can be used together to specify an index\n"); |
|
printf("range to be processed. \n"); |
|
printf("-------------------------------------------------------------\n"); |
|
exit(0); |
|
} |
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////// |
|
////////////////////////////////////////////////////////////////////////////// |
|
////////////////////////////////////////////////////////////////////////////// |
|
////////////////////////////////////////////////////////////////////////////// |
|
int main(int argc, char *argv[]) |
|
{ |
|
FILE *fp; |
|
char filename[256]; |
|
char modelname[128]; |
|
|
|
|
|
//--------------------------------------------------------------- |
|
printf("PTX to PLY conversion\n"); |
|
//--------------------------------------------------------------- |
|
|
|
//-- init params |
|
nummeshes = 1; |
|
currentmesh.Clear(); |
|
angle = 90.0; |
|
singlemap = -1; |
|
frommap = 0; |
|
tomap = 99999; |
|
todump = 1024; |
|
dumpit = false; |
|
unpack = false; |
|
savecolor = false; |
|
saveall = false; |
|
flipfaces = false; |
|
onlypoints = false; |
|
switchside = false; |
|
|
|
|
|
if(argc < 2) |
|
printhelp(); |
|
|
|
|
|
//-- |
|
parseparams(argc, argv); |
|
|
|
strcpy(modelname,argv[1]); |
|
modelname[strlen(argv[1])-4] = '\0'; |
|
|
|
fp = fopen(argv[1],"r"); |
|
|
|
if(unpack) |
|
dounpack(fp); |
|
|
|
while((!feof(fp)) && (nummeshes <= tomap)) |
|
{ |
|
printf("mesh %3i ",nummeshes); |
|
|
|
if((nummeshes >= frommap) && (nummeshes <= tomap) && ((singlemap == -1) || (singlemap == nummeshes))) |
|
{ |
|
if(dumpit) |
|
{ |
|
FILE* outf; |
|
char cbuf; |
|
|
|
outf = fopen("dump.txt","w"); |
|
|
|
for(int dit=0; dit<todump; dit++) |
|
{ |
|
fread(&cbuf,1,1,fp); |
|
fwrite(&cbuf,1,1,outf); |
|
} |
|
|
|
fclose(outf); |
|
fclose(fp); |
|
exit(0); |
|
} |
|
|
|
printf("reading "); |
|
readmesh(fp); |
|
|
|
sprintf(filename,"%s_%03i.ply",modelname,nummeshes); |
|
if(!feof(fp)) |
|
{ |
|
if(hascolor && savecolor) |
|
{ |
|
int plyMask=tri::io::Mask::IOM_VERTCOLOR | tri::io::Mask::IOM_VERTQUALITY; |
|
tri::io::ExporterPLY<MyMeshC>::Save(currentmeshC,filename, plyMask); |
|
} |
|
else |
|
tri::io::ExporterPLY<MyMesh>::Save(currentmesh,filename); |
|
} |
|
|
|
printf("ok! \n"); |
|
|
|
} |
|
else |
|
{ |
|
printf("skipping "); |
|
skipmesh(fp); |
|
printf("ok! \n"); |
|
} |
|
|
|
nummeshes++; |
|
} |
|
|
|
fclose(fp); |
|
|
|
return 0; |
|
} |
|
|
|
|