/* Programa para captura de imagens com uma camera */
/* Trabalho 1 - Fundamentos da Computacao Grafica  */
/* 2004.1     - Marcelo Gattass                    */

#include <stdio.h>
#include <time.h>
#include <stdlib.h>

#include "glut.h"
#include "imvideocapture.h"  /* modulo de captura de imagens de cameras */

#include "filters.h"
#include "image.h"           /* nosso modulo de imagens                 */
#include "hide_background.h"
#include "find_edges.h"
#include "vectorization.h"

#define NFRAMES 100
#define N_IMG_AUX 9

/* Variaveis Globais */
int width=640, height=480;   /* largura e altura da janela                  */
imVideoCapture* myVideoCap;  /* video capturado                             */
unsigned char *data=NULL;    /* aponta para o buffer RGB da imagem corrente */
unsigned char *displayed_image=NULL;
unsigned char showOriginal=1;
unsigned char extractionMode=1;
Image curr_image=NULL;
Image img_aux[N_IMG_AUX];
Image bmask=NULL;
objectSet objects_;
double pixel2MM;
double porcent_found_=0;
int porcent_count_=0;
int pattern_found_=0;

/* funcao (callback) chamada toda vez que ocorre um evendo de display na glut */
/* ou seja, quando a janela e' exibida.                                       */
void display(void) 
{
  int i, j, xc, yc; 
  char msg[255];

  /* define a projecao ortografica em xy na janela {(0,0), (width,height)}   */
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluOrtho2D (0.0, (GLdouble)width, 0.0, (GLdouble)height);
  glMatrixMode(GL_MODELVIEW);
  glLoadIdentity();
  
  /* Desenha a imagem capturada a partir da posicao (0,0) da janela */
  glRasterPos2f(0.f,0.f); 

  displayed_image = data;
  objects_.clear();

  if(!showOriginal)
  {
    if(curr_image!=NULL) 
	{
	  switch(extractionMode)
	  {
	  case 1:
		  blackAndWhite(data, imgGetBuffer(img_aux[1]), width, height);
		  gaussiano2(imgGetBuffer(img_aux[1]), imgGetBuffer(img_aux[2]), width, height);
		  displayed_image = imgGetBuffer(img_aux[2]);
		  break;
	  case 2:
		  blackAndWhite(data, data, width, height);
		  canny(data, imgGetBuffer(img_aux[1]), imgGetBuffer(img_aux[2]), width, height);
		  displayed_image = imgGetBuffer(img_aux[1]);
		  break;
	  case 3:
		  blackAndWhite(data, data, width, height);
		  gaussiano3(data, imgGetBuffer(img_aux[1]), width, height);
		  canny(imgGetBuffer(img_aux[1]), imgGetBuffer(img_aux[2]), imgGetBuffer(img_aux[3]), width, height);
		  displayed_image = imgGetBuffer(img_aux[2]);
		  break;
	  case 4:
		  blackAndWhite(data, imgGetBuffer(img_aux[1]), width, height);
		  gaussiano2(imgGetBuffer(img_aux[1]), imgGetBuffer(img_aux[2]), width, height);
		  canny(imgGetBuffer(img_aux[2]), imgGetBuffer(img_aux[3]), imgGetBuffer(img_aux[4]), width, height);
		  dilatation(imgGetBuffer(img_aux[3]), imgGetBuffer(img_aux[4]), width, height);
		  erosion(imgGetBuffer(img_aux[4]), imgGetBuffer(img_aux[5]), width, height);
		  displayed_image = imgGetBuffer(img_aux[5]);
		  break;
	  case 5:
		  blackAndWhite(data, imgGetBuffer(img_aux[1]), width, height);
		  gaussiano2(imgGetBuffer(img_aux[1]), imgGetBuffer(img_aux[2]), width, height);
		  sobel(imgGetBuffer(img_aux[2]), imgGetBuffer(img_aux[3]), width, height);
		  makeMask(imgGetBuffer(img_aux[3]), imgGetBuffer(img_aux[4]), 240, width, height);
		  displayed_image = imgGetBuffer(img_aux[4]);
		  break;
	  case 6:
		  blackAndWhite(data, imgGetBuffer(img_aux[1]), width, height);
		  gaussiano2(imgGetBuffer(img_aux[1]), imgGetBuffer(img_aux[2]), width, height);
		  canny(imgGetBuffer(img_aux[2]), imgGetBuffer(img_aux[3]), imgGetBuffer(img_aux[4]), width, height);
		  dilatation(imgGetBuffer(img_aux[3]), imgGetBuffer(img_aux[4]), width, height);
		  erosion(imgGetBuffer(img_aux[4]), imgGetBuffer(img_aux[5]), width, height);
		  vectorizeMask2(imgGetBuffer(img_aux[5]), imgGetBuffer(img_aux[6]), objects_, width, height);
		  displayed_image = imgGetBuffer(img_aux[6]);
		  break;
	  case 7:
		  blackAndWhite(data, imgGetBuffer(img_aux[1]), width, height);
		  gaussiano2(imgGetBuffer(img_aux[1]), imgGetBuffer(img_aux[2]), width, height);
		  canny(imgGetBuffer(img_aux[2]), imgGetBuffer(img_aux[3]), imgGetBuffer(img_aux[4]), width, height);
		  vectorizeMask2(imgGetBuffer(img_aux[3]), imgGetBuffer(img_aux[6]), objects_, width, height);
		  displayed_image = data;//imgGetBuffer(img_aux[7]);
		  break;
	  case 8:
		  blackAndWhite(data, imgGetBuffer(img_aux[1]), width, height);
		  gaussiano2(imgGetBuffer(img_aux[1]), imgGetBuffer(img_aux[2]), width, height);
		  canny(imgGetBuffer(img_aux[2]), imgGetBuffer(img_aux[3]), imgGetBuffer(img_aux[4]), width, height);
		  dilatation(imgGetBuffer(img_aux[3]), imgGetBuffer(img_aux[4]), width, height);
		  erosion(imgGetBuffer(img_aux[4]), imgGetBuffer(img_aux[5]), width, height);
		  vectorizeMask2(imgGetBuffer(img_aux[5]), imgGetBuffer(img_aux[6]), objects_, width, height);
		  getCriticalPoints(objects_, data, width, height);
		  displayed_image = data;//imgGetBuffer(img_aux[7]);
		  break;
	  case 9:
		  blackAndWhite(data, data, width, height);
		  gaussiano1(data, imgGetBuffer(img_aux[1]), width, height);
		  laplaciano(imgGetBuffer(img_aux[1]), imgGetBuffer(img_aux[2]), width, height);
		  displayed_image = imgGetBuffer(img_aux[2]);
		  break;
	  }
	}
  }

  drawObjects(objects_, displayed_image, width, height);

  if(displayed_image) glDrawPixels (width, height, GL_BGR_EXT, GL_UNSIGNED_BYTE, (GLubyte *) displayed_image);
  
  /* Desenha o numero do frame na imagem */
  glColor3f(1.0f,0.0f,0.0f); 

  porcent_count_++;

  if(porcent_count_==100)
  {
	porcent_count_ = 0;
	porcent_found_ = pattern_found_;
	pattern_found_ = 0;
  }

  pixel2MM = 1;
  for(i=0; i<objects_.size(); i++)
  {
	if(objects_[i].isPattern) 
	{
	  pixel2MM = 26.0 / objects_[i].perimeter;
	  pattern_found_++;
	  break;
	}
  }

  for(i=0; i<objects_.size(); i++)
  {
	xc = objects_[i].center.x;
	yc = objects_[i].center.y;

	sprintf(msg, "%s\0", (char*)objects_[i].name.c_str());
	glRasterPos2f(xc, yc); 
	for (j=0; msg[j]; j++) 
	  glutBitmapCharacter(GLUT_BITMAP_HELVETICA_10, msg[j]);

//	sprintf(msg, "Ratio = %4.4f\0", objects_[i].perimeter / objects_[i].area);
//	glRasterPos2f(xc, yc-10); 
//	for (j=0; msg[j]; j++) 
//	  glutBitmapCharacter(GLUT_BITMAP_HELVETICA_10, msg[j]);

	sprintf(msg, "Perimetro = %4.2fcm\0", objects_[i].perimeter * pixel2MM);
	glRasterPos2f(xc, yc-10); 
	for (j=0; msg[j]; j++) 
	  glutBitmapCharacter(GLUT_BITMAP_HELVETICA_10, msg[j]);

	sprintf(msg, "Area = %6.2fcm2\0", objects_[i].area * (pixel2MM*pixel2MM));
	glRasterPos2f(xc, yc-20); 
	for (j=0; msg[j]; j++) 
	  glutBitmapCharacter(GLUT_BITMAP_HELVETICA_10, msg[j]);
  }

  sprintf(msg,"Found:%4.2f\0",porcent_found_);
  glColor3f(1.0f,0.0f,0.0f); 
  glRasterPos2f(10.f,10.f); 
  for (j=0; msg[j]; j++) 
       glutBitmapCharacter(GLUT_BITMAP_HELVETICA_12,msg[j]);

  glutSwapBuffers();
} /* fim da callback de DISPLAY */


/* funcao (callback) chamada toda vez que ocorre um evendo de reshape na glut */
/* ou seja, quando a janela muda de tamanho.                                  */
void reshape(int w, int h)
{
 int i;
 glViewport(0, 0, w, h);
 width = w;
 height = h;
 if(curr_image) imgDestroy(curr_image);
 if(bmask) imgDestroy(bmask);
 curr_image = imgCreate(width, height);
 bmask = imgCreate(width, height);
 for(i=0; i<N_IMG_AUX; i++) 
 {
  if(img_aux[i]) imgDestroy(img_aux[i]);
  img_aux[i] = imgCreate(width, height);
 }
} /* fim da callback de RESHAPE */


/* funcao (callback) chamada toda vez que nao ocorre nenhum evento na glut */
/* ou seja, quando o usuario não gera eventos (usuario tem prioridade).    */
void idle(void)
{
  data = imgGetBuffer(curr_image);

  if (imVideoCaptureLive(myVideoCap, -1))
  {
    imVideoCaptureFrame(myVideoCap, data, 1000);
  }

//  imVideoCaptureFrame(myVideoCap, data, IM_RGB, 1000);

  display( );
}

/* funcao (callback) chamada toda vez que um evento de teclado na glut */
void parsekey(unsigned char key, int x, int y)
{
 int i;
// Image avg;
 switch (key) {
  case 27:                                        /* ESC = finaliza */
   printf("\nFinalizando...\n");
   imVideoCaptureDisconnect(myVideoCap);
   imVideoCaptureDestroy(myVideoCap);
   if(curr_image) imgDestroy(curr_image);
   for(i=0; i<N_IMG_AUX; i++) 
    if(img_aux[i]) imgDestroy(img_aux[i]);
   if(bmask) imgDestroy(bmask);
   exit(1);
  case ' ':                                      /* troca o modo da Captura */
   if (imVideoCaptureLive(myVideoCap, IMVC_QUERY))
     imVideoCaptureLive(myVideoCap, 0);
   else
     imVideoCaptureLive(myVideoCap, 1);
   break;

  case 's':                                     /* mostra o dialogo de ajuste de video */
      imVideoCaptureShowSourceDialog(myVideoCap, NULL);
   break;

  case '1':
	  extractionMode = 1; //Gradiente
	  break;

  case '2':
	  extractionMode = 2; //
	  break;

  case '3':
	  extractionMode = 3; //
	  break;

  case '4':
	  extractionMode = 4; //
	  break;

  case '5':
	  extractionMode = 5; //
	  break;

  case '6':
	  extractionMode = 6; //
	  break;

  case '7':
	  extractionMode = 7; //
	  break;

  case '8':
	  extractionMode = 8; //
	  break;

  case '9':
	  extractionMode = 9; //
	  break;

  case 'p':                                    /* calcula uma imagem media */
      printf("\nTirando foto...\n");
//	  imgWriteBMP("picture_display.bmp", displayed_image);
	  writeRGBtoBMP("picture_display.bmp", width, height, displayed_image);
	  writeRGBtoBMP("picture_img.bmp", width, height, data);
	  break;

  case 'f':                                    /* calcula uma imagem media */
	  if(curr_image!=NULL)
	  {
		if(showOriginal)
		{
          showOriginal = 0;
          printf("\nMostrar mascara...\n");
		} else
		{
          showOriginal = 1;
          printf("\nMostrar imagem...\n");
		}
	  }
	  break;

  default:
   glutPostRedisplay();
   return;
 }
}


/* Funcao para inicializar a camera */
int initCamera( )
{
  /* captura a entrada de video */
  myVideoCap = imVideoCaptureCreate();
  if (!myVideoCap) {
      printf("Nao capturou a camera\n"); return 0;
  }
 
  /* conects the device */
  if (!imVideoCaptureConnect(myVideoCap, 0)) {
    imVideoCaptureDestroy(myVideoCap);
    printf("Can not connect to capture device.\n");  return 0;
  }

  if (!imVideoCaptureLive(myVideoCap, 1)) {
    imVideoCaptureDisconnect(myVideoCap);
    imVideoCaptureDestroy(myVideoCap);
    printf("Can not activate capturing.\n");  return 0;
  }

  /* mostra o dialogo de captura da camera */
  imVideoCaptureShowFormatDialog(myVideoCap, NULL);

  /* determina a resolucao da imagem */
  imVideoCaptureGetImageSize(myVideoCap, &width, &height);

  return 1;
}


int main(int argc, char* argv[])
{
  int i;

  printf("FGC: Trab. 2\n");

  for(i=0; i<N_IMG_AUX; i++) img_aux[i] = NULL;


  /* inicializa a camera */
  if (!initCamera ( ) ) 
	  return 1;

  glutInit(&argc, argv);                           /* incializa a glut */
  glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE );   /* coloca o opgl em RGB e double buffer */
  glutInitWindowPosition(100, 100);                /* posicao inicial da janela */    
  glutInitWindowSize(width, height);               /* tamanho da janela */
  glutCreateWindow("FCG2004:Trabalho 1");          /* cria a janela */
  glClearColor(0., 0., 0., 1.0);                   /* cor do fundo da janela */

  /* registra as funcoes de callbacks */
  glutDisplayFunc(display);
  glutReshapeFunc(reshape);
  glutKeyboardFunc(parsekey);
  glutIdleFunc(idle);

  /* passa o controle para a glut */
  glutMainLoop();

  return 0;
}