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;
  }
  vtkSmartPointer<vtkMRMLVolumeNode> Node;
  vtkSmartPointer<vtkMRMLVolumeDisplayNode> DisplayNode;
  vtkSmartPointer<vtkMRMLStorageNode> StorageNode;
  vtkSmartPointer<vtkMRMLScene> Scene;
  bool LabelMap; // is this node set for labelmaps?
};
 
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 };
  };
  std::vector<VolumeDisplayPreset> VolumeDisplayPresets;

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

  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, vtkStringArray* fileList);
  vtkMRMLVolumeNode* AddArchetypeVolume(const char* filename, const char* volname) { return this->AddArchetypeVolume(filename, volname, 0, nullptr); }

  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;
};
 
#endif