u3d_abstract_prgrid2d.hpp

/* u3d_abstract_prgrid2d.hpp */
/* $Id: u3d_abstract_prgrid2d.hpp,v 1.3 2008/10/28 08:12:30 hasher Exp $ */
#ifndef __u3d_abstract_prgrid2d_hpp
#define __u3d_abstract_prgrid2d_hpp

#include <mth/u_base_math.hpp>
#include <mth/u3d_point.hpp>
#include <mth/u3d_box.hpp>

class U3dAbstractPRGrid2d
{
public:
  
  U3dAbstractPRGrid2d();
  
  U3dAbstractPRGrid2d(const U3dPointsAr &points, double g_step, U3dBox *area = NULL);
  
  U3dAbstractPRGrid2d(const U3dPoints &points, double g_step, U3dBox *area = NULL);
  
  U3dAbstractPRGrid2d(const U3dPoints &points, 
              double g_step_x, 
              double g_step_y, 
              U3dBox *area = NULL);
  
  U3dAbstractPRGrid2d(const U3dPointsAr &points, 
              double g_step_x, 
              double g_step_y, 
              U3dBox *area = NULL);
  
  U3dAbstractPRGrid2d(const U3dAbstractPRGrid2d &obj);
  
  virtual ~U3dAbstractPRGrid2d();
  
  virtual U3dAbstractPRGrid2d* clone();
  
  //------------------------------------------------------------------------------------------
  
  virtual void construct(const U3dPointsAr &points, double g_step, U3dBox *area = NULL);
  
  virtual void construct(const U3dPoints &points, double g_step, U3dBox *area = NULL);
  
  void setMinGridStepX(double eps) {
    minGridEpsX = (eps < 0.)?(0.):(eps);
  }
  
  void setMinGridStepY(double eps) {
    minGridEpsY = (eps < 0.)?(0.):(eps);
  }
  
  double getMinGridStepX() {
    return minGridEpsX;
  }  
  
  double getMinGridStepY() {
    return minGridEpsX;
  }  
    
  void getGridArea(U3dPoint &min, U3dPoint &max) {
    min.setXYZ(m_area3d.xmn, m_area3d.ymn, m_area3d.zmn);
    max.setXYZ(m_area3d.xmx, m_area3d.ymx, m_area3d.zmx);
  }
  
  //------------------------------------------------------------------------------------------
  
  int getGridXSize() const {
    return m_grd_x.size();
  }
  
  int getGridYSize() const {
    return m_grd_y.size();
  }
  
  int getGridPoint(int i, int j, U3dPoint &p) const;
  
  int setGridPointZ(int i, int j, double z);
  
  U3dPointsAr& getInitialPoints() {
    return m_ips;
  }
  
  //------------------------------------------------------------------------------------------
  
  virtual void addPoint(U3dPoint*){;};
  
  virtual bool removePoint(int /*ind*/){return false;};
 
  // ------------------------------------------------------------------------------------------
  
  struct GridCell
  {
    GridCell(int i_ind, double i_z) {
      ip_ind = i_ind;
      z = i_z;
    }
    
    int ip_ind;    
    double z;      
  };
  
  typedef std::vector<GridCell> GridLine;
  
  typedef std::vector<GridLine> GridMatrix;
  
  struct Area3d
  {
    double xmn,xmx,ymn,ymx,zmn,zmx;
  };
  
protected:
  
  U3dPointsAr m_ips;
  
  double minGridEpsX;
  double minGridEpsY;
  
  std::vector<double> m_grd_x, m_grd_y;
  
  GridMatrix m_grid;
  
  Area3d m_area3d;
  
  static void correct_id(int &id, int size) {
    if (id < 0)
      id = 0;
    else if (id >= size)
      id = size - 1; 
  }
    
private:
    
};

#endif /* u3d_abstract_prgrid2d.hpp */