Aplicación matrices de transformación

Se sabe que la matriz de transformación homogénea es una representación que permite la representación conjunta de la posición y de la orientación mediante el álgebra lineal. Es una matriz de dimensión 4x4 que representa la transformación de un vector de coordenadas homogéneas de un sistema de coordenadas a otro:

[pic 1]

En donde cada elemento es una su matriz, que generalmente en robótica solo interesa la de rotación y traslación, siendo las demás con utilidad en otros campos, como la de escalado, que se aplica en procesamiento de imágenes, como se verá más adelante.

Matriz transformación homogénea puramente rotacional

La submatriz de rotación R3x3 define esta rotación, de las cuales se pueden definir tres matrices homogéneas básicas de rotación según se realice esta alrededor de cada uno de los tres ejes coordenados OX,OY y OZ del sistema de referencia OXYZ.

[pic 2][pic 3]

Donde cabe notar que en las imágenes, la matriz que nos interesa para poder hacer su rotación es en el sentido z, ya que es la que nos da la sensación en 2D. Por lo que se propone la siguiente función de la clase:

Matriz de transformación homogénea puramente traslacional

Si se supone un sistema O'UVW que esta trasladado un vector p=pxi+pyj+pzk con respecto al sistema OXYZ. La matriz T corresponde a una matriz homogénea de traslación:

[pic 4]

Matriz de transformación homogénea puramente de escalado

[pic 5]

Aplicación al procesamiento de imagenes y visión artificial.

Ya conocidas las matrices de transformación, se proponen las siguientes funciones de la clase:

CMatrix4D CMatrix4D::Identity()

{

        CMatrix4D I;

        for (int j = 0; j < 4;j++)

        for (int i = 0; i < 4; i++)

                I.m[j][i] = (i == j) ? 1.0f : 0.0f;

        return I;

}

CMatrix4D CMatrix4D::Translation(float dx, float dy, float dz)

{

        CMatrix4D T = Identity();

        T.m30 = dx;

        T.m31 = dy;

        T.m32 = dz;

        return T;

}

#include 

CMatrix4D CMatrix4D::RotationMatrixZ(float theta)

{

        CMatrix4D R = Identity();

        R.m00 = cos(theta);

        R.m01 = sin(theta);

        R.m11 = cos(theta);

        R.m10 = -sin(theta);

        return R;

}

CMatrix4D CMatrix4D::Scale(float sx, float sy, float sz)

{

        CMatrix4D S = Identity();

        S.m00 = sx;

        S.m11 = sy;

        S.m22 = sz;

        return S;

}

Donde Identity es la matriz identidad, y las demás son las matrices ya vistas.

Se propone una imagen de dimensiones arbitrarias en donde se van aplicar diversos productos de las matrices de transformación a cada pixel, que junto con un timer definido, es posible ver el resultado directamente en la imagen resultante. La imagen es:

[pic 6]

El pedazo del programa de interés es el siguiente:

theta += 0.01;

                {

                        CMatrix4D S,R,T,TInv,M;

                        S = CMatrix4D::Scale(2, 2, 1);

                        R = CMatrix4D::RotationMatrixZ(theta*4);

                        T = CMatrix4D::Translation(-0.5, -0.5, 0);

                        TInv = CMatrix4D::Translation(0.5, 0.5, 0);

                        float x = 0.0f, y = 0.0f;

                        M = T*S*R*TInv;

                        y = 0;

                        float dx = 1.0f / spImgDest->GetSizeX(), dy = 1.0f / spImgDest-                                                                                        >GetSizeY();

...