transforms.h

Go to the documentation of this file.

#ifndef TRANSFORMS_H
#define TRANSFORMS_H

#ifndef _MSC_VER
#  include <itpp/config.h>
#else
#  include <itpp/config_msvc.h>
#endif

#include <itpp/base/vec.h>
#include <itpp/base/mat.h>
#include <itpp/base/matfunc.h>


namespace itpp
{




void fft(const cvec &in, cvec &out);
cvec fft(const cvec &in);
cvec fft(const cvec &in, const int N);
void ifft(const cvec &in, cvec &out);
cvec ifft(const cvec &in);
cvec ifft(const cvec &in, const int N);

void fft_real(const vec& in, cvec &out);
cvec fft_real(const vec& in);
cvec fft_real(const vec &in, const int N);
void ifft_real(const cvec &in, vec &out);
vec ifft_real(const cvec &in);
vec ifft_real(const cvec &in, const int N);





void dct(const vec &in, vec &out);
vec dct(const vec &in);
void idct(const vec &in, vec &out);
vec idct(const vec &in);



template <class T> Vec<T> dht(const Vec<T> &v);
template <class T> void dht(const Vec<T> &vin, Vec<T> &vout);
template <class T> void self_dht(Vec<T> &v);

template <class T> Vec<T> dwht(const Vec<T> &v);
template <class T> void dwht(const Vec<T> &vin, Vec<T> &vout);
template <class T> void self_dwht(Vec<T> &v);

template <class T> Mat<T> dht2(const Mat<T> &m);
template <class T> Mat<T> dwht2(const Mat<T> &m);

template <class T>
Vec<T> dht(const Vec<T> &v)
{
  Vec<T> ret(v.size());
  dht(v, ret);
  return ret;
}

template <class T>
void bitrv(Vec<T> &out)
{
  int N = out.size();
  int j = 0;
  int N1 = N - 1;
  for (int i = 0; i < N1; ++i) {
    if (i < j) {
      T temp = out[j];
      out[j] = out[i];
      out[i] = temp;
    }
    int K = N / 2;
    while (K <= j) {
      j -= K;
      K /= 2;
    }
    j += K;
  }
}

template <class T>
void dht(const Vec<T> &vin, Vec<T> &vout)
{
  int N = vin.size();
  int m = levels2bits(N);
  it_assert_debug((1 << m) == N, "dht(): The vector size must be a power of two");

  vout.set_size(N);

  // This step is separated because it copies vin to vout
  for (int ib = 0; ib < N; ib += 2) {
    vout(ib) = vin(ib) + vin(ib + 1);
    vout(ib + 1) = vin(ib) - vin(ib + 1);
  }
  N /= 2;

  int l = 2;
  for (int i = 1; i < m; ++i) {
    N /= 2;
    int ib = 0;
    for (int k = 0; k < N; ++k) {
      for (int j = 0; j < l; ++j) {
        T t = vout(ib + j);
        vout(ib + j) += vout(ib + j + l);
        vout(ib + j + l) = t - vout(ib + j + l);
      }
      ib += 2 * l;
    }
    l *= 2;
  }

  vout /= static_cast<T>(std::sqrt(static_cast<double>(vin.size())));
}

template <class T>
void self_dht(Vec<T> &v)
{
  int N = v.size();
  int m = levels2bits(N);
  it_assert_debug((1 << m) == N, "self_dht(): The vector size must be a power "
                  "of two");

  int l = 1;
  for (int i = 0; i < m; ++i) {
    N /= 2;
    int ib = 0;
    for (int k = 0; k < N; ++k) {
      for (int j = 0; j < l; ++j) {
        T t = v(ib + j);
        v(ib + j) += v(ib + j + l);
        v(ib + j + l) = t - v(ib + j + l);
      }
      ib += 2 * l;
    }
    l *= 2;
  }

  v /= static_cast<T>(std::sqrt(static_cast<double>(v.size())));
}

template <class T>
Vec<T> dwht(const Vec<T> &v)
{
  Vec<T> ret(v.size());
  dwht(v, ret);
  return ret;
}

template <class T>
void dwht(const Vec<T> &vin, Vec<T> &vout)
{
  dht(vin, vout);
  bitrv(vout);
}


template <class T>
void self_dwht(Vec<T> &v)
{
  self_dht(v);
  bitrv(v);
}

template <class T>
Mat<T> dht2(const Mat<T> &m)
{
  Mat<T> ret(m.rows(), m.cols());
  Vec<T> v;

  for (int i = 0; i < m.rows(); ++i) {
    v = m.get_row(i);
    self_dht(v);
    ret.set_row(i, v);
  }
  for (int i = 0; i < m.cols(); ++i) {
    v = ret.get_col(i);
    self_dht(v);
    ret.set_col(i, v);
  }

  return transpose(ret);
}

template <class T>
Mat<T> dwht2(const Mat<T> &m)
{
  Mat<T> ret(m.rows(), m.cols());
  Vec<T> v;

  for (int i = 0; i < m.rows(); ++i) {
    v = m.get_row(i);
    self_dwht(v);
    ret.set_row(i, v);
  }
  for (int i = 0; i < m.cols(); ++i) {
    v = ret.get_col(i);
    self_dwht(v);
    ret.set_col(i, v);
  }

  return transpose(ret);
}


// ----------------------------------------------------------------------
// Instantiations
// ----------------------------------------------------------------------

#ifdef HAVE_EXTERN_TEMPLATE

extern template vec dht(const vec &v);
extern template cvec dht(const cvec &v);
extern template void dht(const vec &vin, vec &vout);
extern template void dht(const cvec &vin, cvec &vout);

extern template void self_dht(vec &v);
extern template void self_dht(cvec &v);

extern template vec dwht(const vec &v);
extern template cvec dwht(const cvec &v);
extern template void dwht(const vec &vin, vec &vout);
extern template void dwht(const cvec &vin, cvec &vout);

extern template void self_dwht(vec &v);
extern template void self_dwht(cvec &v);

extern template mat  dht2(const mat &m);
extern template cmat dht2(const cmat &m);

extern template mat  dwht2(const mat &m);
extern template cmat dwht2(const cmat &m);

#endif // HAVE_EXTERN_TEMPLATE


} // namespace itpp

#endif // #ifndef TRANSFORMS_H

---