Filter Library

Camera

Interface Physics

ScanFilterNCCFFT.cpp

/*
 * ScanFilterNCCFFT.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: ScanFilterNCCFFT.cpp 505 2007-01-29 06:46:39Z 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/ScanFilterNCCFFT.h>       // this filter's header FIXME
#include <cfl/FilterDlg_NCCFFT.h>       // this filter's dialog
#include <cfl/ToolCilImage.h>           // for Image type and ToImage conversion shim
#include <cil/Traits.h>                 // type traits

#include <cil/CorrelationImageFilter.h> // CorrelationImageFilter image filter (FFT)
#include <cil/correlation/BackgroundSubtractor.h>    // for class BackgroundSubtractOperator
#include <cil/correlation/MeanSubtractor.h>          // for class MeanSubtractOperator
#include <cil/correlation/NormalOperator.h>          // for class NormalOperator
#include <cil/correlation/PhaseOperator.h>           // for class PhaseOperator
#include <cil/correlation/SimpleOptimizer.h>         // for class CorrelationSimpleOptimizer
#include <cil/correlation/ScaleNormalizer.h>         // for class ScaleNormalizer
#include <cil/correlation/EnergyNormalizer.h>        // for class EnergyNormalizer
#include <cil/correlation/ZeroMeanNormalizer.h>      // for class ZeroMeanNormalizerType

/*
 * configuration defines:
 */

// none

/*
 * end of configuration defines.
 */

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

/*
 * convenience types.
 */

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

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

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

   /*
    * 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.
 */
CScanFilterNCCFFT::~CScanFilterNCCFFT()
{
//    Q_LOG( _T("CScanFilterNCCFFT::~CScanFilterNCCFFT()") );

   ; // do nothing
}

/*
 * store or retrieve the object's settings;
 * currently filter serialization is not used;
 * see also CScanFilterNull::Serialize().
 */
void CScanFilterNCCFFT::Serialize(CArchive& ar)
{
//   Q_LOG( _T("CScanFilterNCCFFT::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 CScanFilterNCCFFT::ReadFilterSettings()
{
//    Q_LOG( _T("CScanFilterNCCFFT::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 CScanFilterNCCFFT::WriteFilterSettings() const
{
//    Q_LOG( _T("CScanFilterNCCFFT::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 CScanFilterNCCFFT::GetParameters() const
{
//    Q_LOG( _T("CScanFilterNCCFFT::GetParameters()") );

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

   csParameters.Format
      ( _T( "%d,%d,%d,%d,%g,%g,%g" )
      , GetSubtractionType()
      , 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 CScanFilterNCCFFT::SetParameters( LPCTSTR lpParameters )
{
//    Q_LOG( _T("CScanFilterNCCFFT::SetParameters()") );

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

   /*
    * set defaults, read parameter string with factor and optional offset:
    */
   int subtract  = bgMean;
   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,%d,%lg,%lg,%lg" )
      , &subtract
      , &norm
      , &normsub
      , &relax
      , &scale0
      , &scale1
      , &scale2
   );

   m_subtract = static_cast< SubtractionType >     ( subtract );
   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( 7 > nfields && "CScanFilterNCCFFT (SetParameters): FIXME parameters expected, got less." ) )
   {
      return FALSE;
   }

   return TRUE;
}

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

/**
 * return the requested input buffer.
 */
CScanBaseBuffer *CScanFilterNCCFFT::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 CScanFilterNCCFFT::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 CScanFilterNCCFFT::RunModeless( CWnd* pParentWnd, CDocument* pDoc )
{
//    Q_LOG( _T("CScanFilterNCCFFT::RunModeless()") );

   CFilterDlg_NCCFFTPtr pDlg = new CFilterDlg_NCCFFT();

   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().
 */
#include <cil/ImageFill.h>                   // for FillImageRandom()
BOOL CScanFilterNCCFFT::Apply()
{
//    Q_LOG( _T("CScanFilterNCCFFT::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
   );

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

   /*
    * apply filter to L2R part:
    */

   /*
    * convenience types.
    */
   typedef cil::Image< InputPixelType > InputImageType;
   typedef cil::Image< OutputPixelType > OutputImageType;

   typedef cil::CorrelationImageFilter
   < const InputImageType
   , const InputImageType
   ,       OutputImageType > FilterType;

   typedef cil::correlation::MeanSubtractor      < FilterType > MeanSubtractorType;
   typedef cil::correlation::BackgroundSubtractor< FilterType > BackgroundSubtractorType;

   typedef cil::correlation::NormalOperator      < FilterType > NormalOperatorType;
   typedef cil::correlation::PhaseOperator       < FilterType > PhaseOperatorType;
   typedef cil::correlation::EnergyNormalizer    < FilterType > EnergyNormalizerType;
   typedef cil::correlation::ZeroMeanNormalizer  < FilterType > ZeroMeanNormalizerType;
   typedef cil::correlation::ScaleNormalizer     < FilterType > ScaleNormalizerType;

   FilterType filter;
   filter.SetRelaxFFTSize( DoRelaxFFTSize() );

   /*
    * background subtraction:
    */
   switch ( GetSubtractionType() )
   {
      case bgMean:
         filter.SetSubtractor( MeanSubtractorType::New() );
         break;
      case bgBackground:
         filter.SetSubtractor( BackgroundSubtractorType::New() );
         break;
      default:
         filter.SetSubtractor( );
         break;
   };

   /*
    * normal or phase correlation:
    */
   switch ( GetNormalizationType() )
   {
      case nmNormal:
         filter.SetOperator( NormalOperatorType::New() );

         /*
          * none, energy or zero-mean normalization:
          */
         switch ( GetNormalizationSubType() )
         {
            case nsEnergy:
            {
               EnergyNormalizerType::Pointer normalizer = EnergyNormalizerType::New();
               normalizer->SetScale( GetScale( GetNormalizationType() ) );
               filter.SetNormalizer( normalizer );
               break;
            }
            case nsZeroMean:
            {
               ZeroMeanNormalizerType::Pointer normalizer = ZeroMeanNormalizerType::New();
               normalizer->SetScale( GetScale( GetNormalizationType() ) );
               filter.SetNormalizer( normalizer );
               break;
            }
            default:
            {
               /*
                * error
                */
               break;
            }
         };
         break; // nmNormal

      case nmPhase: default: {
         if ( nmPhase == GetNormalizationType() )
         {
            filter.SetOperator( PhaseOperatorType::New()  );
         }
         else
         {
            filter.SetOperator( NormalOperatorType::New() );
         }

         ScaleNormalizerType::Pointer normalizer = ScaleNormalizerType::New();
         normalizer->SetScale( GetScale( GetNormalizationType() ) );
         filter.SetNormalizer( normalizer );
         break;
      }
   };

   //            subject image       , template image     , correlation
   filter.Apply( ToImage( m_lpsbIn2 ), ToImage( m_lpsbIn ), 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 ), ToImage( m_lpsbOut, true ) );
   }

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

   return TRUE;
}

/*
 * end of file
 */

---