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://www.centreleonberard.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 <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>
  34 #include <vtkImageMapper3D.h>
  35
  36 //------------------------------------------------------------------------------
  37 vvBinaryImageOverlayActor::vvBinaryImageOverlayActor()
  38 {
  39   mTSlice = -1;
  40   mSlice = 0;
  41   mColor.resize(3);
  42   mAlpha = 0.6;
  43   mImage = 0;
  44   mSlicer = 0;
  45   mColorLUT = vtkSmartPointer<vtkLookupTable>::New();
  46   mForegroundValue = 1;
  47   mBackgroundValue = 0;
  48   m_modeBG = true;
  49   mDepth = 1.0;
  50 }
  51 //------------------------------------------------------------------------------
  52
  53
  54 //------------------------------------------------------------------------------
  55 vvBinaryImageOverlayActor::~vvBinaryImageOverlayActor()
  56 {
  57   mImageActorList.clear();
  58 }
  59 //------------------------------------------------------------------------------
  60
  61
  62 //------------------------------------------------------------------------------
  63 void vvBinaryImageOverlayActor::RemoveActors()
  64 {
  65   for (unsigned int i = 0; i < mImageActorList.size(); i++) {
  66     if (mSlicer != 0) {
  67       if (mSlicer != NULL) {
  68         if (mSlicer->GetRenderer() != 0) {
  69           if (mImageActorList[i] != 0)  {
  70             mSlicer->GetRenderer()->RemoveActor(mImageActorList[i]);
  71           }
  72         }
  73       }
  74     }
  75   }
  76 }
  77 //------------------------------------------------------------------------------
  78
  79
  80 //------------------------------------------------------------------------------
  81 void vvBinaryImageOverlayActor::SetColor(double r, double g, double b)
  82 {
  83   mColor[0] = r;
  84   mColor[1] = g;
  85   mColor[2] = b;
  86 }
  87 //------------------------------------------------------------------------------
  88
  89
  90 //------------------------------------------------------------------------------
  91 void vvBinaryImageOverlayActor::SetSlicer(vvSlicer * slicer)
  92 {
  93   mSlicer = slicer;
  94 }
  95 //------------------------------------------------------------------------------
  96
  97
  98 //------------------------------------------------------------------------------
  99 void vvBinaryImageOverlayActor::Initialize(bool IsVisible)
 100 {
 101   if (!mSlicer) {
 102     std::cerr << "ERROR. Please use setSlicer before setSlicer in vvBinaryImageOverlayActor." << std::endl;
 103     exit(0);
 104   }
 105
 106   if (!mImage) {
 107     std::cerr << "ERROR. Please use setImage before setSlicer in vvBinaryImageOverlayActor." << std::endl;
 108     exit(0);
 109   }
 110   // Create an actor for each time slice
 111   for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
 112     // how many intensity ?
 113
 114
 115
 116     if (!mFusionReslice) {
 117       mFusionReslice = vtkSmartPointer<vtkImageReslice>::New();
 118       mFusionReslice->SetInterpolationModeToLinear();
 119       mFusionReslice->AutoCropOutputOn();
 120       mFusionReslice->SetBackgroundColor(-1000,-1000,-1000,1);
 121     }
 122
 123     mConcatenatedFusionTransform = vtkSmartPointer<vtkTransform>::New();
 124     mConcatenatedFusionTransform->Identity();
 125     if (!mImage->GetTransform().empty()){
 126       mConcatenatedFusionTransform->Concatenate(mImage->GetTransform()[0]);
 127     }
 128     mConcatenatedFusionTransform->Concatenate(mSlicer->GetSlicingTransform());
 129     mFusionReslice->SetResliceAxes(mConcatenatedFusionTransform->GetMatrix());
 130     if (mImage->IsTimeSequence()) {
 131 #if VTK_MAJOR_VERSION <= 5
 132     mFusionReslice->SetInput(0, mImage->GetVTKImages()[numImage]);
 133     mFusionReslice->UpdateInformation();
 134 #else
 135     mFusionReslice->SetInputData(0, mImage->GetVTKImages()[numImage]);
 136 #endif
 137     } else {
 138 #if VTK_MAJOR_VERSION <= 5
 139     mFusionReslice->SetInput(0, mImage->GetVTKImages()[0]);
 140     mFusionReslice->UpdateInformation();
 141 #else
 142     mFusionReslice->SetInputData(0, mImage->GetVTKImages()[0]);
 143 #endif
 144     }
 145     mFusionReslice->Update();
 146
 147
 148
 149     vtkSmartPointer<vtkImageMapToRGBA> mOverlayMapper = vtkSmartPointer<vtkImageMapToRGBA>::New();
 150 #if VTK_MAJOR_VERSION <= 5
 151     mOverlayMapper->SetInput(mFusionReslice->GetOutput());
 152 #else
 153     mOverlayMapper->SetInputConnection(mFusionReslice->GetOutputPort(0));
 154 #endif
 155
 156     double range[2];
 157     if (mImage->IsTimeSequence())
 158     {
 159         mImage->GetVTKImages()[numImage]->GetScalarRange(range);
 160     }
 161     else {
 162         mImage->GetVTKImages()[0]->GetScalarRange(range);
 163     }
 164     int n = range[1]-range[0]+1;
 165     mColorLUT->SetRange(range[0],range[1]);
 166     mColorLUT->SetNumberOfTableValues(n);
 167
 168     // Mode BG -> all is color except BG
 169     if (m_modeBG) {
 170       for(int i=0; i<n; i++) {
 171         mColorLUT->SetTableValue(i, mColor[0], mColor[1], mColor[2], mAlpha);
 172       }
 173       mColorLUT->SetTableValue(mBackgroundValue, 0, 0, 0, 0.0);
 174     }
 175     else {
 176       // Mode FG -> all is BG, except FG which is color
 177       for(int i=0; i<n; i++) {
 178         mColorLUT->SetTableValue(i, 0, 0, 0, 0.0);
 179       }
 180       mColorLUT->SetTableValue(mForegroundValue, mColor[0], mColor[1], mColor[2], mAlpha);
 181     }
 182
 183     mOverlayMapper->SetLookupTable(mColorLUT);
 184
 185     vtkSmartPointer<vtkImageActor> mOverlayActor = vtkSmartPointer<vtkImageActor>::New();
 186 #if VTK_MAJOR_VERSION <= 5
 187     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 188 #else
 189     mOverlayActor->GetMapper()->SetInputConnection(mOverlayMapper->GetOutputPort());
 190 #endif
 191     mOverlayActor->SetPickable(0);
 192     mOverlayActor->SetVisibility(IsVisible);
 193     //mOverlayActor->SetOpacity(1.0);
 194
 195     // FIXME : by default overlay is not interpolated.
 196     // mOverlayActor->SetInterpolate(mSlicer->GetImageActor()->GetInterpolate());
 197     mOverlayActor->InterpolateOff();
 198
 199     mMapperList.push_back(mOverlayMapper);
 200     mImageActorList.push_back(mOverlayActor);
 201     mSlicer->GetRenderer()->AddActor(mImageActorList[numImage]);
 202   }
 203 }
 204 //------------------------------------------------------------------------------
 205
 206
 207 //------------------------------------------------------------------------------
 208 void vvBinaryImageOverlayActor::SetOpacity(double d)
 209 {
 210   mAlpha = d;
 211 }
 212 //------------------------------------------------------------------------------
 213
 214
 215 //------------------------------------------------------------------------------
 216 // void vvBinaryImageOverlayActor::UpdateOpacity(double d) {
 217 //   mAlpha = d;
 218 //   mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
 219 //   for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
 220 //     // how many intensity ?
 221 //     vtkImageMapToRGBA * mOverlayMapper = mMapperList[numImage];
 222 //     mOverlayMapper->SetLookupTable(mColorLUT);
 223
 224 //     vtkImageActor * mOverlayActor = mImageActorList[numImage];
 225 //     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 226 //   }
 227 // }
 228 //------------------------------------------------------------------------------
 229
 230
 231 //------------------------------------------------------------------------------
 232 // void vvBinaryImageOverlayActor::SetColor(double r, double v, double b) {
 233 //   mColor[0] = r;
 234 //   mColor[1] = v;
 235 //   mColor[2] = b;
 236 //   // mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
 237 //   // for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
 238 //   //   // how many intensity ?
 239 //   //   vtkImageMapToRGBA * mOverlayMapper = mMapperList[numImage];
 240 //   //   mOverlayMapper->SetLookupTable(mColorLUT);
 241
 242 //   //   vtkImageActor * mOverlayActor = mImageActorList[numImage];
 243 //   //   mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 244 //   // }
 245 // }
 246 //------------------------------------------------------------------------------
 247
 248
 249 //------------------------------------------------------------------------------
 250 void vvBinaryImageOverlayActor::SetImage(vvImage::Pointer image, double bg, bool modeBG)
 251 {
 252   mImage = image;
 253   if (modeBG) {
 254     mBackgroundValue = bg;
 255     m_modeBG = true;
 256   }
 257   else {
 258     mForegroundValue = bg;
 259     m_modeBG = false;
 260   }
 261 }
 262 //------------------------------------------------------------------------------
 263
 264
 265 //------------------------------------------------------------------------------
 266 void vvBinaryImageOverlayActor::HideActors()
 267 {
 268   if (!mSlicer) return;
 269   mSlice = mSlicer->GetSlice();
 270   for(unsigned int i=0; i<mImageActorList.size(); i++) {
 271     mImageActorList[i]->VisibilityOff();
 272   }
 273   // Caller MUST call Render
 274   //  mSlicer->Render();
 275 }
 276 //------------------------------------------------------------------------------
 277
 278
 279 //------------------------------------------------------------------------------
 280 void vvBinaryImageOverlayActor::ShowActors()
 281 {
 282   if (!mSlicer) return;
 283   mSlice = mSlicer->GetSlice();
 284   mTSlice = mSlicer->GetTSlice();
 285   mImageActorList[mTSlice]->VisibilityOn();
 286   UpdateSlice(0, mSlice);
 287   // Caller MUST call Render
 288   //mSlicer->Render();
 289 }
 290 //------------------------------------------------------------------------------
 291
 292
 293 //------------------------------------------------------------------------------
 294 void vvBinaryImageOverlayActor::UpdateColor()
 295 {
 296   mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
 297   for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
 298     // how many intensity ?
 299     vtkImageMapToRGBA * mOverlayMapper = mMapperList[numImage];
 300     mOverlayMapper->SetLookupTable(mColorLUT);
 301
 302     vtkImageActor * mOverlayActor = mImageActorList[numImage];
 303 #if VTK_MAJOR_VERSION <= 5
 304     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 305 #else
 306     mOverlayActor->SetInputData(mOverlayMapper->GetOutput());
 307 #endif
 308   }
 309 }
 310 //------------------------------------------------------------------------------
 311
 312 //------------------------------------------------------------------------------
 313 void vvBinaryImageOverlayActor::UpdateSlice(int slicer, int slice, bool force)
 314 {
 315   if (!mSlicer) return;
 316
 317   if (!force) {
 318     if (mPreviousSlice == mSlicer->GetSlice()) {
 319       if (mPreviousTSlice == mSlicer->GetTSlice()) {
 320         return; // Nothing to do
 321       }
 322     }
 323   }
 324
 325   // Get current slice
 326   mSlice = mSlicer->GetSlice();
 327   mTSlice = mSlicer->GetTSlice();
 328
 329   // Update extent
 330   int * imageExtent = mSlicer->GetExtent();
 331   int orientation = mSlicer->GetOrientation();
 332   int maskExtent[6];
 333   ComputeExtent(orientation, mSlice, imageExtent, maskExtent);
 334   ComputeExtent(maskExtent, maskExtent, mSlicer->GetImage()->GetVTKImages()[mTSlice], mImage->GetVTKImages()[mTSlice]);
 335 #if VTK_MAJOR_VERSION <= 5
 336   mSlicer->ClipDisplayedExtent(maskExtent, mMapperList[mTSlice]->GetInput()->GetWholeExtent());
 337 #else
 338   mSlicer->ClipDisplayedExtent(maskExtent, mMapperList[mTSlice]->GetInput()->GetInformation()->Get(vtkDataObject::DATA_EXTENT()));
 339 #endif
 340   HideActors();
 341   mImageActorList[mTSlice]->VisibilityOn();
 342   SetDisplayExtentAndCameraPosition(orientation, mSlice, maskExtent, mImageActorList[mTSlice], mDepth);
 343
 344   // set previous slice
 345   mPreviousTSlice = mSlicer->GetTSlice();
 346   mPreviousSlice  = mSlicer->GetSlice();
 347 }
 348 //------------------------------------------------------------------------------
 349
 350
 351 //------------------------------------------------------------------------------
 352 void vvBinaryImageOverlayActor::ComputeExtent(int orientation,
 353                                               int slice,
 354                                               int * inExtent,
 355                                               int * outExtent)
 356 {
 357   switch (orientation) {
 358   case vtkImageViewer2::SLICE_ORIENTATION_XY:
 359     for(int i=0; i<4; i++) outExtent[i] = inExtent[i];
 360     outExtent[4] = outExtent[5] = slice;
 361     break;
 362   case vtkImageViewer2::SLICE_ORIENTATION_XZ:
 363     for(int i=0; i<2; i++) outExtent[i] = inExtent[i];
 364     for(int i=4; i<6; i++) outExtent[i] = inExtent[i];
 365     outExtent[2] = outExtent[3] = slice;
 366     break;
 367   case vtkImageViewer2::SLICE_ORIENTATION_YZ:
 368     for(int i=2; i<6; i++) outExtent[i] = inExtent[i];
 369     outExtent[0] = outExtent[1] = slice;
 370     break;
 371   }
 372 }
 373 //------------------------------------------------------------------------------
 374
 375
 376 //----------------------------------------------------------------------------
 377 void vvBinaryImageOverlayActor::ComputeExtent(int * inExtent, int * outExtent, vtkImageData * image, vtkImageData * overlay)
 378 {
 379   for(int i=0; i<3; i++) {
 380     double a = (image->GetOrigin()[i] + inExtent[i*2]*image->GetSpacing()[i] -
 381                 overlay->GetOrigin()[i]) / overlay->GetSpacing()[i];
 382     double b = (image->GetOrigin()[i] + inExtent[i*2+1]*image->GetSpacing()[i] -
 383                 overlay->GetOrigin()[i]) / overlay->GetSpacing()[i];
 384     outExtent[i*2] = lrint(a);
 385     outExtent[i*2+1] = lrint(b);
 386   }
 387
 388   /* // FIXME (original)
 389   outExtent[0] = (int)lrint(((image->GetOrigin()[0] + inExtent[0]*image->GetSpacing()[0]) - overlay->GetOrigin()[0]) / overlay->GetSpacing()[0]);
 390   outExtent[1] = (int)lrint(((image->GetOrigin()[0] + inExtent[1]*image->GetSpacing()[0]) - overlay->GetOrigin()[0]) / overlay->GetSpacing()[0]);
 391   outExtent[2] = (int)lrint(((image->GetOrigin()[1] + inExtent[2]*image->GetSpacing()[1]) - overlay->GetOrigin()[1]) / overlay->GetSpacing()[1]);
 392   outExtent[3] = (int)lrint(((image->GetOrigin()[1] + inExtent[3]*image->GetSpacing()[1]) - overlay->GetOrigin()[1]) / overlay->GetSpacing()[1]);
 393   outExtent[4] = (int)lrint(((image->GetOrigin()[2] + inExtent[4]*image->GetSpacing()[2]) - overlay->GetOrigin()[2]) / overlay->GetSpacing()[2]);
 394   outExtent[5] = (int)lrint(((image->GetOrigin()[2] + inExtent[5]*image->GetSpacing()[2]) - overlay->GetOrigin()[2]) / overlay->GetSpacing()[2]);
 395   */
 396 }
 397 //----------------------------------------------------------------------------
 398
 399
 400 //------------------------------------------------------------------------------
 401 void vvBinaryImageOverlayActor::SetDisplayExtentAndCameraPosition(int orientation,
 402                                                                   int slice,
 403                                                                   int * extent,
 404                                                                   vtkImageActor * actor,
 405                                                                   double position)
 406 {
 407   /* FIXME
 408      Error according to camera orientation
 409    */
 410
 411   // Set position
 412   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_XY) {
 413     //if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[2] > slice)
 414       actor->SetPosition(0,0, -position);
 415       //else
 416       //actor->SetPosition(0,0, position);
 417   }
 418   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_XZ) {
 419     //if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[1] > slice)
 420     // actor->SetPosition(0,position,0);
 421     //else
 422       actor->SetPosition(0,-position,0);
 423   }
 424   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_YZ) {
 425     //if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[0] > slice)
 426     //  actor->SetPosition(position,0, 0);
 427     //else
 428       actor->SetPosition(-position,0, 0);
 429   }
 430   actor->SetDisplayExtent(extent);
 431 }
 432 //------------------------------------------------------------------------------
 433