Computação Gráfica – Transformações Geométricas

1. Computação Gráfica – Transformações Geométricas Profa. Mercedes Gonzales Márquez

2. Transformação Geométrica Revisão sobre matrizes e vetores As três transformações geométricas básicas: Translação, Escala e Rotação. Tópicos

3. Transformação que altera algumas características como posição, orientação, forma ou tamanho das figuras geométricas no espaço. Apresentamos as três transformações básicas Transformação Geométrica y y y b b x x x c a c a Translação Escala Rotação

4. Revisão de matrizes e vetores Matrizes em Computação Gráfica • As matrizes são mais fáceis de usar e entender do que as equações algébricas • As matrizes são parecidas com o modelo organizacional da memória dos computadores • Matrizes quadradas de 2 x 2 – 2D (x,y) 3 x 3 – 3D (x,y,z)

5. Aritmética de Vetores e Matrizes • Adição : [1 2 3] + [2 0 1] = [3 2 4] • Subtração : [1 2 3] – [2 0 1] = [-1 2 2] • Multiplicação de uma matriz por um escalar: • Multiplicação entre matrizes:

6. Aritmética de Vetores e Matrizes • Multiplicação entre matrizes(exemplos) Possível Impossível Possível • Transposta de um vetor ou matriz:

7. Propriedades do Produto de Matrizes Associativa: A.(B.D) = (A.B).D. Distributiva à direita: A.(B + D) = A.B + A.D. Distributiva à esquerda: (A + B).D = A.D + B.D. Existência de elemento neutro: A.I = I.A = A. Uma matriz I de ordem n é uma matriz identidade, se ijk = 1, quando j = k e os outros elementos são nulos.

8. x x’ y y’ Transformações lineares: Translação Transladar significa movimentar o objeto. Transladamos um objeto transladando todos os seus pontos. Para obter a partir de um ponto (x,y) um novo ponto (x’,y’) no plano adicionamos quantidades às suas coordenadas. y b a = x c

9. Redução (0< sx, sy<1) , Aumento (sx,sy >1) x y x´ a´ = y´ Escalar significa mudar as dimensões de escala. Para isso multiplicamos os valores de suas coordenadas por um fator de escala. Transformações lineares: Escala y b a = x c

10. x´ x´ p' = y´ y´ r r r x y a Rotacionar significa girar. Na Figura abaixo mostra-se a rotação de um ponto p em torno da origem (0,0), passando para a posição p’. Transformações lineares: Rotação y r p q = a x Matriz de rotação no plano xy por um ângulo Ө x´ = x.cos q - y.sen q y´ = x.sen q + y.cos q

11. Resumo - Transformações 2D Translação Escala Rotação

12. Transformações 3D Translação Escala Rotação ao redor do eixo z

13. Rotações 3D y Plano xy Plano yz x Plano zx z

14. Rotação em torno de um ponto que não é a origem Caso de um objeto não estar definido na origem do sistema de coordenadas - A multiplicação de suas coordenadas por uma matriz de rotação também resulta em um translação. y y y (7,7) P (5,2) (9,2) x x x Em torno da origem Em torno de P

15. Rotação em torno de um ponto que não é a origem Para alterar a orientação de um objeto em torno de um certo ponto, é necessário, (1) realizar uma translação para localizar esse ponto na origem do sistema, (2) aplicar a rotação desejada e, (3) Aplicar uma translação inversa

16. Rotação em torno de um ponto que não é a origem y y y y P P x x (1) (2) (3) Objeto original Depois da Translação de Após Rotação Após Translação que P à origem retorna à posição original

17. Coordenadas homogêneas • Translação não é linear. Como representar em forma de matriz? x’=x+tx y’=y+ty z’=z+tz • Solução: uso de coordenadas homogêneas

18. Coordenadas Homogêneas • Adiciona uma terceira coordenada w. • Um ponto 2D passa a ser um vetor com 3 coordenadas • Uma transformação do sistema homogêneo para o cartesiano se dá pela seguinte relação: (x’,y’)=(x/w,y/w) • W=1 a transformação entre os espaços é direta de modo que, (x,y,1) no sistema homogêneo tem os mesmos valores no espaço cartesiano 2D: (x,y).

19. Transformações 3D

20. Transformações 3D Rotação : glRotatef(angle,x,y,z) y Plano xy Plano yz x Plano zx z

21. Analogia da Câmera (OpenGL) • O processo de transformação para produzir a cena desejada para visualização é análogo a tirar uma foto com uma câmera.

22. A Câmera OpenGL • O modelo de visualização em OpenGL, é similar a uma câmera fotográfica! • Tripé: visualização • Modelo: modelagem • Lente: projeção • Papel: viewport

23. Analogia da Câmera (OpenGL) • O processo de transformação para produzir a cena desejada para visualização é análogo a tirar uma foto com uma câmera. Os passos são: • 1. Orientar a câmera em direção da cena (transformação de visualização) • 2. Posicionar devidamente o(s) objeto(s), a serem fotografados, no cenário (transformações geométricas estudadas em aula, também chamadas transformações de modelagem). • 3. Escolher o lente da câmera ou ajustar o zoom (transformação de projeção). • 4. Determinar o tamanho desejado para a fotografia final (transformação de viewport).

24. Orientar a câmera em direção da cena (transformação de visualização)

25. Orientar a câmera em direção da cena (transformação de visualização) A câmera em OpenGL “por default” tem sua posição na origem de coordenadas (0,0,0) e a sua orientação é com vetor up=(0,1,0). Existem três opções para mudar sua posição e orientação: (1) Usar glTranslate*() e glRotate*(). Move a camera ou move todos os objetos em relação a uma camera fixa; (2) gluLookAt()

26. Visualizando devidamente o objeto (Exemplo) • Objeto e câmera na origem

27. Visualizando devidamente o objeto Com a câmera na origem (0,0,0) não posso visualizar devidamente um objeto na posição (0,0,0) Para visualizá-lo tenho duas opções: (a) Mudar a câmera, ou (b) Mudar o objeto

28. Usando glTranslate() e glRotate() (b) Mudando o objeto glTranslatef(0.0, 0.0, -5.0);

29. Usando gluLookAt (a) Mudando a câmera gluLookAt(eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz)

30. gluLookAt • A cena é construída na origem e definimos uma posição arbitrária para a câmera • void gluLookAt (eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz); • Eye: localização da camera • Center: para onde a camera aponta • Up: vetor de direção de topo da camera

31. gluLookAt

32. Exemplo – Cubo (Programa cube.c) Um cubo é escalado pela transformação de modelagem glScalef (1.0, 2.0, 1.0). A transformação de visualização gluLookAt(), posiciona e orienta a câmera em direção do cubo. As transformações de projeção e viewport são também especificadas.

33. Exemplo – Cubo (Programa cube.c) • Example 3-1 : Transformed Cube: cube.c #include <GL/gl.h> #include <GL/glu.h> #include <GL/glut.h> void init(void){ glClearColor (0.0, 0.0, 0.0, 0.0); glShadeModel (GL_FLAT); }

34. Exemplo – Cubo (Programa cube.c) void display(void){ glClear (GL_COLOR_BUFFER_BIT); glColor3f (1.0, 1.0, 1.0); glLoadIdentity (); /* clear the matrix */ /* viewing transformation */ gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); glScalef (1.0, 2.0, 1.0); /* modeling transformation */ glutWireCube (1.0); glFlush (); }

35. Exemplo – Cubo (Programa cube.c) void reshape (int w, int h){ glViewport (0, 0, (GLsizei) w, (GLsizei) h); glMatrixMode (GL_PROJECTION); glLoadIdentity (); glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0); glMatrixMode (GL_MODELVIEW); }

36. Exemplo – Cubo (Programa cube.c) int main(int argc, char** argv){ glutInit(&argc, argv); glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); glutInitWindowSize (500, 500); glutInitWindowPosition (100, 100); glutCreateWindow (argv[0]); init (); glutDisplayFunc(display); glutReshapeFunc(reshape); glutMainLoop(); return 0; }

37. Matrizes de transformação • glMatrixMode(GL_MODELVIEW); - Define a matriz de transformação de visualização. Após isso deve-se definir a câmera com gluLookAt ou definir as transformações geométricas glRotate e/ou glTranslate para orientar e posicionar os objetos em relação da câmera.

38. Pilha de Matrizes – Hierarquia de objetos As vezes queremos construir objetos hierarquicos nos quais objetos complicados são construidos a partir de objetos mais simples. Por exemplo, • Uma mesa ou • um automovel com 4 rodas onde cada uma delas é ligada ao carro com cinco parafusos. • O corpo humano

39. Pilha de Matrizes – Hierarquia de objetos Tronco Coxa Canela Pé

40. Pilha de Matrizes – Hierarquia de objetos Os passos para desenhar um carro serião: • Desenhe o corpo do carro. • Guarde a posição onde estamos e translade à direita a roda da frente. • Desenhe a roda e elimine a última translação talque a posição corrente esteja de volta na origem do carro. • Guarde a posição onde estamos e translade à esquerda a roda da frente .... Assim, para cada roda, desenhamos a roda, guardamos a posição onde estamos, e sucessivamente transladamos a cada uma das posições que os parafusos são desenhados, eliminamos as transformações depois que cada parafuso é desenhado.

41. Pilha de Matrizes – Hierarquia de objetos glPushMatrix glPopMatrix

42. Pilha de Matrizes – Hierarquia de objetos Desenhe um automovel asumindo que existem as rotinas que desenham o corpo do carro, a roda e o parafuso. Example 3-4 : Pushing and Popping the Matrix draw_wheel_and_bolts(){ long i; draw_wheel(); for(i=0;i<5;i++){ glPushMatrix(); glRotatef(72.0*i,0.0,0.0,1.0); glTranslatef(3.0,0.0,0.0); draw_bolt(); glPopMatrix(); }}

43. Pilha de Matrizes – Hierarquia de objetos draw_body_and_wheel_and_bolts(){ draw_car_body(); glPushMatrix(); glTranslatef(40,0,30); /*move to first wheel position*/ draw_wheel_and_bolts(); glPopMatrix(); glPushMatrix(); glTranslatef(40,0,-30); /*move to 2nd wheel position*/ draw_wheel_and_bolts(); glPopMatrix(); ... /*draw last two wheels similarly*/ }

44. Formas geométricas tridimensionais As formas geométricas tridimensionais que mais usaremos e que a Glut fornece são: void glutWireSphere(GLdouble radius, GLint slices, GLint stacks); • void glutSolidSphere(GLdouble radius, GLint slices, GLint stacks); • void glutWireCube(GLdouble size); • void glutSolidCube(GLdouble size); • void glutWireTorus(GLdouble innerRadius, GLdouble outerRadius,GLint nsides, GLint rings); • void glutSolidTorus(GLdouble innerRadius, GLdouble outerRadius,GLint nsides, GLint rings);

45. Formas geométricas tridimensionais • void glutWireIcosahedron(void); • void glutSolidIcosahedron(void); • void glutWireOctahedron(void); • void glutSolidOctahedron(void); • void glutWireTetrahedron(void); • void glutSolidTetrahedron(void); • void glutWireDodecahedron(GLdouble radius); • void glutSolidDodecahedron(GLdouble radius); • void glutWireCone(GLdouble radius, GLdouble height, GLint slices,GLint stacks); • void glutSolidCone(idem); • void glutWireTeapot(GLdouble size); • void glutSolidTeapot(GLdouble size);

46. Exercício • Faça um programa C/OpenGL que desenhe uma mesa retangular, a partir de cubos (glutWireCube) e transformações de modelagem. • Oriente devidamente a câmera, de forma que obtenhamos as seguintes imagens da mesa: (a) (b) (c) (d)