#include <cv.h>
#include <cvaux.h>
#include <highgui.h>
#include <stdio.h>
#include <math.h>

#define LIMITE_TREINO		100		// numero de frames limite para o treinamento
#define TAM_VETOR_CORES		15		// tamanho do vetor de cores


int threshold = 60;		// limiar para a detecção de movimento do vídeo

int main()
{
	int i,j,cont,qtdeContours;
	int width, height;
	bool treinando = true;
	CvScalar pixel, vetorColor[TAM_VETOR_CORES];
	CvMemStorage* storage = cvCreateMemStorage(0);
	CvSeq* first_contour = 0;
	float **mediaBlue, **mediaGreen, **mediaRed;
	char nome[30];
	FILE *arquivo;

	IplImage* img_color; 
	IplImage* frame = 0;
	IplImage* frame_aux = 0;
	IplImage* img_aux;
	CvCapture* capture = 0;


	// lê o arquivo com as informações do vídeo de entrada
	arquivo = fopen("inicio.txt","r");
	fscanf(arquivo,"%s",&nome);
	fscanf(arquivo,"%d",&width);
	fscanf(arquivo,"%d",&height);
	fclose(arquivo);

	// inicializa um vetor de cores
	for(i=0; i<TAM_VETOR_CORES; i++)
		vetorColor[i] = CV_RGB( rand()&255, rand()&255, rand()&255 );
	
	// captura o video de entrada
	capture = cvCaptureFromAVI(nome);
	//capture = cvCaptureFromCAM(1);
	frame = cvQueryFrame(capture);
	img_color = cvCreateImage(cvSize(width,height), 8, 3); // create the image
	img_aux = cvCreateImage(cvSize(width,height), 8, 1);
	
	// Criar janelas para exibir as imagens 
	cvNamedWindow( "camera_original_wnd", 0 );
	cvNamedWindow( "camera_editada_wnd", 0 );
	
	// cria a barra que controla o Threshold
	cvCreateTrackbar( "Threshold", "camera_original_wnd", &threshold, 100, NULL );
	 
	// Move as janelas para uma coordenada x,y da tela
	cvMoveWindow("camera_original_wnd", 200, 200);
	cvMoveWindow("camera_editada_wnd", 520, 200);

	//cria o vetor que no processo de treinamento, irá armazenar a média dos pixels nos 3 canais RGB
	mediaBlue = (float **)malloc(height*sizeof(float *));
	mediaGreen = (float **)malloc(height*sizeof(float *));
	mediaRed = (float **)malloc(height*sizeof(float *));
	for(i=0; i<height; i++)
	{
		mediaBlue[i] = (float *)malloc(width*sizeof(float));
		mediaGreen[i] = (float *)malloc(width*sizeof(float));
		mediaRed[i] = (float *)malloc(width*sizeof(float));
		for(j=0; j<width; j++)
		{
			mediaBlue[i][j] = 0;
			mediaGreen[i][j] = 0;
			mediaRed[i][j] = 0;
		}
	}

	cont = 1;
	while (true)
	{
		if(!cvGrabFrame(capture)) 
			break;

		// captura um frame do vídeo
		frame = cvQueryFrame( capture );

		if (treinando)		// Processo de treinamento
		{
			// filtragem do frame capturado
			cvErode(frame, frame);		
			cvDilate(frame, frame);		
			
			// acumula os valores dos pixels de cada frame
			for(i=0; i<height; i++)
			{
				for(j=0; j<width; j++)
				{
					pixel = cvGet2D(frame,i,j);
					mediaBlue[i][j] += pixel.val[0];
					mediaGreen[i][j] += pixel.val[1];
					mediaRed[i][j] += pixel.val[2];
				}
			}
			
			// calcula a méda de cada pixel da imagem
			if (cont == LIMITE_TREINO)		// limite do treinamento
			{
				for(i=0; i<height; i++)
				{
					for(j=0; j<width; j++)
					{
						mediaBlue[i][j] /= cont;
						mediaGreen[i][j] /= cont;
						mediaRed[i][j] /= cont;
					}
				}

				// reinicializa o vídeo
				cvReleaseCapture( &capture );
				capture = cvCaptureFromAVI(nome);
				frame = cvQueryFrame( capture );

				treinando = false;
			}
			else
				cont++;
		}
		else		// processo de segmentação
		{
			// captura um frame do vídeo
			frame_aux = cvCloneImage(frame);

			// filtragem do frame capturado
			cvErode(frame_aux, frame_aux);		
			cvDilate(frame_aux, frame_aux);		
			
			// com base no treinamento identifica o que está em movimento no vídeo
			for(i=0; i<height; i++)
			{
				for(j=0; j<width; j++)
				{
					pixel = cvGet2D(frame_aux,i,j);	

					if ((abs(pixel.val[0]-mediaBlue[i][j]) > threshold) || (abs(pixel.val[1]-mediaGreen[i][j]) > threshold) || (abs(pixel.val[2]-mediaRed[i][j]) > threshold))
					{
						pixel.val[0] = 255;
						pixel.val[1] = 255;
						pixel.val[2] = 255;
						cvSet2D(img_color,height-1-i,j,pixel);
						cvSet2D(img_aux,height-1-i,j,pixel);
					}
					else
					{
						pixel.val[0] = 0;
						pixel.val[1] = 0;
						pixel.val[2] = 0;
						cvSet2D(img_color,height-1-i,j,pixel);
						cvSet2D(img_aux,height-1-i,j,pixel);
					}
				}
			}
			
			// encontra os contornos ativos e marca com cores diferentes
			cvDilate(img_aux, img_aux);
			cvDilate(img_aux, img_aux);
			cvDilate(img_aux, img_aux);
			cvDilate(img_color, img_color);

			// desenha os contornos ativos
			cvFindContours(img_aux, storage, &first_contour, sizeof(CvContour), CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE);
			int k = 0;
			for( ; first_contour != 0; first_contour = first_contour->h_next )
			{
				if (fabs(cvContourArea(first_contour)) > 40)	// 
				{
					cvDrawContours(img_color, first_contour, vetorColor[k], CV_RGB(255,255,255), 0, 0, 8 );
					k++;
				}

				if (k == TAM_VETOR_CORES)
					break;
			}
			
			// mostra a imagem original e o resultado da segmentação
			cvShowImage("camera_original_wnd", frame );
			cvShowImage( "camera_editada_wnd", img_color);			
		}

		if(cvWaitKey(20) >= 0)
			break;
	}

	/* Desalocar imagens */
	cvReleaseImage(&img_color);
	cvReleaseImage(&img_aux);
	cvReleaseCapture(&capture);

	for(i=0; i<height; i++)
	{
		free(mediaBlue[i]);
		free(mediaGreen[i]);
		free(mediaRed[i]);
	}
	free(mediaBlue);
	free(mediaGreen);
	free(mediaRed);
	  
	/* Desalocar janelas*/
	cvDestroyWindow( "camera_original_wnd" );
	cvDestroyWindow( "camera_editada_wnd" );
	  
	return 0;
}