Filter Library

Camera

Interface Physics

ScanFilterDifferential.cpp

/*
 * ScanFilterDifferential.cpp - frame by frame differentiation.
 *
 * 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: ScanFilterDifferential.cpp 358 2006-03-06 14:49:02Z moene $
 */

/*
 * configuration defines:
 */

//#define NO_RETRACE_LINE               // if the buffers do not contain a retrace line (nacra)

/*
 * 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/ScanFilterDifferential.h> // this filter's header
#include <cfl/FilterDlg_Differential.h> // this filter's dialog

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

#define CFL_SCHEMAVERSION_FILTERDIFFERENTIAL 0  // permanent storage schema version
                                                // this filter's name
LPCTSTR CScanFilterDifferential::m_lpcsFilterName = _T("Differential-Plane");
                                        // this filter's short name
LPCTSTR CScanFilterDifferential::m_lpcsShortFilterName = _T( "Diff" );
                                                // serialization
IMPLEMENT_SERIAL( CScanFilterDifferential, CScanFilter, CFL_SCHEMAVERSION_FILTERDIFFERENTIAL )

/*
 * default angle: 0.
 */
const int CScanFilterDifferential::def_nAngle  = 0;

/*
 * constructor.
 */
CScanFilterDifferential::CScanFilterDifferential() :
   m_nAngle( def_nAngle )
{
   m_csFilterName = m_lpcsFilterName;

   ReadFilterSettings();                 // get filter settings to run without dialog
}

/*
 * destructor.
 */
CScanFilterDifferential::~CScanFilterDifferential()
{
   ; // do nothing
}

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

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

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

   CWinApp* pApp = AfxGetApp();

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

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

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

   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 CScanFilterDifferential::GetParameters( ) const
{
//   Q_LOG( _T("CScanFilterDifferential::GetParameters()") );

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

   csParameters.Format( _T( "%d" ), m_nAngle );

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

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

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

   /*
    * set defaults, read parameter string:
    */
   m_nAngle = def_nAngle;

   int nfields = _stscanf( lpParameters, _T( "%d" ), &m_nAngle );

   if ( Q_INVALID( 1 > nfields && "CScanFilterDifferential (SetParameters): angle expected, got none." ) )
   {
      return FALSE;
   }

   if ( Q_INVALID( ( m_nAngle < 0 || m_nAngle > 360 ) && "CScanFilterDifferential (SetParameters): invalid angle." ) )
   {
      return FALSE;
   }

   return TRUE;
}

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

   CFilterDlg_DifferentialPtr pDlg = new CFilterDlg_Differential();

   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_DIFFERENTIAL, 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 CScanFilterDifferential::RunModeless( CWnd* pParentWnd, CDocument* pDoc )
{
//   Q_LOG( _T("CScanFilterDifferential::RunModeless()") );

   CFilterDlg_Differential *pDlg = new CFilterDlg_Differential();

   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_DIFFERENTIAL, 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 CScanFilterDifferential::Apply()
{
   if ( Q_INVALID( NULL == m_lpsbIn && "ensure valid input buffer" ) )
      return FALSE;

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

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

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

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

   // Process first part (L2R)
   Differentiate( 0 );

   // If we have a double buffer, L2R and R2L, process that part too.
   if ( m_lpsbIn->IsBidirectionalScan() && m_lpsbOut->IsBidirectionalScan() )
   {
      Differentiate( m_lpsbIn->m_dwSizeX * m_lpsbIn->m_dwSizeY );
   }

   return TRUE;
}

/*
 * differentiate frame part at given offset.
 */
void CScanFilterDifferential::Differentiate( DWORD dwOffset )
{
   int clox, chix, cloy, chiy, dx, dy, cybx;

   double coslight = cos( m_nAngle * g_d2PI / 360.0 );
   double sinlight = sin( m_nAngle * g_d2PI / 360.0 );

   int nSizeX = m_lpsbIn->Columns();
   int nSizeY = m_lpsbIn->Rows();
   int nCount = 0;

   for ( int nCountY = 0; nCountY < nSizeY; ++nCountY )
   {
      cloy = max(   0           , ( nCountY - 1 ) );
      chiy = min( ( nSizeY - 1 ), ( nCountY + 1 ) );
      dy   = chiy - cloy;
      cloy *= nSizeX;
      chiy *= nSizeX;
      cybx = nCount = nCountY * nSizeX;

      for ( int nCountX = 0; nCountX < nSizeX; ++nCountX, ++nCount )
      {
         clox = max(   0        , ( nCountX-1 ) );
         chix = min( ( nSizeX-1), ( nCountX+1 ) );
         dx   = chix - clox;

         m_lpsbOut->m_pwData[ nCount + dwOffset ] = (short)(
            coslight * ( m_lpsbIn->m_pwData[ chix    + cybx + dwOffset] - m_lpsbIn->m_pwData[ clox    + cybx + dwOffset ] ) / dx +
            sinlight * ( m_lpsbIn->m_pwData[ nCountX + chiy + dwOffset] - m_lpsbIn->m_pwData[ nCountX + cloy + dwOffset ] ) / dy
         );
      }
   }
}

/*
 * end of file
 */

---