vv/vvSlicerManager.cxx

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