lib/Transparency.cxx

   1 #include "Transparency.h"
   2
   3
   4 /*
   5 * Constructor
   6 */
   7 //------------------------------------------------------------
   8 Transparency::Transparency()
   9 {
  10         _image1=NULL;
  11         _image2=NULL;
  12         _percent=0;
  13         _newImage = NULL;
  14         _processed=false;
  15 }
  16
  17 /*
  18 * Destructor
  19 */
  20 //------------------------------------------------------------
  21 Transparency::~Transparency()
  22 {
  23         if (_newImage != NULL ) { _newImage->Delete(); }
  24 }
  25
  26 //------------------------------------------------------------
  27 void Transparency::calculateImage()
  28 {
  29
  30         if(_image1!=NULL && _image2!=NULL)
  31         {
  32
  33                 // IMAGE 1
  34
  35                 // Information from image1
  36                 _image1->GetSpacing(spcImg1);
  37                 _image1->GetExtent(extImg1);
  38                 _type = _image1->GetScalarType();
  39
  40                 // The Z dimension is 1 for a 2D image
  41                 dimImg1[0] = extImg1[1] - extImg1[0]+1;
  42                 dimImg1[1] = extImg1[3] - extImg1[2]+1;
  43                 dimImg1[2] = 1;
  44
  45                 //IMAGE 2
  46
  47                 // Information from image2
  48                 _image2->GetSpacing(spcImg2);
  49                 _image2->GetExtent(extImg2);
  50
  51                 // The Z dimension is 1 for a 2D image
  52                 dimImg2[0] = extImg2[1] - extImg2[0]+1;
  53                 dimImg2[1] = extImg2[3] - extImg2[2]+1;
  54                 dimImg2[2] = 1;
  55
  56                 long numPixelsImg1 = dimImg1[0]*dimImg1[1];
  57                 long numPixelsImg2 = dimImg2[0]*dimImg2[1];
  58
  59                 double factorX = 1;
  60                 double factorY = 1;
  61                 vtkImageResample *resample = vtkImageResample::New();
  62                 vtkImageData *result;
  63                 if(numPixelsImg1<numPixelsImg2)
  64                 {
  65                         resample->SetInput(_image1);
  66                         factorX = (double)extImg2[1]/extImg1[1];
  67                         factorY = (double)extImg2[3]/extImg1[3];
  68                         resample->SetAxisMagnificationFactor(0,factorX);
  69                         resample->SetAxisMagnificationFactor(1,factorY);
  70                         resample->SetInformationInput(_image2);
  71
  72                         initialize(dimImg2, spcImg2);
  73                         result = resample->GetOutput();
  74                         result->Update();
  75                         createImage(result,_image2,dimImg2[0],dimImg2[1]);
  76
  77                 } //if
  78                 else if (numPixelsImg1>numPixelsImg2)
  79                 {
  80                         resample->SetInput(_image2);
  81                         factorX = (double)extImg1[1]/extImg2[1];
  82                         factorY = (double)extImg1[3]/extImg2[3];
  83                         resample->SetAxisMagnificationFactor(0,factorX);
  84                         resample->SetAxisMagnificationFactor(1,factorY);
  85                         resample->SetInformationInput(_image1);
  86
  87                         initialize(dimImg1, spcImg1);
  88                         result = resample->GetOutput();
  89
  90                         result->Update();
  91
  92                         createImage(_image1,result,dimImg1[0],dimImg1[1]);
  93                 } // else if
  94                 else
  95                 {
  96                         //If both images have the same number of pixels, the resultant image will have the
  97                         //properties of the first image.
  98                         resample->SetInput(_image2);
  99                         factorX = (double)extImg1[1]/extImg2[1];
 100                         factorY = (double)extImg1[3]/extImg2[3];
 101                         resample->SetAxisMagnificationFactor(0,factorX);
 102                         resample->SetAxisMagnificationFactor(1,factorY);
 103                         resample->SetInformationInput(_image1);
 104
 105                         initialize(dimImg1, spcImg1);
 106
 107                         result = resample->GetOutput();
 108                         result->Update();
 109
 110                         createImage(_image1,result,dimImg1[0],dimImg1[1]);
 111
 112                 } //else
 113
 114                 resample->Delete();
 115                 _processed=true;
 116         }
 117 }
 118
 119 void Transparency::initialize(int dimensions[], double spacing[])
 120 {
 121         // Setting the new image
 122         _newImage = vtkImageData::New();
 123         _newImage->SetScalarType(_type);
 124         _newImage->SetSpacing(spacing);
 125         _newImage->SetDimensions(dimensions);
 126         _newImage->AllocateScalars();
 127         _newImage->Update();
 128
 129 }
 130
 131 void Transparency::createImage(vtkImageData *img1, vtkImageData *img2, int sizeX, int sizeY)
 132 {
 133         int i, j;
 134         if(_type == VTK_CHAR)
 135         {
 136                 //POINTERS:
 137                 char* dataImagePointer1 = NULL;
 138                 char* dataImagePointer2 = NULL;
 139                 char* dataImageResultPointer = NULL;
 140
 141                 dataImagePointer1 = (char*) img1->GetScalarPointer(0,0,0);
 142                 dataImagePointer2 = (char*) img2->GetScalarPointer(0,0,0);
 143                 dataImageResultPointer = (char*) _newImage->GetScalarPointer(0,0,0);
 144                 for(i = 0; i < sizeX; i++)
 145                 {
 146                         for(j = 0; j < sizeY; j++)
 147                         {
 148                                 dataImagePointer1 = (char*)img1->GetScalarPointer(i,j,0);
 149                                 dataImagePointer2 = (char*)img2->GetScalarPointer(i,j,0);
 150                                 dataImageResultPointer = (char*)_newImage->GetScalarPointer(i,j,0);
 151
 152                                 *dataImageResultPointer = (char)*dataImagePointer1*_percent + (char)*dataImagePointer2*(1-_percent);
 153                         }
 154                 }
 155         }
 156         else if(_type == VTK_SIGNED_CHAR)
 157         {
 158                 //POINTERS:
 159                 signed char* dataImagePointer1 = NULL;
 160                 signed char* dataImagePointer2 = NULL;
 161                 signed char* dataImageResultPointer = NULL;
 162
 163                 dataImagePointer1 = (signed char*) img1->GetScalarPointer(0,0,0);
 164                 dataImagePointer2 = (signed char*) img2->GetScalarPointer(0,0,0);
 165                 dataImageResultPointer = (signed char*) _newImage->GetScalarPointer(0,0,0);
 166                 for(i = 0; i < sizeX; i++)
 167                 {
 168                         for(j = 0; j < sizeY; j++)
 169                         {
 170                                 dataImagePointer1 = (signed char*)img1->GetScalarPointer(i,j,0);
 171                                 dataImagePointer2 = (signed char*)img2->GetScalarPointer(i,j,0);
 172                                 dataImageResultPointer = (signed char*)_newImage->GetScalarPointer(i,j,0);
 173
 174                                 *dataImageResultPointer = (signed char)*dataImagePointer1*_percent + (signed char)*dataImagePointer2*(1-_percent);
 175                         }
 176                 }
 177         }
 178         else if(_type == VTK_UNSIGNED_CHAR)
 179         {
 180                 //POINTERS:
 181                 unsigned char* dataImagePointer1 = NULL;
 182                 unsigned char* dataImagePointer2 = NULL;
 183                 unsigned char* dataImageResultPointer = NULL;
 184
 185                 dataImagePointer1 = (unsigned char*) img1->GetScalarPointer(0,0,0);
 186                 dataImagePointer2 = (unsigned char*) img2->GetScalarPointer(0,0,0);
 187                 dataImageResultPointer = (unsigned char*) _newImage->GetScalarPointer(0,0,0);
 188                 for(i = 0; i < sizeX; i++)
 189                 {
 190                         for(j = 0; j < sizeY; j++)
 191                         {
 192                                 dataImagePointer1 = (unsigned char*)img1->GetScalarPointer(i,j,0);
 193                                 dataImagePointer2 = (unsigned char*)img2->GetScalarPointer(i,j,0);
 194                                 dataImageResultPointer = (unsigned char*)_newImage->GetScalarPointer(i,j,0);
 195
 196                                 *dataImageResultPointer = (unsigned char)*dataImagePointer1*_percent + (unsigned char)*dataImagePointer2*(1-_percent);
 197                         }
 198                 }
 199         }
 200         else if(_type == VTK_SHORT)
 201         {
 202                 //POINTERS:
 203                 short* dataImagePointer1 = NULL;
 204                 short* dataImagePointer2 = NULL;
 205                 short* dataImageResultPointer = NULL;
 206
 207                 dataImagePointer1 = (short*) img1->GetScalarPointer(0,0,0);
 208                 dataImagePointer2 = (short*) img2->GetScalarPointer(0,0,0);
 209                 dataImageResultPointer = (short*) _newImage->GetScalarPointer(0,0,0);
 210                 for(i = 0; i < sizeX; i++)
 211                 {
 212                         for(j = 0; j < sizeY; j++)
 213                         {
 214                                 dataImagePointer1 = (short*)img1->GetScalarPointer(i,j,0);
 215                                 dataImagePointer2 = (short*)img2->GetScalarPointer(i,j,0);
 216                                 dataImageResultPointer = (short*)_newImage->GetScalarPointer(i,j,0);
 217
 218                                 *dataImageResultPointer = (short)*dataImagePointer1*_percent + (short)*dataImagePointer2*(1-_percent);
 219                         }
 220                 }
 221         }
 222         else if(_type == VTK_UNSIGNED_SHORT)
 223         {
 224                 //POINTERS:
 225                 unsigned short* dataImagePointer1 = NULL;
 226                 unsigned short* dataImagePointer2 = NULL;
 227                 unsigned short* dataImageResultPointer = NULL;
 228
 229                 dataImagePointer1 = (unsigned short*) img1->GetScalarPointer(0,0,0);
 230                 dataImagePointer2 = (unsigned short*) img2->GetScalarPointer(0,0,0);
 231                 dataImageResultPointer = (unsigned short*) _newImage->GetScalarPointer(0,0,0);
 232                 for(i = 0; i < sizeX; i++)
 233                 {
 234                         for(j = 0; j < sizeY; j++)
 235                         {
 236                                 dataImagePointer1 = (unsigned short*)img1->GetScalarPointer(i,j,0);
 237                                 dataImagePointer2 = (unsigned short*)img2->GetScalarPointer(i,j,0);
 238                                 dataImageResultPointer = (unsigned short*)_newImage->GetScalarPointer(i,j,0);
 239
 240                                 *dataImageResultPointer = (unsigned short)*dataImagePointer1*_percent + (unsigned short)*dataImagePointer2*(1-_percent);
 241                         }
 242                 }
 243         }
 244         else if(_type == VTK_INT)
 245         {
 246                 //POINTERS:
 247                 int* dataImagePointer1 = NULL;
 248                 int* dataImagePointer2 = NULL;
 249                 int* dataImageResultPointer = NULL;
 250
 251                 dataImagePointer1 = (int*) img1->GetScalarPointer(0,0,0);
 252                 dataImagePointer2 = (int*) img2->GetScalarPointer(0,0,0);
 253                 dataImageResultPointer = (int*) _newImage->GetScalarPointer(0,0,0);
 254                 for(i = 0; i < sizeX; i++)
 255                 {
 256                         for(j = 0; j < sizeY; j++)
 257                         {
 258                                 dataImagePointer1 = (int*)img1->GetScalarPointer(i,j,0);
 259                                 dataImagePointer2 = (int*)img2->GetScalarPointer(i,j,0);
 260                                 dataImageResultPointer = (int*)_newImage->GetScalarPointer(i,j,0);
 261
 262                                 *dataImageResultPointer = (int)*dataImagePointer1*_percent + (int)*dataImagePointer2*(1-_percent);
 263                         }
 264                 }
 265         }
 266         else if(_type == VTK_UNSIGNED_INT)
 267         {
 268                 //POINTERS:
 269                 unsigned int* dataImagePointer1 = NULL;
 270                 unsigned int* dataImagePointer2 = NULL;
 271                 unsigned int* dataImageResultPointer = NULL;
 272
 273                 dataImagePointer1 = (unsigned int*) img1->GetScalarPointer(0,0,0);
 274                 dataImagePointer2 = (unsigned int*) img2->GetScalarPointer(0,0,0);
 275                 dataImageResultPointer = (unsigned int*) _newImage->GetScalarPointer(0,0,0);
 276                 for(i = 0; i < sizeX; i++)
 277                 {
 278                         for(j = 0; j < sizeY; j++)
 279                         {
 280                                 dataImagePointer1 = (unsigned int*)img1->GetScalarPointer(i,j,0);
 281                                 dataImagePointer2 = (unsigned int*)img2->GetScalarPointer(i,j,0);
 282                                 dataImageResultPointer = (unsigned int*)_newImage->GetScalarPointer(i,j,0);
 283
 284                                 *dataImageResultPointer = (unsigned int)*dataImagePointer1*_percent + (unsigned int)*dataImagePointer2*(1-_percent);
 285                         }
 286                 }
 287         }
 288         else if(_type == VTK_LONG)
 289         {
 290                 //POINTERS:
 291                 long* dataImagePointer1 = NULL;
 292                 long* dataImagePointer2 = NULL;
 293                 long* dataImageResultPointer = NULL;
 294
 295                 dataImagePointer1 = (long*) img1->GetScalarPointer(0,0,0);
 296                 dataImagePointer2 = (long*) img2->GetScalarPointer(0,0,0);
 297                 dataImageResultPointer = (long*) _newImage->GetScalarPointer(0,0,0);
 298                 for(i = 0; i < sizeX; i++)
 299                 {
 300                         for(j = 0; j < sizeY; j++)
 301                         {
 302                                 dataImagePointer1 = (long*)img1->GetScalarPointer(i,j,0);
 303                                 dataImagePointer2 = (long*)img2->GetScalarPointer(i,j,0);
 304                                 dataImageResultPointer = (long*)_newImage->GetScalarPointer(i,j,0);
 305
 306                                 *dataImageResultPointer = (long)*dataImagePointer1*_percent + (long)*dataImagePointer2*(1-_percent);
 307                         }
 308                 }
 309         }
 310         else if(_type == VTK_UNSIGNED_LONG)
 311         {
 312                 //POINTERS:
 313                 unsigned long* dataImagePointer1 = NULL;
 314                 unsigned long* dataImagePointer2 = NULL;
 315                 unsigned long* dataImageResultPointer = NULL;
 316
 317                 dataImagePointer1 = (unsigned long*) img1->GetScalarPointer(0,0,0);
 318                 dataImagePointer2 = (unsigned long*) img2->GetScalarPointer(0,0,0);
 319                 dataImageResultPointer = (unsigned long*) _newImage->GetScalarPointer(0,0,0);
 320                 for(i = 0; i < sizeX; i++)
 321                 {
 322                         for(j = 0; j < sizeY; j++)
 323                         {
 324                                 dataImagePointer1 = (unsigned long*)img1->GetScalarPointer(i,j,0);
 325                                 dataImagePointer2 = (unsigned long*)img2->GetScalarPointer(i,j,0);
 326                                 dataImageResultPointer = (unsigned long*)_newImage->GetScalarPointer(i,j,0);
 327
 328                                 *dataImageResultPointer = (unsigned long)*dataImagePointer1*_percent + (unsigned long)*dataImagePointer2*(1-_percent);
 329                         }
 330                 }
 331         }
 332         else if(_type == VTK_FLOAT)
 333         {
 334                 //POINTERS:
 335                 float* dataImagePointer1 = NULL;
 336                 float* dataImagePointer2 = NULL;
 337                 float* dataImageResultPointer = NULL;
 338
 339                 dataImagePointer1 = (float*) img1->GetScalarPointer(0,0,0);
 340                 dataImagePointer2 = (float*) img2->GetScalarPointer(0,0,0);
 341                 dataImageResultPointer = (float*) _newImage->GetScalarPointer(0,0,0);
 342                 for(i = 0; i < sizeX; i++)
 343                 {
 344                         for(j = 0; j < sizeY; j++)
 345                         {
 346                                 dataImagePointer1 = (float*)img1->GetScalarPointer(i,j,0);
 347                                 dataImagePointer2 = (float*)img2->GetScalarPointer(i,j,0);
 348                                 dataImageResultPointer = (float*)_newImage->GetScalarPointer(i,j,0);
 349
 350                                 *dataImageResultPointer = (float)*dataImagePointer1*_percent + (float)*dataImagePointer2*(1-_percent);
 351                         }
 352                 }
 353         }
 354         else if(_type == VTK_DOUBLE)
 355         {
 356                 //POINTERS:
 357                 double* dataImagePointer1 = NULL;
 358                 double* dataImagePointer2 = NULL;
 359                 double* dataImageResultPointer = NULL;
 360
 361                 dataImagePointer1 = (double*) img1->GetScalarPointer(0,0,0);
 362                 dataImagePointer2 = (double*) img2->GetScalarPointer(0,0,0);
 363                 dataImageResultPointer = (double*) _newImage->GetScalarPointer(0,0,0);
 364                 for(i = 0; i < sizeX; i++)
 365                 {
 366                         for(j = 0; j < sizeY; j++)
 367                         {
 368                                 dataImagePointer1 = (double*)img1->GetScalarPointer(i,j,0);
 369                                 dataImagePointer2 = (double*)img2->GetScalarPointer(i,j,0);
 370                                 dataImageResultPointer = (double*)_newImage->GetScalarPointer(i,j,0);
 371
 372                                 *dataImageResultPointer = (double)*dataImagePointer1*_percent + (double)*dataImagePointer2*(1-_percent);
 373                         }
 374                 }
 375         }
 376
 377         _newImage->Update();
 378 }
 379
 380 /*
 381 * Get new image
 382 */
 383 //------------------------------------------------------------
 384 vtkImageData* Transparency::getImage()
 385 {
 386         if(_processed){
 387                 return _newImage;
 388         }
 389         else{
 390                 return NULL;
 391         }
 392 }
 393
 394 //------------------------------------------------------------
 395 void Transparency::setImage1(vtkImageData *image)
 396 {
 397         _image1=image;
 398 }
 399
 400 //------------------------------------------------------------
 401 void Transparency::setImage2(vtkImageData *image)
 402 {
 403         _image2=image;
 404 }
 405
 406 //------------------------------------------------------------
 407 void Transparency::setPercent(int percent)
 408 {
 409     _percent=(double)percent/100.0;
 410 }
 411