code/include/NewWave/Utils.hh

Go to the documentation of this file.

#ifndef NEWWAVE_UTILS_HH
#define NEWWAVE_UTILS_HH

#include "NewWave/PixelArray.hh"

#include <functional>
#include <algorithm>
#include <assert.h>
#include <cmath>

namespace NewWave{
  
  using std::size_t;
  
  const double TWOPI = 2.0 * M_PI;
  

  inline bool isEven(size_t n){ return (n%2 == 0);}
  

  inline bool isOdd(size_t n){return !isEven(n);}
  

  inline bool isRadix2(size_t n){return !((n-1) & n);}
  
  inline size_t nearestRadix2(size_t n){
    if(isOdd(n)) ++n;
    // @todo clever way of doing this?
    while(!isRadix2(n)){
      n+=2;
    }
    return n;
  }
  

  inline vector<double> makeRowFromArray(const PixelArray &array){
    vector<double> rowMajor;
    
    for(PixelArray::const_iterator row = array.begin();
        row != array.end(); ++row){
      
      for(vector<double>::const_iterator el = row->begin();
          el != row->end(); ++el){
        rowMajor.push_back(*el);
      }
    }
    
    return rowMajor;
  }

  inline PixelArray makeArray(const vector<double> &row){
    size_t n = sqrt(row.size());
    assert(n*n == row.size());
    PixelArray output;

    PixelRow line;
    for(double el: row){
      line.push_back(el);
      if(line.size()==n){
        output.push_back(line);
        line.clear();
      }
    }
    
    return output;
  }
  

  inline vector<double> operator / (vector<double> left,
                                    const vector<double> &right){
    
    std::transform(left.begin(), left.end(), right.begin(), left.begin(), std::divides<double>());
    return left;
  }
  

  inline PixelArray operator / (PixelArray left, const PixelArray &right){
    
    std::transform(left.begin(), left.end(), right.begin(), left.begin(),
                   [](PixelRow num, const PixelRow &denom){return num / denom;});
    return left;
  }
  
  
  inline double mod2Pi(double angle){
    if(angle < TWOPI && angle >= 0) return angle;
    
    double dPhi = fmod(angle, TWOPI);
    return (angle >=0)? dPhi: TWOPI + dPhi;
  }
  
}
#endif