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();

    // makes the iterator go one step further
    void DoExtendedFloodStep();

    // set-method for member-variable
    void SetExpansionDirection(bool upwards);

    // Init-method
    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());
    }
    //[!] is never called?!

    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() 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;

    // Calculate the value the outputImage is initialized to
    static int CalculateInitializeValue(int lower, int upper) { return ((upper - lower) + 1) * (-1); };
    int GetLeakagePoint(void) { return m_DetectedLeakagePoint; }
  protected:
    /*
    * @brief Pointer on the output image to which the result shall be written
    */
    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();

    // calculates how many steps the voxel is from the current step
    int EstimateDistance(IndexType);

    // calculates how many expansion steps will be taken
    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.txx"
#endif

#endif