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