1 /*=========================================================================
2 Program: vv http://www.creatis.insa-lyon.fr/rio/vv
5 - University of LYON http://www.universite-lyon.fr/
6 - Léon Bérard cancer center http://oncora1.lyon.fnclcc.fr
7 - CREATIS CNRS laboratory http://www.creatis.insa-lyon.fr
9 This software is distributed WITHOUT ANY WARRANTY; without even
10 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
11 PURPOSE. See the copyright notices for more information.
13 It is distributed under dual licence
15 - BSD See included LICENSE.txt file
16 - CeCILL-B http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
17 ======================================================================-====*/
19 #include "vvSlicerManager.h"
22 #include "vvSlicerManagerCommand.h"
23 #include "vvInteractorStyleNavigator.h"
24 #include "vvLandmarks.h"
26 #include "vvImageMapToWLColors.h"
27 #include "vvBlendImageActor.h"
29 #include <vtkImageActor.h>
30 #include <vtkImageData.h>
31 #include <vtkRenderWindow.h>
32 #include <vtkRendererCollection.h>
33 #include <vtkRenderWindowInteractor.h>
34 #include <vtkImageMapToWindowLevelColors.h>
35 #include <vtkWindowLevelLookupTable.h>
36 #include <vtkColorTransferFunction.h>
37 #include <vtkImageClip.h>
38 #include <vtkLODActor.h>
39 #include <vtkPointData.h>
40 #include <vtksys/SystemTools.hxx>
41 #include <vtkCamera.h>
43 //----------------------------------------------------------------------------
44 vvSlicerManager::vvSlicerManager(int numberOfSlicers)
53 mType = vvImageReader::UNDEFINEDIMAGETYPE;
66 for ( int i = 0; i < numberOfSlicers; i++)
67 mSlicers.push_back(vtkSmartPointer<vvSlicer>::New());
69 mPreviousSlice.resize(numberOfSlicers);
70 mPreviousTSlice.resize(numberOfSlicers);
72 //----------------------------------------------------------------------------
75 //----------------------------------------------------------------------------
76 vvSlicerManager::~vvSlicerManager()
81 //----------------------------------------------------------------------------
84 //------------------------------------------------------------------------------
85 void vvSlicerManager::SetFilename(std::string filename, int number)
88 mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
89 mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
90 mBaseFileNameNumber = number;
92 mFileName = mBaseFileName;
94 mFileName.append("_"+clitk::toString(number));
96 mFileName.append(vtksys::SystemTools::GetFilenameLastExtension(filename));
98 for(unsigned int i=0; i<mSlicers.size(); i++) {
99 mSlicers[i]->SetFileName(mFileName);//vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
103 //------------------------------------------------------------------------------
106 //----------------------------------------------------------------------------
107 void vvSlicerManager::AddContour(vvMesh::Pointer contour,bool propagate)
109 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
110 mSlicers[i]->AddContour(contour,propagate);
113 //----------------------------------------------------------------------------
116 //----------------------------------------------------------------------------
117 void vvSlicerManager::ToggleContourSuperposition()
119 for ( unsigned int i = 0; i < mSlicers.size(); i++)
120 mSlicers[i]->ToggleContourSuperposition();
122 //----------------------------------------------------------------------------
125 //----------------------------------------------------------------------------
126 bool vvSlicerManager::SetImage(std::string filename, vvImageReader::LoadedImageType type, int n, unsigned int slice)
129 if (mReader.IsNull())
130 mReader = vvImageReader::New();
131 std::vector<std::string> filenames;
132 filenames.push_back(filename);
133 mReader->SetInputFilenames(filenames);
134 mReader->SetSlice(slice); // Only used for SLICED type
135 mReader->Update(type);
137 SetFilename(filename, n);
138 // mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
139 //mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
140 //mBaseFileNameNumber = n;
142 if (mReader->GetLastError().size() == 0) {
143 mImage=mReader->GetOutput();
144 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
145 mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
146 mSlicers[i]->SetImage(mReader->GetOutput());
149 mLastError = mReader->GetLastError();
153 // mFileName.append("_"+clitk::toString(n));
157 //----------------------------------------------------------------------------
160 //----------------------------------------------------------------------------
161 void vvSlicerManager::SetImage(vvImage::Pointer image)
164 for (unsigned int i = 0; i < mSlicers.size(); i++) {
165 mSlicers[i]->SetImage(image);
168 //----------------------------------------------------------------------------
171 //----------------------------------------------------------------------------
172 bool vvSlicerManager::SetImages(std::vector<std::string> filenames, vvImageReader::LoadedImageType type, int n)
175 std::string fileWithoutExtension = vtksys::SystemTools::GetFilenameWithoutExtension(filenames[0]);
176 if (type == vvImageReader::DICOM)
177 fileWithoutExtension += "_dicom";
178 else if (type == vvImageReader::MERGED)
179 fileWithoutExtension += "_merged";
180 else if (type == vvImageReader::MERGEDWITHTIME)
181 fileWithoutExtension += "_merged_wt";
183 mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
184 mFileName = fileWithoutExtension + vtksys::SystemTools::GetFilenameExtension(filenames[0]);
185 if (mReader.IsNull())
186 mReader = vvImageReader::New();
187 mReader->SetInputFilenames(filenames);
188 mReader->Update(type);
190 mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
191 mBaseFileNameNumber = n;
193 if (mReader->GetLastError().size() == 0) {
194 mImage=mReader->GetOutput();
195 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
196 mSlicers[i]->SetFileName(fileWithoutExtension);
197 mSlicers[i]->SetImage(mReader->GetOutput());
200 mLastError = mReader->GetLastError();
204 mFileName.append("_"+clitk::toString(n));
208 //----------------------------------------------------------------------------
211 //----------------------------------------------------------------------------
212 bool vvSlicerManager::SetOverlay(std::string filename,int dim, std::string component)
214 mOverlayName = filename;
215 mOverlayComponent = component;
216 if (dim > mImage->GetNumberOfDimensions()) {
217 mLastError = " Overlay dimension cannot be greater then reference image!";
220 if (mOverlayReader.IsNull())
221 mOverlayReader = vvImageReader::New();
222 std::vector<std::string> filenames;
223 filenames.push_back(filename);
224 mOverlayReader->SetInputFilenames(filenames);
225 mOverlayReader->Update(mImage->GetNumberOfDimensions(),component.c_str(),mType);
226 if (mOverlayReader->GetLastError().size() == 0) {
227 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
228 mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
231 mLastError = mOverlayReader->GetLastError();
236 //----------------------------------------------------------------------------
239 //----------------------------------------------------------------------------
240 bool vvSlicerManager::SetFusion(std::string filename,int dim, std::string component)
242 mFusionName = filename;
243 mFusionComponent = component;
244 if (dim > mImage->GetNumberOfDimensions()) {
245 mLastError = " Overlay dimension cannot be greater then reference image!";
248 if (mFusionReader.IsNull())
249 mFusionReader = vvImageReader::New();
250 std::vector<std::string> filenames;
251 filenames.push_back(filename);
252 mFusionReader->SetInputFilenames(filenames);
253 mFusionReader->Update(mImage->GetNumberOfDimensions(),component.c_str(),mType);
254 if (mFusionReader->GetLastError().size() == 0) {
255 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
256 mSlicers[i]->SetFusion(mFusionReader->GetOutput());
259 mLastError = mFusionReader->GetLastError();
262 double *fusRange = mFusionReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
263 mFusionLevel = (fusRange[0]+fusRange[1])/2;
264 mFusionWindow = fusRange[1]-fusRange[0];
267 //----------------------------------------------------------------------------
270 //----------------------------------------------------------------------------
271 bool vvSlicerManager::SetVF(std::string filename)
273 if (mVectorReader.IsNull())
274 mVectorReader = vvImageReader::New();
275 mVectorReader->SetInputFilename(filename);
276 mVectorReader->Update(vvImageReader::VECTORFIELD);
277 if (mVectorReader->GetLastError().size() != 0) {
278 mLastError = mVectorReader->GetLastError();
281 return SetVF(mVectorReader->GetOutput(),filename);
283 //----------------------------------------------------------------------------
286 //----------------------------------------------------------------------------
287 bool vvSlicerManager::SetVF(vvImage::Pointer vf,std::string filename)
289 if (vf->GetNumberOfDimensions() > mImage->GetNumberOfDimensions()) {
290 mLastError = "Sorry, vector field dimension cannot be greater then reference image.";
293 if (vf->GetNumberOfDimensions() == 4) {
294 if (vf->GetSpacing()[3] != mImage->GetSpacing()[3]) {
295 mLastError = "Sorry, vector field time spacing cannot be different from time spacing of the reference image.";
298 if (vf->GetOrigin()[3] != mImage->GetOrigin()[3]) {
299 mLastError = "Sorry, vector field time origin cannot be different from time origin of the reference image.";
305 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
306 mSlicers[i]->SetVF(vf);
310 //----------------------------------------------------------------------------
313 //----------------------------------------------------------------------------
314 vvSlicer* vvSlicerManager::GetSlicer(int i)
318 //----------------------------------------------------------------------------
321 //----------------------------------------------------------------------------
322 void vvSlicerManager::UpdateSlicer(int num, bool state)
324 if (mSlicers[num]->GetImage())
325 mSlicers[num]->SetDisplayMode(state);
327 //----------------------------------------------------------------------------
330 //----------------------------------------------------------------------------
331 void vvSlicerManager::SetSlicerWindow(int i, vtkRenderWindow* RW)
333 mSlicers[i]->SetRenderWindow(i,RW);
335 //----------------------------------------------------------------------------
338 //----------------------------------------------------------------------------
339 void vvSlicerManager::SetInteractorStyleNavigator(int i, vtkInteractorStyle* style)
341 vvSlicerManagerCommand *smc = vvSlicerManagerCommand::New();
343 smc->SetSlicerNumber(i);
344 mSlicers[i]->GetRenderWindow()->GetInteractor()->SetInteractorStyle(style);
346 mSlicers[i]->GetRenderWindow()->GetInteractor()->
347 GetInteractorStyle()->AddObserver(vtkCommand::KeyPressEvent, smc);
348 mSlicers[i]->GetRenderWindow()->GetInteractor()->
349 GetInteractorStyle()->AddObserver(vtkCommand::WindowLevelEvent, smc);
350 mSlicers[i]->GetRenderWindow()->GetInteractor()->
351 GetInteractorStyle()->AddObserver(vtkCommand::EndWindowLevelEvent, smc);
352 mSlicers[i]->GetRenderWindow()->GetInteractor()->
353 GetInteractorStyle()->AddObserver(vtkCommand::StartWindowLevelEvent, smc);
354 mSlicers[i]->GetRenderWindow()->GetInteractor()->
355 GetInteractorStyle()->AddObserver(vtkCommand::PickEvent, smc);
356 mSlicers[i]->GetRenderWindow()->GetInteractor()->
357 GetInteractorStyle()->AddObserver(vtkCommand::StartPickEvent, smc);
358 mSlicers[i]->GetRenderWindow()->GetInteractor()->
359 GetInteractorStyle()->AddObserver(vtkCommand::LeaveEvent, smc);
360 mSlicers[i]->GetRenderWindow()->GetInteractor()->
361 GetInteractorStyle()->AddObserver(vtkCommand::UserEvent, smc);
362 mSlicers[i]->GetRenderWindow()->GetInteractor()->
363 GetInteractorStyle()->AddObserver(vtkCommand::MouseWheelForwardEvent, smc);
364 mSlicers[i]->GetRenderWindow()->GetInteractor()->
365 GetInteractorStyle()->AddObserver(vtkCommand::MouseWheelBackwardEvent, smc);
366 // mSlicers[i]->GetRenderWindow()->GetInteractor()->
367 // GetInteractorStyle()->AddObserver(vtkCommand::LeftButtonReleaseEvent, smc);
368 mSlicers[i]->GetRenderWindow()->GetInteractor()->
369 GetInteractorStyle()->AddObserver(vtkCommand::EndPickEvent, smc);
370 mSlicers[i]->GetRenderWindow()->GetInteractor()->
371 GetInteractorStyle()->AddObserver(vtkCommand::EndInteractionEvent, smc);
374 //----------------------------------------------------------------------------
377 //----------------------------------------------------------------------------
378 void vvSlicerManager::LeftButtonReleaseEvent(int slicer)
380 emit LeftButtonReleaseSignal(slicer);
382 //----------------------------------------------------------------------------
384 //----------------------------------------------------------------------------
385 void vvSlicerManager::SetSliceOrientation(int slicer, int orientation)
387 mSlicers[slicer]->SetSliceOrientation(orientation);
388 emit UpdateOrientation(slicer, orientation);
390 //----------------------------------------------------------------------------
392 //----------------------------------------------------------------------------
393 void vvSlicerManager::SetTSlice(int slice)
397 else if (slice > mSlicers[0]->GetTMax())
398 slice = mSlicers[0]->GetTMax();
400 mLandmarks->SetTime(slice);
401 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
402 if (slice != mSlicers[i]->GetTSlice()) {
403 mSlicers[i]->SetTSlice(slice);
404 if (mSlicers[i]->GetImageActor()->GetVisibility())
409 //----------------------------------------------------------------------------
412 //----------------------------------------------------------------------------
413 void vvSlicerManager::SetNextTSlice(int originating_slicer)
415 int t = mSlicers[0]->GetTSlice();
417 if (t > mSlicers[0]->GetTMax())
419 //std::cout << "vvSlicerManager::SetNextTSlice" << std::endl;
420 emit UpdateTSlice(originating_slicer,t);
422 //----------------------------------------------------------------------------
425 //----------------------------------------------------------------------------
426 void vvSlicerManager::SetPreviousTSlice(int originating_slicer)
428 int t = mSlicers[0]->GetTSlice();
431 t = mSlicers[0]->GetTMax();
432 //std::cout << "vvSlicerManager::SetPreviousTSlice" << std::endl;
433 emit UpdateTSlice(originating_slicer,t);
435 //----------------------------------------------------------------------------
438 //----------------------------------------------------------------------------
439 void vvSlicerManager::ToggleInterpolation()
441 bool interpolate=!(mSlicers[0]->GetImageActor()->GetInterpolate());
442 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
443 mSlicers[i]->GetImageActor()->SetInterpolate(interpolate);
444 if (mSlicers[i]->GetOverlayActor())
445 mSlicers[i]->GetOverlayActor()->SetInterpolate(interpolate);
446 if (mSlicers[i]->GetFusionActor())
447 mSlicers[i]->GetFusionActor()->SetInterpolate(interpolate);
450 //----------------------------------------------------------------------------
453 //----------------------------------------------------------------------------
454 void vvSlicerManager::SetTSliceInSlicer(int tslice, int slicer)
458 else if (tslice > mSlicers[slicer]->GetTMax())
459 tslice = mSlicers[slicer]->GetTMax();
461 mLandmarks->SetTime(tslice);
463 if (mSlicers[slicer]->GetTSlice() == tslice) return;
465 mSlicers[slicer]->SetTSlice(tslice);
466 if (mSlicers[slicer]->GetImageActor()->GetVisibility())
467 UpdateTSlice(slicer);
469 //----------------------------------------------------------------------------
472 //----------------------------------------------------------------------------
473 void vvSlicerManager::SetColorWindow(double s)
475 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
476 mSlicers[i]->SetColorWindow(s);
479 //----------------------------------------------------------------------------
482 //----------------------------------------------------------------------------
483 void vvSlicerManager::SetColorLevel(double s)
485 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
486 mSlicers[i]->SetColorLevel(s);
489 //----------------------------------------------------------------------------
491 //----------------------------------------------------------------------------
492 void vvSlicerManager::SetCursorAndCornerAnnotationVisibility(int s)
494 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
495 mSlicers[i]->SetCursorVisibility(s);
496 mSlicers[i]->SetCornerAnnotationVisibility(s);
499 //----------------------------------------------------------------------------
501 //----------------------------------------------------------------------------
502 void vvSlicerManager::SetOpacity(int i, double factor)
504 mSlicers[i]->SetOpacity(1/factor);
506 //----------------------------------------------------------------------------
509 //----------------------------------------------------------------------------
510 void vvSlicerManager::UpdateViews(int current,int slicer)
512 double x = (mSlicers[slicer]->GetCurrentPosition()[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
513 /mSlicers[slicer]->GetInput()->GetSpacing()[0];
514 double y = (mSlicers[slicer]->GetCurrentPosition()[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
515 /mSlicers[slicer]->GetInput()->GetSpacing()[1];
516 double z = (mSlicers[slicer]->GetCurrentPosition()[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
517 /mSlicers[slicer]->GetInput()->GetSpacing()[2];
519 if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
520 x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
521 y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
522 y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
523 z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
524 z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]) {
525 mSlicers[slicer]->UpdateCursorPosition();
526 mSlicers[slicer]->SetCursorColor(10,212,255);
528 switch (mSlicers[slicer]->GetSliceOrientation()) {
529 case vtkImageViewer2::SLICE_ORIENTATION_XY:
530 if (mSlicers[slicer]->GetSlice() != (int)floor(z))
531 mSlicers[slicer]->SetSlice((int)floor(z));
534 case vtkImageViewer2::SLICE_ORIENTATION_XZ:
535 if (mSlicers[slicer]->GetSlice() != (int)floor(y))
536 mSlicers[slicer]->SetSlice((int)floor(y));
539 case vtkImageViewer2::SLICE_ORIENTATION_YZ:
540 if (mSlicers[slicer]->GetSlice() != (int)floor(x))
541 mSlicers[slicer]->SetSlice((int)floor(x));
544 mSlicers[slicer]->Render();
546 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
547 if (i != (unsigned int)slicer && mSlicers[i]->GetImageActor()->GetVisibility()
548 && mSlicers[i]->GetRenderWindow()->GetSize()[0] > 2
549 && mSlicers[i]->GetRenderWindow()->GetSize()[1] > 2) {
550 mSlicers[i]->SetCurrentPosition(mSlicers[slicer]->GetCurrentPosition()[0],
551 mSlicers[slicer]->GetCurrentPosition()[1],
552 mSlicers[slicer]->GetCurrentPosition()[2],
553 mSlicers[slicer]->GetTSlice());
554 mSlicers[i]->UpdateCursorPosition();
555 if (current) { //do not display corner annotation if image is the one picked
556 mSlicers[i]->SetCurrentPosition(-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX,
557 -VTK_DOUBLE_MAX, mSlicers[slicer]->GetTSlice());
558 mSlicers[i]->SetCursorColor(255,10,212);
560 mSlicers[i]->SetCursorColor(150,10,282);
562 switch (mSlicers[i]->GetSliceOrientation()) {
563 case vtkImageViewer2::SLICE_ORIENTATION_XY:
564 if (mSlicers[i]->GetSlice() != (int)floor(z))
565 mSlicers[i]->SetSlice((int)floor(z));
568 case vtkImageViewer2::SLICE_ORIENTATION_XZ:
569 if (mSlicers[i]->GetSlice() != (int)floor(y))
570 mSlicers[i]->SetSlice((int)floor(y));
573 case vtkImageViewer2::SLICE_ORIENTATION_YZ:
574 if (mSlicers[i]->GetSlice() != (int)floor(x))
575 mSlicers[i]->SetSlice((int)floor(x));
579 mSlicers[i]->Render();
587 //----------------------------------------------------------------------------
590 //----------------------------------------------------------------------------
591 void vvSlicerManager::UpdateLinked(int slicer)
593 double x = (mSlicers[slicer]->GetCurrentPosition()[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
594 /mSlicers[slicer]->GetInput()->GetSpacing()[0];
595 double y = (mSlicers[slicer]->GetCurrentPosition()[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
596 /mSlicers[slicer]->GetInput()->GetSpacing()[1];
597 double z = (mSlicers[slicer]->GetCurrentPosition()[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
598 /mSlicers[slicer]->GetInput()->GetSpacing()[2];
600 if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
601 x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
602 y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
603 y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
604 z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
605 z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]) {
606 for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++) {
607 emit UpdateLinkManager(*i, slicer,mSlicers[slicer]->GetCurrentPosition()[0],
608 mSlicers[slicer]->GetCurrentPosition()[1],
609 mSlicers[slicer]->GetCurrentPosition()[2],mSlicers[slicer]->GetTSlice());
613 //----------------------------------------------------------------------------
615 //----------------------------------------------------------------------------
616 void vvSlicerManager::UpdateLinkedNavigation(vvSlicer *refSlicer, bool bPropagate)
618 vtkCamera *refCam = refSlicer->GetRenderer()->GetActiveCamera();
619 double refPosition[3], refFocal[3];
620 refCam->GetPosition(refPosition);
621 refCam->GetFocalPoint(refFocal);
623 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
624 vtkCamera *camera = mSlicers[i]->GetRenderer()->GetActiveCamera();
625 camera->SetParallelScale(refCam->GetParallelScale());
627 double position[3], focal[3];
628 camera->GetPosition(position);
629 camera->GetFocalPoint(focal);
631 if(refSlicer->GetSliceOrientation()==mSlicers[i]->GetSliceOrientation()) {
632 for(int i=0; i<3; i++) {
633 position[i] = refPosition[i];
634 focal[i] = refFocal[i];
638 if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) {
639 if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) {
640 position[0] = refPosition[0];
641 focal[0] = refFocal[0];
643 if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) {
644 position[1] = refPosition[1];
645 focal[1] = refFocal[1];
649 if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) {
650 if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) {
651 position[2] = refPosition[2];
652 focal[2] = refFocal[2];
654 if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) {
655 position[0] = refPosition[0];
656 focal[0] = refFocal[0];
660 if(refSlicer->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_YZ) {
661 if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XY) {
662 position[1] = refPosition[1];
663 focal[1] = refFocal[1];
665 if(mSlicers[i]->GetSliceOrientation()==vtkImageViewer2::SLICE_ORIENTATION_XZ) {
666 position[2] = refPosition[2];
667 focal[2] = refFocal[2];
671 camera->SetFocalPoint(focal);
672 camera->SetPosition(position);
675 mSlicers[i]->ForceUpdateDisplayExtent();
680 for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++)
681 emit UpdateLinkedNavigation(*i, this, refSlicer);
683 //----------------------------------------------------------------------------
685 //----------------------------------------------------------------------------
686 double vvSlicerManager::GetColorWindow()
689 return mSlicers[0]->GetColorWindow();
692 //----------------------------------------------------------------------------
695 //----------------------------------------------------------------------------
696 double vvSlicerManager::GetColorLevel()
699 return mSlicers[0]->GetColorLevel();
702 //----------------------------------------------------------------------------
705 //----------------------------------------------------------------------------
706 void vvSlicerManager::Render()
708 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
709 mSlicers[i]->Render();
712 //----------------------------------------------------------------------------
715 //----------------------------------------------------------------------------
716 void vvSlicerManager::GenerateDefaultLookupTable()
719 SetColorMap(mColorMap);
721 //----------------------------------------------------------------------------
724 //----------------------------------------------------------------------------
725 void vvSlicerManager::Reload()
727 mReader->Update(mType);
728 mImage=mReader->GetOutput();
729 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
730 mSlicers[i]->SetImage(mImage);
733 //----------------------------------------------------------------------------
736 //----------------------------------------------------------------------------
737 void vvSlicerManager::ReloadFusion()
739 mFusionReader->Update();
740 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
741 mSlicers[i]->SetFusion(mFusionReader->GetOutput());
742 mSlicers[i]->Render();
745 //----------------------------------------------------------------------------
748 //----------------------------------------------------------------------------
749 void vvSlicerManager::ReloadOverlay()
751 mOverlayReader->Update();
752 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
753 mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
754 mSlicers[i]->Render();
757 //----------------------------------------------------------------------------
760 //----------------------------------------------------------------------------
761 void vvSlicerManager::ReloadVF()
763 mVectorReader->Update(vvImageReader::VECTORFIELD); //deletes the old images through the VF::Init() function
764 mVF=mVectorReader->GetOutput();
765 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
766 mSlicers[i]->SetVF(mVF);
767 mSlicers[i]->Render();
770 //----------------------------------------------------------------------------
773 //----------------------------------------------------------------------------
774 void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_index)
776 if (actor_type =="overlay")
777 mOverlayReader = NULL;
779 if (actor_type =="fusion")
780 mFusionReader = NULL;
782 for (unsigned int i = 0; i < mSlicers.size(); i++)
783 mSlicers[i]->RemoveActor(actor_type,overlay_index);
785 if (actor_type=="vector") {
790 //----------------------------------------------------------------------------
793 //----------------------------------------------------------------------------
794 void vvSlicerManager::RemoveActors()
796 ///This method leaks a few objects. See RemoveActor for what a
797 ///correct implementation would look like
798 //DS -> probably due to the reader (now released in the
799 //RemoveActor() function. (I hope)
800 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
801 mSlicers[i]->SetDisplayMode(0);
802 mSlicers[i]->GetRenderer()->RemoveActor(mSlicers[i]->GetImageActor());
805 //----------------------------------------------------------------------------
808 //----------------------------------------------------------------------------
809 void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)
811 // int view = mSlicers[slicer]->GetSliceOrientation();
812 // int slice = mSlicers[slicer]->GetSlice();
813 double x = mSlicers[slicer]->GetCursorPosition()[0];
814 double y = mSlicers[slicer]->GetCursorPosition()[1];
815 double z = mSlicers[slicer]->GetCursorPosition()[2];
816 double X = (x - mSlicers[slicer]->GetInput()->GetOrigin()[0])/
817 mSlicers[slicer]->GetInput()->GetSpacing()[0];
818 double Y = (y - mSlicers[slicer]->GetInput()->GetOrigin()[1])/
819 mSlicers[slicer]->GetInput()->GetSpacing()[1];
820 double Z = (z - mSlicers[slicer]->GetInput()->GetOrigin()[2])/
821 mSlicers[slicer]->GetInput()->GetSpacing()[2];
822 double value = -VTK_DOUBLE_MAX;
824 double xVec=0, yVec=0, zVec=0, valueVec=0;
827 double valueOver=0, valueFus=0;
828 if (X >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
829 X <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
830 Y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
831 Y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
832 Z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
833 Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5]) {
834 value = this->GetScalarComponentAsDouble(mSlicers[slicer]->GetInput(), X, Y, Z);
836 if (mSlicers[slicer]->GetVFActor() && mSlicers[slicer]->GetVFActor()->GetVisibility()) {
838 unsigned int currentTime = mSlicers[slicer]->GetTSlice();
839 vtkImageData *vf = NULL;
841 if (mSlicers[slicer]->GetVF()->GetVTKImages().size() > currentTime)
842 vf = mSlicers[slicer]->GetVF()->GetVTKImages()[currentTime];
844 vf = mSlicers[slicer]->GetVF()->GetVTKImages()[0];
847 double Xvf = (x - vf->GetOrigin()[0])/ vf->GetSpacing()[0];
848 double Yvf = (y - vf->GetOrigin()[1])/ vf->GetSpacing()[1];
849 double Zvf = (z - vf->GetOrigin()[2])/ vf->GetSpacing()[2];
850 xVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 0);
851 yVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 1);
852 zVec = this->GetScalarComponentAsDouble( vf, Xvf, Yvf, Zvf, 2);
853 valueVec = sqrt(xVec*xVec + yVec*yVec + zVec*zVec);
856 if (mSlicers[slicer]->GetOverlayActor() && mSlicers[slicer]->GetOverlayActor()->GetVisibility()) {
858 vtkImageData *overlay = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetOverlayMapper()->GetInput());
859 double Xover = (x - overlay->GetOrigin()[0]) / overlay->GetSpacing()[0];
860 double Yover = (y - overlay->GetOrigin()[1]) / overlay->GetSpacing()[1];
861 double Zover = (z - overlay->GetOrigin()[2]) / overlay->GetSpacing()[2];
862 valueOver = this->GetScalarComponentAsDouble(overlay, Xover, Yover, Zover);
864 if (mSlicers[slicer]->GetFusionActor() && mSlicers[slicer]->GetFusionActor()->GetVisibility()) {
866 vtkImageData *fusion = dynamic_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput());
867 double Xover = (x - fusion->GetOrigin()[0]) / fusion->GetSpacing()[0];
868 double Yover = (y - fusion->GetOrigin()[1]) / fusion->GetSpacing()[1];
869 double Zover = (z - fusion->GetOrigin()[2]) / fusion->GetSpacing()[2];
870 valueFus = this->GetScalarComponentAsDouble(fusion, Xover, Yover, Zover);
872 emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),
874 emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec);
875 emit UpdateOverlay(displayOver,valueOver,value);
876 emit UpdateFusion(displayFus,valueFus);
877 for (unsigned int i = 0; i < mSlicers.size(); i++) {
878 if (mSlicers[i]->GetImageActor()->GetVisibility() == 1)
879 emit UpdateWindows(i,mSlicers[i]->GetSliceOrientation(),mSlicers[i]->GetSlice());
881 emit UpdateWindows(i,-1,-1);
885 //----------------------------------------------------------------------------
888 //----------------------------------------------------------------------------
889 void vvSlicerManager::Activated()
891 emit currentImageChanged(mId);
893 //----------------------------------------------------------------------------
896 //----------------------------------------------------------------------------
897 void vvSlicerManager::Picked()
899 emit currentPickedImageChanged(mId);
901 //----------------------------------------------------------------------------
903 //----------------------------------------------------------------------------
904 void vvSlicerManager::UpdateWindowLevel()
906 emit WindowLevelChanged(mSlicers[0]->GetColorWindow(),mSlicers[0]->GetColorLevel(),mPreset,mColorMap);
908 //----------------------------------------------------------------------------
911 //----------------------------------------------------------------------------
912 void vvSlicerManager::UpdateSlice(int slicer)
914 if (mPreviousSlice[slicer] == mSlicers[slicer]->GetSlice()) {
915 //DD("============= NOTHING");
918 //std::cout << "vvSlicerManager::UpdateSlice " << slicer << " " << mSlicers[slicer]->GetSlice() << std::endl;
919 emit UpdateSlice(slicer, mSlicers[slicer]->GetSlice());
920 mSlicers[slicer]->Render(); // DS <-- I add this, this could/must be the only Render ...
921 mPreviousSlice[slicer] = mSlicers[slicer]->GetSlice();
923 //----------------------------------------------------------------------------
926 //----------------------------------------------------------------------------
927 void vvSlicerManager::UpdateTSlice(int slicer)
929 int slice = mSlicers[slicer]->GetSlice();
930 int tslice = mSlicers[slicer]->GetTSlice();
931 if (mPreviousSlice[slicer] == slice) {
932 if (mPreviousTSlice[slicer] == tslice) {
933 // DD("************** NOTHING ***********");
937 mPreviousSlice[slicer] = slice;
938 mPreviousTSlice[slicer] = tslice;
939 //std::cout << "vvSlicerManager::UpdateTSlice " << slicer << " " << tslice << std::endl;
940 emit UpdateTSlice(slicer, tslice);
942 //----------------------------------------------------------------------------
945 //----------------------------------------------------------------------------
946 void vvSlicerManager::UpdateSliceRange(int slicer)
948 emit UpdateSliceRange(slicer,
949 mSlicers[slicer]->GetSliceRange()[0], mSlicers[slicer]->GetSliceRange()[1],
950 0,mSlicers[slicer]->GetTMax());
952 //----------------------------------------------------------------------------
955 //----------------------------------------------------------------------------
956 void vvSlicerManager::SetPreset(int preset)
958 //vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
959 double window = mSlicers[0]->GetColorWindow();
960 double level = mSlicers[0]->GetColorLevel();
962 std::string component_type=mImage->GetScalarTypeAsITKString();
966 mImage->GetScalarRange(range);
967 window = range[1] - range[0];
968 level = (range[1] + range[0])* 0.5;
998 this->SetColorWindow(window);
999 this->SetColorLevel(level);
1006 //----------------------------------------------------------------------------
1009 //----------------------------------------------------------------------------
1010 void vvSlicerManager::SetLocalColorWindowing(const int slicer)
1013 this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max);
1014 this->SetColorWindow(max-min);
1015 this->SetColorLevel(0.5*(min+max));
1016 this->UpdateWindowLevel();
1019 //----------------------------------------------------------------------------
1022 //----------------------------------------------------------------------------
1023 void vvSlicerManager::SetColorMap()
1025 SetColorMap(mColorMap);
1027 //----------------------------------------------------------------------------
1030 //----------------------------------------------------------------------------
1031 void vvSlicerManager::SetColorMap(int colormap)
1034 range[0] = mSlicers[0]->GetInput()->GetScalarRange()[0];
1035 range[1] = mSlicers[0]->GetInput()->GetScalarRange()[1];
1037 double window = mSlicers[0]->GetWindowLevel()->GetWindow();
1038 double level = mSlicers[0]->GetWindowLevel()->GetLevel();
1040 vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
1049 LUT = vtkLookupTable::New();
1050 LUT->SetValueRange(0,1);
1051 LUT->SetSaturationRange(1,1);
1052 LUT->SetHueRange(0,0.18);
1056 LUT = vtkLookupTable::New();
1057 LUT->SetValueRange(0,1);
1058 LUT->SetSaturationRange(1,1);
1059 LUT->SetHueRange(0.4,0.80);
1063 LUT = vtkLookupTable::New();
1064 LUT->SetValueRange(0,1);
1065 LUT->SetSaturationRange(1,1);
1066 LUT->SetHueRange(0,1);
1070 LUT = vtkLookupTable::New();
1071 LUT->SetValueRange(0.,1);
1072 LUT->SetSaturationRange(1,1);
1073 LUT->SetHueRange(1,0.1);
1074 //LUT->SetRampToLinear();
1078 LUT->SetTableRange(level-fabs(window)/4,level+fabs(window)/4);
1081 vtkLookupTable* fusLUT = NULL;
1082 if (mSlicers[0]->GetFusion()) {
1083 fusLUT = vtkLookupTable::New();
1084 double fusRange [2];
1085 fusRange[0] = mFusionLevel - mFusionWindow/2;
1086 fusRange[1] = mFusionLevel + mFusionWindow/2;
1087 fusLUT->SetTableRange(fusRange[0],fusRange[1]);
1088 fusLUT->SetValueRange(1,1);
1089 fusLUT->SetSaturationRange(1,1);
1090 if (mFusionColorMap == 1)
1091 fusLUT->SetHueRange(0,0.18);
1092 else if (mFusionColorMap == 2)
1093 fusLUT->SetHueRange(0.4,0.80);
1094 else if (mFusionColorMap == 3)
1095 fusLUT->SetHueRange(0,1);
1097 if (mFusionColorMap == 0)
1100 for ( unsigned int i = 0; i < mSlicers.size(); i++) {
1101 if (mSlicers[i]->GetOverlay() && mSlicers[i]->GetOverlayActor()->GetVisibility()) {
1102 vtkLookupTable* supLUT = vtkLookupTable::New();
1103 supLUT->SetTableRange(range[0],range[1]);
1104 supLUT->SetValueRange(1,1);
1105 supLUT->SetSaturationRange(1,1);
1106 supLUT->SetHueRange(double(mOverlayColor)/360,double(mOverlayColor)/360);
1108 vtkLookupTable* invLUT = vtkLookupTable::New();
1109 invLUT->SetTableRange(range[0],range[1]);
1110 invLUT->SetValueRange(1,1);
1111 invLUT->SetSaturationRange(1,1);
1112 invLUT->SetHueRange(double((mOverlayColor+180)%360)/360,double((mOverlayColor+180)%360)/360);
1114 dynamic_cast<vvImageMapToWLColors*>(mSlicers[i]->GetWindowLevel())
1115 ->SetWindowLevelMode(true);
1116 mSlicers[i]->GetWindowLevel()->SetLookupTable(supLUT);
1117 mSlicers[i]->GetOverlayMapper()->SetLookupTable(invLUT);
1120 } else if (mSlicers[i]->GetOverlay()) {
1121 //dynamic_cast<vvImageMapToWLColors*>(mSlicers[i]->GetWindowLevel())
1122 //->SetWindowLevelMode(false);
1123 mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
1125 mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
1127 if (mSlicers[i]->GetFusion() && mSlicers[i]->GetFusionActor()->GetVisibility()) {
1128 mSlicers[i]->GetFusionActor()->SetOpacity(double(mFusionOpacity)/100);
1129 mSlicers[i]->GetFusionMapper()->SetLookupTable(fusLUT);
1130 mSlicers[i]->GetFusionMapper()->SetWindow(mFusionWindow);
1131 mSlicers[i]->GetFusionMapper()->SetLevel(mFusionLevel);
1137 mColorMap = colormap;
1139 //----------------------------------------------------------------------------
1142 //----------------------------------------------------------------------------
1143 vvLandmarks* vvSlicerManager::GetLandmarks()
1145 if (mLandmarks == NULL) {
1146 mLandmarks = new vvLandmarks(mSlicers[0]->GetTMax()+1);
1147 for (unsigned int i = 0; i < mSlicers.size(); i++)
1148 mSlicers[i]->SetLandmarks(mLandmarks);
1152 //----------------------------------------------------------------------------
1155 //----------------------------------------------------------------------------
1156 void vvSlicerManager::AddLandmark(float x,float y,float z,float t)
1158 double x_index = (x - mSlicers[0]->GetInput()->GetOrigin()[0])/mSlicers[0]->GetInput()->GetSpacing()[0];
1159 double y_index = (y - mSlicers[0]->GetInput()->GetOrigin()[1])/mSlicers[0]->GetInput()->GetSpacing()[1];
1160 double z_index = (z - mSlicers[0]->GetInput()->GetOrigin()[2])/mSlicers[0]->GetInput()->GetSpacing()[2];
1161 if (x_index >= mSlicers[0]->GetInput()->GetWholeExtent()[0] &&
1162 x_index <= mSlicers[0]->GetInput()->GetWholeExtent()[1] &&
1163 y_index >= mSlicers[0]->GetInput()->GetWholeExtent()[2] &&
1164 y_index <= mSlicers[0]->GetInput()->GetWholeExtent()[3] &&
1165 z_index >= mSlicers[0]->GetInput()->GetWholeExtent()[4] &&
1166 z_index <= mSlicers[0]->GetInput()->GetWholeExtent()[5]) {
1167 double value = this->GetScalarComponentAsDouble(mSlicers[0]->GetInput(), x_index, y_index, z_index);
1168 this->GetLandmarks()->AddLandmark(x,y,z,t,value);
1169 emit LandmarkAdded();
1172 //----------------------------------------------------------------------------
1174 //----------------------------------------------------------------------------
1175 void vvSlicerManager::PrevImage(int slicer)
1177 emit ChangeImageWithIndexOffset(this, slicer, -1);
1179 //----------------------------------------------------------------------------
1181 //----------------------------------------------------------------------------
1182 void vvSlicerManager::NextImage(int slicer)
1184 emit ChangeImageWithIndexOffset(this, slicer, 1);
1186 //----------------------------------------------------------------------------
1188 //----------------------------------------------------------------------------
1189 void vvSlicerManager::VerticalSliderHasChanged(int slicer, int slice)
1191 emit AVerticalSliderHasChanged(slicer, slice);
1194 //----------------------------------------------------------------------------
1196 //----------------------------------------------------------------------------
1197 double vvSlicerManager::GetScalarComponentAsDouble(vtkImageData *image, double X, double Y, double Z, int component)
1200 return mSlicers[0]->GetScalarComponentAsDouble(image, X, Y, Z, ix, iy, iz, component);
1202 //----------------------------------------------------------------------------