Filter Library

Camera

Interface Physics

ScanFilterDZ.h

/*
 * ScanFilterDZ.h - scaled add 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: Els van Tol (original), Martin J. Moene
 *
 * $Id: ScanFilterDZ.h 359 2006-03-06 15:52:00Z moene $
 */

#ifndef CFL_SCANFILTERDZ_H
#define CFL_SCANFILTERDZ_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_filterdz Add Scaled Buffer and Offset
 * \brief add scaled buffer and offset.
 *

<h3>Purpose</h3>

Combine original image with delta-Z information.

<h3>Description</h3>

For some (fast) measurements it is useful to construct an image that is a
combination of the original image and the delta-Z signal.

delta-Z can be derived from the delta-I which is obtained after log-conversion.
To convert from delta-I to delta-Z, a conversion factor must be applied. To 
compensate for a possible constant current, a offset value must be applied.

Thus the delta-Z values can be obtained from scaled and shifted delta-I values.

<h3>Algorithm</h3>


\f[
   \textrm{C} = \textrm{A} + a \times \textrm{B} + b
\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( CScanFilterDZ );         // create various types

/**
 * \brief frame-by-frame differential filter.
 *
 */
class CScanFilterDZ : public CScanFilter
{
   /**
    * its dialog class.
    */
   friend class CFilterDlg_DZ;

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

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

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

   /**
    * the size type.
    */
   typedef CSize SizeType;

   /**
    * the size element type.
    */
   typedef DWORD SizeElementType;

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

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

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

   /// @}
   /// \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 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
   /// @{

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

   /**
    * the current factor.
    */
   double GetFactor() const;

   /**
    * the current offset.
    */
   double GetOffset() const;

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

   /**
    * set the factor.
    */
   void SetFactor( double factor );

   /**
    * set the offset.
    */
   void SetOffset( double offset );

   /// @}

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

   /**
    * process the given frame part (L2R, R2L frame part).
    */
   void Process( ConstPointer in1, ConstPointer end1, ConstPointer in2, Pointer out );

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

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

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

   /**
    * the default factor.
    */
   static const double def_dFactor;

   /**
    * the default offset.
    */
   static const double def_dOffset;

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

   /**
    * the filter offset value.
    */
   double m_dOffset;

   /**
    * the filter multiplication value
    */
   double m_dFactor;

};

/// @}  cfl_filterdz

/**
 * the current factor.
 */
inline double CScanFilterDZ::GetFactor() const
{
   return m_dFactor;
}

/**
 * set the factor.
 */
inline void CScanFilterDZ::SetFactor( double factor )
{
   m_dFactor = factor;
}

/**
 * the current offset.
 */
inline double CScanFilterDZ::GetOffset() const
{
   return m_dOffset;
}

/**
 * set the offset.
 */
inline void CScanFilterDZ::SetOffset( double offset )
{
   m_dOffset = offset;
}

#endif // CFL_SCANFILTERDZ_H

/*
 * end of file
 */

---