functions.h

Go to the documentation of this file.

#ifndef FUNCTIONS_H
#define FUNCTIONS_H

#include <boost/array.hpp>
#include <cmath>
#include <complex>
#include <functional>
#include "mimasexception.h"

namespace mimas {

#ifndef sgn
#define sgn(x) ((x<0)?-1:((x>0)?1:0))
#endif

template< typename T >
struct _abs: public std::unary_function< T, T > 
{
  T operator()( const T &x ) const { return std::abs( x ); }
};

template< typename T >
struct _fastsqr: public std::unary_function< T, int >
{
  _fastsqr(void) {
    for ( int i=0; i<(signed)table.size(); i++ )
      table[i] = i * i;
  }
  int operator()( const T &x ) const {
    assert( x > -(signed)table.size() && x < (signed)table.size() );
    return table[ x < 0 ? -x : x ];
  }
  boost::array< int, 512 > table;
};

template< typename T >
struct _sqr: public std::unary_function< T, T > 
{
  T operator()( const T &x ) const { return x * x; }
};

template<typename T>
struct _sqrt: public std::unary_function< T, T >
{
  T operator()( const T &x ) const { return (T)std::sqrt( (float)x ); }
};

template< typename T >
struct _threshold: public std::binary_function< T, T, T >
{
  T operator()( const T &x, const T &y ) const { return x < y ? T() : x; }
};

template< typename T >
struct _tobinary: public std::binary_function< T, T, bool >
{
  bool operator()( const T &x, const T &y ) const { return x >= y; }
};


template< typename T >
struct _bilevel: public std::binary_function< T, T, T > {
  _bilevel( T _val1, T _val2 ): val1(_val1), val2(_val2) {}
  T operator()( const T &x, const T &y ) const { return x >= y ? val2 : val1; }
  T val1;
  T val2;
};

template< typename T >
struct _bilevel_double: public std::unary_function< T, T> {
  T val1, val2, min, max;
  _bilevel_double( T _val1, T _val2, T _min, T _max ): val1(_val1), val2(_val2), min(_min), max(_max){}
  T operator()( const T &x ) const { return (x >= min && x <= max) ? val2 : val1; 
  }
};

template< typename T >
struct _normalise: public std::unary_function< T, T >
{
  _normalise( T _minval, T _maxval, T _val1, T _val2 ) {
    if ( _maxval > _minval ) {
      factor = (double)( _val2 - _val1 ) / ( _maxval - _minval );
      offset = _val1 - _minval * factor;
    } else {
      factor = 0.0;
      offset = _val1;
    };
  }
  T operator()( const T &x ) const {
    // Scale each pixel-value: ( pixel - minval ) * factor + val1.
    // pixel * factor - minval * factor + val1
    return (T)( x * factor + offset );
  }
  double factor;
  double offset;
};

template< typename T1, typename T2 >
struct _norm: public std::unary_function< T2, T1 >
{
  T1 operator()( const T2 &x ) const { return std::norm( x ); }
};

template< typename T1, typename T2 >
struct _arg: public std::unary_function< T2, T1 >
{
  T1 operator()( const T2 &x ) const { return std::arg( x ); }
};

template< typename T >
struct _conj: public std::unary_function< T, T >
{
  T operator()( const T &x ) const { return std::conj( x ); }
};

template< typename T >
struct _log: public std::unary_function< T, T >
{
  T operator()( const T &x ) const { return log( x ); }
};

template< typename T >
struct _sumsquares: public std::binary_function< T, T, T > {
  T operator()( const T &x, const T &y ) const { return x * x + y * y; }
};

template< typename T >
struct _orientation: public std::binary_function< T, T, T > {
  T operator()( const T &y, const T &x ) const { return atan2( y, x ); }
};

};

#endif

---