vv/vvSlicerManager.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 #include "vvSlicerManager.h"
  19
  20 #include "vvSlicer.h"
  21 #include "vvImage.h"
  22 #include "vvSlicerManagerCommand.h"
  23 #include "vvInteractorStyleNavigator.h"
  24 #include "vvLandmarks.h"
  25 #include "vvImageReader.h"
  26 #include "vvImageReader.h"
  27 #include "vvMesh.h"
  28 #include "vvImageMapToWLColors.h"
  29
  30 #include "vtkImageActor.h"
  31 #include "vtkImageData.h"
  32 #include "vtkRenderWindow.h"
  33 #include "vtkRendererCollection.h"
  34 #include "vtkRenderWindowInteractor.h"
  35 #include "vtkImageMapToWindowLevelColors.h"
  36 #include "vtkWindowLevelLookupTable.h"
  37 #include "vtkColorTransferFunction.h"
  38 #include "vtkImageClip.h"
  39 #include <vtkLODActor.h>
  40 #include <vtkPointData.h>
  41
  42 #include <vtksys/SystemTools.hxx>
  43 //----------------------------------------------------------------------------
  44
  45 vvSlicerManager::vvSlicerManager(int numberOfSlicers)
  46 {
  47     mFileName = "";
  48     mId = "";
  49     mVFName = "";
  50     mOverlayName = "";
  51     mFusionName = "";
  52     mVFId = "";
  53     mLastError = "";
  54     mType = UNDEFINEDIMAGETYPE;
  55     mColorMap = 0;
  56     mPreset = 0;
  57     mOverlayColor = 130;
  58
  59     mFusionOpacity = 70;
  60     mFusionColorMap = 3;
  61     mFusionWindow = 1000;
  62     mFusionLevel = 1000;
  63
  64     mReader = NULL;
  65     mImage = NULL;
  66     mVF=NULL;
  67     mVectorReader = NULL;
  68     mOverlayReader = NULL;
  69     mFusionReader = NULL;
  70     mLandmarks = NULL;
  71     mLinkedId.resize(0);
  72
  73     for ( int i = 0; i < numberOfSlicers; i++)
  74     {
  75         vvSlicer *slicer = vvSlicer::New();
  76         mSlicers.push_back(slicer);
  77     }
  78 }
  79
  80 vvSlicerManager::~vvSlicerManager()
  81 {
  82     for ( unsigned int i = 0; i < mSlicers.size(); i++)
  83     {
  84         if (mSlicers[i] != NULL)
  85             mSlicers[i]->Delete();
  86     }
  87     if (mReader)
  88     {
  89         delete mReader;
  90     }
  91     if (mVectorReader)
  92     {
  93         delete mVectorReader;
  94     }
  95     if (mOverlayReader)
  96     {
  97         delete mOverlayReader;
  98     }
  99     if (mFusionReader)
 100     {
 101         delete mFusionReader;
 102     }
 103     if (mLandmarks)
 104         delete mLandmarks;
 105 }
 106
 107 void vvSlicerManager::AddContour(vvMesh::Pointer contour,bool propagate)
 108 {
 109     for ( unsigned int i = 0; i < mSlicers.size(); i++)
 110     {
 111         mSlicers[i]->AddContour(contour,propagate);
 112     }
 113 }
 114
 115 void vvSlicerManager::ToggleContourSuperposition()
 116 {
 117     for ( unsigned int i = 0; i < mSlicers.size(); i++)
 118         mSlicers[i]->ToggleContourSuperposition();
 119 }
 120
 121 bool vvSlicerManager::SetImage(std::string filename,LoadedImageType type)
 122 {
 123     mFileName = filename;
 124     mType = type;
 125     if (mReader == NULL)
 126         mReader = new vvImageReader;
 127     std::vector<std::string> filenames;
 128     filenames.push_back(filename);
 129     mReader->SetInputFilenames(filenames);
 130     mReader->Update(type);
 131     if (mReader->GetLastError().size() == 0)
 132     {
 133         mImage=mReader->GetOutput();
 134         for ( unsigned int i = 0; i < mSlicers.size(); i++)
 135         {
 136             mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
 137             mSlicers[i]->SetImage(mReader->GetOutput());
 138         }
 139     }
 140     else
 141     {
 142         mLastError = mReader->GetLastError();
 143         return false;
 144     }
 145     return true;
 146 }
 147
 148 void vvSlicerManager::SetImage(vvImage::Pointer image)
 149 {
 150     mImage=image;
 151     for (unsigned int i = 0; i < mSlicers.size();i++)
 152     {
 153         mSlicers[i]->SetImage(image);
 154     }
 155 }
 156
 157 bool vvSlicerManager::SetImages(std::vector<std::string> filenames,LoadedImageType type)
 158 {
 159     mType = type;
 160     std::string fileWithoutExtension = vtksys::SystemTools::GetFilenameWithoutExtension(filenames[0]);
 161     if (type == DICOM)
 162         fileWithoutExtension += "_dicom";
 163     else if (type == MERGED)
 164         fileWithoutExtension += "_merged";
 165     else if (type == MERGEDWITHTIME)
 166         fileWithoutExtension += "_merged_wt";
 167
 168     mFileName = fileWithoutExtension + vtksys::SystemTools::GetFilenameExtension(filenames[0]);
 169     if (mReader == NULL)
 170         mReader = new vvImageReader;
 171     mReader->SetInputFilenames(filenames);
 172     mReader->Update(type);
 173
 174
 175     if (mReader->GetLastError().size() == 0)
 176     {
 177         mImage=mReader->GetOutput();
 178         for ( unsigned int i = 0; i < mSlicers.size(); i++)
 179         {
 180             mSlicers[i]->SetFileName(fileWithoutExtension);
 181             mSlicers[i]->SetImage(mReader->GetOutput());
 182         }
 183     }
 184     else
 185     {
 186         mLastError = mReader->GetLastError();
 187         return false;
 188     }
 189     return true;
 190 }
 191
 192 bool vvSlicerManager::SetOverlay(std::string filename,int dim, std::string component)
 193 {
 194     mOverlayName = filename;
 195     mOverlayComponent = component;
 196     if (dim > mImage->GetNumberOfDimensions())
 197     {
 198         mLastError = " Overlay dimension cannot be greater then reference image!";
 199         return false;
 200     }
 201     if (mOverlayReader == NULL)
 202         mOverlayReader = new vvImageReader;
 203     std::vector<std::string> filenames;
 204     filenames.push_back(filename);
 205     mOverlayReader->SetInputFilenames(filenames);
 206     mOverlayReader->Update(mImage->GetNumberOfDimensions(),component.c_str(),mType);
 207     if (mOverlayReader->GetLastError().size() == 0)
 208     {
 209         for ( unsigned int i = 0; i < mSlicers.size(); i++)
 210         {
 211             mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
 212         }
 213     }
 214     else
 215     {
 216         mLastError = mOverlayReader->GetLastError();
 217         return false;
 218     }
 219     return true;
 220 }
 221
 222 bool vvSlicerManager::SetFusion(std::string filename,int dim, std::string component)
 223 {
 224     mFusionName = filename;
 225     mFusionComponent = component;
 226     if (dim > mImage->GetNumberOfDimensions())
 227     {
 228         mLastError = " Overlay dimension cannot be greater then reference image!";
 229         return false;
 230     }
 231     if (mFusionReader == NULL)
 232         mFusionReader = new vvImageReader;
 233     std::vector<std::string> filenames;
 234     filenames.push_back(filename);
 235     mFusionReader->SetInputFilenames(filenames);
 236     mFusionReader->Update(mImage->GetNumberOfDimensions(),component.c_str(),mType);
 237     if (mFusionReader->GetLastError().size() == 0)
 238     {
 239         for ( unsigned int i = 0; i < mSlicers.size(); i++)
 240         {
 241             mSlicers[i]->SetFusion(mFusionReader->GetOutput());
 242         }
 243     }
 244     else
 245     {
 246         mLastError = mFusionReader->GetLastError();
 247         return false;
 248     }
 249     double *fusRange = mFusionReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
 250     mFusionLevel = (fusRange[0]+fusRange[1])/2;
 251     mFusionWindow = fusRange[1]-fusRange[0];
 252     return true;
 253 }
 254
 255 bool vvSlicerManager::SetVF(std::string filename)
 256 {
 257     if (mVectorReader == NULL)
 258         mVectorReader = new vvImageReader;
 259     mVectorReader->SetInputFilename(filename);
 260     mVectorReader->Update(VECTORFIELD);
 261     if (mVectorReader->GetLastError().size() != 0)
 262     {
 263         mLastError = mVectorReader->GetLastError();
 264         return false;
 265     }
 266     else
 267         return SetVF(mVectorReader->GetOutput(),filename);
 268 }
 269
 270 bool vvSlicerManager::SetVF(vvImage::Pointer vf,std::string filename)
 271 {
 272     if (vf->GetNumberOfDimensions() > mImage->GetNumberOfDimensions())
 273     {
 274         mLastError = " Vector field dimension cannot be greater then reference image!";
 275         return false;
 276     }
 277     mVF=vf;
 278     mVFName = filename;
 279     for ( unsigned int i = 0; i < mSlicers.size(); i++)
 280     {
 281         mSlicers[i]->SetVF(vf);
 282     }
 283     return true;
 284 }
 285
 286 void vvSlicerManager::SetExtractedImage(std::string filename,vvImage::Pointer image, int slice)
 287 {
 288     mFileName = filename;
 289     mImage = vvImage::New();
 290     if (image->GetNumberOfDimensions() == 4)
 291     {
 292         mImage->AddImage(image->GetVTKImages()[slice]);
 293         for ( unsigned int i = 0; i < mSlicers.size(); i++)
 294         {
 295             mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
 296             mSlicers[i]->SetImage(mImage);
 297         }
 298     }
 299     else
 300     {
 301         vtkImageClip* clipper = vtkImageClip::New();
 302         int extent[6];
 303         image->GetVTKImages()[0]->GetWholeExtent(extent);
 304         clipper->SetInput(image->GetVTKImages()[0]);
 305         clipper->SetOutputWholeExtent(extent[0],extent[1],extent[2],extent[3],slice,slice);
 306         clipper->Update();
 307         mImage->AddImage(clipper->GetOutput());
 308         for ( unsigned int i = 0; i < mSlicers.size(); i++)
 309         {
 310             mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
 311             mSlicers[i]->SetImage(mImage);
 312         }
 313         clipper->Delete();
 314     }
 315 }
 316
 317 vvSlicer* vvSlicerManager::GetSlicer(int i)
 318 {
 319     return mSlicers[i];
 320 }
 321
 322 void vvSlicerManager::UpdateSlicer(int num, bool state)
 323 {
 324     if (mSlicers[num]->GetImage())
 325             mSlicers[num]->SetDisplayMode(state);
 326 }
 327
 328 void vvSlicerManager::SetSlicerWindow(int i, vtkRenderWindow* RW)
 329 {
 330     mSlicers[i]->SetRenderWindow(i,RW);
 331 }
 332
 333 void vvSlicerManager::SetInteractorStyleNavigator(int i, vtkInteractorStyle* style)
 334 {
 335     vvSlicerManagerCommand *smc = vvSlicerManagerCommand::New();
 336     smc->SM = this;
 337     smc->SetSlicerNumber(i);
 338     mSlicers[i]->GetRenderWindow()->GetInteractor()->SetInteractorStyle(style);
 339
 340     mSlicers[i]->GetRenderWindow()->GetInteractor()->
 341     GetInteractorStyle()->AddObserver(vtkCommand::KeyPressEvent, smc);
 342     mSlicers[i]->GetRenderWindow()->GetInteractor()->
 343     GetInteractorStyle()->AddObserver(vtkCommand::WindowLevelEvent, smc);
 344     mSlicers[i]->GetRenderWindow()->GetInteractor()->
 345     GetInteractorStyle()->AddObserver(vtkCommand::EndWindowLevelEvent, smc);
 346     mSlicers[i]->GetRenderWindow()->GetInteractor()->
 347     GetInteractorStyle()->AddObserver(vtkCommand::StartWindowLevelEvent, smc);
 348     mSlicers[i]->GetRenderWindow()->GetInteractor()->
 349     GetInteractorStyle()->AddObserver(vtkCommand::PickEvent, smc);
 350     mSlicers[i]->GetRenderWindow()->GetInteractor()->
 351     GetInteractorStyle()->AddObserver(vtkCommand::StartPickEvent, smc);
 352     mSlicers[i]->GetRenderWindow()->GetInteractor()->
 353     GetInteractorStyle()->AddObserver(vtkCommand::LeaveEvent, smc);
 354     mSlicers[i]->GetRenderWindow()->GetInteractor()->
 355     GetInteractorStyle()->AddObserver(vtkCommand::UserEvent, smc);
 356     mSlicers[i]->GetRenderWindow()->GetInteractor()->
 357     GetInteractorStyle()->AddObserver(vtkCommand::MouseWheelForwardEvent, smc);
 358     mSlicers[i]->GetRenderWindow()->GetInteractor()->
 359     GetInteractorStyle()->AddObserver(vtkCommand::MouseWheelBackwardEvent, smc);
 360     smc->Delete();
 361 }
 362
 363 void vvSlicerManager::SetTSlice(int slice)
 364 {
 365     if (slice < 0)
 366         slice = 0;
 367     else if (slice > mSlicers[0]->GetTMax())
 368         slice = mSlicers[0]->GetTMax();
 369     if (mLandmarks)
 370         mLandmarks->SetTime(slice);
 371     for ( unsigned int i = 0; i < mSlicers.size(); i++)
 372     {
 373         mSlicers[i]->SetTSlice(slice);
 374         if (mSlicers[i]->GetImageActor()->GetVisibility())
 375             UpdateTSlice(i);
 376     }
 377 }
 378
 379 void vvSlicerManager::SetNextTSlice(int originating_slicer)
 380 {
 381     int t = mSlicers[0]->GetTSlice();
 382     t++;
 383     if (t > mSlicers[0]->GetTMax())
 384         t = 0;
 385     emit UpdateTSlice(originating_slicer,t);
 386 }
 387
 388 void vvSlicerManager::SetPreviousTSlice(int originating_slicer)
 389 {
 390     int t = mSlicers[0]->GetTSlice();
 391     t--;
 392     if (t < 0)
 393         t = mSlicers[0]->GetTMax();
 394     emit UpdateTSlice(originating_slicer,t);
 395 }
 396
 397 void vvSlicerManager::ToggleInterpolation()
 398 {
 399     bool interpolate=!(mSlicers[0]->GetImageActor()->GetInterpolate());
 400     for ( unsigned int i = 0; i < mSlicers.size(); i++)
 401     {
 402         mSlicers[i]->GetImageActor()->SetInterpolate(interpolate);
 403     }
 404 }
 405
 406
 407 void vvSlicerManager::SetTSliceInSlicer(int tslice, int slicer)
 408 {
 409     if (tslice < 0)
 410         tslice = 0;
 411     else if (tslice > mSlicers[slicer]->GetTMax())
 412         tslice = mSlicers[slicer]->GetTMax();
 413     if (mLandmarks)
 414         mLandmarks->SetTime(tslice);
 415     mSlicers[slicer]->SetTSlice(tslice);
 416     if (mSlicers[slicer]->GetImageActor()->GetVisibility())
 417         UpdateTSlice(slicer);
 418 }
 419
 420 void vvSlicerManager::SetColorWindow(double s)
 421 {
 422     for ( unsigned int i = 0; i < mSlicers.size(); i++)
 423     {
 424         mSlicers[i]->SetColorWindow(s);
 425     }
 426 }
 427
 428 void vvSlicerManager::SetColorLevel(double s)
 429 {
 430     for ( unsigned int i = 0; i < mSlicers.size(); i++)
 431     {
 432         mSlicers[i]->SetColorLevel(s);
 433     }
 434 }
 435
 436 void vvSlicerManager::SetCursorVisibility(int s)
 437 {
 438     for ( unsigned int i = 0; i < mSlicers.size(); i++)
 439     {
 440         mSlicers[i]->SetCursorVisibility(s);
 441     }
 442 }
 443
 444 void vvSlicerManager::SetOpacity(int i, double factor)
 445 {
 446     mSlicers[i]->SetOpacity(1/factor);
 447 }
 448
 449 void vvSlicerManager::UpdateViews(int current,int slicer)
 450 {
 451     double x = (mSlicers[slicer]->GetCurrentPosition()[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
 452                /mSlicers[slicer]->GetInput()->GetSpacing()[0];
 453     double y = (mSlicers[slicer]->GetCurrentPosition()[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
 454                /mSlicers[slicer]->GetInput()->GetSpacing()[1];
 455     double z = (mSlicers[slicer]->GetCurrentPosition()[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
 456                /mSlicers[slicer]->GetInput()->GetSpacing()[2];
 457
 458     if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
 459             x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
 460             y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
 461             y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
 462             z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
 463             z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5])
 464     {
 465         mSlicers[slicer]->UpdateCursorPosition();
 466         mSlicers[slicer]->SetCursorColor(10,212,255);
 467
 468         switch (mSlicers[slicer]->GetSliceOrientation())
 469         {
 470         case vtkImageViewer2::SLICE_ORIENTATION_XY:
 471             if (mSlicers[slicer]->GetSlice() == (int)floor(z))
 472                 mSlicers[slicer]->Render();
 473             else
 474                 mSlicers[slicer]->SetSlice((int)floor(z));
 475             break;
 476
 477         case vtkImageViewer2::SLICE_ORIENTATION_XZ:
 478             if (mSlicers[slicer]->GetSlice() == (int)floor(y))
 479                 mSlicers[slicer]->Render();
 480             else
 481                 mSlicers[slicer]->SetSlice((int)floor(y));
 482             break;
 483
 484         case vtkImageViewer2::SLICE_ORIENTATION_YZ:
 485             if (mSlicers[slicer]->GetSlice() == (int)floor(x))
 486                 mSlicers[slicer]->Render();
 487             else
 488                 mSlicers[slicer]->SetSlice((int)floor(x));
 489             break;
 490         }
 491
 492         for ( unsigned int i = 0; i < mSlicers.size(); i++)
 493         {
 494             if (i != (unsigned int)slicer && mSlicers[i]->GetImageActor()->GetVisibility()
 495                     && mSlicers[i]->GetRenderWindow()->GetSize()[0] > 2
 496                     && mSlicers[i]->GetRenderWindow()->GetSize()[1] > 2)
 497             {
 498                 mSlicers[i]->SetCurrentPosition(mSlicers[slicer]->GetCurrentPosition()[0],
 499                                                 mSlicers[slicer]->GetCurrentPosition()[1],
 500                                                 mSlicers[slicer]->GetCurrentPosition()[2],
 501                                                 mSlicers[slicer]->GetTSlice());
 502                 mSlicers[i]->UpdateCursorPosition();
 503                 if (current) //do not display corner annotation if image is the one picked
 504                 {
 505                     mSlicers[i]->SetCurrentPosition(-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX,
 506                                                     -VTK_DOUBLE_MAX, mSlicers[slicer]->GetTSlice());
 507                     mSlicers[i]->SetCursorColor(255,10,212);
 508                 }
 509                 else
 510                 {
 511                     mSlicers[i]->SetCursorColor(150,10,282);
 512                 }
 513                 switch (mSlicers[i]->GetSliceOrientation())
 514                 {
 515                 case vtkImageViewer2::SLICE_ORIENTATION_XY:
 516                     if (mSlicers[i]->GetSlice() == (int)floor(z))
 517                         mSlicers[i]->Render();
 518                     else
 519                         mSlicers[i]->SetSlice((int)floor(z));
 520                     break;
 521
 522                 case vtkImageViewer2::SLICE_ORIENTATION_XZ:
 523                     if (mSlicers[i]->GetSlice() == (int)floor(y))
 524                         mSlicers[i]->Render();
 525                     else
 526                         mSlicers[i]->SetSlice((int)floor(y));
 527                     break;
 528
 529                 case vtkImageViewer2::SLICE_ORIENTATION_YZ:
 530                     if (mSlicers[i]->GetSlice() == (int)floor(x))
 531                         mSlicers[i]->Render();
 532                     else
 533                         mSlicers[i]->SetSlice((int)floor(x));
 534                     break;
 535                 }
 536                 UpdateSlice(i);
 537                 UpdateTSlice(i);
 538             }
 539         }
 540     }
 541 }
 542
 543 void vvSlicerManager::UpdateLinked(int slicer)
 544 {
 545     double x = (mSlicers[slicer]->GetCurrentPosition()[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
 546                /mSlicers[slicer]->GetInput()->GetSpacing()[0];
 547     double y = (mSlicers[slicer]->GetCurrentPosition()[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
 548                /mSlicers[slicer]->GetInput()->GetSpacing()[1];
 549     double z = (mSlicers[slicer]->GetCurrentPosition()[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
 550                /mSlicers[slicer]->GetInput()->GetSpacing()[2];
 551
 552     if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
 553             x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
 554             y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
 555             y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
 556             z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
 557             z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5])
 558     {
 559         for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++)
 560         {
 561             emit UpdateLinkManager(*i, slicer,mSlicers[slicer]->GetCurrentPosition()[0],
 562                                    mSlicers[slicer]->GetCurrentPosition()[1],
 563                                    mSlicers[slicer]->GetCurrentPosition()[2],mSlicers[slicer]->GetTSlice());
 564         }
 565     }
 566 }
 567 double vvSlicerManager::GetColorWindow()
 568 {
 569     if (mSlicers.size())
 570         return mSlicers[0]->GetColorWindow();
 571     return -1;
 572 }
 573
 574 double vvSlicerManager::GetColorLevel()
 575 {
 576     if (mSlicers.size())
 577         return mSlicers[0]->GetColorLevel();
 578     return -1;
 579 }
 580
 581 void vvSlicerManager::Render()
 582 {
 583     for ( unsigned int i = 0; i < mSlicers.size(); i++)
 584     {
 585         mSlicers[i]->Render();
 586     }
 587 }
 588
 589 void vvSlicerManager::GenerateDefaultLookupTable()
 590 {
 591     SetPreset(mPreset);
 592     SetColorMap(mColorMap);
 593 }
 594
 595 void vvSlicerManager::Reload()
 596 {
 597     mReader->Update(mType);
 598     mImage=mReader->GetOutput();
 599     for ( unsigned int i = 0; i < mSlicers.size(); i++)
 600     {
 601         mSlicers[i]->SetImage(mImage);
 602     }
 603 }
 604
 605 void vvSlicerManager::ReloadFusion()
 606 {
 607     mFusionReader->Update();
 608     for ( unsigned int i = 0; i < mSlicers.size(); i++)
 609     {
 610         mSlicers[i]->SetFusion(mFusionReader->GetOutput());
 611         mSlicers[i]->Render();
 612     }
 613 }
 614
 615 void vvSlicerManager::ReloadOverlay()
 616 {
 617     mOverlayReader->Update();
 618     for ( unsigned int i = 0; i < mSlicers.size(); i++)
 619     {
 620         mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
 621         mSlicers[i]->Render();
 622     }
 623 }
 624
 625 void vvSlicerManager::ReloadVF()
 626 {
 627     mVectorReader->Update(VECTORFIELD); //deletes the old images through the VF::Init() function
 628     mVF=mVectorReader->GetOutput();
 629     for ( unsigned int i = 0; i < mSlicers.size(); i++)
 630     {
 631         mSlicers[i]->SetVF(mVF);
 632         mSlicers[i]->Render();
 633     }
 634 }
 635
 636 void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_index)
 637 {
 638     for (unsigned int i = 0; i < mSlicers.size();i++)
 639     {
 640         mSlicers[i]->RemoveActor(actor_type,overlay_index);
 641     }
 642     if (actor_type=="vector")
 643     {
 644         mVF=NULL;
 645         if (mVectorReader) {
 646             delete mVectorReader;
 647             mVectorReader=NULL;
 648         }
 649     }
 650 }
 651
 652 void vvSlicerManager::RemoveActors()
 653 {
 654     ///This method leaks a few objects. See RemoveActor for what a correct implementation would look like
 655     for ( unsigned int i = 0; i < mSlicers.size(); i++)
 656     {
 657         mSlicers[i]->SetDisplayMode(0);
 658         mSlicers[i]->GetRenderer()->RemoveActor(mSlicers[i]->GetImageActor());
 659     }
 660 }
 661
 662 void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)
 663 {
 664 //  int view = mSlicers[slicer]->GetSliceOrientation();
 665 //  int slice = mSlicers[slicer]->GetSlice();
 666     double x = mSlicers[slicer]->GetCursorPosition()[0];
 667     double y = mSlicers[slicer]->GetCursorPosition()[1];
 668     double z = mSlicers[slicer]->GetCursorPosition()[2];
 669     double X = (x - mSlicers[slicer]->GetInput()->GetOrigin()[0])/
 670         mSlicers[slicer]->GetInput()->GetSpacing()[0];
 671     double Y = (y - mSlicers[slicer]->GetInput()->GetOrigin()[1])/
 672         mSlicers[slicer]->GetInput()->GetSpacing()[1];
 673     double Z = (z - mSlicers[slicer]->GetInput()->GetOrigin()[2])/
 674         mSlicers[slicer]->GetInput()->GetSpacing()[2];
 675     double value = -VTK_DOUBLE_MAX;
 676     int displayVec = 0;
 677     double xVec=0, yVec=0, zVec=0, valueVec=0;
 678     int displayOver = 0;
 679     int displayFus = 0;
 680     double valueOver=0, valueFus=0;
 681     if (X >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
 682             X <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
 683             Y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
 684             Y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
 685             Z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
 686             Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5])
 687     {
 688         value = mSlicers[slicer]->GetInput()->GetScalarComponentAsDouble(
 689                 (int)floor(X),
 690                 (int)floor(Y),
 691                 (int)floor(Z),0);
 692         if (mSlicers[slicer]->GetVFActor() && mSlicers[slicer]->GetVFActor()->GetVisibility())
 693         {
 694             displayVec = 1;
 695             unsigned int currentTime = mSlicers[slicer]->GetTSlice();
 696             vtkImageData *vf = NULL;
 697
 698             if (mSlicers[slicer]->GetVF()->GetVTKImages().size() > currentTime)
 699                 vf = mSlicers[slicer]->GetVF()->GetVTKImages()[currentTime];
 700             else
 701                 vf = mSlicers[slicer]->GetVF()->GetVTKImages()[0];
 702
 703             if (vf)
 704             {
 705                 double Xvf = (x - vf->GetOrigin()[0])/ vf->GetSpacing()[0];
 706                 double Yvf = (y - vf->GetOrigin()[1])/ vf->GetSpacing()[1];
 707                 double Zvf = (z - vf->GetOrigin()[2])/ vf->GetSpacing()[2];
 708                 xVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),0);
 709                 yVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),1);
 710                 zVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),2);
 711                 valueVec = sqrt(xVec*xVec + yVec*yVec + zVec*zVec);
 712             }
 713         }
 714         if (mSlicers[slicer]->GetOverlayActor() && mSlicers[slicer]->GetOverlayActor()->GetVisibility())
 715         {
 716             displayOver = 1;
 717             double Xover = (x - mSlicers[slicer]->GetOverlay()->GetOrigin()[0])
 718                 /mSlicers[slicer]->GetOverlay()->GetSpacing()[0];
 719             double Yover = (y - mSlicers[slicer]->GetOverlay()->GetOrigin()[1])
 720                 /mSlicers[slicer]->GetOverlay()->GetSpacing()[1];
 721             double Zover = (z - mSlicers[slicer]->GetOverlay()->GetOrigin()[2])
 722                 /mSlicers[slicer]->GetOverlay()->GetSpacing()[2];
 723             if (Xover >= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[0] &&
 724                     Xover <= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[1] &&
 725                     Yover >= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[2] &&
 726                     Yover <= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[3] &&
 727                     Zover >= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[4] &&
 728                     Zover <= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[5])
 729             {
 730                 valueOver = static_cast<vtkImageData*>(mSlicers[slicer]->GetOverlayMapper()->GetInput())->
 731                     GetScalarComponentAsDouble(
 732                             (int)floor(Xover),
 733                             (int)floor(Yover),
 734                             (int)floor(Zover),0);
 735             }
 736         }
 737         if (mSlicers[slicer]->GetFusionActor() && mSlicers[slicer]->GetFusionActor()->GetVisibility())
 738         {
 739             displayFus = 1;
 740             double Xfus = (x - mSlicers[slicer]->GetFusion()->GetOrigin()[0])
 741                 /mSlicers[slicer]->GetFusion()->GetSpacing()[0];
 742             double Yfus = (y - mSlicers[slicer]->GetFusion()->GetOrigin()[1])
 743                 /mSlicers[slicer]->GetFusion()->GetSpacing()[1];
 744             double Zfus = (z - mSlicers[slicer]->GetFusion()->GetOrigin()[2])
 745                 /mSlicers[slicer]->GetFusion()->GetSpacing()[2];
 746             if (Xfus >= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[0] &&
 747                     Xfus <= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[1] &&
 748                     Yfus >= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[2] &&
 749                     Yfus <= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[3] &&
 750                     Zfus >= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[4] &&
 751                     Zfus <= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[5])
 752             {
 753                 valueFus = static_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput())->
 754                     GetScalarComponentAsDouble(
 755                             (int)floor(Xfus),
 756                             (int)floor(Yfus),
 757                             (int)floor(Zfus),0);
 758             }
 759         }
 760         emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),
 761                 x,y,z,X,Y,Z,value);
 762         emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec);
 763         emit UpdateOverlay(displayOver,valueOver,value);
 764         emit UpdateFusion(displayFus,valueFus);
 765         for (unsigned int i = 0; i < mSlicers.size(); i++)
 766         {
 767             if (mSlicers[i]->GetImageActor()->GetVisibility() == 1)
 768                 emit UpdateWindows(i,mSlicers[i]->GetSliceOrientation(),mSlicers[i]->GetSlice());
 769             else
 770                 emit UpdateWindows(i,-1,-1);
 771         }
 772     }
 773 }
 774
 775 void vvSlicerManager::Activated()
 776 {
 777     emit currentImageChanged(mId);
 778 }
 779
 780 void vvSlicerManager::UpdateWindowLevel()
 781 {
 782     emit WindowLevelChanged(mSlicers[0]->GetColorWindow(),mSlicers[0]->GetColorLevel(),mPreset,mColorMap);
 783 }
 784
 785 void vvSlicerManager::UpdateSlice(int slicer)
 786 {
 787     emit UpdateSlice(slicer, mSlicers[slicer]->GetSlice());
 788 }
 789
 790 void vvSlicerManager::UpdateTSlice(int slicer)
 791 {
 792     emit UpdateTSlice(slicer,mSlicers[0]->GetTSlice());
 793 }
 794
 795 void vvSlicerManager::UpdateSliceRange(int slicer)
 796 {
 797     emit UpdateSliceRange(slicer,
 798                           mSlicers[slicer]->GetSliceRange()[0], mSlicers[slicer]->GetSliceRange()[1],
 799                           0,mSlicers[slicer]->GetTMax());
 800 }
 801
 802 void vvSlicerManager::SetPreset(int preset)
 803 {
 804     //vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
 805     double window = mSlicers[0]->GetColorWindow();
 806     double level = mSlicers[0]->GetColorLevel();
 807
 808     std::string component_type=mImage->GetScalarTypeAsString();
 809     switch (preset)
 810     {
 811     case 0:
 812         if (component_type == "unsigned_char")
 813         {
 814             window = 255;
 815             level = 127;
 816         }
 817         else if (component_type == "short")
 818         {
 819             window = 2000;
 820             level = 0;
 821         }
 822         else
 823         {
 824             double range[2];
 825             mImage->GetScalarRange(range);
 826             window = range[1] - range[0];
 827             level = (range[1] + range[0])* 0.5;
 828         }
 829         break;
 830     case 1:
 831         window = 2000;
 832         level = 0;
 833         break;
 834     case 2:
 835         window = 350;
 836         level = 60;
 837         break;
 838     case 3:
 839         window = 1500;
 840         level = -500;
 841         break;
 842     case 4:
 843         window = 1000;
 844         level = 500;
 845         break;
 846     case 5:
 847         window = 1;
 848         level = 0.5;
 849         break;
 850     case 6:
 851         break;
 852     case 7:
 853         window=1.;
 854         level=0.;
 855         break;
 856     }
 857     mPreset = preset;
 858     this->SetColorWindow(window);
 859     this->SetColorLevel(level);
 860
 861     //if (LUT)
 862     //{
 863     //    SetColorMap(-1);
 864     //}
 865 }
 866
 867 void vvSlicerManager::SetLocalColorWindowing(const int slicer)
 868 {
 869     double min, max;
 870         this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max);
 871     this->SetColorWindow(max-min);
 872     this->SetColorLevel(0.5*(min+max));
 873         this->Render();
 874 }
 875
 876 void vvSlicerManager::SetColorMap()
 877 {
 878     SetColorMap(mColorMap);
 879 }
 880
 881 void vvSlicerManager::SetColorMap(int colormap)
 882 {
 883     double range[2];
 884     range[0] = mSlicers[0]->GetInput()->GetScalarRange()[0];
 885     range[1] = mSlicers[0]->GetInput()->GetScalarRange()[1];
 886
 887     double window = mSlicers[0]->GetWindowLevel()->GetWindow();
 888     double level = mSlicers[0]->GetWindowLevel()->GetLevel();
 889
 890     vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
 891     switch (colormap)
 892     {
 893     case -1:
 894         break;
 895     case 0:
 896         LUT = NULL;
 897         break;
 898     case 1:
 899         if (LUT == NULL)
 900             LUT = vtkLookupTable::New();
 901         LUT->SetValueRange(0,1);
 902         LUT->SetSaturationRange(1,1);
 903         LUT->SetHueRange(0,0.18);
 904         break;
 905     case 2:
 906         if (LUT == NULL)
 907             LUT = vtkLookupTable::New();
 908         LUT->SetValueRange(0,1);
 909         LUT->SetSaturationRange(1,1);
 910         LUT->SetHueRange(0.4,0.80);
 911         break;
 912     case 3:
 913         if (LUT == NULL)
 914             LUT = vtkLookupTable::New();
 915         LUT->SetValueRange(0,1);
 916         LUT->SetSaturationRange(1,1);
 917         LUT->SetHueRange(0,1);
 918         break;
 919     case 5:
 920         if (LUT == NULL)
 921             LUT = vtkLookupTable::New();
 922         LUT->SetValueRange(0.,1);
 923         LUT->SetSaturationRange(1,1);
 924         LUT->SetHueRange(1,0.1);
 925         //LUT->SetRampToLinear();
 926         break;
 927     }
 928     if (LUT)
 929     {
 930         LUT->SetTableRange(level-fabs(window)/4,level+fabs(window)/4);
 931         LUT->Build();
 932     }
 933     vtkLookupTable* fusLUT = NULL;
 934     if (mSlicers[0]->GetFusion())
 935     {
 936         fusLUT = vtkLookupTable::New();
 937         double fusRange [2];
 938         fusRange[0] = mFusionLevel - mFusionWindow/2;
 939         fusRange[1] = mFusionLevel + mFusionWindow/2;
 940         fusLUT->SetTableRange(fusRange[0],fusRange[1]);
 941         fusLUT->SetValueRange(1,1);
 942         fusLUT->SetSaturationRange(1,1);
 943         if (mFusionColorMap == 1)
 944             fusLUT->SetHueRange(0,0.18);
 945         else if (mFusionColorMap == 2)
 946             fusLUT->SetHueRange(0.4,0.80);
 947         else if (mFusionColorMap == 3)
 948             fusLUT->SetHueRange(0,1);
 949         fusLUT->Build();
 950         if (mFusionColorMap == 0)
 951             fusLUT = NULL;
 952     }
 953     for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 954         if (mSlicers[i]->GetOverlay() && mSlicers[i]->GetOverlayActor()->GetVisibility()) {
 955             vtkLookupTable* supLUT = vtkLookupTable::New();
 956             supLUT->SetTableRange(range[0],range[1]);
 957             supLUT->SetValueRange(1,1);
 958             supLUT->SetSaturationRange(1,1);
 959             supLUT->SetHueRange(double(mOverlayColor)/360,double(mOverlayColor)/360);
 960             supLUT->Build();
 961             vtkLookupTable* invLUT = vtkLookupTable::New();
 962             invLUT->SetTableRange(range[0],range[1]);
 963             invLUT->SetValueRange(1,1);
 964             invLUT->SetSaturationRange(1,1);
 965             invLUT->SetHueRange(double((mOverlayColor+180)%360)/360,double((mOverlayColor+180)%360)/360);
 966             invLUT->Build();
 967             dynamic_cast<vvImageMapToWLColors*>(mSlicers[i]->GetWindowLevel())
 968                 ->SetWindowLevelMode(true);
 969             mSlicers[i]->GetWindowLevel()->SetLookupTable(supLUT);
 970             mSlicers[i]->GetOverlayMapper()->SetLookupTable(invLUT);
 971             invLUT->Delete();
 972             supLUT->Delete();
 973         }
 974         else if (mSlicers[i]->GetOverlay())
 975         {
 976             //dynamic_cast<vvImageMapToWLColors*>(mSlicers[i]->GetWindowLevel())
 977                 //->SetWindowLevelMode(false);
 978             mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
 979         }
 980         else
 981         {
 982             mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
 983         }
 984         if (mSlicers[i]->GetFusion() && mSlicers[i]->GetFusionActor()->GetVisibility())
 985         {
 986             mSlicers[i]->GetFusionActor()->SetOpacity(double(mFusionOpacity)/100);
 987             mSlicers[i]->GetFusionMapper()->SetLookupTable(fusLUT);
 988         }
 989     }
 990     if (fusLUT)
 991         fusLUT->Delete();
 992     if (colormap >= 0)
 993         mColorMap = colormap;
 994 }
 995
 996 vvLandmarks* vvSlicerManager::GetLandmarks()
 997 {
 998     if (mLandmarks == NULL)
 999     {
1000         mLandmarks = new vvLandmarks(mSlicers[0]->GetTMax()+1);
1001         for (unsigned int i = 0; i < mSlicers.size(); i++)
1002             mSlicers[i]->SetLandmarks(mLandmarks);
1003     }
1004     return mLandmarks;
1005 }
1006
1007 void vvSlicerManager::AddLandmark(float x,float y,float z,float t)
1008 {
1009     double x_index = (x - mSlicers[0]->GetInput()->GetOrigin()[0])/mSlicers[0]->GetInput()->GetSpacing()[0];
1010     double y_index = (y - mSlicers[0]->GetInput()->GetOrigin()[1])/mSlicers[0]->GetInput()->GetSpacing()[1];
1011     double z_index = (z - mSlicers[0]->GetInput()->GetOrigin()[2])/mSlicers[0]->GetInput()->GetSpacing()[2];
1012     double value = mSlicers[0]->GetInput()->GetScalarComponentAsDouble(
1013             (int)x_index,
1014             (int)y_index,
1015             (int)z_index,0);
1016     this->GetLandmarks()->AddLandmark(x,y,z,t,value);
1017     emit LandmarkAdded();
1018 }