itkPatchBasedDenoisingBaseImageFilter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkPatchBasedDenoisingBaseImageFilter_h
#define itkPatchBasedDenoisingBaseImageFilter_h

#include "itkImageToImageFilter.h"
#include "itkArray.h"
#include "itkSample.h"
#include "itkNumericTraits.h"
#include "itkZeroFluxNeumannBoundaryCondition.h"
#include "itkImageToNeighborhoodSampleAdaptor.h"
#include "itkConstNeighborhoodIterator.h"
#include "itkRGBPixel.h"
#include "itkRGBAPixel.h"
#include "itkDiffusionTensor3D.h"

namespace itk
{

template <typename TInputImage, typename TOutputImage>
class PatchBasedDenoisingBaseImageFilter :
  public ImageToImageFilter<TInputImage, TOutputImage>
{
public:
  typedef PatchBasedDenoisingBaseImageFilter            Self;
  typedef ImageToImageFilter<TInputImage, TOutputImage> Superclass;
  typedef SmartPointer<Self>                            Pointer;
  typedef SmartPointer<const Self>                      ConstPointer;

  itkTypeMacro(PatchBasedDenoisingBaseImageFilter, ImageToImageFilter);

  typedef TInputImage  InputImageType;
  typedef TOutputImage OutputImageType;

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

  typedef typename InputImageType::PixelType           InputPixelType;
  typedef typename OutputImageType::PixelType          OutputPixelType;
  typedef OutputPixelType                              PixelType;
  typedef typename NumericTraits<PixelType>::ValueType PixelValueType;

  typedef enum { NOMODEL = 0, GAUSSIAN = 1, RICIAN = 2, POISSON = 3 } NoiseModelType;

  typedef enum { EUCLIDEAN = 0, RIEMANNIAN = 1 } ComponentSpaceType;

  typedef enum { UNINITIALIZED = 0, INITIALIZED = 1 } FilterStateType;

  typedef Array<float> PatchWeightsType;

  typedef ZeroFluxNeumannBoundaryCondition<OutputImageType> BoundaryConditionType;
  typedef typename::itk::Statistics::ImageToNeighborhoodSampleAdaptor<
      OutputImageType, BoundaryConditionType >              ListAdaptorType;
  typedef typename ListAdaptorType::NeighborhoodRadiusType  PatchRadiusType;
  typedef ConstNeighborhoodIterator<
      InputImageType, BoundaryConditionType >               InputImagePatchIterator;

  itkSetMacro(PatchRadius, unsigned int);
  itkGetConstMacro(PatchRadius, unsigned int);

  PatchRadiusType GetPatchRadiusInVoxels() const;

  PatchRadiusType GetPatchDiameterInVoxels() const;

  typename PatchRadiusType::SizeValueType GetPatchLengthInVoxels() const;

  void SetPatchWeights(const PatchWeightsType& weights);

  PatchWeightsType GetPatchWeights() const;

  itkSetMacro(NoiseModel, NoiseModelType);
  itkGetConstMacro(NoiseModel, NoiseModelType);

  itkSetClampMacro(SmoothingWeight, double, 0.0, 1.0);
  itkGetConstMacro(SmoothingWeight, double);

  itkSetClampMacro(NoiseModelFidelityWeight, double, 0.0, 1.0);
  itkGetConstMacro(NoiseModelFidelityWeight, double);

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

  itkSetClampMacro(KernelBandwidthUpdateFrequency, unsigned int, 1, NumericTraits<unsigned int>::max() );
  itkGetConstMacro(KernelBandwidthUpdateFrequency, unsigned int);

  itkSetClampMacro(NumberOfIterations, unsigned int, 1, NumericTraits<unsigned int>::max() );
  itkGetConstReferenceMacro(NumberOfIterations, unsigned int);

  itkGetConstReferenceMacro(ElapsedIterations, unsigned int);

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

  virtual void SetStateToInitialized();

  virtual void SetStateToUninitialized();

#if !defined(ITK_WRAPPING_PARSER)
  itkSetMacro(State, FilterStateType);
  itkGetConstReferenceMacro(State, FilterStateType);
#endif


  itkSetMacro(ManualReinitialization, bool);
  itkGetConstReferenceMacro(ManualReinitialization, bool);
  itkBooleanMacro(ManualReinitialization);

protected:
  PatchBasedDenoisingBaseImageFilter();
  ~PatchBasedDenoisingBaseImageFilter();

  virtual void PrintSelf(std::ostream& os, Indent indent) const ITK_OVERRIDE;

  virtual void GenerateInputRequestedRegion() ITK_OVERRIDE;

  virtual void GenerateData() ITK_OVERRIDE;

  virtual void CopyInputToOutput() = 0;

  virtual void InitializePatchWeights();

  virtual void Initialize() { }

  virtual void AllocateUpdateBuffer() = 0;

  virtual void PreProcessInput() { }

  virtual void InitializeIteration() { }

  virtual void ComputeKernelBandwidthUpdate() = 0;

  virtual void ComputeImageUpdate() = 0;

  virtual void ApplyUpdate() = 0;

  virtual void PostProcessOutput() { }

  virtual bool Halt();

  virtual bool ThreadedHalt(void *itkNotUsed(threadInfo) )
  {
  return this->Halt();
  }

  itkSetMacro(ElapsedIterations, unsigned int);

  ComponentSpaceType DetermineComponentSpace(const RGBPixel<PixelValueType>& itkNotUsed(p) )
  {
  return EUCLIDEAN;
  }

  ComponentSpaceType DetermineComponentSpace(const RGBAPixel<PixelValueType>& itkNotUsed(p) )
  {
  return EUCLIDEAN;
  }

  ComponentSpaceType DetermineComponentSpace(const DiffusionTensor3D<PixelValueType>& itkNotUsed(p) )
  {
  return RIEMANNIAN;
  }

  template <typename PixelT>
  ComponentSpaceType DetermineComponentSpace(const PixelT& itkNotUsed(p) )
  {
  return EUCLIDEAN;
  }

  unsigned int     m_PatchRadius;
  PatchWeightsType m_PatchWeights;

  bool         m_KernelBandwidthEstimation;
  unsigned int m_KernelBandwidthUpdateFrequency;

  unsigned int m_NumberOfIterations;
  unsigned int m_ElapsedIterations;

  NoiseModelType m_NoiseModel;
  double         m_SmoothingWeight;
  double         m_NoiseModelFidelityWeight;

  bool               m_AlwaysTreatComponentsAsEuclidean;
  ComponentSpaceType m_ComponentSpace;

  bool m_ManualReinitialization;

  const InputImageType *m_InputImage;
  OutputImageType      *m_OutputImage;

private:
  PatchBasedDenoisingBaseImageFilter(const Self&) ITK_DELETE_FUNCTION;
  void operator=(const Self&) ITK_DELETE_FUNCTION;

  FilterStateType m_State;

};  // end class PatchBasedDenoisingBaseImageFilter

} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
# include "itkPatchBasedDenoisingBaseImageFilter.hxx"
#endif

#endif