rt_shooter.hpp

// rtShooter.H
// $Id: rt_shooter.hpp,v 1.8 2008/08/18 08:18:56 sasha Exp $
//---------------------------------------------------------------------
#ifndef __rtShooterH
#define __rtShooterH

#include <math.h>
#include <zm/ZmProgress.H>
#include "ray_tracing.hpp"
#include <mth/u2d_box.hpp>

//---------------------------------------------------------------------
// ÁâàãÚâãàë ÔÛï åàÐÝÕÝØï àÕ×ãÛìâÐâÞÒ ÒëçØáÛÕÝØÙ

// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ Þ ÛãçÐå ßÞßÐÒèØå Ò áÕÙáÜÞßàØÕÜÝØÚØ
struct RecInfo
{
  int     recNum;    // ÝÞÜÕà ßàØÕÜÝØÚÐ 
  double  recAmpl;   // ÐÜßÛØâãÔÐ Ò ßàØÕÜÝØÚÕ 
  double  recT;      // ÒàÕÜï ßàØåÞÔÐ ÛãçÐ Ò ßàØÕÜÝØÚ
  //double  recF;      // ãÓÞÛ ßÐÔÕÝØï ÛãçÐ ÝÐ ÓàÐÝØæã
  double  recAngle;  // ãÓÞÛ ßÞÔ ÚÞâÞàëÜ Ûãç ßÞßÐÛ Ò ßàØÕÜÝØÚ
  double  dr;        // àÐáâÞïÝØÕ Þâ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø áÚÒÐÖØÝë ÔÞ ßàØÕÜÝØÚÐ

  double  sx;        // ÚÞÞàÔØÝÐâë âÞçÚØ ÝÐ ÓàÐÝØæÕ, ÞâÚãÔÐ Ûãç ßàØèÕÛ Ò ßàØÕÜÝØÚ
  double  sz;        //
  
  double  iA;        // ÚÐáÐâÕÛìÝÐï Ú ÓàÐÝØæÕ Ò âÞçÚÕ ÞâàÐÖÕÝØï/ßàÕÛÞÜÛÕÝØï
  double  inF;       // ãÓÞÛ ßÐÔÕÝØï ÝÐ ÓàÐÝØæã 
  double  outF;      // ãÓÞÛ ÞâàÐÖÕÝØï/ßàÕÛÞÜÛÕÝØï
  double  startAngle;// ãÓÞÛ ÒëåÞÔÐ ÛãçÐ Ø× ØáâÞçÝØÚÐ
};

//--------------------
// ²°À¸°½Â 1 (ÕÔØÝØæÐ åàÐÝÕÝØï - âÞçÚÐ ÝÐ ÓàÐÝØæÕ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÑáâàÕÛïÝëå ÓàÐÝØæÐå
struct BShootRes
{
  int bodyNum;      // ½ÞÜÕà âÕÛÐ Ø× ÚÞâÞàÞÓÞ ßàØèÕÛ Ûãç
  int boundNum;     // ½ÞÜÕà ÓàÐÝØæë, ÚÞâÞàãî ßÕàÕáÕÚ Ûãç
  double stAngle;   // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double iAngle;    // ÃÓÞÛ ßÞÔÚÞâÞàëÜ Ûãç "ÒÞâÚÝãÛáï" Ò ÓàÐÝØæã
  double ix;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë âÕÛÐ
  double iz;        // --
  double it;        // ²àÕÜï ßÞ Ûãçã ÝÐ ÜÞÜÕÝâ ßÕàÕáÕçÕÝØï
};

/// LS code structure
struct LSCode
{
  int_ar   *bNum; 
  int_ar   *rtr;
  int_ar   *vPS;
};


typedef BShootRes* pBShootRes;
typedef objects_ar<pBShootRes> BSootResAr;
typedef objects_ar<RecInfo*> RecInfoAr;

//--------------------
// ²°À¸°½Â 2 (ÕÔØÝØæÐ åàÐÝÕÝØï - ÛØÝÕÙÝëÙ ØáâÞçÝØÚ - çÐáâì ÞÑáâàÕÛïÝÝÞÙ ÓàÐÝØæë
//            ÜÕÖÔã ×ÞÝÐÜØ âÕÝØ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÔÝÞÜ ÛØÝÕÙÝÞÜ ØáâÞçÝØÚÕ
struct LSInfo
{
  double_ar stAngle;  // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double_ar x;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë
  double_ar z;        // --
  double_ar t;        // ²àÕÜï ßÞ Ûãçã ÔÞ ßÕàÕáÕçÕÝØï 
  double_ar f;        // ÃÓÞÛ ÒåÞÔÐ ÛãçÐ Ò ÓàÐÝØæã
  double_ar iA;       // ÃÓÞÛ ÚÐáÐâÕÛìÝÞÙ Ú ÓàÐÝØæÕ Ò âÞçÚÕ ßÕàÕáÕçÕÝØï
  LSInfo* StartLS;    // pointer to start linear source
  int_ar StNode;      // number of node which (x, z) point was obtained from
};


// ÁâàãÚâãàÐ áÞÔÕàÖÕéÐï ØÝäÞàÜÐæØî Þ ÝÕáÚÞÛìÚØå ÛØÝÕÙÝëå ØáâÞçÝØÚÐå
struct LSList
{
  objects_ar<LSInfo*>     LSInfos;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  bNum;        // ½ÞÜÕà ÓàÐÝØæë, ÝÐ ÚÞâÞàÞÙ ÛÕÖØâ ØáâÞçÝØÚ
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif



// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ Þ ÛãçÐå ßÞßÐÒèØå Ò áÕÙáÜÞßàØÕÜÝØÚØstruct RecInfo
{
  int     recNum;    // ÝÞÜÕà ßàØÕÜÝØÚÐ 
  double  recAmpl;   // ÐÜßÛØâãÔÐ Ò ßàØÕÜÝØÚÕ 
  double  recT;      // ÒàÕÜï ßàØåÞÔÐ ÛãçÐ Ò ßàØÕÜÝØÚ
  //double  recF;      // ãÓÞÛ ßÐÔÕÝØï ÛãçÐ ÝÐ ÓàÐÝØæã
  double  recAngle;  // ãÓÞÛ ßÞÔ ÚÞâÞàëÜ Ûãç ßÞßÐÛ Ò ßàØÕÜÝØÚ
  double  dr;        // àÐáâÞïÝØÕ Þâ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø áÚÒÐÖØÝë ÔÞ ßàØÕÜÝØÚÐ

  double  sx;        // ÚÞÞàÔØÝÐâë âÞçÚØ ÝÐ ÓàÐÝØæÕ, ÞâÚãÔÐ Ûãç ßàØèÕÛ Ò ßàØÕÜÝØÚ
  double  sz;        //
  
  double  iA;        // ÚÐáÐâÕÛìÝÐï Ú ÓàÐÝØæÕ Ò âÞçÚÕ ÞâàÐÖÕÝØï/ßàÕÛÞÜÛÕÝØï
  double  inF;       // ãÓÞÛ ßÐÔÕÝØï ÝÐ ÓàÐÝØæã 
  double  outF;      // ãÓÞÛ ÞâàÐÖÕÝØï/ßàÕÛÞÜÛÕÝØï
  double  startAngle;// ãÓÞÛ ÒëåÞÔÐ ÛãçÐ Ø× ØáâÞçÝØÚÐ
};

//--------------------
// ²°À¸°½Â 1 (ÕÔØÝØæÐ åàÐÝÕÝØï - âÞçÚÐ ÝÐ ÓàÐÝØæÕ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÑáâàÕÛïÝëå ÓàÐÝØæÐå
struct BShootRes
{
  int bodyNum;      // ½ÞÜÕà âÕÛÐ Ø× ÚÞâÞàÞÓÞ ßàØèÕÛ Ûãç
  int boundNum;     // ½ÞÜÕà ÓàÐÝØæë, ÚÞâÞàãî ßÕàÕáÕÚ Ûãç
  double stAngle;   // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double iAngle;    // ÃÓÞÛ ßÞÔÚÞâÞàëÜ Ûãç "ÒÞâÚÝãÛáï" Ò ÓàÐÝØæã
  double ix;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë âÕÛÐ
  double iz;        // --
  double it;        // ²àÕÜï ßÞ Ûãçã ÝÐ ÜÞÜÕÝâ ßÕàÕáÕçÕÝØï
};

/// LS code structure
struct LSCode
{
  int_ar   *bNum; 
  int_ar   *rtr;
  int_ar   *vPS;
};


typedef BShootRes* pBShootRes;
typedef objects_ar<pBShootRes> BSootResAr;
typedef objects_ar<RecInfo*> RecInfoAr;

//--------------------
// ²°À¸°½Â 2 (ÕÔØÝØæÐ åàÐÝÕÝØï - ÛØÝÕÙÝëÙ ØáâÞçÝØÚ - çÐáâì ÞÑáâàÕÛïÝÝÞÙ ÓàÐÝØæë
//            ÜÕÖÔã ×ÞÝÐÜØ âÕÝØ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÔÝÞÜ ÛØÝÕÙÝÞÜ ØáâÞçÝØÚÕ
struct LSInfo
{
  double_ar stAngle;  // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double_ar x;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë
  double_ar z;        // --
  double_ar t;        // ²àÕÜï ßÞ Ûãçã ÔÞ ßÕàÕáÕçÕÝØï 
  double_ar f;        // ÃÓÞÛ ÒåÞÔÐ ÛãçÐ Ò ÓàÐÝØæã
  double_ar iA;       // ÃÓÞÛ ÚÐáÐâÕÛìÝÞÙ Ú ÓàÐÝØæÕ Ò âÞçÚÕ ßÕàÕáÕçÕÝØï
  LSInfo* StartLS;    // pointer to start linear source
  int_ar StNode;      // number of node which (x, z) point was obtained from
};


// ÁâàãÚâãàÐ áÞÔÕàÖÕéÐï ØÝäÞàÜÐæØî Þ ÝÕáÚÞÛìÚØå ÛØÝÕÙÝëå ØáâÞçÝØÚÐå
struct LSList
{
  objects_ar<LSInfo*>     LSInfos;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  bNum;        // ½ÞÜÕà ÓàÐÝØæë, ÝÐ ÚÞâÞàÞÙ ÛÕÖØâ ØáâÞçÝØÚ
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

struct RecInfo
{
  int     recNum;    // ÝÞÜÕà ßàØÕÜÝØÚÐ 
  double  recAmpl;   // ÐÜßÛØâãÔÐ Ò ßàØÕÜÝØÚÕ 
  double  recT;      // ÒàÕÜï ßàØåÞÔÐ ÛãçÐ Ò ßàØÕÜÝØÚ
  //double  recF;      // ãÓÞÛ ßÐÔÕÝØï ÛãçÐ ÝÐ ÓàÐÝØæã  double  recAngle;  // ãÓÞÛ ßÞÔ ÚÞâÞàëÜ Ûãç ßÞßÐÛ Ò ßàØÕÜÝØÚ
  double  dr;        // àÐáâÞïÝØÕ Þâ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø áÚÒÐÖØÝë ÔÞ ßàØÕÜÝØÚÐ

  double  sx;        // ÚÞÞàÔØÝÐâë âÞçÚØ ÝÐ ÓàÐÝØæÕ, ÞâÚãÔÐ Ûãç ßàØèÕÛ Ò ßàØÕÜÝØÚ
  double  sz;        //
  
  double  iA;        // ÚÐáÐâÕÛìÝÐï Ú ÓàÐÝØæÕ Ò âÞçÚÕ ÞâàÐÖÕÝØï/ßàÕÛÞÜÛÕÝØï
  double  inF;       // ãÓÞÛ ßÐÔÕÝØï ÝÐ ÓàÐÝØæã 
  double  outF;      // ãÓÞÛ ÞâàÐÖÕÝØï/ßàÕÛÞÜÛÕÝØï
  double  startAngle;// ãÓÞÛ ÒëåÞÔÐ ÛãçÐ Ø× ØáâÞçÝØÚÐ
};

//--------------------
// ²°À¸°½Â 1 (ÕÔØÝØæÐ åàÐÝÕÝØï - âÞçÚÐ ÝÐ ÓàÐÝØæÕ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÑáâàÕÛïÝëå ÓàÐÝØæÐå
struct BShootRes
{
  int bodyNum;      // ½ÞÜÕà âÕÛÐ Ø× ÚÞâÞàÞÓÞ ßàØèÕÛ Ûãç
  int boundNum;     // ½ÞÜÕà ÓàÐÝØæë, ÚÞâÞàãî ßÕàÕáÕÚ Ûãç
  double stAngle;   // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double iAngle;    // ÃÓÞÛ ßÞÔÚÞâÞàëÜ Ûãç "ÒÞâÚÝãÛáï" Ò ÓàÐÝØæã
  double ix;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë âÕÛÐ
  double iz;        // --
  double it;        // ²àÕÜï ßÞ Ûãçã ÝÐ ÜÞÜÕÝâ ßÕàÕáÕçÕÝØï
};

/// LS code structure
struct LSCode
{
  int_ar   *bNum; 
  int_ar   *rtr;
  int_ar   *vPS;
};


typedef BShootRes* pBShootRes;
typedef objects_ar<pBShootRes> BSootResAr;
typedef objects_ar<RecInfo*> RecInfoAr;

//--------------------
// ²°À¸°½Â 2 (ÕÔØÝØæÐ åàÐÝÕÝØï - ÛØÝÕÙÝëÙ ØáâÞçÝØÚ - çÐáâì ÞÑáâàÕÛïÝÝÞÙ ÓàÐÝØæë
//            ÜÕÖÔã ×ÞÝÐÜØ âÕÝØ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÔÝÞÜ ÛØÝÕÙÝÞÜ ØáâÞçÝØÚÕ
struct LSInfo
{
  double_ar stAngle;  // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double_ar x;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë
  double_ar z;        // --
  double_ar t;        // ²àÕÜï ßÞ Ûãçã ÔÞ ßÕàÕáÕçÕÝØï 
  double_ar f;        // ÃÓÞÛ ÒåÞÔÐ ÛãçÐ Ò ÓàÐÝØæã
  double_ar iA;       // ÃÓÞÛ ÚÐáÐâÕÛìÝÞÙ Ú ÓàÐÝØæÕ Ò âÞçÚÕ ßÕàÕáÕçÕÝØï
  LSInfo* StartLS;    // pointer to start linear source
  int_ar StNode;      // number of node which (x, z) point was obtained from
};


// ÁâàãÚâãàÐ áÞÔÕàÖÕéÐï ØÝäÞàÜÐæØî Þ ÝÕáÚÞÛìÚØå ÛØÝÕÙÝëå ØáâÞçÝØÚÐå
struct LSList
{
  objects_ar<LSInfo*>     LSInfos;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  bNum;        // ½ÞÜÕà ÓàÐÝØæë, ÝÐ ÚÞâÞàÞÙ ÛÕÖØâ ØáâÞçÝØÚ
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

  double  recAngle;  // ãÓÞÛ ßÞÔ ÚÞâÞàëÜ Ûãç ßÞßÐÛ Ò ßàØÕÜÝØÚ
  double  dr;        // àÐáâÞïÝØÕ Þâ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø áÚÒÐÖØÝë ÔÞ ßàØÕÜÝØÚÐ
  double  sx;        // ÚÞÞàÔØÝÐâë âÞçÚØ ÝÐ ÓàÐÝØæÕ, ÞâÚãÔÐ Ûãç ßàØèÕÛ Ò ßàØÕÜÝØÚ
  double  sz;        //
  
  double  iA;        // ÚÐáÐâÕÛìÝÐï Ú ÓàÐÝØæÕ Ò âÞçÚÕ ÞâàÐÖÕÝØï/ßàÕÛÞÜÛÕÝØï
  double  inF;       // ãÓÞÛ ßÐÔÕÝØï ÝÐ ÓàÐÝØæã 
  double  outF;      // ãÓÞÛ ÞâàÐÖÕÝØï/ßàÕÛÞÜÛÕÝØï
  double  startAngle;// ãÓÞÛ ÒëåÞÔÐ ÛãçÐ Ø× ØáâÞçÝØÚÐ
};

//--------------------
// ²°À¸°½Â 1 (ÕÔØÝØæÐ åàÐÝÕÝØï - âÞçÚÐ ÝÐ ÓàÐÝØæÕ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÑáâàÕÛïÝëå ÓàÐÝØæÐå
struct BShootRes
{
  int bodyNum;      // ½ÞÜÕà âÕÛÐ Ø× ÚÞâÞàÞÓÞ ßàØèÕÛ Ûãç
  int boundNum;     // ½ÞÜÕà ÓàÐÝØæë, ÚÞâÞàãî ßÕàÕáÕÚ Ûãç
  double stAngle;   // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double iAngle;    // ÃÓÞÛ ßÞÔÚÞâÞàëÜ Ûãç "ÒÞâÚÝãÛáï" Ò ÓàÐÝØæã
  double ix;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë âÕÛÐ
  double iz;        // --
  double it;        // ²àÕÜï ßÞ Ûãçã ÝÐ ÜÞÜÕÝâ ßÕàÕáÕçÕÝØï
};

/// LS code structure
struct LSCode
{
  int_ar   *bNum; 
  int_ar   *rtr;
  int_ar   *vPS;
};


typedef BShootRes* pBShootRes;
typedef objects_ar<pBShootRes> BSootResAr;
typedef objects_ar<RecInfo*> RecInfoAr;

//--------------------
// ²°À¸°½Â 2 (ÕÔØÝØæÐ åàÐÝÕÝØï - ÛØÝÕÙÝëÙ ØáâÞçÝØÚ - çÐáâì ÞÑáâàÕÛïÝÝÞÙ ÓàÐÝØæë
//            ÜÕÖÔã ×ÞÝÐÜØ âÕÝØ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÔÝÞÜ ÛØÝÕÙÝÞÜ ØáâÞçÝØÚÕ
struct LSInfo
{
  double_ar stAngle;  // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double_ar x;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë
  double_ar z;        // --
  double_ar t;        // ²àÕÜï ßÞ Ûãçã ÔÞ ßÕàÕáÕçÕÝØï 
  double_ar f;        // ÃÓÞÛ ÒåÞÔÐ ÛãçÐ Ò ÓàÐÝØæã
  double_ar iA;       // ÃÓÞÛ ÚÐáÐâÕÛìÝÞÙ Ú ÓàÐÝØæÕ Ò âÞçÚÕ ßÕàÕáÕçÕÝØï
  LSInfo* StartLS;    // pointer to start linear source
  int_ar StNode;      // number of node which (x, z) point was obtained from
};


// ÁâàãÚâãàÐ áÞÔÕàÖÕéÐï ØÝäÞàÜÐæØî Þ ÝÕáÚÞÛìÚØå ÛØÝÕÙÝëå ØáâÞçÝØÚÐå
struct LSList
{
  objects_ar<LSInfo*>     LSInfos;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  bNum;        // ½ÞÜÕà ÓàÐÝØæë, ÝÐ ÚÞâÞàÞÙ ÛÕÖØâ ØáâÞçÝØÚ
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif


  double  sx;        // ÚÞÞàÔØÝÐâë âÞçÚØ ÝÐ ÓàÐÝØæÕ, ÞâÚãÔÐ Ûãç ßàØèÕÛ Ò ßàØÕÜÝØÚ
  double  sz;        //
  
  double  iA;        // ÚÐáÐâÕÛìÝÐï Ú ÓàÐÝØæÕ Ò âÞçÚÕ ÞâàÐÖÕÝØï/ßàÕÛÞÜÛÕÝØï  double  inF;       // ãÓÞÛ ßÐÔÕÝØï ÝÐ ÓàÐÝØæã 
  double  outF;      // ãÓÞÛ ÞâàÐÖÕÝØï/ßàÕÛÞÜÛÕÝØï
  double  startAngle;// ãÓÞÛ ÒëåÞÔÐ ÛãçÐ Ø× ØáâÞçÝØÚÐ
};

//--------------------
// ²°À¸°½Â 1 (ÕÔØÝØæÐ åàÐÝÕÝØï - âÞçÚÐ ÝÐ ÓàÐÝØæÕ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÑáâàÕÛïÝëå ÓàÐÝØæÐå
struct BShootRes
{
  int bodyNum;      // ½ÞÜÕà âÕÛÐ Ø× ÚÞâÞàÞÓÞ ßàØèÕÛ Ûãç
  int boundNum;     // ½ÞÜÕà ÓàÐÝØæë, ÚÞâÞàãî ßÕàÕáÕÚ Ûãç
  double stAngle;   // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double iAngle;    // ÃÓÞÛ ßÞÔÚÞâÞàëÜ Ûãç "ÒÞâÚÝãÛáï" Ò ÓàÐÝØæã
  double ix;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë âÕÛÐ
  double iz;        // --
  double it;        // ²àÕÜï ßÞ Ûãçã ÝÐ ÜÞÜÕÝâ ßÕàÕáÕçÕÝØï
};

/// LS code structure
struct LSCode
{
  int_ar   *bNum; 
  int_ar   *rtr;
  int_ar   *vPS;
};


typedef BShootRes* pBShootRes;
typedef objects_ar<pBShootRes> BSootResAr;
typedef objects_ar<RecInfo*> RecInfoAr;

//--------------------
// ²°À¸°½Â 2 (ÕÔØÝØæÐ åàÐÝÕÝØï - ÛØÝÕÙÝëÙ ØáâÞçÝØÚ - çÐáâì ÞÑáâàÕÛïÝÝÞÙ ÓàÐÝØæë
//            ÜÕÖÔã ×ÞÝÐÜØ âÕÝØ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÔÝÞÜ ÛØÝÕÙÝÞÜ ØáâÞçÝØÚÕ
struct LSInfo
{
  double_ar stAngle;  // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double_ar x;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë
  double_ar z;        // --
  double_ar t;        // ²àÕÜï ßÞ Ûãçã ÔÞ ßÕàÕáÕçÕÝØï 
  double_ar f;        // ÃÓÞÛ ÒåÞÔÐ ÛãçÐ Ò ÓàÐÝØæã
  double_ar iA;       // ÃÓÞÛ ÚÐáÐâÕÛìÝÞÙ Ú ÓàÐÝØæÕ Ò âÞçÚÕ ßÕàÕáÕçÕÝØï
  LSInfo* StartLS;    // pointer to start linear source
  int_ar StNode;      // number of node which (x, z) point was obtained from
};


// ÁâàãÚâãàÐ áÞÔÕàÖÕéÐï ØÝäÞàÜÐæØî Þ ÝÕáÚÞÛìÚØå ÛØÝÕÙÝëå ØáâÞçÝØÚÐå
struct LSList
{
  objects_ar<LSInfo*>     LSInfos;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  bNum;        // ½ÞÜÕà ÓàÐÝØæë, ÝÐ ÚÞâÞàÞÙ ÛÕÖØâ ØáâÞçÝØÚ
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

  double  inF;       // ãÓÞÛ ßÐÔÕÝØï ÝÐ ÓàÐÝØæã   double  outF;      // ãÓÞÛ ÞâàÐÖÕÝØï/ßàÕÛÞÜÛÕÝØï
  double  startAngle;// ãÓÞÛ ÒëåÞÔÐ ÛãçÐ Ø× ØáâÞçÝØÚÐ
};

//--------------------
// ²°À¸°½Â 1 (ÕÔØÝØæÐ åàÐÝÕÝØï - âÞçÚÐ ÝÐ ÓàÐÝØæÕ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÑáâàÕÛïÝëå ÓàÐÝØæÐå
struct BShootRes
{
  int bodyNum;      // ½ÞÜÕà âÕÛÐ Ø× ÚÞâÞàÞÓÞ ßàØèÕÛ Ûãç
  int boundNum;     // ½ÞÜÕà ÓàÐÝØæë, ÚÞâÞàãî ßÕàÕáÕÚ Ûãç
  double stAngle;   // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double iAngle;    // ÃÓÞÛ ßÞÔÚÞâÞàëÜ Ûãç "ÒÞâÚÝãÛáï" Ò ÓàÐÝØæã
  double ix;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë âÕÛÐ
  double iz;        // --
  double it;        // ²àÕÜï ßÞ Ûãçã ÝÐ ÜÞÜÕÝâ ßÕàÕáÕçÕÝØï
};

/// LS code structure
struct LSCode
{
  int_ar   *bNum; 
  int_ar   *rtr;
  int_ar   *vPS;
};


typedef BShootRes* pBShootRes;
typedef objects_ar<pBShootRes> BSootResAr;
typedef objects_ar<RecInfo*> RecInfoAr;

//--------------------
// ²°À¸°½Â 2 (ÕÔØÝØæÐ åàÐÝÕÝØï - ÛØÝÕÙÝëÙ ØáâÞçÝØÚ - çÐáâì ÞÑáâàÕÛïÝÝÞÙ ÓàÐÝØæë
//            ÜÕÖÔã ×ÞÝÐÜØ âÕÝØ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÔÝÞÜ ÛØÝÕÙÝÞÜ ØáâÞçÝØÚÕ
struct LSInfo
{
  double_ar stAngle;  // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double_ar x;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë
  double_ar z;        // --
  double_ar t;        // ²àÕÜï ßÞ Ûãçã ÔÞ ßÕàÕáÕçÕÝØï 
  double_ar f;        // ÃÓÞÛ ÒåÞÔÐ ÛãçÐ Ò ÓàÐÝØæã
  double_ar iA;       // ÃÓÞÛ ÚÐáÐâÕÛìÝÞÙ Ú ÓàÐÝØæÕ Ò âÞçÚÕ ßÕàÕáÕçÕÝØï
  LSInfo* StartLS;    // pointer to start linear source
  int_ar StNode;      // number of node which (x, z) point was obtained from
};


// ÁâàãÚâãàÐ áÞÔÕàÖÕéÐï ØÝäÞàÜÐæØî Þ ÝÕáÚÞÛìÚØå ÛØÝÕÙÝëå ØáâÞçÝØÚÐå
struct LSList
{
  objects_ar<LSInfo*>     LSInfos;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  bNum;        // ½ÞÜÕà ÓàÐÝØæë, ÝÐ ÚÞâÞàÞÙ ÛÕÖØâ ØáâÞçÝØÚ
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

  double  outF;      // ãÓÞÛ ÞâàÐÖÕÝØï/ßàÕÛÞÜÛÕÝØï  double  startAngle;// ãÓÞÛ ÒëåÞÔÐ ÛãçÐ Ø× ØáâÞçÝØÚÐ
};

//--------------------
// ²°À¸°½Â 1 (ÕÔØÝØæÐ åàÐÝÕÝØï - âÞçÚÐ ÝÐ ÓàÐÝØæÕ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÑáâàÕÛïÝëå ÓàÐÝØæÐå
struct BShootRes
{
  int bodyNum;      // ½ÞÜÕà âÕÛÐ Ø× ÚÞâÞàÞÓÞ ßàØèÕÛ Ûãç
  int boundNum;     // ½ÞÜÕà ÓàÐÝØæë, ÚÞâÞàãî ßÕàÕáÕÚ Ûãç
  double stAngle;   // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double iAngle;    // ÃÓÞÛ ßÞÔÚÞâÞàëÜ Ûãç "ÒÞâÚÝãÛáï" Ò ÓàÐÝØæã
  double ix;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë âÕÛÐ
  double iz;        // --
  double it;        // ²àÕÜï ßÞ Ûãçã ÝÐ ÜÞÜÕÝâ ßÕàÕáÕçÕÝØï
};

/// LS code structure
struct LSCode
{
  int_ar   *bNum; 
  int_ar   *rtr;
  int_ar   *vPS;
};


typedef BShootRes* pBShootRes;
typedef objects_ar<pBShootRes> BSootResAr;
typedef objects_ar<RecInfo*> RecInfoAr;

//--------------------
// ²°À¸°½Â 2 (ÕÔØÝØæÐ åàÐÝÕÝØï - ÛØÝÕÙÝëÙ ØáâÞçÝØÚ - çÐáâì ÞÑáâàÕÛïÝÝÞÙ ÓàÐÝØæë
//            ÜÕÖÔã ×ÞÝÐÜØ âÕÝØ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÔÝÞÜ ÛØÝÕÙÝÞÜ ØáâÞçÝØÚÕ
struct LSInfo
{
  double_ar stAngle;  // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double_ar x;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë
  double_ar z;        // --
  double_ar t;        // ²àÕÜï ßÞ Ûãçã ÔÞ ßÕàÕáÕçÕÝØï 
  double_ar f;        // ÃÓÞÛ ÒåÞÔÐ ÛãçÐ Ò ÓàÐÝØæã
  double_ar iA;       // ÃÓÞÛ ÚÐáÐâÕÛìÝÞÙ Ú ÓàÐÝØæÕ Ò âÞçÚÕ ßÕàÕáÕçÕÝØï
  LSInfo* StartLS;    // pointer to start linear source
  int_ar StNode;      // number of node which (x, z) point was obtained from
};


// ÁâàãÚâãàÐ áÞÔÕàÖÕéÐï ØÝäÞàÜÐæØî Þ ÝÕáÚÞÛìÚØå ÛØÝÕÙÝëå ØáâÞçÝØÚÐå
struct LSList
{
  objects_ar<LSInfo*>     LSInfos;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  bNum;        // ½ÞÜÕà ÓàÐÝØæë, ÝÐ ÚÞâÞàÞÙ ÛÕÖØâ ØáâÞçÝØÚ
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

  double  startAngle;// ãÓÞÛ ÒëåÞÔÐ ÛãçÐ Ø× ØáâÞçÝØÚÐ
};

//--------------------
// ²°À¸°½Â 1 (ÕÔØÝØæÐ åàÐÝÕÝØï - âÞçÚÐ ÝÐ ÓàÐÝØæÕ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÑáâàÕÛïÝëå ÓàÐÝØæÐå
struct BShootRes
{
  int bodyNum;      // ½ÞÜÕà âÕÛÐ Ø× ÚÞâÞàÞÓÞ ßàØèÕÛ Ûãç  int boundNum;     // ½ÞÜÕà ÓàÐÝØæë, ÚÞâÞàãî ßÕàÕáÕÚ Ûãç
  double stAngle;   // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double iAngle;    // ÃÓÞÛ ßÞÔÚÞâÞàëÜ Ûãç "ÒÞâÚÝãÛáï" Ò ÓàÐÝØæã
  double ix;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë âÕÛÐ
  double iz;        // --
  double it;        // ²àÕÜï ßÞ Ûãçã ÝÐ ÜÞÜÕÝâ ßÕàÕáÕçÕÝØï
};

/// LS code structure
struct LSCode
{
  int_ar   *bNum; 
  int_ar   *rtr;
  int_ar   *vPS;
};


typedef BShootRes* pBShootRes;
typedef objects_ar<pBShootRes> BSootResAr;
typedef objects_ar<RecInfo*> RecInfoAr;

//--------------------
// ²°À¸°½Â 2 (ÕÔØÝØæÐ åàÐÝÕÝØï - ÛØÝÕÙÝëÙ ØáâÞçÝØÚ - çÐáâì ÞÑáâàÕÛïÝÝÞÙ ÓàÐÝØæë
//            ÜÕÖÔã ×ÞÝÐÜØ âÕÝØ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÔÝÞÜ ÛØÝÕÙÝÞÜ ØáâÞçÝØÚÕ
struct LSInfo
{
  double_ar stAngle;  // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double_ar x;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë
  double_ar z;        // --
  double_ar t;        // ²àÕÜï ßÞ Ûãçã ÔÞ ßÕàÕáÕçÕÝØï 
  double_ar f;        // ÃÓÞÛ ÒåÞÔÐ ÛãçÐ Ò ÓàÐÝØæã
  double_ar iA;       // ÃÓÞÛ ÚÐáÐâÕÛìÝÞÙ Ú ÓàÐÝØæÕ Ò âÞçÚÕ ßÕàÕáÕçÕÝØï
  LSInfo* StartLS;    // pointer to start linear source
  int_ar StNode;      // number of node which (x, z) point was obtained from
};


// ÁâàãÚâãàÐ áÞÔÕàÖÕéÐï ØÝäÞàÜÐæØî Þ ÝÕáÚÞÛìÚØå ÛØÝÕÙÝëå ØáâÞçÝØÚÐå
struct LSList
{
  objects_ar<LSInfo*>     LSInfos;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  bNum;        // ½ÞÜÕà ÓàÐÝØæë, ÝÐ ÚÞâÞàÞÙ ÛÕÖØâ ØáâÞçÝØÚ
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

  int boundNum;     // ½ÞÜÕà ÓàÐÝØæë, ÚÞâÞàãî ßÕàÕáÕÚ Ûãç  double stAngle;   // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double iAngle;    // ÃÓÞÛ ßÞÔÚÞâÞàëÜ Ûãç "ÒÞâÚÝãÛáï" Ò ÓàÐÝØæã
  double ix;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë âÕÛÐ
  double iz;        // --
  double it;        // ²àÕÜï ßÞ Ûãçã ÝÐ ÜÞÜÕÝâ ßÕàÕáÕçÕÝØï
};

/// LS code structure
struct LSCode
{
  int_ar   *bNum; 
  int_ar   *rtr;
  int_ar   *vPS;
};


typedef BShootRes* pBShootRes;
typedef objects_ar<pBShootRes> BSootResAr;
typedef objects_ar<RecInfo*> RecInfoAr;

//--------------------
// ²°À¸°½Â 2 (ÕÔØÝØæÐ åàÐÝÕÝØï - ÛØÝÕÙÝëÙ ØáâÞçÝØÚ - çÐáâì ÞÑáâàÕÛïÝÝÞÙ ÓàÐÝØæë
//            ÜÕÖÔã ×ÞÝÐÜØ âÕÝØ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÔÝÞÜ ÛØÝÕÙÝÞÜ ØáâÞçÝØÚÕ
struct LSInfo
{
  double_ar stAngle;  // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double_ar x;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë
  double_ar z;        // --
  double_ar t;        // ²àÕÜï ßÞ Ûãçã ÔÞ ßÕàÕáÕçÕÝØï 
  double_ar f;        // ÃÓÞÛ ÒåÞÔÐ ÛãçÐ Ò ÓàÐÝØæã
  double_ar iA;       // ÃÓÞÛ ÚÐáÐâÕÛìÝÞÙ Ú ÓàÐÝØæÕ Ò âÞçÚÕ ßÕàÕáÕçÕÝØï
  LSInfo* StartLS;    // pointer to start linear source
  int_ar StNode;      // number of node which (x, z) point was obtained from
};


// ÁâàãÚâãàÐ áÞÔÕàÖÕéÐï ØÝäÞàÜÐæØî Þ ÝÕáÚÞÛìÚØå ÛØÝÕÙÝëå ØáâÞçÝØÚÐå
struct LSList
{
  objects_ar<LSInfo*>     LSInfos;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  bNum;        // ½ÞÜÕà ÓàÐÝØæë, ÝÐ ÚÞâÞàÞÙ ÛÕÖØâ ØáâÞçÝØÚ
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

  double stAngle;   // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ  double iAngle;    // ÃÓÞÛ ßÞÔÚÞâÞàëÜ Ûãç "ÒÞâÚÝãÛáï" Ò ÓàÐÝØæã
  double ix;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë âÕÛÐ
  double iz;        // --
  double it;        // ²àÕÜï ßÞ Ûãçã ÝÐ ÜÞÜÕÝâ ßÕàÕáÕçÕÝØï
};

/// LS code structure
struct LSCode
{
  int_ar   *bNum; 
  int_ar   *rtr;
  int_ar   *vPS;
};


typedef BShootRes* pBShootRes;
typedef objects_ar<pBShootRes> BSootResAr;
typedef objects_ar<RecInfo*> RecInfoAr;

//--------------------
// ²°À¸°½Â 2 (ÕÔØÝØæÐ åàÐÝÕÝØï - ÛØÝÕÙÝëÙ ØáâÞçÝØÚ - çÐáâì ÞÑáâàÕÛïÝÝÞÙ ÓàÐÝØæë
//            ÜÕÖÔã ×ÞÝÐÜØ âÕÝØ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÔÝÞÜ ÛØÝÕÙÝÞÜ ØáâÞçÝØÚÕ
struct LSInfo
{
  double_ar stAngle;  // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double_ar x;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë
  double_ar z;        // --
  double_ar t;        // ²àÕÜï ßÞ Ûãçã ÔÞ ßÕàÕáÕçÕÝØï 
  double_ar f;        // ÃÓÞÛ ÒåÞÔÐ ÛãçÐ Ò ÓàÐÝØæã
  double_ar iA;       // ÃÓÞÛ ÚÐáÐâÕÛìÝÞÙ Ú ÓàÐÝØæÕ Ò âÞçÚÕ ßÕàÕáÕçÕÝØï
  LSInfo* StartLS;    // pointer to start linear source
  int_ar StNode;      // number of node which (x, z) point was obtained from
};


// ÁâàãÚâãàÐ áÞÔÕàÖÕéÐï ØÝäÞàÜÐæØî Þ ÝÕáÚÞÛìÚØå ÛØÝÕÙÝëå ØáâÞçÝØÚÐå
struct LSList
{
  objects_ar<LSInfo*>     LSInfos;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  bNum;        // ½ÞÜÕà ÓàÐÝØæë, ÝÐ ÚÞâÞàÞÙ ÛÕÖØâ ØáâÞçÝØÚ
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

  double iAngle;    // ÃÓÞÛ ßÞÔÚÞâÞàëÜ Ûãç "ÒÞâÚÝãÛáï" Ò ÓàÐÝØæã  double ix;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë âÕÛÐ
  double iz;        // --
  double it;        // ²àÕÜï ßÞ Ûãçã ÝÐ ÜÞÜÕÝâ ßÕàÕáÕçÕÝØï
};

/// LS code structure
struct LSCode
{
  int_ar   *bNum; 
  int_ar   *rtr;
  int_ar   *vPS;
};


typedef BShootRes* pBShootRes;
typedef objects_ar<pBShootRes> BSootResAr;
typedef objects_ar<RecInfo*> RecInfoAr;

//--------------------
// ²°À¸°½Â 2 (ÕÔØÝØæÐ åàÐÝÕÝØï - ÛØÝÕÙÝëÙ ØáâÞçÝØÚ - çÐáâì ÞÑáâàÕÛïÝÝÞÙ ÓàÐÝØæë
//            ÜÕÖÔã ×ÞÝÐÜØ âÕÝØ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÔÝÞÜ ÛØÝÕÙÝÞÜ ØáâÞçÝØÚÕ
struct LSInfo
{
  double_ar stAngle;  // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double_ar x;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë
  double_ar z;        // --
  double_ar t;        // ²àÕÜï ßÞ Ûãçã ÔÞ ßÕàÕáÕçÕÝØï 
  double_ar f;        // ÃÓÞÛ ÒåÞÔÐ ÛãçÐ Ò ÓàÐÝØæã
  double_ar iA;       // ÃÓÞÛ ÚÐáÐâÕÛìÝÞÙ Ú ÓàÐÝØæÕ Ò âÞçÚÕ ßÕàÕáÕçÕÝØï
  LSInfo* StartLS;    // pointer to start linear source
  int_ar StNode;      // number of node which (x, z) point was obtained from
};


// ÁâàãÚâãàÐ áÞÔÕàÖÕéÐï ØÝäÞàÜÐæØî Þ ÝÕáÚÞÛìÚØå ÛØÝÕÙÝëå ØáâÞçÝØÚÐå
struct LSList
{
  objects_ar<LSInfo*>     LSInfos;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  bNum;        // ½ÞÜÕà ÓàÐÝØæë, ÝÐ ÚÞâÞàÞÙ ÛÕÖØâ ØáâÞçÝØÚ
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

  double ix;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë âÕÛÐ  double iz;        // --
  double it;        // ²àÕÜï ßÞ Ûãçã ÝÐ ÜÞÜÕÝâ ßÕàÕáÕçÕÝØï
};

/// LS code structure
struct LSCode
{
  int_ar   *bNum; 
  int_ar   *rtr;
  int_ar   *vPS;
};


typedef BShootRes* pBShootRes;
typedef objects_ar<pBShootRes> BSootResAr;
typedef objects_ar<RecInfo*> RecInfoAr;

//--------------------
// ²°À¸°½Â 2 (ÕÔØÝØæÐ åàÐÝÕÝØï - ÛØÝÕÙÝëÙ ØáâÞçÝØÚ - çÐáâì ÞÑáâàÕÛïÝÝÞÙ ÓàÐÝØæë
//            ÜÕÖÔã ×ÞÝÐÜØ âÕÝØ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÔÝÞÜ ÛØÝÕÙÝÞÜ ØáâÞçÝØÚÕ
struct LSInfo
{
  double_ar stAngle;  // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double_ar x;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë
  double_ar z;        // --
  double_ar t;        // ²àÕÜï ßÞ Ûãçã ÔÞ ßÕàÕáÕçÕÝØï 
  double_ar f;        // ÃÓÞÛ ÒåÞÔÐ ÛãçÐ Ò ÓàÐÝØæã
  double_ar iA;       // ÃÓÞÛ ÚÐáÐâÕÛìÝÞÙ Ú ÓàÐÝØæÕ Ò âÞçÚÕ ßÕàÕáÕçÕÝØï
  LSInfo* StartLS;    // pointer to start linear source
  int_ar StNode;      // number of node which (x, z) point was obtained from
};


// ÁâàãÚâãàÐ áÞÔÕàÖÕéÐï ØÝäÞàÜÐæØî Þ ÝÕáÚÞÛìÚØå ÛØÝÕÙÝëå ØáâÞçÝØÚÐå
struct LSList
{
  objects_ar<LSInfo*>     LSInfos;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  bNum;        // ½ÞÜÕà ÓàÐÝØæë, ÝÐ ÚÞâÞàÞÙ ÛÕÖØâ ØáâÞçÝØÚ
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

  double iz;        // --
  double it;        // ²àÕÜï ßÞ Ûãçã ÝÐ ÜÞÜÕÝâ ßÕàÕáÕçÕÝØï
};

struct LSCode
{
  int_ar   *bNum; 
  int_ar   *rtr;
  int_ar   *vPS;
};


typedef BShootRes* pBShootRes;
typedef objects_ar<pBShootRes> BSootResAr;
typedef objects_ar<RecInfo*> RecInfoAr;

//--------------------
// ²°À¸°½Â 2 (ÕÔØÝØæÐ åàÐÝÕÝØï - ÛØÝÕÙÝëÙ ØáâÞçÝØÚ - çÐáâì ÞÑáâàÕÛïÝÝÞÙ ÓàÐÝØæë//            ÜÕÖÔã ×ÞÝÐÜØ âÕÝØ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÔÝÞÜ ÛØÝÕÙÝÞÜ ØáâÞçÝØÚÕ
struct LSInfo
{
  double_ar stAngle;  // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ
  double_ar x;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë
  double_ar z;        // --
  double_ar t;        // ²àÕÜï ßÞ Ûãçã ÔÞ ßÕàÕáÕçÕÝØï 
  double_ar f;        // ÃÓÞÛ ÒåÞÔÐ ÛãçÐ Ò ÓàÐÝØæã
  double_ar iA;       // ÃÓÞÛ ÚÐáÐâÕÛìÝÞÙ Ú ÓàÐÝØæÕ Ò âÞçÚÕ ßÕàÕáÕçÕÝØï
  LSInfo* StartLS;    // pointer to start linear source
  int_ar StNode;      // number of node which (x, z) point was obtained from
};


// ÁâàãÚâãàÐ áÞÔÕàÖÕéÐï ØÝäÞàÜÐæØî Þ ÝÕáÚÞÛìÚØå ÛØÝÕÙÝëå ØáâÞçÝØÚÐå
struct LSList
{
  objects_ar<LSInfo*>     LSInfos;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  bNum;        // ½ÞÜÕà ÓàÐÝØæë, ÝÐ ÚÞâÞàÞÙ ÛÕÖØâ ØáâÞçÝØÚ
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

//            ÜÕÖÔã ×ÞÝÐÜØ âÕÝØ)
// ÁâàãÚâãàÐ ÔÛï åàÐÝÕÝØï ØÝäÞàÜÐæØØ ÞÑ ÞÔÝÞÜ ÛØÝÕÙÝÞÜ ØáâÞçÝØÚÕ
struct LSInfo
{
  double_ar stAngle;  // ½ÐçÐÛìÝëÙ ãÓÞÛ ÛãçÐ  double_ar x;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë
  double_ar z;        // --
  double_ar t;        // ²àÕÜï ßÞ Ûãçã ÔÞ ßÕàÕáÕçÕÝØï 
  double_ar f;        // ÃÓÞÛ ÒåÞÔÐ ÛãçÐ Ò ÓàÐÝØæã
  double_ar iA;       // ÃÓÞÛ ÚÐáÐâÕÛìÝÞÙ Ú ÓàÐÝØæÕ Ò âÞçÚÕ ßÕàÕáÕçÕÝØï
  LSInfo* StartLS;    // pointer to start linear source
  int_ar StNode;      // number of node which (x, z) point was obtained from
};


// ÁâàãÚâãàÐ áÞÔÕàÖÕéÐï ØÝäÞàÜÐæØî Þ ÝÕáÚÞÛìÚØå ÛØÝÕÙÝëå ØáâÞçÝØÚÐå
struct LSList
{
  objects_ar<LSInfo*>     LSInfos;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  bNum;        // ½ÞÜÕà ÓàÐÝØæë, ÝÐ ÚÞâÞàÞÙ ÛÕÖØâ ØáâÞçÝØÚ
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

  double_ar x;        // ºÞÞàÔØÝÐâÐ âÞçÚØ ßÕàÕáÕçÕÝØï ÛãçÐ Ø ÓàÐÝØæë  double_ar z;        // --
  double_ar t;        // ²àÕÜï ßÞ Ûãçã ÔÞ ßÕàÕáÕçÕÝØï 
  double_ar f;        // ÃÓÞÛ ÒåÞÔÐ ÛãçÐ Ò ÓàÐÝØæã
  double_ar iA;       // ÃÓÞÛ ÚÐáÐâÕÛìÝÞÙ Ú ÓàÐÝØæÕ Ò âÞçÚÕ ßÕàÕáÕçÕÝØï
  LSInfo* StartLS;    // pointer to start linear source
  int_ar StNode;      // number of node which (x, z) point was obtained from
};


// ÁâàãÚâãàÐ áÞÔÕàÖÕéÐï ØÝäÞàÜÐæØî Þ ÝÕáÚÞÛìÚØå ÛØÝÕÙÝëå ØáâÞçÝØÚÐå
struct LSList
{
  objects_ar<LSInfo*>     LSInfos;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  bNum;        // ½ÞÜÕà ÓàÐÝØæë, ÝÐ ÚÞâÞàÞÙ ÛÕÖØâ ØáâÞçÝØÚ
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

  double_ar z;        // --
  double_ar t;        // ²àÕÜï ßÞ Ûãçã ÔÞ ßÕàÕáÕçÕÝØï 
  double_ar f;        // ÃÓÞÛ ÒåÞÔÐ ÛãçÐ Ò ÓàÐÝØæã  double_ar iA;       // ÃÓÞÛ ÚÐáÐâÕÛìÝÞÙ Ú ÓàÐÝØæÕ Ò âÞçÚÕ ßÕàÕáÕçÕÝØï
  LSInfo* StartLS;    // pointer to start linear source
  int_ar StNode;      // number of node which (x, z) point was obtained from
};


// ÁâàãÚâãàÐ áÞÔÕàÖÕéÐï ØÝäÞàÜÐæØî Þ ÝÕáÚÞÛìÚØå ÛØÝÕÙÝëå ØáâÞçÝØÚÐå
struct LSList
{
  objects_ar<LSInfo*>     LSInfos;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  bNum;        // ½ÞÜÕà ÓàÐÝØæë, ÝÐ ÚÞâÞàÞÙ ÛÕÖØâ ØáâÞçÝØÚ
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

  double_ar iA;       // ÃÓÞÛ ÚÐáÐâÕÛìÝÞÙ Ú ÓàÐÝØæÕ Ò âÞçÚÕ ßÕàÕáÕçÕÝØï
  LSInfo* StartLS;    // pointer to start linear source
  int_ar StNode;      // number of node which (x, z) point was obtained from
};


// ÁâàãÚâãàÐ áÞÔÕàÖÕéÐï ØÝäÞàÜÐæØî Þ ÝÕáÚÞÛìÚØå ÛØÝÕÙÝëå ØáâÞçÝØÚÐåstruct LSList
{
  objects_ar<LSInfo*>     LSInfos;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  bNum;        // ½ÞÜÕà ÓàÐÝØæë, ÝÐ ÚÞâÞàÞÙ ÛÕÖØâ ØáâÞçÝØÚ
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

struct LSList
{
  objects_ar<LSInfo*>     LSInfos;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  bNum;        // ½ÞÜÕà ÓàÐÝØæë, ÝÐ ÚÞâÞàÞÙ ÛÕÖØâ ØáâÞçÝØÚ
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë  int_ar                  bNum;        // ½ÞÜÕà ÓàÐÝØæë, ÝÐ ÚÞâÞàÞÙ ÛÕÖØâ ØáâÞçÝØÚ
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

  int_ar                  bNum;        // ½ÞÜÕà ÓàÐÝØæë, ÝÐ ÚÞâÞàÞÙ ÛÕÖØâ ØáâÞçÝØÚ  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë };

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ
  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

};

//================ new structs based on U2dRayPoint ==================
struct LSpoint 
{
  U2dRayPoint RP;
  double iA;
  double startAngle;
};

typedef vector<LSpoint> LSpointsAr;
//typedef vector<LSpoint> startLSpAr;

struct LSource
{
  LSpointsAr LSpoints;
  LSource *startLS;
  LSpointsAr  startLSps;
  int boundId;
};

struct LSlist
{
  objects_ar<LSource*>     LSources;     // áßØáÞÚ ÛØÝÕÙÝëå ØáâÞçÝØÚÞÒ  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë
  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

  int_ar                  wType;       // âØß ßÐÔÐîéÕÙ ÒÞÛÝë  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë 
};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

  int_ar                  segNum;      // ½ÞÜÕà áÕÓÜÕÝâÐ ÔÐÝÝÞÙ ÓàÐÝØæë };
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);////changed
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);////////Changed
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; /**< Progress indicator object or NULL */
  Progress  *PBar2; /**< Progress indicator object or NULL */
  
  
  
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ
  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

};
//===================================================================

// CâàãÚâãàÐ ÔÛï åàÐÝÕÝØï âÞçÕÚ ÛãçÕÙ 
struct RayPath
{
  float_ar x;
  float_ar z;
};

struct WavePath
{
  objects_ar<RayPath*>  rPath;
};


struct RTParams
{
  int       rtr;
  WAVE_TYPE wt0;
  WAVE_TYPE wt1;
  CodeAr    rCode;
  int_ar     *bNums;

};

struct LSPoint 
{
  double x, z;
  double t, f;
  double iA;
  double startAngle;
};



//=====================================================================
//---------------------------------------------------------------------
// ¾ÑêÕÚâ ÔÛï ÞÑáâàÕÛÐ ÜÞÔÕÛØ ÛãçÐÜØ  
class RayShooter : public RayTracing
{
public:

  RayShooter(Vel2dModelLDB *VelMod2d, ObservSys *OSys=NULL);  
  ~RayShooter();

  void Shooter(double stAngle, double endAngle, int target, double fStep, int &rNum, 
           double *rT, double *rAmpl, double *rAngle, double *recF, int *recNum);   
  void Shooter2(double stAngle, double endAngle, int &num, double *recT, 
        double *recAmpl, double *recAngle, double *recF, int *recNum);

  void GetWATimes(WAVE_TYPE wT, double *recX, double *recZ, int n, double *recT);
    
  // Wave path calculating (described in rtPath.C) -----------------------------
  void GetWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  //double angleStep1=10, double angleStep2=10;
  
  void GetDirectWavePath(CodeAr rCode, WavePath *wp, bool &good_path_flag, bool &stop_pressed_flag, double dl=10., double den=10.); 
  
  bool TestRayPath(RayInfo *ray, int_ar *boundN, CodeAr rCode);

  // Compare LS from recievers and SP LS
  void CompLS(LSList *recLS, LSList *spLS, RecInfoAr &recInfos);
  

  // Massive shooting (described in mShooter.C) ---------------------------------
  void MShooterSP(WAVE_TYPE wT, LSList *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  void MShooterSPNew(WAVE_TYPE wT, LSlist *resLS, bool &stop_pressed_flag, double sx = -1., double sz = -1., int ns_bnum=-1);
  
  void MShooterUP(WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  void MShooterDOWN(WAVE_TYPE wT, bool rt, LSList *inLS, LSList *outLS, bool &stop_pressed_flag); //, int tbn=-1);

  //======== New method instead of  MShooterUP and MShooterDOWNNew==============================================
  void MShooterUniversal(WAVE_TYPE wT, bool rt, LSlist *inLS, LSlist *outLS, bool &stop_pressed_flag, bool WellShoot, int tbn, RTParams &rtp);
  bool WellTransform(WAVE_TYPE wT,  LSlist *outLS, LSlist *inLS, RecInfoAr &recInfos, bool rt, RTParams rtp);
  
  //============================================================================================================

  
  void MShooterREC(int n1=-1, int n2=-1, WAVE_TYPE wt=PRESSURE);
  
  void stop_MShooter(bool &stop_pressed_flag, LSInfo *&lsDesc);
  void stop_MShooterUP(bool &stop_pressed_flag, RecInfoAr &recInfos);
  
  //=========================== new methods====================================================
  bool firstLsPoint(double spX, double spZ, 
            double &startF, double &stepF, 
            CodeAr rCode, int_ar *bNums, 
            int &bn1, 
            bool &big_angle, 
            int ns_bnum, 
            bool &stop_pressed_flag);
  
  void exactFirstPoint(double spX, double spZ, 
               double &startF, double &stepF, 
               CodeAr rCode, int_ar *bNums, 
               int &bn1, 
               bool &stop_pressed_flag);
  
  bool sourceShooter(double spX, double spZ, 
             double &startF, double &stepF,
             CodeAr rCode, 
             int_ar *bNums, 
             WAVE_TYPE wT,
             LSlist *resLS,
             int ns_bnum,
             bool &stop_pressed_flag);
  
  //============================================================================================

  // Data import/export ---------------------------------------------------------
  void SaveHod(RecInfoAr recInfos, double spX, double spZ, int fbLine=-1, int pmLine=-1);

  void SaveLS(dbItem dbiLSList, double spX, double spZ,
          double eps, LSList *ls, LSCode *lsc=NULL);

  void LoadLS(dbItem dbiLSList, LSInfo *ls, double &spX, double &spZ, WAVE_TYPE &wt, double &eps, int &bNum);
  
  void LoadLSList(LSList *LSLst, CodeAr rCode);

  void SaveRecLS(int recNum, WAVE_TYPE wt, int bodyNum, double eps, LSList *recLS);

  bool LoadRecLS(int recNum, WAVE_TYPE wt, int bNum, LSList *recLS);
  
  void DeleteLSList(dbItem dbiModelList);
  
  // Progress bars --------------------------------------------------------------
  void  SetPBars(Progress *PB1, Progress *PB2);

  Progress  *PBar1; 
  Progress  *PBar2; 
  void  LSShooterUP(WavePath *wp, WAVE_TYPE wT, bool rt, LSList *ls, RecInfoAr &recInfos, bool &stop_pressed_flag, int tbn=-1);
  
  // debug
  //bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  //bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
  //        double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
protected:
  
  void clean_LS(LSList *&_list);   
  
  // ¾ßàÕÔÕÛïÕâ ÝÐçÐÛÞ ÐÚâØÒÝÞÙ ×ÞÝë áÚÒÐÖØÝë á âÞçÝÞáâìî eps
  void GetActiveZoneStart(CodeAr rCode, int_ar *bNums, double &tmp_f, double &start_x, double &start_z, 
              double first_x, double first_z, double angleStep2, double eps);
  
  // ÀÐááçÕâ ßàïÜÞÓÞ ÛãçÐ, ßÞßÐÔÐîéÕÓÞ Ò ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num, ßÞ ÚÞÞàÔØÝÐâÐÜ ÔÒãå âÞçÕÚ (x0,z0) Ø (x1,z1) ÝÐ áÚÒÐÖØÝÕ 
  void OneDirectShoot(double x0, double z0, double x1, double z1, double base_angle, int rec_num, 
              double &result_x, double &result_z, double &result_angle, double &result_f, double &time, double eps);
  
  // true - ÕáÛØ ßàØÕÜÝØÚ á ÝÞÜÕàÞÜ rec_num  ÝÐåÞÔØâáï Ò âÕÛÕ á ÝÞÜÕàÞÜ bNum
  bool CheckRec(int rec_num, int bNum);
  
  // ½ÐåÞÔØâ Ò âÕÛÕ á ÝÞÜÕàÞÜ bodyNum ßàØÕÜÝØÚ, ÑÛØÖÐÙèØÙ Ú âÞçÚÕ last_z ÝÐ áÚÒÐÖØÝÕ  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  /////////////////////////////////////////////////////////////////////////////////////////////////
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif

  void GetNearestRecNum(int bodyNum, double last_x, double last_z, int &first_rec, int &count);
  
private:
  
  // Massive shooting (described in mShooterService.C) ---------------------------------
  bool ShootLSRay(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn);      
  bool MShooterDownStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn);
  bool MShooterDownFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, 
              LSPoint &ilsp, double &stF, double &dL);

  void GetLSP(LSInfo *ls, LSPoint &lsp, int n);
  void SetLSP(LSInfo *ls, LSPoint lsp, int n);
  void AddLSP(LSInfo *ls, LSPoint lsp, double stF);  
  void LSPCopy(LSPoint source_lsp, LSPoint &rec_lsp);

  

  
  /* ====================== For mshooter only ====================== */
  bool GetNextPoint(int bn, LSPoint lsp1, double dl, LSPoint &lsp2);
  
  bool MShooterUnivFP(LSInfo *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSPoint &lsp, LSPoint &ilsp, double &stF, double &dL, bool WellShoot);

  
  bool ShootLSRayUniv(RTParams rtp, LSPoint lsp, LSPoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSInfo *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool NextNodeNum(LSInfo *lsDesc, LSPoint lsp, int &r);
  bool ShadowSearch(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint &lsp, LSPoint &ilsp, int stBNum, int bn, int &bn1);
  bool DoublePointShooter(RTParams rtp, LSPoint lsp0, LSPoint ilsp0, LSPoint lsp1, LSPoint ilsp1, LSInfo *InterLS, int bn, int startBN);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSInfo *InterLS);
  bool DoudleTransform(RTParams rtp, LSList *inLS, int lsnum, LSInfo *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool RecordShooter(RTParams rtp, LSList *inLS, int LSNum, vector<int> &res_id, LSPoint lsp0, LSPoint lsp1, LSInfo *stLS, double *recX, double *recZ);
  
  /* Universal method for mshooter and ls_shooter */
  bool GetNextPoint(int bn, double x1, double z1, double f1, double iA1, double oT1, double stA1, double dl, 
            double &x2, double &z2, double &f2, double &iA2, double &oT2, double &stA2);
  /* =============================================================== */
  
  
  
  int  CompareParams(double f1, double f2, double t1, double t2);
  bool CheckNextLSPoint(double x1,double z1,double x2,double z2,int bNum,double &xs,double &zs);
  
  bool CheckUpGoingRay(RayInfo *ray, int bn, bool flag);  
  
  void stop_process(WavePath *&wp, bool &good_path_flag);
  
  //=========== Universal methods based on u2dPoint methods=====================================
  
  int BoxRec(U2dBox *uBox, vector<int> &res_id, double *recX, double *recZ);
  bool RecordShooter(RTParams rtp, vector<int> &res_id, LSpoint lsp0, LSpoint lsp1, LSpoint ilsp0, LSpoint ilsp1, LSource *stLS, 
             double *recX, double *recZ, RecInfoAr &recInfos);

  bool ShootLSRayUniv(RTParams rtp, LSpoint lsp, LSpoint &ilsp, double &stF, int &bn, bool WellShoot);  
  bool MShooterUnivStN(LSource *LS, int stBN, RTParams rtp, int &stN, int &bn, bool WellShoot);
  bool MShooterUnivFP(LSource *LS, int &num, int &bNum, int stBNum, RTParams rtp, LSpoint &lsp, LSpoint &ilsp, double &stF, double &dL, bool WellShoot);

  bool NextNodeNum(LSource *lsDesc, LSpoint lsp, int &r);
  
  /* For ls_shooter methods */
  bool GetNextPoint(int bn, LSpoint lsp1, double dl, LSpoint &lsp2);

  bool ShadowSearch(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint &lsp, LSpoint &ilsp, int stBNum, int bn, int &bn1);
  
  void AddLSPoint(LSource *ls, LSpoint lsp, int bndId, LSpoint stLSp);

  bool DoublePointShooter(RTParams rtp, LSpoint lsp0, LSpoint ilsp0, LSpoint lsp1, LSpoint ilsp1, LSource *InterLS, int bn, int startBN);
  //bool DoudleTransform(RTParams rtp, LSlist *inLS, int lsnum, LSource *WellLS, int fst, int snd,  double recZ, double recX, RecInfo *rInfo);
  bool HalfAngleShooter(double spX, double spZ, double startF, double stepF, CodeAr rCode, int_ar *bNums, bool raySave, LSource *InterLS);
  
  
  void stop_MShooter(bool &stop_pressed_flag, LSource *&lsDesc);
  

};


#endif