itkRecursiveGaussianImageFilter.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 itkRecursiveGaussianImageFilter_h
#define itkRecursiveGaussianImageFilter_h
 
#include "itkRecursiveSeparableImageFilter.h"
#include "ITKSmoothingExport.h"
 
namespace itk
{
class RecursiveGaussianImageFilterEnums
{
public:
  enum class GaussianOrder : uint8_t
  {
    ZeroOrder = 0,
    FirstOrder = 1,
    SecondOrder = 2
  };
};
// Define how to print enumeration
extern ITKSmoothing_EXPORT std::ostream &
                           operator<<(std::ostream & out, const RecursiveGaussianImageFilterEnums::GaussianOrder value);
 
using GaussianOrderEnum = RecursiveGaussianImageFilterEnums::GaussianOrder;
#if !defined(ITK_LEGACY_REMOVE)
 
using OrderEnumType = GaussianOrderEnum;
using EnumGaussianOrderType = GaussianOrderEnum;
// We need to expose the enum values at the class level
// for backwards compatibility
static constexpr GaussianOrderEnum ZeroOrder = GaussianOrderEnum::ZeroOrder;
static constexpr GaussianOrderEnum FirstOrder = GaussianOrderEnum::FirstOrder;
static constexpr GaussianOrderEnum SecondOrder = GaussianOrderEnum::SecondOrder;
#endif
 
template <typename TInputImage, typename TOutputImage = TInputImage>
class ITK_TEMPLATE_EXPORT RecursiveGaussianImageFilter : public RecursiveSeparableImageFilter<TInputImage, TOutputImage>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(RecursiveGaussianImageFilter);
  using Self = RecursiveGaussianImageFilter;
  using Superclass = RecursiveSeparableImageFilter<TInputImage, TOutputImage>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  using typename Superclass::RealType;
  using typename Superclass::ScalarRealType;
 
  itkNewMacro(Self);
 
  itkOverrideGetNameOfClassMacro(RecursiveGaussianImageFilter);
 
  itkGetConstMacro(Sigma, ScalarRealType);
  itkSetMacro(Sigma, ScalarRealType);
  using OutputImageType = TOutputImage;
 
#if !defined(ITK_LEGACY_REMOVE)
 
  using OrderEnumType = GaussianOrderEnum;
  using EnumGaussianOrderType = GaussianOrderEnum;
  // We need to expose the enum values at the class level
  // for backwards compatibility
  static constexpr GaussianOrderEnum ZeroOrder = GaussianOrderEnum::ZeroOrder;
  static constexpr GaussianOrderEnum FirstOrder = GaussianOrderEnum::FirstOrder;
  static constexpr GaussianOrderEnum SecondOrder = GaussianOrderEnum::SecondOrder;
#endif
 
  itkSetMacro(NormalizeAcrossScale, bool);
  itkGetConstMacro(NormalizeAcrossScale, bool);
  itkBooleanMacro(NormalizeAcrossScale);
 
  itkSetMacro(Order, GaussianOrderEnum);
  itkGetConstMacro(Order, GaussianOrderEnum);
  void
  SetZeroOrder();
 
  void
  SetFirstOrder();
 
  void
  SetSecondOrder();
 
protected:
  RecursiveGaussianImageFilter();
  ~RecursiveGaussianImageFilter() override = default;
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  void
  SetUp(ScalarRealType spacing) override;
 
  /* See superclass for doxygen. This method adds the additional check
   * that sigma is greater than zero. */
  void
  VerifyPreconditions() ITKv5_CONST override;
 
private:
  void
  ComputeNCoefficients(ScalarRealType   sigmad,
                       ScalarRealType   A1,
                       ScalarRealType   B1,
                       ScalarRealType   W1,
                       ScalarRealType   L1,
                       ScalarRealType   A2,
                       ScalarRealType   B2,
                       ScalarRealType   W2,
                       ScalarRealType   L2,
                       ScalarRealType & N0,
                       ScalarRealType & N1,
                       ScalarRealType & N2,
                       ScalarRealType & N3,
                       ScalarRealType & SN,
                       ScalarRealType & DN,
                       ScalarRealType & EN);
 
  void
  ComputeDCoefficients(ScalarRealType   sigmad,
                       ScalarRealType   W1,
                       ScalarRealType   L1,
                       ScalarRealType   W2,
                       ScalarRealType   L2,
                       ScalarRealType & SD,
                       ScalarRealType & DD,
                       ScalarRealType & ED);
 
  void
  ComputeRemainingCoefficients(bool symmetric);
 
  ScalarRealType m_Sigma{};
 
  bool m_NormalizeAcrossScale{};
 
  GaussianOrderEnum m_Order{};
};
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkRecursiveGaussianImageFilter.hxx"
#endif
 
#endif