Javier Santiago Bocanegra Romero Código: 1201926

Maira Valentina Díaz Salinas Código: 1201895

ANALISIS:
Se analizo que en el código de bresenham se realizan estas acciones
1. Se capturan los dos extremos de la línea y se almacena el extremo izquierdo en (x0,y0).
2. Se traza el primer punto (x0, y0).
3. Se calculan las constantes y, x, 2 y, 2 y-2 x, y se obtiene el valor inicial para el
parámetro de decisión como p0 = 2 y - x.

4. En cada xk a lo largo de la línea, que inicia en k = 0, se efectúa la prueba siguiente:

si pk < 0, el siguiente punto que se debe trazar es (xk+1, yk) y pk +1 = pk + 2 y. De otro modo,
el siguiente punto en trazarse es (xk+1, yk+1) y pk +1 = pk + 2 y - 2 x.

5. Se repite el paso 4 otras x veces.

En el código implementan un bresenhamX y bresenhamY donde cada función expresa cada

coordenada tanto en el eje X como Y y sus componentes DX Y DY con la pendiente.
Este código es un poco más extenso que el diseñado por nosotros y dda pues ya que utiliza
más funciones que se pueden optimizar.

En el código de DDA se muestra un algoritmo que se basa en el cálculo y la evaluación de

un Delta X (X) y un Delta Y (Y). Se basa en el cálculo del incremento de una variable “X” o en
el incremento de la variable “Y”, con el objetivo de obtener los valores enteros
correspondientes más próximos a la trayectoria de la línea que da la otra coordenada muy
parecido al código que realizamos nosotros para dibujar una línea, sin embargo, nosotros
usábamos la ecuación de la pendiente de la recta para poder realizar el cálculo de los puntos
de la línea a incrementar

También podemos deducir que el algoritmo de bresenham se puede adaptar para dibujar
cirulos o curvas mejor definidas, mientras que el algoritmo de DDA Se utiliza sobre todo para
dibujar líneas de triángulos y polígonos.
#include <stdlib.h>
#include <GL\glut.h>
#include <gl\glut.h>
#include <iostream>
#include <math.h>

using namespace std;

double x_1, y_1, x_2, y_2;

int alto = 600, ancho = 600;// tamaño de la pantalla

int xi, yi, xf, yf; // coordenadas de los dos puntos

bool firstClick = true;

bool drawLine = false;

void pintalinea(int lx, int ly){

glBegin(GL_POINTS);

glVertex2d(lx, ly);

glEnd();

glFlush();
}

void pintapixel1(int x_1, int y_1){

y_1 = y_1;
x_1 = x_1;
glBegin(GL_POINTS);
glColor3f(1, 0, 1);
glVertex2d(x_1, y_1);
glEnd();
glFlush();
}

void pintapixel2(int x_2, int y_2){

y_2 = y_2;
x_2 = x_2;
glBegin(GL_POINTS);
glColor3f(0, 1, 1);
glVertex2d(x_2, y_2);
glEnd();
glFlush();
}

void pintapantalla(){
glClearColor(1, 0, 0, 1);
glViewport(0, 0, alto, ancho);
glMatrixMode(GL_PROJECTION);
glPointSize(6);
glColor3i(1, 0, 0);

gluOrtho2D(0.0, (GLdouble)alto, 0.0, (GLdouble)ancho);

glMatrixMode(GL_MODELVIEW);

}
void mov_raton(int boton, int estado, int x, int y){
if ((estado == GLUT_DOWN) && (boton == GLUT_LEFT_BUTTON)){
x_1 = x;
y_1 = (ancho - y);
pintapixel1(x_1, y_1);
firstClick = false;
drawLine = false;
}
else if ((estado == GLUT_DOWN) && (boton == GLUT_RIGHT_BUTTON)){
x_2 = x;
y_2 = (ancho - y);
pintapixel2(x_2, y_2);
firstClick = true;
drawLine = true;
}
}
void setPixel(int x, int y){

glBegin(GL_POINTS);
glVertex2d(x, y);
glEnd();
}

void bresenhamX(int x0, int y0, int x1, int y1, int dx, int dy){
int i, j, k;
i = 2 * dy - dx;
j = 2 * dy;
k = 2 * (dy - dx);
if (!(x0<x1)){
swap(x0, x1);
swap(y0, y1);
}
setPixel(x0, y0);

while (x0<x1){
if (i<0)
i += j;
else{
if (y0<y1)
++y0;
else
--y0;
i += k;
}
++x0;
setPixel(x0, y0);
}
}

void bresenhamY(int x0, int y0, int x1, int y1, int dx, int dy){// funcion cordenada eje y

int i, j, k;
i = 2 * dy - dx;
j = 2 * dy;
k = 2 * (dy - dx);
if (!(y0<y1)){
swap(x0, x1);
swap(y0, y1);
 }
setPixel(x0, y0);

while (y0<y1){
if (i<0)
i += j;
else{
if (x0<x1)
--x0;
i += k;
}
++y0;
setPixel(x0, y0);
}
}

void linea_Bresenham(int x0, int y0, int x1, int y1){

int dx = abs(x1 - x0);// Diferenciales

int dy = abs(y1 - y0);
if (dx >= dy)
bresenhamX(x0, y0, x1, y1, dx, dy);
else
bresenhamY(x0, y0, x1, y1, dx, dy);
}

void iniciar_pixelbre(){
glClear(GL_COLOR_BUFFER_BIT);// LIMPIA LA PANTALLA
if (drawLine)
{
linea_Bresenham(x_1, y_1, x_2, y_2);
}
glFlush();
}

float round_value(float v){// ayuda a determinar en que momento el for termina

return floor(v + 0.5);
}

void linea_DDA(int x1, int y1, int x2, int y2){

glClear(GL_COLOR_BUFFER_BIT);
double dx = (x2 - x1);
double dy = (y2 - y1);

double steps;
float x_inc, y_inc, x = x1, y = y1;
steps = (abs(dx)>abs(dy)) ? (abs(dx)) : (abs(dy));
x_inc = dx / (float)steps;
y_inc = dy / (float)steps;

glBegin(GL_POINTS);

glVertex2d(x, y);

for (int k = 0; k<steps; k++){// ayuda a decir en que momento deja de imprimir puntos
x += x_inc;
y += y_inc;
glVertex2d(round_value(x), round_value(y));
 }
glEnd();
glFlush();
}

void menu(int value){

if (value == 1){
linea_DDA(x_1, y_1, x_2, y_2);
}
else if (value == 2){
glClear(GL_COLOR_BUFFER_BIT);
glFlush();
}
else if (value == 3){
iniciar_pixelbre();
}
}

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

glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(alto, ancho);
glutCreateWindow("LINEAS CLICK");
glutMouseFunc(mov_raton);
glutDisplayFunc(iniciar_pixelbre);
pintapantalla();
glutCreateMenu(menu);
glutAddMenuEntry("DIBUJAR LINEA DDA", 1);
glutAddMenuEntry("LIMPIAR PANTALLA", 2);
glutAddMenuEntry("DIBUJAR LINEA BRESENHAM", 3);
glutAttachMenu(GLUT_MIDDLE_BUTTON);
glutMainLoop();
}