source: GTP/trunk/Lib/Geom/shared/GTGeometry/src/libs/SimplificationMethod.h @ 1025

#pragma once

#include <set>
#include <map>
#include <vector>
#include <list>
#include <iostream>
#include <simplif.h>
#include <GeoMeshSimplifier.h>

class SimplificationMethod
{
private:
        Geometry::Mesh  *mGeoMesh;
        void compute_pair_info(simplif::pair_info*);
        simplif::Model M0;
        simplif::array<simplif::vert_info> vinfo;
        simplif::Heap *heap;
        simplif::real proximity_limit;    // distance threshold squared
        int initialVertCount;
        int initialEdgeCount;
        int initialFaceCount;

        inline simplif::vert_info& vertex_info(simplif::Vertex *v)
        {
                return vinfo(v->validID());
        }
        
        simplif::real pair_mesh_penalty(simplif::Model& M,
                                                                                                                                simplif::Vertex *v1,
                                                                                                                                simplif::Vertex *v2,
                                                                                                                                simplif::Vec3& vnew);
        
        int predict_face(simplif::Face& F,
                                                                        simplif::Vertex *v1,
                                                                        simplif::Vertex *v2,
                                                                        simplif::Vec3& vnew,
                                                                        simplif::Vec3& f1,
                                                                        simplif::Vec3& f2,
                                                                        simplif::Vec3& f3);
        
        bool check_for_pair(simplif::Vertex *v0, simplif::Vertex *v1);
        
        simplif::pair_info *new_pair(simplif::Vertex *v0, simplif::Vertex *v1);
        
        void delete_pair(simplif::pair_info *pair);
        
        void do_contract(simplif::Model& m, simplif::pair_info *pair);
        
        bool decimate_quadric(simplif::Vertex *v, simplif::Mat4& Q);
        
        void decimate_contract(simplif::Model& m);
        
        simplif::real decimate_error(simplif::Vertex *v);
        
        simplif::real decimate_min_error();
        
        simplif::real decimate_max_error(simplif::Model& m);
        
        void decimate_init(simplif::Model& m, simplif::real limit);
        
        bool pair_is_valid(simplif::Vertex *u, simplif::Vertex *v);
        
        void simplifmethod_run(int,     Geometry::TIPOFUNC      upb=0);
        
        void simplifmethod_runv(int,    Geometry::TIPOFUNC      upb=0);
        
        void simplifmethod_init(void);

        //      To map the mesh with de simplification method structure.
        //      Submeshes which pertains each vertex.
        std::map<int,std::vector<int> > submeshmap;
        
        //      Vertices of the VertexBuffer that point 
        //      at this vertex of the simplification method.
        std::map<int,std::vector<int> > vertexbuffermap; 

        //      Simplification sequence of the simplification method.
        std::vector<Geometry::MeshSimplificationSequence::Step> decim_data;
        
        std::string meshName;
        
        void WriteOBJ(void);
        
        unsigned int *first_index_submesh;
        
        //std::vector<simplif::pair_info *> pointers_to_remove;

        int indexMeshLeaves;
        
public:
        
        const Geometry::Mesh *objmesh;
        
        //      Total number of triangles of all the submeshes.
        int number_of_triangles;
        
        SimplificationMethod(const Geometry::Mesh *m);
        
        void geomesh2simplifModel(void);
        
        Geometry::MeshSimplificationSequence *Decimate( float lod,
                                                                                                                                                                                                        int simpliftype,
                                                                                                                                                                                                        Geometry::TIPOFUNC      upb=0);
        
        void setMeshLeaves(int meshLeaves);

        ///     Gets mesh simplified.
        Geometry::Mesh  *       GetMesh();
        
        ///Destructor
        ~SimplificationMethod();
};