itkThresholdMaximumConnectedComponentsImageFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkThresholdMaximumConnectedComponentsImageFilter.h,v $
  Language:  C++
  Date:      $Date: 2007-04-27 19:05:39 $
  Version:   $Revision: 1.4 $

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

#include "itkInPlaceImageFilter.h"
#include "itkBinaryThresholdImageFilter.h"
#include "itkConnectedComponentImageFilter.h"
#include "itkRelabelComponentImageFilter.h"
#include "itkMinimumMaximumImageCalculator.h"
#include "itkCastImageFilter.h"

#include "itkConceptChecking.h"

namespace itk
{

template <class TInputImage, class TOutputImage = TInputImage>
class ITK_EXPORT ThresholdMaximumConnectedComponentsImageFilter : 
  public ImageToImageFilter< TInputImage , TOutputImage >
{
public:
  typedef ThresholdMaximumConnectedComponentsImageFilter Self;
  typedef ImageToImageFilter<TInputImage,TOutputImage>   Superclass;
  typedef SmartPointer<Self>                             Pointer;
  typedef SmartPointer<const Self>                       ConstPointer;

  itkNewMacro(Self);  

  itkTypeMacro( ThresholdMaximumConnectedComponentsImageFilter,
                ImageToImageFilter );

  typedef typename TInputImage::PixelType   PixelType;

  itkConceptMacro(PixelTypeComparable, (Concept::Comparable<PixelType>));

  itkSetMacro( MinimumObjectSizeInPixels, unsigned int );
  itkGetMacro( MinimumObjectSizeInPixels, unsigned int );

  itkSetMacro( InsideValue, PixelType );
  itkSetMacro( OutsideValue, PixelType );
  itkSetMacro( UpperBoundary, PixelType );
  itkGetMacro( InsideValue, PixelType );
  itkGetMacro( OutsideValue, PixelType );
  itkGetMacro( UpperBoundary, PixelType );

 itkGetMacro( NumberOfObjects, unsigned long );

  itkGetMacro( ThresholdValue, PixelType );

  typedef TInputImage                           InputImageType;
  typedef typename InputImageType::ConstPointer InputImagePointer;
  typedef typename InputImageType::RegionType   InputImageRegionType;
  typedef typename InputImageType::PixelType    InputImagePixelType;

  typedef TOutputImage                         OutputImageType;
  typedef typename OutputImageType::Pointer    OutputImagePointer;
  typedef typename OutputImageType::RegionType OutputImageRegionType;
  typedef typename OutputImageType::PixelType  OutputImagePixelType;


protected:
  ThresholdMaximumConnectedComponentsImageFilter();
  ~ThresholdMaximumConnectedComponentsImageFilter() {};
  void PrintSelf(std::ostream& os, Indent indent) const;

  void GenerateData(void);

  unsigned long int ComputeConnectedComponents(void); 


private:
 
  typedef unsigned int FilterPixelType;

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

  typedef itk::Image< FilterPixelType, itkGetStaticConstMacro(ImageDimension) >
 FilterImageType; 

  typedef typename FilterImageType::Pointer FilterImagePointer;

  //purposely not implemented
  ThresholdMaximumConnectedComponentsImageFilter(const Self&);
  void operator=(const Self&); //purposely not implemented
   
  
  //
  // Binary Threshold Filter
  //
  typedef BinaryThresholdImageFilter< InputImageType, OutputImageType >
  ThresholdFilterType;

  
  // 
  // Connected Components Filter  
  //
  typedef ConnectedComponentImageFilter< OutputImageType, FilterImageType >
  ConnectedFilterType;

  
  //
  // Relabeled Components Filter
  //
  typedef RelabelComponentImageFilter< FilterImageType, FilterImageType >
  RelabelFilterType;

  
  //
  // Minimum maximum calculator
  //
  typedef MinimumMaximumImageCalculator< InputImageType > MinMaxCalculatorType;

  // 
  // Declare member variables for the filters of the internal pipeline.
  //
  typename ThresholdFilterType::Pointer            m_ThresholdFilter;
  typename ConnectedFilterType::Pointer            m_ConnectedComponent;
  typename RelabelFilterType::Pointer              m_LabeledComponent;
  typename MinMaxCalculatorType::Pointer           m_MinMaxCalculator;

  // Variables defined by the user
  unsigned int m_MinimumObjectSizeInPixels;
  
  // Binary threshold variables
  PixelType  m_OutsideValue;
  PixelType  m_InsideValue;
  PixelType  m_LowerBoundary;
  PixelType  m_UpperBoundary;

  // Filter variables
  PixelType      m_ThresholdValue;
  unsigned long  m_NumberOfObjects;
  
};

  
} // end namespace itk
  
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkThresholdMaximumConnectedComponentsImageFilter.txx"
#endif
  
#endif

---