itkBilateralImageFilter.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkBilateralImageFilter.h,v $
  Language:  C++
  Date:      $Date: 2009-04-25 12:27:11 $
  Version:   $Revision: 1.21 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkBilateralImageFilter_h
#define __itkBilateralImageFilter_h

#include "itkImageToImageFilter.h"
#include "itkImage.h"
#include "itkFixedArray.h"
#include "itkNeighborhoodIterator.h"
#include "itkConstNeighborhoodIterator.h"
#include "itkNeighborhood.h"

namespace itk
{
template <class TInputImage, class TOutputImage >
class ITK_EXPORT BilateralImageFilter :
    public ImageToImageFilter< TInputImage, TOutputImage > 
{
public:
  typedef BilateralImageFilter                            Self;
  typedef ImageToImageFilter< TInputImage, TOutputImage > Superclass;
  typedef SmartPointer<Self>                              Pointer;
  typedef SmartPointer<const Self>                        ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(BilateralImageFilter, ImageToImageFilter);

  typedef TInputImage  InputImageType;
  typedef TOutputImage OutputImageType;

  typedef typename Superclass::OutputImageRegionType OutputImageRegionType;

  typedef typename TOutputImage::PixelType                  OutputPixelType;
  typedef typename TOutputImage::InternalPixelType          OutputInternalPixelType;
  typedef typename NumericTraits<OutputPixelType>::RealType OutputPixelRealType;
  typedef typename TInputImage::PixelType                   InputPixelType;
  typedef typename TInputImage::InternalPixelType           InputInternalPixelType;

  itkStaticConstMacro(ImageDimension, unsigned int,
                      TOutputImage::ImageDimension);

  typedef FixedArray<double, itkGetStaticConstMacro(ImageDimension)> ArrayType;

  typedef ConstNeighborhoodIterator<TInputImage> NeighborhoodIteratorType;

  typedef
  Neighborhood<double, itkGetStaticConstMacro(ImageDimension)> KernelType;
  typedef typename KernelType::SizeType                        SizeType;

  typedef typename KernelType::Iterator      KernelIteratorType;
  typedef typename KernelType::ConstIterator KernelConstIteratorType;

  typedef
  Image<double, itkGetStaticConstMacro(ImageDimension)> GaussianImageType;

  itkSetMacro(DomainSigma, ArrayType);
  itkGetConstMacro(DomainSigma, const ArrayType);
  itkSetMacro(RangeSigma, double);
  itkGetConstMacro(RangeSigma, double);
  itkGetConstMacro(FilterDimensionality, unsigned int);
  itkSetMacro(FilterDimensionality, unsigned int);

  void SetDomainSigma(const double v)
    {
    m_DomainSigma.Fill(v);
    }

  itkBooleanMacro(AutomaticKernelSize);
  itkGetConstMacro(AutomaticKernelSize, bool);
  itkSetMacro(AutomaticKernelSize, bool);

  void SetRadius(const unsigned long);
  itkSetMacro(Radius, SizeType);
  itkGetConstReferenceMacro(Radius, SizeType);

  
  itkSetMacro(NumberOfRangeGaussianSamples, unsigned long);
  itkGetConstMacro(NumberOfRangeGaussianSamples, unsigned long);

#ifdef ITK_USE_CONCEPT_CHECKING

  itkConceptMacro(OutputHasNumericTraitsCheck,
                  (Concept::HasNumericTraits<OutputPixelType>));

#endif

protected:
  BilateralImageFilter()
    {
    m_Radius.Fill(1);
    m_AutomaticKernelSize = true;
    m_DomainSigma.Fill(4.0);
    m_RangeSigma = 50.0;
    m_FilterDimensionality = ImageDimension;
    m_NumberOfRangeGaussianSamples = 100;
    m_DynamicRange = 0.0;
    m_DynamicRangeUsed = 0.0;
    m_DomainMu = 2.5;  // keep small to keep kernels small
    m_RangeMu = 4.0;   // can be bigger then DomainMu since we only
                       // index into a single table

    }
  virtual ~BilateralImageFilter() {}
  void PrintSelf(std::ostream& os, Indent indent) const;

  void BeforeThreadedGenerateData();

  void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
                            int threadId); 

  virtual void GenerateInputRequestedRegion() throw(InvalidRequestedRegionError);

  
private:
  BilateralImageFilter(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

  double m_RangeSigma;

  ArrayType m_DomainSigma;

  double m_DomainMu;
  double m_RangeMu;

  unsigned int m_FilterDimensionality;

  KernelType m_GaussianKernel;
  SizeType   m_Radius;
  bool       m_AutomaticKernelSize;

  unsigned long       m_NumberOfRangeGaussianSamples;
  double              m_DynamicRange;
  double              m_DynamicRangeUsed;
  std::vector<double> m_RangeGaussianTable;
};

} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkBilateralImageFilter.txx"
#endif

#endif