source: GTP/trunk/Lib/Geom/shared/GTGeometry/include/GeoMeshSimplifier.h @ 2127

#ifndef __GEO_MESH_SIMPLIFIER__
#define __GEO_MESH_SIMPLIFIER__

#include <map>
#include        <math.h>
#include        "GeoMesh.h"
#include        "GeoMeshSimpSequence.h"
#include        "vmi_simplifier.h"
#include        "change.h"

//#include "SimplificationMethod.h"

using   namespace       Geometry;

namespace Geometry
{

        //-----------------------------------------------------------------------
        //      Class for join triangle holes.
        //-----------------------------------------------------------------------
        class _coord_
        {
                public:
                        float x,y,z;
                        inline _coord_( float x =       0.0f,
                                        float y =       0.0f,
                                        float z =       0.0f)
                        { this->x = x; this->y = y; this->z = z; }

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

                        inline _coord_ & operator=(const _coord_ &f)
                        {
                                x       =       f.x;
                                y       =       f.y;
                                z       =       f.z;

                                return *this;
                        }

                        inline bool operator<(const _coord_ &f) const
                        {
                                if (x<f.x-0.0001) return true;
                                if (x>f.x+0.0001) return false;
                                if (y<f.y-0.0001) return true;
                                if (y>f.y+0.0001) return false;
                                if (z<f.z-0.0001) return true;
                                if (z>f.z+0.0001) return false;

                                return  false;
                        }
        };

        //-----------------------------------------------------------------------
        //      Class tha implements a double-linked map.
        //-----------------------------------------------------------------------
        class   EdgesMultimap
        {
                private:
                        multimap<int,int>       edges;
                public:
                        EdgesMultimap();
                        ~EdgesMultimap();
                        void    insert(int v1,int v2);
                        void    remove(int v1,int v2);
                        void    contract(int v1,int v2);
                        bool    exists(int v1,int v2);
        };

        //-----------------------------------------------------------------------
        //      Class that conserves textures adding new vertices to mesh.
        //-----------------------------------------------------------------------
        class   TextureConserver
        {
                private:
                        EdgesMultimap                   *mEdges;
                        Mesh                                                    *mGeoMesh;

                public:
                        multimap<int,int>       mVertices;

                        TextureConserver();
                        ~TextureConserver();

                        void    JoinVertices(Mesh *mesh);

                        Mesh    *GetMesh();
        };

        /// Mesh simplificator interface.
        /** This module is used by both models, general mesh models and the plant and tree models for the trunk and the branches. It contains functions that generate simplified versions of 3D objects made out of triangles. Given a 3D object, this module computes a sequence of geometric transformations that reduce the object’s geometric detail while preserving its appearance. For each simplification step, returns a simplification sequence containing the edge to be collapse, the two triangles being removed and the new triangles remapped to the model.\n\n

Inputs:\n
- A pointer to the Geometry::Mesh object containing the 3D model to be simplified.
.

Outputs:\n
-# The simplified mesh, contained in a Geometry::Mesh object.
-# Simplification sequence, represented by a Geometry::MeshSimplificationSequence object.
*/

        class MeshSimplifier
        {
                public:
                        /// Class constructor. Retrieves a pointer to a valid Geometry::Mesh object to simplify.
                        MeshSimplifier( const Geometry::Mesh    *,
                                        Geometry::TIPOFUNC              upb=0);

                        /// Virtual class destructor.
                        virtual ~MeshSimplifier (void);

                        /// Copy constructor
                        //MeshSimplifier(const MeshSimplifier&);

                        /// Assignment operator
                        //MeshSimplifier& operator =(const MeshSimplifier&);

                        /// Starts the simplification process. Receives as a parameter the LOD factor in a range of [0,1]. This is a pure virtual method and must be overloaded in a derived class that implements a simplification algorithm.
                        virtual void Simplify(Geometry::Real)=0;

                        /// Starts the simplification process. Receives as a parameter the number of vertices of the resulting mesh. This is a pure virtual method and must be overloaded in a derived class that implements a simplification algorithm.
                        virtual void Simplify(Geometry::uint32)=0;

                        /// Returns the simplified mesh.
                        Mesh *GetMesh();

                        /// Returns the simplification sequence for general meshes.
                        MeshSimplificationSequence *GetSimplificationSequence();

                        // Sets what is the mesh that stores the leaves
                        void setMeshLeaves(Geometry::Index);

                protected:

                        //private: // fer protected
                        Mesh                                                                                            *mGeoMesh;
                        Mesh                                                                                            *mInitialMesh;
                        MeshSimplificationSequence      *msimpsequence;
                        const Mesh                                                                      *objmesh;

                        Geometry::Index indexMeshLeaves;

                        //      Progress bar function.
                        Geometry::TIPOFUNC      mUPB;

                        //      Sort mesh bones.
                        void    sortBones();
        };

        /// Implementation of a simplification algorithm based on viewpoint.
        /** This class implements a simplification algorithm based on a viewpoint evaluation technique. */
        class ViewPointDrivenSimplifier : public MeshSimplifier
        {
                private:

                        //      Vectors of positions, normals and texture coordinates.
                        vector<Vector3> vPositions;
                        vector<Vector3> vNormals;
                        vector<Vector2> vTexCoords;

                        //      Auxiliar vertex buffer.
                        Geometry::VertexBuffer  *mVB;

                        //      Set of indices.
                        map<int,int>    mIndexMap;

                        //      Join and split vertices to matain texture aspect.
                        TextureConserver        *mTexConserver;

                        //      Loads a vmi mesh with a given geometry mesh.
                        VMI::Mesh * initMeshStructure(Geometry::Mesh    *geoMesh);

                        //      Loads a geometry mesh with a given vmi mesh.
                        void    loadMesh();

                        //      Find vertex in auxiliar vertex buffer.
                        void    findVertex(size_t       submesh, size_t index);

                        //      Gets the VMI mesh simplification sequence.
                        void    GetMeshSimpSequence();

                        //      Fill up vectors of positions, normals and texture coordinates.
                        void    fillUpPosNorTC(Mesh     *geoMesh);

                        //      Reassigns bones.
                        void bonesReassignament();

                public:

                        /// Class constructor. Will call Simplifier class constructor.
                        ViewPointDrivenSimplifier(      const Geometry::Mesh    *geoMesh,
                                        Geometry::TIPOFUNC              upb=0);

                        /// Class destructor.
                        ~ViewPointDrivenSimplifier(void);

                        /// Copy constructor
                        //ViewPointDrivenSimplifier(const ViewPointDrivenSimplifier&);

                        /// Assignment operator
                        //ViewPointDrivenSimplifier& operator =(const ViewPointDrivenSimplifier&);

                        /// Starts the simplification process. Receives as a parameter the LOD factor in a range of [0,1]. Implements the Simplifier::Simplify method to perform an image based simplification.
                        void Simplify(Geometry::Real);

                        /// Starts the simplification process. Receives as a parameter the number of vertices of the resulting mesh. Implements the Simplifier::Simplify method to perform an image based simplification.
                        void Simplify(Geometry::uint32);

                        // Returns the simplified mesh.
                        //Mesh *GetMesh();
        };

        /// Implementation of a simplification algorithm based on geometry information.
        /** This class implements a simplification algorithm based on a classic geometry evaluation technique. */
        class GeometryBasedSimplifier : public MeshSimplifier
        {
                public:
                        /// Class constructor. Will call Simplifier class constructor.
                        GeometryBasedSimplifier(        const Geometry::Mesh    *geoMesh,
                                        Geometry::TIPOFUNC              upb=0);

                        /// Class destructor.
                        ~GeometryBasedSimplifier(void);

                        /// Copy constructor
                        //GeometryBasedSimplifier(const GeometryBasedSimplifier&);

                        /// Assignment operator
                        //GeometryBasedSimplifier& operator =(const GeometryBasedSimplifier&);

                        /// Starts the simplification process. Receives as a parameter the LOD factor in a range of [0,1]. Implements the Simplifier::Simplify method to perform an image based simplification.
                        void Simplify(Geometry::Real);

                        /// Starts the simplification process. Receives as a parameter the number of vertices of the resulting mesh. Implements the Simplifier::Simplify method to perform an image based simplification.
                        void Simplify(Geometry::uint32);
        };
} // end of Geometry namespace;

#endif