vtkSlicerMarkupsWidget.h

Go to the documentation of this file.

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

 Copyright (c) ProxSim ltd., Kwun Tong, Hong Kong. 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 Davide Punzo, punzodavide@hotmail.it,
 and development was supported by ProxSim ltd.

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

#ifndef vtkSlicerMarkupsWidget_h
#define vtkSlicerMarkupsWidget_h

#include "vtkSlicerMarkupsModuleVTKWidgetsExport.h"
#include "vtkMRMLAbstractWidget.h"
#include "vtkWidgetCallbackMapper.h"

#include "vtkMRMLMarkupsNode.h"

class vtkMRMLAbstractViewNode;
class vtkMRMLApplicationLogic;
class vtkMRMLInteractionEventData;
class vtkMRMLInteractionNode;
class vtkIdList;
class vtkPolyData;
class vtkSlicerMarkupsWidgetRepresentation;

class VTK_SLICER_MARKUPS_MODULE_VTKWIDGETS_EXPORT vtkSlicerMarkupsWidget : public vtkMRMLAbstractWidget
{
public:
  vtkTypeMacro(vtkSlicerMarkupsWidget, vtkMRMLAbstractWidget);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  virtual void CreateDefaultRepresentation(vtkMRMLMarkupsDisplayNode* markupsDisplayNode, vtkMRMLAbstractViewNode* viewNode, vtkRenderer* renderer) = 0;

  virtual vtkSlicerMarkupsWidget* CreateInstance() const = 0;

  enum
  {
    WidgetStateDefine = WidgetStateUser, // click in empty area will place a new point
    WidgetStateTranslateControlPoint, // translating the active point by mouse move
    WidgetStateOnTranslationHandle, // hovering over a translation interaction handle
    WidgetStateOnRotationHandle, // hovering over a rotation interaction handle
    WidgetStateOnScaleHandle, // hovering over a scale interaction handle
    WidgetStateMarkups_Last
  };

  enum
  {
    WidgetEventControlPointPlace = WidgetEventUser,
    WidgetEventClickAndDragStart,
    WidgetEventClickAndDragEnd,
    WidgetEventStopPlace,
    WidgetEventControlPointMoveStart,
    WidgetEventControlPointMoveEnd,
    WidgetEventControlPointDelete,
    WidgetEventControlPointInsert,
    WidgetEventControlPointSnapToSlice,
    WidgetEventReserved,  // this events is only to prevent other widgets from processing an event
    WidgetEventMarkups_Last
  };

  // Returns true if one of the markup points are just being previewed and not placed yet.
  bool IsPointPreviewed();

  void UpdatePreviewPointIndex(vtkMRMLInteractionEventData* eventData);

  void UpdatePreviewPoint(vtkMRMLInteractionEventData* eventData, const char* associatedNodeID, int positionStatus);

  bool RemovePreviewPoint();

  // Places a new markup point.
  // Reuses current preview point, if possible.
  // Returns true if the event is processed.
  virtual bool PlacePoint(vtkMRMLInteractionEventData* eventData);

  virtual int AddPointFromWorldCoordinate(const double worldCoordinates[3]);

  virtual int AddNodeOnWidget(const int displayPos[2]);

  bool CanProcessInteractionEvent(vtkMRMLInteractionEventData* eventData, double &distance2) override;

  bool ProcessInteractionEvent(vtkMRMLInteractionEventData* eventData) override;

  void Leave(vtkMRMLInteractionEventData* eventData) override;

  // Allows the widget to request interactive mode (faster updates)
  bool GetInteractive() override;
  // Allows the widget to request a cursor shape
  int GetMouseCursor() override;

  vtkMRMLMarkupsNode* GetMarkupsNode();
  vtkMRMLMarkupsDisplayNode* GetMarkupsDisplayNode();
  int GetActiveControlPoint();

  vtkSlicerMarkupsWidgetRepresentation* GetMarkupsRepresentation();

  int GetActiveComponentType();
  int GetActiveComponentIndex();

  vtkMRMLSelectionNode* selectionNode();

protected:
  vtkSlicerMarkupsWidget();
  ~vtkSlicerMarkupsWidget() override;

  void StartWidgetInteraction(vtkMRMLInteractionEventData* eventData);
  void EndWidgetInteraction();

  virtual void TranslatePoint(double eventPos[2], bool snapToSlice = false);
  virtual void TranslateWidget(double eventPos[2]);
  virtual void ScaleWidget(double eventPos[2]);
  virtual void RotateWidget(double eventPos[2]);

  bool IsAnyControlPointLocked();

  // Get accurate world position.
  // World position that comes in the event data may be inaccurate, this method computes a more reliable position.
  // Returns true on success.
  // refWorldPos is an optional reference position: if point distance from camera cannot be determined then
  // depth of this reference position is used.
  bool ConvertDisplayPositionToWorld(const int displayPos[2], double worldPos[3], double worldOrientationMatrix[9],
    double* refWorldPos = nullptr);

  int PreviewPointIndex;

  // Callback interface to capture events when
  // placing the widget.
  // Return true if the event is processed.
  virtual bool ProcessMouseMove(vtkMRMLInteractionEventData* eventData);
  virtual bool ProcessWidgetMenu(vtkMRMLInteractionEventData* eventData);
  virtual bool ProcessWidgetAction(vtkMRMLInteractionEventData* eventData);
  virtual bool ProcessWidgetStopPlace(vtkMRMLInteractionEventData* eventData);
  virtual bool ProcessControlPointSnapToSlice(vtkMRMLInteractionEventData* eventData);
  virtual bool ProcessControlPointDelete(vtkMRMLInteractionEventData* eventData);
  virtual bool ProcessControlPointInsert(vtkMRMLInteractionEventData* eventData);
  virtual bool ProcessControlPointMoveStart(vtkMRMLInteractionEventData* eventData);
  virtual bool ProcessWidgetTranslateStart(vtkMRMLInteractionEventData* eventData);
  virtual bool ProcessWidgetRotateStart(vtkMRMLInteractionEventData* eventData);
  virtual bool ProcessWidgetScaleStart(vtkMRMLInteractionEventData* eventData);
  virtual bool ProcessEndMouseDrag(vtkMRMLInteractionEventData* eventData);
  virtual bool ProcessWidgetReset(vtkMRMLInteractionEventData* eventData);
  virtual bool ProcessWidgetJumpCursor(vtkMRMLInteractionEventData* eventData);

  // Get the closest point on the line defined by the interaction handle axis.
  // Input coordinates are in display coordinates, while output are in world coordinates.
  virtual bool GetClosestPointOnInteractionAxis(int type, int index, const double inputDisplay[2], double outputIntersectionWorld[3]);

  // Get the closest point on the plane defined using the interaction handle axis as the plane normal.
  // Input coordinates are in display coordinates, while output are in world coordinates
  virtual bool GetIntersectionOnAxisPlane(int type, int index, const double inputDisplay[2], double outputIntersectionWorld[3]);

  // Variables for translate/rotate/scale
  double LastEventPosition[2];
  double StartEventOffsetPosition[2];

private:
  vtkSlicerMarkupsWidget(const vtkSlicerMarkupsWidget&) = delete;
  void operator=(const vtkSlicerMarkupsWidget&) = delete;
};

//----------------------------------------------------------------------
// CREATE INSTANCE MACRO

#ifdef VTK_HAS_INITIALIZE_OBJECT_BASE
#define vtkSlicerMarkupsWidgetCreateInstanceMacro(type) \
vtkSlicerMarkupsWidget* CreateInstance() const override\
{ \
  vtkObject* ret = vtkObjectFactory::CreateInstance(#type); \
  if(ret) \
    { \
    return static_cast<type *>(ret); \
    } \
  type* result = new type; \
  result->InitializeObjectBase(); \
  return result; \
}
#else
#define vtkSlicerMarkupsWidgetCreateInstanceMacro(type) \
vtkSlicerMarkupsWidget* CreateInstance() const override\
{ \
  vtkObject* ret = vtkObjectFactory::CreateInstance(#type); \
  if(ret) \
    { \
    return static_cast<type *>(ret); \
    } \
  return new type; \
}
#endif

#endif