Filter Library

Camera

Interface Physics

ScanFilterFourierBase.cpp

/*
 * ScanFilterFourierBase.cpp - base class for FFT.
 *
 * 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: ScanFilterFourierBase.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/ScanFilterFourierBase.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)

#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_FILTERFOURIERBASE 0   // permanent storage schema version
                                                // serialization
IMPLEMENT_SERIAL( CScanFilterFourierBase, CScanFilter, CFL_SCHEMAVERSION_FILTERFOURIERBASE)

/**
 * constructor.
 */
CScanFilterFourierBase::CScanFilterFourierBase()
{
   ; // do nothing
}

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

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

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

/**
 * build a temporary amplitude buffer (real type).
 */
CScanFilterFourierBase::RealType CScanFilterFourierBase::BuildTmpAmpBuffer(int n1, int n2, BOOL bL2R, BOOL bR2L, FourierElementType** alr, FourierElementType** arl, RealType *dAmpBuffer)
{
   RealType dAmplitute;
   RealType dMax = 0.0;

   /*
    * convert all Real/Img data from alr/arl to the log10(|A|) and store in the AmpBuffer;
    * keep track of biggest value so that we scale the results to owr 16 bit data in a ScanBuffer;
    * swap the quadrants while we go
    */
   for (int y = 0; y < n1 / 2; ++y )
   {
      for ( int x = 0; x < n2 * 2 / 2; x += 2 )
      {
         if ( bL2R )
         {
            //Q0 -> Q2
            //                          dAmplitute = lpm::log10( lpm::sqrt( pow(alr[y][x] , 2.0) + pow(alr[y][x+1] , 2.0) ));
            dAmplitute = lpm::log10( lpm::sqrt( lpm::sqr( alr[y][x] ) + lpm::sqr( alr[y][x+1] ) ) );
            dMax = lpm::absmax( dAmplitute, dMax );
            dAmpBuffer[n2/2 + n2*n1/2 + y*n2 + x/2] = dAmplitute;

            //Q1 -> Q3
            //                          dAmplitute = log10(sqrt( pow(alr[y][x+n2],2.0) + pow(alr[y][x+n2+1] , 2.0) ));
            dAmplitute = lpm::log10( lpm::sqrt( lpm::sqr( alr[y][x+n2] ) + lpm::sqr( alr[y][x+n2+1] ) ) );
            dMax = lpm::absmax( dAmplitute, dMax );
            dAmpBuffer[n2*n1/2 + y*n2 + x/2] = dAmplitute;

            //Q2 -> Q0
            //                          dAmplitute = log10(sqrt( pow(alr[y+n1/2][x+n2],2.0) + pow(alr[y+n1/2][x+n2+1] , 2.0) ));
            dAmplitute = lpm::log10( lpm::sqrt( lpm::sqr( alr[y+n1/2][x+n2] ) + lpm::sqr( alr[y+n1/2][x+n2+1] ) ) );
            dMax = lpm::absmax( dAmplitute, dMax );
            dAmpBuffer[y*n2 + x/2] = dAmplitute;

            //Q3 -> Q1
            //                          dAmplitute = log10(sqrt( pow(alr[y+n1/2][x],2.0) + pow(alr[y+n1/2][x+1] , 2.0) ));
            dAmplitute = lpm::log10( lpm::sqrt( lpm::sqr( alr[y+n1/2][x] ) + lpm::sqr( alr[y+n1/2][x+1] ) ) );
            dMax = lpm::absmax( dAmplitute, dMax );
            dAmpBuffer[n2/2 + y*n2 + x/2] = dAmplitute;
         }

         if ( bR2L )
         {
            //Q0 -> Q2
            //                          dAmplitute = log10(sqrt( pow(arl[y][x] , 2.0) + pow(arl[y][x+1] , 2.0) ));
            dAmplitute = lpm::log10( lpm::sqrt( lpm::sqr( arl[y][x] ) + lpm::sqr( arl[y][x+1] ) ) );
            dMax = lpm::absmax( dAmplitute, dMax );
            dAmpBuffer[n1*n2 + n2/2 + n2*n1/2 + y*n2 + x/2] = dAmplitute;

            //Q1 -> Q3
            //                          dAmplitute = log10(sqrt( pow(arl[y][x+n2],2.0) + pow(arl[y][x+n2+1] , 2.0) ));
            dAmplitute = lpm::log10( lpm::sqrt( lpm::sqr( arl[y][x+n2] ) + lpm::sqr( arl[y][x+n2+1] ) ) );
            dMax = lpm::absmax( dAmplitute, dMax );
            dAmpBuffer[n1*n2 + n2*n1/2 + y*n2 + x/2] = dAmplitute;

            //Q2 -> Q0
            //                          dAmplitute = log10(sqrt( pow(arl[y+n1/2][x+n2],2.0) + pow(arl[y+n1/2][x+n2+1] , 2.0) ));
            dAmplitute = lpm::log10( lpm::sqrt( lpm::sqr( arl[y+n1/2][x+n2] ) + lpm::sqr( arl[y+n1/2][x+n2+1] ) ) );
            dMax = lpm::absmax( dAmplitute, dMax );
            dAmpBuffer[n1*n2 + y*n2 + x/2] = dAmplitute;

            //Q3 -> Q1
            //                          dAmplitute = log10(sqrt( pow(arl[y+n1/2][x],2.0) + pow(arl[y+n1/2][x+1] , 2.0) ));
            dAmplitute = lpm::log10( lpm::sqrt( lpm::sqr( arl[y+n1/2][x] ) + lpm::sqr( arl[y+n1/2][x+1] ) ) );
            dMax = lpm::absmax( dAmplitute, dMax );
            dAmpBuffer[n1*n2 + n2/2 + y*n2 + x/2] = dAmplitute;
         }
      }
   }

   return dMax;
}

/**
 * copy a temporary amplitude buffer to the scanbuffer (scaled).
 */
void CScanFilterFourierBase::CopyAmpBufferToScanBuffer( int n1, int n2, BOOL bL2R, BOOL bR2L, RealType *dAmpBuffer, RealType dMax )
{
   m_lpsbOut->ResizeDataBuffer( CSize( n2, n1 ) );

   // Set output buffer stuff
   RealType dScale = 20000.0 / dMax;
   m_lpsbOut->m_dDataScaleFactor = 1.0 / dScale;
   m_lpsbOut->m_nDataOffset = 0;

   // becase we now user log10 of the amplitude, it is possible that
   // a log10 ( x<=0 ) is in the AmpBuffer (-1#INF)
   // if so, convert this value to the minimum (-20.000);

   if ( bR2L && bL2R )
   {
      for (int i = 0; i < 2 * n1 * n2; ++i )
      {
         m_lpsbOut->m_pwData[i] = ( dAmpBuffer[i] < -100 ) ? (ValueType) -20000 : (ValueType)( dScale * dAmpBuffer[i] );
      }
   }
   else if (bL2R)
   {
      for (int i = 0; i < n1 * n2; ++i )
      {
         m_lpsbOut->m_pwData[i] = ( dAmpBuffer[i] < -100 ) ? (ValueType) -20000 : (ValueType)( dScale * dAmpBuffer[i] );
      }
   }
   else
   {
      for (int i = 0; i < n1 * n2; ++i )
      {
         m_lpsbOut->m_pwData[i] = ( dAmpBuffer[i] < -100 ) ? (ValueType) -20000 : (ValueType)( dScale * dAmpBuffer[i+n1*n2] );
      }
   }
}

/*
 * end of file
 */

---