vtkMRMLSequenceBrowserNode.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.
 
  This file was originally developed by Csaba Pinter, PerkLab, Queen's University
  and was supported through the Applied Cancer Research Unit program of Cancer Care
  Ontario with funds provided by the Ontario Ministry of Health and Long-Term Care
 
==============================================================================*/
 
#ifndef __vtkMRMLSequenceBrowserNode_h
#define __vtkMRMLSequenceBrowserNode_h
 
#include "vtkSlicerSequencesModuleMRMLExport.h"
 
// MRML includes
#include <vtkMRML.h>
#include <vtkMRMLNode.h>
#include <vtkNew.h>
 
// STD includes
#include <set>
#include <map>
 
class vtkCollection;
class vtkMRMLSequenceNode;
class vtkIntArray;
 
class VTK_SLICER_SEQUENCES_MODULE_MRML_EXPORT vtkMRMLSequenceBrowserNode : public vtkMRMLNode
{
public:
  static vtkMRMLSequenceBrowserNode* New();
  vtkTypeMacro(vtkMRMLSequenceBrowserNode, vtkMRMLNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  enum
  {
    ProxyNodeModifiedEvent = 21001,
    IndexDisplayFormatModifiedEvent,
    SequenceNodeModifiedEvent
  };

  // Enum is used so that in the future more modes can be added (e.g., fixed frame rate,
  // fixed frame rate matching playback frame rate, etc).
  enum RecordingSamplingModeType
  {
    SamplingAll = 0,
    SamplingLimitedToPlaybackFrameRate,
    NumberOfRecordingSamplingModes // this line must be the last one
  };

  enum MissingItemModeType
  {
    MissingItemInvalid = -1,           
    MissingItemCreateFromPrevious = 0, 
    MissingItemCreateFromDefault,      
    MissingItemSetToDefault,           
    MissingItemIgnore,                 
    MissingItemDisplayHidden,          
    NumberOfMissingItemModes           // this line must be the last one
  };

  enum IndexDisplayModeType
  {
    IndexDisplayAsIndex = 0,
    IndexDisplayAsIndexValue,
    NumberOfIndexDisplayModes // this line must be the last one
  };

  vtkMRMLNode* CreateNodeInstance() override;

  void ReadXMLAttributes(const char** atts) override;

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

  void CopyContent(vtkMRMLNode* node, bool deepCopy = true) override;

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

  std::string SetAndObserveMasterSequenceNodeID(const char* sequenceNodeID);
  vtkMRMLSequenceNode* GetMasterSequenceNode();

  std::string AddSynchronizedSequenceNode(const char* synchronizedSequenceNodeId);

  std::string AddSynchronizedSequenceNodeID(const char* synchronizedSequenceNodeId);

  std::string AddSynchronizedSequenceNode(vtkMRMLSequenceNode* synchronizedSequenceNode);

  void RemoveSynchronizedSequenceNode(const char* nodeId);

  void RemoveAllSequenceNodes();


  void GetSynchronizedSequenceNodes(std::vector<vtkMRMLSequenceNode*>& synchronizedDataNodes, bool includeMasterNode = false);
  void GetSynchronizedSequenceNodes(vtkCollection* synchronizedDataNodes, bool includeMasterNode = false);

  int GetNumberOfSynchronizedSequenceNodes(bool includeMasterNode = false);

  bool IsSynchronizedSequenceNode(const char* sequenceNodeId, bool includeMasterNode = false);


  bool IsSynchronizedSequenceNodeID(const char* sequenceNodeId, bool includeMasterNode = false);
  bool IsSynchronizedSequenceNode(vtkMRMLSequenceNode* sequenceNode, bool includeMasterNode = false);


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


  vtkGetMacro(PlaybackRateFps, double);
  vtkSetMacro(PlaybackRateFps, double);


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


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


  vtkGetMacro(SelectedItemNumber, int);
  vtkSetMacro(SelectedItemNumber, int);

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


  vtkGetMacro(RecordingActive, bool);
  void SetRecordingActive(bool recording);
  vtkBooleanMacro(RecordingActive, bool);


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


  vtkSetMacro(RecordingSamplingMode, int);
  void SetRecordingSamplingModeFromString(const char* recordingSamplingModeString);
  vtkGetMacro(RecordingSamplingMode, int);
  virtual std::string GetRecordingSamplingModeAsString();


  static std::string GetRecordingSamplingModeAsString(int recordingSamplingMode);
  static int GetRecordingSamplingModeFromString(const std::string& recordingSamplingModeString);


  static std::string GetMissingItemModeAsString(int missingItemMode);
  static MissingItemModeType GetMissingItemModeFromString(const std::string& missingItemModeString);


  vtkSetMacro(IndexDisplayMode, int);
  void SetIndexDisplayModeFromString(const char* indexDisplayModeString);
  vtkGetMacro(IndexDisplayMode, int);
  virtual std::string GetIndexDisplayModeAsString();


  void SetIndexDisplayFormat(std::string displayFormat);
  vtkGetMacro(IndexDisplayFormat, std::string);


  static std::string GetIndexDisplayModeAsString(int indexDisplayMode);
  static int GetIndexDisplayModeFromString(const std::string& indexDisplayModeString);


  int SelectNextItem(int selectionIncrement = 1);
  int SelectFirstItem();
  int SelectLastItem();

  int GetNumberOfItems();

  vtkMRMLNode* AddProxyNode(vtkMRMLNode* sourceProxyNode, vtkMRMLSequenceNode* sequenceNode, bool copy = true);

  vtkMRMLNode* GetProxyNode(vtkMRMLSequenceNode* sequenceNode);

  vtkMRMLNode* GetVirtualOutputDataNode(vtkMRMLSequenceNode* sequenceNode)
  {
    static bool warningLogged = false;
    if (!warningLogged)
    {
      vtkWarningMacro("vtkMRMLSequenceBrowserNode::GetVirtualOutputDataNode is deprecated, use vtkMRMLSequenceBrowserNode::GetProxyNode method instead");
      warningLogged = true;
    }
    return this->GetProxyNode(sequenceNode);
  }

  void SetOverwriteTargetNodeName(bool overwrite)
  {
    static bool warningLogged = false;
    if (!warningLogged)
    {
      vtkWarningMacro("vtkMRMLSequenceBrowserNode::SetOverwriteTargetNodeName is deprecated," << " use vtkMRMLSequenceBrowserNode::SetOverwriteProxyName method instead");
      warningLogged = true;
    }
    this->SetOverwriteProxyName(nullptr, overwrite);
  }

  void SetDeepCopyVirtualNodes(bool deepcopy)
  {
    static bool warningLogged = false;
    if (!warningLogged)
    {
      vtkWarningMacro("vtkMRMLSequenceBrowserNode::SetDeepCopyVirtualNodes is deprecated, use vtkMRMLSequenceBrowserNode::SetSaveChanges method instead");
      warningLogged = true;
    }
    this->SetSaveChanges(nullptr, !deepcopy);
  }

  vtkMRMLSequenceNode* GetSequenceNode(vtkMRMLNode* proxyNode);
 
  void GetAllProxyNodes(std::vector<vtkMRMLNode*>& nodes);
  void GetAllProxyNodes(vtkCollection* nodes);

  void GetAllVirtualOutputDataNodes(vtkCollection* nodes)
  {
    static bool warningLogged = false;
    if (!warningLogged)
    {
      vtkWarningMacro("vtkMRMLSequenceBrowserNode::GetAllVirtualOutputDataNodes is deprecated," << " use vtkMRMLSequenceBrowserNode::GetAllProxyNodes method instead");
      warningLogged = true;
    }
    this->GetAllProxyNodes(nodes);
  }

  bool IsProxyNode(const char* nodeId);

  bool IsProxyNodeID(const char* nodeId);
 
  // TODO: Should these methods be protected? Probably the "world" shouldn't need to know about the postfixes.
  void RemoveProxyNode(const std::string& postfix);
 
  void RemoveAllProxyNodes();

  bool IsAnySequenceNodeRecording();


  bool GetPlayback(vtkMRMLSequenceNode* sequenceNode);
  void SetPlayback(vtkMRMLSequenceNode* sequenceNode, bool playback);


  bool GetRecording(vtkMRMLSequenceNode* sequenceNode);
  void SetRecording(vtkMRMLSequenceNode* sequenceNode, bool recording);


  bool GetSaveChanges(vtkMRMLSequenceNode* sequenceNode);
  void SetSaveChanges(vtkMRMLSequenceNode* sequenceNode, bool save);


  bool GetOverwriteProxyName(vtkMRMLSequenceNode* sequenceNode);
  void SetOverwriteProxyName(vtkMRMLSequenceNode* sequenceNode, bool overwrite);


  MissingItemModeType GetMissingItemMode(vtkMRMLSequenceNode* sequenceNode);
  void SetMissingItemMode(vtkMRMLSequenceNode* sequenceNode, MissingItemModeType missingItemMode);

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

  virtual void SaveProxyNodesState();

  std::string GetFormattedIndexValue(int index);

  static bool ValidateFormatString(std::string& validatedFormat, std::string& prefix, std::string& suffix, const std::string& requestedFormat, const std::string& typeString);
 
protected:
  vtkMRMLSequenceBrowserNode();
  ~vtkMRMLSequenceBrowserNode() override;
  vtkMRMLSequenceBrowserNode(const vtkMRMLSequenceBrowserNode&);
  void operator=(const vtkMRMLSequenceBrowserNode&);

  void FixSequenceNodeReferenceRoleName();

  void OnNodeReferenceAdded(vtkMRMLNodeReference* nodeReference) override;

  void OnNodeReferenceRemoved(vtkMRMLNodeReference* nodeReference) override;
 
  std::string GenerateSynchronizationPostfix();
  std::string GetSynchronizationPostfixFromSequence(vtkMRMLSequenceNode* sequenceNode);
  std::string GetSynchronizationPostfixFromSequenceID(const char* sequenceNodeID);
 
protected:
  bool PlaybackActive{ false };
  double PlaybackRateFps{ 10.0 };
  bool PlaybackItemSkippingEnabled{ true };
  bool PlaybackLooped{ true };
  int SelectedItemNumber{ -1 };
 
  double RecordingTimeOffsetSec; // difference between universal time and index value
  vtkSetMacro(RecordingTimeOffsetSec, double);
  vtkGetMacro(RecordingTimeOffsetSec, double);
 
  bool RecordingActive{ false };
 
  double LastSaveProxyNodesStateTimeSec;
  vtkSetMacro(LastSaveProxyNodesStateTimeSec, double);
  vtkGetMacro(LastSaveProxyNodesStateTimeSec, double);
 
  bool RecordMasterOnly{ false };
  int RecordingSamplingMode{ vtkMRMLSequenceBrowserNode::SamplingLimitedToPlaybackFrameRate };
  int IndexDisplayMode{ vtkMRMLSequenceBrowserNode::IndexDisplayAsIndexValue };
  std::string IndexDisplayFormat;
 
  // Unique postfixes for storing references to sequence nodes, proxy nodes, and properties
  // For example, a sequence node reference role name is SEQUENCE_NODE_REFERENCE_ROLE_BASE+synchronizationPostfix
  std::vector<std::string> SynchronizationPostfixes;
 
  // Counter that is used for generating the unique (only for this class) proxy node postfix strings
  int LastPostfixIndex{ 0 };
  vtkSetMacro(LastPostfixIndex, int);
  vtkGetMacro(LastPostfixIndex, int);
 
private:
  struct SynchronizationProperties;
  std::map<std::string, SynchronizationProperties*> SynchronizationPropertiesMap;
  SynchronizationProperties* GetSynchronizationPropertiesForSequence(vtkMRMLSequenceNode* sequenceNode);
  SynchronizationProperties* GetSynchronizationPropertiesForPostfix(const std::string& rolePostfix);
};
 
#endif