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< class TInputImage >
class ITK_EXPORT Segmenter:
  public ProcessObject
{
public:
  typedef Segmenter Self;

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

  typedef Image< IdentifierType, 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;

  itkStaticConstMacro(NULL_LABEL, unsigned long, 0);

  itkStaticConstMacro(NULL_FLOW, unsigned long, -1);

  InputImageType * GetInputImage(void)
  {
    return itkDynamicCastInDebugMode< InputImageType * >
           ( this->ProcessObject::GetInput(0) );
  }

  void SetInputImage(InputImageType *img)
  {  this->ProcessObject::SetNthInput(0, img); }

  OutputImageType * GetOutputImage(void)
  {
    return itkDynamicCastInDebugMode< OutputImageType * >
           ( this->ProcessObject::GetOutput(0) );
  }

  void SetOutputImage(OutputImageType *img)
  { this->ProcessObject::SetNthOutput(0, img);    }

  SegmentTableType * GetSegmentTable(void)
  {
    return itkDynamicCastInDebugMode< SegmentTableType * >
           ( this->ProcessObject::GetOutput(1) );
  }

  void SetSegmentTable(SegmentTableType *s)
  { this->ProcessObject::SetNthOutput(1, s); }

  BoundaryType * GetBoundary(void)
  {
    return itkDynamicCastInDebugMode< 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);

  typedef ProcessObject::DataObjectPointerArraySizeType DataObjectPointerArraySizeType;
  using Superclass::MakeOutput;
  virtual DataObjectPointer MakeOutput(DataObjectPointerArraySizeType idx);

  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;
    flat_region_t():is_on_boundary(false) {}
  };

  typedef itksys::hash_map< IdentifierType, flat_region_t, itksys::hash< IdentifierType > >
  flat_region_table_t;

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

  typedef itksys::hash_map< IdentifierType, InputPixelType, itksys::hash< IdentifierType >
                            > edge_table_t;

  typedef itksys::hash_map< IdentifierType, edge_table_t, itksys::hash< IdentifierType >
                         > 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,
                                   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