itkLabelStatisticsImageFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkLabelStatisticsImageFilter.h,v $
  Language:  C++
  Date:      $Date: 2009-05-05 18:16:17 $
  Version:   $Revision: 1.13 $

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

#include "itkImageToImageFilter.h"
#include "itkNumericTraits.h"
#include "itkArray.h"
#include "itkSimpleDataObjectDecorator.h"
#include "itk_hash_map.h"
#include "itkHistogram.h"
#include "itkFastMutexLock.h"
#include <vector>

namespace itk {

template<class TInputImage, class TLabelImage>
class ITK_EXPORT LabelStatisticsImageFilter : 
    public ImageToImageFilter<TInputImage, TInputImage>
{
public:
  typedef LabelStatisticsImageFilter                  Self;
  typedef ImageToImageFilter<TInputImage,TInputImage> Superclass;
  typedef SmartPointer<Self>                          Pointer;
  typedef SmartPointer<const Self>                    ConstPointer;

  itkNewMacro(Self);  

  itkTypeMacro(LabelStatisticsImageFilter, ImageToImageFilter);

  typedef typename TInputImage::Pointer    InputImagePointer;
  typedef typename TInputImage::RegionType RegionType;
  typedef typename TInputImage::SizeType   SizeType;
  typedef typename TInputImage::IndexType  IndexType;
  typedef typename TInputImage::PixelType  PixelType;

  typedef TLabelImage                      LabelImageType;
  typedef typename TLabelImage::Pointer    LabelImagePointer;
  typedef typename TLabelImage::RegionType LabelRegionType;
  typedef typename TLabelImage::SizeType   LabelSizeType;
  typedef typename TLabelImage::IndexType  LabelIndexType;
  typedef typename TLabelImage::PixelType  LabelPixelType;

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

  typedef typename NumericTraits<PixelType>::RealType RealType;

  typedef typename DataObject::Pointer DataObjectPointer;

  typedef SimpleDataObjectDecorator<RealType> RealObjectType;

  typedef std::vector<typename IndexType::IndexValueType> BoundingBoxType;

#ifdef ITK_USE_REVIEW_STATISTICS
  typedef itk::Statistics::Histogram<RealType> HistogramType;
#else
  typedef itk::Statistics::Histogram<RealType,1> HistogramType;
#endif

  typedef typename HistogramType::Pointer        HistogramPointer;

  class LabelStatistics
    {
    public:

    // default constructor
    LabelStatistics()
      {
      // initialized to the default values
      m_Count = 0;
      m_Sum = NumericTraits<RealType>::Zero;
      m_SumOfSquares = NumericTraits<RealType>::Zero;
      
      // Set such that the first pixel encountered can be compared
      m_Minimum = NumericTraits<RealType>::max();
      m_Maximum = NumericTraits<RealType>::NonpositiveMin();
      
      // Default these to zero
      m_Mean = NumericTraits<RealType>::Zero;
      m_Sigma = NumericTraits<RealType>::Zero;
      m_Variance = NumericTraits<RealType>::Zero;
        
      unsigned int imageDimension = itkGetStaticConstMacro(ImageDimension);
      m_BoundingBox.resize(imageDimension*2);
      for (unsigned int i = 0; i < imageDimension * 2; i += 2)
        {
        m_BoundingBox[i] = NumericTraits<ITK_TYPENAME IndexType::IndexValueType>::max();
        m_BoundingBox[i+1] = NumericTraits<ITK_TYPENAME IndexType::IndexValueType>::NonpositiveMin();
        }
      m_Histogram = 0;
      
      }

      // constructor with histogram enabled
      LabelStatistics(int size, RealType lowerBound, RealType upperBound)
        {
        
        // initialized to the default values
        m_Count = 0;
        m_Sum = NumericTraits<RealType>::Zero;
        m_SumOfSquares = NumericTraits<RealType>::Zero;

        // Set such that the first pixel encountered can be compared
        m_Minimum = NumericTraits<RealType>::max();
        m_Maximum = NumericTraits<RealType>::NonpositiveMin();

        // Default these to zero
        m_Mean = NumericTraits<RealType>::Zero;
        m_Sigma = NumericTraits<RealType>::Zero;
        m_Variance = NumericTraits<RealType>::Zero;

        unsigned int imageDimension = itkGetStaticConstMacro(ImageDimension);
        m_BoundingBox.resize(imageDimension*2);
        for (unsigned int i = 0; i < imageDimension * 2; i += 2)
          {
          m_BoundingBox[i] = NumericTraits<ITK_TYPENAME IndexType::IndexValueType>::max();
          m_BoundingBox[i+1] = NumericTraits<ITK_TYPENAME IndexType::IndexValueType>::NonpositiveMin();
          }

        // Histogram
        m_Histogram = HistogramType::New();
        typename HistogramType::SizeType              hsize;
        typename HistogramType::MeasurementVectorType lb;
        typename HistogramType::MeasurementVectorType ub;
#ifdef ITK_USE_REVIEW_STATISTICS
        hsize.SetSize(1);
        lb.SetSize(1);
        ub.SetSize(1);
        m_Histogram->SetMeasurementVectorSize(1);
#endif
        hsize[0] = size;
        lb[0] = lowerBound;
        ub[0] = upperBound;
        m_Histogram->Initialize(hsize, lb, ub);
        }

      // need copy constructor because of smart pointer to histogram
      LabelStatistics(const LabelStatistics& l)
        {
        m_Count = l.m_Count;
        m_Minimum = l.m_Minimum;
        m_Maximum = l.m_Maximum;
        m_Mean = l.m_Mean;
        m_Sum = l.m_Sum;
        m_SumOfSquares = l.m_SumOfSquares;
        m_Sigma = l.m_Sigma;
        m_Variance = l.m_Variance;
        m_BoundingBox = l.m_BoundingBox;
        m_Histogram = l.m_Histogram;
        }

    // added for completeness
      LabelStatistics& operator= (const LabelStatistics& l)
        {
        m_Count = l.m_Count;
        m_Minimum = l.m_Minimum;
        m_Maximum = l.m_Maximum;
        m_Mean = l.m_Mean;
        m_Sum = l.m_Sum;
        m_SumOfSquares = l.m_SumOfSquares;
        m_Sigma = l.m_Sigma;
        m_Variance = l.m_Variance;
        m_BoundingBox = l.m_BoundingBox;
        m_Histogram = l.m_Histogram;
        }
      
      unsigned long m_Count;
      RealType m_Minimum;
      RealType m_Maximum;
      RealType m_Mean;
      RealType m_Sum;
      RealType m_SumOfSquares;
      RealType m_Sigma;
      RealType m_Variance;
      BoundingBoxType m_BoundingBox;
      typename HistogramType::Pointer m_Histogram;
  };
  
  typedef itk::hash_map<LabelPixelType, LabelStatistics> MapType;
  typedef typename itk::hash_map<LabelPixelType, LabelStatistics>::iterator MapIterator;
  typedef typename itk::hash_map<LabelPixelType, LabelStatistics>::const_iterator MapConstIterator;

  // macros for Histogram enables
  itkSetMacro(UseHistograms, bool);
  itkGetConstMacro(UseHistograms, bool);
  itkBooleanMacro(UseHistograms);
  
  void SetLabelInput(TLabelImage *input)
    {
      // Process object is not const-correct so the const casting is required.
      this->SetNthInput(1, const_cast<TLabelImage *>(input) );
    }

  LabelImageType * GetLabelInput()
    {
      return static_cast<LabelImageType*>(const_cast<DataObject *>(this->ProcessObject::GetInput(1)));
    }

  bool HasLabel(LabelPixelType label) const
    {
    return m_LabelStatistics.find(label) != m_LabelStatistics.end();
    }

  unsigned long GetNumberOfObjects() const
    {
    return m_LabelStatistics.size();
    }
  unsigned long GetNumberOfLabels() const
    {
    return this->GetNumberOfObjects();
    }

  
  RealType GetMinimum(LabelPixelType label) const;

  RealType GetMaximum(LabelPixelType label) const;

  RealType GetMean(LabelPixelType label) const;

  RealType GetMedian(LabelPixelType label) const;

  RealType GetSigma(LabelPixelType label) const;

  RealType GetVariance(LabelPixelType label) const;

  BoundingBoxType GetBoundingBox(LabelPixelType label) const;

  RegionType GetRegion(LabelPixelType label) const;

  RealType GetSum(LabelPixelType label) const;

  unsigned long GetCount(LabelPixelType label) const;

  HistogramPointer GetHistogram(LabelPixelType label) const;

  void SetHistogramParameters(const int numBins, RealType lowerBound,
    RealType upperBound);

#ifdef ITK_USE_CONCEPT_CHECKING

  itkConceptMacro(InputHasNumericTraitsCheck,
                  (Concept::HasNumericTraits<PixelType>));

#endif

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

  void AllocateOutputs();

  void BeforeThreadedGenerateData ();

  void AfterThreadedGenerateData ();

  void  ThreadedGenerateData (const RegionType& 
         outputRegionForThread,
         int threadId);

  // Override since the filter needs all the data for the algorithm
  void GenerateInputRequestedRegion();

  // Override since the filter produces all of its output
  void EnlargeOutputRequestedRegion(DataObject *data);


private:
  LabelStatisticsImageFilter(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented

  std::vector<MapType>  m_LabelStatisticsPerThread;
  MapType               m_LabelStatistics;

  bool                             m_UseHistograms;
  typename HistogramType::SizeType m_NumBins;
  RealType                         m_LowerBound;
  RealType                         m_UpperBound;
  SimpleFastMutexLock              m_Mutex;

}; // end of class

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

#endif

---