vv/vvToolStructureSetManager.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://oncora1.lyon.fnclcc.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 "vvToolStructureSetManager.h"
  21 #include "vvImageReader.h"
  22 #include "vvStructureSetActor.h"
  23 #include "vvSlicer.h"
  24 #include "vvROIActor.h"
  25
  26 // Qt
  27 #include <QFileDialog>
  28 #include <QMessageBox>
  29 #include <QColorDialog>
  30
  31 // vtk
  32 #include <vtkLookupTable.h>
  33 #include <vtkRenderWindow.h>
  34
  35 //------------------------------------------------------------------------------
  36 // Create the tool and automagically (I like this word) insert it in
  37 // the main window menu.
  38 ADD_TOOL(vvToolStructureSetManager);
  39 //------------------------------------------------------------------------------
  40
  41 int vvToolStructureSetManager::m_NumberOfTool = 0;
  42 std::vector<vvSlicerManager*> vvToolStructureSetManager::mListOfInputs;
  43 std::map<vvSlicerManager*, vvToolStructureSetManager*> vvToolStructureSetManager::mListOfOpenTool;
  44
  45 //------------------------------------------------------------------------------
  46 vvToolStructureSetManager::vvToolStructureSetManager(vvMainWindowBase * parent,
  47                                                      Qt::WindowFlags f,
  48                                                      vvSlicerManager * current):
  49   vvToolWidgetBase(parent, f),
  50   // if Qt::Widget -> No dialog in this case (in tab) ; PB = "invisible widget on menu" !
  51   // if "f" normal widget
  52   vvToolBase<vvToolStructureSetManager>(parent),
  53   Ui::vvToolStructureSetManager()
  54 {
  55   Ui_vvToolStructureSetManager::setupUi(mToolWidget);
  56
  57   //  this->setFixedWidth(120);
  58   m_NumberOfTool++;
  59   mCurrentStructureSetActor = 0;
  60   connect(mCloseButton, SIGNAL(clicked()), this, SLOT(close()));
  61   mCloseButton->setVisible(false);
  62   mTree->clear();
  63   mTree->header()->resizeSection(0, 30);
  64   mMainWindowBase->GetTab()->setTabIcon(mTabNumber, GetToolIcon());
  65   mCurrentStructureSet = NULL;
  66   mCurrentStructureSetIndex = -1;
  67   mGroupBoxROI->setEnabled(false);
  68   mCurrentROIActor = NULL;
  69   mIsAllVisibleEnabled = false;
  70   mNumberOfVisibleROI = 0;
  71   mNumberOfVisibleContourROI = 0;
  72   mDefaultLUTColor = vtkLookupTable::New();
  73   for(unsigned int i=0; i<mDefaultLUTColor->GetNumberOfTableValues(); i++) {
  74     double r = (rand()/(RAND_MAX+1.0));
  75     double v = (rand()/(RAND_MAX+1.0));
  76     double b = (rand()/(RAND_MAX+1.0));
  77     mDefaultLUTColor->SetTableValue(i, r, v, b);
  78     //    std::cout << "mDefaultLUTColor->SetTableValue(" << i << ", " << r << ", " << v << ", " << b << ");" << std::endl;
  79   }
  80 #include "vvDefaultLut.h"
  81
  82   // Add input selector
  83   if (current == NULL) {
  84     MustOpenDialogWhenCreated = true;
  85     AddInputSelector("Select image");
  86   }
  87   else {
  88     MustOpenDialogWhenCreated = false;
  89     mMainButtonBox->setEnabled(true);
  90     mCurrentSlicerManager = current;
  91     mCurrentImage = mCurrentSlicerManager->GetImage();
  92     mToolWidget->setEnabled(true);
  93     InputIsSelected(mCurrentSlicerManager);
  94   }
  95 }
  96 //------------------------------------------------------------------------------
  97
  98
  99 //------------------------------------------------------------------------------
 100 vvToolStructureSetManager::~vvToolStructureSetManager()
 101 {
 102   m_NumberOfTool--;
 103 }
 104 //------------------------------------------------------------------------------
 105
 106
 107 //------------------------------------------------------------------------------
 108 // STATIC
 109 void vvToolStructureSetManager::Initialize() {
 110   SetToolName("ROIManager");
 111   SetToolMenuName("Display ROI");
 112   SetToolIconFilename(":/common/icons/tool-roi.png");
 113   SetToolTip("Display ROI from label image.");
 114   SetToolExperimental(true);
 115 }
 116 //------------------------------------------------------------------------------
 117
 118
 119 //------------------------------------------------------------------------------
 120 void vvToolStructureSetManager::InputIsSelected(vvSlicerManager *m)
 121 {
 122   //int mTabNumber = parent->GetTab()->addTab(this, "");
 123   //  this->setFixedWidth(120);
 124   //this->setPreferedHeight(441);
 125   // Refuse if 4D
 126   if (mCurrentImage->GetNumberOfDimensions() != 3) {
 127     QMessageBox::information(this,tr("Sorry only 3D yet"), tr("Sorry only 3D yet"));
 128     close();
 129   }
 130   // Hide selector
 131   HideInputSelector(); // splitter
 132   mToolInputSelectionWidget->hide();
 133   mLabelInputInfo->setText(QString("%1").arg(m->GetFileName().c_str()));
 134
 135   // add to instance
 136   // if (!isWindow()) {
 137   mListOfInputs.push_back(mCurrentSlicerManager);
 138   mListOfOpenTool[mCurrentSlicerManager] = this;
 139   // }
 140
 141   // Connect open menus
 142   connect(mOpenBinaryButton, SIGNAL(clicked()), this, SLOT(OpenBinaryImage()));
 143   connect(mTree, SIGNAL(itemSelectionChanged()), this, SLOT(SelectedItemChangedInTree()));
 144   connect(mCheckBoxShow, SIGNAL(toggled(bool)), this, SLOT(VisibleROIToggled(bool)));
 145   connect(mOpacitySlider, SIGNAL(valueChanged(int)), this, SLOT(OpacityChanged(int)));
 146   connect(mChangeColorButton, SIGNAL(clicked()), this, SLOT(ChangeColor()));
 147   connect(mContourCheckBoxShow, SIGNAL(toggled(bool)), this, SLOT(VisibleContourROIToggled(bool)));
 148   connect(mChangeContourColorButton, SIGNAL(clicked()), this, SLOT(ChangeContourColor()));
 149   connect(mContourWidthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(ChangeContourWidth(int)));
 150   connect(mReloadButton, SIGNAL(clicked()), this, SLOT(ReloadCurrentROI()));
 151   connect(mCheckBoxShowAll, SIGNAL(stateChanged(int)), this, SLOT(AllVisibleROIToggled(int)));
 152   connect(mContourCheckBoxShowAll, SIGNAL(toggled(bool)), this, SLOT(AllVisibleContourROIToggled(bool)));
 153
 154   // Browse to load image
 155   if (MustOpenDialogWhenCreated)
 156     OpenBinaryImage();
 157 }
 158 //------------------------------------------------------------------------------
 159
 160
 161 //------------------------------------------------------------------------------
 162 void vvToolStructureSetManager::Open(int type) {
 163   switch (type) {
 164   case 0: OpenBinaryImage(); return; // Open binary image;
 165   case 1: DD("TODO"); return; // Open DICOM RT
 166   case 2: DD("TODO"); return; // Open mesh
 167   default: std::cerr << "Error ????" << std::endl; exit(0);
 168   }
 169 }
 170 //------------------------------------------------------------------------------
 171
 172
 173 //------------------------------------------------------------------------------
 174 void vvToolStructureSetManager::AddRoiInTreeWidget(clitk::DicomRT_ROI * roi, QTreeWidget * ww) {
 175   QTreeWidgetItem * w = new QTreeWidgetItem(ww);
 176   w->setText(0, QString("%1").arg(roi->GetROINumber()));
 177   w->setText(1, QString("%1").arg(roi->GetName().c_str()));
 178   QBrush brush(QColor(roi->GetDisplayColor()[0]*255, roi->GetDisplayColor()[1]*255, roi->GetDisplayColor()[2]*255));
 179   brush.setStyle(Qt::SolidPattern);
 180   w->setBackground(2, brush);
 181   mMapROIToTreeWidget[roi] = w;
 182   mMapTreeWidgetToROI[w] = roi;
 183   mTree->resizeColumnToContents(0);
 184   mTree->resizeColumnToContents(1);
 185 }
 186 //------------------------------------------------------------------------------
 187
 188
 189 //------------------------------------------------------------------------------
 190 void vvToolStructureSetManager::UpdateStructureSetInTreeWidget(int index, clitk::DicomRT_StructureSet * s) {
 191   // Insert ROI
 192   const std::vector<clitk::DicomRT_ROI*> & rois = s->GetListOfROI();
 193   for(unsigned int i=0; i<rois.size(); i++) {
 194     if (mMapROIToTreeWidget.find(rois[i]) == mMapROIToTreeWidget.end())
 195       AddRoiInTreeWidget(rois[i], mTree); // replace mTree with ss if several SS
 196   }
 197 }
 198 //------------------------------------------------------------------------------
 199
 200
 201 //------------------------------------------------------------------------------
 202 int vvToolStructureSetManager::AddStructureSet(clitk::DicomRT_StructureSet * mStructureSet) {
 203   // Create actor for this SS
 204   vvStructureSetActor * mStructureSetActor = new vvStructureSetActor;
 205   mStructureSetActor->SetStructureSet(mStructureSet);
 206   mStructureSetActor->SetSlicerManager(mCurrentSlicerManager);
 207   // Insert in lists and get index
 208   mStructureSetsList.push_back(mStructureSet);
 209   mStructureSetActorsList.push_back(mStructureSetActor);
 210   int index = mStructureSetsList.size()-1;
 211   // Return index
 212   return index;
 213 }
 214 //------------------------------------------------------------------------------
 215
 216
 217 //------------------------------------------------------------------------------
 218 void vvToolStructureSetManager::OpenBinaryImage()
 219 {
 220   int index;
 221   if (mCurrentStructureSet == NULL) {
 222     if (mStructureSetsList.size() == 0) { // Create a default SS
 223       clitk::DicomRT_StructureSet * mStructureSet = new clitk::DicomRT_StructureSet;
 224       index = AddStructureSet(mStructureSet);
 225     }
 226     else { // Get first SS
 227       index = 0;
 228     }
 229   } else {
 230     index = mCurrentStructureSetIndex;
 231   }
 232   mCurrentStructureSet = mStructureSetsList[index];
 233   mCurrentStructureSetActor = mStructureSetActorsList[index];
 234   mCurrentStructureSetIndex = index;
 235   // Open images
 236   QString Extensions = "Images files ( *.mhd *.hdr *.his)";
 237   Extensions += ";;All Files (*)";
 238   QStringList filename =
 239     QFileDialog::getOpenFileNames(this,tr("Open binary image"),
 240                                   mMainWindowBase->GetInputPathName(),Extensions);
 241   if (filename.size() == 0) return;
 242   mLoadedROIIndex.clear();
 243   for(int i=0; i<filename.size(); i++) {
 244     // Open Image
 245     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 246     vvImageReader * mReader = new vvImageReader;
 247     std::vector<std::string> filenames;
 248     filenames.push_back(filename[i].toStdString());
 249     mReader->SetInputFilenames(filenames);
 250     mReader->Update(IMAGE);
 251     QApplication::restoreOverrideCursor();
 252
 253     if (mReader->GetLastError().size() != 0) {
 254       std::cerr << "Error while reading " << filename[i].toStdString() << std::endl;
 255       QString error = "Cannot open file \n";
 256       error += mReader->GetLastError().c_str();
 257       QMessageBox::information(this,tr("Reading problem"),error);
 258       delete mReader;
 259       return;
 260     }
 261     vvImage::Pointer binaryImage = mReader->GetOutput();
 262     AddImage(binaryImage, filename[i].toStdString(), mBackgroundValueSpinBox->value());
 263   }
 264   UpdateImage();
 265 }
 266 //------------------------------------------------------------------------------
 267
 268
 269 //------------------------------------------------------------------------------
 270 void vvToolStructureSetManager::UpdateImage()
 271 {
 272   // Update the TreeWidget
 273   UpdateStructureSetInTreeWidget(mCurrentStructureSetIndex, mCurrentStructureSet);
 274   // Render loaded ROIs (the first is sufficient)
 275   for(unsigned int i=0; i<mLoadedROIIndex.size(); i++) {
 276     mCurrentStructureSetActor->GetROIActor(mLoadedROIIndex[i])->Update();
 277   }
 278   for(int i=0; i<mCurrentSlicerManager->NumberOfSlicers(); i++) {
 279     mCurrentSlicerManager->GetSlicer(i)->Render();
 280   }
 281 }
 282 //------------------------------------------------------------------------------
 283
 284
 285 //------------------------------------------------------------------------------
 286 void vvToolStructureSetManager::AddImage(vvImage::Pointer binaryImage, std::string filename, double BG, bool m_modeBG)
 287 {
 288   // Check current structure set
 289   int index;
 290   if (mCurrentStructureSet == NULL) {
 291     if (mStructureSetsList.size() == 0) { // Create a default SS
 292       clitk::DicomRT_StructureSet * mStructureSet = new clitk::DicomRT_StructureSet;
 293       index = AddStructureSet(mStructureSet);
 294     }
 295     else { // Get first SS
 296       index = 0;
 297     }
 298   } else {
 299     index = mCurrentStructureSetIndex;
 300   }
 301   mCurrentStructureSet = mStructureSetsList[index];
 302   mCurrentStructureSetActor = mStructureSetActorsList[index];
 303   mCurrentStructureSetIndex = index;
 304
 305   // Check Dimension
 306   int dim = mCurrentImage->GetNumberOfDimensions();
 307   int bin_dim = binaryImage->GetNumberOfDimensions();
 308   if (dim < bin_dim) {  ////////// TO CHANGE FOR 3D/4D
 309     std::ostringstream os;
 310     os << "Error. Loaded binary image is " << bin_dim
 311        << "D while selected image is " << dim << "D" << std::endl;
 312     QMessageBox::information(this,tr("Reading problem"),os.str().c_str());
 313     return;
 314   }
 315
 316   // Add a new roi to the structure
 317   int n = mCurrentStructureSet->AddBinaryImageAsNewROI(binaryImage, filename);
 318   mLoadedROIIndex.push_back(n);
 319   if (m_modeBG)
 320     mCurrentStructureSet->GetROI(n)->SetBackgroundValueLabelImage(BG);
 321   else
 322     mCurrentStructureSet->GetROI(n)->SetForegroundValueLabelImage(BG);
 323
 324   // Change color
 325   if (n<mDefaultLUTColor->GetNumberOfTableValues ()) {
 326     double * color = mDefaultLUTColor->GetTableValue(n % mDefaultLUTColor->GetNumberOfTableValues ());
 327     mCurrentStructureSet->GetROI(n)->SetDisplayColor(color[0], color[1], color[2]);
 328   }
 329
 330   // Add a new roi actor
 331   mCurrentStructureSetActor->CreateNewROIActor(n, m_modeBG);
 332
 333   // CheckBox for "All"
 334   if (mCurrentStructureSetActor->GetROIActor(n)->IsVisible())
 335     mNumberOfVisibleROI++;
 336   if (mCurrentStructureSetActor->GetROIActor(n)->IsContourVisible())
 337     mNumberOfVisibleContourROI++;
 338   UpdateAllROIStatus();
 339 }
 340 //------------------------------------------------------------------------------
 341
 342
 343 //------------------------------------------------------------------------------
 344 void vvToolStructureSetManager::apply()
 345 {
 346   close();
 347 }
 348 //------------------------------------------------------------------------------
 349
 350
 351 //------------------------------------------------------------------------------
 352 bool vvToolStructureSetManager::close()
 353 {
 354   return vvToolWidgetBase::close();
 355 }
 356 //------------------------------------------------------------------------------
 357
 358
 359 //------------------------------------------------------------------------------
 360 void vvToolStructureSetManager::closeEvent(QCloseEvent *event)
 361 {
 362   // DD("vvToolStructureSetManager::closeEvent()");
 363   std::vector<vvSlicerManager*>::iterator iter = std::find(mListOfInputs.begin(), mListOfInputs.end(), mCurrentSlicerManager);
 364   if (iter != mListOfInputs.end()) mListOfInputs.erase(iter);
 365
 366   //  DD("how delete mListOfOpenTool ???");
 367   mListOfOpenTool.erase(mCurrentSlicerManager);
 368
 369   mCheckBoxShowAll->setCheckState(Qt::Unchecked);
 370   mContourCheckBoxShowAll->setCheckState(Qt::Unchecked);
 371   if (mCurrentSlicerManager != 0) mCurrentSlicerManager->Render();
 372   if (mCurrentStructureSetActor) {
 373     for(int i=0; i<mCurrentStructureSetActor->GetNumberOfROIs(); i++) {
 374       // DD(i);
 375       mCurrentStructureSetActor->GetROIList()[i]->SetVisible(false);
 376       mCurrentStructureSetActor->GetROIList()[i]->SetContourVisible(false);
 377       delete mCurrentStructureSetActor->GetROIList()[i];
 378     }
 379   }
 380
 381   if (!isWindow()) {
 382     if (m_NumberOfTool == 1) {
 383       mMainWindow->GetTab()->removeTab(mTabNumber);
 384     }
 385   }
 386
 387   event->accept();
 388 }
 389 //------------------------------------------------------------------------------
 390
 391
 392 //------------------------------------------------------------------------------
 393 // CURRENT ROI INTERACTION
 394 //------------------------------------------------------------------------------
 395
 396
 397 //------------------------------------------------------------------------------
 398 void vvToolStructureSetManager::SelectedItemChangedInTree() {
 399   // Search which roi is selected
 400   QList<QTreeWidgetItem *> l = mTree->selectedItems();
 401   if (l.size() == 0) {
 402     mCurrentROIActor = NULL;
 403     mCurrentROI = NULL;
 404     mGroupBoxROI->setEnabled(false);
 405     return;
 406   }
 407   QTreeWidgetItem * w = l[0];
 408   if (mMapTreeWidgetToROI.find(w) == mMapTreeWidgetToROI.end()) {
 409     mCurrentROIActor = NULL;
 410     mCurrentROI = NULL;
 411     mGroupBoxROI->setEnabled(false);
 412     return;
 413   }
 414   clitk::DicomRT_ROI * roi = mMapTreeWidgetToROI[w];
 415   // Get selected roi actor
 416   vvROIActor * actor = mStructureSetActorsList[mCurrentStructureSetIndex]->GetROIActor(roi->GetROINumber());
 417   mCurrentROI = roi;
 418   mCurrentROIActor = actor;
 419
 420   // Update GUI
 421   mGroupBoxROI->setEnabled(true);
 422   mROInameLabel->setText(roi->GetName().c_str());
 423   mCheckBoxShow->setChecked(actor->IsVisible());
 424   mContourCheckBoxShow->setChecked(actor->IsContourVisible());
 425   mContourWidthSpinBox->setValue(actor->GetContourWidth());
 426
 427   // Warning -> avoir unuseful Render here by disconnect slider
 428   disconnect(mOpacitySlider, SIGNAL(valueChanged(int)),
 429              this, SLOT(OpacityChanged(int)));
 430   mOpacitySlider->setValue((int)lrint(actor->GetOpacity()*100));
 431   mOpacitySpinBox->setValue((int)lrint(actor->GetOpacity()*100));
 432   connect(mOpacitySlider, SIGNAL(valueChanged(int)),
 433           this, SLOT(OpacityChanged(int)));
 434   actor->Update();
 435
 436   // Final rendering
 437   mCurrentSlicerManager->Render();
 438 }
 439 //------------------------------------------------------------------------------
 440
 441
 442 //------------------------------------------------------------------------------
 443 void vvToolStructureSetManager::UpdateAllROIStatus() {
 444   int nbVisible = 0;
 445   int nb = mCurrentStructureSetActor->GetROIList().size();
 446   for(int i=0; i<nb; i++) {
 447     if (mCurrentStructureSetActor->GetROIList()[i]->IsVisible()) {
 448       nbVisible++;
 449     }
 450   }
 451
 452   disconnect(mCheckBoxShowAll, SIGNAL(stateChanged(int)), this, SLOT(AllVisibleROIToggled(int)));
 453   disconnect(mContourCheckBoxShowAll, SIGNAL(toggled(bool)), this, SLOT(AllVisibleContourROIToggled(bool)));
 454   if (nbVisible == nb) mCheckBoxShowAll->setCheckState(Qt::Checked);
 455   else {
 456     if (nbVisible == 0) mCheckBoxShowAll->setCheckState(Qt::Unchecked);
 457     else mCheckBoxShowAll->setCheckState(Qt::PartiallyChecked);
 458   }
 459   connect(mContourCheckBoxShowAll, SIGNAL(toggled(bool)), this, SLOT(AllVisibleContourROIToggled(bool)));
 460   connect(mCheckBoxShowAll, SIGNAL(stateChanged(int)), this, SLOT(AllVisibleROIToggled(int)));
 461 }
 462 //------------------------------------------------------------------------------
 463
 464 //------------------------------------------------------------------------------
 465 void vvToolStructureSetManager::VisibleROIToggled(bool b) {
 466   if (mCurrentROIActor == NULL) return;
 467   if (b == mCurrentROIActor->IsVisible()) return; // nothing to do
 468   mCurrentROIActor->SetVisible(b);
 469   UpdateAllROIStatus();
 470   mCurrentSlicerManager->Render();
 471 }
 472 //------------------------------------------------------------------------------
 473
 474
 475 //------------------------------------------------------------------------------
 476 void vvToolStructureSetManager::VisibleContourROIToggled(bool b) {
 477   if (mCurrentROIActor == NULL) return;
 478   if (mCurrentROIActor->IsContourVisible() == b) return; // nothing to do
 479   mCurrentROIActor->SetContourVisible(b);
 480   mCurrentROIActor->UpdateColor();
 481   mCurrentSlicerManager->Render();
 482 }
 483 //------------------------------------------------------------------------------
 484
 485
 486 //------------------------------------------------------------------------------
 487 void vvToolStructureSetManager::OpacityChanged(int v) {
 488   if (mCurrentROIActor == NULL) return;
 489   mCurrentROIActor->SetOpacity((double)v/100.0);
 490   mCurrentROIActor->UpdateColor();
 491   mCurrentSlicerManager->Render();
 492 }
 493 //------------------------------------------------------------------------------
 494
 495
 496 //------------------------------------------------------------------------------
 497 void vvToolStructureSetManager::AllVisibleROIToggled(int b) {
 498   bool status = false;
 499   if ((mCheckBoxShowAll->checkState() == Qt::Checked) ||
 500       (mCheckBoxShowAll->checkState() == Qt::PartiallyChecked))  status = true;
 501
 502   for(int i=0; i<mCurrentStructureSetActor->GetNumberOfROIs(); i++) {
 503     mCurrentStructureSetActor->GetROIList()[i]->SetVisible(status);
 504   }
 505   if (status) mCheckBoxShowAll->setCheckState(Qt::Checked);
 506   else  mCheckBoxShowAll->setCheckState(Qt::Unchecked);
 507   mCheckBoxShow->setChecked(status);
 508   mCurrentSlicerManager->Render();
 509 }
 510 //------------------------------------------------------------------------------
 511
 512
 513 //------------------------------------------------------------------------------
 514 void vvToolStructureSetManager::AllVisibleContourROIToggled(bool b) {
 515   bool status = false;
 516   if ((mContourCheckBoxShowAll->checkState() == Qt::Checked) ||
 517       (mContourCheckBoxShowAll->checkState() == Qt::PartiallyChecked))  status = true;
 518   // Update current
 519   for(int i=0; i<mCurrentStructureSetActor->GetNumberOfROIs(); i++) {
 520     mCurrentStructureSetActor->GetROIList()[i]->SetContourVisible(status);
 521   }
 522   // Update current selection
 523   if (status) mContourCheckBoxShowAll->setCheckState(Qt::Checked);
 524   else  mContourCheckBoxShowAll->setCheckState(Qt::Unchecked);
 525   mContourCheckBoxShow->setChecked(status);
 526   mCurrentSlicerManager->Render();
 527 }
 528 //------------------------------------------------------------------------------
 529
 530
 531 //------------------------------------------------------------------------------
 532 void vvToolStructureSetManager::ChangeColor() {
 533   QColor color;
 534   color.setRgbF(mCurrentROIActor->GetROI()->GetDisplayColor()[0],
 535                 mCurrentROIActor->GetROI()->GetDisplayColor()[1],
 536                 mCurrentROIActor->GetROI()->GetDisplayColor()[2]);
 537   QColor c = QColorDialog::getColor(color, this, "Choose the ROI color");
 538   mCurrentROIActor->GetROI()->SetDisplayColor(c.redF(), c.greenF(), c.blueF());
 539   mCurrentROIActor->UpdateColor();
 540
 541   QTreeWidgetItem * w = mMapROIToTreeWidget[mCurrentROI];
 542   QBrush brush(QColor(mCurrentROI->GetDisplayColor()[0]*255,
 543                       mCurrentROI->GetDisplayColor()[1]*255,
 544                       mCurrentROI->GetDisplayColor()[2]*255));
 545   brush.setStyle(Qt::SolidPattern);
 546   w->setBackground(2, brush);
 547   // Render
 548   mCurrentSlicerManager->Render();
 549 }
 550 //------------------------------------------------------------------------------
 551
 552
 553 //------------------------------------------------------------------------------
 554 void vvToolStructureSetManager::ChangeContourColor() {
 555   QColor color;
 556   color.setRgbF(mCurrentROIActor->GetContourColor()[0],
 557                 mCurrentROIActor->GetContourColor()[1],
 558                 mCurrentROIActor->GetContourColor()[2]);
 559   QColor c = QColorDialog::getColor(color, this, "Choose the contour color");
 560   mCurrentROIActor->SetContourColor(c.redF(), c.greenF(), c.blueF());
 561   mCurrentROIActor->UpdateColor();
 562   mCurrentSlicerManager->Render();
 563 }
 564 //------------------------------------------------------------------------------
 565
 566
 567 //------------------------------------------------------------------------------
 568 void vvToolStructureSetManager::ChangeContourWidth(int n) {
 569   mCurrentROIActor->SetContourWidth(n);
 570   mCurrentROIActor->UpdateColor();
 571   mCurrentSlicerManager->Render();
 572 }
 573 //------------------------------------------------------------------------------
 574
 575
 576 //------------------------------------------------------------------------------
 577 void vvToolStructureSetManager::ReloadCurrentROI() {
 578   // Reload image
 579   vvImageReader * mReader = new vvImageReader;
 580   mReader->SetInputFilename(mCurrentROI->GetFilename());
 581   mReader->Update(IMAGE);
 582   if (mReader->GetLastError() != "") {
 583     QMessageBox::information(mMainWindowBase, tr("Sorry, error. Could not reload"), mReader->GetLastError().c_str());
 584     return;
 585   }
 586   //  delete mCurrentROI->GetImage();
 587   // DD(mCurrentROI->GetImage()->GetFirstVTKImageData()->GetDataReleased());
 588   //   DD(mCurrentROI->GetImage()->GetFirstVTKImageData()->GetReferenceCount());
 589   mCurrentROI->GetImage()->GetFirstVTKImageData()->ReleaseData();
 590   // DD(mCurrentROI->GetImage()->GetFirstVTKImageData()->GetDataReleased());
 591   mCurrentROI->SetImage(mReader->GetOutput());
 592
 593   // Update visu"
 594   mCurrentROIActor->UpdateImage();
 595   mCurrentSlicerManager->Render();
 596 }
 597 //------------------------------------------------------------------------------
 598
 599
 600 //------------------------------------------------------------------------------
 601 void vvToolStructureSetManager::CheckInputList(std::vector<vvSlicerManager*> & l, int & index)
 602 {
 603   for(unsigned int i=0; i<l.size(); i++) {
 604     std::vector<vvSlicerManager*>::iterator iter = std::find(mListOfInputs.begin(), mListOfInputs.end(), l[i]);
 605     if (iter != mListOfInputs.end()) {
 606       for(unsigned int j=i;j<l.size(); j++) l[j] = l[j+1];
 607       l.pop_back();
 608       if (index == (int)i) index = 0;
 609       i--;
 610     }
 611   }
 612 }
 613 //------------------------------------------------------------------------------
 614
 615
 616 //------------------------------------------------------------------------------
 617 // STATIC
 618 vvToolStructureSetManager * vvToolStructureSetManager::AddImage(vvSlicerManager * m, std::string name, vvImage::Pointer image, double BG, bool m_modeBG)
 619 {
 620   // If the tool is open for this vvSlicerManager, use it and return
 621   if (mListOfOpenTool[m]) {
 622     vvToolStructureSetManager * tool = mListOfOpenTool[m];
 623     tool->AddImage(image, name, BG, m_modeBG);
 624     tool->UpdateImage();
 625     return tool;
 626   }
 627
 628   // If the tool is not open, create it
 629   vvToolStructureSetManager * tool = new vvToolStructureSetManager
 630     (CREATOR(vvToolStructureSetManager)->GetMainWindow(), Qt::Dialog, m);
 631   tool->AddImage(image, name, BG, m_modeBG);
 632   tool->UpdateImage();
 633   tool->show();
 634   return tool;
 635 }
 636 //------------------------------------------------------------------------------