Filter Library

Camera

Interface Physics

ScanFilterLinearRegression.h

/*
 * ScanFilterLinearRegression.h - determine linear regression parameters of image.
 *
 * 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: Martin J. Moene (original)
 *
 * $Id: ScanFilterLinearRegression.h 339 2006-02-27 12:02:15Z moene $
 */

#ifndef CFL_SCANFILTERLINEARREGRESSION_H
#define CFL_SCANFILTERLINEARREGRESSION_H

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <cfl/ScanFilter.h>             // for base class
#include <cfl/ScanBaseBuffer.h>         // for ValueType
#include <cfl/ToolCilImage.h>           // for Image type and ToImage conversion shim

#include <cil/LinearRegressionImageFilter.h> // for class LinearRegressionImageFilter

/**
 * \addtogroup cfl_filterlinearregression Linear Regression Filter
 * \brief linear regression filter.
 *

<h3>Purpose</h3>
This filter calculates linear regression parameters \f$a\f$, \f$b\f$ and \f$c\f$
for a small area around each pixel of an image.

<h3>Description</h3>
This filter reveals the angles in x- and y-direction and the offset in the
z-direction at the location of each pixel of an image.

For a small area around each image's pixel, the filter determines the plane of
that area expressed as \f$a x + b y + c\f$.

The filter determines the linear regression parameters \f$a\f$, \f$b\f$ and
\f$c\f$ by subtracting \f$a x + b y + c\f$ from each point \f$Z_{x,y}\f$,
where \f$a\f$, \f$b\f$ and \f$c\f$ are such that the error with respect to
the flat plane is minimalized.

See also \ref cfl_filterbgsplanar .

<h3>Algorithm</h3>


\f[
   (a, b, c)_{y_i,x_i} = \textrm{LinReg}( Z(x_i,y_i),
      \textrm{Area}(y_i - \frac{height}{2}, x_i - \frac{width}{2},
                    y_i + \frac{height}{2}, x_i + \frac{width}{2} ) )
\f]

For the pixels of regions that only partly overlap with the image, the value
of the pixel that is nearest to the area's pixel location is used: thus the
value of the pixels at the boundary extend into the border.

\code
   k  k  k

   k [k] k  i  i  i  i  i  i

   k  k  k  i  i  i  i  i  i

     i  i  i  i  i  i  i  i

     i  i  i  i  i  i  i  i

   k: region
   i: image
\endcode

\f$\alpha\f$ and \f$\beta\f$ are calculated as follows.
\f{eqnarray*}
\alpha [\pi] & = & \textrm{atan}\ a \\
\alpha [degrees] & = & \frac{180\ \textrm{atan}\ a}{\pi}
\f}

The linear regression algorithm used is described in a separate booklet 
\ref cfl_alg "[CFLALG]".

<h3>Examples</h3>
Try to find some interesting pictures for most filters.

<h3>Contact</h3>
Dipl.phys. M.J. Rost<br>
Huygens Laboratorium<br>
Universiteit Leiden<br>
Niels Bohrweg 2<br>
2333 CA Leiden, The Netherlands<br>
<br>
Tel: +31 71 5275600<br>
Fax: +31 71 5275404<br>
<br>
E-mail: rost@physics.LeidenUniv.nl<br>
Web: http://www.geocities.com/marcel_rost/<br>

 *
 * @{
 */

/**
 * the linear regression filter type.
 */
typedef cil::Image< CScanBaseBuffer::ValueType >      ImageType;
typedef cil::LinearRegressionImageFilter< ImageType > LinearRegressionImageFilter;
//typedef cil::TLinRegFilter<CScanBaseBuffer::ValueType> CLinRegFilter;

DECLARE_CLASS( CScanFilterLinearRegression );       // create various types

/**
 * \brief linear regression scanfilter.
 *
 *
 * \author Martin J. Moene
 */

class CScanFilterLinearRegression : public CScanFilter
{
public:
   /**
    * the value type.
    */
   typedef CScanBaseBuffer::ValueType value_type;

   /**
    * linear regression parameters to select from.
    */
   typedef LinearRegressionImageFilter::FeatureSelector FeatureSelector;

   ///
   /// \name Construction
   /// @{

   /**
    * default constructor.
    */
   CScanFilterLinearRegression();

   /**
    * destructor
    */
   virtual ~CScanFilterLinearRegression();

   /// @}
   /// \name Camera--Filter Interface
   /// @{

//   virtual BOOL    CanDoPartialData() const;
//   virtual BOOL    CanDoDialogEntry() const;

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

   /**
    * \brief save filter settings e.g. for use with the filterlist window (e.g. via registry);
    * see also ReadFilterSettings().
    */
   virtual void WriteFilterSettings( ) const;

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

   /**
    * set parameters for filter-script execution of filter; 
    * see also CScanFilterNull::SetParameters().
    */
   virtual BOOL SetParameters( LPCTSTR lpParameters );

   /**
    * create filter dialog and pre Apply() filter to view result;
    * see also CScanFilterNull::RunModeless().
    */
   virtual BOOL RunModeless( CWnd *pParentWnd, CDocument *pDoc );

   /**
    * let PreApplyCore() perform the filter pre-processing; catch MFC and std exceptions; 
    * see also Apply().
    */
   virtual BOOL PreApply();

   /**
    * let ApplyCore() perform the filter processing; catch MFC and std exceptions;
    * see also CScanFilterNull::Apply().
    */
   virtual BOOL Apply();

   /**
    * check parameters, take care of a properly sized output buffer,
    * set its name and copy filter parameters;
    * see also ApplyCore().
    */
   virtual BOOL PreApplyCore();

   /**
    * pre-apply and process;
    * see also CScanFilterNull::ApplyCore().
    */
   virtual BOOL ApplyCore();

   /**
    * measure algorithm performance.
    */
   virtual SPerformanceTestResult
                   GetPerformanceTestResult();

   /// @}
   /// \name Predicates
   /// @{

   /// @}
   /// \name Accessors
   /// @{

   /**
    * number of columns in area.
    */
   int MaxCols();

   /**
    * number of columns in area.
    */
   int MaxRows();

   /**
    * number of columns in area.
    */
   int Ncols();

   /**
    * number of rows in area.
    */
   int Nrows();

   /**
    * number of pixels in area.
    */
   int Size();

   /**
    * the angle theta for weighted sum of A.cos(theta) + B.sin(theta).
    */
   double Theta();

   /**
    * the factor to scale Alpha or Beta with.
    */
   double Factor();

   /**
    * the selected linear regression parameter.
    */
   FeatureSelector Parameter();

   /**
    * the selected parameter name.
    */
   CharCptr ParamName();

   /// @}
   /// \name Mutators
   /// @{

   /**
    * set the number of columns in area.
    */
   void Ncols( int ncols );

   /**
    * set the number of rows in area.
    */
   void Nrows( int nrows );

   /**
    * set the angle Theta.
    */
   void Theta ( double theta );

   /**
    * set the factor to scale Alpha or Beta with.
    */
   void Factor( double factor );

   /**
    * select the linear regression parameter to output.
    */
   void Parameter( FeatureSelector p );

   /// @}

protected:
   /**
    * store or retrieve the object's settings;
    * currently filter serialization is not used;
    * see also CScanFilterNull::Serialize().
    */
   virtual void Serialize( CArchive& ar );

   DECLARE_SERIAL( CScanFilterLinearRegression )

public:
   /**
    * filter name
    */
   static LPCTSTR m_lpcsFilterName;

   /**
    * the class short filtername.
    */
   static LPCTSTR m_lpcsShortFilterName;

   /**
    * default X and Y
    */
   static const int    def_iXY;

   /**
    *  default A,B,Alpha,Beta multiplication factor
    */
   static const double def_dFactor;

   /**
    *  default selection of parameter
    */
   static const FeatureSelector def_eParameter;

private:
   /**
    * the number of columns to include (must be odd)
    */
   int m_iSizeX;

   /**
    * the number of rows to include (must be odd)
    */
   int m_iSizeY;

   /**
    *  angle for weighted sum of A and B
    */
   double m_dTheta;

   /**
    * factor to multiply Alpha or Beta with
    */
   double m_dFactor;

   /**
    * the selected parameter
    */
   FeatureSelector m_eParameter;
};

/// @} group cfl_filterlinearregression

/*
 * number of columns in area.
 */
inline int CScanFilterLinearRegression::MaxCols()
{
   return m_lpsbIn->Columns();
}

/*
 * number of columns in area.
 */
inline int CScanFilterLinearRegression::MaxRows()
{
   return m_lpsbIn->Rows();
}

/*
 * number of columns in area.
 */
inline int CScanFilterLinearRegression::Ncols()
{
   return m_iSizeX;
}

/*
 * number of rows in area.
 */
inline int CScanFilterLinearRegression::Nrows()
{
   return m_iSizeY;
}

/*
 * number of pixels in area.
 */
inline int CScanFilterLinearRegression::Size()
{
   return Nrows() * Ncols();
}

/*
 * the angle theta for weighted sum of A.cos(theta) + B.sin(theta).
 */
inline double CScanFilterLinearRegression::Theta()
{
   return m_dTheta;
}

/*
 * the factor to scale Alpha or Beta with.
 */
inline double CScanFilterLinearRegression::Factor()
{
   return m_dFactor;
}

/*
 * the selected linear regression parameter.
 */
inline CScanFilterLinearRegression::FeatureSelector CScanFilterLinearRegression::Parameter()
{
   return m_eParameter;
}

/*
 * set the number of columns in area.
 */
inline void CScanFilterLinearRegression::Ncols( int ncols )
{
   m_iSizeX = ncols;
}

/*
 * set the number of rows in area.
 */
inline void CScanFilterLinearRegression::Nrows( int nrows )
{
   m_iSizeY = nrows;
}

/*
 * set the angle Theta.
 */
inline void CScanFilterLinearRegression::Theta( double theta )
{
   m_dTheta = theta;
}

/*
 * set the factor to scale Alpha or Beta with.
 */
inline void CScanFilterLinearRegression::Factor( double factor )
{
   m_dFactor = factor;
}

/*
 * select the linear regression parameter to output.
 */
inline void CScanFilterLinearRegression::Parameter( FeatureSelector p )
{
   m_eParameter = p;
}

#endif // #ifndef CFL_SCANFILTERLINEARREGRESSION_H

/*
 * end of file
 */

---