vtkSlicerVolumesLogic.h

Go to the documentation of this file.

/*=auto=========================================================================
 
  Portions (c) Copyright 2005 Brigham and Women's Hospital (BWH) All Rights Reserved.
 
  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.
 
  Program:   3D Slicer
  Module:    $RCSfile: vtkSlicerVolumesLogic.h,v $
  Date:      $Date: 2006/01/08 04:48:05 $
  Version:   $Revision: 1.45 $
 
=========================================================================auto=*/
 
// .NAME vtkSlicerVolumesLogic - slicer logic class for volumes manipulation
// .SECTION Description
// This class manages the logic associated with reading, saving,
// and changing properties of volumes
 
 
#ifndef __vtkSlicerVolumesLogic_h
#define __vtkSlicerVolumesLogic_h
 
// Slicer includes
#include "vtkSlicerModuleLogic.h"
 
// MRML includes
#include "vtkMRML.h"
#include "vtkMRMLScene.h"
#include "vtkMRMLStorageNode.h"
#include "vtkMRMLVolumeDisplayNode.h"
#include "vtkMRMLVolumeNode.h"
 
// STD includes
#include <cstdlib>
#include <list>
#include <string>
 
#include "vtkSlicerVolumesModuleLogicExport.h"
 
class vtkMRMLLabelMapVolumeNode;
class vtkMRMLScalarVolumeNode;
class vtkMRMLScalarVolumeDisplayNode;
class vtkMRMLVolumeHeaderlessStorageNode;
class vtkStringArray;
 
struct ArchetypeVolumeNodeSet
{
  ArchetypeVolumeNodeSet(vtkMRMLScene * scene):Scene(scene), LabelMap(false){}
  ArchetypeVolumeNodeSet(const ArchetypeVolumeNodeSet& set) {
    Node = set.Node;
    DisplayNode = set.DisplayNode;
    StorageNode = set.StorageNode;
    Scene = set.Scene;
    LabelMap = set.LabelMap;
  }
  ArchetypeVolumeNodeSet(const ArchetypeVolumeNodeSet& set) {…}
  vtkSmartPointer<vtkMRMLVolumeNode> Node;
  vtkSmartPointer<vtkMRMLVolumeDisplayNode> DisplayNode;
  vtkSmartPointer<vtkMRMLStorageNode> StorageNode;
  vtkSmartPointer<vtkMRMLScene> Scene;
  bool LabelMap;  // is this node set for labelmaps?
};
struct ArchetypeVolumeNodeSet {…};
 
class VTK_SLICER_VOLUMES_MODULE_LOGIC_EXPORT vtkSlicerVolumesLogic :
  public vtkSlicerModuleLogic
{
public:
 
  static vtkSlicerVolumesLogic *New();
  vtkTypeMacro(vtkSlicerVolumesLogic,vtkSlicerModuleLogic);
  void PrintSelf(ostream& os, vtkIndent indent) override;
  typedef vtkSlicerVolumesLogic Self;
 
  struct VolumeDisplayPreset
  {
    std::string id;
    std::string name;
    std::string description;
    std::string icon;
    double window{0.0};
    double level{0.0};
    std::string colorNodeID;
    bool valid{false};
  };
  struct VolumeDisplayPreset {…};
  std::vector<VolumeDisplayPreset> VolumeDisplayPresets;

  enum LoadingOptions {
    LabelMap = 1,
    CenterImage = 2,
    SingleFile = 4,
    AutoWindowLevel = 8,
    DiscardOrientation = 16
  };
  enum LoadingOptions {…};

  typedef ArchetypeVolumeNodeSet (*ArchetypeVolumeNodeSetFactory)(std::string& volumeName, vtkMRMLScene* scene, int options);

  int IsFreeSurferVolume(const char* filename);

  void RegisterArchetypeVolumeNodeSetFactory(ArchetypeVolumeNodeSetFactory factory);

  void PreRegisterArchetypeVolumeNodeSetFactory(ArchetypeVolumeNodeSetFactory factory);

  vtkMRMLVolumeNode* AddArchetypeVolume (const char* filename, const char* volname, int loadingOptions)
  {
    return (this->AddArchetypeVolume( filename, volname, loadingOptions, nullptr));
  }
  vtkMRMLVolumeNode* AddArchetypeVolume (const char* filename, const char* volname, int loadingOptions) {…}
  vtkMRMLVolumeNode* AddArchetypeVolume (const char* filename, const char* volname, int loadingOptions, vtkStringArray *fileList);
  vtkMRMLVolumeNode* AddArchetypeVolume (const char *filename, const char* volname)
  {
    return this->AddArchetypeVolume( filename, volname, 0, nullptr);
  }
  vtkMRMLVolumeNode* AddArchetypeVolume (const char *filename, const char* volname) {…}

  vtkMRMLScalarVolumeNode* AddArchetypeScalarVolume(const char* filename, const char* volname, int loadingOptions, vtkStringArray *fileList);

  int SaveArchetypeVolume (const char* filename, vtkMRMLVolumeNode *volumeNode);

  vtkMRMLLabelMapVolumeNode *CreateAndAddLabelVolume(vtkMRMLVolumeNode *volumeNode,
                                                   const char *name);

  vtkMRMLLabelMapVolumeNode *CreateAndAddLabelVolume(vtkMRMLScene *scene,
                                                   vtkMRMLVolumeNode *volumeNode,
                                                   const char *name);
  vtkMRMLLabelMapVolumeNode *CreateLabelVolume(vtkMRMLVolumeNode *volumeNode,
                                             const char *name);
  vtkMRMLLabelMapVolumeNode *CreateLabelVolume(vtkMRMLScene *scene,
                                             vtkMRMLVolumeNode *volumeNode,
                                             const char *name);

  vtkMRMLLabelMapVolumeNode *FillLabelVolumeFromTemplate(vtkMRMLLabelMapVolumeNode *labelNode,
                                                       vtkMRMLVolumeNode *templateNode);

  vtkMRMLLabelMapVolumeNode *FillLabelVolumeFromTemplate(vtkMRMLScene *scene,
                                                       vtkMRMLLabelMapVolumeNode *labelNode,
                                                       vtkMRMLVolumeNode *templateNode);

  vtkMRMLLabelMapVolumeNode *CreateLabelVolumeFromVolume(vtkMRMLScene *scene,
                                                       vtkMRMLLabelMapVolumeNode *outputVolume,
                                                       vtkMRMLVolumeNode *inputVolume);

  vtkMRMLScalarVolumeNode *CreateScalarVolumeFromVolume(vtkMRMLScene *scene,
    vtkMRMLScalarVolumeNode *outputVolume,
    vtkMRMLVolumeNode *inputVolume);

  static void ClearVolumeImageData(vtkMRMLVolumeNode *volumeNode);

  std::string CheckForLabelVolumeValidity(vtkMRMLScalarVolumeNode *volumeNode,
                                          vtkMRMLLabelMapVolumeNode *labelNode);

  std::string CompareVolumeGeometry(vtkMRMLScalarVolumeNode *volumeNode1,
                                    vtkMRMLScalarVolumeNode *volumeNode2);
 

  vtkMRMLScalarVolumeNode *CloneVolume(vtkMRMLVolumeNode *volumeNode, const char *name);

  static vtkMRMLScalarVolumeNode *CloneVolumeWithoutImageData(vtkMRMLScene *scene,
                                                              vtkMRMLVolumeNode *volumeNode,
                                                              const char *name);

  static vtkMRMLScalarVolumeNode *CloneVolume(vtkMRMLScene *scene,
                                              vtkMRMLVolumeNode *volumeNode,
                                              const char *name,
                                              bool cloneImageData=true);
  static vtkMRMLVolumeNode *CloneVolumeGeneric(vtkMRMLScene *scene,
    vtkMRMLVolumeNode *volumeNode,
    const char *name,
    bool cloneImageData = true);

  void TranslateFreeSurferRegistrationMatrixIntoSlicerRASToRASMatrix(vtkMRMLVolumeNode *V1Node,
                             vtkMRMLVolumeNode *V2Node,
                             vtkMatrix4x4 *FSRegistrationMatrix,
                             vtkMatrix4x4 *ResultsMatrix);

  void ComputeTkRegVox2RASMatrix ( vtkMRMLVolumeNode *VNode,
                                   vtkMatrix4x4 *M );

  void CenterVolume(vtkMRMLVolumeNode *volumeNode);

  void GetVolumeCenteredOrigin(vtkMRMLVolumeNode *volumeNode, double* origin);

  static vtkMRMLScalarVolumeNode* ResampleVolumeToReferenceVolume(vtkMRMLVolumeNode *inputVolumeNode,
                                                           vtkMRMLVolumeNode *referenceVolumeNode);

  vtkGetMacro(CompareVolumeGeometryEpsilon, double);
  void SetCompareVolumeGeometryEpsilon(double epsilon);

  vtkGetMacro(CompareVolumeGeometryPrecision, int);

  bool ApplyVolumeDisplayPreset(vtkMRMLVolumeDisplayNode* displayNode, std::string presetId);

  std::string GetAppliedVolumeDisplayPresetId(vtkMRMLVolumeDisplayNode* displayNode);

  std::vector<std::string> GetVolumeDisplayPresetIDs();

  VolumeDisplayPreset GetVolumeDisplayPreset(const std::string& presetId);
 
protected:
  vtkSlicerVolumesLogic();
  ~vtkSlicerVolumesLogic() override;
  vtkSlicerVolumesLogic(const vtkSlicerVolumesLogic&);
  void operator=(const vtkSlicerVolumesLogic&);

  void InitializeDefaultVolumeDisplayPresets();
 
  void ProcessMRMLNodesEvents(vtkObject * caller,
                                  unsigned long event,
                                  void * callData) override;
 
 
  void InitializeStorageNode(vtkMRMLStorageNode * storageNode,
                             const char * filename,
                             vtkStringArray *fileList,
                             vtkMRMLScene * mrmlScene = nullptr);
 
  void SetAndObserveColorToDisplayNode(vtkMRMLDisplayNode* displayNode,
                                       int labelmap, const char* filename);
 
  typedef std::list<ArchetypeVolumeNodeSetFactory> NodeSetFactoryRegistry;

  vtkMRMLVolumeNode* AddArchetypeVolume(
      const NodeSetFactoryRegistry& volumeRegistry,
      const char* filename, const char* volname, int loadingOptions,
      vtkStringArray *fileList);
 
protected:
 
  NodeSetFactoryRegistry VolumeRegistry;

  double CompareVolumeGeometryEpsilon;

  int CompareVolumeGeometryPrecision;
};
class VTK_SLICER_VOLUMES_MODULE_LOGIC_EXPORT vtkSlicerVolumesLogic : {…};
 
#endif