StructureTensor.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 __StructureTensor_hh__
#define __StructureTensor_hh__

#include "FilterBase.hh"
#include "GradientSobel3x3.hh"
#include "GradientGauss.hh"
#include "GradientGaussAsymmetric.hh"
#include "FilterNTo3N.hh"

#define D_ST_WRITE_DEBUG_IM 0x00000001
#define D_ST_INIT           0x00000002
#define D_ST_FEATURES       0x00000004

namespace BIAS {

  /** @class StructureTensor
      @ingroup g_filter
      @brief basic class for structure tensor calculation

      @author woelk 09/2004 */
  template <class InputStorageType, class OutputStorageType> 
  class BIASFilter_EXPORT StructureTensor : public FilterNTo3N<InputStorageType, 
                                             OutputStorageType>
  {
    using FilterBase<InputStorageType,OutputStorageType>::DebugLevelIsSet;
    using FilterBase<InputStorageType,OutputStorageType>
    ::_FilterBorderHandling;
  public:
    StructureTensor();
    StructureTensor(const StructureTensor<InputStorageType, OutputStorageType>& other);
    ~StructureTensor();

    /** calls the apropriate non virtual member function
        returns an 3 channel image where 
        - channel 0 contains gxx
        - channel 1 contains gxy
        - channel 2 contains gyy
        @todo implement StructureTensor
        @author woelk 09/2004 */
    virtual int Filter(const Image<InputStorageType>& src, 
                       Image<OutputStorageType>& dst);
    virtual int FilterInt(const Image<InputStorageType>& src, 
                          Image<OutputStorageType>& dst);
    virtual int FilterFloat(const Image<InputStorageType>& src, 
                            Image<OutputStorageType>& dst);

    virtual int Filter(const Image<InputStorageType>& src, 
                       Image<OutputStorageType>& gxx, 
                       Image<OutputStorageType>& gxy,
                       Image<OutputStorageType>& gyy);

    virtual int FilterInt(const Image<InputStorageType>& src, 
                          Image<OutputStorageType>& gxx, 
                          Image<OutputStorageType>& gxy,
                          Image<OutputStorageType>& gyy);

    virtual int FilterFloat(const Image<InputStorageType>& src, 
                            Image<OutputStorageType>& gxx, 
                            Image<OutputStorageType>& gxy,
                            Image<OutputStorageType>& gyy);

    virtual FilterNTo3N<InputStorageType, OutputStorageType>* Clone() const
    { return new StructureTensor<InputStorageType, OutputStorageType>(*this); }
    

    /** Calculates the gradients uses internal gradient class and calls
        CalcStructureTensor with these gradients
        @author woelk 09/2004 */
    int CalcStructureTensor(const Image<InputStorageType>& src, 
                           Image<OutputStorageType>& sgxx, 
                            Image<OutputStorageType>& sgxy,
                           Image<OutputStorageType>& sgyy);

    /** For any _HalfWinSize. For any border handling.
        @todo implement CalcStructureTensor for other border handling than 
        valid
        @author woelk 09/2004 */
    int CalcStructureTensor(const Image<OutputStorageType>& gx,
                            const Image<OutputStorageType>& gy, 
                            Image<OutputStorageType>& sgxx, 
                            Image<OutputStorageType>& sgxy,
                            Image<OutputStorageType>& sgyy);

    /** For any _HalfWinSize. Uses valid border handling.
        Destination images must be initialized.
        @todo implement separated summation.
        @author woelk 09/2004 */
    int CalcStructureTensorValid(const Image<OutputStorageType>& gx,
                                 const Image<OutputStorageType>& gy, 
                                 Image<OutputStorageType>& sgxx, 
                                 Image<OutputStorageType>& sgxy,
                                 Image<OutputStorageType>& sgyy);

    /** Uses _HalfWinSize=1
        Destination images must be initialized.
        @author woelk 09/2004 */
    int CalcStructureTensor3x3(const Image<OutputStorageType>& gx,
                               const Image<OutputStorageType>& gy, 
                               Image<OutputStorageType>& sgxx, 
                               Image<OutputStorageType>& sgxy,
                               Image<OutputStorageType>& sgyy);

    /** Uses _HalfWinSize=2
        Destination images must be initialized.
        @author woelk 09/2004 */
    int CalcStructureTensor5x5(const Image<OutputStorageType>& gx,
                               const Image<OutputStorageType>& gy, 
                               Image<OutputStorageType>& sgxx, 
                               Image<OutputStorageType>& sgxy,
                               Image<OutputStorageType>& sgyy);

    /** Uses _HalfWinSize=3
        Destination images must be initialized.
        @todo make it really fast
        @author woelk 09/2004 */
    int CalcStructureTensor7x7(const Image<OutputStorageType>& gx,
                               const Image<OutputStorageType>& gy, 
                               Image<OutputStorageType>& sgxx, 
                               Image<OutputStorageType>& sgxy,
                               Image<OutputStorageType>& sgyy);

    ///////////////////////////////////////////////////////////////////////

    inline void SetHalfWinSize(const int hws) { _HalfWinSize=hws; }

    inline int GetHalfWinSize() const { return _HalfWinSize; }

    inline void SetGradientFilter(const FilterNTo2N<InputStorageType, OutputStorageType>& grad) 
    { if (_grad) delete _grad; _grad = grad.Clone(); }

    inline const Image<OutputStorageType>& GetGradientX() const {
      return _gx;
    }

    inline const Image<OutputStorageType>& GetGradientY() const {
      return _gy;
    }

  protected:
    /// pointer to gradient filter actually used:
    FilterNTo2N<InputStorageType, OutputStorageType> *_grad;

    // the window size for the structure tensor computation
    int _HalfWinSize;

    // internal variables
    // gradient images
    Image<OutputStorageType> _gx, _gy;
    // _gxx = gx*gx, gxy = gx*gy, gyy = gy*gy
    Image<OutputStorageType> _gxx, _gxy, _gyy;
    // temporary space for separated summation
    Image<OutputStorageType> _tsgxx, _tsgxy, _tsgyy;
    // size of the internal images
    int _InternalMemWidth, _InternalMemHeight;

    /// for debugging only
    void _WriteDebugImage(Image<OutputStorageType>& im, std::string name);

    /** fills up _gxx, _gxy, _gyy from gx and gy 
        @author woelk 09/2004 */
    void _GradientProducts(const Image<OutputStorageType>& gx,
                           const Image<OutputStorageType>& gy);
    
    
    /// allocates _gxx, _gyy, _gxy, _tsgxx, _tsgxy, _tsgyy
    ///  and sets InternalMemWidth and _InternalMemHeight
    void _AllocInternalMem(const int width, const int height);

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

  }; // class

} // namespace

#endif //__StructureTensor_hh__