} // rotacionaVetor
/// rotaciona o vetor simultaneamente no plano XZ,YZ e XY, nesta ordem, com acréscimos de ângulos em Graus.
/// Calculos:
/// x=r*cos(tetaIni+teta)
/// x=r*(cos(tetaIni)*cos(teta)-sen(tetaIni)*sen(teta))
///
/// x=xini*cos(teta)-yini*sen(teta)
///
/// y=r*sen(tetaIni+teta)
/// y=r*(sen(tetaIni)*cos(teta)+sen(teta)*cos(tetaIni))
///
/// y=yini*cos(teta)+xini*sen(teta)
/// y=xini*sen(teta)+yini*cos(teta)
///
///
/// Matriz de rotação (plano XY):
/// | cos(teta) sen(teta) 0|
/// |-sen(teta) cos(teta) 0|
/// | 0 0 1|
/// <summary>
/// rotaciona um vetor, intercalando 3 matrizes de rotação, para rotacionar os três planos (XY,YZ e XZ).
/// </summary>
/// <param name="anguloRotacaoPlanoXZEmGraus">ângulo para o plano XZ.</param>
/// <param name="anguloRotacaoPlanoYZEmGraus">ângulo para o plano YZ.</param>
/// <param name="anguloRotacaoPlanoXYEmGraus">ângulo para o plano XY.</param>
/// <param name="isAnguloAbsoluto">se [true] os ângulos do vetor são substituidos pelos ângulos parâmetros,
/// se [false] os ângulos do vetor são acrescidos com os ângulos parâmetros.</param>
public void rotacionaVetor(double anguloRotacaoPlanoXZEmGraus,
double anguloRotacaoPlanoYZEmGraus,
double anguloRotacaoPlanoXYEmGraus)
{
double omegaXY = angulos.toRadianos(anguloRotacaoPlanoXYEmGraus);
double omegaXZ = angulos.toRadianos(anguloRotacaoPlanoXZEmGraus);
double omegaYZ = angulos.toRadianos(anguloRotacaoPlanoYZEmGraus);
// converte o vetor currente para uma matriz.
Matriz vetor = new Matriz(1, 3, X, Y, Z);
// matriz de rotação para o plano XY.
Matriz rotXY = new Matriz(3, 3, Math.Cos(omegaXY), Math.Sin(omegaXY), 0,
-Math.Sin(omegaXY), Math.Cos(omegaXY), 0,
0, 0, 1);
// matriz de rotação para o plano XZ.
Matriz rotXZ = new Matriz(3, 3, Math.Cos(omegaXZ), 0, Math.Sin(omegaXZ),
0, 1, 0,
-Math.Sin(omegaXZ), 0, Math.Cos(omegaXZ));
// matriz de rotação para o plano YZ.
Matriz rotYZ = new Matriz(3, 3, 1, 0, 0,
0, Math.Cos(omegaYZ), Math.Sin(omegaYZ),
0, -Math.Sin(omegaYZ), Math.Cos(omegaYZ));
// multiplicação da matriz-vetor pelas matrizes de rotação.
Matriz vetorFinal = vetor * rotXY * rotXZ * rotYZ;
// extrai o vetor currente da matriz-vetor.
this.X = vetorFinal.getElemento(0, 0);
this.Y = vetorFinal.getElemento(0, 1);
this.Z = vetorFinal.getElemento(0, 2);
} // rotacionaVetor()
} // rotacionaImagemComDoisEixos2D()
/// <summary>
/// aplica a imagem [cena] um eixo X e Y dados, sendo o eixo X
/// rotacionado por um ângulo [angle]; o eixo Y é calculado por este método.
/// </summary>
/// <param name="cena">imagem em processamento.</param>
/// <param name="angle">ângulo em graus para o incremento no eixo X e no eixo Y.</param>
/// <param name="eixoX_2D">eixo X calculado manualmente com marcação na imagem [cena].</param>
/// <param name="dimCells">dimensões da imagem final, já processada.</param>
/// <returns>retorna a imagem rotacionada.</returns>
public static Bitmap rotacionaImagemComUmEixo2D(Bitmap cena, double angle, vetor2 eixoX_2D, Size dimCells)
{
if (cena == null)
{
throw new Exception("erro no metodo rotacionaImagemComUmEixo2D(), imagem currente e' nula");
}
double anguloInc = angle;
// prepara os eixos X e Y.
// O eixo Y é conseguido rotacionando o eixo X por 90 graus.
// O eixo X é conseguido rotacionando o eixo Y por -90 graus.
// inicializa o eixo X, a partir do eixoX_2D, que é um eixo X aparente, conseguido com marcação na imagem.
vetor2 ex = new vetor2(eixoX_2D.X, eixoX_2D.Y);
// eixo Y, que foi calculado neste método como uma rotação de 90 graus sobre o eixo X [ex].
vetor2 ey = angulos.rotacionaVetor(90.0F, ex);
// constrói o eixo X como uma matriz [1,2].
MATRIZES.Matriz mtEixoX = new MATRIZES.Matriz(1, 2);
mtEixoX.setElemento(0, 0, ex.X);
mtEixoX.setElemento(0, 1, ex.Y);
// constroi a matriz de transformação (dos eixos construídos para os eixos (1,0) e (0,1).
MATRIZES.Matriz mtrzTransf = new MATRIZES.Matriz(2, 2);
mtrzTransf.setElemento(0, 0, ex.X);
mtrzTransf.setElemento(0, 1, ex.Y);
mtrzTransf.setElemento(1, 0, ey.X);
mtrzTransf.setElemento(1, 1, ey.Y);
// calcula a matriz inversa de transformação.
MATRIZES.Matriz mtrzTransfInversa = MATRIZES.Matriz.MatrizInversa(mtrzTransf);
// multiplica a matriz do eixo X pela matriz inversa de transformação.
MATRIZES.Matriz mtEixoXTransformado = mtEixoX * mtrzTransfInversa;
// rotaciona o eixo X
mtEixoXTransformado = angulos.rotacionaVetor(anguloInc, mtEixoXTransformado);
// constroi o eixo Y como sendo uma rotação de 90.0F graus no eixo X.
MATRIZES.Matriz mtEixoYTransformado = angulos.rotacionaVetor(90.0F, mtEixoXTransformado);
// mutliplica os eixos X e Y pela matriz de transformação, retornando para o universo 2D inicial.
mtEixoXTransformado = mtEixoXTransformado * mtrzTransf;
mtEixoYTransformado = mtEixoYTransformado * mtrzTransf;
// converte a matriz do eixo X para um [vetor2].
vetor2 eixoXFinal = new vetor2((double)mtEixoXTransformado.getElemento(0, 0),
(double)mtEixoXTransformado.getElemento(0, 1));
// converte a matriz do eixo Y para um [vetor2].
vetor2 eixoYFinal = new vetor2((double)mtEixoYTransformado.getElemento(0, 0),
(double)mtEixoYTransformado.getElemento(0, 1));
// normaliza os eixos finais.
eixoXFinal = vetor2.normaliza(eixoXFinal);
eixoYFinal = vetor2.normaliza(eixoYFinal);
// retorna uma Imagem construida com os eixos finais.
return(new Bitmap(aplicaEixos(cena, eixoXFinal, eixoYFinal, dimCells)));
} // rotacionaImagemComUmEixo2D
} // rotacionaVetor()
public static MATRIZES.Matriz rotacionaVetor(double anguloEmGraus, MATRIZES.Matriz mtv)
{
vetor2 vInicial = new vetor2((double)mtv.getElemento(0, 0), (double)mtv.getElemento(0, 1));
vetor2 vFinal = rotacionaVetor(anguloEmGraus, vInicial);
MATRIZES.Matriz mtFinal = new MATRIZES.Matriz(1, 2);
mtFinal.setElemento(0, 0, (double)vFinal.X);
mtFinal.setElemento(0, 1, (double)vFinal.Y);
return(mtFinal);
}
} // 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>
/// rotaciona uma imagem nos eixos X e Y por um angulo,
/// sendos os eixos retirados a partir de marcação numa imagem.
/// </summary>
/// <param name="cena">Imagem a ser rotacionada.</param>
/// <param name="angle">angulo em graus para o qual os eixos X e Y serem transformados.</param>
/// <param name="eixoX_2D">eixo X conseguido através de marcação na imagem.</param>
/// <param name="eixoY_2D">eixo Y conseguido através de marcação na imagem.</param>
/// <param name="dimCell">dimensões da imagem final, já processada.</param>
/// <returns>retorna uma imagem rotacionada pelo angulo em graus [angle], aplicado em eixos X e Y,
/// transformados para (1,0) e (0,1).</returns>
public static Bitmap rotacionaImagemComDoisEixos2D(Bitmap cena, double[] angle,
vetor2 eixoX_2D,
vetor2 eixoY_2D,
Size dimCell)
{
if (cena == null)
{
throw new Exception("erro no metodo rotacionaImagemComUmEixo2D(), imagem currente e' nula");
}
// inicializa o eixo X, a partir do eixoX_2D, que é um eixo X aparente, conseguido com marcação na imagem.
vetor2 ex = new vetor2(eixoX_2D.X, eixoX_2D.Y);
// inicializa o eixo Y, a partir do eixoY_2D, que é um eixo Y aparente, conseguido com marcação na imagem.
vetor2 ey = new vetor2(eixoY_2D.X, eixoY_2D.Y);
// normaliza o eixo X [ex].
ex = vetor2.normaliza(ex);
// normaliza o eixo Y [ey].
ey = vetor2.normaliza(ey);
// constrói o eixo X como uma matriz [1,2].
MATRIZES.Matriz mtEixoX = new MATRIZES.Matriz(1, 2);
mtEixoX.setElemento(0, 0, ex.X);
mtEixoX.setElemento(0, 1, ex.Y);
// constrói o eixo Y como uma matriz [1,2].
MATRIZES.Matriz mtEixoY = new MATRIZES.Matriz(1, 2);
mtEixoY.setElemento(0, 0, ey.X);
mtEixoY.setElemento(0, 1, ey.Y);
// constroi a matriz de transformação (dos eixos construídos para os eixos (1,0) e (0,1).
MATRIZES.Matriz mtrzTransf = new MATRIZES.Matriz(2, 2);
mtrzTransf.setElemento(0, 0, ex.X);
mtrzTransf.setElemento(0, 1, ex.Y);
mtrzTransf.setElemento(1, 0, ey.X);
mtrzTransf.setElemento(1, 1, ey.Y);
// calcula a matriz inversa de transformação.
MATRIZES.Matriz mtrzTransfInversa = MATRIZES.Matriz.MatrizInversa(mtrzTransf);
// multiplica a matriz do eixo X pela matriz inversa de transformação.
MATRIZES.Matriz mtEixoXTransformado = mtEixoX * mtrzTransfInversa;
MATRIZES.Matriz mtEixoYTransformado = mtEixoY * mtrzTransfInversa;
// rotaciona o eixo X transformado, com o ângulo 0.
mtEixoXTransformado = angulos.rotacionaVetor(angle[0], mtEixoXTransformado);
// rotaciona o eixo Y transformado, com o ângulo 1.
mtEixoYTransformado = angulos.rotacionaVetor(angle[1], mtEixoYTransformado);
// mutliplica os eixos X e Y pela matriz de transformação, retornando para o universo 2D inicial.
mtEixoXTransformado = mtEixoXTransformado * mtrzTransf;
mtEixoYTransformado = mtEixoYTransformado * mtrzTransf;
// converte a matriz do eixo X para um [vetor2].
vetor2 eixoXFinal = new vetor2((double)mtEixoXTransformado.getElemento(0, 0),
(double)mtEixoXTransformado.getElemento(0, 1));
// converte a matriz do eixo Y para um [vetor2].
vetor2 eixoYFinal = new vetor2((double)mtEixoYTransformado.getElemento(0, 0),
(double)mtEixoYTransformado.getElemento(0, 1));
// normaliza os eixos finais.
eixoXFinal = vetor2.normaliza(eixoXFinal);
eixoYFinal = vetor2.normaliza(eixoYFinal);
// retorna uma Imagem construida com os eixos finais.
return(new Bitmap(aplicaEixos(cena, eixoXFinal, eixoYFinal, dimCell), dimCell));
} // rotacionaImagemComDoisEixos2D()