vv/vvToolROIManager.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 "vvToolROIManager.h"
  21 #include "vvImageReader.h"
  22 #include "vvImageWriter.h"
  23 #include "vvROIActor.h"
  24 #include "vvSlicer.h"
  25 #include "vvROIActor.h"
  26 #include "vvMeshReader.h"
  27 #include "vvStructSelector.h"
  28 #include "vvToolManager.h"
  29 #include "vvProgressDialog.h"
  30
  31 // clitk
  32 #include "clitkDicomRTStruct2ImageFilter.h"
  33 #include "clitkDicomRT_StructureSet.h"
  34
  35 // Qt
  36 #include <QFileDialog>
  37 #include <QMessageBox>
  38 #include <QColorDialog>
  39 #include <QAbstractEventDispatcher>
  40 #include <QXmlStreamReader>
  41
  42 // vtk
  43 #include <vtkLookupTable.h>
  44 #include <vtkRenderWindow.h>
  45
  46 //------------------------------------------------------------------------------
  47 // Create the tool and automagically (I like this word) insert it in
  48 // the main window menu.
  49 ADD_TOOL(vvToolROIManager);
  50 //------------------------------------------------------------------------------
  51
  52 //------------------------------------------------------------------------------
  53 vvToolROIManager::vvToolROIManager(vvMainWindowBase * parent, Qt::WindowFlags f):
  54   QWidget(parent->GetTab()),
  55   vvToolBase<vvToolROIManager>(parent),
  56   Ui::vvToolROIManager()
  57 {
  58   // Store parent
  59   mMainWindow = parent;
  60
  61   // Assume the initial tab ROI index is 2
  62   mIndexFirstTab = 2;
  63
  64   // Build the UI
  65   Ui_vvToolROIManager::setupUi(this);
  66   setAttribute(Qt::WA_DeleteOnClose);
  67   mTree->clear();
  68   mTree->header()->resizeSection(0, 30);
  69   mGroupBoxROI->setEnabled(false);
  70
  71   // Disable "Load dicom" button -> not useful
  72   frame_4->hide();
  73
  74   // Set default LUT
  75   mDefaultLUTColor = vtkSmartPointer<vtkLookupTable>::New();
  76   for(int i=0; i<mDefaultLUTColor->GetNumberOfTableValues(); i++) {
  77     double r = (rand()/(RAND_MAX+1.0));
  78     double v = (rand()/(RAND_MAX+1.0));
  79     double b = (rand()/(RAND_MAX+1.0));
  80     mDefaultLUTColor->SetTableValue(i, r, v, b);
  81   }
  82 #include "vvDefaultLut.h"
  83
  84   // Initialization
  85   mCurrentSlicerManager = NULL;
  86   mNumberOfVisibleROI = 0;
  87   mNumberOfVisibleContourROI = 0;
  88   mOpenFileBrowserFlag = true; // by default, open the file browser when the tool is launched
  89
  90   // InitializeNewTool must be called to start
  91 }
  92 //------------------------------------------------------------------------------
  93
  94
  95 //------------------------------------------------------------------------------
  96 vvToolROIManager::~vvToolROIManager()
  97 {
  98   mROIActorsList.clear();
  99 }
 100 //------------------------------------------------------------------------------
 101
 102
 103 //------------------------------------------------------------------------------
 104 // STATIC
 105 void vvToolROIManager::Initialize() {
 106   SetToolName("ROIManager");
 107   SetToolMenuName("Open ROI (binary image or RT-STRUCT)");
 108   SetToolIconFilename(":/common/icons/tool-roi.png");
 109   SetToolTip("Display ROI from a binary image or a RT-struct file.");
 110   SetToolExperimental(false);
 111 }
 112 //------------------------------------------------------------------------------
 113
 114
 115
 116 //------------------------------------------------------------------------------
 117 void  vvToolROIManager::InitializeNewTool(bool ReadStateFlag)
 118 {
 119   // Check if we need to start a new tool or read in the state file to load
 120   if (ReadStateFlag == false) {
 121     // Select the current image as the target
 122     int i = mMainWindow->GetSlicerManagerCurrentIndex();
 123     mCurrentSlicerManager = mMainWindow->GetSlicerManagers()[i];
 124     // Set it as current (only if not ReadStateFlag)
 125     mMainWindow->GetTab()->setCurrentIndex(mIndexFirstTab);
 126   }
 127   else {
 128     // Set the first tab in front to avoid displaying two roimanager
 129     // in the same tab. Because toolcreatorBase do show() and I am too
 130     // lazy to find another solution now.
 131     mMainWindow->GetTab()->setCurrentIndex(0);
 132
 133     // Read all information in the XML
 134     ReadXMLInformation();
 135
 136     // Check that a ROI is not already present
 137     mInitialImageIndex += mImageIndex;
 138     if (mInitialImageIndex >= mMainWindow->GetSlicerManagers().size()) {
 139       QMessageBox::warning(this, "ROIManager tool", QString("Image index %1 not found, abort.").arg(mInitialImageIndex));
 140       close();
 141       return;
 142     }
 143
 144     // Set the attached image
 145     mCurrentSlicerManager = mMainWindow->GetSlicerManagers()[mInitialImageIndex];
 146   }
 147
 148   // Tab insertion, check that another tool does not already exist for this image
 149   std::vector<vvToolBaseBase*> & tools =
 150     vvToolManager::GetInstance()->GetToolCreatorFromName(GetToolName())->GetListOfTool();
 151   if (tools.size() > 0) {
 152     for(uint i=0; i<tools.size()-1; i++) { // current tool is last
 153       vvToolROIManager * t = dynamic_cast<vvToolROIManager*>(tools[i]);
 154       if (mCurrentSlicerManager == t->GetCurrentSlicerManager()) {
 155         QMessageBox::warning(this, "ROIManager tool", "Already a ROI for this image, abort.");
 156         close();
 157         return;
 158       }
 159     }
 160   }
 161
 162   // Display tool in the correct tab
 163   QWidget * tab = qFindChild<QWidget*>(mMainWindow->GetTab(), "ROItab");
 164   tab->layout()->addWidget(this);
 165
 166   // If not read in a file we start automatically the browser to load
 167   // a roi file (binary image)
 168   if (ReadStateFlag) {
 169     mOpenFileBrowserFlag = false;
 170     InputIsSelected(mCurrentSlicerManager);
 171     mOpenFileBrowserFlag = true;
 172   }
 173   else InputIsSelected(mCurrentSlicerManager);
 174
 175   // Load ROI (if read in the XML files, empty otherwise)
 176   OpenBinaryImage(mROIFilenames);
 177
 178   // Set the options to the open roi
 179   for(uint i=0; i<mROIActorsParamList.size(); i++) {
 180     QSharedPointer<vvROIActor> roi = mROIActorsList[i];
 181     QSharedPointer<vvROIActor> roi_param = mROIActorsParamList[i];
 182     roi->CopyParameters(roi_param);
 183
 184     // Update Tree
 185     QTreeWidgetItem * w = mMapROIToTreeWidget[roi->GetROI()];
 186     QBrush brush(QColor(roi->GetROI()->GetDisplayColor()[0]*255,
 187                         roi->GetROI()->GetDisplayColor()[1]*255,
 188                         roi->GetROI()->GetDisplayColor()[2]*255));
 189     brush.setStyle(Qt::SolidPattern);
 190     w->setBackground(2, brush);
 191     w->setText(3, QString("%1").arg(roi->GetDepth()));
 192     roi->UpdateColor();
 193   }
 194
 195   // Display the ROI
 196   UpdateAllContours();
 197   UpdateAllROIStatus();
 198
 199   // Connect event from mainwindow to this widget
 200   connect(mMainWindow, SIGNAL(AnImageIsBeingClosed(vvSlicerManager *)),
 201           this, SLOT(AnImageIsBeingClosed(vvSlicerManager *)));
 202   connect(mMainWindow, SIGNAL(SelectedImageHasChanged(vvSlicerManager *)),
 203           this, SLOT(SelectedImageHasChanged(vvSlicerManager *)));
 204   connect(mOpenBinaryButton, SIGNAL(clicked()), this, SLOT(Open()));
 205   //  connect(mOpenDicomButton, SIGNAL(clicked()), this, SLOT(OpenDicomImage()));
 206   connect(mTree, SIGNAL(itemSelectionChanged()), this, SLOT(SelectedItemChangedInTree()));
 207   connect(mCheckBoxShow, SIGNAL(toggled(bool)), this, SLOT(VisibleROIToggled(bool)));
 208   connect(mOpacitySlider, SIGNAL(valueChanged(int)), this, SLOT(OpacityChanged(int)));
 209   connect(mChangeColorButton, SIGNAL(clicked()), this, SLOT(ChangeColor()));
 210   connect(mContourCheckBoxShow, SIGNAL(toggled(bool)), this, SLOT(VisibleContourROIToggled(bool)));
 211   connect(mChangeContourColorButton, SIGNAL(clicked()), this, SLOT(ChangeContourColor()));
 212   connect(mContourWidthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(ChangeContourWidth(int)));
 213   connect(mDepthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(ChangeDepth(int)));
 214   connect(mReloadButton, SIGNAL(clicked()), this, SLOT(ReloadCurrentROI()));
 215   connect(mCheckBoxShowAll, SIGNAL(stateChanged(int)), this, SLOT(AllVisibleROIToggled(int)));
 216   connect(mContourCheckBoxShowAll, SIGNAL(toggled(bool)), this, SLOT(AllVisibleContourROIToggled(bool)));
 217   connect(mCloseButton, SIGNAL(clicked()), this, SLOT(close()));
 218 }
 219 //------------------------------------------------------------------------------
 220
 221
 222 //------------------------------------------------------------------------------
 223 void vvToolROIManager::InputIsSelected(vvSlicerManager *m)
 224 {
 225   // Initialization
 226   mCurrentSlicerManager = m;
 227   mCurrentImage = mCurrentSlicerManager->GetImage();
 228
 229   // Refuse if non 3D image
 230   if (mCurrentImage->GetNumberOfDimensions() != 3) {
 231     QMessageBox::information(this,tr("Warning"), tr("Warning 3D ROI on a 4D image will results in some display bugs"));
 232     //close();
 233     //return;
 234   }
 235
 236   // Change gui
 237   mLabelInputInfo->setText(QString("%1").arg(m->GetFileName().c_str()));
 238
 239   // Auto display browser to select new contours
 240   if (mOpenFileBrowserFlag) Open();
 241 }
 242 //------------------------------------------------------------------------------
 243
 244
 245 //------------------------------------------------------------------------------
 246 void vvToolROIManager::AnImageIsBeingClosed(vvSlicerManager * m)
 247 {
 248   if (m == mCurrentSlicerManager) {
 249     close();
 250     return;
 251   }
 252 }
 253 //------------------------------------------------------------------------------
 254
 255
 256 //------------------------------------------------------------------------------
 257 void vvToolROIManager::close()
 258 {
 259   disconnect(mTree, SIGNAL(itemSelectionChanged()), this, SLOT(SelectedItemChangedInTree()));
 260   disconnect(mCheckBoxShow, SIGNAL(toggled(bool)), this, SLOT(VisibleROIToggled(bool)));
 261   disconnect(mOpacitySlider, SIGNAL(valueChanged(int)), this, SLOT(OpacityChanged(int)));
 262   disconnect(mChangeColorButton, SIGNAL(clicked()), this, SLOT(ChangeColor()));
 263   disconnect(mContourCheckBoxShow, SIGNAL(toggled(bool)), this, SLOT(VisibleContourROIToggled(bool)));
 264   disconnect(mChangeContourColorButton, SIGNAL(clicked()), this, SLOT(ChangeContourColor()));
 265   disconnect(mContourWidthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(ChangeContourWidth(int)));
 266   disconnect(mDepthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(ChangeDepth(int)));
 267
 268   // Remove actors
 269   for (unsigned int i = 0; i < mROIActorsList.size(); i++) {
 270     mROIActorsList[i]->RemoveActors();
 271   }
 272   mROIActorsList.clear();
 273
 274   QWidget::close();
 275   for(int i=0; i<mCurrentSlicerManager->GetNumberOfSlicers(); i++) {
 276     mCurrentSlicerManager->GetSlicer(i)->Render();
 277   }
 278 }
 279 //------------------------------------------------------------------------------
 280
 281
 282 //------------------------------------------------------------------------------
 283 void vvToolROIManager::SelectedImageHasChanged(vvSlicerManager * m) {
 284
 285   if (mCurrentSlicerManager == NULL) return;
 286   if (m == NULL) return;
 287   if (m != mCurrentSlicerManager) hide();
 288   else {
 289     show();
 290   }
 291 }
 292 //------------------------------------------------------------------------------
 293
 294
 295 //------------------------------------------------------------------------------
 296 void vvToolROIManager::Open()
 297 {
 298   // Open images
 299   QString Extensions = "Images or Dicom-Struct files ( *.mha *.mhd *.hdr *.his *.dcm RS*)";
 300   Extensions += ";;All Files (*)";
 301   QStringList filename =
 302     QFileDialog::getOpenFileNames(this,tr("Open binary image or DICOM RT Struct"),
 303                                   mMainWindowBase->GetInputPathName(),Extensions);
 304   if (filename.size() == 0) return;
 305   if (filename.size() > 1) { OpenBinaryImage(filename); return; }
 306
 307   // Try to read dicom rt ?
 308   clitk::DicomRT_StructureSet::Pointer s = clitk::DicomRT_StructureSet::New();
 309   if (s->IsDicomRTStruct(filename[0].toStdString())) OpenDicomImage(filename[0].toStdString());
 310   else OpenBinaryImage(filename);
 311
 312 }
 313 //------------------------------------------------------------------------------
 314
 315
 316 //------------------------------------------------------------------------------
 317 void vvToolROIManager::OpenBinaryImage(QStringList & filename)
 318 {
 319   if (filename.size() == 0) return;
 320
 321   vvProgressDialog p("Reading ROI ...", true);
 322   p.SetCancelButtonEnabled(false);
 323   QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 324
 325   // For each selected file, open the image
 326   for(int i=0; i<filename.size(); i++) {
 327     p.SetProgress(i, filename.size());
 328
 329     // Open Image
 330     vvImageReader::Pointer reader = vvImageReader::New();
 331     std::vector<std::string> filenames;
 332     filenames.push_back(filename[i].toStdString());
 333     reader->SetInputFilenames(filenames);
 334     reader->Update(vvImageReader::IMAGE);
 335
 336     if (reader->GetLastError().size() != 0) {
 337       std::cerr << "Error while reading " << filename[i].toStdString() << std::endl;
 338       QString error = "Cannot open file \n";
 339       error += reader->GetLastError().c_str();
 340       QMessageBox::information(this,tr("Reading problem"),error);
 341       return;
 342     }
 343     vvImage::Pointer binaryImage = reader->GetOutput();
 344     std::ostringstream oss;
 345     oss << vtksys::SystemTools::
 346       GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename[i].toStdString()));
 347     std::string name = oss.str();
 348     AddImage(binaryImage, name, filename[i].toStdString(), mBackgroundValueSpinBox->value(),
 349              (!mBGModeCheckBox->isChecked()));
 350     mOpenedBinaryImageFilenames.push_back(filename[i]);
 351   }
 352   QApplication::restoreOverrideCursor();
 353
 354   // Update the contours
 355   UpdateAllContours();
 356 }
 357 //------------------------------------------------------------------------------
 358
 359
 360 //------------------------------------------------------------------------------
 361 void vvToolROIManager::OpenDicomImage(std::string filename)
 362 {
 363   // GUI selector of roi
 364   vvMeshReader reader;
 365   reader.SetFilename(filename);
 366
 367   vvStructSelector selector;
 368   selector.SetStructures(reader.GetROINames());
 369   selector.SetPropagationCheckBoxFlag(false);
 370
 371   if (selector.exec()) {
 372     vvProgressDialog p("Reading ROI...", true);
 373     p.SetCancelButtonEnabled(false);
 374     QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
 375
 376     // Read information
 377     clitk::DicomRT_StructureSet::Pointer s = clitk::DicomRT_StructureSet::New();
 378     s->Read(filename);
 379
 380     // Loop on selected struct
 381     std::vector<int> list = selector.getSelectedItems();
 382     for (uint i=0; i<list.size(); i++) {
 383       p.SetProgress(i, list.size());
 384
 385       clitk::DicomRTStruct2ImageFilter filter;
 386       filter.SetCropMaskEnabled(true);
 387       filter.SetImage(mCurrentImage);
 388       filter.SetROI(s->GetROIFromROINumber(list[i]));
 389       filter.SetWriteOutputFlag(false);
 390       filter.Update();
 391
 392       // Get image
 393       vvImage::Pointer binaryImage = vvImage::New();
 394       binaryImage->AddVtkImage(filter.GetOutput());
 395
 396       // Add to gui
 397       AddImage(binaryImage, s->GetROIFromROINumber(list[i])->GetName(), "", 0, true); // "" = no filename
 398       mOpenedBinaryImageFilenames.push_back(filename.c_str());
 399     }
 400
 401     QApplication::restoreOverrideCursor();
 402   }
 403   // Update the contours
 404   UpdateAllContours();
 405 }
 406 //------------------------------------------------------------------------------
 407
 408
 409 //------------------------------------------------------------------------------
 410 void vvToolROIManager::AddImage(vvImage * binaryImage,
 411                                 std::string name,
 412                                 std::string filename,
 413                                 double BG, bool modeBG)
 414 {
 415   // Check Dimension
 416   int dim = mCurrentImage->GetNumberOfDimensions();
 417   int bin_dim = binaryImage->GetNumberOfDimensions();
 418   if (dim < bin_dim) {
 419     std::ostringstream os;
 420     os << "Error. Loaded binary image is " << bin_dim
 421        << "D while selected image is " << dim << "D" << std::endl;
 422     QMessageBox::information(this,tr("Reading problem"),os.str().c_str());
 423     return;
 424   }
 425
 426   // Compute roi index
 427   int n = mROIList.size();
 428
 429   // Compute the name of the new ROI
 430   // std::ostringstream oss;
 431   // oss << vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
 432   // std::string name = oss.str();
 433
 434   // Set color
 435   std::vector<double> color;
 436   color.push_back(1);
 437   color.push_back(0);
 438   color.push_back(0);
 439
 440   // Create ROI
 441   clitk::DicomRT_ROI::Pointer roi = clitk::DicomRT_ROI::New();
 442   roi->SetFromBinaryImage(binaryImage, n, name, color, filename);
 443
 444   // Add a new roi to the list
 445   mROIList.push_back(roi);
 446
 447   // Set BG or FG mode
 448   if (modeBG)
 449     roi->SetBackgroundValueLabelImage(BG);
 450   else
 451     roi->SetForegroundValueLabelImage(BG);
 452
 453   // Change color
 454   if (n<mDefaultLUTColor->GetNumberOfTableValues ()) {
 455     double * color = mDefaultLUTColor->GetTableValue(n % mDefaultLUTColor->GetNumberOfTableValues ());
 456     roi->SetDisplayColor(color[0], color[1], color[2]);
 457   }
 458
 459   // Add a new roi actor
 460   QSharedPointer<vvROIActor> actor = QSharedPointer<vvROIActor>(new vvROIActor);
 461   actor->SetBGMode(modeBG);
 462   actor->SetROI(roi);
 463   actor->SetSlicerManager(mCurrentSlicerManager);
 464   actor->Initialize(n+1); // depth is n+1 to start at 1
 465   mROIActorsList.push_back(actor);
 466
 467   // CheckBox for "All"
 468   if (actor->IsVisible()) mNumberOfVisibleROI++;
 469   if (actor->IsContourVisible()) mNumberOfVisibleContourROI++;
 470
 471   // Add ROI in tree
 472   mTreeWidgetList.push_back(QSharedPointer<QTreeWidgetItem>(new QTreeWidgetItem(mTree)));
 473   QTreeWidgetItem * w = mTreeWidgetList.back().data();
 474   w->setText(0, QString("%1").arg(roi->GetROINumber()));
 475   w->setText(1, QString("%1").arg(roi->GetName().c_str()));
 476   w->setText(3, QString("%1").arg(actor->GetDepth()));
 477   QBrush brush(QColor(roi->GetDisplayColor()[0]*255,
 478                       roi->GetDisplayColor()[1]*255,
 479                       roi->GetDisplayColor()[2]*255));
 480   brush.setStyle(Qt::SolidPattern);
 481   w->setBackground(2, brush);
 482   mMapROIToTreeWidget[roi] = w;
 483   mMapTreeWidgetToROI[w] = roi;
 484   mTree->resizeColumnToContents(0);
 485   mTree->resizeColumnToContents(1);
 486
 487   // Update
 488   UpdateAllROIStatus();
 489 }
 490 //------------------------------------------------------------------------------
 491
 492
 493 //------------------------------------------------------------------------------
 494 void vvToolROIManager::UpdateAllContours()
 495 {
 496   if (mCurrentSlicerManager == NULL) return;
 497   // Render loaded ROIs (the first is sufficient)
 498   for(unsigned int i=0; i<mROIList.size(); i++) {
 499     mROIActorsList[i]->Update();
 500   }
 501   mCurrentSlicerManager->Render();
 502 }
 503 //------------------------------------------------------------------------------
 504
 505
 506 //------------------------------------------------------------------------------
 507 void vvToolROIManager::UpdateAllROIStatus() {
 508   int nbVisible = 0;
 509   int nb = mROIList.size();
 510   for(int i=0; i<nb; i++) {
 511     if (mROIActorsList[i]->IsVisible()) {
 512       nbVisible++;
 513     }
 514   }
 515
 516   // change the states
 517   disconnect(mCheckBoxShowAll, SIGNAL(stateChanged(int)), this, SLOT(AllVisibleROIToggled(int)));
 518   disconnect(mContourCheckBoxShowAll, SIGNAL(toggled(bool)), this, SLOT(AllVisibleContourROIToggled(bool)));
 519   if (nbVisible == nb) mCheckBoxShowAll->setCheckState(Qt::Checked);
 520   else {
 521     if (nbVisible == 0) mCheckBoxShowAll->setCheckState(Qt::Unchecked);
 522     else mCheckBoxShowAll->setCheckState(Qt::PartiallyChecked);
 523   }
 524   connect(mContourCheckBoxShowAll, SIGNAL(toggled(bool)), this, SLOT(AllVisibleContourROIToggled(bool)));
 525   connect(mCheckBoxShowAll, SIGNAL(stateChanged(int)), this, SLOT(AllVisibleROIToggled(int)));
 526 }
 527 //------------------------------------------------------------------------------
 528
 529
 530 //------------------------------------------------------------------------------
 531 void vvToolROIManager::SelectedItemChangedInTree() {
 532   // Search which roi is selected
 533   QList<QTreeWidgetItem *> l = mTree->selectedItems();
 534   if (l.size() == 0) {
 535     //    mCurrentROIActor = 0;
 536     mCurrentROI = NULL;
 537     mGroupBoxROI->setEnabled(false);
 538     return;
 539   }
 540   QTreeWidgetItem * w = l[0];
 541   if (w == NULL) return;
 542   if (w == 0) return;
 543   if (mMapTreeWidgetToROI.find(w) == mMapTreeWidgetToROI.end()) {
 544     //    mCurrentROIActor = 0;
 545     mCurrentROI = NULL;
 546     mGroupBoxROI->setEnabled(false);
 547     return;
 548   }
 549   if (w == NULL) return;
 550   clitk::DicomRT_ROI * roi = mMapTreeWidgetToROI[w];
 551   if (roi == NULL) return; // sometimes it is called while there is no roi anymore
 552
 553   // Get selected roi actor
 554   int n = roi->GetROINumber();
 555   QSharedPointer<vvROIActor> actor = mROIActorsList[n];
 556   mCurrentROI = roi;
 557   mCurrentROIActor = actor;
 558
 559   // Warning -> avoid unuseful Render here by disconnect slider
 560   // Update GUI
 561   disconnect(mTree, SIGNAL(itemSelectionChanged()), this, SLOT(SelectedItemChangedInTree()));
 562   disconnect(mCheckBoxShow, SIGNAL(toggled(bool)), this, SLOT(VisibleROIToggled(bool)));
 563   disconnect(mOpacitySlider, SIGNAL(valueChanged(int)), this, SLOT(OpacityChanged(int)));
 564   disconnect(mChangeColorButton, SIGNAL(clicked()), this, SLOT(ChangeColor()));
 565   disconnect(mContourCheckBoxShow, SIGNAL(toggled(bool)), this, SLOT(VisibleContourROIToggled(bool)));
 566   disconnect(mChangeContourColorButton, SIGNAL(clicked()), this, SLOT(ChangeContourColor()));
 567   disconnect(mContourWidthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(ChangeContourWidth(int)));
 568   disconnect(mDepthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(ChangeDepth(int)));
 569
 570   mROInameLabel->setText(roi->GetName().c_str());
 571   mCheckBoxShow->setChecked(actor->IsVisible());
 572   mContourCheckBoxShow->setChecked(actor->IsContourVisible());
 573   mContourWidthSpinBox->setValue(actor->GetContourWidth());
 574   mDepthSpinBox->setValue(actor->GetDepth());
 575   w->setText(3, QString("%1").arg(actor->GetDepth()));
 576   mOpacitySlider->setValue((int)lrint(actor->GetOpacity()*100));
 577   mOpacitySpinBox->setValue((int)lrint(actor->GetOpacity()*100));
 578
 579   connect(mTree, SIGNAL(itemSelectionChanged()), this, SLOT(SelectedItemChangedInTree()));
 580   connect(mCheckBoxShow, SIGNAL(toggled(bool)), this, SLOT(VisibleROIToggled(bool)));
 581   connect(mOpacitySlider, SIGNAL(valueChanged(int)), this, SLOT(OpacityChanged(int)));
 582   connect(mChangeColorButton, SIGNAL(clicked()), this, SLOT(ChangeColor()));
 583   connect(mContourCheckBoxShow, SIGNAL(toggled(bool)), this, SLOT(VisibleContourROIToggled(bool)));
 584   connect(mChangeContourColorButton, SIGNAL(clicked()), this, SLOT(ChangeContourColor()));
 585   connect(mContourWidthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(ChangeContourWidth(int)));
 586   connect(mDepthSpinBox, SIGNAL(valueChanged(int)), this, SLOT(ChangeDepth(int)));
 587
 588
 589   // Set the current color to the selected ROI name
 590   mROInameLabel->setAutoFillBackground(true);// # This is important!!
 591   // mROInameLabel->setStyleSheet("QLabel { background-color : red; color : blue; }");
 592   QColor color = QColor(mCurrentROI->GetDisplayColor()[0]*255,
 593                         mCurrentROI->GetDisplayColor()[1]*255,
 594                         mCurrentROI->GetDisplayColor()[2]*255);
 595   // QString values = QString("%1, %2, %3").arg(color.red()).arg(color.green()).arg(color.blue());
 596   // mROInameLabel->setStyleSheet("QLabel { background-color: rgb("+values+"); }");
 597
 598   QPalette* palette = new QPalette();
 599   QColor colorFG = QColor((1-mCurrentROI->GetDisplayColor()[0])*255,
 600                           (1-mCurrentROI->GetDisplayColor()[1])*255,
 601                           (1-mCurrentROI->GetDisplayColor()[2])*255);
 602   palette->setColor(QPalette::WindowText,colorFG);
 603   palette->setColor(QPalette::Background, color);
 604   mROInameLabel->setPalette(*palette);
 605
 606   // Enable the group box (in case no selection before)
 607   mGroupBoxROI->setEnabled(true);
 608 }
 609 //------------------------------------------------------------------------------
 610
 611
 612 //------------------------------------------------------------------------------
 613 void vvToolROIManager::VisibleROIToggled(bool b) {
 614   if (mCurrentROIActor == NULL) return;
 615   if (b == mCurrentROIActor->IsVisible()) return; // nothing to do
 616   mCurrentROIActor->SetVisible(b);
 617   UpdateAllROIStatus();
 618   mCurrentSlicerManager->Render();
 619 }
 620 //------------------------------------------------------------------------------
 621
 622
 623 //------------------------------------------------------------------------------
 624 void vvToolROIManager::VisibleContourROIToggled(bool b) {
 625   if (mCurrentROIActor == NULL) return;
 626   if (mCurrentROIActor->IsContourVisible() == b) return; // nothing to do
 627   mCurrentROIActor->SetContourVisible(b);
 628   mCurrentROIActor->UpdateColor();
 629   mCurrentSlicerManager->Render();
 630 }
 631 //------------------------------------------------------------------------------
 632
 633
 634 //------------------------------------------------------------------------------
 635 void vvToolROIManager::OpacityChanged(int v) {
 636   if (mCurrentROIActor == NULL) return;
 637   mCurrentROIActor->SetOpacity((double)v/100.0);
 638   mCurrentROIActor->UpdateColor();
 639   mCurrentSlicerManager->Render();
 640 }
 641 //------------------------------------------------------------------------------
 642
 643
 644 //------------------------------------------------------------------------------
 645 void vvToolROIManager::AllVisibleROIToggled(int b) {
 646   bool status = false;
 647   if ((mCheckBoxShowAll->checkState() == Qt::Checked) ||
 648       (mCheckBoxShowAll->checkState() == Qt::PartiallyChecked))  status = true;
 649
 650   for(uint i=0; i<mROIList.size(); i++) {
 651     mROIActorsList[i]->SetVisible(status);
 652   }
 653   if (status) mCheckBoxShowAll->setCheckState(Qt::Checked);
 654   else  mCheckBoxShowAll->setCheckState(Qt::Unchecked);
 655   mCheckBoxShow->setChecked(status);
 656   mCurrentSlicerManager->Render();
 657 }
 658 //------------------------------------------------------------------------------
 659
 660
 661 //------------------------------------------------------------------------------
 662 void vvToolROIManager::AllVisibleContourROIToggled(bool b) {
 663   bool status = false;
 664   if ((mContourCheckBoxShowAll->checkState() == Qt::Checked) ||
 665       (mContourCheckBoxShowAll->checkState() == Qt::PartiallyChecked))  status = true;
 666   // Update current
 667   for(uint i=0; i<mROIActorsList.size(); i++) {
 668     mROIActorsList[i]->SetContourVisible(status);
 669   }
 670   // Update current selection
 671   if (status) mContourCheckBoxShowAll->setCheckState(Qt::Checked);
 672   else  mContourCheckBoxShowAll->setCheckState(Qt::Unchecked);
 673   mContourCheckBoxShow->setChecked(status);
 674   mCurrentSlicerManager->Render();
 675 }
 676 //------------------------------------------------------------------------------
 677
 678
 679 //------------------------------------------------------------------------------
 680 void vvToolROIManager::ChangeColor() {
 681   if (mCurrentROIActor == NULL) return;
 682   QColor color;
 683   color.setRgbF(mCurrentROIActor->GetROI()->GetDisplayColor()[0],
 684                 mCurrentROIActor->GetROI()->GetDisplayColor()[1],
 685                 mCurrentROIActor->GetROI()->GetDisplayColor()[2]);
 686   QColor c = QColorDialog::getColor(color, this, "Choose the ROI color");
 687   if (!c.isValid()) return;// User cancel
 688
 689   mCurrentROIActor->GetROI()->SetDisplayColor(c.redF(), c.greenF(), c.blueF());
 690   mCurrentROIActor->UpdateColor();
 691
 692   QTreeWidgetItem * w = mMapROIToTreeWidget[mCurrentROI];
 693   QBrush brush(QColor(mCurrentROI->GetDisplayColor()[0]*255,
 694                       mCurrentROI->GetDisplayColor()[1]*255,
 695                       mCurrentROI->GetDisplayColor()[2]*255));
 696   brush.setStyle(Qt::SolidPattern);
 697   w->setBackground(2, brush);
 698   // Render
 699   mCurrentSlicerManager->Render();
 700 }
 701 //------------------------------------------------------------------------------
 702
 703
 704 //------------------------------------------------------------------------------
 705 void vvToolROIManager::ChangeContourColor() {
 706   if (mCurrentROIActor == NULL) return;
 707   QColor color;
 708   color.setRgbF(mCurrentROIActor->GetContourColor()[0],
 709                 mCurrentROIActor->GetContourColor()[1],
 710                 mCurrentROIActor->GetContourColor()[2]);
 711   //  QColorDialog d(color);
 712   QColor c = QColorDialog::getColor(color, this, "Choose the contour color");
 713   if (!c.isValid()) return; // User cancel
 714   mCurrentROIActor->SetContourColor(c.redF(), c.greenF(), c.blueF());
 715   mCurrentROIActor->UpdateColor();
 716   mCurrentSlicerManager->Render();
 717 }
 718 //------------------------------------------------------------------------------
 719
 720
 721 //------------------------------------------------------------------------------
 722 void vvToolROIManager::ChangeContourWidth(int n) {
 723   if (mCurrentROIActor == NULL) return;
 724   mCurrentROIActor->SetContourWidth(n);
 725   mCurrentROIActor->UpdateColor();
 726   mCurrentSlicerManager->Render();
 727 }
 728 //------------------------------------------------------------------------------
 729
 730
 731 //------------------------------------------------------------------------------
 732 void vvToolROIManager::ChangeDepth(int n) {
 733   if (mCurrentROIActor == NULL) return;
 734   mCurrentROIActor->SetDepth(n);
 735   // mCurrentROIActor->UpdateImage(); // FIXME
 736   mCurrentSlicerManager->Render();
 737   QList<QTreeWidgetItem *> l = mTree->selectedItems();
 738   QTreeWidgetItem * w = l[0];
 739   w->setText(3, QString("%1").arg(mCurrentROIActor->GetDepth()));
 740 }
 741 //------------------------------------------------------------------------------
 742
 743
 744 //------------------------------------------------------------------------------
 745 void vvToolROIManager::ReloadCurrentROI() {
 746   if (mCurrentROI->GetFilename() == "") {
 747     return; // do nothing (contour from rt struct do not reload)
 748   }
 749
 750   // Remove all contours/overlay first
 751   bool visible = mCurrentROIActor->IsVisible();
 752   bool cvisible = mCurrentROIActor->IsContourVisible();
 753   mCurrentROIActor->SetVisible(false);
 754   mCurrentROIActor->SetContourVisible(false);
 755   mCurrentSlicerManager->Render();
 756
 757   // Reload image
 758   vvImageReader::Pointer reader = vvImageReader::New();
 759   reader->SetInputFilename(mCurrentROI->GetFilename());
 760   reader->Update(vvImageReader::IMAGE);
 761   if (reader->GetLastError() != "") {
 762     // No message just ignore (because can be from dicom)
 763     // QMessageBox::information(mMainWindowBase, tr("Sorry, error. Could not reload"),
 764     //                          reader->GetLastError().c_str());
 765     return;
 766   }
 767
 768   // Free the previous image
 769   mCurrentROI->GetImage()->GetFirstVTKImageData()->ReleaseData(); // Needed to free
 770   mCurrentROI->GetImage()->Reset();
 771   mCurrentROI->SetImage(reader->GetOutput());
 772
 773   mCurrentROIActor->RemoveActors();
 774
 775   // Update visu
 776   mCurrentROIActor->UpdateImage();
 777   mCurrentROIActor->SetVisible(visible);
 778   mCurrentROIActor->SetContourVisible(cvisible);
 779   mCurrentSlicerManager->Render();
 780 }
 781 //------------------------------------------------------------------------------
 782
 783
 784 //------------------------------------------------------------------------------
 785 void  vvToolROIManager::SaveState(std::auto_ptr<QXmlStreamWriter> & m_XmlWriter)
 786 {
 787   // Get index of the image
 788   int n = mMainWindow->GetSlicerManagers().size();
 789   int index=-1;
 790   for(int i=0; i<n; i++) {
 791     if (mCurrentSlicerManager == mMainWindow->GetSlicerManagers()[i]) index = i;
 792   }
 793   if (index == -1) {
 794     std::cerr << "Error while writing state for ROIManager tool no currentimage founded." << std::endl;
 795     return;
 796   }
 797   m_XmlWriter->writeTextElement("Image_Index", QString::number(index));
 798
 799
 800   // Write ROI
 801   for(uint i=0; i<mROIActorsList.size(); i++) {
 802     QSharedPointer<vvROIActor> roi = mROIActorsList[i];
 803
 804     m_XmlWriter->writeStartElement("ROI");
 805     m_XmlWriter->writeTextElement("Image", mOpenedBinaryImageFilenames[i]);
 806
 807     m_XmlWriter->writeStartElement("Overlay");
 808     m_XmlWriter->writeAttribute("Red",  QString("%1").arg(roi->GetOverlayColor()[0]));
 809     m_XmlWriter->writeAttribute("Green",QString("%1").arg(roi->GetOverlayColor()[1]));
 810     m_XmlWriter->writeAttribute("Blue", QString("%1").arg(roi->GetOverlayColor()[2]));
 811     m_XmlWriter->writeAttribute("Visible", QString("%1").arg(roi->IsVisible()));
 812     m_XmlWriter->writeAttribute("Opacity", QString("%1").arg(roi->GetOpacity()));
 813     m_XmlWriter->writeAttribute("Depth", QString("%1").arg(roi->GetDepth()));
 814     m_XmlWriter->writeEndElement();
 815
 816     m_XmlWriter->writeStartElement("Contour");
 817     m_XmlWriter->writeAttribute("Red",  QString("%1").arg(roi->GetContourColor()[0]));
 818     m_XmlWriter->writeAttribute("Green",QString("%1").arg(roi->GetContourColor()[1]));
 819     m_XmlWriter->writeAttribute("Blue", QString("%1").arg(roi->GetContourColor()[2]));
 820     m_XmlWriter->writeAttribute("Visible", QString("%1").arg(roi->IsContourVisible()));
 821     m_XmlWriter->writeAttribute("Width", QString("%1").arg(roi->GetContourWidth()));
 822     m_XmlWriter->writeEndElement();
 823
 824     m_XmlWriter->writeEndElement();
 825   }
 826 }
 827 //------------------------------------------------------------------------------
 828
 829
 830 //------------------------------------------------------------------------------
 831 void vvToolROIManager::ReadXMLInformation()
 832 {
 833   std::string value="";
 834   mInitialImageIndex = -1;
 835   while (!(m_XmlReader->isEndElement() && value == GetToolName().toStdString())) {
 836     m_XmlReader->readNext();
 837     value = m_XmlReader->qualifiedName().toString().toStdString();
 838
 839     if (value == "Image_Index")
 840       mInitialImageIndex = m_XmlReader->readElementText().toInt();
 841
 842     if (m_XmlReader->isStartElement()) {
 843       if (value == "ROI") {
 844         ReadXMLInformation_ROI();
 845       }
 846     }
 847   }
 848 }
 849 //------------------------------------------------------------------------------
 850
 851
 852 //------------------------------------------------------------------------------
 853 void vvToolROIManager::ReadXMLInformation_ROI()
 854 {
 855   QString s;
 856   std::string value="";
 857   QSharedPointer<vvROIActor> param = QSharedPointer<vvROIActor>(new vvROIActor);
 858   param->SetVisible(true);
 859   clitk::DicomRT_ROI::Pointer roi = clitk::DicomRT_ROI::New();
 860   // r->SetDisplayColor(1,1,1);
 861   param->SetROI(roi);
 862
 863   float r=1.0,g=1.0,b=1.0;
 864   float cr=1.0,cg=1.0,cb=1.0;
 865   float opacity = 0.7;
 866   bool visible = true;
 867   bool cvisible = true;
 868   int width = 1;
 869   int depth=1;
 870
 871   while (!(m_XmlReader->isEndElement() && value == "ROI")) {
 872     m_XmlReader->readNext();
 873     value = m_XmlReader->qualifiedName().toString().toStdString();
 874     if (value == "Image") {
 875       s = m_XmlReader->readElementText();
 876     }
 877
 878     if (value == "Overlay" && m_XmlReader->isStartElement()) {
 879       QXmlStreamAttributes attributes = m_XmlReader->attributes();
 880       if (!m_XmlReader->hasError())
 881         r = attributes.value("Red").toString().toFloat();
 882       if (!m_XmlReader->hasError())
 883         g = attributes.value("Green").toString().toFloat();
 884       if (!m_XmlReader->hasError())
 885         b = attributes.value("Blue").toString().toFloat();
 886       if (!m_XmlReader->hasError())
 887         visible = attributes.value("Visible").toString().toInt();
 888       if (!m_XmlReader->hasError())
 889         opacity = attributes.value("Opacity").toString().toFloat();
 890       if (!m_XmlReader->hasError())
 891         depth = attributes.value("Depth").toString().toFloat();
 892     }
 893
 894
 895     if (value == "Contour" && m_XmlReader->isStartElement()) {
 896       QXmlStreamAttributes attributes = m_XmlReader->attributes();
 897       if (!m_XmlReader->hasError())
 898         cr = attributes.value("Red").toString().toFloat();
 899       if (!m_XmlReader->hasError())
 900         cg = attributes.value("Green").toString().toFloat();
 901       if (!m_XmlReader->hasError())
 902         cb = attributes.value("Blue").toString().toFloat();
 903       if (!m_XmlReader->hasError())
 904         cvisible = attributes.value("Visible").toString().toInt();
 905       if (!m_XmlReader->hasError())
 906         width = attributes.value("Width").toString().toFloat();
 907     }
 908     param->SetOverlayColor(r,g,b);
 909     param->SetVisible(visible);
 910     param->SetOpacity(opacity);
 911     param->SetDepth(depth);
 912
 913     param->SetContourColor(cr,cg,cb);
 914     param->SetContourVisible(cvisible);
 915     param->SetContourWidth(width);
 916   }
 917   mROIFilenames.push_back(s);
 918   mROIActorsParamList.push_back(param);
 919 }
 920 //------------------------------------------------------------------------------