Filter Library

Camera

Interface Physics

ScanFilterShift.cpp

/*
 * ScanFilterShift.cpp - shift 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: ScanFilterShift.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/ScanFilterShift.h>        // this filter's header
#include <cfl/FilterDlg_Shift.h>        // this filter's dialog

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

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

/*
 * the default new X-size.
 */
const CScanFilterShift::DiffElementType CScanFilterShift::def_nShiftX = 10;

/*
 * the default new Y-size.
 */
const CScanFilterShift::DiffElementType CScanFilterShift::def_nShiftY = 10;

/*
 * constructor.
 */
CScanFilterShift::CScanFilterShift() :
   m_cpShift( DiffType( def_nShiftX, def_nShiftY ) )
{
   m_csFilterName = m_lpcsFilterName;
   
   ReadFilterSettings();
}

/*
 * destructor.
 */
CScanFilterShift::~CScanFilterShift()
{
   ; // do nothing
}

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

   CScanFilter::Serialize( ar );

   if ( ar.IsStoring() )
   {
      ar << m_cpShift.x << m_cpShift.y;
   }
   else
   {
      ar >> m_cpShift.x >> m_cpShift.y;
   }
};

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

   CWinApp* pApp = AfxGetApp();

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

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

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

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

   csParameters.Format( _T( "%d,%d" ), m_cpShift.x, m_cpShift.y );

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

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

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

   /*
    * set defaults, read parameter string with factor and optional offset:
    */
   m_cpShift = DiffType( def_nShiftX, def_nShiftY );

   int nfields = _stscanf( lpParameters, _T( "%d,%d" ), &m_cpShift.x, &m_cpShift.y );

   if ( Q_INVALID( 2 > nfields && "CScanFilterShift (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 CScanFilterShift::RunModeless( CWnd* pParentWnd, CDocument* pDoc )
{
//   Q_LOG( _T("CScanFilterShift::RunModeless()") );

   CFilterDlg_ShiftPtr pDlg = new CFilterDlg_Shift();

   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_SHIFT, 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 CScanFilterShift::SupportDragInput() const
{
   return SFDS_POINT;
}

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

   SetShiftX( rcIn.right  - rcIn.left );
   SetShiftY( rcIn.bottom - rcIn.top  );

   if ( IsInteractive() )
   {
      m_pDlg->SetDlgItemInt( IDC_SHIFT_SHIFTX, m_cpShift.x );
      m_pDlg->SetDlgItemInt( IDC_SHIFT_SHIFTY, m_cpShift.y );
   }

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

   CFilterDlg_ShiftPtr pDlg = dynamic_cast<CFilterDlg_ShiftPtr>( 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 CScanFilterShift::Apply()
{
//   Q_LOG( _T("CScanFilterShift::Apply()") );

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

   /*
    *  optionally adjust shift:
    */
   BOOL bAdjustX = FALSE;
   BOOL bAdjustY = FALSE;

   if ( GetShiftX() >= ( DiffElementType ) m_lpsbIn->Columns() )
   {
      bAdjustX = TRUE;
      SetShiftX( m_lpsbIn->Columns() - 1 );
   }
   else if ( GetShiftX() <= - ( DiffElementType ) m_lpsbIn->Columns() )
   {
      bAdjustX = TRUE;
      SetShiftX( 1 - ( DiffElementType ) m_lpsbIn->Columns() );
   }

   if ( GetShiftY() >= ( DiffElementType ) m_lpsbIn->Rows() )
   {
      bAdjustY = TRUE;
      SetShiftY( m_lpsbIn->Rows() - 1 );
   }
   else if ( GetShiftY() <= -( DiffElementType ) m_lpsbIn->Rows() )
   {
      bAdjustY = TRUE;
      SetShiftY( 1 - ( DiffElementType ) m_lpsbIn->Rows() );
   }

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

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

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

      if ( bAdjustX )
      {
         m_pDlg->SetDlgItemInt( IDC_SHIFT_SHIFTX, GetShiftX() );
      }

      if ( bAdjustY )
      {
         m_pDlg->SetDlgItemInt(IDC_SHIFT_SHIFTY, GetShiftY() );
      }
   }

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

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

   return TRUE;
}

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

   const CScanBaseBuffer::SizeType& width  =  m_lpsbOut->Columns();
   const CScanBaseBuffer::SizeType& height =  m_lpsbOut->Rows();

   DiffElementType blackLines = abs( GetShiftY() );
   DiffElementType dataLines  = height - blackLines;

   DiffElementType dataStartLine;
   DiffElementType dataStopLine ;

   /*
    * fill black part:
    */
   if ( GetShiftY() > 0 )
   {
      dataStartLine = blackLines;
      dataStopLine  = m_lpsbIn->Rows();

      memset( pOutData, 0, blackLines * width * sizeof( ValueType ) );
   }
   else
   {
      dataStartLine = 0;
      dataStopLine  = dataLines;

      memset( pOutData + dataLines * width, 0, blackLines * width * sizeof( ValueType ) );
   }

   pOutData += dataStartLine * width;

   DiffElementType blackCols = abs( GetShiftX() );
   DiffElementType dataCols  = width - blackCols;

   /*
    * copy the image data into the new area, clear the unused block at the left or right:
    */
   for ( DiffElementType y = dataStartLine; y < dataStopLine; ++y, pOutData += width )
   {
      const int currentLine = (y - GetShiftY() ) * width;

      if ( GetShiftX() > 0 )
      {
         /*
          * first the black part, then the data:
          */
         memset( pOutData, 0, blackCols * sizeof( ValueType ) );

         memcpy( pOutData + blackCols, pInpData + currentLine, dataCols * sizeof( ValueType ) );
      }
      else
      {
         /*
          * first the data, then the black part:
          */
         memcpy( pOutData, pInpData + currentLine + blackCols, dataCols * sizeof( ValueType ) );

         memset( pOutData + dataCols, 0, blackCols * sizeof( ValueType ) );
      }
   }
}

/*
 * end of file
 */

---