lib/CheckBoard.cpp

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