OnlyAngel.Net @ CINVESTAV.NET

Actualizaciones

noreply@blogger.com (OnlyAngel.Net Place) — Fri, 23 May 2008 06:06:00 +0000

Se que tiene mucho tiempo que no escribo nada pero e estado trabajando mucho en la escuela ya saben, les comento que ya voy por el tercer cuatrimestre y empezare a subir las tareas de el segundo cuatrimestre de todas las materias para que puedan descargarlas, independientemente de que esten bien todos los puntos de ellas. Como humano tube muchos errores en algunas pero en otras sali muy bien.

Asi que estamos en contacto y espero que lean que se hace por aqui en esta fantastico Instituto.

Por cierto ya se han publicado las fechas de el proceso de admicion del departamento de computacion, pueden verlo en el siguiente vinculo: http://www.cs.cinvestav.mx/Posgrado/posgrado.html

Estamos en contacto...

"Software and the Concurrency Revolution" Lecture

noreply@blogger.com (OnlyAngel.Net Place) — Thu, 17 Jan 2008 08:45:00 +0000

The original document can be downloaded here.

As first homework of the class of concurrent proggraming we read these article, and these is a small sumary.

The computers are growing in these last days in a way that before were rare, these days the hardware is changing to a multicore processors but that the people didnt understand is tha it only benefit to a concurrent applications(that exist since 30 years). Today desktop applications will not run much faster than they do now. In fact they may run slightly slower on newer Chips, as individual cores become simper and run at lower clok speeds to reduco power consuption on dense multicore processors.

One of the conceptual problems in concurrent programing is that the concurrency requires programmers to think in a way humans find difficult, nevertheless, multicore machines are the future.

Consequences: a new era in software

Semaphores and coroutines are the assembler of concurrency, and locks and threads are the slightly higher-level structured constructs of concurrency. What is needed is OO (Object Oriented) for concurrency.

If you think that sequential programming is hard, concurrent programming is demostrably more difficult, becouse it requires synchronization analysis and other things.

Differences between client and sever applications

For many server-based programs, typically have an abundance of parallelism, as they simultaneously handle many independent request streams.

In client applications is not nearly as well structured and regular typically concurrency is found by dividing a computacion into finer pieces.

Programming models

parallel programming models differ significantly in two dimensions: granularity of the arallel operations and the degree of coupling between these tasks.

Parallel instruction execution generrally requires hardware support, Multicore processors reduce communicacion and synchronization costs, as compared with conventional multiprocessors, witch can reduce the overhead burden on smaller pieces of code.

The other dimension es he degree of coupling in the commuication and synchronization between the operations. The ideals is none: operations run entirely independently and produce distinct outputs.

Independent parallelism

es the parallelism in wich one or more operatiosn are applied independently to each item in a data collection.

Fine-granied data parallelism relies on the independence of the operations executed concurrently. They should no t share input data or results an dshould be executable without coordination.

Regular parallelism

Thw next step is to apply the same operation to a collection of data when the computations are mutually dependent

The problem of shared state, and why locks aren't the answer

When two tasks try to access the same object, and one could modify its state, if we do no thing to coordinate the tasks, we have a data race. Races are bad because the concurrent tasks can read and write inconsistent or corrupted values.

There are a rich variety of syncronization devices that can prevent races. The simplest of these is a lockk. Each task that wants to access a piece of shsred data must adquire the lock for that data, perform its computation, and then release the lock so other operations on the data can proceed.

A fundamental problem with locks is that they are not composable. You can't take two correct lock-based pieces of code, combine them, and know that the result is still correct.

in its simplest form deadlock happens when two locks might be adquired by two tasks in opposite order: task T1 takes lock L1, task T2 takes lock L2 and then T1 tries to take L2 thile T2 tries to take L1. Both block forever. There are some techniques for avoiding deadlocks, lock leveling and lock hierarchies..

There are at least three major problems with synchronized methods. First, they are no appropiate for types whose methods call virtual functions on other objets, synchronized methods can perform too much locking, by acquiring and releasing locks on all objects instances. Third, synchronized methods cna also perform too little locking, by no preservin atomicity when a program call multiple methods on a object ro on different objets.

...

Original document writed by Herb Sutter and James Larus can by downloaded from here.

Notas puntuales de: Bases de Datos

noreply@blogger.com (OnlyAngel.Net Place) — Wed, 16 Jan 2008 08:18:00 +0000

Fundamentos de bases de datos

Transaction Database ACM

Tecnologías de Bases de datos

Data & Knoledge IEEE

Softare & Practice.

Sistemas de Información

Information System

Teorías de Bases de Datos

Teorías algebraicas (Algebras Universales)
Teorías de la Lógica (Lógicas)

Modelo de datos

CODASYL Comité de Datos Sistemas y Lenguajes (Cobol, sistemas de bases de datos, principios de base de datos)

Modelo de datos de Red y Jerárquico (Base: Teoría de Conjuntos)

Base de Datos
Sistema maneador de base de datos (DBMS)

Modelo de datos Relacional

Contiene

Modelo de datos (Esquemas o Objetos de Relación)

Algebra de Relación Relación n’aria R=(A1,... , An)

Restricciones de Integridad

Modelo matemático es M= representa que el modelo esta representado por espacio de relación R el Algebra que lo representa A y las restricciones de integridad I.

Modelo Entity-Relationship

Trato de unificar los modelos de Red, Jerárquico y Relacional

Modelo Semántico de datos

Redes Semánticas

Modelo Funcional de datos

Semántica de datos & Conocimiento

Abstracción y Generalización

Lógica y Bases de datos

Fundamentación de las BD desde la lógica.

Visión de las BD desde la Lógica.

Explicacion

Modelo Relacional <--> Modelo de la lógica de primer orden

Relaciones R - son predicados.

Lenguaje relacional - lenguaje de la lógica

Notas puntuales de: Bases de datos

noreply@blogger.com (OnlyAngel.Net Place) — Mon, 14 Jan 2008 08:10:00 +0000

Materia Bases de Datos Impartida por el Dr. Sergio Chapa.

Sistemas Biológicos es un área muy interesante para el futuro de las ciencias de la computación.
Especialmente en el diseño de datos y modelos de datos

Bases de Datos e Inteligencia Artificial Una buena bibliografía aunque es posible que ya no se siga editando.

Al inicio todo computo se basaba en cintas. Y una de las primeras metas era hacer que el computo se hiciera en memoria, para poder realizar búsquedas, haching, etc.

El problema de la partida doble es un problema viejo y puede ser resuelto como un problema de optimizaron.

Una base de datos es un conjunto de datos, todos relacionados entre ellos.

Vinculos, WatchDog, uptime

noreply@blogger.com (OnlyAngel.Net Place) — Sat, 12 Jan 2008 07:16:00 +0000

Notas de la clase de Sistemas Operativos impartida por el Dr. Dominique Decouchant

Comandos

$ln: crea una liga dura entre archivos ($ln )

$ln -s: crea una liga simbolica.

$ll : es como ls pero muestra la cantidad de referencias de los bloques de los archivos creados con ln.

$uptime: dice estadísticamente la carga del sistema en diferentes lapsos.

WatchDog: es un proceso que que esta constituido por un solo ciclo infinito que mantiene a el procesador trabajando cuando no se esta siendo usado por el usuario por que el procesador no puede detenerse (si eso sucediera el sistema se detendría). Para que este proceso no interrumpa o estorbe a procesos importantes del sistema se le asigna el menor nivel de prioridad del sistema a ese proceso, así que dará en background en cuanto otro proceso requiera usar el procesador.

Segundo cuatrimestre

noreply@blogger.com (OnlyAngel.Net Place) — Sat, 12 Jan 2008 06:43:00 +0000

En esta ocasión les comento que por un buen rato e estado pensando sobre que materias tomar y no repetir el error del cuatrimestre pasado de estresandome entrando a todas las materias para saber de que se tratan (para eso ya tuve un intensivo cuatrimestre pasado), ahora con el apoyo de el Doctor Matías pude definir mi evolución en este siguiente paso en la maestría. Mi intención era tomar Optimización, Inteligencia Artificial, Sistemas Operativos y Bases de Datos. Pero me invitaron a tomar una clase de programación concurrente (de la cual no sabia ni pio), y me di cuenta que es una muy buena herramienta que me puede servir, entonces entre en problemas por que solo podemos llevar cuatro materias y al hablar con el Dr. Matías resalto que quería tomar IA por que tenia la cosquilla de aprender a implementar inteligencia artificial y me comento que si llevaba optimización el Dr. Carlos Coello, el la daba implementando Computación Evolutiva que es una área muy especifica de IA y que eso podría satisfacer mi curiosidad de saber sobre la materia y dejarme el espacio necesario para poder llevar programación concurrente, lo cual me agrado mucho. Ya que aprenderé mas con el mismo tiempo.

Entonces mi carga curricular para este cuatrimestre queda como Optimización, Programación Concurrente, Sistemas Operativos y Bases de Datos.

Nota: Las imágenes son de los doctores Matías (Izquierda) y Carlos Coello (Derecha)

Recuento de los Daños.

noreply@blogger.com (OnlyAngel.Net Place) — Thu, 10 Jan 2008 20:58:00 +0000

Hello fellows, comento que empezare una serie de posts denominada "Recuento de los daños" donde comentare las características de cada uno de los cursos que tome, impresiones de los maestros, y alumnos, tareas y cosas que hayan pasado (realmente me gustaría incluir todo esto pero no estoy muy seguro de realmente poner todos estos puntos en cada curso).

Ahora solo compartiré parte de mis impresiones generales en este cuatrimestre.

Como siempre (según el Dr. Coello, en una platica de bienvenida), los alumnos de nuevo ingreso tratando de cubrir nuestras dudas, necesidades de aprender y comprender que tipo de maestros hay además de los tipos de materias, siempre entramos a todos los cursos, disque para ver de que se trata y conocer a los maestros. Actividad que si de por si es desgastante en esta institución es mucho mas por el nivel de las clases. Así que imaginense tratando de entrar a todas las clases de la primera tabla en esta pagina. Y todas dejando tareas o los doctores "espantando" a los alumnos. En esas primeras dos semanas fueron donde empezaron las primeras risas con los doctores o primeras impresiones dependiendo de cual sea el caso. De esta manera se empeso después de ver algunos temas interesantes y retadores y al hablar con mi asesor de maestria el Dr. Matias al respecto llegue a la conclusión de entrar a las materias de Matemáticas Discretas, Graficacion, Ingeniera de Software y ProgramaciónOrientada a Objetos, impartidas por los doctores Debrup Chakraborti , Luis Gerardo de la Fraga, Pedro Mejía Alvarez y Dominique Decouchant con la Dra. Sonia Mendoza Chapa.

Todos excelentes Doctores con una gran habilidad y lo que mas me gusto des sus clases es que dificilmente tenían un error y si era el caso, se corregían automáticamente, además de la gran cantidad de conocimiento que destilan en cada una de sus secciones de clase, en realidad te hacen sentir en la cima de algo que toda vía no se bien que es.

Al entrar tenia una fuerte inclinación a la computación evolutiva por que me e enterado que es algo muy complejo y eso a mi me encanta, pero en el transcurso de los cursos me latió mucho el tema de graficación. O específicamente de visualización por que e tenido experiencia en esa área y se me ocurren mas cosas que hacer, pero siguen siendo aplicaciones de tecnologías quizá no muy dignas de una tesis de maestría en ciencias, pero el tiempo lo dirá y esta cabeza igual.

No cabe duda que este tiempo aquí en el DF me a ayudado a madurar bastante en el sentido de mantenerme a mi mismo y vivir solo, me a quitado algunas dudas y miedos que tenia en la cabeza. Estas entre otras muchas cosas han sucedido en este cuatrimestre en esta carrera, pronto escribiré sobre el recuento de los daños para las materias que tome.

SDSCC

noreply@blogger.com (OnlyAngel.Net Place) — Thu, 10 Jan 2008 07:36:00 +0000

Proyecto de documentación y desarrollo de un sistema web para administrar una conferencia científica, que se realizo en equipo con Rogelio un compañero de curso, en el trabajo se tubo serios problemas de comunicación independientemente que se trato de manejar buenos métodos de sincronización de información SVN, videoconferencias, remote descktops y aun así no pudimos cumplir con el realizar un trabajo con la calidad suficiente para poder tener una buena realización al final. Sin embargo fue suficiente para pasar la materia (aunque suene emotivo realmente es algo denigrante usar la palabra suficiente, pero así son las cosas, así que aguas con los problemas de comunicación con tus equipos, debes asegurarte que te van a entender para que hay mayor provecho).

Les dejo el documento del proyecto para que estén enterados de que se trata mas a profundo.

Aqui

Trazo de splines

noreply@blogger.com (OnlyAngel.Net Place) — Sun, 16 Dec 2007 12:47:00 +0000

Trazo de splines

• Interpolar un conjunto de puntos usando los splines cubicos naturales.

• Interpolar un conjunto de puntos de una curva cerrada usando los mismos splines cubicos naturales.

• Interpolar el mismo conjunto de puntos del primer punto pero ahora usando los splines Catmull-Rom.

• El trazo debe realizase con gnuplot

Jose Angel Espinoza Portillo, onlyangel@onlyangel.net

December 16, 2007
Archivo PDF
Archivo TEX
Paquete Completo en ZIP

Splines Cubicas Naturales

1 Teorıa
Fue una de las primeras curvas splines que se desarrollo para aplicaciones gr´aﬁcas es el spline cubico natural. Esta se forma imponiendo que dos partes adyacentes e la curva posean la mismas primera y segunda derivada parametrica en su limite comun. Por tanto, los splines cubicos naturales tienen continuidad C 2 .

Si tenemos n + 1puntos de control, como en la Figura 1.1, entonces tenemos n partes de la curva con un total de 4n coeﬁcientes de polinomio que hay que determinar. En cada uno de los n − 1 puntos de control interiores tenemos cuatro condiciones en el limite: las dos partes de la curva a cada lado de un punto de control deben tenerlas mismas primera y segunda derivadas parametricas en dicho punto de control, y cada curva debe pasar por ese punto de control. Esto nos proporciona 4n − 4 ecuaciones que hay que satisfacer con 4n coeﬁcientes de polinomio, obtenemos una ecuaci´on adicional a partir del primer punto de control p0 y pn en el valor 0. Otra t´ecnica es anadir dos puntos de control extra (llamados puntos ﬁcticios ), uno en cada extremo de la secuencia original de puntos de control. Es decir anadimos un punto de control etiquetado como p en el comienzo de la curva y un punto decontrol etiquetado como pn+1 en el ﬁnal. Entonces todos los puntos e control originales son puntos anteriores y tenemos las 4n condiciones necesarias en el limite.

2 Base matematica del dibujo
Si tenemos una secuencia de puntos P = {P0 , P1 , · · · , Pn } donde cada Pa es un punto en el espacio (xa , ya ). Se tiene que desarrollar la siguiente Multiplicaci´on de matrices.

De esta manera se tienen todas las secciones de la curva a dibujar, la cual para ser rendereada por puntos se especiﬁcan segun la siguiente ecuaci´on basada en t.

3 Interpolando un Conjunto de Puntos
3.1 Se propone el siguiente P.

3.2 Se tendr´an unos M de:

3.3 Con lo que nos queda.

3.4 C´odigo de gluplot


X1(t) = 2*(1-t) + 4*t + (-30/6)*( (1-t)*(1-t)*(1-t) - (1-t) ) + (30/6)*( t*t*t - t )
Y1(t) = 3*(1-t) + 8*t + (30/6)*( (1-t)*(1-t)*(1-t) - (1-t) ) + (-30/6)*( t*t*t - t )
X2(t) = 4*(1-t) + 6*t + (-30/6)*( (1-t)*(1-t)*(1-t) - (1-t) ) + (30/6)*( t*t*t - t )
Y2(t) = 8*(1-t) + 3*t + (-30/6)*( (1-t)*(1-t)*(1-t) - (1-t) ) + (30/6)*( t*t*t - t )
X3(t) = 6*(1-t) + 8*t + (-30/6)*( (1-t)*(1-t)*(1-t)-(1-t) ) + (30/6)*( t*t*t - t)
Y3(t) = 3*(1-t) + 8*t + (30/6)*( (1-t)*(1-t)*(1-t)-(1-t) ) + (-30/6)*( t*t*t - t)
set xrange [0:10]
set yrange [0:10]
set multiplot
plot ’puntosNaturales.txt’ w p ps 2
set parametric
set trange [0:1]
plot X1(t),Y1(t), X2(t),Y2(t),X3(t),Y3(t)
unset multiplot
pause -1

3.5 Resultado

4 El caso del la ﬁgura circular
4.1 Se propone el siguiente P.

4.2 Se tendr´an unos M de:

4.3 Con lo que nos queda.

4.4 Codigo en GNUPLOT


X1(t) = 4*(1-t)+3*t + ((-11.81041)/6)*((1-t)*(1-t)*(1-t)-(1-t)) + ((8.33644)/6)*(t*t*t-t)
Y1(t) = 4*(1-t)+0*t + ((-12.21815)/6)*((1-t)*(1-t)*(1-t)-(1-t)) + ((0.76353)/6)*(t*t*t-t)
X2(t) = 3*(1-t)+4*t + ((8.33644)/6)*((1-t)*(1-t)*(1-t)-(1-t)) + ((-9.53533)/6)*(t*t*t-t)
Y2(t) = 0*(1-t)-4*t + ((0.76353)/6)*((1-t)*(1-t)*(1-t)-(1-t)) + ((9.16403)/6)*(t*t*t-t)
X3(t) = 4*(1-t)+0*t + ((-9.53533)/6)*((1-t)*(1-t)*(1-t)-(1-t)) + ((-0.19511)/6)*(t*t*t-t)
Y3(t) = -4*(1-t)-3*t + ((9.16403)/6)*((1-t)*(1-t)*(1-t)-(1-t)) + (( -7.41963)/6)*(t*t*t-t)
X4(t) = 0*(1-t)-4*t + ((-0.19511)/6)*((1-t)*(1-t)*(1-t)-(1-t)) + ((10.31579)/6)*(t*t*t-t)
Y4(t) = -3*(1-t)-4*t + (( -7.41963)/6)*((1-t)*(1-t)*(1-t)-(1-t)) + ((8.51451)/6)*(t*t*t-t)
X5(t) = -4*(1-t)-3*t + ((10.31579)/6)*((1-t)*(1-t)*(1-t)-(1-t)) + ((-11.06804)/6)*(t*t*t-t)
Y5(t) = -4*(1-t)+0*t + ((8.51451)/6)*((1-t)*(1-t)*(1-t)-(1-t)) + ((3.36161)/6)*(t*t*t-t)
X6(t) = -3*(1-t)-4*t + ((-11.06804)/6)*((1-t)*(1-t)*(1-t)-(1-t)) + ((21.95635)/6)*(t*t*t-t)
Y6(t) = 0*(1-t)+4*t + ((-3.36161)/6)*((1-t)*(1-t)*(1-t)-(1-t)) + ((-21.96094)/6)*(t*t*t-t)
X7(t) = -4*(1-t)+0*t + ((21.95635)/6)*((1-t)*(1-t)*(1-t)-(1-t)) + ((-2.84467)/6)*(t*t*t-t)
Y7(t) = 4*(1-t)+3*t + ((-21.96094)/6)*((1-t)*(1-t)*(1-t)-(1-t)) + ((10.56027)/6)*(t*t*t-t)
X8(t) = 0*(1-t)+4*t + ((-2.84467)/6)*((1-t)*(1-t)*(1-t)-(1-t)) + ((10.57766)/6)*(t*t*t-t)
Y8(t) = 3*(1-t)+4*t + ((10.56027)/6)*((1-t)*(1-t)*(1-t)-(1-t)) + ((-8.28013)/6)*(t*t*t-t)
set xrange [-7:7]
set yrange [-7:7]
set multiplot
plot ’puntosNaturalesCirculo.txt’ w p ps 2
set parametric
set trange [0:1]
plot X1(t),Y1(t), X2(t),Y2(t),X3(t),Y3(t), X4(t),Y4(t),X5(t),Y5(t), X6(t),Y6(t),X7(t),Y7(t),X8(t),Y8(
unset multiplot
pause -1

4.5 Resultado

Splines de Catmull-Rom

1 Teor´ıa y base matematica

Al igual que los splines de Hermite, los splines Catmull-Rom son polinomio de interpolaci´on por tramos c´ubicos con tangentes especiﬁcas en los puntos extremos en los limites de cada secci´on de la curva. La diferencia es que no introducimos los valores de las tangentes en los puntos extremos. En un spline CR, la pendiente en en el punto de control se calcula a partir de las coordenadas de los dos puntos de control adyacentes.

Una secci´on de un spline queda completamente determinada con cuatro puntos de control consecutivos. Los puntos de control centrales son los puntos extremos de la secci´on, y otros dos los puntos se utilizan en el calculo de las pendientes en los puntos extremos. Si tomamos P(u) como la representaci´on de la funci´on de punto param´etrica cubica de la secci´on de curva entre los puntos de control Pk−1 hasta Pk+1 se utilizan para establecer las condiciones en los limites de la secci´on del spline de este modo:

Por tanto, las pendientes en los puntos de control Pk y Pk+1 se toman proporcionales, respectivamente, a las cuerdas Pk
−1 Pk+1 y Pk Pk+2 el par´ametro t se denomina par´ametro de tensi´on, ya que controla como de ﬂo jo o apretado se a justa el spline a los puntos de control de entrada.
Utilizando m´etodos similares a los utilizados para los polinomios Hermite, podemos convertir las condiciones de (2.1) de los limites en su forma matricial,

Donde la Matriz Catmun-Rom es:

con s = (1 − t)/2.
Desarrollando la Ecuacion matricial (2.2) en forma polinomica, tenemos:

donde los polinomios C ARK (u) con K = 0, 1, 2, 3 son las funciones de combinacion de la matriz base de los splines Catmull-Rom.

2 El caso del Curva Catmull-Rom
2.1 Se propone el siguiente P.

2.2 Se tienen unos M’s de:

De donde obtenemos la matriz base de Catmull-Rom multiplicandolas:

2.3 Con lo que nos queda un P(u).
Obtenemos C ARen conformidad con (2.2) para obtener (2.4) matricial(P (u)).

2.4 El Codigo en GNUPLOT


P1(t) = (-0.5*t*t*t + 1*t*t - 0.5*t + 0)
P2(t) = ( 1.5*t*t*t - 2.5*t*t + 0*t + 1)
P3(t) = (-1.5*t*t*t + 2*t*t + 0.5*t + 0)
P4(t) = ( 0.5*t*t*t - 0.5*t*t + 0*t + 0)
x1(t) = 1*P1(t) + 2*P2(t) + 4*P3(t) + 6*P4(t)
y1(t) = 8*P1(t) + 3*P2(t) + 8*P3(t) + 3*P4(t)
x2(t) = 2*P1(t) + 4*P2(t) + 6*P3(t) + 8*P4(t)
y2(t) = 3*P1(t) + 8*P2(t) + 3*P3(t) + 8*P4(t)
x3(t) = 4*P1(t) + 6*P2(t) + 8*P3(t) + 10*P4(t)
y3(t) = 8*P1(t) + 3*P2(t) + 8*P3(t) + 3*P4(t)
x4(t) = 4*P1(t) + 6*P2(t) + 8*P3(t) + 20*P4(t)
y4(t) = 8*P1(t) + 3*P2(t) + 8*P3(t) + 20*P4(t)
set xrange [0:10]
set yrange [0:10]
set multiplot
plot ’puntos.txt’ w p ps 2
set parametric
set trange [0:1]
plot x1(t), y1(t), x2(t), y2(t), x3(t), y3(t) ,x4(t), y4(t)
unset multiplot
pause -1

2.5 Resultado

Mi carro con PovRay

noreply@blogger.com (OnlyAngel.Net Place) — Wed, 12 Dec 2007 20:47:00 +0000

Mi carro con PovRay

Dibujado de un carro en OpenGL utilizando ????

Jose Angel Espinoza Portillo

Graficacion • 14 Diciembre 2007

PDF File

Que es Pov-Ray?
Pov-Ray es una herramienta que sirve para generar ambientes en 3D, basada la técnica de trazo de rayo. La cual consiste en dividir el campo de visión en una maya de pixeles y evaluar simular un rayo que pasa por cada pixel y evalúa el objeto que choca y el rebote de la luz desde todos los objetos y las fuentes de luz en el. y así sucesivamente con cada pixel, un ejemplo de esta técnica se puede ver en en la siguiente figura.

Implementación
Como implementar y que pasos seguir para el dibujado.

Base
De manera similar que en Open GL se programan muchas cosas dentro del código, el primer paso antes de empezar a implementar el carro es especificar las características básicas las cuales se especifican a continuación:


#include "colors.inc"
#include "shapes.inc"
#include "textures.inc"

camera {
location <2,5,>
look_at <0,>
}

background { color SkyBlue }
light_source { <20,> color rgb<1,> }

Esto posesionara la cámara en el punto <15,> mirando hacia <0,>, define el fondo en color azul cielo y posiciona una fuente de luz blanca en las coordenadas <20,>

Plano
Ahora se procede a agregar el siguiente código para integrar un plano infinito dentro de la vista:


plane { y, 1
pigment { checker Green, White }
finish { ambient .3 diffuse .7 }
}

El valor de pigment le dice que va a ser una maya de cuadros a continuación de los colores de los cuadros.

Cielo
Para simular el cielo, se agrega una esfera, la cual es magnificada para abarcar el espacio del cielo. Esta esfera es creada de la siguiente manera:


#declare Sky = sky_sphere {
pigment {
gradient y
color_map {
[0.75  color CornflowerBlue]
[1.00  color MidnightBlue]
}                                            
scale 2
translate <-1, -1, -1>
}
pigment {
bozo
turbulence 0.6
octaves 7
omega .49876
lambda 2.5432
color_map {
[0.0 color rgbf<.75, .75, .75, 0.1>]
[0.4 color rgbf<.9, .9, .9, .9>]
[0.7 color rgbf<1,>]
}
scale 6/10
scale <1,>
}
pigment {
bozo
turbulence 0.6
octaves 8
omega .5123
lambda 2.56578
color_map {
[0.0 color rgbf<.375, .375, .375, 0.2>]
[0.4 color rgbf<.45, .45, .45, .9>]
[0.6 color rgbf<0.5,>]
}
scale 6/10
scale <1,>
}
}
sky_sphere { Sky }

El carrito

Los colores

Para hacer el carro primero se especificaron las 6 texturas del objeto pertenecientes a cada lado del mismo especificandole un grado de refleccion y el material del mismo(metal) de la siguiente manera:


#declare TRed = texture {
pigment { color rgb<0.8,> }
finish {
reflection {0.5 metallic}
diffuse 0.4

brilliance 2
specular 1 roughness 0.01
metallic
}
}
#declare TGreen = texture {
pigment { color rgb<0.2,> }
finish {
reflection {0.5 metallic}
diffuse 0.4

brilliance 2
specular 1 roughness 0.01
metallic
}
}
#declare TBlue = texture {
pigment { color rgb<0.2,> }
finish {
reflection {0.5 metallic}
diffuse 0.4

brilliance 2
specular 1 roughness 0.01
metallic
}
}

#declare TWhite = texture {
pigment { color rgb<0.8,> }
finish {
reflection {0.5 metallic}
diffuse 0.4

brilliance 2
specular 1 roughness 0.01
metallic
}
}
#declare TViolet = texture {
pigment { color rgb<0.8,> }
finish {
reflection {0.5 metallic}
diffuse 0.4

brilliance 2
specular 1 roughness 0.01
metallic
}
}

#declare TPurple = texture {
pigment { color rgb<0.8,> }
finish {
reflection {0.5 metallic}
diffuse 0.4

brilliance 2
specular 1 roughness 0.01
metallic
}
}

La figura
Basado en la figura diseñada para el mismo proyecto en OpenGL se implemento un objeto mesh basado en mayas de triángulos especificando que textura tiene cada triángulo esto se dibuja de la siguiente manera:


mesh {

triangle {
<0,>, <5,>, <5,>
texture { TRed }
}
triangle {
<0,>, <5,>, <0,>
texture { TRed }
}
triangle {
<1.25,>, <3.75,>, <3.75,>
texture { TRed }
}
triangle {
<1.25,>, <3.75,>, <1.25,>
texture { TRed }
}

triangle {
<0,>, <5,>, <5,>
texture { TGreen }
}
triangle {
<0,>, <5,>, <0,>
texture { TGreen }
}

triangle {
<0,>, <0,>, <0,>
texture { TWhite }
}
triangle {
<0,>, <0,>, <0,>
texture { TWhite }   
}
triangle {
<1.25,>, <1,>, <1,>
texture { TWhite }
}
triangle {
<1.25,>, <1,>, <1.25,>
texture { TWhite }   
}

triangle {
<0,>, <5,>, <5,>
texture { TViolet }
}
triangle {
<0,>, <5,> <0,>
texture { TViolet }   
}
triangle {
<1,>, <4,>, <3.75,>
texture { TViolet }
}
triangle {
<1,>, <3.75,>, <1.25,>
texture { TViolet }   
}

triangle {
<5,>, <5,>, <5,>
texture { TBlue }
}
triangle {
<5,>, <5,>,  <5,>
texture { TBlue }   
}
triangle {
<4,>, <4,>, <3.75,>
texture { TBlue }
}
triangle {
<4,>, <3.75,>, <3.75,>
texture { TBlue }   
}

triangle {
<5,>, <0,>, <0,>
texture { TPurple }
}
triangle {
<5,>, <0,>,  <5,>
texture { TPurple }   
}
triangle {
<3.75,>, <1.25,>, <1,>
texture { TPurple }
}
triangle {
<3.75,>, <1,>, <4,>
texture { TPurple }   
}

rotate x*-90
}

Cámara
Para efectos de presentación se moverá la cámara a otro punto para poder notar mejor la sombra y el efecto de reflejo de el piso en el objeto, reemplazando la cámara por lo siguiente.


camera {
location <15,>
look_at <0,>
}

BRAZO ARTICULADO CON ILUMINACIÓN

noreply@blogger.com (OnlyAngel.Net Place) — Wed, 12 Dec 2007 20:06:00 +0000

BRAZO ARTICULADO CON ILUMINACIÓN

Implementando la estructura de un brazo articulado con movimiento en 4 grados de libertad e iluminación artificial.

Jose Angel Espinoza Portillo

Otoño 2007

Versión PDF

Definiendo el problema
Dibujar un brazo articulado en 3D que pueda moverse con las pulsaciones de teclas e implementar un sistema de iluminación que permita ver un reflejo de la luz en la estructura del brazo.
Primer paso - Colocar la cámara
Como en la analogía del camarógrafo explicado en clase, el primero paso es colocar la cámara apuntando hacia donde esta lo que se desea visualizar, para esto cargamos la matriz de proyección y especificamos el punto de vista basado en la elevación de la cámara y el ángulo de visión (rotado en el eje y) y llamamos gluLookAt para ser ejecutado con esas coordenadas mirando al origen, con el siguiente código:


glMatrixMode (GL_PROJECTION);
glLoadIdentity ();

gluPerspective(30,1,0.01,100);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity ();             /* clear the matrix */
eye[0] =  zoom *sin(azi*3.1416/180) * cos(ele*3.1416/180);
eye[1] =  zoom *sin(ele*3.1416/180) ;
eye[2] =  zoom *cos(azi*3.1416/180) * cos(ele*3.1416/180);

gluLookAt(eye[0],eye[1],eye[2],0,0,0,0,1,0);

Iluminación

Lo que se quiere lograr con la iluminación es tener un efecto de reflejo de la luz blanca en las superficies de as figuras, con respecto a la cámara y la fuente de luz (que se colocara en el punto (1,1,1)), y que el material del objeto permanezca del color que se le da a el objeto esto se hace habilitando el GL_COLOR_MATERIAL, esto se realiza con el siguiente código:


// Define el punto de origen de luz y su brillo
GLfloat light0_pos[]={1.0,1.0,1.0,1.0};
GLfloat shininess[]={5.0}; // Mientras mas pequeño da la apariencia de mas brillo.

glEnable(GL_LIGHTING);// habilita la iluminación
glEnable(GL_LIGHT0);

Color_white[0]=1.0;     Color_white[1]=1.0;   Color_white[2]=1.0;   Color_white[3]=1.0;
Color_blue[0]=0.0;    Color_white[1]=0.0;   Color_white[2]=1.0;   Color_white[3]=1.0;

// Configura los puntos de luz
glLightfv(GL_LIGHT0,GL_POSITION,light0_pos);
glLightfv(GL_LIGHT0,GL_AMBIENT,Color_white);
glLightfv(GL_LIGHT0,GL_DIFFUSE,Color_white);
glLightfv(GL_LIGHT0,GL_SPECULAR,Color_white);


mat[0][0]=1.0;   mat[0][1]=1.0; mat[0][2]=1.0; mat[0][3]=1.0;

glEnable(GL_COLOR_MATERIAL);// Se habilita que respete el color de la forma como
glColorMaterial(GL_FRONT,GL_AMBIENT_AND_DIFFUSE); // el color del material

glMaterialfv(GL_FRONT,GL_SPECULAR,&mat[0][0]); // Se especifica la luz especular.
glMaterialfv(GL_FRONT,GL_SHININESS,shininess);

El brazo articulado.
Como se comento al inicio del reporte se desea dibujar un brazo articulado el cual esta constituido por tres piezas movibles y una base rotatoria y la transformación que se le haga a cada uno de los elementos desde la base debe afectar a todos los demás elementos hasta la punta, para esto se baso en ir aplicando las transformaciones entre dibujado y dibujado de cada parte del brazo, así las nuevas partes dibujadas heredaran las transformaciones anteriores. Para hacer esto se utilizo el siguiente código:


float h0=2,h1=5,h2=4,h3=4;

glMatrixMode (GL_MODELVIEW);
glPushMatrix();

RotaX(-90);

RotaZ(angulo1);
DibujaCilindro(2,2,h0,20,Color_blue);

RotaY(angulo2);
DibujaCilindro(.5,.2,h1,20,Color_blue);

RotaY(angulo3);
DibujaCilindro(.4,.2,h2,20, Color_blue);

RotaY(angulo4);
DibujaCilindro(.4,.2,h3,20, Color_blue);

glPopMatrix();

Donde Rotax, RotaX y RotaZ son funciones donde están implementadas las matrices de transformación de cada una de estas rotaciones.

Modificación desde el teclado.
En el código anterior se a mostrado como iluminar y dibujar un objeto en 3D, pero no se a explicado la manera en que se modifican las variables de donde se toman los valores para guiarse en el dibujado.

Estas instrucciones se hacen directamente desde el teclado modificando las variables de los parámetros usados anteriormente.


float step = 10;
switch (event->key()) {
case Qt::Key_Plus:
       signo = 1;
break;
case Qt::Key_Minus:
       signo = -1;
break;
case Qt::Key_Left:
       azi += step;
break;
case Qt::Key_Right:
azi -= step;
break;
case Qt::Key_PageDown:
zoom += 1;
break;
case Qt::Key_PageUp:
zoom -= 1;
break;
case Qt::Key_Up:
ele += step;
break;
case Qt::Key_Down:
ele -= step;
break;
case Qt::Key_T:
angulo1 += 10;
break;
case Qt::Key_G:
angulo1 -= 10;
break;
case Qt::Key_Y:
angulo2 += 10;
break;
case Qt::Key_H:
angulo2 -= 10;
break;
case Qt::Key_U:
angulo3 += 10;
break;
case Qt::Key_J:
angulo3 -= 10;
break;
case Qt::Key_I:
angulo4 += 10;
break;
case Qt::Key_K:
angulo4 -= 10;
break;
case Qt::Key_D:
lightXYZ[0] += .1;
break;
case Qt::Key_A:
lightXYZ[0] -= .1;
break;
case Qt::Key_W:
lightXYZ[1] += .1;
break;
case Qt::Key_S:
lightXYZ[1] -= .1;
break;
case Qt::Key_X:
lightXYZ[2] += .1;
break;
case Qt::Key_Z:
lightXYZ[2] -= .1;
break;
default:
        QWidget::keyPressEvent(event);
}
updateGL();

Mi carro con Degradados de colores

noreply@blogger.com (OnlyAngel.Net Place) — Wed, 28 Nov 2007 05:20:00 +0000

Mi carro con Degradados de colores
Dibujado de un carro en OpenGL utilizando ????
PDF File
Jose Angel Espinoza Portillo
Tarea 7 • Graficacion • 31 Octubre 2007

Bases

Se utilizara el mismo proyecto de la tarea 6 con la modificación que se le agregara el código necesario para que pueda ser mostrado con colores degradados.
OpenGL para dibujar una figura, necesita que se le proporcionen los vértices de la misma, y si quieres que la superficie de esta figura tenga algún color antes de escribir el primer vértice se debe especificar el color que tendrá con la función glColor3f especificando los valores de Rojo, Verde y Azul en niveles del 0 al 1.
Pero si se quiere hacer un degradado es tan fácil como asignarle u color diferente a cada nodo antes de cada glVertex3fv poner un glColor3f especificando el color del nodo y al momento de renderizar la aplicación el OpenGL automáticamente dibuja el degradado.

Implementación

Optimizaciones para dar un buen aspecto

Cada nodo es miembro de mas de una sola figura, así que para fines de presentación cada que se dibuje una figura que utilice un nodo compartido, este nodo tendrá el mismo color que tiene en las demás figuras a las que pertenece. Y para que no haya confusiones se hace esto con una matriz, en la cual se le asigna el color del nodo en sus valores de RVA (RGB en ingles) y mandando a dibujar. Esta matriz esta representada en el código de la siguiente manera.


 v2[0][0] = 0.0; v2[0][1] = 0.0; v2[0][2] = 0.0;
 v2[1][0] = 0.0; v2[1][1] = 0.0; v2[1][2] = 1.0;
 v2[2][0] = 0.0; v2[2][1] = 1.0; v2[2][2] = 1.0;
 v2[3][0] = 1.0; v2[3][1] = 0.0; v2[3][2] = 0.0;
 
 v2[4][0] = 1.0; v2[4][1] = 0.0; v2[4][2] = 1.0;
 v2[5][0] = 1.0; v2[5][1] = 1.0; v2[5][2] = 0.0;
 v2[6][0] = 1.0; v2[6][1] = 1.0; v2[6][2] = 1.0;
 v2[7][0] = 0.0; v2[7][1] = 0.0; v2[7][2] = 0.5;
 
 v2[8][0] = 0.0; v2[8][1] = 0.5; v2[8][2] = 0.0;
 v2[9][0] = 0.0; v2[9][1] = 0.5; v2[9][2] = 0.5;
 v2[10][0] = 0.5; v2[10][1] = 0.0; v2[10][2] = 0.0;
 v2[11][0] = 0.5; v2[11][1] = 0.0; v2[11][2] = 0.5;

 v2[12][0] = 0.5; v2[12][1] = 0.5; v2[12][2] = 0.0;
 v2[13][0] = 0.5; v2[13][1] = 0.5; v2[13][2] = 0.5;
 v2[14][0] = 0.3; v2[14][1] = 1.0; v2[14][2] = 0.8;
 v2[15][0] = 0.0; v2[15][1] = 0.0; v2[15][2] = 1.0;

Así se asigna para v2[n][0] el valore de rojo y para v2[n][1] y v2[n][2] los valores de Verde y Azul respectivamente. Este código se ingresa en el el constructor de la clase junto a v1.

Dibujado
A la hora del dibujado se implementa la explicacion dada en area de Bases, pero referenciando el numero de el nodo que se esta dibujando, como lo veremos a continuacion:


glBegin(GL_QUADS);   
        glColor3fv( &v1[0][0] );
        glVertex3fv( &v1[0][0] );
        glColor3fv(  &v1[1][0] );
        glVertex3fv( &v1[1][0] );
        glColor3fv(&v1[2][0] );
        glVertex3fv( &v1[2][0] );
        glColor3fv(  &v1[3][0]);
        glVertex3fv( &v1[3][0] );

        glColor3fv( &v1[8][0]  );
        glVertex3fv( &v1[8][0] );
        glColor3fv( &v1[9][0] );
        glVertex3fv( &v1[9][0] );
        glColor3fv( &v1[10][0] );
        glVertex3fv( &v1[10][0] );
        glColor3fv( &v1[11][0] );
        glVertex3fv( &v1[11][0] );

        glColor3fv( &v1[12][0] );
        glVertex3fv( &v1[12][0] );
        glColor3fv( &v1[13][0] );
        glVertex3fv( &v1[13][0] );
        glColor3fv( &v1[14][0] );
        glVertex3fv( &v1[14][0] );
        glColor3fv( &v1[15][0] );
        glVertex3fv( &v1[15][0] );

        glColor3fv( &v1[0][0] );
        glVertex3fv( &v1[0][0] );
        glColor3fv( &v1[3][0] );
        glVertex3fv( &v1[3][0] );
        glColor3fv( &v1[15][0] );
        glVertex3fv( &v1[15][0] );
        glColor3fv( &v1[12][0] );
        glVertex3fv( &v1[12][0] );
       
        glColor3fv( &v1[8][0] );
        glVertex3fv( &v1[8][0] );
        glColor3fv( &v1[4][0] );
        glVertex3fv( &v1[4][0] );
        glColor3fv( &v1[7][0] );
        glVertex3fv( &v1[7][0] );
        glColor3fv( &v1[11][0] );
        glVertex3fv( &v1[11][0] );

        glColor3fv( &v1[0][0] );
        glVertex3fv( &v1[0][0] );
        glColor3fv( &v1[1][0] );
        glVertex3fv( &v1[1][0] );
        glColor3fv( &v1[13][0] );
        glVertex3fv( &v1[13][0] );
        glColor3fv( &v1[12][0] );
        glVertex3fv( &v1[12][0] );
       
        glColor3fv( &v1[4][0] );
        glVertex3fv( &v1[4][0] );
        glColor3fv( &v1[5][0] );
        glVertex3fv( &v1[5][0] );
        glColor3fv( &v1[9][0] );
        glVertex3fv( &v1[9][0] );
        glColor3fv( &v1[8][0] );
        glVertex3fv( &v1[8][0] );

        glColor3fv( &v1[1][0] );
        glVertex3fv( &v1[1][0] );
        glColor3fv( &v1[2][0] );
        glVertex3fv( &v1[2][0] );
        glColor3fv( &v1[14][0] );
        glVertex3fv( &v1[14][0] );
        glColor3fv( &v1[13][0] );
        glVertex3fv( &v1[13][0] );
       
        glColor3fv( &v1[5][0] );
        glVertex3fv( &v1[5][0] );
        glColor3fv( &v1[6][0] );
        glVertex3fv( &v1[6][0] );
        glColor3fv( &v1[10][0] );
        glVertex3fv( &v1[10][0] );
        glColor3fv( &v1[9][0] );
        glVertex3fv( &v1[9][0] );
       
        glColor3fv( &v1[2][0] );
        glVertex3fv( &v1[2][0] );
        glColor3fv( &v1[3][0] );
        glVertex3fv( &v1[3][0] );
        glColor3fv( &v1[15][0] );
        glVertex3fv( &v1[15][0] );
        glColor3fv( &v1[14][0] );
        glVertex3fv( &v1[14][0] );
       
        glColor3fv( &v1[10][0] );
        glVertex3fv( &v1[10][0] );
        glColor3fv( &v1[11][0] );
        glVertex3fv( &v1[11][0] );
        glColor3fv( &v1[7][0] );
        glVertex3fv( &v1[7][0] );
        glColor3fv( &v1[6][0] );
        glVertex3fv( &v1[6][0] );
    glEnd();

Mi carro en Perspectiva

noreply@blogger.com (OnlyAngel.Net Place) — Wed, 28 Nov 2007 04:45:00 +0000

Mi carro en Perspectiva

Dibujado de un carro en OpenGL y su proyección en Perspectiva
PDF File
Jose Angel Espinoza Portillo
Tarea 5 • Graficacion • 31 Octubre 2007

Trabajo realizado

Se utilizaron unos códigos implementados en una tarea anterior donde ya esa declarada la estructura de datos para los nodos que dan la forma del carro y de las caras del mismo, ademas de un conjunto de funciones ya implementadas donde podemos modificar el código para utilizarlo para nuestros fines en este reporte.

Archivos los archivos importantes para este reporte son
painter.cpp: Donde se encuentra la interfaz de la ventana de visualización.
quad.cpp: Es en este archivo donde se visualiza el modelo y también donde se dibujan y modifican las matrices de transformación implementadas.

Trabajo a realizar
Para que un objeto pueda tener una proyección en perspectiva hay que generar el efecto de que una cámara lo esta rodeando. Esta es una transformación que se puede efectuar en la matriz del objeto o en la matriz de proyección. Pero se elige hacer la modificación directamente en el modelo, ya que es preferible modificar el modelo que la proyección ya que tiene mas espacio en su pila de matrices y hay menos posibilidades de errores.
Para eso se utilizara un método de entrada no utilizado antes en este curso. Que es el teclado para dar comandos, se designan algunas teclas para que se mueva hacia arriba, abajo y ambos lados al igual que un zoom para determinar el acercamiento o alejamiento del objeto desde el punto de vista.

El código

Modificaciones que se tienen que hacer a el código anterior.

Para poder implementar una vista en perspectiva, se tienen que eliminar a toda relación con la visualización ortográfica empezando por las funciones glOrtho que están ubicadas por todo el archivo quad.cpp.
Se declaran algunas variables las cuales definen la altura del punto de visión y el ángulo de rotación del mismo, ademas de una variable step la cual define la cantidad de moviendo que hay entre un estado y otro.
Se modifica la función keyPressEvent, la cual es la que responde a las entradas de comandos quedando como se muestra a continuación:


void Quad::keyPressEvent ( QKeyEvent * e )
{
float step = 10;
switch ( tolower(e->key()) ) {
 case '+':
     signo = 1;
     break;
 case '-':
     signo = -1;
     break;
 case 'a':
     azi -= step;
     break;
 case 's':
     ele -= step;
     break;
 case 'd':
     azi += step;
     break;
 case 'w':
     ele += step;
     break;
 case 'z':
     zoom += 1;
     break;
 case 'x':
     zoom -= 1;
     break;
}
repaint();
}

paintGL
En esta función se debe de hacer la transformación de el ángulo de visión y dibujar el objeto al final para que la transformación de perspectiva surja efecto. Para esto primero hay que hacer:


glMatrixMode (GL_PROJECTION);
glLoadIdentity ();

gluPerspective(30,1,0.01,100);

que carga la matriz defaul a GL_PROJECTION la carga y la asigna una perspectiva.
Luego se hacen los cálculos de el punto donde estará el ojo de visión y aplicarle la transformación a el GL_MODEL con el gluLookAt de la siguiente manera.


glMatrixMode(GL_MODELVIEW);
glLoadIdentity ();             /* clear the matrix */
eye[0] =  zoom *sin(azi*PI/180) * cos(ele*PI/180);
eye[1] =  zoom *sin(ele*PI/180) ;
eye[2] =  zoom *cos(azi*PI/180) * cos(ele*PI/180);
printf("%f %f %f\n",eye[0],eye[1],eye[2]);
gluLookAt(eye[0],eye[1],eye[2],0,0,0,0,1,0);

recordando que zoom, azi y ele están controlados por las teclas presionadas.
Esto debe de estar antes de dibujar el objeto ya que esto definirá la posición en que se dibujara el objeto en el espacio y en la pantalla.

Curbas cubicas paramétricas

noreply@blogger.com (OnlyAngel.Net Place) — Sat, 27 Oct 2007 02:00:00 +0000

Las curvas cubicas paramétricas son las de menor grado que no son planas en 3D. Los tres coeficientes de un polinomio de segundo grado pueden estar completamente especificados por tres puntos y tres puntos definen a un plano.

Los polinomios cúbicos que definen un segmento de cuva Q(t)=[x(t) y(t) z(t)] sonde la forma:

figura 01

Cada polinomio cubico tiene cuatro coeficientes, por lo que se requieren cuatro restricciones, que nos permitan formular cuatro ecuaciones en las cuatro incognitas y poder resolver el sistema de ecuaciones.

Las curbas que se discutiran son:
- Hermite
- Bezier
- Otros splines

* Hermite usa los punots terminales y los rectores tengente enlos puntos terminales

figura 02

* Bezier, esta definido por los dos puntos temrinales y otros dos puntos de control que controlan a los vecotes gtangente en lospuntos terminales

figura 03

Para ver como os coeficientes de la ec (1) pueden depender de cuatro restricciones, se escribe la matriz de coeficientes como

C = M.G
Donde M es la matriz base y G es un vector columna de cuatro elementos de las condiciones, tales como los puntos termianles y los vectores tangente , que definen a la curva.
Se usara G. para referirse al vector columna de solo los componentes x del vector de geometria.

Q(t) = T.C
4x3

C = M.G

Los elementos de M y G son constantes, de forma qeu el produto T.M.G es justo los tres polinomios cubicos en t
Q(t) = [x(t) y(t) z(t)]

figura 04

esta ecuacion enfatiza que la curva es una suma ponderada de los elementos de la matriz de geometria

B = T.M funciones mezcla (blending functions)

Splines Hermite
La curva esta determinada por los puntos terminales P1 y P4 y los vectores tangente R1 y R4 a los puntos teminales.
Tenemso que halar la matriz base Mh

Q(t) = T.Mh.Gh

Gh es el vector de geometria Hermite tomando su componente en x:

figura 05 (1)

figura 06 (2)

Las restricciones sobre x(0) y x(1) pueden encontrarse por sustitucion directa en la ec. (2).

figura 07

Pila de matrices

noreply@blogger.com (OnlyAngel.Net Place) — Fri, 26 Oct 2007 22:48:00 +0000

NOTA: Port falta de medios no puedo subir algunas figuras que se explican en el pizarron por eso solo pongo lo copiado en la computadora, lo siento.

void glPushMatrix(void)

Mete en la pila todas las matrices actuales. La pila usada esta determinada por gl MatrixMode(). Se copia la matriz en el tope de la pila de forma que su contenido se duplica tanto en el tope y la segunda matriz de la pila. Si se meten muchas matrices, se genera un error.

void glPopMatrix(void)

Saca la matrix tope de la pila, destruyendo el contenido de la matriz. la pila viada esta determinada por glMatrixMode(). Si la pila solo contiene una matriz, llamar esta función genera un error.

En el modo MODELVIEW tenemos al menos una pila de 32 matrices
En el modo PROJECTION tenemos al menos una pila de 2 matrices

Figura 01

Realmente la cámara no existe en OpenGL. Dentro del modo PROJECTION solo debe llamarse a LoadIdentity() para limpiar la matrix y a Ortho() o Frustrum(), (o a glePerspective())
Las transformaciones de la cámara realmente devén de realizarse en el modo MODELVIEW. Si no se hace así habrá problemas el calcular la iluminación y la niebla.
La transformacion para crear la proyección oblicua si debe de crearse en el modo PROJECTION.

Mi carro en OpenGL

noreply@blogger.com (OnlyAngel.Net Place) — Sat, 20 Oct 2007 08:08:00 +0000

Vercion en PDF

Mi carro en OpenGL

Dibujado de un carro en OpenGL y su proyección Ortogonal
Jose Angel Espinoza Portillo
Tarea 4 • Graficacion • 24 Octubre 2007

El FrameWork

Se utilizo un conjunto de códigos pre-configurados y listos para cargar una entidad de OpenGL en un widget de Qt, estos códigos fueron entregados por el Dr. Luis Gerardo de la Fraga y pude ser encontrado en el siguiente sitio: http://delta.cs.cinvestav.mx/~fraga/Cursos/Graficacion/2007/.
Algunas de las funciones ya implementadas son la rotación al dar click en el QGLWidget y arrastrar hacia alguna dirección.

Archivos

Utilizando el framework original de trabajo llamado “quad”. El cual contiene los archivos de código siguientes:

painter.cpp y painter.h: Implementación del QWidget es la ventana principal del sistema, aquí se implementan los botones, geometría, eventos y elementos que se observan en la ventana de la aplicación.
quad.cpp y quad.h: Implementa del QGLWidget que representa a el área en la cual se va a dibujar. Incluye funciones de trazado de inicialización de estados y de modos de renderización de el área de trazado.
main.cpp: Es el código que iniciativa la aplicación y le da la ejecución a el Qt para que interprete las instrucciones especificadas en canvas.cpp.

Diseño de el Carro

Especificación de las características de el carro y sus vértices.

Antes de empezar a programar hay que desarrollar una estructura de hilos para identificar la forma de el vehículo vista desde varios ángulos, y para especificar la dimensión de sus puntos (vértices).

De las estructuras anteriores se tomara la distancia de sus puntos desde un origen imaginario para definir un arreglo de vectores v1.

Definiendo el arreglo “v1”
Este arreglo se define en el archivo quad.h, para que pueda usarse en la clase, es inicializada en el constructor junto a su especificación con los puntos que en ella se representan de la siguiente manera.


Quad::Quad( QWidget *parent, const char *name )
...;
v1[0][0] = 0.0; v1[0][1] = 0.0; v1[0][2] = 4.0;
v1[1][0] = 5.0; v1[1][1] = 0.0; v1[1][2] = 4.0;
v1[2][0] = 5.0; v1[2][1] = 8.0; v1[2][2] = 4.0;
v1[3][0] = 0.0; v1[3][1] = 8.0; v1[3][2] = 4.0;

v1[4][0] = 1.0; v1[4][1] = 2.0; v1[4][2] = 4.0;
v1[5][0] = 4.0; v1[5][1] = 2.0; v1[5][2] = 4.0;
v1[6][0] = 4.0; v1[6][1] = 7.0; v1[6][2] = 4.0;
v1[7][0] = 1.0; v1[7][1] = 7.0; v1[7][2] = 4.0;

v1[8][0] = 1.25; v1[8][1] = 2.75; v1[8][2] = 5.25;
v1[9][0] = 3.75; v1[9][1] = 2.75; v1[9][2] = 5.25;
v1[10][0] = 3.75; v1[10][1] = 6.1; v1[10][2] = 5.25;
v1[11][0] = 1.25; v1[11][1] = 6.1; v1[11][2] = 5.25;

v1[12][0] = 0.0; v1[12][1] = 0.0; v1[12][2] = 1.0;
v1[13][0] = 5.0; v1[13][1] = 0.0; v1[13][2] = 1.0;
v1[14][0] = 5.0; v1[14][1] = 8.0; v1[14][2] = 1.0;
v1[15][0] = 0.0; v1[15][1] = 8.0; v1[15][2] = 1.0;
...;
}

Definiendo los valores en v1[n][o], v1[n][1] y v1[n][2] en los planos ‘x’, ‘y’ y ‘z’ respectivamente.

Dibujando el Carro
El arreglo anterior no es suficiente para que una figura sea dibujada en el espacio tridimensional, hay que indicarle a el OpenGL como debe unir los puntos anteriores y esto se hace como a continuación:


void Quad::paintGL(void){
...;
glBegin(GL_QUADS);
glColor3f( 1.0, 0.0, 0.0 );
glVertex3fv( &v1[0][0] );
glVertex3fv( &v1[1][0] );
glVertex3fv( &v1[2][0] );
glVertex3fv( &v1[3][0] );

glVertex3fv( &v1[8][0] );
glVertex3fv( &v1[9][0] );
glVertex3fv( &v1[10][0] );
glVertex3fv( &v1[11][0] );

glColor3f( 0.0, 1.0, 0.0 );
glVertex3fv( &v1[12][0] );
glVertex3fv( &v1[13][0] );
glVertex3fv( &v1[14][0] );
glVertex3fv( &v1[15][0] );

glColor3f( 1.0, 1.0, 1.0 );
glVertex3fv( &v1[0][0] );
glVertex3fv( &v1[3][0] );
glVertex3fv( &v1[15][0] );
glVertex3fv( &v1[12][0] );

glVertex3fv( &v1[8][0] );
glVertex3fv( &v1[4][0] );
glVertex3fv( &v1[7][0] );
glVertex3fv( &v1[11][0] );

glColor3f( 0.0, 0.0, 1.0 );
glVertex3fv( &v1[0][0] );
glVertex3fv( &v1[1][0] );
glVertex3fv( &v1[13][0] );
glVertex3fv( &v1[12][0] );

glVertex3fv( &v1[4][0] );
glVertex3fv( &v1[5][0] );
glVertex3fv( &v1[9][0] );
glVertex3fv( &v1[8][0] );

glColor3f( 1.0, 1.0, 0.0 );
glVertex3fv( &v1[1][0] );
glVertex3fv( &v1[2][0] );
glVertex3fv( &v1[14][0] );
glVertex3fv( &v1[13][0] );

glVertex3fv( &v1[5][0] );
glVertex3fv( &v1[6][0] );
glVertex3fv( &v1[10][0] );
glVertex3fv( &v1[9][0] );

glColor3f( 1.0, 0.0, 1.0 );
glVertex3fv( &v1[2][0] );
glVertex3fv( &v1[3][0] );
glVertex3fv( &v1[15][0] );
glVertex3fv( &v1[14][0] );

glVertex3fv( &v1[10][0] );
glVertex3fv( &v1[11][0] );
glVertex3fv( &v1[7][0] );
glVertex3fv( &v1[6][0] );
glEnd();
...;
}

Problemas

Al implementar el código anterior se detecto un problema con el eje de rotación y la orientación de los puntos, el dibujo se dibujaba como en esta figura:
Para solucionar estos problemas se le resto a todos los puntos la mitad del punto con mayor unidad de cada vértice y se intercambiaron los puntos de ‘z’ y ‘y’ con el siguiente código:


for (n=0;n<16;n++){ n="0;n<16;n++){" u =" v1[n][1];">

Calculando la proyección

Utilizando una matriz de transformación.

Principios matemáticos
Como fue visto en clase para hacer una proyección ortogonal es necesario un valor l para indicar la “Profundidad” visible del objeto y un ángulo a para designar la inclinación de la proyección y asignarlo a una matriz para especificar que transformación, la cual esta expresada en la Tabla (matriz) 01.

Tabla (matriz) 01

La cual multiplicada por la matriz de el objeto se dará el efecto deseado.

Implementación
Para la implementación de matrices en OpenGL se debe utilizar matrices tipo cuaternion que se implementa como un vector de 16 elementos de algún tipo en este caso GLfloat (que es una implementación de OpenGL que garantiza la potabilidad del tipo float en diferentes arquitecturas ) y se declara:

GLfloat matriz2[16];

Como básicamente es una matriz con ceros, se asignaron estos (los ceros) a todos los elementos y luego basandonos las posiciones de los indices señalados en la Tabla 02.

Tabla 02

Se escribió la matriz de la siguiente manera:


matriz2[0]=1;
matriz2[2]=-l*cos((angle*PI)/180);
matriz2[5]=1;
matriz2[6]=-l*sin((angle*PI)/180);
matriz2[15]=1;

Y luego antes de escribir el código de la representación de la figura escribir:


glMultMatrixf(matriz2);

Problema
Pero al implementar este código tal cual con las bases antes mencionadas encontrábamos otro problema, que era básicamente que no parecía dibujar nada en la pantalla, después de algunas comprobaciones matemáticas y con otros objetos nos percatamos de un patrón del error, el cual era básicamente la inversión de los indices de la matriz y fue en ese momento donde se descubrió que OpenGL no interpretaba los indices del cuaternion de la manera que inducimos sino como en la Tabla 03, y al final queda como a continuación:


matriz2[0]=1;
matriz2[8]=-l*cos((angle*PI)/180);
matriz2[5]=1;
matriz2[9]=-l*sin((angle*PI)/180);
matriz2[10] = 0.00001; /* Arregla un depth bug */
matriz2[15]=1;

Donde se usan l y angle que explicare a continuación.

Tabla 03

El painter

Dibujado de los componentes a utilizar

Se implementan por primera vez los objetos QSlider, para dar mas inter actividad a el sistema y conectandolo a unos SLOTS’s en el quad que modifican el valor de a (angulo) o l que se usan en el proceso de dibujado de el objeto en la ventana OpenGL.

Forma final de el Ejecutable

El cual tiene un switch entre la manipulación (Rotación) de el objeto que el Dr. de la Fraga tenia implementado originalmente con el nuevo objeto y la vista de la proyección del cuerpo. Los slides que modifican los valores de l y a (angulo).

Conclución

Es relativamente sencillo crear objetos 3D en OpenGL, pero lo que es complicado es la estructura que devén de tener los datos para su apropiado manejo.
Nunca seré un diseñador de autos.

En Defensa de la Ciencia

noreply@blogger.com (OnlyAngel.Net Place) — Fri, 19 Oct 2007 21:25:00 +0000

Ultima mente el estilo de vida y mi capacidad económica me a obligado a asomarme a unas "excelentes" librerías que existen en esta gran ciudad donde agrupan una gran cantidad de libros usados. Y después de no encontrar mucho en el área de sistemas me moví a la estantería y encontré un espécimen que me llamo la atención e inmediatamente lo tome con migo y me retire con el por la tremenda suma de $30.00 MN con un ejemplar escrito por el Doctor Rui Pérez Tamayo.

Dr. Ruiz Perez Tamayo
El Doctor Pérez Tamayo ha sido miembro de diferentes Sociedades Científicas, dentro de las que destacan el ser miembro extranjero del American College of Physicians; Fundador de la Asociación Mexicana de Patólogos; Sociedad de Becarios e Internos del Instituto Nacional de Cardiología; Sociedad Médica del Hospital General entre muchas otras, pero lo que me interesa de este personaje es que gano el premio nacional de ciencias, hace varios años (unos 20 mas o menos). Este libro es solo una de sus aportaciones a la cultura de el pais tratando de hacer una critica del estado de las ciencias en el momento en que fue publicado (1976).

Esta es una lectura que e empesado a leer en estos ultimos dias y espero si la escuela me lo permite terminarlo en un par mas para poder comentarlo extensivamente.

Dibujando un Reguilete

noreply@blogger.com (OnlyAngel.Net Place) — Tue, 02 Oct 2007 04:32:00 +0000

Vercion en PDF

Con QT y C++
Jose Angel Espinoza Portillo
Graficación
Septiembre - Octubre 2007

Preámbulo
Utilizando el framework original de trabajo llamado “linetest”. El cual contiene los archivos de código siguientes:

painter.cpp y painter.h: Implementación del QWidget es la ventana principal del sistema, aquí se implementan los botones, geometría, eventos y elementos que se observan en la ventana de la aplicación.

canvas.cpp y canvas.h: Implementa del QWidget que representa a el área en la cual se va a dibujar. Incluye funciones de trazado de lineas las cuales son la función en la que me base para dibujar el REGUILETE.

main.cpp: Es el código que iniciativa la aplicación y le da la ejecución a el Qt para que interprete las instrucciones especificadas en canvas.cpp.

Figura 1.

Insertar Botones a el FrameWork proporcionado
Se agrego el inicio del constructor de Painter::Painter() en painter.cpp


QPushButton *boton1 = new QPushButton("Direccion");
boton1->setFont( QFont( "Times", 18, QFont::Bold ) );
connect( boton1, SIGNAL(clicked()), canvas, SLOT(changeDirection()) );

QPushButton *boton2 = new QPushButton("Start/Stop");
boton2->setFont( QFont( "Times", 18, QFont::Bold ) );
connect( boton2, SIGNAL(clicked()), canvas, SLOT(switchMotioin()) );

Para crear la instancia en memoria de los botones con nombres boton1 y boton2.
Al final de la misma función se agrego:


leftBox->addWidget( boton1 );
leftBox->addWidget( boton2 );

Justo antes del “setLayout(grid);”, al compilar se vera una pantalla como en la Figura 1.

Comunicación entre el Canvas y el Painter
Este proceso a sido documentado anteriormente, así que me limito a agregar solo las modificaciones realizadas para este proyecto.
Se agregaron los Slots changeDirection y switchMotioin, para que puedan se accesados desde los botones del painter como se explico en el punto anterior y timeDone para se acezado desde un objeto QTimer, que se explicara a continuación.

Solucionando el Problema
Como un requisito de este problema es hacer que los reguiletes roten, se necesitó planear 3 partes:

Desarrollar una función drawReguilete a la cual le pasan por parámetros el numero de astas del reguilete y su centro y lo dibuja.

Agregar un QTimer para determinar el lapso para cambio de coordenadas rotación.

Programar las funciones que administren los estados de los últimos dos, puntos.

Desarrollando la función drawReguilete()
Basado en la implementación ya dada por el profesor para dibujar un destello la función de reguilete se implemento como sigue:


void Canvas::drawReguilete(int cx, int cy, int lados, QPainter *p){
int incrang = 360/lados; // Incremento del angulo para saber el angulo medio de cada hoja del reguilete
int l = 50; // Se define un largo l de las lineas de las hojas

int n = 360/incrang; //Se define el numero de repeticiones del algoritmo

for ( int i=0; isetPen(QColor("Blue"));
   MidPointLine( cx, cy, px, py, p ); // Se dibuja la linea superior
   MidPointLine( cx, cy, px2, py2, p );// Se dibuja la linea inferior
   MidPointLine( px2, py2, px, py, p );// Se dibuja la linea que une las anteriores para cerrarla
}
}

Agregando el QTimer
Esta es un objeto que te llama una función cada determinado tiempo que el programador le especifique, para implementarla en el código, se agrego la siguiente librería en canvas.cpp:


#include

y dentro del constructor Canvas::Canvas() se agrego el siguiente codigo:


tiempo = new QTimer(this);
connect( tiempo, SIGNAL(timeout()), this, SLOT(timeDone()));

El cual instancia en memoria el el objeto QTimer, en la variable tiempo, y la conecta en su SIGNAL timeout() al objeto canvas en su SLOT timeDone(), el cual se describe a continuación:


void Canvas::timeDone(){
angulo += (10 * direccion);
repaint();
}

En este código se puede ver que se presenta la variable dirección, esta es manejada por las funciones de administración de estados y define la dirección de rotación de los reguiletes, también se observa la variable ángulo que se usa en el dibujado de el reguilete, como el ángulo acumulado de rotación del sistema.

Funciones de administración de estados.
Las siguientes funciones son las que responden a los SLOTS changeDirection y switchMotioin las cuales administran el cambio de estados de el reguilete por medio de la variables globales dirección y tiempo.


void Canvas::changeDirection(){
 direccion *= -1;
}

void Canvas::switchMotioin(){
 if (tiempo->isActive()){
     tiempo->stop();
 }else{
     tiempo->start(400);
 }
}

En changeDirection solo se multiplica su contenido por -1 haciendo que a todo lo que sea multiplicado esta variable tendrá una dirección contraria a la original.
Y en switchMotioin se pregunta a tiempo si esta activo (si se esta ejecutando algún tonteo de lapsos), si es así lo detiene de lo contrario lo inicia.