dox/Imaging/vtkImageMRIFourierFilter.h

Go to the documentation of this file.

/*=========================================================================

  Program:   vtkCNMRRLibrary
  Module:    $RCSfile: vtkImageMRIFourierFilter.h,v $

  Copyright  2005  The Pennsylvania State University
  
          Notice
 
  The contents of this file are subject to The Pennsylvania State University 
  Open Source License (the "License"); you may not use this file except in 
  compliance with the License. You may obtain a copy of the License at H066 
  Radiology, NMR Building, 500 University Drive, Hershey, PA, 
  tel. (717) 531-6069 or via email at dcb210@psu.edu.
 
  Software distributed under the License is distributed on an "AS IS" basis, 
  WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License 
  for the specific language governing rights and limitations under the 
  License.
 
  The Original Code is listed under Exhibit A of the license.
 
  The Initial Developer of the Original Code is Don Bigler.
 
  Contributor(s):
 
     
  Adpated from vtkImageFourierFilter.h

=========================================================================*/
#ifndef __vtkImageMRIFourierFilter_h
#define __vtkImageMRIFourierFilter_h


#include "vtkImageDecomposeFilter.h"
#include "vtkCNMRRImagingWin32Header.h"


//BTX
/*******************************************************************
                        COMPLEX number stuff
*******************************************************************/

#if defined(AMD64_TRUE) && defined(USE_AMD_ACML)
#define SIN    fastsin
#define COS    fastcos
#define EXP    fastexp
#else
#define SIN    sin
#define COS    cos
#define EXP    exp
#endif


typedef struct{
    double Real;
    double Imag;
  } vtkImageComplexNumber;


#define vtkImageComplexNumberEuclidSet(C, R, I) \
  (C).Real = (R); \
  (C).Imag = (I)

#define vtkImageComplexNumberPolarSet(C, M, P) \
  (C).Real = (M)*COS(P); \
  (C).Imag = (M)*SIN(P)

#define vtkImageComplexNumberPrint(C) \
  printf("(%.3f, %.3f)", (C).Real, (C).Imag)

#define vtkImageComplexNumberScale(cOut, S, cIn) \
  (cOut).Real = (cIn).Real * (S); \
  (cOut).Imag = (cIn).Imag * (S)

#define vtkImageComplexNumberConjugate(cIn, cOut) \
  (cOut).Imag = (cIn).Imag * -1.0;    \
  (cOut).Real = (cIn).Real

#define vtkImageComplexNumberAdd(C1, C2, cOut) \
  (cOut).Real = (C1).Real + (C2).Real; \
  (cOut).Imag = (C1).Imag + (C2).Imag

#define vtkImageComplexNumberSubtract(C1, C2, cOut) \
  (cOut).Real = (C1).Real - (C2).Real; \
  (cOut).Imag = (C1).Imag - (C2).Imag

#define vtkImageComplexNumberMultiply(C1, C2, cOut) \
{ \
  vtkImageComplexNumber _vtkImageComplexMultiplyTemp; \
  _vtkImageComplexMultiplyTemp.Real = (C1).Real*(C2).Real-(C1).Imag*(C2).Imag;\
  _vtkImageComplexMultiplyTemp.Imag = (C1).Real*(C2).Imag+(C1).Imag*(C2).Real;\
  cOut = _vtkImageComplexMultiplyTemp; \
}

#define vtkImageComplexNumberDivide(C1, C2, cOut) \
{ \
  vtkImageComplexNumber _vtkImageComplexDivideTemp; \
  _vtkImageComplexDivideTemp.Real = ((C1).Real*(C2).Real+(C1).Imag*(C2).Imag)/((C2).Real*(C2).Real+(C2).Imag*(C2).Imag);\
  _vtkImageComplexDivideTemp.Imag = ((C2).Real*(C1).Imag-(C2).Imag*(C1).Real)/((C2).Real*(C2).Real+(C2).Imag*(C2).Imag);\
  cOut = _vtkImageComplexDivideTemp; \
}

// This macro calculates exp(cIn) and puts the result in cOut 
#define vtkImageComplexNumberExponential(cIn, cOut) \
{ \
  double tmp = EXP(cIn.Real); \
  cOut.Real = tmp * COS(cIn.Imag); \
  cOut.Imag = tmp * SIN(cIn.Imag); \
}

/******************* End of COMPLEX number stuff ********************/
//ETX

class VTK_CNMRR_IMAGING_EXPORT vtkImageMRIFourierFilter : public vtkImageDecomposeFilter
{
   public:
      vtkTypeRevisionMacro(vtkImageMRIFourierFilter,vtkImageDecomposeFilter);
   
   
      // public for templated functions of this object
      //BTX
   

      vtkSetMacro(Decimation, int);
      vtkGetMacro(Decimation, int);
      vtkBooleanMacro(Decimation, int);
      
      void ExecuteFft(vtkImageComplexNumber *in, vtkImageComplexNumber *out, int N);
      
      
      void ExecuteRfft(vtkImageComplexNumber *in, vtkImageComplexNumber *out, int N);
      
      //ETX
   
   protected:
      vtkImageMRIFourierFilter();
      ~vtkImageMRIFourierFilter() {};
      
      //BTX
      int Decimation;
         
      void ExecuteFftStep2(vtkImageComplexNumber *p_in, vtkImageComplexNumber *p_out, 
                     int N, int bsize, int fb);
      void ExecuteFftStepN(vtkImageComplexNumber *p_in, vtkImageComplexNumber *p_out,
                     int N, int bsize, int n, int fb);
      void ExecuteFftForwardBackward(vtkImageComplexNumber *in, vtkImageComplexNumber *out, 
                     int N, int fb);
      //ETX
   private:
      vtkImageMRIFourierFilter(const vtkImageMRIFourierFilter&);  // Not implemented.
      void operator=(const vtkImageMRIFourierFilter&);  // Not implemented.
};



#endif

---