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 "itkLoggerThreadWrapper.h"
#include "itkLogger.h"
#include "itkZeroFluxNeumannBoundaryCondition.h"
#include "itkImageToNeighborhoodSampleAdaptor.h"
#include "itkConstNeighborhoodIterator.h"
#include "itkRGBPixel.h"
#include "itkRGBAPixel.h"
#include "itkDiffusionTensor3D.h"

namespace itk
{

template <class TInputImage, class TOutputImage>
class ITK_EXPORT 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 itk::LoggerThreadWrapper<itk::Logger> LoggerType;
  typedef typename LoggerType::Pointer          LoggerPointer;

  typedef enum { GAUSSIAN = 0, RICIAN = 1, POISSON = 2 } 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(FidelityWeight, double, 0.0, 1.0);
  itkGetConstMacro(FidelityWeight, double);


  itkSetMacro(DoKernelBandwidthEstimation, bool);
  itkBooleanMacro(DoKernelBandwidthEstimation);
  itkGetConstMacro(DoKernelBandwidthEstimation, 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(CABLE_CONFIGURATION)
  itkSetMacro(State, FilterStateType);
  itkGetConstReferenceMacro(State, FilterStateType);
#endif


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

  itkSetObjectMacro(Logger, LoggerType);
  itkGetObjectMacro(Logger, LoggerType);

 protected:
  PatchBasedDenoisingBaseImageFilter();
  ~PatchBasedDenoisingBaseImageFilter();

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

  virtual void GenerateInputRequestedRegion();

  virtual void GenerateData();

  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);

/*   /\** Set the component space based on pixel type *\/ */
/*   itkSetMacro(ComponentSpace, ComponentSpaceType); */
  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 <class PixelT>
  ComponentSpaceType DetermineComponentSpace(const PixelT& itkNotUsed(p))
  { return EUCLIDEAN; }


  unsigned int     m_PatchRadius;
  PatchWeightsType m_PatchWeights;

  bool         m_DoKernelBandwidthEstimation;
  unsigned int m_KernelBandwidthUpdateFrequency;

  unsigned int m_NumberOfIterations;
  unsigned int m_ElapsedIterations;

  NoiseModelType   m_NoiseModel;
  double           m_SmoothingWeight;
  double           m_FidelityWeight;

  bool               m_AlwaysTreatComponentsAsEuclidean;
  ComponentSpaceType m_ComponentSpace;

  bool m_ManualReinitialization;

  LoggerPointer m_Logger;

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

  FilterStateType m_State;

 }; // end class PatchBasedDenoisingBaseImageFilter

} // end namespace itk

// Define instantiation macro for this template

#define ITK_TEMPLATE_PatchBasedDenoisingBaseImageFilter(_, EXPORT, x, y) namespace itk { \
    _(2(class EXPORT PatchBasedDenoisingBaseImageFilter< ITK_TEMPLATE_2 x >)) | \
      namespace Templates { typedef PatchBasedDenoisingBaseImageFilter< ITK_TEMPLATE_2 x > \
        PatchBasedDenoisingBaseImageFilter##y; } \
  }

#if ITK_TEMPLATE_EXPLICIT
# include "Templates/itkPatchBasedDenoisingBaseImageFilter+-.h"
#endif

#if ITK_TEMPLATE_TXX
# include "itkPatchBasedDenoisingBaseImageFilter.hxx"
#endif

#endif