3 Transformações Geométricas
Para que possamos entender projeções em perspectiva, que serão discutidas mais à frente, precisamos estar familiarizados com rotações em 3D. Elas estão intimamente relacionadas à multiplicação de matrizes, que é o assunto com o qual começaremos.
3.1 Multiplicação de Matrizes
Uma matriz é um arranjo retangular de números dentro de colchetes (ou parênteses). Por exemplo,
2 0 0.1 3
1 4 2 10
é uma matriz 2 X 4: ela é formada por duas linhas e quatro colunas. Se uma matriz possuir apenas uma linha, nós a chamamos de matriz linha ou vetor linha. Da mesma maneira, usamos o termo matriz coluna para designar uma matriz que possua apenas uma coluna.
Se A e B forem matrizes e o número de colunas de A for igual ao número de colunas de B, podemos calcular o produto de matrizes AB. Esse produto é outra matriz, com tantas linhas quanto A e tantas colunas quanto B.
Escrevendo =
e expressões semelhantes tanto para a matriz B quanto para o produto de matrizes C = AB, temos
=
Cada elemento c (encontrado na linha i e coluna j do produto de matrizes C) é igual ao produto escalar da linha de índice i de A com a coluna de índice j de B. Por exemplo:
c23 = (a21,a22,a23)(b13,b23,b33) = (a21b13 + a22b23 + a23b33)
Então, de modo geral, os elementos da matriz C anterior são calculados da seguinte maneira:
Cij = (ai1,ai2,ai3)(b1j,b2j,b3j) = (ai1b1j + ai2b2j + ai3b3j)
3.2 Transformações Lineares
Podemos escrever qualquer transformação linear como uma multiplicação de matrizes. Por exemplo, considere a seguinte transformação linear:
= 2
= +
Podemos escrever isto como o produto de matrizes ′
′ = 2 0 1 1 ou da seguinte maneira:
[ ′ ′] = [ ] 2 1 0 1
A notação apresentada na seção 3.1, apesar de ser usada muito em livros-texto de matemática, adotaremos a notação apresentada nesta seção, usando vetores linha. Observe que as linhas da matriz de transformação 2 X 2 são as imagens dos vetores unitários (1,0) e (0,1), respectivamente, enquanto essas imagens são as colunas na seção 3.1. Podemos verificar isto facilmente substituindo [1 0] e [0 1] por [x y] nas equações acima, como os elementos em negrito da matriz a seguir ilustram:
[ ] = [1 0]
0 1
[ ] = [0 1] 2 1
Esse princípio também se aplica a outras transformações lineares. Ele nos fornece uma forma conveniente de encontrar as matrizes de transformação.
3.2.1 Rotação
Para rotacionar todos os pontos no plano xy de um ângulo , em torno de O, podemos agora escrever facilmente a matriz de transformação, usando a regra recém-apresentada. Simplesmente encontramos as imagens dos vetores unitários (1,0) e (0,1). Como sabemos da trigonometria elementar, rotacionar os pontos P(1,0) e Q(0,1) de um ângulo em torno de O resulta em P’(cos , sen ) e Q’(-sen , cos ). Segue-se que (cos , sen ) e (-sen , cos ) são as imagens desejadas dos vetores unitários (1,0) e (0,1), como a Figura 22 ilustra:
Figura 22: Rotação dos vetores unitários
Então, tudo o que precisamos fazer é escrever essas duas imagens como as linhas da nossa matriz de rotação:
[ ′ ′] = [ ] −cos cos
3.2.2 Um Exemplo de Programação
Para vermos a rotação em ação, rotacionaremos uma seta e, torno da origem O. Antes dessa rotação, a seta está na vertical, aponta para cima e pode ser encontrada à direita de O. Rotacionaremos a seta de um ângulo de 120 em torno da origem O, que é o centro da área de desenho. A Figura 23 mostra os eixos das coordenadas (com a intersecção em O) e a seta antes e depois da rotação.
Logo abaixo da Figura 23, se encontra o código-fonte (Arrow.java) que faz a rotação da seta. Se alterarmos o tamanho da janela, a origem continua no centro e os tamanhos das setas e do círculo sobre o qual elas estão mudam apropriadamente, de modo que o círculo permanece como um círculo.
Figura 23: Seta antes e depois da rotação de 120 em torno da origem
import java.awt.*;
import java.awt.event.*;
public class Arrow extends Frame
{ public static void main(String[] args){new Arrow();}
Arrow()
{ super("Seta rotacionada de 120 graus em torno da origem"); addWindowListener(new WindowAdapter()
{public void windowClosing(WindowEvent e){System.exit(0);}}); setSize(400, 300);
add("Center", new CvArrow()); show();
} }
class CvArrow extends Canvas
{ int centerX, centerY, currentX, currentY;
float pixelSize, rWidth = 100.0F, rHeight = 100.0F;
void initgr()
{ Dimension d = getSize();
int maxX = d.width - 1, maxY = d.height - 1; pixelSize = Math.max(rWidth/maxX, rHeight/maxY); centerX = maxX/2; centerY = maxY/2;
}
int iX(float x){return Math.round(centerX + x/pixelSize);} int iY(float y){return Math.round(centerY - y/pixelSize);} void moveTo(float x, float y)
{ currentX = iX(x); currentY = iY(y); }
void lineTo(Graphics g, float x, float y) { int x1 = iX(x), y1 = iY(y);
g.drawLine(currentX, currentY, x1, y1); currentX = x1; currentY = y1;
}
void drawArrow(Graphics g, float[]x, float[]y) { moveTo(x[0], y[0]);
lineTo(g, x[1], y[1]); lineTo(g, x[2], y[2]); lineTo(g, x[3], y[3]); lineTo(g, x[1], y[1]); }
public void paint(Graphics g) { float r = 40.0F;
float[] x = {r, r, r-2, r+2}, y = {-7, 7, 0, 0}; initgr();
// Mostra eixos de coordenadas:
moveTo(30, 0); lineTo(g, 0, 0); lineTo(g, 0, 30); // Mostra a seta inicial:
drawArrow(g, x, y);
float phi = (float)(2 * Math.PI / 3), //120 graus c = (float)Math.cos(phi), s = (float)Math.sin(phi), r11 = c, r12 = s, r21 = -s, r22 = c;
for (int j=0; j<4; j++)
{ float xNew = x[j] * r11 + y[j] * r21, yNew = x[j] * r12 + y[j] * r22; x[j] = xNew; y[j] = yNew;
}
// Seta após a rotação: drawArrow(g, x, y); }
}
As coordenadas lógicas dos quatro pontos relevantes da seta são armazenadas nos vetores x e y e as variáveis r11, r12, r21 e r22 denotam os elementos da matriz de rotação.
3.2.3 Mudança de Escala
Suponha que queiramos mudar a escala com fatores de escala sx, para x e s e sy para y e com ponto O permanecendo no mesmo lugar; essa última condição também é expressa pela referência a O como um
ponto fixo ou por uma escala com referência a O. Isso pode obviamente ser escrito como
= =
que também pode ser escrito como uma multiplicação de matrizes muito simples:
[ ′ ′] = [ ] 0 0
Há alguns casos especiais importantes:
sx = sy = -1 reflexão em torno de O;
sx = 1, sy = -1 reflexão em torno do eixo x;
sx = -1, sy = 1 reflexão em torno do eixo y.
3.2.4 Cisalhamento
Considere transformação linear dada por: (1,0) (1,0)
(0,1) (,1)
Como as imagens dos vetores unitários aparecem como linhas da matriz de transformação, podemos escrever essa transformação, conhecida como cisalhamento, como:
[ ′ ′] = [ ] 1 0 1 ou
= +
=
Esse conjunto de equações expressa que cada ponto (x, y) se move a uma distância y para a
direita, o que tem o efeito de cisalhamento ao longo do eixo x, conforme ilustrado na Figura 24. Podemos usar essa transformação para transformar caracteres comuns em itálico; por exemplo, L se torna L.
Figura 24: Efeitos do cisalhamento (retas tracejadas) sobre um objeto quadrado (retas sólidas)
O cisalhamento ao longo do eixo y, também mostrado na figura 24, pode ser expresso de maneira similar como: [ ′ ′] = [ ] 1 0 1 ou = = +
3.3 Translações
O deslocamento de todos os pontos do plano xy por uma distância constante em uma direção fixa é chamado de translação. Essa é outra transformação, que escrevemos como:
= +
= +
ou
[ ′ ′] = [ ][ ]
Referimo-nos ao par de números (a, b) como o vetor de deslocamento, ou vetor de translação. Embora essa transformação seja muito simples, ela não é linear, como podemos perceber pelo fato de a imagem na origem (0, 0) ser (a, b), e não a própria origem, como ocorre com as transformações lineares.
3.4 Coordenadas Homogêneas
Para expressar todas as transformações introduzidas até aqui como matrizes de transformações de modo que se possam combinar diversos efeitos de transformações, acrescentamos mais uma dimensão. Conforme ilustrado na Figura 25, a dimensão adicional W faz com que qualquer ponto P = (x, y) de coordenadas normais tenha uma família inteira de representações em coordenadas homogêneas (wx, wy,
w) para qualquer valor de w exceto 0. Por exemplo, (3, 6, 1), (0,3; 0,6; 0,1) e (6, 12, 2) representam o
mesmo ponto no espaço bidimensional.
Figura 25: Um sistema de coordenadas homogêneas com o plano W = 1
Podemos descrever uma translação como uma multiplicação de matrizes usando uma matriz 3 X 3 em vez de uma matriz 2 X 2:
[ ′ ′ 1] = [ 1]
1 0 0
0 1 0
1
Podemos usar a seguinte equação em vez da equação apresentada na seção 3.2.1 para uma rotação de um ângulo em torno do O:
[ ′ ′ 1] = [ 1]
cos 0
− cos 0
0 0 1
3.5 Transformações Inversas e Matriz de Inversão
Uma transformação pode ou não ser reversível. Por exemplo, se realizarmos uma rotação em torno da origem de um ângulo e depois realizarmos outra rotação, também em torno da origem de um ângulo -, essas duas transformações se cancelam uma à outra. Denotaremos a matriz de transformação da equação apresentada na seção 3.2 por R. Segue-se que a rotação inversa, pelo ângulo - em vez de , é descrita pela equação:
[ ′ ′] = [ ] em que = (− ) (− ) − (− ) (− ) = cos − cos
A matriz R-1 é chamada de inversa da matriz R. De modo geral, se uma matriz A possuir uma inversa, ela é escrita A-1 e temos:
AA-1 = A-1A = I
em que I é a matriz identidade, que consiste em elementos iguais a zero exceto pela diagonal principal, que contém elementos iguais a 1.
3.6 Rotação em Torno de um Ponto Arbitrário
Até aqui só realizamos rotações em torno da origem O. Uma rotação em torno de qualquer ponto diferente de O não é uma transformação linear, já que não mapeia a origem em si mesma. Ela pode ser descrita como uma multiplicação de matrizes, desde que usemos coordenadas homogêneas.
3.6.1 Uma Aplicação
Para ver esse tipo geral de rotação em ação, veremos agora um programa que rotaciona de 30 uma seta em torno de um ponto selecionado pelo usuário. Inicialmente, uma seta, apontando verticalmente para cima, aparece no centro da área de desenho. Assim que o usuário clica um botão do mouse, uma segunda seta aparece. Essa seta é a imagem da primeira, e resulta da rotação de um ângulo de 30 em torno da posição do cursor. Essa posição é mostrada como um cursor cruzado na Figura 26.
Figura 26: Seta antes e depois da rotação de 30 em torno de um ponto selecionado pelo usuário
Essa ação pode ser executada repetidamente, de forma que a seta rotacionada mais recentemente é novamente rotacionada quando o usuário clica um botão do mouse, e essa última rotação é realizada em torno do último ponto selecionado. Se o usuário tivesse clicado do lado direito, a seta apareceria abaixo da anterior em vez de acima, em razão da rotação ser executada no sentido anti-horário. O programa
ArrowPt.java mostra como esta rotação é calculada.
import java.awt.*;
import java.awt.event.*;
public class ArrowPt extends Frame
{ public static void main(String[] args){new ArrowPt();}
ArrowPt()
{ super("Seta rotacionada em torno de um ponto arbitrário"); addWindowListener(new WindowAdapter()
{public void windowClosing(WindowEvent e){System.exit(0);}}); setSize(400, 300);
add("Center", new CvArrowPt());
setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR)); show();
} }
class CvArrowPt extends Canvas
float pixelSize, xP = 1e9F, yP,
rWidth = 100.0F, rHeight = 100.0F;
float[] x = {0, 0, -2, 2}, y = {-7, 7, 0, 0}; CvArrowPt()
{ addMouseListener(new MouseAdapter()
{ public void mousePressed(MouseEvent evt) { xP = fx(evt.getX()); yP = fy(evt.getY()); repaint(); } }); } void initgr() { Dimension d = getSize();
int maxX = d.width - 1, maxY = d.height - 1; pixelSize = Math.max(rWidth/maxX, rHeight/maxY); centerX = maxX/2; centerY = maxY/2;
}
int iX(float x){return Math.round(centerX + x/pixelSize);} int iY(float y){return Math.round(centerY - y/pixelSize);} float fx(int x){return (x - centerX) * pixelSize;}
float fy(int y){return (centerY - y) * pixelSize;} void moveTo(float x, float y)
{ currentX = iX(x); currentY = iY(y); }
void lineTo(Graphics g, float x, float y) { int x1 = iX(x), y1 = iY(y);
g.drawLine(currentX, currentY, x1, y1); currentX = x1; currentY = y1;
}
void drawArrow(Graphics g, float[]x, float[]y) { moveTo(x[0], y[0]); lineTo(g, x[1], y[1]); lineTo(g, x[2], y[2]); lineTo(g, x[3], y[3]); lineTo(g, x[1], y[1]); }
public void paint(Graphics g) { initgr();
// Mostra a seta inicial: drawArrow(g, x, y);
if (xP > 1e8F) return;
float phi = (float)(Math.PI / 6), //30 graus de rotação c = (float)Math.cos(phi), s = (float)Math.sin(phi), r11 = c, r12 = s,
r21 = -s, r22 = c,
r31 = -xP * c + yP * s + xP, r32 = -xP * s - yP * c + yP; for (int j=0; j<4; j++)
{ float xNew = x[j] * r11 + y[j] * r21 + r31, yNew = x[j] * r12 + y[j] * r22 + r32; x[j] = xNew; y[j] = yNew;
}
// Seta após a rotação: drawArrow(g, x, y); }
Em comparação com o programa Arrow.java da seção 3.2, esse novo programa ArrowPt.java usa a matriz de rotação 3 X 3. Os elementos da matriz r31 e r32 na terceira linha da matriz dependem do ponto (xp,
yp) selecionado pelo usuário e que atua como o centro C(xc, yc) apresentada na discussão acima.
3.7 Mudando o Sistema de Coordenadas
Nas seções anteriores, usamos um sistema de coordenadas fixo e aplicamos transformações a pontos dados por suas coordenadas nesse sistema, usando determinados cálculos. Podemos usar exatamente os mesmos cálculos para um propósito diferente, deixando os pontos inalterados mas alterando o sistema de coordenadas. É importante ter em mente que a direção na qual o sistema de coordenadas se move é oposta à direção do movimento do ponto. Isto pode ser comprovado claramente no caso de uma translação. Na Figura 27 temos uma translação normal com ponto qualquer P(x, y) mapeado para sua imagem P’(x’, y’), em que:
x’ = x + a y’ = y + b
Na Figura 27 não mapeamos o ponto P para outro ponto, mas expressamos sua posição em um novo sistema de coordenadas x’y’.
Figura 27: Mudança de coordenadas
3.8 Rotações em Torno de Eixos de Coordenadas Tridimensionais
Usaremos um sistema de coordenadas tridimensionais com orientação positiva, com eixo x positivo apontando em nossa direção, o eixo y apontando para a direita e o eixo z apontando para cima, conforme mostrado na Figura 28.
Figura 28: Rotações em torno dos eixos de coordenadas
Podemos derivar as matrizes de uma forma trivial da matriz de rotação 2 X 2, e assim poderemos escrever as matrizes de transformação para as rotações em torno dos eixos x, y e z de um ângulo da seguinte forma:
= 1 0 0 0 cos 0 − cos = cos 0 − 0 1 0 0 cos = cos 0 − cos 0 0 0 1
3.9 Rotação em Torno de um Eixo Arbitrário
Para nos prepararmos para uma rotação tridimensional em torno de um eixo arbitrário, primeiro executaremos tal rotação em torno de um eixo que passa pela origem O. Na verdade, a rotação ocorrerá em torno de um vetor, de modo que podemos definir sua orientação, conforme ilustrado na Figura 29.
Se um ponto for rotacionado em torno do vetor v de um ângulo positivo, essa rotação ocorrerá de forma que corresponda a um movimento na direção do vetor da mesma maneira que girar um parafuso (para a direita) corresponde a seu movimento para a frente.
Em vez das coordenadas cartesianas (v1, v2, v3), usaremos os ângulos e para especificar a direção do vetor v. O comprimento desse vetor é irrelevante para o nosso propósito atual. Como podemos ver na Figura 29, é o ângulo entre o eixo x positivo e a projeção do vetor v no plano xy e é o ângulo entre o eixo z positivo e o vetor v.
Figura 29: Rotações em torno de um vetor com origem em O
Para derivarmos uma matriz de rotação 3 X 3 que descreve a rotação em torno do vetor v de um ângulo , mudando o sistema de coordenadas de modo que o vetor v fique sobre o eixo z positivo. Como as transformações no sistema de coordenadas requerem as inversas das matrizes que serão usadas para rotações normais dos pontos, as matrizes Rz-1 e Ry-1 devem ser obtidos:
= cos − 0 cos 0 0 0 1 = cos 0 0 1 0 − 0 cos
=
cos 0
− cos 0
0 0 1
O eixo z deverá ser rotacionado de volta para a posição original, obtendo as seguintes matrizes:
= cos 0 − 0 1 0 0 cos = cos 0 − cos 0 0 0 1
A matriz R resultante, a ser usada na equação
[ ′ ′ ′] = [ ]
para executar a rotação em torno de v de um ângulo , pode agora ser encontrada como se segue:
= =
Conforme discutido nas seções 3.4 e 3.6, precisamos usar coordenadas homogêneas para descrever translações por multiplicação de matrizes. Como usamos matrizes 3 X 3 para transformações no espaço tridimensional, temos que usar matrizes 4 X 4 em conexão com essas coordenadas homogêneas. Tomando as coordenadas a1, a2 e a3 do ponto A sobre o eixo de rotação, a matriz seguinte descreve a translação de A para O: = 1 0 0 0 0 1 0 0 0 0 1 0 − − − 1
Após a translação, executamos a rotação em torno do vetor v, que se inicia no ponto A, usando a matriz R anterior, que escrevemos como R* após adicionarmos uma linha e uma coluna extras da forma habitual: = 0 0 0 0 0 0 1
Finalmente, usamos uma translação de O de volta para A:
=
1 0 0 0
0 1 0 0
0 0 1 0
1
Escrevendo RGEN para a matriz de rotação geral (4 X 4), temos:
RGEN = T-1R*T
[ ′ ′ ′ 1] = [ 1]
3.9.1 Implementação
Já que agora estamos lidando com pontos no espaço tridimensional, comecemos definindo a seguinte classe para representar esses pontos:
class Point3D { float x, y, z;
Point3D(double x, double y, double z) { this.x = (float)x;
this.y = (float)y; this.z = (float)z; }
}
Como normalmente temos muitos pontos a serem rotacionados, vale a pena calcular a matriz RGEN antecipadamente. Embora esse calculo possa ser feito numericamente, também é possível tornar nosso programa um pouco mais rápido realizando-o simbolicamente, isto é, expressando todos os elementos rij da matriz RGEN em seis valores constantes para a rotação: os ângulos , e e as coordenadas a1, a2 e a3 do
ponto A sobre o eixo de rotação. Em vez de escrever aqui esses elementos da matriz, utilizando fórmulas matemáticas costumeiras, será apresentado o código Java resultante (Rota3D.java), que está descrito a seguir:
class Rota3D
{ static double r11, r12, r13, r21, r22, r23, r31, r32, r33, r41, r42, r43;
/* O método initRotate calcula a matriz geral de rotação | r11 r12 r13 0 |
R = | r21 r22 r23 0 | | r31 r32 r33 0 | | r41 r42 r43 1 |
a ser usada como [x1 y1 z1 1] = [x y z 1] R pelo método 'rotate'.
O ponto (x1, y1, z1) é a imagem de (x, y, z). A rotação ocorre em torno do eixo orientado AB e por um ângulo alfa.
*/
static void initRotate(Point3D a, Point3D b, double alpha) { double v1 = b.x - a.x, v2 = b.y - a.y, v3 = b.z - a.z, theta = Math.atan2(v2, v1), phi = Math.atan2(Math.sqrt(v1 * v1 + v2 * v2), v3); initRotate(a, theta, phi, alpha);
}
static void initRotate(Point3D a, double theta, double phi, double alpha)
{ double cosAlpha, sinAlpha, cosPhi, sinPhi, cosTheta, sinTheta, cosPhi2, sinPhi2, cosTheta2, sinTheta2, pi, c,
a1 = a.x, a2 = a.y, a3 = a.z;
cosPhi = Math.cos(phi); sinPhi = Math.sin(phi);
cosPhi2 = cosPhi * cosPhi; sinPhi2 = sinPhi * sinPhi; cosTheta = Math.cos(theta);
cosTheta2 = cosTheta * cosTheta; sinTheta2 = sinTheta * sinTheta; cosAlpha = Math.cos(alpha); sinAlpha = Math.sin(alpha); c = 1.0 - cosAlpha;
r11 = cosTheta2 * (cosAlpha * cosPhi2 + sinPhi2) + cosAlpha * sinTheta2;
r12 = sinAlpha * cosPhi + c * sinPhi2 * cosTheta * sinTheta; r13 = sinPhi * (cosPhi * cosTheta * c - sinAlpha * sinTheta); r21 = sinPhi2 * cosTheta * sinTheta * c - sinAlpha * cosPhi; r22 = sinTheta2 * (cosAlpha * cosPhi2 + sinPhi2)
+ cosAlpha * cosTheta2;
r23 = sinPhi * (cosPhi * sinTheta * c + sinAlpha * cosTheta); r31 = sinPhi * (cosPhi * cosTheta * c + sinAlpha * sinTheta); r32 = sinPhi * (cosPhi * sinTheta * c - sinAlpha * cosTheta); r33 = cosAlpha * sinPhi2 + cosPhi2;
r41 = a1 - a1 * r11 - a2 * r21 - a3 * r31; r42 = a2 - a1 * r12 - a2 * r22 - a3 * r32; r43 = a3 - a1 * r13 - a2 * r23 - a3 * r33; }
static Point3D rotate(Point3D p) { return new Point3D(
p.x * r11 + p.y * r21 + p.z * r31 + r41, p.x * r12 + p.y * r22 + p.z * r32 + r42, p.x * r13 + p.y * r23 + p.z * r33 + r43); }
}
Agora vejamos a classe Rota3D, descrita acima em ação. Embora possa ser usada para qualquer eixo e para qualquer ângulo de rotação, ela é usada aqui apenas de uma forma muito simples, de modo que possamos verificar facilmente o resultado, mesmo sem uma saída gráfica. O programa a seguir (Rota3DTest.java) usa as classes Point3D e Rota3D anteriores para executar a rotação discutida neste capítulo:
public class Rota3DTest
{ public static void main(String[] args)
{ Point3D a = new Point3D(0, 0, 1), b = new Point3D(1, 1, 1); double alpha = Math.PI;
// Especifica AB como eixo orientado de rotação // e alfa como ângulo de rotação:
Rota3D.initRotate(a, b, alpha);
// Vértices de um cubo; 0, 1, 2, 3 na parte inferior, // 4, 5, 6, 7 na parte superior. Vértice 0 na origem O: Point3D[] v = {
new Point3D(0, 0, 0), new Point3D(1, 0, 0), new Point3D(1, 1, 0), new Point3D(0, 1, 0), new Point3D(0, 0, 1), new Point3D(1, 0, 1), new Point3D(1, 1, 1), new Point3D(0, 1, 1)}; System.out.println(
"Cubo rotacionado de 180 graus em torno do segmento AB,"); System.out.println(
"em que A = (0, 0, 1) e B = (1, 1, 1)"); System.out.println("Vértices do cubo:"); System.out.println(
" Antes da rotação Após da rotação"); for (int i=0; i<8; i++)
{ Point3D p = v[i];
// Calcula P1, o resultado da rotação de P: Point3D p1 = Rota3D.rotate(p);
System.out.println(i + ": " +
f(p1.x) + " " + f(p1.y) + " " + f(p1.z)); }
}
static double f(double x){return Math.abs(x) < 1e-10 ? 0.0 : x;} }
Como ainda não discutimos como produzir visões em perspectiva, produzimos apenas saída em texto neste programa, como listado a seguir:
Cubo rotacionado de 180 graus em torno do segmento AB, em que A = (0, 0, 1) e B = (1, 1, 1)
Vértices do cubo:
Antes da rotação Após da rotação 0: 0.0 0.0 0.0 0.0 0.0 2.0 1: 1.0 0.0 0.0 0.0 1.0 2.0 2: 1.0 1.0 0.0 1.0 1.0 2.0 3: 0.0 1.0 0.0 1.0 0.0 2.0 4: 0.0 0.0 1.0 0.0 0.0 1.0 5: 1.0 0.0 1.0 0.0 1.0 1.0 6: 1.0 1.0 1.0 1.0 1.0 1.0 7: 0.0 1.0 1.0 1.0 0.0 1.0
3.10 Exercício
Nossa forma de testar se um determinado ponto P está em um triângulo ABC, discutida na seção 2.8, resultou no método insideTriangle, que supõe que A, B e C estejam no sentido anti-horário. Desenvolva um método diferente para o mesmo propósito, baseado nos vetores a = (a1, a2) = CA e b = (b1, b2) = CB (veja a Figura 14 na seção 2.5). Escrevamos:
CP = p = (p1, p2) = a + b
ou, na forma de um produto de matrizes,
[ ] = [ ]
Através do cálculo da inversa de uma matriz 2 X 2, podemos obter os valores de e da seguinte maneira:
[ ] = [ ]
O ponto P está dentro do triângulo ABC (ou sobre um de seus lados) se, e somente se, ≥ 0, ≥ 0 e + 1. Escreva a classe TriaTest, para que possa ser usada da seguinte forma:
Point2D a, b, c, p;
TriaTest tt = new TriaTest(a, b, c);
if (tt.area2() != 0 && tt.insideTriangle(p)) ... // Ponto P dentro do triângulo ABC.
Assim como na seção 2.5, o método area2 retorna o dobro da área de um triângulo ABC, precedido por um sinal de menos se ABC tiver sentido horário. O valor de retorno também é igual ao determinante da matriz 2 X 2. Não devemos chamar o método insideTriangle de TriaTest se este determinante for zero, já que nesse caso a matriz inversa da equação não existe.
3.11 Resposta do Exercício
Se há muitos pontos para os quais temos que verificar se estão dentro de um único triângulo (ou em um lado dele), o método insideTriangle da classe a seguir é mais eficiente do que o discutido na seção 2.8, já que a maioria do trabalho é feita aqui pelo construtor, que precisa ser chamado apenas uma vez para esse triângulo:
class TriaTest
{ private Point2D c;
private double a1, a2, b1, b2, c1, c2, d1, d2, det;
TriaTest(Point2D a, Point2D b, Point2D c) { this.c = c;
a1 = a.x - c.x; a2 = a.y - c.y; b1 = b.x - c.x; b2 = b.y - c.y; det = a1 * b2 - b1 * a2; if (det != 0) { c1 = b2/det; c2 = -a2/det; d1 = -b1/det; d2 = a1/det; } }
double area2(){return det;}
boolean insideTriangle(Point2D p)
{ double p1 = p.x - c.x, p2 = p.y - c.y, lambda, mu;
return (lambda = p1 * c1 + p2 * d1) >= 0 && (mu = p1 * c2 + p2 * d2) >= 0 &&
lambda + mu <= 1; }
