]> Creatis software - clitk.git/blob - vv/vvSlicerManager.cxx
Added Manual Registration Tool with updated Median Filter tool
[clitk.git] / vv / vvSlicerManager.cxx
1   /*=========================================================================
2   Program:   vv                     http://www.creatis.insa-lyon.fr/rio/vv
3
4   Authors belong to: 
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
8
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.
12
13   It is distributed under dual licence
14
15   - BSD        See included LICENSE.txt file
16   - CeCILL-B   http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
17   ======================================================================-====*/
18
19 #include "vvSlicerManager.h"
20 #include "vvSlicer.h"
21 #include "vvImage.h"
22 #include "vvSlicerManagerCommand.h"
23 #include "vvInteractorStyleNavigator.h"
24 #include "vvLandmarks.h"
25 #include "vvImageReader.h"
26 #include "vvImageReader.h"
27 #include "vvMesh.h"
28 #include "vvImageMapToWLColors.h"
29
30 #include <vtkImageActor.h>
31 #include <vtkImageData.h>
32 #include <vtkRenderWindow.h>
33 #include <vtkRendererCollection.h>
34 #include <vtkRenderWindowInteractor.h>
35 #include <vtkImageMapToWindowLevelColors.h>
36 #include <vtkWindowLevelLookupTable.h>
37 #include <vtkColorTransferFunction.h>
38 #include <vtkImageClip.h>
39 #include <vtkLODActor.h>
40 #include <vtkPointData.h>
41 #include <vtksys/SystemTools.hxx>
42
43 //----------------------------------------------------------------------------
44 vvSlicerManager::vvSlicerManager(int numberOfSlicers)
45 {
46   mFileName = "";
47   mId = "";
48   mVFName = "";
49   mOverlayName = "";
50   mFusionName = "";
51   mVFId = "";
52   mLastError = "";
53   mType = UNDEFINEDIMAGETYPE;
54   mColorMap = 0;
55   mPreset = 0;
56   mOverlayColor = 130;
57
58   mFusionOpacity = 70;
59   mFusionColorMap = 3;
60   mFusionWindow = 1000;
61   mFusionLevel = 1000;
62
63   mReader = NULL;
64   mImage = NULL;
65   mVF=NULL;
66   mVectorReader = NULL;
67   mOverlayReader = NULL;
68   mFusionReader = NULL;
69   mLandmarks = NULL;
70   mLinkedId.resize(0);
71
72   for ( int i = 0; i < numberOfSlicers; i++) {
73     vvSlicer *slicer = vvSlicer::New();
74     mSlicers.push_back(slicer);
75   }
76   mPreviousSlice.resize(numberOfSlicers);
77   mPreviousTSlice.resize(numberOfSlicers);
78 }
79 //----------------------------------------------------------------------------
80
81
82 //----------------------------------------------------------------------------
83 vvSlicerManager::~vvSlicerManager()
84 {
85   for ( unsigned int i = 0; i < mSlicers.size(); i++)
86     {
87       if (mSlicers[i] != NULL)
88         mSlicers[i]->Delete();
89     }
90   if (mReader)
91     {
92       delete mReader;
93     }
94   if (mVectorReader)
95     {
96       delete mVectorReader;
97     }
98   if (mOverlayReader)
99     {
100       delete mOverlayReader;
101     }
102   if (mFusionReader)
103     {
104       delete mFusionReader;
105     }
106   if (mLandmarks)
107     delete mLandmarks;
108 }
109 //----------------------------------------------------------------------------
110
111
112 //------------------------------------------------------------------------------
113 void vvSlicerManager::SetFilename(std::string f) {
114   mFileName = f;
115   for(unsigned int i=0; i<mSlicers.size(); i++) {
116     mSlicers[i]->SetFileName(f);
117   }
118 }
119 //------------------------------------------------------------------------------
120
121
122 //----------------------------------------------------------------------------
123 void vvSlicerManager::AddContour(vvMesh::Pointer contour,bool propagate)
124 {
125   for ( unsigned int i = 0; i < mSlicers.size(); i++)
126     {
127       mSlicers[i]->AddContour(contour,propagate);
128     }
129 }
130 //----------------------------------------------------------------------------
131
132
133 //----------------------------------------------------------------------------
134 void vvSlicerManager::ToggleContourSuperposition()
135 {
136   for ( unsigned int i = 0; i < mSlicers.size(); i++)
137     mSlicers[i]->ToggleContourSuperposition();
138 }
139 //----------------------------------------------------------------------------
140
141
142 //----------------------------------------------------------------------------
143 bool vvSlicerManager::SetImage(std::string filename, LoadedImageType type, int n)
144 {
145   mFileName = filename;
146   mType = type;
147   if (mReader == NULL)
148     mReader = new vvImageReader;
149   std::vector<std::string> filenames;
150   filenames.push_back(filename);
151   mReader->SetInputFilenames(filenames);
152   mReader->Update(type);
153
154   mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
155   mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
156   //  DD(mBaseFileName);
157   mBaseFileNameNumber = n;
158
159   if (mReader->GetLastError().size() == 0)
160     {
161       mImage=mReader->GetOutput();
162       for ( unsigned int i = 0; i < mSlicers.size(); i++)
163         {
164           mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
165           mSlicers[i]->SetImage(mReader->GetOutput());
166           //          DD(mSlicers[i]->GetFileName());
167         }
168     }
169   else
170     {
171       mLastError = mReader->GetLastError();
172       return false;
173     }
174   if (n!=0) {
175     //    DD(mFileName);
176     mFileName.append("_"+clitk::toString(n));
177   }
178   return true;
179 }
180 //----------------------------------------------------------------------------
181
182
183 //----------------------------------------------------------------------------
184 void vvSlicerManager::SetImage(vvImage::Pointer image)
185 {
186   mImage=image;
187   for (unsigned int i = 0; i < mSlicers.size();i++)
188     {
189       mSlicers[i]->SetImage(image);
190     }
191 }
192 //----------------------------------------------------------------------------
193
194
195 //----------------------------------------------------------------------------
196 bool vvSlicerManager::SetImages(std::vector<std::string> filenames,LoadedImageType type, int n)
197 {
198   mType = type;
199   std::string fileWithoutExtension = vtksys::SystemTools::GetFilenameWithoutExtension(filenames[0]);
200   if (type == DICOM)
201     fileWithoutExtension += "_dicom";
202   else if (type == MERGED)
203     fileWithoutExtension += "_merged";
204   else if (type == MERGEDWITHTIME)
205     fileWithoutExtension += "_merged_wt";
206
207   mFileName = vtksys::SystemTools::GetFilenameName(mFileName);
208   mFileName = fileWithoutExtension + vtksys::SystemTools::GetFilenameExtension(filenames[0]);
209   if (mReader == NULL)
210     mReader = new vvImageReader;
211   mReader->SetInputFilenames(filenames);
212   mReader->Update(type);
213
214   mBaseFileName = vtksys::SystemTools::GetFilenameName(vtksys::SystemTools::GetFilenameWithoutLastExtension(mFileName));
215   //  DD(mBaseFileName);
216   mBaseFileNameNumber = n;
217
218   if (mReader->GetLastError().size() == 0)
219     {
220       mImage=mReader->GetOutput();
221       for ( unsigned int i = 0; i < mSlicers.size(); i++)
222         {
223           mSlicers[i]->SetFileName(fileWithoutExtension);
224           mSlicers[i]->SetImage(mReader->GetOutput());
225         }
226     }
227   else
228     {
229       mLastError = mReader->GetLastError();
230       return false;
231     }
232   if (n!=0) {
233     //    DD(mFileName);
234     mFileName.append("_"+clitk::toString(n));
235     //    DD(mFileName);
236   }
237   return true;
238 }
239 //----------------------------------------------------------------------------
240
241
242 //----------------------------------------------------------------------------
243 bool vvSlicerManager::SetOverlay(std::string filename,int dim, std::string component)
244 {
245   mOverlayName = filename;
246   mOverlayComponent = component;
247   if (dim > mImage->GetNumberOfDimensions())
248     {
249       mLastError = " Overlay dimension cannot be greater then reference image!";
250       return false;
251     }
252   if (mOverlayReader == NULL)
253     mOverlayReader = new vvImageReader;
254   std::vector<std::string> filenames;
255   filenames.push_back(filename);
256   mOverlayReader->SetInputFilenames(filenames);
257   mOverlayReader->Update(mImage->GetNumberOfDimensions(),component.c_str(),mType);
258   if (mOverlayReader->GetLastError().size() == 0)
259     {
260       for ( unsigned int i = 0; i < mSlicers.size(); i++)
261         {
262           mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
263         }
264     }
265   else
266     {
267       mLastError = mOverlayReader->GetLastError();
268       return false;
269     }
270   return true;
271 }
272 //----------------------------------------------------------------------------
273
274
275 //----------------------------------------------------------------------------
276 bool vvSlicerManager::SetFusion(std::string filename,int dim, std::string component)
277 {
278   mFusionName = filename;
279   mFusionComponent = component;
280   if (dim > mImage->GetNumberOfDimensions())
281     {
282       mLastError = " Overlay dimension cannot be greater then reference image!";
283       return false;
284     }
285   if (mFusionReader == NULL)
286     mFusionReader = new vvImageReader;
287   std::vector<std::string> filenames;
288   filenames.push_back(filename);
289   mFusionReader->SetInputFilenames(filenames);
290   mFusionReader->Update(mImage->GetNumberOfDimensions(),component.c_str(),mType);
291   if (mFusionReader->GetLastError().size() == 0)
292     {
293       for ( unsigned int i = 0; i < mSlicers.size(); i++)
294         {
295           mSlicers[i]->SetFusion(mFusionReader->GetOutput());
296         }
297     }
298   else
299     {
300       mLastError = mFusionReader->GetLastError();
301       return false;
302     }
303   double *fusRange = mFusionReader->GetOutput()->GetVTKImages()[0]->GetScalarRange();
304   mFusionLevel = (fusRange[0]+fusRange[1])/2;
305   mFusionWindow = fusRange[1]-fusRange[0];
306   return true;
307 }
308 //----------------------------------------------------------------------------
309
310
311 //----------------------------------------------------------------------------
312 bool vvSlicerManager::SetVF(std::string filename)
313 {
314   if (mVectorReader == NULL)
315     mVectorReader = new vvImageReader;
316   mVectorReader->SetInputFilename(filename);
317   mVectorReader->Update(VECTORFIELD);
318   if (mVectorReader->GetLastError().size() != 0)
319     {
320       mLastError = mVectorReader->GetLastError();
321       return false;
322     }
323   else
324     return SetVF(mVectorReader->GetOutput(),filename);
325 }
326 //----------------------------------------------------------------------------
327
328
329 //----------------------------------------------------------------------------
330 bool vvSlicerManager::SetVF(vvImage::Pointer vf,std::string filename)
331 {
332   if (vf->GetNumberOfDimensions() > mImage->GetNumberOfDimensions()) {
333     mLastError = "Sorry, vector field dimension cannot be greater then reference image.";
334     return false;
335   }
336   if (vf->GetNumberOfDimensions() == 4) {
337     // DD(vf->GetSpacing()[3]);
338     //     DD(mImage->GetSpacing()[3]);
339     //     DD(vf->GetOrigin()[3]);
340     //     DD(mImage->GetOrigin()[3]);    
341     if (vf->GetSpacing()[3] != mImage->GetSpacing()[3]) {
342       mLastError = "Sorry, vector field time spacing cannot be different from time spacing of the reference image.";
343       return false;
344     }
345     if (vf->GetOrigin()[3] != mImage->GetOrigin()[3]) {
346       mLastError = "Sorry, vector field time origin cannot be different from time origin of the reference image.";
347       return false;
348     }
349   }
350   mVF=vf;
351   mVFName = filename;
352   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
353     mSlicers[i]->SetVF(vf);
354   }
355   return true;
356 }
357 //----------------------------------------------------------------------------
358
359
360 //----------------------------------------------------------------------------
361 void vvSlicerManager::SetExtractedImage(std::string filename,vvImage::Pointer image, int slice)
362 {
363   mFileName = filename;
364   mImage = vvImage::New();
365   if (image->GetNumberOfDimensions() == 4)
366     {
367       mImage->AddImage(image->GetVTKImages()[slice]);
368       for ( unsigned int i = 0; i < mSlicers.size(); i++)
369         {
370           mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
371           mSlicers[i]->SetImage(mImage);
372         }
373     }
374   else
375     {
376       vtkImageClip* clipper = vtkImageClip::New();
377       int extent[6];
378       image->GetVTKImages()[0]->GetWholeExtent(extent);
379       clipper->SetInput(image->GetVTKImages()[0]);
380       clipper->SetOutputWholeExtent(extent[0],extent[1],extent[2],extent[3],slice,slice);
381       clipper->Update();
382       mImage->AddImage(clipper->GetOutput());
383       for ( unsigned int i = 0; i < mSlicers.size(); i++)
384         {
385           mSlicers[i]->SetFileName(vtksys::SystemTools::GetFilenameWithoutLastExtension(filename));
386           mSlicers[i]->SetImage(mImage);
387         }
388       clipper->Delete();
389     }
390 }
391 //----------------------------------------------------------------------------
392
393
394 //----------------------------------------------------------------------------
395 vvSlicer* vvSlicerManager::GetSlicer(int i)
396 {
397   return mSlicers[i];
398 }
399 //----------------------------------------------------------------------------
400
401
402 //----------------------------------------------------------------------------
403 void vvSlicerManager::UpdateSlicer(int num, bool state)
404 {
405   if (mSlicers[num]->GetImage())
406     mSlicers[num]->SetDisplayMode(state);
407 }
408 //----------------------------------------------------------------------------
409
410
411 //----------------------------------------------------------------------------
412 void vvSlicerManager::SetSlicerWindow(int i, vtkRenderWindow* RW)
413 {
414   mSlicers[i]->SetRenderWindow(i,RW);
415 }
416 //----------------------------------------------------------------------------
417
418
419 //----------------------------------------------------------------------------
420 void vvSlicerManager::SetInteractorStyleNavigator(int i, vtkInteractorStyle* style)
421 {
422   vvSlicerManagerCommand *smc = vvSlicerManagerCommand::New();
423   smc->SM = this;
424   smc->SetSlicerNumber(i);
425   mSlicers[i]->GetRenderWindow()->GetInteractor()->SetInteractorStyle(style);
426
427   mSlicers[i]->GetRenderWindow()->GetInteractor()->
428     GetInteractorStyle()->AddObserver(vtkCommand::KeyPressEvent, smc);
429   mSlicers[i]->GetRenderWindow()->GetInteractor()->
430     GetInteractorStyle()->AddObserver(vtkCommand::WindowLevelEvent, smc);
431   mSlicers[i]->GetRenderWindow()->GetInteractor()->
432     GetInteractorStyle()->AddObserver(vtkCommand::EndWindowLevelEvent, smc);
433   mSlicers[i]->GetRenderWindow()->GetInteractor()->
434     GetInteractorStyle()->AddObserver(vtkCommand::StartWindowLevelEvent, smc);
435   mSlicers[i]->GetRenderWindow()->GetInteractor()->
436     GetInteractorStyle()->AddObserver(vtkCommand::PickEvent, smc);
437   mSlicers[i]->GetRenderWindow()->GetInteractor()->
438     GetInteractorStyle()->AddObserver(vtkCommand::StartPickEvent, smc);
439   mSlicers[i]->GetRenderWindow()->GetInteractor()->
440     GetInteractorStyle()->AddObserver(vtkCommand::LeaveEvent, smc);
441   mSlicers[i]->GetRenderWindow()->GetInteractor()->
442     GetInteractorStyle()->AddObserver(vtkCommand::UserEvent, smc);
443   mSlicers[i]->GetRenderWindow()->GetInteractor()->
444     GetInteractorStyle()->AddObserver(vtkCommand::MouseWheelForwardEvent, smc);
445   mSlicers[i]->GetRenderWindow()->GetInteractor()->
446     GetInteractorStyle()->AddObserver(vtkCommand::MouseWheelBackwardEvent, smc);
447   // mSlicers[i]->GetRenderWindow()->GetInteractor()->
448   //   GetInteractorStyle()->AddObserver(vtkCommand::LeftButtonReleaseEvent, smc);
449   mSlicers[i]->GetRenderWindow()->GetInteractor()->
450      GetInteractorStyle()->AddObserver(vtkCommand::EndPickEvent, smc);
451   smc->Delete();
452 }
453 //----------------------------------------------------------------------------
454
455
456 //----------------------------------------------------------------------------
457 void vvSlicerManager::LeftButtonReleaseEvent(int slicer) {
458   emit LeftButtonReleaseSignal(slicer);
459 }
460 //----------------------------------------------------------------------------
461
462
463 //----------------------------------------------------------------------------
464 void vvSlicerManager::SetTSlice(int slice)
465 {
466   if (slice < 0)
467     slice = 0;
468   else if (slice > mSlicers[0]->GetTMax())
469     slice = mSlicers[0]->GetTMax();
470   if (mLandmarks)
471     mLandmarks->SetTime(slice);
472   for ( unsigned int i = 0; i < mSlicers.size(); i++)
473     {
474       if (slice != mSlicers[i]->GetTSlice()) {
475         mSlicers[i]->SetTSlice(slice);
476         if (mSlicers[i]->GetImageActor()->GetVisibility())
477           UpdateTSlice(i);
478       }
479     }
480 }
481 //----------------------------------------------------------------------------
482
483
484 //----------------------------------------------------------------------------
485 void vvSlicerManager::SetNextTSlice(int originating_slicer)
486 {
487   int t = mSlicers[0]->GetTSlice();
488   t++;
489   if (t > mSlicers[0]->GetTMax())
490     t = 0;
491   // DD("SetNextTSlice");
492 //   DD(originating_slicer);
493 //   DD(t);
494   emit UpdateTSlice(originating_slicer,t);
495 }
496 //----------------------------------------------------------------------------
497
498
499 //----------------------------------------------------------------------------
500 void vvSlicerManager::SetPreviousTSlice(int originating_slicer)
501 {
502   int t = mSlicers[0]->GetTSlice();
503   t--;
504   if (t < 0)
505     t = mSlicers[0]->GetTMax();
506   emit UpdateTSlice(originating_slicer,t);
507 }
508 //----------------------------------------------------------------------------
509
510
511 //----------------------------------------------------------------------------
512 void vvSlicerManager::ToggleInterpolation()
513 {
514   bool interpolate=!(mSlicers[0]->GetImageActor()->GetInterpolate());
515   for ( unsigned int i = 0; i < mSlicers.size(); i++)
516     {
517       mSlicers[i]->GetImageActor()->SetInterpolate(interpolate);
518     }
519 }
520 //----------------------------------------------------------------------------
521
522
523 //----------------------------------------------------------------------------
524 void vvSlicerManager::SetTSliceInSlicer(int tslice, int slicer)
525 {
526   if (tslice < 0)
527     tslice = 0;
528   else if (tslice > mSlicers[slicer]->GetTMax())
529     tslice = mSlicers[slicer]->GetTMax();
530   if (mLandmarks)
531     mLandmarks->SetTime(tslice);
532
533   if (mSlicers[slicer]->GetTSlice() == tslice) return;
534
535   mSlicers[slicer]->SetTSlice(tslice);
536   if (mSlicers[slicer]->GetImageActor()->GetVisibility())
537     UpdateTSlice(slicer);
538 }
539 //----------------------------------------------------------------------------
540
541
542 //----------------------------------------------------------------------------
543 void vvSlicerManager::SetColorWindow(double s)
544 {
545   for ( unsigned int i = 0; i < mSlicers.size(); i++)
546     {
547       mSlicers[i]->SetColorWindow(s);
548     }
549 }
550 //----------------------------------------------------------------------------
551
552
553 //----------------------------------------------------------------------------
554 void vvSlicerManager::SetColorLevel(double s)
555 {
556   for ( unsigned int i = 0; i < mSlicers.size(); i++)
557     {
558       mSlicers[i]->SetColorLevel(s);
559     }
560 }
561 //----------------------------------------------------------------------------
562
563 //----------------------------------------------------------------------------
564 void vvSlicerManager::SetCursorVisibility(int s)
565 {
566   for ( unsigned int i = 0; i < mSlicers.size(); i++)
567     {
568       mSlicers[i]->SetCursorVisibility(s);
569     }
570 }
571 //----------------------------------------------------------------------------
572
573
574 //----------------------------------------------------------------------------
575 void vvSlicerManager::SetOpacity(int i, double factor)
576 {
577   mSlicers[i]->SetOpacity(1/factor);
578 }
579 //----------------------------------------------------------------------------
580
581
582 //----------------------------------------------------------------------------
583 void vvSlicerManager::UpdateViews(int current,int slicer)
584 {
585   double x = (mSlicers[slicer]->GetCurrentPosition()[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
586     /mSlicers[slicer]->GetInput()->GetSpacing()[0];
587   double y = (mSlicers[slicer]->GetCurrentPosition()[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
588     /mSlicers[slicer]->GetInput()->GetSpacing()[1];
589   double z = (mSlicers[slicer]->GetCurrentPosition()[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
590     /mSlicers[slicer]->GetInput()->GetSpacing()[2];
591
592   if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
593       x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
594       y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
595       y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
596       z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
597       z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5])
598     {
599       mSlicers[slicer]->UpdateCursorPosition();
600       mSlicers[slicer]->SetCursorColor(10,212,255);
601
602       switch (mSlicers[slicer]->GetSliceOrientation())
603         {
604         case vtkImageViewer2::SLICE_ORIENTATION_XY:
605           if (mSlicers[slicer]->GetSlice() == (int)floor(z))
606             mSlicers[slicer]->Render();
607           else
608             mSlicers[slicer]->SetSlice((int)floor(z));
609           break;
610
611         case vtkImageViewer2::SLICE_ORIENTATION_XZ:
612           if (mSlicers[slicer]->GetSlice() == (int)floor(y))
613             mSlicers[slicer]->Render();
614           else
615             mSlicers[slicer]->SetSlice((int)floor(y));
616           break;
617
618         case vtkImageViewer2::SLICE_ORIENTATION_YZ:
619           if (mSlicers[slicer]->GetSlice() == (int)floor(x))
620             mSlicers[slicer]->Render();
621           else
622             mSlicers[slicer]->SetSlice((int)floor(x));
623           break;
624         }
625
626       for ( unsigned int i = 0; i < mSlicers.size(); i++)
627         {
628           if (i != (unsigned int)slicer && mSlicers[i]->GetImageActor()->GetVisibility()
629               && mSlicers[i]->GetRenderWindow()->GetSize()[0] > 2
630               && mSlicers[i]->GetRenderWindow()->GetSize()[1] > 2)
631             {
632               mSlicers[i]->SetCurrentPosition(mSlicers[slicer]->GetCurrentPosition()[0],
633                                               mSlicers[slicer]->GetCurrentPosition()[1],
634                                               mSlicers[slicer]->GetCurrentPosition()[2],
635                                               mSlicers[slicer]->GetTSlice());
636               mSlicers[i]->UpdateCursorPosition();
637               if (current) //do not display corner annotation if image is the one picked
638                 {
639                   mSlicers[i]->SetCurrentPosition(-VTK_DOUBLE_MAX,-VTK_DOUBLE_MAX,
640                                                   -VTK_DOUBLE_MAX, mSlicers[slicer]->GetTSlice());
641                   mSlicers[i]->SetCursorColor(255,10,212);
642                 }
643               else
644                 {
645                   mSlicers[i]->SetCursorColor(150,10,282);
646                 }
647               switch (mSlicers[i]->GetSliceOrientation())
648                 {
649                 case vtkImageViewer2::SLICE_ORIENTATION_XY:
650                   if (mSlicers[i]->GetSlice() == (int)floor(z))
651                     mSlicers[i]->Render();
652                   else
653                     mSlicers[i]->SetSlice((int)floor(z));
654                   break;
655
656                 case vtkImageViewer2::SLICE_ORIENTATION_XZ:
657                   if (mSlicers[i]->GetSlice() == (int)floor(y))
658                     mSlicers[i]->Render();
659                   else
660                     mSlicers[i]->SetSlice((int)floor(y));
661                   break;
662
663                 case vtkImageViewer2::SLICE_ORIENTATION_YZ:
664                   if (mSlicers[i]->GetSlice() == (int)floor(x))
665                     mSlicers[i]->Render();
666                   else
667                     mSlicers[i]->SetSlice((int)floor(x));
668                   break;
669                 }
670               // DD("UpdateViews::");
671               // DD(i);
672               UpdateSlice(i);
673               UpdateTSlice(i);
674             }
675         }
676     }
677 }
678 //----------------------------------------------------------------------------
679
680
681 //----------------------------------------------------------------------------
682 void vvSlicerManager::UpdateLinked(int slicer)
683 {
684   double x = (mSlicers[slicer]->GetCurrentPosition()[0] - mSlicers[slicer]->GetInput()->GetOrigin()[0])
685     /mSlicers[slicer]->GetInput()->GetSpacing()[0];
686   double y = (mSlicers[slicer]->GetCurrentPosition()[1] - mSlicers[slicer]->GetInput()->GetOrigin()[1])
687     /mSlicers[slicer]->GetInput()->GetSpacing()[1];
688   double z = (mSlicers[slicer]->GetCurrentPosition()[2] - mSlicers[slicer]->GetInput()->GetOrigin()[2])
689     /mSlicers[slicer]->GetInput()->GetSpacing()[2];
690
691   if (x >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
692       x <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
693       y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
694       y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
695       z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
696       z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5])
697     {
698       for (std::list<std::string>::const_iterator i = mLinkedId.begin(); i != mLinkedId.end(); i++)
699         {
700           emit UpdateLinkManager(*i, slicer,mSlicers[slicer]->GetCurrentPosition()[0],
701                                  mSlicers[slicer]->GetCurrentPosition()[1],
702                                  mSlicers[slicer]->GetCurrentPosition()[2],mSlicers[slicer]->GetTSlice());
703         }
704     }
705 }
706 //----------------------------------------------------------------------------
707
708
709 //----------------------------------------------------------------------------
710 double vvSlicerManager::GetColorWindow()
711 {
712   if (mSlicers.size())
713     return mSlicers[0]->GetColorWindow();
714   return -1;
715 }
716 //----------------------------------------------------------------------------
717
718
719 //----------------------------------------------------------------------------
720 double vvSlicerManager::GetColorLevel()
721 {
722   if (mSlicers.size())
723     return mSlicers[0]->GetColorLevel();
724   return -1;
725 }
726 //----------------------------------------------------------------------------
727
728
729 //----------------------------------------------------------------------------
730 void vvSlicerManager::Render()
731 {
732   for ( unsigned int i = 0; i < mSlicers.size(); i++)
733     {
734       mSlicers[i]->Render();
735     }
736 }
737 //----------------------------------------------------------------------------
738
739
740 //----------------------------------------------------------------------------
741 void vvSlicerManager::GenerateDefaultLookupTable()
742 {
743   SetPreset(mPreset);
744   SetColorMap(mColorMap);
745 }
746 //----------------------------------------------------------------------------
747
748
749 //----------------------------------------------------------------------------
750 void vvSlicerManager::Reload()
751 {
752   mReader->Update(mType);
753   mImage=mReader->GetOutput();
754   for ( unsigned int i = 0; i < mSlicers.size(); i++)
755     {
756       mSlicers[i]->SetImage(mImage);
757     }
758 }
759 //----------------------------------------------------------------------------
760
761
762 //----------------------------------------------------------------------------
763 void vvSlicerManager::ReloadFusion()
764 {
765   mFusionReader->Update();
766   for ( unsigned int i = 0; i < mSlicers.size(); i++)
767     {
768       mSlicers[i]->SetFusion(mFusionReader->GetOutput());
769       mSlicers[i]->Render();
770     }
771 }
772 //----------------------------------------------------------------------------
773
774
775 //----------------------------------------------------------------------------
776 void vvSlicerManager::ReloadOverlay()
777 {
778   mOverlayReader->Update();
779   for ( unsigned int i = 0; i < mSlicers.size(); i++)
780     {
781       mSlicers[i]->SetOverlay(mOverlayReader->GetOutput());
782       mSlicers[i]->Render();
783     }
784 }
785 //----------------------------------------------------------------------------
786
787
788 //----------------------------------------------------------------------------
789 void vvSlicerManager::ReloadVF()
790 {
791   mVectorReader->Update(VECTORFIELD); //deletes the old images through the VF::Init() function
792   mVF=mVectorReader->GetOutput();
793   for ( unsigned int i = 0; i < mSlicers.size(); i++)
794     {
795       mSlicers[i]->SetVF(mVF);
796       mSlicers[i]->Render();
797     }
798 }
799 //----------------------------------------------------------------------------
800
801
802 //----------------------------------------------------------------------------
803 void vvSlicerManager::RemoveActor(const std::string& actor_type, int overlay_index)
804 {
805   for (unsigned int i = 0; i < mSlicers.size();i++)
806     {
807       mSlicers[i]->RemoveActor(actor_type,overlay_index);
808     }
809   if (actor_type=="vector")
810     {
811       mVF=NULL;
812       if (mVectorReader) {
813         delete mVectorReader;
814         mVectorReader=NULL;
815       }
816     }
817 }
818 //----------------------------------------------------------------------------
819
820
821 //----------------------------------------------------------------------------
822 void vvSlicerManager::RemoveActors()
823 {
824   ///This method leaks a few objects. See RemoveActor for what a correct implementation would look like
825   for ( unsigned int i = 0; i < mSlicers.size(); i++)
826     {
827       mSlicers[i]->SetDisplayMode(0);
828       mSlicers[i]->GetRenderer()->RemoveActor(mSlicers[i]->GetImageActor());
829     }
830 }
831 //----------------------------------------------------------------------------
832
833
834 //----------------------------------------------------------------------------
835 void vvSlicerManager::UpdateInfoOnCursorPosition(int slicer)
836 {
837   //  int view = mSlicers[slicer]->GetSliceOrientation();
838   //  int slice = mSlicers[slicer]->GetSlice();
839   double x = mSlicers[slicer]->GetCursorPosition()[0];
840   double y = mSlicers[slicer]->GetCursorPosition()[1];
841   double z = mSlicers[slicer]->GetCursorPosition()[2];
842   double X = (x - mSlicers[slicer]->GetInput()->GetOrigin()[0])/
843     mSlicers[slicer]->GetInput()->GetSpacing()[0];
844   double Y = (y - mSlicers[slicer]->GetInput()->GetOrigin()[1])/
845     mSlicers[slicer]->GetInput()->GetSpacing()[1];
846   double Z = (z - mSlicers[slicer]->GetInput()->GetOrigin()[2])/
847     mSlicers[slicer]->GetInput()->GetSpacing()[2];
848   double value = -VTK_DOUBLE_MAX;
849   int displayVec = 0;
850   double xVec=0, yVec=0, zVec=0, valueVec=0;
851   int displayOver = 0;
852   int displayFus = 0;
853   double valueOver=0, valueFus=0;
854   if (X >= mSlicers[slicer]->GetInput()->GetWholeExtent()[0] &&
855       X <= mSlicers[slicer]->GetInput()->GetWholeExtent()[1] &&
856       Y >= mSlicers[slicer]->GetInput()->GetWholeExtent()[2] &&
857       Y <= mSlicers[slicer]->GetInput()->GetWholeExtent()[3] &&
858       Z >= mSlicers[slicer]->GetInput()->GetWholeExtent()[4] &&
859       Z <= mSlicers[slicer]->GetInput()->GetWholeExtent()[5])
860     {
861       value = mSlicers[slicer]->GetInput()->GetScalarComponentAsDouble(
862                                                                        (int)floor(X),
863                                                                        (int)floor(Y),
864                                                                        (int)floor(Z),0);
865       if (mSlicers[slicer]->GetVFActor() && mSlicers[slicer]->GetVFActor()->GetVisibility())
866         {
867           displayVec = 1;
868           unsigned int currentTime = mSlicers[slicer]->GetTSlice();
869           vtkImageData *vf = NULL;
870
871           if (mSlicers[slicer]->GetVF()->GetVTKImages().size() > currentTime)
872             vf = mSlicers[slicer]->GetVF()->GetVTKImages()[currentTime];
873           else
874             vf = mSlicers[slicer]->GetVF()->GetVTKImages()[0];
875
876           if (vf)
877             {
878               double Xvf = (x - vf->GetOrigin()[0])/ vf->GetSpacing()[0];
879               double Yvf = (y - vf->GetOrigin()[1])/ vf->GetSpacing()[1];
880               double Zvf = (z - vf->GetOrigin()[2])/ vf->GetSpacing()[2];
881               xVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),0);
882               yVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),1);
883               zVec = vf->GetScalarComponentAsDouble( (int)floor(Xvf), (int)floor(Yvf), (int)floor(Zvf),2);
884               valueVec = sqrt(xVec*xVec + yVec*yVec + zVec*zVec);
885             }
886         }
887       if (mSlicers[slicer]->GetOverlayActor() && mSlicers[slicer]->GetOverlayActor()->GetVisibility())
888         {
889           displayOver = 1;
890           double Xover = (x - mSlicers[slicer]->GetOverlay()->GetOrigin()[0])
891             /mSlicers[slicer]->GetOverlay()->GetSpacing()[0];
892           double Yover = (y - mSlicers[slicer]->GetOverlay()->GetOrigin()[1])
893             /mSlicers[slicer]->GetOverlay()->GetSpacing()[1];
894           double Zover = (z - mSlicers[slicer]->GetOverlay()->GetOrigin()[2])
895             /mSlicers[slicer]->GetOverlay()->GetSpacing()[2];
896           if (Xover >= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[0] &&
897               Xover <= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[1] &&
898               Yover >= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[2] &&
899               Yover <= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[3] &&
900               Zover >= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[4] &&
901               Zover <= mSlicers[slicer]->GetOverlayMapper()->GetInput()->GetWholeExtent()[5])
902             {
903               valueOver = static_cast<vtkImageData*>(mSlicers[slicer]->GetOverlayMapper()->GetInput())->
904                 GetScalarComponentAsDouble(
905                                            (int)floor(Xover),
906                                            (int)floor(Yover),
907                                            (int)floor(Zover),0);
908             }
909         }
910       if (mSlicers[slicer]->GetFusionActor() && mSlicers[slicer]->GetFusionActor()->GetVisibility())
911         {
912           displayFus = 1;
913           double Xfus = (x - mSlicers[slicer]->GetFusion()->GetOrigin()[0])
914             /mSlicers[slicer]->GetFusion()->GetSpacing()[0];
915           double Yfus = (y - mSlicers[slicer]->GetFusion()->GetOrigin()[1])
916             /mSlicers[slicer]->GetFusion()->GetSpacing()[1];
917           double Zfus = (z - mSlicers[slicer]->GetFusion()->GetOrigin()[2])
918             /mSlicers[slicer]->GetFusion()->GetSpacing()[2];
919           if (Xfus >= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[0] &&
920               Xfus <= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[1] &&
921               Yfus >= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[2] &&
922               Yfus <= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[3] &&
923               Zfus >= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[4] &&
924               Zfus <= mSlicers[slicer]->GetFusionMapper()->GetInput()->GetWholeExtent()[5])
925             {
926               valueFus = static_cast<vtkImageData*>(mSlicers[slicer]->GetFusionMapper()->GetInput())->
927                 GetScalarComponentAsDouble(
928                                            (int)floor(Xfus),
929                                            (int)floor(Yfus),
930                                            (int)floor(Zfus),0);
931             }
932         }
933       emit UpdatePosition(mSlicers[slicer]->GetCursorVisibility(),
934                           x,y,z,X,Y,Z,value);
935       emit UpdateVector(displayVec,xVec, yVec, zVec, valueVec);
936       emit UpdateOverlay(displayOver,valueOver,value);
937       emit UpdateFusion(displayFus,valueFus);
938       for (unsigned int i = 0; i < mSlicers.size(); i++)
939         {
940           if (mSlicers[i]->GetImageActor()->GetVisibility() == 1)
941             emit UpdateWindows(i,mSlicers[i]->GetSliceOrientation(),mSlicers[i]->GetSlice());
942           else
943             emit UpdateWindows(i,-1,-1);
944         }
945     }
946 }
947 //----------------------------------------------------------------------------
948
949
950 //----------------------------------------------------------------------------
951 void vvSlicerManager::Activated()
952 {
953   emit currentImageChanged(mId);
954 }
955 //----------------------------------------------------------------------------
956
957
958 //----------------------------------------------------------------------------
959 void vvSlicerManager::UpdateWindowLevel()
960 {
961   emit WindowLevelChanged(mSlicers[0]->GetColorWindow(),mSlicers[0]->GetColorLevel(),mPreset,mColorMap);
962 }
963 //----------------------------------------------------------------------------
964
965
966 //----------------------------------------------------------------------------
967 void vvSlicerManager::UpdateSlice(int slicer)
968 {
969   // DD("vvSlicerManager::UpdateSlice emit UpdateSlice");
970 //   DD(slicer);
971 //   DD(mSlicers[slicer]->GetSlice());
972   if (mPreviousSlice[slicer] == mSlicers[slicer]->GetSlice()) {
973     //DD("============= NOTHING");
974     return;
975   }
976   emit UpdateSlice(slicer, mSlicers[slicer]->GetSlice());
977   mPreviousSlice[slicer] = mSlicers[slicer]->GetSlice();
978 }
979 //----------------------------------------------------------------------------
980
981
982 //----------------------------------------------------------------------------
983 void vvSlicerManager::UpdateTSlice(int slicer)
984 {
985   // DD("vvSlicerManager::UpdateTSlice emit UpdateTSlice");
986 //   DD(slicer);
987 //   DD(mSlicers[slicer]->GetTSlice());
988 //   DD(mSlicers[slicer]->GetSlice());
989   if (mPreviousSlice[slicer] == mSlicers[slicer]->GetSlice()) {
990     if (mPreviousTSlice[slicer] == mSlicers[slicer]->GetTSlice()) {
991       //      DD("************** NOTHING ***********");
992       return;
993     }
994   }
995   mPreviousSlice[slicer] = mSlicers[slicer]->GetSlice();
996   mPreviousTSlice[slicer] = mSlicers[slicer]->GetTSlice();
997   emit UpdateTSlice(slicer,mSlicers[slicer]->GetTSlice());  
998 }
999 //----------------------------------------------------------------------------
1000
1001
1002 //----------------------------------------------------------------------------
1003 void vvSlicerManager::UpdateSliceRange(int slicer)
1004 {
1005   emit UpdateSliceRange(slicer,
1006                         mSlicers[slicer]->GetSliceRange()[0], mSlicers[slicer]->GetSliceRange()[1],
1007                         0,mSlicers[slicer]->GetTMax());
1008 }
1009 //----------------------------------------------------------------------------
1010
1011
1012 //----------------------------------------------------------------------------
1013 void vvSlicerManager::SetPreset(int preset)
1014 {
1015   //vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
1016   double window = mSlicers[0]->GetColorWindow();
1017   double level = mSlicers[0]->GetColorLevel();
1018
1019   std::string component_type=mImage->GetScalarTypeAsString();
1020   switch (preset)
1021     {
1022     case 0:
1023       if (component_type == "unsigned_char")
1024         {
1025           window = 255;
1026           level = 127;
1027         }
1028       else if (component_type == "short")
1029         {
1030           window = 2000;
1031           level = 0;
1032         }
1033       else
1034         {
1035           double range[2];
1036           mImage->GetScalarRange(range);
1037           window = range[1] - range[0];
1038           level = (range[1] + range[0])* 0.5;
1039         }
1040       break;
1041     case 1:
1042       window = 2000;
1043       level = 0;
1044       break;
1045     case 2:
1046       window = 350;
1047       level = 60;
1048       break;
1049     case 3:
1050       window = 1500;
1051       level = -500;
1052       break;
1053     case 4:
1054       window = 1000;
1055       level = 500;
1056       break;
1057     case 5:
1058       window = 1;
1059       level = 0.5;
1060       break;
1061     case 6:
1062       break;
1063     case 7:
1064       window=1.;
1065       level=0.;
1066       break;
1067     }
1068   mPreset = preset;
1069   this->SetColorWindow(window);
1070   this->SetColorLevel(level);
1071
1072   //if (LUT)
1073   //{
1074   //    SetColorMap(-1);
1075   //}
1076 }
1077 //----------------------------------------------------------------------------
1078
1079
1080 //----------------------------------------------------------------------------
1081 void vvSlicerManager::SetLocalColorWindowing(const int slicer)
1082 {
1083   double min, max;
1084   this->mSlicers[slicer]->GetExtremasAroundMousePointer(min, max);
1085   this->SetColorWindow(max-min);
1086   this->SetColorLevel(0.5*(min+max));
1087   this->UpdateWindowLevel();
1088   this->Render();
1089 }
1090 //----------------------------------------------------------------------------
1091
1092
1093 //----------------------------------------------------------------------------
1094 void vvSlicerManager::SetColorMap()
1095 {
1096   SetColorMap(mColorMap);
1097 }
1098 //----------------------------------------------------------------------------
1099
1100
1101 //----------------------------------------------------------------------------
1102 void vvSlicerManager::SetColorMap(int colormap)
1103 {
1104   double range[2];
1105   range[0] = mSlicers[0]->GetInput()->GetScalarRange()[0];
1106   range[1] = mSlicers[0]->GetInput()->GetScalarRange()[1];
1107
1108   double window = mSlicers[0]->GetWindowLevel()->GetWindow();
1109   double level = mSlicers[0]->GetWindowLevel()->GetLevel();
1110
1111   vtkLookupTable* LUT = static_cast<vtkLookupTable*>(mSlicers[0]->GetWindowLevel()->GetLookupTable());
1112   switch (colormap)
1113     {
1114     case -1:
1115       break;
1116     case 0:
1117       LUT = NULL;
1118       break;
1119     case 1:
1120       if (LUT == NULL)
1121         LUT = vtkLookupTable::New();
1122       LUT->SetValueRange(0,1);
1123       LUT->SetSaturationRange(1,1);
1124       LUT->SetHueRange(0,0.18);
1125       break;
1126     case 2:
1127       if (LUT == NULL)
1128         LUT = vtkLookupTable::New();
1129       LUT->SetValueRange(0,1);
1130       LUT->SetSaturationRange(1,1);
1131       LUT->SetHueRange(0.4,0.80);
1132       break;
1133     case 3:
1134       if (LUT == NULL)
1135         LUT = vtkLookupTable::New();
1136       LUT->SetValueRange(0,1);
1137       LUT->SetSaturationRange(1,1);
1138       LUT->SetHueRange(0,1);
1139       break;
1140     case 5:
1141       if (LUT == NULL)
1142         LUT = vtkLookupTable::New();
1143       LUT->SetValueRange(0.,1);
1144       LUT->SetSaturationRange(1,1);
1145       LUT->SetHueRange(1,0.1);
1146       //LUT->SetRampToLinear();
1147       break;
1148     }
1149   if (LUT)
1150     {
1151       LUT->SetTableRange(level-fabs(window)/4,level+fabs(window)/4);
1152       LUT->Build();
1153     }
1154   vtkLookupTable* fusLUT = NULL;
1155   if (mSlicers[0]->GetFusion())
1156     {
1157       fusLUT = vtkLookupTable::New();
1158       double fusRange [2];
1159       fusRange[0] = mFusionLevel - mFusionWindow/2;
1160       fusRange[1] = mFusionLevel + mFusionWindow/2;
1161       fusLUT->SetTableRange(fusRange[0],fusRange[1]);
1162       fusLUT->SetValueRange(1,1);
1163       fusLUT->SetSaturationRange(1,1);
1164       if (mFusionColorMap == 1)
1165         fusLUT->SetHueRange(0,0.18);
1166       else if (mFusionColorMap == 2)
1167         fusLUT->SetHueRange(0.4,0.80);
1168       else if (mFusionColorMap == 3)
1169         fusLUT->SetHueRange(0,1);
1170       fusLUT->Build();
1171       if (mFusionColorMap == 0)
1172         fusLUT = NULL;
1173     }
1174   for ( unsigned int i = 0; i < mSlicers.size(); i++) {
1175     if (mSlicers[i]->GetOverlay() && mSlicers[i]->GetOverlayActor()->GetVisibility()) {
1176       vtkLookupTable* supLUT = vtkLookupTable::New();
1177       supLUT->SetTableRange(range[0],range[1]);
1178       supLUT->SetValueRange(1,1);
1179       supLUT->SetSaturationRange(1,1);
1180       supLUT->SetHueRange(double(mOverlayColor)/360,double(mOverlayColor)/360);
1181       supLUT->Build();
1182       vtkLookupTable* invLUT = vtkLookupTable::New();
1183       invLUT->SetTableRange(range[0],range[1]);
1184       invLUT->SetValueRange(1,1);
1185       invLUT->SetSaturationRange(1,1);
1186       invLUT->SetHueRange(double((mOverlayColor+180)%360)/360,double((mOverlayColor+180)%360)/360);
1187       invLUT->Build();
1188       dynamic_cast<vvImageMapToWLColors*>(mSlicers[i]->GetWindowLevel())
1189         ->SetWindowLevelMode(true);
1190       mSlicers[i]->GetWindowLevel()->SetLookupTable(supLUT);
1191       mSlicers[i]->GetOverlayMapper()->SetLookupTable(invLUT);
1192       invLUT->Delete();
1193       supLUT->Delete();
1194     }
1195     else if (mSlicers[i]->GetOverlay())
1196       {
1197         //dynamic_cast<vvImageMapToWLColors*>(mSlicers[i]->GetWindowLevel())
1198         //->SetWindowLevelMode(false);
1199         mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
1200       }
1201     else
1202       {
1203         mSlicers[i]->GetWindowLevel()->SetLookupTable(LUT);
1204       }
1205     if (mSlicers[i]->GetFusion() && mSlicers[i]->GetFusionActor()->GetVisibility())
1206       {
1207         mSlicers[i]->GetFusionActor()->SetOpacity(double(mFusionOpacity)/100);
1208         mSlicers[i]->GetFusionMapper()->SetLookupTable(fusLUT);
1209       }
1210   }
1211   if (fusLUT)
1212     fusLUT->Delete();
1213   if (colormap >= 0)
1214     mColorMap = colormap;
1215 }
1216 //----------------------------------------------------------------------------
1217
1218
1219 //----------------------------------------------------------------------------
1220 vvLandmarks* vvSlicerManager::GetLandmarks()
1221 {
1222   if (mLandmarks == NULL)
1223     {
1224       mLandmarks = new vvLandmarks(mSlicers[0]->GetTMax()+1);
1225       for (unsigned int i = 0; i < mSlicers.size(); i++)
1226         mSlicers[i]->SetLandmarks(mLandmarks);
1227     }
1228   return mLandmarks;
1229 }
1230 //----------------------------------------------------------------------------
1231
1232
1233 //----------------------------------------------------------------------------
1234 void vvSlicerManager::AddLandmark(float x,float y,float z,float t)
1235 {
1236   double x_index = (x - mSlicers[0]->GetInput()->GetOrigin()[0])/mSlicers[0]->GetInput()->GetSpacing()[0];
1237   double y_index = (y - mSlicers[0]->GetInput()->GetOrigin()[1])/mSlicers[0]->GetInput()->GetSpacing()[1];
1238   double z_index = (z - mSlicers[0]->GetInput()->GetOrigin()[2])/mSlicers[0]->GetInput()->GetSpacing()[2];
1239   double value = mSlicers[0]->GetInput()->GetScalarComponentAsDouble(
1240                                                                      (int)x_index,
1241                                                                      (int)y_index,
1242                                                                      (int)z_index,0);
1243   this->GetLandmarks()->AddLandmark(x,y,z,t,value);
1244   emit LandmarkAdded();
1245 }
1246 //----------------------------------------------------------------------------
1247
1248 //----------------------------------------------------------------------------
1249 void vvSlicerManager::PrevImage(int slicer)
1250 {
1251   emit ChangeImageWithIndexOffset(this, slicer, -1);
1252 }
1253 //----------------------------------------------------------------------------
1254
1255
1256 //----------------------------------------------------------------------------
1257 void vvSlicerManager::NextImage(int slicer)
1258 {
1259   emit ChangeImageWithIndexOffset(this, slicer,  1);
1260 }
1261 //----------------------------------------------------------------------------
1262
1263
1264 //----------------------------------------------------------------------------
1265 void vvSlicerManager::VerticalSliderHasChanged(int slicer, int slice) {
1266   emit AVerticalSliderHasChanged(slicer, slice);
1267 }
1268     
1269 //----------------------------------------------------------------------------