old/mitkImageStatisticsCalculator.h

Go to the documentation of this file.

/*===================================================================
The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

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

#ifndef _MITK_IMAGESTATISTICSCALCULATOR_H
#define _MITK_IMAGESTATISTICSCALCULATOR_H

#include <itkObject.h>
#include "MitkImageStatisticsExports.h"
#include <itkImage.h>
#include <itkTimeStamp.h>
#include "mitkImage.h"
#include "mitkPlanarFigure.h"

#ifndef __itkHistogram_h
#include <itkHistogram.h>
#endif

#include <itkImageRegionIteratorWithIndex.h>


#include <vtkSmartPointer.h>

// just a helper to unclutter our code
// to be replaced with references to m_Member (when deprecated public members in Statistics are removed)
#define mitkSetGetConstMacro(name, type) \
  virtual type Get##name() const \
  { \
  return this->name; \
  } \
  \
  virtual void Set##name(const type _arg) \
  { \
  if ( this->name != _arg ) \
    { \
    this->name = _arg; \
    } \
  }

namespace mitk
{
  class MITKIMAGESTATISTICS_EXPORT ImageStatisticsCalculator : public itk::Object
  {
  public:

    enum
    {
      MASKING_MODE_NONE = 0,
      MASKING_MODE_IMAGE = 1,
      MASKING_MODE_PLANARFIGURE = 2
    };

    typedef itk::Statistics::Histogram<double> HistogramType;
    typedef HistogramType::ConstIterator HistogramConstIteratorType;

    class MITKIMAGESTATISTICS_EXPORT Statistics
    {
    public:

      Statistics(bool withHotspotStatistics = true);
      Statistics(const Statistics& other);

      virtual ~Statistics();

      Statistics& operator=(Statistics const& stats);

      const Statistics& GetHotspotStatistics() const;  // real statistics
      Statistics& GetHotspotStatistics();  // real statistics
      bool HasHotspotStatistics() const;
      void SetHasHotspotStatistics(bool hasHotspotStatistics); // set a flag. if set, return empty hotspotstatistics object

      void Reset(unsigned int dimension = 2);

      mitkSetGetConstMacro(Label, unsigned int)
        mitkSetGetConstMacro(N, unsigned int)
        mitkSetGetConstMacro(Min, double)
        mitkSetGetConstMacro(Max, double)
        mitkSetGetConstMacro(Mean, double)
        mitkSetGetConstMacro(Median, double)

        double GetVariance() const;
      void SetVariance( const double );

      double GetSigma() const;
      void SetSigma( const double );

      mitkSetGetConstMacro(RMS, double)
        mitkSetGetConstMacro(MinIndex, vnl_vector<int>)
        mitkSetGetConstMacro(MaxIndex, vnl_vector<int>)
        mitkSetGetConstMacro(HotspotIndex, vnl_vector<int>)

        mitkSetGetConstMacro(Skewness, double)
        mitkSetGetConstMacro(Kurtosis, double)
        mitkSetGetConstMacro(Uniformity, double)
        mitkSetGetConstMacro(Entropy, double)
        mitkSetGetConstMacro(UPP, double);
      mitkSetGetConstMacro(MPP, double);

    private:
      unsigned int Label;
      unsigned int N;
      double Min;
      double Max;
      double Mean;
      double Median;
      double Variance;
      double Sigma;
      double RMS;
      vnl_vector<int> MinIndex;
      vnl_vector<int> MaxIndex;

      bool m_SkewnessAndKurtosisSuccesfulCalculated;
      bool m_ImageStatisticsSuccesfulCalculated;


      Statistics* m_HotspotStatistics;

      double Skewness;
      double Kurtosis;
      double Uniformity;
      double Entropy;
      double UPP;
      double MPP;

      bool m_HasHotspotStatistics;
      vnl_vector<int> HotspotIndex;     //< index of hotspotsphere origin
    };

    typedef std::vector< HistogramType::ConstPointer > HistogramContainer;
    typedef std::vector< Statistics > StatisticsContainer;

    mitkClassMacroItkParent( ImageStatisticsCalculator, itk::Object );
    itkFactorylessNewMacro(Self)
      itkCloneMacro(Self)

      void SetUseDefaultBinSize(bool useDefault);

    void SetImage( const mitk::Image *image );

    void SetImageMask( const mitk::Image *imageMask );

    void SetPlanarFigure( mitk::PlanarFigure *planarFigure );


    void SetMaskingMode( unsigned int mode );

    itkGetMacro( MaskingMode, unsigned int );

    void SetMaskingModeToNone();

    void SetMaskingModeToImage();

    void SetMaskingModeToPlanarFigure();

    void SetIgnorePixelValue(double value);

    double GetIgnorePixelValue();

    void SetDoIgnorePixelValue(bool doit);

    bool GetDoIgnorePixelValue();

    void SetHistogramBinSize( double size);

    double GetHistogramBinSize();

    void SetHotspotRadiusInMM (double hotspotRadiusInMM);

    double GetHotspotRadiusInMM();

    void SetCalculateHotspot(bool calculateHotspot);

    bool IsHotspotCalculated();

    void SetHotspotMustBeCompletlyInsideImage(bool hotspotIsCompletlyInsideImage, bool warn = true);

    bool GetHotspotMustBeCompletlyInsideImage() const;

    virtual bool ComputeStatistics( unsigned int timeStep = 0 );


    const HistogramType *GetHistogram(  unsigned int timeStep = 0, unsigned int label = 0 ) const;

    const HistogramContainer &GetHistogramVector(  unsigned int timeStep = 0 ) const;

    typedef std::map<int, double> BinFrequencyType;

    /* Returning a map including bin and Frequency*/
    BinFrequencyType GetBinsAndFreuqencyForHistograms( unsigned int timeStep = 0, unsigned int label = 0) const;

    const Statistics &GetStatistics( unsigned int timeStep = 0, unsigned int label = 0 ) const;

    const StatisticsContainer &GetStatisticsVector( unsigned int timeStep = 0 ) const;




  protected:
    typedef std::vector< HistogramContainer > HistogramVector;
    typedef std::vector< StatisticsContainer > StatisticsVector;

    typedef std::vector< itk::TimeStamp > TimeStampVectorType;
    typedef std::vector< bool > BoolVectorType;

    typedef itk::Image< unsigned short, 3 > MaskImage3DType;
    typedef itk::Image< unsigned short, 2 > MaskImage2DType;

    ImageStatisticsCalculator();

    virtual ~ImageStatisticsCalculator();

    void ExtractImageAndMask( unsigned int timeStep = 0 );

    /*calculate the min and max value, this is done because we need the min and max value before execution the statistics filter to have the wright range for the histogramm*/
    template < typename TPixel, unsigned int VImageDimension >
    void  GetMinAndMaxValue(double &minimum, double &maximum, int &counter, double &sigma, const itk::Image< TPixel, VImageDimension > *InputImage,
      itk::Image< unsigned short, VImageDimension > *MaskImageType);

    bool GetPrincipalAxis( const BaseGeometry *geometry, Vector3D vector,
      unsigned int &axis );

    template < typename TPixel, unsigned int VImageDimension >
    void InternalCalculateStatisticsUnmasked(
      const itk::Image< TPixel, VImageDimension > *image,
      StatisticsContainer* statisticsContainer,
      HistogramContainer *histogramContainer );

    template < typename TPixel, unsigned int VImageDimension >
    void InternalCalculateStatisticsMasked(
      const itk::Image< TPixel, VImageDimension > *image,
      itk::Image< unsigned short, VImageDimension > *maskImage,
      StatisticsContainer* statisticsContainer,
      HistogramContainer* histogramContainer );

    template < typename TPixel, unsigned int VImageDimension >
    void InternalCalculateMaskFromPlanarFigure(
      const itk::Image< TPixel, VImageDimension > *image, unsigned int axis );

    template < typename TPixel, unsigned int VImageDimension >
    void InternalMaskIgnoredPixels(
      const itk::Image< TPixel, VImageDimension > *image,
      itk::Image< unsigned short, VImageDimension > *maskImage );

    class ImageExtrema
    {
    public:
      bool Defined;
      double Max;
      double Min;
      vnl_vector<int> MaxIndex;
      vnl_vector<int> MinIndex;

      ImageExtrema()
        :Defined(false)
        ,Max(itk::NumericTraits<double>::min())
        ,Min(itk::NumericTraits<double>::max())
      {
      }
    };


    template <typename TPixel, unsigned int VImageDimension >
    ImageExtrema CalculateExtremaWorld(
      const itk::Image<TPixel, VImageDimension> *inputImage,
      itk::Image<unsigned short, VImageDimension> *maskImage,
      double neccessaryDistanceToImageBorderInMM,
      unsigned int label);


    template < typename TPixel, unsigned int VImageDimension>
    Statistics CalculateHotspotStatistics(
      const itk::Image<TPixel, VImageDimension> *inputImage,
      itk::Image<unsigned short, VImageDimension> *maskImage,
      double radiusInMM,
      bool& isHotspotDefined,
      unsigned int label);

    template <typename ITK_Exporter, typename VTK_Importer>
    void ConnectPipelines(ITK_Exporter exporter, vtkSmartPointer<VTK_Importer> importer)
    {
      importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());

      importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
      importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
      importer->SetSpacingCallback(exporter->GetSpacingCallback());
      importer->SetOriginCallback(exporter->GetOriginCallback());
      importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());

      importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());

      importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
      importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
      importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
      importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
      importer->SetCallbackUserData(exporter->GetCallbackUserData());
    }

    template <typename VTK_Exporter, typename ITK_Importer>
    void ConnectPipelines(vtkSmartPointer<VTK_Exporter> exporter, ITK_Importer importer)
    {
      importer->SetUpdateInformationCallback(exporter->GetUpdateInformationCallback());

      importer->SetPipelineModifiedCallback(exporter->GetPipelineModifiedCallback());
      importer->SetWholeExtentCallback(exporter->GetWholeExtentCallback());
      importer->SetSpacingCallback(exporter->GetSpacingCallback());
      importer->SetOriginCallback(exporter->GetOriginCallback());
      importer->SetScalarTypeCallback(exporter->GetScalarTypeCallback());

      importer->SetNumberOfComponentsCallback(exporter->GetNumberOfComponentsCallback());

      importer->SetPropagateUpdateExtentCallback(exporter->GetPropagateUpdateExtentCallback());
      importer->SetUpdateDataCallback(exporter->GetUpdateDataCallback());
      importer->SetDataExtentCallback(exporter->GetDataExtentCallback());
      importer->SetBufferPointerCallback(exporter->GetBufferPointerCallback());
      importer->SetCallbackUserData(exporter->GetCallbackUserData());
    }


    void UnmaskedStatisticsProgressUpdate();

    void MaskedStatisticsProgressUpdate();

    template <unsigned int VImageDimension>
    itk::Size<VImageDimension>
      CalculateConvolutionKernelSize(double spacing[VImageDimension], double radiusInMM);

    template <unsigned int VImageDimension>
    itk::SmartPointer< itk::Image<float, VImageDimension> >
      GenerateHotspotSearchConvolutionKernel(double spacing[VImageDimension], double radiusInMM);

    template <typename TPixel, unsigned int VImageDimension>
    itk::SmartPointer< itk::Image<TPixel, VImageDimension> >
      GenerateConvolutionImage( const itk::Image<TPixel, VImageDimension>* inputImage );

    template < typename TPixel, unsigned int VImageDimension>
    void
      FillHotspotMaskPixels( itk::Image<TPixel, VImageDimension>* maskImage,
      itk::Point<double, VImageDimension> sphereCenter,
      double sphereRadiusInMM);

    mitk::Image::ConstPointer m_Image;

    mitk::Image::ConstPointer m_ImageMask;

    mitk::PlanarFigure::Pointer m_PlanarFigure;

    HistogramVector m_ImageHistogramVector;
    HistogramVector m_MaskedImageHistogramVector;
    HistogramVector m_PlanarFigureHistogramVector;

    HistogramType::Pointer m_EmptyHistogram;
    HistogramContainer m_EmptyHistogramContainer;


    StatisticsVector m_ImageStatisticsVector;
    StatisticsVector m_MaskedImageStatisticsVector;
    StatisticsVector m_PlanarFigureStatisticsVector;
    StatisticsVector m_MaskedImageHotspotStatisticsVector;

    Statistics m_EmptyStatistics;
    StatisticsContainer m_EmptyStatisticsContainer;

    unsigned int m_MaskingMode;
    bool m_MaskingModeChanged;

    mitk::Image::ConstPointer m_InternalImage;
    MaskImage3DType::Pointer m_InternalImageMask3D;
    MaskImage2DType::Pointer m_InternalImageMask2D;

    TimeStampVectorType m_ImageStatisticsTimeStampVector;
    TimeStampVectorType m_MaskedImageStatisticsTimeStampVector;
    TimeStampVectorType m_PlanarFigureStatisticsTimeStampVector;

    BoolVectorType m_ImageStatisticsCalculationTriggerVector;
    BoolVectorType m_MaskedImageStatisticsCalculationTriggerVector;
    BoolVectorType m_PlanarFigureStatisticsCalculationTriggerVector;

    double m_IgnorePixelValue;
    bool m_DoIgnorePixelValue;
    bool m_IgnorePixelValueChanged;

    unsigned int m_PlanarFigureAxis;    // Normal axis for PlanarFigure
    unsigned int m_PlanarFigureSlice;   // Slice which contains PlanarFigure
    int m_PlanarFigureCoordinate0;      // First plane-axis for PlanarFigure
    int m_PlanarFigureCoordinate1;      // Second plane-axis for PlanarFigure

    double m_HistogramBinSize;    
    bool m_UseDefaultBinSize;
    bool m_UseBinSizeBasedOnVOIRegion;
    double m_HotspotRadiusInMM;
    bool m_CalculateHotspot;
    bool m_HotspotRadiusInMMChanged;
    bool m_HotspotMustBeCompletelyInsideImage;


  private:

    unsigned int calcNumberOfBins(mitk::ScalarType min, mitk::ScalarType max);


  };

} // namespace

#endif