QmitkSlicesInterpolator.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef QmitkSlicesInterpolator_h
#define QmitkSlicesInterpolator_h
 
#include "mitkDataNode.h"
#include "mitkDataStorage.h"
#include "mitkSegmentationInterpolationController.h"
#include "mitkSliceNavigationController.h"
#include "mitkSurfaceInterpolationController.h"
#include "mitkToolManager.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 QmitkRenderWindow;
 
enum ModifyLabelActionTrigerred
{
  Null,
  Erase,
  Merge
};
 
class MITKSEGMENTATIONUI_EXPORT QmitkSlicesInterpolator : public QWidget
{
  Q_OBJECT
 
public:
  QmitkSlicesInterpolator(QWidget *parent = nullptr, const char *name = nullptr);
 
  void Initialize(mitk::ToolManager *toolManager, const QList<QmitkRenderWindow*>& windows);
 
  void Uninitialize();
 
  ~QmitkSlicesInterpolator() override;
 
  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 OnInterpolationAborted(const itk::EventObject &);
 
  void OnSurfaceInterpolationInfoChanged(const itk::EventObject &);
 
 
private:
  void Show3DInterpolationResult(bool);
 
  void OnActiveLabelChanged(mitk::Label::PixelType);
 
  void OnLayerChanged();
 
  void OnRemoveLabel(mitk::Label::PixelType removedLabelValue);
 
  void OnModifyLabelChanged(const itk::Object *caller,
                              const itk::EventObject & /*event*/);
 
  void OnAddLabelSetConnection();
 
  void OnAddLabelSetConnection(unsigned int layerID);
 
  void OnRemoveLabelSetConnection();
 
  void MergeContours(unsigned int timeStep, unsigned int layerID);
 
 
  void PrepareInputsFor3DInterpolation();
 
signals:
 
  void SignalRememberContourPositions(bool);
  void SignalShowMarkerNodes(bool);
 
public slots:
 
  virtual void setEnabled(bool);
  void EnableInterpolation(bool);
 
  void Enable3DInterpolation(bool);
 
  void FinishInterpolation(mitk::SliceNavigationController *slicer = nullptr);
 
protected slots:
 
  void OnAcceptInterpolationClicked();
 
  /*
    Opens popup to ask about which orientation should be interpolated
  */
  void OnAcceptAllInterpolationsClicked();
 
  /*
   Reaction to button clicks
  */
  void OnAccept3DInterpolationClicked();
 
  void OnReinit3DInterpolation();
 
  /*
   * 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 OnSurfaceInterpolationFinished();
 
  void StartUpdateInterpolationTimer();
 
  void StopUpdateInterpolationTimer();
 
  void ChangeSurfaceColor();
 
  void OnRemoveLabelSetConnection(mitk::LabelSetImage* labelSetImage, unsigned int layerID);
 
protected:
  const std::map<QAction *, mitk::SliceNavigationController *> createActionToSlicer(const QList<QmitkRenderWindow*>& windows);
  std::map<QAction *, mitk::SliceNavigationController *> m_ActionToSlicer;
 
  void AcceptAllInterpolations(mitk::SliceNavigationController *slicer);
 
  bool TranslateAndInterpolateChangedSlice(const itk::EventObject &e, mitk::SliceNavigationController *slicer);
 
  void Interpolate(mitk::PlaneGeometry *plane, mitk::TimePointType timePoint, mitk::SliceNavigationController *slicer);
 
  // void InterpolateSurface();
 
  void UpdateVisibleSuggestion();
 
  void SetCurrentContourListID();
 
private:
  void InitializeWindow(QmitkRenderWindow* window);
  void HideAllInterpolationControls();
  void Show2DInterpolationControls(bool show);
  void Show3DInterpolationControls(bool show);
  void CheckSupportedImageDimension();
  void WaitForFutures();
  void NodeRemoved(const mitk::DataNode* node);
  void ClearSegmentationObservers();
 
  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;
 
  std::map<mitk::LabelSetImage *, unsigned long> m_SegmentationObserverTags;
 
  unsigned int InterpolationInfoChangedObserverTag;
  unsigned int SurfaceInterpolationInfoChangedObserverTag;
  unsigned int InterpolationAbortedObserverTag;
 
  QGroupBox *m_GroupBoxEnableExclusiveInterpolationMode;
  QComboBox *m_CmbInterpolation;
  QPushButton *m_BtnApply2D;
  QPushButton *m_BtnApplyForAllSlices2D;
  QPushButton *m_BtnApply3D;
 
  // T28261
  // 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 *, mitk::TimePointType> m_TimePoints;
 
  bool m_2DInterpolationEnabled;
  bool m_3DInterpolationEnabled;
 
  unsigned int m_numTimesLabelSetConnectionAdded;
 
  mitk::DataStorage::Pointer m_DataStorage;
 
  QFuture<void> m_Future;
  QFutureWatcher<void> m_Watcher;
 
  QFuture<void> m_ModifyFuture;
  QFutureWatcher<void> m_ModifyWatcher;
 
  QTimer *m_Timer;
 
  QFuture<void> m_PlaneFuture;
  QFutureWatcher<void> m_PlaneWatcher;
 
  mitk::Label::PixelType m_PreviousActiveLabelValue;
  mitk::Label::PixelType m_CurrentActiveLabelValue;
 
  unsigned int m_PreviousLayerIndex;
  unsigned int m_CurrentLayerIndex;
  bool m_FirstRun;
};
 
#endif