Filter Library

Camera

Interface Physics

ScanFilterFFT.h

/*
 * ScanFilterFFT.h - forward FFT.
 *
 * This file is part of the Camera Filter Library.
 * Computer Aided Measurement Environment for Realtime Atomic imaging (Camera)
 *
 * Copyright (C) 2004-2005, Leiden Probe Microscopy.
 * Copyright (C) 2004-2005, Universiteit Leiden.
 *
 * Authors: M. Seynen (original), Martin J. Moene
 *
 * $Id: ScanFilterFFT.h 321 2006-02-21 09:15:41Z moene $
 */

#ifndef CFL_ScanFilterFFT_h
#define CFL_ScanFilterFFT_h

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <cfl/ScanFilter.h>             // for base class
#include <cfl/ScanBaseBuffer.h>         // for ValueType
#include <cfl/ProgressDlg.h>            // for class CProgressDlg
#include <cfl/ToolCilImage.h>           // for class Image

/**
 * \addtogroup cfl_filterfft Forward FFT
 * \brief forward fft.
 *

<h3>Purpose</h3>

<h3>Description</h3>

<h3>Algorithm</h3>


\f[
   \textrm{B} = \textrm{A}
\f]

<h3>Examples</h3>
Try to find some interesting pictures for most filters.

<h3>Contact</h3>
Dipl.phys. M.J. Rost<br>
Huygens Laboratorium<br>
Universiteit Leiden<br>
Niels Bohrweg 2<br>
2333 CA Leiden, The Netherlands<br>
<br>
Tel: +31 71 5275600<br>
Fax: +31 71 5275404<br>
<br>
E-mail: rost@physics.LeidenUniv.nl<br>
Web: http://www.geocities.com/marcel_rost/<br>

 *
 * @{
 */

DECLARE_CLASS( CScanFilterFFT );         // create various types

/**
 * \brief forward FFT.
 *
 */
class CScanFilterFFT : public CScanFilter
{
   /**
    * declare class serializable.
    */
   DECLARE_SERIAL( CScanFilterFFT );

public:
   /**
    * the parent class.
    */
   typedef CScanFilter Super;

   /**
    * the size type.
    */
   typedef CScanBaseBuffer::SizeType SizeType;

   /**
    * the value type.
    */
   typedef CScanBaseBuffer::ValueType ValueType;

   /**
    * the pointer type.
    */
   typedef ValueType* Pointer;

   /**
    * the pointer type.
    */
   typedef const ValueType* ConstPointer;

   /**
    * the Fourier element type.
    */
   typedef CScanBaseBuffer::FourierElementType FourierElementType;

   /**
    * the real type.
    */
   typedef FourierElementType RealType;

   /**
    * the power image type.
    */
   typedef cil::Image< RealType > PowerImageType;

   ///
   /// \name Construction
   /// @{

   /**
    * default constructor.
    */
   CScanFilterFFT();

   /**
    * destructor.
    */
   virtual ~CScanFilterFFT();

   /// @}
   /// \name Camera--Filter Interface
   /// @{

   /**
    * no dialog.
    */
   virtual BOOL CanDoDialogEntry() const;

//    /**
//     * \brief configure filter with settings as provided by the application on the
//     * filterlist window (e.g. via registry); see also CScanFilterNull::ReadFilterSettings().
//     */
//    virtual void ReadFilterSettings( );
//
//    /**
//     * \brief save filter settings e.g. for use with the filterlist window (e.g. via registry);
//     * see also ReadFilterSettings().
//     */
//    virtual void WriteFilterSettings( ) const;
//
   /**
    * no parameters; see also CScanFilterNull::GetParameters().
    */
   virtual LPCTSTR GetParameters() const;

   /**
    * no parameters; see also CScanFilterNull::SetParameters().
    */
   virtual BOOL SetParameters( LPCTSTR lpParameters );

//    /**
//     * start filter dialog to edit parameters; no filter operations;
//     * see also CScanFilterNull::EditModeless().
//     */
//    virtual BOOL EditModeless( CWnd *pParentWnd );
//
//    /**
//     * create filter dialog and prepare filter for Apply();
//     * see also CScanFilterNull::RunModeless().
//     */
//    virtual BOOL RunModeless( CWnd *pParentWnd, CDocument *pDoc );

   /**
    * check parameters, take care of a properly sized output buffer,
    * set its name and copy filter parameters and process;
    * see also CScanFilterNull::ApplyCore().
    */
   virtual BOOL Apply();

   /// @}
   /// \name Predicates
   /// @{

   /// @}
   /// \name Accessors
   /// @{

   /// @}
   /// \name Mutators
   /// @{

   /// @}

public:
   /**
    * the filter name.
    */
   static LPCTSTR m_lpcsFilterName;

   /**
    * the class short filtername.
    */
   static LPCTSTR m_lpcsShortFilterName;

   /*
    * the maximum amplitude to scale the power spectrum to.
    */
   static const ValueType maximumAmplitude; // = 20000;

protected:
   /**
    * store or retrieve the object's settings.
    */
   virtual void Serialize(CArchive& ar);

   /**
    * create a thread that computes the result.
    */
   static UINT ComputationThreadFunction( LPVOID lpContext );

   /**
    * called by working thread
    */
   BOOL Compute( CProgressDlg *pDlg );

   /**
    * compute a frame.
    */
   void ComputePart( CProgressDlg *pDlg, const Image& src, Image& dst, FourierElementType** pFFT );

   /**
    * compute power for a frame.
    */
   RealType ComputePower( CProgressDlg *pDlg, const Image& src, FourierElementType** pFFT, PowerImageType& pwr );

   /**
    * compute output for a frame.
    */
   void ComputeOutput( CProgressDlg *pDlg, RealType maxAmpIn, const PowerImageType& pwr, Image& dst );

   /**
    * the computation thread arguments type.
    */
   class ThreadArgs
   {
   public:
      /**
       * constructor
       */
      ThreadArgs( CProgressDlg* Dlg, CScanFilterFFT* This ) :
         pDlg( Dlg ), pThis( This ), bReturn( 0 )
      {
         ; // do nothing
      }

      BOOL bReturn;                     ///< the thread return value
      CProgressDlg *pDlg;               ///< the progress dialog
      CScanFilterFFT *pThis;            ///< the filter
   };
   
   /**
    * progress counter.
    */
   int m_progress;
};

/// @} cfl_filterfft

#endif // CFL_ScanFilterFFT_h

/*
 * end of file
 */

---