Inherits from ImageToImageGenericFilter

[clitk.git] / vv / vvBinaryImageOverlayActor.cxx

diff --git a/vv/vvBinaryImageOverlayActor.cxx b/vv/vvBinaryImageOverlayActor.cxx
index 0405cdb2fda4c4b49968ee2cbd71b6972c242f3d..a30206f21dcd618c93727f87b705f3ec6c45ee44 100644 (file)
--- a/vv/vvBinaryImageOverlayActor.cxx
+++ b/vv/vvBinaryImageOverlayActor.cxx
@@ -39,6 +39,9 @@ vvBinaryImageOverlayActor::vvBinaryImageOverlayActor()
   mImage = 0;
   mSlicer = 0;
   mColorLUT = vtkLookupTable::New();
+  mForegroundValue = 1;
+  mBackgroundValue = 0;
+  m_modeBG = true;
 }
 //------------------------------------------------------------------------------
 
@@ -90,10 +93,31 @@ void vvBinaryImageOverlayActor::Initialize()
     // how many intensity ?
     vtkImageMapToRGBA * mOverlayMapper = vtkImageMapToRGBA::New();
     mOverlayMapper->SetInput(mImage->GetVTKImages()[0]); // DS TODO : to change if it is 4D !!!
-    mColorLUT->SetRange(0,1);
-    mColorLUT->SetNumberOfTableValues(2);
-    mColorLUT->SetTableValue(mBackgroundValue, 0, 0, 0, 0.0);   // BG
-    mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
+
+    // DD("change to nb of intensity");
+    double range[2];
+    mImage->GetVTKImages()[0]->GetScalarRange(range);
+    // DD(range[0]);
+//     DD(range[1]);
+    int n = range[1]-range[0]+1;
+    mColorLUT->SetRange(range[0],range[1]);
+    mColorLUT->SetNumberOfTableValues(n);
+
+    // Mode BG -> all is color except BG
+    if (m_modeBG) {
+      for(int i=0; i<n; i++) {
+       mColorLUT->SetTableValue(i, mColor[0], mColor[1], mColor[2], mAlpha);
+      }
+      mColorLUT->SetTableValue(mBackgroundValue, 0, 0, 0, 0.0);
+    }
+    else {
+      // Mode FG -> all is BG, except FG which is color
+      for(int i=0; i<n; i++) {
+       mColorLUT->SetTableValue(i, 0, 0, 0, 0.0);
+      }
+      mColorLUT->SetTableValue(mForegroundValue, mColor[0], mColor[1], mColor[2], mAlpha);
+    }
+
     mOverlayMapper->SetLookupTable(mColorLUT);
 
     vtkImageActor * mOverlayActor = vtkImageActor::New();
@@ -153,10 +177,19 @@ void vvBinaryImageOverlayActor::SetOpacity(double d)
 
 
 //------------------------------------------------------------------------------
-void vvBinaryImageOverlayActor::SetImage(vvImage::Pointer image, double bg)
+void vvBinaryImageOverlayActor::SetImage(vvImage::Pointer image, double bg, bool modeBG)
 {
+  //  DD("vvBinaryImageOverlayActor::SetImage");
+  //DD(modeBG);
   mImage = image;
-  mBackgroundValue = bg;
+  if (modeBG) {
+    mBackgroundValue = bg;
+    m_modeBG = true;
+  }
+  else {
+    mForegroundValue = bg;
+    m_modeBG = false;
+  }
 }
 //------------------------------------------------------------------------------
 
@@ -169,7 +202,8 @@ void vvBinaryImageOverlayActor::HideActors()
   for(unsigned int i=0; i<mImageActorList.size(); i++) {
     mImageActorList[i]->VisibilityOff();
   }
-  mSlicer->Render();
+  // Caller MUST call Render
+  //  mSlicer->Render();
 }
 //------------------------------------------------------------------------------
 
@@ -184,7 +218,8 @@ void vvBinaryImageOverlayActor::ShowActors()
   mImageActorList[mTSlice]->VisibilityOn();
   UpdateSlice(0, mSlice);
   //}
-  mSlicer->Render();
+  // Caller MUST call Render
+  //mSlicer->Render();
 }
 //------------------------------------------------------------------------------
 
@@ -243,9 +278,9 @@ void vvBinaryImageOverlayActor::UpdateSlice(int slicer, int slice)
 
 //------------------------------------------------------------------------------
 void vvBinaryImageOverlayActor::ComputeExtent(int orientation,
-    int slice,
-    int * inExtent,
-    int * outExtent)
+                                             int slice,
+                                             int * inExtent,
+                                             int * outExtent)
 {
   //  std::cout << "InExtent = " << inExtent[0] << " " << inExtent[1] << " " << inExtent[2] << " "
   //       << inExtent[3] << " " << inExtent[4] << " " << inExtent[5] << std::endl;
@@ -292,13 +327,11 @@ void vvBinaryImageOverlayActor::ComputeExtent(int * inExtent, int * outExtent, v
 
 //------------------------------------------------------------------------------
 void vvBinaryImageOverlayActor::SetDisplayExtentAndCameraPosition(int orientation,
-    int slice,
-    int * extent,
-    vtkImageActor * actor,
-    double position)
+                                                                 int slice,
+                                                                 int * extent,
+                                                                 vtkImageActor * actor,
+                                                                 double position)
 {
-  actor->SetDisplayExtent(extent);
-
   // Set position
   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_XY) {
     if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[2] > slice)
@@ -318,10 +351,7 @@ void vvBinaryImageOverlayActor::SetDisplayExtentAndCameraPosition(int orientatio
     else
       actor->SetPosition(-position,0, 0);
   }
-
+  actor->SetDisplayExtent(extent);
 }
 //------------------------------------------------------------------------------
 
-
-
-