Filter Library

Camera

Interface Physics

ScanFilterTest.cpp

/*
 * ScanFilterTest.cpp - test 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: ScanFilterTest.cpp 446 2006-12-13 12:20:25Z 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/ScanFilterTest.h>         // this filter's header
#include <cfl/FilterDlg_Test.h>         // this filter's dialog

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

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

/*
 * constructor.
 */
CScanFilterTest::CScanFilterTest() :
   m_eModeL2R( MODE_SIN ),
   m_eModeR2L( MODE_SIN )
{
   m_csFilterName = m_lpcsFilterName;

   srand( static_cast<unsigned int>(time( 0 ) ) );

   ReadFilterSettings();
}

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

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

   if ( ar.IsStoring() )
   {
      ar << static_cast< int >( m_eModeL2R ) << static_cast< int >( m_eModeR2L );
   }
   else
   {
      int op;
      ar >> op;  m_eModeL2R = static_cast< ModeType >( op );
      ar >> op;  m_eModeR2L = static_cast< ModeType >( op );
   }
};

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

   CWinApp* pApp = AfxGetApp();

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

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

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

/*
 * anonymous namespace
 */
namespace
{
   struct Table
   {
      char* name; CScanFilterTest::ModeType mode;
   }
   table[] =
   {
      { "sin"   , CScanFilterTest::MODE_SIN,    },
      { "saw"   , CScanFilterTest::MODE_SAW,    },
      { "ramp"  , CScanFilterTest::MODE_RAMP,   },
      { "zero"  , CScanFilterTest::MODE_ZERO,   },
      { "neg"   , CScanFilterTest::MODE_NEG,    },
      { "copy"  , CScanFilterTest::MODE_COPY,   },
      { "box"   , CScanFilterTest::MODE_BOX,    },
      { "ripple", CScanFilterTest::MODE_RIPPLE, },
      { "noise" , CScanFilterTest::MODE_NOISE,  },
   };

   bool findMode( const char* name, CScanFilterTest::ModeType& mode )
   {
      for ( Table* p = table; p < table + dim(table); ++p )
      {
         if ( 0 == _stricmp( name, p->name ) )
         {
            mode = p->mode;
            return true;
         }
      }
      return false;
   }

   bool findName( CScanFilterTest::ModeType mode, char*& name )
   {
      for ( Table* p = table; p < table + dim(table); ++p )
      {
         if ( mode == p->mode )
         {
            name = p->name;
            return true;
         }
      }
      return false;
   }

} // anonymous namespace

/*
 * provide current filter parameter(s) for filter-scripting capture
 * in the main application;
 * see also CScanFilterNull::GetParameters().
 */
LPCTSTR CScanFilterTest::GetParameters() const
{
//   Q_LOG( _T("CScanFilterTest::GetParameters()") );

   char* partl2r = NULL;
   char* partr2l = NULL;

   if ( Q_INVALID( ( !findName( m_eModeL2R, partl2r ) || !findName( m_eModeR2L, partr2l ) &&
           "CScanFilterTest (GetParameters): invalid function name." ) ) )
   {
      return NULL;
   }

   CString csParameters;

   csParameters.Format( _T( "%s,%s" ), partl2r, partr2l );

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

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

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

   /*
    * set defaults, read parameter string with factor and optional offset:
    */
   char l2rname[10]; l2rname[0] = '\0';
   char r2lname[10]; r2lname[0] = '\0';

   int nfields = _stscanf( lpParameters, _T( "%[a-zA-Z],%[a-zA-Z]" ), l2rname, r2lname );

   if ( Q_INVALID( 2 > nfields && "CScanFilterTest (SetParameters): two function names expected, got fewer." ) )
   {
      Q_LOG( l2rname );
      Q_LOG( r2lname );
      return FALSE;
   }

   if ( !findMode( l2rname, m_eModeL2R ) )
   {
      Q_LOG( "CScanFilterTest (SetParameters): invalid L2R function name." );
      Q_LOG( l2rname );
      return FALSE;
   }

   if ( !findMode( r2lname, m_eModeR2L ) )
   {
      Q_LOG( "CScanFilterTest (SetParameters): invalid R2L function name." );
      Q_LOG( r2lname );
      return FALSE;
   }

   return TRUE;
}

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

   CFilterDlg_TestPtr pDlg = new CFilterDlg_Test();

   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_TEST, 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 and process;
 * see also CScanFilterNull::ApplyCore().
 */
BOOL CScanFilterTest::Apply()
{
   if ( Q_INVALID( NULL == m_lpsbIn && "ensure input buffer") )
      return FALSE;

   if ( Q_INVALID( NULL == m_lpsbOut && "ensure output buffer" ) )
      return FALSE;

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

   m_lpsbOut->m_csBufferName = m_lpsbIn->m_csBufferName + _T(" - ") + m_lpcsShortFilterName;

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

   DWORD i;

//   if (m_lpsbIn->m_dwFlags & SPM_SDBF_LEFT2RIGHT)
   if ( m_lpsbIn->HasLeftToRightScan () )
   {
      switch (m_eModeL2R)
      {
         case MODE_SAW:
            for (i=m_lpsbIn->m_dwPixelOffset; i<(m_lpsbIn->m_dwPixelOffset + m_lpsbIn->m_dwPixelCount); i++)
            {
               m_lpsbOut->m_pwData[i] = (short)(4*(i % (m_lpsbIn->m_dwSizeX/4)));
            }
            break;

         case MODE_SIN:
            for (i=m_lpsbIn->m_dwPixelOffset; i<(m_lpsbIn->m_dwPixelOffset + m_lpsbIn->m_dwPixelCount); i++)
            {
               m_lpsbOut->m_pwData[i] = (short)(m_lpsbIn->m_dwSizeX * sin (5.0 * g_2PI * (i % m_lpsbIn->m_dwSizeX) / m_lpsbIn->m_dwSizeX));
            }
            break;

         case MODE_RAMP:
            for (i=m_lpsbIn->m_dwPixelOffset; i<(m_lpsbIn->m_dwPixelOffset + m_lpsbIn->m_dwPixelCount); i++)
            {
               m_lpsbOut->m_pwData[i] = (short)(i % m_lpsbIn->m_dwSizeX);
            }
            break;

         case MODE_ZERO:
            ZeroMemory(m_lpsbOut->m_pwData + m_lpsbIn->m_dwPixelOffset, m_lpsbIn->m_dwPixelCount * sizeof(short));
            break;

         case MODE_NEG:
            for (i=m_lpsbIn->m_dwPixelOffset; i<(m_lpsbIn->m_dwPixelOffset + m_lpsbIn->m_dwPixelCount); i++)
            {
               m_lpsbOut->m_pwData[i] = (short) -m_lpsbIn->m_pwData[i];
            }
            break;

         case MODE_COPY:
            memcpy(m_lpsbOut->m_pwData + m_lpsbIn->m_dwPixelOffset, m_lpsbIn->m_pwData + m_lpsbIn->m_dwPixelOffset, m_lpsbIn->m_dwPixelCount * sizeof(short));
            break;

         case MODE_BOX:
            for (i=m_lpsbIn->m_dwPixelOffset; i<(m_lpsbIn->m_dwPixelOffset + m_lpsbIn->m_dwPixelCount); i++)
            {
               int x = i % m_lpsbIn->m_dwSizeX;
               int y = i / m_lpsbIn->m_dwSizeX;
               m_lpsbOut->m_pwData[i] = (y%32<16)&&(x%32<16)? (short) 8192 : (short) 0;
            }
            break;

         case MODE_RIPPLE:
            for (i=m_lpsbIn->m_dwPixelOffset; i<(m_lpsbIn->m_dwPixelOffset + m_lpsbIn->m_dwPixelCount); i++)
            {
               int x = (i % m_lpsbIn->m_dwSizeX) - m_lpsbIn->m_dwSizeX/2;
               int y = (i / m_lpsbIn->m_dwSizeX) - m_lpsbIn->m_dwSizeY/2;
               m_lpsbOut->m_pwData[i] = (short)(1024.0*sin ( g_2PI*sqrt((double)x*x + (double)y*y)/200.0 ));
            }
            break;

         case MODE_NOISE:
            for (i=m_lpsbIn->m_dwPixelOffset; i<(m_lpsbIn->m_dwPixelOffset + m_lpsbIn->m_dwPixelCount); i++)
            {
               m_lpsbOut->m_pwData[i] = (short) rand();
            }
            break;
      }
   }


// If we have a double buffer, L2R and R2L, process that part too.
//if ((m_lpsbIn->m_dwFlags & SPM_SDBF_RIGHT2LEFT) && (m_lpsbIn->m_dwFlags & SPM_SDBF_LEFT2RIGHT))
   if ( m_lpsbIn->HasRightToLeftScan() )
   {
      DWORD dwOffsetR2L = m_lpsbIn->m_dwSizeX*m_lpsbIn->m_dwSizeY;
      switch (m_eModeR2L)
      {
         case MODE_SAW:
            for (i=m_lpsbIn->m_dwPixelOffset; i<(m_lpsbIn->m_dwPixelOffset + m_lpsbIn->m_dwPixelCount); i++)
            {
               m_lpsbOut->m_pwData[i + dwOffsetR2L] = (short)(4*(i % (m_lpsbIn->m_dwSizeX/4)));
            }
            break;

         case MODE_SIN:
            for (i=m_lpsbIn->m_dwPixelOffset; i<(m_lpsbIn->m_dwPixelOffset + m_lpsbIn->m_dwPixelCount); i++)
            {
               m_lpsbOut->m_pwData[i + dwOffsetR2L] = (short)(m_lpsbIn->m_dwSizeX * sin (5.0 * g_2PI * (i % m_lpsbIn->m_dwSizeX) / m_lpsbIn->m_dwSizeX));
            }
            break;

         case MODE_NEG:
            for (i=m_lpsbIn->m_dwPixelOffset; i<(m_lpsbIn->m_dwPixelOffset + m_lpsbIn->m_dwPixelCount); i++)
            {
               m_lpsbOut->m_pwData[i + dwOffsetR2L] = (short) -m_lpsbIn->m_pwData[i + dwOffsetR2L];
            }
            break;

         case MODE_ZERO:
            ZeroMemory(m_lpsbOut->m_pwData + m_lpsbIn->m_dwPixelOffset + dwOffsetR2L, m_lpsbIn->m_dwPixelCount * sizeof(short));
            break;

         case MODE_RAMP:
            for (i=m_lpsbIn->m_dwPixelOffset; i<(m_lpsbIn->m_dwPixelOffset + m_lpsbIn->m_dwPixelCount); i++)
            {
               m_lpsbOut->m_pwData[i + dwOffsetR2L] = (short)(i % m_lpsbIn->m_dwSizeX);
            }
            break;

         case MODE_COPY:
            memcpy(m_lpsbOut->m_pwData + m_lpsbIn->m_dwPixelOffset + dwOffsetR2L, m_lpsbIn->m_pwData + m_lpsbIn->m_dwPixelOffset + dwOffsetR2L, m_lpsbIn->m_dwPixelCount * sizeof(short));
            break;

         case MODE_BOX:
            for (i=m_lpsbIn->m_dwPixelOffset; i<(m_lpsbIn->m_dwPixelOffset + m_lpsbIn->m_dwPixelCount); i++)
            {
               int x = i % m_lpsbIn->m_dwSizeX;
               int y = i / m_lpsbIn->m_dwSizeX;
               m_lpsbOut->m_pwData[i + dwOffsetR2L] = (y%32<16)&&(x%32<16)? (short) 8192 : (short) 0;
            }
            break;

         case MODE_RIPPLE:
            for (i=m_lpsbIn->m_dwPixelOffset; i<(m_lpsbIn->m_dwPixelOffset + m_lpsbIn->m_dwPixelCount); i++)
            {
               int x = (i % m_lpsbIn->m_dwSizeX) - m_lpsbIn->m_dwSizeX/2;
               int y = (i / m_lpsbIn->m_dwSizeX) - m_lpsbIn->m_dwSizeY/2;
               m_lpsbOut->m_pwData[i + dwOffsetR2L] = (short)(1024.0*sin ( g_2PI*sqrt((double)x*x + (double)y*y)/200.0 ));
            }
            break;

         case MODE_NOISE:
            for (i=m_lpsbIn->m_dwPixelOffset; i<(m_lpsbIn->m_dwPixelOffset + m_lpsbIn->m_dwPixelCount); i++)
            {
               m_lpsbOut->m_pwData[i + dwOffsetR2L] = (short) rand();
            }
            break;
      }
   }
   
   return TRUE;
}

/*
 * end of file
 */

---