vv/vvROIActor.cxx

   1 /*=========================================================================
   2   Program:   vv                     http://www.creatis.insa-lyon.fr/rio/vv
   3
   4   Authors belong to:
   5   - University of LYON              http://www.universite-lyon.fr/
   6   - Léon Bérard cancer center       http://www.centreleonberard.fr
   7   - CREATIS CNRS laboratory         http://www.creatis.insa-lyon.fr
   8
   9   This software is distributed WITHOUT ANY WARRANTY; without even
  10   the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  11   PURPOSE.  See the copyright notices for more information.
  12
  13   It is distributed under dual licence
  14
  15   - BSD        See included LICENSE.txt file
  16   - CeCILL-B   http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  17   ===========================================================================**/
  18
  19 // vv
  20 #include "vvROIActor.h"
  21 #include "vvSlicerManager.h"
  22
  23 // vtk
  24 #include <vtkImageActor.h>
  25 #include <vtkCamera.h>
  26 #include <vtkRenderer.h>
  27 #include <vtkMarchingSquares.h>
  28 #include <vtkImageClip.h>
  29 #include <vtkImageData.h>
  30 #include <vtkPolyDataMapper.h>
  31 #include <vtkProperty.h>
  32
  33 //------------------------------------------------------------------------------
  34 vvROIActor::vvROIActor()
  35 {
  36   mIsVisible = true;
  37   mIsContourVisible = false;
  38   mOpacity = 0.7;
  39   mIsSelected = false;
  40   mContourWidth = 1;
  41   mContourColor.resize(3);
  42   m_modeBG = true;
  43 }
  44 //------------------------------------------------------------------------------
  45
  46
  47 //------------------------------------------------------------------------------
  48 vvROIActor::~vvROIActor()
  49 {
  50 }
  51 //------------------------------------------------------------------------------
  52
  53
  54 //------------------------------------------------------------------------------
  55 void vvROIActor::SetROI(clitk::DicomRT_ROI * s)
  56 {
  57   mROI = s;
  58 }
  59 //------------------------------------------------------------------------------
  60
  61
  62 //------------------------------------------------------------------------------
  63 void vvROIActor::SetContourWidth(int n) {
  64   mContourWidth = n;
  65 }
  66 //------------------------------------------------------------------------------
  67
  68
  69 //------------------------------------------------------------------------------
  70 void vvROIActor::SetSlicerManager(vvSlicerManager * s) {
  71   mSlicerManager = s;
  72 }
  73 //------------------------------------------------------------------------------
  74
  75
  76 //------------------------------------------------------------------------------
  77 void vvROIActor::UpdateImage()
  78 {
  79   mOverlayActors.clear();
  80   mImageContour.clear();
  81   Initialize(mIsVisible);
  82   Update(); // No Render
  83 }
  84 //------------------------------------------------------------------------------
  85
  86
  87 //------------------------------------------------------------------------------
  88 void vvROIActor::SetVisible(bool b)
  89 {
  90   mIsVisible = b;
  91   if (!b) { // remove actor
  92     for(unsigned int i= 0; i<mOverlayActors.size(); i++)
  93       mOverlayActors[i]->HideActors();
  94   } else {
  95     for(unsigned int i= 0; i<mOverlayActors.size(); i++)
  96       mOverlayActors[i]->ShowActors();
  97   }
  98   Update(); // No Render
  99 }
 100 //------------------------------------------------------------------------------
 101
 102
 103 //------------------------------------------------------------------------------
 104 void vvROIActor::SetContourVisible(bool b) {
 105   mIsContourVisible = b;
 106   if (!b) { // remove actor
 107     for(unsigned int i= 0; i<mImageContour.size(); i++) {
 108       mImageContour[i]->HideActors();
 109     }
 110   }
 111   else {
 112     for(unsigned int i= 0; i<mImageContour.size(); i++) {
 113       mImageContour[i]->ShowActors();
 114     }
 115   }
 116   Update(); // No Render
 117 }
 118 //------------------------------------------------------------------------------
 119
 120
 121 //------------------------------------------------------------------------------
 122 bool vvROIActor::IsVisible() {
 123   return mIsVisible;
 124 }
 125 //------------------------------------------------------------------------------
 126
 127
 128 //------------------------------------------------------------------------------
 129 bool vvROIActor::IsContourVisible() {
 130   return mIsContourVisible;
 131 }
 132 //------------------------------------------------------------------------------
 133
 134
 135 //------------------------------------------------------------------------------
 136 void vvROIActor::Initialize(bool IsVisible) {
 137   if (mROI->GetImage()) {
 138     mImageContour.clear();
 139     mOverlayActors.clear();
 140     for(int i=0; i<mSlicerManager->GetNumberOfSlicers(); i++) {
 141
 142       mImageContour.push_back(vvImageContour::New());
 143       mImageContour[i]->SetSlicer(mSlicerManager->GetSlicer(i));
 144       mImageContour[i]->SetImage(mROI->GetImage());
 145       mContourColor[0] = mROI->GetDisplayColor()[0];
 146       mContourColor[1] = mROI->GetDisplayColor()[1];
 147       mContourColor[2] = mROI->GetDisplayColor()[2];
 148       mImageContour[i]->SetColor(mContourColor[0], mContourColor[1], mContourColor[2]);
 149       mImageContour[i]->SetLineWidth(mContourWidth);
 150       mImageContour[i]->SetPreserveMemoryModeEnabled(true);
 151       //mImageContour[i]->SetPreserveMemoryModeEnabled(false); // SEG FAULT !!!
 152       mImageContour[i]->SetSlicer(mSlicerManager->GetSlicer(i));
 153       mImageContour[i]->HideActors();
 154
 155       mOverlayActors.push_back(vvBinaryImageOverlayActor::New());
 156
 157       // BG or FG
 158       if (m_modeBG) {
 159         mOverlayActors[i]->SetImage(mROI->GetImage(), mROI->GetBackgroundValueLabelImage());
 160       }
 161       else {
 162         mOverlayActors[i]->SetImage(mROI->GetImage(), mROI->GetForegroundValueLabelImage(), false);
 163       }
 164
 165
 166       mOverlayActors[i]->SetColor(mROI->GetDisplayColor()[0],
 167                                   mROI->GetDisplayColor()[1],
 168                                   mROI->GetDisplayColor()[2]);
 169       mOverlayActors[i]->SetOpacity(mOpacity);
 170       mOverlayActors[i]->SetSlicer(mSlicerManager->GetSlicer(i));
 171       mOverlayActors[i]->Initialize(IsVisible);
 172     }
 173
 174     connect(mSlicerManager,SIGNAL(UpdateSlice(int,int)),this,SLOT(UpdateSlice(int, int)));
 175     //connect(mSlicerManager,SIGNAL(UpdateTSlice(int,int)),this,SLOT(UpdateSlice(int, int)));
 176     connect(mSlicerManager, SIGNAL(AVerticalSliderHasChanged(int, int)), SLOT(UpdateSlice(int, int)));
 177   }
 178 }
 179 //------------------------------------------------------------------------------
 180
 181
 182 //------------------------------------------------------------------------------
 183 void vvROIActor::Update()
 184 {
 185   for(int i=0; i<mSlicerManager->GetNumberOfSlicers(); i++) {
 186     UpdateSlice(i, mSlicerManager->GetSlicer(i)->GetSlice());
 187   }
 188 }
 189 //------------------------------------------------------------------------------
 190
 191
 192 //------------------------------------------------------------------------------
 193 void vvROIActor::UpdateSlice(int slicer, int slices)
 194 {
 195   if (!mROI->GetImage())  return;
 196   if ((!mIsVisible) && (!mIsContourVisible)) return;
 197   if (!mSlicerManager) {
 198     std::cerr << "Error. No mSlicerManager ?" << std::endl;
 199     exit(0);
 200   }
 201
 202   if (mIsContourVisible) {
 203     mImageContour[slicer]->Update(mROI->GetBackgroundValueLabelImage()+1);
 204   }
 205
 206   // Refresh overlays
 207   mOverlayActors[slicer]->UpdateSlice(slicer, slices);
 208 }
 209 //------------------------------------------------------------------------------
 210
 211
 212 //------------------------------------------------------------------------------
 213 void vvROIActor::SetOpacity(double d)
 214 {
 215   mOpacity = d;
 216 }
 217 //------------------------------------------------------------------------------
 218
 219
 220 //------------------------------------------------------------------------------
 221 void vvROIActor::SetContourColor(double r, double v, double b) {
 222   mContourColor[0] = r;
 223   mContourColor[1] = v;
 224   mContourColor[2] = b;
 225 }
 226 //------------------------------------------------------------------------------
 227
 228
 229 //------------------------------------------------------------------------------
 230 std::vector<double> & vvROIActor::GetContourColor() {
 231   return mContourColor;
 232 }
 233 //------------------------------------------------------------------------------
 234
 235
 236 //------------------------------------------------------------------------------
 237 void vvROIActor::UpdateColor() {
 238   for(unsigned int i=0; i<mOverlayActors.size(); i++) {
 239     mOverlayActors[i]->SetOpacity(mOpacity);
 240     mOverlayActors[i]->SetColor(mROI->GetDisplayColor()[0],
 241                                 mROI->GetDisplayColor()[1],
 242                                 mROI->GetDisplayColor()[2]);
 243     mOverlayActors[i]->UpdateColor();
 244   }
 245   for(unsigned int i=0; i<mImageContour.size(); i++) {
 246     mImageContour[i]->SetLineWidth(mContourWidth);
 247     mImageContour[i]->SetColor(mContourColor[0], mContourColor[1], mContourColor[2]);
 248     if (mIsContourVisible)
 249       mImageContour[i]->Update(mROI->GetBackgroundValueLabelImage()+1);
 250   }
 251 }
 252 //------------------------------------------------------------------------------
 253
 254
 255 //------------------------------------------------------------------------------
 256 double vvROIActor::GetOpacity()
 257 {
 258   return mOpacity;
 259 }
 260 //------------------------------------------------------------------------------
 261
 262
 263 //------------------------------------------------------------------------------
 264 void vvROIActor::SetSelected(bool b)
 265 {
 266   mIsSelected = b;
 267   if (b) {
 268     for(int i=0; i<mSlicerManager->GetNumberOfSlicers(); i++) {
 269       mImageContour[i]->SetLineWidth(3.0);
 270       mImageContour[i]->ShowActors();
 271     }
 272   } else {
 273     for(int i=0; i<mSlicerManager->GetNumberOfSlicers(); i++) {
 274       mImageContour[i]->HideActors();
 275     }
 276   }
 277 }
 278 //------------------------------------------------------------------------------
 279