lib/maracasVisuLib/src/interface/wxWindows/widgets/manualPaint/FillFilter.cpp

   1
   2 #include "FillFilter.h"
   3
   4
   5 FillFilter::FillFilter()
   6 {
   7     _tolerancefill      =   50;
   8     _distancefill       =   500;
   9     _limitRecursionFill =   50000;
  10     _auxImageFill       =   NULL;
  11 }
  12
  13 //---------------------------------------------------------------------------
  14 FillFilter::~FillFilter()
  15 {
  16     if (_auxImageFill!=NULL)
  17     {
  18         _auxImageFill->Delete();
  19     }
  20 }
  21
  22 //---------------------------------------------------------------------------
  23 void FillFilter::SetImage(vtkImageData *image) // virtual
  24 {
  25     baseFilterManualPaint::SetImage(image);
  26     if (_auxImageFill!=NULL)
  27     {
  28         _auxImageFill->Delete();
  29     }
  30         _auxImageFill = vtkImageData::New();
  31         _auxImageFill->SetDimensions(_maxX+1,_maxY+1,_maxZ+1);
  32         _auxImageFill->SetOrigin(0,0,0);
  33         _auxImageFill->SetExtent( 0 , _maxX , 0 , _maxY , 0, _maxZ );
  34         _auxImageFill->SetWholeExtent( 0 , _maxX , 0 , _maxY , 0, _maxZ );
  35         _auxImageFill->SetScalarTypeToUnsignedChar();
  36         _auxImageFill->AllocateScalars();
  37 }
  38
  39
  40 //---------------------------------------------------------------------------
  41 void FillFilter::Run() // virtual
  42 {
  43     if ((_px>=_minX) && (_px<=_maxX) && (_py>=_minY) && (_py<=_maxY) && (_pz>=_minZ) && (_pz<=_maxZ))
  44     {
  45         _graylevelbasefill          = _image->GetScalarComponentAsDouble(_px,_py,_pz, 0);
  46         _pxfill                     = _px;
  47         _pyfill                     = _py;
  48         _pzfill                     = _pz;
  49         _distbasefill               = _distancefill*_distancefill;
  50         _countRecursiveFill         = 0;
  51         _countRecursiveFillProblem  = 0;
  52         _countProgressingFill       = 0;
  53         unsigned char *pImage = (unsigned char *)_auxImageFill->GetScalarPointer();
  54         _usingAuxImageFill=false;
  55         memset ( pImage , 0 , _maxX*_maxY*_maxZ );
  56
  57         FillToolRecursive(_px,_py,_pz);
  58         printf("--\n");
  59
  60         int ii,jj,kk;
  61         while (_countRecursiveFillProblem!=0)
  62         {
  63             _countRecursiveFillProblem  = 0;
  64             _usingAuxImageFill=true;
  65             for(ii=0;ii<=_maxX;ii++)
  66             {
  67                 for(jj=0;jj<=_maxY;jj++)
  68                 {
  69                     for(kk=0;kk<=_maxZ;kk++)
  70                     {
  71                         pImage=(unsigned char *)_auxImageFill->GetScalarPointer(ii,jj,kk);
  72                         if ( (*pImage)==1 )
  73                         {
  74                             FillToolRecursive(ii,jj,kk);
  75                         }
  76                     } // for kk
  77                 } // for jj
  78             } //for ii
  79             printf("-\n");
  80         } // while
  81
  82     } //if _minX _maxX _minY _maxY _minZ _maxZ
  83 }
  84
  85
  86 //---------------------------------------------------------------------------
  87 void FillFilter::FillToolRecursive(int px,int py, int pz)
  88 {
  89     _countRecursiveFill++;
  90
  91     _countProgressingFill++;
  92     if (_countProgressingFill>200000)
  93     {
  94         printf("R %ld \n", _countRecursiveFill );
  95         _countProgressingFill=0;
  96     }
  97
  98     if ((px>=_minX) && (px<=_maxX) && (py>=_minY) && (py<=_maxY) && (pz>=_minZ) && (pz<=_maxZ))
  99     {
 100         if (_usingAuxImageFill==true)
 101         {
 102                 this->CalculateMinMaxRegion(px,py,pz); //DFCH
 103             _auxImageFill->SetScalarComponentFromFloat (px, py, pz,0, 0);
 104         }
 105         _tmpDistfill=(px-_pxfill)*(px-_pxfill)  + (py-_pyfill)*(py-_pyfill) + (pz-_pzfill)*(pz-_pzfill);
 106         _tmpiglfill=_image->GetScalarComponentAsDouble(px,py,pz, 0);
 107
 108         float grayLBFMTOL = _graylevelbasefill-_tolerancefill;
 109         float grayLBFPTOL = _graylevelbasefill+_tolerancefill;
 110         bool isInRange = false;
 111         //DFCH
 112         if( _RangeMin <= grayLBFMTOL && _RangeMax >= grayLBFPTOL )
 113         {
 114                 isInRange = true;
 115         }//fi esle
 116         else if( _RangeMin > grayLBFMTOL && _RangeMax >= grayLBFPTOL )
 117         {
 118                 grayLBFMTOL = _RangeMin;
 119                 isInRange = true;
 120         }//fi esle
 121         else if( _RangeMin <= grayLBFMTOL && _RangeMax < grayLBFPTOL )
 122         {
 123                 grayLBFPTOL = _RangeMax;
 124                 isInRange = true;
 125         }//fi esle
 126         else if(  ( _RangeMin <= _graylevelbasefill ) && ( _graylevelbasefill <= _RangeMax ) )
 127         {
 128                 grayLBFMTOL = _RangeMin;
 129                 grayLBFPTOL = _RangeMax;
 130                 isInRange = true;
 131         }//fi esle
 132
 133         if( isInRange )
 134         {
 135                 _auxGrayLevelValidationFill =  (_tmpiglfill!=_graylevel) &&
 136                                             (_tmpiglfill>=grayLBFMTOL) &&
 137                                             (_tmpiglfill<=grayLBFPTOL) &&
 138                                             (_tmpDistfill<=_distbasefill); //DFCH
 139         }//fi
 140         else
 141         {
 142                 _auxGrayLevelValidationFill = false;
 143         }//esle
 144         //DFCH
 145         /*_auxGrayLevelValidationFill =   (_tmpiglfill!=_graylevel) &&
 146                                         (_tmpiglfill>=_graylevelbasefill-_tolerancefill) &&
 147                                         (_tmpiglfill<=_graylevelbasefill+_tolerancefill) &&
 148                                         (_tmpDistfill<=_distbasefill);*/ //DFCH
 149
 150
 151         if (  _auxGrayLevelValidationFill==true )
 152         {
 153                 this->CalculateMinMaxRegion(px,py,pz); //DFCH
 154             _image->SetScalarComponentFromFloat (px,py,pz, 0, (float)_graylevel );
 155
 156             if (_countRecursiveFill< _limitRecursionFill)
 157             {
 158
 159                 if (_2D3D==0) //2D
 160                 {
 161                     if (_direction==0)  // YZ
 162                     {
 163                         //FillToolRecursive(px+1,py,pz);
 164                         //FillToolRecursive(px-1,py,pz);
 165                         FillToolRecursive(px,py+1,pz);
 166                         FillToolRecursive(px,py-1,pz);
 167                         FillToolRecursive(px,py,pz-1);
 168                         FillToolRecursive(px,py,pz+1);
 169                     }
 170                     if (_direction==1) // XZ
 171                     {
 172                         FillToolRecursive(px+1,py,pz);
 173                         FillToolRecursive(px-1,py,pz);
 174                         //FillToolRecursive(px,py+1,pz);
 175                         //FillToolRecursive(px,py-1,pz);
 176                         FillToolRecursive(px,py,pz-1);
 177                         FillToolRecursive(px,py,pz+1);
 178                     }
 179                     if (_direction==2) // XY
 180                     {
 181                         FillToolRecursive(px+1,py,pz);
 182                         FillToolRecursive(px,py+1,pz);
 183                         FillToolRecursive(px-1,py,pz);
 184                         FillToolRecursive(px,py-1,pz);
 185                         //FillToolRecursive(px,py,pz-1);
 186                         //FillToolRecursive(px,py,pz+1);
 187                     }
 188                 } else  {   // 3D
 189
 190                     FillToolRecursive(px+1,py,pz);
 191                     FillToolRecursive(px-1,py,pz);
 192                     FillToolRecursive(px,py+1,pz);
 193                     FillToolRecursive(px,py-1,pz);
 194                     FillToolRecursive(px,py,pz-1);
 195                     FillToolRecursive(px,py,pz+1);
 196                 } // 2D 3D
 197
 198             } //_countRecursiveFill
 199         } // _graylevel
 200
 201
 202         if (  (_auxGrayLevelValidationFill==true ) &&
 203               (_countRecursiveFill>= _limitRecursionFill)
 204             )
 205         {
 206             _countRecursiveFillProblem++;
 207
 208                 if (_2D3D==0) //2D
 209                 {
 210                     if (_direction==0)  // YZ
 211                     {
 212                         //SetAuxImageFill(px+1,py,pz);
 213                         //SetAuxImageFill(px-1,py,pz);
 214                         SetAuxImageFill(px,py+1,pz);
 215                         SetAuxImageFill(px,py-1,pz);
 216                         SetAuxImageFill(px,py,pz-1);
 217                         SetAuxImageFill(px,py,pz+1);
 218                     }
 219                     if (_direction==1) // XZ
 220                     {
 221                         SetAuxImageFill(px+1,py,pz);
 222                         SetAuxImageFill(px-1,py,pz);
 223                         //SetAuxImageFill(px,py+1,pz);
 224                         //SetAuxImageFill(px,py-1,pz);
 225                         SetAuxImageFill(px,py,pz-1);
 226                         SetAuxImageFill(px,py,pz+1);
 227                     }
 228                     if (_direction==2) // XY
 229                     {
 230                         SetAuxImageFill(px+1,py,pz);
 231                         SetAuxImageFill(px-1,py,pz);
 232                         SetAuxImageFill(px,py+1,pz);
 233                         SetAuxImageFill(px,py-1,pz);
 234                         //SetAuxImageFill(px,py,pz-1);
 235                         //SetAuxImageFill(px,py,pz+1);
 236                     }
 237                 } else  {   // 3D
 238
 239                     SetAuxImageFill(px+1,py,pz);
 240                     SetAuxImageFill(px-1,py,pz);
 241                     SetAuxImageFill(px,py+1,pz);
 242                     SetAuxImageFill(px,py-1,pz);
 243                     SetAuxImageFill(px,py,pz-1);
 244                     SetAuxImageFill(px,py,pz+1);
 245                 } // 2D 3D
 246
 247         } // _graylevel   //_limitRecursionFill
 248
 249
 250     } //if _minX _maxX _minY _maxY _minZ _maxZ
 251
 252
 253     _countRecursiveFill--;
 254
 255 }
 256
 257 //---------------------------------------------------------------------------
 258 void FillFilter::SetAuxImageFill(int px,int py, int pz)
 259 {
 260     if ((px>=_minX) && (px<=_maxX) && (py>=_minY) && (py<=_maxY) && (pz>=_minZ) && (pz<=_maxZ))
 261     {
 262         this->CalculateMinMaxRegion(px,py,pz); //DFCH
 263         _auxImageFill->SetScalarComponentFromFloat (px, py, pz,0, 1);
 264     }
 265 }
 266
 267
 268 //---------------------------------------------------------------------------
 269 void FillFilter::SetToleranceFill(double tolerancefill)
 270 {
 271     _tolerancefill = tolerancefill;
 272 }
 273
 274 //---------------------------------------------------------------------------
 275 void FillFilter::SetDistanceFill(int distancefill)
 276 {
 277     _distancefill = distancefill;
 278 }
 279
 280 //---------------------------------------------------------------------------
 281 void FillFilter::SetRangeMin(  int min )
 282 {
 283         _RangeMin  = min;
 284 }
 285
 286 //---------------------------------------------------------------------------
 287 void FillFilter::SetRangeMax(  int max )
 288 {
 289         _RangeMax  = max;
 290 }
 291
 292 //---------------------------------------------------------------------------
 293 int FillFilter::GetRangeMin( )
 294 {
 295         return( _RangeMin );
 296 }
 297
 298 //---------------------------------------------------------------------------
 299 int FillFilter::GetRangeMax(  )
 300 {
 301         return( _RangeMax );
 302 }