vtkSlicerMarkupsWidgetRepresentation.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 vtkSlicerMarkupsRepresentation_h
#define vtkSlicerMarkupsRepresentation_h

#include "vtkSlicerMarkupsModuleVTKWidgetsExport.h"

#include "vtkMRMLAbstractWidgetRepresentation.h"
#include "vtkMRMLMarkupsDisplayNode.h"
#include "vtkMRMLMarkupsNode.h"

#include "vtkActor2D.h"
#include "vtkAppendPolyData.h"
#include "vtkArcSource.h"
#include "vtkArrowSource.h"
#include "vtkGlyph3D.h"
#include "vtkLookupTable.h"
#include "vtkMarkupsGlyphSource2D.h"
#include "vtkPointPlacer.h"
#include "vtkPointSetToLabelHierarchy.h"
#include "vtkPolyDataMapper2D.h"
#include "vtkProperty2D.h"
#include "vtkSmartPointer.h"
#include "vtkSphereSource.h"
#include "vtkTextActor.h"
#include "vtkTextProperty.h"
#include "vtkTensorGlyph.h"
#include "vtkTransform.h"
#include "vtkTransformPolyDataFilter.h"
#include "vtkTubeFilter.h"

class vtkMRMLInteractionEventData;

class VTK_SLICER_MARKUPS_MODULE_VTKWIDGETS_EXPORT vtkSlicerMarkupsWidgetRepresentation : public vtkMRMLAbstractWidgetRepresentation
{
public:
  enum
  {
    Unselected,
    Selected,
    Active,
    Project,
    ProjectBack,
    NumberOfControlPointTypes
  };

  vtkTypeMacro(vtkSlicerMarkupsWidgetRepresentation, vtkMRMLAbstractWidgetRepresentation);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  void UpdateFromMRML(vtkMRMLNode* caller, unsigned long event, void *callData = nullptr) override;

  void GetActors(vtkPropCollection*) override;
  void ReleaseGraphicsResources(vtkWindow*) override;
  int RenderOverlay(vtkViewport* viewport) override;
  int RenderOpaqueGeometry(vtkViewport* viewport) override;
  int RenderTranslucentPolygonalGeometry(vtkViewport* viewport) override;
  vtkTypeBool HasTranslucentPolygonalGeometry() override;

  virtual int GetNumberOfControlPoints();

  virtual int GetNthControlPointDisplayPosition(int n, double pos[2]);

  virtual vtkMRMLMarkupsNode::ControlPoint *GetNthControlPoint(int n);

  virtual void SetMarkupsDisplayNode(vtkMRMLMarkupsDisplayNode *markupsDisplayNode);
  virtual vtkMRMLMarkupsDisplayNode* GetMarkupsDisplayNode();
  virtual vtkMRMLMarkupsNode* GetMarkupsNode();

  virtual void UpdateCenterOfRotation();

  virtual bool GetTransformationReferencePoint(double referencePointWorld[3]);

  virtual void CanInteract(vtkMRMLInteractionEventData* interactionEventData,
    int &foundComponentType, int &foundComponentIndex, double &closestDistance2);

  virtual int FindClosestPointOnWidget(const int displayPos[2], double worldPos[3], int *idx);

  virtual vtkPointPlacer* GetPointPlacer();

  virtual vtkPolyData* GetControlPointsPolyData(int controlPointType);
  virtual vtkPolyData* GetLabelControlPointsPolyData(int pipeline);
  virtual vtkStringArray* GetLabels(int pipeline);


  bool IsDisplayable();

  virtual void GetInteractionHandleAxisWorld(int type, int index, double axis[3]);
  virtual void GetInteractionHandleOriginWorld(double origin[3]);
  virtual void GetInteractionHandlePositionWorld(int type, int index, double position[3]);

protected:
  vtkSlicerMarkupsWidgetRepresentation();
  ~vtkSlicerMarkupsWidgetRepresentation() override;

  // Convert glyph types from display node enums to 2D glyph source enums
  static int GetGlyphTypeSourceFromDisplay(int glyphTypeDisplay);

  class ControlPointsPipeline
  {
  public:
    ControlPointsPipeline();
    virtual ~ControlPointsPipeline();

    //vtkSmartPointer<vtkPolyData> PointMarkerShape;
    vtkSmartPointer<vtkMarkupsGlyphSource2D> GlyphSource2D;
    vtkSmartPointer<vtkSphereSource> GlyphSourceSphere;

    vtkSmartPointer<vtkPolyData> ControlPointsPolyData;
    vtkSmartPointer<vtkPoints> ControlPoints;
    vtkSmartPointer<vtkPolyData> LabelControlPointsPolyData;
    vtkSmartPointer<vtkPoints> LabelControlPoints;
    vtkSmartPointer<vtkPointSetToLabelHierarchy> PointSetToLabelHierarchyFilter;
    vtkSmartPointer<vtkStringArray> Labels;
    vtkSmartPointer<vtkStringArray> LabelsPriority;
    vtkSmartPointer<vtkTextProperty> TextProperty;
  };

  class VTK_SLICER_MARKUPS_MODULE_VTKWIDGETS_EXPORT MarkupsInteractionPipeline
  {
  public:
    MarkupsInteractionPipeline(vtkMRMLAbstractWidgetRepresentation* representation);
    virtual ~MarkupsInteractionPipeline();

    vtkWeakPointer<vtkMRMLAbstractWidgetRepresentation> Representation;

    vtkSmartPointer<vtkSphereSource>                    AxisRotationHandleSource;
    vtkSmartPointer<vtkArcSource>                       AxisRotationArcSource;
    vtkSmartPointer<vtkTubeFilter>                      AxisRotationTubeFilter;
    vtkSmartPointer<vtkPolyData>                        AxisRotationInteriorAnglePolyData;
    vtkSmartPointer<vtkTubeFilter>                      AxisRotationInterorAngleTubeFilter;
    vtkSmartPointer<vtkPolyData>                        RotationHandlePoints;
    vtkSmartPointer<vtkTransformPolyDataFilter>         RotationScaleTransform;
    vtkSmartPointer<vtkAppendPolyData>                  AxisRotationGlyphSource;
    vtkSmartPointer<vtkTensorGlyph>                     AxisRotationGlypher;

    vtkSmartPointer<vtkArrowSource>                     AxisTranslationGlyphSource;
    vtkSmartPointer<vtkTransformPolyDataFilter>         AxisTranslationGlyphTransformer;
    vtkSmartPointer<vtkPolyData>                        TranslationHandlePoints;
    vtkSmartPointer<vtkTransformPolyDataFilter>         TranslationScaleTransform;
    vtkSmartPointer<vtkGlyph3D>                         AxisTranslationGlypher;

    vtkSmartPointer<vtkSphereSource>                    AxisScaleHandleSource;
    vtkSmartPointer<vtkPolyData>                        ScaleHandlePoints;
    vtkSmartPointer<vtkTransformPolyDataFilter>         ScaleScaleTransform;
    vtkSmartPointer<vtkGlyph3D>                         AxisScaleGlypher;

    vtkSmartPointer<vtkAppendPolyData>                  Append;
    vtkSmartPointer<vtkTransformPolyDataFilter>         HandleToWorldTransformFilter;
    vtkSmartPointer<vtkTransform>                       HandleToWorldTransform;
    vtkSmartPointer<vtkLookupTable>                     ColorTable;
    vtkSmartPointer<vtkPolyDataMapper2D>                Mapper;
    vtkSmartPointer<vtkActor2D>                         Actor;
    vtkSmartPointer<vtkProperty2D>                      Property;

    double                                              StartFadeAngle{30};
    double                                              EndFadeAngle{20};
    double                                              InteractionHandleSize{1.0};

    virtual void InitializePipeline();
    virtual void CreateRotationHandles();
    virtual void CreateTranslationHandles();
    virtual void CreateScaleHandles();
    virtual void UpdateHandleVisibility();
    virtual void UpdateHandleColors();

    virtual void SetWidgetScale(double scale);
    virtual void GetHandleColor(int type, int index, double color[4]);
    virtual double GetHandleOpacity(int type, int index);

    virtual void GetViewPlaneNormal(double normal[3]);

    virtual void GetInteractionHandlePositionWorld(int type, int index, double position[3]);
    virtual void GetInteractionHandleAxis(int type, int index, double axis[3]);
    virtual void GetInteractionHandleAxisWorld(int type, int index, double axis[3]);
    virtual void GetInteractionHandleOriginWorld(double origin[3]);

    struct HandleInfo
    {
      HandleInfo(int index, int componentType, double positionWorld[3], double positionLocal[3], double color[4])
        : Index(index)
        , ComponentType(componentType)
      {
      for (int i = 0; i < 3; ++i)
        {
        this->PositionWorld[i] = positionWorld[i];
        }
      this->PositionWorld[3] = 1.0;
      for (int i = 0; i < 3; ++i)
        {
        this->PositionLocal[i] = positionLocal[i];
        }
      this->PositionLocal[3] = 1.0;
      for (int i = 0; i < 4; ++i)
        {
        this->Color[i] = color[i];
        }
      }
      int Index;
      int ComponentType;
      double PositionLocal[4];
      double PositionWorld[4];
      double Color[4];
      bool IsVisible()
        {
        double epsilon = 0.001;
        return this->Color[3] > epsilon;
        }
    };

    virtual std::vector<HandleInfo> GetHandleInfoList();
  };
  typedef std::vector<MarkupsInteractionPipeline::HandleInfo> HandleInfoList;

  // Calculate view size and scale factor
  virtual void UpdateViewScaleFactor() = 0;

  virtual void UpdateControlPointSize() = 0;

  // Update the size of the interaction handle based on screen size + vtkMRMLMarkupsDisplayNode::InteractionHandleScale parameter.
  virtual void UpdateInteractionHandleSize();

  double ViewScaleFactorMmPerPixel;
  double ScreenSizePixel; // diagonal size of the screen

  // Control point size, specified in renderer world coordinate system.
  // For slice views, renderer world coordinate system is the display coordinate system, so it is measured in pixels.
  // For 3D views, renderer world coordinate system is the Slicer world coordinate system, so it is measured in the
  // scene length unit (typically millimeters).
  double ControlPointSize;

  virtual void SetMarkupsNode(vtkMRMLMarkupsNode *markupsNode);

  vtkWeakPointer<vtkMRMLMarkupsDisplayNode> MarkupsDisplayNode;
  vtkWeakPointer<vtkMRMLMarkupsNode> MarkupsNode;

  vtkSmartPointer<vtkPointPlacer> PointPlacer;

  vtkSmartPointer<vtkTextActor> TextActor;

  vtkTypeBool CurveClosed;

  virtual bool GetAllControlPointsVisible();

  bool GetAllControlPointsSelected();

  // Utility function to build straight lines between control points.
  // If displayPosition is true then positions will be computed in display coordinate system,
  // otherwise in world coordinate system.
  // displayPosition is normally set to true in 2D, and to false in 3D representations.
  void BuildLine(vtkPolyData* linePolyData, bool displayPosition);

  vtkTimeStamp MarkupsTransformModifiedTime;

  double* GetWidgetColor(int controlPointType);

  ControlPointsPipeline* ControlPoints[NumberOfControlPointTypes]; // Unselected, Selected, Active, Project, ProjectBehind

  virtual void SetupInteractionPipeline();
  MarkupsInteractionPipeline* InteractionPipeline;

  virtual void UpdateInteractionPipeline();

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

#endif