u3d_grid.hpp

/* u3d_grid.hpp */
/* $Id: u3d_grid.hpp,v 1.2 2008/05/29 12:13:35 sasha Exp $ */
#ifndef __u3d_grid_hpp
#define __u3d_grid_hpp

#include "u3d_grid_cell.hpp"
//#include <u_message.hpp>

enum U3D_CELL_TOPOLOGY
{
  WHOLE_CELL = 0,  
  DIVIDED_CELL     
};

//class U3dModel;

class U3dGrid
{
public:
  U3dGrid (const U3dBox* modelBox);//, double min_cell_size);
  
  virtual ~U3dGrid();
  
  /* Return array of cells which lie into the given 3d box or intersect it. */
  //    IntAr getCellsInBox(U3dBox box);
  
  const U3dGridCell* findCell(U3dPoint point);
  
  const U3dGridCell* findCell(U3dBox box);
  
  U3dGridCell* findCell(int ID);
  
  /* Get all neighbours of given cell. 
     Returns pointer to first neighbour in array of ones.
     n - number of neihbours in array. */
  //U3dGridCell* getNeighbours(const U3dGridCell* cell, unsigned* n);  //not implemented yet
  
  void divideCell(U3dGridCell* cell);
  
  void mergeSubCells(U3dGridCell* cell);
  
  U3dGridCell* getRoot(){ return m_Root; };
  
  
  /* In the model grid find first entrance of cell with given parameters.
     bodiId - idebtifier of the body
     cellType - parameter that equal WHOLE_CELL if cell is not intersected by any model surface
     and DIVIDED_CELL if cell is intersected by one or more surfaces.
     if cellType is DIVIDED_CELL, this function finds the cell whose "first" point (point with min values of x,y,z)
     belongs to the given body. */
  //U3dGridCell* findBodyCell(U3dBodyId bodyId, U3D_CELL_TOPOLOGY cellType);
  
  void updateMaxCellId(int cellId){ m_maxCellId = cellId; }
  
  
  /*------------DEBUG-------------------*/
  void printCell();
  void recursivePrintCell(const U3dGridCell* initCell);
  /*------------DEBUG-------------------*/
  
  bool getCommonCells(U3dGridCellsArray *common_cells, U3dBox* surfBox,  U3dGridCell* root);
  
  U3dGridCellsArray getEmptyCellsList();
  
  U3dGridCellsArray getBodyCellsList(int bodyId);
  
  U3dGridCellsArray getBoundCellsList(int boundId);
  
  U3dGridCellsArray getColumnBoundCellsList(U3dPoint p, int boundId) const;
  
  bool getReady() { return m_ready; }
    
  void setReady(bool ready) { m_ready = ready; }
  
protected:
  //const U3dModel1 *m_parentModel; /**< model object to which serves this grid */
  U3dGridCell   *m_Root;    
  static unsigned m_maxCellID;
  
private:    
  int m_ready;              
  int m_maxCellId;          
  void deleteGridCells(U3dGridCell* root);
  
  int pointInCell(U3dPoint point, const U3dGridCell* cell);
  
  U3dGridCell* recursiveFindCell(U3dGridCell* initCell, U3dBox box);
  
  U3dGridCell* recursiveFindCell(U3dGridCell* initCell, U3dPoint p);
  
  U3dGridCell* recursiveFindCell(U3dGridCell* initCell, int ID);
  
  void recursiveFillEmptyCellsList(U3dGridCell *cell, U3dGridCellsArray &cell_ar);
  
  void recursiveFindBodyCell(U3dGridCell* cell, int bodyId, U3dGridCellsArray &cell_ar);
    
  void recursiveFindBoundCell(U3dGridCell* cell, int boundId, U3dGridCellsArray &cell_ar);
  
  void recursiveFindColumnBoundCell(U3dGridCell* cell, U3dPoint p, int boundId, U3dGridCellsArray &cell_ar) const;
  
  /* Find cell by body id starting with initial cell i.e. only among cells that are children of this cell */
  //U3dGridCell* recursiveFindBodyCell(U3dGridCell* cell, U3dBodyId bodyId, U3D_CELL_TOPOLOGY cellType);
  
};

#if 0
class U3dModel1
{
public:
  U3dModel1()
  { 
    U3dPoint p1(1., 1., 0.); 
    U3dPoint p2(4., 4., 2.5);
    m_Root = new U3dBox(p1, p2);
    m_Grid = new U3dGrid(m_Root);
  };
  
  U3dBox* getModelBox() const { return m_Root; };
  U3dGrid* getGrid() { return m_Grid; };
  
protected:
  U3dBox* m_Root;
  U3dGrid* m_Grid;
};
#endif

#endif /* u3d_grid.hpp */