lib/CheckBoard.cpp

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