#include "transicao.h"
#include "BCSLtable.h"


extern int WIDTH, HEIGHT;

void recuperarPadrao(IplImage* img_positiva, IplImage* img_negativa, IplImage* img_dest, int max1, int max2, int sentido)
{
	int i,j;
	CvScalar pP, pN, pixel, pixelAnt, preto;
	
	
	preto.val[0] = preto.val[1] = preto.val[2] = 0;

	for(i=0; i<max1; i++)
	{
		for(j=0; j<max2; j++)
		{
			if (sentido == 1)		//se sentido vertical (padrao com faixas verticais)
			{
				pP = cvGet2D(img_positiva,i,j); 
				pN = cvGet2D(img_negativa,i,j);
			}
			else
			{
				pP = cvGet2D(img_positiva,j,i); 
				pN = cvGet2D(img_negativa,j,i);
			}

			pixel.val[0] = pP.val[0] - pN.val[0];
			pixel.val[1] = pP.val[1] - pN.val[1];
			pixel.val[2] = pP.val[2] - pN.val[2];
			
			if ((pixel.val[0] > THRESHOLD)||(pixel.val[1] > THRESHOLD)||(pixel.val[2] > THRESHOLD))
			{
				if ((pixel.val[0] > pixel.val[1]) && (pixel.val[0] > pixel.val[2]))
				{
					pixel.val[0] = 255;
					pixel.val[1] = 0;
					pixel.val[2] = 0;
				}
				else if ((pixel.val[1] > pixel.val[0]) && (pixel.val[1] > pixel.val[2]))
				{
					pixel.val[0] = 0;
					pixel.val[1] = 255;
					pixel.val[2] = 0;
				}
				else if ((pixel.val[2] > pixel.val[0]) && (pixel.val[2] > pixel.val[1]))
				{
					pixel.val[0] = 0;
					pixel.val[1] = 0;
					pixel.val[2] = 255;
				}
				
				if (sentido == 1)		//se sentido vertical (padrao com faixas verticais)
					cvSet2D(img_dest,i,j,pixel);
				else
					cvSet2D(img_dest,j,i,pixel);
			}
			else
			{
				if (sentido == 1)		//se sentido vertical (padrao com faixas verticais)
					cvSet2D(img_dest,i,j,preto);
				else
					cvSet2D(img_dest,j,i,preto);
			}
		}
	}
}

void encontarTransicao(noMat **pontos, IplImage* img_positiva1, IplImage* img_positiva2, int max1, int max2, int sentido)
{
	int i,j, id;
	bool primeiraTransicao;		// descarta a primeira transicao, por causa do fundo preto
	int cor1e, cor1d, cor2e, cor2d;
	PX pixel, pixelAnt;

	for(i=0; i<max1; i++)
	{
		pixelAnt.px.val[0] = pixelAnt.px.val[1] = pixelAnt.px.val[2] = 0;
		primeiraTransicao = true;

		for(j=0; j<max2; j++)
		{
			if (sentido == 1)		//se sentido vertical (padrao com faixas verticais)
			{
				pixel.px = cvGet2D(img_positiva1,i,j);
				pixel.i = i;
				pixel.j = j;
			}
			else
			{
				pixel.px = cvGet2D(img_positiva1,j,i);
				pixel.i = i;
				pixel.j = j;
			}

			if ((pixel.px.val[0] > THRESHOLD)||(pixel.px.val[1] > THRESHOLD)||(pixel.px.val[2] > THRESHOLD))
			{
				// se houver transição
				if ((pixel.px.val[0] != pixelAnt.px.val[0])||(pixel.px.val[1] != pixelAnt.px.val[1])||(pixel.px.val[2] != pixelAnt.px.val[2]))
				{
					if (!primeiraTransicao)
					{
						cor1e = getCodigoCor(pixelAnt.px);
						cor1d = getCodigoCor(pixel.px);
						
						if (sentido == 1)		//se sentido vertical (padrao com faixas verticais)
						{
							cor2e = getCodigoCor(cvGet2D(img_positiva2,pixelAnt.i,pixelAnt.j-10));
							cor2d = getCodigoCor(cvGet2D(img_positiva2,pixel.i,pixel.j+10));
							id = getBcslStripeCode(3,cor1e,cor1d,cor2e,cor2d);
							pontos[i][j].x = id;
						}
						else
						{
							cor2e = getCodigoCor(cvGet2D(img_positiva2,pixelAnt.j-10,pixelAnt.i));
							cor2d = getCodigoCor(cvGet2D(img_positiva2,pixel.j+10,pixel.i));
							id = getBcslStripeCode(3,cor1e,cor1d,cor2e,cor2d);
							pontos[j][i].y = id;
						}
					}
					else
						primeiraTransicao = false;

					pixelAnt = pixel;
				}
			}
		}
	}
}

void encontarTransicaoLaplace(noMat **pontos, IplImage* img_laplace, IplImage* img_positiva1, IplImage* img_positiva2, int max1, int max2, int sentido)
{
	int i, j, id, ajuste = 10;
	int cor1e, cor1d, cor2e, cor2d;
	PX pixel;

	for(i=0; i<max1; i++)
	{
		for(j=11; j<max2-11; j++)
		{
			if (sentido == 1)		//se sentido vertical (padrao com faixas verticais)
				pixel.px = cvGet2D(img_laplace,i,j);
			else
				pixel.px = cvGet2D(img_laplace,j,i);
			
			// se houver transição
			if ((pixel.px.val[0] > THRESHOLD)||(pixel.px.val[1] > THRESHOLD)||(pixel.px.val[2] > THRESHOLD))
			{
				if (sentido == 1)		//se sentido vertical (padrao com faixas verticais)
				{
					cor1e = getCodigoCor(cvGet2D(img_positiva1,i,j-ajuste));
					cor1d = getCodigoCor(cvGet2D(img_positiva1,i,j+ajuste));
					cor2e = getCodigoCor(cvGet2D(img_positiva2,i,j-ajuste));
					cor2d = getCodigoCor(cvGet2D(img_positiva2,i,j+ajuste));
					id = getBcslStripeCode(3,cor1e,cor1d,cor2e,cor2d);
					if ((id >= 0)&&(id <= 35))
						pontos[i][j].x = id;
				}
				else
				{
					cor1e = getCodigoCor(cvGet2D(img_positiva1,j-ajuste,i));
					cor1d = getCodigoCor(cvGet2D(img_positiva1,j+ajuste,i));
					cor2e = getCodigoCor(cvGet2D(img_positiva2,j-ajuste,i));
					cor2d = getCodigoCor(cvGet2D(img_positiva2,j+ajuste,i));
					id = getBcslStripeCode(3,cor1e,cor1d,cor2e,cor2d);
					if ((id >= 0)&&(id <= 35))
						pontos[j][i].y = id;
				}
			}
		}
	}
}

void setVP(MATRIZ_ID pontosCam1[36][36], noMat **pontos)
{
	int i,j;

	for(i=0;i<HEIGHT;i++)
	{
		for(j=0;j<WIDTH;j++)
		{
			if (((pontos[i][j].x != -1)&&(pontos[i][j].y != -1))&&(pontosCam1[pontos[i][j].x][pontos[i][j].y].flag == 0))
			{
				pontosCam1[pontos[i][j].x][pontos[i][j].y].posX = j;
				pontosCam1[pontos[i][j].x][pontos[i][j].y].posY = i;
				pontosCam1[pontos[i][j].x][pontos[i][j].y].flag = 1;
			}
		}
	}
}

int getCodigoCor(CvScalar pixel)
{
	if ((pixel.val[0] > pixel.val[1]) && (pixel.val[0] > pixel.val[2]))
		return 3;
	else if ((pixel.val[1] > pixel.val[0]) && (pixel.val[1] > pixel.val[2]))
		return 2;
	else if ((pixel.val[2] > pixel.val[0]) && (pixel.val[2] > pixel.val[1]))
		return 1;
	else
		return 0;
}

IplImage* mostrarPontos(noMat **pontos)
{
	int i,j;
	IplImage* imgPontos;
	CvScalar branco,preto;

	branco.val[0] = branco.val[1] = branco.val[2] = 255;
	preto.val[0] = preto.val[1] = preto.val[2] = 0;

	imgPontos = cvCreateImage(cvSize(WIDTH,HEIGHT), IPL_DEPTH_32F, 3);
	
	int cont = 0;
	for(i=0;i<HEIGHT;i++)
	{
		for(j=0;j<WIDTH;j++)
		{
			if ((pontos[i][j].x != -1)&&(pontos[i][j].y != -1))
			{
				cvSet2D(imgPontos,i,j,preto);
				cont++;
			}
			else
				cvSet2D(imgPontos,i,j,branco);
		}
	}
	printf("CONTADOR: %d",cont);

	return imgPontos;
}

noMat **initMatriz()
{
	int i,j;
	noMat **p;

	p = (noMat **)malloc(HEIGHT*sizeof(noMat *));
	for(i=0;i<HEIGHT;i++)
	{
		p[i] = (noMat *)malloc(WIDTH*sizeof(noMat));
		for(j=0;j<WIDTH;j++)
		{
			p[i][j].x = -1;
			p[i][j].y = -1;
		}
	}
	return p;
}

void deleteMatriz(noMat **pontos)
{
	int i;

	for(i=0;i<HEIGHT;i++)
		free(pontos[i]);
	free(pontos);
}