vtkSlicerSliceLogic.h

Go to the documentation of this file.

/*=auto=========================================================================

  Portions (c) Copyright 2005 Brigham and Women's Hospital (BWH) All Rights Reserved.

  See Doc/copyright/copyright.txt
  or http://www.slicer.org/copyright/copyright.txt for details.

  Program:   3D Slicer
  Module:    $RCSfile: vtkSlicerSliceLogic.h,v $
  Date:      $Date: 2011-01-31 20:37:43 -0500 (Mon, 31 Jan 2011) $
  Version:   $Revision: 15879 $

=========================================================================auto=*/

//


#ifndef __vtkSlicerSliceLogic_h
#define __vtkSlicerSliceLogic_h

#include <stdlib.h>

#include "vtkSlicerBaseLogic.h"
#include "vtkSlicerLogic.h"

#include "vtkMRML.h"
#include "vtkMRMLSliceNode.h"
#include "vtkMRMLSliceCompositeNode.h"
#include "vtkSlicerSliceLayerLogic.h"
#include "vtkMRMLModelNode.h"

#include "vtkImageBlend.h"
#include "vtkCollection.h"
#include "vtkPolyDataCollection.h"

class vtkImageData;
class vtkMRMLModelDisplayNode;
class vtkMRMLLinearTransformNode;
class vtkImageReslice;
class vtkPolyDataCollection;
class vtkCollection;

class VTK_SLICER_BASE_LOGIC_EXPORT vtkSlicerSliceLogic : public vtkSlicerLogic 
{
  public:
  
  static vtkSlicerSliceLogic *New();
  vtkTypeRevisionMacro(vtkSlicerSliceLogic,vtkSlicerLogic);
  void PrintSelf(ostream& os, vtkIndent indent);

  vtkGetObjectMacro (SliceNode, vtkMRMLSliceNode);
  void SetSliceNode (vtkMRMLSliceNode *SliceNode);

  vtkGetObjectMacro (SliceCompositeNode, vtkMRMLSliceCompositeNode);
  void SetSliceCompositeNode (vtkMRMLSliceCompositeNode *SliceCompositeNode);

  vtkGetObjectMacro (BackgroundLayer, vtkSlicerSliceLayerLogic);
  void SetBackgroundLayer (vtkSlicerSliceLayerLogic *BackgroundLayer);

  vtkGetObjectMacro (ForegroundLayer, vtkSlicerSliceLayerLogic);
  void SetForegroundLayer (vtkSlicerSliceLayerLogic *ForegroundLayer);

  vtkGetObjectMacro (LabelLayer, vtkSlicerSliceLayerLogic);
  void SetLabelLayer (vtkSlicerSliceLayerLogic *LabelLayer);

  vtkGetMacro (ForegroundOpacity, double);
  void SetForegroundOpacity (double ForegroundOpacity);

  vtkGetMacro (LabelOpacity, double);
  void SetLabelOpacity (double LabelOpacity);

  vtkGetObjectMacro (SliceModelNode, vtkMRMLModelNode);

  vtkGetObjectMacro (SliceModelDisplayNode, vtkMRMLModelDisplayNode);

  vtkGetObjectMacro (SliceModelTransformNode, vtkMRMLLinearTransformNode);

  vtkGetObjectMacro (Blend, vtkImageBlend);

  vtkGetObjectMacro (PolyDataCollection, vtkPolyDataCollection);

  vtkGetObjectMacro (LookupTableCollection, vtkCollection);

  vtkGetObjectMacro (ExtractModelTexture, vtkImageReslice);

  vtkImageData *GetImageData () { 
     if ( (this->GetBackgroundLayer() != NULL && this->GetBackgroundLayer()->GetImageData() != NULL) ||
         (this->GetForegroundLayer() != NULL && this->GetForegroundLayer()->GetImageData() != NULL) ||
         (this->GetLabelLayer() != NULL && this->GetLabelLayer()->GetImageData() != NULL) ) 
      {     
      return this->ImageData;
      }
     else
      {
      return NULL;
      }
  };

  void UpdateImageData () { 
    if ( (this->GetBackgroundLayer() != NULL && this->GetBackgroundLayer()->GetImageData() != NULL) ||
         (this->GetForegroundLayer() != NULL && this->GetForegroundLayer()->GetImageData() != NULL) ||
         (this->GetLabelLayer() != NULL && this->GetLabelLayer()->GetImageData() != NULL) ) 
      {     
      if ( this->Blend->GetInput(0) != NULL ) 
        {
        this->Blend->Update(); 
        }
      //this->ImageData = this->Blend->GetOutput();
      if (this->ImageData== NULL || this->Blend->GetOutput()->GetMTime() > this->ImageData->GetMTime())
        {
        if (this->ImageData== NULL)
          {
          this->ImageData = vtkImageData::New();
          }
        this->ImageData->DeepCopy( this->Blend->GetOutput()); 
        this->ExtractModelTexture->SetInput( this->ImageData );
        vtkTransform *activeSliceTransform = vtkTransform::New();
        activeSliceTransform->Identity();
        activeSliceTransform->Translate(0, 0, this->SliceNode->GetActiveSlice() );
        this->ExtractModelTexture->SetResliceTransform( activeSliceTransform );
        activeSliceTransform->Delete();
        }
      }
    else 
      {
      if (this->ImageData)
        {
        this->ImageData->Delete();
        }
      this->ImageData=NULL;
      this->ExtractModelTexture->SetInput( this->ImageData );
      }
  };

  void UpdatePipeline ();

  virtual void ProcessMRMLEvents ( vtkObject * /*caller*/, 
                                  unsigned long /*event*/, 
                                  void * /*callData*/ );
  virtual void ProcessMRMLEvents () { this->ProcessMRMLEvents( NULL, vtkCommand::NoEvent, NULL ); };

  virtual void ProcessLogicEvents ( vtkObject * /*caller*/, 
                                  unsigned long /*event*/, 
                                  void * /*callData*/ ) {this->ProcessLogicEvents();};
  void ProcessLogicEvents(); 

  void UpdateSliceNode();

  void UpdateSliceNodeFromLayout();

  void UpdateSliceCompositeNode();

  vtkMRMLVolumeNode *GetLayerVolumeNode(int layer);

  static void GetVolumeRASBox(vtkMRMLVolumeNode *volumeNode, double rasDimensions[3], double rasCenter[3]);

  void GetVolumeSliceDimensions(vtkMRMLVolumeNode *volumeNode, double sliceDimensions[3], double sliceCenter[3]);

  double *GetVolumeSliceSpacing(vtkMRMLVolumeNode *volumeNode);

  void GetVolumeSliceBounds(vtkMRMLVolumeNode *volumeNode, double sliceBounds[6]);

  void FitSliceToVolume(vtkMRMLVolumeNode *volumeNode, int width, int height);

  void GetBackgroundRASBox(double rasDimensions[3], double rasCenter[3]);

  void GetBackgroundSliceDimensions(double sliceDimensions[3], double sliceCenter[3]);

  double *GetBackgroundSliceSpacing();

  void GetBackgroundSliceBounds(double sliceBounds[6]);

  void FitSliceToBackground(int width, int height);

  void FitSliceToAll(int width, int height);

  vtkMRMLVolumeNode *GetLowestVolumeNode();

  double *GetLowestVolumeSliceSpacing();

  void GetLowestVolumeSliceBounds(double sliceBounds[6]);

  double GetSliceOffset();
  void SetSliceOffset(double offset);

  void CalculateSliceOffset(double offset, double oldOffsetVector[4], double newOffsetVector[4]);

  void SnapSliceOffsetToIJK();

  static const int SLICE_INDEX_ROTATED;
  static const int SLICE_INDEX_OUT_OF_VOLUME;
  static const int SLICE_INDEX_NO_VOLUME;

  int GetSliceIndexFromOffset(double sliceOffset, vtkMRMLVolumeNode *volumeNode);

  int GetSliceIndexFromOffset(double sliceOffset);

  void CreateSliceModel();
  void DeleteSliceModel();
  
  void GetPolyDataAndLookUpTableCollections(vtkPolyDataCollection *PolyDataCollection,
                                            vtkCollection *LookupTableCollection);
//BTX                                            
  std::vector< vtkMRMLDisplayNode*> GetPolyDataDisplayNodes();
//ETX

protected:
  vtkSlicerSliceLogic();
  ~vtkSlicerSliceLogic();
  vtkSlicerSliceLogic(const vtkSlicerSliceLogic&);
  void operator=(const vtkSlicerSliceLogic&);

  //
  vtkMRMLSliceNode *SliceNode;
  vtkMRMLSliceCompositeNode *SliceCompositeNode;
  vtkSlicerSliceLayerLogic *BackgroundLayer;
  vtkSlicerSliceLayerLogic *ForegroundLayer;
  vtkSlicerSliceLayerLogic *LabelLayer;

  double ForegroundOpacity;
  double LabelOpacity;
  vtkImageBlend *Blend;
  vtkImageData *ImageData;
  vtkImageReslice *ExtractModelTexture;

  vtkPolyDataCollection *PolyDataCollection;
  vtkCollection *LookupTableCollection;

  vtkMRMLModelNode *SliceModelNode;
  vtkMRMLModelDisplayNode *SliceModelDisplayNode;
  vtkMRMLLinearTransformNode *SliceModelTransformNode;
  double SliceSpacing[3];
  
  void AddSliceGlyphs(vtkSlicerSliceLayerLogic *layerLogic);

};

#endif