vtkMRMLClipNode.h

Go to the documentation of this file.

/*==============================================================================
 
  Copyright (c) Laboratory for Percutaneous Surgery (PerkLab)
  Queen's University, Kingston, ON, Canada. 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 Kyle Sunderland, PerkLab, Queen's University
  and was supported in part through NIH grant R01 HL153166.
 
==============================================================================*/
 
#ifndef __vtkMRMLClipNode_h
#define __vtkMRMLClipNode_h
 
#include "vtkMRMLNode.h"
 
class vtkImplicitBoolean;
class vtkImplicitFunction;
class vtkImplicitFunctionCollection;
class vtkMRMLMessageCollection;
class vtkPlaneCollection;

class VTK_MRML_EXPORT vtkMRMLClipNode : public vtkMRMLNode
{
public:
  static vtkMRMLClipNode* New();
  vtkTypeMacro(vtkMRMLClipNode, vtkMRMLNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  //--------------------------------------------------------------------------
  //--------------------------------------------------------------------------
 
  vtkMRMLNode* CreateNodeInstance() override;

  void ReadXMLAttributes(const char** atts) override;

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

  vtkMRMLCopyContentMacro(vtkMRMLClipNode);

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

  enum
  {
    ClipNodeModifiedEvent = 53001
  };
 
  enum ClipTypeType
  {
    ClipIntersection = 0,
    ClipUnion = 1
  };


  void SetClipType(int clipType);
  int GetClipType();


  static int GetClipTypeFromString(const char* name);
  static const char* GetClipTypeAsString(int type);

  int GetClippingNodeIndex(const char* nodeID);

  enum ClippingStateType
  {
    ClipOff = 0,           // Clipping disabled
    ClipPositiveSpace = 1, // Keep +ve region of the implicit function
    ClipNegativeSpace = 2, // Keep -ve region of the implicit function
  };


  int GetClippingNodeState(vtkMRMLNode* node);
  int GetClippingNodeState(const char* nodeID);
  int GetNthClippingNodeState(int n);
  void SetClippingNodeState(vtkMRMLNode*, int);
  void SetClippingNodeState(const char* nodeID, int);
  void SetNthClippingNodeState(int n, int state);


  int GetRedSliceClipState();
  void SetRedSliceClipState(int);


  int GetYellowSliceClipState();
  void SetYellowSliceClipState(int);


  int GetGreenSliceClipState();
  void SetGreenSliceClipState(int);

  static const char* GetClippingNodeStatePropertyName();


  static int GetClippingStateFromString(const char* name);
  static const char* GetClippingStateAsString(int state);


  enum ClippingMethodType
  {
    Straight = 0,
    WholeCells,
    WholeCellsWithBoundary,
  };



  vtkGetMacro(ClippingMethod, int);
  vtkSetMacro(ClippingMethod, int);


  static int GetClippingMethodFromString(const char* name);
  static const char* GetClippingMethodAsString(int type);

  void AddAndObserveClippingNodeID(const char* clippingNodeID);


  void SetAndObserveClippingNodeID(const char* clippingNodeID);
  void SetAndObserveNthClippingNodeID(int n, const char* clippingNodeID);


  void RemoveClippingNodeID(const char* clippingNodeID);
  void RemoveNthClippingNodeID(int n);
  void RemoveAllClippingNodeIDs();


  const char* GetNthClippingNodeID(int n);
  const char* GetClippingNodeID();

  bool HasClippingNodeID(const char* clippingNodeID);

  int GetNumberOfClippingNodes();

  int GetClippingNodeIndexFromID(const char* clippingNodeID);


  vtkMRMLNode* GetNthClippingNode(int n);
  vtkMRMLNode* GetClippingNode();

  const char* GetClippingNodeReferenceRole() const;

  vtkImplicitFunction* GetImplicitFunctionWorld();

  void GetPlanes(vtkPlaneCollection* planes);

  void ProcessMRMLEvents(vtkObject* caller, unsigned long event, void* callData) override;

  void CopyReferences(vtkMRMLNode* node) override;

  bool GetClippingPlanes(vtkPlaneCollection* planeCollection, bool invert = false, vtkMRMLMessageCollection* messages = nullptr);
 
protected:
  void UpdateImplicitFunction();
 
  int GetSliceClipState(const char* nodeID);
  void SetSliceClipState(const char* nodeID, int state);

  static bool GetClippingPlanesFromFunction(vtkImplicitFunction* function, vtkPlaneCollection* planeCollection, bool invert = false);
 
protected:
  vtkMRMLClipNode();
  ~vtkMRMLClipNode() override;
  vtkMRMLClipNode(const vtkMRMLClipNode&);
  void operator=(const vtkMRMLClipNode&);

  void OnNodeReferenceAdded(vtkMRMLNodeReference* reference) override;

  void OnNodeReferenceModified(vtkMRMLNodeReference* reference) override;

  void OnNodeReferenceRemoved(vtkMRMLNodeReference* reference) override;
 
  static const char* ClippingNodeReferenceRole;
  static const char* ClippingNodeReferenceRef;
  static const char* ClippingNodeStatePropertyName;
 
  int ClippingMethod;
 
  vtkSmartPointer<vtkImplicitBoolean> ImplicitFunction;
};
 
#endif