itkWatershedSegmentTreeGenerator.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
 *
 *         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 itkWatershedSegmentTreeGenerator_h
#define itkWatershedSegmentTreeGenerator_h
 
#include "itkWatershedSegmentTable.h"
#include "itkWatershedSegmentTree.h"
#include "itkEquivalencyTable.h"
 
#include <algorithm>
#include <utility>
 
namespace itk
{
namespace watershed
{
template <typename TScalar>
class ITK_TEMPLATE_EXPORT SegmentTreeGenerator : public ProcessObject
{
public:
 
  using Self = SegmentTreeGenerator;
  using Superclass = ProcessObject;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkNewMacro(Self);
  itkTypeMacro(WatershedSegmentTreeGenerator, ProcessObject);
 
  using ScalarType = TScalar;
  using SegmentTableType = SegmentTable<ScalarType>;
  using SegmentTreeType = SegmentTree<ScalarType>;
  using EquivalencyTableType = EquivalencyTable;
  using OneWayEquivalencyTableType = OneWayEquivalencyTable;
  using DataObjectPointer = DataObject::Pointer;
 
  using SegmentTableTypePointer = typename SegmentTableType::Pointer;
  using OneWayEquivalencyTableTypePointer = typename OneWayEquivalencyTableType::Pointer;
  using SegmentTreeTypePointer = typename SegmentTreeType::Pointer;
 
  SegmentTableType *
  GetInputSegmentTable()
  {
    return static_cast<SegmentTableType *>(this->ProcessObject::GetInput(0));
  }
 
  void
  SetInputSegmentTable(SegmentTableType * st)
  {
    // Reset the highest calculated flood level if we are given a
    // different input image.
    if (st != this->GetInput(0))
    {
      m_HighestCalculatedFloodLevel = 0.0;
    }
    this->ProcessObject::SetNthInput(0, st);
  }
 
  void
  SetInputEquivalencyTable(EquivalencyTableType * eq)
  {
    this->ProcessObject::SetNthInput(1, eq);
  }
 
  EquivalencyTableType *
  GetInputEquivalencyTable()
  {
    return static_cast<EquivalencyTableType *>(this->ProcessObject::GetInput(1));
  }
 
  SegmentTreeType *
  GetOutputSegmentTree()
  {
    return static_cast<SegmentTreeType *>(this->ProcessObject::GetOutput(0));
  }
 
  void
  GenerateData() override;
 
  itkSetMacro(Merge, bool);
  itkGetConstMacro(Merge, bool);
 
  void
  SetFloodLevel(double);
 
  itkGetConstMacro(FloodLevel, double);
 
  itkSetMacro(HighestCalculatedFloodLevel, double);
  itkGetConstMacro(HighestCalculatedFloodLevel, double);
 
  itkSetMacro(ConsumeInput, bool);
  itkGetConstMacro(ConsumeInput, bool);
 
  static void
  MergeSegments(SegmentTableTypePointer, OneWayEquivalencyTableTypePointer, const IdentifierType, const IdentifierType);
 
  static void
  PruneMergeSegments(SegmentTableTypePointer,
                     OneWayEquivalencyTableTypePointer,
                     const IdentifierType,
                     const IdentifierType,
                     ScalarType);
 
  using DataObjectPointerArraySizeType = ProcessObject::DataObjectPointerArraySizeType;
  using Superclass::MakeOutput;
  DataObjectPointer
  MakeOutput(DataObjectPointerArraySizeType idx) override;
 
protected:
  SegmentTreeGenerator();
  ~SegmentTreeGenerator() override = default;
  SegmentTreeGenerator(const Self &) {}
  void
  operator=(const Self &)
  {}
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  void CompileMergeList(SegmentTableTypePointer, SegmentTreeTypePointer);
 
  void ExtractMergeHierarchy(SegmentTableTypePointer, SegmentTreeTypePointer);
 
  void
  MergeEquivalencies();
 
  void
  GenerateOutputRequestedRegion(DataObject * output) override;
 
  void
  GenerateInputRequestedRegion() override;
 
private:
  bool   m_Merge{ false };
  double m_FloodLevel{ 0.0 };
  bool   m_ConsumeInput{ false };
 
  using HashMapType = std::unordered_map<IdentifierType, bool>;
 
  OneWayEquivalencyTableType::Pointer m_MergedSegmentsTable;
 
  double m_HighestCalculatedFloodLevel{ 0.0 };
};
} // end namespace watershed
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkWatershedSegmentTreeGenerator.hxx"
#endif
 
#endif