Exibir código-fonte para Transformações em Imagens Vetoriais no Espaço

Afluentes: [[Computação Gráfica]]

= Representação =

{{note|O espaço tridimensional é composto por três vetores. Desta forma, para representar os elementos vetoriais neste espaço é necessário acrescentar o eixo z aos já conhecidos x e y. Dessa forma, cada ponto pode ser representado por (x, y, z).}}

O seguinte exemplo apresenta um algoritmo para a representação aramada de um cubo.

<pre>
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
</pre>

{{note|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.}}

= Transformações =

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.

== Translação ==

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:

<math>
\begin{pmatrix}
   Tx & Ty & Tz
\end{pmatrix}
</math>

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:

<math>
\begin{pmatrix} x & y & z \end{pmatrix} \cdot \begin{pmatrix} Tx & Ty & Tz \end{pmatrix}
</math>

tal que:

<math>
x = x + Tx
</math>

<math>
y = y + Ty
</math>

<math>
z = z + Tz
</math>

=== Algoritmo ===

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:

<pre>
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
</pre>

Ou seja, a operação é executada em todos os pontos do elemento.

== Escala ==

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:

<math>
\begin{pmatrix}
 Sx & 0 & 0 \\ 
 0 & Sy & 0 \\ 
 0 & 0 & Sz
 \end{pmatrix}
</math>

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:

<math>
\begin{pmatrix}
 x & y & z
\end{pmatrix}
\cdot
\begin{pmatrix}
 Sx & 0 & 0 \\ 
 0 & Sy & 0 \\ 
 0 & 0 & Sz
 \end{pmatrix}
</math>

tal que:

<math>
x = (x \cdot Sx) + (y \cdot 0) + (z \cdot 0) = x \cdot Sx
</math>

<math>
y = (x \cdot 0) + (y \cdot Sy) + (z \cdot 0) = y \cdot Sy
</math>

<math>
z = (x \cdot 0) + (y \cdot 0) + (z \cdot Sz) = z \cdot Sz
</math>

=== Algoritmo ===

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:

{{note|Lembre-se que é necessário transladar o objeto para seu ponto de origem, utilizando-se de um pivô para isso, e depois transladar de volta para sua localização no espaço tridimensional. Assim como na operação de Escala no plano.}}

<pre>
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);
</pre>

A operação é executada em todos os pontos do elemento, assim como na operação de translação.

== Rotaçã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:

=== Rotação em z ===

<math>
\begin{pmatrix}
\cos(\theta) & \sin(\theta) & 0 \\
-\sin(\theta) & \cos(\theta) & 0 \\
0 & 0 & 1
\end{pmatrix}
</math>

tal que:

 ''θ'' é o ângulo, em radianos, que se quer rotacionar o objeto,
 ''sin'' é 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:

<math>
\begin{pmatrix}
x & y & z
\end{pmatrix}
\cdot
\begin{pmatrix}
\cos(\theta) & \sin(\theta) & 0 \\
-\sin(\theta) & \cos(\theta) & 0 \\
0 & 0 & 1
\end{pmatrix}
</math>

tal que:

<math>
x' = (x \cdot \cos(\theta)) + (y \cdot -\sin(\theta)) + (z \cdot 0)
</math>

<math>
y' = (x \cdot \sin(\theta)) + (y \cdot \cos(\theta)) + (z \cdot 0)
</math>

<math>
z' = (x \cdot 0) + (y \cdot 0) + (z \cdot 1) = z
</math>

{{note|Aqui temos x', y' e z', assim como na rotação no plano. Porém, z não se modifica, se mantêm. Isso é devido à operação de rotação ser sobre o eixo z. Ainda aqui, assim como na escala, devemos transladar nosso objeto para o ponto de origem do espaço, baseando-se em um pivo do elemento.}}

==== Algoritmo ====

Baseado na matriz de rotação em z, o algoritmo para esta operação fica da seguinte maneira:

<pre>
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)
</pre>

{{note|Como nesta operação (rotação em z) o z do ponto não se modifica, então não é necessário executar qualquer operação sobre z.}}

Aqui, também, operação é executada em todos os pontos do elemento, assim como na operação de translação e na escala.

=== Rotação em x ===

Seguindo o esquema da rotação em z, a rotação em x também possui sua matriz de rotação.

<math>
\begin{pmatrix}
1 & 0 & 0 \\
0 & \cos(\theta) & \sin(\theta) \\
0 & -\sin(\theta) & \cos(\theta)
\end{pmatrix}
</math>

Logo, a fórmula matemática da operação de translação em x fica da seguinte forma:

<math>
\begin{pmatrix}
x & y & z
\end{pmatrix}
\cdot
\begin{pmatrix}
1 & 0 & 0 \\
0 & \cos(\theta) & \sin(\theta) \\
0 & -\sin(\theta) & \cos(\theta)
\end{pmatrix}
</math>

tal que:

<math>x' = (x \cdot 1) + (y \cdot 0) + (z \cdot 0) = x</math>

<math>y' = (x \cdot 0) + (y \cdot \cos(\theta)) + (z \cdot -\sin(\theta))</math>

<math>z' = (x \cdot 0) + (y \cdot \sin(\theta)) + (z \cdot  \cos(\theta))</math>

{{note|Na rotação em x, apenas o x não se modifica.}}

==== Algoritmo ====

<pre>
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)
</pre>

=== Rotação em y ===

Por fim, segue a matriz de rotação em y.

<math>
\begin{pmatrix}
\cos(\theta) & 0 & \sin(\theta)\\
0 & 1 & 0\\
-\sin(\theta) & 0 & \cos(\theta)
\end{pmatrix}
</math>

Aplicando a multimplicação de matrizes:

<math>
\begin{pmatrix}
x & y & z
\end{pmatrix}
\cdot
\begin{pmatrix}
\cos(\theta) & 0 & \sin(\theta)\\
0 & 1 & 0\\
-\sin(\theta) & 0 & \cos(\theta)
\end{pmatrix}
</math>

tem-se:

<math>x' = (x \cdot \cos(\theta)) + (y \cdot 0) + (z \cdot -\sin(\theta))</math>

<math>y' = (x \cdot 0) + (y \cdot 1) + (z \cdot 0) = y</math>

<math>z' = (x \cdot \sin(\theta)) + (y \cdot 0) + (z \cdot \cos(\theta))</math>

==== Algoritmo ====

<pre>
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)
</pre>