martes, 28 de febrero de 2012

Cubo

#include <gl\glut.h>
void myinit(void)
{/* attributes */
glClearColor(1.0, 1.0, 1.0, 1.0); /* white background */

glColor3f(1.0, 0.0, 0.0); /* draw in red */
/* set up viewing */

/* 500 x 500 window with origin lower left */
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 500.0, 0.0, 500.0);
glMatrixMode(GL_MODELVIEW);
}

void display(void)
{       
  typedef GLfloat point2[2];
  point2 vertice[8] = {{100.0,100.0},{300.0,100.0},{300.0,300.0},{100.0,300.0},{400.0,200.0},{400.0,400.0},{200.0,400.0},{200.0,200.0}};  
 
  glColor3f(1.0,0.0,0.0);
  gluOrtho2D(0.0, 500.0, 0.0, 500.0);
  glClear(GL_COLOR_BUFFER_BIT);
  glBegin(GL_LINES);
  glVertex2fv(vertice[0]);
  glVertex2fv(vertice[1]);
  glVertex2fv(vertice[1]);
  glVertex2fv(vertice[2]);
  glVertex2fv(vertice[2]);
  glVertex2fv(vertice[3]);
  glVertex2fv(vertice[3]);
  glVertex2fv(vertice[0]);
  glVertex2fv(vertice[1]);
  glVertex2fv(vertice[4]);
  glVertex2fv(vertice[2]);
  glVertex2fv(vertice[5]);
  glVertex2fv(vertice[5]);
  glVertex2fv(vertice[4]);
  glVertex2fv(vertice[5]);
  glVertex2fv(vertice[6]);
  glVertex2fv(vertice[6]);
  glVertex2fv(vertice[3]);
  glVertex2fv(vertice[0]);
  glVertex2fv(vertice[7]);
  glVertex2fv(vertice[4]);
  glVertex2fv(vertice[7]);
  glVertex2fv(vertice[6]);
  glVertex2fv(vertice[7]);
  glEnd();
        glFlush();
}


void main(int argc, char** argv)
{
        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
        glutInitWindowSize(512, 512);
        glutCreateWindow("Cubo  en 2D");
        glutDisplayFunc(display);
 
        glutMainLoop();      
}

martes, 21 de febrero de 2012

UNIDAD II Graficación 2D.

Algoritmo DDA para generación de rectas.

Este algoritmo sirve para generar lineas rectas haciendo uso de la pendiente Y y de los incrementos en X,Y.
Es un algoritmo de digitalización de líneas basado en calcular dy y dx usando cualquiera de las dos ecuaciones (dy = m * dx) o (dx = m * dy).

El codigo es:
void DDA(int x_0,int y_0, int x_fin, int y_fin){
glClear ( GL_COLOR_BUFFER_BIT );
glPointSize(3.0);
glScalef(4.0, 4.0, 2.0);

glBegin(GL_POINTS);
glVertex2i(x_0,y_0);

int vx=(int)fabs(x_fin-x_0);
int vy=(int)fabs(y_fin-y_0);
int dx,dy;
int m = (int)(y_fin-y_0)/(x_fin-x_0);

if(m==1)m++;
if(m==0)m=-1;

if(m>0&&m<1){
if(x_0<x_fin){
dx=1;
dy=m;
}else{
dx=-1;
dy=-m;
}
}
else
if(m>0&&m>1){
if(m>1){
if(x_0<x_fin){
dy=1;
dx=(int)1/m;

}else{
dy=-1;
dx=(int)-1/m;

}
}else
if(m<0&&fabs(m)<1){
if(x_0>x_fin)
{
dx=-1;
dy=-m;

}else
{
dx=1;
dy=-m;
}

}
else{
if(x_0>x_fin){
dy=1;
dx=-1/m;

}
else {
dy=-1;
dx=1/m;

}
}
if(m>0&&m<1){
for(int i=1;i<=vx;i++)
{
glVertex2i(x_0+dx ,y_0+dy );
x_0+=dx;
y_0+=dy;

}
}
else
if(m>0&&m>1){
for(int i=1;i<=vy;i++){
glVertex2i(x_0+dx ,y_0+dy );
x_0+=dx;
y_0+=dy;}

}else
if(m<0&&fabs(m)<1){
for(int i=1;i<=vx;i++)
{
glVertex2i(x_0+dx ,y_0+dy );
x_0+=dx;
y_0+=dy;

}
}
else{
for(int i=1;i<=vy;i++){
glVertex2i(x_0+dx ,y_0+dy );
x_0+=dx;
y_0+=dy;
}
}
}
glEnd();
glFlush();
}


Algoritmo de Bresenham para trazar líneas.

Es un algoritmo que determina los puntosen un mapa de bits de n dimensiones que son trazados con el fin de formar una aproximación a una línea recta entre dos puntos dados.
El algoritmo de Bresenham selecciona el entero 'Y' correspondiente al pixel central que está más cercano del que sería calculado con fracciones y lo mismo para la coordenada 'X'. En las sucesivas columnas la coordenada 'Y' puede permanecer con el mismo valor o incrementarse en cada paso a una unidad.

Las ecuaciones necesarias son:

Y - Y0 = X - X0
Y1-Y0    X1-X0
    
     Y1-Y0
y = ------- (X - X0) + Y0
     X1-X0

El código es:
void brenenham(int x1, int y1, int x2, int y2)
{
int slope;
int dx, dy, incE, incNE, d, x, y;
// Reverse lines where x1 > x2if (x1 > x2)
{
brenenham(x2, y2, x1, y1)
;return;
}
dx = x2 - x1;
dy = y2 - y1;
// Adjust y-increment for negatively sloped lines
if (dy < 0)
{
slope = -1;
dy = -dy;
}
else
{
slope = 1;
}
// Bresenham constants
incE = 2 * dy;
incNE = 2 * dy - 2 * dx;
d = 2 * dy - dx;y = y1;
// Blit
for (x = x1; x <= x2; x++)
{
putpixel(x, y, 15);
if (d <= 0)
{
d += incE;
}
else
{
d += incNE;
y += slope;
}
}
}


Algoritmo de Bresenham para el trazo de circunferencias.

Se basa en analizar el error entre la verdadera circunferencia y su discretización. En cada paso elige como próximo pixel a aquel que minimice el error.
En este caso se toma como error la distancia al cuadrado del pixel (x,y) a la circunferencia de centro en el origen y radio r:
e
Si elegimos D, entonces el próximo pixel es P
e
Si elegimos S el proximo pixel es P
e=x
 







Fuentes de información:
http://compugrafica.wordpress.com/2008/12/03/algoritmo-dda-para-generacion-de-rectas/
issuu.com/uvitzel/docs/eva_y_chava
http://es.scribd.com/doc/59563233/Algoritmo-Bresenham
= x2+ (y+1)2-r2 = e+2y+1D=(x-1, y+1) = (x-1)2+ (y+1)2-r2 = x2-2x +1+y2+2y+1-r2 = eS -2x+1S=(x, y+1) entonces:2+ y2-r2.

martes, 14 de febrero de 2012

Definiciones (Fractales)

  • Dimensión Fractal:  Dado que un fractal está constituido por elementos cada vez más pequeños, el concepto de longitud no está claramente definido: Cuando se quiere medir una linea fractal con una unidad, o con un instrumento de medida determinado, siempre habrá objetos más finos que escaparán a la sensibilidad de la regla o el instrumento utilizado, y también a medida que aumenta la sensibilidad del instrumento aumenta la longitud de la línea.
  • Dimensión de Minkowski Bouligand: Es una generalización métrica del concepto de dimensión de un espacio topológico, que permite definir una dimensión fraccionaria (no-entera) para un objeto fractal.
  • Dimensión de Hausdorff-Besicovitch: Es la expresión matemática de la dimensión de los objetos. El enfoque generalizado de Hausdorff hace que esta definición útil de los objetos naturales conspiran. 
  • Dimensión topológica:  En una curva solo es posible moverse en una dirección, adelante o hacia atrás. En una superficie es posible ir adelante, atrás, a derecha, a izquierda. En un volumen es posible moverse, además, hacia arriba, hacia abajo. La curva tiene una dimensión, la superficie tiene dos dimensiones y el volumen tiene tres dimensiones.
Ejemplos de Fractales:

Conjuntos de Julia.
Conjunto de Mandelbrot


Curva de Koch.
 Sistemas de Funciones Iteradas (IFS)
    
  • Es una construcción matemática usada para representar de manera simple ciertos conjuntos fractales que presenten autosimilaridad. Muchos fractales clásicos autosimilares, autoafines y autoconformes pueden representarse como el único conjunto compacto invariante por un sistema iterativo de funciones contractivas. 
Archivo:Conjunto de Cantor.png
Conjunto de cantor.

Alfombra de Sierspinski

Triangulo de sierpinski.

Curva de Peano.

curva del dragón
Curva del Dragón

Archivo:Koch snowflake (RGB-CMY).jpg
Copo de nieve de Koch.

La esponja de Menger
Esponja de Menger.
 Fractales de algoritmo de escape:
  • Para cada punto se calculan una serie de valores mediante la repetición de una formula hasta que se cumple una condición, momento en el cual se asigna al punto un color relacionado con el número de repeticiones. Los fractales de este tipo precisan de millones de operaciones, por lo cual sólo pueden dibujarse con la inestimable ayuda del ordenador.
Fractal de Lyapunov.
Fractales aleatorios:
  • Tienen una gran aplicación practica, usándolos para describir varios objetos muy irregulares del mundo real. Ejemplos son las nubes, montañas, turbulencia, costas y árboles. Técnicas de fractales han sido utilizadas en la comprensión de imágenes, así como en una variedad de disciplinas científicas.


Paisaje fractal


Fuentes de información:
  • http://platea.pntic.mec.es/mzapata/tutor_ma/fractal/dim_frac.htm
  • wikipedia.org
  • http://translate.google.com.mx/translate?hl=es&sl=en&u=http://www.tgmdev.be/hausdorffdim.htm&ei=E7U6T_WwDoPe2AXs_YXHCg&sa=X&oi=translate&ct=result&resnum=8&sqi=2&ved=0CGgQ7gEwBw&prev=/search%3Fq%3Ddimension%2Bhausdorff-besicovitch%26hl%3Des%26biw%3D1440%26bih%3D698%26prmd%3Dimvns
  • http://fralbe.wordpress.com/2008/11/11/dimension-topologica-y-dimension-fractal/
  • http://www.arrakis.es/~sysifus/tipos.html

martes, 7 de febrero de 2012

1.4 Aspectos matemáticos de la graficación (Geometría fractal)

¿Qué es un fractal?
Un fractal es un ente geométrico el cual en su desarrollo se va reproduciendo a si mismo en una escala menor.
Una caracteristica de los fractales es cuando se e através de una lupa una parte del fractal, este se ve completo pero a menor escala.

Geometría fractal
Es un tipo de geometría que no distingue entre un conjunto matemático y un objeto de la vida real o natural.
La geomrtría fractal se caracteriza por dibujos que se repiten pero con un menor tamaño al original.

Las 5 imágenes fractales mas conocidas.
  1. El triángulo de Sierpinsky Construcción del triángulo de Sierpinsky
  2. Esponja de Menger.
  3. Dragón de Mandelbrot 
  4. Black and white fractals that capture creativity. Black and White Fractals That Capture Creativity
  5. Atractor de Lorenz.
Atractor de Lorenz



Fuentes de información:
http://casanchi.com/mat/03_gfractal01.pdf
http://www.geometriafractal.com/geometriafractal.asp
http://www.astrosafor.net/Huygens/2002/37/Fractal.htm
http://www.duamu.com/he/2009052053/
http://www.atomosybits.com/category/psicologia/

sábado, 4 de febrero de 2012

OpenGL(Actividad 3)

¿Qué es OpenGL?

Es una especificación estandar que funciona para escribir aplicaciones en 2D y 3D.
OpenGL tiene dos propósitos esenciales:
  1. Ocultar la complejidad de la interfaz con las diferentes tarjetas gráficas, presentando al programador una API única y uniforme.
  2. Ocultar las diferentes capacidades de las diversas plataformas hardware, requiriendo que todas las implementaciones soporten la funcionalidad completa de OpenGL.
Pasos para la libreria del OpenGL:
  1. Se descargan las librerias.
  2. glut32.dll -> C: \ Windows \ System o C: \ WinNT \ System
    glut32.lib -> C: \ Archivos de programa \ Microsoft Visual Studio 8 \ VC \ PlatformSDK \ lib
    glut32.h -> C: \ Archivos de programa \ Microsoft Visual Studio 8 \ VC \ PlatformSDK \ include \ gl
 Código:

/*cubetex.c           */ 
/* Rotating cube with texture mapping */
/* mouse buttons control direction of
/* rotation, keyboard allows start/top/quit */
/* E. Angel, Interactive Computer Graphics */
/* A Top-Down Approach with OpenGL, Third Edition */
/* Addison-Wesley Longman, 2003 */
#include <stdlib.h>
#include <GL/glut.h>
GLfloat planes[]= {-1.0, 0.0, 1.0, 0.0};
GLfloat planet[]= {0.0, -1.0,  0.0, 1.0};
 GLfloat vertices[][3] = {{-1.0,-1.0,-1.0},{1.0,-1.0,-1.0},
 {1.0,1.0,-1.0}, {-1.0,1.0,-1.0}, {-1.0,-1.0,1.0},
 {1.0,-1.0,1.0}, {1.0,1.0,1.0}, {-1.0,1.0,1.0}};
 GLfloat colors[][4] = {{0.0,0.0,0.0,0.5},{1.0,0.0,0.0,0.5},
 {1.0,1.0,0.0,0.5}, {0.0,1.0,0.0,0.5}, {0.0,0.0,1.0,0.5},
 {1.0,0.0,1.0,0.5}, {1.0,1.0,1.0,0.5}, {0.0,1.0,1.0,0.5}};
void polygon(int a, int b, int c , int d)
{
/* draw a polygon via list of vertices */
  glBegin(GL_POLYGON);
 glColor4fv(colors[a]);
 glTexCoord2f(0.0,0.0);
 glVertex3fv(vertices[a]);
 glColor4fv(colors[b]);
 glTexCoord2f(0.0,1.0);
 glVertex3fv(vertices[b]);
 glColor4fv(colors[c]);
 glTexCoord2f(1.0,1.0);
 glVertex3fv(vertices[c]);
 glColor4fv(colors[d]);
 glTexCoord2f(1.0,0.0);
 glVertex3fv(vertices[d]);
 glEnd();
                          }
void colorcube(void)
{
/* map vertices to faces */
 polygon(0,3,2,1);
 polygon(2,3,7,6);
 polygon(0,4,7,3);
 polygon(1,2,6,5);
 polygon(4,5,6,7);
 polygon(0,1,5,4);
}
static GLfloat theta[] = {0.0,0.0,0.0};
static GLint axis = 2;
void display(void)
{
/* display callback, clear frame buffer and z buffer,
   rotate cube and draw, swap buffers */
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 glLoadIdentity();
 glRotatef(theta[0], 1.0, 0.0, 0.0);
 glRotatef(theta[1], 0.0, 1.0, 0.0);
 glRotatef(theta[2], 0.0, 0.0, 1.0);
 colorcube();
 glutSwapBuffers();
}
void spinCube()
{
/* Idle callback, spin cube 2 degrees about selected axis */
 theta[axis] += 2.0;
 if( theta[axis] > 360.0 ) theta[axis] -= 360.0;
 glutPostRedisplay();
}
void mouse(int btn, int state, int x, int y)
{
/* mouse callback, selects an axis about which to rotate */
 if(btn==GLUT_LEFT_BUTTON && state == GLUT_DOWN) axis = 0;
 if(btn==GLUT_MIDDLE_BUTTON && state == GLUT_DOWN) axis = 1;
 if(btn==GLUT_RIGHT_BUTTON && state == GLUT_DOWN) axis = 2;
}
void myReshape(int w, int h)
{
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    if (w <= h)
        glOrtho(-2.0, 2.0, -2.0 * (GLfloat) h / (GLfloat) w,
            2.0 * (GLfloat) h / (GLfloat) w, -10.0, 10.0);
    else
        glOrtho(-2.0 * (GLfloat) w / (GLfloat) h,
            2.0 * (GLfloat) w / (GLfloat) h, -2.0, 2.0, -10.0, 10.0);
    glMatrixMode(GL_MODELVIEW);
}
void key(unsigned char k, int x, int y)
{
 if(k == '1') glutIdleFunc(spinCube);
 if(k == '2') glutIdleFunc(NULL);
 if(k == 'q') exit(0);
}
void
main(int argc, char **argv)
{
   GLubyte image[64][64][3];
   int i, j, r, c;
   for(i=0;i<64;i++)
   {
     for(j=0;j<64;j++)
     {
       c = ((((i&0x8)==0)^((j&0x8))==0))*255;
       image[i][j][0]= (GLubyte) c;
       image[i][j][1]= (GLubyte) c;
       image[i][j][2]= (GLubyte) c;
     }
   }
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(500, 500);
    glutCreateWindow("colorcube");
/* need both double buffering and z buffer */
    glutReshapeFunc(myReshape);
    glutDisplayFunc(display);
   glutIdleFunc(spinCube);
   glutMouseFunc(mouse);
   glEnable(GL_DEPTH_TEST);
   glEnable(GL_TEXTURE_2D);
   glTexImage2D(GL_TEXTURE_2D,0,3,64,64,0,GL_RGB,GL_UNSIGNED_BYTE, image);
   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
   glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
   glutKeyboardFunc(key);
   glClearColor(1.0,1.0,1.0,1.0);
   glutMainLoop();
}

Proyecto de graficacion.

A mi me gustaría hacer un tipo de simulación sobre el sistema solar, la trayectoria de los planetas y lunas de cada planeta, asi como tambien los asteroides o cometas.

viernes, 3 de febrero de 2012

Actividad ensayos unidad 1.

1.1 Aplicaciones gráficas por computadora.


Se refiere al campo de la informática visual que trabaja con imágenes para transformarlas en 3D y 2D. Algunas de las aplicaciones y herramientas son:
·         Despliegue de la información: Se refiere a las imágenes que se crean en diferentes programas y se transforman por medio de la graficación para moverlas, entre otras cosas.
·         Diseño: Esto consiste en pensar en el proyecto que va a crear, conocido también como “pre-figuración”.
·         Simulación y animación: En este caso, la simulación se encarga de dar un movimiento real pero limitado al dibujo con el que se está trabajando. Y la animación se encarga de darle un movimiento libre a la imagen.
·         Interfaces de usuario: Se refiere a lo que se muestra o lo que permite una mejor interacción de usuario y computadora, esto puede ser menús, teclado, ventanas entre otras cosas.
El sistema gráfico contiene algunos conceptos importantes como:
·         Procesador: Que es el cerebro de la computadora y dependiendo del tipo y capacidad o tamaño es el resultado de un mejor rendimiento.
·         Memoria: Es el objeto de almacenamiento donde se guarda la información utilizada al momento de trabajar.
·         Framebuffer: Es la porción de la memoria que guarda una imagen antes de ser vista o enviada al monitor o dispositivo.
·         Dispositivos de salida: Es lo que se encarga del resultado o salida de la información, algunos ejemplos serian: Monitor, bocinas, impresoras, plotters entre otros.
·         Dispositivos de entrada: Son los que se encargan de introducir la información a la computadora para su proceso, como el teclado, lápices ópticos, entre otros.



1.2 Dispositivos de Hardware y software para el despliegue gráfico.


Algunos dispositivos utilizados para el despliegue gráfico son: Los monitores, que son de diferentes tipos.
·         Tubo de rayos catódicos: Este consiste en un tubo vacio que en su interior tiene un cátodo de metal caliente por el cual circula la corriente eléctrica.
·         Monitores de barrido: En algunos monitores se realiza la función de barrido vertical en dos fases, en la primera se recorren las líneas impares y en la segunda se recorren las líneas pares. De esta manera pereciera como si se viera doble.
·         Monitores de trazado aleatorio o vectorial: Este es el menos utilizado ya que el haz de electrones en lugar de recorrer la pantalla a base de pixeles traza una serie de segmentos que a su vez son correspondientes a las líneas de la imagen que se quiere representar.
·         Monitores CRT en color: Son los que utilizan fósforos que producen diferentes colores.
·         Monitores de cuarzo líquido: Con sus siglas LCD, se refiere a dos placas de cristal que prensan el cuarzo líquido creando así líneas verticales de conductores transparentes y en la otra prensa las verticales.

Software de Gráficos


Consiste en un conjunto de pixeles a partir de una idea de alto nivel como una descripción gráfica de líneas, curvas, colores e inclusive términos tridimensionales.
Para obtener la representación de un mapa de pixeles se puede partir de una línea en dos dimensiones pero es necesario seleccionar las posiciones de la pantalla que pertenecen al trazado de la línea.



1.3 Formatos gráficos de almacenamiento.

Se refiere a los archivos donde se guarda la información que forma una imagen, cada formato es independiente ya que cada uno depende de la gama de colores, la compatibilidad y velocidad de carga que puede manejar; se puede dividir en dos grandes grupos de formatos los cuales son: Vectoriales y Bitmap.
Los formatos más importantes son:
·         BMP
·         CDR
·         DXF
·         EPS
·         GIF
·         IFF
·         JPG
·         MAC
·         PCX
·         PIC
·         TGA
·         WMF
·         WPG
Pero los más utilizados son el GIF y el JPG siendo el JPG mejor en muchos aspectos como: comprime mucho más y mejor las imágenes además de la gama de colores que utiliza mucho mas superior que la del GIF.

Fuentes de información:
keylarosacupul.blogspot.com/2009/08/
Wikipedia.or
Monografias.com
Alegsa.or