Romulo:

[clitk.git] / vv / vvImageContour.cxx

diff --git a/vv/vvImageContour.cxx b/vv/vvImageContour.cxx
index 0e4e428110c4a2958e2441fee248149406ca5fb7..5e50b06fd4032655e8eb2841c46e64263eea18fa 100644 (file)
--- a/vv/vvImageContour.cxx
+++ b/vv/vvImageContour.cxx
@@ -34,6 +34,7 @@ vvImageContour::vvImageContour()
   mSlice = 0;
   mHiddenImageIsUsed = false;
   mDisplayModeIsPreserveMemory = true;
+  SetPreserveMemoryModeEnabled(true);
 }
 //------------------------------------------------------------------------------
 
@@ -44,9 +45,9 @@ vvImageContour::~vvImageContour()
   for (unsigned int i = 0; i < mSlicer->GetImage()->GetVTKImages().size(); i++) {
     mSlicer->GetRenderer()->RemoveActor(mSquaresActorList[i]);
   }
-  mSquaresActorList.clear();
-  mSquaresList.clear();
-  mClipperList.clear();
+ mSquaresActorList.clear();
+ mSquaresList.clear();
+ mClipperList.clear();
 }
 //------------------------------------------------------------------------------
 
@@ -56,9 +57,9 @@ void vvImageContour::SetSlicer(vvSlicer * slicer) {
   mSlicer = slicer;  
   // Create an actor for each time slice
   for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
-    vtkImageClip * mClipper = vtkImageClip::New();
-    vtkMarchingSquares * mSquares = vtkMarchingSquares::New();
-    vtkActor * mSquaresActor = vtkActor::New();
+    vtkImageClip * mClipper;// = vtkImageClip::New();
+    vtkMarchingSquares * mSquares;// = vtkMarchingSquares::New();
+    vtkActor * mSquaresActor;// = vtkActor::New();
     CreateNewActor(&mSquaresActor, &mSquares, &mClipper, numImage);
     mSquaresActorList.push_back(mSquaresActor);
     mSquaresList.push_back(mSquares);
@@ -69,7 +70,7 @@ void vvImageContour::SetSlicer(vvSlicer * slicer) {
 
 
 //------------------------------------------------------------------------------
-void vvImageContour::SetImage(vvImage::Pointer image) {
+void vvImageContour::SetImage(vvImage * image) {
   for (unsigned int numImage = 0; numImage < image->GetVTKImages().size(); numImage++) {
     mClipperList[numImage]->SetInput(image->GetVTKImages()[numImage]);
   }
@@ -85,6 +86,7 @@ void vvImageContour::SetPreserveMemoryModeEnabled(bool b) {
   if (mDisplayModeIsPreserveMemory == b) return;
   mDisplayModeIsPreserveMemory = b;
   if (!b) {
+    clitkExceptionMacro("TODO : not implemented yet");
     HideActors();
     InitializeCacheMode();
   }
@@ -133,22 +135,18 @@ void vvImageContour::ShowActors() {
   if (!mSlicer) return;
   mSlice = mSlicer->GetSlice();
   mTSlice = mSlicer->GetTSlice();
-  //  for(unsigned int i=0; i<mSquaresActorList.size(); i++) {
   mSquaresActorList[mTSlice]->VisibilityOn();
   Update(mValue);
-  //}
 }
 //------------------------------------------------------------------------------
 
 
 //------------------------------------------------------------------------------
 void vvImageContour::Update(double value) {
-  //  DD(value);
   if (!mSlicer) return;
   if (mPreviousValue == value) {
     if (mPreviousSlice == mSlicer->GetSlice()) {
       if (mPreviousTSlice == mSlicer->GetTSlice()) {
-        // DD("vvImageContour::update nothing");
         return; // Nothing to do
       }
     }
@@ -159,7 +157,7 @@ void vvImageContour::Update(double value) {
 
   // Get current slice
   mSlice = mSlicer->GetSlice();
-  //  DD(mDisplayModeIsPreserveMemory);
+
   if (mDisplayModeIsPreserveMemory) {
     UpdateWithPreserveMemoryMode();
   }
@@ -167,9 +165,7 @@ void vvImageContour::Update(double value) {
     UpdateWithFastCacheMode();
   }
 
-
-  mSlicer->Render(); //DS ---> REMOVE ??
-
+  //  mSlicer->Render(); //DS ---> REMOVE ??
 
   mPreviousTSlice = mSlicer->GetTSlice();
   mPreviousSlice  = mSlicer->GetSlice();
@@ -181,27 +177,17 @@ void vvImageContour::Update(double value) {
 //------------------------------------------------------------------------------
 void vvImageContour::UpdateWithPreserveMemoryMode() {
   // Only change actor visibility if tslice change
-  //DD(mTSlice);
-  //DD(mSlice);
   int mPreviousTslice = mTSlice;
-  //    ;
-  //   if (mTSlice != mSlicer->GetTSlice()) {
-  //     if (mTSlice != -1) mTsliceToSetOff = mTSlice;
-  //       mSquaresActorList[mTSlice]->VisibilityOff();
   mTSlice = mSlicer->GetTSlice();
-  //   }
-  //  else return;
-  //  DD(mTSlice);
+
   vtkMarchingSquares * mSquares = mSquaresList[mTSlice];
   vtkImageClip * mClipper = mClipperList[mTSlice];
   vtkActor * mSquaresActor = mSquaresActorList[mTSlice];
   int orientation = ComputeCurrentOrientation();
-  //  DD(orientation);
-  //DD(mValue);
-  //DD(mSlice);
-  //DD(mPreviousTslice);
+
   UpdateActor(mSquaresActor, mSquares, mClipper, mValue, orientation, mSlice);
   mSquaresActorList[mTSlice]->VisibilityOn();
+
   if (mPreviousTslice != mTSlice) {
     if (mPreviousTslice != -1) mSquaresActorList[mPreviousTslice]->VisibilityOff();
   }
@@ -211,13 +197,13 @@ void vvImageContour::UpdateWithPreserveMemoryMode() {
 
 //------------------------------------------------------------------------------
 void vvImageContour::InitializeCacheMode() {
+clitkExceptionMacro("TODO : not implemented yet");
   mPreviousSlice = mPreviousOrientation = 0;
   int dim = mSlicer->GetImage()->GetNumberOfDimensions();
 
   mListOfCachedContourActors.resize(dim);
   for(int d=0; d<dim; d++) {
     int size = mSlicer->GetImage()->GetSize()[d];
-    //DD(size);
     mListOfCachedContourActors[d].resize(size);
     for(int j=0; j<size; j++) {
       mListOfCachedContourActors[d][j] = NULL;
@@ -247,6 +233,8 @@ int vvImageContour::ComputeCurrentOrientation() {
 
 //------------------------------------------------------------------------------
 void vvImageContour::UpdateWithFastCacheMode() {
+clitkExceptionMacro("TODO : not implemented yet");
+
   // Compute orientation
   int orientation = ComputeCurrentOrientation();
 
@@ -278,10 +266,10 @@ void vvImageContour::CreateNewActor(vtkActor ** actor,
                                     vtkMarchingSquares ** squares, 
                                     vtkImageClip ** clipper, 
                                     int numImage) {
-  vtkActor * mSquaresActor = (*actor = vtkActor::New());
-  vtkImageClip * mClipper = (*clipper = vtkImageClip::New());
-  vtkMarchingSquares * mSquares = (*squares = vtkMarchingSquares::New());
-  vtkPolyDataMapper * mSquaresMapper = vtkPolyDataMapper::New();
+  vtkSmartPointer<vtkActor> mSquaresActor = (*actor = vtkSmartPointer<vtkActor>::New());
+  vtkSmartPointer<vtkImageClip> mClipper = (*clipper = vtkSmartPointer<vtkImageClip>::New());
+  vtkSmartPointer<vtkMarchingSquares> mSquares = (*squares = vtkSmartPointer<vtkMarchingSquares>::New());
+  vtkSmartPointer<vtkPolyDataMapper> mSquaresMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
 
   if (mHiddenImageIsUsed)
     mClipper->SetInput(mHiddenImage->GetVTKImages()[0]);
@@ -304,7 +292,7 @@ void vvImageContour::UpdateActor(vtkActor * actor,
                                  vtkMarchingSquares * squares, 
                                  vtkImageClip * clipper, 
                                  double threshold, int orientation, int slice) {
-  // Set parameter for the MarchigSquare
+   // Set parameter for the MarchigSquare
   squares->SetValue(0, threshold);
 
   // Get image extent
@@ -316,6 +304,7 @@ void vvImageContour::UpdateActor(vtkActor * actor,
     extent2 = new int[6];
     int * extent3;
     extent3 = mHiddenImage->GetFirstVTKImageData()->GetExtent();
+
     for(int i=0; i<6; i++) extent2[i] = extent3[i];
 
     double s = (double)extent[orientation*2]*(double)mSlicer->GetImage()->GetSpacing()[orientation]; // in mm
@@ -329,47 +318,58 @@ void vvImageContour::UpdateActor(vtkActor * actor,
       extent2[orientation*2] = (int)floor(s);
       extent2[orientation*2+1] = extent2[orientation*2];
     }
+
+    // Do not display a contour if there is no contour on this slice
+    if (extent2[orientation*2+1] > extent3[orientation*2+1]) {
+      actor->VisibilityOff();
+      return;
+    }
+    else actor->VisibilityOn();
+
   } else {
     extent2 = extent;
   }
+ 
   clipper->SetOutputWholeExtent(extent2[0],extent2[1],extent2[2],
                                 extent2[3],extent2[4],extent2[5]);
 
   if (mHiddenImage) delete extent2;
 
   // Move the actor to be visible
-  // DD(orientation);
-  //   DD(slice);
-
-  //TO SIMPLiFY :!!!!!!!!! == ???????
-  // actor->SetPosition(-1,-1,-1);
-
   switch (orientation)  {
   case 0:
+    actor->SetPosition(-1,0,0);
+    /*
     // DD(mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[0]);
     if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[0] > slice) {
-      actor->SetPosition(1,0,0);
+    actor->SetPosition(1,0,0);
     } else {
       actor->SetPosition(-1,0,0);
-    }
+      }*/
     break;
   case 1:
+    actor->SetPosition(0,-1,0);
+    /*
     // DD(mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[1]);
     if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[1] > slice) {
       actor->SetPosition(0,1,0);
     } else {
       actor->SetPosition(0,-1,0);
     }
+    */
     break;
   case 2:
-    // DD(mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[2]);
+    actor->SetPosition(0,0,-1);
+    /*
+    DD(mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[2]);
     if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[2] > slice) {
-      // DD("1");
+      DD("1");
       actor->SetPosition(0,0,1);
     } else {
-      // DD("-1");
+     DD("-1");
       actor->SetPosition(0,0,-1);
     }
+    */
     break;
   }