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.5;
  39   mIsSelected = false;
  40   mContourWidth = 1;
  41   mContourColor.resize(3);
  42   m_modeBG = true;
  43   mDepth = 1.0;
  44   mROI = 0;
  45   mSlicerManager = 0;
  46   mContourColor[0] = 1;
  47   mContourColor[1] = 1;
  48   mContourColor[2] = 1;
  49 }
  50 //------------------------------------------------------------------------------
  51
  52
  53 //------------------------------------------------------------------------------
  54 vvROIActor::~vvROIActor()
  55 {
  56 }
  57 //------------------------------------------------------------------------------
  58
  59
  60 //------------------------------------------------------------------------------
  61 void vvROIActor::RemoveActors()
  62 {
  63   for(unsigned int i= 0; i<mOverlayActors.size(); i++) {
  64     mOverlayActors[i]->RemoveActors();
  65   }
  66
  67   for(unsigned int i= 0; i<mImageContour.size(); i++) {
  68     mImageContour[i]->RemoveActors();
  69   }
  70
  71   Update(true);
  72   //mImageContour.clear();
  73   //mOverlayActors.clear();
  74 }
  75 //------------------------------------------------------------------------------
  76
  77
  78 //------------------------------------------------------------------------------
  79 void vvROIActor::SetROI(clitk::DicomRT_ROI * s)
  80 {
  81   mROI = s;
  82 }
  83 //------------------------------------------------------------------------------
  84
  85
  86 //------------------------------------------------------------------------------
  87 void vvROIActor::SetContourWidth(int n)
  88 {
  89   mContourWidth = n;
  90 }
  91 //------------------------------------------------------------------------------
  92
  93
  94 //------------------------------------------------------------------------------
  95 void vvROIActor::SetSlicerManager(vvSlicerManager * s)
  96 {
  97   mSlicerManager = s;
  98 }
  99 //------------------------------------------------------------------------------
 100
 101
 102 //------------------------------------------------------------------------------
 103 void vvROIActor::UpdateImage()
 104 {
 105   mOverlayActors.clear();
 106   mImageContour.clear();
 107   Initialize(mDepth, mIsVisible);
 108   Update(); // No Render
 109 }
 110 //------------------------------------------------------------------------------
 111
 112
 113 //------------------------------------------------------------------------------
 114 void vvROIActor::SetVisible(bool b)
 115 {
 116   mIsVisible = b;
 117   if (!b) { // remove actor
 118     for(unsigned int i= 0; i<mOverlayActors.size(); i++)
 119       mOverlayActors[i]->HideActors();
 120   } else {
 121     for(unsigned int i= 0; i<mOverlayActors.size(); i++)
 122       mOverlayActors[i]->ShowActors();
 123   }
 124   //Update(); // No Render
 125 }
 126 //------------------------------------------------------------------------------
 127
 128
 129 //------------------------------------------------------------------------------
 130 void vvROIActor::SetContourVisible(bool b)
 131 {
 132   mIsContourVisible = b;
 133   if (!b) { // remove actor
 134     for(unsigned int i= 0; i<mImageContour.size(); i++) {
 135       mImageContour[i]->HideActors();
 136     }
 137   }
 138   else {
 139     for(unsigned int i= 0; i<mImageContour.size(); i++) {
 140       mImageContour[i]->ShowActors();
 141     }
 142   }
 143   //Update(); // No Render
 144 }
 145 //------------------------------------------------------------------------------
 146
 147
 148 //------------------------------------------------------------------------------
 149 bool vvROIActor::IsVisible()
 150 {
 151   return mIsVisible;
 152 }
 153 //------------------------------------------------------------------------------
 154
 155
 156 //------------------------------------------------------------------------------
 157 bool vvROIActor::IsContourVisible()
 158 {
 159   return mIsContourVisible;
 160 }
 161 //------------------------------------------------------------------------------
 162
 163
 164 //------------------------------------------------------------------------------
 165 void vvROIActor::Initialize(double depth, bool IsVisible)
 166 {
 167   if (mROI->GetImage()) {
 168     mImageContour.clear();
 169     mOverlayActors.clear();
 170     mDepth = depth;
 171     for(int i=0; i<mSlicerManager->GetNumberOfSlicers(); i++) {
 172       mImageContour.push_back(vvImageContour::New());
 173       mImageContour[i]->SetSlicer(mSlicerManager->GetSlicer(i));
 174       mImageContour[i]->SetImage(mROI->GetImage());
 175       // Color of the contour is same of roi color
 176       mContourColor[0] = mROI->GetDisplayColor()[0];
 177       mContourColor[1] = mROI->GetDisplayColor()[1];
 178       mContourColor[2] = mROI->GetDisplayColor()[2];
 179       mImageContour[i]->SetColor(mContourColor[0], mContourColor[1], mContourColor[2]);
 180       mImageContour[i]->SetLineWidth(mContourWidth);
 181       mImageContour[i]->SetPreserveMemoryModeEnabled(true);
 182       mImageContour[i]->SetDepth(mDepth+0.5);
 183       mImageContour[i]->ShowActors();
 184
 185       mOverlayActors.push_back(vvBinaryImageOverlayActor::New());
 186
 187       // BG or FG
 188       if (m_modeBG)
 189         mOverlayActors[i]->SetImage(mROI->GetImage(), mROI->GetBackgroundValueLabelImage());
 190       else
 191         mOverlayActors[i]->SetImage(mROI->GetImage(), mROI->GetForegroundValueLabelImage(), false);
 192
 193
 194
 195       mOverlayActors[i]->SetColor(mROI->GetDisplayColor()[0],
 196                                   mROI->GetDisplayColor()[1],
 197                                   mROI->GetDisplayColor()[2]);
 198       mOverlayActors[i]->SetOpacity(mOpacity);
 199       mOverlayActors[i]->SetSlicer(mSlicerManager->GetSlicer(i));
 200       mOverlayActors[i]->Initialize(IsVisible);
 201       mOverlayActors[i]->SetDepth(mDepth);
 202     }
 203     connect(mSlicerManager,SIGNAL(UpdateSlice(int,int)),this,SLOT(UpdateSlice(int, int)));
 204     connect(mSlicerManager,SIGNAL(UpdateTSlice(int,int,int)),this,SLOT(UpdateSlice(int, int, int)));
 205     connect(mSlicerManager, SIGNAL(AVerticalSliderHasChanged(int, int)), SLOT(UpdateSlice(int, int)));
 206   }
 207 }
 208 //------------------------------------------------------------------------------
 209
 210
 211 //------------------------------------------------------------------------------
 212 void vvROIActor::SetDepth(double d)
 213 {
 214   mDepth = d;
 215   if (!mSlicerManager) return;
 216   for(int i=0; i<mSlicerManager->GetNumberOfSlicers(); i++) {
 217     mOverlayActors[i]->SetDepth(d);
 218     mImageContour[i]->SetDepth(d+0.5);
 219   }
 220   Update(true);
 221 }
 222 //------------------------------------------------------------------------------
 223
 224
 225 //------------------------------------------------------------------------------
 226 void vvROIActor::Update(bool force)
 227 {
 228   if (!mSlicerManager) return;
 229   for(int i=0; i<mSlicerManager->GetNumberOfSlicers(); i++) {
 230     UpdateSlice(i, mSlicerManager->GetSlicer(i)->GetSlice(), force);
 231   }
 232 }
 233 //------------------------------------------------------------------------------
 234
 235
 236 //------------------------------------------------------------------------------
 237 void vvROIActor::UpdateSlice(int slicer, int slices, int force)
 238 {
 239   if (!mROI->GetImage())  return;
 240   if ((!mIsVisible) && (!mIsContourVisible)) return;
 241   if (!mSlicerManager) {
 242     std::cerr << "Error. No mSlicerManager ?" << std::endl;
 243     exit(0);
 244   }
 245
 246   if (mIsContourVisible) {
 247     mImageContour[slicer]->Update(mROI->GetBackgroundValueLabelImage()+1);
 248   }
 249
 250   // Refresh overlays
 251   if (mIsVisible) {
 252     mOverlayActors[slicer]->UpdateSlice(slicer, slices, force);
 253   }
 254   //mSlicerManager->GetSlicer(slicer)->Render();
 255 }
 256 //------------------------------------------------------------------------------
 257
 258
 259 //------------------------------------------------------------------------------
 260 void vvROIActor::SetOpacity(double d)
 261 {
 262   mOpacity = d;
 263 }
 264 //------------------------------------------------------------------------------
 265
 266
 267 //------------------------------------------------------------------------------
 268 void vvROIActor::SetContourColor(double r, double v, double b)
 269 {
 270   mContourColor[0] = r;
 271   mContourColor[1] = v;
 272   mContourColor[2] = b;
 273 }
 274 //------------------------------------------------------------------------------
 275
 276
 277 //------------------------------------------------------------------------------
 278 void vvROIActor::SetOverlayColor(double r, double v, double b)
 279 {
 280   if (mROI)
 281     mROI->SetDisplayColor(r,v,b);
 282 }
 283 //------------------------------------------------------------------------------
 284
 285
 286 //------------------------------------------------------------------------------
 287 std::vector<double> & vvROIActor::GetContourColor()
 288 {
 289   return mContourColor;
 290 }
 291 //------------------------------------------------------------------------------
 292
 293
 294 //------------------------------------------------------------------------------
 295 std::vector<double> & vvROIActor::GetOverlayColor()
 296 {
 297   return mROI->GetDisplayColor();
 298 }
 299 //------------------------------------------------------------------------------
 300
 301
 302 //------------------------------------------------------------------------------
 303 void vvROIActor::UpdateColor()
 304 {
 305   for(unsigned int i=0; i<mOverlayActors.size(); i++) {
 306     mOverlayActors[i]->SetOpacity(mOpacity);
 307     mOverlayActors[i]->SetColor(mROI->GetDisplayColor()[0],
 308                                 mROI->GetDisplayColor()[1],
 309                                 mROI->GetDisplayColor()[2]);
 310     mOverlayActors[i]->UpdateColor();
 311   }
 312   for(unsigned int i=0; i<mImageContour.size(); i++) {
 313     mImageContour[i]->SetLineWidth(mContourWidth);
 314     mImageContour[i]->SetColor(mContourColor[0], mContourColor[1], mContourColor[2]);
 315     if (mIsContourVisible)
 316       mImageContour[i]->Update(mROI->GetBackgroundValueLabelImage()+1);
 317   }
 318 }
 319 //------------------------------------------------------------------------------
 320
 321
 322 //------------------------------------------------------------------------------
 323 double vvROIActor::GetOpacity()
 324 {
 325   return mOpacity;
 326 }
 327 //------------------------------------------------------------------------------
 328
 329
 330 //------------------------------------------------------------------------------
 331 void vvROIActor::SetSelected(bool b)
 332 {
 333   mIsSelected = b;
 334   if (b) {
 335     for(int i=0; i<mSlicerManager->GetNumberOfSlicers(); i++) {
 336       mImageContour[i]->SetLineWidth(3.0);
 337       mImageContour[i]->ShowActors();
 338     }
 339   } else {
 340     for(int i=0; i<mSlicerManager->GetNumberOfSlicers(); i++) {
 341       mImageContour[i]->HideActors();
 342     }
 343   }
 344 }
 345 //------------------------------------------------------------------------------
 346
 347
 348 //------------------------------------------------------------------------------
 349 void vvROIActor::CopyParameters(QSharedPointer<vvROIActor> roi)
 350 {
 351   // Overlay
 352   SetVisible(roi->IsVisible());
 353   SetOpacity(roi->GetOpacity());
 354   SetOverlayColor(roi->GetOverlayColor()[0], roi->GetOverlayColor()[1], roi->GetOverlayColor()[2]);
 355
 356   // Contour
 357   SetContourVisible(roi->IsContourVisible());
 358   SetContourWidth(roi->GetContourWidth());
 359   SetContourColor(roi->GetContourColor()[0], roi->GetContourColor()[1], roi->GetContourColor()[2]);
 360
 361   // Global
 362   SetDepth(roi->GetDepth());
 363 }
 364 //------------------------------------------------------------------------------