source: GTP/trunk/Lib/Geom/shared/GTGeometry/include/GeoTreeSimplifier.h @ 774

#ifndef __GEO_TREE_SIMPLIFIER__
#define __GEO_TREE_SIMPLIFIER__

#include "GeoMesh.h"
#include "GeoTreeSimpSequence.h"
#include "Hoja.h"

#define K1              0.8f //distancia
#define K2              0.2f // coplanar

namespace Geometry
{
        /// Tree Simplifier interface 
        /*** This module is used by LODTree to simplify leaves of a tree. It contains functions that generate simplified
        versions of 3D objects made out of quads (represented as pairs of texture-mapped triangles). Given a 3D object, this
        module computes a sequence of geometric transformations that reduce the object’s geometric detail while preserving
        its appearance.\n\n

        For each simplification step, the module returns a simplification sequence containing the leaf collapsed, the two 
        leaves being removed, and the resulting leaf for that contraction.\n\n

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

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

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

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

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

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

                /// Starts the simplification process. Receives as a parameter the LOD factor in a range of [0,1].
                void Simplify(Geometry::Real,Geometry::Index);
        
                /// Returns the simplified mesh.
                Mesh *GetMesh();

                /// Returns the simplification sequence for leaves.
                TreeSimplificationSequence *GetSimplificationSequence();

        //private:
                void Centroh(Hoja       &);
                void GetNormal(Hoja     &);
                void DistanciaEntreHojas(void);
                void CoplanarEntreHojas(FILE*);
                float DiametroEsferaEnvolvente();
                void EstableceCriterio(float);

                float max(float, float);
                float min(float, float);

                //long int Colapsa (TreeSimplificationSequence *, float);
                long int Colapsa(float);
                void DosMayores(float*, int* );
                void ElijeVertices(Hoja& , Hoja& , long int);
                float Hausdorff(Hoja &, Hoja&);
                float distan(float, float, float, float, float, float);
                long int MinimaDistancia(void);
                void NormalizaDistancia(float diametro);
                void EstableceCriterio2(float, long int);
                long int MinimoCriterio(void);

                void Mesh2Estructura(   const Geometry::Mesh *,
                                                                                                        Index);
                
                void EscribeMesh(int);

                Mesh                    *mesh; // objeto mesh simplificado (para la salida)
                const                   Mesh *objmesh;
                float                   (*Vertex)[3];
                Hoja                    *Hojasa;  // las activas
                long int        activas, counth;
                TreeSimplificationSequence      *mtreesimpsequence;
                
        private:
                //      Update progress bar.
                Geometry::TIPOFUNC      mUPB;
        };
}

#endif