mitkPartialVolumeAnalysisHistogramCalculator.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_PartialVolumeAnalysisHistogramCalculator_H
#define _MITK_PartialVolumeAnalysisHistogramCalculator_H

#include "MitkDiffusionCoreExports.h"

#include <itkObject.h>
#include <itkImage.h>
#include <itkTimeStamp.h>


#include "mitkImage.h"
#include "mitkImageTimeSelector.h"
#include "mitkPlanarFigure.h"



namespace mitk
{

  class MITKDIFFUSIONCORE_EXPORT PartialVolumeAnalysisHistogramCalculator : public itk::Object
  {
  public:

    enum
    {
      MASKING_MODE_NONE = 0,
      MASKING_MODE_IMAGE,
      MASKING_MODE_PLANARFIGURE
    };

    typedef mitk::Image::HistogramType HistogramType;
    typedef mitk::Image::HistogramType::ConstIterator HistogramConstIteratorType;

    struct Statistics
    {
      unsigned int N;
      double Min;
      double Max;
      double Mean;
      double Median;
      double Variance;
      double Sigma;
      double RMS;

      void Reset()
      {
        N = 0;
        Min = 0.0;
        Max = 0.0;
        Mean = 0.0;
        Median = 0.0;
        Variance = 0.0;
        Sigma = 0.0;
        RMS = 0.0;
      }
    };

    typedef Statistics StatisticsType;

    typedef itk::TimeStamp TimeStampType;
    typedef bool BoolType;

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

    typedef itk::Image< float, 2 > InternalImage2DType;

    mitkClassMacroItkParent( PartialVolumeAnalysisHistogramCalculator, itk::Object )
    itkFactorylessNewMacro(Self)
    itkCloneMacro(Self)

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

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

    void SetPlanarFigure( const mitk::PlanarFigure *planarFigure );

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

    void SetMaskingMode( unsigned int mode );

    itkGetMacro( MaskingMode, unsigned int );

    void SetMaskingModeToNone();

    void SetMaskingModeToImage();

    void SetMaskingModeToPlanarFigure();

    void SetNumberOfBins( unsigned int number )
    {
      if(m_NumberOfBins != number)
      {
        m_NumberOfBins = number;
        SetModified();
      }
    }

    unsigned int GetNumberOfBins( )
    { return m_NumberOfBins; }

    void SetUpsamplingFactor( float number )
    {
      if(m_UpsamplingFactor != number)
      {
        m_UpsamplingFactor = number;
        SetModified();
      }
    }

    float GetUpsamplingFactor( )
    { return m_UpsamplingFactor; }

    void SetGaussianSigma( float number )
    {
      if(m_GaussianSigma != number)
      {
        m_GaussianSigma = number;
        SetModified();
      }
    }

    unsigned int GetPlanarFigureThickness( )
    { return m_PlanarFigureThickness; }


    void SetPlanarFigureThickness( unsigned int number )
    {
      if(m_PlanarFigureThickness != number)
      {
        m_PlanarFigureThickness = number;
        SetModified();
      }
    }

    float GetGaussianSigma( )
    { return m_GaussianSigma; }

    void SetModified();

    virtual bool ComputeStatistics( );


    const HistogramType *GetHistogram(  ) const;

    const Statistics &GetStatistics( ) const;

    const Image::Pointer GetInternalImage()
    {
      return m_InternalImage;
    }

    const Image::Pointer GetInternalAdditionalResampledImage(unsigned int i)
    {
      if(i < m_InternalAdditionalResamplingImages.size())
      {
        return m_InternalAdditionalResamplingImages[i];
      }
      else
      {
        return nullptr;
      }
    }

    void SetForceUpdate(bool b)
    {
      m_ForceUpdate = b;
    }

  protected:

    PartialVolumeAnalysisHistogramCalculator();

    virtual ~PartialVolumeAnalysisHistogramCalculator();

    void ExtractImageAndMask( );


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

    template < typename TPixel, unsigned int VImageDimension >
        void InternalCalculateStatisticsUnmasked(
            const itk::Image< TPixel, VImageDimension > *image,
            Statistics &statistics,
            typename HistogramType::ConstPointer *histogram );

    template < typename TPixel, unsigned int VImageDimension >
        void InternalCalculateStatisticsMasked(
            const itk::Image< TPixel, VImageDimension > *image,
            itk::Image< unsigned char, VImageDimension > *maskImage,
            Statistics &statistics,
            typename HistogramType::ConstPointer *histogram );

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

    template < typename TPixel, unsigned int VImageDimension >
        void InternalReorientImagePlane(
          const itk::Image< TPixel, VImageDimension > *image, mitk::BaseGeometry* imggeo, mitk::BaseGeometry* planegeo3D, int additionalIndex );

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

    void InternalResampleImage(
        const MaskImage3DType *image/*, mitk::Geometry3D* imggeo*/ );

    template < typename TPixel, unsigned int VImageDimension >
        void InternalCropAdditionalImage(
            itk::Image< TPixel, VImageDimension > *image, int additionalIndex );

    void InternalMaskImage( mitk::Image *image );

    template <typename ITK_Exporter, typename VTK_Importer>
        void ConnectPipelines(ITK_Exporter exporter, 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(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();

    mitk::Image::ConstPointer m_Image;
    mitk::Image::ConstPointer m_ImageMask;
    mitk::PlanarFigure::ConstPointer m_PlanarFigure;

    HistogramType::ConstPointer m_ImageHistogram;
    HistogramType::ConstPointer m_MaskedImageHistogram;
    HistogramType::ConstPointer m_PlanarFigureHistogram;

    HistogramType::Pointer m_EmptyHistogram;

    StatisticsType m_ImageStatistics;
    StatisticsType m_MaskedImageStatistics;
    StatisticsType m_PlanarFigureStatistics;

    Statistics m_EmptyStatistics;

    unsigned int m_MaskingMode;
    bool m_MaskingModeChanged;

    mitk::Image::Pointer m_InternalImage;
    MaskImage3DType::Pointer m_InternalImageMask3D;
    MaskImage2DType::Pointer m_InternalImageMask2D;
    itk::ImageRegion<3> m_InternalMask3D;
    std::vector<mitk::Image::ConstPointer> m_AdditionalResamplingImages;
    std::vector<mitk::Image::Pointer> m_InternalAdditionalResamplingImages;

    TimeStampType m_ImageStatisticsTimeStamp;
    TimeStampType m_MaskedImageStatisticsTimeStamp;
    TimeStampType m_PlanarFigureStatisticsTimeStamp;

    BoolType m_ImageStatisticsCalculationTriggerBool;
    BoolType m_MaskedImageStatisticsCalculationTriggerBool;
    BoolType m_PlanarFigureStatisticsCalculationTriggerBool;

    unsigned int m_NumberOfBins;

    float m_UpsamplingFactor;

    float m_GaussianSigma;

    itk::ImageRegion<3> m_CropRegion;

    bool m_ForceUpdate;

    unsigned int m_PlanarFigureThickness;

  };

}

#endif // #define _MITK_PartialVolumeAnalysisHistogramCalculator_H