itkCannyEdgeDetectionRecursiveGaussianImageFilter.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    itkCannyEdgeDetectionRecursiveGaussianImageFilter.h
  Language:  C++
  Date:      $Date$
  Version:   $Revision$

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef itkCannyEdgeDetectionRecursiveGaussianImageFilter_h
#define itkCannyEdgeDetectionRecursiveGaussianImageFilter_h

#include "itkImageToImageFilter.h"
#include "itkImage.h"
#include "itkFixedArray.h"
#include "itkConstNeighborhoodIterator.h"
#include "itkSmoothingRecursiveGaussianImageFilter.h"
#include "itkMultiplyImageFilter.h"
#include "itkZeroFluxNeumannBoundaryCondition.h"
#include "itkMultiThreaderBase.h"
#include "itkDerivativeOperator.h"
#include "itkSparseFieldLayer.h"
#include "itkObjectStore.h"


namespace itk
{
using MultiThreader = MultiThreaderBase;


template <typename TValueType>
class ListNode
{
public:
  TValueType m_Value;

  ListNode   *Next;
  ListNode   *Previous;
};


template<typename TInputImage, typename TOutputImage>
class ITK_TEMPLATE_EXPORT CannyEdgeDetectionRecursiveGaussianImageFilter
  : public ImageToImageFilter<TInputImage, TOutputImage>
{
public:
  using Self = CannyEdgeDetectionRecursiveGaussianImageFilter;
  using Superclass = ImageToImageFilter<TInputImage, TOutputImage>;

  using InputImageType = TInputImage;
  using OutputImageType = TOutputImage;

  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  using InputImagePixelType = typename TInputImage::PixelType;
  using OutputImagePixelType = typename TOutputImage::PixelType;
  using IndexType = typename TInputImage::IndexType;

  using GaussianImageFilterType = SmoothingRecursiveGaussianImageFilter<
        InputImageType, OutputImageType>;
  using ScalarRealType = typename GaussianImageFilterType::ScalarRealType;
  using SigmaArrayType = typename GaussianImageFilterType::SigmaArrayType;

  using DefaultBoundaryConditionType = ZeroFluxNeumannBoundaryCondition<OutputImageType>;

  using NeighborhoodType = ConstNeighborhoodIterator<OutputImageType,
                                    DefaultBoundaryConditionType>;

  using ListNodeType = ListNode<IndexType>;
  using ListNodeStorageType = ObjectStore<ListNodeType>;
  using ListType = SparseFieldLayer<ListNodeType>;
  using ListPointerType = typename ListType::Pointer;

  itkNewMacro(Self);

  using OutputImageRegionType = typename TOutputImage::RegionType;

  itkTypeMacro(CannyEdgeDetectionRecursiveGaussianImageFilter, ImageToImageFilter);

  static constexpr unsigned int ImageDimension = TInputImage::ImageDimension;
  static constexpr unsigned int OutputImageDimension = TOutputImage::ImageDimension;

  using ArrayType = FixedArray<double, itkGetStaticConstMacro(ImageDimension)>;

  void SetSigmaArray( const SigmaArrayType & sigmas );
  void SetSigma( ScalarRealType sigma );
  SigmaArrayType GetSigmaArray() const;
  ScalarRealType GetSigma() const;

  /* Set the Threshold value for detected edges. */
  void SetThreshold(const OutputImagePixelType th)
    {
    this->m_Threshold = th;
    this->m_UpperThreshold = m_Threshold;
    this->m_LowerThreshold = m_Threshold/2.0;
    itkLegacyReplaceBodyMacro(SetThreshold, 2.2, SetUpperThreshold);
    }

  OutputImagePixelType GetThreshold(OutputImagePixelType itkNotUsed(th))
    {
    itkLegacyReplaceBodyMacro(GetThreshold, 2.2, GetUpperThreshold);
    return this->m_Threshold;
    }

  itkSetMacro(UpperThreshold, OutputImagePixelType );
  itkGetMacro(UpperThreshold, OutputImagePixelType);

  itkSetMacro(LowerThreshold, OutputImagePixelType );
  itkGetMacro(LowerThreshold, OutputImagePixelType);

  /* Set the Thresholdvalue for detected edges. */
  itkSetMacro(OutsideValue, OutputImagePixelType);
  itkGetMacro(OutsideValue, OutputImagePixelType);

  OutputImageType * GetNonMaximumSuppressionImage() const
    {
    return this->m_MultiplyImageFilter->GetOutput();
    }

  void GenerateInputRequestedRegion() throw(InvalidRequestedRegionError) override;

#ifdef ITK_USE_CONCEPT_CHECKING

  itkConceptMacro(InputHasNumericTraitsCheck,
    (Concept::HasNumericTraits<InputImagePixelType>));
  itkConceptMacro(OutputHasNumericTraitsCheck,
    (Concept::HasNumericTraits<OutputImagePixelType>));
  itkConceptMacro(SameDimensionCheck,
    (Concept::SameDimension<ImageDimension, OutputImageDimension>));
  itkConceptMacro(InputIsFloatingPointCheck,
    (Concept::IsFloatingPoint<InputImagePixelType>));
  itkConceptMacro(OutputIsFloatingPointCheck,
    (Concept::IsFloatingPoint<OutputImagePixelType>));

#endif

protected:
  CannyEdgeDetectionRecursiveGaussianImageFilter();
  CannyEdgeDetectionRecursiveGaussianImageFilter(const Self&) {}
  void PrintSelf(std::ostream& os, Indent indent) const override;

  void GenerateData() override;

  using MultiplyImageFilterType = MultiplyImageFilter< OutputImageType,
              OutputImageType, OutputImageType>;

private:
  ~CannyEdgeDetectionRecursiveGaussianImageFilter() override{};

  struct CannyThreadStruct
    {
    CannyEdgeDetectionRecursiveGaussianImageFilter *Filter;
    };

  void AllocateUpdateBuffer();

  void HysteresisThresholding();

  void FollowEdge(IndexType index);

  bool InBounds(IndexType index);


  void Compute2ndDerivative();

  //  virtual
  //  int SplitUpdateContainer(int i, int num, ThreadRegionType& splitRegion);

  void ThreadedCompute2ndDerivative(const OutputImageRegionType&
                                    outputRegionForThread, int threadId);

  static ITK_THREAD_RETURN_TYPE
  Compute2ndDerivativeThreaderCallback( void * arg );

  OutputImagePixelType ComputeCannyEdge(const NeighborhoodType &it,
                                        void *globalData );

  void Compute2ndDerivativePos();

  void ThreadedCompute2ndDerivativePos(const OutputImageRegionType&
                                       outputRegionForThread, int threadId);

  static ITK_THREAD_RETURN_TYPE
  Compute2ndDerivativePosThreaderCallback( void *arg );

  SigmaArrayType                        m_Sigma;

  ArrayType m_MaximumError;

  OutputImagePixelType m_UpperThreshold;  //should be float here?

  OutputImagePixelType m_LowerThreshold; //should be float here?

  OutputImagePixelType m_Threshold;

  OutputImagePixelType m_OutsideValue;

  typename OutputImageType::Pointer  m_UpdateBuffer1;

  typename GaussianImageFilterType::Pointer m_GaussianFilter;

  typename MultiplyImageFilterType::Pointer m_MultiplyImageFilter;

  DerivativeOperator<OutputImagePixelType,itkGetStaticConstMacro(ImageDimension)>
  m_ComputeCannyEdge1stDerivativeOper;
  DerivativeOperator<OutputImagePixelType,itkGetStaticConstMacro(ImageDimension)>
  m_ComputeCannyEdge2ndDerivativeOper;

  std::slice  m_ComputeCannyEdgeSlice[ImageDimension];

  unsigned long m_Stride[ImageDimension];
  unsigned long m_Center;

  typename ListNodeStorageType::Pointer m_NodeStore;
  ListPointerType                       m_NodeList;

};

} //end of namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkCannyEdgeDetectionRecursiveGaussianImageFilter.hxx"
#endif

#endif