Filter Library

Camera

Interface Physics

ScanFilterCustom.cpp

/*
 * ScanFilterCustom.cpp - 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.cpp 358 2006-03-06 14:49: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 <cfl/ScanFilterCustom.h>       // this filter's header
#include <cfl/FilterDlg_Custom.h>       // this filter's dialog

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

#define CFL_SCHEMAVERSION_FILTERCUSTOM 0 // permanent storage schema version
                                        // this filter's name
LPCTSTR CScanFilterCustom::m_lpcsFilterName = _T("Custom");
                                        // this filter's short name
LPCTSTR CScanFilterCustom::m_lpcsShortFilterName = CScanFilterCustom::m_lpcsFilterName;
                                        // serialization
IMPLEMENT_SERIAL( CScanFilterCustom, CScanFilter, CFL_SCHEMAVERSION_FILTERCUSTOM )

/**
 * the blur filter-weights (5x5).
 */
const CScanFilterCustom::WeightType CScanFilterCustom::m_blurWeights[ KernelSize ] =
{
   1, 1, 1, 1, 1,
   1, 1, 1, 1, 1,
   1, 1, 1, 1, 1,
   1, 1, 1, 1, 1,
   1, 1, 1, 1, 1,
};

/**
 * the low-pass filter-weights (5x5).
 */
const CScanFilterCustom::WeightType CScanFilterCustom::m_lowpassWeights[ KernelSize ] =
{
   0, 0, 0, 0, 0,
   0, 1, 1, 1, 0,
   0, 1, 2, 1, 0,
   0, 1, 1, 1, 0,
   0, 0, 0, 0, 0,
};

/**
 * the high-pass filter-weights (5x5).
 */
const CScanFilterCustom::WeightType CScanFilterCustom::m_highpassWeights[ KernelSize ] =
{
   -1, 1,-1,-1,-1,
   -1,-1,-1,-1,-1,
   -1,-1,25,-1,-1,
   -1,-1,-1,-1,-1,
   -1,-1,-1,-1,-1,
};

/**
 * the edge filter-weights (5x5).
 */
const CScanFilterCustom::WeightType CScanFilterCustom::m_edgeWeights[ KernelSize ] =
{
   -1, 0, 0, 0, 0,
    0,-1, 0, 0, 0,
    0, 0, 1, 0, 0,
    0, 0, 0, 1, 0,
    0, 0, 0, 0, 0,
};

/**
 * the pyramidal filter-weights (5x5).
 */
const CScanFilterCustom::WeightType CScanFilterCustom::m_pyramidalWeights[ KernelSize ] =
{
   1, 2, 3, 2, 1,
   2, 4, 6, 4, 2,
   3, 6, 9, 6, 3,
   2, 4, 6, 4, 2,
   1, 2, 3, 2, 1,
};

/**
 * the cone filter-weights (5x5).
 */
const CScanFilterCustom::WeightType CScanFilterCustom::m_coneWeights[ KernelSize ] =
{
   0, 0, 1, 0, 0,
   0, 2, 2, 2, 0,
   1, 2, 5, 2, 1,
   0, 2, 2, 2, 0,
   0, 0, 1, 0, 0,
};

/**
 * the edge filter-weights (5x5).
 */
const CScanFilterCustom::WeightType CScanFilterCustom::m_gaussianWeights[ KernelSize ] =
{
   1, 4, 7, 4, 1,
   4,16,26,16, 4,
   7,26,41,26, 7,
   4,16,26,16, 4,
   1, 4, 7, 4, 1,
};

/**
 * the edge filter-weights (5x5).
 */
const CScanFilterCustom::WeightType CScanFilterCustom::m_laplacianWeights[ KernelSize ] =
{
   0, 0, 0, 0, 0,
   0,+1,+1,+1, 0,
   0,+1,-8,+1, 0,
   0,+1,+1,+1, 0,
   0, 0, 0, 0, 0,
};

/**
 * the edge filter-weights (5x5).
 */
const CScanFilterCustom::WeightType CScanFilterCustom::m_sharpeningWeights[ KernelSize ] =
{
   0, 0, 0, 0, 0,
   0,+1,+1,+1, 0,
   0,+1,-7,+1, 0,
   0,+1,+1,+1, 0,
   0, 0, 0, 0, 0,
};

/*
 * constructor.
 */
CScanFilterCustom::CScanFilterCustom() :
   m_currentFilterType( ftBlur )
{
//   Q_LOG( _T("CScanFilterCustom::CScanFilterCustom()") );

   m_csFilterName = m_lpcsFilterName;

   for ( int i = 0; i < KernelSize; i++ )
   {
      m_userWeights[i] = 1.0;
   }

   SetFilterType( ftBlur );
   ReadFilterSettings();
}

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

   ; // do nothing
}

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

   CScanFilter::Serialize( ar );

   if ( ar.IsStoring() )
   {
      for ( int i = 0; i < KernelSize; ++i )
      {
         ar << m_userWeights[i];
      }

      ar << static_cast< int >( m_currentFilterType );
   }
   else
   {
      for ( int i = 0; i < KernelSize; ++i )
      {
         ar >> m_userWeights[i];
      }

      int type;
      ar >> type;
      m_currentFilterType = static_cast< FilterType >( type );
   }
}

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

   CWinApp* pApp = AfxGetApp();

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

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

/*
 * \brief save filter settings e.g. for use with the filterlist window (e.g. via registry);
 * see also ReadFilterSettings().
 */
void CScanFilterCustom::WriteFilterSettings() const
{
//   Q_LOG( _T("CScanFilterCustom::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 CScanFilterCustom::GetParameters() const
{
//   Q_LOG( _T("CScanFilterCustom::GetParameters()") );

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

   for ( int i = 0; i < KernelSize; ++i )
   {
      csWeight.Format( _T( "%g," ), m_userWeights[i] );

      csParameters += csWeight;
   }

   CString csType; csType.Format( _T( "%d" ), m_currentFilterType );
   csParameters += csType;

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

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

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

   /*
    * set defaults, read parameter string:
    */
   int     nfields = 0;
   CString cs( lpParameters );

   for ( int i = 0; i < KernelSize; ++i )
   {
      double weight = 1.0;

      nfields += _stscanf( cs, _T( "%lg," ), &weight );

      m_userWeights[i] = weight;

      cs.Delete( 0, cs.Find( _T( ',' ) ) + 1 );
   }

   if ( Q_INVALID( KernelSize > nfields && "CScanFilterClad (SetParameters): more kernel weights expected." ) )
   {
      return FALSE;
   }

   /*
    * read filter type:
    */
   FilterType type = ftBlur;
   nfields = _stscanf( cs, _T( "%d" ), &type );
   SetFilterType( type );

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

   return TRUE;
}

/**
 * set the given filter type.
 */
void CScanFilterCustom::SetFilterType( FilterType type )
{
   if ( Q_INVALID ( ( ftBlur > type || type > ftUser ) && "ensure valid filter type." ) )
   {
      return ;
   }

   m_currentFilterType = type;

   switch ( type )
   {
      case ftBlur:
         m_currentWeights = m_blurWeights;
         break;
      case ftLowPass:
         m_currentWeights = m_lowpassWeights;
         break;
      case ftHighPass:
         m_currentWeights = m_highpassWeights;
         break;
      case ftEdge:
         m_currentWeights = m_edgeWeights;
         break;
      case ftPyramidal:
         m_currentWeights = m_pyramidalWeights;
         break;
      case ftCone:
         m_currentWeights = m_coneWeights;
         break;
      case ftGaussian:
         m_currentWeights = m_gaussianWeights;
         break;
      case ftLaplacian:
         m_currentWeights = m_laplacianWeights;
         break;
      case ftSharpening:
         m_currentWeights = m_sharpeningWeights;
         break;
      case ftUser:
         m_currentWeights = m_userWeights;
         break;
   }
}

/*
 * the selected filter name (short).
 */
LPCTSTR CScanFilterCustom::GetShortFilterName() const
{
   switch( GetFilterType() )
   {
      case ftBlur: return "Custom-Blur";
      case ftLowPass: return "Custom-Low-Pass";
      case ftHighPass: return "Custom-High-Pass";
      case ftEdge: return "Custom-Edge";
      case ftPyramidal: return "Custom-Pyramidal";
      case ftCone: return "Custom-Cone";
      case ftGaussian: return "Custom-Gaussian";
      case ftLaplacian: return "Custom-Laplacian";
      case ftSharpening: return "Custom-Sharpening";
      case ftUser: return "Custom-User-Defined";
      default: return "[unrcognized]";
   }
}

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

   CFilterDlg_CustomPtr pDlg = new CFilterDlg_Custom();

   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_CUSTOM, pParentWnd );

   m_pDlg = pDlg;

   BOOL bRet = Apply();

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

   return bRet;
}

BOOL CScanFilterCustom::Apply()
{
//   Q_LOG( _T("CScanFilterShift::Apply()") );

   if ( Q_INVALID( NULL == m_lpsbIn && "ensure 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;

   /*
    * create output buffer:
    */
   Q_RETURN( m_lpsbOut->CreateOutputBufferFor( *m_lpsbIn ) );

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

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

   /*
    * process first part (L2R):
    */
   Convolve( FALSE );

   /*
    * if we have a double buffer, L2R and R2L, process that part tooo.
    */
   if ( m_lpsbIn->IsBidirectionalScan() && m_lpsbOut->IsBidirectionalScan() )
   {
      Convolve( TRUE );
   }

   /*
    * recalculate all temporary variables:
    */
   m_lpsbOut->m_dwParameterMask  = 0;

   return TRUE;
}

/*
 * process the frame part at the given offset (L2R, R2L frame part).
 */
void CScanFilterCustom::Convolve( BOOL bDoR2L )
{
   DWORD dwOffset = bDoR2L ? m_lpsbIn->m_dwSizeX * m_lpsbIn->m_dwSizeY : 0;
   DWORD      ptr = dwOffset;

   for ( DWORD y = 0; y < m_lpsbIn->m_dwSizeY; y++ )
   {
      for ( DWORD x = 0; x < m_lpsbIn->m_dwSizeX; x++ )
      {
         // loop through 5x5 pixel area
         double dDummySum = 0;
         double dDummyCount = 0.0;

         for ( int yi = max( 0, (int) y - 2 ); yi < min( (int) m_lpsbIn->m_dwSizeY, (int) y + 3 ); yi++ )
         {
            for ( int xi = max( 0, (int) x - 2 ); xi < min( (int) m_lpsbIn->m_dwSizeX, (int) x + 3 ); xi++ )
            {
               int nWeight = (2 + yi - (int)y) * 5 + (2 + xi - (int)x);

               dDummySum += m_currentWeights[ nWeight ] * m_lpsbIn->m_pwData[ dwOffset + yi * m_lpsbIn->m_dwSizeX + xi ];

               dDummyCount += m_currentWeights[ nWeight ];
            }
         }

         if ( dDummyCount == 0.0 )
         {
            dDummyCount = 1.0;
         }

         m_lpsbOut->m_pwData[ ptr++ ] = (short)( dDummySum / dDummyCount );
      }
   }
}

/*
 * end of file
 */

---