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 { //out << __func__ << endl;
  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 { //out << __func__ << endl;
  57   mImageActorList.clear();
  58 }
  59 //------------------------------------------------------------------------------
  60
  61
  62 //------------------------------------------------------------------------------
  63 void vvBinaryImageOverlayActor::RemoveActors()
  64 { //out << __func__ << endl;
  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 { //out << __func__ << endl;
  83   mColor[0] = r;
  84   mColor[1] = g;
  85   mColor[2] = b;
  86 }
  87 //------------------------------------------------------------------------------
  88
  89
  90 //------------------------------------------------------------------------------
  91 void vvBinaryImageOverlayActor::SetSlicer(vvSlicer * slicer)
  92 { //out << __func__ << endl;
  93   mSlicer = slicer;
  94 }
  95 //------------------------------------------------------------------------------
  96
  97
  98 //------------------------------------------------------------------------------
  99 void vvBinaryImageOverlayActor::Initialize(bool IsVisible)
 100 { //out << __func__ << endl;
 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     vtkSmartPointer<vtkImageMapToRGBA> mOverlayMapper = vtkSmartPointer<vtkImageMapToRGBA>::New();
 114 #if VTK_MAJOR_VERSION <= 5
 115     mOverlayMapper->SetInput(mImage->GetVTKImages()[0]); // DS TODO : to change if it is 4D !!!
 116 #else
 117     mOverlayMapper->SetInputData(mImage->GetVTKImages()[0]); // DS TODO : to change if it is 4D !!!
 118 #endif
 119
 120     double range[2];
 121     mImage->GetVTKImages()[0]->GetScalarRange(range);
 122     int n = range[1]-range[0]+1;
 123     mColorLUT->SetRange(range[0],range[1]);
 124     mColorLUT->SetNumberOfTableValues(n);
 125
 126     // Mode BG -> all is color except BG
 127     if (m_modeBG) {
 128       for(int i=0; i<n; i++) {
 129         mColorLUT->SetTableValue(i, mColor[0], mColor[1], mColor[2], mAlpha);
 130       }
 131       mColorLUT->SetTableValue(mBackgroundValue, 0, 0, 0, 0.0);
 132     }
 133     else {
 134       // Mode FG -> all is BG, except FG which is color
 135       for(int i=0; i<n; i++) {
 136         mColorLUT->SetTableValue(i, 0, 0, 0, 0.0);
 137       }
 138       mColorLUT->SetTableValue(mForegroundValue, mColor[0], mColor[1], mColor[2], mAlpha);
 139     }
 140
 141     mOverlayMapper->SetLookupTable(mColorLUT);
 142
 143     vtkSmartPointer<vtkImageActor> mOverlayActor = vtkSmartPointer<vtkImageActor>::New();
 144 #if VTK_MAJOR_VERSION <= 5
 145     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 146 #else
 147     mOverlayActor->GetMapper()->SetInputConnection(mOverlayMapper->GetOutputPort());
 148 #endif
 149     mOverlayActor->SetPickable(0);
 150     mOverlayActor->SetVisibility(IsVisible);
 151     //mOverlayActor->SetOpacity(1.0);
 152
 153     // FIXME : by default overlay is not interpolated.
 154     // mOverlayActor->SetInterpolate(mSlicer->GetImageActor()->GetInterpolate());
 155     mOverlayActor->InterpolateOff();
 156
 157     mMapperList.push_back(mOverlayMapper);
 158     mImageActorList.push_back(mOverlayActor);
 159     mSlicer->GetRenderer()->AddActor(mOverlayActor);
 160   }
 161 }
 162 //------------------------------------------------------------------------------
 163
 164
 165 //------------------------------------------------------------------------------
 166 void vvBinaryImageOverlayActor::SetOpacity(double d)
 167 { //out << __func__ << endl;
 168   mAlpha = d;
 169 }
 170 //------------------------------------------------------------------------------
 171
 172
 173 //------------------------------------------------------------------------------
 174 // void vvBinaryImageOverlayActor::UpdateOpacity(double d) {
 175 //   mAlpha = d;
 176 //   mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
 177 //   for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
 178 //     // how many intensity ?
 179 //     vtkImageMapToRGBA * mOverlayMapper = mMapperList[numImage];
 180 //     mOverlayMapper->SetLookupTable(mColorLUT);
 181
 182 //     vtkImageActor * mOverlayActor = mImageActorList[numImage];
 183 //     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 184 //   }
 185 // }
 186 //------------------------------------------------------------------------------
 187
 188
 189 //------------------------------------------------------------------------------
 190 // void vvBinaryImageOverlayActor::SetColor(double r, double v, double b) {
 191 //   mColor[0] = r;
 192 //   mColor[1] = v;
 193 //   mColor[2] = b;
 194 //   // mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
 195 //   // for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
 196 //   //   // how many intensity ?
 197 //   //   vtkImageMapToRGBA * mOverlayMapper = mMapperList[numImage];
 198 //   //   mOverlayMapper->SetLookupTable(mColorLUT);
 199
 200 //   //   vtkImageActor * mOverlayActor = mImageActorList[numImage];
 201 //   //   mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 202 //   // }
 203 // }
 204 //------------------------------------------------------------------------------
 205
 206
 207 //------------------------------------------------------------------------------
 208 void vvBinaryImageOverlayActor::SetImage(vvImage::Pointer image, double bg, bool modeBG)
 209 { //out << __func__ << endl;
 210   mImage = image;
 211   if (modeBG) {
 212     mBackgroundValue = bg;
 213     m_modeBG = true;
 214   }
 215   else {
 216     mForegroundValue = bg;
 217     m_modeBG = false;
 218   }
 219 }
 220 //------------------------------------------------------------------------------
 221
 222
 223 //------------------------------------------------------------------------------
 224 void vvBinaryImageOverlayActor::HideActors()
 225 { //out << __func__ << endl;
 226   if (!mSlicer) return;
 227   mSlice = mSlicer->GetSlice();
 228   for(unsigned int i=0; i<mImageActorList.size(); i++) {
 229     mImageActorList[i]->VisibilityOff();
 230   }
 231   // Caller MUST call Render
 232   //  mSlicer->Render();
 233 }
 234 //------------------------------------------------------------------------------
 235
 236
 237 //------------------------------------------------------------------------------
 238 void vvBinaryImageOverlayActor::ShowActors()
 239 { //out << __func__ << endl;
 240   if (!mSlicer) return;
 241   mSlice = mSlicer->GetSlice();
 242   mTSlice = mSlicer->GetTSlice();
 243   //  for(unsigned int i=0; i<mSquaresActorList.size(); i++) {
 244   mImageActorList[mTSlice]->VisibilityOn();
 245   UpdateSlice(0, mSlice);
 246   //}
 247   // Caller MUST call Render
 248   //mSlicer->Render();
 249 }
 250 //------------------------------------------------------------------------------
 251
 252
 253 //------------------------------------------------------------------------------
 254 void vvBinaryImageOverlayActor::UpdateColor()
 255 { //out << __func__ << endl;
 256   mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
 257   for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
 258     // how many intensity ?
 259     vtkImageMapToRGBA * mOverlayMapper = mMapperList[numImage];
 260     mOverlayMapper->SetLookupTable(mColorLUT);
 261
 262     vtkImageActor * mOverlayActor = mImageActorList[numImage];
 263 #if VTK_MAJOR_VERSION <= 5
 264     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 265 #else
 266     mOverlayActor->SetInputData(mOverlayMapper->GetOutput());
 267 #endif
 268   }
 269 }
 270 //------------------------------------------------------------------------------
 271
 272 //------------------------------------------------------------------------------
 273 void vvBinaryImageOverlayActor::UpdateSlice(int slicer, int slice, bool force)
 274 { //out << __func__ << endl;
 275   if (!mSlicer) return;
 276
 277   if (!force) {
 278     if (mPreviousSlice == mSlicer->GetSlice()) {
 279       if (mPreviousTSlice == mSlicer->GetTSlice()) {
 280         return; // Nothing to do
 281       }
 282     }
 283   }
 284
 285   // Get current slice
 286   mSlice = mSlicer->GetSlice();
 287   mTSlice = mSlicer->GetTSlice();
 288
 289   // Update extent
 290   int * imageExtent = mSlicer->GetExtent();
 291   int orientation = mSlicer->GetOrientation();
 292   int maskExtent[6];
 293   ComputeExtent(orientation, mSlice, imageExtent, maskExtent);
 294   ComputeExtent(maskExtent, maskExtent, mSlicer->GetImage()->GetFirstVTKImageData(), mImage->GetFirstVTKImageData());
 295 #if VTK_MAJOR_VERSION <= 5
 296   mSlicer->ClipDisplayedExtent(maskExtent, mMapperList[mTSlice]->GetInput()->GetWholeExtent());
 297 #else
 298   mSlicer->ClipDisplayedExtent(maskExtent, mMapperList[mTSlice]->GetInput()->GetInformation()->Get(vtkDataObject::DATA_EXTENT()));
 299 #endif
 300   SetDisplayExtentAndCameraPosition(orientation, mSlice, maskExtent, mImageActorList[mTSlice], mDepth);
 301
 302   // set previous slice
 303   mPreviousTSlice = mSlicer->GetTSlice();
 304   mPreviousSlice  = mSlicer->GetSlice();
 305 }
 306 //------------------------------------------------------------------------------
 307
 308
 309 //------------------------------------------------------------------------------
 310 void vvBinaryImageOverlayActor::ComputeExtent(int orientation,
 311                                               int slice,
 312                                               int * inExtent,
 313                                               int * outExtent)
 314 { //out << __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;
 319     break;
 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;
 324     break;
 325   case vtkImageViewer2::SLICE_ORIENTATION_YZ:
 326     for(int i=2; i<6; i++) outExtent[i] = inExtent[i];
 327     outExtent[0] = outExtent[1] = slice;
 328     break;
 329   }
 330 }
 331 //------------------------------------------------------------------------------
 332
 333
 334 //----------------------------------------------------------------------------
 335 void vvBinaryImageOverlayActor::ComputeExtent(int * inExtent, int * outExtent, vtkImageData * image, vtkImageData * overlay)
 336 { //out << __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);
 344   }
 345
 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]);
 353   */
 354 }
 355 //----------------------------------------------------------------------------
 356
 357
 358 //------------------------------------------------------------------------------
 359 void vvBinaryImageOverlayActor::SetDisplayExtentAndCameraPosition(int orientation,
 360                                                                   int slice,
 361                                                                   int * extent,
 362                                                                   vtkImageActor * actor,
 363                                                                   double position)
 364 { //out << __func__ << endl;
 365   /* FIXME
 366      Error according to camera orientation
 367    */
 368
 369   // Set position
 370   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_XY) {
 371     //if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[2] > slice)
 372       actor->SetPosition(0,0, -position);
 373       //else
 374       //actor->SetPosition(0,0, position);
 375   }
 376   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_XZ) {
 377     //if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[1] > slice)
 378     // actor->SetPosition(0,position,0);
 379     //else
 380       actor->SetPosition(0,-position,0);
 381   }
 382   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_YZ) {
 383     //if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[0] > slice)
 384     //  actor->SetPosition(position,0, 0);
 385     //else
 386       actor->SetPosition(-position,0, 0);
 387   }
 388   actor->SetDisplayExtent(extent);
 389 }
 390 //------------------------------------------------------------------------------
 391