871 lines
22 KiB
C++
871 lines
22 KiB
C++
/****************************************************************************
|
|
* VCGLib o o *
|
|
* Visual and Computer Graphics Library o o *
|
|
* _ O _ *
|
|
* Copyright(C) 2005 \/)\/ *
|
|
* 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. *
|
|
* *
|
|
****************************************************************************/
|
|
/****************************************************************************
|
|
History
|
|
|
|
$Log: not supported by cvs2svn $
|
|
Revision 1.41 2007/03/08 22:49:35 cignoni
|
|
Changed the include order and the order in which cleaning filters are applied.
|
|
|
|
Revision 1.40 2006/05/16 21:55:28 cignoni
|
|
Updated to the new remove zero area syntax
|
|
|
|
Revision 1.39 2006/03/29 09:27:07 cignoni
|
|
Added managemnt of non critical errors
|
|
|
|
Revision 1.38 2006/03/29 08:17:56 corsini
|
|
fix typo
|
|
|
|
Revision 1.37 2006/03/27 07:15:59 cignoni
|
|
Added LoadMask
|
|
|
|
Revision 1.36 2006/02/28 14:54:10 corsini
|
|
Fix load mask initialization
|
|
|
|
Revision 1.35 2006/02/09 16:12:27 corsini
|
|
Add normal, color, texture information
|
|
|
|
Revision 1.34 2006/02/06 12:59:12 corsini
|
|
Fix mesh info structure initialization
|
|
|
|
Revision 1.33 2006/01/27 14:18:07 corsini
|
|
fix boolean entry type
|
|
|
|
Revision 1.32 2006/01/27 14:17:10 corsini
|
|
remove junk code
|
|
|
|
Revision 1.31 2006/01/27 13:35:51 corsini
|
|
fix signed/unsigned mismatch
|
|
|
|
Revision 1.30 2006/01/26 16:29:21 corsini
|
|
fix typo
|
|
|
|
Revision 1.29 2005/12/29 12:27:35 cignoni
|
|
Splitted IsComplexManifold in IsTwoManifoldFace and IsTwoManifoldVertex
|
|
|
|
Revision 1.28 2005/12/21 14:11:59 corsini
|
|
Out the number of self intersection
|
|
|
|
Revision 1.27 2005/12/21 13:26:58 corsini
|
|
Re-add save xml feature
|
|
|
|
Revision 1.26 2005/12/21 13:10:10 corsini
|
|
Move duplicated vertices routine
|
|
Modify genus computation call
|
|
|
|
Revision 1.25 2005/12/20 14:44:10 corsini
|
|
Modify html table
|
|
|
|
Revision 1.24 2005/12/20 13:29:41 corsini
|
|
Remove unuseful Clear function
|
|
|
|
Revision 1.23 2005/12/19 15:00:53 corsini
|
|
Disable xml output temporarily
|
|
|
|
Revision 1.22 2005/12/19 11:35:13 corsini
|
|
Add html output support
|
|
|
|
Revision 1.21 2005/12/16 11:16:36 corsini
|
|
Add manifold check to some properties
|
|
|
|
Revision 1.20 2005/12/15 11:20:00 corsini
|
|
Add vertex-face topology
|
|
|
|
Revision 1.19 2005/12/14 14:05:37 corsini
|
|
Adjust comments
|
|
|
|
Revision 1.18 2005/12/14 12:15:37 corsini
|
|
Re-add clean mesh saving feature
|
|
|
|
Revision 1.17 2005/12/13 15:46:30 corsini
|
|
Restructuring code
|
|
|
|
Revision 1.16 2005/12/12 12:09:08 cignoni
|
|
Changed names of clean function and tested inertia.h
|
|
|
|
Revision 1.15 2005/12/12 11:29:21 corsini
|
|
Minor changes
|
|
|
|
Revision 1.14 2005/12/12 10:48:16 corsini
|
|
Fix indentation
|
|
|
|
Revision 1.13 2005/11/17 00:42:03 cignoni
|
|
Changed include order
|
|
removed clean::initialize
|
|
|
|
Revision 1.12 2005/11/16 16:45:51 rita_borgo
|
|
Minor changes
|
|
|
|
Revision 1.11 2005/11/16 15:59:46 cignoni
|
|
Changed name of the component from <Flag> to <BitFlags>
|
|
|
|
Revision 1.10 2005/11/14 09:21:07 cignoni
|
|
Heavily restructured the code of Trimeshinfo.
|
|
Now divided the collecting part from the reporting one (xml and ascii)
|
|
|
|
Revision 1.9 2005/11/04 15:37:57 rita_borgo
|
|
Removed Debug option
|
|
|
|
Revision 1.8 2005/10/11 16:03:40 rita_borgo
|
|
Moved all the main functions inside clean.h
|
|
|
|
Revision 1.7 2005/09/30 15:48:46 rita_borgo
|
|
Fixed manifold Test
|
|
|
|
Revision 1.6 2005/09/30 14:13:01 rita_borgo
|
|
Problem: Text not aligned
|
|
|
|
Revision 1.5 2005/09/30 13:29:40 rita_borgo
|
|
Fixed Manifold Test
|
|
|
|
Revision 1.4 2005/09/29 14:48:15 rita_borgo
|
|
Fixed code related to creation of the XML file
|
|
|
|
Revision 1.3 2005/09/28 13:57:09 rita_borgo
|
|
Fixed some printout not alligned
|
|
|
|
Revision 1.2 2005/09/28 10:46:04 rita_borgo
|
|
Added possibility of saving File in OFF format
|
|
|
|
Revision 1.1 2005/09/20 10:15:27 rita_borgo
|
|
Changed file name to uniform with other solution projects,
|
|
before was main.cpp
|
|
|
|
Revision 1.8 2005/02/15 12:26:06 rita_borgo
|
|
Minor changes to self-intersection
|
|
|
|
Revision 1.7 2005/02/07 15:44:31 rita_borgo
|
|
Fixed Color and Volume
|
|
|
|
Revision 1.6 2005/02/01 17:37:53 rita_borgo
|
|
Fixed Volume and Color
|
|
|
|
Revision 1.5 2005/01/18 16:33:12 rita_borgo
|
|
Added OFF file Option
|
|
|
|
Revision 1.4 2005/01/17 18:19:00 rita_borgo
|
|
Added new routines.
|
|
Self-intersection first release
|
|
|
|
Revision 1.2 2005/01/03 16:13:09 rita_borgo
|
|
Added Standard comments
|
|
|
|
****************************************************************************/
|
|
|
|
// Standard headers
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <vector>
|
|
#include <string>
|
|
#include <stack>
|
|
|
|
using namespace std;
|
|
|
|
// VCG headers
|
|
#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/complex/complex.h>
|
|
#include <vcg/complex/algorithms/update/topology.h>
|
|
#include <vcg/complex/algorithms/update/edges.h>
|
|
#include <vcg/complex/algorithms/update/bounding.h>
|
|
#include <vcg/complex/algorithms/update/flag.h>
|
|
#include <vcg/complex/algorithms/clean.h>
|
|
#include <vcg/space/intersection/triangle_triangle3.h>
|
|
|
|
#include <vcg/math/histogram.h>
|
|
#include <wrap/io_trimesh/import.h>
|
|
#include <wrap/io_trimesh/export.h>
|
|
|
|
#include <vcg/simplex/face/pos.h>
|
|
#include <vcg/complex/algorithms/inertia.h>
|
|
|
|
#include "XMLTree.h"
|
|
|
|
#include <vcg/space/index/grid_static_ptr.h>
|
|
#include "defs.h"
|
|
|
|
using namespace vcg;
|
|
|
|
|
|
class CVertex;
|
|
class CFace;
|
|
|
|
struct MyTypes: public UsedTypes< Use<CVertex>::AsVertexType,Use<CFace>::AsFaceType>{};
|
|
|
|
class CVertex : public Vertex< MyTypes, vertex::VFAdj, vertex::Coord3f,vertex::BitFlags, vertex::Normal3f > {};
|
|
class CFace : public Face< MyTypes, face::FFAdj, face::VFAdj, face::VertexRef, face::Normal3f, face::BitFlags, face::Mark > {};
|
|
class CMesh : public vcg::tri::TriMesh< vector<CVertex>, vector<CFace> > {};
|
|
|
|
typedef CMesh::VertexPointer VertexPointer;
|
|
typedef CMesh::VertexIterator VertexIterator;
|
|
typedef Point3<CMesh::ScalarType> Point3x;
|
|
typedef vector<Point3x> Hole;
|
|
|
|
typedef CMesh::VertexPointer VertexPointer;
|
|
typedef CMesh::VertexIterator VertexIterator;
|
|
typedef CMesh::FaceContainer FaceContainer;
|
|
typedef CMesh::ScalarType ScalarType;
|
|
|
|
struct MeshInfo
|
|
{
|
|
string FileName;
|
|
bool hasVNormal;
|
|
bool hasFNormal;
|
|
bool hasVColor;
|
|
bool hasFColor;
|
|
bool hasTexture;
|
|
int vn,fn;
|
|
bool VManifold;
|
|
bool FManifold;
|
|
int count_e,boundary_e,count_fd,count_uv,numholes;
|
|
int BEdges;
|
|
float Volume;
|
|
int numcomponents,Genus;
|
|
bool Regular,Semiregular;
|
|
bool Orientable,Oriented;
|
|
int dv;
|
|
bool SelfIntersect;
|
|
std::vector<CMesh::FaceType *> intersections;
|
|
};
|
|
|
|
|
|
static const int HTML_LINES = 31;
|
|
static const char * HTML_TABLE[HTML_LINES]=
|
|
{
|
|
"<html>",
|
|
" <head>",
|
|
" <meta http-equiv=\"content-type\" content=\"text/html; charset=ISO-8859-1\">",
|
|
" <title>description.html</title>",
|
|
" </head>",
|
|
" <body>",
|
|
" <span style=\"font-weight: bold;\"></span>",
|
|
" <h2>TriMeshInfo V.1.2 - Results</h2>",
|
|
" <hr style=\"width: 100%; height: 2px;\"><br>",
|
|
" <table",
|
|
" style=\"width: 100%; text-align: center; margin-left: auto; margin-right: auto;\" ",
|
|
" border=\"1\" cellpadding=\"2\" cellspacing=\"2\">",
|
|
" <tbody>",
|
|
" <tr>",
|
|
" <td>Name</td>",
|
|
" <td>Vertices</td>",
|
|
" <td>Faces</td>",
|
|
" <td>Edges</td>",
|
|
" <td>Holes/<br>Boundaries</td>",
|
|
" <td>Connected<br>Components</td>",
|
|
" <td>Isolated<br>Vertices</td>",
|
|
" <td>Duplicated<br>Vertices</td>",
|
|
" <td>Self<br>Interesection</td>",
|
|
" <td>Manifold</td>",
|
|
" <td>Orientable/<br>Oriented</td>",
|
|
" <td>Genus</td>",
|
|
" </tr>",
|
|
" </tbody>",
|
|
" </table>",
|
|
" </body>",
|
|
"</html>"
|
|
};
|
|
|
|
|
|
int OpenMesh(const char *filename, CMesh &m)
|
|
{
|
|
printf(" Mesh loading...");
|
|
|
|
int mask = 0;
|
|
|
|
tri::io::Importer<CMesh>::LoadMask(filename,mask);
|
|
int err = tri::io::Importer<CMesh>::Open(m, filename);
|
|
|
|
if (err)
|
|
{
|
|
if(tri::io::Importer<CMesh>::ErrorCritical(err))
|
|
{
|
|
printf("\n Error during loading %s: '%s'\n",filename,
|
|
tri::io::Importer<CMesh>::ErrorMsg(err));
|
|
exit(-1);
|
|
}
|
|
else
|
|
{
|
|
printf("\n Non Critical Troubles during loading %s: '%s'\n",filename,
|
|
tri::io::Importer<CMesh>::ErrorMsg(err));
|
|
}
|
|
}
|
|
else
|
|
printf(" done.\n\n");
|
|
|
|
return mask;
|
|
}
|
|
|
|
void initMeshInfo(MeshInfo &mi)
|
|
{
|
|
mi.vn = 0;
|
|
mi.fn = 0;
|
|
mi.hasVColor = false;
|
|
mi.hasFColor = false;
|
|
mi.hasFNormal = false;
|
|
mi.hasVNormal = false;
|
|
mi.hasTexture = false;
|
|
mi.VManifold = false;
|
|
mi.FManifold = false;
|
|
mi.count_e = 0;
|
|
mi.boundary_e = 0;
|
|
mi.count_fd = 0;
|
|
mi.count_uv = 0;
|
|
mi.numholes = 0;
|
|
mi.BEdges = 0;
|
|
mi.Volume = 0;
|
|
mi.numcomponents = 0;
|
|
mi.Genus = 0;
|
|
mi.Regular = false;
|
|
mi.Semiregular = false;
|
|
mi.Orientable = false;
|
|
mi.Oriented = false;
|
|
mi.dv = 0;
|
|
mi.SelfIntersect = false;
|
|
// mi.FileName has a constructor
|
|
// mi.intersections has a constructor
|
|
}
|
|
|
|
void PrintMeshInfo(MeshInfo &mi)
|
|
{
|
|
printf(" *** Mesh information ***\n\n");
|
|
printf(" Mesh: '%s' \n", mi.FileName.c_str());
|
|
printf(" Number of vertices: %d \n", mi.vn);
|
|
printf(" Number of faces: %d \n", mi.fn);
|
|
printf(" Number of edges: %d \n", mi.count_e);
|
|
printf(" Number of internal edges: %d \n", mi.count_e-mi.boundary_e);
|
|
printf(" Number of boundary edges: %i \n", mi.boundary_e);
|
|
printf(" Number of degenerated faces: %d\n", mi.count_fd);
|
|
printf(" Number of unreferenced vertices: %d\n",mi.count_uv);
|
|
printf(" Number of duplicated vertices found: %d\n", mi.dv);
|
|
printf(" Number of holes/boundaries: %d \n", mi.numholes);
|
|
|
|
if (mi.hasVNormal)
|
|
printf(" Has Per-Vertex Normal: YES\n");
|
|
else
|
|
printf(" Has Per-Vertex Normal: NO\n");
|
|
|
|
if (mi.hasFNormal)
|
|
printf(" Has Per-Face Normal: YES\n");
|
|
else
|
|
printf(" Has Per-Face Normal: NO\n");
|
|
|
|
if (mi.hasVColor)
|
|
printf(" Has Per-Vertex Color: YES\n");
|
|
else
|
|
printf(" Has Per-Vertex Color: NO\n");
|
|
|
|
if (mi.hasFColor)
|
|
printf(" Has Per-Face Color: YES\n");
|
|
else
|
|
printf(" Has Per-Face Color: NO\n");
|
|
|
|
if (mi.hasTexture)
|
|
printf(" Has Texture information: YES\n");
|
|
else
|
|
printf(" Has Texture information: NO\n");
|
|
|
|
if ((mi.VManifold && mi.FManifold )&&(mi.Oriented)&&(!mi.numholes))
|
|
printf(" Volume: %f \n", mi.Volume);
|
|
else
|
|
printf(" Volume: UNDEFINED (a closed oriented manifold is required)\n");
|
|
|
|
printf(" Number of connected components: %d\n", mi.numcomponents);
|
|
|
|
// Orientation
|
|
if (!mi.VManifold && mi.FManifold)
|
|
{
|
|
printf(" Orientable Mesh: NO\n");
|
|
printf(" Oriented Mesh: NO\n");
|
|
}
|
|
else
|
|
{
|
|
if (mi.Orientable)
|
|
printf(" Orientable Mesh: YES\n");
|
|
else
|
|
printf(" Orientable Mesh: NO\n");
|
|
|
|
if (mi.Oriented)
|
|
printf(" Oriented Mesh: YES\n");
|
|
else
|
|
printf(" Oriented Mesh: NO\n");
|
|
}
|
|
|
|
// Manifold
|
|
if (mi.VManifold && mi.FManifold )
|
|
printf(" Manifold: YES\n");
|
|
else
|
|
printf(" Manifold: NO\n");
|
|
|
|
// Genus
|
|
if (mi.VManifold && mi.FManifold)
|
|
printf(" Genus: %d \n", mi.Genus);
|
|
else
|
|
printf(" Genus: N/A \n");
|
|
|
|
// Mesh Type
|
|
if (mi.Regular)
|
|
printf(" Mesh Type: REGULAR\n");
|
|
else if (mi.Semiregular)
|
|
printf(" Mesh Type: SEMIREGULAR\n");
|
|
else
|
|
printf(" Mesh Type: IRREGULAR\n");
|
|
|
|
// Further details
|
|
if (mi.SelfIntersect)
|
|
printf(" Self Intersection: %d\n", mi.intersections.size());
|
|
else
|
|
printf(" Self Intersection: NONE.\n");
|
|
}
|
|
|
|
void SaveXMLInfo(MeshInfo &mi)
|
|
{
|
|
XMLTree doc;
|
|
doc.initializeMain();
|
|
|
|
char s[256];
|
|
sprintf(s,"%d",mi.vn);
|
|
doc.addNode(s, VALUE_INTEGER, "Number of Vertices");
|
|
sprintf(s,"%d",mi.fn);
|
|
doc.addNode(s, VALUE_INTEGER, "Number of Faces");
|
|
|
|
if(mi.VManifold && mi.FManifold)
|
|
doc.addNode("false", VALUE_BOOL,"Manifold");
|
|
else
|
|
doc.addNode("true", VALUE_BOOL,"Manifold");
|
|
|
|
sprintf(s,"%d",mi.count_e);
|
|
doc.addNode(s, VALUE_INTEGER,"Number of Edges");
|
|
sprintf(s,"%d",mi.count_fd);
|
|
doc.addNode(s, VALUE_INTEGER,"Number of Degenerated Faces");
|
|
|
|
sprintf(s,"%d",mi.count_uv);
|
|
doc.addNode(s, VALUE_INTEGER,"Number of unreferenced vertices");
|
|
sprintf(s,"%d",mi.numholes);
|
|
doc.addNode(s, VALUE_INTEGER, "Number of Holes");
|
|
sprintf(s,"%d",mi.BEdges);
|
|
doc.addNode(s, VALUE_INTEGER, "Number of Border Edges");
|
|
|
|
if (mi.hasVColor)
|
|
doc.addNode("true", VALUE_BOOL, "Per-Vertex Color Information");
|
|
else
|
|
doc.addNode("false", VALUE_BOOL, "Per-Vertex Color Information");
|
|
|
|
if (mi.hasFColor)
|
|
doc.addNode("true", VALUE_BOOL, "Per-Face Color Information");
|
|
else
|
|
doc.addNode("false", VALUE_BOOL, "Per-Face Color Information");
|
|
|
|
if (mi.hasVNormal)
|
|
doc.addNode("true", VALUE_BOOL, "Per-Vertex Normal");
|
|
else
|
|
doc.addNode("false", VALUE_BOOL, "Per-Vertex Normal");
|
|
|
|
if (mi.hasFNormal)
|
|
doc.addNode("true", VALUE_BOOL, "Per-Face Normal");
|
|
else
|
|
doc.addNode("false", VALUE_BOOL, "Per-Face Normal");
|
|
|
|
if (mi.hasTexture)
|
|
doc.addNode("true", VALUE_BOOL, "Texture Information");
|
|
else
|
|
doc.addNode("false", VALUE_BOOL, "Texture Information");
|
|
|
|
sprintf(s,"%f",mi.Volume);
|
|
doc.addNode(s, VALUE_FLOAT,"Volume");
|
|
sprintf(s,"%d",mi.numcomponents);
|
|
doc.addNode(s, VALUE_INTEGER,"Number of Connected Components");
|
|
sprintf(s,"%d",mi.Genus);
|
|
doc.addNode(s, VALUE_INTEGER,"Genus");
|
|
|
|
if (mi.Regular)
|
|
doc.addNode("REGULAR", VALUE_STRING,"Type of Mesh");
|
|
else if (mi.Semiregular)
|
|
doc.addNode("SEMIREGULAR", VALUE_STRING,"Type of Mesh");
|
|
else
|
|
doc.addNode("IRREGULAR", VALUE_STRING,"Type of Mesh");
|
|
|
|
if (!mi.VManifold && mi.FManifold)
|
|
{
|
|
doc.addNode("NO", VALUE_STRING,"Orientable Mesh");
|
|
doc.addNode("NO", VALUE_STRING,"Oriented Mesh");
|
|
}
|
|
else
|
|
{
|
|
doc.addNode(mi.Orientable?"Yes":"No", VALUE_STRING,"Orientable Mesh");
|
|
doc.addNode(mi.Oriented?"Yes":"No", VALUE_STRING,"Oriented Mesh");
|
|
}
|
|
|
|
sprintf(s,"%d",mi.dv);
|
|
doc.addNode(s, VALUE_INTEGER,"Duplicated Vertices");
|
|
doc.addNode(mi.SelfIntersect?"Yes":"No", VALUE_STRING,"Self Intersection");
|
|
|
|
doc.finalizeMain();
|
|
|
|
// save xml tree
|
|
string filename = mi.FileName;
|
|
|
|
int l = static_cast<int>(filename.size());
|
|
int index = static_cast<int>(filename.find_first_of('.'));
|
|
filename.erase(index, l - index);
|
|
filename.append(".xml");
|
|
|
|
doc.setName(filename.c_str());
|
|
doc.printXMLTree();
|
|
}
|
|
|
|
void SaveMeshInfoHtmlTable(fstream &fout, MeshInfo &mi)
|
|
{
|
|
fout << " <tr>" << std::endl;
|
|
fout << " <td>" << mi.FileName << "</td>" << std::endl;
|
|
fout << " <td>" << mi.vn << "</td>" << std::endl;
|
|
fout << " <td>" << mi.fn << "</td>" << std::endl;
|
|
fout << " <td>" << mi.count_e << "</td>" << std::endl;
|
|
|
|
if (mi.VManifold && mi.FManifold)
|
|
fout << " <td>" << mi.numholes << "</td>" << std::endl;
|
|
else
|
|
fout << " <td>N/A</td>" << std::endl;
|
|
|
|
|
|
fout << " <td>" << mi.numcomponents << "</td>" << std::endl;
|
|
fout << " <td>" << mi.count_uv << "</td>" << std::endl;
|
|
fout << " <td>" << mi.dv << "</td>" << std::endl;
|
|
|
|
if (mi.SelfIntersect)
|
|
fout << " <td>" << static_cast<unsigned int>(mi.intersections.size())
|
|
<< "</td>" << std::endl;
|
|
else
|
|
fout << " <td>None</td>" << std::endl;
|
|
|
|
if(mi.VManifold && mi.FManifold)
|
|
fout << " <td>Yes</td>" << std::endl;
|
|
else
|
|
fout << " <td>No</td>" << std::endl;
|
|
|
|
if ((mi.Orientable)&&(mi.Oriented))
|
|
fout << " <td>Yes / Yes</td>" << std::endl;
|
|
else if ((mi.Orientable)&&(!mi.Oriented))
|
|
fout << " <td>Yes / No</td>" << std::endl;
|
|
else if (!mi.Orientable)
|
|
fout << " <td>No / No</td>" << std::endl;
|
|
|
|
if (mi.VManifold && mi.FManifold)
|
|
fout << " <td>" << mi.Genus << "</td>" << std::endl;
|
|
else
|
|
fout << " <td>N/A</td>" << std::endl;
|
|
|
|
fout << " </tr>" << std::endl;
|
|
}
|
|
|
|
void SaveHtmlInfo(MeshInfo &mi)
|
|
{
|
|
char buff[1024];
|
|
bool flagInsert = false;
|
|
ifstream fin;
|
|
fstream fout;
|
|
|
|
// Try to open
|
|
fin.open("result.html");
|
|
long pos;
|
|
if (fin.is_open())
|
|
{
|
|
while (!fin.eof())
|
|
{
|
|
pos = fin.tellg();
|
|
fin.getline(buff, 1024);
|
|
string str(buff);
|
|
if (str == " </tbody>")
|
|
break;
|
|
}
|
|
flagInsert = true;
|
|
}
|
|
fin.close();
|
|
|
|
if (flagInsert)
|
|
fout.open("result.html", ios::in | ios::out);
|
|
else
|
|
fout.open("result.html", ios::out);
|
|
|
|
if (!fout.is_open())
|
|
{
|
|
printf("\n Impossible to write the HTML output file.\n");
|
|
}
|
|
else
|
|
{
|
|
if (flagInsert)
|
|
{
|
|
// Insert the mesh information into an existing table
|
|
fout.seekp(pos, ios::beg);
|
|
|
|
SaveMeshInfoHtmlTable(fout, mi);
|
|
|
|
for (int i = HTML_LINES - 4; i < HTML_LINES; i++)
|
|
fout << HTML_TABLE[i] << std::endl;
|
|
}
|
|
else
|
|
{
|
|
// Create a new table
|
|
for (int i = 0; i < HTML_LINES - 4; i++)
|
|
fout << HTML_TABLE[i] << std::endl;
|
|
|
|
SaveMeshInfoHtmlTable(fout, mi);
|
|
|
|
for (int i = HTML_LINES - 4; i < HTML_LINES; i++)
|
|
fout << HTML_TABLE[i] << std::endl;
|
|
}
|
|
}
|
|
|
|
fout.close();
|
|
}
|
|
|
|
int main(int argc, char ** argv)
|
|
{
|
|
CMesh m;
|
|
bool saveCleanMeshFlag = false; // Save the clean mesh
|
|
bool verboseFlag = true; // Verbose mode on/off
|
|
bool XmlFlag= false; // XML output enabled/disabled
|
|
bool HtmlFlag = false; // HTML output enabled/disabled
|
|
|
|
string SaveName;
|
|
|
|
MeshInfo mi;
|
|
initMeshInfo(mi);
|
|
|
|
printf("\n -------------------------------\n"
|
|
" TriMeshInfo V.1.23 \n"
|
|
" http://vcg.isti.cnr.it\n"
|
|
" release date: "__DATE__"\n"
|
|
" -------------------------------\n\n\n");
|
|
|
|
|
|
// Parsing arguments
|
|
///////////////////////////////////////////////
|
|
|
|
if (argc <= 1)
|
|
{
|
|
printf(MSG_ERR_N_ARGS);
|
|
exit(-1);
|
|
}
|
|
|
|
mi.FileName = argv[1];
|
|
|
|
int i = 2;
|
|
while (i < argc)
|
|
{
|
|
if (argv[i][0] == '-')
|
|
{
|
|
switch(argv[i][1])
|
|
{
|
|
case 'q' :
|
|
// Quiet mode, disable verbose mode
|
|
verboseFlag = false;
|
|
break;
|
|
|
|
case 's':
|
|
// Save the clean mesh with the name specified
|
|
saveCleanMeshFlag = true;
|
|
|
|
// Check clean mesh name (minimal check)
|
|
if (i+1 >= argc)
|
|
{
|
|
printf(" Invalid output mesh name.\n\n");
|
|
exit(-1);
|
|
}
|
|
else if (argv[i+1][0] != '-')
|
|
SaveName = argv[i+1];
|
|
else
|
|
{
|
|
printf(" Invalid output mesh name.\n\n");
|
|
exit(-1);
|
|
}
|
|
|
|
i++;
|
|
break;
|
|
|
|
case 'x' :
|
|
// Enable XML output
|
|
XmlFlag = true;
|
|
break;
|
|
|
|
case 'h' :
|
|
// Enable HTML output
|
|
HtmlFlag = true;
|
|
break;
|
|
|
|
default:
|
|
printf(MSG_ERR_INVALID_OPTION, argv[i]);
|
|
exit(0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
i++;
|
|
};
|
|
|
|
// Mesh loading
|
|
//////////////////////////////////////////
|
|
|
|
int load_mask = OpenMesh(mi.FileName.c_str(), m);
|
|
|
|
if (load_mask & vcg::tri::io::Mask::IOM_VERTNORMAL)
|
|
mi.hasVNormal = true;
|
|
else
|
|
mi.hasVNormal = false;
|
|
|
|
if (load_mask & vcg::tri::io::Mask::IOM_FACENORMAL)
|
|
mi.hasFNormal = true;
|
|
else
|
|
mi.hasFNormal = false;
|
|
|
|
if (load_mask & vcg::tri::io::Mask::IOM_VERTCOLOR)
|
|
mi.hasVColor = true;
|
|
else
|
|
mi.hasVColor = false;
|
|
|
|
if (load_mask & vcg::tri::io::Mask::IOM_FACECOLOR)
|
|
mi.hasFColor = true;
|
|
else
|
|
mi.hasFColor = false;
|
|
|
|
if( (load_mask & vcg::tri::io::Mask::IOM_VERTTEXCOORD) ||
|
|
(load_mask & vcg::tri::io::Mask::IOM_WEDGTEXCOORD) )
|
|
mi.hasTexture = true;
|
|
else
|
|
mi.hasTexture = false;
|
|
|
|
// Mesh processing
|
|
//////////////////////////////////////////
|
|
|
|
printf(" Mesh processing...\n\n");
|
|
|
|
// Number of vertices
|
|
mi.vn = m.vn;
|
|
|
|
// Number of faces
|
|
mi.fn = m.fn;
|
|
|
|
// DUPLICATED VERTICES
|
|
mi.dv = tri::Clean<CMesh>::RemoveDuplicateVertex(m);
|
|
|
|
// DEGENERATED FACES => (faces with area zero)
|
|
mi.count_fd = tri::Clean<CMesh>::RemoveDegenerateFace(m);
|
|
mi.count_fd += tri::Clean<CMesh>::RemoveFaceOutOfRangeArea<false>(m,0);
|
|
|
|
// UNREFERENCED VERTEX
|
|
mi.count_uv = tri::Clean<CMesh>::RemoveUnreferencedVertex(m);
|
|
|
|
// Update topology (face-to-face)
|
|
tri::UpdateTopology<CMesh>::FaceFace(m);
|
|
tri::UpdateTopology<CMesh>::VertexFace(m);
|
|
|
|
// IS MANIFOLD?
|
|
mi.VManifold = tri::Clean<CMesh>::CountNonManifoldVertexFF(m)>0;
|
|
mi.FManifold = tri::Clean<CMesh>::CountNonManifoldEdgeFF(m)>0;
|
|
|
|
// COUNT EDGES
|
|
tri::Clean<CMesh>::CountEdges(m, mi.count_e, mi.boundary_e);
|
|
|
|
// HOLES COUNT
|
|
if(mi.VManifold && mi.FManifold)
|
|
{
|
|
mi.numholes = tri::Clean<CMesh>::CountHoles(m);
|
|
tri::Clean<CMesh>::CountEdges(m, mi.BEdges,mi.numholes);
|
|
}
|
|
|
|
// CONNECTED COMPONENTS
|
|
mi.numcomponents = tri::Clean<CMesh>::CountConnectedComponents(m);
|
|
|
|
// ORIENTATION
|
|
if (mi.VManifold && mi.FManifold)
|
|
tri::Clean<CMesh>::IsOrientedMesh(m, mi.Oriented, mi.Orientable);
|
|
else
|
|
{
|
|
mi.Oriented = false;
|
|
mi.Orientable = false;
|
|
}
|
|
|
|
// Rebuild Vertex-Face topology
|
|
tri::UpdateTopology<CMesh>::VertexFace(m);
|
|
|
|
// VOLUME (require a closed oriented manifold)
|
|
if ((mi.VManifold && mi.FManifold)&&(mi.Oriented)&&(!mi.numholes))
|
|
{
|
|
tri::Inertia<CMesh> mm;
|
|
mm.Compute(m);
|
|
mi.Volume = mm.Mass();
|
|
|
|
// the sign of the volume depend on the mesh orientation
|
|
if (mi.Volume < 0.0)
|
|
mi.Volume = -mi.Volume;
|
|
}
|
|
|
|
// GENUS
|
|
if(mi.VManifold && mi.FManifold)
|
|
mi.Genus = tri::Clean<CMesh>::MeshGenus(m, mi.numholes,
|
|
mi.numcomponents, mi.count_e);
|
|
|
|
// REGULARITY
|
|
if (mi.VManifold && mi.FManifold)
|
|
tri::Clean<CMesh>::IsRegularMesh(m, mi.Regular, mi.Semiregular);
|
|
else
|
|
{
|
|
mi.Regular = false;
|
|
mi.Semiregular = false;
|
|
}
|
|
|
|
// SELF INTERSECTION
|
|
mi.SelfIntersect = tri::Clean<CMesh>::SelfIntersections(m, mi.intersections);
|
|
|
|
// Mesh Information Output
|
|
//////////////////////////////////////////
|
|
|
|
// Print mesh information
|
|
if(verboseFlag)
|
|
PrintMeshInfo(mi);
|
|
|
|
// Save mesh information in XML format
|
|
if(XmlFlag)
|
|
SaveXMLInfo(mi);
|
|
|
|
// Save mesh information in HTML format
|
|
if (HtmlFlag)
|
|
SaveHtmlInfo(mi);
|
|
|
|
// Save the clean mesh
|
|
if (saveCleanMeshFlag)
|
|
{
|
|
printf(" Save the 'clean' mesh...");
|
|
tri::io::Exporter<CMesh>::Save(m, SaveName.c_str());
|
|
printf(" done.\n\n");
|
|
}
|
|
|
|
mi.intersections.clear();
|
|
|
|
return 0;
|
|
}
|
|
|