itkWatershedSegmenter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    itkWatershedSegmenter.h
  Language:  C++
  Date:      $Date$
  Version:   $Revision$

  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 __itkWatershedSegmenter_h
#define __itkWatershedSegmenter_h

#if defined(_MSC_VER)
#pragma warning ( disable : 4786 )
#endif

#include "itk_hash_map.h"
#include "itkWatershedBoundary.h"
#include "itkWatershedSegmentTable.h"
#include "itkEquivalencyTable.h"
#include "itkImage.h"

namespace itk
{
namespace watershed
{
template <class TInputImage>
class ITK_EXPORT Segmenter
  : public ProcessObject
{
public:
  typedef Segmenter Self;

  typedef TInputImage InputImageType;
  itkStaticConstMacro(ImageDimension, unsigned int,
                      TInputImage::ImageDimension);

  typedef Image<unsigned long, itkGetStaticConstMacro(ImageDimension)>
                                                   OutputImageType;
  typedef typename InputImageType::RegionType      ImageRegionType;
  typedef typename InputImageType::PixelType       InputPixelType;
  typedef Boundary<InputPixelType, itkGetStaticConstMacro(ImageDimension)>
                                                   BoundaryType;
  typedef typename BoundaryType::IndexType         BoundaryIndexType;
  typedef typename BoundaryType::FlatHashValueType BoundaryFlatHashValueType;
  typedef SegmentTable<InputPixelType>             SegmentTableType;
  typedef DataObject::Pointer                      DataObjectPointer;
  
  typedef ProcessObject            Superclass;
  typedef SmartPointer<Self>       Pointer;
  typedef SmartPointer<const Self> ConstPointer;
  itkNewMacro(Self);
  itkTypeMacro(WatershedSegmenter, ProcessObject);

  typedef typename InputImageType::Pointer   InputImageTypePointer;
  typedef typename OutputImageType::Pointer  OutputImageTypePointer;
  typedef typename SegmentTableType::Pointer SegmentTableTypePointer;
  typedef typename BoundaryType::Pointer     BoundaryTypePointer;
    
  static unsigned long NULL_LABEL;

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

  OutputImageType * GetOutputImage(void)
    {
    return static_cast<OutputImageType *>
      (this->ProcessObject::GetOutput(0));
    }
  void SetOutputImage(OutputImageType *img)
    { this->ProcessObject::SetNthOutput(0, img);    }
  
  SegmentTableType * GetSegmentTable(void)
    {
    return static_cast<SegmentTableType *>
      (this->ProcessObject::GetOutput(1));
    }
  void SetSegmentTable(SegmentTableType *s)
    { this->ProcessObject::SetNthOutput(1, s); }
  
  BoundaryType * GetBoundary(void)
    {
    return static_cast<BoundaryType *>
      (this->ProcessObject::GetOutput(2));
    }
  void SetBoundary(BoundaryType *b)
    { this->ProcessObject::SetNthOutput(2,b); }
  
  void GenerateData();

  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);
  
  virtual DataObjectPointer MakeOutput(unsigned int idx);

  itkSetMacro(CurrentLabel, unsigned long);
  itkGetConstMacro(CurrentLabel, unsigned long);

  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
    {
    unsigned long   *min_label_ptr;
    InputPixelType  bounds_min;
    //    InputPixelType  bounds_max; // <-- may not be necc.
    InputPixelType  value;
    bool            is_on_boundary;
    flat_region_t() : is_on_boundary(false) {}
    };

  typedef itk::hash_map<unsigned long, flat_region_t, itk::hash<unsigned long> >
  flat_region_table_t;

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

  typedef itk::hash_map<unsigned long, InputPixelType, itk::hash<unsigned long> 
  > edge_table_t;
  
  typedef itk::hash_map<unsigned long, edge_table_t, itk::hash<unsigned long>
  > edge_table_hash_t;
  
  Segmenter();
  Segmenter(const Self&) {}
  virtual ~Segmenter();
  void PrintSelf(std::ostream& os, Indent indent) const;
  void operator=(const Self&) {}
  
  virtual void GenerateConnectivity();
  
  void GenerateInputRequestedRegion();
  void GenerateOutputRequestedRegion(DataObject *output);
  void UpdateOutputInformation();

  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,
                             unsigned long 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;
  unsigned long m_CurrentLabel;
};
  
}// end namespace watershed
}// end namespace itk

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

#endif