vtkMRMLSliceDisplayNode.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 __vtkMRMLSliceDisplayNode_h
#define __vtkMRMLSliceDisplayNode_h
 
// MRML includes
#include "vtkMRMLModelDisplayNode.h"

class VTK_MRML_EXPORT vtkMRMLSliceDisplayNode : public vtkMRMLModelDisplayNode
{
public:
  static vtkMRMLSliceDisplayNode* New();
  vtkTypeMacro(vtkMRMLSliceDisplayNode, vtkMRMLModelDisplayNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  void ReadXMLAttributes(const char** atts) override;

  void WriteXML(ostream& of, int indent) override;

  vtkMRMLCopyContentMacro(vtkMRMLSliceDisplayNode);
 
  vtkMRMLNode* CreateNodeInstance() override;

  const char* GetNodeTagName() override { return "SliceDisplay"; }


  bool GetIntersectingSlicesVisibility() { return this->GetVisibility2D(); };
 
  void SetIntersectingSlicesVisibility(bool visible) { this->SetVisibility2D(visible); };
  vtkBooleanMacro(IntersectingSlicesVisibility, bool);


  vtkGetMacro(IntersectingThickSlabVisibility, bool);
  vtkSetMacro(IntersectingThickSlabVisibility, bool);
  vtkBooleanMacro(IntersectingThickSlabVisibility, bool);


  vtkGetMacro(IntersectingSlicesInteractive, bool);
  vtkSetMacro(IntersectingSlicesInteractive, bool);
  vtkBooleanMacro(IntersectingSlicesInteractive, bool);


  vtkGetMacro(IntersectingThickSlabInteractive, bool);
  vtkSetMacro(IntersectingThickSlabInteractive, bool);
  vtkBooleanMacro(IntersectingThickSlabInteractive, bool);


  vtkGetMacro(IntersectingSlicesTranslationEnabled, bool);
  vtkSetMacro(IntersectingSlicesTranslationEnabled, bool);
  vtkBooleanMacro(IntersectingSlicesTranslationEnabled, bool);
  vtkGetMacro(IntersectingSlicesRotationEnabled, bool);
  vtkSetMacro(IntersectingSlicesRotationEnabled, bool);
  vtkBooleanMacro(IntersectingSlicesRotationEnabled, bool);
 
  enum IntersectingSlicesInteractiveMode
  {
    ModeRotation,
    ModeTranslation
  };


  void SetIntersectingSlicesInteractiveModeEnabled(IntersectingSlicesInteractiveMode mode, bool enabled);
  bool GetIntersectingSlicesInteractiveModeEnabled(IntersectingSlicesInteractiveMode mode);
 
  enum HandlesVisibilityMode
  {
    NeverVisible = 0, 
    NearbyVisible,    
    AlwaysVisible,    
    // FadingVisible, // Handles' opacity increases as the mouse gets closer to them
    HandlesVisibilityMode_Last // insert new types above this line
  };


  vtkGetMacro(IntersectingSlicesInteractiveHandlesVisibilityMode, int);
  vtkSetMacro(IntersectingSlicesInteractiveHandlesVisibilityMode, int);


  static const char* GetIntersectingSlicesInteractiveHandlesVisibilityModeAsString(int id);
  static int GetIntersectingSlicesInteractiveHandlesVisibilityModeFromString(const char*);
 
  enum IntersectionMode
  {
    SkipLineCrossings = 0, 
    FullLines,             
    IntersectionMode_Last  // insert new types above this line
  };


  vtkGetMacro(IntersectingSlicesIntersectionMode, int);
  vtkSetMacro(IntersectingSlicesIntersectionMode, int);


  static const char* GetIntersectingSlicesIntersectionModeAsString(int id);
  static int GetIntersectingSlicesIntersectionModeFromString(const char*);
 
  enum LineThicknessMode
  {
    FineLines = 0,         
    MediumLines,           
    ThickLines,            
    LineThicknessMode_Last // insert new types above this line
  };


  vtkGetMacro(IntersectingSlicesLineThicknessMode, int);
  vtkSetMacro(IntersectingSlicesLineThicknessMode, int);


  static const char* GetIntersectingSlicesLineThicknessModeAsString(int id);
  static int GetIntersectingSlicesLineThicknessModeFromString(const char*);

  static const std::string GetDefaultContextName() { return ""; };
 
  enum ComponentType
  {
    ComponentNone = 0,                               
    ComponentTranslateIntersectingSlicesHandle,      
    ComponentRotateIntersectingSlicesHandle,         
    ComponentTranslateSingleIntersectingSliceHandle, 
    ComponentSliceIntersection,                      
    ComponentTranslateIntersectingThickSlabHandle,   
    Component_Last
  };

  int GetActiveComponentType(std::string context = vtkMRMLSliceDisplayNode::GetDefaultContextName());

  int GetActiveComponentIndex(std::string context = vtkMRMLSliceDisplayNode::GetDefaultContextName());

  void SetActiveComponent(int componentType, int componentIndex, std::string context = vtkMRMLSliceDisplayNode::GetDefaultContextName());

  bool HasActiveComponent();

  std::vector<std::string> GetActiveComponentInteractionContexts();
 
protected:
  vtkMRMLSliceDisplayNode();
  ~vtkMRMLSliceDisplayNode() override;
  vtkMRMLSliceDisplayNode(const vtkMRMLSliceDisplayNode&);
  void operator=(const vtkMRMLSliceDisplayNode&);
 
  struct ComponentInfo
  {
    ComponentInfo()
    {
      this->Type = ComponentNone;
      this->Index = -1;
    }
    int Type;
    int Index;
  };
 
  bool IntersectingSlicesInteractive{ false };
  bool IntersectingSlicesTranslationEnabled{ true };
  bool IntersectingSlicesRotationEnabled{ true };
  bool IntersectingThickSlabInteractive{ false };
  bool IntersectingThickSlabVisibility{ false };
 
  int IntersectingSlicesInteractiveHandlesVisibilityMode{ NeverVisible };
 
  int IntersectingSlicesIntersectionMode{ FullLines };
 
  int IntersectingSlicesLineThicknessMode{ FineLines };

  std::map<std::string, ComponentInfo> ActiveComponents;
};
 
#endif