lib/Surface.cxx

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