Filter Library

Camera

Interface Physics

ScanFilterLowPass.cpp

/*
 * ScanFilterLowPass.cpp - low-pass filter (frequency domain).
 *
 * 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: ScanFilterLowPass.cpp 400 2006-09-28 13:34:02Z moene $
 */

/*
 * configuration defines:
 */

// currently none

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

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

#undef min                              // use lpm::min instead of macro
#undef max                              // use lpm::max instead of macro

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

#define CFL_SCHEMAVERSION_FILTERLOWPASS 0  // permanent storage schema version
                                                // this filter's name
LPCTSTR CScanFilterLowPass::m_lpcsFilterName = _T("Low-Pass");
                                        // this filter's short name
LPCTSTR CScanFilterLowPass::m_lpcsShortFilterName = _T( "LP" );
                                                // serialization
IMPLEMENT_SERIAL( CScanFilterLowPass, CScanFilterFourierBase, CFL_SCHEMAVERSION_FILTERLOWPASS )

/*
 * the default shift flag.
 */
const CScanFilterLowPass::RealType CScanFilterLowPass::def_dCutOff = 0.75;

/*
 * the default clad flag.
 */
const CScanFilterLowPass::RealType CScanFilterLowPass::def_dSoftEdge = 0.05;

/*
 * constructor.
 */
CScanFilterLowPass::CScanFilterLowPass() :
   m_dCutOff   ( def_dCutOff ),
   m_dSoftEdge ( def_dSoftEdge )
{
//   Q_LOG( _T("CScanFilterLowPass::CScanFilterLowPass()") );

   m_csFilterName = m_lpcsFilterName;

   ReadFilterSettings();
}

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

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

   CScanFilterFourierBase::Serialize( ar );

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

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

   CWinApp* pApp = AfxGetApp();

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

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

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

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

   csParameters.Format( _T("%.2lf,%.2lf"), m_dCutOff, m_dSoftEdge );

   return strcpy( new TCHAR[ csParameters.GetLength() + 1 ], csParameters );
}
/*
 * set parameters for filter-script execution of filter;
 * see also CScanFilterNull::SetParameters().
 */
BOOL CScanFilterLowPass::SetParameters( LPCTSTR lpParameters )
{
//   Q_LOG( _T("CScanFilterLowPass::SetParameters()") );

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

   /*
    * set defaults, read parameter string with factor and optional offset:
    */
   m_dCutOff = 0.0;
   m_dSoftEdge = 0.0;

   int nfields = _stscanf( lpParameters, _T( "%lf,%lf" ), &m_dCutOff, &m_dSoftEdge );

   if ( Q_INVALID( 2 > nfields && "CScanFilterLowPass (SetParameters): cutoff and softedge expected, got fewer." ) )
   {
      return FALSE;
   }

   if ( Q_INVALID( ( m_dCutOff < 0.0 || m_dCutOff > 10.0 ) && "CScanFilterLowPass: invalid cutoff value." ) )
   {
      return FALSE;
   }

   if ( Q_INVALID( ( m_dSoftEdge < 0.0 || m_dSoftEdge > 10.0 ) && "CScanFilterLowPass: invalid softedge value." ) )
   {
      return FALSE;
   }

   return TRUE;
}

/*
 * create filter dialog and prepare filter for Apply();
 * see also CScanFilterNull::RunModeless().
 */
BOOL CScanFilterLowPass::RunModeless( CWnd* pParentWnd, CDocument* pDoc )
{
//   Q_LOG( _T("CScanFilterLowPass::RunModeless()") );

   CFilterDlg_LowPassPtr pDlg = new CFilterDlg_LowPass();

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

   m_pDlg = pDlg;

   /*
    * apply the filter now:
    */
   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 CScanFilterLowPass::Apply()
{
//   Q_LOG( _T("CScanFilterLowPass::Apply()") );

//    /*
//     * pre-apply must also be done from apply for scripting use:
//     */
//   if ( !PreApply() )
//   {
//      return FALSE;
//   }

   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;

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

   m_lpsbOut->m_csBufferName = m_lpsbIn->m_csBufferName + _T(" - ") + m_lpcsShortFilterName;

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

   /*
    * create a new suspended thread to do the computation;
    * the progressdialog resumes the thread and displays the progress:
    */
   CProgressDlg dlg( IsInteractive() ? m_pDlg : AfxGetMainWnd() );

   ThreadArgs threadArgs( &dlg, this );

   CWinThread *hThread = AfxBeginThread(
      ComputationThreadFunction,        // the controlling function for the worker thread
      &threadArgs,                      // the arguments and return value
      THREAD_PRIORITY_BELOW_NORMAL,     // the priority
      0,                                // 0: the stack size defaults to the same size
                                        //    stack as the creating thread.
      CREATE_SUSPENDED,                 // create it in suspended state
      NULL                              // security attributes structure
   );

   /*
    * show progress dialog, try to start thread:
    */
   if ( dlg.DoModal( hThread ) <= 0 )
   {
      return FALSE;
   };

   /*
    * return thread result:
    */
   return threadArgs.bReturn;
}

/**
 * thread-function.
 */
UINT CScanFilterLowPass::ComputationThreadFunction(LPVOID lpContext)
{
//   Q_LOG( _T("CScanFilterLowPass::ComputationThreadFunction()") );

   CScanFilterLowPass::ThreadArgs *lpTreadArgs = static_cast< CScanFilterLowPass::ThreadArgs* >( lpContext );

   lpTreadArgs->bReturn = lpTreadArgs->pThis->Compute( lpTreadArgs->pDlg );

   lpTreadArgs->pDlg->Terminate();

   return lpTreadArgs->bReturn;
}

/**
 * compute the desired result.
 */
BOOL CScanFilterLowPass::Compute( CProgressDlg *pDlg )
{
//   Q_LOG( _T("CScanFilterLowPass::Compute()") );

   /*
    * prepare some local varables:
    */
   BOOL bL2R = m_lpsbIn->HasLeftToRightScan();
   BOOL bR2L = m_lpsbIn->HasRightToLeftScan();

   /*
    * update progress dlg: don't touch dialog from other thread!
    */
   pDlg->SetText(_T("Computing 2D low-pass"));
   pDlg->SetRange( 0, bR2L && bL2R ? 4 : 3 );

   /*
    * check for FFT input to filter:
    */
   if ( bL2R && 0 == m_lpsbIn->m_pdFourierL2R ||
        bR2L && 0 == m_lpsbIn->m_pdFourierR2L   )
   {
      MessageBox(
         IsInteractive() ? m_pDlg->m_hWnd : AfxGetMainWnd()->m_hWnd,
         _T( "This scanbuffer does not contain a fourier spectrum." ),
         _T( "Cannot transform" ),
         MB_ICONEXCLAMATION | MB_OK
      );

      return FALSE;
   }

   /*
    * allocate fourier buffer:
    *
    * Note if we come this far, we know that the output buffer is created from
    * an input buffer that contains an FFT, so the output buffers size is already
    * appropriate for handling FFT.
    */
   Q_RETURN( m_lpsbOut->CreateFourierBuffer() );

   /*
    * keep track of progress:
    */
   int progress = 0;

   /*
    * perform the left-right and right-left transformations:
    */
   if ( bL2R )
   {
      ComputePart( m_lpsbIn->FourierDataL2R(), m_lpsbOut->FourierDataL2R() );

      pDlg->SetPos( ++progress );
   }

   /*
    * process right-left part:
    */
   if ( bR2L )
   {
      ComputePart( m_lpsbIn->FourierDataR2L(), m_lpsbOut->FourierDataR2L() );

      pDlg->SetPos( ++progress );
   }

   /*
    * compute amplitude response:
    */
   const int& nrow = m_lpsbOut->Rows();
   const int& ncol = m_lpsbOut->Columns();

   RealType *dAmpBuffer = new RealType[ nrow * ncol * 2 ];

   RealType dMax = CScanFilterFourierBase::BuildTmpAmpBuffer(
                    nrow, ncol, bL2R, bR2L, m_lpsbOut->FourierDataL2R(), m_lpsbOut->FourierDataR2L(), dAmpBuffer );

   pDlg->SetPos( ++progress );

   CScanFilterFourierBase::CopyAmpBufferToScanBuffer( nrow, ncol, bL2R, bR2L, dAmpBuffer, dMax );

   pDlg->SetPos( ++progress );

   delete dAmpBuffer;

   /*
    * check if a stop is requested from the progress dialog:
    */
   if ( pDlg->StopRequested() )
   {
      return FALSE;
   }
   else
   {
      return TRUE;
   }
}

/**
 * compute a frame.
 */
void CScanFilterLowPass::ComputePart( FourierElementType** in, FourierElementType** out )
{
   /*
    * get the image data properly into out:
    */
   SizeType nrow = m_lpsbOut->GetRowsForFFT();
   SizeType ncol = m_lpsbOut->GetColumnsForFFT();

   for ( SizeType y = 0; y < nrow / 2; ++y )
   {
      for ( SizeType x = 0; x < ncol / 2; ++x )
      {
         SizeType xi = 2 * x;

//         RealType dDistance = sqrt( pow( 2.0 * x / ncol, 2.0 ) + pow( 2.0 * y / nrow, 2.0 ) );
// 
//          RealType dScale = ( dDistance < ( m_dCutOff - m_dSoftEdge ) ? 1.0 :
//                            ( dDistance > ( m_dCutOff + m_dSoftEdge ) ? 0.0 :
//                              0.5 * ( 1.0 - sin( g_PI * ( dDistance - m_dCutOff ) / ( 2.0 * m_dSoftEdge ) ) ) ) );

         RealType dDistance = lpm::sqrt( lpm::sqr( 2.0 * x / ncol ) + lpm::sqr( 2.0 * y / nrow ) );

         RealType    dScale = ( dDistance < ( m_dCutOff - m_dSoftEdge ) ? 1.0 :
                              ( dDistance > ( m_dCutOff + m_dSoftEdge ) ? 0.0 :
                                0.5 * ( 1.0 - lpm::sin( lpm::Pi * ( dDistance - m_dCutOff ) / ( 2.0 * m_dSoftEdge ) ) ) ) );

         out[       y    ][           xi    ] = dScale * in[       y    ][           xi    ];
         out[       y    ][           xi + 1] = dScale * in[       y    ][           xi + 1];
         out[nrow - y - 1][           xi    ] = dScale * in[nrow - y - 1][           xi    ];
         out[nrow - y - 1][           xi + 1] = dScale * in[nrow - y - 1][           xi + 1];
         out[       y    ][2 * ncol - xi - 2] = dScale * in[       y    ][2 * ncol - xi - 2];
         out[       y    ][2 * ncol - xi - 1] = dScale * in[       y    ][2 * ncol - xi - 1];
         out[nrow - y - 1][2 * ncol - xi - 2] = dScale * in[nrow - y - 1][2 * ncol - xi - 2];
         out[nrow - y - 1][2 * ncol - xi - 1] = dScale * in[nrow - y - 1][2 * ncol - xi - 1];
      }
   }
}

/*
 * end of file
 */

---