Tarea 1. Transformaciones en 2D: Cuadricóptero

Problema

Realizar el cuadricóptero mostrado en la figura:

La aplicación en Qt y OpenGl debe realizar lo siguiente:

1. Con las flechas del teclado debe transladarse todo el cuadricóptero sobre la ventana de OpenGL. No debe salirse el cuadricóptero de la ventana.
2. Presionando la tecla "r" el cuadricóptero rota.
3. Presionando la tecla ESC, si las hélices no rotan, se ponen a rotar; si las hélices rotan, entones dejan de rotar. Chequen el sentido correcto de giro.

Análisis

Para resolver este problema se necesita el uso de las trasnformaciones báscias en 2D. Las transformaciones que se utilizarán son:

• Rotaciones: Se rota el objeto, tomando como punto de referencia el origen, un ángulo θ. Se denota por R(θ).
• Translaciones: Se mueve el objeto al punto (a,b), tomando como referencia el origen. Se denota por T(a,b).

Para realizar las transformaciones de manera adecuada, en especial las rotaciones, es recomendable transladar nuestro objeto al origen. Por lo tanto, para poder hacer esta translación, lo primero que se debe de definir es en dónde se encontrará el punto de referencia de nuestro objeto con respecto al origen, es decir, que posición tendra nuestro objeto cuando lo coloquemos en el origen. De manera natural el punto de referencia del cuadricóptero debería encontarse en el centro de masa del mismo, que se ubica en el centro del cuadrado. Esta será la convención que se utlizará para este trabajo.

Una vez que tenemos definida la posición que tendrá nuestro objeto en el orgien, se debe decidir cuáles transformaciones y en qué orden deben de realizarse para obtener los resultados deseados. Antes de continuar es importante notar que cada hélice del cuadricóptero, así como su base cuadrada, tendrán un comportamiento distinto, por lo que debemos realizar transformaciones diferentes, aunque similares, para cada uno de estos elementos. Esto nos deja con cinco elementos diferentes.

Sin embargo como conjunto, lo que se desea es llevar el cuaricóptero de una posición base en el origen, a nueva una posición (a,b). En esta nueva posición se tendrá además la base cuadrada rotada un ángulo θ y las aspas rotadas un ángulo α según la dirección y "velocidad de giro". Esta es la idea central, los detalles relativos a la implementación se detallarán más adelante.

Veamos las tranformaciones por elemento considerando que nuestro cuadricóptero se encuentra en el origen:

• Base cuadrada: Como su centro coincide, por nuestra convención, con el origen del sistema coordenado, se puede hacer la rotación en θ y posteriormente la translación a (a,b). Es decir, empleando la notación de clase: T(a,b) R(θ).
• Aspas: Si consideramos que la base cuadrada tiene por lado 2L, entonces las aspas tendrán, respectivamente, su centro en: (L,L), (-L,L), (-L,-L) y (L,-L). Se considera para este análisis un aspa con centro en (L,L). Para rotar de forma correcta el aspa respecto a su centro, debemos hacer primero una translación al origen T(-L,-L). Con esto podemos rotar un ángulo α o -α según la dirección que le corresponda a esa aspa de forma correcta. Para que se tenga un efecto de movimiento en caso de que α sea positivo, este ángulo debe ser diferente al ángulo θ, cuanto más diferente sea más se notará el efecto de giro de las aspas, tenemos entonces R(α). Finalmente regresamos el aspa a su posición en (L,L) con una translación T(L,L). Si pensamos en el cuadricóptero como conjunto, el aspa estaría en la posición indicada para rotase un ángulo θ al igual que la base, es decir R(θ).

  En resumen debemos hacer lo siguiente para cada aspa, según su posición incial y dirección de giro: R(θ) T(L,L) R(α) T(-L,-L)

  Una vez que se sabe que hacer se muestra acontinuación los detalles de la implementación en Qt y OpenGL.

Alternativa de Solución en Qt y OpenGL

La única diferencia importante respecto al análisis previo es que el objeto puede estar fuera del origen, para tener una referencia de donde está se definen las variables px, py. Con esto se debe hacer una translación previa del cuadricóptero al origen y al final de vuelta a su posición original, es decir:

• Base cuadrada: T(px,py) R(θ) T(L,L) R(α) T(-L,-L) T(-px,-py)
• Aspas: T(px,py) R(θ) T(L,L) R(α) T(-L,-L) T(-px,-py)

Para que el objeto no se salga de la pantalla hay que calcular los límites del sistema coordenado en OpenGL según las ecuaciones vistas en clase. Se define un tamaño máximo del centro del cuadricóptero a la punta de alguna de sus aspas y se restringe a que la posición (px,py) no se acerque a más de esta distancia a cualquiera de los límites del sistema. Se define de esta forma porque el cuadrícoptero podría ser llevado en su posición original a un punto límite, y si se rota estando ahí una parte de terminaría por salir de la pantalla, al restringir de esta forma se evita esa posibilidad.

Para controlar el giro automático de las aspas se utiliza un timer y una variable que indica si las aspas giran o no. El timer siempre esta activo y cada que se actualiza, verifica la variable de control de giro, en caso que deba girar aumenta el ángulo de giro de las aspas y si no no hace nada. La variable de control de giro para las aspas se controla con la tecla ESC. La base del cuadricóptero tiene también un grio automático controlado con la tecla "g".

Si se presiona la tecla "r" se aumenta el ángulo de la base y se actualiza una sola vez.

Las flechas de navegación modifican los valores de (px,py) según correspona y se actualiza.

Como se mencionó anteriormente se tienen cinco elementos distintos: cuatro aspas y una base cuadrada. Cada que se hace una transformación en el cuadricóptero, se debe usar una matriz identidad para cada elemento, por lo que se tienen cinco push() con sus respectivos cinco pop() para cada transformacion del cuadricóptero.

Estos son los detalles a grandes rasgos de la implementación. Por último se agrega el link de descarga del código fuente del programa: