5.3 ANIMACIÓN POR COMPUTADORA.

La animación es la simulación de un movimiento, creada por la muestra de una serie de imágenes o cuadros. Un ejemplo sencillo de esto son las caricaturas, que pertenecen a la animación tradicional. Hace algunos años se debía de dibujar cada cuadro y se unían para formar una imagen animada. Ahora, el uso de la computadora permite crear escenas mucho más reales.

La animación por computadora se puede definir como un formato de presentación de información digital en movimiento a través de una secuencia de imágenes o cuadros creadas o generadas por la computadora se utiliza principalmente en videojuegos y películas.


Características de la Animación 3D.


La animación por computadora permite crear escenar “realmente” tridimensionales, en una escena animada por computadora es posible cambiar el ángulo de la cámara y ver otra parte de la escena. Se pueden reutilizar partes de la animación por separado.

Una animación se ve más realista si variamos el peso y el tamaño de los objetos. Para cambiar el peso es necesario cambiar el tiempo que tarda en moverse. Mientras más pesado su masa es mayor y es necesario aplicar mayor fuerza para moverlo.

Es necesario pensar en la forma como se moverán los objetos. Cada movimiento se realiza por una razón. Es necesario conocer las formas en que actúan los cuerpos.

En la animación en tres dimensiones debe considerarse la forma en que se detiene los cuerpos. Al animar a un personaje es conveniente que si se va a detener, alguna parte de su cuerpo se siga moviendo ligeramente, como la cabeza o un brazo.

Hay tres fases que componen una acción: La anticipación de la acción, la acción en sí y la reacción a la acción.


Técnicas de animación.


· Animación en acetatos. Los acetatos de animación se colocan en capas, una encima de la otra, para producir un solo cuadro de animación. Se utiliza un acetato separado para la capa del fondo y otro para cada objeto que se mueve independientemente sobre el fondo.

· Animación basada en cuadros. Es el tipo más simple de animación. Quizá de niños tuvieron uno de esos libros que contenían una serie de dibujos al hojear rápidamente el libro, los dibujos de las páginas sucesivas aparentaban movimiento.

· Animación en Sprite. Esta animación es también llamada animación basada en repartos cada un sprite puede ser un objeto, es sobrepuesto y animado sobre un fondo estático. Esta animación es muy común en videojuegos.

· Key Framming: Se refiere a establecer posiciones en puntos específicos de tiempo en una animación y la parte intermedia la obtiene la computadora por medio de interpolación matemática.

· Rotoscopiado: Se obtienen la posición y el ángulo de los puntos clave de imágenes reales y se trata de hacer converger los modelos en computadora con ellos.

· Motion Control: Consiste en obtener posiciones clave de manera automática a partir de un actor real por medio de dispositivos que se conectan a su cuerpo.

· Wavelets: Significa “pequeñas ondulaciones”. Esta técnica permite que en una sola imagen se compriman una gran cantidad de datos para que al acercarse a ella, se vayan viendo los detalles.

· Técnicas de Pixar: El proceso que utiliza Pixar [12] para crear sus animaciones se compone de cuatro etapas principales: Desarrollo (crear el guion de la historia), preproducción (se direccionan los retos técnicos), producción (creación de la película) y post producción (pulir los últimos detalles).

 
Bibliografía:

http://graficacionporcomputadora.blogspot.mx/2013/05/53-animacion-por-computadora_8.html

http://graficacion-suirot18.blogspot.mx/2013/11/53-animacion-por-computadora.html http://lermalerma.blogspot.mx/2012/11/unidad-v-5.html

5.2 VISIÓN POR COMPUTADORA.

La visión por computadora es una rama de la inteligencia artificial que tiene por objetivo modelar matemáticamente los procesos de percepción visual en los seres vivos y generar programas que permitan simular estas capacidades visuales por computadora.

El proceso de visión por computadora puede subdividirse en sus áreas principales:

-Sensado. Es el proceso que nos lleva a la obtención de una imagen visual
- Preprocesamiento. Trata de las técnicas de reducción de ruido y enriquecimiento de detalles en la imagen
- Segmentación. Es el proceso que particiona una imagen en objetos de interés
- Descripción. Trata con el cómputo de características útiles para diferenciar un tipo de objeto de otro.
- Reconocimiento. Es el proceso que identifica esos objetos
- Interpretación. Asigna un significado a un conjunto de objetos reconocidos.

Esquema general del procesamiento de imágenes.





Esquema general de visión por computadora.





Ejemplo de procesamiento de imágenes. La tarea a realizar es mejorar la imagen de entrada, la cual es obscura. La imagen de salida es esencialmente la misma pero de mejor calidad o “más útil"




Se ilustra la diferencia entre procesamiento de imágenes y visión; la imagen muestra ciertas descripciones importantes, como los números, que previamente fueron detectados. La salida de este sistema de visión se complementa con un módulo de reconocimiento de patrones, es decir, “saber" qué letras y números contiene la placa.




Actualmente existen múltiples aplicaciones prácticas de la visión computacional, entre estas podemos mencionar las siguientes:

· Robótica móvil y vehículos autónomos.
· Manufactura.
· Interpretación de imágenes aéreas y de satélite.
· Análisis e interpretación de imágenes médicas.
· Análisis de imágenes para astrónoma.


Dispositivos para Visión.

Existen diferentes dispositivos para la captura de imágenes. Dichas imágenes son digitalizadas y almacenadas en la memoria de la computadora. Una vez en la computadora, o en ocasiones desde el mismo dispositivo de captura, la imagen puede ser ya procesada.

Para la adquisición de la imagen se requiere de un dispositivo físico que sea sensible a una determinada banda del espectro electromagnético. El dispositivo produce una señal eléctrica proporcional al nivel de energía detectado, la cual es posteriormente digitalizada. Entre los dispositivos de captura o sensores se encuentran:


· Cámaras fotográficas.
· Cámaras de televisión (vidicón o de estado solido - CCD).
· Digitalizadores (scanners).
· Sensores de rango (franjas de luz, laser).
· Sensores de ultrasonido (sonares).
· Rayos X.
· Imágenes de tomografía.
· Imágenes de resonancia magnética.


Bibliografía.

http://graficacionporcomputadora.blogspot.mx/2013/05/52-vision-por-computadora.html
http://lermalerma.blogspot.mx/2012/11/unidad-v-5.html

5.1 PROCESAMIENTO DE IMÁGENES.

Tiene como objetivo mejorar el aspecto de las imágenes y hacer más evidentes en ellas ciertos detalles que se desean hacer notar. La imagen puede haber sido generada de muchas maneras como fotográficamente o electrónicamente por medio de televisión. El procesamiento de las imágenes se puede hacer por medio de métodos ópticos, o bien por medio de métodos digitales, en una computadora.

Procesamiento óptico.

Los principios del procesamiento óptico de imágenes están bien establecidos desde el siglo pasado, cuando se desarrolló la teoría de la difracción de la luz. Sin embargo, su aplicación práctica data apenas del principio de la década de los sesenta, cuando se comenzó a disponer del rayo láser.

El procesamiento óptico se basa en el hecho de que la imagen de difracción de Fraunhofer de una transparencia colocada en el plano focal frontal de una lente es una distribución luminosa que representa la distribución de las frecuencias de Fourier que componen la imagen, a la que se le llama técnicamente transformada de Fourier.

Consideremos el arreglo óptico de la figura 42. En el plano focal frontal de la lente L1 se ha colocado la transparencia T, la cual está siendo iluminada por un haz de rayos paralelos provenientes de un láser de gas. Sobre el plano focal F1 de la lente L1 se forma una distribución luminosa que representa la transformada de Fourier de la transparencia. Si ahora se coloca otra lente L2 como se muestra en la misma figura, se puede formar una imagen de la transparencia en el plano focal F2 de esta lente. Si ahora se coloca cualquier objeto o diafragma sobre el plano F1, se pueden eliminar las porciones que se deseen de la transformada de Fourier de la transparencia, eliminando así de la imagen las frecuencias de Fourier deseadas.

Cada porción de la transformada de Fourier corresponde a una frecuencia espacial diferente sobre el objeto. Por lo tanto, mediante los diafragmas adecuados se pueden eliminar las frecuencias espaciales, llamadas también de Fourier, que se deseen quitar.


Procesamiento digital.




Al igual que en el caso del procesamiento óptico, los principios fundamentales del procesamiento digital de imágenes están establecidos hace muchos años, pero no se llevaban a cabo debido a la falta de computadoras. Con la aparición de las computadoras de alta capacidad y memoria, era natural que se comenzara a desarrollar este campo. Uno de los primeros lugares donde se empezó a realizar el procesamiento digital fue en el Jet Propulsion Laboratory, en 1959, con el propósito de mejorar las imágenes enviadas por los cohetes. Los resultados obtenidos en un tiempo relativamente corto fueron tan impresionantes que muy pronto se extendieron las aplicaciones del método a otros campos.




División de una imagen en pixeles.


El procesamiento digital de imágenes se efectúa dividiendo la imagen en un arreglo rectangular de elementos, como se muestra en la figura 43. Cada elemento de la imagen así dividida se conoce con el nombre de pixel. El siguiente paso es asignar un valor numérico a la luminosidad promedio de cada pixel. Así, los valores de la luminosidad de cada pixel, con sus coordenadas que indican su posición, definen completamente la imagen.

Todos estos números se almacenan en la memoria de una computadora.

El tercer paso es alterar los valores de la luminosidad de los pixeles mediante las operaciones o transformaciones matemáticas necesarias, a fin de hacer que resalten los detalles de la imagen que sean convenientes. El paso final es pasar la representación de estos pixeles a un monitor de televisión de alta definición, con el fin de mostrar la imagen procesada.

Bibliografía:

http://bibliotecadigital.ilce.edu.mx/sites/ciencia/volumen2/ciencia3/084/htm/sec_9.htmhttp://lermalerma.blogspot.mx/2012/11/unidad-v-5.html



ACCIÓN DE GRACIAS.

Por qué se celebra:
En 1620 los peregrinos viajaron desde Inglaterra a las Américas en el barco Mayflower y desembarcaron en Plymouth. Escapaban de las constricciones de la iglesia de Inglaterra y también de la pobreza. Podrían considerarse los primeros inmigrantes de Norteamérica.

Los indios nativos de Massachusetts los recibieron amistosamente y compartieron con los peregrinos sus conocimientos sobre las cosechas en esta tierra y les enseñaron a cazar y a curar la carne de los animales de la zona.

Para celebrar que habían logrado sobrevivir un invierno muy duro y que tenían una abundante cosecha que les ayudaría a enfrentar el siguiente, los peregrinos organizaron una gran cena . Invitaron a los indios nativos para agradecer su ayuda. La primera celebración de acción de gracias duró varios días. Tanto los indios como los peregrinos compartieron alimentos, bebidas y diversión

Hoy día es una jornada de agradecimiento por las cosechas y por todo lo que uno tiene en la vida.

Cuándo se celebra:

El primer presidente de los EE.UU, George Washington declaró el primer día de acción de gracias el 19 de febrero de 1795. Más tarde, Abraham Lincoln escogió el 3 de octubre de 1863 como día de reflexión y agradecimiento.

El presidente Theodore Roosevelt cambió en 1941 el día de acción de gracias al cuarto jueves el mes de noviembre, que sigue siendo el día en que se celebra esta festividad.

Cómo se celebra Thanksgiving en Estados Unidos:

Es una celebración familiar en que las personas incluso viajan a otro estado para reunirse con su familia. Dado que en Estados Unidos son más independientes unos de otros que en las familias latinas, realizan el esfuerzo de reunirse al menos una vez al año.

Es una de las celebraciones más importantes en los Estados Unidos y marca el inicio de la temporada comercial de navidad. El día siguiente, viernes, se denomina Black Friday, en que hay rebajas en los comercios, en preparación para la época de regalos que se avecina. Ahora también hay rebajas en las tiendas virtuales en Internet ese día.


El menú de acción de gracias:

El menú tradicional es el pavo asado, puré de patatas, batatas caramelizadas y judías verdes o zanahorias glaseadas y panecillos de acompañamiento. El postre típico es el pastel de calabaza o de nueces pacanás.

En muchos restaurantes sirven un menú especial ese día, y también algunos supermercados ydelis venden el menú tradicional ya cocinado.

 

 

 

 

 

Bibliografía:

http://www.christiananswers.net/spanish/q-eden/ednkc002s.html

http://mamalatina.about.com/od/Tradiciones_familiares/p/Como-cuando-por-que-se-celebra-accion-de-gracias-Thanksgiving.htm

NAVIDAD Y AÑO NUEVO.

En México, la Navidad es una celebración muy importante. Las fiestas inician desde el 16 de Diciembre hasta el 6, con la tradición conocida como “las Posadas”. La Posada es una representación de lo que pasaron la Virgen y José para que les dieran posada y dar a luz al Niño Jesús. Así que un grupo de gente va caminando de casa en casa cantando algo como esto:


En el nombre del cielo,
os pido posada...

Hasta que llegan a la casa en que se va a celebrar la fiesta y los aceptan. Hay piñatas, comida, música, juegos etc.

24 y 25 de Diciembre.

El 24 de diciembre se llama la “Noche Buena”, y se celebra con toda la familia. Cuando dan las 12 campanadas, a la media noche, una persona arrulla al Niño Dios. Todos los familiares cantan villancicos y se prenden velas y luces de bengala. Toda familia hace una petición, ya sea en silencio o en voz alta y posteriormente se dan los abrazos y si hay regalos también. La cena del 24 puede ser: pavo relleno, bacalao, romeritos (platillo tradicional), caldo de camarón, pierna de cerdo, lomo adobado, ensalada de manzana, pasta, y algún postre. Tomamos ponche sin alcohol preparado con frutas de la temporada (caña, naranja, lima, tejocotes).

En cuanto al Año Nuevo, la celebración es muy similar a la de Noche Buena, solo que a las 00:00 hrs se hace un brindis y se comen 12 uvas, que representan cada uno de los meses del año que llega, con cada uva pedimos un deseo. La cena es similar a la de la Noche Buena y Navidad

El 5 de enero todos los niños escriben una carta a los Reyes Magos con los juguetes que desean recibir, algunos la mandan por globo al cielo y otros lo dejan dentro de un zapato a lado del árbol de navidad para que el 6 en la mañana encuentren sus regalos. El mismo 6 se corta la rosca de reyes que contiene muñequitos representando al niño Dios, el que saque el muñequito debe invitar a todos tamales y atole el día de la candelaria 2 de febrero.

 Bibliografía:

http://www.navidadlatina.com/mexico/

www.sunderlandschools.org/mfl-sunderland/.../ navidad en México

DÍA DE LA REVOLUCIÓN MEXICANA (20 DE NOVIEMBRE).

La Revolución mexicana fue la primera revolución social y política del siglo XX, que inició en 1910 y terminó oficialmente en 1917 con la promulgación de la Constitución de 1917, si bien hubo conflictos intestinos y rebeliones armadas hasta la década de los treinta. El movimiento armado inició como una rebelión en contra de la dictadura de Porfirio Díaz, quien se mantuvo bajo una dictadura por 39 años.

En 1910, Porfirio Díaz se reeligió por sétima vez, después de encarcelar al candidato opositor Francisco Madero. Pero éste, al salir de prisión, hizo un llamado a la rebelión nacional y fue seguido por líderes populares como Pancho Villa y Emiliano Zapata. Al verse acorralado, Porfirio Díaz renunció el 25 de mayo de 1911, y huyó a Europa.

Victorioso, Madero restauró la Constitución de 1857, implantó el sufragio popular y prohibió la reelección. Pero las masas campesinas clamaban por reformas económicas, y el jefe guerrillero del sur Emiliano Zapata propuso el Plan de Ayala, para distribuir tierras entre los trabajadores. Lo apoyó Pancho Villa desde el norte del país. Mientras tanto los sectores conservadores (hacendados, la Iglesia) apoyaron al ministro Victoriano Huerta, quien traicionó a Madero y lo mandó asesinar en 1913.

Después de dos años de caos político y social, a fines de 1915 tomó el poder Venustiano Carranza, quien en 1917 promulgó la Constitución de Querétaro, donde se implantaban importantes reformas como: la jornada laboral de 8 horas, la indemnización por accidentes de trabajo, la libertad de creencias, la reforma agraria y la nacionalización del petróleo. En 1919, fue asesinado Emiliano Zapata.

En 1920, Venustiano Carranza fue asesinado por los partidarios de Álvaro Obregón, quien poco después tomó el poder. En 1923, los terratenientes asesinaron a Pancho Villa. Para muchos la muerte de Carranza y Villa marcan el fin de la Revolución Mexicana. Sin embargo, los conatos de violencia continuaron hasta que en 1934 llegó al gobierno don Lázaro Cárdenas, e hizo realidad la reforma agraria y la expropiación de los yacimientos petroleros.

Bibliografía:

http://mexablog.com/2009/11/20/20-de-noviembre-de-1910-inicio-de-la-revolucion-mexicana/#ixzz2l2zxJLSD

http://www.sanmiguelguide.com/revolucion-mexicana.htm

http://www.resumendehistoria.com/2009/10/la-revolucion-mexicana-resumen.html

 

PROGRAMA 3D.

Para la visualización de un objeto 3D, se requieren 3 pasos:


En primer lugar se necesita una base de datos con las coordenadas (x,y,z) de los vértices y ademas los polígonos que forman el objeto.
En segundo lugar el objeto primero se rota y luego se traslada hasta la localización adecuada, con lo que se obtienen unas nuevas coordenadas (x,y,z) para los vértices.
Finalmente, se eliminan los polígonos que no son visibles por el observador, se aplica la perspectiva y se dibuja el objeto en la pantalla.

Base de Datos del Objeto 3D

Mi objeto esta compuesto por polígonos de tres lados, y cada poligono tiene 3 vértices cuyas coordenadas son (x,y,z).


Número máximo de vértices que puede tener el objeto

#define NUM_VERTICES

Cantidad máxima de polígonos que tiene el objeto


#define NUM_FACES


Definición de un vértice

typedef struct VTX


{
double x, y, z;
};

Definición de un polígono
typedef struct TRI
{
int a, b, c;
};


Estructura para el ordenamiento qsort, donde para cada polígono

almaceno la cordenada z y el indice del polígono
d=coordenada z del poligono, index=indice del polígono
typedef struct LSTR
{
int d;
int index;
};

Tabla que contiene los vértices originales
VTX points[NUM_VERTICES];
Tabla con los vértices transformados
VTX outpoints[NUM_VERTICES];
Tabla que contiene los polígonos
TRI faces[NUM_FACES];
Tabla de polígonos para aplicar el ordenamiento qsort
LSTRI ListFaces[NUM_FACES];
Número de vértices, y polígonos del objeto
int vertices, poligonos;

Vértices del objeto

V0 = points[0].x, points[0].y, points[0].z
V1 = points[1].x, points[1].y, points[1].z
V7 = points[7].x, points[7].y, points[7].z

Polígonos del objeto
faces[0].a = 0 faces[0].b = 2 faces[0].c = 1
faces[1].a = 2 faces[1].b = 3 faces[1].c = 1
faces[5].a = 6 faces[5].b = 7 faces[5].c = 5

Matrices de Transformación 3D
Sistema de Coordenadas

El sistema de coordenadas tridimensional utilizado es el llamado de la mano izquierda

Rotación en torno al eje X

Código en C

void matriz_rotacion_x(MATRIZ *m, double angulo)
{
double tmpsin, tmpcos;
tmpsin=sin(angulo);
tmpcos=cos(angulo);
*m = matriz_identidad;
m->v[1][1] = tmpcos;
m->v[1][2] = tmpsin;
m->v[2][1] = -tmpsin;
m->v[2][2] = tmpcos;
}

Ejemplo: matriz_rotacion_x(&Rx, 0.7)
Esto crea la matriz de rotación alrededor del eje X, donde Rx es una matriz 4x4 y 0.7 es el angulo de rotación, en radianes.

Rotación en torno al eje Y

Código en C.
void matriz_rotacion_y(MATRIZ *m, double angulo)
{
double tmpsin, tmpcos;
tmpsin=sin(angulo);
tmpcos=cos(angulo);
*m = matriz_identidad;
m->v[0][0] = tmpcos;
m->v[0][2] = -tmpsin;
m->v[2][0] = tmpsin;
m->v[2][2] = tmpcos;
}

Rotación en torno al eje Z

Código en C
void matriz_rotacion_z(MATRIZ *m, double angulo)
{
double tmpsin, tmpcos;
tmpsin=sin(angulo);
tmpcos=cos(angulo);
*m = matriz_identidad;
m->v[0][0] = tmpcos;
m->v[0][1] = tmpsin;
m->v[1][0] = -tmpsin;
m->v[1][1] = tmpcos;
}


Ejemplo : matriz_rotacion_z(&Rz, 0.7)
donde Rz es la matriz de 4x4, y 0.7 es el angulo de rotación en torno al eje Z.


Traslación

Código en C

void matriz_traslacion(MATRIZ *m, double Tx, double Ty, double Tz)
{
*m = matriz_identidad;
m->v[3][0] = Tx;
m->v[3][1] = Ty;
m->v[3][2] = Tz;
}


ESTRUCTURA DE TODO EL PROGRAMA.

#include <graphics.h>
#include <stdlib.h>
#include <math.h>
#include <stdio.h>
#include <conio.h>
#include <dos.h>
#include "svga256.h"

#define NUM_VERTICES 512
#define NUM_FACES 1024

typedef struct MATRIZ
{
double v[4][4];
};

typedef struct VTX
{
double x, y, z;
};

typedef struct TRI
{
int a, b, c;
};

typedef struct LSTRI
{
int d;
int index;
};

VTX points[NUM_VERTICES];
VTX outpoints[NUM_VERTICES];
TRI faces[NUM_FACES];
LSTRI ListFaces[NUM_FACES];
int vertices, poligonos;
//posicion de la fuente de luz
double xlight=1.0, ylight=-1.0, zlight=1.0;
unsigned char paleta[256][3];

MATRIZ matriz_identidad = {
{
{ 1.0, 0.0, 0.0, 0.0},
{ 0.0, 1.0, 0.0, 0.0},
{ 0.0, 0.0, 1.0, 0.0},
{ 0.0, 0.0, 0.0, 1.0}
}
};

double persp_xoffset;
double persp_yoffset;
double D;

int huge deteccion()
{
int modo;

clrscr();
printf("Selecciona un modo de video...\n");
printf(" 0) 320x200x256 VGA\n");
printf(" 1) 640x400x256 SVGA\n");
printf(" 2) 640x480x256 SVGA\n");
printf(" 3) 800x600x256 SVGA\n");
printf(" 4) 1024x768x256 SVGA\n\n>");
scanf("%d", &modo);
return modo;
}

void aplicar_matriz(MATRIZ *m, double x, double y, double z, double *xout, double *yout, double *zout)
{
*xout = x*m->v[0][0] + y*m->v[1][0] + z*m->v[2][0] + 1.0*m->v[3][0];
*yout = x*m->v[0][1] + y*m->v[1][1] + z*m->v[2][1] + 1.0*m->v[3][1];
*zout = x*m->v[0][2] + y*m->v[1][2] + z*m->v[2][2] + 1.0*m->v[3][2];
}

void matriz_multiplicacion(MATRIZ *m1, MATRIZ *m2, MATRIZ *out)
{
int i, j, k;

for (i=0; i<4; i++) {
for (j=0; j<4; j++) {
out->v[i][j] = 0.0;
for (k=0; k<4; k++)
out->v[i][j] = out->v[i][j] + m1->v[i][k]*m2->v[k][j];
}
}
}

void matriz_traslacion(MATRIZ *m, double Tx, double Ty, double Tz)
{
*m = matriz_identidad;
m->v[3][0] = Tx;
m->v[3][1] = Ty;
m->v[3][2] = Tz;
}

void matriz_escalamiento(MATRIZ *m, double Ex, double Ey, double Ez)
{
*m = matriz_identidad;
m->v[0][0] = Ex;
m->v[1][1] = Ey;
m->v[2][2] = Ez;
}

void matriz_rotacion_x(MATRIZ *m, double angulo)
{
double tmpsin, tmpcos;

tmpsin=sin(angulo);
tmpcos=cos(angulo);
*m = matriz_identidad;
m->v[1][1] = tmpcos;
m->v[1][2] = tmpsin;
m->v[2][1] = -tmpsin;
m->v[2][2] = tmpcos;
}

void matriz_rotacion_y(MATRIZ *m, double angulo)
{
double tmpsin, tmpcos;

tmpsin=sin(angulo);
tmpcos=cos(angulo);
*m = matriz_identidad;
m->v[0][0] = tmpcos;
m->v[0][2] = -tmpsin;
m->v[2][0] = tmpsin;
m->v[2][2] = tmpcos;
}

void matriz_rotacion_z(MATRIZ *m, double angulo)
{
double tmpsin, tmpcos;

tmpsin=sin(angulo);
tmpcos=cos(angulo);
*m = matriz_identidad;
m->v[0][0] = tmpcos;
m->v[0][1] = tmpsin;
m->v[1][0] = -tmpsin;
m->v[1][1] = tmpcos;
}

void persp_projeccion(double x, double y, double z, double *xout, double *yout)
{
double z1 = 1.0 / z;
*xout = ((x * z1) * D) + persp_xoffset;
*yout = ((y * z1) * D) + persp_yoffset;
}

void set_projeccion_viewport(int w, int h)
{
D = 800;
persp_xoffset = w/2;
persp_yoffset = h/2;
}

void ver_matriz(MATRIZ *m)
{
printf("%lf %lf %lf %lf\n", m->v[0][0], m->v[0][1], m->v[0][2], m->v[0][3]);
printf("%lf %lf %lf %lf\n", m->v[1][0], m->v[1][1], m->v[1][2], m->v[1][3]);
printf("%lf %lf %lf %lf\n", m->v[2][0], m->v[2][1], m->v[2][2], m->v[2][3]);
printf("%lf %lf %lf %lf\n", m->v[3][0], m->v[3][1], m->v[3][2], m->v[3][3]);
}

double producto_escalar(double x1, double y1, double z1, double x2, double y2, double z2)
{
return ((x1 * x2) + (y1 * y2) + (z1 * z2));
}

void producto_vectorial(VTX v1, VTX v2, VTX *out)
{
out->x = (v1.y * v2.z) - (v1.z * v2.y);
out->y = (v1.z * v2.x) - (v1.x * v2.z);
out->z = (v1.x * v2.y) - (v1.y * v2.x);
}

double modulo_vector(double x, double y, double z)
{
return sqrt(x*x + y*y + z*z);
}

void vector_normalizado(double *x, double *y, double *z)
{
double length = 1.0 / modulo_vector(*x, *y, *z);

*x *= length;
*y *= length;
*z *= length;
}

//Esta funcion permite conocer si un poligono esta de cara
//o de espaldas al observador, segun devuelva un valor mayor
//o menor que cero
double Hidden(VTX v1, VTX v2, VTX v3)
{
VTX u, v;
VTX out;
double xout, yout, zout;
double temp;

u.x = v2.x - v1.x;
u.y = v2.y - v1.y;
u.z = v2.z - v1.z;
v.x = v3.x - v1.x;
v.y = v3.y - v1.y;
v.z = v3.z - v1.z;
producto_vectorial(u, v, &out);
temp = producto_escalar(out.x, out.y, out.z, 0.0, 0.0, -1.0);
return temp;
}

//funcion usada para calcular el nivel de intensidad de la
//luz que recibe un poligono
int Light(VTX v1, VTX v2, VTX v3)
{
VTX u, v, out;
double temp;

u.x = v2.x - v1.x;
u.y = v2.y - v1.y;
u.z = v2.z - v1.z;
v.x = v3.x - v1.x;
v.y = v3.y - v1.y;
v.z = v3.z - v1.z;
//out es el vector normal al poligono
producto_vectorial(u, v, &out);
vector_normalizado(&out.x, &out.y, &out.z);
vector_normalizado(&xlight, &ylight, &zlight);
//El resultado de todas estas operaciones dar un valor comprendido
//entre 0.0 (m¡nima luz) y 1.0f (m xima luz)
temp = producto_escalar(out.x, out.y, out.z, xlight, ylight, zlight);
temp = 256.0*temp;
if (temp<0.0)
temp=0.0;
else
if (temp>255.0)
temp=255.0;
return (int) (temp);
}

//me dibuja un poligono solido, el color lo determino
//de acuerdo al nivel de luz que recibe.
void DibujarPoligono(int num)
{
int A, B, C;
int poly[6];
int i, color;

i=ListFaces[num].index;
A=faces[i].a;
B=faces[i].b;
C=faces[i].c;
//verifico si el poligono es visible o no
if (Hidden(outpoints[A], outpoints[B], outpoints[C])<0.0)
{
//se llama a la funci¢n que calcula la luz de un pol¡gono
color = Light(outpoints[A], outpoints[B], outpoints[C]);
poly[0]=(int) outpoints[A].x;
poly[1]=(int) outpoints[A].y;
poly[2]=(int) outpoints[B].x;
poly[3]=(int) outpoints[B].y;
poly[4]=(int) outpoints[C].x;
poly[5]=(int) outpoints[C].y;
setfillstyle(SOLID_FILL, color);
setcolor(color);
fillpoly(3, poly);
}
}

int comparar(const void * e1, const void * e2)
{
int d1, d2;

LSTRI *q1 = (LSTRI *)e1;
LSTRI *q2 = (LSTRI *)e2;

d1=q1->d;
d2=q2->d;
return (d2-d1);
}

void setvgapalette256(DacPalette256 *PalBuf)
{
struct REGPACK reg;

reg.r_ax = 0x1012;
reg.r_bx = 0;
reg.r_cx = 256;
reg.r_es = FP_SEG(PalBuf);
reg.r_dx = FP_OFF(PalBuf);
intr(0x10,®);
}

void LeerObjeto(char *nombre)
{
int i;

FILE *in = fopen(nombre, "r");
if (!in)
return;
fscanf(in, "%d\n", &vertices);
//printf("%d\n", vertices);
for (i = 0; i<vertices; i++)
{
fscanf(in, "%lf %lf %lf\n", &points[i].x, &points[i].y, &points[i].z);
//printf("%lf %lf %lf\n", points[i].x, points[i].y, points[i].z);
};
fscanf(in, "%d\n", &poligonos);
//printf("%d\n", poligonos);
for (i = 0; i<poligonos; i++)
{
fscanf(in, "%d %d %d\n", &faces[i].a, &faces[i].b, &faces[i].c);
//printf("%d %d %d\n", faces[i].a, faces[i].b, faces[i].c);
}
//printf("Presionar una tecla para continuar...");
//getch();
fclose(in);
}

int main(void)
{
MATRIZ Rx, Ry, Rz, Rot;
MATRIZ Tr, Mat;
MATRIZ temp;
int i;


//Carga el modelo en memoria
LeerObjeto("toro.dat");

//Inicializa el modo grafico
int driver = DETECT, modo = DETECT;
installuserdriver("Svga256", deteccion);
initgraph(&driver, &modo, "");

for (i=0; i<256; i++)
{
paleta[i][0]=i/4;
paleta[i][1]=i/4;
paleta[i][2]=i/4;
}

//me cambia la paleta de colores a una escala de 64 tonos de grises
setvgapalette256(&paleta);

for (i=0; i<256; i++)
{
setcolor(i);
line(i,0,i,20);
};

set_projeccion_viewport(getmaxx(), getmaxy());

//Inicializa las matrices de rotacion y
//traslacion.
matriz_rotacion_x(&Rx, -0.785);
matriz_rotacion_y(&Ry, 0.523);
matriz_rotacion_z(&Rz, 0.0);
matriz_traslacion(&Tr, 0.0, 0.0, -350.0);
//multiplica las matrices
//Mat=Rx*Ry*Rz*Tr (matriz de transformacion)
matriz_multiplicacion(&Rx, &Ry, &temp);
matriz_multiplicacion(&temp, &Rz, &Rot);
matriz_multiplicacion(&Rot, &Tr, &Mat);
//aplica la matriz de transformacion a cada uno
//de los vertices del modelo.
for (i=0; i<vertices; i++)
{
aplicar_matriz(&Mat, points[i].x, points[i].y, points[i].z,
&outpoints[i].x, &outpoints[i].y, &outpoints[i].z);
persp_projeccion(outpoints[i].x, outpoints[i].y, outpoints[i].z,
&outpoints[i].x, &outpoints[i].y);
};
//construyo una tabla con las coordenadas z, de cada uno
//de los poligonos.
for (i=0; i<poligonos; i++)
{
ListFaces[i].d = (int) fabs(outpoints[faces[i].a].z + outpoints[faces[i].b].z + outpoints[faces[i].c].z);
ListFaces[i].index=i;
}
//ordeno los poligonos de acuerdo a z.
qsort(ListFaces, poligonos, sizeof(ListFaces[0]), comparar);

//dibujo los poligonos
for (i=0; i<poligonos; i++)
DibujarPoligono(i);

getch();
closegraph();
return 0;
}