GradientSobel3x3.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 __GradientSobel3x3_hh__
#define __GradientSobel3x3_hh__

#include "FilterNTo2N.hh"

#include <Base/Math/Vector3.hh>
#include "Convolution.hh"


namespace BIAS {

  /** @class GradientSobel3x3
      @ingroup g_filter
      @brief gradient calculation with sobel 3 by 3 masks

      calculates the gradient using the sobel operators<br>
           -1 0 1         -1 -2 -1
      WE:  -2 0 2    NS:   0  0  0
           -1 0 1          1  2  1

      They can be separated into:

      WE: vh = (-1, 0, 1) and vv = (1, 2, 1)^T
      
      NS: vh = (1, 2, 1) and vv = (-1, 0, 1)^T

      @author woelk 09/2004 */
  template <class InputStorageType, class OutputStorageType> 
  class BIASFilter_EXPORT GradientSobel3x3 : public FilterNTo2N<InputStorageType,
                                              OutputStorageType>
  {
  public:
    GradientSobel3x3();
    GradientSobel3x3(const GradientSobel3x3<InputStorageType, OutputStorageType>& other);
    virtual ~GradientSobel3x3();

    /** returns a 2 channel image containing 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 GradientSobel3x3<InputStorageType, OutputStorageType>(*this); }

  protected:
    /// @brief sets the sobel kernel for the convolution object
    void InitKernel_();

    /// computation object to execute the convolution
    Convolution<InputStorageType, OutputStorageType> _Conv;

    /// uses CONV_FLOAT for calculation
    int Sobel3x3GreyValidFloat_(const Image<InputStorageType>& src,
                                Image<OutputStorageType>& gWE,
                                Image<OutputStorageType>& gNS);

    /// uses CONV_INT for calculation
    int Sobel3x3GreyValidInt_(const Image<InputStorageType>& src,
                              Image<OutputStorageType>& gWE,
                              Image<OutputStorageType>& gNS);

    /** Repeats the border pixel infinitly in direction perpendicular to 
        the border to achieve destination image ROIs of same size as 
        source image ROIs. Untested !! 
        @author woelk 07/2005 */
    int Sobel3x3GreySameFloat_(const Image<InputStorageType>& src,
                               Image<OutputStorageType>& gWE,
                               Image<OutputStorageType>& gNS);

    CONV_FLOAT **_fwork, **_fwork2;
    CONV_INT **_iwork, **_iwork2;

    int _InternalMemWidth;
    int _InternalMemHeight;

    void _DeleteInternalMem();
    /** deletes _work1 and _work2 and sets _InternalMemSize */
    void _AllocInternalMem(const int width, const int height);

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

    // shrinks the roi according to filter size
    void ShrinkROI_(ROI *roi) const;

  }; // class

} // namsepace

#endif // __GradientSobel3x3_hh__