/* Image Processing and Recognition Module for the IUPGLCAP application. */
/* It should not contain interface code, neither OpenGL nor IUP.         */

#ifdef WIN32            
#include <windows.h>    /* necessary because of the Microsoft OpenGL headers dependency */
#endif

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

#include <GL/gl.h>
#include <GL/glu.h>
#include "glut.h"

#include "ARProcess.h"
#include "PatternMatchDLL.h"
#include "tsai.h"

#include <im.h>
#include <im_capture.h>
#include <im_image.h>
#include <im_convert.h>
#include <im_process.h>
#include <im_format_avi.h>

int safeArea[1000];

int calibrated;
double modelview[16];
double projection[16];
int width, height;
unsigned char* rgbImageAux[2];
unsigned char *leftImage;
unsigned char *rightImage;

/*
 *  Primitivas para inicializar o OpenGL
 */
void initOpenGL()
{
//  gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);
  glShadeModel(GL_SMOOTH);
  glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
  glClearDepth(1.0f);
//  glEnable(GL_DEPTH_TEST);
  glDepthFunc(GL_LEQUAL);
  glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
}

/*
 *  Inicializa o módulo.
 */
void arInit(int w, int h)
{
  int i;

  width = w;
  height = h;

  for(i=0; i<2; i++)
    rgbImageAux[i] = (unsigned char*)malloc(3*w*h*sizeof(unsigned char));

  initPatternMatch(w, h);

  initOpenGL();
}

/*
 *  Acende um pixel em uma imagem.
 */
__inline void drawPixel(unsigned char* img, int width, int height, int x, int y, unsigned char r, unsigned char g, unsigned char b)
{
  int index = 3*(y*width + x);
  img[index  ] = r;
  img[index+1] = g;
  img[index+2] = b;
}

/*
 *  Desenha um ponto em uma imagem.
 */
__inline void drawPoint(unsigned char* img, int width, int height, int x, int y, unsigned char r, unsigned char g, unsigned char b)
{
  if((x<1)||(x>=width-1)||(y<1)||(y>=height-1)) return;

  drawPixel(img, width, height, x, y, r, g, b);
  drawPixel(img, width, height, x-1, y, r, g, b);
  drawPixel(img, width, height, x+1, y, r, g, b);
  drawPixel(img, width, height, x, y-1, r, g, b);
  drawPixel(img, width, height, x, y+1, r, g, b);

  drawPixel(img, width, height, x-1, y-1, r, g, b);
  drawPixel(img, width, height, x+1, y+1, r, g, b);
  drawPixel(img, width, height, x+1, y-1, r, g, b);
  drawPixel(img, width, height, x-1, y+1, r, g, b);
}

/*
 *  Copia uma imagem.
 */
__inline void copyImg(unsigned char* rgb_from, unsigned char* rgb_to, int width, int height)
{
  int i, lastIndex;

  lastIndex = width*height*3;

  for(i=0; i<lastIndex; i++)
    rgb_to[i] = rgb_from[i];
}

/*
 *  Calibra a camera: chama a rotina de identificação do padrão
 * (que está na dll) e em seguida chama o algoritmo do tsai.
 */
void arFrameProcess(unsigned char *rgb, int *flags, double angle, double value)
{
  int i;
  int xs[8];
  int ys[8];
  double xf[8];
  double yf[8];
  double xw[8] = {2.375, 2.375, -2.375, -2.375, 1.0, 1.0, -1.0, -1.0};
  double yw[8] = {2.47, -2.47, -2.47, 2.47, 1.1, -1.1, -1.1, 1.1};
  double f;
  double T[3];
  double R[9];

  calibrated = 0;
  copyImg(rgb, rgbImageAux[0], width, height);

  if(findPattern(xs, ys, rgb, width, height))
  {
	for(i=0; i<8; i++)
	{
	  xf[i] = (double)(xs[i] - width/2);
	  yf[i] = (double)(ys[i] - height/2);
	  drawPoint(rgbImageAux[0], width, height, xs[i], ys[i], 255*((i/1)%2), 255*((i/2)%2), 255*((i/4)%2));
	}

	f = 10.0f;
//	if(tsaiCalibration2D_Tr(8, xw, yw, xf, yf, f, T, R))
	if(tsaiCalibration2D(8, xw, yw, xf, yf, &f, T, R))
	{
	  calibrated = 1;
	  tsaiOGLModelViewMatrix(T, R, modelview);
	  tsaiOGLProjectionMatrix(f, 0.1, 100.0, width, height, projection);
	}
  }

  leftImage = rgb;
  rightImage = rgbImageAux[0];
}

/*
 *  Desenha o canvas do lado direito: primeiro copia a imagem
 * original e depois desenha uma figura em cima.
 */
void arRepaintRightCanvas(void)
{
  float lightPos[4] = {0.0f, 0.0f, 4.0f, 0.0f};
  float ambientComponents[4] = {0.0f, 0.0f, 0.8f, 0.0f};
  float diffuseComponents[4] = {0.0f, 0.0f, 0.8f, 0.0f};
  float specularComponents[4] = {0.2f, 0.2f, 0.2f, 0.0f};

  glClear(GL_COLOR_BUFFER_BIT);
  glRasterPos2f(0.f, 0.f); 

  glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE, rightImage);

  if(!calibrated) return; //Checa se a camera foi calibrada

  glViewport(0, 0, width, height);

  glMatrixMode (GL_PROJECTION);
  glPushMatrix();
  glLoadIdentity();
  glLoadMatrixd (projection);

  glMatrixMode (GL_MODELVIEW);
  glPushMatrix();
  glLoadIdentity();
  glLoadMatrixd (modelview);

  glEnable(GL_DEPTH_TEST);
  glClear(GL_DEPTH_BUFFER_BIT);

//Desenha uma figura qualquer (teste)
/*
  glBegin(GL_QUADS);
	glColor3f(1.0f,0.0f,0.0f);
	glVertex3f( 1.0f, 1.0f, 0.0f);
	glColor3f(0.0f,1.0f,0.0f);
	glVertex3f( 1.0f,-1.0f, 0.0f);
	glColor3f(0.0f,0.0f,1.0f);
	glVertex3f(-1.0f,-1.0f, 0.0f);
	glColor3f(0.0f,0.0f,1.0f);
	glVertex3f(-1.0f, 1.0f, 0.0f);
  glEnd();
*/

  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);
  glLightfv(GL_LIGHT0, GL_POSITION, lightPos);

  glEnable(GL_COLOR_MATERIAL);
  glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);

  glMaterialfv(GL_FRONT, GL_AMBIENT, ambientComponents);
  glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuseComponents);
  glMaterialfv(GL_FRONT, GL_SPECULAR, specularComponents);

  /* Desenha Teapot no centro do padrao */
  glColor3f(0.0f,0.0f,1.0f);
  glPushMatrix();
  glTranslatef(0.f, 0.0f, 0.75f);
  glRotatef(90.f, 1.0f, 0.0f, 0.0f);
  glutSolidTeapot(1.0);
  glPopMatrix();

  glDisable(GL_DEPTH_TEST);
  glDisable(GL_COLOR_MATERIAL);
  glDisable(GL_LIGHTING);
  glDisable(GL_LIGHT0);

  glMatrixMode (GL_PROJECTION);
  glPopMatrix();
  glMatrixMode (GL_MODELVIEW);
  glPopMatrix();
}

/*
 *  Desenha o canvas da esquerda (imagem original).
 */
void arRepaintLeftCanvas(void)
{
  glDrawPixels(width, height, GL_RGB, GL_UNSIGNED_BYTE, leftImage);
}

/*
 *  Finaliza o módulo.
 */
void arEnd(void)
{
  int i;

  for(i=0; i<2; i++)
    free(rgbImageAux[i]);

  finishPatternMatch();
}