vtkMRMLSequenceNode.h

Go to the documentation of this file.

/*==============================================================================
 
  Program: 3D Slicer
 
  Copyright (c) Kitware Inc.
 
  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 __vtkMRMLSequenceNode_h
#define __vtkMRMLSequenceNode_h
 
// MRML includes
#include <vtkMRML.h>
#include <vtkMRMLStorableNode.h>
 
// std includes
#include <deque>
#include <set>

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

  vtkMRMLNode* CreateNodeInstance() override;

  void ReadXMLAttributes(const char** atts) override;

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

  void Copy(vtkMRMLNode* node) override;

  virtual void CopySequenceIndex(vtkMRMLNode* node);

  void UpdateSequenceIndex();

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

  void SetIndexName(const std::string& str);
  vtkGetMacro(IndexName, std::string);

  void SetIndexUnit(const std::string& str);
  vtkGetMacro(IndexUnit, std::string);

  void SetIndexType(int indexType);
  void SetIndexTypeFromString(const char* indexTypeString);
  vtkGetMacro(IndexType, int);
  virtual std::string GetIndexTypeAsString();

  vtkGetMacro(NumericIndexValueTolerance, double);
  void SetNumericIndexValueTolerance(double tolerance);

  static std::string GetIndexTypeAsString(int indexType);
  static int GetIndexTypeFromString(const std::string& indexTypeString);

  vtkMRMLNode* SetDataNodeAtValue(vtkMRMLNode* node, const std::string& indexValue);

  bool UpdateDataNodeAtValue(vtkMRMLNode* node, const std::string& indexValue, bool shallowCopy = false);

  void RemoveDataNodeAtValue(const std::string& indexValue);

  void RemoveAllDataNodes();

  vtkMRMLNode* GetDataNodeAtValue(const std::string& indexValue, bool exactMatchRequired = true);

  vtkMRMLNode* GetNthDataNode(int itemNumber);

  std::string GetNthIndexValue(int itemNumber);

  int GetItemNumberFromIndexValue(const std::string& indexValue, bool exactMatchRequired = true);

  bool UpdateIndexValue(const std::string& oldIndexValue, const std::string& newIndexValue);

  int GetNumberOfDataNodes();

  std::string GetDataNodeClassName();

  std::string GetDataNodeTagName();

  vtkMRMLScene* GetSequenceScene(bool autoCreate = true);

  vtkMRMLStorageNode* CreateDefaultStorageNode() override;

  std::string GetDefaultStorageNodeClassName(const char* filename = nullptr) override;

  void UpdateScene(vtkMRMLScene* scene) override;

  enum IndexTypes
  {
    NumericIndex = 0,
    TextIndex,
    NumberOfIndexTypes // this line must be the last one
  };
 
protected:
  vtkMRMLSequenceNode();
  ~vtkMRMLSequenceNode() override;
  vtkMRMLSequenceNode(const vtkMRMLSequenceNode&);
  void operator=(const vtkMRMLSequenceNode&);

  int GetInsertPosition(const std::string& indexValue);
 
  void ReadIndexValues(const std::string& indexText);
 
  vtkMRMLNode* DeepCopyNodeToScene(vtkMRMLNode* source, vtkMRMLScene* scene);
 
  struct IndexEntryType
  {
    std::string IndexValue;
    vtkWeakPointer<vtkMRMLNode> DataNode;
    std::string DataNodeID; // only used temporarily, during scene load
  };
 
protected:
  std::string IndexName;
  std::string IndexUnit;
  int IndexType{ vtkMRMLSequenceNode::NumericIndex };
  double NumericIndexValueTolerance{ 0.001 };

  vtkMRMLScene* SequenceScene{ 0 };

  std::deque<IndexEntryType> IndexEntries;
};
 
#endif