Вы находитесь на странице: 1из 44

Cap.

3:
Transformaes
Geomtricas
Ensino de Informtica (3326) - 4 ano, 2 semestre
Engenharia Electrotcnica (2287) - 5 ano, 2 semestre
Engenharia Informtica (2852) - 4 ano, 2 semestre

1
Sumrio
Motivao.
Transformaes mtricas euclidianas: translao e rotao.

Geometria mtrica euclidiana.

Coordenadas homogneas.

Transformaes afins: translao, rotao, variao de tamanho e cisalhamento.

Representao matricial de transformaes afins.

Composio de transformaes geomtricas 2D e 3D.

Transformaes afins em OpenGL.

Operaes com matrizes em OpenGL e transformaes geomtricas arbitrrias.

Exemplos em OpenGL.

2
Motivao

Transformaes geomtricas
Translao, Rotao, Reflexo
Variao de Tamanho (scaling), Cisalhamento (shearing)
Projeco Ortogonal, Projeco Perspectiva

Motivao Porque que as transformaes


geomtricas so necessrias?
Como operaes de posicionamento de objectos em 2D e 3D.
Como operaes de modelao de objectos em 2D e 3D.
Como operaes de visualizao em 2D e 3D.

3
Motivao (cont.):
modelao de objectos em 2D
Transformaes geomtricas podem especificar
operaes de modelao de objectos
Permitem a definio dum objecto no seu prprio sistema de
coordenadas locais (modeling coordinates ou coordenadas de
modelao)
Permite usar a definio dum objecto vrias vezes numa cena com um
sistema de coordenadas globais (world coordinates ou coordenadas do
domnio da cena)
A OpenGL fornece uma pilha de transformaes que
permite a sua utilizao frequente

4
Motivao (cont.):
modelao de objectos em 2D

Variao de Tamanho
Rotao
Translao

Coordenadas Globais
x Variao de Tamanho (world coordinates)
Coordenadas Locais Translao
(modeling coordinates)

5
Motivao (cont.):
modelao de objectos em 2D
Coordenadas Locais Coordenadas
y Globais

x y

Posicionamento
x

Variao de Tamanho

y
6
x
Motivao (cont.):
modelao de objectos em 2D
Coordenadas Locais Coordenadas
y Globais

Rotao
y
x

Translao
y
x

7
Translao 2D
x=x+x
y=y+y

Transladar um ponto (x, y) significa desloc-lo de uma quantidade de


movimento linear (x,y).

x=2
y=1

8
http://encyclopedia.laborlawtalk.com/Linear_combination

Translao 2D: forma matricial

x ' x x
y' = y + y

x no uma combinao linear de x e y


y no uma combinao linear de x e y

9
Rotao 2D
(x, y) x ' = x cos ysin

y' = x sin + y cos

(x, y)

Rodar um ponto P=(x,y) de um


ngulo relativamente origem
significa encontrar outro ponto
Q=(x,y) sobre uma circunferncia
centrada na origem que passa
pelos dois pontos, com =POQ.
10
Rotao 2D: clculo de equaes
(x, y) x = r cos x ' = r cos( + )

y = r sin y' = r sin( + )

Desenvolvendo as expresses de
(x, y) x e y, tem-se:
x ' = r cos cos r sin sin

y' = r cos sin + r sin cos
Substituindo r cos() e r sin() por
x e y nas equaes anteriores
tem-se:
x ' = x cos ysin

y' = x sin + y cos
11
Rotao 2D: forma matricial

x ' cos sin x


y' = sin cos y

Embora sin() e cos() sejam funes no-lineares de ,


x uma combinao linear de x e y
y uma combinao linear de x e y

12
http://www.geom.uiuc.edu/docs/reference/CRC-formulas/node6.html

Coordenadas homogneas
Um triplo (x,y,t) de nmeros reais com
t0, um conjunto de coordenadas
homogneas para o ponto P com
coordenadas cartesianas (x/t,y/t). P t
y
Portanto, o mesmo ponto tem muitos Q
conjuntos de coordenadas t =1
homogneas. Assim, (x,y,t) e (x,y,t)
representam o mesmo ponto sse existe O x
algum escalar tal que x= x, y= y e
t= t.
Se P tem as coordenadas cartesianas
(x,y), um dos seus conjuntos de
coordenadas homogneas (x,y,1),
conjunto este que usado em
computao grfica.

13
Problema fundamental das
transformaes
O facto de a translao no ser uma transformao linear de x e y
impede que se possa efectuar uma srie de transformaes
(translaes e rotaes por ordem arbitrria) atravs do produto de
matrizes 2x2.
Repare-se que possvel, no entanto, fazer k rotaes atravs do
produto de k matrizes de rotao.
SOLUO: coordenadas homogneas!

14
Translao 2D e Rotao 2D:
coordenadas homogneas

x ' 1 0 x x
Translao y' = 0 1 y y

1 0 0 1 1

x ' cos sin 0 x


Rotao y' = sin cos 0 y

1 0 0 1 1

15
http://planetmath.org/encyclopedia/Geometry.html

Geometria mtrica euclidiana


Conjunto de transformaes geomtricas: translaes e rotaes (tambm
designadas por isometrias).
Com o uso de coordenadas homogneas, as transformaes da geometria mtrica
podem ser representadas por matrices 3x3, o que permite usar o operador produto
para encontrar uma matriz de transformao que resulta da concatenao arbitrria de
translaes e rotaes.
O conjunto I(n) de isometrias em Rn e o operador de concatenao formam um grupo
GI(n)=(I(n),).
Invariante mtrico fundamental:
distncia entre pontos.

Outros invariantes mtricos:


ngulos
comprimentos
reas
volumes

Geometria euclidiana 2-dimensional: (R2,GI(2)) 16


Definio de grupo: lembrete
Um conjunto C e uma operao formam um grupo (C, ) se:

Axioma de Fecho. Para quaisquer elementos c1,c2C, c1 c2 C.


Axioma de Identidade. Existe um elemento identidade i C tal que c i=c=i c,
para qualquer c C.
Axioma de Elemento Inverso. Para qualquer c C, existe um inverso c-1 C tal
que
c c-1 = i = c-1 c
Axioma de Associatividade. Para quaisquer elementos c1 ,c2 ,c3 C,
c1 (c2 c3) = (c1 c2) c3

17
http://planetmath.org/encyclopedia/Geometry.html

Geometria afim
uma generalizao da geometria euclidiana.
Conjunto de transformaes afins (ou afinidades): translao, rotao, variao de
tamanho (scaling) e cisalhamento (shearing).
O conjunto A(n) de afinidades em Rn e o operador de concatenao formam um
grupo GA(n)=(A(n),).
Invariante fundamental:
paralelismo.

Outros invariantes:
razo de distncias entre quaisquer trs pontos pertencentes a uma linha
colinearidade

Exemplos:
um quadrado pode ser transformado num rectngulo
uma circunferncia pode ser transformada numa elipse

Geometria afim 2-dimensional: (R2,GA(2))


18
Variao de tamanho 2D
x ' = x x

y' = y y
Variar o tamanho dum objecto multiplicar cada componente de cada um
dos seus pontos (x,y) por um escalar.

x = 2
y = 2

19
Variao de tamanho no-uniforme
x ' = x x x y
com

y' = y y
Variar o tamanho dum objecto multiplicar cada componente de cada um
dos seus pontos (x,y) por um escalar.

x = 2
y = 0.5

20
Cisalhamento
x ' = x + x y

y' = y + y x
Cisalhar um objecto deform-lo linearmente ao longo do eixo x ou do
eixo y ou de ambos.

x = 1
y = 0

21
S transformaes lineares podem ser representadas por uma matriz 2x2

Resumo: representao matricial


3x3 de transformaes afins 2D

x ' 1 0 x x x ' x 0 0 x
y' = 0 1 y y y' = 0 y 0 y

1 0 0 1 1 1 0 0 1 1

Translao Variao de Tamanho

x ' cos sin 0 x x ' 1 x 0 x


y' = sin 0 y y' =
cos
y 1 0 y
1 0 0 1 1 1 0 0 1 1

Rotao Cisalhamento
22
Composio de transformaes
afins 2D
O operador de composio o produto de matrizes.
uma consequncia do Axioma da Associatividade da geometria
afim e da dimenso 3x3 das matrizes associadas s transformaes
afins 2D.
ATENO:
A ordem de composio de transformaes afins relevante.
O produto de matrizes no uma operao comutativa.
A geometria afim no satisfaz o Axioma da Comutatividade.

Exemplo:
x ' 1 0 x cos sin 0 x 0 0 x
y' = 0 1 y sin cos 0 0 y 0 y

1 0 0 1 0 0 1 0 0 1 1 23
Exemplo: rotao = 30 dum
segmento PQ em torno de P(2,0)

P
P P

Incorrecto Correcto
Rot(30) Tr(-2) Rot(30) Tr(2)

24
Exemplo: rotao = 30 dum
segmento PQ em torno de P(2,0)

P P P P

x ' 1 0 2 cos sin 0 1 0 2 x


y' = 0 1 0 sin cos 0 0 1 0 y

1 0 0 1 0 0 1 0 0 1 1

25
Transformaes afins 3D
x ' 1 0 0 0 x x ' x 0 0 0 x
y' 0 1 0 0 y y' 0 y 0 0 y
= =
z ' 0 0 1 0 z z ' 0 0 z 0 z

1 0 0 0 1 1 1 0 0 0 1 1

Identidade Variao de Tamanho

x ' 1 0 0 x x x ' 1 0 0 0 x
y' 0 1 0 y y y' 0 1 0 0 y
= =
z ' 0 0 1 z z z ' 0 0 1 0 z

1 0 0 0 1 1 1 0 0 0 1 1

Translao Reflexo
relativamente ao plano YZ 26
Outras transformaes afins 3D
x ' cos sin 0 0 x
y' sin cos 0 0 y
Rotao em torno do eixo Z =
z ' 0 0 1 0 z

1 0 0 0 1 1

x ' cos 0 sin 0 x


y' 0 1 0 0 y
Rotao em torno do eixo Y =
z ' sin 0 cos 0 z

1 0 0 0 1 1

x ' 1 0 0 0 x
y' 0 cos sin 0 y
Rotao em torno do eixo X =
z ' 0 sin cos 0 z

1 0 0 0 1 1
27
Transformaes afins em OpenGL

H duas formas de especificar uma transformao :


Transformaes geomtricas pr-definidas: glTranslate, glRotate e glScale.

Transformaes geomtricas arbitrrias atravs de especificao directa de matrizes:


glLoadMatrix, glMultMatrix

Transformaes geomtricas so efectuadas pela matriz de


modelao e visualizao (modelview).
Para operacionalizar estas transformaes geomtricas, h que
designar a matriz modelview como a matriz corrente atravs da
instruo glMatrixMode(GL_MODELVIEW).
A OpenGL tem uma pilha para cada um dos quatro tipos de
matrizes: modelao e visualizao (modelview), projeco
(projection), textura (projection) e cor (color).
A pilha modelview inicializada com a matriz identidade. 28
Transformaes afins pr-definidas
em OpenGL
glTranslate{f,d}(dx, dy, dz)
Especifica uma translao segundo o vector (dx,dy,dz), em que as componentes
so nmeros reais de preciso simples f ou dupla d.

glRotate{f,d}(angle, vx, vy, vz)


Especifica uma rotao de angle graus em torno do eixo definido pelo vector
(vx,vy,vz) na origem.

Note-se que esta funo define uma rotao geral relativamente a um eixo que
passa pela origem.

glScale{f,d}(sx, sy, sz)


Especifica uma variao de tamanho segundo cada um dos eixos de coordenadas.

Esta funo pode ser usada para fazer reflexes usando valores negativos nos
factores de escala sx, sy ou sz.

ATENO: se algum factor de escala for zero, pode ocorrer um erro de


processamento. 29
Operaes com matrizes
em OpenGL
glLoadIdentity()
Especifica a matriz identidade como a matriz de topo da pilha corrente. A
matriz de topo duma pilha sempre a matriz corrente.

glLoadMatrix{f,d}(<array>)
Especifica a matriz corrente atravs dum array 1-dimensional com 16
elementos dados na ordem de coluna-a-coluna.

glMultMatrix{f,d}(<array>)
Multiplica a matriz corrente M com a matriz N dada pelos elementos
fornecidos pelo array 1-dimensional: M=M.N

30
Exemplo: produo da matriz
.
modelview M=M2 M1
A sequncia de instrues a seguinte
glLoadIdentity();

glMultMatrixf(<array of M2>);

glMultMatrixf(<array of M1>);

Note-se que a primeira transformao efectuada a ltima que


especificada.

31
Exemplos em OpenGL

Transformaes afins com acumulao


Transformaes afins sem acumulao
Transformaes afins com acumulao controlada pela stack

32
Transformaes 2D
c/ acumulao
/* * quad.cc - Cumulative 2D transformations * Abel Gomes */
#include <OpenGL/gl.h> // Header File For The OpenGL Library
#include <OpenGL/glu.h> // Header File For The GLu Library
#include <GLUT/glut.h> // Header File For The GLut Library
#include <stdlib.h>

void draw(){
// Make background colour yellow
glClearColor( 100, 100, 0, 0 );
glClear ( GL_COLOR_BUFFER_BIT );
// modelview matrix for modeling transformations
glMatrixMode(GL_MODELVIEW);
// x-axis
glColor3f(0,0,0);
glBegin(GL_LINES);
glVertex2f(0.0,0.0);
glVertex2f(0.5,0.0);
glEnd();
// y-axis
glColor3f(0,0,0);
glBegin(GL_LINES);
glVertex2f(0.0,0.0);
glVertex2f(0.0,0.5);
glEnd(); 33
Transformaes 2D
c/ acumulao (cont.)
// RED rectangle
glColor3f( 1, 0, 0 );
glRectf(0.1,0.2,0.4,0.3);
// Translate GREEN rectangle
glColor3f( 0, 1, 0 );
glTranslatef(-0.4, -0.1, 0.0);
glRectf(0.1,0.2,0.4,0.3);
// Rotate and translate BLUE rectangle
glColor3f( 0, 0, 1 );
//glLoadIdentity();// reset the modelview matrix
glRotatef(90, 0.0, 0.0,1.0);
glRectf(0.1,0.2,0.4,0.3);
// Scale, rotate and translate MAGENTA rectangle
glColor3f( 1, 0, 1 );
//glLoadIdentity();// reset the modelview matrix
glScalef(-0.5, 1.0, 1.0);
glRectf(0.1,0.2,0.4,0.3);
// display rectangles
glutSwapBuffers();
} // end of draw()

34
Transformaes 2D
c/ acumulao (cont.)
// Keyboard method to allow ESC key to quit
void keyboard(unsigned char key,int x,int y)
{
if(key==27) exit(0);
}

int main(int argc, char ** argv)


{
glutInit(&argc, argv);
// Double Buffered RGB display
glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE);
// Set window size
glutInitWindowSize( 500,500 );
glutCreateWindow("Rectangles moving around: CUMULATIVE 2D transformations");
// Declare the display and keyboard functions
glutDisplayFunc(draw);
glutKeyboardFunc(keyboard);
// Start the Main Loop
glutMainLoop();
return 0;
}

35
Transformaes 2D
c/ acumulao (cont.): output

36
Transformaes 2D
s/ acumulao
/* * quad.cc - Non-cumulative 2D transformations * Abel Gomes */
#include <OpenGL/gl.h> // Header File For The OpenGL Library
#include <OpenGL/glu.h> // Header File For The GLu Library
#include <GLUT/glut.h> // Header File For The GLut Library
#include <stdlib.h>

void draw(){
// Make background colour yellow
glClearColor( 100, 100, 0, 0 );
glClear ( GL_COLOR_BUFFER_BIT );
// modelview matrix for modeling transformations
glMatrixMode(GL_MODELVIEW);
// x-axis
glColor3f(0,0,0);
glBegin(GL_LINES);
glVertex2f(0.0,0.0);
glVertex2f(0.5,0.0);
glEnd();
// y-axis
glColor3f(0,0,0);
glBegin(GL_LINES);
glVertex2f(0.0,0.0);
glVertex2f(0.0,0.5);
glEnd(); 37
Transformaes 2D
s/ acumulao (cont.)
// RED rectangle
glColor3f( 1, 0, 0 );
glRectf(0.1,0.2,0.4,0.3);
// Translate GREEN rectangle
glColor3f( 0, 1, 0 );
glTranslatef(-0.4, -0.1, 0.0);
glRectf(0.1,0.2,0.4,0.3);
// Rotate BLUE rectangle
glColor3f( 0, 0, 1 );
glLoadIdentity(); // reset the modelview matrix
glRotatef(90, 0.0, 0.0,1.0);
glRectf(0.1,0.2,0.4,0.3);
// Scale MAGENTA rectangle
glColor3f( 1, 0, 1 );
glLoadIdentity(); // reset the modelview matrix
glScalef(-0.5, 1.0, 1.0);
glRectf(0.1,0.2,0.4,0.3);
// display rectangles
glutSwapBuffers();
} // end of draw()

38
Transformaes 2D
s/ acumulao (cont.)
// Keyboard method to allow ESC key to quit
void keyboard(unsigned char key,int x,int y)
{
if(key==27) exit(0);
}

int main(int argc, char ** argv)


{
glutInit(&argc, argv);
// Double Buffered RGB display
glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE);
// Set window size
glutInitWindowSize( 500,500 );
glutCreateWindow("Rectangles moving around: NON-CUMULATIVE 2D transformations");
// Declare the display and keyboard functions
glutDisplayFunc(draw);
glutKeyboardFunc(keyboard);
// Start the Main Loop
glutMainLoop();
return 0;
}

39
Transformaes 2D
s/ acumulao (cont.): output

40
Transf. 2D c/ acum. controlada
pela stack
/* * quad.cc - Stack-cumulative 2D transformations * Abel Gomes */
#include <OpenGL/gl.h> // Header File For The OpenGL Library
#include <OpenGL/glu.h> // Header File For The GLu Library
#include <GLUT/glut.h> // Header File For The GLut Library
#include <stdlib.h>

void draw(){
// Make background colour yellow
glClearColor( 100, 100, 0, 0 );
glClear ( GL_COLOR_BUFFER_BIT );
// modelview matrix for modeling transformations
glMatrixMode(GL_MODELVIEW);
// x-axis
glColor3f(0,0,0);
glBegin(GL_LINES);
glVertex2f(0.0,0.0);
glVertex2f(0.5,0.0);
glEnd();
// y-axis
glColor3f(0,0,0);
glBegin(GL_LINES);
glVertex2f(0.0,0.0);
glVertex2f(0.0,0.5);
glEnd(); 41
Transf. 2D c/ acum. controlada
pela stack (cont.)
// RED rectangle
glColor3f( 1, 0, 0 );
glRectf(0.1,0.2,0.4,0.3);
// Translate GREEN rectangle
glColor3f( 0, 1, 0 );
glTranslatef(-0.4, -0.1, 0.0);
glRectf(0.1,0.2,0.4,0.3);
// save modelview matrix on the stack
glPushMatrix();
// Rotate and translate BLUE rectangle
glColor3f( 0, 0, 1 );
glRotatef(90, 0.0, 0.0,1.0);
glRectf(0.1,0.2,0.4,0.3);
// restore modelview matrix from the stack
glPopMatrix();

// Scale and translate MAGENTA rectangle


glColor3f( 1, 0, 1 );
glScalef(-0.5, 1.0, 1.0);
glRectf(0.1,0.2,0.4,0.3);
// display rectangles
glutSwapBuffers();
} // end of draw()
42
Transf. 2D c/ acum. controlada
pela stack (cont.):
// Keyboard method to allow ESC key to quit
void keyboard(unsigned char key,int x,int y)
{
if(key==27) exit(0);
}

int main(int argc, char ** argv)


{
glutInit(&argc, argv);
// Double Buffered RGB display
glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE);
// Set window size
glutInitWindowSize( 500,500 );
glutCreateWindow("Rectangles moving around: STACK-CUMULATIVE 2D transformations");
// Declare the display and keyboard functions
glutDisplayFunc(draw);
glutKeyboardFunc(keyboard);
// Start the Main Loop
glutMainLoop();
return 0;
}

43
Transf. 2D c/ acum. controlada
pela stack (cont.): output

44 FIM