Filter Library

Camera

Interface Physics

ScanFilterCustom.h

/*
 * ScanFilterCustom.h - custom 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: M. Seynen (original), Martin J. Moene
 *
 * $Id: ScanFilterCustom.h 236 2005-06-27 09:03:17Z moene $
 */

#ifndef CFL_SCANFILTERCUSTOM_H
#define CFL_SCANFILTERCUSTOM_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_filtercustom Custom Filter
 * \brief smooth filter.
 *

<h3>Purpose</h3>

Provide filters based on several predefined convolution kernels and a user definable kernel.

<h3>Description</h3>

The custom filter provides the following predefined filter kernels:
- Blur (5 x 5)
- Low pass (3 x 3)
- High pass (5 x 5)
- Edge (4 x 4)
- Pyramidal (5 x 5)
- Cone (5 x 5)
- Gaussian, sigma=1 (5 x 5)
- Laplacian (3 x 3)
- Sharpening (3 x 3)

<h3>Algorithm</h3>

Convolution

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

/**
 * \brief smooth filter.
 *
 */
class CScanFilterCustom : public CScanFilter
{
   /**
    * its dialog class.
    */
   friend class CFilterDlg_Custom;

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

   /**
    * the kernel-weight type.
    */
   typedef double WeightType;

   /**
    * the kernel-weight pointer type.
    */
   typedef WeightType* WeightTypePtr;

   /**
    * the kernel-weight pointer type (const).
    */
   typedef const WeightType* WeightTypeConstPtr;

   /**
    * the filter type.
    */
   enum FilterType
   {
      ftBlur = 0,                       ///< the blur filter
      ftLowPass,                        ///< the low pass filter
      ftHighPass,                       ///< the high pass filter
      ftEdge,                           ///< the edge filter
      ftPyramidal,                      ///< the pyramidal filter
      ftCone,                           ///< the cone filter
      ftGaussian,                       ///< the gaussian filter
      ftLaplacian,                      ///< the laplacian filter
      ftSharpening,                     ///< the laplacian sharpening filter
      ftUser,                           ///< the user defined filter
   };

   /**
    * the kernel size.
    */
   enum
   {
      KernelWidth  = 5,                 ///< the kernel width
      KernelHeight = 5,                 ///< the kernel height
      KernelSize   = KernelWidth * KernelHeight,        ///< the kernel size
   };

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

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

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

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

   /**
    * \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 );

   /**
    * 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::ApplyCore().
    */
   virtual BOOL Apply();

   /**
    * the supported dragmethod(s).
    */
//   virtual DragSupportType SupportDragInput() const;

   /**
    * apply the filter to the selected area.
    */
//   void SetDragInput( BOOL bL2R, CRect rcIn );

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

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

   /**
    * the current filter type.
    */
   FilterType GetFilterType() const;

   /**
    * the current short filter name.
    */
   LPCTSTR GetShortFilterName() const;

   /**
    * the given kernel weight.
    */
   WeightType GetWeight( int n ) const;

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

   /**
    * set the given filter type.
    */
   void SetFilterType( FilterType type );

   /**
    * set the given kernel weight.
    */
   void SetWeight( int n, WeightType w );

   /// @}

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

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

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

   /**
    * process the given frame part (L2R, R2L frame part).
    */
   void Convolve( BOOL bDoR2L );

protected:
   /**
    * the filter type.
    */
   FilterType m_currentFilterType;

   /**
    * the current filter-weights (5x5).
    */
   WeightTypeConstPtr m_currentWeights;

   /**
    * the blur filter-weights (5x5).
    */
   static const WeightType m_blurWeights[ KernelSize ];

   /**
    * the low-pass filter-weights (5x5).
    */
   static const WeightType m_lowpassWeights[ KernelSize ];

   /**
    * the high-pass filter-weights (5x5).
    */
   static const WeightType m_highpassWeights[ KernelSize ];

   /**
    * the edge filter-weights (5x5).
    */
   static const WeightType m_edgeWeights[ KernelSize ];

   /**
    * the pyramidal filter-weights (5x5).
    */
   static const WeightType m_pyramidalWeights[ KernelSize ];

   /**
    * the cone filter-weights (5x5).
    */
   static const WeightType m_coneWeights[ KernelSize ];

   /**
    * the gaussian filter-weights (5x5).
    */
   static const WeightType m_gaussianWeights[ KernelSize ];

   /**
    * the laplacian filter-weights (5x5).
    */
   static const WeightType m_laplacianWeights[ KernelSize ];

   /**
    * the sharpening filter-weights (5x5).
    */
   static const WeightType m_sharpeningWeights[ KernelSize ];

   /**
    * the user filter-weights (5x5).
    */
   WeightType m_userWeights[ KernelSize ];

};

/// @} cfl_filterCustom

/**
 * the current filter type.
 */
inline CScanFilterCustom::FilterType CScanFilterCustom::GetFilterType() const
{
   return m_currentFilterType;
}

/*
 * the given kernel weight.
 */
inline CScanFilterCustom::WeightType CScanFilterCustom::GetWeight( int n ) const
{
   if ( Q_INVALID ( ( 0 > n || n > KernelSize ) && "ensure valid weight number." ) )
   {
      return 1.0;
   }

   return m_currentWeights[ n ];
}

/*
 * set the given kernel weight.
 */
inline void CScanFilterCustom::SetWeight( int n, WeightType w )
{
   if ( Q_INVALID ( ( 0 > n || n > KernelSize ) && "ensure valid weight number." ) )
   {
      return ;
   }

   if ( Q_INVALID ( ftUser != GetFilterType() && "ensure user filter type." ) )
   {
      return ;
   }

   m_userWeights[ n ] = w;
}

#endif // CFL_SCANFILTERCUSTOM_H

/*
 * end of file
 */

---