Explicacin del Algoritmo de Bresenham

1.- Se reciben los enteros x0,y0,x1,y1, los cuales son los pertenecientes a los pares
ordenados que corresponden al punto inicial (x0,y0) y al punto final (x1,y1).
2.- Se obtienen las constantes: Dx= x1-x0, Dy=y1-y0, 2Dy, 2Dy-Dx, donde Dy y Dx son
aquellos valores correspondientes a la pendiente de la recta

donde

los valores de 2Dy y Dx son valores que se obtienen para poder definir un parmetro de
decisin.
3.- El parmetro de decisin di=2Dy-Dx, posteriormente definimos a x=x0 y a y=y0, esto
con fines de referencia al mandarse a llamar desde una funcin que dibuje dichos puntos
posteriormente atreves del algoritmo.
4.- Mientras x<=x1 (es decir que mientras se recorre el ciclo el valor del punto inicial debe
terminar justo en el valor del punto final) que se ejecute las siguientes condiciones y
acciones:
Si parmetro de decisin di<0 entonces di= di+2Dy;
Si no se cumple de esta manera entonces y=y+1, di=2Dy-2Dx.
Ademas x=x+1 a cada iteracin y al cumplimiento de las condiciones se dibujar el
punto (x,y) con una funcin que se llame drwa(x,y)., donde sta parte del algoritmo es
una toma decisin hacia el pixel ms cercano.

Miranda Hernndez Marco Antonio

Graficacin Por Computadora

Implementacin del lgoritmo de Bresenham para Lineas discretizadas:

#include<GL/glut.h>
#include <stdio.h>
int positivo(int a)
{
return a*(-1);
}
void draw(int ix, int iy)
{
glBegin(GL_POINTS);
glVertex2i( ix, iy);
glEnd();
}
void init (void)
{
glClearColor(1.0, 1.0, 1.0, 1.0);
glColor3f(1.0, 0.0, 0.0);
glPointSize(1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 200.0, 0.0, 200.0);
}
void Bresenham(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0 );
glClear(GL_COLOR_BUFFER_BIT);

do
{
if(di<0)
{
di=di+(2*Dy);
}
else
{
di=di+((2*Dy)-(2*Dx));
y=y+1;
}
x=x+1;
glBegin(GL_POINTS);
draw(x,y);
}while(x<=x1);
glFlush();
}
int main ( int argc, char ** argv )
{
glutInit ( &argc, argv);
glutInitDisplayMode(GLUT_SINGLE |
GLUT_RGBA);
glutInitWindowPosition(10,100);
glutInitWindowSize(300,300);
glutCreateWindow("Bresenham");

/*que inicie en el punto 0,0 y finalice en el punto 10,10 */

int x0=1,y0=2,x1=13,y1=9;
int Dx=x1-x0;
int Dy=y1-y0;

init();
glutDisplayFunc(Bresenham);
glutMainLoop();
}

int di= (2*Dy)-Dx;

int x=x0;
int y=y0;
int absDx=positivo(Dx);
if(Dy<0) Dy=positivo(Dy);

Miranda Hernndez Marco Antonio

Graficacin Por Computadora

#include<GL/glut.h>
#include <stdio.h>
int positivo(int a)
{
return a*(-1);
}
void draw(int ix, int iy)
{
glBegin(GL_POINTS);
glVertex2i( ix, iy);
glEnd();
}
void init (void)
{
glClearColor(1.0, 1.0, 1.0, 1.0);
glColor3f(1.0, 0.0, 0.0);
glPointSize(1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 200.0, 0.0, 200.0);
}
void Bresenham(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0 );
glClear(GL_COLOR_BUFFER_BIT);
/* que inicie en el punto 0,0 y finalice en el punto 10,10
*/
int x0=0,y0=0,x1=10,y1=10;
int Dx=x1-x0;
int Dy=y1-y0;

do
{
if(di<0)
{
di=di+(2*Dy);
}
else
{
di=di+((2*Dy)-(2*Dx));
y=y+1;
}
x=x+1;
glBegin(GL_POINTS);
draw(x,y);
}while(x<=x1);
glFlush();
}
int main ( int argc, char ** argv )
{
glutInit ( &argc, argv);
glutInitDisplayMode(GLUT_SINGLE |
GLUT_RGBA);
glutInitWindowPosition(10,100);
glutInitWindowSize(300,300);
glutCreateWindow("Bresenham");
init();
glutDisplayFunc(Bresenham);
glutMainLoop();
}

int di= (2*Dy)-Dx;

int x=x0;
int y=y0;
int absDx=positivo(Dx);
if(Dy<0) Dy=positivo(Dy);

Miranda Hernndez Marco Antonio

Graficacin Por Computadora

Principios Geomtricos aplicados en Algoritmo de Bresenham para circunferencias:

Se basa en un ciclo que inicia en (0,r) y termina en (

) (dnde el

para crear un octante de un circulo y los cuales son 8 puntos simtricos como se muestra
en la siguiente imagen:

Ecuacin polinomial cuadrada (reducida) de la circunferencia

El tipo de coordenadas utilizadas para este caso son las cartesianas.
r2 = x2 + y2
Explicacin del Algoritmo de Bresenham para circunferencias
En este algoritmo se calculan los puntos de 0 a 45, el cual aprovecha la simetra de la
circunferencia para obtener el trazado del resto de los puntos. Est basado en la ecuacin
de la recta polinomial de segundo grado.
Se toman dos posibles valores: De x=0 a x=
A(xi+1, yi) o B(xi+1, yi-1)
r2 = (xi+1)2 + y2
y2 = r2 - (xi+1)2
d(a)= yi2 - y2
d(b)= y2 (yi -1)2
d(a)= yi2 r2 + (xi+1)2
d(b)= r2 - (xi+1)2 (yi -1)2
Miranda Hernndez Marco Antonio
Graficacin Por Computadora

Si la distancias hacia algunos puntos candidatos es igual a 0, el punto est sobre la

circunferencia, sino es lo anterior, toma el punto ms cercano:
P1 = d(a) d(b)
P1 = yi2 r2 + (xi+1)2 - r2 + (xi+1)2 + (yi -1)2
P1 = 2(xi+1)2 + yi2 + (yi -1)2 2r2
Si el punto inicial es x=0, y=r
Pi = 2(0+1)2 + r2 + (r -1)2 2r2
Pi = 2 + r2 + (r -1)2 2r2
Pi = 2 + r2 + r2 2r +1 2r2
Pi = 3 - 2r
Si el valor de Pi < 0
xi+1=xi+1
y i+1=y i
2
2
r = (xi+1) + (y i)2
p i+1 = pi + 4xi + 6
Si el valor de Pi >= 0
xi+1=xi+1
y i+1=y i - 1
2
2
r = (xi+1) + (y i - 1)2
p i+1 = pi + 4(xi - y i)+ 10
1. seleccionar como punto inicial la coordenada (0, r) donde r = radio
2. calcular el primer parmetro como:
P=3-2r
3. incrementando x en pasos unitarios, calcular cada parmetro sucesivo de pi+1 a partir
de los siguientes:
Si pi<0
si si y i+1=y i
p i+1 = pi + 4xi + 6

Si pi>0
si si y i+1=y i - 1
p i+1 = pi + 4(xi - y i)+ 10
4. repetir paso 3 hasta que x sea mayor o igual que y
Para dibujar la circunferencia, aplicar la simetra de la circunferencia para los siete puntos
restantes, en los clculos se obtiene el primer punto(x, y), por lo que bastara que se
vayan intercambiando estas dos coordenadas, al igual que sus signos

Miranda Hernndez Marco Antonio

Graficacin Por Computadora

algoritmo circulo_Bresenham(entero xc, entero yc, entero r)

inicio
entero p, x, y
x=0
y=r
p=3-2*r
mientras (x<=y)
inicio
dibujarPixel(xc+x, yc+y)
dibujarPixel(xc-x, yc+y)
dibujarPixel(xc+x, yc-y)
dibujarPixel(xc-x, yc-y)
dibujarPixel(xc+y, yc+x)
dibujarPixel(xc+y, yc-x)
dibujarPixel(xc-y, yc+x)
dibujarPixel(xc-y, yc-x)
si p<0
si si p=p+4*x+6
si no inicio
p=p+4*(x-y)+10
y=y-1
fin
x=x+1
fin
fin

Miranda Hernndez Marco Antonio

Graficacin Por Computadora

Implementacin del Algoritmo de Bresenham para circunferencias:

#include<GL/glut.h>
while(x<=y)
#include <stdio.h>
{
dibujaoctantes(x,y);
void dibujaoctantes(int ix, int iy)
{
if(p>0)
glBegin(GL_POINTS);
{
glVertex2i(ix, iy); //Octante a 45
y=y-1;
glVertex2i(-ix, -iy);//Octante a 90
p=p+(4*(x-y))+10;
glVertex2i(-ix, iy);//Octante a 135
glVertex2i(ix, -iy);//Octante a 180
}
else
/*Puntos de simetra*/
{
glVertex2i(iy,ix);//Octante a 225
p=p+(4*x)+6;
glVertex2i(-iy,-ix);//Octante a 270
}
glVertex2i(-iy,ix);//Octante a 315
x=x+1;
glVertex2i(iy,-ix);//Octante a 360
}
glEnd();
}
void init (void)
{
glClearColor(1.0, 1.0, 1.0, 1.0);
glColor3f(1.0, 1.0, 1.0);
glPointSize(1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 200.0, 0.0, 200.0);
}
void Bresenhamcir(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0 );
glClear(GL_COLOR_BUFFER_BIT);
/* circulo de radio 10 */
int r=10;
int x=0;
int y=r;
int p=3-(2*r);

if (x=y)
{
dibujaoctantes(x,y);
}
glFlush();
}
int main(int argc, char ** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE |
GLUT_RGBA);
glutInitWindowPosition(300,300);
glutInitWindowSize(300,300);
glutCreateWindow("Bresenham");
init();
glutDisplayFunc(Bresenhamcir);
glutMainLoop();
}

Miranda Hernndez Marco Antonio

Graficacin Por Computadora

#include<GL/glut.h>
#include <stdio.h>

while(x<=y)
{
dibujaoctantes(x,y);

void dibujaoctantes(int ix, int iy)

{
glBegin(GL_POINTS);
glVertex2i(ix, iy); //Octante a 45
glVertex2i(-ix, -iy);//Octante a 90
glVertex2i(-ix, iy);//Octante a 135
glVertex2i(ix, -iy);//Octante a 180
/*Puntos de simetra*/
glVertex2i(iy,ix);//Octante a 225
glVertex2i(-iy,-ix);//Octante a 270
glVertex2i(-iy,ix);//Octante a 315
glVertex2i(iy,-ix);//Octante a 360
glEnd();
}
void init (void)
{
glClearColor(1.0, 1.0, 1.0, 1.0);
glColor3f(1.0, 1.0, 1.0);
glPointSize(1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 200.0, 0.0, 200.0);
}
void Bresenhamcir(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0 );
glClear(GL_COLOR_BUFFER_BIT);
/* circulo de radio 5 */
int r=5;
int x=0;
int y=r;
int p=3-(2*r);

if(p>0)
{
y=y-1;
p=p+(4*(x-y))+10;
}
else
{
p=p+(4*x)+6;
}
x=x+1;
}
if (x=y)
{
dibujaoctantes(x,y);
}
glFlush();
}
int main(int argc, char ** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE |
GLUT_RGBA);
glutInitWindowPosition(300,300);
glutInitWindowSize(300,300);
glutCreateWindow("Bresenham");
init();
glutDisplayFunc(Bresenhamcir);
glutMainLoop();
}

Miranda Hernndez Marco Antonio

Graficacin Por Computadora