X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=vv%2FvvSlicerManager.cxx;h=813ba2258bc1f2b247b342f9176e5b2be8f91a4b;hb=9794609d9607a3bc76aec1d10fb58bcb9aed4357;hp=4ba327b91c745444d1a80746033adbb90d286e47;hpb=26c6b8e9d0333a9e0be98c3fb9d57f133477d97d;p=clitk.git

diff --git a/vv/vvSlicerManager.cxx b/vv/vvSlicerManager.cxx
index 4ba327b..813ba22 100644
--- a/vv/vvSlicerManager.cxx
+++ b/vv/vvSlicerManager.cxx
@@ -1,7 +1,7 @@
-  /*=========================================================================
+/*=========================================================================
   Program:   vv                     http://www.creatis.insa-lyon.fr/rio/vv
 
-  Authors belong to: 
+  Authors belong to:
   - University of LYON              http://www.universite-lyon.fr/
   - Léon Bérard cancer center       http://oncora1.lyon.fnclcc.fr
   - CREATIS CNRS laboratory         http://www.creatis.insa-lyon.fr
@@ -22,8 +22,6 @@
 #include "vvSlicerManagerCommand.h"
 #include "vvInteractorStyleNavigator.h"
 #include "vvLandmarks.h"
-#include "vvImageReader.h"
-#include "vvImageReader.h"
 #include "vvMesh.h"
 #include "vvImageMapToWLColors.h"
 #include "vvBlendImageActor.h"
@@ -40,6 +38,9 @@
 #include <vtkLODActor.h>
 #include <vtkPointData.h>
 #include <vtksys/SystemTools.hxx>
+#include <vtkCamera.h>
+
+#include <qfileinfo.h>
 
 //----------------------------------------------------------------------------
 vvSlicerManager::vvSlicerManager(int numberOfSlicers)
@@ -51,29 +52,23 @@ vvSlicerManager::vvSlicerManager(int numberOfSlicers)
   mFusionName = "";
   mVFId = "";
   mLastError = "";
-  mType = UNDEFINEDIMAGETYPE;
+  mType = vvImageReader::UNDEFINEDIMAGETYPE;
   mColorMap = 0;
   mPreset = 0;
   mOverlayColor = 130;
 
-  mFusionOpacity = 70;
+  mFusionOpacity = 30;
+  mFusionThresOpacity = 1;
   mFusionColorMap = 3;
   mFusionWindow = 1000;
   mFusionLevel = 1000;
 
-  mReader = NULL;
-  mImage = NULL;
-  mVF=NULL;
-  mVectorReader = NULL;
-  mOverlayReader = NULL;
-  mFusionReader = NULL;
   mLandmarks = NULL;
   mLinkedId.resize(0);
 
-  for ( int i = 0; i < numberOfSlicers; i++) {
-    vvSlicer *slicer = vvSlicer::New();
-    mSlicers.push_back(slicer);
-  }
+  for ( int i = 0; i < numberOfSlicers; i++)
+    mSlicers.push_back(vtkSmartPointer<vvSlicer>::New());
+
   mPreviousSlice.resize(numberOfSlicers);
   mPreviousTSlice.resize(numberOfSlicers);
 }
@@ -83,27 +78,6 @@ vvSlicerManager::vvSlicerManager(int numberOfSlicers)
 //----------------------------------------------------------------------------
 vvSlicerManager::~vvSlicerManager()
 {
-  for ( unsigned int i = 0; i < mSlicers.size(); i++)
-    {
-      if (mSlicers[i] != NULL)
-	mSlicers[i]->Delete();
-    }
-  if (mReader)
-    {
-      delete mReader;
-    }
-  if (mVectorReader)
-    {
-      delete mVectorReader;
-    }
-  if (mOverlayReader)
-    {
-      delete mOverlayReader;
-    }
-  if (mFusionReader)
-    {
-      delete mFusionReader;
-    }
   if (mLandmarks)
     delete mLandmarks;
 }
@@ -111,11 +85,23 @@ vvSlicerManager::~vvSlicerManager()
 
 
 //------------------------------------------------------------------------------
-void vvSlicerManager::SetFilename(std::string f) {
-  mFileName = f;
+void vvSlicerManager::SetFilename(std::string filename, int number)
+{
+  mFileName = filename;
+  mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
+  mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
+  mBaseFileNameNumber = number;
+
+  mFileName = mBaseFileName;
+  if (number != 0) {
+    mFileName.append("_"+clitk::toString(number));
+  }
+  mFileName.append(vtksys::SystemTools::GetFilenameLastExtension(filename));
+
   for(unsigned int i=0; i<mSlicers.size(); i++) {
-    mSlicers[i]->SetFileName(f);
+    mSlicers[i]->SetFileName(mFileName);//vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
   }
+  
 }
 //------------------------------------------------------------------------------
 
@@ -123,10 +109,9 @@ void vvSlicerManager::SetFilename(std::string f) {
 //----------------------------------------------------------------------------
 void vvSlicerManager::AddContour(vvMesh::Pointer contour,bool propagate)
 {
-  for ( unsigned int i = 0; i < mSlicers.size(); i++)
-    {
-      mSlicers[i]->AddContour(contour,propagate);
-    }
+  for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+    mSlicers[i]->AddContour(contour,propagate);
+  }
 }
 //----------------------------------------------------------------------------
 
@@ -139,43 +124,65 @@ void vvSlicerManager::ToggleContourSuperposition()
 }
 //----------------------------------------------------------------------------
 
+//----------------------------------------------------------------------------
+std::string vvSlicerManager::GetListOfAbsoluteFilePathInOneString(const std::string &actorType)
+{
+  vvImageReader *reader = NULL;
+
+  if(actorType=="image")
+    reader = mReader;
+  else if(actorType=="overlay")
+    reader = mOverlayReader;
+  else if(actorType=="fusion")
+    reader = mFusionReader;
+  else if(actorType=="vector")
+    reader = mVectorReader;
+
+  if(!reader)
+    return "";
+
+  std::string list;
+  for(unsigned int i=0; i<reader->GetInputFilenames().size(); i++){
+    QFileInfo fileinfo(reader->GetInputFilenames()[i].c_str()); //Do not show the path
+    if(i)
+      list += '\n';
+    list += fileinfo.absoluteFilePath().toStdString();
+  }
+  return list;
+}
+//----------------------------------------------------------------------------
+
 
 //----------------------------------------------------------------------------
-bool vvSlicerManager::SetImage(std::string filename, LoadedImageType type, int n)
+bool vvSlicerManager::SetImage(std::string filename, vvImageReader::LoadedImageType type, int n, unsigned int slice)
 {
-  mFileName = filename;
   mType = type;
-  if (mReader == NULL)
-    mReader = new vvImageReader;
+  if (mReader.IsNull())
+    mReader = vvImageReader::New();
   std::vector<std::string> filenames;
   filenames.push_back(filename);
   mReader->SetInputFilenames(filenames);
+  mReader->SetSlice(slice); // Only used for SLICED type
   mReader->Update(type);
 
-  mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
-  mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
-  //  DD(mBaseFileName);
-  mBaseFileNameNumber = n;
+  SetFilename(filename, n);
+  //  mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
+  //mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
+  //mBaseFileNameNumber = n;
 
-  if (mReader->GetLastError().size() == 0)
-    {
-      mImage=mReader->GetOutput();
-      for ( unsigned int i = 0; i < mSlicers.size(); i++)
-        {
-	  mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
-	  mSlicers[i]->SetImage(mReader->GetOutput());
-          //          DD(mSlicers[i]->GetFileName());
-        }
+  if (mReader->GetLastError().size() == 0) {
+    mImage=mReader->GetOutput();
+    for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+      mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
+      mSlicers[i]->SetImage(mReader->GetOutput());
     }
-  else
-    {
-      mLastError = mReader->GetLastError();
-      return false;
-    }
-  if (n!=0) {
-    //    DD(mFileName);
-    mFileName.append("_"+clitk::toString(n));
+  } else {
+    mLastError = mReader->GetLastError();
+    return false;
   }
+  // if (n!=0) {
+  //   mFileName.append("_"+clitk::toString(n));
+  // }
   return true;
 }
 //----------------------------------------------------------------------------
@@ -185,55 +192,47 @@ bool vvSlicerManager::SetImage(std::string filename, LoadedImageType type, int n
 void vvSlicerManager::SetImage(vvImage::Pointer image)
 {
   mImage=image;
-  for (unsigned int i = 0; i < mSlicers.size();i++)
-    {
-      mSlicers[i]->SetImage(image);
-    }
+  for (unsigned int i = 0; i < mSlicers.size(); i++) {
+    mSlicers[i]->SetImage(image);
+  }
 }
 //----------------------------------------------------------------------------
 
 
 //----------------------------------------------------------------------------
-bool vvSlicerManager::SetImages(std::vector<std::string> filenames,LoadedImageType type, int n)
+bool vvSlicerManager::SetImages(std::vector<std::string> filenames, vvImageReader::LoadedImageType type, int n)
 {
   mType = type;
   std::string fileWithoutExtension = vtksys::SystemTools::GetFilenameWithoutExtension(filenames[0]);
-  if (type == DICOM)
+  if (type == vvImageReader::DICOM)
     fileWithoutExtension += "_dicom";
-  else if (type == MERGED)
+  else if (type == vvImageReader::MERGED)
     fileWithoutExtension += "_merged";
-  else if (type == MERGEDWITHTIME)
+  else if (type == vvImageReader::MERGEDWITHTIME)
     fileWithoutExtension += "_merged_wt";
 
   mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
   mFileName = fileWithoutExtension + vtksys::SystemTools::GetFilenameExtension(filenames[0]);
-  if (mReader == NULL)
-    mReader = new vvImageReader;
+  if (mReader.IsNull())
+    mReader = vvImageReader::New();
   mReader->SetInputFilenames(filenames);
   mReader->Update(type);
 
   mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
-  //  DD(mBaseFileName);
   mBaseFileNameNumber = n;
 
-  if (mReader->GetLastError().size() == 0)
-    {
-      mImage=mReader->GetOutput();
-      for ( unsigned int i = 0; i < mSlicers.size(); i++)
-        {
-	  mSlicers[i]->SetFileName(fileWithoutExtension);
-	  mSlicers[i]->SetImage(mReader->GetOutput());
-        }
-    }
-  else
-    {
-      mLastError = mReader->GetLastError();
-      return false;
+  if (mReader->GetLastError().size() == 0) {
+    mImage=mReader->GetOutput();
+    for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+      mSlicers[i]->SetFileName(fileWithoutExtension);
+      mSlicers[i]->SetImage(mReader->GetOutput());
     }
+  } else {
+    mLastError = mReader->GetLastError();
+    return false;
+  }
   if (n!=0) {
-    //    DD(mFileName);
     mFileName.append("_"+clitk::toString(n));
-    //    DD(mFileName);
   }
   return true;
 }
@@ -245,29 +244,24 @@ bool vvSlicerManager::SetOverlay(std::string filename,int dim, std::string compo
 {
   mOverlayName = filename;
   mOverlayComponent = component;
-  if (dim > mImage->GetNumberOfDimensions())
-    {
-      mLastError = " Overlay dimension cannot be greater then reference image!";
-      return false;
-    }
-  if (mOverlayReader == NULL)
-    mOverlayReader = new vvImageReader;
+  if (dim > mImage->GetNumberOfDimensions()) {
+    mLastError = " Overlay dimension cannot be greater then reference image!";
+    return false;
+  }
+  if (mOverlayReader.IsNull())
+    mOverlayReader = vvImageReader::New();
   std::vector<std::string> filenames;
   filenames.push_back(filename);
   mOverlayReader->SetInputFilenames(filenames);
   mOverlayReader->Update(mImage->GetNumberOfDimensions(),component.c_str(),mType);
-  if (mOverlayReader->GetLastError().size() == 0)
-    {
-      for ( unsigned int i = 0; i < mSlicers.size(); i++)
-        {
-	  mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
-        }
-    }
-  else
-    {
-      mLastError = mOverlayReader->GetLastError();
-      return false;
+  if (mOverlayReader->GetLastError().size() == 0) {
+    for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+      mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
     }
+  } else {
+    mLastError = mOverlayReader->GetLastError();
+    return false;
+  }
   return true;
 }
 //----------------------------------------------------------------------------
@@ -278,32 +272,28 @@ bool vvSlicerManager::SetFusion(std::string filename,int dim, std::string compon
 {
   mFusionName = filename;
   mFusionComponent = component;
-  if (dim > mImage->GetNumberOfDimensions())
-    {
-      mLastError = " Overlay dimension cannot be greater then reference image!";
-      return false;
-    }
-  if (mFusionReader == NULL)
-    mFusionReader = new vvImageReader;
+  if (dim > mImage->GetNumberOfDimensions()) {
+    mLastError = " Overlay dimension cannot be greater then reference image!";
+    return false;
+  }
+  if (mFusionReader.IsNull())
+    mFusionReader = vvImageReader::New();
   std::vector<std::string> filenames;
   filenames.push_back(filename);
   mFusionReader->SetInputFilenames(filenames);
   mFusionReader->Update(mImage->GetNumberOfDimensions(),component.c_str(),mType);
-  if (mFusionReader->GetLastError().size() == 0)
-    {
-      for ( unsigned int i = 0; i < mSlicers.size(); i++)
-        {
-	  mSlicers[i]->SetFusion(mFusionReader->GetOutput());
-        }
-    }
-  else
-    {
-      mLastError = mFusionReader->GetLastError();
-      return false;
+  if (mFusionReader->GetLastError().size() == 0) {
+    for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+      mSlicers[i]->SetFusion(mFusionReader->GetOutput());
     }
+  } else {
+    mLastError = mFusionReader->GetLastError();
+    return false;
+  }
   double *fusRange = mFusionReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
   mFusionLevel = (fusRange[0]+fusRange[1])/2;
   mFusionWindow = fusRange[1]-fusRange[0];
+
   return true;
 }
 //----------------------------------------------------------------------------
@@ -312,16 +302,18 @@ bool vvSlicerManager::SetFusion(std::string filename,int dim, std::string compon
 //----------------------------------------------------------------------------
 bool vvSlicerManager::SetVF(std::string filename)
 {
-  if (mVectorReader == NULL)
-    mVectorReader = new vvImageReader;
+  if (mVectorReader.IsNull())
+    mVectorReader = vvImageReader::New();
   mVectorReader->SetInputFilename(filename);
-  mVectorReader->Update(VECTORFIELD);
-  if (mVectorReader->GetLastError().size() != 0)
-    {
-      mLastError = mVectorReader->GetLastError();
-      return false;
-    }
+  
+  if (mType == vvImageReader::IMAGEWITHTIME)
+    mVectorReader->Update(vvImageReader::VECTORFIELDWITHTIME);
   else
+    mVectorReader->Update(vvImageReader::VECTORFIELD);
+  if (mVectorReader->GetLastError().size() != 0) {
+    mLastError = mVectorReader->GetLastError();
+    return false;
+  } else
     return SetVF(mVectorReader->GetOutput(),filename);
 }
 //----------------------------------------------------------------------------
@@ -335,10 +327,6 @@ bool vvSlicerManager::SetVF(vvImage::Pointer vf,std::string filename)
     return false;
   }
   if (vf->GetNumberOfDimensions() == 4) {
-    // DD(vf->GetSpacing()[3]);
-    //     DD(mImage->GetSpacing()[3]);
-    //     DD(vf->GetOrigin()[3]);
-    //     DD(mImage->GetOrigin()[3]);    
     if (vf->GetSpacing()[3] != mImage->GetSpacing()[3]) {
       mLastError = "Sorry, vector field time spacing cannot be different from time spacing of the reference image.";
       return false;
@@ -358,40 +346,6 @@ bool vvSlicerManager::SetVF(vvImage::Pointer vf,std::string filename)
 //----------------------------------------------------------------------------
 
 
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetExtractedImage(std::string filename,vvImage::Pointer image, int slice)
-{
-  mFileName = filename;
-  mImage = vvImage::New();
-  if (image->GetNumberOfDimensions() == 4)
-    {
-      mImage->AddImage(image->GetVTKImages()[slice]);
-      for ( unsigned int i = 0; i < mSlicers.size(); i++)
-        {
-	  mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
-	  mSlicers[i]->SetImage(mImage);
-        }
-    }
-  else
-    {
-      vtkImageClip* clipper = vtkImageClip::New();
-      int extent[6];
-      image->GetVTKImages()[0]->GetWholeExtent(extent);
-      clipper->SetInput(image->GetVTKImages()[0]);
-      clipper->SetOutputWholeExtent(extent[0],extent[1],extent[2],extent[3],slice,slice);
-      clipper->Update();
-      mImage->AddImage(clipper->GetOutput());
-      for ( unsigned int i = 0; i < mSlicers.size(); i++)
-        {
-	  mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
-	  mSlicers[i]->SetImage(mImage);
-        }
-      clipper->Delete();
-    }
-}
-//----------------------------------------------------------------------------
-
-
 //----------------------------------------------------------------------------
 vvSlicer* vvSlicerManager::GetSlicer(int i)
 {
@@ -448,18 +402,28 @@ void vvSlicerManager::SetInteractorStyleNavigator(int i, vtkInteractorStyle* sty
   // mSlicers[i]->GetRenderWindow()->GetInteractor()->
   //   GetInteractorStyle()->AddObserver(vtkCommand::LeftButtonReleaseEvent, smc);
   mSlicers[i]->GetRenderWindow()->GetInteractor()->
-     GetInteractorStyle()->AddObserver(vtkCommand::EndPickEvent, smc);
+    GetInteractorStyle()->AddObserver(vtkCommand::EndPickEvent, smc);
+  mSlicers[i]->GetRenderWindow()->GetInteractor()->
+    GetInteractorStyle()->AddObserver(vtkCommand::EndInteractionEvent, smc);
   smc->Delete();
 }
 //----------------------------------------------------------------------------
 
 
 //----------------------------------------------------------------------------
-void vvSlicerManager::LeftButtonReleaseEvent(int slicer) {
+void vvSlicerManager::LeftButtonReleaseEvent(int slicer)
+{
   emit LeftButtonReleaseSignal(slicer);
 }
 //----------------------------------------------------------------------------
 
+//----------------------------------------------------------------------------
+void vvSlicerManager::SetSliceOrientation(int slicer, int orientation)
+{
+  mSlicers[slicer]->SetSliceOrientation(orientation);
+  emit UpdateOrientation(slicer, orientation);
+}
+//----------------------------------------------------------------------------
 
 //----------------------------------------------------------------------------
 void vvSlicerManager::SetTSlice(int slice)
@@ -470,14 +434,12 @@ void vvSlicerManager::SetTSlice(int slice)
     slice = mSlicers[0]->GetTMax();
   if (mLandmarks)
     mLandmarks->SetTime(slice);
-  for ( unsigned int i = 0; i < mSlicers.size(); i++)
-    {
-      if (slice != mSlicers[i]->GetTSlice()) {
-        mSlicers[i]->SetTSlice(slice);
-        if (mSlicers[i]->GetImageActor()->GetVisibility())
-          UpdateTSlice(i);
-      }
+  for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+    if (slice != mSlicers[i]->GetTSlice()) {
+      mSlicers[i]->SetTSlice(slice);
+        UpdateTSlice(i);
     }
+  }
 }
 //----------------------------------------------------------------------------
 
@@ -489,9 +451,7 @@ void vvSlicerManager::SetNextTSlice(int originating_slicer)
   t++;
   if (t > mSlicers[0]->GetTMax())
     t = 0;
-  // DD("SetNextTSlice");
-//   DD(originating_slicer);
-//   DD(t);
+  //std::cout << "vvSlicerManager::SetNextTSlice" << std::endl;
   emit UpdateTSlice(originating_slicer,t);
 }
 //----------------------------------------------------------------------------
@@ -504,6 +464,7 @@ void vvSlicerManager::SetPreviousTSlice(int originating_slicer)
   t--;
   if (t < 0)
     t = mSlicers[0]->GetTMax();
+  //std::cout << "vvSlicerManager::SetPreviousTSlice" << std::endl;
   emit UpdateTSlice(originating_slicer,t);
 }
 //----------------------------------------------------------------------------
@@ -513,10 +474,13 @@ void vvSlicerManager::SetPreviousTSlice(int originating_slicer)
 void vvSlicerManager::ToggleInterpolation()
 {
   bool interpolate=!(mSlicers[0]->GetImageActor()->GetInterpolate());
-  for ( unsigned int i = 0; i < mSlicers.size(); i++)
-    {
-      mSlicers[i]->GetImageActor()->SetInterpolate(interpolate);
-    }
+  for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+    mSlicers[i]->GetImageActor()->SetInterpolate(interpolate);
+    if (mSlicers[i]->GetOverlayActor())
+      mSlicers[i]->GetOverlayActor()->SetInterpolate(interpolate);
+    if (mSlicers[i]->GetFusionActor())
+      mSlicers[i]->GetFusionActor()->SetInterpolate(interpolate);
+  }
 }
 //----------------------------------------------------------------------------
 
@@ -534,8 +498,7 @@ void vvSlicerManager::SetTSliceInSlicer(int tslice, int slicer)
   if (mSlicers[slicer]->GetTSlice() == tslice) return;
 
   mSlicers[slicer]->SetTSlice(tslice);
-  if (mSlicers[slicer]->GetImageActor()->GetVisibility())
-    UpdateTSlice(slicer);
+  UpdateTSlice(slicer);
 }
 //----------------------------------------------------------------------------
 
@@ -543,34 +506,57 @@ void vvSlicerManager::SetTSliceInSlicer(int tslice, int slicer)
 //----------------------------------------------------------------------------
 void vvSlicerManager::SetColorWindow(double s)
 {
-  for ( unsigned int i = 0; i < mSlicers.size(); i++)
-    {
-      mSlicers[i]->SetColorWindow(s);
-    }
+  for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+    mSlicers[i]->SetColorWindow(s);
+  }
 }
 //----------------------------------------------------------------------------
 
-
 //----------------------------------------------------------------------------
 void vvSlicerManager::SetColorLevel(double s)
 {
-  for ( unsigned int i = 0; i < mSlicers.size(); i++)
-    {
-      mSlicers[i]->SetColorLevel(s);
-    }
+  for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+    mSlicers[i]->SetColorLevel(s);
+  }
 }
 //----------------------------------------------------------------------------
 
 //----------------------------------------------------------------------------
-void vvSlicerManager::SetCursorVisibility(int s)
+void vvSlicerManager::SetOverlayColorWindow(double s)
 {
-  for ( unsigned int i = 0; i < mSlicers.size(); i++)
-    {
-      mSlicers[i]->SetCursorVisibility(s);
-    }
+  for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+    mSlicers[i]->SetOverlayColorWindow(s);
+  }
+}
+//----------------------------------------------------------------------------
+
+//----------------------------------------------------------------------------
+void vvSlicerManager::SetOverlayColorLevel(double s)
+{
+  for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+    mSlicers[i]->SetOverlayColorLevel(s);
+  }
 }
 //----------------------------------------------------------------------------
 
+//----------------------------------------------------------------------------
+void vvSlicerManager::SetLinkOverlayWindowLevel(bool b)
+{
+  for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+    mSlicers[i]->SetLinkOverlayWindowLevel(b);
+  }
+}
+//----------------------------------------------------------------------------
+
+//----------------------------------------------------------------------------
+void vvSlicerManager::SetCursorAndCornerAnnotationVisibility(int s)
+{
+  for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+    mSlicers[i]->SetCursorVisibility(s);
+    mSlicers[i]->SetCornerAnnotationVisibility(s);
+  }
+}
+//----------------------------------------------------------------------------
 
 //----------------------------------------------------------------------------
 void vvSlicerManager::SetOpacity(int i, double factor)
@@ -583,10 +569,6 @@ void vvSlicerManager::SetOpacity(int i, double factor)
 //----------------------------------------------------------------------------
 void vvSlicerManager::UpdateViews(int current,int slicer)
 {
-  // DD("UpdateViews");
-//   DD(current);
-//   DD(slicer);
-
   double x = (mSlicers[slicer]->GetCurrentPosition()[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
     /mSlicers[slicer]->GetInput()->GetSpacing()[0];
   double y = (mSlicers[slicer]->GetCurrentPosition()[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
@@ -599,86 +581,69 @@ void vvSlicerManager::UpdateViews(int current,int slicer)
       y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
       y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
       z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
-      z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5])
-    {
-      mSlicers[slicer]->UpdateCursorPosition();
-      mSlicers[slicer]->SetCursorColor(10,212,255);
+      z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]) {
+    mSlicers[slicer]->UpdateCursorPosition();
+    mSlicers[slicer]->SetCursorColor(10,212,255);
+
+    switch (mSlicers[slicer]->GetSliceOrientation()) {
+    case vtkImageViewer2::SLICE_ORIENTATION_XY:
+      if (mSlicers[slicer]->GetSlice() != (int)floor(z))
+        mSlicers[slicer]->SetSlice((int)floor(z));
+      break;
+
+    case vtkImageViewer2::SLICE_ORIENTATION_XZ:
+      if (mSlicers[slicer]->GetSlice() != (int)floor(y))
+        mSlicers[slicer]->SetSlice((int)floor(y));
+      break;
 
-      switch (mSlicers[slicer]->GetSliceOrientation())
-        {
+    case vtkImageViewer2::SLICE_ORIENTATION_YZ:
+      if (mSlicers[slicer]->GetSlice() != (int)floor(x))
+        mSlicers[slicer]->SetSlice((int)floor(x));
+      break;
+    }
+    mSlicers[slicer]->Render();
+
+    for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+      if (i != (unsigned int)slicer
+          && mSlicers[i]->GetRenderer()->GetDraw()
+          && mSlicers[i]->GetRenderWindow()->GetSize()[0] > 2
+          && mSlicers[i]->GetRenderWindow()->GetSize()[1] > 2) {
+        mSlicers[i]->SetCurrentPosition(mSlicers[slicer]->GetCurrentPosition()[0],
+                                        mSlicers[slicer]->GetCurrentPosition()[1],
+                                        mSlicers[slicer]->GetCurrentPosition()[2],
+                                        mSlicers[slicer]->GetTSlice());
+        mSlicers[i]->UpdateCursorPosition();
+        if (current) { //do not display corner annotation if image is the one picked
+          mSlicers[i]->SetCurrentPosition(-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX,
+                                          -VTK_DOUBLE_MAX, mSlicers[slicer]->GetTSlice());
+          mSlicers[i]->SetCursorColor(255,10,212);
+        } else {
+          mSlicers[i]->SetCursorColor(150,10,282);
+        }
+        switch (mSlicers[i]->GetSliceOrientation()) {
         case vtkImageViewer2::SLICE_ORIENTATION_XY:
-	  if (mSlicers[slicer]->GetSlice() == (int)floor(z))
-	    mSlicers[slicer]->Render();
-	  else
-	    mSlicers[slicer]->SetSlice((int)floor(z));
-	  break;
+          if (mSlicers[i]->GetSlice() != (int)floor(z))
+            mSlicers[i]->SetSlice((int)floor(z));
+          break;
 
         case vtkImageViewer2::SLICE_ORIENTATION_XZ:
-	  if (mSlicers[slicer]->GetSlice() == (int)floor(y))
-	    mSlicers[slicer]->Render();
-	  else
-	    mSlicers[slicer]->SetSlice((int)floor(y));
-	  break;
+          if (mSlicers[i]->GetSlice() != (int)floor(y))
+            mSlicers[i]->SetSlice((int)floor(y));
+          break;
 
         case vtkImageViewer2::SLICE_ORIENTATION_YZ:
-	  if (mSlicers[slicer]->GetSlice() == (int)floor(x))
-	    mSlicers[slicer]->Render();
-	  else
-	    mSlicers[slicer]->SetSlice((int)floor(x));
-	  break;
-        }
-
-      for ( unsigned int i = 0; i < mSlicers.size(); i++)
-        {
-	  if (i != (unsigned int)slicer && mSlicers[i]->GetImageActor()->GetVisibility()
-	      && mSlicers[i]->GetRenderWindow()->GetSize()[0] > 2
-	      && mSlicers[i]->GetRenderWindow()->GetSize()[1] > 2)
-            {
-	      mSlicers[i]->SetCurrentPosition(mSlicers[slicer]->GetCurrentPosition()[0],
-					      mSlicers[slicer]->GetCurrentPosition()[1],
-					      mSlicers[slicer]->GetCurrentPosition()[2],
-					      mSlicers[slicer]->GetTSlice());
-	      mSlicers[i]->UpdateCursorPosition();
-	      if (current) //do not display corner annotation if image is the one picked
-                {
-		  mSlicers[i]->SetCurrentPosition(-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX,
-						  -VTK_DOUBLE_MAX, mSlicers[slicer]->GetTSlice());
-		  mSlicers[i]->SetCursorColor(255,10,212);
-                }
-	      else
-                {
-		  mSlicers[i]->SetCursorColor(150,10,282);
-                }
-	      switch (mSlicers[i]->GetSliceOrientation())
-                {
-                case vtkImageViewer2::SLICE_ORIENTATION_XY:
-		  if (mSlicers[i]->GetSlice() == (int)floor(z))
-		    mSlicers[i]->Render();
-		  else
-		    mSlicers[i]->SetSlice((int)floor(z));
-		  break;
-
-                case vtkImageViewer2::SLICE_ORIENTATION_XZ:
-		  if (mSlicers[i]->GetSlice() == (int)floor(y))
-		    mSlicers[i]->Render();
-		  else
-		    mSlicers[i]->SetSlice((int)floor(y));
-		  break;
-
-                case vtkImageViewer2::SLICE_ORIENTATION_YZ:
-		  if (mSlicers[i]->GetSlice() == (int)floor(x))
-		    mSlicers[i]->Render();
-		  else
-		    mSlicers[i]->SetSlice((int)floor(x));
-		  break;
-                }
-              // DD("UpdateViews::");
-              // DD(i);
-	      UpdateSlice(i);
-	      UpdateTSlice(i);
-            }
+          if (mSlicers[i]->GetSlice() != (int)floor(x))
+            mSlicers[i]->SetSlice((int)floor(x));
+          break;
         }
+        
+        mSlicers[i]->Render();
+        
+        UpdateSlice(i);
+        UpdateTSlice(i);
+      }
     }
+  }
 }
 //----------------------------------------------------------------------------
 
@@ -698,18 +663,85 @@ void vvSlicerManager::UpdateLinked(int slicer)
       y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
       y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
       z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
-      z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5])
-    {
-      for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++)
-        {
-	  emit UpdateLinkManager(*i, slicer,mSlicers[slicer]->GetCurrentPosition()[0],
-				 mSlicers[slicer]->GetCurrentPosition()[1],
-				 mSlicers[slicer]->GetCurrentPosition()[2],mSlicers[slicer]->GetTSlice());
-        }
+      z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]) {
+    for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++) {
+      emit UpdateLinkManager(*i, slicer,mSlicers[slicer]->GetCurrentPosition()[0],
+                             mSlicers[slicer]->GetCurrentPosition()[1],
+                             mSlicers[slicer]->GetCurrentPosition()[2],mSlicers[slicer]->GetTSlice());
     }
+  }
 }
 //----------------------------------------------------------------------------
 
+//----------------------------------------------------------------------------
+void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagate)
+{
+  vtkCamera *refCam = refSlicer->GetRenderer()->GetActiveCamera();
+  double refPosition[3], refFocal[3];
+  refCam->GetPosition(refPosition);
+  refCam->GetFocalPoint(refFocal);
+  
+  for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+    vtkCamera *camera = mSlicers[i]->GetRenderer()->GetActiveCamera();
+    camera->SetParallelScale(refCam->GetParallelScale());
+
+    double position[3], focal[3];
+    camera->GetPosition(position);
+    camera->GetFocalPoint(focal);
+
+    if(refSlicer->GetSliceOrientation()==mSlicers[i]->GetSliceOrientation()) {
+      for(int i=0; i<3; i++) {
+        position[i] = refPosition[i];
+        focal[i]    = refFocal[i];
+      }
+    }
+
+    if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) {
+      if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) {
+        position[0] = refPosition[0];
+        focal[0]    = refFocal[0];
+      }
+      if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) {
+        position[1] = refPosition[1];
+        focal[1]    = refFocal[1];
+      }
+    }
+
+    if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) {
+      if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) {
+        position[2] = refPosition[2];
+        focal[2]    = refFocal[2];
+      }
+      if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) {
+        position[0] = refPosition[0];
+        focal[0]    = refFocal[0];
+      }
+    }
+
+    if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) {
+      if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) {
+        position[1] = refPosition[1];
+        focal[1]    = refFocal[1];
+      }
+      if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) {
+        position[2] = refPosition[2];
+        focal[2]    = refFocal[2];
+      }
+    }
+
+    camera->SetFocalPoint(focal);
+    camera->SetPosition(position);
+  
+    //Fix for bug #243
+    mSlicers[i]->ForceUpdateDisplayExtent();
+  }
+  
+  Render();
+  if(bPropagate)
+    for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++)
+      emit UpdateLinkedNavigation(*i, this, refSlicer);
+}
+//----------------------------------------------------------------------------
 
 //----------------------------------------------------------------------------
 double vvSlicerManager::GetColorWindow()
@@ -730,16 +762,61 @@ double vvSlicerManager::GetColorLevel()
 }
 //----------------------------------------------------------------------------
 
+//----------------------------------------------------------------------------
+double vvSlicerManager::GetOverlayColorWindow() const
+{
+  if (mSlicers.size())
+    return mSlicers[0]->GetOverlayColorWindow();
+  return -1;
+}
+//----------------------------------------------------------------------------
+
+//----------------------------------------------------------------------------
+double vvSlicerManager::GetOverlayColorLevel() const
+{
+  if (mSlicers.size())
+    return mSlicers[0]->GetOverlayColorLevel();
+  return -1;
+}
+//----------------------------------------------------------------------------
+
+//----------------------------------------------------------------------------
+bool vvSlicerManager::GetLinkOverlayWindowLevel() const
+{
+  if (mSlicers.size())
+    return mSlicers[0]->GetLinkOverlayWindowLevel();
+  return -1;
+}
+//----------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+void vvSlicerManager::ResetTransformationToIdentity(const std::string actorType)
+{
+  if(actorType == "image")
+    this->GetImage()->GetTransform()->Identity();
+  else if(actorType == "overlay")
+    this->GetSlicer(0)->GetOverlay()->GetTransform()->Identity();
+  else if(actorType == "fusion")
+    this->GetSlicer(0)->GetFusion()->GetTransform()->Identity();
+  else if(actorType == "vf")
+    this->GetVF()->GetTransform()->Identity();
+  else
+    return;
+
+  for(int i=0; i< this->GetNumberOfSlicers(); i++){
+    this->GetSlicer(i)->ForceUpdateDisplayExtent();
+    this->GetSlicer(i)->ResetCamera();
+    this->GetSlicer(i)->Render();
+  }
+}
+//------------------------------------------------------------------------------
 
 //----------------------------------------------------------------------------
 void vvSlicerManager::Render()
 {
-  // DD("vvSlicerManager::Render");
-  for ( unsigned int i = 0; i < mSlicers.size(); i++)
-    {
-     //  DD(i);
-      mSlicers[i]->Render();
-    }
+  for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+    mSlicers[i]->Render();
+  }
 }
 //----------------------------------------------------------------------------
 
@@ -758,10 +835,9 @@ void vvSlicerManager::Reload()
 {
   mReader->Update(mType);
   mImage=mReader->GetOutput();
-  for ( unsigned int i = 0; i < mSlicers.size(); i++)
-    {
-      mSlicers[i]->SetImage(mImage);
-    }
+  for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+    mSlicers[i]->SetImage(mImage);
+  }
 }
 //----------------------------------------------------------------------------
 
@@ -770,11 +846,10 @@ void vvSlicerManager::Reload()
 void vvSlicerManager::ReloadFusion()
 {
   mFusionReader->Update();
-  for ( unsigned int i = 0; i < mSlicers.size(); i++)
-    {
-      mSlicers[i]->SetFusion(mFusionReader->GetOutput());
-      mSlicers[i]->Render();
-    }
+  for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+    mSlicers[i]->SetFusion(mFusionReader->GetOutput());
+    mSlicers[i]->Render();
+  }
 }
 //----------------------------------------------------------------------------
 
@@ -783,11 +858,10 @@ void vvSlicerManager::ReloadFusion()
 void vvSlicerManager::ReloadOverlay()
 {
   mOverlayReader->Update();
-  for ( unsigned int i = 0; i < mSlicers.size(); i++)
-    {
-      mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
-      mSlicers[i]->Render();
-    }
+  for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+    mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
+    mSlicers[i]->Render();
+  }
 }
 //----------------------------------------------------------------------------
 
@@ -795,13 +869,12 @@ void vvSlicerManager::ReloadOverlay()
 //----------------------------------------------------------------------------
 void vvSlicerManager::ReloadVF()
 {
-  mVectorReader->Update(VECTORFIELD); //deletes the old images through the VF::Init() function
+  mVectorReader->Update(vvImageReader::VECTORFIELD); //deletes the old images through the VF::Init() function
   mVF=mVectorReader->GetOutput();
-  for ( unsigned int i = 0; i < mSlicers.size(); i++)
-    {
-      mSlicers[i]->SetVF(mVF);
-      mSlicers[i]->Render();
-    }
+  for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+    mSlicers[i]->SetVF(mVF);
+    mSlicers[i]->Render();
+  }
 }
 //----------------------------------------------------------------------------
 
@@ -809,18 +882,19 @@ void vvSlicerManager::ReloadVF()
 //----------------------------------------------------------------------------
 void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_index)
 {
-  for (unsigned int i = 0; i < mSlicers.size();i++)
-    {
-      mSlicers[i]->RemoveActor(actor_type,overlay_index);
-    }
-  if (actor_type=="vector")
-    {
-      mVF=NULL;
-      if (mVectorReader) {
-	delete mVectorReader;
-	mVectorReader=NULL;
-      }
-    }
+  if (actor_type =="overlay")
+    mOverlayReader = NULL;
+
+  if (actor_type =="fusion")
+    mFusionReader = NULL;
+
+  for (unsigned int i = 0; i < mSlicers.size(); i++)
+    mSlicers[i]->RemoveActor(actor_type,overlay_index);
+
+  if (actor_type=="vector") {
+    mVF=NULL;
+    mVectorReader=NULL;
+  }
 }
 //----------------------------------------------------------------------------
 
@@ -828,12 +902,14 @@ void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_ind
 //----------------------------------------------------------------------------
 void vvSlicerManager::RemoveActors()
 {
-  ///This method leaks a few objects. See RemoveActor for what a correct implementation would look like
-  for ( unsigned int i = 0; i < mSlicers.size(); i++)
-    {
-      mSlicers[i]->SetDisplayMode(0);
-      mSlicers[i]->GetRenderer()->RemoveActor(mSlicers[i]->GetImageActor());
-    }
+  ///This method leaks a few objects. See RemoveActor for what a
+  ///correct implementation would look like
+  //DS -> probably due to the reader (now released in the
+  //RemoveActor() function. (I hope)
+  for ( unsigned int i = 0; i < mSlicers.size(); i++) {
+    mSlicers[i]->SetDisplayMode(0);
+    mSlicers[i]->GetRenderer()->RemoveActor(mSlicers[i]->GetImageActor());
+  }
 }
 //----------------------------------------------------------------------------
 
@@ -863,93 +939,51 @@ void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)
       Y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
       Y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
       Z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
-      Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5])
-    {
-      value = mSlicers[slicer]->GetInput()->GetScalarComponentAsDouble(
-								       (int)floor(X),
-								       (int)floor(Y),
-								       (int)floor(Z),0);
-      if (mSlicers[slicer]->GetVFActor() && mSlicers[slicer]->GetVFActor()->GetVisibility())
-        {
-	  displayVec = 1;
-	  unsigned int currentTime = mSlicers[slicer]->GetTSlice();
-	  vtkImageData *vf = NULL;
-
-	  if (mSlicers[slicer]->GetVF()->GetVTKImages().size() > currentTime)
-	    vf = mSlicers[slicer]->GetVF()->GetVTKImages()[currentTime];
-	  else
-	    vf = mSlicers[slicer]->GetVF()->GetVTKImages()[0];
-
-	  if (vf)
-            {
-	      double Xvf = (x - vf->GetOrigin()[0])/ vf->GetSpacing()[0];
-	      double Yvf = (y - vf->GetOrigin()[1])/ vf->GetSpacing()[1];
-	      double Zvf = (z - vf->GetOrigin()[2])/ vf->GetSpacing()[2];
-	      xVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),0);
-	      yVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),1);
-	      zVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),2);
-	      valueVec = sqrt(xVec*xVec + yVec*yVec + zVec*zVec);
-            }
-        }
-      if (mSlicers[slicer]->GetOverlayActor() && mSlicers[slicer]->GetOverlayActor()->GetVisibility())
-        {
-	  displayOver = 1;
-	  double Xover = (x - mSlicers[slicer]->GetOverlay()->GetOrigin()[0])
-	    /mSlicers[slicer]->GetOverlay()->GetSpacing()[0];
-	  double Yover = (y - mSlicers[slicer]->GetOverlay()->GetOrigin()[1])
-	    /mSlicers[slicer]->GetOverlay()->GetSpacing()[1];
-	  double Zover = (z - mSlicers[slicer]->GetOverlay()->GetOrigin()[2])
-	    /mSlicers[slicer]->GetOverlay()->GetSpacing()[2];
-	  if (Xover >= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[0] &&
-	      Xover <= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[1] &&
-	      Yover >= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[2] &&
-	      Yover <= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[3] &&
-	      Zover >= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[4] &&
-	      Zover <= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[5])
-            {
-	      valueOver = static_cast<vtkImageData*>(mSlicers[slicer]->GetOverlayMapper()->GetInput())->
-		GetScalarComponentAsDouble(
-					   (int)floor(Xover),
-					   (int)floor(Yover),
-					   (int)floor(Zover),0);
-            }
-        }
-      if (mSlicers[slicer]->GetFusionActor() && mSlicers[slicer]->GetFusionActor()->GetVisibility())
-        {
-	  displayFus = 1;
-	  double Xfus = (x - mSlicers[slicer]->GetFusion()->GetOrigin()[0])
-	    /mSlicers[slicer]->GetFusion()->GetSpacing()[0];
-	  double Yfus = (y - mSlicers[slicer]->GetFusion()->GetOrigin()[1])
-	    /mSlicers[slicer]->GetFusion()->GetSpacing()[1];
-	  double Zfus = (z - mSlicers[slicer]->GetFusion()->GetOrigin()[2])
-	    /mSlicers[slicer]->GetFusion()->GetSpacing()[2];
-	  if (Xfus >= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[0] &&
-	      Xfus <= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[1] &&
-	      Yfus >= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[2] &&
-	      Yfus <= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[3] &&
-	      Zfus >= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[4] &&
-	      Zfus <= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[5])
-            {
-	      valueFus = static_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput())->
-		GetScalarComponentAsDouble(
-					   (int)floor(Xfus),
-					   (int)floor(Yfus),
-					   (int)floor(Zfus),0);
-            }
-        }
-      emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),
-			  x,y,z,X,Y,Z,value);
-      emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec);
-      emit UpdateOverlay(displayOver,valueOver,value);
-      emit UpdateFusion(displayFus,valueFus);
-      for (unsigned int i = 0; i < mSlicers.size(); i++)
-        {
-	  if (mSlicers[i]->GetImageActor()->GetVisibility() == 1)
-	    emit UpdateWindows(i,mSlicers[i]->GetSliceOrientation(),mSlicers[i]->GetSlice());
-	  else
-	    emit UpdateWindows(i,-1,-1);
-        }
+      Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]) {
+    value = this->GetScalarComponentAsDouble(mSlicers[slicer]->GetInput(), X, Y, Z);
+
+    if (mSlicers[slicer]->GetVFActor() ) {
+      displayVec = 1;
+      unsigned int currentTime = mSlicers[slicer]->GetTSlice();
+      vtkImageData *vf = NULL;
+
+      if (mSlicers[slicer]->GetVF()->GetVTKImages().size() > currentTime)
+        vf = mSlicers[slicer]->GetVF()->GetVTKImages()[currentTime];
+      else
+        vf = mSlicers[slicer]->GetVF()->GetVTKImages()[0];
+
+      if (vf) {
+        double Xvf = (x - vf->GetOrigin()[0])/ vf->GetSpacing()[0];
+        double Yvf = (y - vf->GetOrigin()[1])/ vf->GetSpacing()[1];
+        double Zvf = (z - vf->GetOrigin()[2])/ vf->GetSpacing()[2];
+        xVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 0);
+        yVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 1);
+        zVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 2);
+        valueVec = sqrt(xVec*xVec + yVec*yVec + zVec*zVec);
+      }
     }
+    if (mSlicers[slicer]->GetOverlayActor() ) {
+      displayOver = 1;
+      vtkImageData *overlay = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetOverlayMapper()->GetInput());
+      double Xover = (x - overlay->GetOrigin()[0]) / overlay->GetSpacing()[0];
+      double Yover = (y - overlay->GetOrigin()[1]) / overlay->GetSpacing()[1];
+      double Zover = (z - overlay->GetOrigin()[2]) / overlay->GetSpacing()[2];
+      valueOver = this->GetScalarComponentAsDouble(overlay, Xover, Yover, Zover);
+    }
+    if (mSlicers[slicer]->GetFusionActor() ) {
+      displayFus = 1;
+      vtkImageData *fusion = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput());
+      double Xover = (x - fusion->GetOrigin()[0]) / fusion->GetSpacing()[0];
+      double Yover = (y - fusion->GetOrigin()[1]) / fusion->GetSpacing()[1];
+      double Zover = (z - fusion->GetOrigin()[2]) / fusion->GetSpacing()[2];
+      valueFus = this->GetScalarComponentAsDouble(fusion, Xover, Yover, Zover);
+    }
+    emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),
+                        x,y,z,X,Y,Z,value);
+    emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec);
+    emit UpdateOverlay(displayOver,valueOver,value);
+    emit UpdateFusion(displayFus,valueFus);
+  }
 }
 //----------------------------------------------------------------------------
 
@@ -962,10 +996,18 @@ void vvSlicerManager::Activated()
 //----------------------------------------------------------------------------
 
 
+//----------------------------------------------------------------------------
+void vvSlicerManager::Picked()
+{
+  emit currentPickedImageChanged(mId);
+}
+//----------------------------------------------------------------------------
+
+
 //----------------------------------------------------------------------------
 void vvSlicerManager::UpdateWindowLevel()
 {
-  emit WindowLevelChanged(mSlicers[0]->GetColorWindow(),mSlicers[0]->GetColorLevel(),mPreset,mColorMap);
+  emit WindowLevelChanged();
 }
 //----------------------------------------------------------------------------
 
@@ -973,13 +1015,11 @@ void vvSlicerManager::UpdateWindowLevel()
 //----------------------------------------------------------------------------
 void vvSlicerManager::UpdateSlice(int slicer)
 {
-  // DD("vvSlicerManager::UpdateSlice emit UpdateSlice");
-//   DD(slicer);
-//   DD(mSlicers[slicer]->GetSlice());
   if (mPreviousSlice[slicer] == mSlicers[slicer]->GetSlice()) {
     //DD("============= NOTHING");
     return;
   }
+  //std::cout << "vvSlicerManager::UpdateSlice " << slicer << " " << mSlicers[slicer]->GetSlice() << std::endl;
   emit UpdateSlice(slicer, mSlicers[slicer]->GetSlice());
   mSlicers[slicer]->Render(); // DS <-- I add this, this could/must be the only Render ...
   mPreviousSlice[slicer] = mSlicers[slicer]->GetSlice();
@@ -990,19 +1030,18 @@ void vvSlicerManager::UpdateSlice(int slicer)
 //----------------------------------------------------------------------------
 void vvSlicerManager::UpdateTSlice(int slicer)
 {
-  // DD("vvSlicerManager::UpdateTSlice emit UpdateTSlice");
-//   DD(slicer);
-//   DD(mSlicers[slicer]->GetTSlice());
-//   DD(mSlicers[slicer]->GetSlice());
-  if (mPreviousSlice[slicer] == mSlicers[slicer]->GetSlice()) {
-    if (mPreviousTSlice[slicer] == mSlicers[slicer]->GetTSlice()) {
+  int slice = mSlicers[slicer]->GetSlice();
+  int tslice = mSlicers[slicer]->GetTSlice();
+  if (mPreviousSlice[slicer] == slice) {
+    if (mPreviousTSlice[slicer] == tslice) {
       //      DD("************** NOTHING ***********");
       return;
     }
   }
-  mPreviousSlice[slicer] = mSlicers[slicer]->GetSlice();
-  mPreviousTSlice[slicer] = mSlicers[slicer]->GetTSlice();
-  emit UpdateTSlice(slicer,mSlicers[slicer]->GetTSlice());  
+  mPreviousSlice[slicer] = slice;
+  mPreviousTSlice[slicer] = tslice;
+  //std::cout << "vvSlicerManager::UpdateTSlice " << slicer << " " << tslice << std::endl;
+  emit UpdateTSlice(slicer, tslice);
 }
 //----------------------------------------------------------------------------
 
@@ -1011,8 +1050,8 @@ void vvSlicerManager::UpdateTSlice(int slicer)
 void vvSlicerManager::UpdateSliceRange(int slicer)
 {
   emit UpdateSliceRange(slicer,
-			mSlicers[slicer]->GetSliceRange()[0], mSlicers[slicer]->GetSliceRange()[1],
-			0,mSlicers[slicer]->GetTMax());
+                        mSlicers[slicer]->GetSliceRange()[0], mSlicers[slicer]->GetSliceRange()[1],
+                        0,mSlicers[slicer]->GetTMax());
 }
 //----------------------------------------------------------------------------
 
@@ -1024,55 +1063,41 @@ void vvSlicerManager::SetPreset(int preset)
   double window = mSlicers[0]->GetColorWindow();
   double level = mSlicers[0]->GetColorLevel();
 
-  std::string component_type=mImage->GetScalarTypeAsString();
-  switch (preset)
-    {
-    case 0:
-      if (component_type == "unsigned_char")
-        {
-	  window = 255;
-	  level = 127;
-        }
-      else if (component_type == "short")
-        {
-	  window = 2000;
-	  level = 0;
-        }
-      else
-        {
-	  double range[2];
-	  mImage->GetScalarRange(range);
-	  window = range[1] - range[0];
-	  level = (range[1] + range[0])* 0.5;
-        }
-      break;
-    case 1:
-      window = 2000;
-      level = 0;
-      break;
-    case 2:
-      window = 350;
-      level = 60;
-      break;
-    case 3:
-      window = 1500;
-      level = -500;
-      break;
-    case 4:
-      window = 1000;
-      level = 500;
-      break;
-    case 5:
-      window = 1;
-      level = 0.5;
-      break;
-    case 6:
-      break;
-    case 7:
-      window=1.;
-      level=0.;
-      break;
-    }
+  std::string component_type=mImage->GetScalarTypeAsITKString();
+  switch (preset) {
+  case 0:
+    double range[2];
+    mImage->GetScalarRange(range);
+    window = range[1] - range[0];
+    level = (range[1] + range[0])* 0.5;
+    break;
+  case 1:
+    window = 2000;
+    level = 0;
+    break;
+  case 2:
+    window = 400;
+    level = 20;
+    break;
+  case 3:
+    window = 1500;
+    level = -500;
+    break;
+  case 4:
+    window = 1000;
+    level = 500;
+    break;
+  case 5:
+    window = 1;
+    level = 0.5;
+    break;
+  case 6:
+    break;
+  case 7:
+    window=1.;
+    level=0.;
+    break;
+  }
   mPreset = preset;
   this->SetColorWindow(window);
   this->SetColorLevel(level);
@@ -1086,22 +1111,34 @@ void vvSlicerManager::SetPreset(int preset)
 
 
 //----------------------------------------------------------------------------
-void vvSlicerManager::SetLocalColorWindowing(const int slicer)
+void vvSlicerManager::SetLocalColorWindowing(const int slicer, const bool bCtrlKey)
 {
   double min, max;
-  this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max);
-  this->SetColorWindow(max-min);
-  this->SetColorLevel(0.5*(min+max));
-  this->UpdateWindowLevel();
+  int t = this->mSlicers[slicer]->GetTSlice();
+  if(bCtrlKey && this->mSlicers[slicer]->GetFusion()) {
+    this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max, this->mSlicers[slicer]->GetFusion()->GetVTKImages()[t]);
+    this->SetFusionWindow(max-min);
+    this->SetFusionLevel(0.5*(min+max));
+    this->SetColorMap(mColorMap);
+  }
+  else if(bCtrlKey && this->mSlicers[slicer]->GetOverlay()) {
+    this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max, this->mSlicers[slicer]->GetOverlay()->GetVTKImages()[t]);
+    if(this->mSlicers[slicer]->GetLinkOverlayWindowLevel()){
+      this->SetColorWindow(max-min);
+      this->SetColorLevel(0.5*(min+max));
+    } else {
+      this->SetOverlayColorWindow(max-min);
+      this->SetOverlayColorLevel(0.5*(min+max));
+    }
+  }
+  else {
+    this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max, this->mSlicers[slicer]->GetInput());
+    this->SetColorWindow(max-min);
+    this->SetColorLevel(0.5*(min+max));
+    this->SetPreset(6);
+  }
   this->Render();
-}
-//----------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------
-void vvSlicerManager::SetColorMap()
-{
-  SetColorMap(mColorMap);
+  this->UpdateWindowLevel();
 }
 //----------------------------------------------------------------------------
 
@@ -1117,70 +1154,101 @@ void vvSlicerManager::SetColorMap(int colormap)
   double level = mSlicers[0]->GetWindowLevel()->GetLevel();
 
   vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
-  switch (colormap)
+  switch (colormap) {
+  case -1:
+    break;
+  case 0:
+    LUT = NULL;
+    break;
+  case 1:
+    if (LUT == NULL)
+      LUT = vtkLookupTable::New();
+    LUT->SetValueRange(0,1);
+    LUT->SetSaturationRange(1,1);
+    LUT->SetHueRange(0,0.18);
+    break;
+  case 2:
+    if (LUT == NULL)
+      LUT = vtkLookupTable::New();
+    LUT->SetValueRange(0,1);
+    LUT->SetSaturationRange(1,1);
+    LUT->SetHueRange(0.4,0.80);
+    break;
+  case 3:
+    if (LUT == NULL)
+      LUT = vtkLookupTable::New();
+    LUT->SetValueRange(0.5,1);
+    LUT->SetSaturationRange(1,1);
+    LUT->SetHueRange(0.666,0);
+    break;
+  case 4:
+    if (LUT == NULL)
+      LUT = vtkLookupTable::New();
+    LUT->SetValueRange(0,1);
+    LUT->SetSaturationRange(1,1);
+    LUT->SetHueRange(0,1);
+    break;
+  case 5:
+    if (LUT == NULL)
+      LUT = vtkLookupTable::New();
+    LUT->SetValueRange(0.,1);
+    LUT->SetSaturationRange(1,1);
+    LUT->SetHueRange(1,0.1);
+    //LUT->SetRampToLinear();
+    break;
+  }
+  if (LUT) {
+    LUT->SetTableRange(level-fabs(window)/2,level+fabs(window)/2);
+    LUT->Build();
+  }
+  vtkWindowLevelLookupTable* fusLUT = NULL;
+  if (mSlicers[0]->GetFusion()) { // && mFusionColorMap >= 0) {
+    fusLUT = vtkWindowLevelLookupTable::New();
+    double fusRange [2];
+    fusRange[0] = mFusionLevel - mFusionWindow/2;
+    fusRange[1] = mFusionLevel + mFusionWindow/2;
+    double* frange = mFusionReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
+    fusLUT->SetTableRange(frange);
+    fusLUT->SetValueRange(1,1);
+    fusLUT->SetSaturationRange(1,1);
+    fusLUT->SetAlphaRange(1, 1);
+    fusLUT->SetWindow(mFusionWindow);
+    fusLUT->SetLevel(mFusionLevel);
+    if (mFusionColorMap == 1)
+      fusLUT->SetHueRange(0,0.18);
+    else if (mFusionColorMap == 2)
+      fusLUT->SetHueRange(0.4,0.80);
+    else if (mFusionColorMap == 3)
     {
-    case -1:
-      break;
-    case 0:
-      LUT = NULL;
-      break;
-    case 1:
-      if (LUT == NULL)
-	LUT = vtkLookupTable::New();
-      LUT->SetValueRange(0,1);
-      LUT->SetSaturationRange(1,1);
-      LUT->SetHueRange(0,0.18);
-      break;
-    case 2:
-      if (LUT == NULL)
-	LUT = vtkLookupTable::New();
-      LUT->SetValueRange(0,1);
-      LUT->SetSaturationRange(1,1);
-      LUT->SetHueRange(0.4,0.80);
-      break;
-    case 3:
-      if (LUT == NULL)
-	LUT = vtkLookupTable::New();
-      LUT->SetValueRange(0,1);
-      LUT->SetSaturationRange(1,1);
-      LUT->SetHueRange(0,1);
-      break;
-    case 5:
-      if (LUT == NULL)
-	LUT = vtkLookupTable::New();
-      LUT->SetValueRange(0.,1);
-      LUT->SetSaturationRange(1,1);
-      LUT->SetHueRange(1,0.1);
-      //LUT->SetRampToLinear();
-      break;
+      fusLUT->SetHueRange(0.666, 0);
+      fusLUT->SetValueRange(0.5, 1);
     }
-  if (LUT)
+    else if (mFusionColorMap == 4)
+      fusLUT->SetHueRange(0,1);
+    else if (mFusionColorMap <= 0)
     {
-      LUT->SetTableRange(level-fabs(window)/4,level+fabs(window)/4);
-      LUT->Build();
+      fusLUT->SetValueRange(0,1);
+      fusLUT->SetSaturationRange(0,0);
     }
-  vtkLookupTable* fusLUT = NULL;
-  if (mSlicers[0]->GetFusion())
-    {
-      fusLUT = vtkLookupTable::New();
-      double fusRange [2];
-      fusRange[0] = mFusionLevel - mFusionWindow/2;
-      fusRange[1] = mFusionLevel + mFusionWindow/2;
-      fusLUT->SetTableRange(fusRange[0],fusRange[1]);
-      fusLUT->SetValueRange(1,1);
-      fusLUT->SetSaturationRange(1,1);
-      if (mFusionColorMap == 1)
-	fusLUT->SetHueRange(0,0.18);
-      else if (mFusionColorMap == 2)
-	fusLUT->SetHueRange(0.4,0.80);
-      else if (mFusionColorMap == 3)
-	fusLUT->SetHueRange(0,1);
-      fusLUT->Build();
-      if (mFusionColorMap == 0)
-	fusLUT = NULL;
+    
+    fusLUT->ForceBuild();
+    double v[4];
+    
+    // set color table transparency
+    double range_end = frange[0] + (double)mFusionThresOpacity*(frange[1] - frange[0])/100;
+    double curr_value = frange[0];
+    int nvalues = fusLUT->GetNumberOfTableValues();
+    //for (double i = frange[0]; i <= alpha_range_end; i++) {
+    for (double i = 0; curr_value < range_end; i++) {  
+      fusLUT->GetTableValue(i, v);
+      v[3] = 0;
+      fusLUT->SetTableValue(i, v);
+      curr_value += (frange[1] - frange[0])/nvalues;
     }
+  }
   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
-    if (mSlicers[i]->GetOverlay() && mSlicers[i]->GetOverlayActor()->GetVisibility()) {
+    
+    if (mSlicers[i]->GetOverlay()) {
       vtkLookupTable* supLUT = vtkLookupTable::New();
       supLUT->SetTableRange(range[0],range[1]);
       supLUT->SetValueRange(1,1);
@@ -1194,27 +1262,23 @@ void vvSlicerManager::SetColorMap(int colormap)
       invLUT->SetHueRange(double((mOverlayColor+180)%360)/360,double((mOverlayColor+180)%360)/360);
       invLUT->Build();
       dynamic_cast<vvImageMapToWLColors*>(mSlicers[i]->GetWindowLevel())
-	->SetWindowLevelMode(true);
+        ->SetWindowLevelMode(true);
       mSlicers[i]->GetWindowLevel()->SetLookupTable(supLUT);
       mSlicers[i]->GetOverlayMapper()->SetLookupTable(invLUT);
       invLUT->Delete();
       supLUT->Delete();
+    } else if (mSlicers[i]->GetOverlay()) {
+      //dynamic_cast<vvImageMapToWLColors*>(mSlicers[i]->GetWindowLevel())
+      //->SetWindowLevelMode(false);
+      mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
+    } else {
+      mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
+    }
+    
+    if (mSlicers[i]->GetFusion()) {
+      mSlicers[i]->GetFusionMapper()->SetLookupTable(fusLUT);
+      mSlicers[i]->GetFusionActor()->SetOpacity(double(mFusionOpacity)/100);
     }
-    else if (mSlicers[i]->GetOverlay())
-      {
-	//dynamic_cast<vvImageMapToWLColors*>(mSlicers[i]->GetWindowLevel())
-	//->SetWindowLevelMode(false);
-	mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
-      }
-    else
-      {
-	mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
-      }
-    if (mSlicers[i]->GetFusion() && mSlicers[i]->GetFusionActor()->GetVisibility())
-      {
-	mSlicers[i]->GetFusionActor()->SetOpacity(double(mFusionOpacity)/100);
-	mSlicers[i]->GetFusionMapper()->SetLookupTable(fusLUT);
-      }
   }
   if (fusLUT)
     fusLUT->Delete();
@@ -1227,12 +1291,11 @@ void vvSlicerManager::SetColorMap(int colormap)
 //----------------------------------------------------------------------------
 vvLandmarks* vvSlicerManager::GetLandmarks()
 {
-  if (mLandmarks == NULL)
-    {
-      mLandmarks = new vvLandmarks(mSlicers[0]->GetTMax()+1);
-      for (unsigned int i = 0; i < mSlicers.size(); i++)
-	mSlicers[i]->SetLandmarks(mLandmarks);
-    }
+  if (mLandmarks == NULL) {
+    mLandmarks = new vvLandmarks(mSlicers[0]->GetTMax()+1);
+    for (unsigned int i = 0; i < mSlicers.size(); i++)
+      mSlicers[i]->SetLandmarks(mLandmarks);
+  }
   return mLandmarks;
 }
 //----------------------------------------------------------------------------
@@ -1244,12 +1307,16 @@ void vvSlicerManager::AddLandmark(float x,float y,float z,float t)
   double x_index = (x - mSlicers[0]->GetInput()->GetOrigin()[0])/mSlicers[0]->GetInput()->GetSpacing()[0];
   double y_index = (y - mSlicers[0]->GetInput()->GetOrigin()[1])/mSlicers[0]->GetInput()->GetSpacing()[1];
   double z_index = (z - mSlicers[0]->GetInput()->GetOrigin()[2])/mSlicers[0]->GetInput()->GetSpacing()[2];
-  double value = mSlicers[0]->GetInput()->GetScalarComponentAsDouble(
-								     (int)x_index,
-								     (int)y_index,
-								     (int)z_index,0);
-  this->GetLandmarks()->AddLandmark(x,y,z,t,value);
-  emit LandmarkAdded();
+  if (x_index >= mSlicers[0]->GetInput()->GetWholeExtent()[0] &&
+      x_index <= mSlicers[0]->GetInput()->GetWholeExtent()[1] &&
+      y_index >= mSlicers[0]->GetInput()->GetWholeExtent()[2] &&
+      y_index <= mSlicers[0]->GetInput()->GetWholeExtent()[3] &&
+      z_index >= mSlicers[0]->GetInput()->GetWholeExtent()[4] &&
+      z_index <= mSlicers[0]->GetInput()->GetWholeExtent()[5]) {
+    double value = this->GetScalarComponentAsDouble(mSlicers[0]->GetInput(), x_index, y_index, z_index);
+    this->GetLandmarks()->AddLandmark(x,y,z,t,value);
+    emit LandmarkAdded();
+  }
 }
 //----------------------------------------------------------------------------
 
@@ -1260,7 +1327,6 @@ void vvSlicerManager::PrevImage(int slicer)
 }
 //----------------------------------------------------------------------------
 
-
 //----------------------------------------------------------------------------
 void vvSlicerManager::NextImage(int slicer)
 {
@@ -1268,10 +1334,18 @@ void vvSlicerManager::NextImage(int slicer)
 }
 //----------------------------------------------------------------------------
 
-
 //----------------------------------------------------------------------------
-void vvSlicerManager::VerticalSliderHasChanged(int slicer, int slice) {
+void vvSlicerManager::VerticalSliderHasChanged(int slicer, int slice)
+{
   emit AVerticalSliderHasChanged(slicer, slice);
 }
-    
+
+//----------------------------------------------------------------------------
+
+//----------------------------------------------------------------------------
+double vvSlicerManager::GetScalarComponentAsDouble(vtkImageData *image, double X, double Y, double Z, int component)
+{
+  int ix, iy, iz;
+  return mSlicers[0]->GetScalarComponentAsDouble(image, X, Y, Z, ix, iy, iz, component);
+}
 //----------------------------------------------------------------------------