NIREPvtkViewImage2D.cxx

Go to the documentation of this file.

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

Program:   vtkINRIA3D
Module:    $Id: NIREPvtkViewImage2D.cxx,v 1.15 2010/12/02 23:20:19 hawle Exp $
Language:  C++
Author:    $Author: hawle $
Date:      $Date: 2010/12/02 23:20:19 $
Version:   $Revision: 1.15 $

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.

=========================================================================*/
#include "NIREPvtkViewImage2D.h"

#include "vtkInteractorObserver.h"
#include "vtkInteractorStyleSwitch.h"
#include "vtkRenderer.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkRendererCollection.h"
#include "vtkProp.h"
#include "vtkTextActor.h"
#include "vtkCoordinate.h"
#include "vtkProperty.h"
#include "vtkProperty2D.h"
#include "vtkTextProperty.h"
#include <vtkCornerAnnotation.h>
#include <vtkLightCollection.h>
#include <vtkLight.h>
#include <vtkOrientationAnnotation.h>

#include "assert.h"
#include <iostream>
#include <sstream>
#include <cmath>

#include <NIREPvtkViewImage2DCommand.h>
#include <vtkRenderingAddOn/vtkViewImage2DFullCommand.h>
#include <NIREPvtkInteractorStyleImage2D.h>
#include "vtkCamera.h"
#include "vtkImageReslice.h"
#include "vtkRenderWindow.h"
#include "vtkTransform.h"
#include "vtkImageMapToWindowLevelColors.h"
#include "vtkImageMapToColors.h"
#include "vtkImageActor.h"
#include "vtkImageData.h"
#include "vtkActor.h"
#include "vtkPolyDataMapper.h"
#include "vtkLineSource.h"
#include "vtkLookupTable.h"
#include <vtkRenderingAddOn/vtkImageBlendWithMask.h>
#include "vtkImageBlend.h"
#include <vtkPolyDataMapper2D.h>
#include <vtkActor2D.h>
#include <vtkMatrix4x4.h>

#include <vtkColorTransferFunction.h>
#include <vtkDataArray.h>
#include <vtkPointData.h>
#include <vtkCellData.h>
#include <vtkExtractGeometry.h>
#include <vtkDataSet.h>
#include <vtkUnstructuredGrid.h>
#include <vtkDataSetMapper.h>
#include <vtkPlane.h>
#include <vtkPlaneCollection.h>
#include <vtkPolyDataMapper2D.h>
#include <vtkActor2D.h>
#include <vtkClipDataSet.h>
#include <vtkCutter.h>
#include <vtkBox.h>
#include <vtkPolyDataWriter.h>
#include <vtkPolyDataNormals.h>
#include <vtkTransform.h>
#include <vtkMath.h>
#include <vtkRulerWidget.h>


vtkCxxRevisionMacro(NIREPvtkViewImage2D, "$Revision: 1.15 $");
vtkStandardNewMacro(NIREPvtkViewImage2D);

// Initialize static member that controls display convention (0: radiologic, 1: neurologic)
static int vtkViewImage2DDisplayConventions = 0;


void NIREPvtkViewImage2D::SetViewImage2DDisplayConventions(int val)
{
  vtkViewImage2DDisplayConventions = val;
}


int NIREPvtkViewImage2D::GetViewImage2DDisplayConventions()
{
  return vtkViewImage2DDisplayConventions;
}


NIREPvtkViewImage2D::NIREPvtkViewImage2D()
{
  this->FirstRender = 1;
  this->ShowSliceNumber  = 1;
  this->InteractionStyle = SELECT_INTERACTION;
  this->LeftButtonInteractionStyle = SELECT_INTERACTION;
  this->MiddleButtonInteractionStyle = SELECT_INTERACTION;
  this->RightButtonInteractionStyle = SELECT_INTERACTION;
  this->WheelInteractionStyle = SELECT_INTERACTION;
  this->Show2DAxis = 1;
  this->RulerWidgetVisibility = 0;

  this->Conventions = RADIOLOGIC;

  this->InitialParallelScale = 1.0;


  this->ImageReslice     = vtkImageReslice::New();
  this->ImageActor       = vtkImageActor::New();
  this->WindowLevelForCorner = vtkImageMapToWindowLevelColors::New();
  this->WindowLevel      = vtkImageMapToColors::New();
  this->MaskFilter       = vtkImageBlendWithMask::New();
  this->Blender          = vtkImageBlend::New();

  this->WindowLevel->SetOutputFormatToRGB();

  
  this->OrientationMatrix = vtkMatrix4x4::New();
  this->OrientationMatrix->Identity();
  this->ScreenToRealWorldMatrix = vtkMatrix4x4::New();
  this->ScreenToRealWorldMatrix->Zero();
  this->ScreenToRealWorldMatrix->SetElement (2, 2, 1.0);
  
  
  /*
    this->BGActor          = vtkImageActor::New();
    this->BGWindowLevel    = vtkImageMapToColors::New();
    this->BGImage = vtkImageData::New();
  */
  this->BGActor          = 0;
  this->BGWindowLevel    = 0;
  this->BGImage = 0;

  this->HorizontalLineSource = vtkLineSource::New();
  this->VerticalLineSource   = vtkLineSource::New();
  this->HorizontalLineActor  = vtkActor::New();
  this->VerticalLineActor    = vtkActor::New();

  this->DataSetCutPlane      = vtkPlane::New();
  this->DataSetCutBox        = vtkBox::New();


  this->DataSetCutPlane->SetOrigin (0,0,0);
  this->DataSetCutPlane->SetNormal (0,0,1);
  this->DataSetCutBox->SetBounds (0,0,0,0,0,0);
  this->BoxThickness = 2;


  // set the filters properties
  this->Blender->SetBlendModeToNormal();
  //this->Blender->SetOpacity (0,0.25 ); GEC 7/10/2010 changed to 50% opacity
  //this->Blender->SetOpacity (1, 0.75);
  this->Blender->SetOpacity (0,0.5);
  this->Blender->SetOpacity (1,0.5);


  // set up the vtk pipeline
  this->ImageReslice->SetOutputDimensionality(2);
  this->ImageReslice->InterpolateOff();
  this->ImageReslice->SetInputConnection( this->WindowLevel->GetOutputPort() );


  this->AuxInput     = this->WindowLevel->GetOutput();
  this->ResliceInput = this->WindowLevel->GetOutput();


  // Interactor Style
  this->SetInteractionStyle( NIREPvtkViewImage2D::SELECT_INTERACTION );


  // Initialize cursor lines
  vtkPolyDataMapper* mapper =  vtkPolyDataMapper::New();
  mapper->SetInputConnection( this->HorizontalLineSource->GetOutputPort() );

  this->HorizontalLineActor->SetMapper(mapper);
  this->HorizontalLineActor->GetProperty()->SetColor (1.0,0.0,0.0);
  mapper->Delete();
  this->HorizontalLineActor->SetVisibility (0);
  this->HorizontalLineActor->PickableOff();
  this->HorizontalLineActor->DragableOff();
 


  vtkPolyDataMapper* mapper2 =  vtkPolyDataMapper::New();
  mapper2->SetInputConnection( this->VerticalLineSource->GetOutputPort() );
  this->VerticalLineActor->SetMapper(mapper2);
  this->VerticalLineActor->GetProperty()->SetColor (1.0,0.0,0.0);
  mapper2->Delete();
  this->VerticalLineActor->SetVisibility (0);
  this->VerticalLineActor->PickableOff();
  this->VerticalLineActor->DragableOff();

  this->GetCornerAnnotation()->SetWindowLevel ( this->WindowLevelForCorner );

  this->SetOrientation ( NIREPvtkViewImage::AXIAL_ID );

  if( NIREPvtkViewImage2D::GetViewImage2DDisplayConventions()==0 )
  {
    this->SetConventionsToRadiological();
  }
  else
  {
    this->SetConventionsToNeurological();
  }

  this->RulerWidget = vtkRulerWidget::New();
  this->RulerWidget->KeyPressActivationOff();

  //this->GetCornerAnnotation()->SetLinearFontScaleFactor(15);
    
}



NIREPvtkViewImage2D::~NIREPvtkViewImage2D()
{
  if(this->ImageActor != NULL) {
    this->ImageActor->Delete();
  }
  this->WindowLevel->Delete();
  this->WindowLevelForCorner->Delete();
  this->ImageReslice->Delete();
  this->MaskFilter->Delete();
  this->Blender->Delete();

  //this->BGActor->Delete();
  //this->BGWindowLevel->Delete();
  /*
    if( this->BGImage )
    {
    this->BGImage->Delete();
    }
  */

  this->OrientationMatrix->Delete();
  this->ScreenToRealWorldMatrix->Delete();

  this->HorizontalLineSource->Delete();
  this->HorizontalLineActor->Delete();

  this->VerticalLineSource->Delete();
  this->VerticalLineActor->Delete();

  this->DataSetCutPlane->Delete();
  this->DataSetCutBox->Delete();

  this->RulerWidget->Delete();
}


void NIREPvtkViewImage2D::InternalUpdate()
{
  this->UpdateImageActor();
  //  this->UpdatePosition();
  this->InitializeImagePositionAndSize();
}


void NIREPvtkViewImage2D::Initialize()
{
  this->Superclass::Initialize();

  if (this->GetRenderer())
  {
    this->GetRenderer()->TwoSidedLightingOff();
  }

  if( this->GetRenderWindowInteractor() )
  {
    NIREPvtkInteractorStyleImage2D *interactor = NIREPvtkInteractorStyleImage2D::New();
    interactor->SetView(this);

    NIREPvtkViewImage2DCommand *cbk = NIREPvtkViewImage2DCommand::New();
    cbk->SetView(this);

    interactor->AddObserver(vtkCommand::KeyPressEvent, cbk);
    interactor->AddObserver(vtkCommand::WindowLevelEvent, cbk);
    interactor->AddObserver(vtkCommand::StartWindowLevelEvent, cbk);
    interactor->AddObserver(vtkCommand::ResetWindowLevelEvent, cbk);
    interactor->AddObserver(vtkCommand::EndWindowLevelEvent, cbk);
    interactor->AddObserver(vtkCommand::PickEvent, cbk);
    interactor->AddObserver(vtkCommand::StartPickEvent, cbk);
    interactor->AddObserver(vtkCommand::EndPickEvent, cbk);
    interactor->AddObserver(NIREPvtkViewImage2DCommand::ResetZoomEvent, cbk);
    interactor->AddObserver(NIREPvtkViewImage2DCommand::ResetPositionEvent, cbk);
    interactor->AddObserver(NIREPvtkViewImage2DCommand::StartZSliceMoveEvent, cbk);
    interactor->AddObserver(NIREPvtkViewImage2DCommand::ZSliceMoveEvent, cbk);
    interactor->AddObserver(NIREPvtkViewImage2DCommand::EndZSliceMoveEvent, cbk);
    interactor->AddObserver(NIREPvtkViewImage2DCommand::StartMeasureEvent, cbk);
    interactor->AddObserver(NIREPvtkViewImage2DCommand::MeasureEvent, cbk);
    interactor->AddObserver(NIREPvtkViewImage2DCommand::EndMeasureEvent, cbk);
    interactor->AddObserver(NIREPvtkViewImage2DCommand::FullPageEvent, cbk);
    interactor->AddObserver(NIREPvtkViewImage2DCommand::ZoomEvent, cbk);
    interactor->AddObserver(NIREPvtkViewImage2DCommand::DefaultMoveEvent, cbk);

    this->GetRenderWindowInteractor()->SetInteractorStyle( interactor );

    this->RulerWidget->SetInteractor ( this->GetRenderWindowInteractor() );
    
    interactor->Delete();
    cbk->Delete();
  }

}


void NIREPvtkViewImage2D::Uninitialize()
{
  this->RemoveActor( this->HorizontalLineActor );
  this->RemoveActor( this->VerticalLineActor );
  if(this->ImageActor != NULL) {
    this->RemoveActor( this->ImageActor );
  }
  for( unsigned int i=0; i<this->DataSetActorList.size(); i++)
    this->RemoveActor( this->DataSetActorList[i] );

  if ( this->GetRenderWindowInteractor() )
  {
    this->GetRenderWindowInteractor()->SetInteractorStyle( NULL );
  }
  this->RulerWidget->SetInteractor ( NULL );

  NIREPvtkViewImage::Uninitialize();
}


void NIREPvtkViewImage2D::SetVisibility (int state)
{
  NIREPvtkViewImage::SetVisibility ( state );
  if(this->ImageActor != NULL) {
    this->ImageActor->SetVisibility ( state );
  }
}


void NIREPvtkViewImage2D::UpdateImageActor()
{
  if( !this->GetImage() )
  {
    return;
  }
  if(this->ImageActor == NULL) {
    return;
  }

  this->ImageReslice->GetOutput()->UpdateInformation();
  this->ImageActor->GetInput()->SetUpdateExtent( this->ImageReslice->GetOutput()->GetWholeExtent() );
  this->ImageActor->SetDisplayExtent( this->ImageReslice->GetOutput()->GetWholeExtent() );
  this->FirstRender = 1;
}


void NIREPvtkViewImage2D::InitializeImagePositionAndSize()
{
  if( !this->GetImage() )
  {
    return;
  }


  if (this->FirstRender)
  {
    // make sur the input is up-to-date

    this->GetRenderer()->GetActiveCamera()->OrthogonalizeViewUp();
    this->GetRenderer()->GetActiveCamera()->ParallelProjectionOn();

    if(this->ImageActor != NULL) {
      this->ImageActor->GetInput()->Update();


      


      // Get the current position of the camera:
      //double Pos[3];
      //this->GetRenderer()->GetActiveCamera()->GetPosition(Pos);


      // Get the bounds of the image: coordinates in the real world
      double bnds[6];
      this->ImageActor->GetBounds(bnds);


      // extension of the image:
      double xs = (bnds[1] - bnds[0]);
      double ys = (bnds[3] - bnds[2]);

      double bnds_x = xs/2.0;
      double bnds_y = ys/2.0;

      //this->GetRenderer()->GetActiveCamera()->SetParallelScale(xs < ys ? bnds_y:bnds_x);
      //this->InitialParallelScale = this->GetRenderer()->GetActiveCamera()->GetParallelScale();
      this->InitialParallelScale = xs < ys ? bnds_y:bnds_x;
    }

    this->VerticalLineActor->SetVisibility (0);
    this->HorizontalLineActor->SetVisibility (0);

    double zoom = this->GetZoom();
    this->ResetZoom();
    this->SetZoom (zoom);

    if( this->Show2DAxis ){
      this->VerticalLineActor->SetVisibility (1);
      this->HorizontalLineActor->SetVisibility (1);
    }


    this->FirstRender = 0;

  }
}


/*
void NIREPvtkViewImage2D::SetFullInteraction()
{
  vtkInteractorStyleImage *interactor = vtkInteractorStyleImage::New();
  vtkViewImage2DFullCommand *cbk = vtkViewImage2DFullCommand::New();
  cbk->IV = this;
  interactor->AddObserver(vtkCommand::WindowLevelEvent, cbk);
  interactor->AddObserver(vtkCommand::StartWindowLevelEvent, cbk);
  interactor->AddObserver(vtkCommand::ResetWindowLevelEvent, cbk);
  interactor->AddObserver(vtkCommand::EndWindowLevelEvent, cbk);
  interactor->AddObserver(vtkCommand::KeyPressEvent, cbk);
  interactor->AddObserver(vtkCommand::EnterEvent, cbk);
  interactor->AddObserver(vtkCommand::LeaveEvent, cbk);
  cbk->Delete();
  this->SetInteractorStyle(interactor);
  interactor->Delete();
}
*/


 /*
void NIREPvtkViewImage2D::SetShowDirections(int p_showDirections)
{
  this->ShowDirections = p_showDirections;

  if (this->ShowDirections)
  {
    switch(this->Orientation)
    {
        case NIREPvtkViewImage::AXIAL_ID:
          
          this->SetNorthAnnotation("A");
          this->SetSouthAnnotation("P");
          if( this->Conventions == RADIOLOGIC )
          {
            this->SetEastAnnotation ("L");
            this->SetWestAnnotation("R");
          }
          else
          {
            this->SetEastAnnotation ("R");
            this->SetWestAnnotation("L");
          }
          break;
          
        case NIREPvtkViewImage::SAGITTAL_ID:

          this->SetNorthAnnotation("S");
          this->SetSouthAnnotation("I");
          this->SetEastAnnotation ("P");
          this->SetWestAnnotation("A");
          break;
          
        case NIREPvtkViewImage::CORONAL_ID:

          this->SetNorthAnnotation("S");
          this->SetSouthAnnotation("I");
          
          if( this->Conventions == RADIOLOGIC)
          {
            this->SetEastAnnotation ("L");
            this->SetWestAnnotation("R");
          }
          else
          {
            this->SetEastAnnotation ("R");
            this->SetWestAnnotation("L");
          }
          break;
    }
  }
  
  else
  {
    this->SetNorthAnnotation("");
    this->SetSouthAnnotation("");
    this->SetEastAnnotation ("");
    this->SetWestAnnotation("");
  }
  this->Modified();
}
 */
 

void NIREPvtkViewImage2D::SetShowSliceNumber(int p_showSliceNumber)
{
  this->ShowSliceNumber = p_showSliceNumber;

  if (!this->ShowSliceNumber)
  {
    this->SetUpRightAnnotation("");
  }

  this->Modified();
}


int NIREPvtkViewImage2D::GetWholeZMin()
{
  return 0;
}


int NIREPvtkViewImage2D::GetWholeZMax()
{
  if(!this->GetImage())
  {
    return 0;
  }

  int* ext = this->GetImage()->GetWholeExtent();

  assert(this->Orientation<NIREPvtkViewImage::NB_DIRECTION_IDS);

  int axis = this->GetOrthogonalAxis(this->Orientation);
  return ext[2*axis+1];
}


int NIREPvtkViewImage2D::GetZSlice()
{
  return this->GetSlice(this->Orientation);
}


void NIREPvtkViewImage2D::SetZSlice(int p_zslice)
{
  this->SetSlice(this->Orientation, p_zslice);
  this->Modified();
}


void NIREPvtkViewImage2D::UpdatePosition ()
{
  if( !this->GetImage() )
  {
    return;
  }

  double x=0;
  double y=0;
  double max_x=0;
  double max_y=0;
  double min_x=0;
  double min_y=0;
  double pos[4];

  this->GetCurrentPoint(pos);
  pos[3] = 0.0;

  double* spacing = this->GetImage()->GetSpacing();
  double* origin  = this->GetImage()->GetOrigin();
  
  // check if pos lies inside image bounds
  /*
  double *imBounds = this->GetImage()->GetBounds();
  if( pos[0]<imBounds[0] || pos[0]>imBounds[1] ||
      pos[1]<imBounds[2] || pos[1]>imBounds[3] ||
      pos[2]<imBounds[4] || pos[2]>imBounds[5])
  {
    // we are outside image bounds
    return;
  }
  */
  
  // round to the nearest integer slice
  pos[0] = vtkMath::Round ((pos[0]-origin[0])/spacing[0] )*spacing[0]+origin[0];
  pos[1] = vtkMath::Round ((pos[1]-origin[1])/spacing[1] )*spacing[1]+origin[1];
  pos[2] = vtkMath::Round ((pos[2]-origin[2])/spacing[2] )*spacing[2]+origin[2];

  /*
    double *bounds = this->ImageActor->GetBounds();
    min_x = bounds[0];
    max_x = bounds[1];
    min_y = bounds[2];
    max_y = bounds[3];
  */

  double min_bounds[4] = { this->GetWholeMinPosition(0),
                           this->GetWholeMinPosition(1),
                           this->GetWholeMinPosition(2),
                           0.0 };

  double max_bounds[4] = { this->GetWholeMaxPosition(0),
                           this->GetWholeMaxPosition(1),
                           this->GetWholeMaxPosition(2),
                           0.0 };
  

  // new efficient way to get the reslice origin and the axis coordinates.
  double reslice[4], pos2[4];
  this->ScreenToRealWorldMatrix->MultiplyPoint (pos, reslice);
  this->ImageReslice->SetResliceAxesOrigin(reslice[0], reslice[1], reslice[2]);


  vtkMatrix4x4* mat = vtkMatrix4x4::New();
  vtkMatrix4x4::Transpose (this->OrientationMatrix, mat);
  mat->MultiplyPoint (pos, pos2);
  mat->MultiplyPoint (min_bounds, min_bounds);
  mat->MultiplyPoint (max_bounds, max_bounds);
  mat->Delete();

  x = pos2[0];
  y = pos2[1];

  max_x = max_bounds[0];
  max_y = max_bounds[1];
  
  min_x = min_bounds[0];
  min_y = min_bounds[1];

  /*
  switch (this->Orientation)
  {
      case NIREPvtkViewImage::SAGITTAL_ID:

        this->ImageReslice->SetResliceAxesOrigin(pos[0],0,0);
        x = (double)pos[1];
        y = (double)pos[2];
        max_x = bounds[3];
        max_y = bounds[5];
        min_x = bounds[2];
        min_y = bounds[4];
        break;

      case NIREPvtkViewImage::CORONAL_ID:

        this->ImageReslice->SetResliceAxesOrigin(0,pos[1],0);
        if( this->Conventions==RADIOLOGIC )
        {
          x = (double)pos[0];
          max_x = bounds[1];
          min_x = bounds[0];
        }
        else
        {
          x = (double)pos[0]*-1.0;
          max_x = bounds[1]*-1.0;
          min_x = bounds[0]*-1.0;
        }
        y = (double)pos[2];
        max_y = bounds[5];
        min_y = bounds[4];
        break;


      case NIREPvtkViewImage::AXIAL_ID:

        this->ImageReslice->SetResliceAxesOrigin(0,0,pos[2]);

        if( this->Conventions==RADIOLOGIC )
        {
          x = (double)pos[0];
          max_x = bounds[1];
          min_x = bounds[0];
        }
        else
        {
          x = (double)pos[0]*-1.0;
          max_x = bounds[1]*-1.0;
          min_x = bounds[0]*-1.0;
        }
        y = (double)pos[1]*-1.0;
        max_y = bounds[3]*-1.0;
        min_y = bounds[2]*-1.0;
        break;
  }
  */


  this->HorizontalLineSource->SetPoint1(min_x, y, 0.001);
  this->HorizontalLineSource->SetPoint2(max_x, y, 0.001);
  this->VerticalLineSource->SetPoint1(x, min_y, 0.001);
  this->VerticalLineSource->SetPoint2(x, max_y, 0.001);
  

  this->ImageReslice->Update(); // needed to update input Extent


  int imCoor[3];
  this->GetCurrentVoxelCoordinates(imCoor);
  int dims[3];
  this->GetImage()->GetDimensions (dims);

  std::ostringstream os2;
  std::ostringstream os;
  //os << "Slice: ";

  os2 << "Zoom: " << this->GetZoom()*100.0 << " \%\n";
    
  switch( this->Orientation )
  {
      case NIREPvtkViewImage::AXIAL_ID :
        os << "Image size: " << dims[0] << " x " << dims[1] << "\n";
        os << "Voxel size: " << spacing[0] << " x " << spacing[1] << "\n";
        //os << imCoor[2] << " / " << dims[2]-1 << std::endl;
        os << "X: " << imCoor[0] << " px Y: " << imCoor[1] << " px Value: "
           << this->GetCurrentPointDoubleValue() << std::endl;
        os << "X: " << pos[0] << " mm Y: " << pos[1] << " mm\n";
        if ( this->ShowSliceNumber )
          os2 << "Slice: " << imCoor[2] << " / " << dims[2]-1 << std::endl;
        os2 << "Location: " << pos[2] << " mm";
        break;
          
        
      case NIREPvtkViewImage::CORONAL_ID :
        os << "Image size: " << dims[0] << " x " << dims[2] << "\n";
        os << "Voxel size: " << spacing[0] << " x " << spacing[2] << "\n";
        //os << imCoor[1] << " / " << dims[1]-1 << std::endl;
        os << "X: " << imCoor[0] << " px Z: " << imCoor[2] << " px Value: "
           << this->GetCurrentPointDoubleValue() << std::endl;
        os << "X: " << pos[0] << " mm Z: " << pos[2] << " mm\n";
        if ( this->ShowSliceNumber )
          os2 << "Slice: " << imCoor[1] << " / " << dims[1]-1 << std::endl;
        os2 << "Location: " << pos[1] << " mm";
        break;
        
        
      case NIREPvtkViewImage::SAGITTAL_ID :
        os << "Image size: " << dims[1] << " x " << dims[2] << "\n";
        os << "Voxel size: " << spacing[1] << " x " << spacing[2] << "\n";
        //os << imCoor[0] << " / " << dims[0]-1 << std::endl;
        os << "Y: " << imCoor[1] << " px Z: " << imCoor[2] << " px Value: "
           << this->GetCurrentPointDoubleValue() << std::endl;
        os << "Y: " << pos[1] << " mm Z: " << pos[2] << " mm\n";
        if ( this->ShowSliceNumber )
          os2 << "Slice: " << imCoor[0] << " / " << dims[0]-1 << std::endl;
        os2 << "Location: " << pos[0] << " mm";
        break;
  }
  os << "<window_level>";
  
  this->SetUpLeftAnnotation( os.str().c_str() );
  this->SetDownLeftAnnotation( os2.str().c_str() );
  //  }
  //  else
  //    this->SetUpRightAnnotation("");
  
  unsigned int direction = this->GetOrthogonalAxis (this->GetOrientation());
  this->DataSetCutPlane->SetOrigin (reslice[0], reslice[1], reslice[2]);
  
  switch(direction)
  {
      case X_ID :
        //this->DataSetCutPlane->SetNormal (1,0,0);
        this->DataSetCutBox->SetBounds (this->DataSetCutPlane->GetOrigin()[0],this->DataSetCutPlane->GetOrigin()[0]+this->BoxThickness,
                                        this->GetWholeMinPosition(1),this->GetWholeMaxPosition(1),
                                        this->GetWholeMinPosition(2),this->GetWholeMaxPosition(2));

        break;
      case Y_ID :
        //this->DataSetCutPlane->SetNormal (0,1,0);
        this->DataSetCutBox->SetBounds (this->GetWholeMinPosition(0),this->GetWholeMaxPosition(0),
                                        this->DataSetCutPlane->GetOrigin()[1],this->DataSetCutPlane->GetOrigin()[1]+this->BoxThickness,
                                        this->GetWholeMinPosition(2),this->GetWholeMaxPosition(2));
        break;
      case Z_ID :
        //this->DataSetCutPlane->SetNormal (0,0,1);
        this->DataSetCutBox->SetBounds (this->GetWholeMinPosition(0),this->GetWholeMaxPosition(0),
                                        this->GetWholeMinPosition(1),this->GetWholeMaxPosition(1),
                                        this->DataSetCutPlane->GetOrigin()[2],this->DataSetCutPlane->GetOrigin()[2]+this->BoxThickness);
        break;
  }


  if( this->DataSetList.size() )
  {

    this->ResetAndRestablishZoomAndCamera();

    /*
      We need to correct for the origin of the actor. Indeed, the ImageActor
      has always position 0 in Z in axial view, in X in sagittal view and
      in Y in coronal view. The projected dataset have an origin that depends
      on the required slice and can be negative. In that case, the projected
      data are behind the image actor and thus not visible. Here, we correct
      this by translating the actor so that it becomes visible.
     */
    for( unsigned int i=0; i<this->DataSetActorList.size(); i++)
    {
      double Pos[3];
      this->DataSetActorList[i]->GetPosition (Pos);

      switch(direction)
      {
          case X_ID :
            Pos[0] = -1.0*reslice[0] + 1.0;
            break;

          case Y_ID:
            Pos[1] = -1.0*reslice[1] + 1.0;
            break;

          case Z_ID:
            Pos[2] = -1.0*reslice[2] + 1.0;
            break;
      }

      this->DataSetActorList[i]->SetPosition (Pos);
    }

  }

  this->Modified();
}


void NIREPvtkViewImage2D::SetWindow (double w)
{

  if( w<0.0 )
  {
    w = 0.0;
  }

  double shiftScaleWindow = this->GetShift() + w*this->GetScale();

  NIREPvtkViewImage::SetWindow ( shiftScaleWindow );
  this->WindowLevelForCorner->SetWindow( shiftScaleWindow );

  double v_min = this->GetLevel() - 0.5*this->GetWindow();
  double v_max = this->GetLevel() + 0.5*this->GetWindow();

  if( this->GetLookupTable() && this->WindowLevel->GetLookupTable())
  {

    this->GetLookupTable()->SetRange ( (v_min-0.5*this->GetShift())/this->GetScale(),
                                       (v_max-1.5*this->GetShift())/this->GetScale());
    this->WindowLevel->GetLookupTable()->SetRange (v_min, v_max);
  }

  if (this->BGWindowLevel && this->BGWindowLevel->GetLookupTable())
      this->BGWindowLevel->GetLookupTable()->SetRange (v_min, v_max);


}


void NIREPvtkViewImage2D::SetLevel (double l)
{

  double shiftScaleLevel = this->GetShift() + l*this->GetScale();

  NIREPvtkViewImage::SetLevel ( shiftScaleLevel );
  this->WindowLevelForCorner->SetLevel( shiftScaleLevel );

  double v_min = this->GetLevel() - 0.5*this->GetWindow();
  double v_max = this->GetLevel() + 0.5*this->GetWindow();

  if( this->GetLookupTable() && this->WindowLevel->GetLookupTable())
  {
    this->GetLookupTable()->SetRange ( (v_min-0.5*this->GetShift())/this->GetScale(),
                                       (v_max-1.5*this->GetShift())/this->GetScale());
    this->WindowLevel->GetLookupTable()->SetRange (v_min, v_max);
  }
}


double NIREPvtkViewImage2D::GetColorWindow()
{
  return this->GetWindow();
}


double  NIREPvtkViewImage2D::GetColorLevel()
{
  return this->GetLevel();
}


void NIREPvtkViewImage2D::SetTransform(vtkTransform* p_transform)
{
  this->ImageReslice->SetResliceTransform(p_transform);
  this->Modified();
}


void NIREPvtkViewImage2D::SetMatrix(vtkMatrix4x4* p_matrix, bool centered)
{
    if(!p_matrix)
        return;

    if(this->ImageActor) {
        if(centered) {
            //we need to decompose the matrix.:
            //1. move the image to the center
            //2. rotate the image with rotation in p_matrix
            //3. move the image back to its place
            //4. apply the translation contained in p_matrix

            double *propCenter = 0;
            double *propPosition = 0;

            propCenter = this->ImageActor->GetCenter();
            propPosition = this->ImageActor->GetPosition();

            vtkMatrix4x4 *finalMat = vtkMatrix4x4::New();

            vtkMatrix4x4 *toCenterMat = vtkMatrix4x4::New();
            toCenterMat->Identity();
            (*toCenterMat)[0][3] = - ( propCenter[0] - propPosition[0] );
            (*toCenterMat)[1][3] = - ( propCenter[1] - propPosition[1] );
            (*toCenterMat)[2][3] = - ( propCenter[2] - propPosition[2] );

            vtkMatrix4x4 *rotationMat = vtkMatrix4x4::New();
            rotationMat->Identity();
            (*rotationMat)[0][0] = (*p_matrix)[0][0];
            (*rotationMat)[0][1] = (*p_matrix)[0][1];
            (*rotationMat)[0][2] = (*p_matrix)[0][2];

            (*rotationMat)[1][0] = (*p_matrix)[1][0];
            (*rotationMat)[1][1] = (*p_matrix)[1][1];
            (*rotationMat)[1][2] = (*p_matrix)[1][2];

            (*rotationMat)[2][0] = (*p_matrix)[2][0];
            (*rotationMat)[2][1] = (*p_matrix)[2][1];
            (*rotationMat)[2][2] = (*p_matrix)[2][2];

            vtkMatrix4x4 *fromCenterMat = vtkMatrix4x4::New();
            fromCenterMat->Identity();
            (*fromCenterMat)[0][3] = ( propCenter[0] - propPosition[0] );
            (*fromCenterMat)[1][3] = ( propCenter[1] - propPosition[1] );
            (*fromCenterMat)[2][3] = ( propCenter[2] - propPosition[2] );

            vtkMatrix4x4 *translationMat = vtkMatrix4x4::New();
            translationMat->Identity();
            (*translationMat)[0][3] = (*p_matrix)[0][3];
            (*translationMat)[1][3] = (*p_matrix)[1][3];
            (*translationMat)[2][3] = (*p_matrix)[2][3];

            vtkMatrix4x4::Multiply4x4(rotationMat, toCenterMat, finalMat);
            vtkMatrix4x4::Multiply4x4(fromCenterMat, finalMat, finalMat);
            vtkMatrix4x4::Multiply4x4(translationMat, finalMat, finalMat);

            this->ImageActor->SetUserMatrix(finalMat);
            finalMat->Delete();
            toCenterMat->Delete();
            rotationMat->Delete();
            translationMat->Delete();
        }
        else {
            this->ImageActor->SetUserMatrix(p_matrix);
        }
        this->ImageActor->GetUserMatrix()->PrintSelf(std::cout, vtkIndent());
    }

    this->Modified();
}


void NIREPvtkViewImage2D::SetImage(vtkImageData* image)
{
  if(!image)
  {
    return;
  }

  int* extent = image->GetExtent();
  if( extent[1]<extent[0] || extent[3]<extent[2] || extent[5]<extent[4] )
  {
    vtkErrorMacro ( << "Image extent is not valid: " << extent[0] << " "
                    << extent[1] << " "
                    << extent[2] << " "
                    << extent[3] << " "
                    << extent[4] << " "
                    << extent[5]);
    return;
  }

  NIREPvtkViewImage::SetImage( image );

  // check if there is a mask image. If yes, then we check
  // if the new image size and spacing agrees with the mask image.
  // If not, we remove the mask image
  if( this->GetMaskImage() )
  {
    int*    dims        = image->GetDimensions();
    double* spacing     = image->GetSpacing();
    int*    maskDims    = this->GetMaskImage()->GetDimensions();
    double* maskSpacing = this->GetMaskImage()->GetSpacing();

    if( dims[0]!=maskDims[0] || dims[1]!=maskDims[1] || dims[2]!=maskDims[2] ||
        spacing[0]!=maskSpacing[0] || spacing[1]!=maskSpacing[1] || spacing[2]!=maskSpacing[2] )
    {
      this->RemoveMaskImage();
    }
  }

  // should check also the overlapping image

  if( image->GetScalarType() == VTK_UNSIGNED_CHAR  && (image->GetNumberOfScalarComponents()==3 || image->GetNumberOfScalarComponents()==4) )
  {
    this->AuxInput = image;
  }
  else
  {
    this->AuxInput = this->WindowLevel->GetOutput();

    this->WindowLevel->SetInput (image);
    double range[2];
    image->GetScalarRange (range);
    if ( this->WindowLevel->GetLookupTable() )
    {
      this->WindowLevel->GetLookupTable()->SetRange (range);
    }
  }


  if( this->GetOverlappingImage() )
  {
    this->Blender->SetInput (0, this->AuxInput );
  }
  else
  {
    if( this->GetMaskImage() )
    {
      this->MaskFilter->SetImageInput ( this->AuxInput );
    }
    else
    {
      this->ImageReslice->SetInput ( this->AuxInput );
      this->ResliceInput = this->AuxInput;
    }
  }

  this->ImageActor->SetInput( this->ImageReslice->GetOutput() );

  this->AddActor(this->HorizontalLineActor);
  this->AddActor(this->VerticalLineActor);

  this->AddActor(this->ImageActor);



  // Save the camera focal and position, and zoom, before calling InternalUpdate()
  double focal[3], pos[3], zoom;
  this->GetCameraFocalAndPosition (focal, pos);
  zoom = this->GetZoom();
  

  this->SetupAnnotations();
  this->InternalUpdate();

  
  // Check that the current displayed point lies within the bounds of the image. If not,
  // we camp it to the nearest acceptable position.
  double *wextent = image->GetBounds();
  double position[3];
  this->GetCurrentPoint ( position );
  position[0]<wextent[0]?position[0]=wextent[0]:position[0];
  position[0]>wextent[1]?position[0]=wextent[1]:position[0];
  position[1]<wextent[2]?position[1]=wextent[2]:position[1];
  position[1]>wextent[3]?position[1]=wextent[3]:position[1];
  position[2]<wextent[4]?position[2]=wextent[4]:position[2];
  position[2]>wextent[5]?position[2]=wextent[5]:position[2];
  this->SetCurrentPoint ( position );

  
    
  //this->SetWindow( this->GetWindow() );
  //this->SetLevel( this->GetLevel() );


  // restore the zoom and focal in case this is not the first time we render the image.
  if( !this->GetFirstImage() )
  {
    this->SetZoom ( zoom );
    this->SetCameraFocalAndPosition (focal, pos);
    this->SetFirstImage (0);
  }

  if( this->RulerWidgetVisibility )
    this->RulerWidget->On();
  
}


void NIREPvtkViewImage2D::SetLookupTable (vtkScalarsToColors* lut)
{

  if( !lut )
  {
    return;
  }

  NIREPvtkViewImage::SetLookupTable (lut);

  double v_min = this->GetLevel() - 0.5*this->GetWindow();
  double v_max = this->GetLevel() + 0.5*this->GetWindow();

  lut->SetRange ( (v_min-0.5*this->GetShift())/this->GetScale(),
                  (v_max-1.5*this->GetShift())/this->GetScale() );


  vtkLookupTable* realLut = vtkLookupTable::SafeDownCast (lut);

  if( !realLut )
  {
    std::cerr << "Error: Cannot cast vtkScalarsToColors to vtkLookupTable." << std::endl;
    return;
  }

  vtkLookupTable* newLut = vtkLookupTable::New();
  newLut->DeepCopy (realLut);
  newLut->SetRange (v_min, v_max);
  this->WindowLevel->SetLookupTable (newLut);
  newLut->Delete();
}


void NIREPvtkViewImage2D::SetBGLookupTable (vtkScalarsToColors* lut)
{
  this->BGLookupTable = lut;
  double v_min = this->GetLevel() - 0.5*this->GetWindow();
  double v_max = this->GetLevel() + 0.5*this->GetWindow();

  lut->SetRange ( (v_min-0.5*this->GetShift())/this->GetScale(),
                  (v_max-1.5*this->GetShift())/this->GetScale() );


  vtkLookupTable* realLut = vtkLookupTable::SafeDownCast (lut);

  if( !realLut )
  {
    std::cerr << "Error: Cannot cast vtkScalarsToColors to vtkLookupTable." << std::endl;
    return;
  }

  vtkLookupTable* newLut = vtkLookupTable::New();
  newLut->DeepCopy (realLut);
  newLut->SetRange (v_min, v_max);
  this->BGWindowLevel->SetLookupTable (newLut);
  newLut->Delete();

  this->Modified();
}


vtkScalarsToColors* NIREPvtkViewImage2D::GetBGLookupTable (void) const
{
    return this->BGLookupTable;
}


void NIREPvtkViewImage2D::SetOrientation(unsigned int p_orientation)
{
  if( (p_orientation > NIREPvtkViewImage::NB_PLAN_IDS - 1) || (this->Orientation == p_orientation) )
  {
    return;
  }

  this->Orientation = p_orientation;

  
  // setup the OrientationMatrix and the ScreenToRealWorldMatrix. Then, we have no
  // need to check the view's orientation to determine what slice to display: a
  // simple matrix multiplication will tell it for us.
  this->OrientationMatrix->Zero();
  this->ScreenToRealWorldMatrix->Zero();

  
  if( this->Orientation == NIREPvtkViewImage::SAGITTAL_ID )
  {
    this->ImageReslice->SetResliceAxesDirectionCosines( 0, -1, 0,
                                                        0, 0, 1,
                                                        1, 0, 0);
    this->OrientationMatrix->SetElement (0, 2, 0.0);
    this->OrientationMatrix->SetElement (1, 0, -1.0);
    this->OrientationMatrix->SetElement (2, 1, 1.0);

    this->ScreenToRealWorldMatrix->SetElement (0, 0, 1.0);
  }

  
  if( this->Orientation == NIREPvtkViewImage::CORONAL_ID )
  {
    if( this->Conventions == RADIOLOGIC )
    {
      this->OrientationMatrix->SetElement(0, 0, 1.0);
      this->ImageReslice->SetResliceAxesDirectionCosines(1,  0, 0,
                                                         0,  0, 1,
                                                         0,  1, 0); 
    }
    else
    {  
      this->OrientationMatrix->SetElement(0, 0, -1.0);
      this->ImageReslice->SetResliceAxesDirectionCosines(-1,  0, 0,
                                                         0,  0, 1,
                                                         0,  1, 0); 
    }
    
    this->OrientationMatrix->SetElement(2, 1, 1.0);
    this->ScreenToRealWorldMatrix->SetElement (1, 1, 1.0);
  }

  
  if( this->Orientation == NIREPvtkViewImage::AXIAL_ID )
  {

    
    if( this->Conventions == RADIOLOGIC )
    {
      this->OrientationMatrix->SetElement(0, 0, 1.0 );
      this->ImageReslice->SetResliceAxesDirectionCosines(1, 0, 0,
                                                         0, 1, 0,
                                                         0, 0, 1);
    }
    else
    {  
      this->OrientationMatrix->SetElement(0, 0, -1.0 );
      this->ImageReslice->SetResliceAxesDirectionCosines(-1, 0, 0,
                                                         0, 1, 0,
                                                         0, 0, 1);
    }


    
    this->OrientationMatrix->SetElement(1, 1, 1.0 );
    this->ScreenToRealWorldMatrix->SetElement (2, 2, 1.0);
  }

  unsigned int direction = this->GetOrthogonalAxis (this->GetOrientation());
  switch(direction)
  {
      case X_ID :
        this->DataSetCutPlane->SetNormal (1,0,0);
        break;
      case Y_ID :
        this->DataSetCutPlane->SetNormal (0,1,0);
        break;
      case Z_ID :
        this->DataSetCutPlane->SetNormal (0,0,1);
        break;
  }

  //this->ImageReslice->Modified();

  this->UpdateImageActor(); // make sure update extent are up to date
  this->UpdatePosition(); // make sure reslicer origin are ok
  this->InitializeImagePositionAndSize(); // reset and center the view
  this->SetupAnnotations(); // make sure annotations are ok
  
  this->Modified();
}


void NIREPvtkViewImage2D::SetupAnnotations()
{
  if( !this->GetImage() )
  {
    return;
  }
  
  //  int    *dims    = this->GetImage()->GetDimensions();
  //  double *spacing = this->GetImage()->GetSpacing();

  //  std::ostringstream os;
  // os << "Image Size: ";

  std::ostringstream os;
  
  if( strcmp (this->GetPatientNameData(),"")!=0 )
    os << this->GetPatientNameData() << "\n";
  else
    os << "No Patient Name\n";

  if( strcmp (this->GetStudyNameData(),"")!=0 )
    os << this->GetStudyNameData() << "\n";
  else
    os << "No Study Name\n";

  if( strcmp (this->GetSerieNameData(),"")!=0 )
    os << this->GetSerieNameData() << "\n";
  else
    os << "No Serie Name\n";

  this->SetUpRightAnnotation ( os.str().c_str() );

  if( this->Orientation == NIREPvtkViewImage::SAGITTAL_ID )
  {
    //    os << dims[1] << " x " << dims[2] << std::endl;
    //    os << "Voxel Size: " << spacing[1] << " x " << spacing[2] << " mm";
    
    this->SetNorthAnnotation("S");
    this->SetSouthAnnotation("I");
    this->SetEastAnnotation ("P");
    this->SetWestAnnotation("A");

    this->HorizontalLineActor->GetProperty()->SetColor (1.0,0.0,0.0);
    this->VerticalLineActor->GetProperty()->SetColor (0.0,1.0,0.0);
  }

  
  if( this->Orientation == NIREPvtkViewImage::CORONAL_ID )
  {
    //    os << dims[0] << " x " << dims[2] << std::endl;
    //    os << "Voxel Size: " << spacing[0] << " x " << spacing[2] << " mm";
    
    this->HorizontalLineActor->GetProperty()->SetColor (1.0,0.0,0.0);
    this->VerticalLineActor->GetProperty()->SetColor (0.0,0.0,1.0);
    
    this->SetNorthAnnotation("S");
    this->SetSouthAnnotation("I");
    if( this->Conventions == RADIOLOGIC)
    {
      this->SetEastAnnotation ("L");
      this->SetWestAnnotation("R");
    }
    else
    {
      this->SetEastAnnotation ("R");
      this->SetWestAnnotation("L");
    }
  }
  
  if( this->Orientation == NIREPvtkViewImage::AXIAL_ID )
  {
    //    os << dims[0] << " x " << dims[1] << std::endl;
    //    os << "Voxel Size: " << spacing[0] << " x " << spacing[1] << " mm";
    
    this->SetNorthAnnotation("A");
    this->SetSouthAnnotation("P");
    if( this->Conventions == RADIOLOGIC )
    {
      this->SetEastAnnotation ("L");
      this->SetWestAnnotation("R");
    }
    else
    {
      this->SetEastAnnotation ("R");
      this->SetWestAnnotation("L");
    }

    this->HorizontalLineActor->GetProperty()->SetColor (0.0,1.0,0.0);
    this->VerticalLineActor->GetProperty()->SetColor (0.0,0.0,1.0);
  }
  
  //  this->SetSizeData ( os.str().c_str() );
  this->Modified();  
}


void NIREPvtkViewImage2D::ScreenCoordinatesToPosition (double sc[2], double pos[3] )
{
  double p_sc[4];
  p_sc[0] = sc[0];
  p_sc[1] = sc[1];
  p_sc[2] = 0.0;
  p_sc[3] = 0.0;

  double p_pos[4];
  this->GetCurrentPoint (p_pos);
  p_pos[3] = 0.0;

  this->OrientationMatrix->MultiplyPoint (p_sc, p_sc);  
  this->ScreenToRealWorldMatrix->MultiplyPoint (p_pos, p_pos);

  for( int i=0; i<3; i++)
    pos[i] = p_sc[i] + p_pos[i];
}


void NIREPvtkViewImage2D::SetInterpolationMode(int i)
{
  this->ImageActor->SetInterpolate(i);
  this->Modified();
}


int NIREPvtkViewImage2D::GetInterpolationMode(void)
{
  return this->ImageActor->GetInterpolate();
}


void NIREPvtkViewImage2D::SetRulerWidgetVisibility (int val)
{
  this->RulerWidgetVisibility = val;
  if( this->RulerWidgetVisibility )
  {
    this->RulerWidget->On();
  }
  else
  {
    this->RulerWidget->Off();
  }
}


void NIREPvtkViewImage2D::SetMaskImage (vtkImageData* mask, vtkLookupTable* lut)
{

  if( !this->GetImage() || !mask || !lut)
  {
    return;
  }


  NIREPvtkViewImage::SetMaskImage (mask, lut);


  // check if the mask dimensions match the image dimensions
  int dim1[3], dim2[3];
  this->GetImage()->GetDimensions (dim1);
  mask->GetDimensions (dim2);
  if (    (dim1[0] != dim2[0]) ||
          (dim1[1] != dim2[1]) ||
          (dim1[2] != dim2[2]) )
  {
    vtkErrorMacro("Dimensions of the mask image do not match");
    return;
  }


  // check if the scalar range match the number of entries in the LUT
  double range[2];
  mask->GetScalarRange (range);
  int numLUT = lut->GetNumberOfTableValues();
  if( numLUT<(int)(range[1])+1 )
  {
    vtkErrorMacro("The number of LUT entries is less than the range of the mask.");
    return;
  }

  if( this->GetOverlappingImage() )
  {
    this->MaskFilter->SetImageInput ( this->Blender->GetOutput() );
  }
  else
  {
    this->MaskFilter->SetImageInput ( this->AuxInput );
  }
  this->MaskFilter->SetMaskInput (mask);
  this->MaskFilter->SetLookupTable (lut);
  this->MaskFilter->Update();


  this->ImageReslice->SetInputConnection( this->MaskFilter->GetOutputPort() );
  this->ResliceInput = this->MaskFilter->GetOutput();

}


void NIREPvtkViewImage2D::RemoveMaskImage()
{

  if( this->GetOverlappingImage() )
  {
    this->ImageReslice->SetInputConnection( this->Blender->GetOutputPort() );
    this->ResliceInput = this->Blender->GetOutput();
  }
  else
  {
    this->ImageReslice->SetInput( this->AuxInput );
    this->ResliceInput = this->AuxInput;
  }

  NIREPvtkViewImage::SetMaskImage (0,0);
}


void NIREPvtkViewImage2D::SetOverlappingImage (vtkImageData* image)
{
  NIREPvtkViewImage::SetOverlappingImage ( image );
  
  if( !this->GetImage() || !image )
  {
    return;
  }

  this->Blender->RemoveAllInputs();
  this->Blender->AddInput ( this->AuxInput );
  this->Blender->AddInput ( image );

  if( this->GetMaskImage() )
  {
    this->MaskFilter->SetInputConnection ( this->Blender->GetOutputPort() );
  }
  else
  {
    this->ImageReslice->SetInputConnection ( this->Blender->GetOutputPort() );
    this->ResliceInput = this->Blender->GetOutput();
  }
}


void NIREPvtkViewImage2D::RemoveOverlappingImage()
{

  if( this->GetMaskImage() )
  {
    this->MaskFilter->SetInput (this->AuxInput);
  }
  else
  {
    this->ImageReslice->SetInput (this->AuxInput);
    this->ResliceInput = this->AuxInput;
  }

  NIREPvtkViewImage::SetOverlappingImage ( 0 );
}


vtkActor* NIREPvtkViewImage2D::AddDataSet (vtkDataSet* dataset,  vtkProperty* property)
{

  bool doit = true;

  if (!dataset)
    doit = false;

  if( this->HasDataSet (dataset) )
  {
    doit = false;
  }

  
  vtkImageData* imagedata = vtkImageData::SafeDownCast(dataset);

  if (imagedata)
  {
    this->SetImage(imagedata);
  }
  else
  {
    if ( !this->GetImage() && !this->GetBGImage() )
    {
      doit = false;
    }
    // don't constrain the memory of input datasets anymore.
    if (doit)
    {

      vtkMatrix4x4* matrix = vtkMatrix4x4::New();
      for (unsigned int i=0; i<3; i++)
      {
        for (unsigned int j=0; j<3; j++)
        {
          matrix->SetElement(i,j,this->ImageReslice->GetResliceAxes()->GetElement(j,i));
        }
        matrix->SetElement(i,3,0);
      }
      matrix->SetElement(3,3,1);

      vtkCutter* cutter = vtkCutter::New();
      cutter->SetCutFunction ( this->DataSetCutPlane );

      // Very strangely in some cases (ex : landmarks)
      // the cutter increments the RefCount of the input dataset by 2
      // making some memory leek...
      // I could not manage to know what is wrong here
      cutter->SetInput (dataset);
      cutter->Update();

      if (!cutter->GetOutput())
      {
        vtkWarningMacro(<< "Unable to cut this dataset...");
        matrix->Delete();
        cutter->Delete();
        return NULL;
      }

      vtkPolyDataMapper* mapper = vtkPolyDataMapper::New();
      mapper->SetInput (cutter->GetOutput());

      vtkActor* actor = vtkActor::New();
      actor->SetUserMatrix (matrix);
      actor->SetMapper (mapper);
      if (property)
      {
        actor->SetProperty (property);
      }
      
      //actor->PickableOff();

      this->AddActor (actor);
      this->DataSetList.push_back (dataset);
      this->DataSetActorList.push_back (actor);

      this->ResetAndRestablishZoomAndCamera();

      actor->Delete();
      mapper->Delete();
      matrix->Delete();
      cutter->Delete();
    }
  }

  return this->GetDataSetActor(dataset);

}


vtkActor* NIREPvtkViewImage2D::AddPolyData (vtkPolyData* polydata,  vtkProperty* property, double thickness)
{

  bool doit = true;
  if (!polydata || this->HasDataSet (polydata) || !this->GetImage())
  {
    doit = false;
  }


  if (doit)
  {

    if (thickness)
    {
      this->BoxThickness = thickness;
    }


    vtkClipDataSet* clipper = vtkClipDataSet::New();
    clipper->GenerateClippedOutputOff();
    clipper->InsideOutOn ();
    clipper->SetInput (polydata);

    /*
    unsigned int  direction = this->GetOrthogonalAxis (this->GetOrientation());
    switch(direction)
    {

        case X_ID :
          this->DataSetCutBox->SetBounds (this->DataSetCutPlane->GetOrigin()[0]-0.5*this->BoxThickness,this->DataSetCutPlane->GetOrigin()[0]+0.5*this->BoxThickness,
                                          this->GetWholeMinPosition(1),this->GetWholeMaxPosition(1),
                                          this->GetWholeMinPosition(2),this->GetWholeMaxPosition(2));

          break;
        case Y_ID :
          this->DataSetCutBox->SetBounds (this->GetWholeMinPosition(0),this->GetWholeMaxPosition(0),
                                          this->DataSetCutPlane->GetOrigin()[1]-0.5*this->BoxThickness,this->DataSetCutPlane->GetOrigin()[1]+0.5*this->BoxThickness,
                                          this->GetWholeMinPosition(2),this->GetWholeMaxPosition(2));
          break;
        case Z_ID :
          this->DataSetCutBox->SetBounds (this->GetWholeMinPosition(0),this->GetWholeMaxPosition(0),
                                          this->GetWholeMinPosition(1),this->GetWholeMaxPosition(1),
                                          this->DataSetCutPlane->GetOrigin()[2]-0.5*this->BoxThickness,this->DataSetCutPlane->GetOrigin()[2]+0.5*this->BoxThickness);
          break;
    }
    */ // -> already done in SetOrientation()

    clipper->SetClipFunction ( this->DataSetCutBox );
    clipper->Update();


    vtkMatrix4x4* matrix = vtkMatrix4x4::New();
    for (unsigned int i=0; i<3; i++)
    {
      for (unsigned int j=0; j<3; j++)
      {
        matrix->SetElement(i, j, this->ImageReslice->GetResliceAxes()->GetElement(j,i));
      }
    }
    matrix->SetElement(3,3,1);



    vtkDataSetMapper* mapper = vtkDataSetMapper::New();
    mapper->SetInput (clipper->GetOutput());

    vtkActor* actor = vtkActor::New();
    actor->SetMapper (mapper);
    actor->SetUserMatrix (matrix);
    if (property)
    {
      actor->SetProperty (property);
    }


    this->AddActor (actor);
    this->DataSetList.push_back (polydata);
    this->DataSetActorList.push_back (actor);

    this->ResetAndRestablishZoomAndCamera();

    actor->Delete();
    mapper->Delete();
    matrix->Delete();
    clipper->Delete();
  }

  return this->GetDataSetActor(polydata);

}


vtkActor* NIREPvtkViewImage2D::SyncAddPolyData (vtkPolyData* polydata,  vtkProperty* property, double thickness)
{

  if( this->IsLocked() )
  {
    return NULL;
  }

  vtkActor* actor = this->AddPolyData (polydata, property, thickness);

  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {
    NIREPvtkViewImage2D* view = NIREPvtkViewImage2D::SafeDownCast (this->Children[i]);
    if( view )
    {
      view->SyncAddPolyData (polydata, property, thickness);
    }
  }
  this->UnLock();

  return actor;
}


void NIREPvtkViewImage2D::ResetZoom()
{
  NIREPvtkViewImage::ResetZoom();
  this->SetZoom ( 1.0 );
}


void NIREPvtkViewImage2D::SetShow2DAxis(int show)
{
  this->Show2DAxis = show;
  this->HorizontalLineActor->SetVisibility(show);
  this->VerticalLineActor->SetVisibility(show);
  this->Modified();
}


void NIREPvtkViewImage2D::SetZoom (double factor)
{

  if ( !this->GetRenderer() )
  {
    return;
  }

  NIREPvtkViewImage::SetZoom ( factor ); //this->GetZoom() ); //*factor );


  vtkCamera *camera = this->GetRenderer()->GetActiveCamera();


  camera->SetParallelScale(this->InitialParallelScale / this->GetZoom() );
  //camera->GetParallelScale() / factor );


  if ( this->GetRenderWindowInteractor()->GetLightFollowCamera() )
  {
    this->GetRenderer()->UpdateLightsGeometryToFollowCamera();
  }


  if( this->GetImage() )
  {
    int imCoor[3];
    this->GetCurrentVoxelCoordinates(imCoor);
    double pos[3];
    this->GetCurrentPoint (pos);
    int* dims = this->GetImage()->GetDimensions();
    std::ostringstream os;
    os << "Zoom: " << this->GetZoom()*100.0 << " \%\n";
    switch( this->Orientation )
    {
        case NIREPvtkViewImage::AXIAL_ID :
          if ( this->ShowSliceNumber )
            os << "Slice: " << imCoor[2] << " / " << dims[2]-1 << std::endl;
          os << "Location: " << pos[2] << " mm";
          break;

        case NIREPvtkViewImage::CORONAL_ID :
          if ( this->ShowSliceNumber )
            os << "Slice: " << imCoor[1] << " / " << dims[1]-1 << std::endl;
          os << "Location: " << pos[1] << " mm";
          break;
          
        case NIREPvtkViewImage::SAGITTAL_ID :
          if ( this->ShowSliceNumber )
          os << "Slice: " << imCoor[0] << " / " << dims[0]-1 << std::endl;
        os << "Location: " << pos[0] << " mm";
        break;
    }
    
    this->SetDownLeftAnnotation( os.str().c_str() );
  }
  
}


void NIREPvtkViewImage2D::SetConventions (int val)
{
  if( val==NIREPvtkViewImage2D::RADIOLOGIC )
    this->SetConventionsToRadiological();
  else if( val==NIREPvtkViewImage2D::NEUROLOGIC )
    this->SetConventionsToNeurological();
  else
    vtkErrorMacro ( << "Conventions not supported.");
}


void NIREPvtkViewImage2D::SetConventionsToRadiological()
{
  this->Conventions = RADIOLOGIC;

  unsigned int orientation = this->GetOrientation();
  this->Orientation = NIREPvtkViewImage::NB_PLAN_IDS;
  this->SetOrientation ( orientation );

  this->ResetAndRestablishZoomAndCamera();
  this->Modified();
}


void NIREPvtkViewImage2D::SetConventionsToNeurological()
{
  this->Conventions = NEUROLOGIC;

  unsigned int orientation = this->GetOrientation();
  this->Orientation = NIREPvtkViewImage::NB_PLAN_IDS;
  this->SetOrientation ( orientation );
  
  this->ResetAndRestablishZoomAndCamera();
  this->Modified();
}


void NIREPvtkViewImage2D::ResetAndRestablishZoomAndCamera()
{

  if( !this->GetRenderer() )
  {
    return;
  }

  double zoom = this->GetZoom();
  vtkCamera *camera = this->GetRenderer()->GetActiveCamera();
  double c_position[3], focal[3];
  camera->GetPosition(c_position);
  camera->GetFocalPoint (focal);

  this->ResetZoom();
  double focal2[3], pos2[3];
  camera->GetFocalPoint (focal2);
  camera->GetPosition (pos2);

  camera->SetFocalPoint (focal[0], focal[1], focal2[2]);
  camera->SetPosition (c_position[0], c_position[1], pos2[2]);

  this->SetZoom ( zoom/this->GetZoom() );

}


void NIREPvtkViewImage2D::PrintSelf(ostream& os, vtkIndent indent)
{
  this->Superclass::PrintSelf(os, indent);
  os << indent << "Orientation = " << this->Orientation << "\n";
  double* bounds   = 0;
  double* spacing  = 0;
  double* origin   = 0;
  int*    extent   = 0;
  int*    wextent  = 0;
  int*    uextent  = 0;

  if( !this->GetImage() )
  {
    return;
  }


  this->GetImage()->Update();
  this->ImageReslice->GetOutput()->Update();
  this->WindowLevel->GetOutput()->Update();

  this->GetImage()->GetBounds();
  this->ImageReslice->GetOutput()->GetBounds();
  this->WindowLevel->GetOutput()->GetBounds();
  this->ImageActor->GetBounds();

  extent  = this->GetImage()->GetExtent();
  uextent = this->GetImage()->GetUpdateExtent();
  wextent = this->GetImage()->GetWholeExtent();
  origin  = this->GetImage()->GetOrigin();
  spacing = this->GetImage()->GetSpacing();
  os << indent << "InputImage   - "<<this->GetImage()->GetNumberOfPoints()<<" points.\n"
     << "  extent : ("
     << extent[0] << "/" << extent[1] << " ; "
     << extent[2] << "/" << extent[3] << " ; "
     << extent[4] << "/" << extent[5] << ") \n"
     << " uextent : ("
     << uextent[0] << "/" << uextent[1] << " ; "
     << uextent[2] << "/" << uextent[3] << " ; "
     << uextent[4] << "/" << uextent[5] << ") \n"
     << " wextent : ("
     << wextent[0] << "/" << wextent[1] << " ; "
     << wextent[2] << "/" << wextent[3] << " ; "
     << wextent[4] << "/" << wextent[5] << ") \n"
     << "  origin : ("
     << origin[0] << " , " << origin[1] << " , " << origin[2] << ")\n"
     << "  spacing : ("
     << spacing[0] << " , " << spacing[1] << " , " << spacing[2] << ")\n";

  extent  = this->ImageReslice->GetOutput()->GetExtent();
  uextent = this->ImageReslice->GetOutput()->GetUpdateExtent();
  wextent = this->ImageReslice->GetOutput()->GetWholeExtent();
  origin  = this->ImageReslice->GetOutput()->GetOrigin();
  spacing = this->ImageReslice->GetOutput()->GetSpacing();
  os << indent << "Resliced Image   - "<<this->ImageReslice->GetOutput()->GetNumberOfPoints()<<" points.\n"
     << "  extent : ("
     << extent[0] << "/" << extent[1] << " ; "
     << extent[2] << "/" << extent[3] << " ; "
     << extent[4] << "/" << extent[5] << ") \n"
     << " uextent : ("
     << uextent[0] << "/" << uextent[1] << " ; "
     << uextent[2] << "/" << uextent[3] << " ; "
     << uextent[4] << "/" << uextent[5] << ") \n"
     << " wextent : ("
     << wextent[0] << "/" << wextent[1] << " ; "
     << wextent[2] << "/" << wextent[3] << " ; "
     << wextent[4] << "/" << wextent[5] << ") \n"
     << "  origin : ("
     << origin[0] << " , " << origin[1] << " , " << origin[2] << ")\n"
     << "  spacing : ("
     << spacing[0] << " , " << spacing[1] << " , " << spacing[2] << ")\n";

  extent  = this->WindowLevel->GetOutput()->GetExtent();
  uextent = this->WindowLevel->GetOutput()->GetUpdateExtent();
  wextent = this->WindowLevel->GetOutput()->GetWholeExtent();
  origin  = this->WindowLevel->GetOutput()->GetOrigin();
  spacing = this->WindowLevel->GetOutput()->GetSpacing();
  os << indent << "WindowLevel Image   - "<<this->WindowLevel->GetOutput()->GetNumberOfPoints()<<" points.\n"
     << "  extent : ("
     << extent[0] << "/" << extent[1] << " ; "
     << extent[2] << "/" << extent[3] << " ; "
     << extent[4] << "/" << extent[5] << ") \n"
     << " uextent : ("
     << uextent[0] << "/" << uextent[1] << " ; "
     << uextent[2] << "/" << uextent[3] << " ; "
     << uextent[4] << "/" << uextent[5] << ") \n"
     << " wextent : ("
     << wextent[0] << "/" << wextent[1] << " ; "
     << wextent[2] << "/" << wextent[3] << " ; "
     << wextent[4] << "/" << wextent[5] << ") \n"
     << "  origin : ("
     << origin[0] << " , " << origin[1] << " , " << origin[2] << ")\n"
     << "  spacing : ("
     << spacing[0] << " , " << spacing[1] << " , " << spacing[2] << ")\n";

  bounds = this->GetImage()->GetBounds();
  os << indent << "InputImage \n"
     << "           bounds : ("
     << bounds[0] << "/" << bounds[1] << " ; "
     << bounds[2] << "/" << bounds[3] << " ; "
     << bounds[4] << "/" << bounds[5] << ") \n";
  bounds = this->ImageReslice->GetOutput()->GetBounds();
  os << indent << "Resliced Image \n"
     << "           bounds : ("
     << bounds[0] << "/" << bounds[1] << " ; "
     << bounds[2] << "/" << bounds[3] << " ; "
     << bounds[4] << "/" << bounds[5] << ") \n";
  bounds = this->WindowLevel->GetOutput()->GetBounds();
  os << indent << "WindowLevel Image \n"
     << "           bounds : ("
     << bounds[0] << "/" << bounds[1] << " ; "
     << bounds[2] << "/" << bounds[3] << " ; "
     << bounds[4] << "/" << bounds[5] << ") \n";
  bounds = this->ImageActor->GetBounds();
  os << indent << "Image Actor  bounds : ("
     << bounds[0] << "/" << bounds[1] << " ; "
     << bounds[2] << "/" << bounds[3] << " ; "
     << bounds[4] << "/" << bounds[5] << ") \n";

}


void NIREPvtkViewImage2D::SetBGImage (vtkImageData *image, int slice, vtkTransform* transform)
{
    if (!this->GetRenderer() || !image || slice < 0)
        return;

    int dim = image->GetDataDimension();
    vtkImageActor* actor = vtkImageActor::New();
    vtkImageMapToColors*  windowLevel = vtkImageMapToColors::New();
    int* w_ext = image->GetWholeExtent();
    vtkLookupTable* lut = vtkLookupTable::New();


//  vtkImageData * input = vtkImageData::New();
// case image->GetScalarTypr() == VTK_UNSIGNED_CHAR?

    vtkLookupTable* imgLut =  vtkLookupTable::SafeDownCast (this->WindowLevel->GetLookupTable());
    if(imgLut)
    {
        lut->DeepCopy(imgLut);
        windowLevel->SetLookupTable(lut);
    }

    double range[2];
    image->GetScalarRange (range);
    if ( windowLevel->GetLookupTable() )
    {
        windowLevel->GetLookupTable()->SetRange (range);
    }


    windowLevel->SetInput(image);
    actor->SetInput(windowLevel->GetOutput());

    if (dim==3)
    {
        int nbSl;
        switch (this->Orientation)
        {
        case NIREPvtkViewImage::AXIAL_ID:
            nbSl = w_ext[5] - w_ext[4] + 1;
            if (slice > nbSl)
            {
                std::cout<<"Error: cannot add a background image, the slice number is too high "<<std::endl;
                return;
            }
            else
                actor->SetDisplayExtent( w_ext[0], w_ext[1], w_ext[2], w_ext[3], slice, slice);
            break;


        case NIREPvtkViewImage::CORONAL_ID:
            nbSl = w_ext[3] - w_ext[2] + 1;
            if (slice > nbSl)
            {
                std::cout<<"Error: can't add a background image, the slice number is too high "<<std::endl;
                return;
            }
            else
                actor->SetDisplayExtent( w_ext[0], w_ext[1], slice ,slice, w_ext[4], w_ext[5]);
            break;


        case NIREPvtkViewImage::SAGITTAL_ID:
            nbSl = w_ext[1] - w_ext[0] + 1;
            if (slice > nbSl)
            {
                std::cout<<"Error: can't add a background image, the slice number is too high "<<std::endl;
                return;
            }
            else
            actor->SetDisplayExtent( slice, slice, w_ext[2], w_ext[3], w_ext[4], w_ext[5]);
            break;
        }
    }
    else
    {
        slice = 0;
        actor->SetDisplayExtent( w_ext[0], w_ext[1], w_ext[2], w_ext[3], 0, 0);
    }

    if (transform)
    {
    actor->SetUserTransform(transform);
    }

    vtkTransform * transform2 = vtkTransform::New();
    transform2->RotateX(180);
    actor->SetUserTransform(transform2);

    actor->PickableOff();
    actor->DragableOff();

    if (this->BGActor && this->GetRenderer()->HasViewProp(this->BGActor) )
    {
        this->GetRenderer()->RemoveActor(BGActor);
    }

    this->BGActor = actor;
    this->BGWindowLevel = windowLevel;
    this->BGImage = image;

    if (this->ImageActor)
    {
        this->GetRenderer()->RemoveActor(ImageActor);
        this->GetRenderer()->AddViewProp(this->BGActor);
        this->GetRenderer()->AddViewProp(ImageActor);
    }
    else
        this->GetRenderer()->AddViewProp(this->BGActor);


    actor->Delete();
    windowLevel->Delete();
    lut->Delete();
    transform2->Delete();

}


void NIREPvtkViewImage2D::RemoveBGImage()
{

    if (this->BGActor && this->GetRenderer()->HasViewProp(this->BGActor))
    {
        this->GetRenderer()->RemoveActor(this->BGActor);
    }

    this->BGImage = 0;
    this->BGWindowLevel = 0;

}


void NIREPvtkViewImage2D::SetBGImageOpacity(double opacity)
{
    if (!this->BGActor)
        return;
    this->BGActor->SetOpacity(opacity);
}


double NIREPvtkViewImage2D::GetBGImageOpacity() const
{
    if (!this->BGActor)
        return -1.0;
    return this->BGActor->GetOpacity();
}


void NIREPvtkViewImage2D::SetOpacity(double opacity)
{
  this->ImageActor->SetOpacity(opacity);
}

double NIREPvtkViewImage2D::GetOpacity() const
{
  return this->ImageActor->GetOpacity();
}


void NIREPvtkViewImage2D::Clear(void)
{
  // maybe containing some bugs or missing process
  this->Reset();
  this->FirstRender = 1;
  this->SetFirstImage (1);
  
  this->RemoveBGImage();
  
  if (this->ImageActor && this->GetRenderer()->HasViewProp(this->ImageActor) )
  {
    this->ImageActor->SetPosition(0.0, 0.0, 0.0);
    this->ImageActor->SetScale(1.0);
    this->ImageActor->SetOrientation( this->ImageActor->GetOrientation()[0],
                                      this->ImageActor->GetOrientation()[0],
                                      0);

    this->ImageActor->SetUserMatrix(vtkMatrix4x4::New());
    this->GetRenderer()->RemoveActor(this->ImageActor);
  }
  this->RemoveActor( this->HorizontalLineActor );
  this->RemoveActor( this->VerticalLineActor );
  
  if ( this->GetImage() )
  {
    NIREPvtkViewImage::SetImage( 0 );
  }

  int NumberOfRenderers = this->GetRenderWindow()->GetRenderers()->GetNumberOfItems();
  this->GetRenderWindow()->RemoveRenderer(this->GetRenderWindow()->GetRenderers()->GetFirstRenderer());
  int NumberOfRenderersTwo = this->GetRenderWindow()->GetRenderers()->GetNumberOfItems();

  int tempStop = 1;
  // useful?
  
  //this->RemoveAllDataSet();
  //   this->ImageReslice->RemoveAllInputs();
  //     this->WindowLevel->RemoveAllInputs();
  //     this->Blender->RemoveAllInputs();
  //     this->MaskFilter->RemoveAllInputs();
  // this->ImageActor       = vtkImageActor::New(); // remove inputs?
  // this->BGActor          = vtkImageActor::New();
  //  this->BGWindowLevel->RemoveAllInputs();
  
  // this->AuxInput     = this->WindowLevel->GetOutput();
  // this->ResliceInput = this->WindowLevel->GetOutput();
  // this->RemoveAllDataSet();
  // this->InternalUpdate(); 
}