lib/Transparency.cxx

   1 /*
   2 # ---------------------------------------------------------------------
   3 #
   4 # Copyright (c) CREATIS (Centre de Recherche en Acquisition et Traitement de l'Image
   5 #                        pour la Santé)
   6 # Authors : Eduardo Davila, Frederic Cervenansky, Claire Mouton
   7 # Previous Authors : Laurent Guigues, Jean-Pierre Roux
   8 # CreaTools website : www.creatis.insa-lyon.fr/site/fr/creatools_accueil
   9 #
  10 #  This software is governed by the CeCILL-B license under French law and
  11 #  abiding by the rules of distribution of free software. You can  use,
  12 #  modify and/ or redistribute the software under the terms of the CeCILL-B
  13 #  license as circulated by CEA, CNRS and INRIA at the following URL
  14 #  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  15 #  or in the file LICENSE.txt.
  16 #
  17 #  As a counterpart to the access to the source code and  rights to copy,
  18 #  modify and redistribute granted by the license, users are provided only
  19 #  with a limited warranty  and the software's author,  the holder of the
  20 #  economic rights,  and the successive licensors  have only  limited
  21 #  liability.
  22 #
  23 #  The fact that you are presently reading this means that you have had
  24 #  knowledge of the CeCILL-B license and that you accept its terms.
  25 # ------------------------------------------------------------------------      */
  26
  27 #include "Transparency.h"
  28
  29
  30 /*
  31 * Constructor
  32 */
  33 //------------------------------------------------------------
  34 Transparency::Transparency()
  35 {
  36         _image1=NULL;
  37         _image2=NULL;
  38         _percent=0;
  39         _newImage = NULL;
  40         _processed=false;
  41 }
  42
  43 /*
  44 * Destructor
  45 */
  46 //------------------------------------------------------------
  47 Transparency::~Transparency()
  48 {
  49         if (_newImage != NULL ) { _newImage->Delete(); }
  50 }
  51
  52 //------------------------------------------------------------
  53 void Transparency::calculateImage()
  54 {
  55
  56         if(_image1!=NULL && _image2!=NULL)
  57         {
  58
  59                 // IMAGE 1
  60
  61                 // Information from image1
  62                 _image1->GetSpacing(spcImg1);
  63                 _image1->GetExtent(extImg1);
  64                 _type = _image1->GetScalarType();
  65
  66                 // The Z dimension is 1 for a 2D image
  67                 dimImg1[0] = extImg1[1] - extImg1[0]+1;
  68                 dimImg1[1] = extImg1[3] - extImg1[2]+1;
  69                 dimImg1[2] = 1;
  70
  71                 //IMAGE 2
  72
  73                 // Information from image2
  74                 _image2->GetSpacing(spcImg2);
  75                 _image2->GetExtent(extImg2);
  76
  77                 // The Z dimension is 1 for a 2D image
  78                 dimImg2[0] = extImg2[1] - extImg2[0]+1;
  79                 dimImg2[1] = extImg2[3] - extImg2[2]+1;
  80                 dimImg2[2] = 1;
  81
  82                 long numPixelsImg1 = dimImg1[0]*dimImg1[1];
  83                 long numPixelsImg2 = dimImg2[0]*dimImg2[1];
  84
  85                 double factorX = 1;
  86                 double factorY = 1;
  87                 vtkImageResample *resample = vtkImageResample::New();
  88                 vtkImageData *result;
  89                 if(numPixelsImg1<numPixelsImg2)
  90                 {
  91                         resample->SetInput(_image1);
  92                         factorX = (double)extImg2[1]/extImg1[1];
  93                         factorY = (double)extImg2[3]/extImg1[3];
  94                         resample->SetAxisMagnificationFactor(0,factorX);
  95                         resample->SetAxisMagnificationFactor(1,factorY);
  96                         resample->SetInformationInput(_image2);
  97
  98                         initialize(dimImg2, spcImg2);
  99                         result = resample->GetOutput();
 100                         result->Update();
 101                         createImage(result,_image2,dimImg2[0],dimImg2[1]);
 102
 103                 } //if
 104                 else if (numPixelsImg1>numPixelsImg2)
 105                 {
 106                         resample->SetInput(_image2);
 107                         factorX = (double)extImg1[1]/extImg2[1];
 108                         factorY = (double)extImg1[3]/extImg2[3];
 109                         resample->SetAxisMagnificationFactor(0,factorX);
 110                         resample->SetAxisMagnificationFactor(1,factorY);
 111                         resample->SetInformationInput(_image1);
 112
 113                         initialize(dimImg1, spcImg1);
 114                         result = resample->GetOutput();
 115
 116                         result->Update();
 117
 118                         createImage(_image1,result,dimImg1[0],dimImg1[1]);
 119                 } // else if
 120                 else
 121                 {
 122                         //If both images have the same number of pixels, the resultant image will have the
 123                         //properties of the first image.
 124                         resample->SetInput(_image2);
 125                         factorX = (double)extImg1[1]/extImg2[1];
 126                         factorY = (double)extImg1[3]/extImg2[3];
 127                         resample->SetAxisMagnificationFactor(0,factorX);
 128                         resample->SetAxisMagnificationFactor(1,factorY);
 129                         resample->SetInformationInput(_image1);
 130
 131                         initialize(dimImg1, spcImg1);
 132
 133                         result = resample->GetOutput();
 134                         result->Update();
 135
 136                         createImage(_image1,result,dimImg1[0],dimImg1[1]);
 137
 138                 } //else
 139
 140                 resample->Delete();
 141                 _processed=true;
 142         }
 143 }
 144
 145 void Transparency::initialize(int dimensions[], double spacing[])
 146 {
 147         // Setting the new image
 148         _newImage = vtkImageData::New();
 149         _newImage->SetScalarType(_type);
 150         _newImage->SetSpacing(spacing);
 151         _newImage->SetDimensions(dimensions);
 152         _newImage->AllocateScalars();
 153         _newImage->Update();
 154
 155 }
 156
 157 void Transparency::createImage(vtkImageData *img1, vtkImageData *img2, int sizeX, int sizeY)
 158 {
 159 //      int i, j;  EED ???
 160
 161         if(_type == VTK_CHAR)
 162         {
 163                 //POINTERS:
 164                 char* dataImagePointer1 = NULL;
 165                 char* dataImagePointer2 = NULL;
 166                 char* dataImageResultPointer = NULL;
 167
 168                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 169         }
 170         else if(_type == VTK_SIGNED_CHAR)
 171         {
 172                 //POINTERS:
 173                 signed char* dataImagePointer1 = NULL;
 174                 signed char* dataImagePointer2 = NULL;
 175                 signed char* dataImageResultPointer = NULL;
 176
 177                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 178         }
 179         else if(_type == VTK_UNSIGNED_CHAR)
 180         {
 181                 //POINTERS:
 182                 unsigned char* dataImagePointer1 = NULL;
 183                 unsigned char* dataImagePointer2 = NULL;
 184                 unsigned char* dataImageResultPointer = NULL;
 185
 186                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 187         }
 188         else if(_type == VTK_SHORT)
 189         {
 190                 //POINTERS:
 191                 short* dataImagePointer1 = NULL;
 192                 short* dataImagePointer2 = NULL;
 193                 short* dataImageResultPointer = NULL;
 194
 195                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 196         }
 197         else if(_type == VTK_UNSIGNED_SHORT)
 198         {
 199                 //POINTERS:
 200                 unsigned short* dataImagePointer1 = NULL;
 201                 unsigned short* dataImagePointer2 = NULL;
 202                 unsigned short* dataImageResultPointer = NULL;
 203
 204                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 205         }
 206         else if(_type == VTK_INT)
 207         {
 208                 //POINTERS:
 209                 int* dataImagePointer1 = NULL;
 210                 int* dataImagePointer2 = NULL;
 211                 int* dataImageResultPointer = NULL;
 212
 213                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 214         }
 215         else if(_type == VTK_UNSIGNED_INT)
 216         {
 217                 //POINTERS:
 218                 unsigned int* dataImagePointer1 = NULL;
 219                 unsigned int* dataImagePointer2 = NULL;
 220                 unsigned int* dataImageResultPointer = NULL;
 221
 222                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 223         }
 224         else if(_type == VTK_LONG)
 225         {
 226                 //POINTERS:
 227                 long* dataImagePointer1 = NULL;
 228                 long* dataImagePointer2 = NULL;
 229                 long* dataImageResultPointer = NULL;
 230
 231                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 232         }
 233         else if(_type == VTK_UNSIGNED_LONG)
 234         {
 235                 //POINTERS:
 236                 unsigned long* dataImagePointer1 = NULL;
 237                 unsigned long* dataImagePointer2 = NULL;
 238                 unsigned long* dataImageResultPointer = NULL;
 239
 240                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 241         }
 242         else if(_type == VTK_FLOAT)
 243         {
 244                 //POINTERS:
 245                 float* dataImagePointer1 = NULL;
 246                 float* dataImagePointer2 = NULL;
 247                 float* dataImageResultPointer = NULL;
 248
 249                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 250         }
 251         else if(_type == VTK_DOUBLE)
 252         {
 253                 //POINTERS:
 254                 double* dataImagePointer1 = NULL;
 255                 double* dataImagePointer2 = NULL;
 256                 double* dataImageResultPointer = NULL;
 257
 258                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 259         }
 260
 261         _newImage->Update();
 262 }
 263
 264 template <class T>
 265 void Transparency::createImageByType(T* dataImagePointer1, T* dataImagePointer2, T* dataImageResultPointer, vtkImageData *img1, vtkImageData *img2, int sizeX, int sizeY)
 266 {
 267         int i, j;
 268
 269         dataImagePointer1 = (T*) img1->GetScalarPointer(0,0,0);
 270         dataImagePointer2 = (T*) img2->GetScalarPointer(0,0,0);
 271         dataImageResultPointer = (T*) _newImage->GetScalarPointer(0,0,0);
 272         for(i = 0; i < sizeX; i++)
 273         {
 274                 for(j = 0; j < sizeY; j++)
 275                 {
 276                         dataImagePointer1 = (T*)img1->GetScalarPointer(i,j,0);
 277                         dataImagePointer2 = (T*)img2->GetScalarPointer(i,j,0);
 278                         dataImageResultPointer = (T*)_newImage->GetScalarPointer(i,j,0);
 279
 280                         *dataImageResultPointer = (T)*dataImagePointer1*_percent + (T)*dataImagePointer2*(1-_percent);
 281                 }
 282         }
 283 }
 284
 285 /*
 286 * Get new image
 287 */
 288 //------------------------------------------------------------
 289 vtkImageData* Transparency::getImage()
 290 {
 291         if(_processed){
 292                 return _newImage;
 293         }
 294         else{
 295                 return NULL;
 296         }
 297 }
 298
 299 //------------------------------------------------------------
 300 void Transparency::setImage1(vtkImageData *image)
 301 {
 302         _image1=image;
 303 }
 304
 305 //------------------------------------------------------------
 306 void Transparency::setImage2(vtkImageData *image)
 307 {
 308         _image2=image;
 309 }
 310
 311 //------------------------------------------------------------
 312 void Transparency::setPercent(int percent)
 313 {
 314     _percent=(double)percent/100.0;
 315 }
 316