u3d_prgrid2d.hpp

/* u3d_prgrid2d.hpp */
/* $Id: u3d_prgrid2d.hpp,v 1.5 2008/04/14 08:17:02 urij Exp $ */
#ifndef __u3d_prgrid2d_hpp
#define __u3d_prgrid2d_hpp

#include "u3d_abstract_prgrid2d.hpp"

class U3dPRGrid2d : public U3dAbstractPRGrid2d  
{
  
  friend class U3dPRGrid3d; 
  
public:
  
  U3dPRGrid2d();
  
  U3dPRGrid2d(const U3dPointsAr &points, double g_step, U3dBox *area = NULL);
  
  U3dPRGrid2d(const U3dPoints &points, double g_step, U3dBox *area = NULL);
  
  U3dPRGrid2d(const U3dPoints &points, 
          double g_step_x,
          double g_step_y,
          U3dBox *area = NULL);
  
  U3dPRGrid2d(const U3dPointsAr &points, 
          double g_step_x,
          double g_step_y,
          U3dBox *area = NULL);
  
  U3dPRGrid2d(const U3dPRGrid2d &obj);
  
  virtual ~U3dPRGrid2d();
  
  
  virtual void construct(const U3dPointsAr &points, 
             double g_step_x,
             double g_step_y,
             U3dBox *area = NULL);
  
  virtual void construct(const U3dPoints &points, 
             double g_step_x, 
             double g_step_y, 
             U3dBox *area = NULL);
  
protected:
      
  virtual void push_ip(const U3dPoint *point);
  
  static int get_ip_id(double x, std::vector<double> &grd_x, 
               double dx, double &xmn, double &xmx);
  
  void clear();
  
  virtual void calc_grid_z_levels();
  
  virtual double calc_nip_z(double x, double y);
    
  void expand_grid_area(U3dBox *area);    
  
  static bool add_grid_cell(int ix, int jy, GridCell &cell, GridMatrix &rgrid, 
                double &zmn, double &zmx, double &pzmn, double &pzmx,
                std::vector<double> &xgd, std::vector<double> &ygd,
                double x, double y, bool is_increase_xy = true);
    
private:
  
  class U3dIntEqLeftPart : public UEqAbstractFunction
  {
  public:
    U3dIntEqLeftPart()
    {is_init = false;}
    
    U3dIntEqLeftPart(const U3dIntEqLeftPart &obj);
    
    virtual ~U3dIntEqLeftPart(){}
    
    double calc(double z);
    
    void init(U3dPointsAr &pips)
    {ips = pips; is_init = true;}
  
    void setPCoords(double px, double py)
    {x = px; y = py;}
    
    double get_2d_ip_dist(int i, double x, double y) {
      return ((ips[i]->getX() - x)*(ips[i]->getX() - x) +
          (ips[i]->getY() - y)*(ips[i]->getY() - y));
    }
    
    double get_3d_ip_dist(int i, double x, double y, double z) {
      return ((ips[i]->getX() - x)*(ips[i]->getX() - x) +
          (ips[i]->getY() - y)*(ips[i]->getY() - y) +
          (ips[i]->getZ() - z)*(ips[i]->getZ() - z));
    }
    
  protected:
    
    U3dPointsAr ips;
    
    double x, y;
    
    bool is_init;
  };
    
  UEqDiv2Solve *m_grd_eq_solver;
  
  U3dIntEqLeftPart *m_grd_eq_lp;
      
  double m_prev_zmn, m_prev_zmx;
};

//------------------------------------------------------------------------------------------
class U3dPRGrid2dFiller
{
public:
  
  static bool fill(U3dPRGrid2d::GridMatrix &M);
  
protected:
  
  static double x_i(const U3dPRGrid2d::GridMatrix &M, const U3dPRGrid2d::GridLine &y,
            const U3dPRGrid2d::GridLine &b, int i);
  
  static double y_j(const U3dPRGrid2d::GridMatrix &M, const U3dPRGrid2d::GridLine &x, int j);
  
  static double b_j(const U3dPRGrid2d::GridMatrix &M, const U3dPRGrid2d::GridLine &x, 
            const U3dPRGrid2d::GridLine &y, int j);
};


#endif /* u3d_prgrid2d.hpp */