jueves, 31 de mayo de 2012

Exámenes Regulas de Graficación!!!!

Baja el archivo y contesta correctamente.

https://docs.google.com/document/d/1toWYU08BhAaU_GrYxMbA1Aip2q3l4qBgNsh0ba3DA_0/edit

Datos unidad 3




Suerte!

miércoles, 23 de mayo de 2012

Manejo de archivos.


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO; //Libreria manejo de archivos


namespace Archivos
{
    class ManejoArchivos
    {
        public string nomArch;
        public StreamWriter writer;
        public StreamReader reader;


        public ManejoArchivos(string arch) {
            this.nomArch = arch;
            writer = new StreamWriter(this.nomArch);
        }


        public ManejoArchivos(string arch, bool l)
        { //siempre configurar por verdadero TRUE
            this.nomArch = arch;
            if (l) { 
                reader = new StreamReader(this.nomArch);
            }
        }


        //public ~ManejoArchivos() {
          //  writer.Close();
        //}


        


        public void Escribir(string cad) {
            writer.WriteLine(cad);
           
        }


        public void cerrarWriter() {
            writer.Close();
        }


        public void cerrarReader() {
            reader.Close();
        }


        public string Leer() {
            string caracter = reader.ReadLine();
            //reader.Close();
            return caracter;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Archivos
{
    class Program
    {
        static void Main(string[] args)
        {
            ManejoArchivos F1 = new ManejoArchivos(@"C:\F1.txt");
            F1.Escribir("HolaMundo1");
            F1.Escribir("HolaMundo2");
            F1.Escribir("HolaMundo3");
            F1.cerrarWriter();

            ManejoArchivos F2 = new ManejoArchivos(@"C:\F1.txt", true);

            Console.WriteLine(F2.Leer());
            F2.cerrarReader();
            Console.ReadKey();
        }
    }
}

martes, 22 de mayo de 2012

Código de Texturas.


#include "stdafx.h"
#include <GL\glut.h>
#include <stdio.h>


void Dibuja();
void Inicializa();
void CargaArchivos();




unsigned char TexYo[196608];//256*256*3 //El tres es por x-y-z


float ambiental[4]={0, 0, 0, 1},
 difusa[4]={1, 1, 1, 1},
 especular[4]={1, 1, 1, 1};




void main()
{
glutInitDisplayMode(GLUT_RGB|GLUT_DOUBLE|GLUT_DEPTH);
glutInitWindowSize(600,600);
glutInitWindowPosition(100,100);
    glutCreateWindow("Textura sencilla");
glutDisplayFunc(Dibuja);
Inicializa();
glutMainLoop();
}


//----------------inicializa------------------------------
void Inicializa()
{
glClearColor(0,0,0,0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(70,1,.1,1000);
glMatrixMode(GL_MODELVIEW);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_MODULATE);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
//glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);


CargaArchivos();
}


//-----------------dibuja----------------------------------------------
void Dibuja()
{
//int i,j;
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();


GLfloat ambientlight[4]  =    {0.5f ,0.5f ,0.5f ,1.0f};
float glfLightPosition[4] = {0.0, 2, 2.0, 1.0};
float glfLightDiffuse[4] = {0.7, 0.7, 0.7, 1.0};
float glfLightSpecular[4] = {0.7, 0.7, 0.7, 1.0};
//
//glLightfv(GL_LIGHT0,GL_AMBIENT,ambientlight);
glLightfv(GL_LIGHT0, GL_POSITION, glfLightPosition); // Se definen las
glLightfv(GL_LIGHT0, GL_DIFFUSE, glfLightDiffuse); //carácterísticas de la
glLightfv(GL_LIGHT0, GL_SPECULAR, glfLightSpecular);// luces
 glEnable(GL_LIGHT0);
 glEnable(GL_LIGHTING);


//---------------------------------------------------------------------------
 glPushMatrix();
glColor3d(1,1,1);
ambiental[0]=0;
ambiental[1]=1;
ambiental[2]=1;
ambiental[3] = 1;
especular[0]=0.8;
especular[1]=0.8;
especular[2]=0.8;
especular[3] = 1;
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, ambiental);
glMaterialfv(GL_FRONT, GL_SPECULAR, especular);
glMaterialf(GL_FRONT, GL_SHININESS, 30);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);

glTranslated(0,0,-5);
//------------------------------------------------------//
glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,256,256,0,GL_RGB,GL_UNSIGNED_BYTE,TexYo);
glEnable(GL_TEXTURE_2D);
glutSolidTeapot(1);
glPopMatrix();


//----------------------------------------------------------//
glPushMatrix();

glTranslated(0,-3,0);

glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,256,256,0,GL_RGB,GL_UNSIGNED_BYTE,TexYo);
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
glTexCoord2d(0,0);
glVertex3d(-1,-1,-7);
glTexCoord2d(0,1);
glVertex3d(-1,1,-7);
glTexCoord2d(1,1);
glVertex3d(1,1,-7);
glTexCoord2d(1,0);
glVertex3d(1,-1,-7);
glEnd();
glPopMatrix();
//--------------------------------------------------------------------------
glutSwapBuffers();
}






//----------carga archivos--------------------------------------------------------
void CargaArchivos(){
int i,j,alto,ancho;
FILE *arch;
unsigned char c;


//ABRE BMP
if((arch=fopen("rsYo.bmp","rb"))==NULL)
printf("Error abriendo el archivo");
else
{
alto=256;
ancho=256;
for(i=0;i<54;i++) //Los primeros 54 renglones del archivo BMP 
//contienen datos de cabecera entre los que se encuentran: 
//altura, anchura, etc.
fscanf(arch,"%c",&c); //recorremos las 53 posiciones del archivo.
for(i=0;i<alto;i++)
for(j=0;j<ancho;j++)
{
fscanf(arch,"%c",&c);
TexYo[ancho*3*i+3*j+2]=c; //256*3*0=0 //+ 3*0+2=2
   fscanf(arch,"%c",&c);
TexYo[ancho*3*i+3*j+1]=c; //256*3*0=0 //+3*0+1=1
fscanf(arch,"%c",&c);
TexYo[ancho*3*i+3*j]=c;//256*3*0=0//3*0=0

}
fclose(arch);
}
}

jueves, 10 de mayo de 2012

Código del Radix Sort.


using System;
using System.Collections.Generic;
namespace RadixSort
{
                class Radix
                {
                public void RadixSort(int[] a)
               
                   // Este es nuestro arreglo auxiliar.
                   int[] t=new int[a.Length];
                   
                   // Tamaño en bits de nuestro grupo.
                    // Intenta también 2, 8 o 16 para ver si es rápido o no.
                   int r=2; 
                   
                   // Número de bits de un entero en c#.
                   int b=32;
                   
                   // Inicia el conteo a asignación de los arreglos.
                    // Notar dimensiones 2^r el cual es el número de todos los valores posibles de un número r-bit.
                   int[] count=new int[1<<r];
                   int[] pref=new int[1<<r];
                   
                   // Número de grupos.
                   int groups=(int)Math.Ceiling((double)b/(double)r);
                   
                   // Máscara para identificar los grupos.
                   int mask = (1<<r)-1;
                   
                   // Implementación del algoritmo
                   for (int c=0, shift=0; c<groups; c++, shift+=r)
                    {
                       // Reiniciar el conteo en los arreglos.
                       for (int j=0; j<count.Length; j++)
                           count[j]=0;
               
                       // Contar elementos del c-vo grupo.
                       for (int i=0; i<a.Length; i++)
                           count[(a[i]>>shift)&mask]++;
               
                       // Calculando prefijos.
                       pref[0]=0;
                       for (int i=1; i<count.Length; i++)
                           pref[i]=pref[i-1]+count[i-1];
               
                       // De a[] a t[] elementos ordenados por c-vo grupo .
                       for (int i=0; i<a.Length; i++)
                           t[pref[(a[i]>>shift)&mask]++]=a[i];
               
                       // a[]=t[] e inicia otra vez hasta el último grupo.
                       t.CopyTo(a,0);
                      
                       Console.WriteLine("{0}",c);
                    }
                   // Está ordenado             
                }
                              
                               public static void Main(string[] args)

                               {
                                               int[] a = new int[7] {2,3,1,0,5,6,9};
                                              
                                               Console.WriteLine("Ordenamiento Radix");
                                              
                                               Radix O = new Radix();                                
                                               O.RadixSort(a);
                                              
                                               Console.ReadLine();
                               }
                }
}

Práctica de Interacción.


//Secccion de librerias
#include "stdafx.h"
#include <GL/glut.h>
#include <math.h>


//seccion de prototipos
void Inicializa();
void Dibuja();
void Teclado(unsigned char, int, int);
void Especial(int, int, int);
void Anima();
void Raton(int, int, int, int);
void Pasivo(int, int);
void Mueve(int, int);
void Tiempo(int);


//variables globales
float ambiental[4]={.6,.5,.3,0};
float difusa[4]={.3,.4,.7,0};
float especular[4]={1,1,1,0};
float posicion[4]={0,7,2,1};
float rx,ry,rz,sx=1,sy=1,sz=1,tx,ty,tz;


void main()
{
glutInitDisplayMode(GLUT_RGB|GLUT_DOUBLE|GLUT_DEPTH);
glutInitWindowSize(600, 600); 
glutInitWindowPosition(100,50); 
glutCreateWindow("Ejemplo Interactividad");
glutDisplayFunc(Dibuja);
Inicializa();
glutKeyboardFunc(Teclado);
glutSpecialFunc(Especial);
glutIdleFunc(Anima);
glutMouseFunc(Raton);
glutMotionFunc(Mueve);
glutPassiveMotionFunc(Pasivo);
glutTimerFunc(10,Tiempo,10);
glutMainLoop();
}


void Inicializa()
{
glClearColor(0.235235,0.235325,0.134,0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(90,1,0.1,50);
glMatrixMode(GL_MODELVIEW);
glEnable(GL_DEPTH_TEST);
glLightfv(GL_LIGHT0,GL_AMBIENT,ambiental);
glLightfv(GL_LIGHT0,GL_DIFFUSE,difusa);
glLightfv(GL_LIGHT0,GL_SPECULAR,especular);
glLightfv(GL_LIGHT0,GL_POSITION,posicion);
glLightf(GL_LIGHT0,GL_CONSTANT_ATTENUATION,1);
glLightf(GL_LIGHT0,GL_QUADRATIC_ATTENUATION,0.0001);
glLightf(GL_LIGHT0,GL_LINEAR_ATTENUATION,0.0001);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
}


void Dibuja()
{
GLUquadricObj *p;
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
p=gluNewQuadric();


gluQuadricDrawStyle(p,GLU_FILL);
gluQuadricNormals(p,GLU_SMOOTH);
gluQuadricOrientation(p,GLU_OUTSIDE);
glMaterialfv(GL_FRONT,GL_SPECULAR,especular);
ambiental[0]=0;ambiental[1]=1;ambiental[2]=0;
glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE, ambiental);
glMaterialf(GL_FRONT,GL_SHININESS,20);
glShadeModel(GL_SMOOTH);
glTranslated(-4,5,-15);
glRotated(rx,1,0,0);
glScaled(sx,sx,sx);
gluCylinder(p,1,1,4,20,20);
gluDeleteQuadric(p);


glLoadIdentity();
glMaterialfv(GL_FRONT,GL_SPECULAR,especular);
ambiental[0]=0;ambiental[1]=0;ambiental[2]=1;
glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE, ambiental);
glMaterialf(GL_FRONT,GL_SHININESS,20);
glShadeModel(GL_SMOOTH);
glTranslated(0,-5,-15);
glTranslated(tx,ty,tz);
glRotated(ry,0,1,0);
glScaled(sy,sy,sy);
glutSolidTeapot(2);


glLoadIdentity();
glMaterialfv(GL_FRONT,GL_SPECULAR,especular);
ambiental[0]=1;ambiental[1]=0;ambiental[2]=0;
glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE, ambiental);
glMaterialf(GL_FRONT,GL_SHININESS,20);
glShadeModel(GL_FLAT);
glTranslated(4,5,-15);
glRotated(rz,0,0,1);
glScaled(sz,sz,sz);
glutSolidTorus(1,2,10,10);


glutSwapBuffers();
}
void Anima()
{
rx+=.5;
glutPostRedisplay();
}


void Teclado(unsigned char t, int x, int y)
{
if(t=='c' || t=='C')
{
sx-=.1;
glutPostRedisplay();
}
if(t=='t' || t=='T')
{
sy-=.1;
glutPostRedisplay();
}
if(t=='o' || t=='O')
{
sz-=.1;
glutPostRedisplay();
}
}


void Especial(int t, int x, int y)
{
if(t==GLUT_KEY_RIGHT)
{
tx+=.2;
glutPostRedisplay();
}
if(t==GLUT_KEY_LEFT)
{
tx-=.2;
glutPostRedisplay();
}
if(t==GLUT_KEY_UP)
{
ty+=.2;
glutPostRedisplay();
}
if(t==GLUT_KEY_DOWN)
{
ty-=.2;
glutPostRedisplay();
}
if(t==GLUT_KEY_PAGE_DOWN)
{
tz-=.2;
glutPostRedisplay();
}
if(t==GLUT_KEY_PAGE_UP)
{
tz+=.2;
glutPostRedisplay();
}
}


void Raton(int t, int e, int x, int y)
{
if(t==GLUT_LEFT_BUTTON && e==GLUT_UP)
{
sx+=.1;
glutPostRedisplay();
}
if(t==GLUT_RIGHT_BUTTON && e==GLUT_UP)
{
sy+=.1;
glutPostRedisplay();
}
if(t==GLUT_MIDDLE_BUTTON && e==GLUT_UP)
{
sz+=.1;
glutPostRedisplay();
}
}


void Mueve(int x, int y)
{
rz-=1;
glutPostRedisplay();
}


void Pasivo(int x, int y)
{
rz+=1;
glutPostRedisplay();
}


void Tiempo(int p)
{
ry+=1;
glutPostRedisplay();
glutTimerFunc(p+1,Tiempo,p);
}

Examen TAP!!


1.- Desarrolle un programa en hilos, que ejecute dos métodos. Uno debe de calcular el perímetro de un círculo y el otro debe de calcular el perímetro de un triángulo.
2.- Desarrolle un programa en hilos, que ejecute dos métodos. Uno debe de mostrar la tabla de 7 y el otro debe de mostrar la secuencia de fibonacci.
3.- Desarrolle un programa en hilos, que ejecute dos métodos.Uno debe de calcular la fórmula de la aceleración y el otro, el tiro parabólico.