itkWatershedSegmenter.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 itkWatershedSegmenter_h
#define itkWatershedSegmenter_h
 
 
#include "itkWatershedBoundary.h"
#include "itkWatershedSegmentTable.h"
#include "itkEquivalencyTable.h"
 
namespace itk
{
namespace watershed
{
template <typename TInputImage>
class ITK_TEMPLATE_EXPORT Segmenter : public ProcessObject
{
public:

  using Self = Segmenter;

  using InputImageType = TInputImage;
  static constexpr unsigned int ImageDimension = TInputImage::ImageDimension;
 
  using OutputImageType = Image<IdentifierType, Self::ImageDimension>;
  using ImageRegionType = typename InputImageType::RegionType;
  using InputPixelType = typename InputImageType::PixelType;
  using BoundaryType = Boundary<InputPixelType, Self::ImageDimension>;
  using BoundaryIndexType = typename BoundaryType::IndexType;
  using BoundaryFlatHashValueType = typename BoundaryType::FlatHashValueType;
  using SegmentTableType = SegmentTable<InputPixelType>;
  using DataObjectPointer = DataObject::Pointer;

  using Superclass = ProcessObject;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
  itkNewMacro(Self);
  itkOverrideGetNameOfClassMacro(Segmenter);

  using InputImageTypePointer = typename InputImageType::Pointer;
  using OutputImageTypePointer = typename OutputImageType::Pointer;
  using SegmentTableTypePointer = typename SegmentTableType::Pointer;
  using BoundaryTypePointer = typename BoundaryType::Pointer;

  static constexpr IdentifierType NULL_LABEL = 0;

  static constexpr short NULL_FLOW = -1;

  InputImageType *
  GetInputImage()
  {
    return itkDynamicCastInDebugMode<InputImageType *>(this->ProcessObject::GetInput(0));
  }
 
  void
  SetInputImage(InputImageType * img)
  {
    this->ProcessObject::SetNthInput(0, img);
  }

  OutputImageType *
  GetOutputImage()
  {
    return itkDynamicCastInDebugMode<OutputImageType *>(this->ProcessObject::GetOutput(0));
  }
 
  void
  SetOutputImage(OutputImageType * img)
  {
    this->ProcessObject::SetNthOutput(0, img);
  }

  SegmentTableType *
  GetSegmentTable()
  {
    return itkDynamicCastInDebugMode<SegmentTableType *>(this->ProcessObject::GetOutput(1));
  }
 
  void
  SetSegmentTable(SegmentTableType * s)
  {
    this->ProcessObject::SetNthOutput(1, s);
  }

  BoundaryType *
  GetBoundary()
  {
    return itkDynamicCastInDebugMode<BoundaryType *>(this->ProcessObject::GetOutput(2));
  }
 
  void
  SetBoundary(BoundaryType * b)
  {
    this->ProcessObject::SetNthOutput(2, b);
  }

  void
  GenerateData() override;

  void
  SetLargestPossibleRegion(ImageRegionType reg)
  {
    if (reg == m_LargestPossibleRegion)
    {
      return;
    }
    m_LargestPossibleRegion = reg;
    this->Modified();
  }

 
  ImageRegionType
  GetLargestPossibleRegion() const
  {
    return m_LargestPossibleRegion;
  }

  static void RelabelImage(OutputImageTypePointer, ImageRegionType, EquivalencyTable::Pointer);

  using DataObjectPointerArraySizeType = ProcessObject::DataObjectPointerArraySizeType;
  using Superclass::MakeOutput;
  DataObjectPointer
  MakeOutput(DataObjectPointerArraySizeType idx) override;

  itkSetMacro(CurrentLabel, IdentifierType);
  itkGetConstMacro(CurrentLabel, IdentifierType);

  itkSetClampMacro(Threshold, double, 0.0, 1.0);
  itkGetConstMacro(Threshold, double);

  itkSetMacro(DoBoundaryAnalysis, bool);
  itkGetConstMacro(DoBoundaryAnalysis, bool);

  itkGetConstMacro(SortEdgeLists, bool);
  itkSetMacro(SortEdgeLists, bool);
 
protected:
  struct flat_region_t
  {
    IdentifierType * min_label_ptr;
    InputPixelType   bounds_min;
    //    InputPixelType  bounds_max; // <-- may not be necc.
    InputPixelType value;
    bool           is_on_boundary{ false };
    flat_region_t() = default;
  };

  using flat_region_table_t = std::unordered_map<IdentifierType, flat_region_t>;
 
  struct connectivity_t
  {
    unsigned int                          size;
    unsigned int *                        index;
    typename InputImageType::OffsetType * direction;
  };

  using edge_table_t = std::map<IdentifierType, InputPixelType>;
 
  using edge_table_hash_t = std::unordered_map<IdentifierType, edge_table_t>;
 
  Segmenter();
  Segmenter(const Self &) {}
  ~Segmenter() override;
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  void
  operator=(const Self &)
  {}

  virtual void
  GenerateConnectivity();

  void
  GenerateInputRequestedRegion() override;
 
  void
  GenerateOutputRequestedRegion(DataObject * output) override;
 
  void
  UpdateOutputInformation() override;

  void
  InitializeBoundary();

  void
  AnalyzeBoundaryFlow(InputImageTypePointer, flat_region_table_t &, InputPixelType);

  void BuildRetainingWall(InputImageTypePointer, ImageRegionType, InputPixelType);

  void
  LabelMinima(InputImageTypePointer, ImageRegionType, flat_region_table_t &, InputPixelType);

  void GradientDescent(InputImageTypePointer, ImageRegionType);

  void
  DescendFlatRegions(flat_region_table_t &, ImageRegionType);

  void UpdateSegmentTable(InputImageTypePointer, ImageRegionType);

  void
  CollectBoundaryInformation(flat_region_table_t &);

  static void
  Threshold(InputImageTypePointer destination,
            InputImageTypePointer source,
            const ImageRegionType source_region,
            const ImageRegionType destination_region,
            InputPixelType        threshold);

  static void
  MinMax(InputImageTypePointer img, ImageRegionType region, InputPixelType & min, InputPixelType & max);

  static void
  MergeFlatRegions(flat_region_table_t &, EquivalencyTable::Pointer);

  static void
  SetInputImageValues(InputImageTypePointer img, const ImageRegionType region, InputPixelType value);
 
  static void
  SetOutputImageValues(OutputImageTypePointer img, const ImageRegionType region, IdentifierType value);

  //  bool CheckLabeledBoundaries();

  connectivity_t m_Connectivity{};
 
private:
  //  void PrintFlatRegions(flat_region_table_t &t);

  ImageRegionType m_LargestPossibleRegion{};
 
  bool           m_SortEdgeLists{};
  bool           m_DoBoundaryAnalysis{};
  double         m_Threshold{};
  double         m_MaximumFloodLevel{};
  IdentifierType m_CurrentLabel{};
};
} // end namespace watershed
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkWatershedSegmenter.hxx"
#endif
 
#endif