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

#ifndef __GEO_TREE_SIMPLIFIER__
#define __GEO_TREE_SIMPLIFIER__

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

#define K1              0.8f //distance factor
#define K2              0.2f //coplanar factor

class LeafOctree;
class Leaf;

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

                /// 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 CalculateLeafCenter(Leaf &);
                void CalculateLeafNormal(Leaf &);
                float CalculateLeafArea(Leaf &) const;
                void CoplanarBetweenLeaves(void);
                float BoundingSphereDiameter() const;
//              void SetCriteria(float);  // to be erased: obsolete!
                void SetCriteriaOptimized(float);

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

                long int Collapse(float);
                void TwoGreater(float*, int* );
                void ChooseVertices(Leaf& , Leaf& , long int);
                float HausdorffOptimized(const Leaf &, const Leaf&) const;
                float DistanceFromCenters(const Leaf &, const Leaf &) const;
                float distan(float, float, float, float, float, float) const;
                long int MinDistance(void);
                void NormalizeDistance(float diametro);
//              void SetCriteria2(float, long int); obsolete!
                void SetCriteria2Optimized(float, long int);
                long int MinCriteria(void);

                void Mesh2Structure(const Geometry::Mesh *,Index);
                void BuildOutputMesh(int);
                void CrossProduct(const float *v1, const float *v2, float *res) const;
                float SquaredModule(const float *v) const;

                Mesh                    *mesh; // simplified mesh object (for output)
                const                   Mesh *objmesh;
                float                   (*Vertex)[3];
                Leaf                    *Leaves;
                long int        activeLeaves, countLeaves;
                TreeSimplificationSequence      *mtreesimpsequence;
                
                //      Update progress bar.
                Geometry::TIPOFUNC      mUPB;

                // the octree used to speed up the simplification process
                LeafOctree *octree;
                void RecursiveCreateLeafOctree(LeafOctree*, int deep); // this is called from CreateLeafNode
                void RecursiveFillOctreeWithLeaves(LeafOctree*);
                LeafOctree* CreateLeafOctree(int deep); // generates a new leaf octree and returns its root node
                size_t  vertex_count;
                LeafOctree ** octree_owning_leaf;
                LeafOctree *GetMinOctreeNodeForLeaf(LeafOctree *start, const Leaf &leaf);
                bool PruneOctree(LeafOctree *); // erases one octree level and translates its leaves to the parent. Returns true if the node itself was pruned
        };
}

#endif