u3d_model.hpp

/* u3d_model.hpp */
/* $Id: u3d_model.hpp,v 1.40 2009/01/16 17:02:46 guser2 Exp $ */
#ifndef __u3d_model_hpp
#define __u3d_model_hpp

#include "u3d_body.hpp"
#include "u3d_bound.hpp"
#include "u3d_grid.hpp"
#include <u3d_progress.hpp>


class U3dGrid;

//============================================================================
class U3dModel
{
  friend bool U3dModelExport(char*, U3dModel*, char*, U3dProgress*);

public:
  
  U3dModel(U3dModAreaPos modAreaPos, U3dBox modelBox, 
       U3dBoundInfoAr bounds, U3dBodyInfoAr bodies, U3dProgress* prg=0x0);

  U3dModel(U3dModAreaPos modAreaPos, U3dBox modelBox, U3d1dModBodyInfoAr mod1dBodies, U3dProgress* prg=0x0);
  
  U3dModel(U3dModel*, U3dProgress* prg=0x0);
  ~U3dModel();

  double        getVel(U3dPoint p, U3D_WAVE_TYPE wt, int bId=-1);
  
  bool          getVelGrad(U3dPoint point, double &v, double &vf, double &vaz, U3D_WAVE_TYPE wt) ;
  
  bool          getVelGrad(U3dPoint point, int bodyId, double &v, double &vf, double &vaz, U3D_WAVE_TYPE wt) ;

  //  double        getDensity(U3dPoint p) const;
  
  int           getBodyId(U3dPoint);
  
  
  U3dBody*      getBody(int bodyId);


  const U3dBody*      getBody(int bodyId) const { return const_cast<U3dModel&>(*this).getBody(bodyId); };
  
  int           getBodiesNum() const { return m_bodies.size(); }
  
  U3dBox        getModelBox() const  { return m_modellingArea; }
     
  U3dGrid*      getGrid() { return m_grid; }

  const U3dGrid*      getGrid() const { return m_grid; }

  
  U3dBound*     getBound(int boundId) const;
  
  int           getBoundsNum() const { return m_bounds.size(); }
  
  U3dModAreaPos getModelAreaPos() const;
  
  void          setModelAreaPos(U3dModAreaPos MAP);
  
  bool          getFBNormal(U3dPoint p, double &iA, double &iAz);
  
  bool          getReady() { return m_ready;  }

  void          addDescription(const char* description);
  
  std::vector<int>        getCommonBoundsIds(int bodyId_0, int bodyId_1);
  
  //protected: 
  
  void constructGrid(bool plane_surf_model); 
  
  void gridCrusher(int boundId);
  
  void getCommonCells(U3dGridCellsArray *common_cells, U3dBox* surfBox,  U3dGridCell* root);
  
  void recursiveDivideCell(int boundId, int_set &trianglesId_ar, U3dGridCell* cell);
  
  
  
  
  void fillGridInfoSimple();
  
  void recursiveFillCellInfo(U3dGridCell* cell);
  
  void fillGridInfoComplex();
  
  void getNeighbours(U3dBox box, U3dGridCellsArray &cell_array, U3dGridCellsArray &neighbour_cells);
  
  void fillBoundCellsInfo();
  
  void fillBoundCellsInfo(std::vector<int> bodies, int boundId, U3dGridCell *cell, U3D_COLOR b_color);
  
  
  
  
  U3dGridCell* getBodyIdFromGrid(U3dPoint p, int &body_id) ;
  
  int getBodyIdFromCell(U3dPoint p, U3dGridCell* cell);
  
  int getBodyIdDummy(U3dPoint p);
  
  
  
  
  bool getNormalLimPoints(U3dPoint p, U3dPoint *&p0, U3dPoint *&p1, 
              double &iA0, double &iAz0, double &iA1, double &iAz1);
  
  void defineNearestIntPoints(U3dPoint p, int bodyId, U3dPointsAr intersection_ps, std::vector<int> intersected_bounds_ind, 
                  int &p0_ind, int &p1_ind);
    
  void interpolateNormals(U3dPoint p, U3dPoint* p0, U3dPoint* p1, 
              double iA0, double iAz0, double iA1, double iAz1, 
              double &iA, double &iAz);

  void intersectCellTriangles(U3dPoint* p0, U3dPoint* p1, U3dGridCell* goal_cell, std::vector<int>& int_trIds, U3dPointsAr& int_points);
  
  void clearOnStop();

  void checkInternalData(std::string &errstr);

  bool       m_ready;              
  char*      m_name;
  char*      m_desc;
  
  U3dModAreaPos m_modelAreaPosition;  
  U3dBodiesAr    m_bodies;         
  U3dBoundsAr    m_bounds;         
  U3dBox         m_modellingArea;  
  U3dGrid*       m_grid;           
  U3dProgress*    progress;


};

#endif /* u3d_model.hpp */