itkWatershedSegmentTreeGenerator.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkWatershedSegmentTreeGenerator.h,v $
  Language:  C++
  Date:      $Date: 2009-01-27 19:30:19 $
  Version:   $Revision: 1.14 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkWatershedSegmentTreeGenerator_h
#define __itkWatershedSegmentTreeGenerator_h

#include "itkWatershedSegmentTable.h"
#include "itkWatershedSegmentTree.h"
#include "itkEquivalencyTable.h"
#include "itkOneWayEquivalencyTable.h"

#include <algorithm>
#include <utility>

namespace itk
{
namespace watershed
{
 
template <class TScalarType>
class ITK_EXPORT SegmentTreeGenerator  : public ProcessObject
{
public:

  typedef SegmentTreeGenerator     Self;
  typedef ProcessObject            Superclass;
  typedef SmartPointer<Self>       Pointer;
  typedef SmartPointer<const Self> ConstPointer;
  itkNewMacro(Self);
  itkTypeMacro(WatershedSegmentTreeGenerator, ProcessObject);

  typedef TScalarType              ScalarType;
  typedef SegmentTable<ScalarType> SegmentTableType;
  typedef SegmentTree<ScalarType>  SegmentTreeType;
  typedef EquivalencyTable         EquivalencyTableType;
  typedef OneWayEquivalencyTable   OneWayEquivalencyTableType;
  typedef DataObject::Pointer      DataObjectPointer;

  typedef typename SegmentTableType::Pointer SegmentTableTypePointer;
  typedef typename OneWayEquivalencyTableType::Pointer
                                             OneWayEquivalencyTableTypePointer;
  typedef typename SegmentTreeType::Pointer  SegmentTreeTypePointer;


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

  itkSetMacro(Merge, bool);
  itkGetMacro(Merge, bool);

  void SetFloodLevel(double);
  itkGetMacro(FloodLevel, double);

  itkSetMacro(HighestCalculatedFloodLevel, double);
  itkGetMacro(HighestCalculatedFloodLevel, double);

  itkSetMacro(ConsumeInput, bool);
  itkGetMacro(ConsumeInput, bool);

  static void MergeSegments(SegmentTableTypePointer,
                            OneWayEquivalencyTableTypePointer,
                            const unsigned long,
                            const unsigned long);

  static void PruneMergeSegments(SegmentTableTypePointer,
                                 OneWayEquivalencyTableTypePointer,
                                 const unsigned long,
                                 const unsigned long,
                                 ScalarType);

  virtual DataObjectPointer MakeOutput(unsigned int idx);

protected:
  SegmentTreeGenerator();
  virtual ~SegmentTreeGenerator() {}
  SegmentTreeGenerator(const Self&) {}
  void operator=(const Self&) {}
  void PrintSelf(std::ostream& os, Indent indent) const;
  
  void CompileMergeList(SegmentTableTypePointer, SegmentTreeTypePointer);

  void ExtractMergeHierarchy(SegmentTableTypePointer, SegmentTreeTypePointer);

  void MergeEquivalencies();

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

private:
  bool   m_Merge;
  double m_FloodLevel;
  bool   m_ConsumeInput;

  OneWayEquivalencyTableType::Pointer m_MergedSegmentsTable;
  
  double m_HighestCalculatedFloodLevel;
};

}// end namespace watershed
}// end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkWatershedSegmentTreeGenerator.txx"
#endif

#endif