Fractales

 

 

 

 

 

 

 

 

 

 actividad Lunes 3 de septiembre:  el siguiente enlace contine fractales  compilados en c++ y GDI (Graphics Device Interface) investigue  sobre GDI y ejecute los  programas de los fractales, examine el código

 

http://www.programacioncpp.irandohosting.0lx.net/page.php?opc=fractales



referencia opengl

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

codigo base

#include <GL/gl.h>
#include <GL/glut.h>

void display(void)
{
/*  clear all pixels  */
    glClear (GL_COLOR_BUFFER_BIT);

/*  draw white polygon (rectangle) with corners at
 *  (0.25, 0.25, 0.0) and (0.75, 0.75, 0.0)  
 */
    glColor3f (1.0, 1.0, 1.0);
    glBegin(GL_LINES);
        glVertex3f (0.25, 0.25, 0.0);
        glVertex3f (0.75, 0.25, 0.0);
        glVertex3f (0.75, 0.75, 0.0);
        glVertex3f (0.25, 0.75, 0.0);
    glEnd();

/*  don't wait!  
 *  start processing buffered OpenGL routines 
 */
    glFlush ();
}

void init (void) 
{
/*  select clearing (background) color       */
    glClearColor (0.0, 0.0, 0.0, 0.0);

/*  initialize viewing values  */
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0.0, 4.0, 0.0, 4.0, -2.0, 4.0);
}

/* 
 *  Declare initial window size, position, and display mode
 *  (single buffer and RGBA).  Open window with "hello"
 *  in its title bar.  Call initialization routines.
 *  Register callback function to display graphics.
 *  Enter main loop and process events.
 */
int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize (250, 250); 
    glutInitWindowPosition (100, 100);
    glutCreateWindow ("hello");
    init ();
    glutDisplayFunc(display); 
    glutMainLoop();
    return 0;   /* ISO C requires main to return int. */
}

nota  

void glOrtho(GLdouble left,
             GLdouble right,
             GLdouble bottom,
             GLdouble top,
             GLdouble near,
             GLdouble far)

vertices 2 dimensiones:  V0- 0,0 v1=2,0 v2= 2,2 v3=0,2 v4= 3.73,3 v5=3.73,3 v6= 1.73,3 v7= 1.73,1
vertices 3 dimensiones: v0=0,0,0  v1=2,0,0 v2=2,2,0 v3=0,2,0 v4=2,0,-2 v5= 2,2,-2 v6=0,2,-2 v7=0,0,-2

Cubo 2 y tres dimensiones

calcule el conjunto de vertices para dibujarlo en dos y tres dimensiones

nota : para dibujar en dos dimensiones  encuentre los valores de los vertices usando trigonometria

 los  resultados deben estar publcados  en su blog el miércoles 28 de agosto

Triangulo de Sierpisnki

ejecutar el siguiente programa en opengl.
Nota : incluir la libreria de c  que contiene rand() para generar los numeros aleatorios
capture la pantalla de la ejecución del programa y  publique en su blog

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

OPENGL ( PRIMITIVAS)

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();

Opengl Guias de consulta

opengl   guía de  aprendizaje  http://glprogramming.com/red/   Inglés

Codigo opengl (cubo)

Ejecute el siguiente codigo:

trate de   identificar lo que hace cada pieza del programa

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

codigo #2

#include <GL/gl.h>
#include <GL/glut.h>

void display(void)
{
/*  clear all pixels  */
    glClear (GL_COLOR_BUFFER_BIT);

/*  draw white polygon (rectangle) with corners at
 *  (0.25, 0.25, 0.0) and (0.75, 0.75, 0.0)  
 */
    glColor3f (1.0, 1.0, 1.0);
    glBegin(GL_POLYGON);
        glVertex3f (0.25, 0.25, 0.0);
        glVertex3f (0.75, 0.25, 0.0);
        glVertex3f (0.75, 0.75, 0.0);
        glVertex3f (0.25, 0.75, 0.0);
    glEnd();

/*  don't wait!  
 *  start processing buffered OpenGL routines 
 */
    glFlush ();
}

void init (void) 
{
/*  select clearing (background) color       */
    glClearColor (0.0, 0.0, 0.0, 0.0);

/*  initialize viewing values  */
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
}

/* 
 *  Declare initial window size, position, and display mode
 *  (single buffer and RGBA).  Open window with "hello"
 *  in its title bar.  Call initialization routines.
 *  Register callback function to display graphics.
 *  Enter main loop and process events.
 */
int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize (250, 250); 
    glutInitWindowPosition (100, 100);
    glutCreateWindow ("hello");
    init ();
    glutDisplayFunc(display); 
    glutMainLoop();
    return 0;   /* ISO C requires main to return int. */
}

 

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/

Pasos para  usar Opengl
1. descargar Glut-3.7.6
2. Instalación:

Como instalar  GLUT & OpenGL in Visual C++ 6.0

OpenGL GLUT provee la interfase grafica y otras utilidades para ejecutar OpenGL en Windows. aquí están los pasos para instalar  in Visual C++ de Windows.

1. Descargar  "glut-3.7.6-bin.zip".
2. Descomprimir  "glut-3.7.6-bin.zip". This generates four files: "glut.h", "glut32.lib", "glut32.dll", and "readMe.txt". Note that you must choose the file view option to view all files (including system files). Otherwise "glut32.dll" will not show up.
3. Copiar los archivos del glut a los direcctorios :
   • copy "glut.h" to C:\..\..\VC98\include\GL (Visual C++ include directory) (For example: C:\Program Files\Microsoft Visual Studio\VC98\Include\GL)
   • copy "glut32.lib" to C:\..\..\VC98\lib (Visual C++ library directory)
   • copy "glut32.dll" to C:\WINDOWS\SYSTEM or C:\WINNT\SYSTEM32 (for NT), where your system files are located.

listo para  ejecutar codigos OpenGL en   Visual C++ Studio. 
 

prueba de ejecucion

:

1. Abra  un proyecto aplicación windows en Visual C++ 6.0, copie el codigo que se presente en la parte inferior y ejecute el programa .

#include <stdio.h>
#include <GL/glut.h>
void display(void)
{
        glClearColor(1.0, 1.0, 1.0, 0.0);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glColor3f(1.0,0.0,0.0);
        glutWireTorus(0.25,0.75, 28, 28);
        glColor3f(0.0,0.0,1.0) ;
        glutWireCube(.60) ;
        glutSwapBuffers();
}
int main(int argc, char** argv)
{
        glutInit(&argc, argv);
        glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
        glutInitWindowSize(512, 512);
        glutInitWindowPosition(20, 20);
        glutCreateWindow("Toroide");
        glutDisplayFunc(display);
        glutMainLoop();
        return 0;
}

si logra la imagen felicidades!
sino Intente de nuevo

1.3 Formatos gráficos de almacenamiento

Actividad martes 21 de agosto.

investigar y publicar los diferentes formatos de almacenamiento de imagen.

haga una tabla donde especifique las caracteristicas de los formatos( tipps de información que se almacena , espacio en memoria, etc).

inlcuya ejemplos de las imagenes.

1.2 Dispositivos de hardware y software para despliegue gráfico

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 jueves  16 de Agosto


Actividad  lunes 20 de agosto : 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 Martes 21 de agosto
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