itkWienerDeconvolutionImageFilter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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 itkWienerDeconvolutionImageFilter_h
#define itkWienerDeconvolutionImageFilter_h
 
#include "itkInverseDeconvolutionImageFilter.h"
 
namespace itk
{
template <typename TInputImage,
          typename TKernelImage = TInputImage,
          typename TOutputImage = TInputImage,
          typename TInternalPrecision = double>
class ITK_TEMPLATE_EXPORT WienerDeconvolutionImageFilter
  : public InverseDeconvolutionImageFilter<TInputImage, TKernelImage, TOutputImage, TInternalPrecision>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(WienerDeconvolutionImageFilter);
 
  using Self = WienerDeconvolutionImageFilter;
  using Superclass = InverseDeconvolutionImageFilter<TInputImage, TKernelImage, TOutputImage, TInternalPrecision>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkNewMacro(Self);
 
  itkTypeMacro(WienerDeconvolutionImageFilter, InverseDeconvolutionImageFilter);
 
  static constexpr unsigned int ImageDimension = TInputImage::ImageDimension;
 
  using InputImageType = TInputImage;
  using OutputImageType = TOutputImage;
  using KernelImageType = TKernelImage;
  using InputPixelType = typename Superclass::InputPixelType;
  using OutputPixelType = typename Superclass::OutputPixelType;
  using KernelPixelType = typename Superclass::KernelPixelType;
  using InputIndexType = typename Superclass::InputIndexType;
  using OutputIndexType = typename Superclass::OutputIndexType;
  using KernelIndexType = typename Superclass::KernelIndexType;
  using InputSizeType = typename Superclass::InputSizeType;
  using OutputSizeType = typename Superclass::OutputSizeType;
  using KernelSizeType = typename Superclass::KernelSizeType;
  using SizeValueType = typename Superclass::SizeValueType;
  using InputRegionType = typename Superclass::InputRegionType;
  using OutputRegionType = typename Superclass::OutputRegionType;
  using KernelRegionType = typename Superclass::KernelRegionType;
 
  using InternalImageType = typename Superclass::InternalImageType;
  using InternalImagePointerType = typename Superclass::InternalImagePointerType;
  using InternalComplexType = typename Superclass::InternalComplexType;
  using InternalComplexImageType = typename Superclass::InternalComplexImageType;
  using InternalComplexImagePointerType = typename Superclass::InternalComplexImagePointerType;
 
  itkSetMacro(NoiseVariance, double);
  itkGetConstMacro(NoiseVariance, double);
 
protected:
  WienerDeconvolutionImageFilter();
  ~WienerDeconvolutionImageFilter() override = default;
 
  void
  GenerateData() override;
 
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
private:
  double m_NoiseVariance;
};
 
namespace Functor
{
template <typename TPixel>
class ITK_TEMPLATE_EXPORT WienerDeconvolutionFunctor
{
public:
  WienerDeconvolutionFunctor() = default;
  ~WienerDeconvolutionFunctor() = default;
  WienerDeconvolutionFunctor(const WienerDeconvolutionFunctor & f)
    : m_NoisePowerSpectralDensityConstant(f.m_NoisePowerSpectralDensityConstant)
    , m_KernelZeroMagnitudeThreshold(f.m_KernelZeroMagnitudeThreshold)
  {}
 
  bool
  operator!=(const WienerDeconvolutionFunctor &) const
  {
    return false;
  }
  bool
  operator==(const WienerDeconvolutionFunctor & other) const
  {
    return !(*this != other);
  }
  inline TPixel
  operator()(const TPixel & I, const TPixel & H) const
  {
    TPixel Pn = m_NoisePowerSpectralDensityConstant;
 
    // We estimate the power spectral density of the output image to
    // be the same as the power spectral density of the blurred input
    // minus the power spectral density of the noise.
    TPixel Pf = std::norm(I);
 
    TPixel denominator = std::norm(H) + (Pn / (Pf - Pn));
    TPixel value = NumericTraits<TPixel>::ZeroValue();
    if (std::abs(denominator) >= m_KernelZeroMagnitudeThreshold)
    {
      value = I * (std::conj(H) / denominator);
    }
 
    return value;
  }
 
  void
  SetNoisePowerSpectralDensityConstant(double constant)
  {
    m_NoisePowerSpectralDensityConstant = constant;
  }
  double
  GetNoisePowerSpectralDensityConstant() const
  {
    return m_NoisePowerSpectralDensityConstant;
  }
 
  void
  SetKernelZeroMagnitudeThreshold(double mu)
  {
    m_KernelZeroMagnitudeThreshold = mu;
  }
  double
  GetKernelZeroMagnitudeThreshold() const
  {
    return m_KernelZeroMagnitudeThreshold;
  }
 
private:
  double m_NoisePowerSpectralDensityConstant = 0.0;
  double m_KernelZeroMagnitudeThreshold = 0.0;
};
} // namespace Functor
 
} // namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkWienerDeconvolutionImageFilter.hxx"
#endif
 
#endif