Filter Library

Camera

Interface Physics

CFiltLib.cpp

/*
 * CFiltLib.cpp - AFX extension DLL module main part.
 *
 * This file is part of the Camera Filter Library.
 * Computer Aided Measurement Environment for Realtime Atomic imaging (Camera)
 *
 * Copyright (C) 2004-2006, Leiden Probe Microscopy.
 * Copyright (C) 2000-2004, Universiteit Leiden.
 * Copyright (C) 1999-2000, FOM Institute for Atomic and Molecular Physics, Amsterdam.
 *
 * Authors: M. Seynen (initial version, 03/10/2000), Martin J. Moene
 *
 * $Id: CFiltLib.cpp 508 2007-02-26 10:28:58Z moene $
 */

#include "stdafx.h"                             // for common (pre-compiled) headers
#include <afxdllx.h>                            // for using MFC in a DLL that multiple running applications can share
//#include <cfl/stdafx.h>                         // for common (pre-compiled) headers
#include <cfl/resource.h>                       // for messages and other resources

/*
 * Configuration:
 */
// #define USE_NEW_DEVELOPMENT                     // include/exclude new developments
// #define USE_VISUAL_LEAK_DETECTOR                // for Visual Leak detector

/*
 * End configuration
 */

#if defined( USE_VISUAL_LEAK_DETECTOR )
#include <vld.h>                                // for Visual Leak Detector
#endif

#include <cfl/version.h>                        // for PRODUCT_NAME etc.

#include <cfl/ScanBaseBuffer.h>                 // Filter buffers
#include <cfl/ScanFilter.h>                     // Include overall FilterBaseClass
#include <cfl/ProgressDlg.h>                    // Progress Dialog

#include <cfl/ScanFilterClip.h>                 // Clip Filter
#include <cfl/ScanFilterClad.h>                 // Clad Filter
#include <cfl/ScanFilterShift.h>                // Shift Filter

#include <cfl/ScanFilterMean.h>                 // Mean Filter
#include <cfl/ScanFilterMedian.h>               // Median Filter
#include <cfl/ScanFilterMinimum.h>              // Minimum Filter
#include <cfl/ScanFilterMaximum.h>              // Maximum Filter
#include <cfl/ScanFilterKuwahara.h>             // Kuwahara Filter
#include <cfl/ScanFilterCustom.h>               // Custom Filter
#include <cfl/ScanFilterLinearRegression.h>     // Linear Regression

#include <cfl/ScanFilterThreshold.h>            // General Threshold filter
#include <cfl/ScanFilterBinaryThreshold.h>      // Binary threshold filter

#include <cfl/ScanFilterNull.h>                 // Null Filter (filter template)
#include <cfl/ScanFilterTest.h>                 // TestFilter, our first one in this Lib.

#include <cfl/ScanFilterErosion.h>              // Erosion Filter
#include <cfl/ScanFilterDilation.h>             // Dilation Filter

#include <cfl/ScanFilterDifferential_LbL.h>     // Differential Filter (Line by Line)
#include <cfl/ScanFilterDifferential.h>         // Differential Filter

#include <cfl/ScanFilterBGS_LbL.h>              // Background Subtract (Line)
#include <cfl/ScanFilterBGS_Planar.h>           // Background Subtract (Plane)
#include <cfl/ScanFilterBGS_MCN.h>              // Most Common Normal (MSN) Background Subtraction

#include <cfl/ScanFilterMath.h>                 // Math Filter
#include <cfl/ScanFilterDZ.h>                   // DZ Filter
#include <cfl/ScanFilterNCCFFT.h>               // Fast Normalized Cross-Correlation
// #include <cfl/ScanFilterNCCFFTOld.h>               // Fast Normalized Cross-Correlation
#include <cfl/ScanFilterCrossCorrelate.h>       // Cross-Correlate
#if defined( USE_NEW_DEVELOPMENT )
//#include <cfl/ScanFilterCrossCorrelate2.h>       // Cross-Correlate
#endif

#include <cfl/ScanFilterFFT.h>                  // Fast Fourier Transform
#include <cfl/ScanFilterFFTInverse.h>           // Inverse Fast Fourier Transform

#include <cfl/ScanFilterSwapQuadrants.h>        // Swap Quadrants (for FFT--Correlate--IFFT)
#include <cfl/ScanFilterLowPass.h>              // LowPass Fourier spectrum
#include <cfl/ScanFilterHighPass.h>             // HighPass Fourier spectrum
#include <cfl/ScanFilterAutoCorrelateF.h>       // Auto-Correlate Fourier spectrum
#include <cfl/ScanFilterCrossCorrelateF.h>      // Cross-Correlate Fourier spectrum

#include <cfl/ScanFilterBgsDiff.h>              // On-line Background Subtract plus Differential filter (Frame)
#include <cfl/ScanFilterBgsDiff_LbL.h>          // On-line Background Subtract plus Differential filter (Line)

#include <cfl/CalculatorImageShift.h>           // On-line image stabilization (Frame)

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

/* *
 * \file CFiltLib.cpp
 * \brief AFX Extension Module main part.
 * \author M. Seynen (03/10/2000, Initial version)
 */

/**
 * \addtogroup cfl_cfiltlib AFX Extension DLL module
 * \brief AFX Extension Module main part.
 * \author M. Seynen (03/10/2000, Initial version)
 *
 * Doxygen conversion and update by Martin J. Moene.
 *
 * @{
 */

/**
 * Camera application registry subkey for filter settings.
 */
const char* gCflRegistrySubkey = CFL_REGISTRY_SUBKEY;

/**
 * the product name.
 */
extern LPCTSTR GetFilterLibraryName()
{
   return PRODUCT_NAME;
}

/**
 * the product description.
 */
extern LPCTSTR GetFilterLibraryDescription()
{
   return FILE_DESCRIPTION;
}

/**
 * the product version string.
 */
extern LPCTSTR GetFilterLibraryVersionString()
{
   return COMMENT_STRING;
}

/**
 * structure to hold the state of of MFC extension DLL module.
 *
 * \code
 * struct AFX_EXTENSION_MODULE
 * {
 *    BOOL bInitialized;
 *    HMODULE hModule;
 *    HMODULE hResource;
 *    CRuntimeClass* pFirstSharedClass;
 *    COleObjectFactory* pFirstSharedFactory;
 * };
 *
 * static AFX_EXTENSION_MODULE extensionDLL;
 *
 * extern "C" int APIENTRY
 * DllMain( HINSTANCE hInstance, DWORD dwReason, LPVOID )
 * {
 *    if ( dwReason == DLL_PROCESS_ATTACH )
 *    {
 *       // Extension DLL one-time initialization
 *       if ( !AfxInitExtensionModule( extensionDLL, hInstance ) )
 *          return 0;
 * ...
 * \endcode
 */
static AFX_EXTENSION_MODULE CFiltLibDLL = { NULL, NULL };       // FIXME: remove initializer?

/**
 * the extension's main entry.
 */
extern "C" int APIENTRY DllMain( HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved )
{
   /*
    * Remove this if you use lpReserved
    */

   UNREFERENCED_PARAMETER( lpReserved );

   if ( dwReason == DLL_PROCESS_ATTACH )
   {
      Q_SET_MODULE( _T( "CFiltLib.dll" ) );

      TRACE0( "CFILTLIB.DLL Initializing!\n" );

      /*
       * Extension DLL one-time initialization
       */

      if ( !AfxInitExtensionModule( CFiltLibDLL, hInstance ) )
         return 0;

      // Insert this DLL into the resource chain
      // NOTE: If this Extension DLL is being implicitly linked to by
      //  an MFC Regular DLL (such as an ActiveX Control)
      //  instead of an MFC application, then you will want to
      //  remove this line from DllMain and put it in a separate
      //  function exported from this Extension DLL.  The Regular DLL
      //  that uses this Extension DLL should then explicitly call that
      //  function to initialize this Extension DLL.  Otherwise,
      //  the CDynLinkLibrary object will not be attached to the
      //  Regular DLL's resource chain, and serious problems will
      //  result.

      new CDynLinkLibrary( CFiltLibDLL );
   }
   else if ( dwReason == DLL_PROCESS_DETACH )
   {
      TRACE0( "CFILTLIB.DLL Terminating!\n" );

      /*
       * Terminate the library before destructors are called
       */

      AfxTermExtensionModule( CFiltLibDLL );
   }

   return TRUE;                         // Ok
}

#define EDIT TRUE       ///< has EditModeless()
#define edit FALSE      ///< does not have EditModeless()
#define ONLN TRUE       ///< is online filter
#define onln FALSE      ///< is not online filter
#define VIEW TRUE       ///< is viewing filter
#define view FALSE      ///< is not viewing filter
#define IACT TRUE       ///< is interactive filter
#define iact FALSE      ///< is not interactive filter

/**
 * the scanfilter list.
 */
_tFilterList g_FilterDefTable[] =
{
   // EditModeless
   //    | is online filter
   //    |     | is viewing filter
   //    |     |     | is interactive filter
   //    |     |     |     | menu name                                 | filter name                                   | filter class
   { edit, onln, view, IACT, _T("Clip (crop)")                         , CScanFilterClip::m_lpcsFilterName            , RUNTIME_CLASS(CScanFilterClip)             },
   { edit, onln, view, IACT, _T("Clad...")                             , CScanFilterClad::m_lpcsFilterName            , RUNTIME_CLASS(CScanFilterClad)             },
   { edit, onln, view, IACT, _T("Shift (move)...")                     , CScanFilterShift::m_lpcsFilterName           , RUNTIME_CLASS(CScanFilterShift)            },
   { edit, onln, view, IACT, _T("Clip, clad, shift")           /*---*/ , NULL                                         , NULL                                       },

#if defined( USE_NEW_DEVELOPMENT )
   { edit, onln, view, IACT, _T("Normalize      (not implemented)")    , "X" /* NormalizeImageFilter */               , RUNTIME_CLASS(CScanFilterNull)             },
   { edit, onln, view, IACT, _T("Rescale...     (not implemented)")    , "X" /* RescaleIntensityImageFilter */        , RUNTIME_CLASS(CScanFilterNull)             },
   { edit, onln, view, IACT, _T("Shift Scale... (not implemented)")    , "X" /* ShiftScaleImageFilter */              , RUNTIME_CLASS(CScanFilterNull)             },
   { edit, onln, view, IACT, _T("Sigmoid...     (not implemented)")    , "X" /* SigmoidImageFilter */                 , RUNTIME_CLASS(CScanFilterNull)             },
   { edit, onln, view, IACT, _T("Scale")                       /*---*/ , NULL                                         , NULL                                       },
#endif

   { edit, onln, view, IACT, _T("Binary Threshold...")                 , CScanFilterBinaryThreshold::m_lpcsFilterName , RUNTIME_CLASS(CScanFilterBinaryThreshold)  },
   { edit, onln, view, IACT, _T("General Threshold...")                , CScanFilterThreshold::m_lpcsFilterName       , RUNTIME_CLASS(CScanFilterThreshold)        },
   { edit, onln, view, IACT, _T("Threshold")                   /*---*/ , NULL                                         , NULL                                       },

   { edit, onln, view, IACT, _T("Mean...")                             , CScanFilterMean::m_lpcsFilterName            , RUNTIME_CLASS(CScanFilterMean)             },
   { edit, onln, view, IACT, _T("Median...")                           , CScanFilterMedian::m_lpcsFilterName          , RUNTIME_CLASS(CScanFilterMedian)           },
   { edit, onln, view, IACT, _T("Minimum...")                          , CScanFilterMinimum::m_lpcsFilterName         , RUNTIME_CLASS(CScanFilterMinimum)          },
   { edit, onln, view, IACT, _T("Maximum...")                          , CScanFilterMaximum::m_lpcsFilterName         , RUNTIME_CLASS(CScanFilterMaximum)          },
   { edit, onln, view, IACT, _T("Kuwahara")                            , CScanFilterKuwahara::m_lpcsFilterName        , RUNTIME_CLASS(CScanFilterKuwahara)         },
   { edit, onln, view, IACT, _T("Custom...")                           , CScanFilterCustom::m_lpcsFilterName          , RUNTIME_CLASS(CScanFilterCustom)           },
   { edit, onln, view, IACT, _T("Linear Regression...")                , CScanFilterLinearRegression::m_lpcsFilterName, RUNTIME_CLASS(CScanFilterLinearRegression) },
   { edit, onln, view, IACT, _T("Smooth, Sharpen")             /*---*/ , NULL                                         , NULL                                       },

   { edit, onln, view, IACT, _T("Dilation")                            , CScanFilterDilation::m_lpcsFilterName        , RUNTIME_CLASS(CScanFilterDilation)         },
   { edit, onln, view, IACT, _T("Erosion")                             , CScanFilterErosion::m_lpcsFilterName         , RUNTIME_CLASS(CScanFilterErosion)          },
   { edit, onln, view, IACT, _T("Morphology")                  /*---*/ , NULL                                         , NULL                                       },

   { EDIT, ONLN, VIEW, IACT, _T("Differential (Line)...")              , CScanFilterDifferential_LbL::m_lpcsFilterName, RUNTIME_CLASS(CScanFilterDifferential_LbL) },
   { EDIT, ONLN, VIEW, IACT, _T("Differential (Plane)...")             , CScanFilterDifferential::m_lpcsFilterName    , RUNTIME_CLASS(CScanFilterDifferential)     },
   { edit, onln, view, IACT, _T("Derivative")                  /*---*/ , NULL                                         , NULL                                       },

   { edit, ONLN, VIEW, IACT, _T("Linear Regression (&Line)")           , CScanFilterBGS_LbL::m_lpcsFilterName         , RUNTIME_CLASS(CScanFilterBGS_LbL)          },
   { EDIT, ONLN, VIEW, IACT, _T("Linear Regression (&Plane)...")       , CScanFilterBGS_Planar::m_lpcsFilterName      , RUNTIME_CLASS(CScanFilterBGS_Planar)       },
   { EDIT, ONLN, VIEW, IACT, _T("Most Common Normal...")               , CScanFilterBGS_MCN::m_lpcsFilterName         , RUNTIME_CLASS(CScanFilterBGS_MCN)          },
#if defined( USE_NEW_DEVELOPMENT )
   { edit, onln, view, IACT, _T("Area...           (not implemented)") , "X" /* Manual background subtraction. */     , RUNTIME_CLASS(CScanFilterNull)             },
   { edit, onln, view, IACT, _T("Line path...      (not implemented)") , "X" /* Manual background subtraction. */     , RUNTIME_CLASS(CScanFilterNull)             },
   { edit, onln, view, IACT, _T("Manual...         (not implemented)") , "X" /* Manual background subtraction. */     , RUNTIME_CLASS(CScanFilterNull)             },
#endif
   { edit, onln, view, IACT, _T("Background")                  /*---*/ , NULL                                         , NULL                                       },

   { edit, onln, view, IACT, _T("Math...")                             , CScanFilterMath::m_lpcsFilterName            , RUNTIME_CLASS(CScanFilterMath)             },
   { edit, onln, view, IACT, _T("DZ-Correction...")                    , CScanFilterDZ::m_lpcsFilterName              , RUNTIME_CLASS(CScanFilterDZ)               },
   { edit, onln, view, IACT, _T("Fast Normalized Cross-Correlation..."), CScanFilterNCCFFT::m_lpcsFilterName          , RUNTIME_CLASS(CScanFilterNCCFFT)           },
//   { edit, onln, view, IACT, _T("Fast Normalized Cross-Correlation...  [old development]"), CScanFilterNCCFFTOld::m_lpcsFilterName          , RUNTIME_CLASS(CScanFilterNCCFFTOld)           },
   { edit, onln, view, IACT, _T("Cross-Correlate (Spatial Domain)...") , CScanFilterCrossCorrelate::m_lpcsFilterName  , RUNTIME_CLASS(CScanFilterCrossCorrelate)   },
#if defined( USE_NEW_DEVELOPMENT )
//   { edit, onln, view, IACT, _T("Cross-Correlate (Spatial Domain)...*"), CScanFilterCrossCorrelate2::m_lpcsFilterName  , RUNTIME_CLASS(CScanFilterCrossCorrelate2)   },
#endif
   { edit, onln, view, IACT, _T("Double buffer")               /*---*/ , NULL                                         , NULL                                       },

//    { edit, onln, view, IACT, _T("Fourier &Transform-")                 , CScanFilterFourier::m_lpcsFilterName         , RUNTIME_CLASS(CScanFilterFourier)          },
//    { edit, onln, view, IACT, _T("&Inverse Fourier Transform-")         , CScanFilterInvFourier::m_lpcsFilterName      , RUNTIME_CLASS(CScanFilterInvFourier)       },
   { edit, onln, view, IACT, _T("Fourier &Transform")                  , CScanFilterFFT::m_lpcsFilterName             , RUNTIME_CLASS(CScanFilterFFT)              },
   { edit, onln, view, IACT, _T("&Inverse Fourier Transform")          , CScanFilterFFTInverse::m_lpcsFilterName      , RUNTIME_CLASS(CScanFilterFFTInverse)       },
   { edit, onln, view, IACT, _T("&Swap Quadrants")                     , CScanFilterSwapQuadrants::m_lpcsFilterName   , RUNTIME_CLASS(CScanFilterSwapQuadrants)    },
   { edit, onln, view, IACT, _T("Low-Pass...")                         , CScanFilterLowPass::m_lpcsFilterName         , RUNTIME_CLASS(CScanFilterLowPass)          },
   { edit, onln, view, IACT, _T("High-Pass...")                        , CScanFilterHighPass::m_lpcsFilterName        , RUNTIME_CLASS(CScanFilterHighPass)         },
   { edit, onln, view, IACT, _T("Auto-Correlate")                      , CScanFilterAutoCorrelate::m_lpcsFilterName   , RUNTIME_CLASS(CScanFilterAutoCorrelate)    },
   { edit, onln, view, IACT, _T("Cross-Correlate...")                  , CScanFilterCrossCorrelateF::m_lpcsFilterName , RUNTIME_CLASS(CScanFilterCrossCorrelateF)  },
   { edit, onln, view, IACT, _T("Frequency Domain")            /*---*/ , NULL                                         , NULL                                       },

   { edit, onln, view, IACT, _T("Null Filter...")                      , CScanFilterNull::m_lpcsFilterName            , RUNTIME_CLASS(CScanFilterNull)             },
   { edit, onln, view, IACT, _T("Test Filter...")                      , CScanFilterTest::m_lpcsFilterName            , RUNTIME_CLASS(CScanFilterTest)             },
   { edit, ONLN, VIEW, IACT, _T("Linear Regression + Diff (Line)")     , CScanFilterBgsDiff_LbL::m_lpcsFilterName     , RUNTIME_CLASS(CScanFilterBgsDiff_LbL)      },
   { edit, ONLN, VIEW, IACT, _T("Linear Regression + Diff (Plane)")    , CScanFilterBgsDiff::m_lpcsFilterName         , RUNTIME_CLASS(CScanFilterBgsDiff)          },
//   { edit, onln, view, IACT, _T("More")                      /*---*/ , NULL                                         , NULL                                       },

   { edit, onln, view, iact, _T("Image shift calculator")              , CCalculatorImageShift::m_lpcsFilterName      , RUNTIME_CLASS(CCalculatorImageShift)       },
};

/**
 * the number of scanfilters in the list.
 */
const DWORD g_dwNrOfFiltersInDll = dim( g_FilterDefTable );

/**
 * the number of available filters: online, viewing, other filters and
 * submenu titles.
 */
extern int GetTotalNumberOfFilters()
{
   return g_dwNrOfFiltersInDll;
}

/**
 * the number of filters that implement EditModeless().
 */
extern int GetNumberOfEditModelessFilters()
{
   int count = 0;
   for ( DWORD i = 0; i < g_dwNrOfFiltersInDll; i++ )
   {
      if ( g_FilterDefTable[i].bHasEditModeless )
      {
         ++count;
      }
   }

   return count;
}

/**
 * the number of online filters.
 */
extern int GetNumberOfOnlineFilters()
{
   int count = 0;
   for ( DWORD i = 0; i < g_dwNrOfFiltersInDll; i++ )
   {
      if ( g_FilterDefTable[i].bIsOnlineFilter )
      {
         ++count;
      }
   }

   return count;
}

/**
 * the number of viewing filters.
 */
extern int GetNumberOfViewingFilters()
{
   int count = 0;
   for ( DWORD i = 0; i < g_dwNrOfFiltersInDll; i++ )
   {
      if ( g_FilterDefTable[i].bIsViewingFilter )
      {
         ++count;
      }
   }

   return count;
}

/**
 * the number of filters in the filter menu.
 */
extern int GetNumberOfInteractiveFilters()
{
   int count = 0;
   for ( DWORD i = 0; i < g_dwNrOfFiltersInDll; i++ )
   {
      if ( g_FilterDefTable[i].bIsInteractiveFilter )
      {
         ++count;
      }
   }

   return count;
}

/**
 * obtain all filters: online, viewing and other filters;
 * reports actual number of filters obtained in count.
 */
extern BOOL GetAllFilters( FilterListType* lpList, DWORD& count )
{
   /*
    * count = min( count, g_dwNrOfFiltersInDll )
    */
   count = ( count < g_dwNrOfFiltersInDll ) ? count : g_dwNrOfFiltersInDll;

   DWORD i = 0;
   for ( ; i < count; ++i )
   {
      /*
       * default compiler struct copy:
       */
      lpList[ i ] = g_FilterDefTable[ i ];
   }

   count = i;

   return TRUE;
}

/**
 * obtain filters that implement EditModeless();
 * reports actual number of filters obtained in count.
 */
extern BOOL GetEditModelessFilters( FilterListType* lpList, DWORD& count )
{
   DWORD n = 0;
   for ( DWORD i = 0; i < g_dwNrOfFiltersInDll && n < count; ++i )
   {
      if ( g_FilterDefTable[i].bHasEditModeless )
      {
         /*
          * default compiler struct copy:
          */
         lpList[ n++ ] = g_FilterDefTable[ i ];
      }
   }

   /*
    * report actual number of filters obtained:
    */
   count = n;

   return TRUE;
}

/**
 * obtain online filters;
 * reports actual number of filters obtained in count.
 */
extern BOOL GetOnlineFilters( FilterListType* lpList, DWORD& count )
{
   DWORD n = 0;
   for ( DWORD i = 0; i < g_dwNrOfFiltersInDll && n < count; ++i )
   {
      if ( g_FilterDefTable[i].bIsOnlineFilter )
      {
         /*
          * default compiler struct copy:
          */
         lpList[ n++ ] = g_FilterDefTable[ i ];
      }
   }

   /*
    * report actual number of filters obtained:
    */
   count = n;

   return TRUE;
}

/**
 * obtain viewing filters;
 * reports actual number of filters obtained in count.
 */
extern BOOL GetViewingFilters( FilterListType* lpList, DWORD& count )
{
   DWORD n = 0;
   for ( DWORD i = 0; i < g_dwNrOfFiltersInDll && n < count; ++i )
   {
      if ( g_FilterDefTable[i].bIsViewingFilter )
      {
         /*
          * default compiler struct copy:
          */
         lpList[ n++ ] = g_FilterDefTable[ i ];
      }
   }

   /*
    * report actual number of filters obtained:
    */
   count = n;

   return TRUE;
}

/**
 * obtain interactive filters;
 * reports actual number of filters obtained in count.
 */
extern BOOL GetInteractiveFilters( FilterListType* lpList, DWORD& count )
{
   DWORD n = 0;
   for ( DWORD i = 0; i < g_dwNrOfFiltersInDll && n < count; ++i )
   {
      if ( g_FilterDefTable[i].bIsInteractiveFilter )
      {
         /*
          * default compiler struct copy:
          */
         lpList[ n++ ] = g_FilterDefTable[ i ];
      }
   }

   /*
    * report actual number of filters obtained:
    */
   count = n;

   return TRUE;
}

/**
 * obtain an image shift calculator object.
 */
extern CRuntimeClass* GetImageShiftCalculator()
{
   return RUNTIME_CLASS( CCalculatorImageShift );
}

/// @} cfl_cfiltlib

/*
 * end of file
 */

---