} // transformacaoPerspectivaIsometrica()
/// <summary>
/// transformação geométrica simples, dividindo as coordenadas [x] e [y] pela
/// coordenda 3D [z], aumentada e multiplicada esta por um [fatorGeometrico].
/// </summary>
/// <param name="v"></param>
/// <param name="fatorGeometrico"></param>
/// <returns></returns>
public static vetor2 transformacaoPerspectivaGeometrica(vetor3 v, double fatorGeometrico)
{
vetor2 v2 = new vetor2((fatorGeometrico + 20.0) * v.X / (v.Z + fatorGeometrico),
(fatorGeometrico + 20.0) * v.Y / (v.Z + fatorGeometrico));
return(v2);
} // transformacaoPerspectivaGeometrica()
/// <summary>
/// inicializa um vetor 3D, fazendo uma cópia do vetor 3D parâmetro.
/// </summary>
/// <param name="v">vetor 3D a ser copiado.</param>
public vetor3(vetor3 v)
{
this.X = v.X;
this.Y = v.Y;
this.Z = v.Z;
this.cor = v.cor;
}
/// <summary>
/// transformação isométrica simples, trasladando-se a coordenada 3D z para cada cordenada 2D x e y.
/// </summary>
/// <param name="v">vetor 3D a ser transformado em perspectiva isométrica.</param>
/// <param name="fatorIsometrico">índice de divisão sobre a cordenada que é projetada nos eixos 2D.</param>
/// <returns>retorna o vetor 2D transformado isometricamente.</returns>
public static vetor2 transformacaoPerspectivaIsometrica(vetor3 v, double fatorIsometrico)
{
vetor2 v2 = new vetor2(v.X + v.Z / fatorIsometrico, v.Y + v.Z / fatorIsometrico);
v2.cor = v.cor;
return(v2);
} // transformacaoPerspectivaIsometrica()
/// <summary>
/// multiplica o vetor currente por uma base das pelos eixos vetores de entrada.
/// </summary>
/// <param name="i">eixo i.</param>
/// <param name="j">eixo j.</param>
/// <param name="k">eixo k.</param>
public void multiplicaPorUmaBase(vetor3 i, vetor3 j, vetor3 k)
{
vetor3 v = new vetor3(this);
this.X = v.X * i.X + v.Y * j.X + v.Z * k.X;
this.Y = v.X * i.Y + v.Y * j.Y + v.Z * k.Y;
this.Z = v.X * i.Z + v.Y * j.Z + v.Z * k.Z;
} // multiplicaPorUmaBase()
} // Sort().
/// <summary>
/// tranforma um vetor3 em uma matriz.
/// </summary>
/// <param name="v">vetor 3D a ser transformado em matriz.</param>
/// <returns>retorna uma matriz [1,3] representando o vetor 3D.</returns>
public static Matriz DeVetorParaMatriz(vetor3 v)
{
Matriz mr = new Matriz(1, 3);
mr.setElemento(0, 0, v.X);
mr.setElemento(0, 1, v.Y);
mr.setElemento(0, 2, v.Z);
return(mr);
} // toMatriz()
} // operator *()
/// <summary>
/// calcula o produto vetorial de dois vetores dados.
/// </summary>
/// <param name="v1">vetor 1 a gerar o produto vetorial.</param>
/// <param name="v2">vetor 2 a gerar o produto vetorial.</param>
/// <returns>retorna o produto vetorial, determinada pelo determinante
/// dos dois vetores, mais as cordenadas literais (x,y,z).</returns>
public static vetor3 operator &(vetor3 v1, vetor3 v2)
{
vetor3 vr = new vetor3();
vr.X = v1.Y * v2.Z - v1.Z * v2.Y;
vr.Y = v1.Z * v2.X - v1.X * v2.Z;
vr.Z = v1.X * v2.Y - v1.Y * v2.X;
return(vr);
} // produtoVetorial()
} // raio()
/// <summary>
/// converte o tipo [Matriz] para o tipo [vetor3], se houver
/// compatibilizaçao de linhas e colunas da matriz de entrada (dimensões [3,1]).
/// Se não houver compatibilização de dimensões, lança uma exceção.
/// </summary>
/// <param name="mi">[Matriz] a ser convertida.</param>
/// <returns>o vetor3 resulante da conversão.</returns>
public static vetor3 deMatrizTovetor3(Matriz mi)
{
// se as dimensões não são compatíveis, lança uma exceção.
if ((mi.qtLin != 3) && (mi.qtCol != 1))
{
throw new Exception("dimensões da matriz: " + mi.ToString() + "de entrada não são compatíveis com as dimensões de vetor3");
}
vetor3 v = new vetor3(mi.getElemento(0, 0), mi.getElemento(1, 0), mi.getElemento(2, 0));
return(v);
} // tovetor3()
/// <summary>
/// clona a matriz de entrada.
/// </summary>
/// <param name="matrix">matriz a ser clonada.</param>
/// <returns>retorna um clone da matriz clonada.</returns>
public static vetor3[, ,] cloneMatriz(vetor3[, ,] matrix)
{
vetor3[, ,] mcln = new vetor3[matrix.GetLength(0), matrix.GetLength(1), matrix.GetLength(2)];
int x, y, z;
for (z = 0; z < matrix.GetLength(2); z++)
{
for (y = 0; y < matrix.GetLength(1); y++)
{
for (x = 0; x < matrix.GetLength(0); x++)
{
mcln[x, y, z] = new vetor3(matrix[x, y, z]);
} // for x
}
}
return(mcln);
} // cloneMatriz()
} // encontraAnguloTeta()
/// <summary>
/// calcula a matriz de cossenos-diretores para mudança
/// de base de uma base antiga com eixos (i1,j1,k1)
/// para uma base com eixos (i0,j0,k0).
/// </summary>
/// <param name="i0">antigo eixo X.</param>
/// <param name="j0">antigo eixo Y.</param>
/// <param name="k0">antigo eixo Z.</param>
/// <param name="i1">novo eixo X.</param>
/// <param name="j1">novo eixo Y.</param>
/// <param name="k1">novo eixo Z.</param>
/// <returns>retorna a matriz de mudança de base do sistema de coordenadas com base (i1,j1,k1) para
/// o sistema de coordenadas com base (i0,j0,k0).</returns>
public static double[,] matrizMudancaDeBase(
vetor3 i0, vetor3 j0, vetor3 k0,
vetor3 i1, vetor3 j1, vetor3 k1)
{
double[,] matrizMudanca = new double[3, 3];
i0.normaliza();
j0.normaliza();
k0.normaliza();
i1.normaliza();
j1.normaliza();
k1.normaliza();
double Ax = Math.Acos(i0 * i1);
double Ay = Math.Acos(i0 * j1);
double Az = Math.Acos(i0 * k1);
double Bx = Math.Acos(j0 * i1);
double By = Math.Acos(j0 * j1);
double Bz = Math.Acos(j0 * k1);
double Cx = Math.Acos(k0 * i1);
double Cy = Math.Acos(k0 * j1);
double Cz = Math.Acos(k0 * k1);
matrizMudanca[0, 0] = Math.Cos(Ax);
matrizMudanca[1, 0] = Math.Cos(Ay);
matrizMudanca[2, 0] = Math.Cos(Az);
matrizMudanca[0, 1] = Math.Cos(Bx);
matrizMudanca[1, 1] = Math.Cos(By);
matrizMudanca[2, 1] = Math.Cos(Bz);
matrizMudanca[0, 2] = Math.Cos(Cx);
matrizMudanca[1, 2] = Math.Cos(Cy);
matrizMudanca[2, 2] = Math.Cos(Cz);
return(matrizMudanca);
} // matrizMudancaDeBase()
public void perspectivaIsometrica(vetor3 v)
{
this.X = v.X + v.Z / 2;
this.Y = v.Y + v.Z / 2;
this.cor = v.cor;
}
} // calcAnguloEntreVetores()
/// <summary>
/// calcula o raio (magnitude) do vetor 3D [v].
/// </summary>
/// <param name="v">vetor 3D de entrada.</param>
/// <returns>retorna a magnitude do vetor 3D de entrada.</returns>
public static double raio(vetor3 v)
{
return(Math.Sqrt(v.X * v.X + v.Y * v.Y + v.Z * v.Z));
} // raio()
/// <summary>
/// calcula o ângulo em radianos entre dois vetores.
/// </summary>
/// <param name="v1">vetor 1 para o cálculo.</param>
/// <param name="v2">vetor 2 para o cálculo.</param>
/// <returns>retorna o ângulo entre os dois vetores.</returns>
public static double calcAnguloEntreVetores(vetor3 v1, vetor3 v2)
{
double angulo = Math.Acos((1 / (v1.modulo() * v2.modulo())) * (v1 * v2));
return(angulo);
} // calcAnguloEntreVetores()
