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