Universidad Nacional Autónoma de México

Facultad de Ingeniería

Computación Gráfica

Tarea No. 5:Algoritmo de Bresenham para línea y circunferencia

Algoritmo de recorte de líneasRelleno de polígonos

Fecha de entrega:11/09/2011

Bustos Ramírez Luis Fernando

No. Cuenta: 306218347

Algoritmo de Bresenham para línea

El algoritmo de Bresenham es un algoritmo preciso para la generación de lineas que convierte mediante rastreo   las   líneas   al   utilizar   solo   cálculos   incrementales   con   enteros   que   se   pueden   adaptar   para desplegar circunferencias y curvas. Sirve para dibujar rectas en los dispositivos de gráficos rasterizados, como por ejemplo un monitor de ordenador, que determina qué pixeles se rellenarán, en función de la inclinación del ángulo de la recta a dibujar.

El algoritmo básico utiliza la ecuación de la recta expresada como: y = mx + b

Si la recta se dibuja desde el punto (x0, y0) hasta el punto (x1, y1), el algoritmo varia x desde x0 hasta x1 en incrementos de una unidad. 

El siguiente es el código en Java.

 public void rectaSimple(int x0, int y0, int x1, int y1, Graphics g){  int dx = x1 ­ x0;  int dy = y1 ­ y0;

 g.drawLine( x0, y0, x0, y0); if (dx != 0){

float m = (float) dy / (float) dx;float b = y0 ­ m*x0;if(x1 > x0)

       dx = 1;      else      dx = ­1;     while (x0 != x1) {     x0 += dx;     y0 = Math.round(m*x0 + b);       g.drawLine( x0, y0, x0, y0);    }  }}

Algoritmo de Bresenham para curva

En computación  gráfica  el  algoritmo del  punto  medio  del  circulo  para   la  curva  es  una  algoritmo utilizado para determinar los puntos necesarios para dibujar un circulo. El algoritmo es una variante del algoritmo de Bresenham para la linea por lo que se le conoce como el algoritmo de Bresenham para la  curva.El algoritmo comienza en consecuencia con la ecuación de círculo: x 2 + y 2 = r 2. Así, el centro del circulo se encuentra en (0,0). Calcula la ubicación de los pixeles en los primeros 45°. Por cada pixel (x,y) se calcula y dibuja un pixel en cada uno de los ocho octantes del circulo.

Por lo tanto, remodelar nuestro próximo punto de ecuaciones en una recursiva mediante la sustitución 

de   : 

Este seria el código del algoritmo para dibujar círculos en “C”

void rasterCircle(int x0, int y0, int radius){   int f = 1 ­ radius;

int ddF_x = 1;   int ddF_y = ­2 * radius;   int x = 0;   int y = radius;   setPixel(x0, y0 + radius);   setPixel(x0, y0 ­ radius);   setPixel(x0 + radius, y0);   setPixel(x0 ­ radius, y0);   while(x < y) {    // ddF_x == 2 * x + 1;    // ddF_y == ­2 * y;     // f == x*x + y*y ­ radius*radius + 2*x ­ y + 1;     if(f >= 0) {       y­­;       ddF_y += 2;       f += ddF_y;     }     x++;     ddF_x += 2;     f += ddF_x;         setPixel(x0 + x, y0 + y);     setPixel(x0 ­ x, y0 + y);     setPixel(x0 + x, y0 ­ y);     setPixel(x0 ­ x, y0 ­ y);     setPixel(x0 + y, y0 + x);     setPixel(x0 ­ y, y0 + x);     setPixel(x0 + y, y0 ­ x);     setPixel(x0 ­ y, y0 ­ x);   }}

Algoritmo de recorte de líneas

En computación gráfica, el recorte de líneas es el proceso de quitar las líneas o porciones de ellas que estén fuera de un área de interés. Normalmente cualquier línea o una parte es quitada si está fuera del área de vista.Este algoritmo resuelve el recorte de líneas que quedan fuera de un rectángulo alineado con los ejes. Para ello divide el espacio 2D en una matriz de 9 regiones, de las cuales la única visible es la parte central (el viewport). El viewport, es la pantalla o plano de proyección.Cada punto tiene asignados unos códigos de frontera que indican la posición de ese punto respecto al viewport. Cada código de frontera se compone de 4 bits.

El algoritmo incluye, excluye, o incluye parcialmente, la línea (segmento) basado en dónde están sus puntos extremos:

• Ambos puntos están en el viewport (la operación bitwise OR de sus puntos extremos es igual a cero): aceptación trivial.

• Ambos puntos están en la misma región no visible (la operación bitwise AND de sus puntos extremos no es igual a cero): rechazo trivial.

• Ambos puntos están en regiones distintas: En caso de esta situación no trivial el algoritmo encuentra uno de los 2 puntos que está fuera del viewport (hay al menos un punto fuera). La intersección del punto exterior con la frontera extendida es entonces calculada (es decir, con la ecuación paramétrica de la línea) y este nuevo punto reemplaza al punto exterior. El algoritmo se repite hasta que ocurre un éxito o rechazo trivial.

Puede verse en el dibujo un ejemplo para cada caso. Nótese como sólo las porciones de las líneas dentro del área verde (coloreadas de azul) necesitan ser dibujadas.

Codigo en OpenGL del recorte de figuras

#include <windows.h>

#include <gl/glut.h>

void dibuja(void){// Llamado a la funcion que dibuja la pantalla

                glClear(GL_COLOR_BUFFER_BIT);

    glFlush();

}

// parametros iniciales{

void parametros_iniciales(void){

    glClearColor(0.0f, 0.0f, 1.0f, 1.0f);

} 

void main(void){

                glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);

                glutCreateWindow("Mi primer ejemplo");

                glutDisplayFunc(dibuja);

                 parametros_iniciales();

}

Relleno de polígonos La tarea de los primitivos de llenado se puede separar en dos partes:1. la decisión de que pixeles llenar (esto depende de la forma de la primitiva), y2. la decisión mas sencilla de cual valor utilizar para el relleno.En general, determinar que pixeles llenar consiste de tomar líneas de rastreo sucesivas que intersectan la primitiva y llenar en intervalos (spans ) de pixeles adyacentes que están dentro de la primitiva de izquierda a derecha.

Para llenar un rectángulo con un color sólido, se asigna a cada pixel sobre una misma línea de rastreo desde el borde izquierdo al borde derecho el mismo valor de pixel; o sea llenamos cada intervalo de xmin a xmax .Se aprovecha de varios tipos de coherencias no solamente para convertir primitivas de 2D, pero también de 3D.· Los intervalos explotan la coherencia espacial (spatial coherence ) de una primitiva: el hecho que las primitivas a menudo no cambian de pixel en pixel dentro de un intervalo o de línea de rastreo a línea de rastreo. Se explota esta coherencia buscando solo aquellos pixeles donde ocurren cambios.· Para una primitiva trazada de forma sólida, se asigna el mismo valor a todos los pixeles en un mismo intervalo, proporcionando coherencia de intervalo (span coherence ).· Un rectángulo trazado de forma sólida también muestra una fuerte coherencia de línea de rastreo (scan-line coherence ) ya que líneas de rastreo consecutivas que intersectan el rectángulo son idéntica; mas tarde se usa también coherencia de arista (edge coherence ) para los lados de polígonos generales.