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

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

Program:   vtkINRIA3D
Module:    $Id: NIREPvtkViewImage2D.h,v 1.9 2011/02/08 21:07:53 hawle Exp $
Language:  C++
Author:    $Author: hawle $
Date:      $Date: 2011/02/08 21:07:53 $
Version:   $Revision: 1.9 $

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 vtkViewImage2D to
//NIREPvtkViewImage2D so that we can have our changes but
//not have to have vtkINRIA3D in our source tree.
//I wanted to have vtkViewImage2D be the main class I pass around in 
//NIREPDisplay and I already made changes to vtkViewImage which is the 
//parent of this class.  So I had to pull vtkViewImage2D out of vtkINRIA3D 
//and rename to NIREPvtkViewImage2D, so that my changes stayed.
//Jeffrey Hawley

#ifndef _NIREPvtkViewImage2D_h_
#define _NIREPvtkViewImage2D_h_

#include "vtkINRIA3DConfigure.h"

#include <iostream>
#include "NIREPvtkViewImage.h"

class vtkActor;
class vtkAlgorithmOutput;
class vtkBox;
class vtkBoxCutPolyLines;
class vtkColorTransferFunction;
class vtkColorTransferFunction;
class vtkCutter;
class vtkCutter;
class vtkDataSet;
class vtkDataSetMapper;
class vtkImageActor;
class vtkImageBlend;
class vtkImageBlendWithMask;
class vtkImageMapToColors;
class vtkImageMapToWindowLevelColors;
class vtkImageReslice;
class NIREPvtkInteractorStyleImage2D;
class vtkLineSource;
class vtkLookupTable;
class vtkMatrix4x4;
class vtkPlane;
class vtkPolyDataMapper;
class vtkProp;
class vtkProperty;
class vtkScalarsToColors;
class vtkTextMapper;
class vtkTransform;
class vtkRulerWidget;

class VTK_RENDERINGADDON_EXPORT NIREPvtkViewImage2D : public NIREPvtkViewImage
{
 public:
  
  static NIREPvtkViewImage2D* New();
  vtkTypeRevisionMacro(NIREPvtkViewImage2D, NIREPvtkViewImage);

  
  //BTX
  enum InteractionStyleIds {
    NO_INTERACTION,
    SELECT_INTERACTION,
    WINDOW_LEVEL_INTERACTION,
    FULL_PAGE_INTERACTION,
    MEASURE_INTERACTION,
    ZOOM_INTERACTION
  };
  //ETX

  //BTX
  enum ConventionIds{
    RADIOLOGIC,
    NEUROLOGIC
  };
  //ETX  

  
  void PrintSelf(ostream& os, vtkIndent indent);

  
  virtual void SetShowSliceNumber(int p_showSliceNumber);
  vtkBooleanMacro (ShowSliceNumber, int);
  vtkGetMacro (ShowSliceNumber, int);

  
  virtual void SetShow2DAxis(int);
  vtkBooleanMacro (Show2DAxis, int);
  vtkGetMacro (Show2DAxis, int);
  

  virtual void SetImage(vtkImageData* image);


  virtual void SetTransform(vtkTransform* p_transform);

  
  virtual void SetMatrix(vtkMatrix4x4* p_matrix, bool centered = false);

  
  virtual void SetOrientation(unsigned int orientation);
  vtkGetMacro (Orientation, unsigned int);


  virtual int GetWholeZMin();

  
  virtual int GetWholeZMax();

  
  virtual int GetZSlice();

  
  virtual void SetZSlice(int p_slice);

  
  virtual double GetColorWindow();

  
  virtual double GetColorLevel();

  
  virtual void SetWindow (double);

  
  virtual void SetLevel (double);

  
  
  
  virtual void SetInterpolationMode(int i);

  
  virtual int GetInterpolationMode(void);

  
  vtkSetMacro (LeftButtonInteractionStyle, unsigned int);
  vtkGetMacro (LeftButtonInteractionStyle, unsigned int);

  
  vtkSetMacro (RightButtonInteractionStyle, unsigned int);
  vtkGetMacro (RightButtonInteractionStyle, unsigned int);

  
  vtkSetMacro (MiddleButtonInteractionStyle, unsigned int);
  vtkGetMacro (MiddleButtonInteractionStyle, unsigned int);

  vtkSetMacro (WheelInteractionStyle, unsigned int);
  vtkGetMacro (WheelInteractionStyle, unsigned int);

  
  virtual void SetInteractionStyle (const unsigned int& style)
  {
    if (this->GetLeftButtonInteractionStyle() == this->InteractionStyle)
      this->SetLeftButtonInteractionStyle   (style);
    if (this->GetMiddleButtonInteractionStyle() == this->InteractionStyle)
      this->SetMiddleButtonInteractionStyle (style);
    if (this->GetRightButtonInteractionStyle() == this->InteractionStyle)
      this->SetRightButtonInteractionStyle  (style);
    if (this->GetWheelInteractionStyle() == this->InteractionStyle)
      this->SetWheelInteractionStyle        (style);
    this->InteractionStyle = style;
  }
  vtkGetMacro (InteractionStyle, unsigned int);


  virtual void SetRulerWidgetVisibility (int);
  vtkBooleanMacro (RulerWidgetVisibility, int);
  vtkGetMacro (RulerWidgetVisibility, int);


  vtkGetObjectMacro (RulerWidget, vtkRulerWidget);

  
  virtual void SetMaskImage (vtkImageData* mask, vtkLookupTable* lut);

  
  virtual void RemoveMaskImage (void);

  
  virtual void SetOverlappingImage (vtkImageData* image);

  
  virtual void RemoveOverlappingImage (void);

  
  virtual void SetLookupTable (vtkScalarsToColors* lut);


  virtual void SetBGLookupTable (vtkScalarsToColors* lut);
  virtual vtkScalarsToColors* GetBGLookupTable (void) const;

  
  virtual void UpdatePosition ();

  
  virtual void SetVisibility (int state);

  
  virtual void SetOpacity(double opacity);
  virtual double GetOpacity (void) const;
  
  
  virtual vtkActor* AddDataSet (vtkDataSet* dataset, vtkProperty* property = NULL);

  
  virtual vtkActor* AddPolyData (vtkPolyData* polydata,  vtkProperty* property = NULL, double thickness = 0.2);
  virtual vtkActor* SyncAddPolyData (vtkPolyData* polydata,  vtkProperty* property = NULL, double thickness = 0.2);

  
  virtual void SetZoom (double factor);

  
  virtual void ResetZoom (void);

  
  virtual void ResetAndRestablishZoomAndCamera (void);

  
  virtual void SetConventionsToRadiological (void);

  
  virtual void SetConventionsToNeurological (void);

  
  virtual void SetConventions (int);
  vtkGetMacro (Conventions, unsigned int);


  static void SetViewImage2DDisplayConventions(int val);
  static void SetViewImage2DDisplayConventionsToRadiologic() {NIREPvtkViewImage2D::SetViewImage2DDisplayConventions(0);};
  static void SetViewImage2DDisplayConventionsToNeurologic() {NIREPvtkViewImage2D::SetViewImage2DDisplayConventions(1);};
  static int  GetViewImage2DDisplayConventions();


  virtual void SetBGImage (vtkImageData* image, int slice = 0, vtkTransform* transform = NULL);
  vtkGetObjectMacro (BGImage, vtkImageData);

  
  virtual void RemoveBGImage (void);

  
  virtual void SetBGImageOpacity(double opacity);
  double GetBGImageOpacity (void) const;
  
  
  virtual void Clear(void);

  
  virtual void ScreenCoordinatesToPosition (double sc[2], double pos[3]);



  
  // access methods to internal classes
  

  vtkGetObjectMacro (ImageActor, vtkImageActor);

  
  vtkGetObjectMacro (BGActor, vtkImageActor);

  
  vtkGetObjectMacro (WindowLevel, vtkImageMapToColors);

  
  vtkGetObjectMacro (ImageReslice, vtkImageReslice);

  
  
  
 protected:
  NIREPvtkViewImage2D();
  ~NIREPvtkViewImage2D();

  virtual void Initialize();

  
  virtual void Uninitialize();


  virtual void InitializeImagePositionAndSize(void);


  vtkGetObjectMacro (ScreenToRealWorldMatrix, vtkMatrix4x4);

  
  vtkGetObjectMacro (OrientationMatrix, vtkMatrix4x4);


  virtual void InternalUpdate(void);


  virtual void SetupAnnotations (void);
  

// private:

  // Update data information and set the update and display extents.
  // Reset the camera position.
  void           UpdateImageActor();


  vtkImageData*                   AuxInput;

  vtkImageData*                   ResliceInput;

  vtkImageMapToWindowLevelColors* WindowLevelForCorner;
  vtkImageMapToColors*            WindowLevel;

  vtkImageReslice*                ImageReslice;

  // mask filter
  vtkImageBlendWithMask*          MaskFilter;

  // image blender
  vtkImageBlend*                  Blender;

  vtkImageActor*                  ImageActor;
  vtkActor*                       HorizontalLineActor;
  vtkLineSource*                  HorizontalLineSource;
  vtkActor*                       VerticalLineActor;
  vtkLineSource*                  VerticalLineSource;

  vtkScalarsToColors*             BGLookupTable;

  int                            FirstRender;
  //int                            ShowDirections;
  int                            ShowSliceNumber;
  int                            Show2DAxis;
  int                            RulerWidgetVisibility;

  unsigned int                    Orientation;
  unsigned int                    InteractionStyle;

  vtkPlane*                     DataSetCutPlane;
  vtkBox*                       DataSetCutBox;
  double                        BoxThickness;

  unsigned int LeftButtonInteractionStyle;
  unsigned int RightButtonInteractionStyle;
  unsigned int MiddleButtonInteractionStyle;
  unsigned int WheelInteractionStyle;


  double       InitialParallelScale;

  unsigned int Conventions;

  vtkImageData*                  BGImage;
  vtkImageActor *                BGActor;
  vtkImageMapToColors*           BGWindowLevel;


  vtkMatrix4x4 *OrientationMatrix;
  vtkMatrix4x4 *ScreenToRealWorldMatrix;

  vtkRulerWidget* RulerWidget;

};

#endif /* _NIREPvtkViewImage2D_h_ */