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 }
  43 //------------------------------------------------------------------------------
  44
  45
  46 //------------------------------------------------------------------------------
  47 vvBinaryImageOverlayActor::~vvBinaryImageOverlayActor()
  48 {
  49   for (unsigned int i = 0; i < mSlicer->GetImage()->GetVTKImages().size(); i++) {
  50     mSlicer->GetRenderer()->RemoveActor(mImageActorList[i]);
  51   }
  52   mImageActorList.clear();
  53   mMapperList.clear();
  54 }
  55 //------------------------------------------------------------------------------
  56
  57
  58 //------------------------------------------------------------------------------
  59 void vvBinaryImageOverlayActor::SetColor(double r, double g, double b)
  60 {
  61   mColor[0] = r;
  62   mColor[1] = g;
  63   mColor[2] = b;
  64 }
  65 //------------------------------------------------------------------------------
  66
  67
  68 //------------------------------------------------------------------------------
  69 void vvBinaryImageOverlayActor::SetSlicer(vvSlicer * slicer)
  70 {
  71   mSlicer = slicer;
  72 }
  73 //------------------------------------------------------------------------------
  74
  75
  76 //------------------------------------------------------------------------------
  77 void vvBinaryImageOverlayActor::Initialize()
  78 {
  79   if (!mSlicer) {
  80     std::cerr << "ERROR. Please use setSlicer before setSlicer in vvBinaryImageOverlayActor." << std::endl;
  81     exit(0);
  82   }
  83
  84   if (!mImage) {
  85     std::cerr << "ERROR. Please use setImage before setSlicer in vvBinaryImageOverlayActor." << std::endl;
  86     exit(0);
  87   }
  88   // Create an actor for each time slice
  89   for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
  90     // how many intensity ?
  91     vtkImageMapToRGBA * mOverlayMapper = vtkImageMapToRGBA::New();
  92     mOverlayMapper->SetInput(mImage->GetVTKImages()[0]); // DS TODO : to change if it is 4D !!!
  93     mColorLUT->SetRange(0,1);
  94     mColorLUT->SetNumberOfTableValues(2);
  95     mColorLUT->SetTableValue(mBackgroundValue, 0, 0, 0, 0.0);   // BG
  96     mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
  97     mOverlayMapper->SetLookupTable(mColorLUT);
  98
  99     vtkImageActor * mOverlayActor = vtkImageActor::New();
 100     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 101     mOverlayActor->SetPickable(0);
 102     mOverlayActor->SetVisibility(true);
 103     //mOverlayActor->SetOpacity(1.0);
 104
 105     mMapperList.push_back(mOverlayMapper);
 106     mImageActorList.push_back(mOverlayActor);
 107     mSlicer->GetRenderer()->AddActor(mOverlayActor);
 108   }
 109 }
 110 //------------------------------------------------------------------------------
 111
 112
 113 //------------------------------------------------------------------------------
 114 void vvBinaryImageOverlayActor::SetOpacity(double d)
 115 {
 116   mAlpha = d;
 117 }
 118 //------------------------------------------------------------------------------
 119
 120
 121 //------------------------------------------------------------------------------
 122 // void vvBinaryImageOverlayActor::UpdateOpacity(double d) {
 123 //   mAlpha = d;
 124 //   mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
 125 //   for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
 126 //     // how many intensity ?
 127 //     vtkImageMapToRGBA * mOverlayMapper = mMapperList[numImage];
 128 //     mOverlayMapper->SetLookupTable(mColorLUT);
 129
 130 //     vtkImageActor * mOverlayActor = mImageActorList[numImage];
 131 //     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 132 //   }
 133 // }
 134 //------------------------------------------------------------------------------
 135
 136
 137 //------------------------------------------------------------------------------
 138 // void vvBinaryImageOverlayActor::SetColor(double r, double v, double b) {
 139 //   mColor[0] = r;
 140 //   mColor[1] = v;
 141 //   mColor[2] = b;
 142 //   // mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
 143 //   // for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
 144 //   //   // how many intensity ?
 145 //   //   vtkImageMapToRGBA * mOverlayMapper = mMapperList[numImage];
 146 //   //   mOverlayMapper->SetLookupTable(mColorLUT);
 147
 148 //   //   vtkImageActor * mOverlayActor = mImageActorList[numImage];
 149 //   //   mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 150 //   // }
 151 // }
 152 //------------------------------------------------------------------------------
 153
 154
 155 //------------------------------------------------------------------------------
 156 void vvBinaryImageOverlayActor::SetImage(vvImage::Pointer image, double bg)
 157 {
 158   mImage = image;
 159   mBackgroundValue = bg;
 160 }
 161 //------------------------------------------------------------------------------
 162
 163
 164 //------------------------------------------------------------------------------
 165 void vvBinaryImageOverlayActor::HideActors()
 166 {
 167   if (!mSlicer) return;
 168   mSlice = mSlicer->GetSlice();
 169   for(unsigned int i=0; i<mImageActorList.size(); i++) {
 170     mImageActorList[i]->VisibilityOff();
 171   }
 172   // Caller MUST call Render
 173   //  mSlicer->Render();
 174 }
 175 //------------------------------------------------------------------------------
 176
 177
 178 //------------------------------------------------------------------------------
 179 void vvBinaryImageOverlayActor::ShowActors()
 180 {
 181   if (!mSlicer) return;
 182   mSlice = mSlicer->GetSlice();
 183   mTSlice = mSlicer->GetTSlice();
 184   //  for(unsigned int i=0; i<mSquaresActorList.size(); i++) {
 185   mImageActorList[mTSlice]->VisibilityOn();
 186   UpdateSlice(0, mSlice);
 187   //}
 188   // Caller MUST call Render
 189   //mSlicer->Render();
 190 }
 191 //------------------------------------------------------------------------------
 192
 193
 194 //------------------------------------------------------------------------------
 195 void vvBinaryImageOverlayActor::UpdateColor()
 196 {
 197   mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
 198   for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
 199     // how many intensity ?
 200     vtkImageMapToRGBA * mOverlayMapper = mMapperList[numImage];
 201     mOverlayMapper->SetLookupTable(mColorLUT);
 202
 203     vtkImageActor * mOverlayActor = mImageActorList[numImage];
 204     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 205   }
 206 }
 207 //------------------------------------------------------------------------------
 208
 209 //------------------------------------------------------------------------------
 210 void vvBinaryImageOverlayActor::UpdateSlice(int slicer, int slice)
 211 {
 212   if (!mSlicer) return;
 213
 214   if (mPreviousSlice == mSlicer->GetSlice()) {
 215     if (mPreviousTSlice == mSlicer->GetTSlice()) {
 216       //DD("=========== NOTHING");
 217       return; // Nothing to do
 218     }
 219   }
 220
 221   // Get current slice
 222   mSlice = mSlicer->GetSlice();
 223   mTSlice = mSlicer->GetTSlice();
 224
 225   // Update extent
 226   int * imageExtent = mSlicer->GetExtent();
 227   int orientation = mSlicer->GetOrientation();
 228   int maskExtent[6];
 229   ComputeExtent(orientation, mSlice, imageExtent, maskExtent);
 230   //ComputeExtent(imageExtent, maskExtent, mSlicer->GetImage()->GetFirstVTKImageData(), mImage->GetFirstVTKImageData());
 231   ComputeExtent(maskExtent, maskExtent, mSlicer->GetImage()->GetFirstVTKImageData(), mImage->GetFirstVTKImageData());
 232   // std::cout << "maskExtent = " << maskExtent[0] << " " << maskExtent[1] << " " << maskExtent[2] << " "
 233   //        << maskExtent[3] << " " << maskExtent[4] << " " << maskExtent[5] << std::endl;
 234   mSlicer->ClipDisplayedExtent(maskExtent, mMapperList[mTSlice]->GetInput()->GetWholeExtent());
 235   // std::cout << "maskExtent = " << maskExtent[0] << " " << maskExtent[1] << " " << maskExtent[2] << " "
 236   //        << maskExtent[3] << " " << maskExtent[4] << " " << maskExtent[5] << std::endl;
 237   SetDisplayExtentAndCameraPosition(orientation, mSlice, maskExtent, mImageActorList[mTSlice], 0.0);
 238
 239   // set previous slice
 240   mPreviousTSlice = mSlicer->GetTSlice();
 241   mPreviousSlice  = mSlicer->GetSlice();
 242 }
 243 //------------------------------------------------------------------------------
 244
 245
 246 //------------------------------------------------------------------------------
 247 void vvBinaryImageOverlayActor::ComputeExtent(int orientation,
 248                                               int slice,
 249                                               int * inExtent,
 250                                               int * outExtent)
 251 {
 252   //  std::cout << "InExtent = " << inExtent[0] << " " << inExtent[1] << " " << inExtent[2] << " "
 253   //        << inExtent[3] << " " << inExtent[4] << " " << inExtent[5] << std::endl;
 254   //  DD(orientation);
 255   switch (orientation) {
 256   case vtkImageViewer2::SLICE_ORIENTATION_XY:
 257     for(int i=0; i<4; i++) outExtent[i] = inExtent[i];
 258     outExtent[4] = outExtent[5] = slice;
 259     break;
 260   case vtkImageViewer2::SLICE_ORIENTATION_XZ:
 261     for(int i=0; i<2; i++) outExtent[i] = inExtent[i];
 262     for(int i=4; i<6; i++) outExtent[i] = inExtent[i];
 263     outExtent[2] = outExtent[3] = slice;
 264     break;
 265   case vtkImageViewer2::SLICE_ORIENTATION_YZ:
 266     for(int i=2; i<6; i++) outExtent[i] = inExtent[i];
 267     outExtent[0] = outExtent[1] = slice;
 268     break;
 269   }
 270   // std::cout << "OutExtent = " << outExtent[0] << " " << outExtent[1] << " " << outExtent[2] << " "
 271   //        << outExtent[3] << " " << outExtent[4] << " " << outExtent[5] << std::endl;
 272 }
 273 //------------------------------------------------------------------------------
 274
 275
 276 //----------------------------------------------------------------------------
 277 void vvBinaryImageOverlayActor::ComputeExtent(int * inExtent, int * outExtent, vtkImageData * image, vtkImageData * overlay)
 278 {
 279   outExtent[0] = (( image->GetOrigin()[0] + inExtent[0]*image->GetSpacing()[0] ) - overlay->GetOrigin()[0]) /
 280                  overlay->GetSpacing()[0];
 281   outExtent[1] = (( image->GetOrigin()[0] + inExtent[1]*image->GetSpacing()[0] ) - overlay->GetOrigin()[0]) /
 282                  overlay->GetSpacing()[0];
 283   outExtent[2] = (( image->GetOrigin()[1] + inExtent[2]*image->GetSpacing()[1] ) - overlay->GetOrigin()[1]) /
 284                  overlay->GetSpacing()[1];
 285   outExtent[3] = (( image->GetOrigin()[1] + inExtent[3]*image->GetSpacing()[1] ) - overlay->GetOrigin()[1]) /
 286                  overlay->GetSpacing()[1];
 287   outExtent[4] = (( image->GetOrigin()[2] + inExtent[4]*image->GetSpacing()[2] ) - overlay->GetOrigin()[2]) /
 288                  overlay->GetSpacing()[2];
 289   outExtent[5] = (( image->GetOrigin()[2] + inExtent[5]*image->GetSpacing()[2] ) - overlay->GetOrigin()[2]) /
 290                  overlay->GetSpacing()[2];
 291 }
 292 //----------------------------------------------------------------------------
 293
 294
 295 //------------------------------------------------------------------------------
 296 void vvBinaryImageOverlayActor::SetDisplayExtentAndCameraPosition(int orientation,
 297                                                                   int slice,
 298                                                                   int * extent,
 299                                                                   vtkImageActor * actor,
 300                                                                   double position)
 301 {
 302   // Set position
 303   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_XY) {
 304     if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[2] > slice)
 305       actor->SetPosition(0,0, position);
 306     else
 307       actor->SetPosition(0,0, -position);
 308   }
 309   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_XZ) {
 310     if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[1] > slice)
 311       actor->SetPosition(0,position,0);
 312     else
 313       actor->SetPosition(0,-position,0);
 314   }
 315   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_YZ) {
 316     if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[0] > slice)
 317       actor->SetPosition(position,0, 0);
 318     else
 319       actor->SetPosition(-position,0, 0);
 320   }
 321   actor->SetDisplayExtent(extent);
 322 }
 323 //------------------------------------------------------------------------------
 324