vv/vvSlicerManager.cxx

   1 /*=========================================================================
   2
   3 Program:   vv
   4 Module:    $RCSfile: vvSlicerManager.cxx,v $
   5 Language:  C++
   6 Date:      $Date: 2010/01/06 13:31:57 $
   7 Version:   $Revision: 1.1 $
   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::ReloadVF()
 614 {
 615     mVectorReader->Update(VECTORFIELD); //deletes the old images through the VF::Init() function
 616     mVF=mVectorReader->GetOutput();
 617     for ( unsigned int i = 0; i < mSlicers.size(); i++)
 618     {
 619         mSlicers[i]->SetVF(mVF);
 620         mSlicers[i]->Render();
 621     }
 622 }
 623
 624 void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_index)
 625 {
 626     for (unsigned int i = 0; i < mSlicers.size();i++)
 627     {
 628         mSlicers[i]->RemoveActor(actor_type,overlay_index);
 629     }
 630     if (actor_type=="vector")
 631     {
 632         mVF=NULL;
 633         if (mVectorReader) {
 634             delete mVectorReader;
 635             mVectorReader=NULL;
 636         }
 637     }
 638 }
 639
 640 void vvSlicerManager::RemoveActors()
 641 {
 642     ///This method leaks a few objects. See RemoveActor for what a correct implementation would look like
 643     for ( unsigned int i = 0; i < mSlicers.size(); i++)
 644     {
 645         mSlicers[i]->SetDisplayMode(0);
 646         mSlicers[i]->GetRenderer()->RemoveActor(mSlicers[i]->GetImageActor());
 647     }
 648 }
 649
 650 void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)
 651 {
 652 //  int view = mSlicers[slicer]->GetSliceOrientation();
 653 //  int slice = mSlicers[slicer]->GetSlice();
 654     double x = mSlicers[slicer]->GetCursorPosition()[0];
 655     double y = mSlicers[slicer]->GetCursorPosition()[1];
 656     double z = mSlicers[slicer]->GetCursorPosition()[2];
 657     double X = (x - mSlicers[slicer]->GetInput()->GetOrigin()[0])/
 658         mSlicers[slicer]->GetInput()->GetSpacing()[0];
 659     double Y = (y - mSlicers[slicer]->GetInput()->GetOrigin()[1])/
 660         mSlicers[slicer]->GetInput()->GetSpacing()[1];
 661     double Z = (z - mSlicers[slicer]->GetInput()->GetOrigin()[2])/
 662         mSlicers[slicer]->GetInput()->GetSpacing()[2];
 663     double value = -VTK_DOUBLE_MAX;
 664     int displayVec = 0;
 665     double xVec=0, yVec=0, zVec=0, valueVec=0;
 666     int displayOver = 0;
 667     int displayFus = 0;
 668     double valueOver=0, valueFus=0;
 669     if (X >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
 670             X <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
 671             Y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
 672             Y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
 673             Z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
 674             Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5])
 675     {
 676         value = mSlicers[slicer]->GetInput()->GetScalarComponentAsDouble(
 677                 (int)floor(X),
 678                 (int)floor(Y),
 679                 (int)floor(Z),0);
 680         if (mSlicers[slicer]->GetVFActor() && mSlicers[slicer]->GetVFActor()->GetVisibility())
 681         {
 682             displayVec = 1;
 683             unsigned int currentTime = mSlicers[slicer]->GetTSlice();
 684             vtkImageData *vf = NULL;
 685
 686             if (mSlicers[slicer]->GetVF()->GetVTKImages().size() > currentTime)
 687                 vf = mSlicers[slicer]->GetVF()->GetVTKImages()[currentTime];
 688             else
 689                 vf = mSlicers[slicer]->GetVF()->GetVTKImages()[0];
 690
 691             if (vf)
 692             {
 693                 double Xvf = (x - vf->GetOrigin()[0])/ vf->GetSpacing()[0];
 694                 double Yvf = (y - vf->GetOrigin()[1])/ vf->GetSpacing()[1];
 695                 double Zvf = (z - vf->GetOrigin()[2])/ vf->GetSpacing()[2];
 696                 xVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),0);
 697                 yVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),1);
 698                 zVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),2);
 699                 valueVec = sqrt(xVec*xVec + yVec*yVec + zVec*zVec);
 700             }
 701         }
 702         if (mSlicers[slicer]->GetOverlayActor() && mSlicers[slicer]->GetOverlayActor()->GetVisibility())
 703         {
 704             displayOver = 1;
 705             double Xover = (x - mSlicers[slicer]->GetOverlay()->GetOrigin()[0])
 706                 /mSlicers[slicer]->GetOverlay()->GetSpacing()[0];
 707             double Yover = (y - mSlicers[slicer]->GetOverlay()->GetOrigin()[1])
 708                 /mSlicers[slicer]->GetOverlay()->GetSpacing()[1];
 709             double Zover = (z - mSlicers[slicer]->GetOverlay()->GetOrigin()[2])
 710                 /mSlicers[slicer]->GetOverlay()->GetSpacing()[2];
 711             if (Xover >= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[0] &&
 712                     Xover <= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[1] &&
 713                     Yover >= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[2] &&
 714                     Yover <= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[3] &&
 715                     Zover >= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[4] &&
 716                     Zover <= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[5])
 717             {
 718                 valueOver = static_cast<vtkImageData*>(mSlicers[slicer]->GetOverlayMapper()->GetInput())->
 719                     GetScalarComponentAsDouble(
 720                             (int)floor(Xover),
 721                             (int)floor(Yover),
 722                             (int)floor(Zover),0);
 723             }
 724         }
 725         if (mSlicers[slicer]->GetFusionActor() && mSlicers[slicer]->GetFusionActor()->GetVisibility())
 726         {
 727             displayFus = 1;
 728             double Xfus = (x - mSlicers[slicer]->GetFusion()->GetOrigin()[0])
 729                 /mSlicers[slicer]->GetFusion()->GetSpacing()[0];
 730             double Yfus = (y - mSlicers[slicer]->GetFusion()->GetOrigin()[1])
 731                 /mSlicers[slicer]->GetFusion()->GetSpacing()[1];
 732             double Zfus = (z - mSlicers[slicer]->GetFusion()->GetOrigin()[2])
 733                 /mSlicers[slicer]->GetFusion()->GetSpacing()[2];
 734             if (Xfus >= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[0] &&
 735                     Xfus <= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[1] &&
 736                     Yfus >= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[2] &&
 737                     Yfus <= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[3] &&
 738                     Zfus >= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[4] &&
 739                     Zfus <= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[5])
 740             {
 741                 valueFus = static_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput())->
 742                     GetScalarComponentAsDouble(
 743                             (int)floor(Xfus),
 744                             (int)floor(Yfus),
 745                             (int)floor(Zfus),0);
 746             }
 747         }
 748         emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),
 749                 x,y,z,X,Y,Z,value);
 750         emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec);
 751         emit UpdateOverlay(displayOver,valueOver,value);
 752         emit UpdateFusion(displayFus,valueFus);
 753         for (unsigned int i = 0; i < mSlicers.size(); i++)
 754         {
 755             if (mSlicers[i]->GetImageActor()->GetVisibility() == 1)
 756                 emit UpdateWindows(i,mSlicers[i]->GetSliceOrientation(),mSlicers[i]->GetSlice());
 757             else
 758                 emit UpdateWindows(i,-1,-1);
 759         }
 760     }
 761 }
 762
 763 void vvSlicerManager::Activated()
 764 {
 765     emit currentImageChanged(mId);
 766 }
 767
 768 void vvSlicerManager::UpdateWindowLevel()
 769 {
 770     emit WindowLevelChanged(mSlicers[0]->GetColorWindow(),mSlicers[0]->GetColorLevel(),mPreset,mColorMap);
 771 }
 772
 773 void vvSlicerManager::UpdateSlice(int slicer)
 774 {
 775     emit UpdateSlice(slicer, mSlicers[slicer]->GetSlice());
 776 }
 777
 778 void vvSlicerManager::UpdateTSlice(int slicer)
 779 {
 780     emit UpdateTSlice(slicer,mSlicers[0]->GetTSlice());
 781 }
 782
 783 void vvSlicerManager::UpdateSliceRange(int slicer)
 784 {
 785     emit UpdateSliceRange(slicer,
 786                           mSlicers[slicer]->GetSliceRange()[0], mSlicers[slicer]->GetSliceRange()[1],
 787                           0,mSlicers[slicer]->GetTMax());
 788 }
 789
 790 void vvSlicerManager::SetPreset(int preset)
 791 {
 792     double range[2];
 793     mImage->GetScalarRange(range);
 794     //vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
 795     double window = mSlicers[0]->GetColorWindow();
 796     double level = mSlicers[0]->GetColorLevel();
 797
 798     std::string component_type=mImage->GetScalarTypeAsString();
 799     switch (preset)
 800     {
 801     case 0:
 802         if (component_type == "unsigned_char")
 803         {
 804             window = 255;
 805             level = 127;
 806         }
 807         else if (component_type == "short")
 808         {
 809             window = 2000;
 810             level = 0;
 811         }
 812         else
 813         {
 814             window = range[1] - range[0];
 815             level = (range[1] + range[0])* 0.5;
 816         }
 817         break;
 818     case 1:
 819         window = 2000;
 820         level = 0;
 821         break;
 822     case 2:
 823         window = 350;
 824         level = 60;
 825         break;
 826     case 3:
 827         window = 1500;
 828         level = -500;
 829         break;
 830     case 4:
 831         window = 1000;
 832         level = 500;
 833         break;
 834     case 5:
 835         window = 1;
 836         level = 0.5;
 837         break;
 838     case 6:
 839         break;
 840     case 7:
 841         window=1.;
 842         level=1;
 843         break;
 844     }
 845     mPreset = preset;
 846     this->SetColorWindow(window);
 847     this->SetColorLevel(level);
 848
 849     //if (LUT)
 850     //{
 851     //    SetColorMap(-1);
 852     //}
 853 }
 854
 855 void vvSlicerManager::SetColorMap(int colormap)
 856 {
 857     double range[2];
 858     range[0] = mSlicers[0]->GetInput()->GetScalarRange()[0];
 859     range[1] = mSlicers[0]->GetInput()->GetScalarRange()[1];
 860
 861     double window = mSlicers[0]->GetWindowLevel()->GetWindow();
 862     double level = mSlicers[0]->GetWindowLevel()->GetLevel();
 863
 864     vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
 865     switch (colormap)
 866     {
 867     case -1:
 868         if (LUT)
 869             LUT->SetTableRange(level-fabs(window)/4,level+fabs(window)/4);
 870         break;
 871     case 0:
 872         LUT = NULL;
 873         break;
 874     case 1:
 875         if (LUT == NULL)
 876             LUT = vtkLookupTable::New();
 877         LUT->SetTableRange(level-fabs(window)/4,level+fabs(window)/4);
 878         LUT->SetValueRange(0,1);
 879         LUT->SetSaturationRange(1,1);
 880         LUT->SetHueRange(0,0.18);
 881         break;
 882     case 2:
 883         if (LUT == NULL)
 884             LUT = vtkLookupTable::New();
 885         LUT->SetTableRange(level-fabs(window)/4,level+fabs(window)/4);
 886         LUT->SetValueRange(0,1);
 887         LUT->SetSaturationRange(1,1);
 888         LUT->SetHueRange(0.4,0.80);
 889         break;
 890     case 3:
 891         if (LUT == NULL)
 892             LUT = vtkLookupTable::New();
 893         LUT->SetTableRange(level-fabs(window)/4,level+fabs(window)/4);
 894         LUT->SetValueRange(0,1);
 895         LUT->SetSaturationRange(1,1);
 896         LUT->SetHueRange(0,1);
 897         break;
 898     case 5:
 899         if (LUT == NULL)
 900             LUT = vtkLookupTable::New();
 901         LUT->SetValueRange(0.,1);
 902         LUT->SetSaturationRange(1,1);
 903         LUT->SetHueRange(1,0.1);
 904         //LUT->SetRampToLinear();
 905         break;
 906     }
 907     if (LUT)
 908         LUT->Build();
 909     vtkLookupTable* fusLUT = NULL;
 910     if (mSlicers[0]->GetFusion())
 911     {
 912         fusLUT = vtkLookupTable::New();
 913         double fusRange [2];
 914         fusRange[0] = mFusionLevel - mFusionWindow/2;
 915         fusRange[1] = mFusionLevel + mFusionWindow/2;
 916         fusLUT->SetTableRange(fusRange[0],fusRange[1]);
 917         fusLUT->SetValueRange(1,1);
 918         fusLUT->SetSaturationRange(1,1);
 919         if (mFusionColorMap == 1)
 920             fusLUT->SetHueRange(0,0.18);
 921         else if (mFusionColorMap == 2)
 922             fusLUT->SetHueRange(0.4,0.80);
 923         else if (mFusionColorMap == 3)
 924             fusLUT->SetHueRange(0,1);
 925         fusLUT->Build();
 926         if (mFusionColorMap == 0)
 927             fusLUT = NULL;
 928     }
 929     for ( unsigned int i = 0; i < mSlicers.size(); i++) {
 930         if (mSlicers[i]->GetOverlay() && mSlicers[i]->GetOverlayActor()->GetVisibility()) {
 931             vtkLookupTable* supLUT = vtkLookupTable::New();
 932             supLUT->SetTableRange(range[0],range[1]);
 933             supLUT->SetValueRange(1,1);
 934             supLUT->SetSaturationRange(1,1);
 935             supLUT->SetHueRange(double(mOverlayColor)/360,double(mOverlayColor)/360);
 936             supLUT->Build();
 937             vtkLookupTable* invLUT = vtkLookupTable::New();
 938             invLUT->SetTableRange(range[0],range[1]);
 939             invLUT->SetValueRange(1,1);
 940             invLUT->SetSaturationRange(1,1);
 941             invLUT->SetHueRange(double((mOverlayColor+180)%360)/360,double((mOverlayColor+180)%360)/360);
 942             invLUT->Build();
 943             dynamic_cast<vvImageMapToWLColors*>(mSlicers[i]->GetWindowLevel())
 944                 ->SetWindowLevelMode(true);
 945             mSlicers[i]->GetWindowLevel()->SetLookupTable(supLUT);
 946             mSlicers[i]->GetOverlayMapper()->SetLookupTable(invLUT);
 947             invLUT->Delete();
 948             supLUT->Delete();
 949         }
 950         else if (mSlicers[i]->GetOverlay())
 951         {
 952             dynamic_cast<vvImageMapToWLColors*>(mSlicers[i]->GetWindowLevel())
 953                 ->SetWindowLevelMode(false);
 954             mSlicers[i]->GetWindowLevel()->SetLookupTable(NULL);
 955         }
 956         else
 957         {
 958             mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
 959         }
 960         if (mSlicers[i]->GetFusion() && mSlicers[i]->GetFusionActor()->GetVisibility())
 961         {
 962             mSlicers[i]->GetFusionActor()->SetOpacity(double(mFusionOpacity)/100);
 963             mSlicers[i]->GetFusionMapper()->SetLookupTable(fusLUT);
 964         }
 965     }
 966     if (fusLUT)
 967         fusLUT->Delete();
 968     if (colormap >= 0)
 969         mColorMap = colormap;
 970 }
 971
 972 vvLandmarks* vvSlicerManager::GetLandmarks()
 973 {
 974     if (mLandmarks == NULL)
 975     {
 976         mLandmarks = new vvLandmarks(mSlicers[0]->GetTMax()+1);
 977         for (unsigned int i = 0; i < mSlicers.size(); i++)
 978             mSlicers[i]->SetLandmarks(mLandmarks);
 979     }
 980     return mLandmarks;
 981 }
 982
 983 void vvSlicerManager::AddLandmark(float x,float y,float z,float t)
 984 {
 985     double x_index = (x - mSlicers[0]->GetInput()->GetOrigin()[0])/mSlicers[0]->GetInput()->GetSpacing()[0];
 986     double y_index = (y - mSlicers[0]->GetInput()->GetOrigin()[1])/mSlicers[0]->GetInput()->GetSpacing()[1];
 987     double z_index = (z - mSlicers[0]->GetInput()->GetOrigin()[2])/mSlicers[0]->GetInput()->GetSpacing()[2];
 988     double value = mSlicers[0]->GetInput()->GetScalarComponentAsDouble(
 989             (int)x_index,
 990             (int)y_index,
 991             (int)z_index,0);
 992     this->GetLandmarks()->AddLandmark(x,y,z,t,value);
 993     emit LandmarkAdded();
 994 }