itkWatershedSegmenter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkWatershedSegmenter.h,v $
  Language:  C++
  Date:      $Date: 2002/09/11 19:39:01 $
  Version:   $Revision: 1.8 $

  Copyright (c) 2002 Insight 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 "itkWatershedEquivalencyTable.h"
#include "itkImage.h"

namespace itk
{
namespace watershed
{
template <class TInputImage>
class 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(Segmenter, 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);
  itkGetMacro(CurrentLabel, unsigned long);

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

  itkSetMacro(DoBoundaryAnalysis, bool);
  itkGetMacro(DoBoundaryAnalysis, bool);

  itkGetMacro(Minimum, InputPixelType);
  itkSetMacro(Minimum, InputPixelType);
  itkGetMacro(Maximum, InputPixelType);
  itkSetMacro(Maximum, InputPixelType);
  
  itkGetMacro(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()
    {
      if (m_Connectivity.index != 0)     delete[] m_Connectivity.index;
      if (m_Connectivity.direction !=0 ) delete[] m_Connectivity.direction;
    }
  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 SetImageValues(InputImageTypePointer img,
                             const ImageRegionType region,
                             InputPixelType value);

  static void SetImageValues(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;
  InputPixelType m_Minimum;
  InputPixelType m_Maximum;
  unsigned long m_CurrentLabel;
};
  
}// end namespace watershed
}// end namespace itk

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

#endif

---