PROGRAMACIN

BSICA
Reporte
Unidades 6, 7, 8
Flix
07/06/2013

Presentacin
REPORTE

PROGRAMACION BASICA
Unidad VI Y VII

MODULOS Y GRAFICACIN

Catedrtico:

LIC. Edgar Hernndez Garca

Alumno:

Flix Gonzlez Bonilla

INDICE

Introduccin a funciones

Aproximacin al nmero e

Circulo

24

Factorial de un nmero

Lneas

26

Suma de 2 vectores

Hexgono regular inscrito

28

Operaciones bsicas de matrices

11

Polgonos

29

Conclusin

17

Funcin seno y coseno

32

Introduccin a grficos

18

Tablero de ajedrez

34

Ventana

19

Conclusin

36

Primitivas 2D

20

Practica Puerto Paralelo

37

20

Conclusin

38

Lneas y puntos

Polgonos

21

INTRODUCCIN A FUNCIONES
En la unidad 6 llamada mdulos (funciones o procedimientos) se trabaj con funciones. Una
funcin es un bloque de instrucciones que se les asigna un nombre. Podra decirse que son
semejantes a programas que estandarizan tareas que son repetitivas, es un fragmento de cdigo
que realiza una tarea bien definida, de debe dejar en claro que las funciones solo son capaces de
devolver un solo dato despus de realizar su trabajo, la sintaxis para declarar un funcin es la
siguiente.
Tipo_DatoNomb_Func(Tipo_Dato Arg 1, Tipo_Dato Arg 2, Tipo_Dato Arg n);
{
Instruccin 1
Instruccin 2
Instruccin n
Return dato
};
Se debe dejar en claro que el argumento es necesario para realizar la funcin.
Existen diversos tipos de funciones, en este curso solo vimos una pequea introduccin a las
funciones tocando el tema de procedimientos. Los procedimiento son semejantes a las funciones,
pero a diferencia de las funciones, es que los procedimientos son capaces de devolvernos datos en
variables especficas, la sintaxis para declarar un procedimiento es la siguiente.
Void Nom_Proc(Tipo _Dato Arg 1, Tipo _Dato Arg 2, Tipo _Dato Arg n);
{
Instrucciones
};
A continuacin se presentan algunas prcticas y trabajos pasados realizados con funciones y
procedimientos.

Aproximacin al nmero e
Cdigo:
using namespace std;
double euler(int fac, int s);
int main(int argc, char *argv[])
{
int pot, sum;
double res;
cout<<"programa que calcula la serie de Maclaudi";
cout<<"\ningrese la potencia: ";
cin>>pot;
cout<<"\ningrese el numero de sumas ";
cin>>sum;
res=euler(pot, sum);
cout<<"\nresultado: "<<res<<endl;
system("PAUSE");
return EXIT_SUCCESS;
}
double euler(int fac, int s)
{
if(fac==0)
{
return 1;
}
else
{
double factorial=1, potencia, resultado;
double serie=1;
for(int i=1; i<=s; i++)
{
factorial=factorial*i;
potencia=pow(fac,i);
serie=serie+(potencia/factorial);
}
return serie;
}
}

Consola:

Como se puede observar en el programa en ejecucin el numero e elevado a la potencia 2, el

resultado exacto es 7.38905, sin embargo en el programa nos arroja 7.26667, que es un valor
aproximado a el valor real, como veremos si ocupamos el mismo exponente pero con un nmero
mayor de sumas realizadas en la serie, la sumatoria se aproxima ms al resultado real, como lo
podemos ver en la siguiente imagen.

En este caso 7.35556 se aproxima ms a 7.39905.

Factorial de un nmero
Cdigo:
using namespace std;
int factorialx(int n);
int main(int argc, char *argv[])
{
cout<<"programa que calcula el fectorial de un numero mediante una funcion";
int x, xfactor;
cout<<"\n\nIntrodusca el dato para el factorial: ";
cin>>x;
xfactor=factorialx(x);
cout<<"\n\n"<<x<<"!="<<xfactor<<endl;
system("PAUSE");
return EXIT_SUCCESS;
}
int factorialx(int n)
{
if(n==0 || n==1)
{
return 1;
}
else
{
int fac=1;
for(int i=1; i<=n; i++)
{
fac*=i;
}
return fac;
}
}

Consola:

Suma de 2 vectores
Cdigo:
#include <cstdlib>
#include <iostream>
using namespace std;
void lee_vec(int orden, int vecA[]); //se declara el procedimiento
void Suma_Vec(int i, int vec1[], int vec2[], int re[]);
int main(int argc, char *argv[])
{
cout<<"\n\n\t\t\tPrograma que calcula la suma de 2 vectores";
cout<<"\n\nLos vecteres deven tener las mismas dimenciones";
int t;
cout<<"\nIntroduzca el orden (tamao) de los vectores: ";
cin>>t;
int A[t], B[t], R[t]; //se declaran los arreglos despues de tener su valor
cout<<"\nIntrodusca los datos del vector A: "<<endl;
lee_vec(t,A);
cout<<"\nIntrodusca los datos del vector B: "<<endl;
lee_vec(t,B);
cout<<"\n\n\t\tEl resultado de la suma es: "<<endl;
Suma_Vec(t, A, B, R);
cout<<endl;
system("PAUSE");
return EXIT_SUCCESS;
}
void lee_vec(int orden, int vec[])
{
for(int i=0; i<orden; i++)
{
cout<<" Posicion ["<<i+1<<"]= ";
cin>>vec[i];
};
for(int i=0; i<orden; i++)
{
cout<<vec[i]<<"\t";
}
}

void Suma_Vec(int i, int vec1[], int vec2[], int re[])

{
for(int j=0; j<i; j++)
{
re[i]=vec1[j]+vec2[j];
cout<<"\t"<<re[i];
}
cout<<endl;

Consola:

Operaciones bsicas de matrices

Cdigo:
using namespace std;
void guarda(int fil, int col, int matriz[100][100]);
void muestra(int fil, int col, int matriz[100][100]);
void suma(int f, int c, int ff, int cc, int MA[100][100], int MB[100][100], int MR[100][100]);
void resta(int f, int c, int ff, int cc, int MA[100][100], int MB[100][100], int MR[100][100]);
void producto(int f, int c, int ff, int cc, int MA[100][100], int MB[100][100], int MR[100][100]);
int main(int argc, char *argv[])
{
int f, c, ff, cc;
cout<<"\n\n\t\tPrograma que realiza operaciones basicas de matrices";
cout<<"Nombrando A y B a las matrices realize lo siguiente "<<endl;
cout<<"\nFilas de A: ";
cin>>f;
cout<<"columnas de A: ";
cin>>c;
cout<<"\nFilas de B: ";
cin>>ff;
cout<<"columnas de B: ";
cin>>cc;
int A[100][100], B[100][100], R[100][100];
cout<<"\n\tIngrese los datos de A: "<<endl;
guarda(f, c, A);
cout<<"\n\tLa matriz A es: "<<endl;
muestra(f, c, A);
cout<<"\n\tIngrese los datos de B: "<<endl;
guarda(ff, cc, B);
cout<<"\n\tLa matriz B es: "<<endl;
muestra(ff, cc, B);
char opcion;
do
{
cout<<"\n\n\t\tAhora elija una opcion"<<endl;
cout<<"A) Suma A + B"<<endl;
cout<<"B) Resta A - B"<<endl;
cout<<"C) Resta B - A"<<endl;
cout<<"D) Producto A * B"<<endl;
cout<<"E) Producto B * A"<<endl;
cout<<"X) Para salir "<<endl;
cin>>opcion;
switch(opcion)
{

case 'A':
cout<<"\n\n\tLa suma A + B es: "<<endl;
suma(f, c, ff, cc, A, B, R);
break;
case 'B':
cout<<"\n\n\tLa resta A - B es: "<<endl;
resta(f, c, ff, cc, A, B, R);
break;
case 'C':
cout<<"\n\n\tLa resta B - A es: "<<endl;
resta(ff, cc, f, c, B, A, R);
break;
case 'D':
cout<<"\n\n\tEl producto A * B es:"<<endl;
producto(f, c, ff, cc, A, B, R);
break;
case 'E':
cout<<"\n\n\tEl producto B * A es: "<<endl;
producto(ff, cc, f, c, B, A,R);
break;
default:
cout<<"\n\n\t\tOpcion no valida intente de nuevo"<<endl;
}
}
while(opcion!='X');
cout<<"\t\t\t\tFIN DEL CILCLO GRACIAS"<<endl;
system("PAUSE");
return EXIT_SUCCESS;
}
void guarda(int fil, int col, int matriz[100][100])
{
for(int i=0; i<fil; i++)
{
for(int j=0; j<col; j++)
{
cout<<"El dato ["<<i+1<<","<<j+1<<"] es: ";
cin>>matriz[i][j];
}
}
}
void muestra(int fil, int col, int matriz[100][100])
{
for(int i=0; i<fil; i++)
{
cout<<"\n";
for(int j=0; j<col; j++)
{
cout<<"\t"<<matriz[i][j]<<"\t";

10

}
}
}
void suma(int f, int c, int ff, int cc, int MA[100][100], int MB[100][100], int MR[100][100])
{
if(f==ff && c==cc)
{
for(int i=0; i<f; i++)
{
cout<<"\n";
for(int j=0; j<c; j++)
{
MR[i][j]=MA[i][j]+MB[i][j];
}
}
muestra(f, c, MR);
}
else
cout<<"\n\tLo siento operacion no valida"<<endl;
}
void resta(int f, int c, int ff, int cc, int MA[100][100], int MB[100][100], int MR[100][100])
{
if(f==ff && c==cc)
{
for(int i=0; i<f; i++)
{
cout<<"\n";
for(int j=0; j<c; j++)
{
MR[i][j]=MA[i][j]-MB[i][j];
}
}
muestra(f, c, MR);
}
else
cout<<"\n\tLo siento operacion no valida"<<endl;
}
void producto(int f, int c, int ff, int cc, int MA[100][100], int MB[100][100], int MR[100][100])
{
if(c==ff)
{
int k;
for(int i=0; i<f; i++)
{
for(int j=0; j<cc; j++)
{
MR[i][j]=0;

11

for(k=0; k<c; k++)

{
MR[i][j]=MR[i][j]+(MA[i][k]*MB[k][j]);
}
}
}
muestra(f, cc, MR);
}
else
cout<<"\n\n\t\tLo siento operacion no valida";
}
Consola

12

13

14

Conclusin
Las funciones y/o procedimientos son como programas pequeos que solo realizan una
determinada accin y pueden ser llamados por el programa principal en ms de una ocasin, son
de gran utilidad al momento de realizar programas extensos, las funciones nos facilitan procesos
dentro del programa principal, solo basta indicar su nombre dentro del programa principal e
indicar los argumentos con los que va a trabajar, y la funcin realiza su trabajo.
Algunos nos parecen que son difciles de entender para trabajar con ellos, pero lo que es un poco
complejo es tener bien definidos los argumentos de la operacin que se desea realizar. Es
importante mencionar una experiencia que tuve la primera vez que programe operaciones bsicas
con matrices sin ayuda de funciones, me resulto un cdigo demasiado grande, cuando lo volv a
realizar este mismo programa, pero esta vez utilizando procedimientos, pude notar que mi cdigo
principal se redujo demasiado, esto es de mucha ayuda porque ayuda a entender mejor el cdigo
y se reduce el espacio de memoria que se ocupa.
Se observ que pueden existir funciones dentro de otras, las llamadas funciones anidadas. Esto lo
aplique al escribir el cdigo que realiza operaciones bsicas de matrices, en este programa declare
un procedimiento que mostrara en pantalla las matrices ingresadas por el usuario, este mismo
procedimiento muestra las matrices que resultan de las operaciones, este procedimiento est
dentro de cada procedimiento que realiza una operacin.
Eleg escribir el cdigo de esta forma porque al llamar el procedimiento dentro de main no existen
los argumentos para el resultado que tiene la matriz que resulta.

15

Introduccin a grficos
Introduccin
Es importante saber cmo elaborar las instrucciones para que el monitor nos muestre una
ventana, para ello se requiere de modos para un ambiente grfico, y ciertas caractersticas como
son resolucin, color, modo grafico etc. Los elementos de un ambiente grafico son:
Hardware
*Adaptador grafico
*Monitor
*Dispositivo de entrada y salida
Software
*GUI Graphical User Interface
*API Aplication Programming Interface
*Aplicaciones
Al momento de programar grficos en c++, se usara la librera <GL/glut.h> , para poder graficar,
dentro de la funcin principal primero se deben segur los siguientes pasos:
1) Iniciar la librera glut.
2) Iniciar el modo de despliegue
3) Iniciar el tamao indicado en pixeles
4) Indicar la posicin de la pantalla recordando que va hacer acomodada desde la esquina
superior izquierda a la distancia medida en pixeles
5) Asignar un nombre a la ventana, crear la ventana
6) Indicar la funcin de desplegado y llamar a la funcin encargada de dibujar
7) Indicar la instruccin que le indica al display que vuelva a redibujar el miso dibujo
En resumen estos son los pasos dentro del Main para dibujar.
El siguiente cdigo es un ejemplo de cmo crear una ventana

16

Ventana.
Cdigo
using namespace std;
void dibuja(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glFlush();
}
int main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
glutInitWindowSize(640,380);
glutInitWindowPosition(100,100);
glutCreateWindow("ventana");
glutDisplayFunc(dibuja);
glutMainLoop();
return 0;
}
Consola

17

Primitivas 2D
Existen otras instrucciones importantes que definen diferentes cosas y son necesarias y de gran
utilidad para poder darle otras caractersticas a nuestro programa, algunas son:
glClearColor(R,G,B,A); Esta instruccin establece el color con el que ser limpiada la pantalla.
glMatrixMode(GLenum Mode); Instruccin que establece como se van a proyectar las cosas en
un pixel, nosotros usaremos el modo (GL_PROJECTION)
glLoadIdentity(); Instruccin que carga una matriz identidad dentro de la matriz de pixeles, en
pocas palabras limpia el buffer,
gluOrtho2D(Izquierda,Derecha, Abajo,Arriba); Instruccin que selecciona una proporcin de la
ventana, esta proporcin es la que se muestra en la ventana.
Lneas y Puntos
Llamamos primitivas 2D a las instrucciones de callbacks que permiten trazar sobre nuestra
pantalla o consola.
Para poder trazar puntos se utiliza callbacks GL_POINTS.
Para iniciar se indica:
glBegin(GL_primitiva);
vrtice 1
vrtice 2
glEnd(); //para terminar.
Los vrtices se denominan atravez del comando glVertex que tiene diversas variantes
glVertex2iv();
Donde:
gl -Indica la librera
Vertex-Es el comando
2 -Es el numero de argumentos (2= 2D, 3= 3D RGV, 4=coordenadas, Homogneas/RGBA)
I Es el tipo de dato.
V Formato escalar o vectorial (solo se pone cuando se utilizan vectores)
glPointSize(GL Float Tamao); Indica el tamao del punto.
glLineWidth(GL Float Ancho); Indica el ancho de la lnea.
glColor#t&(); Indica el color de la lnea o punto.
# -Numero de argumentos.
t Tipo de dato
& -Indica si es un vector o un escalar.
Para poder trazar lneas dentro de nuestro lienzo (ventana) se utilizan otra serie de instrucciones
dependiendo del tipo de lnea que se quiera trazar, estas son:
GL_LIENES Traza una recta individual con vrtice de inicio y fin.
GL_LINE_STRIP Traza varias rectas, todas conectadas, una detrs de otra.
GL_LINE_LOOP Traza varias lneas rectas, considerando que el conjunto forma un objeto cerrado (
Tenerse en mente la cantidad de vrtices).

18

Polgonos

Tambin existen instrucciones que nos facilitan la creacin de figuras geomtricas estas se llaman:
GL_TRIANGLES Traza superficies triangulares con tres coordenadas desiguales.
GL_TRIANGLE_STRIP Genera superficies triangulares, en funcin de las coordenadas, por ejemplo
si se indican cuatro coordenadas se generan 2 tringulos.
GL_TRIANGLE_FAN Genera polgonos mediante tringulos empatados pero compartiendo el
mismo puto inicial
GL_QUADS Genera superficies rectangulares en funcin de cuatro coordenadas.
GL_QUADS_STRIP Genera rectngulos conectados, los primeros cuatro vrtices generan un
rectngulo, luego cada par de vrtices aumentan otro rectngulo.
GL_POYGON Genera superficies poligonales en funcin de la cantidad de coordenadas indicadas
glRectf{i}(X1,Y1,X2,Y2) Esta instruccin facilita el trazado de del rectngulo
Tambin es importante la declaracin de variables de tipo booleano, (lgico, faso) se declaran:
GLBoolean variable= Condicion_Logica_Inicial
La condicin lgica es:
GL_True
Gl_False

A continuacin se muestran ejemplos de cmo utilizar estas instrucciones.

19

Puntos
Cdigo
void inicia(void)
{
glClearColor(0.0,0.0,1.0,0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,500.0,0.0,500.0);
}
void dibuja(void)
{
int vector[]={150,150};
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0,0.0,0.0);
glPointSize(5);
glBegin(GL_POINTS);
glVertex2iv(vector);
glVertex2i(375,375);
for(int i=0; i<=500; i+=20)
{
glVertex2i(i,250);
}
for(int j=0; j<=500; j+=20)
{
glVertex2i(250,j);
}
glEnd();
glFlush();
}
int main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
glutInitWindowSize(500,500);
glutInitWindowPosition(100,100);
glutCreateWindow("puntos");
inicia();
glutDisplayFunc(dibuja);
glutMainLoop();
return 0;
}

20

Consola

21

Crculo
Codigo
void inicia(void)
{
glClearColor(0.0,0.0,0.0,0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,500.0,0.0,500.0);
}
void circunferencia(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0,1.0,1.0);
glPointSize(1);
glBegin(GL_POINTS);
glVertex2i(250,250); //centro del circulo
for(float x=50.0; x<=450.0; x+=0.002)
{
glVertex2f(x,sqrt(-1*pow(x,2)+500*x-22500)+250);
}
for(float y=50.0; y<=450.0; y+=0.002)
{
glVertex2f(y,-1*sqrt(-1*pow(y,2)+500*y-22500)+250);
}
glEnd();
glFlush();
}
int main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
glutInitWindowSize(500,500);
glutInitWindowPosition(100,100);
glutCreateWindow("CIRCUNFERENCIA");
inicia();
glutDisplayFunc(circunferencia);
glutMainLoop();
return 0;
}

22

Consola

23

Lneas
Cdigo
void inicia(void)
{
glClearColor(0.5,0.5,0.5,1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,500.0,0.0,500.0);
}
void dibuja_linea(void)
{
int vec[2][2]={{150,150},{350,350}};
float vecc[]={0.0,1.0,0.0};
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0,0.0,0.0);
glLineWidth(1.0);
glBegin(GL_LINES);
glVertex2i(150,350);
glVertex2i(350,150);
for(int i=0; i<2; i++)
{
glVertex2iv(vec[i]);
}
glEnd();
glColor3f(1.0,0.0,0.0);
glLineWidth(4.0);
glBegin(GL_LINE_STRIP);
for(int i=0; i<=10; i++)
{
glVertex2i(i*50,75+25*pow(-1,i));
}
glEnd();
glColor3fv(vecc);
glLineWidth(4.0);
glBegin(GL_LINE_LOOP);
glVertex2i(150,370);
glVertex2i(350,370);
glVertex2i(350,445);
glVertex2i(250,500);
glVertex2i(150,445);
glEnd();
glFlush();
}
int main(int argc, char *argv[])
{
glutInit(&argc, argv);

24

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
glutInitWindowSize(500,500);
glutInitWindowPosition(250,200);
glutCreateWindow("LINEAS");
inicia();
glutDisplayFunc(dibuja_linea);
glutMainLoop();
return 0;
}
Consola

25

Hexgono regular inscrito

Cdigo:
void inicia(void)
{
glClearColor(0.0,0.0,0.0,0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,500.0,0.0,500.0);
}
void circunferencia(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0,1.0,1.0);
glPointSize(2);
glBegin(GL_POINTS);
glVertex2i(250,250); //centro del circulo
for(float x=50.0; x<=450.0; x+=0.002)
{
glVertex2f(x,sqrt(-1*pow(x,2)+500*x-22500)+250);
glVertex2f(x,-1*sqrt(-1*pow(x,2)+500*x-22500)+250);
}
glEnd();
int hexa[6][2]={{50,250},{150,80},{350,80},{450,250},{350,420},{150,420}};
glColor3f(0.5,1.0,0.5);
glBegin(GL_POLYGON);
for(int i=0; i<6; i++)
{
glVertex2iv(hexa[i]);
}
glEnd();
glFlush();
}
int main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
glutInitWindowSize(500,500);
glutInitWindowPosition(100,100);
glutCreateWindow("CIRCUNFERENCIA");
inicia();
glutDisplayFunc(circunferencia);
glutMainLoop();
return 0;
}

26

Consola

27

Polgonos
Cdigo
void inicia(void)
{
glClearColor(0.0,0.0,0.0,0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,500.0,0.0,500.0);
}
void poligono(void)
{
int tri[3][2]={{100,50},{400,50},{250,150}};
int exa[6][2]={{100,250},{250,165},{400,250},{400,400},{250,485},{100,400}};
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(1.0,1.0,1.0);
glLineWidth(3);
glBegin(GL_TRIANGLES);
for(int i=0; i<=3; i++)
{
glVertex2iv(tri[i]);
}
glEnd();
glBegin(GL_POLYGON);
for(int i=0; i<6; i++)
{
glVertex2iv(exa[i]);
}
glEnd();
glFlush();

}
int main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
glutInitWindowSize(500,500);
glutInitWindowPosition(300,100);
glutCreateWindow("POLIGONOS");
inicia();
glutDisplayFunc(poligono);
glutMainLoop();
return 0;
}

28

Consola

29

Funcin Seno y Coseno

Cdigo
void inicia(void)
{
glClearColor(0.0,0.0,0.0,0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,12.56,-2.0,2.0);
}
void funcion(void)
{
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0,0.0,1.0);
glPointSize(1);
glBegin(GL_POINTS);
glVertex2f(250.0,250.0);
for(double i=0; i<640; i+=.001)
{
glVertex2f(i,sin(i));
}
glEnd();
glColor3f(0.0,1.0,0.0);
glPointSize(1);
glBegin(GL_POINTS);
glVertex2f(250.0,250.0);
for(double i=0; i<640; i+=.001)
{
glVertex2f(i,cos(i));
}
glEnd();
glColor3f(1.0,0.,0.0);
glLineWidth(2);
glBegin(GL_LINES);
glVertex2i(0,0);
glVertex2i(640,0);
glEnd();
glFlush();
}
int main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
glutInitWindowSize(640,480);

30

glutInitWindowPosition(300,200);
glutCreateWindow("FUNCION SENO Y COSENO");
inicia();
glutDisplayFunc(funcion);
glutMainLoop();
return 0;
}
Consola

31

Tablero de ajedrez
Cdigo
void inicia(void)
{
glClearColor(0.0,0.0,1.0,0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,400.0,0.0,400.0);
}
void domino(void)
{
float blanco[]={1.0,1.0,1.0};
float negro[]={0.0,0.0,0.0};
GLboolean color_blanco=GL_TRUE;
int i;
glClear(GL_COLOR_BUFFER_BIT);
for(i=0; i<400; i+=50)
{
if(color_blanco)
{
glColor3fv(blanco);
}
else
{
// glColor3fv(negro);
}
glRecti(i,0,i+50,50);
color_blanco=!color_blanco;
for(int y=0; y<400; y+=50)
{
if(color_blanco)
{
glColor3fv(blanco);
}
else
{
glColor3fv(negro);
}
glRecti(i,y,i+50,y+50);
color_blanco=!color_blanco;
}
}
glFlush();
}
int main(int argc, char *argv[])

32

{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
glutInitWindowSize(400,400);
glutInitWindowPosition(200,200);
glutCreateWindow("AJEDREZ");
inicia();
glutDisplayFunc(domino);
glutMainLoop();
return 0;
}
Consola

33

Conclusin
Esta unidad me pareci muy interesante al darme cuenta como es el funcionamiento de colores en
un aparato electrnico como es la televisin y la computadora entre otros. La forma en que
nosotros podemos apreciar una pantalla es muy importante ya que nos muy fcil hacer que una
pantalla muestre colores definidos creando una imagen como en el caso del programa que dibuja
un circulo, y el que grafica la funcin seno y coseno.
Lo que realmente me parece importante es el saber que al programar un grfico en una ventana,
nosotros no dibujamos directamente sobre la pantalla, nosotros creamos las instrucciones, y las
recibe el buffer, l es el encargado de dibujar en la pantalla.
Me pareci muy importante, e interesante la creacin de grficos mediante la programacin, le da
un aspecto esttico a los programas.

34

Practica:

En esta prctica se realiz la representacin de un registro de memoria (un byte). En la prctica se

simulo al Byte con 8 leds, cada led represento a un bit, en las siguientes imgenes se muestra el
formulario con sus componentes y algunas pruebas de cada botn y direcciones de nmeros.

Formulario

Leds apagados (Byte)

35

Formulario en ejecucin

Conclusin
Los Puertos son muy importantes en el manejo de datos, como sabemos existen 2 tipos de
puertos el puerto paralelo y el puerto serial, en esta prctica utilizamos el puerto paralelo, en la
actualidad el solo se usa el puerto serial ya que es el ms eficaz que el puerto paralelo, aunque el
puerto paralelo es ms rpido para enviar datos requiere de ms energa, es por eso que el puerto
serial es el ms utilizado. En esta prctica observamos esto al armar el protoboard, se necesit de
ocho hilos de cable para dar corriente a lo que represento un Byte, si necesitramos una cantidad
ms alta de bytes sera necesario utilizar ms hilos de cable.