Bilateral.hh

/* This file is part of the BIAS library (Basic ImageAlgorithmS).
   
   Copyright (C) 2003, 2004    (see file CONTACTS 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 __Bilateral_hh__
#define __Bilateral_hh__

#include <Base/Image/Image.hh> 
#include <Filter/FilterNToN.hh>

namespace BIAS {

  /** @class Bilateral
      @ingroup g_filter
      @brief 2D bilateral filter
      @author ischiller 
  */
  template <class InputStorageType, class OutputStorageType>
  class BIASFilter_EXPORT Bilateral
    : public FilterNToN<InputStorageType, OutputStorageType>
  {
  public:
    Bilateral();

    Bilateral(const Bilateral<InputStorageType, OutputStorageType>& other);

    virtual ~Bilateral();

    /** @brief Bilateral filtering with given filter size (5x5 as standard) */
    virtual int Filter(const Image<InputStorageType>& src,
                       Image<OutputStorageType>& dst);

    /** @brief Bilateral filtering with given filter size (5x5 as standard) 
               uses support image as smoothing restriction, see 
               Petschnigg 2004: DigitalPhotography
     */
    virtual int Filter(const Image<InputStorageType>& src,
                       const Image<InputStorageType>& support,
                       Image<OutputStorageType>& dst);

    virtual int FilterInt(const Image<InputStorageType>& src,
                          Image<OutputStorageType>& dst);

    virtual int FilterFloat(const Image<InputStorageType>& src,
                            Image<OutputStorageType>& dst);

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

    /**
       @brief Filter a color image by calling Filter(...) for every channel
     */ 
    int FilterColorImg(const Image<InputStorageType>& src,
                       Image<OutputStorageType>& dst);

    /**
       @brief Filter a color image with support image by calling Filter(...) 
       for every channel
     */ 
    int FilterColorImg(const Image<InputStorageType>& src,
                       const Image<InputStorageType>& support,
                       Image<OutputStorageType>& dst);
    
  
    void SetSize(int newsize, int secondsize=-1);

    inline void SetSigma(const double si) { _CalculateKernels(si); }
    inline double GetSigma() const  { return _GaussSigma; }
    inline void SetBilateralSigma(const double si) { _BilateralSigma=si;}
    inline double GetBilateralSigma() const  { return _BilateralSigma; }   
    inline void SetIgnoreValue(InputStorageType ignore){_ignoreValue = ignore;};
    inline InputStorageType GetIgnoreValue(){return _ignoreValue;};

  protected:
    void _CalculateKernels(double gaussSigma);

  protected:
    /// sigma of gaussian kernel
    double _GaussSigma, _BilateralSigma;
    /// half win size of filter, 1 means 3x3
    int _BilateralSize, _lastBilateralSize;
    /// Use this variable for non-quadratic filter sizes e.g. 3x1
    int _secondSize,_lastSecondSize;
    
    BIAS::Image<float> _gaussFilterMask;
    
    InputStorageType _ignoreValue;

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




#endif // __Bilateral_hh__