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