Filter Library

Camera

Interface Physics

ScanFilterDZ.cpp

/*
 * ScanFilterDZ.cpp - 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-Homan (original), Martin J. Moene
 *
 * $Id: ScanFilterDZ.cpp 400 2006-09-28 13:34:02Z moene $
 */

/*
 * configuration defines:
 */

// currently nothing

/*
 * end of configuration defines.
 */

#include "stdafx.h"                     // for common (pre-compiled) headers
//#include <cfl/stdafx.h>                 // for common (pre-compiled) headers
#include <cfl/resource.h>               // for messages and other resources

#include <Camera/InterfaceDll.h>        // Camera--Filter Library interface
//#include <Camera/CameraGeneralDefines.h>// for g_d2PI

#include <cfl/ScanFilterDZ.h>           // this filter's header
#include <cfl/FilterDlg_DZ.h>           // this filter's dialog

#pragma warning( disable: 4018 4100 4116 4146 4244 4663)
#include <cil/Math.h>                   // for cil::min()
#pragma warning( default: 4018 4100 4116 4146 4244 4663)

#include <algorithm>                    // for std::transform()

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

#define CFL_SCHEMAVERSION_FILTERDZ 0  // permanent storage schema version
                                                // this filter's name
LPCTSTR CScanFilterDZ::m_lpcsFilterName = _T("DZ-Correction");
                                        // this filter's short name
LPCTSTR CScanFilterDZ::m_lpcsShortFilterName = _T( "DZ" );
                                                // serialization
IMPLEMENT_SERIAL(CScanFilterDZ, CScanFilter, CFL_SCHEMAVERSION_FILTERDZ )

/*
 * default factor: 1.
 */
const double CScanFilterDZ::def_dFactor = 1.0;

/*
 * default offset: 0.
 */
const double CScanFilterDZ::def_dOffset = 0.0;

/*
 * constructor.
 */
CScanFilterDZ::CScanFilterDZ() :
   m_lpsbIn2( NULL ),
   m_dFactor( def_dFactor ),
   m_dOffset( def_dOffset )
{
//   Q_LOG( _T("CScanFilterDZ::CScanFilterDZ()") );

   m_csFilterName = m_lpcsFilterName;

   ReadFilterSettings();
}

/*
 * destructor.
 */
CScanFilterDZ::~CScanFilterDZ()
{
//   Q_LOG( _T("CScanFilterDZ::~CScanFilterDZ()") );

   ; // do nothing
}

/*
 * store or retrieve the object's settings;
 * see also CScanFilterNull::Serialize().
 */
void CScanFilterDZ::Serialize(CArchive& ar)
{
//   Q_LOG( _T("CScanFilterDZ::Serialize()") );

   CScanFilter::Serialize( ar );

   if ( ar.IsStoring() )
   {
      ar << m_dFactor << m_dOffset;
   }
   else
   {
      ar >> m_dFactor >> m_dOffset;
   }
};

/*
 * \brief configure filter with settings as provided by the application on the
 * filterlist window (e.g. via registry); see also CScanFilterNull::ReadFilterSettings().
 */
void CScanFilterDZ::ReadFilterSettings()
{
//   Q_LOG( _T("CScanFilterDZ::ReadFilterSettings()") );

   CWinApp* pApp = AfxGetApp();

   if ( Q_INVALID( NULL == pApp ) )
      return ;

   /*
    * parameter string:
    */
   SetParameters( pApp->GetProfileString( gCflRegistrySubkey, m_lpcsFilterName, _T( "1,0" ) ) );
}

/*
 * \brief save filter settings e.g. for use with the filterlist window (e.g. via registry);
 * see also ReadFilterSettings().
 */
void CScanFilterDZ::WriteFilterSettings() const
{
//   Q_LOG( _T("CScanFilterDZ::WriteFilterSettings()") );

   CWinApp* pApp = AfxGetApp();

   if ( Q_INVALID( NULL == pApp ) )
      return ;

   /*
    * parameter string:
    */
   LPCTSTR pStr = GetParameters();

   if ( pStr )
   {
      pApp->WriteProfileString( gCflRegistrySubkey, m_lpcsFilterName, pStr );
      delete const_cast<LPTSTR>( pStr );
   }
}

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

   /*
    * format parameters and return a c-string on the heap:
    */
   CString csParameters;

   csParameters.Format( _T( "%g,%g" ), m_dFactor, m_dOffset );

   return strcpy( new TCHAR[ csParameters.GetLength() + 1 ], csParameters );
}

/*
 * set parameters for filter-script execution of filter;
 * see also CScanFilterNull::SetParameters().
 */
BOOL CScanFilterDZ::SetParameters( LPCTSTR lpParameters )
{
//   Q_LOG( _T("CScanFilterDZ::SetParameters()") );

   if ( Q_INVALID( NULL == lpParameters && "ScanFilterDZ (SetParameters): parameters expected, none provided (NULL)." ) )
   {
      return FALSE;
   }

   /*
    * set defaults, read parameter string with factor and optional offset:
    */
   m_dFactor = def_dFactor;
   m_dOffset = def_dOffset;

   int nfields = _stscanf( lpParameters, _T( "%lg,%lg" ), &m_dFactor, &m_dOffset );

   if ( Q_INVALID( 2 > nfields && "CScanFilterDZ (SetParameters): factor and optional offset expected, got none." ) )
   {
      return FALSE;
   }

   return TRUE;
}

/**
 * the number of input buffers.
 */
DWORD CScanFilterDZ::GetNrOfInBuffers() const
{
   return 2;
}

/**
 * return the requested input buffer.
 */
CScanBaseBuffer *CScanFilterDZ::GetInputBuffer( UINT nNr )
{
   Q_ASSERT( 0 <= nNr && nNr < GetNrOfInBuffers() && "ensure valid input buffer nr" );

   if ( 1 == nNr )
   {
      return m_lpsbIn2;
   }

   return m_lpsbIn;
}

/**
 * set the given input buffer.
 */
void CScanFilterDZ::SetInputBuffer( UINT nNr, CScanBaseBuffer *lpsbIn )
{
   Q_ASSERT( 0 <= nNr && nNr < GetNrOfInBuffers() && "ensure valid input buffer nr" );
   Q_ASSERT( NULL != lpsbIn && "ensure valid input buffer" );

   if ( 0 == nNr )
   {
      m_lpsbIn = lpsbIn;
   }
   else if ( 1 == nNr )
   {
      m_lpsbIn2 = lpsbIn;
   }
}

/*
 * start filter dialog to edit parameters; no filter operations;
 * see also CScanFilterNull::EditModeless().
 */
BOOL CScanFilterDZ::EditModeless( CWnd *pParentWnd )
{
//   Q_LOG( _T("CScanFilterDZ::EditModeless()") );

   CFilterDlg_DZPtr pDlg = new CFilterDlg_DZ();

   if ( Q_INVALID( NULL == pDlg ) )
      return FALSE;

   /*
    * set filter, no doc (edit modeless):
    */
   pDlg->SetParameters( this, NULL );   // (void) method

   /*
    * Create returns non-zero if dialog was created and initialized succesfully.
    * Note: no pDlg->DestroyWindow() must be done.
    */
   BOOL bRet = pDlg->Create( IDD_FILTERDLG_DZ, pParentWnd );
   m_pDlg    = pDlg;

   /*
    * gray-out buffers
    */
   pDlg->DisableBufferControls();

   return bRet;
}

/*
 * create filter dialog and pre Apply() filter to view result;
 * see also CScanFilterNull::RunModeless().
 */
BOOL CScanFilterDZ::RunModeless( CWnd* pParentWnd, CDocument* pDoc )
{
//   Q_LOG( _T("CScanFilterDZ::RunModeless()") );

   CFilterDlg_DZPtr pDlg = new CFilterDlg_DZ();

   if ( Q_INVALID( NULL == pDlg ) )
      return FALSE;

   pDlg->SetParameters( this, pDoc );   // (void) method

   /*
    * Create returns non-zero if dialog was created and initialized succesfully.
    * Note: no pDlg->DestroyWindow() must be done.
    */
   pDlg->Create( IDD_FILTERDLG_DZ, pParentWnd );

   m_pDlg = pDlg;

   BOOL bRet = Apply();

   if ( bRet )
   {
      pDlg->UpdateView();
   }

   return bRet;
}

/*
 * check parameters, take care of a properly sized output buffer,
 * set its name and copy filter parameters and process;
 * see also CScanFilterNull::ApplyCore().
 */
BOOL CScanFilterDZ::Apply()
{
   if ( Q_INVALID( NULL == m_lpsbIn && "ensure first input buffer") )
      return FALSE;

   if ( Q_INVALID( NULL == m_lpsbIn2 && "ensure second input buffer" ) )
      return FALSE;

   if ( Q_INVALID( NULL == m_lpsbOut && "ensure output buffer" ) )
      return FALSE;

   if ( Q_INVALID( !m_lpsbIn->IsCompleteFrame() && "ensure complete frame" ) )
      return FALSE;

   /*
    * copy the filter settings (not the data):
    */
   Q_RETURN( m_lpsbOut->CreateOutputBufferFor( *m_lpsbIn ) );

   m_lpsbOut->m_csBufferName.Format(_T("%s - %s"),m_lpsbIn->m_csBufferName, m_lpcsShortFilterName );

   if ( IsInteractive() )
   {
      m_pDlg->SetDlgItemText( IDC_BUFFERINNAME2, m_lpsbIn2->m_csBufferName );
      m_pDlg->SetDlgItemText( IDC_BUFFEROUTNAME, m_lpsbOut->m_csBufferName );
   }

   /*
    * limit buffer access to the smallest one: this also handles backtrace removal:
    */
   SizeElementType size = lpm::min( m_lpsbIn->GetFrameSize(), m_lpsbIn2->GetFrameSize(), m_lpsbOut->GetFrameSize() );

   /*
    * process first part (L2R):
    */
   Process(
      m_lpsbIn->Data(),
      m_lpsbIn->Data() + size,
      m_lpsbIn2->Data(),
      m_lpsbOut->Data()
   );

   /*
    * if we have a double buffer, L2R and R2L, process that part too.
    */
   if ( m_lpsbIn->IsBidirectionalScan() && m_lpsbIn2->IsBidirectionalScan() && m_lpsbOut->IsBidirectionalScan() )
   {
      Process(
         m_lpsbIn->Data()  + m_lpsbIn->GetFrameSize(),
         m_lpsbIn->Data()  + m_lpsbIn->GetFrameSize() + size,
         m_lpsbIn2->Data() + m_lpsbIn2->GetFrameSize(),
         m_lpsbOut->Data() + m_lpsbOut->GetFrameSize()
      );
   }

   m_lpsbOut->m_dwParameterMask = 0;            // Recalculate all temp.vars.

   return TRUE;
}

/**
 * anonymous namespace to hide class AddOp, SubOp, InvSubOp from other modules:
 */
namespace
{
   /**
    * binary functor to perform calculation on a + b in std::transform.
    */
   template <typename T>
   class DZOp : public std::binary_function<T, T, T>
   {
   public:
      /**
       * default contructor; 0.5 is added to offset for rounding.
       */
      inline DZOp( double fac = 1.0, double off = 0.0 ) : m_factor( fac ), m_offset( off )
      {
         ; // do nothing
      }

      /**
       * visit elements; return a + factor * b + offset.
       */
      inline T operator()( const T a, const T b ) const
      {
         return static_cast<T>( a + m_factor * b + m_offset );
      }
      
   private:
      double m_factor;                  ///< the factor
      double m_offset;                  ///< the offset
   };

}  // end anonymous namespace

/*
 * apply the operation to the buffers.
 */
void CScanFilterDZ::Process( ConstPointer in1, ConstPointer end1, ConstPointer in2, Pointer out )
{
   std::transform( in1, end1, in2, out, DZOp< ValueType >( m_dFactor, m_dOffset ) );
}

/*
 * end of file
 */

---