Compartir a través de

¿Por qué el orden de transformación es significativo?

Un único Matrix objeto puede almacenar una sola transformación o una secuencia de transformaciones. Este último se denomina transformación compuesta. La matriz de una transformación compuesta se obtiene multiplicando las matrices de transformaciones individuales.

Ejemplos de transformación compuesta

En una transformación compuesta, el orden de las transformaciones individuales es importante. Por ejemplo, si gira por primera vez, escala y, después, traduce, obtiene un resultado diferente que si se traduce por primera vez, después gira y, a continuación, escala. En GDI+, las transformaciones compuestas se crean de izquierda a derecha. Si S, R y T son matrices de escala, rotación y traducción respectivamente, el producto SRT (en ese orden) es la matriz de la transformación compuesta que primero escala, luego gira y luego se traduce. ** La matriz producida por el producto SRT es diferente de la matriz producida por el producto TRS.

Una razón por la que el orden es significativo es que las transformaciones como la rotación y el escalado se realizan en relación con el origen del sistema de coordenadas. El escalado de un objeto centrado en el origen genera un resultado diferente al de escalar un objeto que se ha movido fuera del origen. Del mismo modo, la rotación de un objeto centrado en el origen genera un resultado diferente al de girar un objeto que se ha movido fuera del origen.

En el ejemplo siguiente se combinan el escalado, la rotación y la traducción (en ese orden) para formar una transformación compuesta. El argumento Append pasado al RotateTransform método indica que la rotación seguirá el escalado. Del mismo modo, el argumento Append pasado al TranslateTransform método indica que la traducción seguirá la rotación. Append y Prepend son miembros de la MatrixOrder enumeración.

Rectangle rect = new Rectangle(0, 0, 50, 50);
Pen pen = new Pen(Color.FromArgb(128, 200, 0, 200), 2);
e.Graphics.ResetTransform();
e.Graphics.ScaleTransform(1.75f, 0.5f);
e.Graphics.RotateTransform(28, MatrixOrder.Append);
e.Graphics.TranslateTransform(150, 150, MatrixOrder.Append);
e.Graphics.DrawRectangle(pen, rect);

Dim rect As New Rectangle(0, 0, 50, 50)
Dim pen As New Pen(Color.FromArgb(128, 200, 0, 200), 2)
e.Graphics.ResetTransform()
e.Graphics.ScaleTransform(1.75F, 0.5F)
e.Graphics.RotateTransform(28, MatrixOrder.Append)
e.Graphics.TranslateTransform(150, 150, MatrixOrder.Append)
e.Graphics.DrawRectangle(pen, rect)

En el ejemplo siguiente se realizan las mismas llamadas de método que el ejemplo anterior, pero se invierte el orden de las llamadas. El orden resultante de las operaciones es primero traducir, luego girar, luego escalar, lo que produce un resultado muy diferente que primero escalar, luego girar, luego traducir.

Rectangle rect = new Rectangle(0, 0, 50, 50);
Pen pen = new Pen(Color.FromArgb(128, 200, 0, 200), 2);
e.Graphics.ResetTransform();
e.Graphics.TranslateTransform(150, 150, MatrixOrder.Append);
e.Graphics.RotateTransform(28, MatrixOrder.Append);
e.Graphics.ScaleTransform(1.75f, 0.5f);
e.Graphics.DrawRectangle(pen, rect);

Dim rect As New Rectangle(0, 0, 50, 50)
Dim pen As New Pen(Color.FromArgb(128, 200, 0, 200), 2)
e.Graphics.ResetTransform()
e.Graphics.TranslateTransform(150, 150, MatrixOrder.Append)
e.Graphics.RotateTransform(28, MatrixOrder.Append)
e.Graphics.ScaleTransform(1.75F, 0.5F)
e.Graphics.DrawRectangle(pen, rect)

Una manera de invertir el orden de las transformaciones individuales en una transformación compuesta es invertir el orden de una secuencia de llamadas a métodos. Una segunda manera de controlar el orden de las operaciones es cambiar el argumento de orden de matriz. El ejemplo siguiente es el mismo que el ejemplo anterior, excepto que Append se ha cambiado a Prepend. La multiplicación de matriz se realiza en el orden SRT, donde S, R y T son las matrices de escala, rotación y traducción, respectivamente. El orden de la transformación compuesta es escalar primero, luego rotar y finalmente trasladar.

Rectangle rect = new Rectangle(0, 0, 50, 50);
Pen pen = new Pen(Color.FromArgb(128, 200, 0, 200), 2);
e.Graphics.ResetTransform();
e.Graphics.TranslateTransform(150, 150, MatrixOrder.Prepend);
e.Graphics.RotateTransform(28, MatrixOrder.Prepend);
e.Graphics.ScaleTransform(1.75f, 0.5f);
e.Graphics.DrawRectangle(pen, rect);

Dim rect As New Rectangle(0, 0, 50, 50)
Dim pen As New Pen(Color.FromArgb(128, 200, 0, 200), 2)
e.Graphics.ResetTransform()
e.Graphics.TranslateTransform(150, 150, MatrixOrder.Prepend)
e.Graphics.RotateTransform(28, MatrixOrder.Prepend)
e.Graphics.ScaleTransform(1.75F, 0.5F)
e.Graphics.DrawRectangle(pen, rect)

El resultado del ejemplo anterior inmediatamente es el mismo que el resultado del primer ejemplo de este tema. Esto se debe a que invertimos el orden de las llamadas al método y el orden de la multiplicación de la matriz.

Consulte también