lib/CheckBoard.cpp

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