/*******************************************************************************
*                     Amanda Safady Luiz              NUSP 6426594             *
*                     Mateus Brandao de Pontes        NUSP 6427208             *
*                                                                              *
*                     Exercicio de CG - Algoritmo de Brasenham                 *
*                                                                              *
********************************************************************************/

#include <GL/gl.h>
#include <GL/glut.h>
#include <stdlib.h>
#include <math.h>
#include <windows.h>
#include <stdio.h>
#define NTESTES 20


SYSTEMTIME inicio, fim;                //Armazenarao o retorno da funçao de tempo
long int minicio, mfim, tdec;          //Armazenarao tempo em milisegundos

void cronometro_comecar()  {
   GetSystemTime(&inicio);                //Inicializa inicio
   minicio = inicio.wMilliseconds + inicio.wSecond*1000 + inicio.wMinute*60000;    //Acumula o total de ms
}

void cronometro_parar()  {
   GetSystemTime(&fim);                 //Inicializa fim
   mfim = fim.wMilliseconds + fim.wSecond*1000 + fim.wMinute*60000;               //Acumula o total de ms
}

/*Funcao que projeta as coordenas inteiras nos 8 octantes*/
void CirclePoints(int x, int y)  {
   glBegin(GL_POINTS);
      glVertex2i( x, y);
      glVertex2i( x, -y);
      glVertex2i(-x, y);
      glVertex2i(-x, -y);
      glVertex2i( y, x);
      glVertex2i( y, -x);
      glVertex2i(-y, x);
      glVertex2i(-y, -x);
   glEnd();
}

/*Funcao que projeta as coordenas reias nos 8 octantes*/
void CirclePointsf(float x, float y)  {
   glBegin(GL_POINTS);
      glVertex2f( x, y);
      glVertex2f( x, -y);
      glVertex2f(-x, y);
      glVertex2f(-x, -y);
      glVertex2f( y, x);
      glVertex2f( y, -x);
      glVertex2f(-y, x);
      glVertex2f(-y, -x);
   glEnd();
}

/*Calcula o valor das coordenadas a serem projetas, atraves do algoritmo de Senos/Cossenos*/
void SinCosin(float r)  {
   double ang = 45;
   float x,y;
   while(ang <= 90)       //Varre o octante.
   {
      x = r*cos(ang);    //X obtido em coordenadas polares
      y = r*sin(ang);    //Y obtido em coordenadas polares
      CirclePointsf(x,y);
      ang = ang+1/r;
   }
}

/*Calcula o valor das coordenadas a serem projetas, a partir do algoritmo de Bresenhan*/
void MidPointCircleInt(int r)  {
   int x, y, d;
   /* Valores iniciais. Comeca do topo do segundo octante*/
   x = 0;
   y = r;
   d = 1 - r;
   CirclePoints(x,y);
   while (y > x){   //Varre o octante do angulo de 90º para o de 45º
      if (d < 0){
      /* Seleciona E, ou seja, adiciona 1 no eixo X */
         x++;
         d = d + 2 * x + 3;
      }
      else  {
         /*Seleciona SE, ou seja, adiciona 1 no eixo X e reduz 1 no eixo Y*/
         x++;
         y--;
         d = d + 2 * (x - y) + 5;
      }
      CirclePoints(x,y);
   }
}


void display()  {

   int r = 150;     //Raio usado para o desenho das circunferencias
   int r1 = 1000;
   int i;
   float media = 0;   //Variavel que ir armazenam a media dos tempos

   glClear (GL_COLOR_BUFFER_BIT);
//   glFlush();
   do  {
//      printf("\n***************************************************************\n");
     // printf("\nAlgoritmo de Bresenhan\n");
//      printf("Raio: %d\n",r);
      for (i = 0; i < NTESTES; i++) {
  //       time_t  inicio, fim;
    //     glColor3f (1.0,1.0,1.0);    //Cor preta
//         cronometro_comecar();
         MidPointCircleInt(r);       //Chamada do algoritmo de Bresenhan
  //       cronometro_parar();
//         media = media +(mfim-minicio);
  //       glClear (GL_COLOR_BUFFER_BIT);
    //     glFlush();
      }
//      printf("Media do tempo decorrido (ms): %lf\n", media/20);
  //    printf("\n***************************************************************\n\n");

      media = 0;
    //  printf("\n***************************************************************\n");
      //printf("\nAlgoritmo Sinos/Cossenos\n");
//      printf("Raio: %d\n",r);
      for (i = 0; i < NTESTES; i++) {
         glColor3f (1.0, 0.0, 1.0);    //Cor magenta
      //   cronometro_comecar();
         SinCosin((float)r1);           //Chamada do algoritmo Senos/Cossenos
        // cronometro_parar();
         //media = media +(mfim-minicio);
      //   glClear (GL_COLOR_BUFFER_BIT);
        // glFlush();
      }
//      printf("Media do tempo decorrido (ms): %lf\n", media/20);
  //    printf("\n***************************************************************\n\n");

      r = r*2;    //Incrementa o raio
      r1 = r1*2;
       glFlush();
   } while (r < 60000);
}

void init ()  {
   /* Seleciona a cor de fundo para limpeza da tela */
   glClearColor (0.0, 0.0, 0.0, 0.0);

   /* Inicializa os valores de visualização */
   glMatrixMode(GL_PROJECTION);


   /* Faz com que a matriz corrente seja inicializada com a matriz identidade
   (nenhuma transformação é acumulada) */
   gluOrtho2D(-60000,60000,-60000,60000);
}



/* Cria a janela */
int main(int argc, char** argv)  {

   /* Estabelece o modo de exibição a ser utilizado pela janela a ser criada
    neste caso utiliza-se de um buffer simples, ou seja, a apresentação será imediata à
    execução. Define o modo de cores como RGBA */
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);

   /*Determina o tamanho em pixels da janela a ser criada*/
   glutInitWindowSize (700,700 );

   /*Estabelece a posição inicial para criação da janela*/
   glutInitWindowPosition (100, 100);

   /* Cria uma janela com base nos parâmetros especificados
   nas funções glutInitWindowSize e glutInitWindowPosition
   com o nome de título especificado em seu argumento */
   glutCreateWindow ("Bresenhan VS. Senos/Cossenos");

   /* Especifica os parâmetros inicias para as variáveis de estado do OpenGL*/
   init ();

   // Associa a função display como uma função de callback
   glutDisplayFunc(display);

   /* Inicia a execução do programa OpenGL.
   O programa irá executar num loop infinito devendo
   o desenvolvedor especificar as condições de saída do mesmo
   através de interrupções no próprio programa ou através
   de comandos de mouse ou teclado como funções de callback*/
   glutMainLoop();

   return 0;
}