Está en la página 1de 4

Instituto Nacional de Mxico

Campus Tlhuac

Presentan:
Garca Alcaide Lucia Leticia
Leyte Pea Hctor Jovanni
Miranda Moreno Jaime Israel
Ocegueda Jurez Jess Antonio
Santiago Bazan Jessica
Tenorio Cortes Daniel
Tema:
Algoritmo de Bresenham

Docente:
Ing. Martnez Lozano Olivia

Mxico D.F. 10 de Marzo del 2016

ALGORITMO DE BRESENHAM
Introduccin

*Trazamos (xk+1, yk+1).

El algoritmo de Bresenham es un algoritmo creado


para dibujar rectas en los dispositivos de grficos
rasterizados, como por ejemplo un monitor de
ordenador, que determina qu pixeles se rellenarn, en
funcin de la inclinacin del ngulo de la recta a
dibujar.

*Asignamos pk+1= pk+2y-2x.


Fin Para
Si |m|>1

Es un algoritmo preciso para la generacin de lneas


que convierte mediante rastreo las lneas al utilizar
solo clculos incrementales con enteros que se pueden
adaptar para desplegar circunferencias y curvas. Los
ejes verticales muestran las posiciones de rastreo y los
ejes horizontales identifican columnas de pixel.

El algoritmo de Bresenham sera el siguiente:


Si 0<|m|<1
*Se capturan los extremos de la lnea y se almacena el
extremo izquierdo en (x0, y0).
*Se carga (x0, y0) en el buffer de estructura (se traza
el primer punto)

*Recorremos la direccin en pasos unitarios y


calculamos los valores sucesivos de x que se
aproximen ms a la trayectoria de la lnea.

Algoritmo de Bresenham con Opengl y c#


Console.WriteLine("introduzca el valor de X1");
x1 = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("introduzca el valor de Y1");
y1 = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("introduzca el valor de X2");
x2 = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("introduzca el valor de Y2");
y2 = Convert.ToDouble(Console.ReadLine());
//inicializar todo esto para tao opengl
Glut.glutInit();
Glut.glutInitDisplayMode(Glut.GLUT_SINGLE |
Glut.GLUT_RGB);

*Se calculan las constantes x,y, 2y y 2y-x y se


obtiene el valor inicial para el parmetro de decisin
p0=2y-x.
Para j=0 mientras j<x

Glut.glutInitWindowSize(640, 480);
Glut.glutCreateWindow("**************Bresenha
m**************");
//termina inicializacin de componentes tao opengl
Glut.glutDisplayFunc(Bresen);

*En cada xk a lo largo de la lnea, que inicia en k=0


se efecta la prueba siguiente:
Si pk<0

Glut.glutMainLoop();

*Trazamos (xk+1,yk).
*Asignamos pk+1= pk+2y.
Sino

Se utiliza un mtodo llamado Bresen como el


siguiente cdigo el siguiente cdigo:

public static void Bresen()


{
//componentes necesarios
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT);
Gl.glColor3f(0.6F, 0.6F, 0.6F);
Gl.glLoadIdentity();
Gl.glBegin(Gl.GL_POINTS);
//dibujando el plano
float z = -1, w = 1, c = 0;
for (int i = 0; i < 200; i++)
{
Gl.glColor3f(w, c, z);
Gl.glVertex2d(z, 0);
Gl.glVertex2d(0, w);
z += .01f;
w -= .01f;
c += .1f;
}
Gl.glEnd();
Gl.glPointSize(5.0f);
Gl.glColor3f(1.0f, 0.111f, 1.0f);
BresenDibujar(x1, y1, x2, y2);

ultimo = xfinal;
}
Gl.glBegin(Gl.GL_POINTS);
//Gl.glColor3f(1f, 1.0f, .5f);
Gl.glVertex2d(x, y);
while (x < ultimo)
{
x += .1;
if (constanteP < 0)
constanteP +=2 * deltay;
else
{
y += .1;
constanteP += 2 * (deltay - deltax);
}
Gl.glVertex2d(x, y);
}
Gl.glEnd();
}

}
Creamos otro metodo llamado Bresendibujar donde
se va a desarrollar el algoritmo de Bresenham
public static void BresenDibujar(double x1,double
y1,double x2,double y2)
{
double x inicial = x1, y inicial = y1, x final = x2,
yfinal= y2, x=0, y=0;
double delta x, delta y, constante P, ultimo;
deltax = Math.Abs( xfinal - xinicial);
deltay =Math.Abs( yfinal - yinicial);
constanteP = 2 * deltay - deltax;
if (xinicial > xfinal)
{
x = xfinal;
y = yfinal;
ultimo = xinicial;
}
else
{
x = xinicial;
y = yinicial;

Fig. 1 Programa del cdigo

Conclusin
Asimismo, podemos revisar el programa para trazar
pixels iniciando desde cualquier extremo.
Si la posicin inicial para una lnea con una pendiente
positiva es el extremo derecho, tanto x como y
disminuyen conforme pasamos de derecha a
izquierda.
Con el fin de asegurarnos de que los mismos pixeles
se tracen sin que importe el extremo en que se
comienza, se seleccionara el pixel superior (o
inferior) cuando se pase exactamente en el medio (d1
= d2).
En el caso de pendientes negativas, los
procedimientos son similares excepto que ahora, una
coordenada decrece conforme la otra aumenta.
Por ultimo, es posible manejar los casos especiales
por separado.

Las lneas horizontales (Dy = 0), las lneas verticales


(Dx = 0) y las diagonales | Dy | = | Dx | se pueden
cargar en forma directa sin procesarlas mediante el
algoritmo para el trazo de lneas.

Referencia bibliogrfica
http://graf8-9.blogspot.mx/2013/09/12-dispositivosde-hardware-y-software.html?m=1
http://sabia.tic.udc.es/gc/trabajos%20201112/Fractales/aspectosmatematicos.html
http://www.cannes.itam.mx/Alfredo/Espaniol/Cursos/
Grafica/Linea.pdf

También podría gustarte