Romulo:

[clitk.git] / vv / vvSlicerManager.cxx

diff --git a/vv/vvSlicerManager.cxx b/vv/vvSlicerManager.cxx
index 42982b7f99ffb6693afc4f04deb88f51ad629355..1daee2c666332458ffba9e6f722d31c5b8f7c1f9 100644 (file)
--- a/vv/vvSlicerManager.cxx
+++ b/vv/vvSlicerManager.cxx
@@ -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"
@@ -62,19 +60,12 @@ vvSlicerManager::vvSlicerManager(int numberOfSlicers)
   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);
 }
@@ -84,22 +75,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;
 }
@@ -114,13 +89,16 @@ void vvSlicerManager::SetFilename(std::string filename, int number)
   mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
   mBaseFileNameNumber = number;
 
-  for(unsigned int i=0; i<mSlicers.size(); i++) {
-    mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
-  }
-  
+  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(mFileName);//vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
+  }
+  
 }
 //------------------------------------------------------------------------------
 
@@ -148,8 +126,8 @@ void vvSlicerManager::ToggleContourSuperposition()
 bool vvSlicerManager::SetImage(std::string filename, LoadedImageType type, int n, unsigned int slice)
 {
   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);
@@ -204,8 +182,8 @@ bool vvSlicerManager::SetImages(std::vector<std::string> filenames,LoadedImageTy
 
   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);
 
@@ -239,8 +217,8 @@ bool vvSlicerManager::SetOverlay(std::string filename,int dim, std::string compo
     mLastError = " Overlay dimension cannot be greater then reference image!";
     return false;
   }
-  if (mOverlayReader == NULL)
-    mOverlayReader = new vvImageReader;
+  if (mOverlayReader.IsNull())
+    mOverlayReader = vvImageReader::New();
   std::vector<std::string> filenames;
   filenames.push_back(filename);
   mOverlayReader->SetInputFilenames(filenames);
@@ -267,8 +245,8 @@ bool vvSlicerManager::SetFusion(std::string filename,int dim, std::string compon
     mLastError = " Overlay dimension cannot be greater then reference image!";
     return false;
   }
-  if (mFusionReader == NULL)
-    mFusionReader = new vvImageReader;
+  if (mFusionReader.IsNull())
+    mFusionReader = vvImageReader::New();
   std::vector<std::string> filenames;
   filenames.push_back(filename);
   mFusionReader->SetInputFilenames(filenames);
@@ -292,8 +270,8 @@ 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) {
@@ -502,15 +480,15 @@ void vvSlicerManager::SetColorLevel(double s)
 //----------------------------------------------------------------------------
 
 //----------------------------------------------------------------------------
-void vvSlicerManager::SetCursorVisibility(int s)
+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)
 {
@@ -691,12 +669,15 @@ void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *slicer, bool bPropagate)
 
     camera->SetFocalPoint(focal);
     camera->SetPosition(position);
-
-    if(bPropagate)
-      for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++)
-        emit UpdateLinkedNavigation(*i, this);
+  
+    //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);
 }
 //----------------------------------------------------------------------------
 
@@ -791,25 +772,18 @@ void vvSlicerManager::ReloadVF()
 //----------------------------------------------------------------------------
 void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_index)
 {
-  if (actor_type =="overlay") {
-    delete mOverlayReader;
+  if (actor_type =="overlay")
     mOverlayReader = NULL;
-  }
 
-  if (actor_type =="fusion") {
-    delete mFusionReader;
+  if (actor_type =="fusion")
     mFusionReader = NULL;
-  }
 
-  for (unsigned int i = 0; i < mSlicers.size(); i++) {
+  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;
-    }
+    mVectorReader=NULL;
   }
 }
 //----------------------------------------------------------------------------
@@ -856,10 +830,8 @@ void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)
       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);
+    value = this->GetScalarComponentAsDouble(mSlicers[slicer]->GetInput(), X, Y, Z);
+
     if (mSlicers[slicer]->GetVFActor() && mSlicers[slicer]->GetVFActor()->GetVisibility()) {
       displayVec = 1;
       unsigned int currentTime = mSlicers[slicer]->GetTSlice();
@@ -874,9 +846,9 @@ void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)
         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);
+        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);
       }
     }
@@ -894,11 +866,7 @@ void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)
           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);
+        valueOver = this->GetScalarComponentAsDouble(static_cast<vtkImageData*>(mSlicers[slicer]->GetOverlayMapper()->GetInput()), Xover, Yover, Zover);
       }
     }
     if (mSlicers[slicer]->GetFusionActor() && mSlicers[slicer]->GetFusionActor()->GetVisibility()) {
@@ -915,11 +883,7 @@ void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)
           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);
+        valueFus = this->GetScalarComponentAsDouble(static_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput()), Xfus, Yfus, Zfus);
       }
     }
     emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),
@@ -946,6 +910,13 @@ void vvSlicerManager::Activated()
 //----------------------------------------------------------------------------
 
 
+//----------------------------------------------------------------------------
+void vvSlicerManager::Picked()
+{
+  emit currentPickedImageChanged(mId);
+}
+//----------------------------------------------------------------------------
+
 //----------------------------------------------------------------------------
 void vvSlicerManager::UpdateWindowLevel()
 {
@@ -1206,10 +1177,7 @@ void vvSlicerManager::AddLandmark(float x,float y,float z,float t)
       y_index <= mSlicers[0]->GetInput()->GetWholeExtent()[3] &&
       z_index >= mSlicers[0]->GetInput()->GetWholeExtent()[4] &&
       z_index <= mSlicers[0]->GetInput()->GetWholeExtent()[5]) {
-    double value = mSlicers[0]->GetInput()->GetScalarComponentAsDouble(
-                                                                       (int)x_index,
-                                                                       (int)y_index,
-                                                                       (int)z_index,0);
+    double value = this->GetScalarComponentAsDouble(mSlicers[0]->GetInput(), x_index, y_index, z_index);
     this->GetLandmarks()->AddLandmark(x,y,z,t,value);
     emit LandmarkAdded();
   }
@@ -1223,7 +1191,6 @@ void vvSlicerManager::PrevImage(int slicer)
 }
 //----------------------------------------------------------------------------
 
-
 //----------------------------------------------------------------------------
 void vvSlicerManager::NextImage(int slicer)
 {
@@ -1231,7 +1198,6 @@ void vvSlicerManager::NextImage(int slicer)
 }
 //----------------------------------------------------------------------------
 
-
 //----------------------------------------------------------------------------
 void vvSlicerManager::VerticalSliderHasChanged(int slicer, int slice)
 {
@@ -1239,3 +1205,11 @@ void vvSlicerManager::VerticalSliderHasChanged(int slicer, int 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);
+}
+//----------------------------------------------------------------------------