itkScalarImageToCooccurrenceMatrixFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkScalarImageToCooccurrenceMatrixFilter.h,v $
  Language:  C++
  Date:      $Date: 2009-05-02 05:43:58 $
  Version:   $Revision: 1.1 $

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

#include "itkImage.h"
#include "itkHistogram.h"
#include "itkDenseFrequencyContainer2.h"
#include "itkVectorContainer.h"
#include "itkObject.h"
#include "itkNumericTraits.h"
#include "itkMacro.h"

namespace itk {
namespace Statistics {

template< class TImageType,
          class THistogramFrequencyContainer = DenseFrequencyContainer2 >
class ITK_EXPORT ScalarImageToCooccurrenceMatrixFilter : public ProcessObject
{
public:
  typedef ScalarImageToCooccurrenceMatrixFilter               Self;
  typedef ProcessObject                                       Superclass;
  typedef SmartPointer<Self>                                  Pointer;
  typedef SmartPointer<const Self>                            ConstPointer;

  itkTypeMacro(ScalarImageToCooccurrenceMatrixFilter, ProcessObject);

  itkNewMacro(Self);

  typedef TImageType                                      ImageType;
  typedef typename ImageType::Pointer                     ImagePointer;
  typedef typename ImageType::ConstPointer                ImageConstPointer;
  typedef typename ImageType::PixelType                   PixelType;
  typedef typename ImageType::RegionType                  RegionType;
  typedef typename ImageType::SizeType                    RadiusType;
  typedef typename ImageType::OffsetType                  OffsetType;
  typedef VectorContainer<unsigned char, OffsetType>      OffsetVector;
  typedef typename OffsetVector::Pointer                  OffsetVectorPointer;
  typedef typename OffsetVector::ConstPointer             OffsetVectorConstPointer;

  typedef typename NumericTraits<PixelType>::RealType     MeasurementType;

  typedef Histogram< MeasurementType, THistogramFrequencyContainer >
                                                          HistogramType;
  typedef typename HistogramType::Pointer                 HistogramPointer;
  typedef typename HistogramType::ConstPointer            HistogramConstPointer;
  typedef typename HistogramType::MeasurementVectorType   MeasurementVectorType;


  itkStaticConstMacro(DefaultBinsPerAxis, unsigned int, 256);

  itkSetConstObjectMacro( Offsets, OffsetVector );
  itkGetConstObjectMacro( Offsets, OffsetVector );
  void SetOffset( const OffsetType offset );

  itkSetMacro( NumberOfBinsPerAxis, unsigned int );
  itkGetConstMacro( NumberOfBinsPerAxis, unsigned int );

  void SetPixelValueMinMax( PixelType min, PixelType max );
  itkGetConstMacro(Min, PixelType);
  itkGetConstMacro(Max, PixelType);

  itkSetMacro(Normalize, bool);
  itkGetConstMacro(Normalize, bool);
  itkBooleanMacro(Normalize);

  void SetInput( const ImageType* image );
  const ImageType* GetInput() const;

  void SetMaskImage( const ImageType* image );
  const ImageType* GetMaskImage() const;

  const HistogramType * GetOutput() const;

  itkSetMacro( InsidePixelValue, PixelType );
  itkGetConstMacro( InsidePixelValue, PixelType );


protected:
  ScalarImageToCooccurrenceMatrixFilter();
  virtual ~ScalarImageToCooccurrenceMatrixFilter() {};
  void PrintSelf(std::ostream& os, Indent indent) const;
  virtual void FillHistogram( RadiusType radius, RegionType region );
  virtual void FillHistogramWithMask( RadiusType radius, RegionType region, const ImageType * maskImage );

   
  typedef DataObject::Pointer DataObjectPointer;
  virtual DataObjectPointer MakeOutput(unsigned int idx);

  virtual void GenerateData();

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

  void NormalizeHistogram( void );

  OffsetVectorConstPointer m_Offsets;
  PixelType                m_Min;
  PixelType                m_Max;

  unsigned int            m_NumberOfBinsPerAxis;
  MeasurementVectorType   m_LowerBound;
  MeasurementVectorType   m_UpperBound;
  bool                    m_Normalize;

  PixelType               m_InsidePixelValue;

};
    
    
} // end of namespace Statistics 
} // end of namespace itk 

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

#endif