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
  35 //------------------------------------------------------------------------------
  36 vvBinaryImageOverlayActor::vvBinaryImageOverlayActor()
  37 {
  38   mTSlice = -1;
  39   mSlice = 0;
  40   mColor.resize(3);
  41   mAlpha = 0.6;
  42   mImage = 0;
  43   mSlicer = 0;
  44   mColorLUT = vtkSmartPointer<vtkLookupTable>::New();
  45   mForegroundValue = 1;
  46   mBackgroundValue = 0;
  47   m_modeBG = true;
  48   mDepth = 1.0;
  49 }
  50 //------------------------------------------------------------------------------
  51
  52
  53 //------------------------------------------------------------------------------
  54 vvBinaryImageOverlayActor::~vvBinaryImageOverlayActor()
  55 {
  56   mImageActorList.clear();
  57 }
  58 //------------------------------------------------------------------------------
  59
  60
  61 //------------------------------------------------------------------------------
  62 void vvBinaryImageOverlayActor::RemoveActors()
  63 {
  64   for (unsigned int i = 0; i < mImageActorList.size(); i++) {
  65     if (mSlicer != 0) {
  66       if (mSlicer != NULL) {
  67         if (mSlicer->GetRenderer() != 0) {
  68           if (mImageActorList[i] != 0)  {
  69             mSlicer->GetRenderer()->RemoveActor(mImageActorList[i]);
  70           }
  71         }
  72       }
  73     }
  74   }
  75 }
  76 //------------------------------------------------------------------------------
  77
  78
  79 //------------------------------------------------------------------------------
  80 void vvBinaryImageOverlayActor::SetColor(double r, double g, double b)
  81 {
  82   mColor[0] = r;
  83   mColor[1] = g;
  84   mColor[2] = b;
  85 }
  86 //------------------------------------------------------------------------------
  87
  88
  89 //------------------------------------------------------------------------------
  90 void vvBinaryImageOverlayActor::SetSlicer(vvSlicer * slicer)
  91 {
  92   mSlicer = slicer;
  93 }
  94 //------------------------------------------------------------------------------
  95
  96
  97 //------------------------------------------------------------------------------
  98 void vvBinaryImageOverlayActor::Initialize(bool IsVisible)
  99 {
 100   if (!mSlicer) {
 101     std::cerr << "ERROR. Please use setSlicer before setSlicer in vvBinaryImageOverlayActor." << std::endl;
 102     exit(0);
 103   }
 104
 105   if (!mImage) {
 106     std::cerr << "ERROR. Please use setImage before setSlicer in vvBinaryImageOverlayActor." << std::endl;
 107     exit(0);
 108   }
 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 !!!
 115 #else
 116     mOverlayMapper->SetInputData(mImage->GetVTKImages()[0]); // DS TODO : to change if it is 4D !!!
 117 #endif
 118
 119     double range[2];
 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);
 124
 125     // Mode BG -> all is color except BG
 126     if (m_modeBG) {
 127       for(int i=0; i<n; i++) {
 128         mColorLUT->SetTableValue(i, mColor[0], mColor[1], mColor[2], mAlpha);
 129       }
 130       mColorLUT->SetTableValue(mBackgroundValue, 0, 0, 0, 0.0);
 131     }
 132     else {
 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);
 136       }
 137       mColorLUT->SetTableValue(mForegroundValue, mColor[0], mColor[1], mColor[2], mAlpha);
 138     }
 139
 140     mOverlayMapper->SetLookupTable(mColorLUT);
 141
 142     vtkSmartPointer<vtkImageActor> mOverlayActor = vtkSmartPointer<vtkImageActor>::New();
 143 #if VTK_MAJOR_VERSION <= 5
 144     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 145 #else
 146     mOverlayActor->SetInputData(mOverlayMapper->GetOutput());
 147 #endif
 148     mOverlayActor->SetPickable(0);
 149     mOverlayActor->SetVisibility(IsVisible);
 150     //mOverlayActor->SetOpacity(1.0);
 151
 152     // FIXME : by default overlay is not interpolated.
 153     // mOverlayActor->SetInterpolate(mSlicer->GetImageActor()->GetInterpolate());
 154     mOverlayActor->InterpolateOff();
 155
 156     mMapperList.push_back(mOverlayMapper);
 157     mImageActorList.push_back(mOverlayActor);
 158     mSlicer->GetRenderer()->AddActor(mOverlayActor);
 159   }
 160 }
 161 //------------------------------------------------------------------------------
 162
 163
 164 //------------------------------------------------------------------------------
 165 void vvBinaryImageOverlayActor::SetOpacity(double d)
 166 {
 167   mAlpha = d;
 168 }
 169 //------------------------------------------------------------------------------
 170
 171
 172 //------------------------------------------------------------------------------
 173 // void vvBinaryImageOverlayActor::UpdateOpacity(double d) {
 174 //   mAlpha = 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);
 180
 181 //     vtkImageActor * mOverlayActor = mImageActorList[numImage];
 182 //     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 183 //   }
 184 // }
 185 //------------------------------------------------------------------------------
 186
 187
 188 //------------------------------------------------------------------------------
 189 // void vvBinaryImageOverlayActor::SetColor(double r, double v, double b) {
 190 //   mColor[0] = r;
 191 //   mColor[1] = v;
 192 //   mColor[2] = 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);
 198
 199 //   //   vtkImageActor * mOverlayActor = mImageActorList[numImage];
 200 //   //   mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 201 //   // }
 202 // }
 203 //------------------------------------------------------------------------------
 204
 205
 206 //------------------------------------------------------------------------------
 207 void vvBinaryImageOverlayActor::SetImage(vvImage::Pointer image, double bg, bool modeBG)
 208 {
 209   mImage = image;
 210   if (modeBG) {
 211     mBackgroundValue = bg;
 212     m_modeBG = true;
 213   }
 214   else {
 215     mForegroundValue = bg;
 216     m_modeBG = false;
 217   }
 218 }
 219 //------------------------------------------------------------------------------
 220
 221
 222 //------------------------------------------------------------------------------
 223 void vvBinaryImageOverlayActor::HideActors()
 224 {
 225   if (!mSlicer) return;
 226   mSlice = mSlicer->GetSlice();
 227   for(unsigned int i=0; i<mImageActorList.size(); i++) {
 228     mImageActorList[i]->VisibilityOff();
 229   }
 230   // Caller MUST call Render
 231   //  mSlicer->Render();
 232 }
 233 //------------------------------------------------------------------------------
 234
 235
 236 //------------------------------------------------------------------------------
 237 void vvBinaryImageOverlayActor::ShowActors()
 238 {
 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);
 245   //}
 246   // Caller MUST call Render
 247   //mSlicer->Render();
 248 }
 249 //------------------------------------------------------------------------------
 250
 251
 252 //------------------------------------------------------------------------------
 253 void vvBinaryImageOverlayActor::UpdateColor()
 254 {
 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);
 260
 261     vtkImageActor * mOverlayActor = mImageActorList[numImage];
 262 #if VTK_MAJOR_VERSION <= 5
 263     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 264 #else
 265     mOverlayActor->SetInputData(mOverlayMapper->GetOutput());
 266 #endif
 267   }
 268 }
 269 //------------------------------------------------------------------------------
 270
 271 //------------------------------------------------------------------------------
 272 void vvBinaryImageOverlayActor::UpdateSlice(int slicer, int slice, bool force)
 273 {
 274   if (!mSlicer) return;
 275
 276   if (!force) {
 277     if (mPreviousSlice == mSlicer->GetSlice()) {
 278       if (mPreviousTSlice == mSlicer->GetTSlice()) {
 279         return; // Nothing to do
 280       }
 281     }
 282   }
 283
 284   // Get current slice
 285   mSlice = mSlicer->GetSlice();
 286   mTSlice = mSlicer->GetTSlice();
 287
 288   // Update extent
 289   int * imageExtent = mSlicer->GetExtent();
 290   int orientation = mSlicer->GetOrientation();
 291   int maskExtent[6];
 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());
 296 #else
 297   mSlicer->ClipDisplayedExtent(maskExtent, mMapperList[mTSlice]->GetInput()->GetInformation()->Get(vtkDataObject::DATA_EXTENT()));
 298 #endif
 299   SetDisplayExtentAndCameraPosition(orientation, mSlice, maskExtent, mImageActorList[mTSlice], mDepth);
 300
 301   // set previous slice
 302   mPreviousTSlice = mSlicer->GetTSlice();
 303   mPreviousSlice  = mSlicer->GetSlice();
 304 }
 305 //------------------------------------------------------------------------------
 306
 307
 308 //------------------------------------------------------------------------------
 309 void vvBinaryImageOverlayActor::ComputeExtent(int orientation,
 310                                               int slice,
 311                                               int * inExtent,
 312                                               int * outExtent)
 313 {
 314   switch (orientation) {
 315   case vtkImageViewer2::SLICE_ORIENTATION_XY:
 316     for(int i=0; i<4; i++) outExtent[i] = inExtent[i];
 317     outExtent[4] = outExtent[5] = slice;
 318     break;
 319   case vtkImageViewer2::SLICE_ORIENTATION_XZ:
 320     for(int i=0; i<2; i++) outExtent[i] = inExtent[i];
 321     for(int i=4; i<6; i++) outExtent[i] = inExtent[i];
 322     outExtent[2] = outExtent[3] = slice;
 323     break;
 324   case vtkImageViewer2::SLICE_ORIENTATION_YZ:
 325     for(int i=2; i<6; i++) outExtent[i] = inExtent[i];
 326     outExtent[0] = outExtent[1] = slice;
 327     break;
 328   }
 329 }
 330 //------------------------------------------------------------------------------
 331
 332
 333 //----------------------------------------------------------------------------
 334 void vvBinaryImageOverlayActor::ComputeExtent(int * inExtent, int * outExtent, vtkImageData * image, vtkImageData * overlay)
 335 {
 336   for(int i=0; i<3; i++) {
 337     double a = (image->GetOrigin()[i] + inExtent[i*2]*image->GetSpacing()[i] -
 338                 overlay->GetOrigin()[i]) / overlay->GetSpacing()[i];
 339     double b = (image->GetOrigin()[i] + inExtent[i*2+1]*image->GetSpacing()[i] -
 340                 overlay->GetOrigin()[i]) / overlay->GetSpacing()[i];
 341     outExtent[i*2] = lrint(a);
 342     outExtent[i*2+1] = lrint(b);
 343   }
 344
 345   /* // FIXME (original)
 346   outExtent[0] = (int)lrint(((image->GetOrigin()[0] + inExtent[0]*image->GetSpacing()[0]) - overlay->GetOrigin()[0]) / overlay->GetSpacing()[0]);
 347   outExtent[1] = (int)lrint(((image->GetOrigin()[0] + inExtent[1]*image->GetSpacing()[0]) - overlay->GetOrigin()[0]) / overlay->GetSpacing()[0]);
 348   outExtent[2] = (int)lrint(((image->GetOrigin()[1] + inExtent[2]*image->GetSpacing()[1]) - overlay->GetOrigin()[1]) / overlay->GetSpacing()[1]);
 349   outExtent[3] = (int)lrint(((image->GetOrigin()[1] + inExtent[3]*image->GetSpacing()[1]) - overlay->GetOrigin()[1]) / overlay->GetSpacing()[1]);
 350   outExtent[4] = (int)lrint(((image->GetOrigin()[2] + inExtent[4]*image->GetSpacing()[2]) - overlay->GetOrigin()[2]) / overlay->GetSpacing()[2]);
 351   outExtent[5] = (int)lrint(((image->GetOrigin()[2] + inExtent[5]*image->GetSpacing()[2]) - overlay->GetOrigin()[2]) / overlay->GetSpacing()[2]);
 352   */
 353 }
 354 //----------------------------------------------------------------------------
 355
 356
 357 //------------------------------------------------------------------------------
 358 void vvBinaryImageOverlayActor::SetDisplayExtentAndCameraPosition(int orientation,
 359                                                                   int slice,
 360                                                                   int * extent,
 361                                                                   vtkImageActor * actor,
 362                                                                   double position)
 363 {
 364   /* FIXME
 365      Error according to camera orientation
 366    */
 367
 368   // Set position
 369   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_XY) {
 370     //if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[2] > slice)
 371       actor->SetPosition(0,0, -position);
 372       //else
 373       //actor->SetPosition(0,0, position);
 374   }
 375   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_XZ) {
 376     //if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[1] > slice)
 377     // actor->SetPosition(0,position,0);
 378     //else
 379       actor->SetPosition(0,-position,0);
 380   }
 381   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_YZ) {
 382     //if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[0] > slice)
 383     //  actor->SetPosition(position,0, 0);
 384     //else
 385       actor->SetPosition(-position,0, 0);
 386   }
 387   actor->SetDisplayExtent(extent);
 388 }
 389 //------------------------------------------------------------------------------
 390