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

#pragma once

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

using   namespace       Geometry;

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;

                //      Simplification sequence.
                MeshSimplificationSequence      *msimpseq;

                //      Stores the simplification step.
                MeshSimplificationSequence::Step simplifstep;

                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;

                unsigned int *first_index_submesh;

                //std::vector<simplif::pair_info *> pointers_to_remove;

                int indexMeshLeaves;

                //      Contract lonely vertices that have same coords than the contracted one.
                void    contractLonelyVertices( simplif::Model  &m,
                                                                                                                                        simplif::Vertex *v0,
                                                                                                                                        simplif::Vertex *v1,
                                                                                                                                        simplif::Vec3           candidate);

                //      Remove twin edges.
                void    removeTwinEdges(simplif::Model  &m,
                                                                                                        simplif::Vertex *v0,
                                                                                                        simplif::Vertex *v1,
                                                                                                        simplif::Vec3           candidate);

        public:

                const Geometry::Mesh *objmesh;

                //      Total number of triangles of all the submeshes.
                int number_of_triangles;

                SimplificationMethod(const Geometry::Mesh *m);

                void    generateSimplifModel(void);

                Geometry::MeshSimplificationSequence *Decimate( float lod,
                                int simpliftype,
                                Geometry::TIPOFUNC      upb=0);

                void setMeshLeaves(int meshLeaves);

                ///     Gets mesh simplified.
                Geometry::Mesh  *       GetMesh();

                ///     Destructor.
                ~SimplificationMethod();
};