lib/Substraction.cxx

   1 #include "Substraction.h"
   2
   3 Substraction::Substraction(vtkImageData* imageData1,vtkImageData* imageData2, int uZLevel,int lZLevel, std::vector<double> uColor, std::vector<double> lColor, std::vector<double> mColor)
   4 {
   5         imageResult= vtkImageData::New();
   6         sizeImage=0;
   7         uZeroLevel=uZLevel;
   8         lZeroLevel=lZLevel;
   9         if(uColor.size() != NULL)
  10         {
  11                 upperColor[0] = uColor[0];
  12                 upperColor[1] = uColor[1];
  13                 upperColor[2] = uColor[2];
  14         }
  15         else
  16         {
  17                 upperColor[0] = 255;
  18                 upperColor[1] = 255;
  19                 upperColor[2] = 255;
  20         }
  21         if(mColor.size() != NULL)
  22         {
  23                 mediumColor[0] = mColor[0];
  24                 mediumColor[1] = mColor[1];
  25                 mediumColor[2] = mColor[2];
  26         }
  27         else
  28         {
  29                 mediumColor[0] = 125;
  30                 mediumColor[1] = 125;
  31                 mediumColor[2] = 125;
  32         }
  33         if(lColor.size() != NULL)
  34         {
  35                 lowerColor[0] = lColor[0];
  36                 lowerColor[1] = lColor[1];
  37                 lowerColor[2] = lColor[2];
  38         }
  39         else
  40         {
  41                 lowerColor[0] = 0;
  42                 lowerColor[1] = 0;
  43                 lowerColor[2] = 0;
  44         }
  45
  46         //Original image type this case is an unsigned char (3)
  47         int t=imageData1->GetScalarType();
  48         //substracting the image
  49         substractImage(imageData1, imageData2);
  50 }
  51
  52 Substraction::~Substraction()
  53 {
  54         if(imageResult!=NULL)imageResult->Delete();
  55 }
  56
  57 //----------------------------------------------------------------------------
  58 // Methods
  59 //----------------------------------------------------------------------------
  60
  61
  62 /*
  63 Calculate the new image and save it in the attribute imageResult
  64 it is used if the user had given the imageData
  65 */
  66 void Substraction::substractImage(vtkImageData* imageData1, vtkImageData* imageData2)
  67 {
  68         //dimensions of the image (extent)
  69         int ext[6];
  70         //setting the dimensionality (1d or 2d or 3d )
  71     int newDim[3];
  72         //image spacing
  73     double spc[3];
  74
  75         //getting the information from the original image
  76         imageData1->GetSpacing(spc);
  77         imageData1->GetExtent(ext);
  78
  79         //this a 2d image
  80         newDim[0]=ext[1]-ext[0]+1;
  81     newDim[1]=ext[3]-ext[2]+1;
  82     newDim[2]=1;// in general it is ext[5]-ext[4]+1
  83
  84
  85         imageType = imageData1->GetScalarType();
  86         //initializing the image that represents the substracted image
  87         initialize(newDim,spc);
  88         //Time to substract
  89         substract(imageData1, imageData2);
  90 }
  91
  92 /*
  93   getting ready the imageResult
  94 */
  95 void Substraction::initialize(int dimensions[], double spacing[])
  96 {
  97         //setting image data of the imageResult
  98         imageResult->SetScalarType(imageType);
  99         imageResult->SetSpacing(spacing);
 100         imageResult->SetDimensions(dimensions);
 101         imageResult->AllocateScalars();
 102         imageResult->Update();
 103 }
 104
 105 /*
 106          Setting the values for the
 107 */
 108 void Substraction::substract(vtkImageData* imageData1, vtkImageData* imageData2)
 109 {
 110         if(imageType == VTK_CHAR)
 111         {
 112                 /*
 113                 images pointers
 114                 */
 115                 // pointers to get into the image
 116                 char* dataImagePointer1=NULL;
 117                 char* dataImagePointer2=NULL;
 118                 char* dataImageResultPointer=NULL;
 119                 // we start where the  image starts
 120                 dataImagePointer1=(char*)imageData1->GetScalarPointer(0,0,0);
 121                 dataImagePointer2=(char*)imageData2->GetScalarPointer(0,0,0);
 122                 dataImageResultPointer=(char*)imageResult->GetScalarPointer(0,0,0);
 123
 124                 /*
 125                 Image Size
 126                 */
 127                 int ext[6];
 128                 imageData1->GetExtent(ext);
 129                 int sx,sy,sz;
 130                 sx=ext[1]-ext[0]+1;
 131                 sy=ext[3]-ext[2]+1;
 132                 sz=ext[5]-ext[4]+1;
 133
 134                 sizeImage=sx*sy*sz;
 135
 136                 //-----------------
 137                 //A3
 138                 //-----------------
 139                 //walking in the image
 140                 int i=0,j=0,k=0,counter=0,nU=0,nL=0,nZ=0;
 141                 double sum1=0,sum2=0;
 142                 for(i=0;i<sx;i++)
 143                 {
 144                         for(j=0;j<sy;j++)
 145                         {
 146                                 for(k=0;k<sz;k++)
 147                                 {
 148
 149                                         // this is for getting just the grey level in that position
 150                                         //originalValue=(short)imageData->GetScalarComponentAsFloat(i,j,k,0);
 151
 152                                         // we get the pointer to the position (i,j,k)y that way we can get the
 153                                         //grey level and we can change it
 154                                         dataImagePointer1=(char*)imageData1->GetScalarPointer(i,j,k);
 155                                         dataImagePointer2=(char*)imageData2->GetScalarPointer(i,j,k);
 156                                         dataImageResultPointer=(char*)imageResult->GetScalarPointer(i,j,k);
 157
 158                                         sum1=(int)(dataImagePointer1[0]) + (int)(dataImagePointer1[1]) + (int)(dataImagePointer1[2]);
 159                                         sum1=sum1/3;
 160                                         sum2=(int)(dataImagePointer2[0]) + (int)(dataImagePointer2[1]) + (int)(dataImagePointer2[2]);
 161                                         sum2=sum2/3;
 162                                         if((sum1 - sum2) < lZeroLevel)
 163                                         {
 164                                                 dataImageResultPointer[0] =(char) lowerColor[0];
 165                                                 dataImageResultPointer[1] =(char) lowerColor[1];
 166                                                 dataImageResultPointer[2] =(char) lowerColor[2];
 167                                                 nL++;
 168                                         }
 169                                         else if((sum1 - sum2) > uZeroLevel)
 170                                         {
 171                                                 dataImageResultPointer[0] =(char) upperColor[0];
 172                                                 dataImageResultPointer[1] =(char) upperColor[1];
 173                                                 dataImageResultPointer[2] =(char) upperColor[2];
 174                                                 nU++;
 175                                         }
 176                                         else
 177                                         {
 178                                                 dataImageResultPointer[0] =(char) mediumColor[0];
 179                                                 dataImageResultPointer[1] =(char) mediumColor[1];
 180                                                 dataImageResultPointer[2] =(char) mediumColor[2];
 181                                                 nZ++;
 182                                         }
 183                                         counter++;
 184                                 }
 185                         }
 186                 }
 187         }
 188         else if(imageType == VTK_UNSIGNED_CHAR)
 189         {
 190                 /*
 191                 images pointers
 192                 */
 193                 // pointers to get into the image
 194                 unsigned char* dataImagePointer1=NULL;
 195                 unsigned char* dataImagePointer2=NULL;
 196                 unsigned char* dataImageResultPointer=NULL;
 197                 // we start where the  image starts
 198                 dataImagePointer1=(unsigned char*)imageData1->GetScalarPointer(0,0,0);
 199                 dataImagePointer2=(unsigned char*)imageData2->GetScalarPointer(0,0,0);
 200                 dataImageResultPointer=(unsigned char*)imageResult->GetScalarPointer(0,0,0);
 201
 202                 /*
 203                 Image Size
 204                 */
 205                 int ext[6];
 206                 imageData1->GetExtent(ext);
 207                 int sx,sy,sz;
 208                 sx=ext[1]-ext[0]+1;
 209                 sy=ext[3]-ext[2]+1;
 210                 sz=ext[5]-ext[4]+1;
 211
 212                 sizeImage=sx*sy*sz;
 213
 214                 //-----------------
 215                 //A3
 216                 //-----------------
 217                 //walking in the image
 218                 int i=0,j=0,k=0,counter=0,nU=0,nL=0,nZ=0;
 219                 double sum1=0,sum2=0;
 220                 for(i=0;i<sx;i++)
 221                 {
 222                         for(j=0;j<sy;j++)
 223                         {
 224                                 for(k=0;k<sz;k++)
 225                                 {
 226
 227                                         // this is for getting just the grey level in that position
 228                                         //originalValue=(short)imageData->GetScalarComponentAsFloat(i,j,k,0);
 229
 230                                         // we get the pointer to the position (i,j,k)y that way we can get the
 231                                         //grey level and we can change it
 232                                         dataImagePointer1=(unsigned char*)imageData1->GetScalarPointer(i,j,k);
 233                                         dataImagePointer2=(unsigned char*)imageData2->GetScalarPointer(i,j,k);
 234                                         dataImageResultPointer=(unsigned char*)imageResult->GetScalarPointer(i,j,k);
 235
 236                                         sum1=(int)(dataImagePointer1[0]) + (int)(dataImagePointer1[1]) + (int)(dataImagePointer1[2]);
 237                                         sum1=sum1/3;
 238                                         sum2=(int)(dataImagePointer2[0]) + (int)(dataImagePointer2[1]) + (int)(dataImagePointer2[2]);
 239                                         sum2=sum2/3;
 240                                         if((sum1 - sum2) < lZeroLevel)
 241                                         {
 242                                                 dataImageResultPointer[0] =(unsigned char) lowerColor[0];
 243                                                 dataImageResultPointer[1] =(unsigned char) lowerColor[1];
 244                                                 dataImageResultPointer[2] =(unsigned char) lowerColor[2];
 245                                                 nL++;
 246                                         }
 247                                         else if((sum1 - sum2) > uZeroLevel)
 248                                         {
 249                                                 dataImageResultPointer[0] =(unsigned char) upperColor[0];
 250                                                 dataImageResultPointer[1] =(unsigned char) upperColor[1];
 251                                                 dataImageResultPointer[2] =(unsigned char) upperColor[2];
 252                                                 nU++;
 253                                         }
 254                                         else
 255                                         {
 256                                                 dataImageResultPointer[0] =(unsigned char) mediumColor[0];
 257                                                 dataImageResultPointer[1] =(unsigned char) mediumColor[1];
 258                                                 dataImageResultPointer[2] =(unsigned char) mediumColor[2];
 259                                                 nZ++;
 260                                         }
 261                                         counter++;
 262                                 }
 263                         }
 264                 }
 265         }
 266         else if(imageType == VTK_SIGNED_CHAR)
 267         {
 268                 /*
 269                 images pointers
 270                 */
 271                 // pointers to get into the image
 272                 signed char* dataImagePointer1=NULL;
 273                 signed char* dataImagePointer2=NULL;
 274                 signed char* dataImageResultPointer=NULL;
 275                 // we start where the  image starts
 276                 dataImagePointer1=(signed char*)imageData1->GetScalarPointer(0,0,0);
 277                 dataImagePointer2=(signed char*)imageData2->GetScalarPointer(0,0,0);
 278                 dataImageResultPointer=(signed char*)imageResult->GetScalarPointer(0,0,0);
 279
 280                 /*
 281                 Image Size
 282                 */
 283                 int ext[6];
 284                 imageData1->GetExtent(ext);
 285                 int sx,sy,sz;
 286                 sx=ext[1]-ext[0]+1;
 287                 sy=ext[3]-ext[2]+1;
 288                 sz=ext[5]-ext[4]+1;
 289
 290                 sizeImage=sx*sy*sz;
 291
 292                 //-----------------
 293                 //A3
 294                 //-----------------
 295                 //walking in the image
 296                 int i=0,j=0,k=0,counter=0,nU=0,nL=0,nZ=0;
 297                 double sum1=0,sum2=0;
 298                 for(i=0;i<sx;i++)
 299                 {
 300                         for(j=0;j<sy;j++)
 301                         {
 302                                 for(k=0;k<sz;k++)
 303                                 {
 304
 305                                         // this is for getting just the grey level in that position
 306                                         //originalValue=(short)imageData->GetScalarComponentAsFloat(i,j,k,0);
 307
 308                                         // we get the pointer to the position (i,j,k)y that way we can get the
 309                                         //grey level and we can change it
 310                                         dataImagePointer1=(signed char*)imageData1->GetScalarPointer(i,j,k);
 311                                         dataImagePointer2=(signed char*)imageData2->GetScalarPointer(i,j,k);
 312                                         dataImageResultPointer=(signed char*)imageResult->GetScalarPointer(i,j,k);
 313
 314                                         sum1=(int)(dataImagePointer1[0]) + (int)(dataImagePointer1[1]) + (int)(dataImagePointer1[2]);
 315                                         sum1=sum1/3;
 316                                         sum2=(int)(dataImagePointer2[0]) + (int)(dataImagePointer2[1]) + (int)(dataImagePointer2[2]);
 317                                         sum2=sum2/3;
 318                                         if((sum1 - sum2) < lZeroLevel)
 319                                         {
 320                                                 dataImageResultPointer[0] =(signed char) lowerColor[0];
 321                                                 dataImageResultPointer[1] =(signed char) lowerColor[1];
 322                                                 dataImageResultPointer[2] =(signed char) lowerColor[2];
 323                                                 nL++;
 324                                         }
 325                                         else if((sum1 - sum2) > uZeroLevel)
 326                                         {
 327                                                 dataImageResultPointer[0] =(signed char) upperColor[0];
 328                                                 dataImageResultPointer[1] =(signed char) upperColor[1];
 329                                                 dataImageResultPointer[2] =(signed char) upperColor[2];
 330                                                 nU++;
 331                                         }
 332                                         else
 333                                         {
 334                                                 dataImageResultPointer[0] =(signed char) mediumColor[0];
 335                                                 dataImageResultPointer[1] =(signed char) mediumColor[1];
 336                                                 dataImageResultPointer[2] =(signed char) mediumColor[2];
 337                                                 nZ++;
 338                                         }
 339                                         counter++;
 340                                 }
 341                         }
 342                 }
 343         }
 344         else if(imageType == VTK_SHORT)
 345         {
 346                 /*
 347                 images pointers
 348                 */
 349                 // pointers to get into the image
 350                 short* dataImagePointer1=NULL;
 351                 short* dataImagePointer2=NULL;
 352                 short* dataImageResultPointer=NULL;
 353                 // we start where the  image starts
 354                 dataImagePointer1=(short*)imageData1->GetScalarPointer(0,0,0);
 355                 dataImagePointer2=(short*)imageData2->GetScalarPointer(0,0,0);
 356                 dataImageResultPointer=(short*)imageResult->GetScalarPointer(0,0,0);
 357
 358                 /*
 359                 Image Size
 360                 */
 361                 int ext[6];
 362                 imageData1->GetExtent(ext);
 363                 int sx,sy,sz;
 364                 sx=ext[1]-ext[0]+1;
 365                 sy=ext[3]-ext[2]+1;
 366                 sz=ext[5]-ext[4]+1;
 367
 368                 sizeImage=sx*sy*sz;
 369
 370                 //-----------------
 371                 //A3
 372                 //-----------------
 373                 //walking in the image
 374                 int i=0,j=0,k=0,counter=0,nU=0,nL=0,nZ=0;
 375                 double sum1=0,sum2=0;
 376                 for(i=0;i<sx;i++)
 377                 {
 378                         for(j=0;j<sy;j++)
 379                         {
 380                                 for(k=0;k<sz;k++)
 381                                 {
 382
 383                                         // this is for getting just the grey level in that position
 384                                         //originalValue=(short)imageData->GetScalarComponentAsFloat(i,j,k,0);
 385
 386                                         // we get the pointer to the position (i,j,k)y that way we can get the
 387                                         //grey level and we can change it
 388                                         dataImagePointer1=(short*)imageData1->GetScalarPointer(i,j,k);
 389                                         dataImagePointer2=(short*)imageData2->GetScalarPointer(i,j,k);
 390                                         dataImageResultPointer=(short*)imageResult->GetScalarPointer(i,j,k);
 391
 392                                         sum1=(int)(dataImagePointer1[0]) + (int)(dataImagePointer1[1]) + (int)(dataImagePointer1[2]);
 393                                         sum1=sum1/3;
 394                                         sum2=(int)(dataImagePointer2[0]) + (int)(dataImagePointer2[1]) + (int)(dataImagePointer2[2]);
 395                                         sum2=sum2/3;
 396                                         if((sum1 - sum2) < lZeroLevel)
 397                                         {
 398                                                 dataImageResultPointer[0] =(short) lowerColor[0];
 399                                                 dataImageResultPointer[1] =(short) lowerColor[1];
 400                                                 dataImageResultPointer[2] =(short) lowerColor[2];
 401                                                 nL++;
 402                                         }
 403                                         else if((sum1 - sum2) > uZeroLevel)
 404                                         {
 405                                                 dataImageResultPointer[0] =(short) upperColor[0];
 406                                                 dataImageResultPointer[1] =(short) upperColor[1];
 407                                                 dataImageResultPointer[2] =(short) upperColor[2];
 408                                                 nU++;
 409                                         }
 410                                         else
 411                                         {
 412                                                 dataImageResultPointer[0] =(short) mediumColor[0];
 413                                                 dataImageResultPointer[1] =(short) mediumColor[1];
 414                                                 dataImageResultPointer[2] =(short) mediumColor[2];
 415                                                 nZ++;
 416                                         }
 417                                         counter++;
 418                                 }
 419                         }
 420                 }
 421         }
 422         else if(imageType == VTK_UNSIGNED_SHORT)
 423         {
 424                 /*
 425                 images pointers
 426                 */
 427                 // pointers to get into the image
 428                 unsigned short* dataImagePointer1=NULL;
 429                 unsigned short* dataImagePointer2=NULL;
 430                 unsigned short* dataImageResultPointer=NULL;
 431                 // we start where the  image starts
 432                 dataImagePointer1=(unsigned short*)imageData1->GetScalarPointer(0,0,0);
 433                 dataImagePointer2=(unsigned short*)imageData2->GetScalarPointer(0,0,0);
 434                 dataImageResultPointer=(unsigned short*)imageResult->GetScalarPointer(0,0,0);
 435
 436                 /*
 437                 Image Size
 438                 */
 439                 int ext[6];
 440                 imageData1->GetExtent(ext);
 441                 int sx,sy,sz;
 442                 sx=ext[1]-ext[0]+1;
 443                 sy=ext[3]-ext[2]+1;
 444                 sz=ext[5]-ext[4]+1;
 445
 446                 sizeImage=sx*sy*sz;
 447
 448                 //-----------------
 449                 //A3
 450                 //-----------------
 451                 //walking in the image
 452                 int i=0,j=0,k=0,counter=0,nU=0,nL=0,nZ=0;
 453                 double sum1=0,sum2=0;
 454                 for(i=0;i<sx;i++)
 455                 {
 456                         for(j=0;j<sy;j++)
 457                         {
 458                                 for(k=0;k<sz;k++)
 459                                 {
 460
 461                                         // this is for getting just the grey level in that position
 462                                         //originalValue=(short)imageData->GetScalarComponentAsFloat(i,j,k,0);
 463
 464                                         // we get the pointer to the position (i,j,k)y that way we can get the
 465                                         //grey level and we can change it
 466                                         dataImagePointer1=(unsigned short*)imageData1->GetScalarPointer(i,j,k);
 467                                         dataImagePointer2=(unsigned short*)imageData2->GetScalarPointer(i,j,k);
 468                                         dataImageResultPointer=(unsigned short*)imageResult->GetScalarPointer(i,j,k);
 469
 470                                         sum1=(int)(dataImagePointer1[0]) + (int)(dataImagePointer1[1]) + (int)(dataImagePointer1[2]);
 471                                         sum1=sum1/3;
 472                                         sum2=(int)(dataImagePointer2[0]) + (int)(dataImagePointer2[1]) + (int)(dataImagePointer2[2]);
 473                                         sum2=sum2/3;
 474                                         if((sum1 - sum2) < lZeroLevel)
 475                                         {
 476                                                 dataImageResultPointer[0] =(unsigned short) lowerColor[0];
 477                                                 dataImageResultPointer[1] =(unsigned short) lowerColor[1];
 478                                                 dataImageResultPointer[2] =(unsigned short) lowerColor[2];
 479                                                 nL++;
 480                                         }
 481                                         else if((sum1 - sum2) > uZeroLevel)
 482                                         {
 483                                                 dataImageResultPointer[0] =(unsigned short) upperColor[0];
 484                                                 dataImageResultPointer[1] =(unsigned short) upperColor[1];
 485                                                 dataImageResultPointer[2] =(unsigned short) upperColor[2];
 486                                                 nU++;
 487                                         }
 488                                         else
 489                                         {
 490                                                 dataImageResultPointer[0] =(unsigned short) mediumColor[0];
 491                                                 dataImageResultPointer[1] =(unsigned short) mediumColor[1];
 492                                                 dataImageResultPointer[2] =(unsigned short) mediumColor[2];
 493                                                 nZ++;
 494                                         }
 495                                         counter++;
 496                                 }
 497                         }
 498                 }
 499         }
 500         else if(imageType == VTK_INT)
 501         {
 502                 /*
 503                 images pointers
 504                 */
 505                 // pointers to get into the image
 506                 int* dataImagePointer1=NULL;
 507                 int* dataImagePointer2=NULL;
 508                 int* dataImageResultPointer=NULL;
 509                 // we start where the  image starts
 510                 dataImagePointer1=(int*)imageData1->GetScalarPointer(0,0,0);
 511                 dataImagePointer2=(int*)imageData2->GetScalarPointer(0,0,0);
 512                 dataImageResultPointer=(int*)imageResult->GetScalarPointer(0,0,0);
 513
 514                 /*
 515                 Image Size
 516                 */
 517                 int ext[6];
 518                 imageData1->GetExtent(ext);
 519                 int sx,sy,sz;
 520                 sx=ext[1]-ext[0]+1;
 521                 sy=ext[3]-ext[2]+1;
 522                 sz=ext[5]-ext[4]+1;
 523
 524                 sizeImage=sx*sy*sz;
 525
 526                 //-----------------
 527                 //A3
 528                 //-----------------
 529                 //walking in the image
 530                 int i=0,j=0,k=0,counter=0,nU=0,nL=0,nZ=0;
 531                 double sum1=0,sum2=0;
 532                 for(i=0;i<sx;i++)
 533                 {
 534                         for(j=0;j<sy;j++)
 535                         {
 536                                 for(k=0;k<sz;k++)
 537                                 {
 538
 539                                         // this is for getting just the grey level in that position
 540                                         //originalValue=(short)imageData->GetScalarComponentAsFloat(i,j,k,0);
 541
 542                                         // we get the pointer to the position (i,j,k)y that way we can get the
 543                                         //grey level and we can change it
 544                                         dataImagePointer1=(int*)imageData1->GetScalarPointer(i,j,k);
 545                                         dataImagePointer2=(int*)imageData2->GetScalarPointer(i,j,k);
 546                                         dataImageResultPointer=(int*)imageResult->GetScalarPointer(i,j,k);
 547
 548                                         sum1=(int)(dataImagePointer1[0]) + (int)(dataImagePointer1[1]) + (int)(dataImagePointer1[2]);
 549                                         sum1=sum1/3;
 550                                         sum2=(int)(dataImagePointer2[0]) + (int)(dataImagePointer2[1]) + (int)(dataImagePointer2[2]);
 551                                         sum2=sum2/3;
 552                                         if((sum1 - sum2) < lZeroLevel)
 553                                         {
 554                                                 dataImageResultPointer[0] =(int) lowerColor[0];
 555                                                 dataImageResultPointer[1] =(int) lowerColor[1];
 556                                                 dataImageResultPointer[2] =(int) lowerColor[2];
 557                                                 nL++;
 558                                         }
 559                                         else if((sum1 - sum2) > uZeroLevel)
 560                                         {
 561                                                 dataImageResultPointer[0] =(int) upperColor[0];
 562                                                 dataImageResultPointer[1] =(int) upperColor[1];
 563                                                 dataImageResultPointer[2] =(int) upperColor[2];
 564                                                 nU++;
 565                                         }
 566                                         else
 567                                         {
 568                                                 dataImageResultPointer[0] =(int) mediumColor[0];
 569                                                 dataImageResultPointer[1] =(int) mediumColor[1];
 570                                                 dataImageResultPointer[2] =(int) mediumColor[2];
 571                                                 nZ++;
 572                                         }
 573                                         counter++;
 574                                 }
 575                         }
 576                 }
 577         }
 578         else if(imageType == VTK_UNSIGNED_INT)
 579         {
 580                 /*
 581                 images pointers
 582                 */
 583                 // pointers to get into the image
 584                 unsigned int* dataImagePointer1=NULL;
 585                 unsigned int* dataImagePointer2=NULL;
 586                 unsigned int* dataImageResultPointer=NULL;
 587                 // we start where the  image starts
 588                 dataImagePointer1=(unsigned int*)imageData1->GetScalarPointer(0,0,0);
 589                 dataImagePointer2=(unsigned int*)imageData2->GetScalarPointer(0,0,0);
 590                 dataImageResultPointer=(unsigned int*)imageResult->GetScalarPointer(0,0,0);
 591
 592                 /*
 593                 Image Size
 594                 */
 595                 int ext[6];
 596                 imageData1->GetExtent(ext);
 597                 int sx,sy,sz;
 598                 sx=ext[1]-ext[0]+1;
 599                 sy=ext[3]-ext[2]+1;
 600                 sz=ext[5]-ext[4]+1;
 601
 602                 sizeImage=sx*sy*sz;
 603
 604                 //-----------------
 605                 //A3
 606                 //-----------------
 607                 //walking in the image
 608                 int i=0,j=0,k=0,counter=0,nU=0,nL=0,nZ=0;
 609                 double sum1=0,sum2=0;
 610                 for(i=0;i<sx;i++)
 611                 {
 612                         for(j=0;j<sy;j++)
 613                         {
 614                                 for(k=0;k<sz;k++)
 615                                 {
 616
 617                                         // this is for getting just the grey level in that position
 618                                         //originalValue=(short)imageData->GetScalarComponentAsFloat(i,j,k,0);
 619
 620                                         // we get the pointer to the position (i,j,k)y that way we can get the
 621                                         //grey level and we can change it
 622                                         dataImagePointer1=(unsigned int*)imageData1->GetScalarPointer(i,j,k);
 623                                         dataImagePointer2=(unsigned int*)imageData2->GetScalarPointer(i,j,k);
 624                                         dataImageResultPointer=(unsigned int*)imageResult->GetScalarPointer(i,j,k);
 625
 626                                         sum1=(int)(dataImagePointer1[0]) + (int)(dataImagePointer1[1]) + (int)(dataImagePointer1[2]);
 627                                         sum1=sum1/3;
 628                                         sum2=(int)(dataImagePointer2[0]) + (int)(dataImagePointer2[1]) + (int)(dataImagePointer2[2]);
 629                                         sum2=sum2/3;
 630                                         if((sum1 - sum2) < lZeroLevel)
 631                                         {
 632                                                 dataImageResultPointer[0] =(unsigned int) lowerColor[0];
 633                                                 dataImageResultPointer[1] =(unsigned int) lowerColor[1];
 634                                                 dataImageResultPointer[2] =(unsigned int) lowerColor[2];
 635                                                 nL++;
 636                                         }
 637                                         else if((sum1 - sum2) > uZeroLevel)
 638                                         {
 639                                                 dataImageResultPointer[0] =(unsigned int) upperColor[0];
 640                                                 dataImageResultPointer[1] =(unsigned int) upperColor[1];
 641                                                 dataImageResultPointer[2] =(unsigned int) upperColor[2];
 642                                                 nU++;
 643                                         }
 644                                         else
 645                                         {
 646                                                 dataImageResultPointer[0] =(unsigned int) mediumColor[0];
 647                                                 dataImageResultPointer[1] =(unsigned int) mediumColor[1];
 648                                                 dataImageResultPointer[2] =(unsigned int) mediumColor[2];
 649                                                 nZ++;
 650                                         }
 651                                         counter++;
 652                                 }
 653                         }
 654                 }
 655         }
 656         else if(imageType == VTK_LONG)
 657         {
 658                 /*
 659                 images pointers
 660                 */
 661                 // pointers to get into the image
 662                 long* dataImagePointer1=NULL;
 663                 long* dataImagePointer2=NULL;
 664                 long* dataImageResultPointer=NULL;
 665                 // we start where the  image starts
 666                 dataImagePointer1=(long*)imageData1->GetScalarPointer(0,0,0);
 667                 dataImagePointer2=(long*)imageData2->GetScalarPointer(0,0,0);
 668                 dataImageResultPointer=(long*)imageResult->GetScalarPointer(0,0,0);
 669
 670                 /*
 671                 Image Size
 672                 */
 673                 int ext[6];
 674                 imageData1->GetExtent(ext);
 675                 int sx,sy,sz;
 676                 sx=ext[1]-ext[0]+1;
 677                 sy=ext[3]-ext[2]+1;
 678                 sz=ext[5]-ext[4]+1;
 679
 680                 sizeImage=sx*sy*sz;
 681
 682                 //-----------------
 683                 //A3
 684                 //-----------------
 685                 //walking in the image
 686                 int i=0,j=0,k=0,counter=0,nU=0,nL=0,nZ=0;
 687                 double sum1=0,sum2=0;
 688                 for(i=0;i<sx;i++)
 689                 {
 690                         for(j=0;j<sy;j++)
 691                         {
 692                                 for(k=0;k<sz;k++)
 693                                 {
 694
 695                                         // this is for getting just the grey level in that position
 696                                         //originalValue=(short)imageData->GetScalarComponentAsFloat(i,j,k,0);
 697
 698                                         // we get the pointer to the position (i,j,k)y that way we can get the
 699                                         //grey level and we can change it
 700                                         dataImagePointer1=(long*)imageData1->GetScalarPointer(i,j,k);
 701                                         dataImagePointer2=(long*)imageData2->GetScalarPointer(i,j,k);
 702                                         dataImageResultPointer=(long*)imageResult->GetScalarPointer(i,j,k);
 703
 704                                         sum1=(int)(dataImagePointer1[0]) + (int)(dataImagePointer1[1]) + (int)(dataImagePointer1[2]);
 705                                         sum1=sum1/3;
 706                                         sum2=(int)(dataImagePointer2[0]) + (int)(dataImagePointer2[1]) + (int)(dataImagePointer2[2]);
 707                                         sum2=sum2/3;
 708                                         if((sum1 - sum2) < lZeroLevel)
 709                                         {
 710                                                 dataImageResultPointer[0] =(long) lowerColor[0];
 711                                                 dataImageResultPointer[1] =(long) lowerColor[1];
 712                                                 dataImageResultPointer[2] =(long) lowerColor[2];
 713                                                 nL++;
 714                                         }
 715                                         else if((sum1 - sum2) > uZeroLevel)
 716                                         {
 717                                                 dataImageResultPointer[0] =(long) upperColor[0];
 718                                                 dataImageResultPointer[1] =(long) upperColor[1];
 719                                                 dataImageResultPointer[2] =(long) upperColor[2];
 720                                                 nU++;
 721                                         }
 722                                         else
 723                                         {
 724                                                 dataImageResultPointer[0] =(long) mediumColor[0];
 725                                                 dataImageResultPointer[1] =(long) mediumColor[1];
 726                                                 dataImageResultPointer[2] =(long) mediumColor[2];
 727                                                 nZ++;
 728                                         }
 729                                         counter++;
 730                                 }
 731                         }
 732                 }
 733         }
 734         else if(imageType == VTK_UNSIGNED_LONG)
 735         {
 736                 /*
 737                 images pointers
 738                 */
 739                 // pointers to get into the image
 740                 unsigned long* dataImagePointer1=NULL;
 741                 unsigned long* dataImagePointer2=NULL;
 742                 unsigned long* dataImageResultPointer=NULL;
 743                 // we start where the  image starts
 744                 dataImagePointer1=(unsigned long*)imageData1->GetScalarPointer(0,0,0);
 745                 dataImagePointer2=(unsigned long*)imageData2->GetScalarPointer(0,0,0);
 746                 dataImageResultPointer=(unsigned long*)imageResult->GetScalarPointer(0,0,0);
 747
 748                 /*
 749                 Image Size
 750                 */
 751                 int ext[6];
 752                 imageData1->GetExtent(ext);
 753                 int sx,sy,sz;
 754                 sx=ext[1]-ext[0]+1;
 755                 sy=ext[3]-ext[2]+1;
 756                 sz=ext[5]-ext[4]+1;
 757
 758                 sizeImage=sx*sy*sz;
 759
 760                 //-----------------
 761                 //A3
 762                 //-----------------
 763                 //walking in the image
 764                 int i=0,j=0,k=0,counter=0,nU=0,nL=0,nZ=0;
 765                 double sum1=0,sum2=0;
 766                 for(i=0;i<sx;i++)
 767                 {
 768                         for(j=0;j<sy;j++)
 769                         {
 770                                 for(k=0;k<sz;k++)
 771                                 {
 772
 773                                         // this is for getting just the grey level in that position
 774                                         //originalValue=(short)imageData->GetScalarComponentAsFloat(i,j,k,0);
 775
 776                                         // we get the pointer to the position (i,j,k)y that way we can get the
 777                                         //grey level and we can change it
 778                                         dataImagePointer1=(unsigned long*)imageData1->GetScalarPointer(i,j,k);
 779                                         dataImagePointer2=(unsigned long*)imageData2->GetScalarPointer(i,j,k);
 780                                         dataImageResultPointer=(unsigned long*)imageResult->GetScalarPointer(i,j,k);
 781
 782                                         sum1=(int)(dataImagePointer1[0]) + (int)(dataImagePointer1[1]) + (int)(dataImagePointer1[2]);
 783                                         sum1=sum1/3;
 784                                         sum2=(int)(dataImagePointer2[0]) + (int)(dataImagePointer2[1]) + (int)(dataImagePointer2[2]);
 785                                         sum2=sum2/3;
 786                                         if((sum1 - sum2) < lZeroLevel)
 787                                         {
 788                                                 dataImageResultPointer[0] =(unsigned long) lowerColor[0];
 789                                                 dataImageResultPointer[1] =(unsigned long) lowerColor[1];
 790                                                 dataImageResultPointer[2] =(unsigned long) lowerColor[2];
 791                                                 nL++;
 792                                         }
 793                                         else if((sum1 - sum2) > uZeroLevel)
 794                                         {
 795                                                 dataImageResultPointer[0] =(unsigned long) upperColor[0];
 796                                                 dataImageResultPointer[1] =(unsigned long) upperColor[1];
 797                                                 dataImageResultPointer[2] =(unsigned long) upperColor[2];
 798                                                 nU++;
 799                                         }
 800                                         else
 801                                         {
 802                                                 dataImageResultPointer[0] =(unsigned long) mediumColor[0];
 803                                                 dataImageResultPointer[1] =(unsigned long) mediumColor[1];
 804                                                 dataImageResultPointer[2] =(unsigned long) mediumColor[2];
 805                                                 nZ++;
 806                                         }
 807                                         counter++;
 808                                 }
 809                         }
 810                 }
 811         }
 812         else if(imageType == VTK_FLOAT)
 813         {
 814                 /*
 815                 images pointers
 816                 */
 817                 // pointers to get into the image
 818                 float* dataImagePointer1=NULL;
 819                 float* dataImagePointer2=NULL;
 820                 float* dataImageResultPointer=NULL;
 821                 // we start where the  image starts
 822                 dataImagePointer1=(float*)imageData1->GetScalarPointer(0,0,0);
 823                 dataImagePointer2=(float*)imageData2->GetScalarPointer(0,0,0);
 824                 dataImageResultPointer=(float*)imageResult->GetScalarPointer(0,0,0);
 825
 826                 /*
 827                 Image Size
 828                 */
 829                 int ext[6];
 830                 imageData1->GetExtent(ext);
 831                 int sx,sy,sz;
 832                 sx=ext[1]-ext[0]+1;
 833                 sy=ext[3]-ext[2]+1;
 834                 sz=ext[5]-ext[4]+1;
 835
 836                 sizeImage=sx*sy*sz;
 837
 838                 //-----------------
 839                 //A3
 840                 //-----------------
 841                 //walking in the image
 842                 int i=0,j=0,k=0,counter=0,nU=0,nL=0,nZ=0;
 843                 double sum1=0,sum2=0;
 844                 for(i=0;i<sx;i++)
 845                 {
 846                         for(j=0;j<sy;j++)
 847                         {
 848                                 for(k=0;k<sz;k++)
 849                                 {
 850
 851                                         // this is for getting just the grey level in that position
 852                                         //originalValue=(short)imageData->GetScalarComponentAsFloat(i,j,k,0);
 853
 854                                         // we get the pointer to the position (i,j,k)y that way we can get the
 855                                         //grey level and we can change it
 856                                         dataImagePointer1=(float*)imageData1->GetScalarPointer(i,j,k);
 857                                         dataImagePointer2=(float*)imageData2->GetScalarPointer(i,j,k);
 858                                         dataImageResultPointer=(float*)imageResult->GetScalarPointer(i,j,k);
 859
 860                                         sum1=(int)(dataImagePointer1[0]) + (int)(dataImagePointer1[1]) + (int)(dataImagePointer1[2]);
 861                                         sum1=sum1/3;
 862                                         sum2=(int)(dataImagePointer2[0]) + (int)(dataImagePointer2[1]) + (int)(dataImagePointer2[2]);
 863                                         sum2=sum2/3;
 864                                         if((sum1 - sum2) < lZeroLevel)
 865                                         {
 866                                                 dataImageResultPointer[0] =(float) lowerColor[0];
 867                                                 dataImageResultPointer[1] =(float) lowerColor[1];
 868                                                 dataImageResultPointer[2] =(float) lowerColor[2];
 869                                                 nL++;
 870                                         }
 871                                         else if((sum1 - sum2) > uZeroLevel)
 872                                         {
 873                                                 dataImageResultPointer[0] =(float) upperColor[0];
 874                                                 dataImageResultPointer[1] =(float) upperColor[1];
 875                                                 dataImageResultPointer[2] =(float) upperColor[2];
 876                                                 nU++;
 877                                         }
 878                                         else
 879                                         {
 880                                                 dataImageResultPointer[0] =(float) mediumColor[0];
 881                                                 dataImageResultPointer[1] =(float) mediumColor[1];
 882                                                 dataImageResultPointer[2] =(float) mediumColor[2];
 883                                                 nZ++;
 884                                         }
 885                                         counter++;
 886                                 }
 887                         }
 888                 }
 889         }
 890         else if(imageType == VTK_DOUBLE)
 891         {
 892                 /*
 893                 images pointers
 894                 */
 895                 // pointers to get into the image
 896                 double* dataImagePointer1=NULL;
 897                 double* dataImagePointer2=NULL;
 898                 double* dataImageResultPointer=NULL;
 899                 // we start where the  image starts
 900                 dataImagePointer1=(double*)imageData1->GetScalarPointer(0,0,0);
 901                 dataImagePointer2=(double*)imageData2->GetScalarPointer(0,0,0);
 902                 dataImageResultPointer=(double*)imageResult->GetScalarPointer(0,0,0);
 903
 904                 /*
 905                 Image Size
 906                 */
 907                 int ext[6];
 908                 imageData1->GetExtent(ext);
 909                 int sx,sy,sz;
 910                 sx=ext[1]-ext[0]+1;
 911                 sy=ext[3]-ext[2]+1;
 912                 sz=ext[5]-ext[4]+1;
 913
 914                 sizeImage=sx*sy*sz;
 915
 916                 //-----------------
 917                 //A3
 918                 //-----------------
 919                 //walking in the image
 920                 int i=0,j=0,k=0,counter=0,nU=0,nL=0,nZ=0;
 921                 double sum1=0,sum2=0;
 922                 for(i=0;i<sx;i++)
 923                 {
 924                         for(j=0;j<sy;j++)
 925                         {
 926                                 for(k=0;k<sz;k++)
 927                                 {
 928
 929                                         // this is for getting just the grey level in that position
 930                                         //originalValue=(short)imageData->GetScalarComponentAsFloat(i,j,k,0);
 931
 932                                         // we get the pointer to the position (i,j,k)y that way we can get the
 933                                         //grey level and we can change it
 934                                         dataImagePointer1=(double*)imageData1->GetScalarPointer(i,j,k);
 935                                         dataImagePointer2=(double*)imageData2->GetScalarPointer(i,j,k);
 936                                         dataImageResultPointer=(double*)imageResult->GetScalarPointer(i,j,k);
 937
 938                                         sum1=(int)(dataImagePointer1[0]) + (int)(dataImagePointer1[1]) + (int)(dataImagePointer1[2]);
 939                                         sum1=sum1/3;
 940                                         sum2=(int)(dataImagePointer2[0]) + (int)(dataImagePointer2[1]) + (int)(dataImagePointer2[2]);
 941                                         sum2=sum2/3;
 942                                         if((sum1 - sum2) < lZeroLevel)
 943                                         {
 944                                                 dataImageResultPointer[0] =(double) lowerColor[0];
 945                                                 dataImageResultPointer[1] =(double) lowerColor[1];
 946                                                 dataImageResultPointer[2] =(double) lowerColor[2];
 947                                                 nL++;
 948                                         }
 949                                         else if((sum1 - sum2) > uZeroLevel)
 950                                         {
 951                                                 dataImageResultPointer[0] =(double) upperColor[0];
 952                                                 dataImageResultPointer[1] =(double) upperColor[1];
 953                                                 dataImageResultPointer[2] =(double) upperColor[2];
 954                                                 nU++;
 955                                         }
 956                                         else
 957                                         {
 958                                                 dataImageResultPointer[0] =(double) mediumColor[0];
 959                                                 dataImageResultPointer[1] =(double) mediumColor[1];
 960                                                 dataImageResultPointer[2] =(double) mediumColor[2];
 961                                                 nZ++;
 962                                         }
 963                                         counter++;
 964                                 }
 965                         }
 966                 }
 967         }
 968 }
 969 /*
 970 Returns the filtered image
 971 */
 972 vtkImageData* Substraction::getSubstractedImage()
 973 {
 974         return imageResult;
 975 }
 976
 977 /*
 978         Get Image Size
 979 */
 980 int Substraction::getImageSize()
 981 {
 982         return sizeImage;
 983 }