vtkMRMLSliceIntersectionInteractionRepresentation.h

Go to the documentation of this file.

/*==============================================================================
 
  Program: 3D Slicer
 
  Copyright (c) Ebatinca S.L., Las Palmas de Gran Canaria, Spain
 
  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.
 
==============================================================================*/
 
#ifndef vtkMRMLSliceIntersectionInteractionRepresentation_h
#define vtkMRMLSliceIntersectionInteractionRepresentation_h
 
#include "vtkMRMLDisplayableManagerExport.h" // For export macro
#include "vtkMRMLAbstractWidgetRepresentation.h"
#include "vtkMRMLSliceIntersectionInteractionRepresentationHelper.h"
 
#include "vtkMRMLSliceDisplayNode.h"
#include "vtkMRMLSliceNode.h"
 
class vtkMRMLApplicationLogic;
class vtkMRMLModelDisplayNode;
class vtkMRMLSliceLogic;
 
class vtkProperty2D;
class vtkActor2D;
class vtkPolyDataMapper2D;
class vtkPolyData;
class vtkPoints;
class vtkCellArray;
class vtkTextProperty;
class vtkLeaderActor2D;
class vtkTextMapper;
class vtkTransform;
class vtkActor2D;
 
class SliceIntersectionInteractionDisplayPipeline;
class vtkMRMLInteractionEventData;
 
class VTK_MRML_DISPLAYABLEMANAGER_EXPORT vtkMRMLSliceIntersectionInteractionRepresentation : public vtkMRMLAbstractWidgetRepresentation
{
  public:
    static vtkMRMLSliceIntersectionInteractionRepresentation* New();
 
 
    vtkTypeMacro(vtkMRMLSliceIntersectionInteractionRepresentation, vtkMRMLAbstractWidgetRepresentation);
    void PrintSelf(ostream& os, vtkIndent indent) override;
 
    void SetSliceNode(vtkMRMLSliceNode* sliceNode);
    vtkMRMLSliceNode* GetSliceNode();
 
    vtkMRMLSliceDisplayNode* GetSliceDisplayNode();
 
    bool IsDisplayable();
    void UpdateFromMRML(vtkMRMLNode* caller, unsigned long event, void* callData = nullptr) override;
 
    void AddIntersectingSliceLogic(vtkMRMLSliceLogic* sliceLogic);
    void RemoveIntersectingSliceNode(vtkMRMLSliceNode* sliceNode);
    void UpdateIntersectingSliceNodes();
    void RemoveAllIntersectingSliceNodes();
 
 
    void GetActors2D(vtkPropCollection*) override;
    void ReleaseGraphicsResources(vtkWindow*) override;
    int RenderOverlay(vtkViewport* viewport) override;
 
    void SetMRMLApplicationLogic(vtkMRMLApplicationLogic*);
    vtkGetObjectMacro(MRMLApplicationLogic, vtkMRMLApplicationLogic);
 
    void ComputeSliceIntersectionPoint();
 
    bool DistanceFromSliceIntersectionToPoint(vtkMRMLSliceNode* intersectingSlice, double point_RAS[3], double& distance);
 
    double* GetSliceIntersectionPoint() VTK_SIZEHINT(3);
 
    bool IsMouseCursorInSliceView(double cursorPosition[2]);
 
    void SetPipelinesHandlesVisibility(bool visible);
    void SetPipelinesHandlesOpacity(double opacity);
 
    void TransformIntersectingSlices(vtkMatrix4x4* rotatedSliceToSliceTransformMatrix);
 
    virtual std::string CanInteract(vtkMRMLInteractionEventData* interactionEventData,
        int& foundComponentType, int& foundComponentIndex, double& closestDistance2, double& handleOpacity);
 
    virtual double GetMaximumHandlePickingDistance2();
 
    class HandleInfo
    {
      public:
        HandleInfo(int index, int componentType, const std::string& intersectingSliceNodeID, double positionWorld[3], double positionLocal[3])
          : Index(index)
          , ComponentType(componentType)
          , IntersectingSliceNodeID(intersectingSliceNodeID)
        {
          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;
        }
        int Index;
        int ComponentType;
        std::string IntersectingSliceNodeID;
        double PositionLocal[4];
        double PositionWorld[4];
    };
 
    typedef std::vector<HandleInfo> HandleInfoList;
    virtual HandleInfoList GetHandleInfoList(SliceIntersectionInteractionDisplayPipeline* pipeline);
 
    virtual int GetTranslateArrowCursor(const std::string& intersectingSliceNodeID);
 
  protected:
    vtkMRMLSliceIntersectionInteractionRepresentation();
    ~vtkMRMLSliceIntersectionInteractionRepresentation() override;
 
    SliceIntersectionInteractionDisplayPipeline* GetDisplayPipelineFromSliceLogic(vtkMRMLSliceLogic* sliceLogic);
 
    static void SliceNodeModifiedCallback(vtkObject* caller, unsigned long eid, void* clientData, void* callData);
    void SliceNodeModified(vtkMRMLSliceNode* sliceNode);
    void SliceModelDisplayNodeModified(vtkMRMLModelDisplayNode* sliceNode);
 
    void UpdateSliceIntersectionDisplay(SliceIntersectionInteractionDisplayPipeline* pipeline);
 
    vtkMRMLSliceDisplayNode* GetSliceDisplayNode(vtkMRMLSliceNode* sliceNode);
 
    void SetSliceDisplayNode(vtkMRMLSliceDisplayNode* sliceDisplayNode);
 
    double GetSliceRotationAngleRad(int eventPos[2]);
 
    double GetLineThicknessFromMode(int lineThicknessMode);
 
    double LastEventPosition[2];
 
    double SliceIntersectionPoint[4];
 
    bool SliceIntersectionPointFound;
 
    double InteractionSize{ 3.0 };
 
    vtkMRMLApplicationLogic* MRMLApplicationLogic;
 
    class vtkInternal;
    vtkInternal* Internal;
 
    vtkSmartPointer<vtkMRMLSliceIntersectionInteractionRepresentationHelper> Helper;
 
  private:
    vtkMRMLSliceIntersectionInteractionRepresentation(const vtkMRMLSliceIntersectionInteractionRepresentation&) = delete;
    void operator=(const vtkMRMLSliceIntersectionInteractionRepresentation&) = delete;
};
 
#endif