Filter Library

Camera

Interface Physics

ScanFilterSwapQuadrants.cpp

/*
 * ScanFilterSwapQuadrants.cpp - swap quadrants.
 *
 * 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: ScanFilterSwapQuadrants.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/ScanFilterSwapQuadrants.h>// this filter's header

#pragma warning( disable: 4018 4100 4116 4146 4244 4663)
#include <cil/Math.h>                   // for cil::min()
#pragma warning( default: 4018 4100 4116 4146 4244 4663)

// #pragma warning( disable : 4663 )       // template<> Class<type>
// #include <limits>                       // for numeric_limits<>
// #pragma warning( default : 4663 )

#undef min                              // use cil::min instead of macro
#undef max                              // use cil::max instead of macro

/*
 * configuration defines:
 */

// currently none

/*
 * end of configuration defines.
 */

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

#define CFL_SCHEMAVERSION_FILTERIFFT 0  // permanent storage schema version
                                        // this filter's name
LPCTSTR CScanFilterSwapQuadrants::m_lpcsFilterName = _T("Swap-Quadrants");
                                        // this filter's short name
LPCTSTR CScanFilterSwapQuadrants::m_lpcsShortFilterName = _T( "SwapQ" );
                                        // serialization
IMPLEMENT_SERIAL( CScanFilterSwapQuadrants, CScanFilter, CFL_SCHEMAVERSION_FILTERIFFT)

/**
 * constructor.
 */
CScanFilterSwapQuadrants::CScanFilterSwapQuadrants()
{
   m_csFilterName = m_lpcsFilterName;
}

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

/**
 * no dialog.
 */
BOOL CScanFilterSwapQuadrants::CanDoDialogEntry() const
{
   return FALSE;
}

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

   if ( ar.IsStoring() )
   {
      ; // do nothing
   }
   else
   {
      ; // do nothing
   }
};

/**
 * no parameters.
 */
#pragma warning( push )
#pragma warning( disable : 4100 )       // unreferenced formal parameter

BOOL CScanFilterSwapQuadrants::SetParameters(LPCTSTR lpParameters)
{
   return TRUE;
}

#pragma warning( pop )

/*
 * no parameters.
 */
LPCTSTR CScanFilterSwapQuadrants::GetParameters() const
{
   return NULL;
}

/**
 * check parameters, take care of a properly sized output buffer,
 * set its name and copy filter parameters and process;
 * see also CScanFilterNull::ApplyCore().
 */
BOOL CScanFilterSwapQuadrants::Apply()
{
//   Q_LOG( _T("CScanFilterCrossCorrelate::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;

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

   m_lpsbOut->m_csBufferName = m_lpsbIn->m_csBufferName + _T(" - ") + m_lpcsShortFilterName;
   m_lpsbOut->m_csDataName.Format(_T("%s(%s)"), m_lpcsShortFilterName, m_lpsbIn->m_csDataName );

   return Compute();
}

/**
 * compute the desired result.
 */
BOOL CScanFilterSwapQuadrants::Compute()
{
//   Q_LOG( _T("CScanFilterSwapQuadrants::Compute()") );

   ASSERT( m_lpsbIn );
   ASSERT( m_lpsbOut );

   /*
    * perform the left-right and right-left transformations:
    */
   if ( m_lpsbIn->HasLeftToRightScan() )
   {
      CopyPart   ( m_lpsbIn->Data() , m_lpsbOut->Data(), m_lpsbOut->GetFrameSize() );
      ComputePart( m_lpsbOut->Data(), m_lpsbOut->Rows(), m_lpsbOut->Columns()     );
   }

   if ( m_lpsbIn->HasRightToLeftScan() )
   {
      ConstPointer pIn  = m_lpsbIn->Data()  + m_lpsbIn->GetFrameSize() ;
      Pointer      pOut = m_lpsbOut->Data() + m_lpsbOut->GetFrameSize();

      CopyPart   ( pIn , pOut, m_lpsbOut->GetFrameSize()         );
      ComputePart( pOut, m_lpsbOut->Rows(), m_lpsbOut->Columns() );
   }

   return TRUE;
}

/**
 * copy a frame.
 */
void CScanFilterSwapQuadrants::CopyPart( ConstPointer pIn, Pointer pOut, SizeType elements )
{
   CopyMemory( pOut, pIn, elements * sizeof( ValueType ) );
}

/**
 * compute a frame in-place; intended to only swap even x even matrices.
 */
void CScanFilterSwapQuadrants::ComputePart( Pointer pFrame, const SizeType& nrow, const SizeType& ncol )
{
   /*
    * ensure even x even:
    */
//   assert( 0 == nrow % 2 );
//   assert( 0 == ncol % 2 );

   SizeType hrow = nrow / 2;           // half row
   SizeType hcol = ncol / 2;           // half column
   SizeType hsiz = hrow * ncol;        // half size

   for ( SizeType y = 0; y < hrow; ++y )
   {
      Pointer ptop = pFrame + y * ncol;
      Pointer pbot = ptop   + hsiz;

      for ( SizeType left = 0; left < hcol; ++left )
      {
         SizeType right = hcol + left;

         //          top--left  bottom--right
         lpm::swap( ptop[ left ], pbot[ right ] );
         lpm::swap( pbot[ left ], ptop[ right ] );
      }  //        bottom--left     top--right
   }
}

/*
 * end of file
 */

---