itkDiscreteGaussianImageFilter.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
 *
 *         https://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 itkDiscreteGaussianImageFilter_h
#define itkDiscreteGaussianImageFilter_h
 
#include "itkGaussianOperator.h"
#include "itkImageToImageFilter.h"
#include "itkImage.h"
#include "itkZeroFluxNeumannBoundaryCondition.h"
 
namespace itk
{
template <typename TInputImage, typename TOutputImage = TInputImage>
class ITK_TEMPLATE_EXPORT DiscreteGaussianImageFilter : public ImageToImageFilter<TInputImage, TOutputImage>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(DiscreteGaussianImageFilter);
 
  using Self = DiscreteGaussianImageFilter;
  using Superclass = ImageToImageFilter<TInputImage, TOutputImage>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkNewMacro(Self);
 
  itkOverrideGetNameOfClassMacro(DiscreteGaussianImageFilter);
 
  using InputImageType = TInputImage;
  using OutputImageType = TOutputImage;
 
  using OutputPixelType = typename TOutputImage::PixelType;
  using OutputInternalPixelType = typename TOutputImage::InternalPixelType;
  using InputPixelType = typename TInputImage::PixelType;
  using InputInternalPixelType = typename TInputImage::InternalPixelType;
 
  using InputPixelValueType = typename NumericTraits<InputPixelType>::ValueType;
  using OutputPixelValueType = typename NumericTraits<OutputPixelType>::ValueType;
 
  static constexpr unsigned int ImageDimension = TOutputImage::ImageDimension;
 
  using RealOutputPixelType = typename NumericTraits<OutputPixelType>::RealType;
  using RealOutputImageType = Image<OutputPixelType, ImageDimension>;
  using RealOutputPixelValueType = typename NumericTraits<RealOutputPixelType>::ValueType;
 
  using BoundaryConditionType = ImageBoundaryCondition<TInputImage>;
  using InputBoundaryConditionPointerType = BoundaryConditionType *;
  using InputDefaultBoundaryConditionType = ZeroFluxNeumannBoundaryCondition<TInputImage>;
  using RealBoundaryConditionPointerType = ImageBoundaryCondition<RealOutputImageType> *;
  using RealDefaultBoundaryConditionType = ZeroFluxNeumannBoundaryCondition<RealOutputImageType>;
 
  using ArrayType = FixedArray<double, Self::ImageDimension>;
  using SigmaArrayType = ArrayType;
  using ScalarRealType = double;
 
  using KernelType = GaussianOperator<RealOutputPixelValueType, ImageDimension>;
  using RadiusType = typename KernelType::RadiusType;
 
  itkSetMacro(Variance, ArrayType);
  itkGetConstMacro(Variance, const ArrayType);
  itkSetMacro(MaximumError, ArrayType);
  itkGetConstMacro(MaximumError, const ArrayType);
  itkGetConstMacro(MaximumKernelWidth, unsigned int);
  itkSetMacro(MaximumKernelWidth, unsigned int);
  itkGetConstMacro(FilterDimensionality, unsigned int);
  itkSetMacro(FilterDimensionality, unsigned int);
  itkSetMacro(InputBoundaryCondition, InputBoundaryConditionPointerType);
  itkGetConstMacro(InputBoundaryCondition, InputBoundaryConditionPointerType);
  itkSetMacro(RealBoundaryCondition, RealBoundaryConditionPointerType);
  itkGetConstMacro(RealBoundaryCondition, RealBoundaryConditionPointerType);
  void
  SetVariance(const typename ArrayType::ValueType v)
  {
    m_Variance.Fill(v);
    this->Modified();
  }
  void
  SetMaximumError(const typename ArrayType::ValueType v)
  {
    m_MaximumError.Fill(v);
    this->Modified();
  }
 
  void
  SetVariance(const double * v)
  {
    ArrayType dv;
 
    for (unsigned int i = 0; i < ImageDimension; ++i)
    {
      dv[i] = v[i];
    }
    this->SetVariance(dv);
  }
 
  void
  SetVariance(const float * v)
  {
    ArrayType dv;
 
    for (unsigned int i = 0; i < ImageDimension; ++i)
    {
      dv[i] = v[i];
    }
    this->SetVariance(dv);
  }
 
  void
  SetSigma(const ArrayType & sigma)
  {
    ArrayType variance;
    for (unsigned int i = 0; i < ImageDimension; ++i)
    {
      variance[i] = sigma[i] * sigma[i];
    }
    this->SetVariance(variance);
  }
 
  void
  SetSigmaArray(const ArrayType & sigmas)
  {
    this->SetSigma(sigmas);
  }
  void
  SetSigma(double sigma)
  {
    this->SetVariance(sigma * sigma);
  }
  ArrayType
  GetSigmaArray() const
  {
    ArrayType sigmas;
    for (unsigned int i = 0; i < ImageDimension; ++i)
    {
      sigmas[i] = std::sqrt(m_Variance[i]);
    }
    return sigmas;
  }
  double
  GetSigma() const
  {
    return std::sqrt(m_Variance[0]);
  }
 
  void
  SetMaximumError(const double * v)
  {
    ArrayType dv;
 
    for (unsigned int i = 0; i < ImageDimension; ++i)
    {
      dv[i] = v[i];
    }
    this->SetMaximumError(dv);
  }
 
  void
  SetMaximumError(const float * v)
  {
    ArrayType dv;
 
    for (unsigned int i = 0; i < ImageDimension; ++i)
    {
      dv[i] = v[i];
    }
    this->SetMaximumError(dv);
  }
 
  unsigned int
  GetKernelRadius(const unsigned int dimension) const;
 
  ArrayType
  GetKernelRadius() const;
 
  ArrayType
  GetKernelSize() const;
 
  itkSetMacro(UseImageSpacing, bool);
  itkGetConstMacro(UseImageSpacing, bool);
  itkBooleanMacro(UseImageSpacing);
#if !defined(ITK_FUTURE_LEGACY_REMOVE)
 
  void
  SetUseImageSpacingOn()
  {
    this->SetUseImageSpacing(true);
  }
 
  void
  SetUseImageSpacingOff()
  {
    this->SetUseImageSpacing(false);
  }
#endif
 
  itkLegacyMacro(unsigned int GetInternalNumberOfStreamDivisions() const);
  itkLegacyMacro(void SetInternalNumberOfStreamDivisions(unsigned int));
 
#ifdef ITK_USE_CONCEPT_CHECKING
  // Begin concept checking
 
  itkConceptMacro(OutputHasNumericTraitsCheck, (Concept::HasNumericTraits<OutputPixelValueType>));
 
  // End concept checking
#endif
 
protected:
  DiscreteGaussianImageFilter()
  {
    m_Variance.Fill(0.0);
    m_MaximumError.Fill(0.01);
    m_MaximumKernelWidth = 32;
    m_UseImageSpacing = true;
    m_FilterDimensionality = ImageDimension;
    m_InputBoundaryCondition = &m_InputDefaultBoundaryCondition;
    m_RealBoundaryCondition = &m_RealDefaultBoundaryCondition;
  }
 
  ~DiscreteGaussianImageFilter() override = default;
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  void
  GenerateInputRequestedRegion() override;
 
  void
  GenerateData() override;
 
  void
  GenerateKernel(const unsigned int dimension, KernelType & oper) const;
 
  ArrayType
  GetKernelVarianceArray() const;
 
private:
  ArrayType m_Variance{};
 
  ArrayType m_MaximumError{};
 
  unsigned int m_MaximumKernelWidth{};
 
  unsigned int m_FilterDimensionality{};
 
  bool m_UseImageSpacing{};
 
  InputBoundaryConditionPointerType m_InputBoundaryCondition{};
 
  InputDefaultBoundaryConditionType m_InputDefaultBoundaryCondition{};
 
  RealBoundaryConditionPointerType m_RealBoundaryCondition{};
 
  RealDefaultBoundaryConditionType m_RealDefaultBoundaryCondition{};
};
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkDiscreteGaussianImageFilter.hxx"
#endif
 
#endif