Filter Library

Camera

Interface Physics

ScanFilterNull.cpp

/*
 * // FIXME-ADAPT: filename and text
 * ScanFilterNull.cpp - a null filter to
 * (1) document general ascpects of filters, (2) act as a filter template.
 *
 * This file is part of the Camera Filter Library.
 * Computer Aided Measurement Environment for Realtime Atomic imaging (Camera)
 *
 * Copyright (C) 2004, Leiden Probe Microscopy.
 * Copyright (C) 2004, Universiteit Leiden.
 *
 * Authors: Martin J. Moene (original)
 *
 * $Id: ScanFilterNull.cpp 236 2005-06-27 09:03:17Z moene $
 */

/*
 * configuration defines:
 */

//#define NO_PARAMETERS                 // if Get/SetParameters() is not supported
//#define NO_FILTER_SETTINGS            // if Get/WriteFilterSettings() is not supported

/*
 * end of configuration defines.
 */

/**
 * \todo: can do partial data?
 */

/**
 * \todo change "stdafx.h" to <cfl/stdafx.h> when all filters have been adapted.
 * "stdafx.h" is used to determine the contents of the precompiled headers;
 * see prj settings C/C++, precompiled headers, through header "stdafx.h")
 */

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

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

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

// FIXME-ADAPT: this filter's name 3x
                                        ///< permanent storage schema version
#define CFL_SCHEMAVERSION_FILTERLINREG 0
                                        // this filter's name
LPCTSTR CScanFilterNull::m_lpcsFilterName = _T( "Null" );
                                        // this filter's short name
LPCTSTR CScanFilterNull::m_lpcsShortFilterName = CScanFilterNull::m_lpcsFilterName;
                                        // serialization
IMPLEMENT_SERIAL( CScanFilterNull, CScanFilter, CFL_SCHEMAVERSION_FILTERLINREG )

/*
 * default values: [out] = 1 x [in] + 0.
 */

const double CScanFilterNull::def_dFactor = 1.0;
const double CScanFilterNull::def_dOffset = 0.0;

/**
 * default constructor: setup filter to run without dialog;
 * see also CScanFilterNull::CScanFilterNull().
 *
 * The constructor initializes the class' datamembers and prepares the filter to
 * run without dialog by calling ReadFilterSettings().
 *
 * For example:
 * \code
 * CScanFilterNull::CScanFilterNull() : CScanFilter( ),
 *    m_dFactor( def_dFactor ), m_dOffset( def_dOffset )
 * {
 *    m_csFilterName = m_lpcsFilterName;
 *
 *    ReadFilterSettings();      // get filter settings to run without dialog
 * }
 * \endcode
 *
 */

CScanFilterNull::CScanFilterNull() : CScanFilter( ),
   m_dFactor( def_dFactor ), m_dOffset( def_dOffset )
{
   m_csFilterName = m_lpcsFilterName;

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

/**
 * destructor.
 *
 * The destructor may have to release resources (e.g. memory) that the constructor
 * has allocated. In this specific case, the destructor does nothing;
 * however note that the base-class destructor (CScanFilter::~CScanFilter())
 * does some more work: it destroys the dialog if present.
 *
 * For example:
 * \code
 * CScanFilterNull::~CScanFilterNull()
 * {
 *    ; // do nothing
 * }
 * \endcode
 */

CScanFilterNull::~CScanFilterNull()
{
   ; // do nothing
}

/**
 * store or retrieve the object's settings;
 * currently filter serialization is not used;
 * see also CScanFilterNull::Serialize().
 *
 * This method lets you store the filter's settings to and retrieve them from an
 * archive. This process is called serialization.
 *
 * \note Currently filter serialization is not used.
 *
 * \param ar the archiver
 * \return void
 *
 * This is an example of how you may implement Serialize().
 * \code
 * // store or retrieve the object's settings.
 *
 * void CScanFilterNull::Serialize( CArchive& ar )
 * {
 *    CScanFilter::Serialize( ar );
 *
 *    if ( ar.IsStoring() )
 *    {
 *       ar << m_dFactor << m_dOffset;
 *    }
 *    else
 *    {
 *       ar >> m_dFactor >> m_dOffset;
 *    }
 * }
 * \endcode
 */

void CScanFilterNull::Serialize( CArchive& ar )
{
// Q_LOG( _T("CScanFilterNull::Serialize") );

   CScanFilter::Serialize( ar );

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

#if 0
/**
 * true if filter can process a data-selection in the buffer.
 */

BOOL CScanFilterNull::CanDoPartialData() const
{
   return TRUE;
}
#endif

#if 0
/**
 * true if a dialog can be used.
 */

BOOL CScanFilterNull::CanDoDialogEntry() const
{
   return FALSE;
}
#endif

/**
 * \brief configure filter with settings as provided by the application on the
 * filterlist window (e.g. via registry); see also CScanFilterNull::ReadFilterSettings().
 *
 * This method obtains the filter setting as supplied by the application on the
 * filterlist window, for example via the registry, and initializes the filter
 * with these settings.
 *
 * ReadFilterSettings() is called from the constructor of the filter.
 *
 * A no-op example:
 * \code
 * void CScanFilterNull::ReadFilterSettings( )
 * {
 *    // Only few filters provide this method.
 * }
 * \endcode
 *
 * An if-used example:
 * \code
 * void CScanFilterNull::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( "1,0" ) ) );
 * }
 * \endcode
 */

void CScanFilterNull::ReadFilterSettings( )
{
// Q_LOG( _T("CScanFilterNull::ReadFilterSettings()") );

#ifdef NO_FILTER_SETTINGS
   /*
    * Only few filters provide this method.
    */
#else
   CWinApp* pApp = AfxGetApp();

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

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

/**
 * \brief save filter settings e.g. for use with the filterlist window (e.g. via registry);
 * see also ReadFilterSettings().
 *
 * A no-op example:
 * \code
 * void CScanFilterNull::WriteFilterSettings( ) const
 * {
 *    // Only few filters provide this method.
 * }
 * \endcode
 *
 * An if-used example:
 * \code
 * void CScanFilterNull::WriteFilterSettings( ) const
 * {
 *    CWinApp* pApp = AfxGetApp();
 *
 *    if ( Q_INVALID( NULL == pApp ) )
 *       return ;
 *
 *    //
 *    // parameter string: x-size,y-size,parameter,factor
 *    //
 *    LPCTSTR pStr = GetParameters();
 *
 *    if ( pStr )
 *    {
 *       pApp->WriteProfileString( gCflRegistrySubkey, m_lpcsFilterName, pStr );
 *       delete const_cast<LPTSTR>( pStr );
 *    }
 * }
 * \endcode
 */

void CScanFilterNull::WriteFilterSettings() const
{
#ifdef NO_FILTER_SETTINGS
   /*
    * Only few filters provide this method.
    */
#else
   CWinApp* pApp = AfxGetApp();

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

   /*
    * parameter string: x-size,y-size,parameter,factor
    */
   LPCTSTR pStr = GetParameters();

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

/**
 * provide current filter parameter(s) for filter-scripting capture
 * in the main application;
 * see also CScanFilterNull::GetParameters().
 *
 * Analogous to GetInitParameters(), this method returns filter parameters, in
 * this case for the filter-scripting capture operation in the main application.
 *
 * \return C-string with parameter values, e.g. "1.23,4.56"
 * \see GetInitParameters().
 * \note caller is responsible for \c delete-ing returned string storage.
 *
 * A no-op example:
 * \code
 * LPCTSTR CScanFilterNull::GetParameters( ) const
 * {
 *    // returns "no parameter values":
 *
 *    return NULL;
 * }
 * \endcode
 *
 * An if-used example:
 * \code
 * LPCTSTR CScanFilterNull::GetParameters( ) const
 * {
 *    // 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 );
 * }
 * \endcode
 */

LPCTSTR CScanFilterNull::GetParameters( ) const
{
// Q_LOG( _T("CScanFilterNull::GetParameters()") );

#ifdef NO_PARAMETERS
   /*
    * no-op:
    */
   return NULL;
#else
   /*
    * 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 );
#endif
}

/**
 * set parameters for filter-script execution of filter;
 * see also CScanFilterNull::SetParameters().
 *
 * This method initializes the filter parameters for filter-script execution of
 * the filter toe the parameters specified.
 *
 * \param lpParameters a C-string specifying the filter parameter values, e.g. "1.23,4.56".
 * \return TRUE (Success), FALSE (Failure)
 *
 * A not-supported example:
 * \code
 * BOOL CScanFilterNull::SetParameters( LPCTSTR lpParameters )
 * {
 *    // we do not expect any parameters, so say so:
 *
 *    if ( Q_INVALID ( NULL != lpParameters && 0 < ::strlen( lpParameters ) &&
 *       "CScanFilterNull (SetParameters): no parameters expected." ) )
 *    {
 *       return FALSE;
 *    }
 *
 *    return FALSE;
 * }
 * \endcode
 *
 * An if-used example:
 * \code
 * BOOL CScanFilterNull::SetParameters( LPCTSTR lpParameters )
 * {
 *    if ( Q_INVALID( NULL == lpParameters && 
 *           "CScanFilterNull (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_LOG( 1 > nfields && 
 *         "CScanFilterNull (SetParameters): factor and optional offset expected, got none." ) )
 *    {
 *       return FALSE;
 *    }
 *
 *    return TRUE;
 * }
 * \endcode
 */

BOOL CScanFilterNull::SetParameters( LPCTSTR lpParameters )
{
// Q_LOG( _T("CScanFilterNull::SetParameters()") );

#ifdef NO_PARAMETERS
   /*
    * we do not expect any parameters, so say so:
    */
   Q_LOG( NULL != lpParameters && 0 < ::strlen( lpParameters &&
           "CScanFilterNull (SetParameters): no parameters expected." ) )

   return FALSE;
#else
   if ( Q_INVALID( NULL == lpParameters && 
           "CScanFilterNull (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( 1 > nfields && "CScanFilterNull (SetParameters): factor and optional offset expected, got none." ) )
   {
      return FALSE;
   }

   return TRUE;
#endif
}

/**
 * create filter dialog and pre Apply() filter to view result;
 * see also CScanFilterNull::RunModeless().
 *
 * This method creates the filter dialog and pre-applies the filter using
 * Apply() to show its result.
 *
 * \param pDoc the document to update on a filter action (parameter change, Ok, Cancel)
 * \param pParentWnd the parent window for the creation of the filter dialog box
 * \return TRUE (Success), FALSE (Failure)
 *
 * Here's an example of how you may implement RunModeless().
 * \code
 * BOOL CScanFilter::RunModeless( CWnd* pParentWnd, CDocument* pDoc )
 * {
 *    CFilterDlg_NullPtr pDlg = new CFilterDlg_Null();
 *
 *    if ( Q_INVALID( NULL == pDlg ) )
 *       return FALSE;
 *
 *    pDlg->SetParameters( this, pDoc );   // (void) method
 *
 * //   Q_RETURN( pDlg->Create( IDD_FILTERDLG_NULL, pParentWnd ) );   // FIXME-ADAPT: IDD_
 *    pDlg->Create( IDD_FILTERDLG_NULL, pParentWnd );   // FIXME-ADAPT: IDD_
 *
 *    m_pDlg = pDlg;
 *
 *    // pre-Apply the filter and show initial results;
 *    // on error, simulate failure to create dialog:
 *
 *    BOOL bRet = Apply();
 *
 *    if ( bRet )
 *    {
 *       pDlg->UpdateView();
 *    }
 *
 *    return bRet;
 * }
 * \endcode
 */

BOOL CScanFilterNull::RunModeless( CWnd* pParentWnd, CDocument* pDoc )
{
// Q_LOG( _T("CScanFilterNull::RunModeless()") );               // FIXME-ADAPT: string

   CFilterDlg_NullPtr pDlg = new CFilterDlg_Null();             // FIXME-ADAPT: type

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

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

   /*
    * For the dialog panel, I had to replace several lines in resource.h with
    * lines from a previously created dialog to make the dialog visible.
    *
    * Create returns non-zero if dialog was created and initialized succesfully.
    * Note: no pDlg->DestroyWindow() must be done.
    */
//   Q_RETURN( pDlg->Create( IDD_FILTERDLG_NULL, pParentWnd ) );   // FIXME-ADAPT: IDD_
   pDlg->Create( IDD_FILTERDLG_NULL, pParentWnd );   // FIXME-ADAPT: IDD_

   m_pDlg = pDlg;

   /*
    * pre-Apply the filter and show initial results;
    * on error, simulate failure to create dialog:
    */
   BOOL bRet = Apply();

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

   return bRet;
}

/**
 * let ApplyCore() perform the filter processing; catch MFC and std exceptions;
 * see also CScanFilterNull::Apply().
 *
 * Method Apply is an MFC and std exception handling wrapper around method ApplyCore.
 *
 * \return TRUE (Success), FALSE (Failure)
 *
 * Here is an example of how you may implement Apply().
 * \code
 * BOOL CScanFilterNull::Apply()
 * {
 *    BOOL bRet = FALSE;        // preset to Failure
 *
 *    try
 *    {
 *       bRet = ApplyCore();    // sets status, unless exception occurs
 *    }
 *    catch ( CException* e )
 *    {
 *       Q_MFC_EXCEPTION( e );  // macro uses pointer-to (without surrounding () )
 *       e->Delete();           // see MSDN: Exceptions: Catching and Deleting Exceptions
 *    }
 *    catch ( const std::exception& e )
 *    {
 *       Q_STD_EXCEPTION( e );
 *    }
 *
 *    return bRet;              // return status
 * }
 * \endcode
 */

BOOL CScanFilterNull::Apply()
{
// Q_LOG( _T("CScanFilterNull::Apply()") );

   BOOL bRet = FALSE;                   // preset to Failure

   try
   {
      bRet = ApplyCore();               // sets status, unless exception occurs
   }
   catch ( CException* e )
   {
      Q_MFC_EXCEPTION( e );             // macro uses pointer-to (without surrounding () )
      e->Delete();                      // see MSDN: Exceptions: Catching and Deleting Exceptions
   }
   catch ( const std::exception& e )
   {
      Q_STD_EXCEPTION( e );
#if 0
//    if ( m_pDlg )
      if ( IsInteractive() )          // FIXME: when member of CScanFilter.
      {
         ::MessageBox(                  // FIXME-ADAPT: filter name.
            AfxGetMainWnd()->m_hWnd, e.what(), _T("NullFilter Failure"), MB_OK | MB_ICONWARNING );
      }
#endif
   }

   return bRet;                         // return status
}

/**
 * check parameters, take care of a properly sized output buffer,
 * set its name and copy filter parameters and Process();
 * see also CScanFilterNull::ApplyCore().
 *
 * This method checks the presence of the filter's buffer(s), takes care of a
 * properly sized output buffer, set its name and copies the filter parameters
 * from the input buffer to the ouput buffer and calls Process() to do the filter
 * processing.
 *
 * \note Currently this filter does not support partial (line-by-line) filtering.
 * \note For an example of a filter that uses two input buffers, see filter
 * %ScanFilterDZ.h and %ScanFilterDZ.cpp (class CScanFilterDZ).
 *
 * Here is an example of how ApplyCore() may be implemented.
 * Note that method ApplyCore() is highly filter-specific.
 * \code
 * BOOL CScanFilterNull::ApplyCore()
 * {
 *    if ( Q_INVALID( NULL == m_lpsbIn ) )
 *       return FALSE;
 *
 *    if ( Q_INVALID( NULL == m_lpsbOut ) )
 *       return FALSE;
 *
 *    //
 *    // for first Apply, setup filter settings, filter name, dialog if present
 *    // and output buffer:
 *    //

 *    //
 *    // copy the filter settings (not the data):
 *    //
 *    Q_RETURN( m_lpsbOut->CreateOutputBufferFor( *m_lpsbIn ) );
 *
 *    // FIXME-ADAPT: filtername
 *    m_lpsbOut->m_csBufferName.Format( _T("%s - %s"), m_lpsbIn->m_csBufferName, m_lpcsShortFilterName );
 *
 *    //
 *    // if the dialog is present:
 *    //
 *    if ( IsInteractive() )
 *    {
 *       m_pDlg->SetDlgItemText( IDC_BUFFEROUTNAME, m_lpsbOut->m_csBufferName );
 *    }
 *
 *    //
 *    // process the L2R part and the R2L part (if present).
 *    //
 *    DWORD dwSize =  m_lpsbIn->FrameSize();
 *
 *    if (  m_lpsbIn->IsBidirectionalScan() && m_lpsbOut->IsBidirectionalScan() )
 *    {
 *       dwSize *= 2;
 *    }
 *
 *    Process( m_lpsbIn->Data(), m_lpsbOut->Data(), dwSize );
 *
 *    //
 *    // recalculate all temporary variables:
 *    //
 *    m_lpsbOut->m_dwParameterMask  = 0;
 *
 *    return TRUE;                         // return Ok
 * }
 * \endcode
 */

BOOL CScanFilterNull::ApplyCore()       // FIXME-ADAPT: method ApplyCore is highly filter-specific
{
   if ( Q_INVALID( NULL == m_lpsbIn ) )
      return FALSE;

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

   /*
    * for first Apply, setup filter settings, filter name, dialog if present
    * and output buffer:
    */

    /*
     * BUG: this is Not a Good thing for scripting. There one filter object is
     *      used for filter operations on more than one channel. Each channel
     *      requires its own processing (e.g. name).
     */

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

   // FIXME-ADAPT: filtername
   m_lpsbOut->m_csBufferName.Format( _T("%s - %s"), m_lpsbIn->m_csBufferName, m_lpcsShortFilterName );

   /*
    * if the dialog is present:
    */
   if ( IsInteractive() )          // FIXME: when member of CScanFilter.
   {
      m_pDlg->SetDlgItemText( IDC_BUFFEROUTNAME, m_lpsbOut->m_csBufferName );
   }

   /*
    * process the L2R part and the R2L part (if present).
    */
   DWORD dwSize = m_lpsbIn->GetFrameSize();

   if ( m_lpsbIn->IsBidirectionalScan() && m_lpsbOut->IsBidirectionalScan() )
   {
      dwSize *= 2;
   }

   Process( m_lpsbIn->Data(), m_lpsbOut->Data(), dwSize );

   /*
    * recalculate all temporary variables:
    */
   // ClearParametersMask( m_lpsbOut ); // FIXME: maybe
   m_lpsbOut->m_dwParameterMask  = 0;

   return TRUE;                         // return Ok
}

/*
 * anonymous namespace to hide class NullOp from other modules:
 */

namespace
{
   // FIXME-ADAPT: required operation is highly filter-specific.

   /**
    * unary functor to perform calculation in std::transform.
    */
   template <typename T>
   class NullOp : public std::unary_function<T, T>
   {
   public:
      /**
       * default contructor; 0.5 is added to offset for rounding.
       */
      NullOp(double fac = 1.0, double off = 0.0) : m_factor(fac), m_offset(off + 0.5)
      {
      }

      /**
       * visit element; return factor x elem + offset.
       */
      inline T operator()( T x )
      {
         return static_cast<T>( m_factor * x + m_offset );
      }

   private:
      double m_factor;                  ///< the factor
      double m_offset;                  ///< the offset
   };
}  // end anonymous namespace

/**
 * filter specified data range to output.
 *
 * This filter simply copies its input buffer to its ouput buffer using STL std::
 * transform(), while applying the formula: \f$y_{ij} = factor \times x_{ij} + offset\f$.
 * \code
 * void CScanFilterNull::Process( ConstPointer pStartIn, Pointer pStartOut, DWORD dwSize )
 * {
 *    // FIXME-ADAPT: required operation is highly filter-specific.
 *
 *    std::transform(
 *       pStartIn,                         // in.begin()
 *       pStartIn + dwSize,                // in.end()
 *       pStartOut,                        // out.begin()
 *       NullOp<ValueType>( GetFactor(), GetOffset() )    // UnaryOp
 *    );
 * }
 * \endcode
 */

void CScanFilterNull::Process( ConstPointer pStartIn, Pointer pStartOut, DWORD dwSize )
{
   // FIXME-ADAPT: required operation is highly filter-specific.

   std::transform(
      pStartIn,                         // in.begin()
      pStartIn + dwSize,                // in.end()
      pStartOut,                        // out.begin()
      NullOp<ValueType>( GetFactor(), GetOffset() )    // UnaryOp
   );
}

/**
 * measure algorithm performance.
 *
 * We measure two aspects of the algorithm:
 * -# the time to prepare for the operation on the buffers
 * -# the time to process the data from the input buffer to the output buffer
 *
 * In the following example, there is no preparation phase, so all time is
 * attributed to the operation on the buffers.
 * \code
 *    SPerformanceTestResult result;
 *
 *    typedef long Count;
 *
 *    CPerfTimer Timer;
 *
 *    //
 *    // time Preparation:
 *    //
 *
 *    ; // nothing here
 *
 *    //
 *    // time Process:
 *    //
 *    Time  timeToProcess  = 0.4;          // time to measure in [s]
 *    Count countProcessed = 0;            // iteration count
 *
 *    Timer.Start( true );                 // restart start the timing
 *    while ( Timer.Elapsed() < timeToProcess )
 *    {
 *       Process( m_lpsbIn->Data(), m_lpsbOut->Data(), m_lpsbIn->FrameSize() );
 *
 *       ++countProcessed;                // update iteration count
 *    }
 *
 *    Timer.Stop();                        // stop the timing
 *    result.timeBuffer = Timer.Elapsed() / countProcessed;
 *
 *    if ( m_lpsbIn->IsBidirectionalScan() && m_lpsbOut->IsBidirectionalScan() )
 *    {
 *       result.timeBuffer *= 2;
 *    }
 *
 *    result.totalTime = result.timePrepare + result.timeBuffer;
 *
 *    return result;
 * }
 * \endcode
 */

SPerformanceTestResult CScanFilterNull::GetPerformanceTestResult()
{
   SPerformanceTestResult result;

   typedef long Count;

   CPerfTimer Timer;

   /*
    * time Preparation:
    */

   /*
    * time Process:
    */
   Time  timeToProcess  = 0.4;          // time to measure in [s]
   Count countProcessed = 0;            // iteration count

   Timer.Start( true );                 // restart start the timing
   while ( Timer.Elapsed() < timeToProcess )
   {
      Process( m_lpsbIn->Data(), m_lpsbOut->Data(), m_lpsbIn->GetFrameSize() );

      ++countProcessed;                // update iteration count
   }

   Timer.Stop();                        // stop the timing
   result.timeBuffer = Timer.Elapsed() / countProcessed;

   if ( m_lpsbIn->IsBidirectionalScan() && m_lpsbOut->IsBidirectionalScan() )
   {
      result.timeBuffer *= 2;
   }

   result.totalTime = result.timePrepare + result.timeBuffer;

   return result;
}

/*
 * end of file
 */

---