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