Filter Library

Camera

Interface Physics

ScanFilterClad.cpp

/*
 * ScanFilterClad.cpp - clad filter.
 *
 * 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: M. Seynen (original), Martin J. Moene
 *
 * $Id: ScanFilterClad.cpp 358 2006-03-06 14:49:02Z moene $
 */

/*
 * configuration defines:
 */

// currently nothing

/*
 * end of configuration defines.
 */

#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 <Camera/CameraGeneralDefines.h>// for g_d2PI

#include <cfl/ScanFilterClad.h>         // this filter's header
#include <cfl/FilterDlg_Clad.h>         // this filter's dialog

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

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

/*
 * the default new X-size.
 */
const CScanFilterClad::SizeElementType CScanFilterClad::def_nWidth = 220;

/*
 * the default new Y-size.
 */
const CScanFilterClad::SizeElementType CScanFilterClad::def_nHeight = 120;

/*
 * constructor.
 */
CScanFilterClad::CScanFilterClad() :
   m_cSize( CSize( def_nWidth, def_nHeight ) )
{
//   Q_LOG( _T("CScanFilterClad::CScanFilterClad()") );

   m_csFilterName = m_lpcsFilterName;

   ReadFilterSettings();
}

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

   ; // do nothing
}

/*
 * store or retrieve the object's settings;
 * see also CScanFilterNull::Serialize().
 */
void CScanFilterClad::Serialize( CArchive& ar )
{
//   Q_LOG( _T("CScanFilterClad::Serialize()") );

   CScanFilter::Serialize( ar );

   if ( ar.IsStoring() )
   {
      ar << m_cSize.cx << m_cSize.cy;
   }
   else
   {
      ar >> m_cSize.cx >> m_cSize.cy;
   }
};

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

   CWinApp* pApp = AfxGetApp();

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

   /*
    * parameter string:
    */
   SetParameters( pApp->GetProfileString( gCflRegistrySubkey, m_lpcsFilterName, _T( "220,120" ) ) );
}

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

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

   csParameters.Format( _T( "%d,%d" ), m_cSize.cx, m_cSize.cy );

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

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

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

   /*
    * set defaults, read parameter string with factor and optional offset:
    */
   m_cSize = SizeType( def_nWidth, def_nHeight );

   int nfields = _stscanf( lpParameters, _T( "%d,%d" ), &m_cSize.cx, &m_cSize.cy );

   if ( Q_INVALID( 2 > nfields && "CScanFilterClad (SetParameters): x- and y-size expected, got none." ) )
   {
      return FALSE;
   }

   return TRUE;
}

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

   CFilterDlg_CladPtr pDlg = new CFilterDlg_Clad();

   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_CLAD, pParentWnd );

   m_pDlg = pDlg;

   BOOL bRet = Apply();

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

   return bRet;
}

#pragma warning( push )
#pragma warning( disable : 4100 )       // unreferenced formal parameter

/**
 * the supported dragmethod(s).
 */
DragSupportType CScanFilterClad::SupportDragInput() const 
{ 
   return SFDS_RECT; 
}

/*
 * apply the filter to the selected area.
 */
void CScanFilterClad::SetDragInput( BOOL bL2R, CRect rcIn )
{
//   Q_LOG( _T("CScanFilterClad::SetDragInput()") );

   /* 
    * Note: use NormalizeRect() because otherwise width and height of rcIn may wel be negative;
    * minimally retain image size.
    */
   rcIn.NormalizeRect();
   SetWidth ( max( rcIn.Width() , static_cast< int >( m_lpsbIn->Columns() ) ) );
   SetHeight( max( rcIn.Height(), static_cast< int >( m_lpsbIn->Rows   () ) ) );

   if ( IsInteractive() )
   {
      m_pDlg->SetDlgItemInt( IDC_CLAD_SIZEX, GetWidth() );
      m_pDlg->SetDlgItemInt( IDC_CLAD_SIZEY, GetHeight() );
   }

  if ( Q_FAILED( Apply() ) )
   {
      return ;
   }

   CFilterDlg_CladPtr pDlg = dynamic_cast<CFilterDlg_CladPtr>( m_pDlg );

   if ( Q_ASSERT( NULL != pDlg ) )
   {
      pDlg->UpdateView();
   }
}

#pragma warning( pop )

/*
 * check parameters, take care of a properly sized output buffer,
 * set its name and copy filter parameters and process;
 * see also CScanFilterNull::ApplyCore().
 */
BOOL CScanFilterClad::Apply()
{
//   Q_LOG( _T("CScanFilterClad::Apply()") );

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

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

   /*
    * minimally retain image size:
    */
   SetWidth ( max( GetWidth() , m_lpsbIn->Columns() ) );
   SetHeight( max( GetHeight(), m_lpsbIn->Rows   () ) );

   /*
    * extra number of elements to allocate in data buffer:
    */
   SizeElementType extra = GetWidth() * GetHeight();

   /*
    * create output buffer:
    */
   Q_RETURN( m_lpsbOut->CreateOutputBufferFor( *m_lpsbIn, extra ) );

   /*
    * resize data buffer to requested size; also for first-time to show correct view:
    */
   Q_RETURN( m_lpsbOut->ResizeDataBuffer( GetSize(), extra ) );

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

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

   /*
    * process first part (L2R):
    */
   Clad( FALSE );

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

   return TRUE;
}

/*
 * process the frame part at the given offset (L2R, R2L frame part).
 */
void CScanFilterClad::Clad( BOOL bDoR2L )
{
   CScanBaseBuffer::ConstPointer pInpData = m_lpsbIn->Data()  + ( bDoR2L ? m_lpsbIn->GetFrameSize() : 0 );
   CScanBaseBuffer::Pointer      pOutData = m_lpsbOut->Data() + ( bDoR2L ? m_lpsbOut->GetFrameSize() : 0 );

   SizeElementType newWidth    = m_lpsbOut->Columns();
   SizeElementType newHeight   = m_lpsbOut->Rows();

   SizeElementType oldWidth    = m_lpsbIn->Columns();
   SizeElementType oldHeight   = m_lpsbIn->Rows();

   SizeElementType extraWidth  = newWidth  - oldWidth;
   SizeElementType extraHeight = newHeight - oldHeight;

   /*
    * copy the image data into the new area, clear the unused block at the right:
    */
   for ( SizeElementType y = 0; y < oldHeight; ++y )
   {
      //      dst       src       count
      memcpy( pOutData, pInpData, oldWidth * sizeof( CScanBaseBuffer::ValueType ) );

      //      dst                val  count
      memset( pOutData + oldWidth, 0, extraWidth * sizeof( CScanBaseBuffer::ValueType ) );

      pInpData += oldWidth;
      pOutData += newWidth;
   }

   /*
    * clear the unused block at the bottom:
    */

   //      dst     val  count
   memset( pOutData, 0, extraHeight * newWidth * sizeof( CScanBaseBuffer::ValueType ) );

}

/*
 * end of file
 */

---