ImageStatisticsView.h

Go to the documentation of this file.

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

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). 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 in the top level directory for details.

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

#ifndef ImageStatisticsView_h
#define ImageStatisticsView_h

#include <berryISelectionListener.h>

#include <QmitkAbstractView.h>

#include "ui_ImageStatisticsViewControls.h"

#include <itkMIDASHelper.h>

class ImageStatisticsView : public QmitkAbstractView
{  
  Q_OBJECT

  typedef QmitkAbstractView Superclass;

public:

  berryObjectMacro(ImageStatisticsView);
  ImageStatisticsView();
  virtual ~ImageStatisticsView();

  static const QString VIEW_ID;

  virtual void CreateQtPartControl(QWidget *parent) override;

  virtual void OnSelectionChanged( berry::IWorkbenchPart::Pointer source,
                                   const QList<mitk::DataNode::Pointer>& nodes ) override;

  virtual void OnPreferencesChanged(const berry::IBerryPreferences*) override;

protected slots:

  void OnPerSliceStatsCheckBoxToggled(bool toggled);

  void OnAxialRadioButtonToggled(bool toggled);

  void OnSagittalRadioButtonToggled(bool toggled);

  void OnCoronalRadioButtonToggled(bool toggled);

  void OnUpdateButtonClicked();

  void OnCopyAllButtonClicked();

protected:

  virtual void SetFocus() override;

private:

  void Copy();

  void RetrievePreferenceValues();

  void EnableControls(bool enabled);

  bool IsSelectionValid(const QList<mitk::DataNode::Pointer>& nodes);

  void InitializeTable();

  void Update(const QList<mitk::DataNode::Pointer>& nodes);

  template <typename PixelType>
  QTreeWidgetItem* CreateTableRow(QTreeWidgetItem* parentItem,
      const QString& value,
      PixelType min,
      PixelType max,
      double mean,
      double median,
      double stdDev,
      unsigned long count,
      double volume,
      int sliceIndex = 0);

  template <typename PixelType, unsigned int VImageDimension>
  void GetLabelValues(
      itk::Image<PixelType, VImageDimension>* itkImage,
      std::set<PixelType>& labels);


  template <typename PixelType, unsigned int VImageDimension>
  void GetVoxelVolume(
      itk::Image<PixelType, VImageDimension>* itkImage,
      double& volume
      );

  template <typename TPixel>
  void TestMinAndMax(
      TPixel imageValue,
      TPixel& min,
      TPixel& max
      );

  template <typename TPixel>
  void AccumulateData(
      TPixel imageValue,
      double& mean,
      double& s0,
      double& s1,
      double& s2,
      unsigned long& counter
      );

  void CalculateMeanAndStdDev(
      double& mean,
      double s0,
      double s1,
      double s2,
      double& stdDev,
      unsigned long counter
      );

  template <typename TPixel>
  void AccumulateValue(
      TPixel imageValue,
      TPixel& min,
      TPixel& max,
      double& mean,
      double& s0,
      double& s1,
      double& s2,
      unsigned long& counter,
      TPixel* imagePixelsCopy
      );

  template <typename TPixel1, typename TPixel2>
  void AccumulateValue(
      bool invert,
      TPixel2 valueToCompareMaskAgainst,
      TPixel1 imageValue,
      TPixel2 maskValue,
      TPixel1& min,
      TPixel1& max,
      double& mean,
      double& s0,
      double& s1,
      double& s2,
      unsigned long& counter,
      TPixel1* imagePixelsCopy
      );

  template <typename TPixel, unsigned VImageDimension>
  void CalculateStats(
      itk::Image<TPixel, VImageDimension>* itkImage,
      const itk::ImageRegion<VImageDimension>& region,
      TPixel& min,
      TPixel& max,
      double& mean,
      double& s0,
      double& s1,
      double& s2,
      double& stdDev,
      unsigned long& counter,
      TPixel* imagePixelsCopy,
      double& median
      );

  template <typename TPixel1, typename TPixel2, unsigned int VImageDimension>
  void CalculateStatsWithMask(
      itk::Image<TPixel1, VImageDimension>* itkImage,
      itk::Image<TPixel2, VImageDimension>* itkMask,
      const itk::ImageRegion<VImageDimension>& region,
      bool invert,
      TPixel2 label,
      TPixel1& min,
      TPixel1& max,
      double& mean,
      double& s0,
      double& s1,
      double& s2,
      double& stdDev,
      unsigned long& counter,
      TPixel1* imagePixelsCopy,
      double& median
      );

  template <typename TPixel, unsigned int VImageDimension>
  void UpdateTable(
      itk::Image<TPixel, VImageDimension>* itkImage
      );

  template <typename TPixel1, unsigned int VImageDimension1, typename TPixel2, unsigned int VImageDimension2>
  void UpdateTableWithMask(
      itk::Image<TPixel1, VImageDimension1>* itkImage,
      itk::Image<TPixel2, VImageDimension2>* itkMask
      );


  bool eventFilter(QObject* object, QEvent* event) override;

  Ui::ImageStatisticsViewControls m_Controls;
  bool                            m_AutoUpdate;
  bool                            m_RequireSameSizeImage;
  bool                            m_AssumeBinary;
  int                             m_BackgroundValue;
  mitk::DataNode::Pointer         m_MaskNode;
  mitk::DataNode::Pointer         m_ImageNode;
  bool m_PerSliceStats;
  itk::Orientation m_Orientation;

};

#endif