Filter Library

Camera

Interface Physics

ScanFilterThreshold.cpp

/*
 * ScanFilterThreshold.cpp - general threshold 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: ScanFilterThreshold.cpp 400 2006-09-28 13:34:02Z 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/ScanFilterThreshold.h>      // this filter's header FIXME
#include <cfl/FilterDlg_Threshold.h>      // this filter's dialog
#include <cfl/ToolCilImage.h>                   // for Image type and ToImage conversion shim

#include <cil/Traits.h>                         // type traits
#include <cil/ThresholdImageFilter.h>     // ThresholdImageFilter image filter

/*
 * configuration defines:
 */

// none

/*
 * end of configuration defines.
 */

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

/*
 * convenience types.
 */
typedef cil::ThresholdImageFilter< Image > ThresholdFilterType;

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

// /*
//  * the default new X-size.
//  */
// const CScanFilterThreshold::DiffElementType CScanFilterThreshold::def_nSizeX = 3;
// 
// /*
//  * the default new Y-size.
//  */
// const CScanFilterThreshold::DiffElementType CScanFilterThreshold::def_nSizeY = 3;
// 
/*
 * default constructor: setup filter to run without dialog;
 * see also CScanFilterNull::CScanFilterNull().
 */
CScanFilterThreshold::CScanFilterThreshold()
{
//   Q_LOG( _T("CScanFilterThreshold::CScanFilterThreshold()") );

   /*
    * we define our own threshold mode 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( tmBelow   == ThresholdFilterType::tmBelow  , tmBelow_values_must_match   );
   cil_static_assert( tmAbove   == ThresholdFilterType::tmAbove  , tmAbove_values_must_match   );
   cil_static_assert( tmOutside == ThresholdFilterType::tmOutside, tmOutside_values_must_match );

   m_csFilterName = m_lpcsFilterName;

   ReadFilterSettings();
}

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

   ; // do nothing
}

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

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

   CWinApp* pApp = AfxGetApp();

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

   /*
    * parameter string:
    */
   SetParameters( pApp->GetProfileString( gCflRegistrySubkey, m_lpcsFilterName, _T( "0,-30000,+30000,0" ) ) );
}

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

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

   csParameters.Format
      ( _T( "%d,%d,%d,%d" )
      , GetThresholdMode()
      , GetLowerThreshold()
      , GetUpperThreshold()
      , GetOutsideValue()
   );

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

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

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

   /*
    * set defaults, read parameter string with factor and optional offset:
    */
   int mode    = tmBelow; 
   int lower   = lpm::NumericTraits< InputPixelType >::Min();
   int upper   = lpm::NumericTraits< InputPixelType >::Max();
   int outside = 0;

   int nfields = _stscanf
      ( lpParameters
      , _T( "%d,%d,%d,%d" )
      , &mode
      , &lower
      , &upper
      , &outside
   );

   m_mode    = static_cast< ThresholdMode   >( mode    );
   m_lower   = static_cast< InputPixelType  >( lower   );
   m_upper   = static_cast< InputPixelType  >( upper   );
   m_outside = static_cast< OutputPixelType >( outside );

   if ( Q_INVALID( 4 > nfields && "CScanFilterThreshold (SetParameters): four parameters expected, got less." ) )
   {
      return FALSE;
   }

   return TRUE;
}

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

   CFilterDlg_ThresholdPtr pDlg = new CFilterDlg_Threshold();

   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_THRESHOLD, 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 CScanFilterThreshold::Apply()
{
//   Q_LOG( _T("CScanFilterThreshold::Apply()") );

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

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

   if ( Q_INVALID( false == m_lpsbIn->IsCompleteFrame() ) )
      return FALSE;

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

   m_lpsbOut->m_csBufferName.Format
      ( _T("%s - %s %d,%d,%d,%d")
      , m_lpsbIn->m_csBufferName
      , m_lpcsShortFilterName
      , GetThresholdMode()
      , GetLowerThreshold()
      , GetUpperThreshold()
      , GetOutsideValue()
   );

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

   /*
    * apply filter to L2R part, use radius as specified by size (size 3x3 => radus 1x1):
    */
   ThresholdFilterType filter;
   
   filter.SetOutsideValue ( GetOutsideValue()  );

   switch ( GetThresholdMode() )
   {
      case tmBelow:
         filter.ThresholdBelow( GetLowerThreshold() );
         break;
      case tmAbove:
         filter.ThresholdAbove( GetUpperThreshold() );
         break;
      case tmOutside:
         filter.ThresholdOutside( GetLowerThreshold(), GetUpperThreshold() );
         break;
   };

   filter.Apply( ToImage( m_lpsbIn ), ToImage( m_lpsbOut ) );

   /*
    * if we have a double buffer, L2R and R2L, process that part too.
    */
   if ( m_lpsbIn->IsBidirectionalScan() && m_lpsbOut->IsBidirectionalScan() )
   {
      filter.Apply( ToImage( m_lpsbIn, true ), ToImage( m_lpsbOut, true ) );
   }

   return TRUE;
}

/*
 * end of file
 */

---