Transcript CG-transformações

Computação Gráfica –
Transformações Geométricas
Profa. Mercedes Gonzales
Márquez
Tópicos



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.
Transformação Geométrica


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
y
y
b
b
c
y
a
Translação
x
c
Escala
a
x
x
Rotação
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)
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:
2


2
2
1

4
0
4  1
 
 8  1
2
0
2 

 4
Multiplicação entre matrizes:
1

3
2 7

4 5
6 1 x 7  2 x 5

0 3 x 7  4 x 5
1 x 6  2 x 0   17

3 x 6  4 x 0   41
6

18 
Aritmética de Vetores e Matrizes

Multiplicação entre matrizes(exemplos)
vw 
1 
v    , w  3
2
vw 
vw
T

4
wv 
Possível
wv 
Impossível
1
3
v   , w   
2
4
vw
T

Possível
T

Transposta de um vetor ou matriz:
1 
   1
2
2
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.
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.
x’
y’
y
b
a=
x'  x  t x ,
x
y
c
x
y'  y  t y
Transformações lineares: Escala
Escalar significa mudar as dimensões de escala. Para
isso multiplicamos os valores de suas coordenadas por
um fator de escala.
Redução (0< sx, sy<1) ,
Aumento (sx,sy >1)
y
b
a=
x'  s x x ,
x
y'  s y y
y
c
a´=
x´
x
y´
 x'  sx x  sx
 
   
s y
y
'
   y  0
0 
 
s y 
x

y
sx
S  
0
0

sy 
Transformações lineares: Rotação
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’.
y
p'
x´
=
y´
sin( a  q )  sin a  cos q  cos a  sin q
r
qr
a
p
=
cos( a  q )  cos a  cos q - sin a  sin q
x
y
x
x´ = x.cos q - y.sen q
y´ = x.sen q + y.cos q
 x '   r cos( a  q ) 
   

 y '   r sin( a  q ) 
 x '   cos q
   
 y '   sin q
 r cos a  cos q  r sin a sin q
 
 r sin a  cos q  r cos a  sin q
 sin q   x 
  
cos q   y 



Matriz de rotação no
plano xy por um
ângulo Ө
Resumo - Transformações 2D
Translação
 x '  x 
   
 y '  y 
Escala
 x '  s x
   0
 y ' 
Rotação
 x '   cos q
 
 y '  sin q
 tx 
 
 ty 
0 x
 
sy  y
 sin q   x 
 
cos q   y 
Transformações 3D
Translação
Escala
Rotação ao redor
do eixo z
 x '   x   tx 
 y '   y    ty 
     
 z '   z   tz 
 x '  s x
 y '   0
  
 z '   0
 x '   cos q
 y '   sin q
  
 z '   0
0
sy
0
0 x
 
0 y
 
s z   z 
 sin q
cos q
0
0  x 
 
0 y
 
1   z 
Rotações 3D
 cos q

R z (q ) : sen q

 0
y
Plano
xy
Plano
yz
Plano zx
z
x
 sen q
cos q
0
 cos q

R y (q ) :
0

  sen q
1

R x (q ) : 0

 0
0

0

1 
0
1
0
0
cos q
sen q
sen q 

0

cos q 


 sen q

cos q 
0
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)
x (9,2)
x
Em torno
da origem
x
Em torno
de P
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
Rotação em torno de um ponto que não é a origem
y
y
y
y
P
P
x
x
(1)
Objeto original
Depois da Translação de
P à origem
(2)
Após Rotação
(3)
Após Translação que
retorna à posição
original
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
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).
Transformações 3D
Transformações 3D
 cos q

sen q

R z (q ) :
 0

 0
Rotação :
y
glRotatef(angle,x,y,z)
Plano
xy
Plano
yz
Plano zx
z
x
 sen q
0
cos q
0
0
1
0
0
 cos q

0

R y (q ) :
  sen q

0

1

0

R x (q ) :
0

0
0
sen q
1
0
0
cos q
0
0
0
0
cos q
 sen q
sen q
cos q
0
0
0

0

0

1
0

0

0

1
0

0

0

1
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.
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
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).
Orientar a câmera em direção da cena
(transformação de visualização)
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()
Visualizando devidamente o objeto
(Exemplo)

Objeto e câmera
na origem
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
Usando glTranslate() e glRotate()
(b) Mudando o objeto
glTranslatef(0.0, 0.0, -5.0);
Usando gluLookAt
(a) Mudando a câmera
gluLookAt(eyex, eyey, eyez,
centerx, centery, centerz,
upx, upy, upz)
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
gluLookAt
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.
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);
}

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 ();
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);
}
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();
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.
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,
(a)Uma mesa ou
(b)um automovel com 4 rodas onde cada uma
delas é ligada ao carro com cinco parafusos.
(c)O corpo humano
Pilha de Matrizes – Hierarquia de objetos
Tronco
Coxa
Canela
Pé
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.
Pilha de Matrizes – Hierarquia de objetos
glPushMatrix
glPopMatrix
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();
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*/
}
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);
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);
Exercício
(1)Faça
um programa C/OpenGL que desenhe uma mesa
retangular, a partir de cubos (glutWireCube) e
transformações de modelagem.
(2)Oriente devidamente a câmera, de forma que obtenhamos
as seguintes imagens da mesa:
(a)
(b)
(c)
(d)