intersection.hpp

Go to the documentation of this file.

#ifndef INTERSECTION_HPP
#define INTERSECTION_HPP

#include <algorithm>
#include <functional>
#include <numeric>
#include "spline3d.hpp"
#include "metaimage.hpp"

template<typename T>
class Spline3D;

template<typename T>
class Intersection 
{
public:

  Intersection():m_points()
  {
    m_spline = NULL;
    m_intersection_pos = 0.0;
    m_cosTheta = 0.0;
    m_origAvgValue = 0.0;
    m_valid = false;
    m_img = NULL;
    m_avg_computed = 0;
    m_avgValue = 0;
  }      
  inline const Spline3D<T> 
  *getSpline() const
  {
    return m_spline;
  }
  
  inline void 
  setSpline(const Spline3D<T> *spline)
  {
    m_spline = spline;
  }
  
  inline T 
  getParameterPosition() const
  {
    return m_intersection_pos;
  }

  inline void 
  setParameterPosition(T t)
  {
    m_intersection_pos = t;
  }

  inline T 
  getCosTheta() const 
  {
    return m_cosTheta;
  }

  inline void 
  setCosTheta(T t)
  {
    m_cosTheta = t;
  }

  inline void
  setPoints(const vector<T>& points)
  {
    m_points = points;
    m_avg_computed = false;
  }
 
  inline void
  setPoints(vector<T>&& points)
  {
    m_points = std::move(points);
    m_avg_computed = false;
  }

  inline vector<T>& 
  getPoints()
  {
    return m_points;
  }

  inline T 
  getAverage()
  {
    if(!m_avg_computed)
      __computeAverage();
    return m_avgValue;
  }

  inline void 
  setValid(bool valid)
  {
    m_valid = valid;
  }
  
  inline bool 
  isValid() const
  {
    return m_valid;
  }
  
  inline const MetaImage<inData_t>* 
  getMetaImage() const
  {
    return m_img;
  }

  inline void 
  setMetaImage(const MetaImage<inData_t>* img)
  {
    m_img = img;
    m_avg_computed = false;
  }
  
  inline void 
  evaluate(T p[3]) const
  {
    if(isValid())
    {
      m_spline->evaluateSingle(m_intersection_pos,p);
    }
  }

  inline T 
  getOrigAvgValue()
  {
    return m_origAvgValue;
  }
  
  inline void 
  correctAliasing(T direction,T Vnyq)
  {

    m_avgValue = 0.0;
    for(auto it = m_points.begin(); it != m_points.end(); it++)
    {
      bool sign = sgn(direction) == sgn(m_cosTheta);
      if(*it < 0 && sign)
      {
          *it += 2*Vnyq;
      }
      else if(*it > 0 && !sign)
      {
          *it -= 2*Vnyq;
      }
      m_avgValue += *it;
    }
    if (m_points.size()==0){
        m_avgValue =0.0;
        m_valid = false;
    }else{
        m_avgValue = m_avgValue/m_points.size();
    }
  }
 
  inline T 
  sampleWeight(const T A, const T a, const T b) const
  {
    int positive;
    int negative;
    positive = std::accumulate(m_points.begin(), m_points.end(), 0, 
                               [](int k, T l){ if(l > 0) return k + 1; return k; }
      );

    negative = m_points.size()-positive;
  
    T pos_weight = (T)(positive - negative)/(double)(positive + negative);
    pos_weight = pos_weight * pos_weight;
    T ret = A*pos_weight;
    if(abs(m_cosTheta) > a && abs(m_cosTheta) < b)
    {
      ret += 1;
    }
    return ret;
  }
      
  inline T 
  estimateVelocitySimple() 
  {
    if(isValid())
    {
      return getAverage()/m_cosTheta;
    }
    else 
      return 0.0;
  }
      
  inline void 
  regionGrow()
  {
    if(!isValid()) return;
    T p[3];
    evaluate(p);
    T img_x, img_y;
    m_img->toImgCoords(img_x, img_y, p);
    if(m_img->inImage(img_x, img_y))
    {
      m_img->regionGrow(m_points,(int)img_x, (int)img_y);
    }
  }


private:
  void __computeAverage()
    {
      m_avgValue = std::accumulate(m_points.begin(), m_points.end(), 0.0, plus<T>());
      //m_avgValue = m_avgValue/(T)m_points.size();
      m_origAvgValue = m_avgValue;
      m_avg_computed = true;

      if (m_points.size()==0){
        m_avgValue =0.0;
        m_valid = false;
      }else{
          m_avgValue = m_avgValue/(T)m_points.size();
      }
    }
  
  const Spline3D<T> *m_spline;
  T m_intersection_pos;
  T m_cosTheta;
  T m_avgValue;
  const MetaImage<inData_t> *m_img;
  vector<T> m_points;
  bool m_valid;
  bool m_avg_computed;
  T m_origAvgValue;
};
  

#endif //INTERSECTION_HPP