CG-transformações
Download
Report
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)
vw
1
v , w 3
2
vw
vw
T
4
wv
Possível
wv
Impossível
1
3
v , w
2
4
vw
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)