sábado, 6 de octubre de 2012

Glosario


CAVE (Cave Automatic Virtual Environment). Es un entorno de realidad virtual inmersiva. Se trata de una sala en forma de cubo en la que hay proyectores orientados hacia las diferentes paredes, suelo y techo. Dependiendo del resultado que se quiera obtener se proyectará la imagen a todas o sólo alguna de las paredes de la sala.

Coordenadas Homogéneas. Las coordenadas homogéneas son un instrumento usado para describir un punto en el espacio proyectivo. Su notación en forma matricial se emplea en bibliotecas de programación gráfica en 3D como OpenGL y Direct3D.

Diafana. Que deja pasar a través la luz casi en su totalidad.

Ecografía. Es un procedimiento de imagenología que emplea los ecos de una emisión de ultrasonidos dirigida sobre un cuerpo u objeto como fuente de datos para formar una imagen de los órganos o masas internas con fines de diagnóstico. 

Espejo cóncavo. Es el que con su superficie forma un paraboloide de revolución, todos los rayos que inciden paralelos al eje del espejo, se reflejan pasando por el foco, y los que inciden pasando por el foco, se reflejan paralelos al eje.

Estereoscopía. Es cualquier técnica capaz de recoger información visual tridimensional y/o crear la ilusión de profundidad mediante una imagen estereográfica, un estereograma, o una imagen tridimensional.

Holografía. Es una técnica avanzada de fotografía, que consiste en crear imágenes tridimensionales. Para esto se utiliza un rayo láser, que graba microscópicamente una película fotosensible. Ésta, al recibir la luz desde la perspectiva adecuada, proyecta una imagen en tres dimensiones.

Obturador. Es el dispositivo que controla el tiempo durante el que llega la luz al dispositivo fotosensible. Este tiempo es conocido como la velocidad de obturación, y de él se desprenden conceptos como el congelado o el barrido fotográfico.

Pila (programacion). Una pila (stack en inglés) es una lista ordinal o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que permite almacenar y recuperar datos. Esta estructura se aplica en multitud de ocasiones en el área de informática debido a su simplicidad y ordenación implícita de la propia estructura.

Proyector LCD. El sistema de pantalla de cristal líquido es el más simple, por tanto uno de los más comunes y accesibles para el uso doméstico.
Realidad virtual inmersiva. Los métodos inmersivos de realidad virtual con frecuencia se ligan a un ambiente tridimensional creado por un ordenador, el cual se manipula a través de cascos, guantes u otros dispositivos que capturan la posición y rotación de diferentes partes del cuerpo humano.

Reconstrucción 3D. Es el proceso mediante el cual, objetos reales, son reproducidos en la memoria de una computadora, manteniendo sus características físicas.

Viewport


Aplicaciones
·         Tener varias áreas de dibujo y proyección en una ventana
·         Mantener la proporción del aspecto

SINTAXIS
glViewport(Xminimo, Yminimo,Anco,Alto)

La pila de matrices


En la función display() se encuentran las llamadas a dos funciones de matrices que todavía no han sido comentadas. Se trata de glPushMatrix() y glPopMatrix(). Para comprender su funcionamiento, primero se va a experimentar que es lo que ocurre cuando no están dichas llamadas. Para ello se comentan en la función display() ambas llamadas:
void display(void) {
...
// glPushMatrix();
...
glTranslatef(0.0, 0.0, .5);
...
// glPopMatrix();
glutSwapBuffers();
}

La razón de este movimiento es que en la función display está incluida una llamada a glTranslatef() que se utiliza para posicionar uno de los objetos. Como se ha explicado anteriormente, las funciones de traslación multiplican la matriz actual por una matriz de traslación creada con los argumentos que se le pasan, por tanto, sucesivas llamadas a la función display() provocan sucesivas multiplicaciones de la matriz actual con el efecto que se observa de incrementar la traslación.
Para solucionar este problema OpenGL dispone de unos stacks o pilas de matrices, que permiten almacenar y recuperar una matriz anterior. Aunque OpenGL dispone de pilas para las matrices GL_MODELVIEW y GL_PROJECTION, sólo se suele utilizar la pila de GL_MODELVIEW.
Una pila es un almacén con funcionamiento LIFO, el último en entrar es el primero en salir, por lo que suele comparar a una pila de platos en la que sólo se puede dejar uno encima de la pila o coger el superior que es el último depositado. La pila de matrices tiene el mismo funcionamiento sustituyendo los platos por matrices. La matriz superior de la pila es sobre la que se aplican las distintas transformaciones, multiplicándola por la matriz que generan las distintas funciones.
La función glPushMatrix() realiza una copia de la matriz superior y la pone encima de la pila, de tal forma que las dos matrices superiores son iguales. En la figura 1 se observa la pila en la situación inicial con una sola matriz, al llamar a la función glPushMatrix() se duplica la matriz superior. Las siguientes transformaciones que se realizan se aplican sólo a la matriz superior de la pila, quedando la anterior con los valores que tenía en el momento de llamar a la función glPushMatrix().
La función glPopMatrix() elimina la matriz superior, quedando en la parte superior de la pila la matriz que estaba en el momento de llamar a la función glPushMatrix().

Dibujando un rastro

Una característica de Logo es que la tortuga al avanzar va dibujando el camino por el que ha pasado. Hasta ahora la aplicación va transformando las coordenadas del objeto para situarlo en la nueva posición según las instrucciones introducidas pero no muestra la ruta seguida.
Para mostrar la ruta es necesario almacenar los puntos por los que pasa la tortuga. El rastro consistirá en una línea que una estos puntos.
Necesitaremos realizar tres operaciones: calcular la coordendas donde se encuentra la tortuga, almacenar dicha coordenada y dibujar el rastro.
Para almacenar los puntos se utiliza una variable para indicar el número de puntos y tres vectores para las coordenadas x, y, z.
int np = 0;
float px [10000];
float py [10000];
float pz [10000];
Para calcular las coordenadas de la tortuga es necesario conocer la matriz de transformación de modelado. Debido a que en OpenGL, la matriz de modelado se almacena junto con la de visualización en la matriz GL_MODELVIEW, es necesario guardar de modo independiente esta matriz de modelado. Para ello definimos la variable mModel, como una variable global, ya que va a ser accedida en distinos puntos de la aplicación: GLdouble mModel[16]
Para operar con la matriz mModel, se cargará en la pila de matrices de GL_MODELVIEW despues de realizar un PushMatrix(), de modo que no altere la matriz actual. En la función main() se inicializa esta matriz con el código:
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glGetDoublev (GL_MODELVIEW_MATRIX, mModel);
glPopMatrix();

MOSTRAR TEXTO
Las instrucciones introducidas se muestran en la ventana MSDOS. Se pueden mostrar en la ventana gráfica. Para ello es necesario cambiar las matrices de transformación. La siguiente función realiza la representación del texto:
void text(GLuint x, GLuint y, GLfloat scale, char* format, ...) {
va_list args;
char buffer[255], *p;
GLfloat font_scale = 119.05f + 33.33f;
va_start(args, format);
vsprintf(buffer, format, args);
va_end(args);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, glutGet(GLUT_WINDOW_WIDTH), 0,
glutGet(GLUT_WINDOW_HEIGHT));
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glTranslatef(x, y, 0.0);
glScalef(scale/font_scale, scale/font_scale, scale/font_scale);
for(p = buffer; *p; p++)
glutStrokeCharacter(GLUT_STROKE_ROMAN, *p);
glPopAttrib();
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}

miércoles, 26 de septiembre de 2012

Matrices


Matrices

Las matemáticas que hay tras las transformaciones se simplifican gracias a las matrices. Cada una de las transformaciones puede conseguirse multiplicando una matriz que contenga los vértices por una matriz que describa la transformación. Por tanto todas las transformaciones ejecutables con ogl pueden describirse como la multiplicación de dos o más matrices.

El canal de transformaciones

Para poder llevar a cabo todas las transformaciones de, deben modificarse dos matrices: la matriz del Modelador y la matriz de Proyección. OpenGL proporciona muchas funciones de alto nivel que hacen muy sencillo la construcción de matrices para transformaciones. Éstas se aplican sobre la matriz que este activa en ese instante. Para activar una de las dos matrices utilizamos la función glMatrixMode. Hay dos parámetros posibles:

glMatrixMode(GL_PROJECTION);
Activa la matriz de proyección, y
glMatrixMode(GL_MODELVIEW);

Activa la del modelador. Es necesario especificar con que matriz se trabaja, para poder aplicar las transformaciones necesarias en función de lo que se desee hacer.

El camino que va desde los datos “en bruto” de los vértices hasta las coordenadas en pantalla sigue el siguiente camino: Primero, el vértice se convierte en una matriz 1x4 en la que los tres primeros valores son las coordenadas x, y, z. El cuarto número (llamado parámetro w) es un factor de escala, que no se va a usar de momento, usando el valor 1.0. Entonces se multiplica el vértice por la matriz del modelador, para obtener las coordenadas oculares. Éstas se multiplican por la matriz de proyección para conseguir las coordenadas de trabajo. Con esto se eliminan todos los datos que están fuera del volumen de proyección. Estas coordenadas de trabajo se dividen por el parámetro w del vértice, para hacer el escalado relativo. Finalmente, las coordenadas resultantes se mapean en un plano 2D mediante la transformación de la vista.

La matriz del modelador

La matriz del modelador es una matriz 4x4 que representa el sistema de coordenadas transformado que se está usando para colocar y orientar los objetos. Si se multiplica la matriz del vértice (de tamaño 1x4) por ésta se obtiene otra matriz 1x4 con los vértices transformados sobre ese sistema de coordenadas.

OpenGL proporciona funciones de alto nivel para conseguir matrices de translación, rotación y escalado, y además la multiplican por la matriz activa en ese instante, de manera que no hay que preocuparse por ello en absoluto.

Traslación

Imaginemos que se quiere dibujar un cubo con la función de la librería GLUT glutSolidCube, que lleva como parámetro el lado del cubo. Si se escribe el siguiente código:

glutSolidCube(5);

Se obtiene un cubo centrado en el origen (0,0,0) y con el lado de la arista 5. Ahora se quiere mover 10 unidades hacia la derecha (es decir, 10 unidades en el sentido positivo del eje de las x). Para ello se tendría que construir una matriz de transformación y multiplicarla por la matriz del modelador. Ogl nos ofrece la función glTranslate, que crea la matriz de transformación y la multiplica por la matriz que está activa en ese instante (en este caso debería ser la del modelador, GL_MODELVIEW). Entonces el código quedaría de la siguiente manera:

glTranslatef(10.0f, 0.0f, 0.0f);
glutSolidCube(5);

La “f” añadida a la función indica que se usarán flotantes. Los parámetros de glTranslate son las unidades a desplazar en el eje x, y y z, respectivamente. Pueden ser valores negativos, para trasladar en el sentido contrario.

Rotación

Para rotar, tenemos también una función de alto nivel que construye la matriz de transformación y la multiplica por la matriz activa, glRotate. Lleva como parámetros el ángulo a rotar (en grados, sentido horario), y después x, y y z del vector sobre el cual se quiere rotar el objeto. Una rotación simple, sobre el eje y, de 10° sería:
glRotatef(10, 0.0f, 1.0f, 0.0f);

Escalado

Una transformación de escala incrementa el tamaño de nuestro objeto expandiendo todos los vértices a lo largo de los tres ejes por los factores especificados. La función glScale lleva como parámetros la escala en x, y y z, respectivamente. El valor 1.0f es la referencia de la escala, de tal forma que:

glScalef(1.0f, 1.0f, 1.0f);

No modificaría el objeto en absoluto. Un valor de 2.0f sería el doble, y 0.5f sería la mitad. Por ejemplo, para ensanchar un objeto a lo largo de su eje z, de tal forma que quedase cuatro veces más “alargado” en este eje, sería:
glScalef(1.0f, 1.0f, 4.0f);

La matriz identidad

El “problema” del uso de estas funciones surge cuando se tiene más de un objeto en la escena. Estas funciones tienen efectos acumulativos. Es decir, si se quiere preparar una escena como la de la ilustración:

Con una esfera (de radio 3) centrada en (0, 10, 0) y otra centrada en (10, 0, 0), y se escribe el siguiente código (que es incorrecto):

glTranslatef(0.0f, 10.0f, 0.0f);
glutSolidSphere(3.0f, 8, 8);
glTranslate(10.0f, 0.0f, 0.0f);
glutSolidsphere(3.0f, 8, 8);

En este código, se dibuja primero una esfera en (0, 10, 0) como se quiere. Pero después, se está multiplicando la matriz del modelador (que ya estaba transformada para dibujar la primera esfera) por otra matriz de transformación que desplaza 10 unidades hacia la derecha. Por ello la segunda matriz se dibujaría, en (10, 10 ,0), y no en (10, 0, 0), como se pretendía.

Para solventar este problema se debe reiniciar la matriz del modelador a un estado conocido, en este caso, centrada en el origen de nuestro sistema de coordenadas oculares. Para ello se carga en la matriz del modelador la matriz identidad (una matriz 4x4 llena de ceros excepto en la diagonal, que contiene unos). Esto se consigue gracias a la función glLoadIdentity, que no lleva parámetros. Simplemente carga la matriz identidad en la matriz activa en ese instante. El código correcto para el ejemplo anterior quedaría de la siguiente manera:

glTranslatef(0.0f, 10.0f, 0.0f);
glutSolidSphere(3.0f, 8, 8);
glLoadIdentity();
glTranslate(10.0f, 0.0f, 0.0f);
glutSolidsphere(3.0f, 8, 8);  


La matriz de proyección

La matriz de proyección especifica el tamaño y la forma del volumen de visualización. El volumen de visualización es aquel cuyo contenido es el que se representa en pantalla. Está delimitado por una serie de planos de trabajo. De estos planos, los más importantes son los planos de corte, que son los que nos acotan el volumen de visualización por delante y por detrás. En el plano más cercano a la cámara (znear) es donde se proyecta la escena para luego pasarla a la pantalla. Todo lo que está más adelante del plano de corte más alejado de la cámara (zfar) no se representa.

Proyecciones ortográficas

Una proyección ortográfica es cuadrada en todas sus caras. Esto produce una proyección paralela, útil para aplicaciones de tipo CAD o dibujos arquitectónicos, o también para tomar medidas, ya que las dimensiones de lo que representan no se ven alteradas por la proyección.

Una aproximación menos técnica pero más comprensible de esta proyección es imaginar que se tiene un objeto fabricado con un material deformable, y se aplasta literalmente como una pared. Se obtendría el mismo objeto, pero plano, liso. Pues eso es lo que se vería por pantalla.

Para definir la matriz de proyección ortográfica y multiplicarla por la matriz activa (que debería ser en ese momento la de proyección, GL_PROJECTION), se utiliza la función glOrtho, que se define de la siguiente forma:

glOrtho(limiteIzquierdo, limiteDerecho, limiteAbajo, limiteArriba, znear, zfar)

Siendo todos flotantes. Los valores de znear y zfar no son las posiciones de esos planos en el espacio 3D. Representan la distancia desde el centro de proyección, con valor positivo hacia delante y negativo hacia atrás. Con esto simplemente se acota  lo que será¡ el volumen de visualización (un cubo).

Por ejemplo, la ilustración es un render de un coche con proyección ortográfica, visto desde delante.

El código utilizado para esta proyección ha sido:

glOrtho(-0.5f, 0.5f, -0.5f, 0.5f, 0.01f, 20.0f);

Proyecciones perspectivas

Una proyección en perspectiva reduce y estira los objetos más alejados del observador. Es importante saber que las medidas de la proyección de un objeto no tienen por qué coincidir con las del objeto real, ya que han sido deformadas.

El volumen de visualización creado por una perspectiva se llama frustum. Un frustum es una sección piramidal, vista desde la parte afilada hasta la base.

Se puede definir esta proyección utilizando la función glFrustum. Pero existe otra función de la librería GLU llamada gluPerspective que hace el proceso más sencillo. Se define de la siguiente forma:

Void gluPerspective(angulo, aspecto, znear, zfar);

Los parámetros de gluPerspective son flotantes y definen las características mostradas en la ilustración, el ángulo para el campo de visión en sentido vertical, el aspecto que es la relación entre la altura (h) y la anchura (w) y las distancias znear y zfar de los planos que acotan el fustrum al observador. Los valores de znear y zfar no son las posiciones de esos planos en el espacio 3D, representan la distancia desde el centro de proyección, con valor positivo hacia delante y negativo hacia atrás.
La ilustración muestra la escena del coche de la sección anterior, esta vez con una proyección en perspectiva:

El código utilizado para definir la proyección ha sido:

gluPerspective(45.0f,(GLfloat)(width/height),0.01f,100.0f);

Se usan 45° de ángulo, la relación entre el ancho y alto de la pantalla (width y height son el ancho y alto actual de la ventana) y las distancias a los planos de corte znear y zfar son 0.01 y 100 respectivamente.

martes, 25 de septiembre de 2012

Transformaciones geometricas

Hay que tener claro que no es lo mismo mover el objeto que mover la cámara. Si se mueve la cámara 3 unidades para atrás y se mueve el objeto 3 unidades para adelante la visión que se produce es la misma pero la escena ya no es la misma.
   
Las definiciones de las funciones son:

void glTranslate{fd}(TYPE x, TYPE y, TYPE z);
Multiplica la matriz actual por una matriz de traslación que mueve el objeto.s


void glRotate{fd}(TYPE angle,TYPE x, TYPE y, TYPE z);
Multiplica la matriz actual por una matriz de rotación que rota el objeto en la dirección de las agujas del reloj sobre el radio de origen en el punto x,y,z.



void glScale{fd}(TYPE x, TYPE y, TYPE z);
Multiplica la matriz actual por una matriz que cambia el tamaño del objeto a lo largo de los ejes. Las coordenadas x, y, z de cada objeto es multiplicada por los parámetros x, y, z.

lunes, 24 de septiembre de 2012

Proyeccion en OpenGL

Es  necesario activar la matriz e inicializarla mediante las órdenes OpenGL:

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

La proyección define el volumen del espacio que va a utilizarse para formar la imagen; en el caso de la proyección perspectiva este volumen es una pirámide truncada o frustum. Por lo tanto, en esta proyección se produce un efecto tamaño - distancia y es la proyección más usada en animación por ordenador o simulación visual, donde se requiere un alto grado de realismo. El frustum de visualización se define en OpenGL de la forma siguiente:

void glFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top,

GLdouble near, GLdouble far)

Dónde los parámetros left, right, bottom, top, near y far definen el frustum tal y como se muestra en la figura siguiente:

Tal y como se muestra en la figura, el frustum no tiene porqué ser simétrico respecto al eje Z, ya que es posible utilizar valores distintos para left y right, o para bottom y top.

La especificación de una proyección perspectiva mediante glFrustum puede resultar complicada debido a que la forma de definición no resulta intuitiva. En lugar de esta orden, podemos utilizar la rutina de la librería de utilidades de OpenGL gluPerspective. Esta rutina permite especificar el volumen de la vista de forma diferente, utilizando el ángulo de visión sobre el plano XZ (fovy) y el ratio de la anchura respecto a la altura (aspect). Mediante estos parámetros es posible determinar el volumen de la vista, tal y como se muestra en la figura siguiente: 
Esta forma de definir la proyección resulta más intuitiva. La sintaxis de la rutina gluPerspective es la siguiente:

void gluPerspective (GLdouble fovy, GLdouble aspect, GLdouble near, GLdouble far)

Cuando utilicemos la rutina gluPerspective tendremos que tomar precauciones con respecto a los valores de fovy y near. Una mala elección de dichos valores puede producir deformaciones en la imagen similares a las aberraciones ópticas habituales en las lentes fotográficas (v.g. efecto “ojo de pez”).

Otra forma de definir la manera en que una cámara sintética observa una escena es mediante dos posiciones en el espacio: la del punto de interés o punto al que la cámara está enfocando, y la del punto de vista o punto dónde se encuentra situada la cámara. Esta forma de definir la transformación de la vista es la que utiliza la orden de la librería de utilidades de OpenGL gluLookAt. La sintaxis de la orden es la siguiente:

gluLookAt(GLdouble eyex, GLdouble eyey, GLdouble eyez,

GLdouble centerx, GLdouble centery, GLdouble centerz,

GLdouble upx, GLdouble upy, GLdouble upz);

Donde los parámetros eyex, eyey, eyez indican la posición del punto de vista; centerx, centery, centerz especifican el punto de interés y upx, upy, upz la dirección tomada como “arriba”, o inclinación de la cámara

La proyección ortográfica define un volumen de la vista cuya geometría es la de un paralelepípedo rectangular (o informalmente, una “caja”). A diferencia de la proyección perspectiva, la distancia de un objeto a la cámara no influye en el tamaño final del mismo en la imagen. Este tipo de proyecciones son comunes en aplicaciones de diseño asistido por ordenador, ya que las medidas sobre la imagen son proporcionales a las reales de acuerdo a un determinado factor de escala. Entre las proyecciones ortográficas más comunes en este tipo de sistemas cabe destacar la proyección ortográfica (planta, alzado y perfil) y la proyección isométrica. La caja de visualización se define en OpenGL de la forma siguiente:

void glOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top,

GLdouble near, GLdouble far)

Dónde los parámetros left, right, bottom, top, near y far definen la caja tal y como se muestra en la figura siguiente:
 

jueves, 13 de septiembre de 2012

Generacion de lineas rectas


LINEA

Es el medio gráfico fundamental para representar las formas que nos rodean y las ideas, creando un lenguaje que no necesita palabras. Es el elemento visual más importante del dibujo. Tiene la facultad de transmitir sensaciones ya sea por su forma o por su disposición, solas o agrupadas.

 Líneas rectas: Expresan robustez y rigidez
 Líneas curvas: Sugiere movimiento, vitalidad, suavidad, delicadeza.
 Líneas horizontales: Expresan calma, reposo, tranquilidad, peso, estabilidad. Hacen las   cosas más anchas y extensas.
 Líneas verticales: Nos transmiten fuerza, orden, equilibrio, movimiento ascendente o descendente, elegancia, espiritualidad. Producen el fenómeno visual de alargar las cosas.
 Líneas oblicuas: Expresan inestabilidad, acción, caída, caos, desorden, confusión, sensación de profundidad y alejamiento.
 Líneas quebradas: Producen el efecto de incertidumbre,  indecisión. Una sensación similar a la ro-tura, la fragmentación.
 Líneas radiales o concurrentes: Sugieren luminosidad, explosión, asombro, dispersión, profundidad.

ALGORITMO DDA PARA GENERACION DE RECTAS

Este Algoritmo sirve para Generar Una Línea Recta, y Para eso Hace Uso de La pendiente Y de los Incrementos en X, Y.
Como todos saben Open GL es una herramienta que nos facilita mucho la generación de gráficos por computadora. Aquí aplicamos conocimientos matemáticos, usando Open GL para generar rectas, circunferencias, elipses, etc. El Algoritmo DDA es un algoritmo de línea de conversión de rastreo que se basa en el cálculo ya sea en el incremento de X o en el incremento de Y. La finalidad de este algoritmo es determinar los valores enteros correspondientes más próximos a la trayectoria de la línea para la otra coordenada.

void DDA(int x0,int y0,int xFin,int yFin){
int dx = xFin - x0, dy = yFin - y0, steps, k;
float xIncremento, yIncremento;
float x = x0, y = y0;
if (fabs (dx) > fabs (dy))
steps = fabs (dx); /* |m|<1>
else
steps = fabs (dy); /* |m|>=1 */
xIncremento=float(dx)/float (steps);
yIncrement = float (dy) / float (steps);
setPixel (round (x), round (y));
for (k = 0; k <>{
x += xIncremento;
y += yIncremento;
setPixel (round (x), round (y));
}

}

ALGORITMO DE BRESENHAM PARA TRAZAR LÍNEAS

El algoritmo de Bresenham es un algoritmo creado 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 de Bresenham sirve para trazar una línea entre dos puntos.

void Bres(int x0,int y0,int xFin,int yFin){
int dx = fabs(xFin - x0),
dy = fabs(yFin - y0);
int p = 2 * dy - dx;
int dosDy = 2 * dy,
dosDyMenosDx = 2 * (dy - dx);
int x, y;
if (x0 > xFin) {
x = xFin;
y = yFin;
xFin = x0;
}
else {
x = x0;
y = y0;
}
setPixel (x, y);
while (x <>
x++;
if (p <>
p += dosDy;
else {
y++;
p += dosDyMenosDx;
}

setPixel (x, y);

}

}

CIRCUNFERENCIA

Se conoce como circunferencia a la línea cerrada de formato curva y apariencia plana en la cual los puntos resultan equidistantes del punto central que se localiza en el mismo plano. Esta distancia que separa al conjunto de puntos y al área central se conoce como radio, mientras que el segmento de recta que compone un par de radios alineados recibe el nombre de diámetro.

ALGORITMO DE BRESENHAM PARA TRAZAR CIRCUNFERENCIAS

Los dos procedimientos planteados en esta sección utilizan demasiadas operaciones, sobre todo de aritmética de punto flotante, cuando deseamos trazar cientos de círculos, comenzamos a pensar en que debemos encontrar una forma más eficiente de hacerlo.

Estamos de acuerdo en que si somos capaces de trazar el circulo en el origen, moverlo de manera en que su centro quede ubicado en (xc; yc) implica simplemente sumar xc a todas las coordenadas x y sumar yc a todas