itkAdaptiveThresholdIterator.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef itkAdaptiveThresholdIterator_h
#define itkAdaptiveThresholdIterator_h
 
#include <itkConditionalConstIterator.h>
#include <itkImage.h>
#include <itkIndex.h>
#include <itkSize.h>
 
#include <map>
#include <queue>
#include <utility>
#include <vector>
 
namespace itk
{
  template <class TImage, class TFunction>
  class ITK_EXPORT AdaptiveThresholdIterator : public ConditionalConstIterator<TImage>
  {
  public:
    typedef AdaptiveThresholdIterator Self;
 
    typedef ConditionalConstIterator<TImage> Superclass;
 
    typedef TImage ImageType;
 
    // A temporary image used for storing info about all indices
    typedef TImage TTempImage;
 
    typename TTempImage::Pointer tempPtr;
    //[!] isn't really used?!
 
    typedef TFunction FunctionType;
 
    typedef typename TFunction::InputType FunctionInputType;
 
    typedef typename TImage::SizeType SizeType;
 
    typedef typename TImage::RegionType RegionType;
 
    typedef typename TImage::IndexType IndexType;
 
    typedef typename TImage::InternalPixelType InternalPixelType;
 
    typedef typename TImage::PixelType PixelType;
 
    typedef std::queue<IndexType> IndexQueueType;
 
    typedef std::map<unsigned int, IndexQueueType> QueueMapType;
 
    itkStaticConstMacro(NDimensions, unsigned int, TImage::ImageDimension);
 
    AdaptiveThresholdIterator(ImageType *imagePtr, FunctionType *fnPtr, IndexType startIndex);
 
    AdaptiveThresholdIterator(ImageType *imagePtr, FunctionType *fnPtr, std::vector<IndexType> &startIndex);
 
    AdaptiveThresholdIterator(ImageType *imagePtr, FunctionType *fnPtr);
 
    ~AdaptiveThresholdIterator() override{};
 
    void InitializeIterator();
 
    void DoExtendedFloodStep();
 
    void SetExpansionDirection(bool upwards);
 
    void InitRegionGrowingState();
 
    void SetMinTH(int min);
 
    void SetMaxTH(int max);
 
    int GetSeedPointValue(void);
 
    void SetFineDetectionMode(bool fine = false)
    {
      m_FineDetectionMode = fine;
      m_DetectionStop = false;
    }
 
    const IndexType GetIndex() override
    {
      return (*m_QueueMap.find(m_RegionGrowingState)).second.front();
    } // [!] is never called?!
 
    const PixelType Get(void) const override
    {
      return const_cast<ImageType *>(this->m_Image.GetPointer())
        ->GetPixel((*m_QueueMap.find(m_RegionGrowingState)).second.front());
    }
 
    void Set(const PixelType &value)
    {
      const_cast<ImageType *>(this->m_Image.GetPointer())
        ->GetPixel((*m_QueueMap.find(m_RegionGrowingState)).second.front()) = value;
    }
 
    void GoToBegin();
 
    bool IsAtEnd() const override { return this->m_IsAtEnd; };
 
    void operator++() override { this->DoExtendedFloodStep(); }
 
    virtual SmartPointer<FunctionType> GetFunction() const { return m_Function; }
    Self &operator=(const Self &it)
    {
      this->m_Image = it.m_Image; // copy the smart pointer
      this->m_Region = it.m_Region;
      this->m_InitializeValue = it.m_InitializeValue;
      this->m_RegionGrowingState = it.m_RegionGrowingState;
      this->m_MinTH = it.m_MinTH;
      this->m_MaxTH = it.m_MaxTH;
      this->m_SeedPointValue = it.m_SeedPointValue;
      this->m_VoxelCounter = it.m_VoxelCounter;
      this->m_LastVoxelNumber = it.m_LastVoxelNumber;
      this->m_DetectedLeakagePoint = it.m_DetectedLeakagePoint;
      this->m_CurrentLeakageRatio = it.m_CurrentLeakageRatio;
      return *this;
    }
 
    bool IsPixelIncluded(const IndexType &index) const override;
 
    static int CalculateInitializeValue(int lower, int upper) { return ((upper - lower) + 1) * (-1); };
 
    int GetLeakagePoint(void) { return m_DetectedLeakagePoint; }
  protected:
    SmartPointer<ImageType> m_OutputImage;
 
    SmartPointer<FunctionType> m_Function;
 
    std::vector<IndexType> m_StartIndices;
 
    typename ImageType::PointType m_ImageOrigin;
 
    typename ImageType::SpacingType m_ImageSpacing;
 
    RegionType m_ImageRegion;
 
    bool m_UpwardsExpansion;
 
    int m_InitializeValue;
 
    void ExpandThresholdUpwards();
 
    void ExpandThresholdDownwards();
 
    void IncrementRegionGrowingState();
 
    int EstimateDistance(IndexType);
 
    unsigned int CalculateMaxRGS();
 
  private:
    void InsertIndexTypeIntoQueueMap(unsigned int key, IndexType index);
 
    int m_RegionGrowingState;
 
    QueueMapType m_QueueMap;
 
    int m_MinTH;
 
    int m_MaxTH;
 
    int m_SeedPointValue;
 
    unsigned int m_VoxelCounter;
    unsigned int m_LastVoxelNumber;
 
    int m_DetectedLeakagePoint;
    float m_CurrentLeakageRatio;
 
    void CheckSeedPointValue();
 
    /* flag for switching between raw leakage detection (bigger bronchial vessels)
    * and fine leakage detection (smaller bronchial vessels [starting from leaves])
    */
    bool m_FineDetectionMode;
    bool m_DetectionStop;
  };
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#include <itkAdaptiveThresholdIterator.tpp>
#endif
 
#endif