QmitkSlicesInterpolator.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 QmitkSlicesInterpolator_h_Included
#define QmitkSlicesInterpolator_h_Included

#include "mitkDataNode.h"
#include "mitkDataStorage.h"
#include "mitkSegmentationInterpolationController.h"
#include "mitkSliceNavigationController.h"
#include "mitkSurfaceInterpolationController.h"
#include "mitkToolManager.h"
#include "mitkWeakPointer.h"
#include <MitkSegmentationUIExports.h>

#include "mitkFeatureBasedEdgeDetectionFilter.h"
#include "mitkPointCloudScoringFilter.h"

#include <QWidget>
#include <map>

#include <QCheckBox>
#include <QComboBox>
#include <QFrame>
#include <QGroupBox>
#include <QRadioButton>

#include "mitkVtkRepresentationProperty.h"
#include "vtkProperty.h"

// For running 3D interpolation in background
#include <QFuture>
#include <QFutureWatcher>
#include <QTimer>
#include <QtConcurrentRun>

namespace mitk
{
  class PlaneGeometry;
  class SliceNavigationController;
}

class QPushButton;

class MITKSEGMENTATIONUI_EXPORT QmitkSlicesInterpolator : public QWidget
{
  Q_OBJECT

public:
  QmitkSlicesInterpolator(QWidget *parent = 0, const char *name = 0);

  void Initialize(mitk::ToolManager *toolManager, const QList<mitk::SliceNavigationController *> &controllers);

  void Uninitialize();

  virtual ~QmitkSlicesInterpolator();

  void SetDataStorage(mitk::DataStorage::Pointer storage);
  mitk::DataStorage *GetDataStorage();

  void OnToolManagerWorkingDataModified();

  void OnToolManagerReferenceDataModified();

  void OnTimeChanged(itk::Object *sender, const itk::EventObject &);

  void OnSliceChanged(itk::Object *sender, const itk::EventObject &);

  void OnSliceNavigationControllerDeleted(const itk::Object *sender, const itk::EventObject &);

  void OnInterpolationInfoChanged(const itk::EventObject &);

  void OnSurfaceInterpolationInfoChanged(const itk::EventObject &);

  void Show3DInterpolationResult(bool);

signals:

  void SignalRememberContourPositions(bool);
  void SignalShowMarkerNodes(bool);

public slots:

  virtual void setEnabled(bool);
  void EnableInterpolation(bool);

  void Enable3DInterpolation(bool);

  void FinishInterpolation(mitk::SliceNavigationController *slicer = NULL);

protected slots:

  void OnAcceptInterpolationClicked();

  /*
    Opens popup to ask about which orientation should be interpolated
  */
  void OnAcceptAllInterpolationsClicked();

  /*
   Reaction to button clicks
  */
  void OnAccept3DInterpolationClicked();

  void OnReinit3DInterpolation();

  void OnSuggestPlaneClicked();

  /*
   * Will trigger interpolation for all slices in given orientation (called from popup menu of
   * OnAcceptAllInterpolationsClicked)
   */
  void OnAcceptAllPopupActivated(QAction *action);

  void OnInterpolationActivated(bool);

  void On3DInterpolationActivated(bool);

  void OnInterpolationMethodChanged(int index);

  // Enhancement for 3D interpolation
  void On2DInterpolationEnabled(bool);
  void On3DInterpolationEnabled(bool);
  void OnInterpolationDisabled(bool);
  void OnShowMarkers(bool);

  void Run3DInterpolation();

  void RunPlaneSuggestion();

  void OnSurfaceInterpolationFinished();

  void StartUpdateInterpolationTimer();

  void StopUpdateInterpolationTimer();

  void ChangeSurfaceColor();

protected:
  const std::map<QAction *, mitk::SliceNavigationController *> createActionToSliceDimension();
  std::map<QAction *, mitk::SliceNavigationController *> ACTION_TO_SLICEDIMENSION;

  void AcceptAllInterpolations(mitk::SliceNavigationController *slicer);

  bool TranslateAndInterpolateChangedSlice(const itk::EventObject &e, mitk::SliceNavigationController *slicer);

  void Interpolate(mitk::PlaneGeometry *plane, unsigned int timeStep, mitk::SliceNavigationController *slicer);

  // void InterpolateSurface();

  void UpdateVisibleSuggestion();

  void SetCurrentContourListID();

private:
  void HideAllInterpolationControls();
  void Show2DInterpolationControls(bool show);
  void Show3DInterpolationControls(bool show);
  void CheckSupportedImageDimension();
  void WaitForFutures();
  void NodeRemoved(const mitk::DataNode* node);

  mitk::SegmentationInterpolationController::Pointer m_Interpolator;
  mitk::SurfaceInterpolationController::Pointer m_SurfaceInterpolator;

  mitk::FeatureBasedEdgeDetectionFilter::Pointer m_EdgeDetector;
  mitk::PointCloudScoringFilter::Pointer m_PointScorer;

  mitk::ToolManager::Pointer m_ToolManager;
  bool m_Initialized;

  QHash<mitk::SliceNavigationController *, int> m_ControllerToTimeObserverTag;
  QHash<mitk::SliceNavigationController *, int> m_ControllerToSliceObserverTag;
  QHash<mitk::SliceNavigationController *, int> m_ControllerToDeleteObserverTag;

  unsigned int InterpolationInfoChangedObserverTag;
  unsigned int SurfaceInterpolationInfoChangedObserverTag;

  QGroupBox *m_GroupBoxEnableExclusiveInterpolationMode;
  QComboBox *m_CmbInterpolation;
  QPushButton *m_BtnApply2D;
  QPushButton *m_BtnApplyForAllSlices2D;
  QPushButton *m_BtnApply3D;

  QPushButton *m_BtnSuggestPlane;

  QCheckBox *m_ChkShowPositionNodes;
  QPushButton *m_BtnReinit3DInterpolation;

  mitk::DataNode::Pointer m_FeedbackNode;
  mitk::DataNode::Pointer m_InterpolatedSurfaceNode;
  mitk::DataNode::Pointer m_3DContourNode;

  mitk::Image *m_Segmentation;

  mitk::SliceNavigationController *m_LastSNC;
  unsigned int m_LastSliceIndex;

  QHash<mitk::SliceNavigationController *, unsigned int> m_TimeStep;

  bool m_2DInterpolationEnabled;
  bool m_3DInterpolationEnabled;
  // unsigned int m_CurrentListID;

  mitk::DataStorage::Pointer m_DataStorage;

  QFuture<void> m_Future;
  QFutureWatcher<void> m_Watcher;
  QTimer *m_Timer;

  QFuture<void> m_PlaneFuture;
  QFutureWatcher<void> m_PlaneWatcher;

  bool m_FirstRun;
};

#endif