intersection_set.hpp

Go to the documentation of this file.

#ifndef INTERSECTION_SET_HPP
#define INTERSECTION_SET_HPP
#include "intersection.hpp"

#include <vector>

template<typename T>
class IntersectionSet : public std::vector<Intersection<T> >
{
public:

  IntersectionSet()
  {
    m_direction = 0.0;
    m_have_direction = false;
    m_have_velocity_ls = false;
    m_velocity_ls = 0.0;
    m_dir_a = 0.07;
    m_dir_b = 0.9;
    m_dir_A = 10.0;
    m_vel_a = 0.17;
    m_vel_b = 1.0;
  }
public:
  void 
  estimateDirection()
  {
    std::pair<T,T> vel_weight;
    struct 
    {
      T A;
      T a;
      T b;
      std::pair<T,T>& operator()(std::pair<T,T>& ret, Intersection<T>& i)
      {
           
                T weight = i.sampleWeight(A, a,b);
                T tmp = i.getAverage()*i.getCosTheta();
                tmp = weight*tmp/abs(tmp);

                if(!std::isnan(tmp))
                {
                  ret.first += tmp;
                  ret.second += weight;

                }
                return ret;

          }
    } weight_accum;
    
    weight_accum.a = m_dir_a;
    weight_accum.b = m_dir_b;
    weight_accum.A = m_dir_A;
    vel_weight = std::accumulate(this->begin(), this->end(), std::make_pair(0.0, 0.0),
                                 weight_accum);
    m_direction = vel_weight.first/vel_weight.second;
    m_have_direction = true;
    if(std::isnan(m_direction))
    {
        m_direction = 0.0;
    }
  }
  
  void 
  estimateVelocityLS()
  {
    std::pair<T,T> top_bottom;
      
    struct
    {
      T a;
      T b;
      std::pair<T,T>& operator()(std::pair<T,T> &ret, Intersection<T> &i)
      {
        if(abs(i.getCosTheta()) < a || abs(i.getCosTheta()) > b){
                  return ret;
        }
                double tmp1, tmp2;

                tmp1 = i.getAverage()*i.getCosTheta();
                tmp2 = i.getCosTheta()*i.getCosTheta();
                if(!std::isnan(tmp1) && !std::isnan(tmp2))
                {
                  ret.first += tmp1;
                  ret.second += tmp2;
                }
                return ret;
      }
    } accum;
        
    accum.a = m_vel_a;
    accum.b = m_vel_b;
    top_bottom = std::accumulate(this->begin(), this->end(), 
                                 std::make_pair(0.0,0.0), accum);
    m_velocity_ls = top_bottom.first/top_bottom.second;
    m_have_velocity_ls = true;

    if(std::isnan(m_velocity_ls ))
    {
        m_velocity_ls = 0.0;
    }
  }
  
  void 
  correctAliasing(T Vnyq)
  {
    for(auto &intersection : *this)
    {
      intersection.correctAliasing(m_direction,Vnyq);
    }
  }

  void setDirectionEstimationParameters(T A, T lower, T upper)
    {
      m_dir_A = A;
      m_dir_a = lower;
      m_dir_b = upper;
    }

  void setVelocityEstimationCutoff(T lower, T upper)
    {
      m_vel_a = lower;
      m_vel_b = upper;
    }

  T getEstimatedDirection()
    {
      if(!m_have_direction)
          estimateDirection();
      return m_direction;
    }

  T getEstimatedVelocity()
    {
      if(!m_have_velocity_ls)
          estimateVelocityLS();
      return m_velocity_ls;
    }
        
  

private:
  T m_direction;
  bool m_have_direction;
  bool m_have_velocity_ls;
  T m_velocity_ls;
  T m_dir_a, m_dir_b;
  T m_vel_a, m_vel_b;
  T m_dir_A;
  
};




#endif