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.
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:
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.
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:
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)
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
Suscribirse a:
Entradas (Atom)








