itkBayesianClassifierImageFilter.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 itkBayesianClassifierImageFilter_h
#define itkBayesianClassifierImageFilter_h
 
#include "itkVectorImage.h"
#include "itkImageToImageFilter.h"
#include "itkMaximumDecisionRule.h"
#include "itkImageRegionIterator.h"
 
namespace itk
{
template <typename TInputVectorImage,
          typename TLabelsType = unsigned char,
          typename TPosteriorsPrecisionType = double,
          typename TPriorsPrecisionType = double>
class ITK_TEMPLATE_EXPORT BayesianClassifierImageFilter
  : public ImageToImageFilter<TInputVectorImage, Image<TLabelsType, TInputVectorImage::ImageDimension>>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(BayesianClassifierImageFilter);
 
  using Self = BayesianClassifierImageFilter;
  using Superclass = ImageToImageFilter<TInputVectorImage, Image<TLabelsType, TInputVectorImage::ImageDimension>>;
 
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkNewMacro(Self);
 
  itkOverrideGetNameOfClassMacro(BayesianClassifierImageFilter);
 
  using typename Superclass::InputImageType;
 
  static constexpr unsigned int Dimension = InputImageType::ImageDimension;
 
  using OutputImageType = Image<TLabelsType, Self::Dimension>;
  using InputImagePointer = typename InputImageType::ConstPointer;
  using OutputImagePointer = typename OutputImageType::Pointer;
  using ImageRegionType = typename InputImageType::RegionType;
 
  using InputImageIteratorType = ImageRegionConstIterator<InputImageType>;
  using OutputImageIteratorType = ImageRegionIterator<OutputImageType>;
 
  using InputPixelType = typename InputImageType::PixelType;
  using OutputPixelType = typename OutputImageType::PixelType;
 
  using PriorsImageType = VectorImage<TPriorsPrecisionType, Self::Dimension>;
  using PriorsPixelType = typename PriorsImageType::PixelType;
  using PriorsImagePointer = typename PriorsImageType::Pointer;
  using PriorsImageIteratorType = ImageRegionConstIterator<PriorsImageType>;
 
  using MembershipImageType = TInputVectorImage;
  using MembershipPixelType = typename MembershipImageType::PixelType;
  using MembershipImagePointer = typename MembershipImageType::Pointer;
  using MembershipImageIteratorType = ImageRegionConstIterator<MembershipImageType>;
 
  using PosteriorsImageType = VectorImage<TPosteriorsPrecisionType, Self::Dimension>;
  using PosteriorsPixelType = typename PosteriorsImageType::PixelType;
  using PosteriorsImagePointer = typename PosteriorsImageType::Pointer;
  using PosteriorsImageIteratorType = ImageRegionIterator<PosteriorsImageType>;
 
  using DecisionRuleType = Statistics::MaximumDecisionRule;
  using DecisionRulePointer = DecisionRuleType::Pointer;
 
  using typename Superclass::DataObjectPointer;
 
  using ExtractedComponentImageType = itk::Image<TPosteriorsPrecisionType, Self::Dimension>;
 
  using SmoothingFilterType = ImageToImageFilter<ExtractedComponentImageType, ExtractedComponentImageType>;
 
  using SmoothingFilterPointer = typename SmoothingFilterType::Pointer;
 
  void
  SetSmoothingFilter(SmoothingFilterType *);
  itkGetConstMacro(SmoothingFilter, SmoothingFilterPointer);
  virtual void
  SetPriors(const PriorsImageType *);
 
  itkSetMacro(NumberOfSmoothingIterations, unsigned int);
  itkGetConstMacro(NumberOfSmoothingIterations, unsigned int);
  using DataObjectPointerArraySizeType = ProcessObject::DataObjectPointerArraySizeType;
  using Superclass::MakeOutput;
  DataObjectPointer
  MakeOutput(DataObjectPointerArraySizeType idx) override;
 
#ifdef ITK_USE_CONCEPT_CHECKING
  // Begin concept checking
  itkConceptMacro(UnsignedIntConvertibleToLabelsCheck, (Concept::Convertible<unsigned int, TLabelsType>));
  itkConceptMacro(PosteriorsAdditiveOperatorsCheck, (Concept::AdditiveOperators<TPosteriorsPrecisionType>));
  itkConceptMacro(IntConvertibleToPosteriorsCheck, (Concept::Convertible<int, TPosteriorsPrecisionType>));
  itkConceptMacro(InputHasNumericTraitsCheck, (Concept::HasNumericTraits<typename InputPixelType::ValueType>));
  itkConceptMacro(PosteriorsHasNumericTraitsCheck, (Concept::HasNumericTraits<TPosteriorsPrecisionType>));
  itkConceptMacro(PriorsHasNumericTraitsCheck, (Concept::HasNumericTraits<TPriorsPrecisionType>));
  itkConceptMacro(
    InputPriorsPosteriorsMultiplyOperatorCheck,
    (Concept::MultiplyOperator<typename InputPixelType::ValueType, PriorsPixelType, PosteriorsPixelType>));
  // End concept checking
#endif
 
protected:
  BayesianClassifierImageFilter();
  ~BayesianClassifierImageFilter() override = default;
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  void
  GenerateData() override;
 
  void
  GenerateOutputInformation() override;
 
  virtual void
  ComputeBayesRule();
 
  virtual void
  NormalizeAndSmoothPosteriors();
 
  virtual void
  ClassifyBasedOnPosteriors();
 
  PosteriorsImageType *
  GetPosteriorImage();
 
private:
  bool m_UserProvidedPriors{ false };
 
  bool m_UserProvidedSmoothingFilter{ false };
 
  SmoothingFilterPointer m_SmoothingFilter{};
 
  unsigned int m_NumberOfSmoothingIterations{ 0 };
};
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkBayesianClassifierImageFilter.hxx"
#endif
 
#endif