NIREPvtkViewImage.cxx

Go to the documentation of this file.

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

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

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 "NIREPvtkViewImage.h"

#include "vtkObjectFactory.h"

#include "vtkProp.h"
#include "vtkTextActor.h"
#include "vtkCoordinate.h"
#include "vtkProperty.h"
#include "vtkProperty2D.h"
#include "vtkTextProperty.h"
#include "vtkScalarsToColors.h"
#include "vtkImageMapToWindowLevelColors.h"
#include "vtkImageData.h"
#include "vtkActor.h"
#include "vtkRenderWindow.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 <vtkImageAccumulate.h>
#include <vtkDoubleArray.h>
#include <vtkIntArray.h>
#include <vtkMath.h>

//#include <vtkScalarBarWidget.h>

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

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

vtkCxxRevisionMacro(NIREPvtkViewImage, "$Revision: 1.5 $");
vtkStandardNewMacro(NIREPvtkViewImage);


NIREPvtkViewImage::NIREPvtkViewImage()
{

  this->Image       = 0;
  this->MaskImage   = 0;
  this->OverlappingImage = 0;
  this->MaskLUT     = 0;
  this->Transform   = 0;
  this->LookupTable = 0;
  this->LinkWindowLevel = 1;
  this->LinkPosition    = 1;
  this->LinkZoom        = 0;
  this->FirstImage      = 1;

  this->Visibility = 1;
  this->SizeDataVisibility = 1;
  
  this->Shift = 0.0;
  this->Scale = 1.0;
  this->Level = 128.0;
  this->Window = 255.0;
  this->Zoom   = 1.0;

  this->ScalarBar = vtkScalarBarWidget::New();
  this->ScalarBar->GetScalarBarActor()->GetLabelTextProperty()->SetColor (1.0,1.0,1.0);
  this->ScalarBar->GetScalarBarActor()->GetTitleTextProperty()->SetColor (1.0,1.0,1.0);
  //this->ScalarBar->GetScalarBarActor()->SetTextPositionToPrecedeScalarBar();
  this->ScalarBar->GetScalarBarActor()->GetLabelTextProperty()->BoldOff();
  this->ScalarBar->GetScalarBarActor()->GetLabelTextProperty()->ShadowOff();
  this->ScalarBar->GetScalarBarActor()->GetLabelTextProperty()->ItalicOff();
  this->ScalarBar->GetScalarBarActor()->SetNumberOfLabels (3);
  this->ScalarBar->GetScalarBarActor()->GetLabelTextProperty()->SetFontSize (1);
  this->ScalarBar->GetScalarBarActor()->GetPositionCoordinate()->SetCoordinateSystemToNormalizedViewport();
  this->ScalarBar->GetScalarBarActor()->SetWidth (0.1);
  this->ScalarBar->GetScalarBarActor()->SetHeight (0.5);
  this->ScalarBar->GetScalarBarActor()->SetPosition (0.9,0.3);
  //this->ScalarBar->GetScalarBarActor()->GetPositionCoordinate()->SetValue ( 0.1, 0.01);
  //this->ScalarBar->GetScalarBarActor()->PickableOff();

  vtkLookupTable* bwLut = vtkLookupTable::New();
  bwLut->SetTableRange (0, 1);
  bwLut->SetSaturationRange (0, 0);
  bwLut->SetHueRange (0, 0);
  bwLut->SetValueRange (0, 1);
  bwLut->SetAlphaRange (0, 1);
  bwLut->Build();
  this->SetLookupTable (bwLut);
  bwLut->Delete();

  this->CurrentPoint[0] = 0.0;
  this->CurrentPoint[1] = 0.0;
  this->CurrentPoint[2] = 0.0;

  this->ResetWindowLevelMode = UserDefinedPercentage;
  this->WindowLevelPercentage = 0.1;

  // Increase polygon offsets to support some OpenGL drivers
  //vtkMapper::SetResolveCoincidentTopologyToPolygonOffset();
  //vtkMapper::SetResolveCoincidentTopologyPolygonOffsetParameters(10,10);

#ifdef vtkINRIA3D_USE_ITK
  this->ImageConverter = 0;
  this->ITKImage = 0;
#endif

}


NIREPvtkViewImage::~NIREPvtkViewImage()
{
  if( this->Transform )
  {
    this->Transform->Delete();
  }

  if( this->Image )
  {
    this->Image->Delete();
  }


  //this->ScalarBar->GetScalarBarActor()->Delete();
  this->ScalarBar->Delete();

  this->RemoveAllDataSet();

  this->LookupTable->Delete();

#ifdef vtkINRIA3D_USE_ITK
  this->ImageConverter = 0;
  this->ITKImage = 0;
#endif

}


void NIREPvtkViewImage::Initialize()
{
  vtkSynchronizedView::Initialize();
  this->SetLookupTable( this->GetLookupTable() );
  this->AddActor (this->ScalarBar->GetScalarBarActor());
}


void NIREPvtkViewImage::Uninitialize()
{
  this->RemoveActor (this->ScalarBar->GetScalarBarActor());
  vtkSynchronizedView::Uninitialize();
}


void NIREPvtkViewImage::RegisterImage(vtkImageData* image)
{
  if(!image)  return;

  if( image != this->Image )
  {
    if( this->Image != NULL )
    {
      this->Image->UnRegister (this);
    }

    this->Image = image;
    this->Image->Register (this);
  }
}


double NIREPvtkViewImage::GetWholeMinPosition(unsigned int p_axis)
{
  if(!this->Image)
  {
    return -VTK_LARGE_FLOAT;
  }

  return this->Image->GetBounds()[p_axis * 2];
}


double NIREPvtkViewImage::GetWholeMaxPosition(unsigned int p_axis)
{
  if(!this->Image)
  {
    return VTK_LARGE_FLOAT;
  }

  return this->Image->GetBounds()[p_axis * 2 + 1];
}


unsigned int NIREPvtkViewImage::GetOrthogonalAxis(unsigned int p_plan)
{
  assert(p_plan<NB_DIRECTION_IDS);

  switch(p_plan)
  {
      case SAGITTAL_ID:
        return X_ID;
        break;

      case CORONAL_ID:
        return Y_ID;
        break;

      case AXIAL_ID:

        return Z_ID;
        break;
  }
  return 0;
}


int NIREPvtkViewImage::GetSliceForPosition(const double pos[3], unsigned int p_plan)
{

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

  assert(p_plan < NB_DIRECTION_IDS);

  double*       spacing = this->GetImage()->GetSpacing();
  double*       origin  = this->GetImage()->GetOrigin();

  int   axis     = this->GetOrthogonalAxis(p_plan);
  double  soft_pos = pos[axis];
  
  // Treat extreme position at the end of the last pixel
  /*
    double  pos_max  = this->GetWholeMaxPosition(axis);
    double  pos_min  = this->GetWholeMinPosition(axis);
    
    if ((soft_pos > pos_max-0.005) && (soft_pos < pos_max+0.005))
    {
    soft_pos = pos_max-0.005;
    }
    if ((soft_pos > pos_min-0.005) && (soft_pos < pos_min+0.005))
    {
    soft_pos = pos_min+0.005;
    }
  */
  return (int)vtkMath::Round((soft_pos-origin[axis])/spacing[axis]);
}


int NIREPvtkViewImage::GetSlice(unsigned int p_plan)
{
  const double* pos = this->GetCurrentPoint();
  return this->GetSliceForPosition (pos, p_plan);
}


void NIREPvtkViewImage::SetSlice (unsigned int p_plan, int p_zslice)
{
  double pos[3];
  this->GetPositionForSlice (p_zslice, p_plan, pos);
  this->SetCurrentPoint(pos);
}


void NIREPvtkViewImage::GetPositionForSlice (int p_zslice, int orientation, double pos[3])
{
  
  if( !this->GetImage() )
  {
    return;
  }

  unsigned int axis = this->GetOrthogonalAxis(orientation);
  
  double* spacing = this->GetImage()->GetSpacing();
  int*    extent  = this->GetImage()->GetWholeExtent();
  double* origin  = this->GetImage()->GetOrigin();
  int     slice   = p_zslice;
  
  int dims[3];
  dims[0] = extent[1];
  dims[1] = extent[3];
  dims[2] = extent[5];
  
  if(slice >= dims[axis])  slice = dims[axis];
  if(slice <  0)           slice = 0;
  
  this->GetCurrentPoint(pos);
  pos[axis] = origin[axis] + slice * spacing[axis];
}


void NIREPvtkViewImage::SyncSetSlice(unsigned int p_plan, int p_zslice)
{
  if( this->IsLocked() )
  {
    return;
  }
  
  this->SetSlice(p_plan, p_zslice);
  
  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {
    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast (this->Children[i]);
    if( view && view->GetLinkPosition())
    {
      view->SyncSetSlice (p_plan, p_zslice);
      view->Update();
    }
  }
  this->UnLock();
}


void NIREPvtkViewImage::SyncSetZSlice(int p_zslice)
{
  if( this->IsLocked() )
  {
    return;
  }

  this->SetZSlice(p_zslice);

  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {
    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast (this->Children[i]);
    if( view && view->GetLinkPosition())
    {
      view->SyncSetZSlice (p_zslice);
      view->Update();
    }
  }
  this->UnLock();
}


void NIREPvtkViewImage::SetCurrentPoint (const double p_point[3])
{
  this->CurrentPoint[0] = p_point[0];
  this->CurrentPoint[1] = p_point[1];
  this->CurrentPoint[2] = p_point[2];
  this->UpdatePosition();
  this->InvokeEvent (NIREPvtkViewImage::ViewImagePositionChangeEvent, NULL);
}


void NIREPvtkViewImage::GetVoxelCoordinates(double pos[3], int p_coordinates[3])
{
  if(!this->Image)
  {
    return;
  }
  p_coordinates[this->GetOrthogonalAxis(SAGITTAL_ID)] = this->GetSliceForPosition(pos, SAGITTAL_ID);
  p_coordinates[this->GetOrthogonalAxis(CORONAL_ID)]  = this->GetSliceForPosition(pos, CORONAL_ID);
  p_coordinates[this->GetOrthogonalAxis(AXIAL_ID)]    = this->GetSliceForPosition(pos, AXIAL_ID);
}


void NIREPvtkViewImage::GetCurrentVoxelCoordinates(int p_coordinates[3])
{
  p_coordinates[this->GetOrthogonalAxis(SAGITTAL_ID)] = this->GetSlice(SAGITTAL_ID);
  p_coordinates[this->GetOrthogonalAxis(CORONAL_ID)]  = this->GetSlice(CORONAL_ID);
  p_coordinates[this->GetOrthogonalAxis(AXIAL_ID)]    = this->GetSlice(AXIAL_ID);
}


void NIREPvtkViewImage::SyncSetCurrentPoint(const double p_point[3])
{

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

  this->SetCurrentPoint (p_point);

  this->Lock();

  for( unsigned int i=0; i<this->Children.size(); i++)
  {
    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast( this->Children[i] );
    if( view && view->GetLinkPosition())
    {
      view->SyncSetCurrentPoint (p_point);
      view->Update();
    }
  }

  this->UnLock();

  

}


double NIREPvtkViewImage::GetCurrentPointDoubleValue ()
{
  if (!this->Image)
  {
    return -1;
  }

  int coordinates[3];
  this->GetCurrentVoxelCoordinates(coordinates);
  
  void *scalar = this->GetImage()->GetScalarPointer(coordinates);

  if( !scalar ) return -1.0;

  switch (this->GetImage()->GetScalarType()) {
  case VTK_DOUBLE:
    return (*(double*)scalar);
  case VTK_FLOAT:
    return (double) (*(float*)scalar);
  case VTK_UNSIGNED_LONG:
    return (double) (*(unsigned long*)scalar);
  case VTK_LONG:
    return (double) (*(long*)scalar);
  case VTK_UNSIGNED_INT:
    return (double) (*(unsigned int*)scalar);
  case VTK_INT:
    return (double) (*(int*)scalar);
  case VTK_UNSIGNED_SHORT:
    return (double) (*(unsigned short*)scalar);
  case VTK_SHORT:
    return (double) (*(short*)scalar);
  case VTK_UNSIGNED_CHAR:
    return (double) (*(unsigned char*)scalar);
  case VTK_CHAR:
    return (double) (*(char*)scalar);
  }
  return -1;
}


void NIREPvtkViewImage::SyncResetCurrentPoint()
{
  if( this->IsLocked() )
  {
    return;
  }

  this->ResetCurrentPoint();
  
  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {
    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast( this->Children[i] );
    if( view && view->GetLinkPosition() )
    {
      view->SyncResetCurrentPoint ();
      view->Update();
    }
  }
  this->UnLock();

}


void NIREPvtkViewImage::ResetCurrentPoint()
{

  if (!this->Image)
  {
    return;
  }
  
  double* bounds  = this->GetImage()->GetBounds();
  double  pos[3] =
    {
      (bounds[0]+bounds[1])/2.0,
      (bounds[2]+bounds[3])/2.0,
      (bounds[4]+bounds[5])/2.0
    };
  
  this->SetCurrentPoint(pos);
}


void NIREPvtkViewImage::SyncSetWindow (double w)
{
  if( this->IsLocked() )
  {
    return;
  }


  this->SetWindow (w);


  // this boolean is used so that the other observe won't call
  // SetCurrentPoint again and again and again...
  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {

    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast (this->Children[i]);

    if( view && view->GetLinkWindowLevel() )
    {
      view->SyncSetWindow (w);
      view->Update();
    }
  }

  this->UnLock();
}


void NIREPvtkViewImage::SyncStartWindowing ()
{
  if( this->IsLocked() )
  {
    return;
  }


  this->StartWindowing ();


  // this boolean is used so that the other observe won't call
  // SetCurrentPoint again and again and again...
  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {

    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast (this->Children[i]);

    if( view && view->GetLinkWindowLevel() )
    {
      view->SyncStartWindowing ();
      view->Update();
    }
  }

  this->UnLock();
}


void NIREPvtkViewImage::SyncEndWindowing ()
{
  if( this->IsLocked() )
  {
    return;
  }


  this->EndWindowing ();


  // this boolean is used so that the other observe won't call
  // SetCurrentPoint again and again and again...
  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {

    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast (this->Children[i]);

    if( view && view->GetLinkWindowLevel() )
    {
      view->SyncEndWindowing ();
      view->Update();
    }
  }

  this->UnLock();
}


void NIREPvtkViewImage::SyncSetLevel (double l)
{

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


  this->SetLevel (l);

  // this boolean is used so that the other observe won't call
  // SetCurrentPoint again and again and again...
  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {
    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast (this->Children[i]);

    if( view && view->GetLinkWindowLevel() )
    {
      view->SyncSetLevel (l);
      view->Update();
    }
  }

  this->UnLock();

}


void NIREPvtkViewImage::SetWindowLevelFrom(NIREPvtkViewImage* p_view)
{
  if (p_view)
  {
    this->SetWindow( p_view->GetWindow() );
    this->SetLevel( p_view->GetLevel() );
  }
}



void NIREPvtkViewImage::SyncResetWindowLevel()
{

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


  this->ResetWindowLevel();

  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {
    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast(this->Children[i]);
    if( view && view->GetLinkWindowLevel() )
    {
      view->SyncResetWindowLevel ();
      view->Update();
    }
  }
  this->UnLock();
}


void NIREPvtkViewImage::ResetWindowLevel()
{

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

  this->Image->UpdateInformation();
  int* extent = this->Image->GetWholeExtent();
  if( extent[0]==extent[1] && extent[2]==extent[3] && extent[4]==extent[5] ) // image has a null extent -> GetScalarRange() will crash
  {
    return;
  }
  
  this->Image->SetUpdateExtentToWholeExtent();
  this->Image->Update();
  
  
  if( this->Image->GetScalarType() == VTK_UNSIGNED_CHAR  && (this->Image->GetNumberOfScalarComponents()==3 || this->Image->GetNumberOfScalarComponents()==4) )
  {
    return;
  }


  double* range = this->Image->GetScalarRange();

  double window = range[1]-range[0];
  double level = 0.5*(range[1]+range[0]);

  if( this->ResetWindowLevelMode ==  FullRange )
  {
    // nothing to do
  }
  else if( this->ResetWindowLevelMode ==  UserDefinedPercentage )
  {

    vtkImageAccumulate* histogram = vtkImageAccumulate::New();
    histogram->SetInput ( this->Image );

    int extent[6] = {0, 1000, 0, 0, 0, 0};
    histogram->SetComponentExtent (extent);

    double spacing[3] = { (range[1]-range[0])/1000.0, 0.0, 0.0};
    histogram->SetComponentSpacing (spacing);

    double origin[3] = {range[0], 0.0, 0.0};
    histogram->SetComponentOrigin (origin);
    histogram->Update();


    vtkImageData* output = histogram->GetOutput();
    vtkIntArray*  ptData = vtkIntArray::SafeDownCast (output->GetPointData()->GetScalars());

    if( !ptData)
    {
      vtkErrorMacro( << "Error: Cannot cast point data to integers.");
      return;
    }

    double numVox = histogram->GetVoxelCount();
    double onePercent = numVox/100.0;

    int start=1;
    double currentPercent = 0.0;
    while( currentPercent<this->UserDefinedPercentage && start<1000-this->UserDefinedPercentage)
    {
      double tuple;
      ptData->GetTuple (start, &tuple);
      currentPercent += tuple/onePercent;
      start++;
    }

    currentPercent = 0.0;
    int end = 999;
    while( currentPercent<this->UserDefinedPercentage && end>0 )
    {
      double tuple;
      ptData->GetTuple (end, &tuple);
      currentPercent += tuple/onePercent;
      end--;
    }

    window = (end-start)*(range[1]-range[0])/1000.0;
    level = 0.5*(start + end)*(range[1]-range[0])/1000.0;

    histogram->Delete();
  }


  window = (window-this->GetShift())/this->GetScale();
  level = (level-this->GetShift())/this->GetScale();


  this->SetWindow ( window );
  this->SetLevel ( level );
}


bool NIREPvtkViewImage::HasDataSet (vtkDataSet* dataset)
{
  if( !dataset )
  {
    return false;
  }

  bool res = false;
  for( unsigned int i=0; i<this->DataSetList.size(); i++)
  {
    if( dataset == this->DataSetList[i] )
    {
      res = true;
      break;
    }
  }

  return res;
}


vtkActor* NIREPvtkViewImage::SyncAddDataSet (vtkDataSet* dataset,  vtkProperty* property)
{

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


  vtkActor* actor = this->AddDataSet (dataset, property);

  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {
    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast (this->Children[i]);

    if( view )
    {
      view->SyncAddDataSet (dataset, property);
    }
  }
  this->UnLock();

  return actor;
}


vtkActor* NIREPvtkViewImage::AddDataSet (vtkDataSet* dataset,  vtkProperty* property)
{
  vtkErrorMacro(<<"You should not use this function here\nPlease use vtkViewImage2D or vtkViewImage3D classes instead (or any derived class).");
  return NULL;
}


void NIREPvtkViewImage::SyncRemoveDataSet (vtkDataSet* dataset)
{

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


  this->RemoveDataSet (dataset);

  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {
    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast (this->Children[i]);

    if( view )
    {
      view->SyncRemoveDataSet (dataset);
    }
  }
  this->UnLock();

}


void NIREPvtkViewImage::RemoveDataSet (vtkDataSet* dataset)
{

  if (!dataset)
  {
    return;
  }

  std::vector<vtkActor*>   t_actorlist = this->DataSetActorList;
  std::vector<vtkDataSet*> t_datasetlist = this->DataSetList;
  this->DataSetActorList.clear();
  this->DataSetList.clear();

  for (unsigned int i=0; i<t_datasetlist.size(); i++)
  {
    if (dataset != t_datasetlist[i])
    {
      this->DataSetList.push_back (t_datasetlist[i]);
      this->DataSetActorList.push_back (t_actorlist[i]);
      }
    else
    {
      this->RemoveActor (t_actorlist[i]);
    }
  }
}


void NIREPvtkViewImage::SyncRemoveAllDataSet ()
{

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


  this->RemoveAllDataSet ();

  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {
    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast (this->Children[i]);

    if( view )
    {
      view->SyncRemoveAllDataSet ();
    }
  }
  this->UnLock();
}


void NIREPvtkViewImage::RemoveAllDataSet ()
{
  for (unsigned int i=0; i<this->DataSetActorList.size(); i++)
  {
    this->RemoveActor (this->DataSetActorList[i]);
  }
  this->DataSetActorList.clear();
  this->DataSetList.clear();

}


void NIREPvtkViewImage::SyncModifyActors(vtkDataSet* dataset, bool cellColors)
{

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


  this->ModifyActors (dataset, cellColors);


  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {
    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast (this->Children[i]);

    if( view )
    {
      view->SyncModifyActors (dataset, cellColors);
    }
  }
  this->UnLock();

}


void NIREPvtkViewImage::ModifyActors(vtkDataSet* dataset, bool cellColors)
{
  bool doit = true;


  if (!dataset)
  {
    doit = false;
  }

  vtkMapper* mapper = NULL;

  if (doit)
  {
    for (unsigned int i=0; i<this->DataSetList.size(); i++)
    {
      if (dataset == this->DataSetList[i])
      {
        mapper = this->DataSetActorList[i]->GetMapper();
        break;
      }
    }
    if (!mapper)
    {
      doit = false;
    }
  }

  if (doit)
  {
    mapper->Modified();

    if ( cellColors )
      mapper->SetScalarModeToUseCellData();
    else
      mapper->SetScalarModeToUsePointData();
  }
}


void NIREPvtkViewImage::SyncColorDataSetByArray(vtkDataSet* dataset, const char* arrayname, vtkColorTransferFunction* transfer)
{

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


  this->ColorDataSetByArray (dataset, arrayname, transfer);


  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {
    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast (this->Children[i]);

    if( view )
    {
      view->SyncColorDataSetByArray (dataset, arrayname, transfer);
    }
  }
  this->UnLock();
}


void NIREPvtkViewImage::ColorDataSetByArray(vtkDataSet* dataset, const char* arrayname, vtkColorTransferFunction* transfer)
{

  bool doit = true;
  
  if (!dataset)
  {
    doit = false;
  }

  vtkDataArray* array = NULL;
  vtkMapper* mapper = NULL;

  if (doit)
  {
    for (unsigned int i=0; i<this->DataSetList.size(); i++)
    {
      if (dataset == this->DataSetList[i])
      {
        mapper = this->DataSetActorList[i]->GetMapper();
        break;
      }
    }
    if (!mapper)
    {
      doit = false;
    }
  }

  if (doit)
  {
    mapper->Modified();

    if (dataset->GetCellData())
    {
      array = dataset->GetCellData()->GetArray (arrayname);
      if (array)
      {
        mapper->SetScalarModeToUseCellFieldData();
      }
    }

    if (!array && dataset->GetPointData())
    {
      array = dataset->GetPointData()->GetArray (arrayname);
      if (array)
      {
        mapper->SetScalarModeToUsePointFieldData();
      }

    }

    if (!array)
    {
      mapper->SetScalarModeToDefault();
      mapper->SetInterpolateScalarsBeforeMapping(0);
      doit = false;
    }
  }

  if (doit)
  {
    mapper->SetLookupTable (transfer);
    mapper->SetScalarRange (array->GetRange()[0], array->GetRange()[1]);
    mapper->SetInterpolateScalarsBeforeMapping(1);
    mapper->SelectColorArray (array->GetName());
  }
}



vtkDataSet* NIREPvtkViewImage::GetDataSet (unsigned int i)
{
  if (i<0 || i>this->DataSetList.size())
    return NULL;

  return this->DataSetList[i];
}


vtkDataSet* NIREPvtkViewImage::GetDataSetFromActor (vtkActor* actor)
{
  for (unsigned int i=0; i<this->DataSetActorList.size(); i++)
  {
    if (actor == this->DataSetActorList[i])
      return this->DataSetList[i];
  }
  return NULL;
}


vtkActor* NIREPvtkViewImage::GetDataSetActor (unsigned int i)
{
  if (i<0 || i>=this->DataSetActorList.size())
    return NULL;

  return this->DataSetActorList[i];
}


vtkActor* NIREPvtkViewImage::GetDataSetActor (vtkDataSet* dataset)
{
  if (!dataset)
    return NULL;

  for (unsigned int i=0; i<this->DataSetList.size(); i++)
  {
    if (dataset == this->DataSetList[i])
      return this->DataSetActorList[i];
  }
  return NULL;

}


void NIREPvtkViewImage::PrintSelf(ostream& os, vtkIndent indent)
{
  this->Superclass::PrintSelf(os, indent);
}


void NIREPvtkViewImage::SyncSetZoom (double factor)
{

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

  this->SetZoom (factor);

  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {
    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast (this->Children[i]);

    if( view && view->GetLinkZoom() )
    {
      view->SyncSetZoom (factor);
      view->Update();
    }
  }

  this->UnLock();
}


void NIREPvtkViewImage::SyncSetLookupTable (vtkScalarsToColors* lut)
{

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

  this->SetLookupTable (lut);

  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {
    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast (this->Children[i]);

    if( view )
    {
      view->SyncSetLookupTable (lut);
      view->Update();
    }
  }

  this->UnLock();
}


void NIREPvtkViewImage::SyncResetZoom ()
{

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

  this->ResetZoom ();

  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {
    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast (this->Children[i]);

    if( view )
    {
      if( view->GetLinkZoom() )
      {
        view->SyncResetZoom ();
        view->Update();
      }
    }
  }

  this->UnLock();
}


void NIREPvtkViewImage::ResetZoom()
{
  this->ResetCamera();
  this->Zoom = 1.0;
}


void NIREPvtkViewImage::SyncReset ()
{

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

  this->Reset ();

  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {
    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast (this->Children[i]);

    if( view )
    {
      view->SyncReset ();
      view->Update();
    }
  }

  this->UnLock();
}


void NIREPvtkViewImage::SetSizeData (const char* str)
{
  this->SizeData_str = str;
  this->Modified();
}


void NIREPvtkViewImage::SetPatientNameData (const char* str)
{
  this->PatientNameData = str;
  this->Modified();
}


void NIREPvtkViewImage::SetStudyNameData (const char* str)
{
  this->StudyNameData = str;
  this->Modified();
}


void NIREPvtkViewImage::SetSerieNameData (const char* str)
{
  this->SerieNameData = str;
  this->Modified();
}


void NIREPvtkViewImage::SetSizeDataVisibility (int val)
{
  this->SizeDataVisibility = val;
  if( val )
  {
    this->SetUpLeftAnnotation ( this->GetSizeData() );
  }
  else
  {
    this->SetUpRightAnnotation ("");
  }
  
}


void NIREPvtkViewImage::SyncSetMaskImage (vtkImageData* mask, vtkLookupTable* lut)
{

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

  this->SetMaskImage (mask, lut);

  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {
    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast (this->Children[i]);

    if( view )
    {
      view->SyncSetMaskImage (mask, lut);
      view->Update();
    }
  }

  this->UnLock();
}


void NIREPvtkViewImage::SyncSetOverlappingImage (vtkImageData* image)
{

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

  this->SetOverlappingImage (image);

  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {
    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast (this->Children[i]);

    if( view )
    {
      view->SyncSetOverlappingImage (image);
      view->Update();
    }
  }

  this->UnLock();
}



void NIREPvtkViewImage::SyncRemoveMaskImage ()
{

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

  this->RemoveMaskImage ();

  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {
    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast (this->Children[i]);

    if( view )
    {
      view->SyncRemoveMaskImage ();
      view->Update();
    }
  }

  this->UnLock();
}


void NIREPvtkViewImage::SyncRemoveOverlappingImage ()
{

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

  this->RemoveOverlappingImage ();

  this->Lock();
  for( unsigned int i=0; i<this->Children.size(); i++)
  {
    NIREPvtkViewImage* view = NIREPvtkViewImage::SafeDownCast (this->Children[i]);

    if( view )
    {
      view->SyncRemoveOverlappingImage ();
      view->Update();
    }
  }

  this->UnLock();
}


#ifdef vtkINRIA3D_USE_ITK

void NIREPvtkViewImage::SetITKImage (itk::Image<double, 3>::Pointer itkImage)
{
  if( itkImage.IsNull() )
  {
    return;
  }

  typedef itk::ImageToVTKImageFilter< itk::Image<double, 3> > ConverterType;
  ConverterType::Pointer myConverter = ConverterType::New();
  myConverter->SetInput ( itkImage );
  myConverter->Update();
  

  this->SetImage ( myConverter->GetOutput() );

  this->ImageConverter = myConverter;
  this->ITKImage = itkImage;

}


void NIREPvtkViewImage::SetITKImage (itk::Image<float, 3>::Pointer itkImage)
{
  if( itkImage.IsNull() )
  {
    return;
  }
  /*
  typedef itk::Image<float, 3>           ImageType;
  typedef itk::FlipImageFilter<ImageType> FlipFilerType;

  FlipFilerType::FlipAxesArrayType axesFlip;
  axesFlip.Fill (0);
  
  if (itkImage->GetDirection()(0,0) < 0 )
    axesFlip[0] = 1;
  if (itkImage->GetDirection()(1,1) < 0 )
    axesFlip[1] = 1;
  if (itkImage->GetDirection()(2,2) < 0 )
    axesFlip[2] = 1;

  std::cout << itkImage << std::endl;

  std::cout << "Flipping along: " << axesFlip[0] << " " << axesFlip[1] << " " << axesFlip[2] << std::endl;
  getchar();
  
  FlipFilerType::Pointer fliper = FlipFilerType::New();
  fliper->SetInput ( itkImage );
  fliper->SetFlipAxes ( axesFlip );
  try
  {
    fliper->Update();
  }
  catch (itk::ExceptionObject &e )
  {
    std::cerr << e;
    return;
  }
  ImageType::Pointer image = fliper->GetOutput();
  std::cout << image << std::endl;
  */
  
  typedef itk::ImageToVTKImageFilter< itk::Image<float, 3> > ConverterType;
  ConverterType::Pointer myConverter = ConverterType::New();
  myConverter->SetInput ( itkImage );
  myConverter->Update();

  this->SetImage ( myConverter->GetOutput() );

  this->ImageConverter = myConverter;
  this->ITKImage = itkImage;
}

void NIREPvtkViewImage::SetITKImage (itk::Image<int, 3>::Pointer itkImage)
{
  if( itkImage.IsNull() )
  {
    return;
  }

  typedef itk::ImageToVTKImageFilter< itk::Image<int, 3> > ConverterType;
  ConverterType::Pointer myConverter = ConverterType::New();
  myConverter->SetInput ( itkImage );
  myConverter->Update();

  this->SetImage ( myConverter->GetOutput() );

  this->ImageConverter = myConverter;
  this->ITKImage = itkImage;
}


void NIREPvtkViewImage::SetITKImage (itk::Image<unsigned int, 3>::Pointer itkImage)
{
  if( itkImage.IsNull() )
  {
    return;
  }

  typedef itk::ImageToVTKImageFilter< itk::Image<unsigned int, 3> > ConverterType;
  ConverterType::Pointer myConverter = ConverterType::New();
  myConverter->SetInput ( itkImage );
  myConverter->Update();

  this->SetImage ( myConverter->GetOutput() );

  this->ImageConverter = myConverter;
  this->ITKImage = itkImage;
}


void NIREPvtkViewImage::SetITKImage (itk::Image<short, 3>::Pointer itkImage)
{
  if( itkImage.IsNull() )
  {
    return;
  }
  
  typedef itk::ImageToVTKImageFilter< itk::Image<short, 3> > ConverterType;
  ConverterType::Pointer myConverter = ConverterType::New();
  myConverter->SetInput ( itkImage );
  myConverter->Update();

  this->SetImage ( myConverter->GetOutput() );

  this->ImageConverter = myConverter;
  this->ITKImage = itkImage;
}

void NIREPvtkViewImage::SetITKImage (itk::Image<unsigned short, 3>::Pointer itkImage)
{
  if( itkImage.IsNull() )
  {
    return;
  }

  typedef itk::ImageToVTKImageFilter< itk::Image<unsigned short, 3> > ConverterType;
  ConverterType::Pointer myConverter = ConverterType::New();
  myConverter->SetInput ( itkImage );
  myConverter->Update();

  this->SetImage ( myConverter->GetOutput() );

  this->ImageConverter = myConverter;
  this->ITKImage = itkImage;
}


void NIREPvtkViewImage::SetITKImage (itk::Image<char, 3>::Pointer itkImage)
{
  if( itkImage.IsNull() )
  {
    return;
  }
  
  typedef itk::ImageToVTKImageFilter< itk::Image<char, 3> > ConverterType;
  ConverterType::Pointer myConverter = ConverterType::New();
  myConverter->SetInput ( itkImage );
  myConverter->Update();

  this->SetImage ( myConverter->GetOutput() );

  this->ImageConverter = myConverter;
  this->ITKImage = itkImage;
}


void NIREPvtkViewImage::SetITKImage (itk::Image<unsigned char, 3>::Pointer itkImage)
{
  if( itkImage.IsNull() )
  {
    return;
  }

  typedef itk::ImageToVTKImageFilter< itk::Image<unsigned char, 3> > ConverterType;
  ConverterType::Pointer myConverter = ConverterType::New();
  myConverter->SetInput ( itkImage );
  myConverter->Update();

  this->SetImage ( myConverter->GetOutput() );

  this->ImageConverter = myConverter;
  this->ITKImage = itkImage;
}

void NIREPvtkViewImage::SetITKImage (itk::Image<long, 3>::Pointer itkImage)
{
  if( itkImage.IsNull() )
  {
    return;
  }

  typedef itk::ImageToVTKImageFilter< itk::Image<long, 3> > ConverterType;
  ConverterType::Pointer myConverter = ConverterType::New();
  myConverter->SetInput ( itkImage );
  myConverter->Update();

  this->SetImage ( myConverter->GetOutput() );

  this->ImageConverter = myConverter;
  this->ITKImage = itkImage;
}

void NIREPvtkViewImage::SetITKImage (itk::Image<unsigned long, 3>::Pointer itkImage)
{
  if( itkImage.IsNull() )
  {
    return;
  }

  typedef itk::ImageToVTKImageFilter< itk::Image<unsigned long, 3> > ConverterType;
  ConverterType::Pointer myConverter = ConverterType::New();
  myConverter->SetInput ( itkImage );
  myConverter->Update();

  this->SetImage ( myConverter->GetOutput() );

  this->ImageConverter = myConverter;
  this->ITKImage = itkImage;
}

itk::ImageBase<3>* NIREPvtkViewImage::GetITKImage (void) const
{
  return this->ITKImage;
}

#endif