#include "bbUtilitiesMetzRegionGrowing.h"
#include "bbUtilitiesPackage.h"
namespace bbUtilities
{

BBTK_ADD_BLACK_BOX_TO_PACKAGE(Utilities,MetzRegionGrowing)
//BBTK_USER_BLACK_BOX_IMPLEMENTATION(MetzRegionGrowing,bbtk::AtomicBlackBox);
BBTK_BLACK_BOX_IMPLEMENTATION(MetzRegionGrowing,bbtk::AtomicBlackBox);

void MetzRegionGrowing::Process()
{
	initialImage=bbGetInputInImage();
	upper=(unsigned short)bbGetInputUpper();
	lower =(unsigned short)bbGetInputLower();
	std::vector<int> inputPoint = bbGetInputSeedPoint();
	int size =inputPoint.size();

	if(inputPoint.size()==3)
		seedPoint=inputPoint;
	
	if(filteredImage == NULL)
		filteredImage = vtkImageData::New();
	
	double* spc = initialImage->GetSpacing();
	initialImage->GetExtent(ext);  
	filteredImage->SetSpacing(spc[0], spc[1], spc[2]);
    filteredImage->SetScalarTypeToInt();
    filteredImage->SetNumberOfScalarComponents(1);
    filteredImage->SetExtent(ext);
    filteredImage->AllocateScalars();

	for(int i=ext[0]; i<=ext[1]; i++)
	{
		for(int j=ext[2]; j<=ext[3]; j++)
		{
			for(int  k=ext[4]; k<=ext[5]; k++)
			{
				int * imagptr= ( int*)filteredImage->GetScalarPointer(i,j,k);
				*imagptr=NO_VISITADO;
			}
		}
	}

	int seedXpoint = seedPoint[0];
	int	seedYpoint = seedPoint[1]; 
    int	seedZpoint = seedPoint[2];
    connectivityMONIK(seedXpoint, seedYpoint, seedZpoint);

	for(int i=ext[0]; i<=ext[1]; i++)
	{
		for(int j=ext[2]; j<=ext[3]; j++)
		{
			for(int  k=ext[4]; k<=ext[5]; k++)
			{
				int * imagptr= (int*)filteredImage->GetScalarPointer(i,j,k);
				int grey=*imagptr;

				if(grey == INVALIDO)
				{
					*imagptr=0;
				}
				else if (grey == VALIDO)
				{
					*imagptr=2000;
				}
				else if (grey == NO_VISITADO)
				{
					*imagptr=0;
				}
			}
		}
	}
	bbSetOutputOutImage(filteredImage);
}


void MetzRegionGrowing::bbUserSetDefaultValues()
{

	upper=1900;
	lower=1174;
	bbSetInputInImage(NULL);
	bbSetOutputOutImage(NULL);
	bbSetInputUpper(upper);
	bbSetInputLower(lower);
	seedPoint.push_back(0);
	seedPoint.push_back(0);
	seedPoint.push_back(0);
	bbSetInputSeedPoint(seedPoint);
	initialImage=NULL;
    filteredImage=NULL;
	voxels=0;

}
void MetzRegionGrowing::bbUserInitializeProcessing()
{

}
void MetzRegionGrowing::bbUserFinalizeProcessing()
{

}

//------------------------------------------------


void MetzRegionGrowing::invalidateSegment(int x, int y ,int z)
{
	for(int p = x-RADIO; p < x+RADIO; p++)
	{
		for(int q = y-RADIO; q < y+RADIO; q++)
		{
			for(int r = z-RADIO; r < z+RADIO; r++)
			{
				if(pow(p-x,2)+pow(q-y,2)+pow(r-z,2)<pow(RADIO, 2))
				{
					int * imagptr= (int*)filteredImage->GetScalarPointer(p,q,r);
					int grey=*imagptr;
					mark(p,q,r,INVALIDO);
				}
			}
		}
    }
}

int MetzRegionGrowing::countValidPoints (int x, int y, int z)
{
	int voxels=0;
	for(int p = x-RADIO; p < x+RADIO; p++)
	{
		for(int q = y-RADIO; q < y+RADIO; q++)
		{
			for(int r = z-RADIO; r < z+RADIO; r++)
			{
				if(p >=ext[0]  && p <= ext[1]  && q >=ext[2]  && q <= ext[3] && r >=ext[4]  && r <= ext[5])
				{
					if(pow(p-x,2)+pow(q-y,2)+pow(r-z,2)<=pow(RADIO, 2))
					{
						int * imagptr= (int*)filteredImage->GetScalarPointer(p,q,r);
						int grey=*imagptr;
						if(grey == VALIDO)
						{
							voxels++;
						}
					}
				}
			}
		}
    }
	return voxels;
}


void MetzRegionGrowing:: connectivityMONIK (int x, int y, int z)
{	
	MetzData* metzData= new MetzData(x,y,z);
    unsigned short * imagptr= (unsigned short*)initialImage->GetScalarPointer(x,y,z);
	unsigned short greyLevel =(unsigned short)*imagptr;
	
	if ( (greyLevel >= lower) && (greyLevel<= upper))
	{
	    mark(x,y,z,VALIDO);
		bool repeat=false;
		secondIteration.push_back(metzData);
		int i = 1;
		
		while(secondIteration.size() > 0)
		{
			if(repeat)
			{
				for(int j=0; j < secondIteration.size();j++ )
				{	
				    MetzData* point = secondIteration.at(j);
					int px=point->getX();
					int py=point->getY();
					int pz=point->getZ();
					
					int totalVoxels = countValidPoints(px,py,pz);
					double volEsfera =(4/3)*PI* pow(RADIO,3);
					
					if(totalVoxels == (int)volEsfera)
					{
						invalidateSegment(px,py,pz);
						std::vector<MetzData*>::iterator iterator;
						iterator = secondIteration.begin()+j;
						secondIteration.erase(iterator);
					}
					/*
					if(totalVoxels >= VOXELS_LIMIT)
					{
						mark(px,py,pz,INVALIDO);
						std::vector<MetzData*>::iterator iterator;
						iterator = secondIteration.begin()+j;
						secondIteration.erase(iterator);
					}
					*/
				 }
			  }
		      
			for(int j=0; j < secondIteration.size();j++ )
			{
				MetzData* point = secondIteration.at(j);
				int px=point->getX();
                int py=point->getY();
				int pz=point->getZ();
				addNeighborsToVector(point->getX(),point->getY(),point->getZ(),&thirdIteration,-1); 
			}
			int totalV = thirdIteration.size() + secondIteration.size();
			
			std::cout << "Total voxeles" << totalV << std::endl;
			if(totalV >= VOXELS_LIMIT)
			{
				thirdIteration.clear();
				repeat=true;
				i--;

			}
			else
			{
				secondIteration.clear();
				secondIteration=thirdIteration;
				thirdIteration.clear();
			}
			i++;
		}
		std::cout << "total iteraciones " << i << std::endl;
	}
	else
	{
       mark(x,y,z,INVALIDO);
	}	
}

void MetzRegionGrowing::addNeighborsToVector(int x, int y, int z, std::vector<MetzData*>* v, int it)
{	
	unsigned short * imagptr;
    unsigned short greyLeveli;
	int* filtptr;
	int greyLevelf;
	
    for(int i=x-1; i<=x+1; i++)
	{
		for(int j=y-1; j<=y+1; j++)
		{
			for(int  k=z-1; k<=z+1; k++)
			{
				if( i >=ext[0]  && i <= ext[1] && j >=ext[2] && j <= ext[3] 
					&& k >=ext[4]  && k <= ext[5] && (i!=x || j!=y || k!=z) )
				{
					filtptr= (int*) filteredImage->GetScalarPointer(i,j,k);
					greyLevelf=(int)*filtptr;
					if(greyLevelf == NO_VISITADO )
					{
						imagptr= (unsigned short*)initialImage->GetScalarPointer(i,j,k);
						greyLeveli =(unsigned short)*imagptr;
						if(greyLeveli >= lower && greyLeveli <= upper)
						{
							mark(i,j,k,VALIDO);
							MetzData* point = new MetzData(i,j,k); 	
						    v->push_back(point);
						}
						else
						{
							mark(i,j,k,INVALIDO);
						}
						   
					}
					else
					{
					//std::cout << "VISITADO" << std::endl;
					}
						 
				}
					
			}
		}
	}
}

void MetzRegionGrowing::cleanVector(std::vector<MetzData*>* v)
{
	for(int i= 0 ; i < v->size(); i++)
	{
		MetzData* point = v->at(i);
		delete point;
	}
	v->clear();
}

void MetzRegionGrowing::mark(int x,int y,int z, int it)
{
	 int * imagptr= (int*) filteredImage->GetScalarPointer(x,y,z);
	*imagptr = it;
}

bool MetzRegionGrowing::isMarked(int x,int y,int z)
{
	int * imagptr= (int*)filteredImage->GetScalarPointer(x,y,z);
	int greyLevel =(int)*imagptr;
	if(greyLevel == VALIDO ||  greyLevel == INVALIDO)
	{
		return true;	
	}
	imagptr = NULL;
	return false;
}
}
// EO namespace bbUtilities