O seguinte exemplo apresenta um algoritmo para a representação aramada de um cubo.
Ponto {
Real x
Real y
Real z
}
Cubo = Vetor [8] Ponto
Cubo[0].Ponto = ( 5, 5, 5);
Cubo[1].Ponto = (10, 5, 5);
Cubo[2].Ponto = (10, 10, 5);
Cubo[3].Ponto = ( 5, 10, 5);
Cubo[4].Ponto = ( 5, 5, 10);
Cubo[5].Ponto = (10, 5, 10);
Cubo[6].Ponto = (10, 10, 10);
Cubo[7].Ponto = ( 5, 10, 10);
j = 1;
Para i = 0 até 3 Fazer
j = i + 1;
Se j == 4
Então j = 0
Fim se
Desenhar_linha(
Cubo[i].Ponto.x, Cubo[i].Ponto.y,
Cubo[i+4].Ponto.x, Cubo[i+4].Ponto.y)
Desenhar_linha(
Cubo[i].Ponto.x, Cubo[i].Ponto.y,
Cubo[j].Ponto.x, Cubo[j].Ponto.y)
Desenhar_linha(
Cubo[i+4].Ponto.x, Cubo[i+4].Ponto.y,
Cubo[j+4].Ponto.x, Cubo[j+4].Ponto.y)
Fim para
O algoritmo acima é apresentado em linguagem C no código fonte exemplo cubo.c.
Observe que o vetor z dos pontos não estão envolvidos na apresentação da figura na tela do computador. Isso por que a tela não possui profundidade. Temos que apresentar todos os elementos chapados na tela do monitor do computador.
As transformações no espaço tridimensional devem ser aplicadas, assim como nas transformações no plano, em todos os pontos do objeto. Aqui são apresentadas as transformações de translação, escala e rotação em x, y e z.
A operação da translação ocorre com a soma da matriz de translação com todos os pontos do objeto, assim como a translação no espaço. Porém, agora a matriz de translação possui um elemento a mais para tratar do eixo z, o Tz. A matriz de translação no espaço tridimensional é a seguinte:
[ Tx Ty Tz ]
tal que:
Tx é a translação na horizontal e Ty é a translação na vertical e Tz é a translação em relação à profundidade.
Logo, a fórmula matemática da operação de translação fica da seguinte forma:
[ x y z ] + [ Tx Ty Tz ]
tal que:
x = x + Tx y = y + Ty z = z + Tz
Baseado na matriz e na fórmula para a operação de translação no plano, o algoritmo para esta operação fica da seguinte maneira:
Entrada Tx, Ty e Tz Para i = 0 Até Quantidade_de_pontos Fazer Ponto[i].x = Ponto[i].x + Tx Ponto[i].y = Ponto[i].y + Ty Ponto[i].z = Ponto[i].z + Tz Fim para
Ou seja, a operação é executada em todos os pontos do elemento.
A operação da escala ocorre com a multiplicação da matriz de Escala com todos os pontos do objeto, agora com o eixo Z acrescido e o novo elemento Sz (Escala em profundidade). A matriz de escala é a seguinte:
| Sx 0 0 | | 0 Sy 0 | | 0 0 Sz |
tal que:
Sx é a modificação da escala na horizontal, Sy é a modificação da escala na vertical e Sz é a modificação da escala em relação à profundidade.
Logo, a fórmula matemática da operação de translação fica da seguinte forma:
| Sx 0 0 | [ x y z ] * | 0 Sy 0 | | 0 0 Sz |
tal que:
x = (x * Sx) + (y * 0) + (z * 0) = x * Sx y = (x * 0) + (y * Sy) + (z * 0) = y * Sy z = (x * 0) + (y * 0) + (z * Sz) = z * Zz
Baseado na matriz e na fórmula para a operação de escala no plano, o algoritmo para esta operação fica da seguinte maneira:
Entrada Sx, Sy e Sz Pivo = Ponto[0]; Transladar(-Pivo.x, -Pivo.y, -Pivo.z); Para i = 0 Até Quantidade_de_pontos Fazer Ponto[i].x = Ponto[i].x * Sx Ponto[i].y = Ponto[i].y * Sy Ponto[i].z = Ponto[i].z * Sz Fim para Transladar(Pivo.x, Pivo.y, Pivo.z);
A operação é executada em todos os pontos do elemento, assim como na operação de translação.
A operação de rotação ocorre com a multiplicação da matriz de Rotação com todos os pontos do objeto. Porém, é importante observar que a matriz de rotação agora pode ser aplicada nos eixos x, y e z. No plano, a rotação é considerada sobre o eixo z. Dessa forma, as matrizes de rotação são apresentadas a seguir:
| cos(ang) sen(ang) 0 | |-sen(ang) cos(ang) 0 | | 0 0 1 |
tal que:
ang é o ângulo, em radianos, que se quer rotacionar o objeto, sen é a operação do seno sobre o ângulo e cos é a operação do cosseno sobre o ângulo.
Logo, a fórmula matemática da operação de translação fica da seguinte forma:
| cos(ang) sen(ang) 0 | [ x y z ] * |-sen(ang) cos(ang) 0 | | 0 0 1 |
tal que:
x' = (x * cos(ang)) + (y * -sen(ang)) + (z * 0) y' = (x * sen(ang)) + (y * cos(ang)) + (z * 0) z' = (x * 0) + (y * 0) + (z * 1) = z
Baseado na matriz de rotação em z, o algoritmo para esta operação fica da seguinte maneira:
Entrada ang Pivo = Ponto[0]; Transladar (-Pivo.x, -Pivo.y, -Pivo.z) Para i = 0 Até Quantidade_de_pontos Fazer xAux = (Ponto[i].x * cos(ang)) + (Ponto[i].y * -sen(ang)) yAux = (Ponto[i].x * sen(ang)) + (Ponto[i].y * cos(ang)) Ponto[i].x = xAux Ponto[i].y = yAux Fim para Transladar (Pivo.x, Pivo.y, Pivo.z)
Aqui, também, operação é executada em todos os pontos do elemento, assim como na operação de translação e na escala.
Seguindo o esquema da rotação em z, a rotação em x também possui sua matriz de rotação.
| 1 0 0 | | 0 cos(ang) sen(ang) | | 0 -sen(ang) cos(ang) |
Logo, a fórmula matemática da operação de translação em x fica da seguinte forma:
| 1 0 0 | [ x y z ] * | 0 cos(ang) sen(ang) | | 0 -sen(ang) cos(ang) |
tal que:
x' = (x * 1) + (y * 0) + (z * 0) = x y' = (x * 0) + (y * cos(ang)) + (z * -sen(ang)) z' = (x * 0) + (y * sen(ang)) + (z * cos(ang))
Entrada ang Pivo = Ponto[0]; Transladar (-Pivo.x, -Pivo.y, -Pivo.z) Para i = 0 Até Quantidade_de_pontos Fazer yAux = (Ponto[i].y * cos(ang)) + (Ponto[i].z * -sen(ang)) zAux = (Ponto[i].y * sen(ang)) + (Ponto[i].z * cos(ang)) Ponto[i].y = yAux Ponto[i].z = zAux Fim para Transladar (Pivo.x, Pivo.y, Pivo.z)
Por fim, segue a matriz de rotação em y.
| cos(ang) 0 sen(ang) | | 0 1 0 | |-sen(ang) 0 cos(ang) |
Aplicando a multimplicação de matrizes:
| cos(ang) 0 sen(ang) | [ x y z ] * | 0 1 0 | |-sen(ang) 0 cos(ang) |
tem-se:
x' = (x * cos(ang) + (y * 0) + (z * -sen(ang) y' = (x * 0) + (y * 1) + (z * 0) = y z' = (x * sen(ang) + (y * 0) + (z * cos(ang))
Entrada ang Pivo = Ponto[0]; Transladar (-Pivo.x, -Pivo.y, -Pivo.z) Para i = 0 Até Quantidade_de_pontos Fazer xAux = (Ponto[i].x * cos(ang)) + (Ponto[i].z * -sen(ang)) zAux = (Ponto[i].x * sen(ang)) + (Ponto[i].z * cos(ang)) Ponto[i].x = xAux Ponto[i].z = zAux Fim para Transladar (Pivo.x, Pivo.y, Pivo.z)
[voltar]