GradientSimple.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 __GradientSimple_hh__
#define __GradientSimple_hh__

#include "FilterNTo2N.hh"

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


namespace BIAS {

  /** @class GradientSimple
      @ingroup g_filter
      @brief simple gradient calculation 
      gx(x,y) = I(x+1,y) - I(x-1,y)
      gy(x,y) = I(x,y+1) - I(x,y-1)

      weights (not filter mask, ->reflection!) are
      -                            -1
      - WE:   -1 0 1          NS:   0
      -                             1

      The main interface Filter dispatches: If there is a fast version, it
      is called, otherwise Filter calls the generic convolution.
      @author koeser 04/2005 */
  template <class InputStorageType, class OutputStorageType> 
  class BIASFilter_EXPORT GradientSimple : public FilterNTo2N<InputStorageType,
                                            OutputStorageType>
  {
  public:
    GradientSimple(bool BuildPCM = false);
    GradientSimple(const GradientSimple<InputStorageType, OutputStorageType>& other);
    virtual ~GradientSimple();

    /** 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 GradientSimple<InputStorageType, OutputStorageType>(*this); }


    void PolarTransform(Image<OutputStorageType>& gx, 
                        Image<OutputStorageType>& gy, 
                        Image<float>& magnitude, 
                        Image<float>& phase);
    
    /** @brief if true, we use a filter of [1 -1] otherwise [1 0 -1]

    If true we get a better spatial resolution of gradients, however, the
    result is shifted by 0.5;0.5 pixels. Take care of noise in your input data.
    @author koeser 
    @date 03/2006 */
    void UseDirectNeighbors(bool UseDirectNeighbors) {
      if (UseDirectNeighbors != useDirectNeighbors_) {
        useDirectNeighbors_ = UseDirectNeighbors;
        InitKernel_();
      }      
    }
   
  protected:

    /// set up pRadius and pAngle for polar coordinate transformation
    void BuildPolarCoordinateMap_();


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

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

    /** @brief loop unrolled fast float version for [1 0 -1] */
    int SimpleGreyValidFloat_(const Image<InputStorageType>& src,
                              Image<OutputStorageType>& gWE,
                              Image<OutputStorageType>& gNS);

    /** @brief loop unrolled fast int version [1 0 -1] */
    int SimpleGreyValidInt_(const Image<InputStorageType>& src,
                            Image<OutputStorageType>& gWE,
                            Image<OutputStorageType>& gNS);

    /** @brief loop unrolled fast float version [1 -1]*/
    int DirectNeighborsGreyValidFloat_(const Image<InputStorageType>& src,
                                       Image<OutputStorageType>& gWE,
                                       Image<OutputStorageType>& gNS);

    /** @brief loop unrolled fast int version [1 -1] */
    int DirectNeighborsGreyValidInt_(const Image<InputStorageType>& src,
                                     Image<OutputStorageType>& gWE,
                                     Image<OutputStorageType>& gNS);
 
    virtual void GetBordersValid_(int &border_x, int &border_y) const;

    /// polar coordinate transformation for char values
    float **pRadius_, **pAngle_;
     
    /// if true, we use a filter of [-1 1] otherwise [-1 0 1]
    bool useDirectNeighbors_;

  }; // class

} // namsepace

#endif // __GradientSimple_hh__