Explicación Del Algoritmo de Bresenham

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);

#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);
glLoadIdentity();
gluOrtho2D(0.0, 200.0, 0.0, 200.0);
}
void Bresenham(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0 );
/* 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);
GLUT_RGBA);
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);

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
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

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

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);
glLoadIdentity();
gluOrtho2D(0.0, 200.0, 0.0, 200.0);
}
void Bresenhamcir(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0 );
/* circulo de radio 10 */
int r=10;
int x=0;
int y=r;
int p=3-(2*r);
if (x=y)
{
}
glFlush();
}
int main(int argc, char ** argv)
{
glutInit(&argc, argv);
GLUT_RGBA);
init();
glutDisplayFunc(Bresenhamcir);
glutMainLoop();
}

#include<GL/glut.h>
#include <stdio.h>
while(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);
glLoadIdentity();
gluOrtho2D(0.0, 200.0, 0.0, 200.0);
}
void Bresenhamcir(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0 );
/* 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)
{
}
glFlush();
}
int main(int argc, char ** argv)
{
glutInit(&argc, argv);
GLUT_RGBA);
init();
glutDisplayFunc(Bresenhamcir);
glutMainLoop();
}


Explicación Del Algoritmo de Bresenham

Cargado por

Copyright:

Formatos disponibles

Explicación Del Algoritmo de Bresenham

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Explicación Del Algoritmo de Bresenham

Cargado por

Copyright:

Formatos disponibles

Explicacin del Algoritmo de Bresenham

Miranda Hernndez Marco Antonio

Implementacin del lgoritmo de Bresenham para Lineas discretizadas:

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

int di= (2*Dy)-Dx;

Miranda Hernndez Marco Antonio

int di= (2*Dy)-Dx;

Miranda Hernndez Marco Antonio

Principios Geomtricos aplicados en Algoritmo de Bresenham para circunferencias:

Ecuacin polinomial cuadrada (reducida) de la circunferencia

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

Miranda Hernndez Marco Antonio

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

Miranda Hernndez Marco Antonio

Implementacin del Algoritmo de Bresenham para circunferencias:

Miranda Hernndez Marco Antonio

void dibujaoctantes(int ix, int iy)

Miranda Hernndez Marco Antonio

También podría gustarte