Filter Library

Camera

Interface Physics

ScanFilterNCCFFT.h

/*
 * ScanFilterNCCFFT.h - fast normalized cross-correlation filter.
 *
 * 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: Martin J. Moene
 *
 * $Id: ScanFilterNCCFFT.h 464 2007-01-07 14:01:00Z moene $
 */

#ifndef CFL_ScanFilterNCCFFT_h
#define CFL_ScanFilterNCCFFT_h

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

#include <cfl/ScanFilter.h>             // for base class
#include <cfl/ScanBaseBuffer.h>         // for ValueType

/**
 * \addtogroup  cfl_fastnormalizedcrosscorrelation Fast Normalized Cross-Correlation Filter
 * \brief fast normalized cross-correlation filter.
 *

<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( CScanFilterNCCFFT );         // create various types

/**
 * \brief mean filter.
 *
 */
class CScanFilterNCCFFT : public CScanFilter
{
   /**
    * its dialog class.
    */
   friend class CFilterDlg_NCCFFT;

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

   /**
    * the input pixel type.
    */
   typedef ValueType InputPixelType;

   /**
    * the output pixel type.
    */
   typedef ValueType OutputPixelType;

   /**
    * normalization type.
    */
   enum SubtractionType
   {
      bgNone,                   ///< none
      bgMean,                   ///< normal
      bgBackground,             ///< linear regression, planar background
      bgDimension_,             ///< the number of entries
   };

   /**
    * normalization type.
    */
   enum NormalizationType
   {
      nmNone,                   ///< none
      nmNormal,                 ///< normal
      nmPhase,                  ///< phase
      nmDimension_,             ///< the number of entries
   };

   /**
    * normalization sub-type.
    */
   enum NormalizationSubType
   {
      nsZeroMean,               ///< zero-mean
      nsEnergy,                 ///< energy
      nsPlanar,                 ///< planer bg subtr for image-under-template
      nsDimension_,             ///< the number of entries
   };

   /**
    * the scale type.
    */
   typedef double ScaleType;

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

   /**
    * default constructor: setup filter to run without dialog;
    * see also CScanFilterNull::CScanFilterNull().
    */
   CScanFilterNCCFFT();

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

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

//    /**
//     * no partial data.
//     */
//   virtual BOOL CanDoPartialData() const;
//
//    /**
//     * has dialog (default true).
//     */
//    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;

   /**
    * provide current filter parameter(s) for filter-scripting capture
    * in the main application;
    * see also CScanFilterNull::GetParameters().
    */
   virtual LPCTSTR GetParameters() const;

   /**
    * set parameters for filter-script execution of filter;
    * see also CScanFilterNull::SetParameters().
    */
   virtual BOOL SetParameters( LPCTSTR lpParameters );

//    /**
//     * the supported dragmethod(s).
//     */
//    virtual DragSupportType SupportDragInput() const;
//
//    /**
//     * apply the filter to the selected area.
//     */
//    virtual void SetDragInput( BOOL bL2R, CRect rcIn );
//
//    /**
//     * start filter dialog to edit parameters; no filter operations;
//     * see also CScanFilterNull::EditModeless().
//     */
//    virtual BOOL EditModeless( CWnd *pParentWnd );

   /**
    * create filter dialog and pre Apply() filter to view result;
    * 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::Apply().
    */
   virtual BOOL Apply();

   /**
    * the number of input buffers is 2.
    */
   virtual DWORD GetNrOfInBuffers() const;

   /**
    * the requested input buffer.
    */
   virtual CScanBaseBuffer* GetInputBuffer( UINT nNr );

   /**
    * set the given input buffer.
    */
   virtual void SetInputBuffer( UINT nNr, CScanBaseBuffer *lpsbIn );

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

   /**
    * true if the FFT size has been relaxed (allow overlap).
    */
   bool DoRelaxFFTSize() const
   {
      return m_relax_fft_size;
   }

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

   /**
    * the normalization type.
    */
   SubtractionType GetSubtractionType() const
   {
      return m_subtract;
   }

   /**
    * the normalization type.
    */
   NormalizationType GetNormalizationType() const
   {
      return m_norm;
   }

   /**
    * the normalization sub-type.
    */
   NormalizationSubType GetNormalizationSubType() const
   {
      return m_normsub;
   }

   /**
    * the scale factor.
    */
   ScaleType GetScale( NormalizationType type ) const
   {
//       return m_scale;
      return m_scale[ type ];
   }

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

   /**
    * set the subtraction type.
    */
   void SetSubtractionType( SubtractionType subtract )
   {
      m_subtract = subtract;
   }

   /**
    * set the normalization type.
    */
   void SetNormalizationType( NormalizationType norm )
   {
      m_norm = norm;
   }

   /**
    * set the normalization sub-type.
    */
   void SetNormalizationSubType( NormalizationSubType normsub )
   {
      m_normsub = normsub;
   }

   /**
    * relax the FFT image size and allow overlap in the transformation.
    */
   void SetRelaxFFTSize( bool relax_fft_size )
   {
      m_relax_fft_size = relax_fft_size;
   }

   /**
    * set the scale factor.
    */
   void SetScale( NormalizationType type, ScaleType scale )
   {
      m_scale[ type ] = scale;
   }

    /// @}

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

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

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

   /**
    * the default scale factor.
    */
   static const ScaleType m_defScale;

protected:
   /**
    * the second input buffer.
    */
   CScanBaseBuffer *m_lpsbIn2;

   /**
    * the normalization type.
    */
   SubtractionType m_subtract;

   /**
    * the normalization type.
    */
   NormalizationType m_norm;

   /**
    * the normalization sub-type.
    */
   NormalizationSubType m_normsub;

   /**
    * use minimal FFT size.
    */
   bool m_relax_fft_size;

   /**
    * the scale factors (one for each normalization type).
    */
   ScaleType m_scale[ nmDimension_ ];
};

/// @} cfl_filtermean

#endif // CFL_ScanFilterNCCFFT_h

/*
 * end of file
 */

---