EgtGeomKernel/Tree.h

//----------------------------------------------------------------------------
//  EgalTech 2023
//----------------------------------------------------------------------------
// File : Tree.h         Data : 21.04.23          Versione : 
// Contenuto : Implementazione della classe Cell di un albero binario Tree.
//
//
//
// Modifiche : 21.04.23 DB Creazione modulo.
//
//
//----------------------------------------------------------------------------

#pragma once

//--------------------------- Include ----------------------------------------
#include <map>
#include "SurfBezier.h"
#include "GeoConst.h"

//----------------------------------------------------------------------------
class Cell
{
   public :
      ~Cell( void) ;
      Cell( void) ;
      Cell( Point3d& ptBL, Point3d& ptTR) ;
      inline bool IsSame( const Cell& cOtherCell) const ;
      void SetBottomLeft( Point3d ptBL) { m_ptPbl = ptBL ; }
      void SetTopRight( Point3d ptTR) { m_ptPtr = ptTR ; }
      void SetSplitDirVert( bool bVert) { m_bSplitVert = bVert ; }
      void SetParent( int nParent) { m_nParent = nParent ; }
      Point3d GetBottomLeft( void) const { return m_ptPbl ; }
      Point3d GetTopRight( void) const { return m_ptPtr ; }
      double GetSplitValue( void) const { return m_dSplit ; }
      bool IsSplitVert( void) const { return m_bSplitVert ; }           // se true la cella verrebbe splittata verticalmente, sennò orizzontalmente
      bool IsLeaf( void) const ;                                        // flag che indica se la cella ha figli o se è una foglia
      bool IsProcessed( void) const { return m_bProcessed ; }           // flag che indica se tutti i figli della cella, se ce ne sono, sono stati processati
      void Processed( void) { m_bProcessed = true ; }
      static bool minorX ( const Cell& c1, const Cell& c2) { return c1.m_ptPbl.x < c2.m_ptPbl.x ; }
      static bool minorY ( const Cell& c1, const Cell& c2) { return c1.m_ptPbl.y < c2.m_ptPbl.y ; }

   public :
      int           m_nId ;              // Id della cella
      int           m_nTop ;             // cella adiacente al lato top
      int           m_nBottom ;          // cella adiacente al lato bottom
      int           m_nLeft ;            // cella adiacente al lato left
      int           m_nRight ;           // cella adiacente al lato right
      int           m_nParent ;          // cella genitore
      int           m_nDepth ;           // profondità della cella rispetto a root
      double        m_dSplit ;           // parametro a cui è stata splittata la cella
      int           m_nChild1 ;          // prima cella figlio
      int           m_nChild2 ;          // seconda cella figlio

   private :
      Point3d          m_ptPbl ;            // punto bottom left
      Point3d          m_ptPtr ;            // punto top right
      bool             m_bProcessed ;       // flag che indica se la cella è stata processata
      bool             m_bSplitVert ;       // flag che indica in quale direzione è stata divisa la cella
} ;

//----------------------------------------------------------------------------
class Tree
{
public :
   ~Tree( void) ;
   Tree( void) ;
   Tree ( const SurfBezier* pSrfBz, bool bSplitPatches = false) ;
   void SetSurf( const SurfBezier* pSrfBz, bool bSplitPatches = true) ;
   bool BuildTree( double dLinTol = LIN_TOL_STD, double dSideMin = 5, double dSideMax = INFINITO) ; // dSideMax è il massimo per la dimensione maggiore di un triangolo della trimesh
                                                                                                    // dSideMin è lunghezza minima del lato di una cella nello spazio reale
   bool GetPolygons( POLYLINEVECTOR& vPolygons) ;                                                   // restituisce il poligono corrispondente ad ogni cella foglia dell'albero
                                                                                                    // ad ogni poligono sono stati aggiunti tutti i vertici dei vicini posizionati sui suoi lati

private :
   void Split( int nId, double dSplitValue) ;                              // funzione di split di una cella al parametro indicato nella direzione data da bVert
   void Split( int nId) ;                                                  // funzione di split di una cella dell'albero a metà nella direzione data da bVert
   void Balance () ;                                                       // creo rami in modo che tutte tutte le foglie abbiano come adiacenti foglie ad una profonditù di +- 1
   int GetHeightLeaves ( int nId, INTVECTOR& vnLeaves, int d = 0) const ;  // altezza del subtree a partire dal nodo nId
   int GetDepth ( int nId, int nRef) const ;                               // livello del nodo nId
   void GetTopNeigh( int nId, INTVECTOR& vTopNeighs) const ;               // restituisce le celle foglie che sono adiacenti al lato top
   void GetBottomNeigh( int nId, INTVECTOR& vBottomNeighs) const ;         // restituisce le celle foglie che sono adiacenti al lato bottom
   void GetLeftNeigh( int nId, INTVECTOR& vLeftNeighs) const ;             // restituisce le celle foglie che sono adiacenti al lato left
   void GetRightNeigh( int nId, INTVECTOR& vRightNeighs) const ;           // restituisce le celle foglie che sono adiacenti al lato right

private :
   const SurfBezier*           m_pSrfBz ;           // superficie di bezier
   DBLVECTOR                   m_vDim ;             // distanze tra i vertici della superficie di bezier in ordine antiorario a partire da ptP00
   bool                        m_bTrimmed ;         // superficie trimmata
   bool                        m_bBilinear ;        // superficie bilineare
   bool                        m_bMulti ;           // superficie multi-patch
   bool                        m_bClosed ;          // superficie chiusa
   int                         m_nDegU ;            // grado della superficie nel parametro U
   int                         m_nDegV ;            // grado della superficie nel parametro V
   POLYLINEVECTOR              m_vPolygons ;        // vettore dei poligoni del tree
   std::map<int,Cell>          m_mTree ;            // mappa che contiene tutti i nodi e le foglie dell'albero. -2 è puntatore Null e -1 è root
   std::map<int,PNTVECTOR>     m_mVert ;            // mappa che contiene tutti i vertici 3d delle celle del tree. L'Id è lo stesso che la cella ha in m_mTree
   INTVECTOR                   m_vnLeaves ;         // vettore delle foglie
} ;