Filter Library

Camera

Interface Physics

ScanFilterNCCFFTOld.cpp

/*
 * ScanFilterNCCFFTOld.cpp - fast normalized cross-correlation filter.
 *
 * 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
 *
 * $Id: ScanFilterNCCFFTOld.cpp 458 2007-01-04 15:20:34Z moene $
 */

#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/ScanFilterNCCFFTOld.h>      // this filter's header FIXME
#include <cfl/FilterDlg_NCCFFTOld.h>      // this filter's dialog
#include <cfl/ToolCilImage.h>                   // for Image type and ToImage conversion shim

#include <cil/Traits.h>                         // type traits
#include <cil/CorrelationImageFilterOld.h> // CorrelationImageFilterOld image filter (FFT)
#include <cil/ShiftScaleImageFilter.h>  // for class ShiftScaleImageFilter

/*
 * configuration defines:
 */

// none

/*
 * end of configuration defines.
 */

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

/*
 * convenience types.
 */

/**
 * the correlation image type.
 */
typedef cil::Image< double > CorrelationImageType;

/**
 * the correlation filter type.
 */
typedef cil::CorrelationImageFilterOld< Image, Image, CorrelationImageType > CorrelationImageFilterType;

/**
 * the shift-scale filter type.
 */
typedef cil::ShiftScaleImageFilter< CorrelationImageType, Image > ShiftScaleImageFilterType;

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

/*
 * the default scale factor.
 */
const CScanFilterNCCFFTOld::ScaleType CScanFilterNCCFFTOld::m_defScale = 1000;

/*
 * default constructor: setup filter to run without dialog;
 * see also CScanFilterNull::CScanFilterNull().
 */
CScanFilterNCCFFTOld::CScanFilterNCCFFTOld()
   : m_lpsbIn2( NULL )
{
//    Q_LOG( _T("CScanFilterNCCFFTOld::CScanFilterNCCFFTOld()") );

   /*
    * we define our own normlization (sub-)type values to decouple this filter's
    * header from the Camera Imaging Library (CIL). Nonetheless, we want to use
    * the mode values as if they were from the CIL Threshld filter. Here we check
    * at compile-time if the values do match.
    */
   cil_static_assert( nmNone     == CorrelationImageFilterType::Normalization::None  , nmNone_values_must_match   );
   cil_static_assert( nmNormal   == CorrelationImageFilterType::Normalization::Normal, nmNormal_values_must_match   );
   cil_static_assert( nmPhase    == CorrelationImageFilterType::Normalization::Phase , nmPhase_values_must_match   );

   cil_static_assert( nsZeroMean == CorrelationImageFilterType::NormalizationSub::ZeroMean, nsZeroMean_values_must_match   );
   cil_static_assert( nsEnergy   == CorrelationImageFilterType::NormalizationSub::Energy  , nsEnergy_values_must_match   );

   m_csFilterName = m_lpcsFilterName;

   ReadFilterSettings();
}

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

   ; // do nothing
}

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

   CScanFilter::Serialize( ar );

   if ( ar.IsStoring() )
   {
//        ar << m_mode << m_lower << m_upper << m_outside;
   }
   else
   {
//       int mode;
//
//       ar >> mode >> m_lower >> m_upper >> m_outside;
//
//       m_mode = static_cast< NormalizationMode >( mode );
   }
};

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

   CWinApp* pApp = AfxGetApp();

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

   /*
    * parameter string:
    */
   SetParameters( pApp->GetProfileString( gCflRegistrySubkey, m_lpcsFilterName, _T( "1,0,0,1e-6,1000,1000" ) ) );
}

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

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

   csParameters.Format
      ( _T( "%d,%d,%d,%g,%g,%g" )
      , GetNormalizationType()
      , GetNormalizationSubType()
      , DoRelaxFFTSize()
      , GetScale( nmNone )
      , GetScale( nmNormal )
      , GetScale( nmPhase )
   );

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

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

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

   /*
    * set defaults, read parameter string with factor and optional offset:
    */
   int norm      = nmNormal;
   int normsub   = nsEnergy;
   int relax     = false;
   double scale0 = 1e-6; // m_defScale;
   double scale1 = m_defScale;
   double scale2 = m_defScale;

   int nfields = _stscanf
      ( lpParameters
      , _T( "%d,%d,%d,%lg,%lg,%lg" )
      , &norm
      , &normsub
      , &relax
      , &scale0
      , &scale1
      , &scale2
   );

   m_norm    = static_cast< NormalizationType >   ( norm );
   m_normsub = static_cast< NormalizationSubType >( normsub );
   m_relax_fft_size = 0 != relax;
   m_scale[0] = scale0;
   m_scale[1] = scale1;
   m_scale[2] = scale2;

   if ( Q_INVALID( 5 > nfields && "CScanFilterNCCFFTOld (SetParameters): FIXME parameters expected, got less." ) )
   {
      return FALSE;
   }

   return TRUE;
}

/**
 * the number of input buffers.
 */
DWORD CScanFilterNCCFFTOld::GetNrOfInBuffers() const
{
   return 2;
}

/**
 * return the requested input buffer.
 */
CScanBaseBuffer *CScanFilterNCCFFTOld::GetInputBuffer( UINT nNr )
{
   Q_ASSERT( 0 <= nNr && nNr < GetNrOfInBuffers() && "ensure valid input buffer nr" );

   if ( 1 == nNr )
   {
      return m_lpsbIn2;
   }

   return m_lpsbIn;
}

/**
 * set the given input buffer.
 */
void CScanFilterNCCFFTOld::SetInputBuffer( UINT nNr, CScanBaseBuffer *lpsbIn )
{
   Q_ASSERT( 0 <= nNr && nNr < GetNrOfInBuffers() && "ensure valid input buffer nr" );
   Q_ASSERT( NULL != lpsbIn && "ensure valid input buffer" );

   if ( 0 == nNr )
   {
      m_lpsbIn = lpsbIn;
   }
   else if ( 1 == nNr )
   {
      m_lpsbIn2 = lpsbIn;
   }
}

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

   CFilterDlg_NCCFFTOldPtr pDlg = new CFilterDlg_NCCFFTOld();

   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_NCCFFT, 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, CalculatePlane() and SubtractPlane();
 * see also CScanFilterNull::ApplyCore().
 */
BOOL CScanFilterNCCFFTOld::Apply()
{
//    Q_LOG( _T("CScanFilterNCCFFTOld::Apply()") );

   if ( Q_INVALID( NULL == m_lpsbIn && "ensure first input buffer") )
      return FALSE;

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

   if ( Q_INVALID( !m_lpsbIn2->IsCompleteFrame() && "ensure complete frame" ) )
      return FALSE;

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

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

//    m_lpsbOut->m_csBufferName.Format
//       ( _T("%s - %s %d,%d,%d,%d")
//       , m_lpsbIn->m_csBufferName
//       , m_lpcsShortFilterName
//       , GetNormalizationMode()
//       , GetLowerNCCFFT()
//       , GetUpperNCCFFT()
//       , GetOutsideValue()
//    );
//
   if ( IsInteractive() )
   {
      m_pDlg->SetDlgItemText( IDC_BUFFEROUTNAME, m_lpsbOut->m_csBufferName );
   }

   /*
    * apply filter to L2R part:
    */
   CorrelationImageFilterType filter;
   ShiftScaleImageFilterType  scaler;

   filter.SetNormalizationType   ( static_cast<CorrelationImageFilterType::NormalizationType>(GetNormalizationType() )   );
   filter.SetNormalizationSubType( static_cast<CorrelationImageFilterType::NormalizationSubType>(GetNormalizationSubType() ) );
   filter.SetRelaxFFTSize        ( DoRelaxFFTSize() );
   scaler.SetScale               ( GetScale( GetNormalizationType() ) );

   CorrelationImageType correlation;

   //            subject image       , template image     , correlation
   filter.Apply( ToImage( m_lpsbIn2 ), ToImage( m_lpsbIn ), correlation );
   scaler.Apply( correlation         , ToImage( m_lpsbOut ) );

   /*
    * if we have a double buffer, L2R and R2L, process that part tooo.
    */
   if ( m_lpsbIn->IsBidirectionalScan() && m_lpsbOut->IsBidirectionalScan() )
   {
      //                     subject image    , template image           , correlation
      filter.Apply( ToImage( m_lpsbIn2, true ), ToImage( m_lpsbIn, true ), correlation );
      scaler.Apply( correlation               , ToImage( m_lpsbOut, true ) );
   }

   return TRUE;
}

/*
 * end of file
 */

---