qMRMLSegmentEditorWidget.h

Go to the documentation of this file.

/*==============================================================================
 
  Program: 3D Slicer
 
  Copyright (c) Laboratory for Percutaneous Surgery (PerkLab)
  Queen's University, Kingston, ON, Canada. All Rights Reserved.
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
 
  This file was originally developed by Csaba Pinter, PerkLab, Queen's University
  and was supported through the Applied Cancer Research Unit program of Cancer Care
  Ontario with funds provided by the Ontario Ministry of Health and Long-Term Care
 
==============================================================================*/
 
#ifndef __qMRMLSegmentEditorWidget_h
#define __qMRMLSegmentEditorWidget_h
 
// Segmentations includes
#include "qSlicerSegmentationsModuleWidgetsExport.h"
 
// MRMLWidgets includes
#include "qMRMLWidget.h"
 
// Qt includes
#include <QVariant>
 
// CTK includes
#include <ctkVTKObject.h>
 
// STD includes
#include <cstdlib>
 
class vtkMRMLNode;
class vtkMRMLInteractionNode;
class vtkMRMLSegmentationNode;
class vtkMRMLSegmentEditorNode;
class vtkMRMLVolumeNode;
class vtkObject;
class QItemSelection;
class QAbstractButton;
class qMRMLSegmentEditorWidgetPrivate;
class qSlicerSegmentEditorAbstractEffect;
class qSlicerAbstractModuleWidget;

class Q_SLICER_MODULE_SEGMENTATIONS_WIDGETS_EXPORT qMRMLSegmentEditorWidget : public qMRMLWidget
{
  Q_OBJECT
  QVTK_OBJECT
  Q_PROPERTY(bool segmentationNodeSelectorVisible READ segmentationNodeSelectorVisible WRITE setSegmentationNodeSelectorVisible)
  Q_PROPERTY(bool sourceVolumeNodeSelectorVisible READ sourceVolumeNodeSelectorVisible WRITE setSourceVolumeNodeSelectorVisible)
  Q_PROPERTY(bool maskingSectionVisible READ maskingSectionVisible WRITE setMaskingSectionVisible)
  Q_PROPERTY(bool specifyGeometryButtonVisible READ specifyGeometryButtonVisible WRITE setSpecifyGeometryButtonVisible)
  Q_PROPERTY(bool show3DButtonVisible READ show3DButtonVisible WRITE setShow3DButtonVisible)
  Q_PROPERTY(bool addRemoveSegmentButtonsVisible READ addRemoveSegmentButtonsVisible WRITE setAddRemoveSegmentButtonsVisible)
  Q_PROPERTY(bool autoShowSourceVolumeNode READ autoShowSourceVolumeNode WRITE setAutoShowSourceVolumeNode)
  Q_PROPERTY(bool masterVolumeNodeSelectorVisible READ masterVolumeNodeSelectorVisible WRITE setMasterVolumeNodeSelectorVisible) // deprecated
  Q_PROPERTY(bool autoShowMasterVolumeNode READ autoShowMasterVolumeNode WRITE setAutoShowMasterVolumeNode)                      // deprecated
  Q_PROPERTY(bool switchToSegmentationsButtonVisible READ switchToSegmentationsButtonVisible WRITE setSwitchToSegmentationsButtonVisible)
  Q_PROPERTY(bool undoEnabled READ undoEnabled WRITE setUndoEnabled)
  Q_PROPERTY(int maximumNumberOfUndoStates READ maximumNumberOfUndoStates WRITE setMaximumNumberOfUndoStates)
  Q_PROPERTY(bool readOnly READ readOnly WRITE setReadOnly)
  Q_PROPERTY(Qt::ToolButtonStyle effectButtonStyle READ effectButtonStyle WRITE setEffectButtonStyle)
  Q_PROPERTY(int effectColumnCount READ effectColumnCount WRITE setEffectColumnCount)
  Q_PROPERTY(bool unorderedEffectsVisible READ unorderedEffectsVisible WRITE setUnorderedEffectsVisible)
  Q_PROPERTY(QString defaultTerminologyEntrySettingsKey READ defaultTerminologyEntrySettingsKey WRITE setDefaultTerminologyEntrySettingsKey)
  Q_PROPERTY(QString defaultTerminologyEntry READ defaultTerminologyEntry WRITE setDefaultTerminologyEntry)
  Q_PROPERTY(bool jumpToSelectedSegmentEnabled READ jumpToSelectedSegmentEnabled WRITE setJumpToSelectedSegmentEnabled)
 
public:
  typedef qMRMLWidget Superclass;
  explicit qMRMLSegmentEditorWidget(QWidget* parent = nullptr);
  ~qMRMLSegmentEditorWidget() override;

  Q_INVOKABLE vtkMRMLSegmentEditorNode* mrmlSegmentEditorNode() const;

  Q_INVOKABLE vtkMRMLNode* segmentationNode() const;
  Q_INVOKABLE QString segmentationNodeID() const;
  Q_INVOKABLE vtkMRMLNode* sourceVolumeNode() const;
  Q_INVOKABLE QString sourceVolumeNodeID() const;

  Q_INVOKABLE vtkMRMLNode* masterVolumeNode() const
  {
    qWarning("qMRMLSegmentEditorWidget::masterVolumeNode is deprecated, use sourceVolumeNode() method instead.");
    return this->sourceVolumeNode();
  };

  Q_INVOKABLE QString masterVolumeNodeID() const
  {
    qWarning("qMRMLSegmentEditorWidget::masterVolumeNodeID is deprecated, use sourceVolumeNodeID() method instead.");
    return this->sourceVolumeNodeID();
  };

  Q_INVOKABLE QString currentSegmentID() const;

  Q_INVOKABLE qSlicerSegmentEditorAbstractEffect* activeEffect() const;
  Q_INVOKABLE void setActiveEffect(qSlicerSegmentEditorAbstractEffect* effect);

  Q_INVOKABLE qSlicerSegmentEditorAbstractEffect* effectByName(const QString& name);

  Q_INVOKABLE QStringList availableEffectNames();

  Q_INVOKABLE void setEffectNameOrder(const QStringList& effectNames);

  Q_INVOKABLE QStringList effectNameOrder() const;

  void setUnorderedEffectsVisible(bool visible);

  bool unorderedEffectsVisible() const;

  Q_INVOKABLE int effectCount();

  Q_INVOKABLE qSlicerSegmentEditorAbstractEffect* effectByIndex(int index);

  Q_INVOKABLE void setupViewObservations();

  Q_INVOKABLE void removeViewObservations();

  bool segmentationNodeSelectorVisible() const;
  bool sourceVolumeNodeSelectorVisible() const;
  bool autoShowSourceVolumeNode() const;

  bool masterVolumeNodeSelectorVisible() const
  {
    qWarning("qMRMLSegmentEditorWidget::masterVolumeNodeSelectorVisible is deprecated, use sourceVolumeNodeSelectorVisible() method instead.");
    return this->sourceVolumeNodeSelectorVisible();
  };

  bool autoShowMasterVolumeNode() const
  {
    qWarning("qMRMLSegmentEditorWidget::autoShowMasterVolumeNode is deprecated, use autoShowSourceVolumeNode() method instead.");
    return this->autoShowSourceVolumeNode();
  };

  bool maskingSectionVisible() const;

  bool specifyGeometryButtonVisible() const;

  bool show3DButtonVisible() const;

  bool addRemoveSegmentButtonsVisible() const;

  bool switchToSegmentationsButtonVisible() const;
  bool undoEnabled() const;
  int maximumNumberOfUndoStates() const;
  bool readOnly() const;

  Qt::ToolButtonStyle effectButtonStyle() const;

  int effectColumnCount() const;

  Q_INVOKABLE void segmentationNodeSelectorAddAttribute(const QString& nodeType, const QString& attributeName, const QVariant& attributeValue = QVariant());
  Q_INVOKABLE void segmentationNodeSelectorRemoveAttribute(const QString& nodeType, const QString& attributeName);

  Q_INVOKABLE void sourceVolumeNodeSelectorAddAttribute(const QString& nodeType, const QString& attributeName, const QVariant& attributeValue = QVariant());
  Q_INVOKABLE void sourceVolumeNodeSelectorRemoveAttribute(const QString& nodeType, const QString& attributeName);

  Q_INVOKABLE void masterVolumeNodeSelectorAddAttribute(const QString& nodeType, const QString& attributeName, const QVariant& attributeValue = QVariant())
  {
    qWarning("qMRMLSegmentEditorWidget::masterVolumeNodeSelectorAddAttribute is deprecated, use sourceVolumeNodeSelectorAddAttribute method instead.");
    this->sourceVolumeNodeSelectorAddAttribute(nodeType, attributeName, attributeValue);
  }

  Q_INVOKABLE void masterVolumeNodeSelectorRemoveAttribute(const QString& nodeType, const QString& attributeName)
  {
    qWarning("qMRMLSegmentEditorWidget::masterVolumeNodeSelectorRemoveAttribute is deprecated,"
             " use sourceVolumeNodeSelectorRemoveAttribute instead.");
    this->sourceVolumeNodeSelectorRemoveAttribute(nodeType, attributeName);
  }

  Q_INVOKABLE vtkMRMLInteractionNode* interactionNode() const;

  void setDefaultTerminologyEntrySettingsKey(const QString& terminologyEntrySettingsKey);
  QString defaultTerminologyEntrySettingsKey() const;

  void setDefaultTerminologyEntry(const QString& terminologyEntry);
  QString defaultTerminologyEntry();

  bool jumpToSelectedSegmentEnabled() const;
 
public slots:
  void setMRMLScene(vtkMRMLScene* newScene) override;

  void setMRMLSegmentEditorNode(vtkMRMLSegmentEditorNode* newSegmentEditorNode);

  virtual void updateWidgetFromMRML();

  void setSegmentationNode(vtkMRMLNode* node);
  void setSegmentationNodeID(const QString& nodeID);
  void setSourceVolumeNode(vtkMRMLNode* node);
  void setSourceVolumeNodeID(const QString& nodeID);

  void setMasterVolumeNode(vtkMRMLNode* node)
  {
    qWarning("qMRMLSegmentEditorWidget::setMasterVolumeNode is deprecated, use setSourceVolumeNode method instead.");
    this->setSourceVolumeNode(node);
  }

  void setMasterVolumeNodeID(const QString& nodeID)
  {
    qWarning("qMRMLSegmentEditorWidget::setMasterVolumeNodeID is deprecated, use setSourceVolumeNodeID method instead.");
    this->setSourceVolumeNodeID(nodeID);
  }

  void setCurrentSegmentID(const QString& segmentID);

  void setActiveEffectByName(const QString& effectName);

  void saveStateForUndo();

  void updateVolume(void* volumePtr, bool& success);

  void setSegmentationNodeSelectorVisible(bool);
  void setSourceVolumeNodeSelectorVisible(bool);
  void setAutoShowSourceVolumeNode(bool);
  void setMaskingSectionVisible(bool);
  void setSpecifyGeometryButtonVisible(bool);
  void setShow3DButtonVisible(bool);
  void setAddRemoveSegmentButtonsVisible(bool);
  void setSwitchToSegmentationsButtonVisible(bool);
  void setUndoEnabled(bool);
  void setMaximumNumberOfUndoStates(int);
  void setReadOnly(bool aReadOnly);
  void toggleSourceVolumeIntensityMaskEnabled();

  void setMasterVolumeNodeSelectorVisible(bool visible)
  {
    qWarning("qMRMLSegmentEditorWidget::setMasterVolumeNodeSelectorVisible is deprecated, use setSourceVolumeNodeSelectorVisible method instead.");
    this->setSourceVolumeNodeSelectorVisible(visible);
  }

  void setAutoShowMasterVolumeNode(bool autoShow)
  {
    qWarning("qMRMLSegmentEditorWidget::setAutoShowMasterVolumeNode is deprecated, use setAutoShowSourceVolumeNode method instead.");
    this->setAutoShowSourceVolumeNode(autoShow);
  }

  void toggleMasterVolumeIntensityMaskEnabled()
  {
    qWarning("qMRMLSegmentEditorWidget::toggleMasterVolumeIntensityMaskEnabled is deprecated, use toggleSourceVolumeIntensityMaskEnabled method instead.");
    this->toggleSourceVolumeIntensityMaskEnabled();
  }

  void undo();

  void redo();

  void installKeyboardShortcuts(QWidget* parent = nullptr);

  void uninstallKeyboardShortcuts();

  bool turnOffLightboxes();

  void hideLabelLayer();

  void setEffectButtonStyle(Qt::ToolButtonStyle toolButtonStyle);

  void setEffectColumnCount(int columnCount);

  void updateEffectList();

  void showSourceVolumeInSliceViewers(bool forceShowInBackground = false, bool fitSlice = false);
 
  // Deprecated. Use showSourceVolumeInSliceViewers method instead.
  void showMasterVolumeInSliceViewers(bool forceShowInBackground = false, bool fitSlice = false)
  {
    qWarning("qMRMLSegmentEditorWidget::showMasterVolumeInSliceViewers is deprecated, use showSourceVolumeInSliceViewers method instead.");
    this->showSourceVolumeInSliceViewers(forceShowInBackground, fitSlice);
  }

  void rotateSliceViewsToSegmentation();

  void setInteractionNode(vtkMRMLInteractionNode* interactionNode);

  void selectPreviousSegment();

  void selectNextSegment();

  void selectSegmentAtOffset(int offset);

  void jumpSlices();

  void setJumpToSelectedSegmentEnabled(bool enable);
 
signals:
  void currentSegmentIDChanged(const QString&);

  void sourceVolumeNodeChanged(vtkMRMLVolumeNode*);

  void masterVolumeNodeChanged(vtkMRMLVolumeNode*);

  void segmentationNodeChanged(vtkMRMLSegmentationNode*);
 
protected slots:
  void onSegmentationNodeChanged(vtkMRMLNode* node);
  void onSourceVolumeNodeChanged(vtkMRMLNode* node);
  void onSegmentSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected);

  void onInteractionNodeModified();

  void onEffectButtonClicked(QAbstractButton* button);

  void onSelectEffectShortcut();

  void onSelectSegmentShortcut();

  void onAddSegment();
  void onRemoveSegment();
  void onSwitchToSegmentations();
  void onCreateSurfaceToggled(bool on);
  void onSegmentAddedRemoved();
  void onSourceVolumeImageDataModified();
  void onLayoutChanged(int layoutIndex);
  void onSegmentationDisplayModified();

  void onMaskModeChanged(int);

  void onSourceVolumeIntensityMaskChecked(bool checked);
  void onSourceVolumeIntensityMaskRangeChanged(double low, double high);

  void onOverwriteModeChanged(int);

  void onMRMLSceneEndCloseEvent();

  void onMRMLSceneEndBatchProcessEvent();

  void initializeParameterSetNode();

  void updateUndoRedoButtonsState();

  void onSegmentationHistoryChanged();

  void onImportExportActionClicked();
  void onExportToFilesActionClicked();
  void onExportToColorTableActionClicked();

  void updateMaskingSection();

  void updateSliceRotateWarningButtonVisibility();

  void showSegmentationGeometryDialog();
 
  static void pauseRender();
  static void resumeRender();
 
protected:
  static void processEvents(vtkObject* caller, unsigned long eid, void* clientData, void* callData);
 
  void updateWidgetFromSegmentationNode();
  void updateWidgetFromSourceVolumeNode();
  void updateEffectsSectionFromMRML();

  bool setSourceRepresentationToBinaryLabelmap();

  static qSlicerAbstractModuleWidget* switchToSegmentationsModule();
 
protected:
  QScopedPointer<qMRMLSegmentEditorWidgetPrivate> d_ptr;
 
private:
  Q_DECLARE_PRIVATE(qMRMLSegmentEditorWidget);
  Q_DISABLE_COPY(qMRMLSegmentEditorWidget);
};
 
#endif