vv/vvSlicerManager.cxx

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