simplification

#define NOMINMAX

#include <stdio.h>
#include <conio.h>
#include <Windows.h>

//#undef max
//#undef min

#include <set>
#include <vector>
#include <algorithm>

#include <vcg/complex/algorithms/local_optimization/tri_edge_collapse_quadric_tex.h>
#include <vcg/complex/algorithms/hole.h>
#include <vcg/connectors/hedge.h>
#include <vcg/complex/complex.h>
#include <vcg/complex/algorithms/update/topology.h>
#include <vcg/complex/algorithms/update/bounding.h>
#include <vcg/complex/algorithms/update/normal.h>
#include <vcg/complex/algorithms/clean.h>
#include <vcg/complex/algorithms/update/halfedge_indexed.h>
#include <vcg/complex/algorithms/local_optimization/quad_diag_collapse.h>
#include <vcg/complex/algorithms/update/fitmaps.h>

class CVertex;
class CFace;
class CEdge;

struct CUsedTypes :
    public vcg::UsedTypes<  vcg::Use<CVertex>   ::AsVertexType,
                            vcg::Use<CFace>     ::AsFaceType,
                            vcg::Use<CEdge>     ::AsEdgeType>
{
};

class CVertex :
    public vcg::Vertex<CUsedTypes,
        vcg::vertex::InfoOcf,
        vcg::vertex::BitFlags,
        vcg::vertex::Coord3f,
        vcg::vertex::Normal3f,
        vcg::vertex::TexCoord2f,
        vcg::vertex::VFAdj,
        vcg::vertex::MarkOcf>
{
};

class CFace :
    public vcg::Face<CUsedTypes,
        vcg::face::InfoOcf,
        vcg::face::BitFlags,
        vcg::face::WedgeTexCoordfOcf,
        vcg::face::VFAdj,
        vcg::face::FFAdj,
        vcg::face::VertexRef,
        vcg::face::MarkOcf>
{
};

class CEdge :
    public vcg::Edge<CUsedTypes,
        vcg::edge::BitFlags,
        vcg::edge::EEAdj,
        vcg::edge::EVAdj>
{
};

class CMesh :
    public vcg::tri::TriMesh<vcg::vertex::vector_ocf<CVertex>, vcg::face::vector_ocf<CFace>>
{
};

typedef vcg::tri::BasicVertexPair<CVertex> VertexPair;

class MyTriEdgeCollapse:
    public vcg::tri::TriEdgeCollapseQuadricTex<CMesh, VertexPair, MyTriEdgeCollapse, vcg::tri::QuadricTexHelper<CMesh>>
{
public:
    typedef TriEdgeCollapseQuadricTex<CMesh,  VertexPair, MyTriEdgeCollapse, vcg::tri::QuadricTexHelper<CMesh>> TECQ;
    inline MyTriEdgeCollapse(const VertexPair &p, int i, vcg::BaseParameterClass *pp)
        : TECQ(p, i, pp)
    {
    }
};

typedef vcg::SimpleTempData<CMesh::VertContainer, vcg::math::Quadric<double> > QuadricTemp;


class QHelper
{
public:
    QHelper(){}
    static void Init(){}
    static vcg::math::Quadric<double> &Qd(CVertex &v) {return TD()[v];}
    static vcg::math::Quadric<double> &Qd(CVertex *v) {return TD()[*v];}
    static CVertex::ScalarType W(CVertex * /*v*/) {return 1.0;}
    static CVertex::ScalarType W(CVertex & /*v*/) {return 1.0;}
    static void Merge(CVertex & /*v_dest*/, CVertex const & /*v_del*/){}
    static QuadricTemp* &TDp() {static QuadricTemp *td; return td;}
    static QuadricTemp &TD() {return *TDp();}
};

void QuadricTexSimplification(CMesh &m, int  TargetFaceNum, vcg::tri::TriEdgeCollapseQuadricParameter &pp)
{
    vcg::math::Quadric<double> QZero;
    QZero.SetZero();
    QuadricTemp TD(m.vert,QZero);
    QHelper::TDp()=&TD;

    if(pp.NormalCheck)
        pp.NormalThrRad = M_PI/4.0;


    vcg::LocalOptimization<CMesh> DeciSession(m,&pp);
    DeciSession.Init<MyTriEdgeCollapse >();

    DeciSession.SetTargetSimplices(TargetFaceNum);
    DeciSession.SetTimeBudget(0.1f); // this allow to update the progress bar 10 time for sec...

    int faceToDel=m.fn-TargetFaceNum;
    while( DeciSession.DoOptimization() && m.fn>TargetFaceNum )
    {
    };

    DeciSession.Finalize<MyTriEdgeCollapse >();

    /*
    vcg::math::Quadric<double> QZero;
    QZero.SetZero();

    vcg::tri::QuadricTexHelper<CMesh>::QuadricTemp TD3(m.vert, QZero);
    vcg::tri::QuadricTexHelper<CMesh>::TDp3() = &TD3;

    std::vector<std::pair<vcg::TexCoord2<float>, vcg::Quadric5<double>>> qv;

    vcg::tri::QuadricTexHelper<CMesh>::Quadric5Temp TD(m.vert, qv);
    vcg::tri::QuadricTexHelper<CMesh>::TDp() = &TD;

    vcg::LocalOptimization<CMesh> DeciSession(m, &pp);
    DeciSession.Init<MyTriEdgeCollapseQTex>();

    DeciSession.SetTargetSimplices(TargetFaceNum);
    DeciSession.SetTimeBudget(0.1f);

    int nFaceToDel = m.fn - TargetFaceNum;

    while( DeciSession.DoOptimization() && m.fn > TargetFaceNum )
    {
        printf("Simplifing heap size %i ops %i; faces: %d\n", (int)DeciSession.h.size(), DeciSession.nPerfmormedOps, (int)(100.0f - 100 * (m.fn - TargetFaceNum) / (nFaceToDel)));
    };

    DeciSession.Finalize<MyTriEdgeCollapseQTex>();
    */
}

int main()
{
    CMesh m;

    m.face.EnableWedgeTexCoord();
    m.face.EnableMark();

    m.vert.EnableMark();

    CMesh::VertexIterator iV = vcg::tri::Allocator<CMesh>::AddVertices(m, 3);

    iV->N() = vcg::Point3f(0.1f, 0.2f, 0.3f);
    iV->P() = vcg::Point3f(0.4f, 0.5f, 0.6f);
    iV->T() = vcg::TexCoord2f(0.7f, 0.8f);
    iV++;

    iV->N() = vcg::Point3f(0.9f, 1.0f, 1.1f);
    iV->P() = vcg::Point3f(1.2f, 1.3f, 1.4f);
    iV->T() = vcg::TexCoord2f(1.5f, 1.6f);
    iV++;

    iV->N() = vcg::Point3f(1.7f, 1.8f, 1.9f);
    iV->P() = vcg::Point3f(2.0f, 2.1f, 2.2f);
    iV->T() = vcg::TexCoord2f(2.3f, 2.4f);


    CMesh::FaceIterator iF = vcg::tri::Allocator<CMesh>::AddFaces(m, 1);

    iF->V(0) = &m.vert[2];
    iF->V(1) = &m.vert[0];
    iF->V(2) = &m.vert[1];

    iF->WT(0) = vcg::TexCoord2f(0.7f, 0.8f);
    iF->WT(1) = vcg::TexCoord2f(1.5f, 1.6f);
    iF->WT(2) = vcg::TexCoord2f(2.3f, 2.4f);

    /*
    vcg::tri::Clean<CMesh>::RemoveDegenerateFace(m);
    vcg::tri::Clean<CMesh>::RemoveDuplicateFace(m);
    vcg::tri::Clean<CMesh>::RemoveDuplicateVertex(m);
    vcg::tri::Clean<CMesh>::RemoveUnreferencedVertex(m);
    */
    /*
    vcg::tri::UpdateTopology<CMesh>::VertexFace(m);
    vcg::tri::UpdateTopology<CMesh>::EdgeEdge(m);
    vcg::tri::UpdateTopology<CMesh>::FaceFace(m);
    vcg::tri::UpdateTopology<CMesh>::FaceFaceFromTexCoord(m);
    vcg::tri::UpdateTopology<CMesh>::VertexEdge(m);
    vcg::tri::UpdateFlags<CMesh>::Clear(m);
    vcg::tri::UpdateFlags<CMesh>::FaceBorderFromFF(m);
    vcg::tri::UpdateFlags<CMesh>::FaceBorderFromVF(m);
    */

    vcg::tri::TriEdgeCollapseQuadricParameter SimplifParameters;
    SimplifParameters.SetDefaultParams();

    QuadricTexSimplification(m, 1, SimplifParameters);

    int nNumVert = 0;

    std::vector<int> VertexID(m.vert.size());
    for (CMesh::VertexIterator iV = m.vert.begin(); iV != m.vert.end(); iV++)
    {
        VertexID[iV - m.vert.begin()] = nNumVert;

        printf("Vertex %d: n - %0.1f; t - %0.1f; p - %0.1f\n", nNumVert, iV->N().X(), iV->T().U(), iV->P().X());

        nNumVert++;
    }

    int nNumFaces = 0;
    for (CMesh::FaceIterator iFace = m.face.begin(); iFace != m.face.end(); iFace++)
    {
        int nIndex0 = VertexID[vcg::tri::Index(m, iFace->V(0))];
        int nIndex1 = VertexID[vcg::tri::Index(m, iFace->V(1))];
        int nIndex2 = VertexID[vcg::tri::Index(m, iFace->V(2))];

        printf("face %d: %d %d %d\n", nNumFaces, nIndex0, nIndex1, nIndex2);

        nNumFaces++;
    }

    _getch();
    return 0;
}