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

#pragma once

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

using   namespace       Geometry;
using   namespace       std;

//-------------------------------------------------------------------------
// Class to create a map without repeated vertices
//-------------------------------------------------------------------------
class _float3_
{
        public:

                float x,y,z;

                _float3_(float x=0.0f, float y=0.0f, float z=0.0f)
                {
                        this->x = x; this->y = y; this->z = z;
                }

                _float3_(const _float3_ &f)
                {
                        x=f.x; y=f.y; z=f.z;
                }

                _float3_ & operator=(const _float3_ &f)
                {
                        x=f.x; y=f.y; z=f.z; return *this;
                }

                /*
                bool operator==(const _float3_  &f) const
                {
                        float   F3_EPS;
                        float dx;
                        float dy;
                        float dz;
                        
                        F3_EPS  =       1e-12;
                        dx                      =       x - f.x;
                        dy                      =       y - f.y;
                        dz                      =       z - f.z;

                        return (dx*dx + dy*dy + dz*dz) < F3_EPS;
                }
                */

                bool operator<(const _float3_ &f) const
                {
                        if (x<f.x) return true;
                        if (x>f.x) return false;
                        if (y<f.y) return true;
                        if (y>f.y) return false;
                        if (z<f.z) return true;
                        if (z>f.z) return false;
                        return false;
                }
};

//-------------------------------------------------------------------------
// Class to perform mesh simplification.
//-------------------------------------------------------------------------
class SimplificationMethod
{
        private:

                Geometry::Mesh  *mGeoMesh;

                void compute_pair_info(simplif::pair_info*);

                simplif::Model M0;

                simplif::buffer<simplif::vert_info *> vinfo;

                simplif::Heap *heap;
                simplif::real proximity_limit;  // Distance threshold squared.

                int initialVertCount;
                int initialEdgeCount;
                int initialFaceCount;

                //      Simplification sequence.
                MeshSimplificationSequence      *msimpseq;

                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,
                                                                                        int                                                                     obligatory);

                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;

                //      Multimap to store current vertex in a simplification state.
                typedef multimap<_float3_,      int>    vertex_map;
                typedef vertex_map::iterator                    vertex_map_str;
                typedef vertex_map::value_type          vertex_pair;

                //      Store unique vertices by submesh (without repetitions).
                typedef std::map<int,int> MAPAINDIND;

                //      Store all the indices by submesh (with repetitions).
                typedef std::vector<int> REPINDLIST;

                vertex_map      vertexMultimap;

                //      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);

                //      Find twin vertices to the contracted one and contract them.
                void    removeTwinVertices(     simplif::Model  &m,
                                                                                                                        simplif::Vertex *v0,
                                                                                                                        simplif::Vertex *v1,
                                                                                                                        simplif::Vec3           candidate);

                void    fillUpSharedVertices(   MAPAINDIND      &shared_vertex_map,
                                                                                                                                REPINDLIST *ver_inds_rep_by_geo);

                void    fillUpVertices( MAPAINDIND      *unique_verts_inds_by_geo,
                                                                                                        REPINDLIST *ver_inds_rep_by_geo);

                void    addNewBoneAssignments();

        public:

                Mesh *mInitialMesh;

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

                ///     Constructor.
                SimplificationMethod(const Mesh *m);

                ///     Destructor.
                ~SimplificationMethod();

                void    generateSimplifModel(void);

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

                void setMeshLeaves(int meshLeaves);

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

};