]> Creatis software - clitk.git/blob - vv/vvBinaryImageOverlayActor.cxx
remove argsinfo template
[clitk.git] / vv / vvBinaryImageOverlayActor.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 "vvBinaryImageOverlayActor.h"
20 #include "vvImage.h"
21 #include <vtkImageActor.h>
22 #include <vtkCamera.h>
23 #include <vtkRenderer.h>
24 #include <vtkMarchingSquares.h>
25 #include <vtkImageClip.h>
26 #include <vtkImageData.h>
27 #include <vtkPolyDataMapper.h>
28 #include <vtkProperty.h>
29 #include <vtkImageMapToRGBA.h>
30 #include <vtkLookupTable.h>
31
32 //------------------------------------------------------------------------------
33 vvBinaryImageOverlayActor::vvBinaryImageOverlayActor()
34 {
35   mTSlice = -1;
36   mSlice = 0;
37   mColor.resize(3);
38   mAlpha = 0.6;
39   mImage = 0;
40   mSlicer = 0;
41   mColorLUT = vtkLookupTable::New();
42   mForegroundValue = 1;
43   mBackgroundValue = 0;
44   m_modeBG = true;
45 }
46 //------------------------------------------------------------------------------
47
48
49 //------------------------------------------------------------------------------
50 vvBinaryImageOverlayActor::~vvBinaryImageOverlayActor()
51 {
52   for (unsigned int i = 0; i < mSlicer->GetImage()->GetVTKImages().size(); i++) {
53     mSlicer->GetRenderer()->RemoveActor(mImageActorList[i]);
54   }
55   mImageActorList.clear();
56   mMapperList.clear();
57 }
58 //------------------------------------------------------------------------------
59
60
61 //------------------------------------------------------------------------------
62 void vvBinaryImageOverlayActor::SetColor(double r, double g, double b)
63 {
64   mColor[0] = r;
65   mColor[1] = g;
66   mColor[2] = b;
67 }
68 //------------------------------------------------------------------------------
69
70
71 //------------------------------------------------------------------------------
72 void vvBinaryImageOverlayActor::SetSlicer(vvSlicer * slicer)
73 {
74   mSlicer = slicer;
75 }
76 //------------------------------------------------------------------------------
77
78
79 //------------------------------------------------------------------------------
80 void vvBinaryImageOverlayActor::Initialize()
81 {
82   if (!mSlicer) {
83     std::cerr << "ERROR. Please use setSlicer before setSlicer in vvBinaryImageOverlayActor." << std::endl;
84     exit(0);
85   }
86
87   if (!mImage) {
88     std::cerr << "ERROR. Please use setImage before setSlicer in vvBinaryImageOverlayActor." << std::endl;
89     exit(0);
90   }
91   // Create an actor for each time slice
92   for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
93     // how many intensity ?
94     vtkImageMapToRGBA * mOverlayMapper = vtkImageMapToRGBA::New();
95     mOverlayMapper->SetInput(mImage->GetVTKImages()[0]); // DS TODO : to change if it is 4D !!!
96
97     // DD("change to nb of intensity");
98     double range[2];
99     mImage->GetVTKImages()[0]->GetScalarRange(range);
100     // DD(range[0]);
101 //     DD(range[1]);
102     int n = range[1]-range[0]+1;
103     mColorLUT->SetRange(range[0],range[1]);
104     mColorLUT->SetNumberOfTableValues(n);
105
106     // Mode BG -> all is color except BG
107     if (m_modeBG) {
108       for(int i=0; i<n; i++) {
109         mColorLUT->SetTableValue(i, mColor[0], mColor[1], mColor[2], mAlpha);
110       }
111       mColorLUT->SetTableValue(mBackgroundValue, 0, 0, 0, 0.0);
112     }
113     else {
114       // Mode FG -> all is BG, except FG which is color
115       for(int i=0; i<n; i++) {
116         mColorLUT->SetTableValue(i, 0, 0, 0, 0.0);
117       }
118       mColorLUT->SetTableValue(mForegroundValue, mColor[0], mColor[1], mColor[2], mAlpha);
119     }
120
121     mOverlayMapper->SetLookupTable(mColorLUT);
122
123     vtkImageActor * mOverlayActor = vtkImageActor::New();
124     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
125     mOverlayActor->SetPickable(0);
126     mOverlayActor->SetVisibility(true);
127     //mOverlayActor->SetOpacity(1.0);
128
129     mMapperList.push_back(mOverlayMapper);
130     mImageActorList.push_back(mOverlayActor);
131     mSlicer->GetRenderer()->AddActor(mOverlayActor);
132   }
133 }
134 //------------------------------------------------------------------------------
135
136
137 //------------------------------------------------------------------------------
138 void vvBinaryImageOverlayActor::SetOpacity(double d)
139 {
140   mAlpha = d;
141 }
142 //------------------------------------------------------------------------------
143
144
145 //------------------------------------------------------------------------------
146 // void vvBinaryImageOverlayActor::UpdateOpacity(double d) {
147 //   mAlpha = d;
148 //   mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
149 //   for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
150 //     // how many intensity ?
151 //     vtkImageMapToRGBA * mOverlayMapper = mMapperList[numImage];
152 //     mOverlayMapper->SetLookupTable(mColorLUT);
153
154 //     vtkImageActor * mOverlayActor = mImageActorList[numImage];
155 //     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
156 //   }
157 // }
158 //------------------------------------------------------------------------------
159
160
161 //------------------------------------------------------------------------------
162 // void vvBinaryImageOverlayActor::SetColor(double r, double v, double b) {
163 //   mColor[0] = r;
164 //   mColor[1] = v;
165 //   mColor[2] = b;
166 //   // mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
167 //   // for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
168 //   //   // how many intensity ?
169 //   //   vtkImageMapToRGBA * mOverlayMapper = mMapperList[numImage];
170 //   //   mOverlayMapper->SetLookupTable(mColorLUT);
171
172 //   //   vtkImageActor * mOverlayActor = mImageActorList[numImage];
173 //   //   mOverlayActor->SetInput(mOverlayMapper->GetOutput());
174 //   // }
175 // }
176 //------------------------------------------------------------------------------
177
178
179 //------------------------------------------------------------------------------
180 void vvBinaryImageOverlayActor::SetImage(vvImage::Pointer image, double bg, bool modeBG)
181 {
182   //  DD("vvBinaryImageOverlayActor::SetImage");
183   //DD(modeBG);
184   mImage = image;
185   if (modeBG) {
186     mBackgroundValue = bg;
187     m_modeBG = true;
188   }
189   else {
190     mForegroundValue = bg;
191     m_modeBG = false;
192   }
193 }
194 //------------------------------------------------------------------------------
195
196
197 //------------------------------------------------------------------------------
198 void vvBinaryImageOverlayActor::HideActors()
199 {
200   if (!mSlicer) return;
201   mSlice = mSlicer->GetSlice();
202   for(unsigned int i=0; i<mImageActorList.size(); i++) {
203     mImageActorList[i]->VisibilityOff();
204   }
205   // Caller MUST call Render
206   //  mSlicer->Render();
207 }
208 //------------------------------------------------------------------------------
209
210
211 //------------------------------------------------------------------------------
212 void vvBinaryImageOverlayActor::ShowActors()
213 {
214   if (!mSlicer) return;
215   mSlice = mSlicer->GetSlice();
216   mTSlice = mSlicer->GetTSlice();
217   //  for(unsigned int i=0; i<mSquaresActorList.size(); i++) {
218   mImageActorList[mTSlice]->VisibilityOn();
219   UpdateSlice(0, mSlice);
220   //}
221   // Caller MUST call Render
222   //mSlicer->Render();
223 }
224 //------------------------------------------------------------------------------
225
226
227 //------------------------------------------------------------------------------
228 void vvBinaryImageOverlayActor::UpdateColor()
229 {
230   mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
231   for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
232     // how many intensity ?
233     vtkImageMapToRGBA * mOverlayMapper = mMapperList[numImage];
234     mOverlayMapper->SetLookupTable(mColorLUT);
235
236     vtkImageActor * mOverlayActor = mImageActorList[numImage];
237     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
238   }
239 }
240 //------------------------------------------------------------------------------
241
242 //------------------------------------------------------------------------------
243 void vvBinaryImageOverlayActor::UpdateSlice(int slicer, int slice)
244 {
245   if (!mSlicer) return;
246
247   if (mPreviousSlice == mSlicer->GetSlice()) {
248     if (mPreviousTSlice == mSlicer->GetTSlice()) {
249       //DD("=========== NOTHING");
250       return; // Nothing to do
251     }
252   }
253
254   // Get current slice
255   mSlice = mSlicer->GetSlice();
256   mTSlice = mSlicer->GetTSlice();
257
258   // Update extent
259   int * imageExtent = mSlicer->GetExtent();
260   int orientation = mSlicer->GetOrientation();
261   int maskExtent[6];
262   ComputeExtent(orientation, mSlice, imageExtent, maskExtent);
263   //ComputeExtent(imageExtent, maskExtent, mSlicer->GetImage()->GetFirstVTKImageData(), mImage->GetFirstVTKImageData());
264   ComputeExtent(maskExtent, maskExtent, mSlicer->GetImage()->GetFirstVTKImageData(), mImage->GetFirstVTKImageData());
265   // std::cout << "maskExtent = " << maskExtent[0] << " " << maskExtent[1] << " " << maskExtent[2] << " "
266   //        << maskExtent[3] << " " << maskExtent[4] << " " << maskExtent[5] << std::endl;
267   mSlicer->ClipDisplayedExtent(maskExtent, mMapperList[mTSlice]->GetInput()->GetWholeExtent());
268   // std::cout << "maskExtent = " << maskExtent[0] << " " << maskExtent[1] << " " << maskExtent[2] << " "
269   //        << maskExtent[3] << " " << maskExtent[4] << " " << maskExtent[5] << std::endl;
270   SetDisplayExtentAndCameraPosition(orientation, mSlice, maskExtent, mImageActorList[mTSlice], 0.0);
271
272   // set previous slice
273   mPreviousTSlice = mSlicer->GetTSlice();
274   mPreviousSlice  = mSlicer->GetSlice();
275 }
276 //------------------------------------------------------------------------------
277
278
279 //------------------------------------------------------------------------------
280 void vvBinaryImageOverlayActor::ComputeExtent(int orientation,
281                                               int slice,
282                                               int * inExtent,
283                                               int * outExtent)
284 {
285   //  std::cout << "InExtent = " << inExtent[0] << " " << inExtent[1] << " " << inExtent[2] << " "
286   //        << inExtent[3] << " " << inExtent[4] << " " << inExtent[5] << std::endl;
287   //  DD(orientation);
288   switch (orientation) {
289   case vtkImageViewer2::SLICE_ORIENTATION_XY:
290     for(int i=0; i<4; i++) outExtent[i] = inExtent[i];
291     outExtent[4] = outExtent[5] = slice;
292     break;
293   case vtkImageViewer2::SLICE_ORIENTATION_XZ:
294     for(int i=0; i<2; i++) outExtent[i] = inExtent[i];
295     for(int i=4; i<6; i++) outExtent[i] = inExtent[i];
296     outExtent[2] = outExtent[3] = slice;
297     break;
298   case vtkImageViewer2::SLICE_ORIENTATION_YZ:
299     for(int i=2; i<6; i++) outExtent[i] = inExtent[i];
300     outExtent[0] = outExtent[1] = slice;
301     break;
302   }
303   // std::cout << "OutExtent = " << outExtent[0] << " " << outExtent[1] << " " << outExtent[2] << " "
304   //        << outExtent[3] << " " << outExtent[4] << " " << outExtent[5] << std::endl;
305 }
306 //------------------------------------------------------------------------------
307
308
309 //----------------------------------------------------------------------------
310 void vvBinaryImageOverlayActor::ComputeExtent(int * inExtent, int * outExtent, vtkImageData * image, vtkImageData * overlay)
311 {
312   outExtent[0] = (( image->GetOrigin()[0] + inExtent[0]*image->GetSpacing()[0] ) - overlay->GetOrigin()[0]) /
313                  overlay->GetSpacing()[0];
314   outExtent[1] = (( image->GetOrigin()[0] + inExtent[1]*image->GetSpacing()[0] ) - overlay->GetOrigin()[0]) /
315                  overlay->GetSpacing()[0];
316   outExtent[2] = (( image->GetOrigin()[1] + inExtent[2]*image->GetSpacing()[1] ) - overlay->GetOrigin()[1]) /
317                  overlay->GetSpacing()[1];
318   outExtent[3] = (( image->GetOrigin()[1] + inExtent[3]*image->GetSpacing()[1] ) - overlay->GetOrigin()[1]) /
319                  overlay->GetSpacing()[1];
320   outExtent[4] = (( image->GetOrigin()[2] + inExtent[4]*image->GetSpacing()[2] ) - overlay->GetOrigin()[2]) /
321                  overlay->GetSpacing()[2];
322   outExtent[5] = (( image->GetOrigin()[2] + inExtent[5]*image->GetSpacing()[2] ) - overlay->GetOrigin()[2]) /
323                  overlay->GetSpacing()[2];
324 }
325 //----------------------------------------------------------------------------
326
327
328 //------------------------------------------------------------------------------
329 void vvBinaryImageOverlayActor::SetDisplayExtentAndCameraPosition(int orientation,
330                                                                   int slice,
331                                                                   int * extent,
332                                                                   vtkImageActor * actor,
333                                                                   double position)
334 {
335   // Set position
336   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_XY) {
337     if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[2] > slice)
338       actor->SetPosition(0,0, position);
339     else
340       actor->SetPosition(0,0, -position);
341   }
342   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_XZ) {
343     if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[1] > slice)
344       actor->SetPosition(0,position,0);
345     else
346       actor->SetPosition(0,-position,0);
347   }
348   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_YZ) {
349     if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[0] > slice)
350       actor->SetPosition(position,0, 0);
351     else
352       actor->SetPosition(-position,0, 0);
353   }
354   actor->SetDisplayExtent(extent);
355 }
356 //------------------------------------------------------------------------------
357