Filter Library

Camera

Interface Physics

ScanFilterNull.h

/*
 * // FIXME: filename and text
 * ScanFilterNull.h - a null filter to
 * (1) document general ascpects of filters, (2) act as a filter template.
 *
 * This file is part of the Camera Filter Library.
 * Computer Aided Measurement Environment for Realtime Atomic imaging (Camera)
 *
 * Copyright (C) 2004, Leiden Probe Microscopy.
 * Copyright (C) 2004, Universiteit Leiden.
 *
 * Authors: Martin J. Moene (original)
 *
 * $Id: ScanFilterNull.h 236 2005-06-27 09:03:17Z moene $
 */

#ifndef CFL_SCANFILTERNULL_H            // FIXME: filename
#define CFL_SCANFILTERNULL_H            // FIXME: filename

#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_filternull Null Filter
 * \brief almost no-op filter to document general aspects of filters.
 *

<h3>Purpose</h3>

This filter serves two purposes:
-# it documents the features common to all filters
-# it is a template to create new filters from (see \ref cfl_develop_filter_class)

<h3>Description</h3>
Tell more about the filter.

<h3>Algorithm</h3>

The algorithm used: \f$y_{ij} = a \times x_{ij} + b\f$.

As display:
\f[
   y_{ij} = a \times x_{ij} + b
\f]

<h3>Examples</h3>
Try to find some interesting pictures for most filters. This one is not so interesting.

<h3>Contact</h3>

Ing. M.J. Moene<br>
Huygens Laboratorium<br>
Universiteit Leiden<br>
Niels Bohrweg 2<br>
2333 CA Leiden, The Netherlands<br>

Tel: +31 71 5275960<br>
Fax: +31 71 5275819<br>

E-mail: m.j.moene@eld.physics.LeidenUniv.nl<br>
Web: http://www.eld.physics.leidenuniv.nl/~moene/<br>

 *
 * @{
 */

DECLARE_CLASS( CScanFilterNull );       // create various types

/**
 * \brief null scanfilter.
 *
 * This is the class for the Null Filter. Its purpose is twofold:
 * -# document the features common to all filters
 * -# be a template to create new filters from (see \ref cfl_develop_filter_class)
 *
 * As a filter, class CScanFilterNull simply copies its input buffer to its 
 * ouput buffer using STL std::transform(), while applying the formula: 
 * \f$y_{ij} = factor \times x_{ij} + offset\f$.
 *
 * \todo change "stdafx.h" in .cpp to <cfl/stdafx.h> when all filters have been adapted.
 * "stdafx.h" is used to determine the contents of the precompiled headers;
 * see prj settings C/C++, precompiled headers, through header "stdafx.h")
 *
 * \author Martin J. Moene
 */

class CScanFilterNull : public CScanFilter
{
public:
   ///
   /// \name Types
   /// @{

   /**
    * specify the scan base buffer datatype; having ValueType we omit the type
    * specification from the variablename: \p pStart in stead of \p pwStart;
    * see for example Process().
    */

   typedef CScanBaseBuffer::ValueType ValueType;

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

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

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

   CScanFilterNull();
   virtual ~CScanFilterNull();

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

//   virtual BOOL    CanDoPartialData() const;
//   virtual BOOL    CanDoDialogEntry() const;

   virtual void    ReadFilterSettings( );
   virtual void    WriteFilterSettings( ) const;

   virtual LPCTSTR GetParameters( ) const;
   virtual BOOL    SetParameters( LPCTSTR lpParameters );

   virtual BOOL    RunModeless( CWnd *pParentWnd, CDocument *pDoc );

   virtual BOOL    Apply();
   virtual BOOL    ApplyCore();
   virtual void    Process( ConstPointer pStartIn, Pointer pStartOut, DWORD dwSize );

   virtual SPerformanceTestResult 
                   GetPerformanceTestResult();

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

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

   double  GetFactor();
   double  GetOffset();

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

   void    SetFactor( double aFactor );
   void    SetOffset( double aOffset );

   /// @}

protected:
   virtual void Serialize( CArchive& ar );

   DECLARE_SERIAL( CScanFilterNull )

public:
   static LPCTSTR m_lpcsFilterName;     ///< filter name

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

   static const double def_dFactor;     ///< default factor
   static const double def_dOffset;     ///< default offset

private:
   double m_dFactor;                    ///< current factor value
   double m_dOffset;                    ///< current offset value
};

/// @} group cfl_filternul

/**
 * the factor.
 */

inline double CScanFilterNull::GetFactor()
{
   return m_dFactor;
}

/**
 * the offset.
 */

inline double  CScanFilterNull::GetOffset()
{
   return m_dOffset;
}

/**
 * set the factor.
 */

inline void CScanFilterNull::SetFactor( double aFactor )
{
   m_dFactor = aFactor;
}

/**
 * set the offset.
 */

inline void CScanFilterNull::SetOffset( double aOffset )
{
   m_dOffset = aOffset;
}


#endif // #ifndef CFL_SCANFILTERNULL_H

/*
 * end of file
 */

---