vtkSlicerTransformLogic.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.
 
  This file was partly developed by Andras Lasso and Franklin King at
  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.
 
=========================================================================auto=*/

 
#ifndef __vtkSlicerTransformLogic_h
#define __vtkSlicerTransformLogic_h
 
// SlicerLogic includes
#include "vtkSlicerBaseLogic.h"
#include "vtkSlicerTransformsModuleLogicExport.h"
 
// MRMLLogic includes
#include <vtkMRMLAbstractLogic.h>
 
// STD includes
#include <vector>
 
// MRML includes
class vtkMRMLDisplayableNode;
class vtkMRMLMarkupsNode;
class vtkMRMLMessageCollection;
class vtkMRMLScalarVolumeNode;
class vtkMRMLScene;
class vtkMRMLSliceNode;
class vtkMRMLTransformableNode;
class vtkMRMLTransformDisplayNode;
class vtkMRMLTransformNode;
class vtkMRMLVolumeNode;
 
// VTK includes
class vtkImageData;
class vtkMatrix4x4;
class vtkPoints;
class vtkPointSet;
class vtkPolyData;
class vtkUnstructuredGrid;
 
class VTK_SLICER_TRANSFORMS_MODULE_LOGIC_EXPORT vtkSlicerTransformLogic : public vtkMRMLAbstractLogic
{
public:
  static vtkSlicerTransformLogic* New();
  vtkTypeMacro(vtkSlicerTransformLogic, vtkMRMLAbstractLogic);
  void PrintSelf(ostream& os, vtkIndent indent) override { Superclass::PrintSelf(os, indent); }

  static bool hardenTransform(vtkMRMLTransformableNode* node);

  vtkMRMLTransformNode* AddTransform(const char* filename, vtkMRMLScene* scene, vtkMRMLMessageCollection* userMessages = nullptr);

  static bool GetVisualization2d(vtkPolyData* output_RAS, vtkMRMLTransformDisplayNode* displayNode, vtkMRMLSliceNode* sliceNode, vtkMRMLMarkupsNode* glyphPointsNode = nullptr);

  static bool GetVisualization2d(vtkPolyData* output_RAS,
                                 vtkMRMLTransformDisplayNode* displayNode,
                                 vtkMatrix4x4* sliceToRAS,
                                 double* fieldOfViewOrigin,
                                 double* fieldOfViewSize,
                                 vtkPoints* samplePositions_RAS = nullptr);

  static bool GetVisualization3d(vtkPolyData* output_RAS, vtkMRMLTransformDisplayNode* displayNode, vtkMatrix4x4* roiToRAS, int* roiSize, vtkPoints* samplePositions_RAS = nullptr);

  static bool GetVisualization3d(vtkPolyData* output_RAS, vtkMRMLTransformDisplayNode* displayNode, vtkMRMLNode* regionNode, vtkMRMLMarkupsNode* glyphPointsNode = nullptr);

  static const char* GetVisualizationDisplacementMagnitudeScalarName();

  vtkMRMLVolumeNode* CreateDisplacementVolumeFromTransform(vtkMRMLTransformNode* inputTransformNode,
                                                           vtkMRMLVolumeNode* referenceVolumeNode = nullptr,
                                                           bool magnitude = true,
                                                           vtkMRMLVolumeNode* existingOutputVolumeNode = nullptr);

  vtkMRMLTransformNode* ConvertToGridTransform(vtkMRMLTransformNode* inputTransformNode,
                                               vtkMRMLVolumeNode* referenceVolumeNode = nullptr,
                                               vtkMRMLTransformNode* existingOutputTransformNode = nullptr);

  static bool GetTransformedPointSamplesAsMagnitudeImage(vtkImageData* outputMagnitudeImage,
                                                         vtkMRMLTransformNode* inputTransformNode,
                                                         vtkMatrix4x4* ijkToRAS,
                                                         bool transformToWorld = true);

  static bool GetTransformedPointSamplesAsVectorImage(vtkImageData* outputVectorImage,
                                                      vtkMRMLTransformNode* inputTransformNode,
                                                      vtkMatrix4x4* ijkToRAS,
                                                      bool transformToWorld = true);

  static void GetTransformedNodes(vtkMRMLScene* scene, vtkMRMLTransformNode* transformNode, std::vector<vtkMRMLDisplayableNode*>& transformedNodes, bool recursive = true);

  static void GetNodesRASBounds(const std::vector<vtkMRMLDisplayableNode*>& nodes, double bounds[6]);

  static void GetNodesBounds(const std::vector<vtkMRMLDisplayableNode*>& nodes, double bounds[6]);
 
  enum TransformKind
  {
    TRANSFORM_OTHER,
    TRANSFORM_LINEAR,
    TRANSFORM_BSPLINE,
    TRANSFORM_GRID,
    TRANSFORM_THINPLATESPLINE
  };

  static TransformKind GetTransformKind(vtkMRMLTransformNode* transformNode);
 
protected:
  vtkSlicerTransformLogic();
  ~vtkSlicerTransformLogic() override;
  vtkSlicerTransformLogic(const vtkSlicerTransformLogic&);
  void operator=(const vtkSlicerTransformLogic&);

  static void GetGlyphVisualization2d(vtkPolyData* output_RAS,
                                      vtkMRMLTransformDisplayNode* displayNode,
                                      vtkMatrix4x4* sliceToRAS,
                                      double* fieldOfViewOrigin,
                                      double* fieldOfViewSize,
                                      vtkPoints* samplePositions_RAS = nullptr);
  static void GetGlyphVisualization3d(vtkPolyData* output_RAS,
                                      vtkMRMLTransformDisplayNode* displayNode,
                                      vtkMatrix4x4* roiToRAS,
                                      int* roiSize,
                                      vtkPoints* samplePositions_RAS = nullptr);

  static void GetGridVisualization2d(vtkPolyData* output_RAS,
                                     vtkMRMLTransformDisplayNode* displayNode,
                                     vtkMatrix4x4* sliceToRAS,
                                     double* fieldOfViewOrigin,
                                     double* fieldOfViewSize);
  static void GetGridVisualization3d(vtkPolyData* output_RAS, vtkMRMLTransformDisplayNode* displayNode, vtkMatrix4x4* roiToRAS, int* roiSize);

  static void GetContourVisualization2d(vtkPolyData* output_RAS,
                                        vtkMRMLTransformDisplayNode* displayNode,
                                        vtkMatrix4x4* sliceToRAS,
                                        double* fieldOfViewOrigin,
                                        double* fieldOfViewSize);
  static void GetContourVisualization3d(vtkPolyData* output_RAS, vtkMRMLTransformDisplayNode* displayNode, vtkMatrix4x4* roiToRAS, int* roiSize);

  static int GetGridSubdivision(vtkMRMLTransformDisplayNode* displayNode);

  static void CreateGrid(vtkPolyData* outputGrid_RAS, vtkMRMLTransformDisplayNode* displayNode, int numGridPoints[3], vtkPolyData* outputWarpedGrid_RAS = nullptr);

  static void GetTransformedPointSamples(vtkPointSet* outputPointSet, vtkMRMLTransformNode* inputTransformNode, vtkPoints* samplePositions_RAS, bool transformToWorld = true);

  static void GetTransformedPointSamples(vtkPointSet* outputPointSet_RAS,
                                         vtkMRMLTransformNode* inputTransformNode,
                                         vtkMatrix4x4* gridToRAS,
                                         int* gridSize,
                                         bool transformToWorld = true);

  static void GetTransformedPointSamplesOnSlice(vtkPointSet* outputPointSet_RAS,
                                                vtkMRMLTransformNode* inputTransformNode,
                                                vtkMatrix4x4* sliceToRAS,
                                                double* fieldOfViewOrigin,
                                                double* fieldOfViewSize,
                                                double pointSpacing,
                                                int pointGroupSize = 1,
                                                int* numGridPoints = nullptr,
                                                vtkPoints* samplePositions_RAS = nullptr);

  static void GetTransformedPointSamplesOnRoi(vtkPointSet* outputPointSet_RAS,
                                              vtkMRMLTransformNode* inputTransformNode,
                                              vtkMatrix4x4* roiToRAS,
                                              int* roiSize,
                                              double pointSpacingMm,
                                              int pointGroupSize = 1,
                                              int* numGridPoints = nullptr);

  static void GetMarkupsAsPoints(vtkMRMLMarkupsNode* markupsNode, vtkPoints* samplePoints_RAS);
};
 
#endif