PackRecalage/src/bbPackRecalageImageSubstraction.cxx

   1 #include "bbPackRecalageImageSubstraction.h"
   2 #include "bbPackRecalagePackage.h"
   3 namespace bbPackRecalage
   4 {
   5
   6         MyImageSubstraction::MyImageSubstraction(vtkImageData* imageData1,vtkImageData* imageData2, int uZLevel,int lZLevel, std::vector<double> uColor, std::vector<double> lColor, std::vector<double> mColor)
   7 {
   8         imageResult= vtkImageData::New();
   9         sizeImage=0;
  10         uZeroLevel=uZLevel;
  11         lZeroLevel=lZLevel;
  12         if(uColor.size() != NULL)
  13         {
  14                 upperColor[0] = uColor[0];
  15                 upperColor[1] = uColor[1];
  16                 upperColor[2] = uColor[2];
  17         }
  18         else
  19         {
  20                 upperColor[0] = 255;
  21                 upperColor[1] = 255;
  22                 upperColor[2] = 255;
  23         }
  24         if(mColor.size() != NULL)
  25         {
  26                 mediumColor[0] = mColor[0];
  27                 mediumColor[1] = mColor[1];
  28                 mediumColor[2] = mColor[2];
  29         }
  30         else
  31         {
  32                 mediumColor[0] = 125;
  33                 mediumColor[1] = 125;
  34                 mediumColor[2] = 125;
  35         }
  36         if(lColor.size() != NULL)
  37         {
  38                 lowerColor[0] = lColor[0];
  39                 lowerColor[1] = lColor[1];
  40                 lowerColor[2] = lColor[2];
  41         }
  42         else
  43         {
  44                 lowerColor[0] = 0;
  45                 lowerColor[1] = 0;
  46                 lowerColor[2] = 0;
  47         }
  48
  49         //Original image type this case is an unsigned char (3)
  50         int t=imageData1->GetScalarType();
  51         //substracting the image
  52         substractImage(imageData1, imageData2);
  53 }
  54
  55 MyImageSubstraction::~MyImageSubstraction()
  56 {
  57         if(imageResult!=NULL)imageResult->Delete();
  58 }
  59
  60 //----------------------------------------------------------------------------
  61 // Methods
  62 //----------------------------------------------------------------------------
  63
  64
  65 /*
  66 Calculate the new image and save it in the attribute imageResult
  67 it is used if the user had given the imageData
  68 */
  69 void MyImageSubstraction::substractImage(vtkImageData* imageData1, vtkImageData* imageData2)
  70 {
  71         //dimensions of the image (extent)
  72         int ext[6];
  73         //setting the dimensionality (1d or 2d or 3d )
  74     int newDim[3];
  75         //image spacing
  76     double spc[3];
  77
  78         //getting the information from the original image
  79         imageData1->GetSpacing(spc);
  80         imageData1->GetExtent(ext);
  81
  82         //this a 2d image
  83         newDim[0]=ext[1]-ext[0]+1;
  84     newDim[1]=ext[3]-ext[2]+1;
  85     newDim[2]=1;// in general it is ext[5]-ext[4]+1
  86
  87
  88         //initializing the image that represents the substracted image
  89         initialize(newDim,spc);
  90         //Time to substract
  91         substract(imageData1, imageData2);
  92 }
  93
  94 /*
  95   getting ready the imageResult
  96 */
  97 void MyImageSubstraction::initialize(int dimensions[], double spacing[])
  98 {
  99         //setting image data of the imageResult
 100         imageResult->SetScalarTypeToUnsignedChar();
 101         imageResult->SetSpacing(spacing);
 102         imageResult->SetDimensions(dimensions);
 103         imageResult->AllocateScalars();
 104         imageResult->Update();
 105 }
 106
 107 /*
 108          Setting the values for the
 109 */
 110 void MyImageSubstraction::substract(vtkImageData* imageData1, vtkImageData* imageData2)
 111 {
 112         /*
 113                 images pointers
 114         */
 115         //the new image type is unsigned short (5)
 116         int t=imageData1->GetScalarType();
 117
 118         // pointers to get into the image
 119         unsigned char* dataImagePointer1=NULL;
 120         unsigned char* dataImagePointer2=NULL;
 121         unsigned char* dataImageResultPointer=NULL;
 122         // we start where the  image starts
 123         dataImagePointer1=(unsigned char*)imageData1->GetScalarPointer(0,0,0);
 124         dataImagePointer2=(unsigned char*)imageData2->GetScalarPointer(0,0,0);
 125         dataImageResultPointer=(unsigned char*)imageResult->GetScalarPointer(0,0,0);
 126
 127         /*
 128          Image Size
 129         */
 130         int ext[6];
 131         imageData1->GetExtent(ext);
 132         int sx,sy,sz;
 133         sx=ext[1]-ext[0]+1;
 134         sy=ext[3]-ext[2]+1;
 135         sz=ext[5]-ext[4]+1;
 136
 137         sizeImage=sx*sy*sz;
 138
 139         //-----------------
 140         //A3
 141         //-----------------
 142         //walking in the image
 143         int i=0,j=0,k=0,counter=0,nU=0,nL=0,nZ=0;
 144         double sum1=0,sum2=0;
 145         for(i=0;i<sx;i++)
 146         {
 147                 for(j=0;j<sy;j++)
 148                 {
 149                         for(k=0;k<sz;k++)
 150                         {
 151
 152                                 // this is for getting just the grey level in that position
 153                                 //originalValue=(short)imageData->GetScalarComponentAsFloat(i,j,k,0);
 154
 155                                 // we get the pointer to the position (i,j,k)y that way we can get the
 156                                 //grey level and we can change it
 157                                 dataImagePointer1=(unsigned char*)imageData1->GetScalarPointer(i,j,k);
 158                                 dataImagePointer2=(unsigned char*)imageData2->GetScalarPointer(i,j,k);
 159                                 dataImageResultPointer=(unsigned char*)imageResult->GetScalarPointer(i,j,k);
 160
 161                                 sum1=(int)(dataImagePointer1[0]) + (int)(dataImagePointer1[1]) + (int)(dataImagePointer1[2]);
 162                                 sum1=sum1/3;
 163                                 sum2=(int)(dataImagePointer2[0]) + (int)(dataImagePointer2[1]) + (int)(dataImagePointer2[2]);
 164                                 sum2=sum2/3;
 165                                 if((sum1 - sum2) < lZeroLevel)
 166                                 {
 167                                         dataImageResultPointer[0] =(unsigned char) lowerColor[0];
 168                                         dataImageResultPointer[1] =(unsigned char) lowerColor[1];
 169                                         dataImageResultPointer[2] =(unsigned char) lowerColor[2];
 170                                         nL++;
 171                                 }
 172                                 else if((sum1 - sum2) > uZeroLevel)
 173                                 {
 174                                         dataImageResultPointer[0] =(unsigned char) upperColor[0];
 175                                         dataImageResultPointer[1] =(unsigned char) upperColor[1];
 176                                         dataImageResultPointer[2] =(unsigned char) upperColor[2];
 177                                         nU++;
 178                                 }
 179                                 else
 180                                 {
 181                                         dataImageResultPointer[0] =(unsigned char) mediumColor[0];
 182                                         dataImageResultPointer[1] =(unsigned char) mediumColor[1];
 183                                         dataImageResultPointer[2] =(unsigned char) mediumColor[2];
 184                                         nZ++;
 185                                 }
 186                                 counter++;
 187                         }
 188                 }
 189         }
 190 }
 191 /*
 192 Returns the filtered image
 193 */
 194 vtkImageData* MyImageSubstraction::getSubstractedImage()
 195 {
 196         return imageResult;
 197 }
 198
 199 /*
 200         Get Image Size
 201 */
 202 int MyImageSubstraction::getImageSize()
 203 {
 204         return sizeImage;
 205 }
 206
 207 BBTK_ADD_BLACK_BOX_TO_PACKAGE(PackRecalage,ImageSubstraction)
 208 BBTK_BLACK_BOX_IMPLEMENTATION(ImageSubstraction,bbtk::AtomicBlackBox);
 209 void ImageSubstraction::Process()
 210 {
 211         MyImageSubstraction* subImage = new MyImageSubstraction(bbGetInputIn1(),bbGetInputIn2(),bbGetInputIn3(),bbGetInputIn4(),bbGetInputInU(),bbGetInputInL(),bbGetInputInM());
 212
 213     bbSetOutputOut(subImage->getSubstractedImage());
 214 }
 215 void ImageSubstraction::bbUserSetDefaultValues()
 216 {
 217         bbSetInputIn1(NULL);
 218         bbSetInputIn2(NULL);
 219         bbSetInputIn3(0);
 220         bbSetInputIn4(0);
 221         std::vector<double> vector;
 222         bbSetInputInU(vector);
 223         bbSetInputInM(vector);
 224         bbSetInputInL(vector);
 225
 226 }
 227 void ImageSubstraction::bbUserInitializeProcessing()
 228 {
 229
 230 //  THE INITIALIZATION METHOD BODY :
 231 //    Here does nothing
 232 //    but this is where you should allocate the internal/output pointers
 233 //    if any
 234
 235
 236 }
 237 void ImageSubstraction::bbUserFinalizeProcessing()
 238 {
 239
 240 //  THE FINALIZATION METHOD BODY :
 241 //    Here does nothing
 242 //    but this is where you should desallocate the internal/output pointers
 243 //    if any
 244
 245 }
 246 }
 247 // EO namespace bbCreaRecalage
 248
 249