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     DD(numImage);
  86
  87     // how many intensity ?
  88     vtkImageMapToRGBA * mOverlayMapper = vtkImageMapToRGBA::New();
  89     mOverlayMapper->SetInput(mImage->GetVTKImages()[0]); // DS TODO : to change if it is 4D !!!
  90     DD(mColorLUT->IsOpaque ());
  91     mColorLUT->SetRange(0,1);
  92     mColorLUT->SetNumberOfTableValues(2);
  93     mColorLUT->SetTableValue(mBackgroundValue, 0, 0, 0, 0.0);   // BG
  94     mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
  95     DD(mColor[0]);
  96     mOverlayMapper->SetLookupTable(mColorLUT);
  97
  98     vtkImageActor * mOverlayActor = vtkImageActor::New();
  99     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 100     mOverlayActor->SetPickable(0);
 101     mOverlayActor->SetVisibility(true);
 102     //mOverlayActor->SetOpacity(1.0);
 103
 104     mMapperList.push_back(mOverlayMapper);
 105     mImageActorList.push_back(mOverlayActor);
 106     mSlicer->GetRenderer()->AddActor(mOverlayActor);
 107   }
 108 }
 109 //------------------------------------------------------------------------------
 110
 111
 112 //------------------------------------------------------------------------------
 113 void vvBinaryImageOverlayActor::SetOpacity(double d) {
 114   mAlpha = d;
 115   mColorLUT->SetTableValue(1, mColor[0], mColor[1], mColor[2], mAlpha); // FG
 116   for (unsigned int numImage = 0; numImage < mSlicer->GetImage()->GetVTKImages().size(); numImage++) {
 117     DD(numImage);
 118
 119     // how many intensity ?
 120     vtkImageMapToRGBA * mOverlayMapper = mMapperList[numImage];
 121     mOverlayMapper->SetLookupTable(mColorLUT);
 122
 123     vtkImageActor * mOverlayActor = mImageActorList[numImage];
 124     mOverlayActor->SetInput(mOverlayMapper->GetOutput());
 125     //mOverlayActor->SetPickable(0);
 126     //    mOverlayActor->SetVisibility(true);
 127     //mOverlayActor->SetOpacity(1.0);
 128   }
 129   DD("end SetOpacity");
 130 }
 131 //------------------------------------------------------------------------------
 132
 133
 134 //------------------------------------------------------------------------------
 135 void vvBinaryImageOverlayActor::setImage(vvImage::Pointer image, double bg) {
 136   mImage = image;
 137   mBackgroundValue = bg;
 138 }
 139 //------------------------------------------------------------------------------
 140
 141
 142 //------------------------------------------------------------------------------
 143 void vvBinaryImageOverlayActor::hideActors() {
 144   if (!mSlicer) return;
 145   mSlice = mSlicer->GetSlice();
 146   for(unsigned int i=0; i<mImageActorList.size(); i++) {
 147     mImageActorList[i]->VisibilityOff();
 148   }
 149 }
 150 //------------------------------------------------------------------------------
 151
 152
 153 //------------------------------------------------------------------------------
 154 void vvBinaryImageOverlayActor::showActors() {
 155   if (!mSlicer) return;
 156   mSlice = mSlicer->GetSlice();
 157   mTSlice = mSlicer->GetTSlice();
 158   //  for(unsigned int i=0; i<mSquaresActorList.size(); i++) {
 159   mImageActorList[mTSlice]->VisibilityOn();
 160   update(0, mSlice);
 161   //}
 162 }
 163 //------------------------------------------------------------------------------
 164
 165
 166 //------------------------------------------------------------------------------
 167 void vvBinaryImageOverlayActor::update(int slicer, int slice) {
 168   if (!mSlicer) return;
 169
 170   if (mPreviousSlice == mSlicer->GetSlice()) {
 171     if (mPreviousTSlice == mSlicer->GetTSlice()) {
 172       //DD("=========== NOTHING");
 173       return; // Nothing to do
 174     }
 175   }
 176
 177   // Get current slice
 178   mSlice = mSlicer->GetSlice();
 179   mTSlice = mSlicer->GetTSlice();
 180
 181   // Update extent
 182   int * imageExtent = mSlicer->GetExtent();
 183   int orientation = mSlicer->GetOrientation();
 184   int maskExtent[6];
 185   ComputeExtent(orientation, mSlice, imageExtent, maskExtent);
 186   //ComputeExtent(imageExtent, maskExtent, mSlicer->GetImage()->GetFirstVTKImageData(), mImage->GetFirstVTKImageData());
 187   ComputeExtent(maskExtent, maskExtent, mSlicer->GetImage()->GetFirstVTKImageData(), mImage->GetFirstVTKImageData());
 188   // std::cout << "maskExtent = " << maskExtent[0] << " " << maskExtent[1] << " " << maskExtent[2] << " "
 189   //        << maskExtent[3] << " " << maskExtent[4] << " " << maskExtent[5] << std::endl;
 190   mSlicer->ClipDisplayedExtent(maskExtent, mMapperList[mTSlice]->GetInput()->GetWholeExtent());
 191   // std::cout << "maskExtent = " << maskExtent[0] << " " << maskExtent[1] << " " << maskExtent[2] << " "
 192   //        << maskExtent[3] << " " << maskExtent[4] << " " << maskExtent[5] << std::endl;
 193   SetDisplayExtentAndCameraPosition(orientation, mSlice, maskExtent, mImageActorList[mTSlice], 0.0);
 194
 195   // set previous slice
 196   mPreviousTSlice = mSlicer->GetTSlice();
 197   mPreviousSlice  = mSlicer->GetSlice();
 198 }
 199 //------------------------------------------------------------------------------
 200
 201
 202 //------------------------------------------------------------------------------
 203 void vvBinaryImageOverlayActor::ComputeExtent(int orientation,
 204                                               int slice,
 205                                               int * inExtent,
 206                                               int * outExtent) {
 207   //  std::cout << "InExtent = " << inExtent[0] << " " << inExtent[1] << " " << inExtent[2] << " "
 208   //        << inExtent[3] << " " << inExtent[4] << " " << inExtent[5] << std::endl;
 209   //  DD(orientation);
 210   switch (orientation) {
 211   case vtkImageViewer2::SLICE_ORIENTATION_XY:
 212     for(int i=0; i<4; i++) outExtent[i] = inExtent[i];
 213     outExtent[4] = outExtent[5] = slice;
 214     break;
 215   case vtkImageViewer2::SLICE_ORIENTATION_XZ:
 216     for(int i=0; i<2; i++) outExtent[i] = inExtent[i];
 217     for(int i=4; i<6; i++) outExtent[i] = inExtent[i];
 218     outExtent[2] = outExtent[3] = slice;
 219     break;
 220   case vtkImageViewer2::SLICE_ORIENTATION_YZ:
 221     for(int i=2; i<6; i++) outExtent[i] = inExtent[i];
 222     outExtent[0] = outExtent[1] = slice;
 223     break;
 224   }
 225   // std::cout << "OutExtent = " << outExtent[0] << " " << outExtent[1] << " " << outExtent[2] << " "
 226   //        << outExtent[3] << " " << outExtent[4] << " " << outExtent[5] << std::endl;
 227 }
 228 //------------------------------------------------------------------------------
 229
 230
 231 //----------------------------------------------------------------------------
 232 void vvBinaryImageOverlayActor::ComputeExtent(int * inExtent, int * outExtent, vtkImageData * image, vtkImageData * overlay)
 233 {
 234   outExtent[0] = (( image->GetOrigin()[0] + inExtent[0]*image->GetSpacing()[0] ) - overlay->GetOrigin()[0]) /
 235     overlay->GetSpacing()[0];
 236   outExtent[1] = (( image->GetOrigin()[0] + inExtent[1]*image->GetSpacing()[0] ) - overlay->GetOrigin()[0]) /
 237     overlay->GetSpacing()[0];
 238   outExtent[2] = (( image->GetOrigin()[1] + inExtent[2]*image->GetSpacing()[1] ) - overlay->GetOrigin()[1]) /
 239     overlay->GetSpacing()[1];
 240   outExtent[3] = (( image->GetOrigin()[1] + inExtent[3]*image->GetSpacing()[1] ) - overlay->GetOrigin()[1]) /
 241     overlay->GetSpacing()[1];
 242   outExtent[4] = (( image->GetOrigin()[2] + inExtent[4]*image->GetSpacing()[2] ) - overlay->GetOrigin()[2]) /
 243     overlay->GetSpacing()[2];
 244   outExtent[5] = (( image->GetOrigin()[2] + inExtent[5]*image->GetSpacing()[2] ) - overlay->GetOrigin()[2]) /
 245     overlay->GetSpacing()[2];
 246 }
 247 //----------------------------------------------------------------------------
 248
 249
 250 //------------------------------------------------------------------------------
 251 void vvBinaryImageOverlayActor::SetDisplayExtentAndCameraPosition(int orientation,
 252                                                                   int slice,
 253                                                                   int * extent,
 254                                                                   vtkImageActor * actor,
 255                                                                   double position) {
 256   actor->SetDisplayExtent(extent);
 257
 258   // Set position
 259   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_XY) {
 260     if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[2] > slice)
 261       actor->SetPosition(0,0, position);
 262     else
 263       actor->SetPosition(0,0, -position);
 264   }
 265   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_XZ) {
 266     if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[1] > slice)
 267       actor->SetPosition(0,position,0);
 268     else
 269       actor->SetPosition(0,-position,0);
 270   }
 271   if (orientation == vtkImageViewer2::SLICE_ORIENTATION_YZ) {
 272     if (mSlicer->GetRenderer()->GetActiveCamera()->GetPosition()[0] > slice)
 273       actor->SetPosition(position,0, 0);
 274     else
 275       actor->SetPosition(-position,0, 0);
 276   }
 277
 278 }
 279 //------------------------------------------------------------------------------
 280
 281
 282
 283