itkWatershedSegmenter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  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
 *
 *         http://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);
  itkTypeMacro(WatershedSegmenter, ProcessObject);

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

  using flat_region_table_t = itksys::hash_map< IdentifierType, flat_region_t, itksys::hash< IdentifierType > >;

  struct connectivity_t {
    unsigned int size;
    unsigned int *index;
    typename InputImageType::OffsetType * direction;
  };

  using edge_table_t = itksys::hash_map< IdentifierType, InputPixelType, itksys::hash< IdentifierType > >;

  using edge_table_hash_t = itksys::hash_map< IdentifierType, edge_table_t, itksys::hash< IdentifierType > >;

  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