necesito ayuda sobre barrido rotacional
wenas a todos, tengo que realizar una practica en opengl y c con el visual studio c++ y la practica dice lo siguiente:
El objetivo de esta segunda parte de la práctica consistirá en modelar utilizando
OpenGL nuevos objetos 3D mediante modelado por barrido rotacional.
El modelado por barrido es una técnica de modelado que consiste básicamente en:
1. Modelar en 2D (plano) una silueta o figura plana.
2. Definir un camino o trayectoria en el espacio 3D.
3. Hacer que la silueta 2D recorra el camino. Durante este recorrido o barrido, a
intervalos regulares, almacenamos los puntos 3D de la silueta en el espacio.
4. La correcta conexión de los puntos 3D almacenados configuran un conjunto de
polígonos que a su vez modelan un objeto 3D.
Por tanto, nuestro objetivo ahora será, utilizando el programa anterior, substituir el
modelo de la tetera por un nuevo objeto 3D modelado mediante un barrido rotacional.
El modelo se generará mediante la correcta especificación de un conjunto de vértices
entre el par de primitivas OpenGL glBegin y glEnd.
Veamos a continuación con más detalle las tareas a realizar:
7.1 La silueta 2D
El primer paso consiste en trazo de una figura 2D. El trazo se materializa mediante el
almacenamiento en un vector del conjunto de puntos 2D de la figura 2D.
Las estructuras de datos necesarias para ello podrían ser las siguientes:
typedef struct {
double x, y;
} punto2D;
punto2D * vectorPuntos;
vectorPuntos = (punto2D *) malloc(sizeof(punto2D) * numPuntos);
Cojamos, por ejemplo, la siguiente figura:
(0,0)
(1,1)
(0,0.1)
(0.4,0.1)
(0.1,0.2)
(0.1,0.4)
(0.2,0.5)
(0.3,0.7)
(1,0.3)
Estos valores podríamos introducirlos de la siguiente forma:
vectorPuntos[0].x = 0.0; // Una copa
vectorPuntos[0].y = 0.1;
vectorPuntos[1].x = 0.4;
vectorPuntos[1].y = 0.1;
vectorPuntos[2].x = 0.1;
vectorPuntos[2].y = 0.2;
vectorPuntos[3].x = 0.1;
vectorPuntos[3].y = 0.4;
vectorPuntos[4].x = 0.2;
vectorPuntos[4].y = 0.5;
vectorPuntos[5].x = 0.3;
vectorPuntos[5].y = 0.7;
vectorPuntos[6].x = 0.3;
vectorPuntos[6].y = 1.0;
7.2 El barrido rotacional
El primer paso para el barrido rotacional consiste en situar la silueta en el espacio
tridimensional. Una vez ubicada, llevamos a cabo el barrido rotacional. Para ello aplicaremos una
rotación a todos los puntos de la figura respecto al eje y. La matriz de rotación a aplicar
es la siguiente:
En el barrido rotacional, tenemos que decidir el número de pasos intermedios en los 2π
radianes de la circunferencia y que, en definitiva, definirán el número total de vértices
de la figura 3D generada.
Para almacenar los vértices, una posible estructura podría ser la siguiente:
typedef struct {
double x, y, z;
} punto3D;
punto3D * vectorVertices;
vectorVertices = (punto3D *) malloc(sizeof(punto3D) * numPuntos *
(numVertices + 1));
donde numPuntos es el número de puntos de la figura 2D y numVertices el
número de vértices que se generan por cada punto de la figura 2D7.
Para almacenar los polígonos, una posible estructura podría ser la siguiente:
typedef struct {
int v1, v2, v3, v4;
} poligono;
polígono * vectorPoligonos;
vectorPoligonos = (poligono *) malloc(sizeof(poligono) * numVertices *
(numPuntos - 1));
donde numPuntos y numVertices tienen el mismo significado que el descrito
anteriormente.
Trabajo a desarrollar:
Desarrollar el código necesario para inicializar el vectorVertices con los valores
adecuados surgidos por el barrido rotacional de la figura 2D vista anteriormente.
Hay que tener en cuenta que los vértices son puntos 3D y los puntos de la figura son
originalmente 2D. Una forma de rellenar el vectorVertices podría ser la siguiente:
k = 0;
for (i = 0; i < numPuntos; i++)
for (j = 0; j < numVertices + 1; j++) {
vectorVertices[k].x = ...
vectorVertices[k].y = ...
vectorVertices[k].z =...
k++;
}
Se ha dejado en puntos suspensivos el cálculo del vértice a partir del vector de puntos
de la figura 2D.
7.3 Visualización del resultado
Nuestro trabajo no termina con el cálculo y almacenamiento de los vértices. La
visualización del objeto 3D no es un proceso directo.
7 Cada punto 2D va a generar por rotación un total de numVertices puntos. Sumamos uno a
numVertices para facilitar su posterior visualización y que el primer punto quede también incluido
como último.
Partiendo del programa inicial, debemos substituir el dibujo de la tetera por una o varias
parejas de instrucciones glBegin y glEnd.
Mostrar el objeto 3D como un modelo alámbrico, implica el correcto lanzamiento del
dibujo de líneas a partir de los vértices almacenados.
Trabajo a desarrollar:
Revisar las diferentes posibilidades de glBegin, y decidir la forma de trazar el modelo
3D almacenado de forma que generemos una visualización del tipo alámbrico.
El caso es que no tengo ni idea de como comenzar a hacerlo, si alguien sabe la forma de hacerlo contestarme y ya nos ponemos en contacto y hablamos sobre el trabajo q he de realizar.
Muchas gracias por todo.
Crear cuenta