HessianSimple.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 __HessianSimple_hh__
#define __HessianSimple_hh__

#include "FilterNTo3N.hh"

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


namespace BIAS {

  /** @class HessianSimple
      @ingroup g_filter
      @brief simple hessian calculation 
      hxx(x,y) = Hessian in x direction
      hyy(x,y) = Hessian in y direction

      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 HessianSimple : public FilterNTo3N<InputStorageType,
                                            OutputStorageType>
  {
  public:
    HessianSimple(bool BuildPCM = false);
    HessianSimple(const HessianSimple<InputStorageType, OutputStorageType>& other);
    virtual ~HessianSimple();

    virtual int Filter(const Image<InputStorageType>& src, 
                       Image<OutputStorageType>& hxx,
                       Image<OutputStorageType>& hyx);

    virtual int Filter(const Image<InputStorageType>& src, 
                       Image<OutputStorageType>& hxx,
                       Image<OutputStorageType>& hyx, 
                       Image<OutputStorageType>& hxy);

    virtual FilterNTo3N<InputStorageType, OutputStorageType>* Clone() const
    { return new HessianSimple<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;

    /** @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);

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

} // namsepace

#endif // __HessianSimple_hh__