ExampleFFT2D.cpp

/* This file is part of the BIAS library (Basic ImageAlgorithmS).

   Copyright (C) 2003-2009    (see file CONTACT for details)
   Multimediale Systeme der Informationsverarbeitung
   Institut fuer Informatik
   Christian-Albrechts-Universitaet Kiel
   
   
   BIAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published by
   the Free Software Foundation; either version 2.1 of the License, or
   (at your option) any later version.
   
   BIAS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.
   
   You should have received a copy of the GNU Lesser General Public License
   along with BIAS; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA*/


/**
 * @example ExampleFFT2D.cpp
   @relates FFT2D
   @brief Example for using the fast fourier Transform (FFT)
   @ingroup g_examples
   @author  MIP
*/

#include <Image/FFT2D.hh>
#include <Base/Image/Image.hh>
#include <Base/Image/ImageIO.hh>
#include <Base/Image/ImageConvert.hh>
#include <Base/Debug/TimeMeasure.hh>


using namespace std;
using namespace BIAS;


int main(int argc, char *argv[])
{
  TimeMeasure StopWatch;

  if (argc<2 || argc > 3){
    cerr << argv[0] << "  <image> [image2]\n";
    return -1;
  }

  Image<unsigned char> im1, im1grey;

  if (ImageIO::Load(argv[1], im1)!=0){
    BIASERR("error loading image "<<argv[1]);
    return -2;
  } 
  
  ImageConvert::ToGrey(im1,im1grey);
  //ImageIO::Save("0_Grey1",im1grey);
  ImageIO::Save("0_Grey1",im1grey);

  FFT2D<unsigned char, float> fft;
  fft.Init(im1grey.GetWidth(),im1grey.GetHeight());

  Image<float> i,r,m,p;
  Image<float> test;
  StopWatch.Start();
 // for (unsigned int k=0;k<100;k++)
    fft.Filter(im1grey,r,i);
  StopWatch.Stop();
  cout <<"FFT Forward took [ms] :"<<StopWatch.GetRealTime()/1000<<endl;;

  fft.Filter(im1grey, test);
  fft.Normalize(test);
  Image<unsigned char> revTrans;
  fft.TransformReverse(test, revTrans);
  ImageIO::Save("revTrans.mip", revTrans);
  
  ImageIO::Save("1_Imaginaer1",i);
  ImageIO::Save("1_Real1",r);

  fft.TransformPhase(im1grey,p);
    fft.TransformAbs(im1grey,m);
   // fft.Normalize(m);
    ImageIO::Save("2_M1",m);
    //ImageIO::Write("2_P1",p);

  if(argc == 3){
    Image<unsigned char> im2, im2grey,res;
    Image<float> cps;
    if (ImageIO::Load(argv[2], im2)!=0){
      BIASERR("error loading image "<<argv[2]);
      return -2;
    }
    if((im1.GetWidth() != im2.GetWidth()) || 
       (im1.GetHeight() != im2.GetHeight())){
      BIASERR("images must have same size!");
      return -2;
    }
    ImageConvert::ToGrey(im2,im2grey);
    //ImageIO::Save("0_Grey2",im2grey);
    ImageIO::Save("0_Grey2",im2grey);

    fft.Filter(im2grey,r,i);
    //ImageIO::Save("1_Imaginaer2",i);
    //ImageIO::Save("1_Real2",r);
    ImageIO::Save("1_Imaginaer2",i);
    ImageIO::Save("1_Real2",r);
    //ImageIO::Save("1_Hanning2",im2grey);

    //fft.TransformPhase(im2grey,p);
    //fft.TransformAbs(im2grey,m);
    //fft.Normalize(m);
    //ImageIO::Save("2_M2",m);
    //ImageIO::Save("2_P2",p);

    fft.CrossPowerSpectrum(im1grey,im2grey,cps);
    //ImageIO::Save("2_CPS",cps);
    ImageIO::Save("2_CPS",cps);
    //ImageIO::Save("2_M_Norm",m);
    //fft.Normalize(cps);
    //fft.Normalize(cps);
    //ImageIO::Save("3_Normalized",cps);
    fft.TransformReverse(cps,res);
    //ImageIO::Save("4_Resolution",res);
    ImageIO::Save("4_Resolution",res);

  }



/*
  // transform to 2-channel image for complex representation
  fft.Filter(imgrey,res);
  ImageIO::Save("1_FFT2D_Filter",res);
  fft.Normalize(res);
  ImageIO::Save("2_FFT2D_Normalized",res);
  fft.TransformReverse(res,imgrev);
  ImageIO::Save("3_FFT2D_Reversed",imgrev);
*/
/*
  // transform to 2 image (1 channel per image) for complex representation
  fft.Filter(im1grey,r1,r2);
  ImageIO::Save("4_FFT2D_real",r1);
  ImageIO::Save("5_FFT2D_im",r2);

  fft.Normalize(r1);
  fft.Normalize(r2);
  ImageIO::Save("6_FFT2D_real_norm",r1);
  ImageIO::Save("7_FFT2D_im_norm",r2);

  // transform to 1 image with 1 channel, magnitude and phase
  fft.TransformAbs(im1grey,res);
  ImageIO::Save("8_FFT2D_magnitude",res);
  fft.MultHanning(res);
  ImageIO::Save("8_FFT2D_magnitude_hanning",res);
  fft.Normalize(res);
  ImageIO::Save("8_FFT2D_magnitude_norm",res);

  fft.TransformPhase(im1grey,res);
  ImageIO::Save("9_FFT2D_phase",res);
  fft.Normalize(res);
  ImageIO::Save("9_FFT2D_phase_norm",res);
*/
  return 0;
}