trimeshinfo.cpp

Go to the documentation of this file.

/****************************************************************************
* 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;
}