Clase Tec. Lerdo: mayo 2012

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.

lunes, 7 de mayo de 2012

Tutorial de Android

Un alumno del tec, me pasó este tutorial. Espero que lo aprovechen para su proyecto.

http://libreyextremo.blogspot.mx/2011/07/tutoriales-android.html

Clase Tec. Lerdo