corr_wave_detector.hpp

/* corr_wave_detector.hpp */
/* $Id: corr_wave_detector.hpp 21741 2012-08-10 12:34:54Z hoot $ */
#ifndef __corr_wave_detector_hpp
#define __corr_wave_detector_hpp

#include <s2proc/wave_field.hpp>
#include <s2proc/u_abs_hod.hpp>
#include <mth/medmean.hpp>
#include <math.h>

#include "abstract_wave_detector.hpp"

class CorrWaveDetector : public AbstractWaveDetector
{
public:

  CorrWaveDetector();

  CorrWaveDetector(size_t sb_size, size_t sb_step, size_t start_smpl, size_t end_smpl);

  
  const WaveField& getWavefield() const;
  void setWavefield(const WaveField& wf);

  virtual ~CorrWaveDetector();
 
  //static size_t op_num;

protected:
  
  virtual bool calc(Trace &tr) const;

  bool getCorrVal(size_t start_smpl, size_t length, int win_number, float &corr_val) const;


  size_t m_sb_size;
  size_t m_sb_step;
  size_t m_start_smpl;
  size_t m_end_smpl;
  const WaveField  *m_wf;

private:
  mutable std::map<int, std::map<std::pair<int, int>, float > > m_corr_map;
  // outer key int -> number of window
  // inner key pair -> pair of traces
  // inner float -> correlation value
};




struct  badness
{
  badness(const std::vector<float> &v)
  {
    mean=0;
    for(size_t i=0; i<v.size(); i++)
      mean+=v[i];
    mean/=v.size();

    float D=0;
    for(size_t i=0; i<v.size(); i++)
      D+=(v[i]-mean)*(v[i]-mean);
    D/=v.size();

    d=sqrt(D);
  }

  // The badness of whole vector is sum of variances against mean
  float operator()() const
  {
    return d;
  }
  // The badness of any given variable against vector is variance
  //  of variable against mean of vector.

  float operator()(const float &v) const
  {
    return fabs(v-mean);
  }

  float mean, d;
    
};








#endif /* corr_wave_detector.hpp */