vtkMRMLMarkupsFiducialNode.h

Go to the documentation of this file.

/*==============================================================================
 
  Program: 3D Slicer
 
  Portions (c) Copyright Brigham and Women's Hospital (BWH) 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.
 
==============================================================================*/
 
#ifndef __vtkMRMLMarkupsFiducialNode_h
#define __vtkMRMLMarkupsFiducialNode_h
 
// MRML includes
#include "vtkMRMLDisplayableNode.h"
 
// Markups includes
#include "vtkMRMLExport.h"
#include "vtkMRMLMarkupsDisplayNode.h"
#include "vtkMRMLMarkupsNode.h"

class  VTK_MRML_EXPORT vtkMRMLMarkupsFiducialNode : public vtkMRMLMarkupsNode
{
public:
  static vtkMRMLMarkupsFiducialNode *New();
  vtkTypeMacro(vtkMRMLMarkupsFiducialNode,vtkMRMLMarkupsNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  const char* GetIcon() override {return ":/Icons/MarkupsFiducial.png";}
  const char* GetAddIcon() override {return ":/Icons/MarkupsFiducialMouseModePlace.png";}
  const char* GetPlaceAddIcon() override {return ":/Icons/MarkupsFiducialMouseModePlaceAdd.png";}
 
  //--------------------------------------------------------------------------
  // MRMLNode methods
  //--------------------------------------------------------------------------
 
  vtkMRMLNode* CreateNodeInstance() override;

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

  const char* GetMarkupType() override {return "Fiducial";};

  void ReadXMLAttributes( const char** atts) override;

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

  vtkMRMLCopyContentMacro(vtkMRMLMarkupsFiducialNode);

  vtkSetMacro(MaximumNumberOfControlPoints, int);

  vtkSetMacro(RequiredNumberOfControlPoints, int);

  void CreateDefaultDisplayNodes() override;
 
  //-----------------------------------------------------------
  // All public methods below are deprecated
  //
  // These methods are either deprecated because they use old terms (markup instead of control point),
  // or include "array", "vector", "pointer" in the name (it is redundant, as input arguments can be
  // deduced from the type; and return type for vectors is always vtkVectorNd).
  //

  int GetNumberOfFiducials()
  {
    vtkWarningMacro("vtkMRMLMarkupsFiducialNode::GetNumberOfFiducials method is deprecated, please use GetNumberOfControlPoints instead");
    return this->GetNumberOfControlPoints();
  };
  int GetNumberOfFiducials() {…}

  int AddFiducial(double x, double y, double z, std::string label = std::string())
  {
    vtkWarningMacro("vtkMRMLMarkupsFiducialNode::AddFiducial method is deprecated, please use AddControlPoint instead");
    return this->AddControlPoint(vtkVector3d(x, y, z), label);
  }
  int AddFiducial(double x, double y, double z, std::string label = std::string()) {…}

  int AddFiducialFromArray(double pos[3], std::string label = std::string())
  {
    vtkWarningMacro("vtkMRMLMarkupsFiducialNode::AddFiducialFromArray method is deprecated, please use AddControlPoint instead");
    return this->AddControlPoint(pos, label);
  }
  int AddFiducialFromArray(double pos[3], std::string label = std::string()) {…}

  void GetNthFiducialPosition(int n, double pos[3])
  {
    vtkWarningMacro("vtkMRMLMarkupsFiducialNode::GetNthFiducialPosition method is deprecated, please use GetNthControlPointPosition instead");
    this->GetNthControlPointPosition(n, pos);
  }
  void GetNthFiducialPosition(int n, double pos[3]) {…}

  void SetNthFiducialPosition(int n, double x, double y, double z)
  {
    vtkWarningMacro("vtkMRMLMarkupsFiducialNode::SetNthFiducialPosition method is deprecated, please use SetNthControlPointPosition instead");
    this->SetNthControlPointPosition(n, x, y, z);
  };
  void SetNthFiducialPosition(int n, double x, double y, double z) {…}

  void SetNthFiducialPositionFromArray(int n, double pos[3])
  {
    vtkWarningMacro("vtkMRMLMarkupsFiducialNode::SetNthFiducialPositionFromArray method is deprecated, please use SetNthControlPointPositionFromArray instead");
    this->SetNthControlPointPositionFromArray(n, pos);
  };
  void SetNthFiducialPositionFromArray(int n, double pos[3]) {…}

  bool GetNthFiducialSelected(int n = 0)
  {
    vtkWarningMacro("vtkMRMLMarkupsFiducialNode::GetNthFiducialSelected method is deprecated, please use GetNthControlPointSelected instead");
    return this->GetNthControlPointSelected(n);
  };
  bool GetNthFiducialSelected(int n = 0) {…}

  void SetNthFiducialSelected(int n, bool flag)
  {
    vtkWarningMacro("vtkMRMLMarkupsFiducialNode::SetNthFiducialSelected method is deprecated, please use SetNthControlPointSelected instead");
    this->SetNthControlPointSelected(n, flag);
  };
  void SetNthFiducialSelected(int n, bool flag) {…}

  bool GetNthFiducialLocked(int n = 0)
  {
    vtkWarningMacro("vtkMRMLMarkupsFiducialNode::GetNthFiducialLocked method is deprecated, please use GetNthControlPointLocked instead");
    return this->GetNthControlPointLocked(n);
  };
  bool GetNthFiducialLocked(int n = 0) {…}

  void SetNthFiducialLocked(int n, bool flag)
  {
    vtkWarningMacro("vtkMRMLMarkupsFiducialNode::SetNthFiducialLocked method is deprecated, please use SetNthControlPointLocked instead");
    this->SetNthControlPointLocked(n, flag);
  };
  void SetNthFiducialLocked(int n, bool flag) {…}

  bool GetNthFiducialVisibility(int n = 0)
  {
    vtkWarningMacro("vtkMRMLMarkupsFiducialNode::GetNthFiducialVisibility method is deprecated, please use GetNthControlPointVisibility instead");
    return this->GetNthControlPointVisibility(n);
  };
  bool GetNthFiducialVisibility(int n = 0) {…}

  void SetNthFiducialVisibility(int n, bool flag)
  {
    vtkWarningMacro("vtkMRMLMarkupsFiducialNode::SetNthFiducialVisibility method is deprecated, please use SetNthControlPointVisibility instead");
    this->SetNthControlPointVisibility(n, flag);
  };
  void SetNthFiducialVisibility(int n, bool flag) {…}

  std::string GetNthFiducialLabel(int n = 0)
  {
    vtkWarningMacro("vtkMRMLMarkupsFiducialNode::GetNthFiducialLabel method is deprecated, please use GetNthControlPointLabel instead");
    return this->GetNthControlPointLabel(n);
  };
  std::string GetNthFiducialLabel(int n = 0) {…}

  void SetNthFiducialLabel(int n, std::string label)
  {
    vtkWarningMacro("vtkMRMLMarkupsFiducialNode::SetNthFiducialLabel method is deprecated, please use SetNthControlPointLabel instead");
    this->SetNthControlPointLabel(n, label);
  };
  void SetNthFiducialLabel(int n, std::string label) {…}

  std::string GetNthFiducialAssociatedNodeID(int n = 0)
  {
    vtkWarningMacro("vtkMRMLMarkupsFiducialNode::GetNthFiducialAssociatedNodeID method is deprecated, please use GetNthControlPointAssociatedNodeID instead");
    return this->GetNthControlPointAssociatedNodeID(n);
  };
  std::string GetNthFiducialAssociatedNodeID(int n = 0) {…}

  void SetNthFiducialAssociatedNodeID(int n, const char* id)
  {
    vtkWarningMacro("vtkMRMLMarkupsFiducialNode::SetNthFiducialAssociatedNodeID method is deprecated, please use SetNthControlPointAssociatedNodeID instead");
    this->SetNthControlPointAssociatedNodeID(n, (id ? std::string(id) : ""));
  };
  void SetNthFiducialAssociatedNodeID(int n, const char* id) {…}

  void SetNthFiducialWorldCoordinates(int n, double coords[4])
  {
    vtkWarningMacro("vtkMRMLMarkupsFiducialNode::SetNthFiducialWorldCoordinates method is deprecated, please use SetNthControlPointPositionWorld instead");
    this->SetNthControlPointPositionWorld(n, coords[0], coords[1], coords[2]);
  };
  void SetNthFiducialWorldCoordinates(int n, double coords[4]) {…}

  void GetNthFiducialWorldCoordinates(int n, double coords[4])
  {
    vtkWarningMacro("vtkMRMLMarkupsFiducialNode::GetNthFiducialWorldCoordinates method is deprecated, please use GetNthControlPointPositionWorld instead");
    this->GetNthControlPointPositionWorld(n, coords);
  };
  void GetNthFiducialWorldCoordinates(int n, double coords[4]) {…}
 
protected:
  vtkMRMLMarkupsFiducialNode();
  ~vtkMRMLMarkupsFiducialNode() override;
  vtkMRMLMarkupsFiducialNode(const vtkMRMLMarkupsFiducialNode&);
  void operator=(const vtkMRMLMarkupsFiducialNode&);
 
};
class  VTK_MRML_EXPORT vtkMRMLMarkupsFiducialNode : public vtkMRMLMarkupsNode {…};
 
#endif