X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=vv%2FvvROIActor.cxx;h=b46ae0ac990b0bcc058f6b864292fb3c1d467761;hb=efba8919f9e2fb300f82d5bd2cafe70a0f7cffd1;hp=abf3eb6ca2e8cb4388316a5ce04bef4bc55530dc;hpb=1e034c70105f0926939acaaa27ddb46e904ae8bf;p=clitk.git

diff --git a/vv/vvROIActor.cxx b/vv/vvROIActor.cxx
index abf3eb6..b46ae0a 100644
--- a/vv/vvROIActor.cxx
+++ b/vv/vvROIActor.cxx
@@ -3,7 +3,7 @@
 
   Authors belong to:
   - University of LYON              http://www.universite-lyon.fr/
-  - Léon Bérard cancer center       http://oncora1.lyon.fnclcc.fr
+  - Léon Bérard cancer center       http://www.centreleonberard.fr
   - CREATIS CNRS laboratory         http://www.creatis.insa-lyon.fr
 
   This software is distributed WITHOUT ANY WARRANTY; without even
@@ -14,16 +14,16 @@
 
   - BSD        See included LICENSE.txt file
   - CeCILL-B   http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
-  ======================================================================-====*/
+  ===========================================================================**/
 
+// vv
 #include "vvROIActor.h"
-#include "vvImageContour.h"
 #include "vvSlicerManager.h"
-#include "vvBinaryImageOverlayActor.h"
+
+// vtk
 #include <vtkImageActor.h>
 #include <vtkCamera.h>
 #include <vtkRenderer.h>
-//#include <vtkRenderWindow.h>
 #include <vtkMarchingSquares.h>
 #include <vtkImageClip.h>
 #include <vtkImageData.h>
@@ -33,11 +33,14 @@
 //------------------------------------------------------------------------------
 vvROIActor::vvROIActor()
 {
-  mImageContour.clear();
-  mOverlayActors.clear();
   mIsVisible = true;
+  mIsContourVisible = false;
   mOpacity = 0.7;
   mIsSelected = false;
+  mContourWidth = 1;
+  mContourColor.resize(3);
+  m_modeBG = true;
+  mDepth = 1.0;
 }
 //------------------------------------------------------------------------------
 
@@ -58,13 +61,30 @@ void vvROIActor::SetROI(clitk::DicomRT_ROI * s)
 
 
 //------------------------------------------------------------------------------
-void vvROIActor::SetSlicerManager(vvSlicerManager * s)
-{
+void vvROIActor::SetContourWidth(int n) {
+  mContourWidth = n;
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvROIActor::SetSlicerManager(vvSlicerManager * s) {
   mSlicerManager = s;
 }
 //------------------------------------------------------------------------------
 
 
+//------------------------------------------------------------------------------
+void vvROIActor::UpdateImage()
+{
+  mOverlayActors.clear();
+  mImageContour.clear();
+  Initialize(mDepth, mIsVisible);
+  Update(); // No Render
+}
+//------------------------------------------------------------------------------
+
+
 //------------------------------------------------------------------------------
 void vvROIActor::SetVisible(bool b)
 {
@@ -76,44 +96,83 @@ void vvROIActor::SetVisible(bool b)
     for(unsigned int i= 0; i<mOverlayActors.size(); i++)
       mOverlayActors[i]->ShowActors();
   }
-  Update();
+  Update(); // No Render
 }
 //------------------------------------------------------------------------------
 
 
 //------------------------------------------------------------------------------
-bool vvROIActor::IsVisible()
-{
+void vvROIActor::SetContourVisible(bool b) {
+  mIsContourVisible = b;
+  if (!b) { // remove actor
+    for(unsigned int i= 0; i<mImageContour.size(); i++) {
+      mImageContour[i]->HideActors();
+    }
+  }
+  else {
+    for(unsigned int i= 0; i<mImageContour.size(); i++) {
+      mImageContour[i]->ShowActors();
+    }
+  }
+  Update(); // No Render
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+bool vvROIActor::IsVisible() {
   return mIsVisible;
 }
 //------------------------------------------------------------------------------
 
 
 //------------------------------------------------------------------------------
-void vvROIActor::Initialize()
-{
+bool vvROIActor::IsContourVisible() {
+  return mIsContourVisible;
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+void vvROIActor::Initialize(double depth, bool IsVisible) {
   if (mROI->GetImage()) {
     mImageContour.clear();
     mOverlayActors.clear();
-    for(int i=0; i<mSlicerManager->NumberOfSlicers(); i++) {
-      mImageContour.push_back(new vvImageContour);
-      mImageContour[i]->setSlicer(mSlicerManager->GetSlicer(i));
-      mImageContour[i]->setImage(mROI->GetImage());
-      //mImageContour[i]->setColor(1.0, 0.0, 0.0);
-      mImageContour[i]->setColor(1.0-mROI->GetDisplayColor()[0],
-                                 1.0-mROI->GetDisplayColor()[1],
-                                 1.0-mROI->GetDisplayColor()[2]);
-      mImageContour[i]->setPreserveMemoryModeEnabled(true);
-      mImageContour[i]->setSlicer(mSlicerManager->GetSlicer(i));
-
-      mOverlayActors.push_back(new vvBinaryImageOverlayActor);
-      mOverlayActors[i]->SetImage(mROI->GetImage(), mROI->GetBackgroundValueLabelImage());
+    mDepth = depth;
+    for(int i=0; i<mSlicerManager->GetNumberOfSlicers(); i++) {
+
+      mImageContour.push_back(vvImageContour::New());
+      mImageContour[i]->SetSlicer(mSlicerManager->GetSlicer(i));
+      mImageContour[i]->SetImage(mROI->GetImage());
+      mContourColor[0] = mROI->GetDisplayColor()[0];
+      mContourColor[1] = mROI->GetDisplayColor()[1];
+      mContourColor[2] = mROI->GetDisplayColor()[2];
+      mImageContour[i]->SetColor(mContourColor[0], mContourColor[1], mContourColor[2]);
+      mImageContour[i]->SetLineWidth(mContourWidth);
+      mImageContour[i]->SetPreserveMemoryModeEnabled(true);
+      mImageContour[i]->SetDepth(mDepth);
+      //mImageContour[i]->SetPreserveMemoryModeEnabled(false); // SEG FAULT !!!
+      mImageContour[i]->SetSlicer(mSlicerManager->GetSlicer(i));
+      mImageContour[i]->HideActors();
+      
+      mOverlayActors.push_back(vvBinaryImageOverlayActor::New());
+
+      // BG or FG
+      if (m_modeBG) {
+	mOverlayActors[i]->SetImage(mROI->GetImage(), mROI->GetBackgroundValueLabelImage());
+      }
+      else {
+	mOverlayActors[i]->SetImage(mROI->GetImage(), mROI->GetForegroundValueLabelImage(), false);
+      }
+
+
       mOverlayActors[i]->SetColor(mROI->GetDisplayColor()[0],
                                   mROI->GetDisplayColor()[1],
                                   mROI->GetDisplayColor()[2]);
       mOverlayActors[i]->SetOpacity(mOpacity);
       mOverlayActors[i]->SetSlicer(mSlicerManager->GetSlicer(i));
-      mOverlayActors[i]->Initialize();
+      mOverlayActors[i]->Initialize(IsVisible);      
+      mOverlayActors[i]->SetDepth(mDepth);
     }
 
     connect(mSlicerManager,SIGNAL(UpdateSlice(int,int)),this,SLOT(UpdateSlice(int, int)));
@@ -125,70 +184,74 @@ void vvROIActor::Initialize()
 
 
 //------------------------------------------------------------------------------
-void vvROIActor::Update()
+void vvROIActor::SetDepth(double d)
 {
-  for(int i=0; i<mSlicerManager->NumberOfSlicers(); i++) {
-    UpdateSlice(i, mSlicerManager->GetSlicer(i)->GetSlice());
+  mDepth = d;
+  for(int i=0; i<mSlicerManager->GetNumberOfSlicers(); i++) {  
+    mOverlayActors[i]->SetDepth(d);
+    mImageContour[i]->SetDepth(d);
   }
+  Update(true);
 }
 //------------------------------------------------------------------------------
 
 
 //------------------------------------------------------------------------------
-void vvROIActor::UpdateSlice(int slicer, int slices)
+void vvROIActor::Update(bool force)
 {
-  if (!mROI->GetImage())  return;
+  for(int i=0; i<mSlicerManager->GetNumberOfSlicers(); i++) {
+    UpdateSlice(i, mSlicerManager->GetSlicer(i)->GetSlice(), force);
+  }
+}
+//------------------------------------------------------------------------------
 
-  if (!mIsVisible) return;
 
+//------------------------------------------------------------------------------
+void vvROIActor::UpdateSlice(int slicer, int slices, bool force)
+{
+  if (!mROI->GetImage())  return;
+  if ((!mIsVisible) && (!mIsContourVisible)) return; 
   if (!mSlicerManager) {
     std::cerr << "Error. No mSlicerManager ?" << std::endl;
     exit(0);
   }
 
-  // CONTOUR HERE
-  DD("vvROIActor::UpdateSlice");
-  DD(mROI->GetName());
-  DD(mIsSelected);
-  DD(mROI->GetBackgroundValueLabelImage());
-  if (mIsSelected) {
-    mImageContour[slicer]->update(1.0);//mROI->GetBackgroundValueLabelImage());
-    //    mImageContour[slicer]->showActors();
+  if (mIsContourVisible) {
+    mImageContour[slicer]->Update(mROI->GetBackgroundValueLabelImage()+1); 
   }
 
   // Refresh overlays
-  mOverlayActors[slicer]->UpdateSlice(slicer, slices);
+  mOverlayActors[slicer]->UpdateSlice(slicer, slices, force);
+}
+//------------------------------------------------------------------------------
+
 
-  // Do not used the following line : TOO SLOW.
-  // mSlicerManager->GetSlicer(slicer)->GetRenderWindow()->Render();
+//------------------------------------------------------------------------------
+void vvROIActor::SetOpacity(double d)
+{
+  mOpacity = d;
 }
 //------------------------------------------------------------------------------
 
 
 //------------------------------------------------------------------------------
-// void vvROIActor::UpdateOpacity(double d) {
-//   if (d == mOpacity) return;
-//   mOpacity = d;
-//   for(unsigned int i=0; i<mOverlayActors.size(); i++) {
-//     mOverlayActors[i]->SetOpacity(d);
-//     mOverlayActors[i]->UpdateColor();
-//   }
-//   mSlicerManager->Render();
-// }
+void vvROIActor::SetContourColor(double r, double v, double b) {
+  mContourColor[0] = r;
+  mContourColor[1] = v;
+  mContourColor[2] = b;  
+}
 //------------------------------------------------------------------------------
 
 
 //------------------------------------------------------------------------------
-void vvROIActor::SetOpacity(double d)
-{
-  mOpacity = d;
+std::vector<double> & vvROIActor::GetContourColor() { 
+  return mContourColor; 
 }
 //------------------------------------------------------------------------------
 
 
 //------------------------------------------------------------------------------
-void vvROIActor::UpdateColor()
-{
+void vvROIActor::UpdateColor() {
   for(unsigned int i=0; i<mOverlayActors.size(); i++) {
     mOverlayActors[i]->SetOpacity(mOpacity);
     mOverlayActors[i]->SetColor(mROI->GetDisplayColor()[0],
@@ -196,6 +259,12 @@ void vvROIActor::UpdateColor()
                                 mROI->GetDisplayColor()[2]);
     mOverlayActors[i]->UpdateColor();
   }
+  for(unsigned int i=0; i<mImageContour.size(); i++) {
+    mImageContour[i]->SetLineWidth(mContourWidth);
+    mImageContour[i]->SetColor(mContourColor[0], mContourColor[1], mContourColor[2]);
+    if (mIsContourVisible)
+      mImageContour[i]->Update(mROI->GetBackgroundValueLabelImage()+1);
+  }
 }
 //------------------------------------------------------------------------------
 
@@ -213,13 +282,13 @@ void vvROIActor::SetSelected(bool b)
 {
   mIsSelected = b;
   if (b) {
-    for(int i=0; i<mSlicerManager->NumberOfSlicers(); i++) {
+    for(int i=0; i<mSlicerManager->GetNumberOfSlicers(); i++) {
       mImageContour[i]->SetLineWidth(3.0);
-      mImageContour[i]->showActors();
+      mImageContour[i]->ShowActors();
     }
   } else {
-    for(int i=0; i<mSlicerManager->NumberOfSlicers(); i++) {
-      mImageContour[i]->hideActors();
+    for(int i=0; i<mSlicerManager->GetNumberOfSlicers(); i++) {
+      mImageContour[i]->HideActors();
     }
   }
 }