sitkPatchBasedDenoisingImageFilter.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 sitkPatchBasedDenoisingImageFilter_h
#define sitkPatchBasedDenoisingImageFilter_h
 
/*
 * WARNING: DO NOT EDIT THIS FILE!
 * THIS FILE IS AUTOMATICALLY GENERATED BY THE SIMPLEITK BUILD PROCESS.
 * Please look at sitkImageFilterTemplate.h.in to make changes.
 */
 
#include <memory>
 
#include "sitkBasicFilters.h"
#include "sitkImageFilter.h"
 
namespace itk {
  namespace simple {
 
    class SITKBasicFilters_EXPORT PatchBasedDenoisingImageFilter : public ImageFilter {
    public:
      using Self = PatchBasedDenoisingImageFilter;
 
      virtual ~PatchBasedDenoisingImageFilter();
 
      PatchBasedDenoisingImageFilter();
 
      using PixelIDTypeList = BasicPixelIDTypeList;
\
 
      SITK_RETURN_SELF_TYPE_HEADER SetKernelBandwidthSigma ( double KernelBandwidthSigma ) { this->m_KernelBandwidthSigma = KernelBandwidthSigma; return *this; }
 
      double GetKernelBandwidthSigma() const { return this->m_KernelBandwidthSigma; }\
 
      SITK_RETURN_SELF_TYPE_HEADER SetPatchRadius ( uint32_t PatchRadius ) { this->m_PatchRadius = PatchRadius; return *this; }
 
      uint32_t GetPatchRadius() const { return this->m_PatchRadius; }\
 
      SITK_RETURN_SELF_TYPE_HEADER SetNumberOfIterations ( uint32_t NumberOfIterations ) { this->m_NumberOfIterations = NumberOfIterations; return *this; }
 
      uint32_t GetNumberOfIterations() const { return this->m_NumberOfIterations; }\
 
      SITK_RETURN_SELF_TYPE_HEADER SetNumberOfSamplePatches ( uint32_t NumberOfSamplePatches ) { this->m_NumberOfSamplePatches = NumberOfSamplePatches; return *this; }
 
      uint32_t GetNumberOfSamplePatches() const { return this->m_NumberOfSamplePatches; }\
 
      SITK_RETURN_SELF_TYPE_HEADER SetSampleVariance ( double SampleVariance ) { this->m_SampleVariance = SampleVariance; return *this; }
 
      double GetSampleVariance() const { return this->m_SampleVariance; }
 
      typedef enum {NOMODEL,GAUSSIAN,RICIAN,POISSON} NoiseModelType;\
 
      SITK_RETURN_SELF_TYPE_HEADER SetNoiseModel ( NoiseModelType NoiseModel ) { this->m_NoiseModel = NoiseModel; return *this; }
 
      NoiseModelType GetNoiseModel() const { return this->m_NoiseModel; }\
 
      SITK_RETURN_SELF_TYPE_HEADER SetNoiseSigma ( double NoiseSigma ) { this->m_NoiseSigma = NoiseSigma; return *this; }
 
      double GetNoiseSigma() const { return this->m_NoiseSigma; }\
 
      SITK_RETURN_SELF_TYPE_HEADER SetNoiseModelFidelityWeight ( double NoiseModelFidelityWeight ) { this->m_NoiseModelFidelityWeight = NoiseModelFidelityWeight; return *this; }
 
      double GetNoiseModelFidelityWeight() const { return this->m_NoiseModelFidelityWeight; }\
 
      SITK_RETURN_SELF_TYPE_HEADER SetAlwaysTreatComponentsAsEuclidean ( bool AlwaysTreatComponentsAsEuclidean ) { this->m_AlwaysTreatComponentsAsEuclidean = AlwaysTreatComponentsAsEuclidean; return *this; }
 
      SITK_RETURN_SELF_TYPE_HEADER AlwaysTreatComponentsAsEuclideanOn() { return this->SetAlwaysTreatComponentsAsEuclidean(true); }
      SITK_RETURN_SELF_TYPE_HEADER AlwaysTreatComponentsAsEuclideanOff() { return this->SetAlwaysTreatComponentsAsEuclidean(false); }
 
      bool GetAlwaysTreatComponentsAsEuclidean() const { return this->m_AlwaysTreatComponentsAsEuclidean; }\
 
      SITK_RETURN_SELF_TYPE_HEADER SetKernelBandwidthEstimation ( bool KernelBandwidthEstimation ) { this->m_KernelBandwidthEstimation = KernelBandwidthEstimation; return *this; }
 
      SITK_RETURN_SELF_TYPE_HEADER KernelBandwidthEstimationOn() { return this->SetKernelBandwidthEstimation(true); }
      SITK_RETURN_SELF_TYPE_HEADER KernelBandwidthEstimationOff() { return this->SetKernelBandwidthEstimation(false); }
 
      bool GetKernelBandwidthEstimation() const { return this->m_KernelBandwidthEstimation; }\
 
      SITK_RETURN_SELF_TYPE_HEADER SetKernelBandwidthMultiplicationFactor ( double KernelBandwidthMultiplicationFactor ) { this->m_KernelBandwidthMultiplicationFactor = KernelBandwidthMultiplicationFactor; return *this; }
 
      double GetKernelBandwidthMultiplicationFactor() const { return this->m_KernelBandwidthMultiplicationFactor; }\
 
      SITK_RETURN_SELF_TYPE_HEADER SetKernelBandwidthUpdateFrequency ( uint32_t KernelBandwidthUpdateFrequency ) { this->m_KernelBandwidthUpdateFrequency = KernelBandwidthUpdateFrequency; return *this; }
 
      uint32_t GetKernelBandwidthUpdateFrequency() const { return this->m_KernelBandwidthUpdateFrequency; }\
 
      SITK_RETURN_SELF_TYPE_HEADER SetKernelBandwidthFractionPixelsForEstimation ( double KernelBandwidthFractionPixelsForEstimation ) { this->m_KernelBandwidthFractionPixelsForEstimation = KernelBandwidthFractionPixelsForEstimation; return *this; }
 
      double GetKernelBandwidthFractionPixelsForEstimation() const { return this->m_KernelBandwidthFractionPixelsForEstimation; }
 
      std::string GetName() const { return std::string ("PatchBasedDenoisingImageFilter"); }
 
      std::string ToString() const;
 
 
      Image Execute ( const Image& image1 );
 
    private:
 
      using MemberFunctionType = Image (Self::*)( const Image& image1 );
      template <class TImageType> Image ExecuteInternal ( const Image& image1 );
 
 
      friend struct detail::MemberFunctionAddressor<MemberFunctionType>;
 
      std::unique_ptr<detail::MemberFunctionFactory<MemberFunctionType> > m_MemberFactory;
 
 
      /* KernelBandwidthSigma */
      double  m_KernelBandwidthSigma{400.0};
 
      uint32_t  m_PatchRadius{4u};
 
      /* Number of iterations to run */
      uint32_t  m_NumberOfIterations{1u};
 
      uint32_t  m_NumberOfSamplePatches{200u};
 
      double  m_SampleVariance{400.0};
 
      NoiseModelType  m_NoiseModel{itk::simple::PatchBasedDenoisingImageFilter::NOMODEL};
 
      double  m_NoiseSigma{0.0};
 
      double  m_NoiseModelFidelityWeight{0.0};
 
      bool  m_AlwaysTreatComponentsAsEuclidean{false};
 
      bool  m_KernelBandwidthEstimation{false};
 
      double  m_KernelBandwidthMultiplicationFactor{1.0};
 
      uint32_t  m_KernelBandwidthUpdateFrequency{3u};
 
      double  m_KernelBandwidthFractionPixelsForEstimation{0.2};
 
 
    };
 
 
  }
}
#endif