Filter Library

Camera

Interface Physics

ScanFilterMinimum.cpp

/*
 * ScanFilterMinimum.cpp - minimum image filter.
 *
 * This file is part of the Camera Filter Library.
 * Computer Aided Measurement Environment for Realtime Atomic imaging (Camera)
 *
 * Copyright (C) 2004-2006, Leiden Probe Microscopy.
 * Copyright (C) 2004-2006, Universiteit Leiden.
 *
 * Authors: Martin J. Moene
 *
 * $Id: ScanFilterMinimum.cpp 363 2006-03-09 13:21:27Z 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/ScanFilterMinimum.h>      // this filter's header FIXME
#include <cfl/FilterDlg_Minimum.h>      // this filter's dialog
#include <cfl/ToolCilImage.h>           // for Image type and ToImage conversion shim

#include <cil/MinimumImageFilter.h>     // minimum 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.
 */
#ifdef CIL_MinimumImageFilter_USE_TYPE_HACK     // ::Type hack
   typedef cil::MinimumImageFilter< Image >::Type MinimumFilterType;
#else
   typedef cil::MinimumImageFilter< Image > MinimumFilterType;
#endif

#define CFL_SCHEMAVERSION_FILTERMINIMUM 0 ///< permanent storage schema version
                                        // this filter's name
LPCTSTR CScanFilterMinimum::m_lpcsFilterName = _T("Minimum");
                                        // this filter's short name
LPCTSTR CScanFilterMinimum::m_lpcsShortFilterName = CScanFilterMinimum::m_lpcsFilterName;
                                        // serialization
IMPLEMENT_SERIAL(CScanFilterMinimum, CScanFilterRank, CFL_SCHEMAVERSION_FILTERMINIMUM)

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

   m_csFilterName = m_lpcsFilterName;

   ReadFilterSettings();
}

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

   CFilterDlg_MinimumPtr pDlg = new CFilterDlg_Minimum();

   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_MINIMUM, 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 CScanFilterMinimum::Apply()
{
//   Q_LOG( _T("CScanFilterMinimum::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"), m_lpsbIn->m_csBufferName, m_lpcsShortFilterName, GetSizeX(), GetSizeY() );

   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):
    */
   MinimumFilterType filter( ToRadius( m_cpSize.x, m_cpSize.y ) );

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

---