vv/vvSlicerManager.cxx

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