qSlicerSegmentEditorAbstractEffect.h

Go to the documentation of this file.

/*==============================================================================
 
  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 __qSlicerSegmentEditorAbstractEffect_h
#define __qSlicerSegmentEditorAbstractEffect_h
 
// Segmentations Editor Effects includes
#include "qSlicerSegmentationsEditorEffectsExport.h"
 
// Qt includes
#include <QCursor>
#include <QIcon>
#include <QList>
#include <QObject>
#include <QPoint>
#include <QVector3D>
 
// VTK includes
#include "vtkWeakPointer.h"
 
class qSlicerSegmentEditorAbstractEffectPrivate;
 
class vtkActor2D;
class vtkMRMLInteractionNode;
class vtkMRMLNode;
class vtkMRMLScene;
class vtkMRMLSegmentEditorNode;
class vtkMRMLAbstractViewNode;
class vtkMRMLSegmentationNode;
class vtkMRMLSliceNode;
class vtkMRMLTransformNode;
class vtkSegment;
class vtkSlicerSegmentEditorLogic;
class vtkRenderer;
class vtkRenderWindow;
class vtkRenderWindowInteractor;
class vtkOrientedImageData;
class vtkProp3D;
class qMRMLWidget;
class qMRMLSliceWidget;
class QColor;
class QFormLayout;
class QFrame;
class QLayout;

class Q_SLICER_SEGMENTATIONS_EFFECTS_EXPORT qSlicerSegmentEditorAbstractEffect : public QObject
{
  Q_OBJECT
  Q_ENUMS(ConfirmationResult)
  Q_ENUMS(ModificationMode)
 
public:
  Q_PROPERTY(QString name READ name WRITE setName)
 
  
  Q_PROPERTY(QString title READ title WRITE setTitle)

  Q_PROPERTY(bool perSegment READ perSegment WRITE setPerSegment)

  Q_PROPERTY(bool requireSegments READ requireSegments WRITE setRequireSegments)

  Q_PROPERTY(bool showEffectCursorInSliceView READ showEffectCursorInSliceView WRITE setShowEffectCursorInSliceView)

  Q_PROPERTY(bool showEffectCursorInThreeDView READ showEffectCursorInThreeDView WRITE setShowEffectCursorInThreeDView)
 
public:
  typedef QObject Superclass;
  qSlicerSegmentEditorAbstractEffect(QObject* parent = nullptr);
  ~qSlicerSegmentEditorAbstractEffect() override;
 
  // API: Methods that are to be reimplemented in the effect subclasses
public:
  enum ModificationMode
  {
    ModificationModeSet,
    ModificationModeAdd,
    ModificationModeRemove,
    ModificationModeRemoveAll
  };
 
  enum ConfirmationResult
  {
    NotConfirmed,
    ConfirmedWithoutDialog,
    ConfirmedWithDialog,
  };

  virtual QIcon icon() { return QIcon(); };

  Q_INVOKABLE virtual const QString helpText() const { return QString(); };

  virtual qSlicerSegmentEditorAbstractEffect* clone() = 0;

  Q_INVOKABLE virtual void activate();

  Q_INVOKABLE virtual void deactivate();

  Q_INVOKABLE virtual bool active();
 
  Q_INVOKABLE virtual void modifySelectedSegmentByLabelmap(vtkOrientedImageData* modifierLabelmap,
                                                           ModificationMode modificationMode,
                                                           const int modificationExtent[6],
                                                           bool bypassMasking = false);
  Q_INVOKABLE virtual void modifySelectedSegmentByLabelmap(vtkOrientedImageData* modifierLabelmap, ModificationMode modificationMode, bool bypassMasking = false);
  Q_INVOKABLE virtual void modifySelectedSegmentByLabelmap(vtkOrientedImageData* modifierLabelmap,
                                                           ModificationMode modificationMode,
                                                           QList<int> extent,
                                                           bool bypassMasking = false);
  Q_INVOKABLE virtual void modifySegmentByLabelmap(vtkMRMLSegmentationNode* segmentationNode,
                                                   const char* segmentID,
                                                   vtkOrientedImageData* modifierLabelmap,
                                                   ModificationMode modificationMode,
                                                   bool bypassMasking = false);
  Q_INVOKABLE virtual void modifySegmentByLabelmap(vtkMRMLSegmentationNode* segmentationNode,
                                                   const char* segmentID,
                                                   vtkOrientedImageData* modifierLabelmap,
                                                   ModificationMode modificationMode,
                                                   const int modificationExtent[6],
                                                   bool bypassMasking = false);

  Q_INVOKABLE static void applyImageMask(vtkOrientedImageData* input, vtkOrientedImageData* mask, double fillValue, bool notMask = false);

  virtual void setupOptionsFrame() {};

  Q_INVOKABLE virtual QCursor createCursor(qMRMLWidget* viewWidget);

  virtual bool processInteractionEvents(vtkRenderWindowInteractor* callerInteractor, unsigned long eid, qMRMLWidget* viewWidget)
  {
    Q_UNUSED(callerInteractor);
    Q_UNUSED(eid);
    Q_UNUSED(viewWidget);
    return false;
  };

  virtual void processViewNodeEvents(vtkMRMLAbstractViewNode* callerViewNode, unsigned long eid, qMRMLWidget* viewWidget)
  {
    Q_UNUSED(callerViewNode);
    Q_UNUSED(eid);
    Q_UNUSED(viewWidget);
  };

  virtual void setMRMLDefaults() = 0;

  virtual void referenceGeometryChanged() {};
  virtual void sourceVolumeNodeChanged() {};
  virtual void masterVolumeNodeChanged() {};
  virtual void layoutChanged() {};
  virtual void interactionNodeModified(vtkMRMLInteractionNode* interactionNode);
  Q_INVOKABLE virtual void cleanup() {};
 
public slots:
  virtual void updateGUIFromMRML() = 0;

  virtual void updateMRMLFromGUI() = 0;
 
  // Get/set methods
public:
  Q_INVOKABLE vtkMRMLSegmentEditorNode* parameterSetNode();
  Q_INVOKABLE void setParameterSetNode(vtkMRMLSegmentEditorNode* node);

  Q_INVOKABLE vtkMRMLScene* scene();

  Q_INVOKABLE QFrame* optionsFrame();

  Q_INVOKABLE QFormLayout* optionsLayout();

  Q_INVOKABLE void addActor2D(qMRMLWidget* viewWidget, vtkActor2D* actor);

  Q_INVOKABLE void removeActor2D(qMRMLWidget* viewWidget, vtkActor2D* actor);

  Q_INVOKABLE void addActor3D(qMRMLWidget* viewWidget, vtkProp3D* actor);

  Q_INVOKABLE void removeActor3D(qMRMLWidget* viewWidget, vtkProp3D* actor);

  Q_INVOKABLE void addOptionsWidget(QWidget* newOptionsWidget);
  Q_INVOKABLE void addOptionsWidget(QLayout* newOptionsWidget);
 
  Q_INVOKABLE QWidget* addLabeledOptionsWidget(QString label, QWidget* newOptionsWidget);
  Q_INVOKABLE QWidget* addLabeledOptionsWidget(QString label, QLayout* newOptionsWidget);

  virtual QString name() const;
  virtual void setName(QString name);

  virtual QString title() const;
  virtual void setTitle(QString title);

  virtual bool perSegment() const;
  virtual void setPerSegment(bool perSegment);

  virtual bool requireSegments() const;
  virtual void setRequireSegments(bool requireSegments);

  Q_INVOKABLE void cursorOff(qMRMLWidget* viewWidget);
  Q_INVOKABLE void cursorOn(qMRMLWidget* viewWidget);

  Q_INVOKABLE void selectEffect(QString effectName);

  void setCallbackSlots(QObject* receiver, const char* selectEffectSlot, const char* updateVolumeSlot, const char* saveStateForUndoSlot);

  void setVolumes(vtkOrientedImageData* alignedSourceVolume,
                  vtkOrientedImageData* modifierLabelmap,
                  vtkOrientedImageData* maskLabelmap,
                  vtkOrientedImageData* selectedSegmentLabelmap,
                  vtkOrientedImageData* referenceGeometryImage);
 
  // Effect parameter functions
public:
  Q_INVOKABLE QString parameter(QString name);

  Q_INVOKABLE int integerParameter(QString name);

  Q_INVOKABLE double doubleParameter(QString name);

  Q_INVOKABLE vtkMRMLNode* nodeReference(QString name);

  Q_INVOKABLE void setParameter(QString name, QString value);
  Q_INVOKABLE void setParameterDefault(QString name, QString value);
  Q_INVOKABLE void setCommonParameter(QString name, QString value);
  Q_INVOKABLE void setCommonParameterDefault(QString name, QString value);

  Q_INVOKABLE void setParameter(QString name, int value);
  Q_INVOKABLE void setParameterDefault(QString name, int value);
  Q_INVOKABLE void setCommonParameter(QString name, int value);
  Q_INVOKABLE void setCommonParameterDefault(QString name, int value);

  Q_INVOKABLE void setParameter(QString name, double value);
  Q_INVOKABLE void setParameterDefault(QString name, double value);
  Q_INVOKABLE void setCommonParameter(QString name, double value);
  Q_INVOKABLE void setCommonParameterDefault(QString name, double value);

  Q_INVOKABLE void setNodeReference(QString name, vtkMRMLNode* node);
  Q_INVOKABLE void setCommonNodeReference(QString name, vtkMRMLNode* node);
 
  // Utility functions
public:
  Q_INVOKABLE bool parameterDefined(QString name);

  Q_INVOKABLE bool commonParameterDefined(QString name);

  Q_INVOKABLE int confirmCurrentSegmentVisible();
 
  Q_INVOKABLE vtkOrientedImageData* modifierLabelmap();

  Q_INVOKABLE vtkOrientedImageData* defaultModifierLabelmap();
 
  Q_INVOKABLE vtkOrientedImageData* maskLabelmap();
 
  Q_INVOKABLE vtkOrientedImageData* selectedSegmentLabelmap();
 
  Q_INVOKABLE vtkOrientedImageData* referenceGeometryImage();
 
  void setShowEffectCursorInSliceView(bool show);
  void setShowEffectCursorInThreeDView(bool show);
 
  bool showEffectCursorInSliceView();
  bool showEffectCursorInThreeDView();

  Q_INVOKABLE vtkOrientedImageData* sourceVolumeImageData();

  Q_INVOKABLE vtkOrientedImageData* masterVolumeImageData();

  Q_INVOKABLE void saveStateForUndo();

  Q_INVOKABLE static vtkRenderWindow* renderWindow(qMRMLWidget* viewWidget);
  Q_INVOKABLE static vtkRenderer* renderer(qMRMLWidget* viewWidget);
  Q_INVOKABLE static vtkMRMLAbstractViewNode* viewNode(qMRMLWidget* viewWidget);

  static QPoint rasToXy(double ras[3], qMRMLSliceWidget* sliceWidget);
  Q_INVOKABLE static QPoint rasToXy(QVector3D ras, qMRMLSliceWidget* sliceWidget);
  static void xyzToRas(double inputXyz[3], double outputRas[3], qMRMLSliceWidget* sliceWidget);
  Q_INVOKABLE static QVector3D xyzToRas(QVector3D inputXyz, qMRMLSliceWidget* sliceWidget);
  static void xyToRas(QPoint xy, double outputRas[3], qMRMLSliceWidget* sliceWidget);
  static void xyToRas(double xy[2], double outputRas[3], qMRMLSliceWidget* sliceWidget);
  Q_INVOKABLE static QVector3D xyToRas(QPoint xy, qMRMLSliceWidget* sliceWidget);
  static void xyzToIjk(double inputXyz[3], int outputIjk[3], qMRMLSliceWidget* sliceWidget, vtkOrientedImageData* image, vtkMRMLTransformNode* parentTransform = nullptr);
  Q_INVOKABLE static QVector3D xyzToIjk(QVector3D inputXyz, qMRMLSliceWidget* sliceWidget, vtkOrientedImageData* image, vtkMRMLTransformNode* parentTransform = nullptr);
  static void xyToIjk(QPoint xy, int outputIjk[3], qMRMLSliceWidget* sliceWidget, vtkOrientedImageData* image, vtkMRMLTransformNode* parentTransform = nullptr);
  static void xyToIjk(double xy[2], int outputIjk[3], qMRMLSliceWidget* sliceWidget, vtkOrientedImageData* image, vtkMRMLTransformNode* parentTransform = nullptr);
  Q_INVOKABLE static QVector3D xyToIjk(QPoint xy, qMRMLSliceWidget* sliceWidget, vtkOrientedImageData* image, vtkMRMLTransformNode* parentTransform = nullptr);
 
  Q_INVOKABLE static void forceRender(qMRMLWidget* viewWidget);
  Q_INVOKABLE static void scheduleRender(qMRMLWidget* viewWidget);
 
  Q_INVOKABLE static double sliceSpacing(qMRMLSliceWidget* sliceWidget);
 
  Q_INVOKABLE bool segmentationDisplayableInView(vtkMRMLAbstractViewNode* viewNode);
 
  void setSegmentEditorLogic(vtkSlicerSegmentEditorLogic* segmentEditorLogic);
 
protected:
  static vtkMRMLSliceNode* sliceNode(qMRMLSliceWidget* viewWidget);
 
  QString m_Name;
  bool m_Active{ false };
  QString m_Title;

  bool m_PerSegment{ true };
 
  bool m_RequireSegments{ true };
 
  bool m_ShowEffectCursorInSliceView{ true };
  bool m_ShowEffectCursorInThreeDView{ false };
 
  double m_FillValue{ 1.0 };
  double m_EraseValue{ 0.0 };

  vtkWeakPointer<vtkSegment> m_AlreadyConfirmedSegmentVisible;
 
protected:
  QScopedPointer<qSlicerSegmentEditorAbstractEffectPrivate> d_ptr;
 
private:
  Q_DECLARE_PRIVATE(qSlicerSegmentEditorAbstractEffect);
  Q_DISABLE_COPY(qSlicerSegmentEditorAbstractEffect);
};
 
#endif