Filter Library

Camera

Interface Physics

ScanFilterLinearRegression.cpp

/*
 * ScanFilterLinearRegression.cpp - determine linear regression parameters of image.
 *
 * 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: Martin J. Moene (original)
 *
 * $Id: ScanFilterLinearRegression.cpp 339 2006-02-27 12:02:15Z moene $
 */

/*
 * configuration defines:
 */

//#define NO_FILTER_SETTINGS            // if Get/WriteFilterSettings() is not supported
//#define NO_RETRACE_LINE               // if the buffers do not contain a retrace line (nacra)

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

#pragma warning( push, 3 )              // header file limits requires warning level 3

#include <limits>                       // for std::numeric_limits<>

#pragma warning( pop )

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

#define CFL_SCHEMAVERSION_FILTERLINEARREGRESSION 0  ///< permanent storage schema version

                                        // this filter's name
LPCTSTR CScanFilterLinearRegression::m_lpcsFilterName = _T( "Linear-Regression" );
                                        // this filter's short name
LPCTSTR CScanFilterLinearRegression::m_lpcsShortFilterName = _T( "LinReg" );
                                        // serialization
IMPLEMENT_SERIAL( CScanFilterLinearRegression, CScanFilter, CFL_SCHEMAVERSION_FILTERLINEARREGRESSION )

/*
 * default parameter values: 9x9.
 */
const int CScanFilterLinearRegression::def_iXY  = 9;

/*
 * default A, B, Alpha, Beta multiplication factor.
 */
const double CScanFilterLinearRegression::def_dFactor = 100;

/*
 * default selection of A, B, Alpha, etc.
 */
const LinearRegressionImageFilter::FeatureSelector CScanFilterLinearRegression::def_eParameter = LinearRegressionImageFilter::AlphaPi;

/*
 * default constructor: initialize filter with last used settings;
 * see also CScanFilterNull::CScanFilterLinearNull().
 */
CScanFilterLinearRegression::CScanFilterLinearRegression() : CScanFilter( ),
   m_iSizeX    ( def_iXY ),
   m_iSizeY    ( def_iXY ),
   m_dFactor   ( def_dFactor ),
   m_eParameter( def_eParameter )
{
   m_csFilterName = m_lpcsFilterName;

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

/*
 * destructor; current filter settings are saved via WriteFilterSettings()
 * when user pressed OK-button, see CFilterDlg::OnOK().
 */
CScanFilterLinearRegression::~CScanFilterLinearRegression()
{
   ; // do nothing here
}

/*
 * store or retrieve the object's settings;
 * currently filter serialization is not used;
 * see also CScanFilterNull::Serialize().
 */
void CScanFilterLinearRegression::Serialize( CArchive& ar )
{
//   Q_LOG( _T("CScanFilterLinearRegression::Serialize") );

   CScanFilter::Serialize( ar );

   if ( ar.IsStoring() )
   {
      ar << m_iSizeX << m_iSizeY << static_cast<int>( m_eParameter ) << m_dFactor;
   }
   else
   {
      int iParameter;
      ar >> m_iSizeX >> m_iSizeY >> iParameter >> m_dFactor;
      m_eParameter = static_cast<FeatureSelector>( iParameter );
   }
}

#if 0
/*
 * true if filter can process a data-selection in the buffer.
 */
BOOL CScanFilterLinearRegression::CanDoPartialData() const
{
   return TRUE;
}
#endif

#if 0
/*
 * true if a dialog can be used.
 */
BOOL CScanFilterLinearRegression::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().
 */
void CScanFilterLinearRegression::ReadFilterSettings( )
{
//   Q_LOG( _T("CScanFilterLinearRegression::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( "5,5,1,100" ) ) );
#endif
}

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

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

   csParameters.Format( _T( "%d,%d,%d,%g,%g" ),
      m_iSizeX, m_iSizeY, m_eParameter, m_dTheta, m_dFactor );

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

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

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

   /*
    * set defaults, read parameter string with factor and optional offset:
    */
   m_iSizeX     = def_iXY;
   m_iSizeY     = def_iXY;
   m_dFactor    = def_dFactor;
   m_eParameter = def_eParameter;

   int nfields = _stscanf( lpParameters, _T( "%d,%d,%d,%lg,%lg" ),
      &m_iSizeX, &m_iSizeY, &m_eParameter, &m_dTheta, &m_dFactor );

   if ( Q_INVALID( 4 > nfields &&
      "CScanFilterLinearRegression (SetParameters): X- and Y-size, parameter and factor expected, got fewer." ) )
   {
      return FALSE;
   }

   return TRUE;
}

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

   CFilterDlg_LinearRegressionPtr pDlg = new CFilterDlg_LinearRegression();

   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.
    */
   pDlg->Create( IDD_FILTERDLG_LINEARREGRESSION, pParentWnd );

   m_pDlg = pDlg;

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

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

   return bRet;
}

/*
 * let PreApplyCore() perform the filter pre-processing; catch MFC and std exceptions;
 * see also CScanFilterNull::Apply().
 */
BOOL CScanFilterLinearRegression::PreApply()
{
//   Q_LOG( _T("CScanFilterLinearRegression::Apply()") );

   BOOL bRet = FALSE;                   // preset to Failure

   try
   {
      bRet = PreApplyCore();            // 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
}

/*
 * let ApplyCore() perform the filter processing; catch MFC and std exceptions;
 * see also CScanFilterNull::Apply().
 */
BOOL CScanFilterLinearRegression::Apply()
{
//   Q_LOG( _T("CScanFilterLinearRegression::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(
            AfxGetMainWnd()->m_hWnd, e.what(), _T("Linear Regression Filter Failure"), MB_OK | MB_ICONWARNING );
      }
#endif
   }

   return bRet;                         // return status
}

/*
 * the selected parameter name.
 */
CharCptr CScanFilterLinearRegression::ParamName()
{
   switch( Parameter() )
   {
      case  LinearRegressionImageFilter::A: return "A";
      case  LinearRegressionImageFilter::B: return "B";
      case  LinearRegressionImageFilter::C: return "C";
      case  LinearRegressionImageFilter::AlphaPi: return "Alpha[Pi]";
      case  LinearRegressionImageFilter::AlphaDeg: return "Alpha[deg]";
      case  LinearRegressionImageFilter::BetaPi: return "Beta[Pi]";
      case  LinearRegressionImageFilter::BetaDeg: return "Beta[deg]";
      case  LinearRegressionImageFilter::AngleLength: return "Length";
      case  LinearRegressionImageFilter::AngleLengthNeg: return "Length (Neg)";
      case  LinearRegressionImageFilter::AngleLengthPi: return "Length[Pi]";
      case  LinearRegressionImageFilter::AngleLengthPiNeg: return "Length[Pi] (Neg)";
      case  LinearRegressionImageFilter::AngleLengthDeg: return "Length[deg]";
      case  LinearRegressionImageFilter::AngleLengthDegNeg: return "Length[deg] (Neg)";
      case  LinearRegressionImageFilter::AngleSum: return "Sum";
      case  LinearRegressionImageFilter::AngleSumPi: return "Sum[Pi]";
      case  LinearRegressionImageFilter::AngleSumDeg: return "Sum[deg]";
      default: return "[unrcognized]";
   }
}

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

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

   /*
    * 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 ) );

   switch ( Parameter() )
   {
      case LinearRegressionImageFilter::C:
         m_lpsbOut->m_csBufferName.Format( _T("%s - %s %dx%d %s"),
            m_lpsbIn->m_csBufferName, m_lpcsShortFilterName, Ncols(), Nrows(), ParamName() );
         break;

      case LinearRegressionImageFilter::AngleSum:
      case LinearRegressionImageFilter::AngleSumPi:
      case LinearRegressionImageFilter::AngleSumDeg:
         m_lpsbOut->m_csBufferName.Format( _T("%s - %s %dx%d %g·%s(%g\xB0)" ),
            m_lpsbIn->m_csBufferName, m_lpcsShortFilterName, Ncols(), Nrows(), Factor(), ParamName(), Theta() );
         break;

      default:
         m_lpsbOut->m_csBufferName.Format( _T("%s - %s %dx%d %g·%s"),
            m_lpsbIn->m_csBufferName, m_lpcsShortFilterName, Ncols(), Nrows(), Factor(), ParamName() );
         break;
   }

   /*
    * if the dialog is present:
    */
   if ( IsInteractive() )
   {
      m_pDlg->SetDlgItemText( IDC_BUFFEROUTNAME, m_lpsbOut->m_csBufferName );
   }

   return TRUE;                         // Ok
}

/*
 * pre-apply and process;
 * see also CScanFilterNull::ApplyCore().
 */
BOOL CScanFilterLinearRegression::ApplyCore()
{
   /*   
    * pre-apply must also be done from apply for scripting use:
    */
   if ( !PreApplyCore() )
   {
      return FALSE;
   }

   /*
    * process the L2R part and the R2L part (if present).
    */

//   LinearRegressionImageFilter filter( Ncols(), Nrows(), Parameter() );
   LinearRegressionImageFilter filter( ToRadius( Ncols(), Nrows() ) );
   
   filter.Select   ( Parameter() );
   filter.SetTheta ( Theta()  );
   filter.SetFactor( Factor() );

   /** \todo setNorm(): verify its correct working */
   if ( std::numeric_limits< CScanBaseBuffer::SpacingType >::epsilon() < m_lpsbIn->GetSpacingX() )
   {
      filter.SetNorm( m_lpsbIn->GetSpacingZ() / m_lpsbIn->GetSpacingX() );
   }
   else
   {
      filter.SetNorm( 1.0 );
   }

//   filter.apply( to_channel( m_lpsbIn ), to_channel( m_lpsbOut )  );
   filter.Apply( ToImage( m_lpsbIn ), ToImage( m_lpsbOut )  );

   if ( m_lpsbIn->IsBidirectionalScan() && m_lpsbOut->IsBidirectionalScan() )
   {
//      filter.apply( to_channel( m_lpsbIn, true ), to_channel( m_lpsbOut, true ) );
      filter.Apply( ToImage( m_lpsbIn, true ), ToImage( m_lpsbOut, true ) );
   }

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

   return TRUE;                         // return Ok
}

/*
 * measure algorithm performance.
 */
SPerformanceTestResult CScanFilterLinearRegression::GetPerformanceTestResult()
{
   SPerformanceTestResult result;

   typedef long Count;

   CPerfTimer Timer;

   /*
    * time Preparation:
    */

   ; // do nothing

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

   Timer.Start( true );                 // restart the timing
   while ( Timer.Elapsed() < timeToProcess )
   {
      LinearRegressionImageFilter filter( ToRadius( Ncols(), Nrows() ) ); 
      
      filter.Select   ( Parameter() );
      filter.SetFactor( Factor()    );

//      filter.apply( to_channel( m_lpsbIn ), to_channel( m_lpsbOut )  );
      filter.Apply( ToImage( m_lpsbIn ), ToImage( m_lpsbOut )  );

      ++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
 */

---