Median.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 __Median_hh__
#define __Median_hh__

#include <Base/Image/Image.hh>
#include <Filter/FilterNToN.hh>
#include <utility>
#ifdef _OPENMP
#include <omp.h>
#endif

namespace BIAS
{

  /** @class Median
      @ingroup g_filter
      @brief Implements a 2D median filter for images.
  */
  template<class InputStorageType, class OutputStorageType>
  class BIASFilter_EXPORT Median
    : public FilterNToN<InputStorageType, OutputStorageType>
    {
    public:

      Median();

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

      virtual
      ~Median();

      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 FilterNToN<InputStorageType, OutputStorageType>*
      Clone() const
      {
        return new Median<InputStorageType, OutputStorageType> (*this);
      }

      /** @brief */
      int
      FilterIgnoreZero5x5(const Image<InputStorageType>& src, Image<
          OutputStorageType>& dst) const;

      /** @brief fill spurious gaps in depth maps
       compute 5x5 median at zero points, thereby ignoring zero values
       @param Threshold all values<=threshold are rewritten,
       all values>threshold are used for median sorting */
      int
      FilterOnlyZeroIgnoreZero5x5(const Image<InputStorageType>& src, Image<
          OutputStorageType>& dst, const float& Threshold = 0.0f) const;

      /** @brief fill spurious gaps in depth maps
       compute 3x3 median at zero points, thereby ignoring zero values
       @param Threshold all values<=threshold are rewritten, all
       values>threshold are used for median sorting */
      int
      FilterOnlyZeroIgnoreZero3x3(const Image<InputStorageType>& src, Image<
          OutputStorageType>& dst, const float& Threshold = 0.0f) const;

      /** @brief filters using only values above threshold as input */
      int
      FilterIgnore3x3(const Image<InputStorageType>& src, Image<
          OutputStorageType>& dst, const float& threshold) const;

      /** @brief Specialized median filter for images with invalid values.

       Only positions containing an invalid value (i.e. a value < threshold)
       are touched by the filter. They are set to the median of all
       neighboring pixels, which are not invalid themselves, iff a minimium
       number of min_support_pixels are found. Otherwise the invalid value
       is preserved.
       @author woelk 06/2008 (c) www.vision-n.de */
      int
      FilterOnlyBelowIgnoreBelow3x3(const Image<InputStorageType>& src, Image<
          OutputStorageType>& dst, const float &threshold,
          const unsigned &min_support = 1) const;

      /** @brief removes "salt and pepper" by replacing outliers (Threshold)
       with median of neighbourhood. For two channels: assume second channel
       is covariance, do not filter but copy corresponding value from median */
      int
      FilterRemoveSaltAndPepper(const Image<InputStorageType>& src, Image<
          OutputStorageType>& dst, const float &Threshold = 3.0f) const;

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

      int
      FilterColorImgVec(const Image<InputStorageType>& src, Image<
          OutputStorageType>& dst, unsigned int px, unsigned int py,
          const Image<unsigned char>* ignorePixels = NULL);

      int
      FilterColorImgVec(const Image<InputStorageType>& src, Image<
          OutputStorageType>& dst,
          const Image<unsigned char>* ignorePixels = NULL);

      int FilterParallel(Image<InputStorageType>& source,
              Image<OutputStorageType>& dest, unsigned int numberOfThreads);

      int
      Filter3x3x3Grey(std::vector<Image<InputStorageType> >& srcs, Image<
          OutputStorageType>& dst);

      int
      Filter3x3x3Color(std::vector<Image<InputStorageType> >& srcs, Image<
          OutputStorageType>& dst);

      inline void
      SetSize(int newsize, int secondsize = -1)
      {
        _MedianSize = newsize;
        if (secondsize != -1)
          _secondSize = secondsize;
        else
          _secondSize = _MedianSize;
      }

      // all data below this threshold will be ignored
      void
      SetMinValue(float min)
      {
        _MinValue = min;
      }
      
    protected:

      /// half win size of median, 1 means 3x3
      int _MedianSize;

      /// Use this variable for non-quadratic filter sizes e.g. 3x1
      int _secondSize;
      float _MinValue;

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

    };

}

#endif // __Median_hh__