vtkSlicerMarkupsWidgetRepresentation2D.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 vtkSlicerMarkupsWidgetRepresentation2D_h
#define vtkSlicerMarkupsWidgetRepresentation2D_h
 
#include "vtkSlicerMarkupsModuleVTKWidgetsExport.h"
#include "vtkSlicerMarkupsWidgetRepresentation.h"
 
#include "vtkMRMLSliceNode.h"
 
#include <memory>
 
class vtkActor2D;
class vtkAlgorithmOutput;
class vtkDoubleArray;
class vtkDiscretizableColorTransferFunction;
class vtkFloatArray;
class vtkGlyph2D;
class vtkLabelPlacementMapper;
class vtkMarkupsGlyphSource2D;
class vtkPlane;
class vtkPoints;
class vtkPolyData;
class vtkPolyDataMapper2D;
class vtkProperty2D;
class vtkScalarsToColors;
 
class vtkMRMLInteractionEventData;
 
class VTK_SLICER_MARKUPS_MODULE_VTKWIDGETS_EXPORT vtkSlicerMarkupsWidgetRepresentation2D : public vtkSlicerMarkupsWidgetRepresentation
{
public:
  vtkTypeMacro(vtkSlicerMarkupsWidgetRepresentation2D, vtkSlicerMarkupsWidgetRepresentation);
  void PrintSelf(ostream& os, vtkIndent indent) override;

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

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

  void UpdateFromMRMLInternal(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;

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

  virtual bool GetNthControlPointViewVisibility(int n);

  virtual void SetNthControlPointSliceVisibility(int n, bool visibility);

  virtual void SetCenterSliceVisibility(bool visibility);
 
  void GetSliceToWorldCoordinates(const double[2], double[3]);
  void GetWorldToSliceCoordinates(const double worldPos[3], double slicePos[2]);
 
protected:
  vtkSlicerMarkupsWidgetRepresentation2D();
  ~vtkSlicerMarkupsWidgetRepresentation2D() override;

  vtkMRMLSliceNode* GetSliceNode();
 
  void UpdatePlaneFromSliceNode();
 
  void UpdateViewScaleFactor() override;
  void UpdateControlPointSize() override;
 
  // Return squared distance of maximum distance for picking a control point,
  // in pixels.
  double GetMaximumControlPointPickingDistance2();
 
  bool GetAllControlPointsVisible() override;

  virtual bool IsControlPointDisplayableOnSlice(vtkMRMLMarkupsNode* node, int pointIndex = 0);
 
  // Update colormap based on provided base color (modulated with settings stored in the display node)
  virtual void UpdateDistanceColorMap(vtkDiscretizableColorTransferFunction* colormap, double color[3]);

  virtual bool IsPointBehindSlice(vtkMRMLMarkupsNode* node, int pointIndex = 0);

  virtual bool IsPointInFrontSlice(vtkMRMLMarkupsNode* node, int pointIndex = 0);

  virtual bool IsCenterDisplayableOnSlice(vtkMRMLMarkupsNode* node);

  void GetWorldToDisplayCoordinates(double r, double a, double s, double* displayCoordinates);
  void GetWorldToDisplayCoordinates(double* worldCoordinates, double* displayCoordinates);

  bool IsRepresentationIntersectingSlice(vtkPolyData* representation, const char* arrayName);

  virtual void ComputeIntersectionFadingScalars(vtkPolyData* worldPolyData,
                                                vtkPlane* slicePlane,
                                                vtkPolyData* outputPolyData,
                                                vtkFloatArray* distanceArray = nullptr,
                                                vtkPoints* intersectionPoints = nullptr);

  virtual void UpdateSliceIntersectionPointDisplay(double glyphSize, vtkScalarsToColors* colorMap);
 
  class ControlPointsPipeline2D : public ControlPointsPipeline
  {
  public:
    ControlPointsPipeline2D();
    ~ControlPointsPipeline2D() override;
 
    vtkSmartPointer<vtkActor2D> Actor;
    vtkSmartPointer<vtkPolyDataMapper2D> Mapper;
    vtkSmartPointer<vtkGlyph2D> Glypher;
    vtkSmartPointer<vtkActor2D> LabelsActor;
    vtkSmartPointer<vtkLabelPlacementMapper> LabelsMapper;
    // Properties used to control the appearance of selected objects and
    // the manipulator in general.
    vtkSmartPointer<vtkProperty2D> Property;
  };
 
  ControlPointsPipeline2D* GetControlPointsPipeline(int controlPointType);
 
  vtkSmartPointer<vtkIntArray> PointsVisibilityOnSlice;
  bool CenterVisibilityOnSlice = { false };
  bool AnyPointVisibilityOnSlice = { false }; // at least one point is visible
 
  vtkSmartPointer<vtkTransform> WorldToSliceTransform;
  vtkSmartPointer<vtkPlane> SlicePlane;

  class LineIntersectionPointsPipeline2D
  {
  public:
    LineIntersectionPointsPipeline2D(vtkAlgorithmOutput* glyphSourcePort, vtkProperty2D* property);
    ~LineIntersectionPointsPipeline2D() = default;
 
    vtkSmartPointer<vtkPoints> DisplayPoints;
    vtkSmartPointer<vtkPolyData> PointsPoly;
    vtkSmartPointer<vtkGlyph2D> Glypher;
    vtkSmartPointer<vtkPolyDataMapper2D> Mapper;
    vtkSmartPointer<vtkProperty2D> Property;
    vtkSmartPointer<vtkActor2D> Actor;
  };

  class LineDirectionArrowPipeline2D
  {
  public:
    LineDirectionArrowPipeline2D();
    ~LineDirectionArrowPipeline2D() = default;
 
    vtkSmartPointer<vtkPoints> Points;
    vtkSmartPointer<vtkDoubleArray> Normals;
    vtkSmartPointer<vtkFloatArray> SliceDistances; 
    vtkSmartPointer<vtkPolyData> PointsPoly;
    vtkSmartPointer<vtkGlyph2D> Glypher;
    vtkSmartPointer<vtkPolyDataMapper2D> Mapper;
    vtkSmartPointer<vtkActor2D> Actor;
  };

  std::unique_ptr<LineDirectionArrowPipeline2D> LineDirectionArrowPipeline;

  vtkSmartPointer<vtkPoints> LineDirectionMarkerCachedWorldPositions;
  vtkSmartPointer<vtkDoubleArray> LineDirectionMarkerCachedWorldTangents;
  double LineDirectionMarkerLastSpacing = -1.0;
  vtkMTimeType LineDirectionMarkerLastGeometryMTime = 0;
  vtkMTimeType LineDirectionMarkerLastSlicePlaneMTime = 0;
  vtkMTimeType LineDirectionMarkerLastMarkupsDisplayMTime = 0;
  bool LineDirectionFirstToLastControlPoint = true;
 
  // Line slice intersection point glyph pipelines (2D).
  // Mark the exact positions where a curve/line crosses the slice plane.
  // Entering (CircledCross) and exiting (CircledPoint) are driven by
  // SliceIntersectionApproachingSigns.
  vtkSmartPointer<vtkPoints> LineSliceIntersectionWorldPoints;
  vtkSmartPointer<vtkFloatArray> LineSliceIntersectionApproachingSigns;
  vtkSmartPointer<vtkProperty2D> LineSliceIntersectionProperty;
  std::unique_ptr<LineIntersectionPointsPipeline2D> LineSliceIntersectionEnteringPipeline;
  std::unique_ptr<LineIntersectionPointsPipeline2D> LineSliceIntersectionExitingPipeline;

  vtkMTimeType FadingScalarsLastWorldDataMTime = 0;
  vtkMTimeType FadingScalarsLastSlicePlaneMTime = 0;
  double FadingScalarsLastFadingEnd = -1.0;
 
  virtual void UpdateAllPointsAndLabelsFromMRML(double labelsOffset);
 
  double GetWidgetOpacity(int controlPointType);
 
private:
  vtkSlicerMarkupsWidgetRepresentation2D(const vtkSlicerMarkupsWidgetRepresentation2D&) = delete;
  void operator=(const vtkSlicerMarkupsWidgetRepresentation2D&) = delete;
};
 
#endif