synaps/topology/Octree.h

Go to the documentation of this file.

/*********************************************************************
*      This file is part of the source code of SYNAPS library          *
*   Author(s): L. Deschamps                                          *
*              G. Gatellier  , GALAAD, INRIA                         *
**********************************************************************/
#ifndef synaps_mesh_octree_H
#define synaps_mesh_octree_H

/*********************************************************************/

#include <synaps/init.h>

#include <iostream>
#include <vector>

/*********************************************************************/

__BEGIN_NAMESPACE_SYNAPS


namespace OCTREE
{
  
  enum FACE_TYPE{B,F,W,E,S,N};

  //The order of the node_types should not be changed:
  // B_SW, F_SW, B_SE, F_SE, B_NW, F_NW, B_NE, F_NE
  enum NODE_TYPE{B_SW, F_SW, B_SE, F_SE, B_NW, F_NW, B_NE, F_NE};
  //  {F_NE, F_NW, F_SW, F_SE, B_NE, B_NW, B_SW, B_SE};
  enum EDGE_TYPE{B_E, B_W, B_S, B_N, F_E, F_W, F_S, F_N, S_E, N_E, S_W, N_W};
  
  template <class Cell>
  class Node
  {
    //the node of the octree, see octree at the end of this file 
    //each node corresponding to a box when breaking planes
  public:
  
    // Each node points on a cell. 
    Cell cell;
    
    // The type of the node. 
    // Makes some, its geographic situation in the subdivision into 8.
    NODE_TYPE type;
  
    // The father.
    Node* parent;

    //front side
    Node* F_NEchild; 
    Node* F_NWchild;
    Node* F_SEchild;
    Node* F_SWchild; 

    //back side          
    Node* B_NEchild;
    Node* B_NWchild; 
    Node* B_SEchild; 
    Node* B_SWchild; 

    // Depth of the node (that of the father is has 0)
    int depth;

    // The index of the node in the tree.
    int index;

  private :
 
    Node(Node& node);

  public:

    // Constructors
    Node(NODE_TYPE nodeType, Node<Cell>* theParent, Cell &theCell);

    Node();     
  
    // Modifieurs
    void  SetCell(Cell &c) { cell = c; }

    void  SetParent(Node* n){parent = n;}
         
    void  SetF_NEchild( Node<Cell>* n){F_NEchild = n;}
    void  SetF_NWchild( Node<Cell>* n){F_NWchild = n;}
    void  SetF_SEchild( Node<Cell>* n){F_SEchild = n;}
    void  SetF_SWchild( Node<Cell>* n){F_SWchild = n;} 
         
    void  SetB_NEchild( Node<Cell>* n){B_NEchild = n;} 
    void  SetB_NWchild( Node<Cell>* n){B_NWchild = n;} 
    void  SetB_SEchild( Node<Cell>* n){B_SEchild = n;} 
    void  SetB_SWchild( Node<Cell>* n){B_SWchild = n;} 
         
        
    // Accessors
    Cell&          GetCell() {return cell;}

    Node<Cell>*    GetF_NEchild(){return(F_NEchild);}
    Node<Cell>*    GetF_NWchild(){return(F_NWchild);}
    Node<Cell>*    GetF_SEchild(){return(F_SEchild);}
    Node<Cell>*    GetF_SWchild(){return(F_SWchild);}
         
    Node<Cell>*    GetB_NEchild(){return(B_NEchild);} 
    Node<Cell>*    GetB_NWchild(){return(B_NWchild);} 
    Node<Cell>*    GetB_SEchild(){return(B_SEchild);} 
    Node<Cell>*    GetB_SWchild(){return(B_SWchild);} 
 
    // Is the node a leaf?
    bool isLeaf();


    void getAllFaceNeighbors(std::vector< Node<Cell> * > &nbrs); 
  
    void getAllNeighbors(std::vector< Node<Cell> * > &nbrs);
    
    void getAllEdgeNeighbors(std::vector< Node<Cell> * > &nbrs);

    /**************************************** 
     *             DUE SECTION              * 
     ****************************************/
  
    //---------------DUE SOUTH---------------------

    void getAllSouthNeighbors(std::vector< Node<Cell>*>& nbrs);
    Node<Cell>* getSouthNeighborNode();
    void getNorthBoundary(std::vector< Node<Cell>*>& nbrs);

    //---------------DUE NORTH---------------------

    void getAllNorthNeighbors(std::vector< Node<Cell>*>& nbrs);
    Node<Cell>* getNorthNeighborNode();
    void getSouthBoundary(std::vector< Node<Cell>*>& nbrs);

    //---------------DUE WEST---------------------

    void getAllWestNeighbors(std::vector< Node<Cell>*>& nbrs);
    Node<Cell>* getWestNeighborNode();
    void getEastBoundary(std::vector< Node<Cell>*>& nbrs);

    //--------DUE EAST--------------------

    void getWestBoundary(std::vector< Node<Cell>*>& nbrs);
    void getAllEastNeighbors(std::vector< Node<Cell>*>& nbrs);
    Node<Cell>* getEastNeighborNode(); 

    //---------------DUE FRONT--------------------- 

    void getAllFrontNeighbors(std::vector< Node<Cell>*>& nbrs); 
    Node<Cell>* getFrontNeighborNode(); 
    void getBackBoundary(std::vector< Node<Cell>*>& nbrs); 

    //---------------DUE BACK--------------------- 

    void getAllBackNeighbors(std::vector< Node<Cell>*>& nbrs); 
    Node<Cell>* getBackNeighborNode(); 
    void getFrontBoundary(std::vector< Node<Cell>*>& nbrs); 

    /************************************************ 
     *             CORNER-LINE PARTS                * 
     ************************************************/ 
    void getNWLine(std::vector< Node<Cell>*>& line); 
    void getNELine(std::vector< Node<Cell>*>& line); 
    void getSWLine(std::vector< Node<Cell>*>& line); 
    void getSELine(std::vector< Node<Cell>*>& line); 
    void getF_NLine(std::vector< Node<Cell>*>& line); 
    void getF_SLine(std::vector< Node<Cell>*>& line); 
    void getF_ELine(std::vector< Node<Cell>*>& line); 
    void getF_WLine(std::vector< Node<Cell>*>& line); 
    void getB_NLine(std::vector< Node<Cell>*>& line); 
    void getB_SLine(std::vector< Node<Cell>*>& line); 
    void getB_ELine(std::vector< Node<Cell>*>& line); 
    void getB_WLine(std::vector< Node<Cell>*>& line); 
         
    void getNWNeighbors(std::vector< Node<Cell>*>& nbrs); 
    void getNENeighbors(std::vector< Node<Cell>*>& nbrs); 
    void getSWNeighbors(std::vector< Node<Cell>*>& nbrs); 
    void getSENeighbors(std::vector< Node<Cell>*>& nbrs); 
    void getF_NNeighbors(std::vector< Node<Cell>*>& nbrs); 
    void getF_SNeighbors(std::vector< Node<Cell>*>& nbrs); 
    void getF_ENeighbors(std::vector< Node<Cell>*>& nbrs); 
    void getF_WNeighbors(std::vector< Node<Cell>*>& nbrs); 
    void getB_NNeighbors(std::vector< Node<Cell>*>& nbrs); 
    void getB_SNeighbors(std::vector< Node<Cell>*>& nbrs); 
    void getB_ENeighbors(std::vector< Node<Cell>*>& nbrs); 
    void getB_WNeighbors(std::vector< Node<Cell>*>& nbrs); 
    /************************************************ 
     *             TRUE CORNER PARTS                * 
     ************************************************/ 
    Node<Cell>* getF_NWCorner(); 
    Node<Cell>* getF_NECorner(); 
    Node<Cell>* getF_SWCorner(); 
    Node<Cell>* getF_SECorner(); 
    
    Node<Cell>* getB_NWCorner(); 
    Node<Cell>* getB_NECorner(); 
    Node<Cell>* getB_SWCorner(); 
    Node<Cell>* getB_SECorner(); 
 
    Node<Cell>* F_NENeighbor();
    Node<Cell>* F_NWNeighbor(); 
    Node<Cell>* F_SWNeighbor(); 
    Node<Cell>* F_SENeighbor(); 
 
    Node<Cell>* B_NENeighbor();
    Node<Cell>* B_NWNeighbor(); 
    Node<Cell>* B_SWNeighbor(); 
    Node<Cell>* B_SENeighbor(); 

    bool isSmallerThanNeighbors( std::vector< Node<Cell> * > &nbrs );

  };
  

  template <class Cell>
  class Octree
  {
  public:
 
    // The root node.
    Node<Cell>* root;
    
    // Constructor with initialization.
    Octree<Cell>()
      {
        root = new Node<Cell>();
        root->SetParent(NULL);
      } 
     
    // Accessor.
    Node<Cell>* GetRoot(){ return(root); }

  };

  template <class Cell>
  std::ostream& operator<<( std::ostream& os, const Octree<Cell>& octree)
  {return os;}

/*****************************************************************************/
#include "Octree.C"
/*****************************************************************************/
}

__END_NAMESPACE_SYNAPS

#endif // synaps_mesh_octree_H