polycor.hpp

/* polycor.hpp */
/* $Id$ */
#ifndef __polycor_hpp
#define __polycor_hpp

#include <map>
#include <set>
#include <string>
#include <utility>

#ifdef GE_BUILD
#include <trace.hpp>
#else
#include <s2proc/trace.hpp>
#endif

namespace PSC
{
  struct PSC_Params
  {
    int corr_direct;                 
    unsigned int stride_num;         
    float start_time;                
    float time_width;                
    float ccf_length;                
    float offset_range[2];           
    float max_shift;                 
    bool use_offset_weights_flag;    
    float l_max;                     
    float l_half;                    
    float l_eps;                     
    bool CheckParams();
    
    void info();
  };

  enum Direction
    {
      SP_LINE = 0,  
      RP_LINE,      
      SL_LINE,      
      SS_LINE,      
      RL_LINE,      
      RS_LINE,      
      CMP_LINE,     
      OFFSET_LINE   
    };
  
  std::string toString(const Direction &dir);

  enum StMode
    {
      SP_RP_ORT = 0,
      SP_OFFSET,
      RP_OFFSET,
      SP_CMP,
      RP_CMP
    };
  
  typedef std::map<int, Trace::TimeT> Statics;
  
  // fixed CCF1 row
  typedef std::map<int, std::pair<int, float> > CCF1_ROW;
  //   key: index of RP
  // value: first->index correcponded to CCF1 body in TrSet, second-> max value of CCF1
  
  // array of CCF1 rows in current stride
  typedef std::map<int, CCF1_ROW> ROW_AR;
  //   key: index of fixed CCF1 row
  // value: CCF1_ROW
  
  // array of all strides
  typedef std::map<int, ROW_AR> STRIDE_AR;
  //   key: stride num
  // value: array of CCF1 rows in current stride
  
  // container for formed row
  //  key: id for CCF1 row (id for CCF2 row in case of CCF2 row)
  //value: body of CCF1 (body of CCF2 in case of CCF2 row)
  typedef std::multimap<int, Trace> ROW;

  // container for formed sum row
  //  outer key: Statics calculation mode PSC::StMode
  //  inner key: number of stride
  //  inner value: sum row for statics calculation
  typedef std::map<PSC::StMode, std::map<int, PSC::ROW> > ROWS_MAP;
  


  // first ->  number of line
  // end -> number of point in current line
  typedef std::pair<int, int> POINT_ID;

  // container for formed row
  //  key: id for CCF row 
  //value: body of CCF 
  typedef std::map<PSC::POINT_ID, Trace> ROW3D;

  // container for array of calculated rows
  // Direction can be realised in two main ways
  // inline (SS_LINE or RS_LINE)
  // crossline (SL_LINE or RL_LINE)
  //typedef std::map<PSC::Direction, PSC::ROW3D> ROW3D_AR;
  typedef std::map<PSC::POINT_ID, PSC::ROW3D> ROW3D_AR;

  //container for all calculated CCF1 rows for current stride
  //typedef std::map<PSC::POINT_ID, PSC::ROW3D_AR> CCF_AR;
  typedef std::map<PSC::Direction, PSC::ROW3D_AR> CCF_AR;
    

  double calc_offset_weight(double L,       
                double L_half,  
                double L_max,   
                double eps      );
    

  // determines maximum of CCF1 in window limited by window [midle - max_shift, midle + max_shift] 
  bool get_max_in_win(float *samples, int samples_count, int max_shift, std::pair<int, float> &max_pair);

  bool get_max_in_win_tr(const Trace &tr, float max_shift, std::pair<int, float> &max_pair);

  bool get_intersection_3d(const ROW3D &add_row, const ROW3D &base_row, float &intersection);

  bool get_best_row(const std::map<int, std::map<int, PSC::ROW3D> > &rows, 
            const std::set<int> &lines,
            float max_shift,
            std::map<int, PSC::ROW3D> &best_rows,
            int &id,
            float &weignt);

  bool row3d2d_convertor(const std::map<int, PSC::ROW3D> &row_3d, 
             std::map<int, PSC::ROW> &row_2d,
             bool is_inline);


  bool stack_rows_3d(PSC::ROW3D &base_row,
             PSC::ROW3D &add_row,  
             const PSC::PSC_Params &params, 
             std::map<PSC::POINT_ID, int> &count_ar);

};


#endif /* polycor.hpp */