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 "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