jueves, 28 de febrero de 2013

Estás preparado para la edición más importante del programa de Google destinado a la creación de proyectos de software libre.







8/02/2013 - Google Summer of Code 2013 está diseñado para promover a la participación de estudiantes de todo el mundo en el desarrollo de software libre.

Desde su primera edición en 2005, Google Summer of Code ha reunido miles de participantes de más de 100 países a nivel mundial con el objetivo crear y liberar código abierto para el beneficio de todos e inspirar a los jóvenes desarrolladores a participar en la creación de aplicaciones Open Source.

Las propuestas de proyectos de organizaciones de código abierto empezarán el 18 de marzo, y los estudiantes podrán aplicar para ellos durante el período de abril y mayo.

Además del reconocimiento por haber desarrollado un proyecto de estas características Google otorgará un cheque de 5000 dolares a los estudiantes que hayan completado satisfactoriamente un proyecto Open Source durante Google Summer of Code 2013.

Interesados pueden acceder a más información de Google Summer of Code 2013 desde www.google-melange.com

http://google-opensource.blogspot.mx/


Agenda | 22/02/2013
Primeras informaciones de la nueva edición del encuentro de desarrolladores.

Demuestra tus capacidades como programador web y llevate el reconocimiento de la Comunidad JavaScript.

13/02/2013 - Como ya hemos señalado en alguna ocasión, JS1K es una competición creada por Peter van der Zee en la que cualquier desarrollador interesado puede participar para demostrar sus habilidades y conocimientos.

El objetivo de esta competición es crear una aplicación JavaScript soportada al menos por Firefox 18, Chrome 24 y Opera 12, cuyo código debe pesar menos de 1k (1024 bytes).

Las aplicaciones deben presentarse antes del próximo 31 de marzo para ser valoradas por un jurado de prestigio internacional que será quien tenga la última palabra a la hora de otorgar premios y reconocimientos.

Para conocer las posibilidades y nivel de la competición que mejor que las aplicaciones más destacadas de otras ediciones de este mismo evento.

http://js1k.com/2012-love/demo/1243


martes, 19 de febrero de 2013

Actividad :modelo- real-virtual

Acividad: realizar un objeto geometrico con colores de forma fisica, traducir  vertices y representar el objeto en opengl
.
fecha de entrega: Lunes 25 de Febrero.

referencias opengl

Opengl
referencia opengl
http://www.tecnun.es/asignaturas/grafcomp/OpenGL/tutorial-opengl.pdf

http://www.dccia.ua.es/dccia/inf/asignaturas/GC/Teoria/OpenGL.Introduccion.pdf

http://glprogramming.com/red/
Para crear imagenes  en opengl usando primitivas debe usarse la sintaxis  siguiente
glBegin(<tipo de primitiva>); glVertex(...); glVertex(...); ... glVertex(...);glEnd();

donde dentro de los parentesis debe estar   como parametro el modo de dibujo seguidos d ela lista de parametros.

glBegin(GL_ POLYGON);glVertex(...); glVertex(...);...glVertex(...);glEnd();

miércoles, 13 de febrero de 2013

gasket (ejecutar el siguiente codigo)

/* gasket2.c   */
/* E. Angel, Interactive Computer Graphics */
/* A Top-Down Approach with OpenGL, Third Edition */
/* Addison-Wesley Longman, 2003 */
/* Recursive subdivision of triangle to form Sierpinski gasket */
#include <GL/glut.h>
typedef float point2[2];
/* initial triangle */
point2 v[]={{-1.0, -0.58}, {1.0, -0.58}, {0.0, 1.15}};
int n;
void triangle( point2 a, point2 b, point2 c)
/* display one triangle  */
{
    glBegin(GL_TRIANGLES);
       glVertex2fv(a);
       glVertex2fv(b);
       glVertex2fv(c);
    glEnd();
}
void divide_triangle(point2 a, point2 b, point2 c, int m)
{
/* triangle subdivision using vertex numbers */
    point2 v0, v1, v2;
    int j;
    if(m>0)
    {
        for(j=0; j<2; j++) v0[j]=(a[j]+b[j])/2;
        for(j=0; j<2; j++) v1[j]=(a[j]+c[j])/2;
        for(j=0; j<2; j++) v2[j]=(b[j]+c[j])/2;
        divide_triangle(a, v0, v1, m-1);
        divide_triangle(c, v1, v2, m-1);
        divide_triangle(b, v2, v0, m-1);
    }
    else(triangle(a,b,c)); /* draw triangle at end of recursion */
}

void display(void)
{

    glClear(GL_COLOR_BUFFER_BIT);
 divide_triangle(v[0], v[1], v[2], n);
    glFlush();
}
void myinit()
{
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(-2.0, 2.0, -2.0, 2.0);
    glMatrixMode(GL_MODELVIEW);
    glClearColor (1.0, 1.0, 1.0, 1.0);
 glColor3f(0.0,0.0,0.0);
}
void
main(int argc, char **argv)
{
    n=4;
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB );
    glutInitWindowSize(500, 500);
    glutCreateWindow("3D Gasket");
    glutDisplayFunc(display);
 myinit();
    glutMainLoop();
}

martes, 12 de febrero de 2013

Actividad para subir al blog (geometria fractal)

Investigar:

Definición de :
1. Fractal
2. Geometria fractal
3. Conjuntos de Julia
4. Conjunto de Mandelbrot
5. Fractales en la Naturaleza
6.Triangulo de Sierpinski
subir al blog





GEOMETRÍA FRACTAL Y GEOMETRÍA EUCLIDIANA
Los elementos de la geometría euclidiana son puntos, líneas, curvas, etc., esto es, entes ideales concebidos por el hombre para modelizar los fenómenos naturales y cuantificarlos  midiendo longitudes, áreas o volúmenes. Pero estos  entes pueden ser tan complejos e irregulares que la medición usando la métrica euclidiana deja de tener sentido. Sin embargo, hay una manera de medir
él grado de complejidad e irregularidad, evaluando cuan rápido aumenta la longitud, la superficie o el volumen, si lo medímos en escalas cada vez más pequeñas. Este enfoque fue el adoptado por Mandelbrot, matemático polaco, que en 1980 acuñó el término fractal para designar entes muy irregulares, pero autosemejantes.


La geometría fractal cambiará afondo su visión de las cosas. Seguir leyendo es peligroso. Se arriesga a perder definitivamente la imagen inofensiva que tiene de nubes, bosques, galaxias, hojas, plumas, flores, rocas, montañas, tapices y de muchas otras cosas.Jamás volverá a recuperar las interpretaciones de todos estos objetos que hasta ahora le eran familiares.


Michael Barnsley (1988)


La geometría fractal, una teoría matemática  moderna que se aparta radicalmente de la geometría euclidiana tradicional, describe objetos geométricos que son autosemejantes o simétricos en escala. Esto significa que, cuando se amplifican tales objetos, sus partes guardan una semejanza exacta con el todo, prolongándose la similitud con las partes de las partes y así hasta el infinito. Los fractales, que es el nombre que se les da a estos objetos, carecen de simetría traslatoria, esto es, carecen de la suavidad asociada con líneas, planos y esferas euclidianas. En cambio, mantienen en cualquier escala un contorno rugoso y mellado. La palabra fractal  proviene del verbo latino  frangere (romper) y el adjetivo correspondiente  fractus
(irregular y fragmentado).

Fue Benoit B. Mandelbrot, matemático nacido en1924 en Varsovia, Polonia, quien abrió nuestros ojos a la geometría fractal de la naturaleza. La geometría fractal es un nuevo lenguaje cuyos elementos son algoritmos que computacionalmente pueden expresarse en formas y estructuras. La esencia del mensaje de Mandelbrot es que muchas estructuras naturales con una aparente complejidad (tales como nubes, 
montañas, costas marinas, fallas tectónicas, sistemas vasculares, superficies fracturadas de distintos materiales, etc.), están caracterizadas por una invariancia de escala geométrica cuya dimensión fractal provee una adecuada descripción matemática del fenómeno en cuestión.



El fractal geométrico más simple es el conjunto ternario de Cantor (introducido por el brillante  matemático alemán del siglo pasado George Cantor), que se muestra en la figura 1. Este  conjunto se construye tomando un segmentocualquiera, se divide en tres partes iguales y se extrae la parte central. Este proceso se aplica reiterativamente en cada una de las dos partes restantes, luego en las cuatro siguientes y así sucesivamente, hasta que el objeto tenga un número infinito de partes, cada una de las cuales es infinitamente pequeña. El fractal geométrico así obtenido es autosemejante, ya que en cada iteración se han repetido los mismos pasos.




Los fractales no quedan, obviamente, relegados exclusivamente al reino de las construcciones matemáticas. Si se amplía un poco el concepto, tales objetos pueden ser identificados virtualmente en cualquier parte del mundo natural. La diferencia consiste en que los fractales "naturales" no son exactamente autosemejantes, sino tan sólo al azar, en forma estadística o estocástica. La forma rugosa revelada en una escala guarda únicamente una similitud aproximada con la obtenida en otra escala. Además, en los fractales naturales existen límites inferiores y superiores para el rango de escalas enlas cuales estos objetos son verdaderamente fractales. Por debajo y por encima de este rango, las formas son rugosas (pero no autosemejantes) o suaves; en otras palabras, convencionalmente euclidianas.











Referencia
http://aprendeenlinea.udea.edu.co/revistas/index.php/revistaeyp/article/viewFile/5945/5355














Dispositivos de hardware y software para el despliegue gráfico.

Un sistema gráfico tradicional consta de cuatro componentes: procesador, unidadde procesamiento gráfico, dispositivos de entrada y dispositivos de salida. Elprocesador desempeña un papel central en cualquier sistema gráfico y cada unode los demás componentes debe comunicarse en algún momento con otro, o conel procesador mediante un canal de datos.

Generalmente el dispositivo principal de salida de un sistema gráfico es un monitorde video. El tipo más común es un CRT y actualmente se incrementa el uso de losLCD.

 
La cantidad de memoria de video requerida para almacenar una pantalla se determina multiplicando el número de pixeles horizontales, el número depixeles verticales y el número de bytes usados para codificar un pixel. Memoria de video = Res. H x Res. V x Núm. de bytes por pixel

Cada pixel se codifica mediante un conjunto de bits de longituddeterminada (la llamada profundidad de color ), por ejemplo, puede codificarseun pixel con un byte, u 8 bits, de manera que cada pixel admite 256 variantes (2dígitos por bit, elevados a la octava potencia). En las imágenes de color verdadero se suelen usar tres bytes para definir un color, es decir, en totalpodemos representar un total de 2 elevado a 24, o sea 16,777,216 colores diferentes.


El usuario de un sistema gráfico se comunica con el programa por medio deciertos dispositivos de entrada y obtiene los resultados en los dispositivos de salida.


El software gráfico
Una representación gráfica consisten en un conjunto de pixeles que se obtiene apartir de una idea de más alto nivel; como puede ser la descripción de la gráfica entérminos de líneas, arcos, colores etc. o incluso en términos de objetostridimensionales, puntos de vista e iluminación.El como llegar de estas descripciones de alto nivel al conjunto de pixeles final esalgo de lo que las diferentes partes del sistema se deberán encargar; por logeneral el programador dispone de una serie de librerías de programación gráficaque le permiten escribir aplicaciones sin tener que llegar a conocer en detalle elhardware sobre el que se ejecutará su código, y sin tener que escribir desde elprincipio miles de procedimientos que, además, distan de ser triviales. Ejemplosde estas librerías podrían son
OpenGL de SGI y Direct3D de Microsoft.
 
Investiga:
Que implementaciones existen basadas en OpenGL.
Que es un API.
revisión ( en clase,  apuntar en cuaderno)

más información y referencia: http://es.scribd.com/doc/13642361/Introduccion-Computacion-Grafica

lunes, 11 de febrero de 2013

actividad opengl

Actividad práctica

  1. Investigue que es opengl
  2. Como instalar las librerías
  3. Probar el siguiente código
  4. Los resultados de la actividad deben publicarse en su blog , incluyendo una captura de la pantalla donde se muestra los resultados de la ejecución del programa, la secuencia de pasos que realizó desde la instalación de la s librerías, fecha de revision Lunes 11 de Febrero

/*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();
}

Instalar glut 3.7.6

Configurar OpenGL y GLUT en Windows (Visual Studio)


Configurar OpenGL y GLUT en Visual Studio de Windows es también muy sencillo.
  1. Aunque OpenGL viene con todas las versiones de Windows, GLUT hace falta descargarlo. Esto se puede hacer desde la web de Nate Robins (glut-3.7.6-bin.zip).
  2. Después de descomprimirlo borramos los ficheros glut.def y README-win32.txt.
  3. Copiamos la dll glut32.dll en %WinDir%\System32 (C:\Windows\System32 por ejemplo).
  4. También copiamos la librería glut32.lib en el subdirectorio lib de VC (C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\lib en Windows 7/Vista o C:\Program Files\Microsoft Visual Studio 9.0\VC\lib en Windows XP por ejemplo).
  5. Después crear el subdirectorio gl en el directorio include de VC y copiar allí el fichero de cabecera glut32.h (C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\include\gl o C:\Program Files\Microsoft Visual Studio 9.0\VC\include\gl).
El siguiente video muestra los pasos anteriormente explicados:

miércoles, 6 de febrero de 2013

Opengl

Actividad práctica
  1. Investigue que es opengl
  2. Como instalar las librerías ( version  glut 3.7.6)
  3. Probar el siguiente código
  4. Los resultados de la actividad deben publicarse en su blog , incluyendo una captura de la pantalla donde se muestra los resultados de la ejecución del programa, la secuencia de pasos que realizó desde la instalación de la s librerías, fecha de revision Lunes 11 de Enero
/*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();
}

Fecha de publicacion Lunes 11 de febrero

lunes, 4 de febrero de 2013

Investigue los siguientes conceptos y publique en su blog los resultados, no olvide incluir las fuentes de información

1.Aplicaciones de gráficos de computadora
2. Sistema de gráficos
       Procesador
       Memoria
       frame buffer
       dispositivos de salida
      dispositivos de entrada
3.  disparidad binocular
     información monocular
revise el siguiente enlace

http://www.slideshare.net/AlonsoAlvarez/graficos-por-computadora-1

consulte otras  fuentes para profundizar en cada tema.

publique en su blog como  glosario ( agregar al glosario de la activiadad 2)

actividad Miércoles  6 de Febrero


Actividad   Jueves  7 de  Febrero : Leer la información de los siguientes enlaces, hacer un glosario de términos( 15 mínimo) incluirlo en la sección de glosario de su blog bajo el subtitulo de hardware y software dentro del mismo.  publicación  Lunes 11  de Febrero
escriba un ensayo sobre los temas  vistos en los enlaces,  (mínimo 2 cuartillas)
nota : una cuartilla es equivalente a  una hoja tamaño carta, espaciado sencillo y letra arial 12.
          Primero escribalo en word y luego pegar el texto en el blog.
Dispositivos                   http://giga.cps.unizar.es/~spd/work/curso_hs/

pantallas lcd                  http://www.xataka.com/hd/como-funciona-un-televisor-lcd

pantallas  de plasma     http://www.profisica.cl/comofuncionan/como.php?id=13

aliasing                          http://es.wikipedia.org/wiki/Aliasing

antialiasing                   
http://es.wikipedia.org/wiki/Antialiasing