C:/Programs/source/NIREP/DisplayManager/NIREPvtkViewImage.h

/*=========================================================================

Program:   vtkINRIA3D
Module:    $Id: NIREPvtkViewImage.h,v 1.7 2011/02/22 02:55:15 hawle Exp $
Language:  C++
Author:    $Author: hawle $
Date:      $Date: 2011/02/22 02:55:15 $
Version:   $Revision: 1.7 $

Copyright (c) 2007 INRIA - Asclepios Project. All rights reserved.
See Copyright.txt for details.

This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.  See the above copyright notices for more information.

=========================================================================*/

//I have renamed this class from vtkViewImage to
//NIREPvtkViewImage so that we can have our changes but
//not have to have vtkINRIA3D in our source tree.
//I made a slight change.  I changed the variable ScalarBar from being a 
//vtkScalarBarActor* to a vtkScalarBarWidget*.  This meant that I needed to 
//make the changes to the get and set functions.  As well, since I wanted 
//to have vtkViewImage2D be the main class I pass around in NIREPDisplay, 
//I had to pull vtkViewImage2D out of vtkINRIA3D and rename to NIREPvtkViewImage2D.
//Jeffrey Hawley


#ifndef _NIREPvtkViewImage_h_
#define _NIREPvtkViewImage_h_

#include "vtkINRIA3DConfigure.h"

#include <vtkRenderingAddOn/vtkSynchronizedView.h>

#include <vtkCommand.h>
#include <vtkTransform.h>
#include <vtkScalarBarActor.h>
#include <vtkLookupTable.h>
#include <vtkImageData.h>
#include <vtkScalarBarWidget.h>

#ifdef vtkINRIA3D_USE_ITK
#include <itkImage.h>
#endif

#include <vector>

class vtkScalarsToColors;
class vtkImageData;
class vtkImageBlend;

class vtkColorTransferFunction;

class vtkDataSet;
class vtkProperty;
class vtkMapper;
class vtkActor;



class VTK_RENDERINGADDON_EXPORT NIREPvtkViewImage : public vtkSynchronizedView
{

 public:

  static NIREPvtkViewImage* New();
  vtkTypeRevisionMacro(NIREPvtkViewImage, vtkSynchronizedView);

  //BTX
  enum DirectionIds
  {
    X_ID,
    Y_ID,
    Z_ID,
    NB_DIRECTION_IDS  // The number of DirectionIds
  };
  //ETX


  //BTX
  enum PlanIds
  {
    SAGITTAL_ID,
    CORONAL_ID,
    AXIAL_ID,
    NB_PLAN_IDS  // The number of PlanIds
  };
  //ETX


  //BTX
  enum EventIds
  {
    ViewImagePositionChangeEvent=(vtkCommand::UserEvent+1),
    ViewImageWindowLevelChangeEvent,
    ViewImageZoomChangeEvent
  };
  //ETX


  //BTX
  enum
  {
    FullRange,
    UserDefinedPercentage
  };
  //ETX


  // General Get Methods about the image

  virtual double GetWholeMinPosition(unsigned int p_axis);


  virtual  double GetWholeMaxPosition(unsigned int p_axis);


  static unsigned int GetOrthogonalAxis(unsigned int p_plan);
  

  void GetVoxelCoordinates( double pos[3], int p_coordinates[3]);


  virtual void GetCurrentVoxelCoordinates(int p_coordinates[3]);


  virtual double GetCurrentPointDoubleValue ();
  

  vtkGetObjectMacro (Image, vtkImageData);


  vtkSetObjectMacro(Image, vtkImageData);


#ifdef vtkINRIA3D_USE_ITK

  //BTX
  void SetITKImage (itk::Image<double, 3>::Pointer);

  void SetITKImage (itk::Image<float, 3>::Pointer);

  void SetITKImage (itk::Image<int, 3>::Pointer);

  void SetITKImage (itk::Image<unsigned int, 3>::Pointer);

  void SetITKImage (itk::Image<short, 3>::Pointer);

  void SetITKImage (itk::Image<unsigned short, 3>::Pointer);

  void SetITKImage (itk::Image<long, 3>::Pointer);

  void SetITKImage (itk::Image<unsigned long, 3>::Pointer);

  void SetITKImage (itk::Image<char, 3>::Pointer);

  void SetITKImage (itk::Image<unsigned char, 3>::Pointer);

  itk::ImageBase<3>* GetITKImage (void) const;
  //ETX
#endif


  virtual void UpdatePosition(void) {};

  
  vtkSetObjectMacro (Transform, vtkTransform);
  vtkGetObjectMacro (Transform, vtkTransform);


  vtkGetObjectMacro (ScalarBar, vtkScalarBarWidget);

  
  void SetScalarBarVisibility (int v)
  { this->ScalarBar->GetScalarBarActor()->SetVisibility(v);
    this->Modified(); }
  int GetScalarBarVisibility (void) const
  { return this->ScalarBar->GetScalarBarActor()->GetVisibility(); }
  vtkBooleanMacro (ScalarBarVisibility, int);
  
  
  virtual void SetLookupTable (vtkScalarsToColors* lut)
  {
    this->LookupTable = lut;
    vtkScalarBarActor *temp = this->ScalarBar->GetScalarBarActor();
    this->ScalarBar->GetScalarBarActor()->SetLookupTable ( lut );
    this->Modified();
  }
  void SyncSetLookupTable (vtkScalarsToColors* lut);
  virtual vtkScalarsToColors* GetLookupTable (void) const
  { return this->LookupTable; }

  
  virtual void SetWindow (double win)
  {
    this->Window = win;
    this->InvokeEvent (NIREPvtkViewImage::ViewImageWindowLevelChangeEvent, NULL);
    this->Modified();
  }
  vtkGetMacro (Window, double);
  void SyncSetWindow(double w);

  
  virtual void StartWindowing (void){};
  void SyncStartWindowing (void);


  virtual void EndWindowing (void){};
  void SyncEndWindowing (void);
  
  virtual void SetLevel (double lev)
  {
    this->Level = lev;
    this->InvokeEvent (NIREPvtkViewImage::ViewImageWindowLevelChangeEvent, NULL);
    this->Modified();
  }
  vtkGetMacro (Level, double);
  void SyncSetLevel(double l);
  

  virtual void ResetWindowLevel();
  void SyncResetWindowLevel();

  
  virtual void SetWindowLevelFrom(NIREPvtkViewImage* p_view);

  
  virtual void SetZoom (double zoom)
  {
    this->Zoom = zoom;
    this->InvokeEvent (NIREPvtkViewImage::ViewImageZoomChangeEvent, NULL);
    this->Modified();
  }
  vtkGetMacro (Zoom, double);
  void SyncSetZoom (double factor);


  virtual void ResetZoom();
  void SyncResetZoom();
  
  
  virtual int GetSliceForPosition(const double pos[3], unsigned int p_orientation);


  virtual void GetPositionForSlice ( int slice, int orientation, double pos[3]);

  
  virtual void SetSlice (unsigned int p_orientation, int p_slice);
  virtual void SyncSetSlice (unsigned int p_orientation, int p_slice);
  virtual int GetSlice(unsigned int p_orientation);

  
  virtual void SetZSlice(int p_slice)
  { (void) p_slice; this->Modified(); }
  void SyncSetZSlice (int p_slice);
  // GetZSlice() ??


  virtual void SetCurrentPoint (const double p_point[3]);
  void SyncSetCurrentPoint(const double p_point[3]);
  

  void SetPosition (const double p_point[3] )
  { this->SetCurrentPoint ( p_point ); }
  void SyncSetPosition (const double p_point[3])
  { this->SyncSetCurrentPoint (p_point); }


  virtual const double* GetCurrentPoint() const
  { return CurrentPoint; }
  void GetCurrentPoint(double p_point[3]) const
  {
    p_point[0] = CurrentPoint[0];
    p_point[1] = CurrentPoint[1];
    p_point[2] = CurrentPoint[2];
  }
  

  virtual void ResetCurrentPoint();
  void SyncResetCurrentPoint();


  void SyncResetPosition()
  {
    this->SyncResetCurrentPoint();
  }
  

  virtual void Reset (void)
  {
    this->ResetWindowLevel();
    this->ResetCurrentPoint();
    this->ResetZoom();
  }
  void SyncReset();
  


  vtkSetMacro (LinkWindowLevel, int);
  vtkGetMacro (LinkWindowLevel, int);


  vtkSetMacro (LinkPosition, int);
  vtkGetMacro (LinkPosition, int);

  
  vtkSetMacro (LinkZoom, int);
  vtkGetMacro (LinkZoom, int);


  vtkSetMacro (Shift, double);
  vtkGetMacro (Shift, double);

  
  vtkSetMacro (Scale, double);
  vtkGetMacro (Scale, double);


  vtkSetMacro (Visibility, int);
  vtkGetMacro (Visibility, int);
  vtkBooleanMacro (Visibility, int);
  

  virtual void PrintSelf(ostream& os, vtkIndent indent);


  virtual void SetSizeData (const char* str);
  virtual const char* GetSizeData(void) const
  { return SizeData_str.c_str(); }


  virtual void SetSizeDataVisibility (int val);
  vtkBooleanMacro (SizeDataVisibility, int);
  vtkGetMacro (SizeDataVisibility, int);


  virtual void SetPatientNameData (const char* str);
  virtual const char* GetPatientNameData(void) const
  { return PatientNameData.c_str(); }

  virtual void SetStudyNameData (const char* str);
  virtual const char* GetStudyNameData(void) const
  { return StudyNameData.c_str(); }

  virtual void SetSerieNameData (const char* str);
  virtual const char* GetSerieNameData(void) const
  { return SerieNameData.c_str(); }

  
  virtual void SetMaskImage (vtkImageData* mask, vtkLookupTable* lut)
  {
    this->MaskImage = mask;
    this->MaskLUT   = lut;
    this->Modified();
  }
  void SyncSetMaskImage (vtkImageData* mask, vtkLookupTable* lut);
  vtkGetObjectMacro (MaskImage, vtkImageData);
  
  
  virtual void RemoveMaskImage (void){};
  void SyncRemoveMaskImage ();
  

  virtual void SetOverlappingImage (vtkImageData* image)
  { this->OverlappingImage = image; this->Modified(); }
  void SyncSetOverlappingImage (vtkImageData* image);
  vtkGetObjectMacro (OverlappingImage, vtkImageData);

  
  virtual void RemoveOverlappingImage (void){};
  void SyncRemoveOverlappingImage ();
  
  
  virtual vtkActor* AddDataSet (vtkDataSet* dataset, vtkProperty* property = NULL);
  vtkActor* SyncAddDataSet (vtkDataSet* dataset, vtkProperty* property = NULL);
  
  
  virtual void RemoveDataSet (vtkDataSet* dataset);
  void SyncRemoveDataSet (vtkDataSet* dataset);
  

  virtual void RemoveAllDataSet ();
  void SyncRemoveAllDataSet ();
  

  virtual bool HasDataSet (vtkDataSet* dataset);


  vtkDataSet* GetDataSet (unsigned int i);
  vtkDataSet* GetDataSetFromActor (vtkActor* actor);
  vtkActor* GetDataSetActor (unsigned int i);
  vtkActor* GetDataSetActor (vtkDataSet* dataset);


  virtual void ColorDataSetByArray(vtkDataSet* dataset, const char* arrayname, vtkColorTransferFunction* transfer);
  void SyncColorDataSetByArray(vtkDataSet* dataset, const char* arrayname, vtkColorTransferFunction* transfer);

  
  virtual void ModifyActors(vtkDataSet* dataset, bool cellColors);
  void SyncModifyActors(vtkDataSet* dataset, bool cellColors);
  
  
  void SetResetWindowLevelMode(const int& mode)
  {
    this->ResetWindowLevelMode = mode;
    this->Modified();
  }

  void SetResetWindowLevelModeToFullRange( void )
  {
    this->ResetWindowLevelMode = FullRange;
    this->Modified();
  }

  void SetResetWindowLevelModeToUserDefinedPercentage( void )
  {
    this->ResetWindowLevelMode = UserDefinedPercentage;
    this->Modified();
  }


  vtkSetMacro (WindowLevelPercentage, double);
  vtkGetMacro (WindowLevelPercentage, double);


 protected:
  NIREPvtkViewImage();
  ~NIREPvtkViewImage();


  // derived from vtkSynchronizedView
  virtual void Initialize(void);
  virtual void Uninitialize(void);


  virtual void RegisterImage (vtkImageData* image);

  //BTX
  std::vector<vtkDataSet*>      DataSetList;
  std::vector<vtkActor*>        DataSetActorList;
  //ETX

  vtkSetMacro (FirstImage, int);
  vtkGetMacro (FirstImage, int);

 private:

  vtkImageData*   Image;
  vtkImageData*   OverlappingImage;

  vtkImageData*   MaskImage;
  vtkLookupTable* MaskLUT;

  double          CurrentPoint[3];

  vtkTransform*   Transform;
  vtkScalarsToColors* LookupTable;

  //vtkScalarBarActor*  ScalarBar;
  vtkScalarBarWidget*  ScalarBar;

  int            LinkWindowLevel;
  int            LinkPosition;
  int            LinkZoom;
  int            LinkRender;

  int            Visibility;
  int            SizeDataVisibility;

  double          Scale;
  double          Shift;

  double          Window;
  double          Level;
  double          Zoom;

#ifdef vtkINRIA3D_USE_ITK

  //BTX
  itk::ProcessObject::Pointer ImageConverter;
  itk::ImageBase<3>::Pointer  ITKImage;
  //ETX
#endif

  //BTX
  std::string     SizeData_str;
  std::string     PatientNameData;
  std::string     StudyNameData;
  std::string     SerieNameData;
  //ETX

  int           ResetWindowLevelMode;
  double        WindowLevelPercentage;

  int FirstImage;

};

#endif /* _vtkViewImage_h_ */