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://www.centreleonberard.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 "vvBinaryImageOverlayActor.h"
21 #include <vtkVersion.h>
22 #include <vtkStreamingDemandDrivenPipeline.h>
23 #include <vtkInformation.h>
24 #include <vtkImageActor.h>
25 #include <vtkCamera.h>
26 #include <vtkRenderer.h>
27 #include <vtkMarchingSquares.h>
28 #include <vtkImageClip.h>
29 #include <vtkImageData.h>
30 #include <vtkPolyDataMapper.h>
31 #include <vtkProperty.h>
32 #include <vtkImageMapToRGBA.h>
33 #include <vtkLookupTable.h>
35 //------------------------------------------------------------------------------
36 vvBinaryImageOverlayActor::vvBinaryImageOverlayActor()
37 { cout << __func__ << endl;
44 mColorLUT = vtkSmartPointer<vtkLookupTable>::New();
50 //------------------------------------------------------------------------------
53 //------------------------------------------------------------------------------
54 vvBinaryImageOverlayActor::~vvBinaryImageOverlayActor()
55 { cout << __func__ << endl;
56 mImageActorList.clear();
58 //------------------------------------------------------------------------------
61 //------------------------------------------------------------------------------
62 void vvBinaryImageOverlayActor::RemoveActors()
63 { cout << __func__ << endl;
64 for (unsigned int i = 0; i < mImageActorList.size(); i++) {
66 if (mSlicer != NULL) {
67 if (mSlicer->GetRenderer() != 0) {
68 if (mImageActorList[i] != 0) {
69 mSlicer->GetRenderer()->RemoveActor(mImageActorList[i]);
76 //------------------------------------------------------------------------------
79 //------------------------------------------------------------------------------
80 void vvBinaryImageOverlayActor::SetColor(double r, double g, double b)
81 { cout << __func__ << endl;
86 //------------------------------------------------------------------------------
89 //------------------------------------------------------------------------------
90 void vvBinaryImageOverlayActor::SetSlicer(vvSlicer * slicer)
91 { cout << __func__ << endl;
94 //------------------------------------------------------------------------------
97 //------------------------------------------------------------------------------
98 void vvBinaryImageOverlayActor::Initialize(bool IsVisible)
99 { cout << __func__ << endl;
101 std::cerr << "ERROR. Please use setSlicer before setSlicer in vvBinaryImageOverlayActor." << std::endl;
106 std::cerr << "ERROR. Please use setImage before setSlicer in vvBinaryImageOverlayActor." << std::endl;
109 // Create an actor for each time slice
110 for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
111 // how many intensity ?
112 vtkSmartPointer<vtkImageMapToRGBA> mOverlayMapper = vtkSmartPointer<vtkImageMapToRGBA>::New();
113 #if VTK_MAJOR_VERSION <= 5
114 mOverlayMapper->SetInput(mImage->GetVTKImages()[0]); // DS TODO : to change if it is 4D !!!
116 mOverlayMapper->SetInputData(mImage->GetVTKImages()[0]); // DS TODO : to change if it is 4D !!!
120 mImage->GetVTKImages()[0]->GetScalarRange(range);
121 int n = range[1]-range[0]+1;
122 mColorLUT->SetRange(range[0],range[1]);
123 mColorLUT->SetNumberOfTableValues(n);
125 // Mode BG -> all is color except BG
127 for(int i=0; i<n; i++) {
128 mColorLUT->SetTableValue(i, mColor[0], mColor[1], mColor[2], mAlpha);
130 mColorLUT->SetTableValue(mBackgroundValue, 0, 0, 0, 0.0);
133 // Mode FG -> all is BG, except FG which is color
134 for(int i=0; i<n; i++) {
135 mColorLUT->SetTableValue(i, 0, 0, 0, 0.0);
137 mColorLUT->SetTableValue(mForegroundValue, mColor[0], mColor[1], mColor[2], mAlpha);
140 mOverlayMapper->SetLookupTable(mColorLUT);
142 vtkSmartPointer<vtkImageActor> mOverlayActor = vtkSmartPointer<vtkImageActor>::New();
143 #if VTK_MAJOR_VERSION <= 5
144 mOverlayActor->SetInput(mOverlayMapper->GetOutput());
146 mOverlayActor->SetInputData(mOverlayMapper->GetOutput());
148 mOverlayActor->SetPickable(0);
149 mOverlayActor->SetVisibility(IsVisible);
150 //mOverlayActor->SetOpacity(1.0);
152 // FIXME : by default overlay is not interpolated.
153 // mOverlayActor->SetInterpolate(mSlicer->GetImageActor()->GetInterpolate());
154 mOverlayActor->InterpolateOff();
156 mMapperList.push_back(mOverlayMapper);
157 mImageActorList.push_back(mOverlayActor);
158 mSlicer->GetRenderer()->AddActor(mOverlayActor);
161 //------------------------------------------------------------------------------
164 //------------------------------------------------------------------------------
165 void vvBinaryImageOverlayActor::SetOpacity(double d)
166 { cout << __func__ << endl;
169 //------------------------------------------------------------------------------
172 //------------------------------------------------------------------------------
173 // void vvBinaryImageOverlayActor::UpdateOpacity(double d) {
175 // mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
176 // for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
177 // // how many intensity ?
178 // vtkImageMapToRGBA * mOverlayMapper = mMapperList[numImage];
179 // mOverlayMapper->SetLookupTable(mColorLUT);
181 // vtkImageActor * mOverlayActor = mImageActorList[numImage];
182 // mOverlayActor->SetInput(mOverlayMapper->GetOutput());
185 //------------------------------------------------------------------------------
188 //------------------------------------------------------------------------------
189 // void vvBinaryImageOverlayActor::SetColor(double r, double v, double b) {
193 // // mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
194 // // for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
195 // // // how many intensity ?
196 // // vtkImageMapToRGBA * mOverlayMapper = mMapperList[numImage];
197 // // mOverlayMapper->SetLookupTable(mColorLUT);
199 // // vtkImageActor * mOverlayActor = mImageActorList[numImage];
200 // // mOverlayActor->SetInput(mOverlayMapper->GetOutput());
203 //------------------------------------------------------------------------------
206 //------------------------------------------------------------------------------
207 void vvBinaryImageOverlayActor::SetImage(vvImage::Pointer image, double bg, bool modeBG)
208 { cout << __func__ << endl;
211 mBackgroundValue = bg;
215 mForegroundValue = bg;
219 //------------------------------------------------------------------------------
222 //------------------------------------------------------------------------------
223 void vvBinaryImageOverlayActor::HideActors()
224 { cout << __func__ << endl;
225 if (!mSlicer) return;
226 mSlice = mSlicer->GetSlice();
227 for(unsigned int i=0; i<mImageActorList.size(); i++) {
228 mImageActorList[i]->VisibilityOff();
230 // Caller MUST call Render
231 // mSlicer->Render();
233 //------------------------------------------------------------------------------
236 //------------------------------------------------------------------------------
237 void vvBinaryImageOverlayActor::ShowActors()
238 { cout << __func__ << endl;
239 if (!mSlicer) return;
240 mSlice = mSlicer->GetSlice();
241 mTSlice = mSlicer->GetTSlice();
242 // for(unsigned int i=0; i<mSquaresActorList.size(); i++) {
243 mImageActorList[mTSlice]->VisibilityOn();
244 UpdateSlice(0, mSlice);
246 // Caller MUST call Render
249 //------------------------------------------------------------------------------
252 //------------------------------------------------------------------------------
253 void vvBinaryImageOverlayActor::UpdateColor()
254 { cout << __func__ << endl;
255 mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
256 for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
257 // how many intensity ?
258 vtkImageMapToRGBA * mOverlayMapper = mMapperList[numImage];
259 mOverlayMapper->SetLookupTable(mColorLUT);
261 vtkImageActor * mOverlayActor = mImageActorList[numImage];
262 #if VTK_MAJOR_VERSION <= 5
263 mOverlayActor->SetInput(mOverlayMapper->GetOutput());
265 mOverlayActor->SetInputData(mOverlayMapper->GetOutput());
269 //------------------------------------------------------------------------------
271 //------------------------------------------------------------------------------
272 void vvBinaryImageOverlayActor::UpdateSlice(int slicer, int slice, bool force)
273 { cout << __func__ << endl;
274 if (!mSlicer) return;
277 if (mPreviousSlice == mSlicer->GetSlice()) {
278 if (mPreviousTSlice == mSlicer->GetTSlice()) {
279 return; // Nothing to do
285 mSlice = mSlicer->GetSlice();
286 mTSlice = mSlicer->GetTSlice();
289 int * imageExtent = mSlicer->GetExtent();
290 int orientation = mSlicer->GetOrientation();
292 ComputeExtent(orientation, mSlice, imageExtent, maskExtent);
293 ComputeExtent(maskExtent, maskExtent, mSlicer->GetImage()->GetFirstVTKImageData(), mImage->GetFirstVTKImageData());
294 #if VTK_MAJOR_VERSION <= 5
295 mSlicer->ClipDisplayedExtent(maskExtent, mMapperList[mTSlice]->GetInput()->GetWholeExtent());
297 mSlicer->ClipDisplayedExtent(maskExtent, mMapperList[mTSlice]->GetInput()->GetInformation()->Get(vtkDataObject::DATA_EXTENT()));
299 mSlicer->Print(cout);
300 SetDisplayExtentAndCameraPosition(orientation, mSlice, maskExtent, mImageActorList[mTSlice], mDepth);
302 // set previous slice
303 mPreviousTSlice = mSlicer->GetTSlice();
304 mPreviousSlice = mSlicer->GetSlice();
306 //------------------------------------------------------------------------------
309 //------------------------------------------------------------------------------
310 void vvBinaryImageOverlayActor::ComputeExtent(int orientation,
314 { cout << __func__ << endl;
315 switch (orientation) {
316 case vtkImageViewer2::SLICE_ORIENTATION_XY:
317 for(int i=0; i<4; i++) outExtent[i] = inExtent[i];
318 outExtent[4] = outExtent[5] = slice;
320 case vtkImageViewer2::SLICE_ORIENTATION_XZ:
321 for(int i=0; i<2; i++) outExtent[i] = inExtent[i];
322 for(int i=4; i<6; i++) outExtent[i] = inExtent[i];
323 outExtent[2] = outExtent[3] = slice;
325 case vtkImageViewer2::SLICE_ORIENTATION_YZ:
326 for(int i=2; i<6; i++) outExtent[i] = inExtent[i];
327 outExtent[0] = outExtent[1] = slice;
331 //------------------------------------------------------------------------------
334 //----------------------------------------------------------------------------
335 void vvBinaryImageOverlayActor::ComputeExtent(int * inExtent, int * outExtent, vtkImageData * image, vtkImageData * overlay)
336 { cout << __func__ << endl;
337 for(int i=0; i<3; i++) {
338 double a = (image->GetOrigin()[i] + inExtent[i*2]*image->GetSpacing()[i] -
339 overlay->GetOrigin()[i]) / overlay->GetSpacing()[i];
340 double b = (image->GetOrigin()[i] + inExtent[i*2+1]*image->GetSpacing()[i] -
341 overlay->GetOrigin()[i]) / overlay->GetSpacing()[i];
342 outExtent[i*2] = lrint(a);
343 outExtent[i*2+1] = lrint(b);
346 /* // FIXME (original)
347 outExtent[0] = (int)lrint(((image->GetOrigin()[0] + inExtent[0]*image->GetSpacing()[0]) - overlay->GetOrigin()[0]) / overlay->GetSpacing()[0]);
348 outExtent[1] = (int)lrint(((image->GetOrigin()[0] + inExtent[1]*image->GetSpacing()[0]) - overlay->GetOrigin()[0]) / overlay->GetSpacing()[0]);
349 outExtent[2] = (int)lrint(((image->GetOrigin()[1] + inExtent[2]*image->GetSpacing()[1]) - overlay->GetOrigin()[1]) / overlay->GetSpacing()[1]);
350 outExtent[3] = (int)lrint(((image->GetOrigin()[1] + inExtent[3]*image->GetSpacing()[1]) - overlay->GetOrigin()[1]) / overlay->GetSpacing()[1]);
351 outExtent[4] = (int)lrint(((image->GetOrigin()[2] + inExtent[4]*image->GetSpacing()[2]) - overlay->GetOrigin()[2]) / overlay->GetSpacing()[2]);
352 outExtent[5] = (int)lrint(((image->GetOrigin()[2] + inExtent[5]*image->GetSpacing()[2]) - overlay->GetOrigin()[2]) / overlay->GetSpacing()[2]);
355 //----------------------------------------------------------------------------
358 //------------------------------------------------------------------------------
359 void vvBinaryImageOverlayActor::SetDisplayExtentAndCameraPosition(int orientation,
362 vtkImageActor * actor,
364 { cout << __func__ << endl;
366 Error according to camera orientation
370 if (orientation == vtkImageViewer2::SLICE_ORIENTATION_XY) {
371 //if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[2] > slice)
372 actor->SetPosition(0,0, -position);
374 //actor->SetPosition(0,0, position);
376 if (orientation == vtkImageViewer2::SLICE_ORIENTATION_XZ) {
377 //if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[1] > slice)
378 // actor->SetPosition(0,position,0);
380 actor->SetPosition(0,-position,0);
382 if (orientation == vtkImageViewer2::SLICE_ORIENTATION_YZ) {
383 //if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[0] > slice)
384 // actor->SetPosition(position,0, 0);
386 actor->SetPosition(-position,0, 0);
388 actor->SetDisplayExtent(extent);
390 //------------------------------------------------------------------------------