Filter Library

Camera

Interface Physics

ScanBaseBuffer.cpp

/*
 * ScanBaseBuffer.cpp - scanbuffer base class.
 *
 * 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: ScanBaseBuffer.cpp 235 2005-06-27 08:59:48Z moene $
 */

/*
 * configuration defines:
 */

/**
 * if USE_OLD_FFTBUFFER_ALLOCATION is defined,
 * - allocate a column with row pointers
 * - allocate buffer for each row
 *
 * if USE_OLD_FFTBUFFER_ALLOCATION is NOT defined,
 * - allocate a column with row pointers
 * - allocate buffer as one block
 */
// #define USE_OLD_FFTBUFFER_ALLOCATION

/*
 * 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 <cfl/ScanBaseBuffer.h>         // header

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

IMPLEMENT_DYNCREATE( CScanBaseBuffer, CObject )

#if defined( USE_OLD_FFTBUFFER_ALLOCATION )

/**
 * allocate 2D buffer.
 */
template< class ElementType >
ElementType** Allocate2D( const int& rows, const int& cols )
{
   typedef ElementType* ElementTypePtr;

   ElementTypePtr *ii = (ElementTypePtr*) calloc( rows, sizeof(ElementTypePtr) );

   for ( int i = 0; i < rows; i++ )
   {
      /*
       * every line, has x data (Re,Im):
       */
      ii[i] = (double *) calloc( cols, sizeof(ElementType) );
   }

   return ii;
}

/**
 * delete 2D buffer.
 */
template < class ElementType >
void Delete2D( ElementType**& ii, const int& rows )
{
   /*
    * free 2D buffer, if any:
    */
   if ( 0 != ii )
   {
      for ( int y = 0; y < rows; ++y )
      {
         free( ii[ y ] );
      }

      free( ii ); ii = 0;
   }
}

#else

/**
 * allocate 2D buffer.
 */
template< class ElementType >
ElementType** Allocate2D( const int& rows, const int& cols )
{
   typedef ElementType* ElementTypePtr;

   ElementTypePtr *ii, i;

   if ( 0 == ( ii = new ElementTypePtr[ rows ] ) )
   {
      return 0;
   }

   if ( 0 == ( i = new ElementType[ rows * cols ] ) )
   {
      return 0;
   }

   ii[0] = i;

   for ( int j = 1; j < rows; ++j )
   {
      ii[j] = &i[ cols * j ];
   }

   return ii;
}


/**
 * delete 2D buffer.
 */
template < class ElementType >
void Delete2D( ElementType**& ii )
{
   if ( 0 != ii )
   {
      delete[] ii[0];
      delete[] ii;
      
      ii = 0;
   }
}

#endif

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

   ReleaseAllBuffers();
}

/**
 * constructor; \todo m_eStatus set to SB_NOTLOADED, so, when will it be SB_NEW ??
 */
CScanBaseBuffer::CScanBaseBuffer()
{
//   Q_LOG( "CScanBaseBuffer::CScanBaseBuffer()" );

   /*
    * public members:
    */
   m_dwFlags               = 0;         // FlagType
   m_dwSizeX               = 0;         // SizeType
   m_dwSizeY               = 0;         // SizeType
   m_dwPixels              = 0;         // SizeType
   m_pwData                = NULL;      // Pointer
   m_pdFourierL2R          = NULL;      // double**
   m_pdFourierR2L          = NULL;      // double**
   m_csBufferName          = "";        // CString
   m_csDataName            = "";        // CString
   m_csDataUnit            = "";        // CString
   m_dDataScaleFactor      = 0;         // double
   m_nDataOffset           = 0;         // int
   m_dwParameterMask       = 0;         // MaskType
   m_dSlopeX               = 0;         // double
   m_dSlopeY               = 0;         // double
   m_dAvg                  = 0;         // double
   m_nMinZ                 = 0;         // int
   m_nMaxZ                 = 0;         // int
   m_dSecMom               = 0;         // double
   m_dwPixelOffset         = 0;         // SizeType
   m_dwPixelCount          = 0;         // SizeType
   m_dXStepSize            = 0;         // double
   m_dYStepSize            = 0;         // double
   m_dwOrgScanXSize        = 0;         // SizeType
   m_dwOrgScanYSize        = 0;         // SizeType
   m_dScanAngle            = 0;         // double

   /*
    * protected members:
    */
   m_eStatus               = SB_NOTLOADED; // StatusType        // FIXME: what should it be?
   m_dwMemoryAllocated     = 0;         // SizeType
   m_liRAWIndex.QuadPart   = 0;         // LARGE_INTEGER
   m_liEditIndex.QuadPart  = 0;         // LARGE_INTEGER
}

/**
 * shallow copy-assignment constructor; do not copy data and fourier buffers.
 */
CScanBaseBuffer::CScanBaseBuffer( const Self& rhs )
{
//   Q_LOG( "CScanBaseBuffer::CScanBaseBuffer(const Self& rhs)" );

   ReleaseAllBuffers();
   Copy( rhs );
}

/**
 * shallo copy-assignment; do not copy data and fourier buffers.
 */
CScanBaseBuffer::Self& CScanBaseBuffer::operator= ( const Self& rhs )
{
//   Q_LOG( "CScanBaseBuffer::operator=(const Self& rhs)" );

   if ( this != &rhs )
   {
      ReleaseAllBuffers();
      Copy( rhs );
   }

   return *this;
}

/**
 * shallow copy; set data and fourier buffer pointers to 0; 
 * \todo set mdwFlags to 0?.
 */
void CScanBaseBuffer::Copy( const Self& rhs )
{
//   Q_LOG( "CScanBaseBuffer::Copy(const Self& rhs)" );

   /*
    * public members:
    */
   m_dwFlags               = rhs.m_dwFlags;             // FlagType
   m_dwSizeX               = rhs.m_dwSizeX;             // SizeType
   m_dwSizeY               = rhs.m_dwSizeY;             // SizeType
   m_dwPixels              = rhs.m_dwPixels;            // SizeType
   m_pwData                = NULL;                      // Pointer
   m_pdFourierL2R          = NULL;                      // double**
   m_pdFourierR2L          = NULL;                      // double**
   m_csBufferName          = rhs.m_csBufferName;        // CString
   m_csDataName            = rhs.m_csDataName;          // CString
   m_csDataUnit            = rhs.m_csDataUnit;          // CString
   m_dDataScaleFactor      = rhs.m_dDataScaleFactor;    // double
   m_nDataOffset           = rhs.m_nDataOffset;         // int
   m_dwParameterMask       = 0;                         // MaskType: recalculate
//   m_dwParameterMask       = rhs.m_dwParameterMask;     // MaskType
   m_dSlopeX               = rhs.m_dSlopeX;             // double
   m_dSlopeY               = rhs.m_dSlopeY;             // double
   m_dAvg                  = rhs.m_dAvg;                // double
   m_nMinZ                 = rhs.m_nMinZ;               // int
   m_nMaxZ                 = rhs.m_nMaxZ;               // int
   m_dSecMom               = rhs.m_dSecMom;             // double
   m_dwPixelOffset         = rhs.m_dwPixelOffset;       // SizeType
   m_dwPixelCount          = rhs.m_dwPixelCount;        // SizeType
   m_dXStepSize            = rhs.m_dXStepSize;          // double
   m_dYStepSize            = rhs.m_dYStepSize;          // double
   m_dwOrgScanXSize        = rhs.m_dwOrgScanXSize;      // SizeType
   m_dwOrgScanYSize        = rhs.m_dwOrgScanYSize;      // SizeType
   m_dScanAngle            = rhs.m_dScanAngle;          // double

   /*
    * protected members:
    *
    * Note: the application sets the status of the output buffer to SB_NEW,
    * so it knows it has to write the data to disk yet: we leave it alone here.
    */
   // DO NOT ASSIGN TO m_eStatus = rhs.m_eStatus;       // StatusType

   m_dwMemoryAllocated     = 0;                         // SizeType
   m_liRAWIndex.QuadPart   = 0;                         // LARGE_INTEGER
   m_liEditIndex.QuadPart  = 0;                         // LARGE_INTEGER
}

/*
 * clear data buffer.
 */
void CScanBaseBuffer::ClearDataBuffer()
{
//   Q_LOG( "CScanBaseBuffer::ClearDataBuffer()" );

   Q_ASSERT( NULL != m_pwData && "ensure buffer set" );

   /*
    * only clear used part (m_dwPixels), not whole buffer(m_dwMemoryAllocated):
    */
   ZeroMemory( m_pwData, m_dwPixels * sizeof( ValueType ) );
}

/*
 * clear fourier buffer.
 */
void CScanBaseBuffer::ClearFourierBuffer()
{
//   Q_LOG( "CScanBaseBuffer::ClearFourierBuffer()" );

#if defined( USE_OLD_FFTBUFFER_ALLOCATION )
   /*
    * in this case only the line buffer are contiguous:
    */
   if ( 0 != m_pdFourierL2R )   // if it exists
   {
      for ( int row = 0; row < GetRowsForFFT(); ++row )
      {
         ZeroMemory( m_pdFourierL2R[row], 2 * GetColumnsForFFT() * sizeof( RealType ) );
      }
   }

   if ( 0 != m_pdFourierR2L )   // if it exists
   {
      for ( int row = 0; row < GetRowsForFFT(); ++row )
      {
         ZeroMemory( m_pdFourierR2L[row], 2 * GetColumnsForFFT() * sizeof( RealType ) );
      }
   }
#else
   /*
    * in this case both buffers are contiguous:
    */
   if ( 0 != m_pdFourierL2R )   // if it exists
   {
      ZeroMemory( m_pdFourierL2R[0], GetRowsForFFT() * 2 * GetColumnsForFFT() * sizeof( FourierElementType ) );
   }

   if ( 0 != m_pdFourierR2L )   // if it exists
   {
      ZeroMemory( m_pdFourierR2L[0], GetRowsForFFT() * 2 * GetColumnsForFFT() * sizeof( FourierElementType ) );
   }
#endif
}

/*
 * allocate data buffer, but not fourier buffers.
 */
void CScanBaseBuffer::AllocateDataBuffer( SizeType extra /* = 0 */ )
{
//   Q_LOG( "CScanBaseBuffer::AllocateDataBuffer()" );

   Q_ASSERT( NULL == m_pwData && "ensure buffer not set" );

   SizeType newSize = m_dwPixels + extra;

   if ( 0 == newSize )
   {
      m_pwData = NULL;
   }
   else
   {
      try
      {
         m_pwData = new ValueType[ newSize ];
      }
      catch ( std::bad_alloc )     // or std::exception
      {
//            Q_LOG( "CScanBaseBuffer::Allocate(): memory allocation failed" );
         return ;
      }

      ZeroMemory( m_pwData, newSize * sizeof( ValueType ) );
   }

   m_dwMemoryAllocated = newSize;
}

/**
 * create the fourier buffer(s) based on the current databuffer size.
 */
BOOL CScanBaseBuffer::CreateFourierBuffer()
{
   AllocateFourierBuffer();

   return 0 != m_pdFourierL2R ; // and ...
}

/**
 * delete the fourier buffer(s).
 */
BOOL CScanBaseBuffer::DeleteFourierBuffer()
{
   ReleaseFourierBuffer();
   
   return 0 == m_pdFourierL2R && 0 == m_pdFourierR2L;
}

/**
 * allocate fourier buffer.
 */
void CScanBaseBuffer::AllocateFourierBuffer()
{
//   Q_LOG( "CScanBaseBuffer::AllocateFourierBuffer()" );

   if ( HasLeftToRightScan() && 0 == m_pdFourierL2R )
   {
      m_pdFourierL2R = Allocate2D< FourierElementType >( GetRowsForFFT(), 2 * GetColumnsForFFT() );
   }

   if ( HasRightToLeftScan() && 0 == m_pdFourierR2L )
   {
      m_pdFourierR2L = Allocate2D< FourierElementType >( GetRowsForFFT(), 2 * GetColumnsForFFT() );
   }
   
   ClearFourierBuffer();
}

/*
 * release all buffers.
 */
void CScanBaseBuffer::ReleaseAllBuffers()
{
//   Q_LOG( "CScanBaseBuffer::ReleaseAllBuffers()" );

   ReleaseDataBuffer();
   ReleaseFourierBuffer();
}

/*
 * release data buffer.
 */
void CScanBaseBuffer::ReleaseDataBuffer()
{
//   Q_LOG( "CScanBaseBuffer::ReleaseDataBuffer()" );

   /*
    * delete data buffer:
    */
   if ( /* m_dwMemoryAllocated && */ m_pwData )
   {
      delete[] m_pwData; m_pwData = NULL;
      m_dwMemoryAllocated = 0;
   }
}

/*
 * release fourier buffer.
 */
void CScanBaseBuffer::ReleaseFourierBuffer()
{
//   Q_LOG( "CScanBaseBuffer::ReleaseFourierBuffer()" );

#if defined( USE_OLD_FFTBUFFER_ALLOCATION )
   Delete2D< FourierElementType >( m_pdFourierL2R, Rows() );
   Delete2D< FourierElementType >( m_pdFourierR2L, Rows() );
#else
   Delete2D< FourierElementType >( m_pdFourierL2R );
   Delete2D< FourierElementType >( m_pdFourierR2L );
#endif
}

/**
 * create this buffer for output based on the given input buffer;
 * \note remember to add new member variables.
 */
BOOL CScanBaseBuffer::CreateOutputBufferFor( const Self& input, SizeType extra /* = 0 */ )
{
//   Q_LOG( "CScanBaseBuffer::CreateOutputBufferFor()" );

   /*
    * skip rest if buffers are already correctly setup:
    */
   if ( IsUsableOutputBufferFor( input ) )
   {
      return TRUE;
   }

   /*
    * release my buffers, shallow copy from input buffer:
    */
   ReleaseAllBuffers();
   Copy( input );

   /*
    * allocate new data buffer:
    */
   AllocateDataBuffer( extra );

   /*
    * true if valid buffer present:
    */
   return 0 != m_pwData;
}

/**
 * resize this data buffer to the given size, on reallocation add extra elements.
 */
BOOL CScanBaseBuffer::ResizeDataBuffer( const CSize& size, SizeType extra /* = 0 */ )
{
//   Q_LOG( "CScanBaseBuffer::ResizeDataBuffer()" );

   /*
    * return if uchanged:
    */
   if ( m_dwSizeX == static_cast<SizeType>( size.cx ) && m_dwSizeY == static_cast<SizeType>( size.cy ) )
   {
      return TRUE;
   }

   /*
    * store new x- and y-size and number of pixels:
    */
   m_dwSizeX       = size.cx;
   m_dwSizeY       = size.cy;
   m_dwPixelOffset = 0;
   m_dwPixelCount  = m_dwSizeX * m_dwSizeY;
   m_dwPixels      = IsBidirectionalScan() ? 2 * m_dwPixelCount : m_dwPixelCount;

   /*
    * return if buffer is large enough:
    */
   if ( m_dwPixels <= m_dwMemoryAllocated )
   {
      return TRUE;
   }

   /*
    * release fourier buffer and data buffer, allocate new buffer:
    */
//   Q_LOG( "CScanBaseBuffer::ResizeDataBuffer(): release databuffer and allocate new buffer" );

   ReleaseFourierBuffer(     );
   ReleaseDataBuffer (       );
   AllocateDataBuffer( extra );

   /*
    * true if valid buffer present:
    */
   return 0 != m_pwData;
}

#pragma warning( push, 3 )              // disable unreferenced parameter warning

/**
 * true if buffer has the right size and settings to use as output buffer
 * for the given input buffer.
 */
BOOL CScanBaseBuffer::IsUsableOutputBufferFor( const Self& input )
{
//   Q_LOG( "CScanBaseBuffer::IsUsableOutputBufferFor()" );

   return FALSE;
}

#pragma warning( pop )

/**
 * allocate fourier buffer based on the current databuffer size and
 * copy contents from other buffer.
 */
BOOL CScanBaseBuffer::CopyFourierBufferFrom( const Self& other )
{
   if ( FALSE == CreateFourierBuffer() )
   {
      return FALSE;
   }

#if defined( USE_OLD_FFTBUFFER_ALLOCATION )
   /*
    * in this case only the line buffer are contiguous:
    */
   if ( 0 != m_pdFourierL2R )   // if it exists
   {
      for ( int row = 0; row < GetRowsForFFT(); ++row )
      {
         CopyMemory(
            this->m_pdFourierL2R[row],                  // destination
            other.m_pdFourierL2R[row],                  // source
            2 * GetColumnsForFFT() * sizeof( FourierElementType ) // bytes
      }
   }

   if ( 0 != m_pdFourierR2L )   // if it exists
   {
      for ( int row = 0; row < GetRowsForFFT(); ++row )
      {
         CopyMemory(
            this->m_pdFourierR2L[row],                  // destination
            other.m_pdFourierR2L[row],                  // source
            2 * GetColumnsForFFT() * sizeof( FourierElementType ) // bytes
      }
   }
#else
   /*
    * in this case both buffers are contiguous:
    */
   if ( 0 != m_pdFourierL2R && 0 != other.m_pdFourierL2R )
   {
      CopyMemory(
         this->m_pdFourierL2R[0],                                // destination
         other.m_pdFourierL2R[0],                                // source
         GetRowsForFFT() * 2 * GetColumnsForFFT() * sizeof( FourierElementType ) // bytes
      );
   }

   if ( 0 != m_pdFourierR2L && 0 != other.m_pdFourierR2L )
   {
      CopyMemory(
         this->m_pdFourierR2L[0],                                // destination
         other.m_pdFourierR2L[0],                                // source
         GetRowsForFFT() * 2 * GetColumnsForFFT() * sizeof( FourierElementType ) // bytes
      );
   }
#endif

   return TRUE;
}

// -----------------------------------------------------------------------

/*
 * make sure a buffer of appropriate size is available; return true on success.
 */
BOOL CScanBaseBuffer::CheckAndSetBufferSize()
{
   /*
    * allocate new buffer if size does not match:
    */
   if ( m_dwPixels && ( m_dwMemoryAllocated != m_dwPixels ) )
   {
      // delete previous buffer, if any:

      if ( m_pwData )
      {
         delete m_pwData;
      }

      // allocate new byffer and initialize it to zero and set check:

      m_pwData = new ValueType[ m_dwPixels ];

      ZeroMemory( m_pwData, m_dwPixels * sizeof( ValueType ) );

      m_dwMemoryAllocated = m_dwPixels;
   }

   /*
    * true if valid buffer present:
    */
   return ( m_pwData != NULL );
}

/*
 * end of file
 */

---