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 //EED 2017-01-01 Migration VTK7
  92 #if VTK_MAJOR_VERSION <= 5
  93                         resample->SetInput(_image1);
  94 #else
  95                         resample->SetInputData(_image1);
  96 #endif
  97                         factorX = (double)extImg2[1]/extImg1[1];
  98                         factorY = (double)extImg2[3]/extImg1[3];
  99                         resample->SetAxisMagnificationFactor(0,factorX);
 100                         resample->SetAxisMagnificationFactor(1,factorY);
 101                         resample->SetInformationInput(_image2);
 102
 103                         initialize(dimImg2, spcImg2);
 104 //EED 2017-01-01 Migration VTK7
 105 #if VTK_MAJOR_VERSION <= 5
 106                         //..
 107 #else
 108                         resample->Update();
 109 #endif
 110
 111                         result = resample->GetOutput();
 112 //EED 2017-01-01 Migration VTK7
 113 #if VTK_MAJOR_VERSION <= 5
 114                         result->Update();
 115 #else
 116                         //...
 117 #endif
 118                         createImage(result,_image2,dimImg2[0],dimImg2[1]);
 119
 120                 } //if
 121                 else if (numPixelsImg1>numPixelsImg2)
 122                 {
 123 //EED 2017-01-01 Migration VTK7
 124 #if VTK_MAJOR_VERSION <= 5
 125                         resample->SetInput(_image2);
 126 #else
 127                         resample->SetInputData(_image2);
 128 #endif
 129                         factorX = (double)extImg1[1]/extImg2[1];
 130                         factorY = (double)extImg1[3]/extImg2[3];
 131                         resample->SetAxisMagnificationFactor(0,factorX);
 132                         resample->SetAxisMagnificationFactor(1,factorY);
 133                         resample->SetInformationInput(_image1);
 134
 135                         initialize(dimImg1, spcImg1);
 136
 137 //EED 2017-01-01 Migration VTK7
 138 #if VTK_MAJOR_VERSION <= 5
 139                         // ...
 140 #else
 141                         resample->Update();
 142 #endif
 143                         result = resample->GetOutput();
 144
 145 //EED 2017-01-01 Migration VTK7
 146 #if VTK_MAJOR_VERSION <= 5
 147                         result->Update();
 148 #else
 149                         result->Modified();
 150 #endif
 151
 152                         createImage(_image1,result,dimImg1[0],dimImg1[1]);
 153                 } // else if
 154                 else
 155                 {
 156                         //If both images have the same number of pixels, the resultant image will have the
 157                         //properties of the first image.
 158 //EED 2017-01-01 Migration VTK7
 159 #if VTK_MAJOR_VERSION <= 5
 160                         resample->SetInput(_image2);
 161 #else
 162                         resample->SetInputData(_image2);
 163 #endif
 164                         factorX = (double)extImg1[1]/extImg2[1];
 165                         factorY = (double)extImg1[3]/extImg2[3];
 166                         resample->SetAxisMagnificationFactor(0,factorX);
 167                         resample->SetAxisMagnificationFactor(1,factorY);
 168                         resample->SetInformationInput(_image1);
 169                         initialize(dimImg1, spcImg1);
 170 //EED 2017-01-01 Migration VTK7
 171 #if VTK_MAJOR_VERSION <= 5
 172                         // ...
 173 #else
 174                         resample->Update();
 175 #endif
 176
 177                         result = resample->GetOutput();
 178
 179 //EED 2017-01-01 Migration VTK7
 180 #if VTK_MAJOR_VERSION <= 5
 181                         result->Update();
 182 #else
 183                         result->Modified();
 184 #endif
 185
 186                         createImage(_image1,result,dimImg1[0],dimImg1[1]);
 187
 188                 } //else
 189
 190                 resample->Delete();
 191                 _processed=true;
 192         }
 193 }
 194
 195 void Transparency::initialize(int dimensions[], double spacing[])
 196 {
 197         // Setting the new image
 198         _newImage = vtkImageData::New();
 199         _newImage->SetSpacing(spacing);
 200         _newImage->SetDimensions(dimensions);
 201 //EED 2017-01-01 Migration VTK7
 202 #if VTK_MAJOR_VERSION <= 5
 203         _newImage->SetScalarType(_type);
 204         _newImage->AllocateScalars();
 205         _newImage->Update();
 206 #else
 207         _newImage->AllocateScalars(_type,1);
 208 #endif
 209
 210
 211 }
 212
 213 void Transparency::createImage(vtkImageData *img1, vtkImageData *img2, int sizeX, int sizeY)
 214 {
 215 //      int i, j;  EED ???
 216
 217         if(_type == VTK_CHAR)
 218         {
 219                 //POINTERS:
 220                 char* dataImagePointer1 = NULL;
 221                 char* dataImagePointer2 = NULL;
 222                 char* dataImageResultPointer = NULL;
 223
 224                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 225         }
 226         else if(_type == VTK_SIGNED_CHAR)
 227         {
 228                 //POINTERS:
 229                 signed char* dataImagePointer1 = NULL;
 230                 signed char* dataImagePointer2 = NULL;
 231                 signed char* dataImageResultPointer = NULL;
 232
 233                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 234         }
 235         else if(_type == VTK_UNSIGNED_CHAR)
 236         {
 237                 //POINTERS:
 238                 unsigned char* dataImagePointer1 = NULL;
 239                 unsigned char* dataImagePointer2 = NULL;
 240                 unsigned char* dataImageResultPointer = NULL;
 241
 242                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 243         }
 244         else if(_type == VTK_SHORT)
 245         {
 246                 //POINTERS:
 247                 short* dataImagePointer1 = NULL;
 248                 short* dataImagePointer2 = NULL;
 249                 short* dataImageResultPointer = NULL;
 250
 251                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 252         }
 253         else if(_type == VTK_UNSIGNED_SHORT)
 254         {
 255                 //POINTERS:
 256                 unsigned short* dataImagePointer1 = NULL;
 257                 unsigned short* dataImagePointer2 = NULL;
 258                 unsigned short* dataImageResultPointer = NULL;
 259
 260                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 261         }
 262         else if(_type == VTK_INT)
 263         {
 264                 //POINTERS:
 265                 int* dataImagePointer1 = NULL;
 266                 int* dataImagePointer2 = NULL;
 267                 int* dataImageResultPointer = NULL;
 268
 269                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 270         }
 271         else if(_type == VTK_UNSIGNED_INT)
 272         {
 273                 //POINTERS:
 274                 unsigned int* dataImagePointer1 = NULL;
 275                 unsigned int* dataImagePointer2 = NULL;
 276                 unsigned int* dataImageResultPointer = NULL;
 277
 278                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 279         }
 280         else if(_type == VTK_LONG)
 281         {
 282                 //POINTERS:
 283                 long* dataImagePointer1 = NULL;
 284                 long* dataImagePointer2 = NULL;
 285                 long* dataImageResultPointer = NULL;
 286
 287                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 288         }
 289         else if(_type == VTK_UNSIGNED_LONG)
 290         {
 291                 //POINTERS:
 292                 unsigned long* dataImagePointer1 = NULL;
 293                 unsigned long* dataImagePointer2 = NULL;
 294                 unsigned long* dataImageResultPointer = NULL;
 295
 296                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 297         }
 298         else if(_type == VTK_FLOAT)
 299         {
 300                 //POINTERS:
 301                 float* dataImagePointer1 = NULL;
 302                 float* dataImagePointer2 = NULL;
 303                 float* dataImageResultPointer = NULL;
 304
 305                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 306         }
 307         else if(_type == VTK_DOUBLE)
 308         {
 309                 //POINTERS:
 310                 double* dataImagePointer1 = NULL;
 311                 double* dataImagePointer2 = NULL;
 312                 double* dataImageResultPointer = NULL;
 313
 314                 createImageByType(dataImagePointer1, dataImagePointer2, dataImageResultPointer, img1, img2, sizeX, sizeY);
 315         }
 316
 317 //EED 2017-01-01 Migration VTK7
 318 #if VTK_MAJOR_VERSION <= 5
 319         _newImage->Update();
 320 #else
 321         _newImage->Modified();
 322 #endif
 323
 324
 325 }
 326
 327 template <class T>
 328 void Transparency::createImageByType(T* dataImagePointer1, T* dataImagePointer2, T* dataImageResultPointer, vtkImageData *img1, vtkImageData *img2, int sizeX, int sizeY)
 329 {
 330         int i, j;
 331
 332         dataImagePointer1 = (T*) img1->GetScalarPointer(0,0,0);
 333         dataImagePointer2 = (T*) img2->GetScalarPointer(0,0,0);
 334         dataImageResultPointer = (T*) _newImage->GetScalarPointer(0,0,0);
 335         for(i = 0; i < sizeX; i++)
 336         {
 337                 for(j = 0; j < sizeY; j++)
 338                 {
 339                         dataImagePointer1 = (T*)img1->GetScalarPointer(i,j,0);
 340                         dataImagePointer2 = (T*)img2->GetScalarPointer(i,j,0);
 341                         dataImageResultPointer = (T*)_newImage->GetScalarPointer(i,j,0);
 342
 343                         *dataImageResultPointer = (T)*dataImagePointer1*_percent + (T)*dataImagePointer2*(1-_percent);
 344                 }
 345         }
 346 }
 347
 348 /*
 349 * Get new image
 350 */
 351 //------------------------------------------------------------
 352 vtkImageData* Transparency::getImage()
 353 {
 354         if(_processed){
 355                 return _newImage;
 356         }
 357         else{
 358                 return NULL;
 359         }
 360 }
 361
 362 //------------------------------------------------------------
 363 void Transparency::setImage1(vtkImageData *image)
 364 {
 365         _image1=image;
 366 }
 367
 368 //------------------------------------------------------------
 369 void Transparency::setImage2(vtkImageData *image)
 370 {
 371         _image2=image;
 372 }
 373
 374 //------------------------------------------------------------
 375 void Transparency::setPercent(int percent)
 376 {
 377     _percent=(double)percent/100.0;
 378 }
 379