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