GradientGauss.hh

/*
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
  Multimediale Systeme der Informationsverarbeitung
  Institut fuer Informatik
  Christian-Albrechts-Universitaet Kiel


BIAS is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.

BIAS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/


#ifndef __GradientGauss_hh__
#define __GradientGauss_hh__

#include "FilterNTo2N.hh"
#include "Convolution.hh"

#include <Base/Math/Vector3.hh>

  // the debugfasgs are defined in Convolution.hh
  // #define D_GRADGAUSS_KERNEL 0x00000001

namespace BIAS {

  /** @class GradientGauss
      @ingroup g_filter
      @brief gradient calculation with separated gauss masks
      @author woelk 09/2004 */
  template <class InputStorageType, class OutputStorageType> 
  class BIASFilter_EXPORT GradientGauss : public FilterNTo2N<InputStorageType, OutputStorageType>
  {
  public:
    GradientGauss();
    GradientGauss(const GradientGauss<InputStorageType, OutputStorageType>& other);
    virtual ~GradientGauss();

    /** returns a 2 channel image containig gx and gy 
        @author woelk 12/2004, untested */
    virtual int Filter(const Image<InputStorageType>& src, 
                       Image<OutputStorageType>& grad);

    virtual int Filter(const Image<InputStorageType>& src, 
                       Image<OutputStorageType>& gx,
                       Image<OutputStorageType>& gy);

    virtual int Filter(const Image<InputStorageType>& src, 
                       Image<OutputStorageType>& gx,
                       Image<OutputStorageType>& gy, 
                       Image<OutputStorageType>& absg);

    virtual FilterNTo2N<InputStorageType, OutputStorageType>* Clone() const
    { return new GradientGauss<InputStorageType, OutputStorageType>(*this); }
    
    ////////////////////////////////////////////////////////////////////////

    inline void SetGradGaussSigma(const double sigma)
    { _GradGaussSigma=sigma; }

    inline double GetGradGaussSigma() const { return _GradGaussSigma; }

    inline void SetGradGaussRatio(const double ratio)
    { _GradGaussRatio=ratio; }

    inline double GetGradGaussRatio() const { return _GradGaussRatio; }

    inline void PrintKernel() const
    { _Conv.PrintKernel(); }

  protected:
    /// the parameters
    double _GradGaussSigma, _GradGaussRatio;
    /// the parameters at the time of the last call
    double _LastSigma, _LastRatio;
    /// computation object to execute the convolution
    Convolution<InputStorageType, OutputStorageType> _Conv;

    /** Fills _HVec with gaussian function and _VVec with derivative of 
        gaussian function with standard deviation Sigma. The size of _HVec 
        and _VVec is calculated by using Ration. The Gaussian function is 
        truncated, when the ration between biggest and smalles entry falls
        below Ratio.
        @author woelk 09/2004 */
    void _CalculateKernels(double Sigma, double Ratio);

    virtual void GetBordersValid_(int& border_x, int &border_y) const;

  }; // class


} // namsepace

#endif // __GradientGauss_hh__