Partager via

Importance de l'ordre des transformations

  • Article

Un objet unique Matrix peut stocker une transformation unique ou une séquence de transformations. Ce dernier est appelé transformation composite. La matrice d’une transformation composite est obtenue en multipliant les matrices des transformations individuelles.

Exemples de transformation composite

Dans une transformation composite, l’ordre des transformations individuelles est important. Par exemple, si vous faites d’abord pivoter, puis effectuez une mise à l’échelle, vous obtenez un résultat différent de celui que si vous traduisez d’abord, puis faites pivoter, puis mettez à l’échelle. Dans GDI+, les transformations composites sont générées de gauche à droite. Si les matrices S, R et T sont respectivement mises à l’échelle, la rotation et les matrices de traduction, le produit SRT (dans cet ordre) est la matrice de la transformation composite qui se met à l’échelle, puis effectue une rotation, puis se traduit. La matrice produite par le produit SRT est différente de la matrice produite par le produit TRS.

Un ordre de raison est important : les transformations telles que la rotation et la mise à l’échelle sont effectuées en ce qui concerne l’origine du système de coordonnées. La mise à l’échelle d’un objet centré à l’origine produit un résultat différent de celui d’un objet qui a été déplacé loin de l’origine. De même, la rotation d’un objet centré à l’origine produit un résultat différent de celui d’un objet qui a été déplacé loin de l’origine.

L’exemple suivant combine la mise à l’échelle, la rotation et la traduction (dans cet ordre) pour former une transformation composite. L’argument Append passé à la RotateTransform méthode indique que la rotation suivra la mise à l’échelle. De même, l’argument Append passé à la TranslateTransform méthode indique que la traduction suivra la rotation. Append et Prepend sont membres de l’énumération MatrixOrder .

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)

L’exemple suivant effectue les mêmes appels de méthode que l’exemple précédent, mais l’ordre des appels est inversé. L’ordre des opérations résultant est d’abord traduire, puis faire pivoter, puis mettre à l’échelle, ce qui produit un résultat très différent de celui de la première échelle, puis de la faire pivoter, puis traduire.

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)

Une façon d’inverser l’ordre des transformations individuelles dans une transformation composite consiste à inverser l’ordre d’une séquence d’appels de méthode. Une deuxième façon de contrôler l’ordre des opérations consiste à modifier l’argument d’ordre de matrice. L’exemple suivant est le même que l’exemple précédent, sauf qu’il Append a été modifié en Prepend. La multiplication de matrices est effectuée dans l’ordre SRT, où S, R et T sont les matrices pour l’échelle, la rotation et la traduction, respectivement. L’ordre de la transformation composite est d’abord mis à l’échelle, puis pivote, puis traduit.

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)

Le résultat de l’exemple précédent est le même que le résultat du premier exemple de cette rubrique. Cela est dû au fait que nous avons inversé à la fois l’ordre des appels de méthode et l’ordre de la multiplication de la matrice.

Voir aussi