#include "FillFilter.h"


FillFilter::FillFilter()
{
    _tolerancefill      =   50;
    _distancefill       =   500;
    _limitRecursionFill =   50000;
    _auxImageFill       =   NULL;
}

//---------------------------------------------------------------------------
FillFilter::~FillFilter()
{
    if (_auxImageFill!=NULL)
    {
        _auxImageFill->Delete();
    }
}

//---------------------------------------------------------------------------
void FillFilter::SetImage(vtkImageData *image) // virtual
{
    baseFilterManualPaint::SetImage(image);
    if (_auxImageFill!=NULL)
    {
        _auxImageFill->Delete();
    }
	_auxImageFill = vtkImageData::New();
	_auxImageFill->SetDimensions(_maxX+1,_maxY+1,_maxZ+1);
	_auxImageFill->SetOrigin(0,0,0);
	_auxImageFill->SetExtent( 0 , _maxX , 0 , _maxY , 0, _maxZ );
	_auxImageFill->SetWholeExtent( 0 , _maxX , 0 , _maxY , 0, _maxZ );
	_auxImageFill->SetScalarTypeToUnsignedChar();
	_auxImageFill->AllocateScalars();
}


//---------------------------------------------------------------------------
void FillFilter::Run() // virtual
{
    if ((_px>=_minX) && (_px<=_maxX) && (_py>=_minY) && (_py<=_maxY) && (_pz>=_minZ) && (_pz<=_maxZ))
    {
        _graylevelbasefill          = _image->GetScalarComponentAsDouble(_px,_py,_pz, 0);
        _pxfill                     = _px;
        _pyfill                     = _py;
        _pzfill                     = _pz;
        _distbasefill               = _distancefill*_distancefill;
        _countRecursiveFill         = 0;
        _countRecursiveFillProblem  = 0;
        _countProgressingFill       = 0;
        unsigned char *pImage = (unsigned char *)_auxImageFill->GetScalarPointer();
        _usingAuxImageFill=false;
        memset ( pImage , 0 , _maxX*_maxY*_maxZ );

        FillToolRecursive(_px,_py,_pz);
        printf("--\n");

        int ii,jj,kk;
        while (_countRecursiveFillProblem!=0)
        {
            _countRecursiveFillProblem  = 0;
            _usingAuxImageFill=true;
            for(ii=0;ii<=_maxX;ii++)
            {
                for(jj=0;jj<=_maxY;jj++)
                {
                    for(kk=0;kk<=_maxZ;kk++)
                    {
                        pImage=(unsigned char *)_auxImageFill->GetScalarPointer(ii,jj,kk);
                        if ( (*pImage)==1 )
                        {
                            FillToolRecursive(ii,jj,kk);
                        }
                    } // for kk
                } // for jj
            } //for ii
            printf("-\n");
        } // while

    } //if _minX _maxX _minY _maxY _minZ _maxZ
}


//---------------------------------------------------------------------------
void FillFilter::FillToolRecursive(int px,int py, int pz)
{
    _countRecursiveFill++;

    _countProgressingFill++;
    if (_countProgressingFill>200000)
    {
        printf("R %ld \n", _countRecursiveFill );
        _countProgressingFill=0;
    }

    if ((px>=_minX) && (px<=_maxX) && (py>=_minY) && (py<=_maxY) && (pz>=_minZ) && (pz<=_maxZ))
    {
        if (_usingAuxImageFill==true)
        {
        	this->CalculateMinMaxRegion(px,py,pz); //DFCH
            _auxImageFill->SetScalarComponentFromFloat (px, py, pz,0, 0);
        }
        _tmpDistfill=(px-_pxfill)*(px-_pxfill)  + (py-_pyfill)*(py-_pyfill) + (pz-_pzfill)*(pz-_pzfill);
        _tmpiglfill=_image->GetScalarComponentAsDouble(px,py,pz, 0);

        float grayLBFMTOL = _graylevelbasefill-_tolerancefill;
        float grayLBFPTOL = _graylevelbasefill+_tolerancefill;
        bool isInRange = false;
        //DFCH
        if( _RangeMin <= grayLBFMTOL && _RangeMax >= grayLBFPTOL )
        {
        	isInRange = true;
        }//fi esle
        else if( _RangeMin > grayLBFMTOL && _RangeMax >= grayLBFPTOL )
        {
        	grayLBFMTOL = _RangeMin;
        	isInRange = true;
        }//fi esle
        else if( _RangeMin <= grayLBFMTOL && _RangeMax < grayLBFPTOL )
        {
        	grayLBFPTOL = _RangeMax;
        	isInRange = true;
        }//fi esle
        else if(  ( _RangeMin <= _graylevelbasefill ) && ( _graylevelbasefill <= _RangeMax ) )
        {
        	grayLBFMTOL = _RangeMin;
        	grayLBFPTOL = _RangeMax;
        	isInRange = true;
        }//fi esle

        if( isInRange )
        {
        	_auxGrayLevelValidationFill =  (_tmpiglfill!=_graylevel) &&
        	                            (_tmpiglfill>=grayLBFMTOL) &&
        	                            (_tmpiglfill<=grayLBFPTOL) &&
        	                            (_tmpDistfill<=_distbasefill); //DFCH
        }//fi
        else
        {
        	_auxGrayLevelValidationFill = false;
        }//esle
        //DFCH
        /*_auxGrayLevelValidationFill =   (_tmpiglfill!=_graylevel) &&
                                        (_tmpiglfill>=_graylevelbasefill-_tolerancefill) &&
                                        (_tmpiglfill<=_graylevelbasefill+_tolerancefill) &&
                                        (_tmpDistfill<=_distbasefill);*/ //DFCH


        if (  _auxGrayLevelValidationFill==true )
        {
        	this->CalculateMinMaxRegion(px,py,pz); //DFCH
            _image->SetScalarComponentFromFloat (px,py,pz, 0, (float)_graylevel );

            if (_countRecursiveFill< _limitRecursionFill)
            {

                if (_2D3D==0) //2D
                {
                    if (_direction==0)  // YZ
                    {
                        //FillToolRecursive(px+1,py,pz);
                        //FillToolRecursive(px-1,py,pz);
                        FillToolRecursive(px,py+1,pz);
                        FillToolRecursive(px,py-1,pz);
                        FillToolRecursive(px,py,pz-1);
                        FillToolRecursive(px,py,pz+1);
                    }
                    if (_direction==1) // XZ
                    {
                        FillToolRecursive(px+1,py,pz);
                        FillToolRecursive(px-1,py,pz);
                        //FillToolRecursive(px,py+1,pz);
                        //FillToolRecursive(px,py-1,pz);
                        FillToolRecursive(px,py,pz-1);
                        FillToolRecursive(px,py,pz+1);
                    }
                    if (_direction==2) // XY
                    {
                        FillToolRecursive(px+1,py,pz);
                        FillToolRecursive(px,py+1,pz);
                        FillToolRecursive(px-1,py,pz);
                        FillToolRecursive(px,py-1,pz);
                        //FillToolRecursive(px,py,pz-1);
                        //FillToolRecursive(px,py,pz+1);
                    }
                } else  {   // 3D

                    FillToolRecursive(px+1,py,pz);
                    FillToolRecursive(px-1,py,pz);
                    FillToolRecursive(px,py+1,pz);
                    FillToolRecursive(px,py-1,pz);
                    FillToolRecursive(px,py,pz-1);
                    FillToolRecursive(px,py,pz+1);
                } // 2D 3D

            } //_countRecursiveFill
        } // _graylevel


        if (  (_auxGrayLevelValidationFill==true ) &&
              (_countRecursiveFill>= _limitRecursionFill)
            )
        {
            _countRecursiveFillProblem++;

                if (_2D3D==0) //2D
                {
                    if (_direction==0)  // YZ
                    {
                        //SetAuxImageFill(px+1,py,pz);
                        //SetAuxImageFill(px-1,py,pz);
                        SetAuxImageFill(px,py+1,pz);
                        SetAuxImageFill(px,py-1,pz);
                        SetAuxImageFill(px,py,pz-1);
                        SetAuxImageFill(px,py,pz+1);
                    }
                    if (_direction==1) // XZ
                    {
                        SetAuxImageFill(px+1,py,pz);
                        SetAuxImageFill(px-1,py,pz);
                        //SetAuxImageFill(px,py+1,pz);
                        //SetAuxImageFill(px,py-1,pz);
                        SetAuxImageFill(px,py,pz-1);
                        SetAuxImageFill(px,py,pz+1);
                    }
                    if (_direction==2) // XY
                    {
                        SetAuxImageFill(px+1,py,pz);
                        SetAuxImageFill(px-1,py,pz);
                        SetAuxImageFill(px,py+1,pz);
                        SetAuxImageFill(px,py-1,pz);
                        //SetAuxImageFill(px,py,pz-1);
                        //SetAuxImageFill(px,py,pz+1);
                    }
                } else  {   // 3D

                    SetAuxImageFill(px+1,py,pz);
                    SetAuxImageFill(px-1,py,pz);
                    SetAuxImageFill(px,py+1,pz);
                    SetAuxImageFill(px,py-1,pz);
                    SetAuxImageFill(px,py,pz-1);
                    SetAuxImageFill(px,py,pz+1);
                } // 2D 3D

        } // _graylevel   //_limitRecursionFill


    } //if _minX _maxX _minY _maxY _minZ _maxZ


    _countRecursiveFill--;

}

//---------------------------------------------------------------------------
void FillFilter::SetAuxImageFill(int px,int py, int pz)
{
    if ((px>=_minX) && (px<=_maxX) && (py>=_minY) && (py<=_maxY) && (pz>=_minZ) && (pz<=_maxZ))
    {
    	this->CalculateMinMaxRegion(px,py,pz); //DFCH
        _auxImageFill->SetScalarComponentFromFloat (px, py, pz,0, 1);
    }
}


//---------------------------------------------------------------------------
void FillFilter::SetToleranceFill(double tolerancefill)
{
    _tolerancefill = tolerancefill;
}

//---------------------------------------------------------------------------
void FillFilter::SetDistanceFill(int distancefill)
{
    _distancefill = distancefill;
}

//---------------------------------------------------------------------------
void FillFilter::SetRangeMin(  int min )
{
	_RangeMin  = min;
}

//---------------------------------------------------------------------------
void FillFilter::SetRangeMax(  int max )
{
	_RangeMax  = max;
}

//---------------------------------------------------------------------------
int FillFilter::GetRangeMin( )
{
	return( _RangeMin );
}

//---------------------------------------------------------------------------
int FillFilter::GetRangeMax(  )
{
	return( _RangeMax );
}