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