lib/CheckBoard.cpp

   1 #include "CheckBoard.h"
   2
   3
   4 /*
   5 * Constructor
   6 */
   7 //------------------------------------------------------------
   8 CheckBoard::CheckBoard()
   9 {
  10         image1=NULL;
  11         image2=NULL;
  12         squaresX=0;
  13         squaresY=0;
  14         newImage = NULL;
  15         processed=false;
  16         newImage = NULL;
  17         resample = NULL;
  18         result = NULL;
  19 }
  20
  21 /*
  22 * Destructor
  23 */
  24 //------------------------------------------------------------
  25 CheckBoard::~CheckBoard()
  26 {
  27         //if (image1 != NULL ) { image1->Delete(); }
  28         //if (image2 != NULL ) { image2->Delete(); }
  29         if (newImage != NULL ) { newImage->Delete(); }
  30         if (result != NULL ) { result->Delete(); }
  31 }
  32
  33 //------------------------------------------------------------
  34 void CheckBoard::calculateImage()
  35 {
  36
  37         if(image1!=NULL && image2!=NULL)
  38         {
  39
  40                 // IMAGE 1
  41
  42                 // Information from image1
  43                 image1->GetSpacing(spcImg1);
  44                 image1->GetExtent(extImg1);
  45
  46                 type = image1->GetScalarType();
  47
  48                 // The Z dimension is 1 for a 2D image
  49                 dimImg1[0] = extImg1[1] - extImg1[0]+1;
  50                 dimImg1[1] = extImg1[3] - extImg1[2]+1;
  51                 dimImg1[2] = 1;
  52
  53                 //IMAGE 2
  54
  55                 // Information from image2
  56                 image2->GetSpacing(spcImg2);
  57                 image2->GetExtent(extImg2);
  58
  59                 // The Z dimension is 1 for a 2D image
  60                 dimImg2[0] = extImg2[1] - extImg2[0]+1;
  61                 dimImg2[1] = extImg2[3] - extImg2[2]+1;
  62                 dimImg2[2] = 1;
  63
  64                 long numPixelsImg1 = dimImg1[0]*dimImg1[1];
  65                 long numPixelsImg2 = dimImg2[0]*dimImg2[1];
  66
  67                 double factorX = 1;
  68                 double factorY = 1;
  69                 resample = vtkImageResample::New();
  70                 result = vtkImageData::New();
  71                 if(numPixelsImg1<numPixelsImg2)
  72                 {
  73                         resample->SetInput(image1);
  74                         factorX = (double)extImg2[1]/extImg1[1];
  75                         factorY = (double)extImg2[3]/extImg1[3];
  76                         resample->SetAxisMagnificationFactor(0,factorX);
  77                         resample->SetAxisMagnificationFactor(1,factorY);
  78                         resample->SetInformationInput(image2);
  79
  80                         initialize(dimImg2, spcImg2);
  81                         result = resample->GetOutput();
  82                         result->Update();
  83                         createImage(result,image2,dimImg2[0],dimImg2[1]);
  84
  85                 } //if
  86                 else if (numPixelsImg1>numPixelsImg2)
  87                 {
  88                         resample->SetInput(image2);
  89                         factorX = (double)extImg1[1]/extImg2[1];
  90                         factorY = (double)extImg1[3]/extImg2[3];
  91                         resample->SetAxisMagnificationFactor(0,factorX);
  92                         resample->SetAxisMagnificationFactor(1,factorY);
  93                         resample->SetInformationInput(image1);
  94
  95                         initialize(dimImg1, spcImg1);
  96                         result = resample->GetOutput();
  97
  98                         result->Update();
  99
 100                         createImage(image1,result,dimImg1[0],dimImg1[1]);
 101                 } // else if
 102                 else
 103                 {
 104                         //If both images have the same number of pixels, the resultant image will have the
 105                         //properties of the first image.
 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
 115                         result = resample->GetOutput();
 116                         result->Update();
 117
 118                         createImage(image1,result,dimImg1[0],dimImg1[1]);
 119
 120                 } //else
 121
 122                 resample->Delete();
 123                 processed=true;
 124         }
 125 }
 126
 127 //------------------------------------------------------------
 128 void CheckBoard::initialize(int dimensions[], double spacing[])
 129 {
 130         // Setting the new image
 131         if(newImage != NULL){
 132                         newImage->Delete();
 133         }
 134         newImage = vtkImageData::New();
 135         newImage->SetScalarType(type);
 136         newImage->SetSpacing(spacing);
 137         newImage->SetDimensions(dimensions);
 138         newImage->AllocateScalars();
 139         newImage->Update();
 140
 141
 142 }
 143
 144 //------------------------------------------------------------
 145 void CheckBoard::createImage(vtkImageData *img1, vtkImageData *img2, int sizeX, int sizeY)
 146 {
 147         int imageType=img1->GetScalarType();
 148
 149         if(imageType == VTK_CHAR)
 150         {
 151                 //POINTERS:
 152                 char* dataImagePointer1 = NULL;
 153                 char* dataImagePointer2 = NULL;
 154                 char* dataImageResultPointer = NULL;
 155
 156                 createImageByType(dataImagePointer1,dataImagePointer2,dataImageResultPointer,img1,img2,sizeX,sizeY);
 157         }
 158         else if(imageType == VTK_SIGNED_CHAR)
 159         {
 160                 //POINTERS:
 161                 signed char* dataImagePointer1 = NULL;
 162                 signed char* dataImagePointer2 = NULL;
 163                 signed char* dataImageResultPointer = NULL;
 164
 165                 createImageByType(dataImagePointer1,dataImagePointer2,dataImageResultPointer,img1,img2,sizeX,sizeY);
 166         }
 167         else if(imageType == VTK_UNSIGNED_CHAR)
 168         {
 169                 //POINTERS:
 170                 unsigned char* dataImagePointer1 = NULL;
 171                 unsigned char* dataImagePointer2 = NULL;
 172                 unsigned char* dataImageResultPointer = NULL;
 173
 174                 createImageByType(dataImagePointer1,dataImagePointer2,dataImageResultPointer,img1,img2,sizeX,sizeY);
 175         }
 176         else if(imageType == VTK_SHORT)
 177         {
 178         //POINTERS:
 179                 short* dataImagePointer1 = NULL;
 180                 short* dataImagePointer2 = NULL;
 181                 short* dataImageResultPointer = NULL;
 182
 183                 createImageByType(dataImagePointer1,dataImagePointer2,dataImageResultPointer,img1,img2,sizeX,sizeY);
 184         }
 185         else if(imageType == VTK_UNSIGNED_SHORT)
 186         {
 187                 //POINTERS:
 188                 unsigned short* dataImagePointer1 = NULL;
 189                 unsigned short* dataImagePointer2 = NULL;
 190                 unsigned short* dataImageResultPointer = NULL;
 191
 192                 createImageByType(dataImagePointer1,dataImagePointer2,dataImageResultPointer,img1,img2,sizeX,sizeY);
 193         }
 194
 195         else if(imageType == VTK_INT)
 196         {
 197                 //POINTERS:
 198                 int* dataImagePointer1 = NULL;
 199                 int* dataImagePointer2 = NULL;
 200                 int* dataImageResultPointer = NULL;
 201
 202                 createImageByType(dataImagePointer1,dataImagePointer2,dataImageResultPointer,img1,img2,sizeX,sizeY);
 203         }
 204         else if(imageType == VTK_UNSIGNED_INT)
 205         {
 206                 //POINTERS:
 207                 unsigned int* dataImagePointer1 = NULL;
 208                 unsigned int* dataImagePointer2 = NULL;
 209                 unsigned int* dataImageResultPointer = NULL;
 210
 211                 createImageByType(dataImagePointer1,dataImagePointer2,dataImageResultPointer,img1,img2,sizeX,sizeY);
 212         }
 213         else if(imageType == VTK_LONG)
 214         {
 215                 //POINTERS:
 216                 long* dataImagePointer1 = NULL;
 217                 long* dataImagePointer2 = NULL;
 218                 long* dataImageResultPointer = NULL;
 219
 220                 createImageByType(dataImagePointer1,dataImagePointer2,dataImageResultPointer,img1,img2,sizeX,sizeY);
 221         }
 222         else if(imageType == VTK_UNSIGNED_LONG)
 223         {
 224                 //POINTERS:
 225                 unsigned long* dataImagePointer1 = NULL;
 226                 unsigned long* dataImagePointer2 = NULL;
 227                 unsigned long* dataImageResultPointer = NULL;
 228
 229                 createImageByType(dataImagePointer1,dataImagePointer2,dataImageResultPointer,img1,img2,sizeX,sizeY);
 230         }
 231         else if(imageType == VTK_FLOAT)
 232         {
 233                 //POINTERS:
 234                 float* dataImagePointer1 = NULL;
 235                 float* dataImagePointer2 = NULL;
 236                 float* dataImageResultPointer = NULL;
 237
 238                 createImageByType(dataImagePointer1,dataImagePointer2,dataImageResultPointer,img1,img2,sizeX,sizeY);
 239         }
 240         else if(imageType == VTK_DOUBLE)
 241         {
 242                 //POINTERS:
 243                 double* dataImagePointer1 = NULL;
 244                 double* dataImagePointer2 = NULL;
 245                 double* dataImageResultPointer = NULL;
 246
 247                 createImageByType(dataImagePointer1,dataImagePointer2,dataImageResultPointer,img1,img2,sizeX,sizeY);
 248         }
 249
 250
 251         //std::cout << "The image has been checkboardized!" << std::endl;
 252    newImage->Update();
 253 //   newImage->Modified();
 254 }
 255 /**Template used for the different image types
 256 */
 257 template <class T>
 258 void CheckBoard::createImageByType(T* dataImagePointer1, T* dataImagePointer2, T* dataImageResultPointer, vtkImageData *img1, vtkImageData *img2, int sizeX, int sizeY)
 259 {
 260         dataImagePointer1 = (T*) img1->GetScalarPointer(0,0,0);
 261         dataImagePointer2 = (T*) img2->GetScalarPointer(0,0,0);
 262         dataImageResultPointer = (T*) newImage->GetScalarPointer(0,0,0);
 263
 264         if(squaresX == 0)
 265         {
 266                 squaresX = 1;
 267         }
 268         if(squaresY == 0)
 269         {
 270                 squaresY = 1;
 271         }
 272
 273         int divX = sizeX/squaresX;
 274         int divY = sizeY/squaresY;
 275         int i, j, counterX, counterY;
 276         for(i = 0; i < sizeX; i++)
 277         {
 278                 counterY = 0;
 279                 for(j = 0; j < sizeY; j++)
 280                 {
 281                         dataImagePointer1 = (T*)img1->GetScalarPointer(i,j,0);
 282                         dataImagePointer2 = (T*)img2->GetScalarPointer(i,j,0);
 283                         dataImageResultPointer = (T*)newImage->GetScalarPointer(i,j,0);
 284                         if( (counterX <= divX && counterY <= divY) || ((counterX >= divX && counterX <= 2*divX) && (counterY >= divY && counterY <= 2*divY)) )
 285                         {
 286                                 *dataImageResultPointer = (T) *dataImagePointer1;
 287                         }
 288                         else //if( ((counterX >= divX && counterX <= 2*divX) && counterY <= divY) || (counterX <= divX && (counterY >= divY && counterY <= 2*divY)) )
 289                         {
 290                                 *dataImageResultPointer = (T) *dataImagePointer2;
 291                         }
 292
 293                         if(counterX >= 2*divX)
 294                         {
 295                                 counterX = 0;
 296                         }
 297                         else if(counterY >= 2*divY)
 298                         {
 299                                 counterY = 0;
 300                         }
 301                         counterY++;
 302                 }
 303                 counterX++;
 304         }
 305 }
 306
 307 /*
 308 * Get new image
 309 */
 310 //------------------------------------------------------------
 311 vtkImageData* CheckBoard::getFilteredImage()
 312 {
 313         if(processed){
 314                 return newImage;
 315         }
 316         else{
 317                 return NULL;
 318         }
 319 }
 320
 321 //------------------------------------------------------------
 322 void CheckBoard::setInputImage1(vtkImageData *_image)
 323 {
 324         image1=_image;
 325 }
 326
 327 //------------------------------------------------------------
 328 void CheckBoard::setInputImage2(vtkImageData *_image)
 329 {
 330         image2=_image;
 331 }
 332
 333 //------------------------------------------------------------
 334 void CheckBoard::setCols(int cols)
 335 {
 336         squaresX=cols;
 337 }
 338
 339 //------------------------------------------------------------
 340 void CheckBoard::setRows(int rows)
 341 {
 342         squaresY=rows;
 343 }
 344