Valeur qui affecte le positionnement des pixels sur l'axe x lors du redimensionnement ou de la rotation d'une image.

import flash.geom.Matrix;

var myMatrix:Matrix = new Matrix();
trace(myMatrix.a);  // 1

myMatrix.a = 2;
trace(myMatrix.a);  // 2

Valeur qui affecte le positionnement des pixels sur l'axe y lors de la rotation ou de l'inclinaison d'une image.

import flash.geom.Matrix;
 
var myMatrix:Matrix = new Matrix();
trace(myMatrix.b);  // 0

var degrees:Number = 30;
var radians:Number = (degrees/180) * Math.PI;
myMatrix.b = Math.tan(radians);
trace(myMatrix.b);  // 0.5773502691896257

Valeur qui affecte le positionnement des pixels sur l'axe x lors de la rotation ou de l'inclinaison d'une image.

import flash.geom.Matrix;

var myMatrix:Matrix = new Matrix();
trace(myMatrix.c);  // 0

var degrees:Number = 30;
var radians:Number = (degrees/180) * Math.PI;
myMatrix.c = Math.tan(radians);
trace(myMatrix.c);  // 0.5773502691896257

Valeur qui affecte le positionnement des pixels sur l'axe y lors du redimensionnement ou de la rotation d'une image.

import flash.geom.Matrix;

var myMatrix:Matrix = new Matrix();
trace(myMatrix.d);  // 1

myMatrix.d = 2;
trace(myMatrix.d);  // 2

Distance de translation de chaque point sur l'axe x.

import flash.geom.Matrix;

var myMatrix:Matrix = new Matrix();
trace(myMatrix.tx);  // 0

myMatrix.tx = 50;  // 50
trace(myMatrix.tx);

Distance de translation de chaque point sur l'axe y.

import flash.geom.Matrix;

var myMatrix:Matrix = new Matrix();
trace(myMatrix.ty);  // 0

myMatrix.ty = 50;
trace(myMatrix.ty);  // 50

Crée un objet Matrix avec les paramètres spécifiés. Dans la notation des matrices, les propriétés sont organisées comme suit :

Si vous ne transmettez aucun paramètre au constructeur new Matrix(), celui-ci crée une matrice d'identité dotée des valeurs suivantes :

Dans la notation des matrices, la matrice d'identité a l'aspect suivant :

import flash.geom.Matrix;

var matrix_1:Matrix = new Matrix();
trace(matrix_1);  // (a=1, b=0, c=0, d=1, tx=0, ty=0)

var matrix_2:Matrix = new Matrix(1, 2, 3, 4, 5, 6);
trace(matrix_2);  // (a=1, b=2, c=3, d=4, tx=5, ty=6)

Renvoie un nouvel objet Matrix, clone de cette matrice, avec une copie exacte de l'objet contenu.

Concatène une matrice et la matrice actuelle, ce qui a pour effet de combiner les effets géométriques des deux matrices. En termes mathématiques, la concaténation de deux matrices revient à les combiner par l'intermédiaire de la multiplication de matrices.

Par exemple, si la matrice m1 redimensionne un objet en le multipliant par 4 et si la matrice m2 fait pivoter un objet de 1,5707963267949 radians (Math.PI/2), alors m1.concat(m2) transforme m1 en une matrice qui redimensionne un objet en le multipliant par 4 et le fait pivoter de Math.PI/2 radians.

Cette méthode permet de remplacer la matrice source par la matrice concaténée. Si vous souhaitez concaténer deux matrices sans modifier les deux matrices source, copiez d'abord la matrice source via la méthode clone(), comme indiqué dans la section relative aux exemples de la classe.

Paramètres

Inclut les paramètres de redimensionnement, de rotation et de translation. Lorsqu'elle est appliquée à une matrice, elle définit ses valeurs en fonction de ces paramètres.

L'utilisation de la méthode createBox() vous permet d'obtenir la même matrice que si vous appliquiez successivement les méthodes identity(), rotate(), scale() et translate(). Par exemple, mat1.createBox(2,2, Math.PI/4, 100, 100) permet d'obtenir le résultat suivant :

import flash.geom.Matrix;
          var mat1:Matrix = new Matrix();
     mat1.identity();
     mat1.rotate(Math.PI/4);
     mat1.scale(2,2);
     mat1.translate(10,20);

Paramètres

Voir aussi

package
{
    import flash.display.Shape;
    import flash.display.Sprite;
    import flash.geom.Matrix;
    import flash.geom.Transform;
    
    public class Matrix_createBox extends Sprite
    {
        public function Matrix_createBox()
        {
             var myMatrix:Matrix = new Matrix();
             trace(myMatrix.toString());  // (a=1, b=0, c=0, d=1, tx=0, ty=0)
             
             myMatrix.createBox(1, 2, Math.PI/4, 50, 100);
             trace(myMatrix.toString());  
             // (a=0.7071067811865476, b=1.414213562373095, c=-0.7071067811865475, 
             //  d=1.4142135623730951, tx=100, ty=200)
             
             var rectangleShape:Shape = createRectangle(20, 80, 0xFF0000);   
             addChild(rectangleShape);
              
             var rectangleTrans:Transform = new Transform(rectangleShape);
             rectangleTrans.matrix = myMatrix;
        }
        
        public function createRectangle(w:Number, h:Number, color:Number):Shape 
        {
            var rect:Shape = new Shape();
            rect.graphics.beginFill(color);
            rect.graphics.drawRect(0, 0, w, h);
            addChild(rect);
            return rect;
        }
    }
}

Crée le style spécifique de matrice attendu par les méthodes beginGradientFill() et lineGradientStyle() de la classe Graphics. La largeur et la hauteur sont redimensionnées selon une paire scaleX/scaleY et les valeurs tx/ty sont décalées de la moitié de la largeur et de la hauteur.

Par exemple, supposons un dégradé possédant les caractéristiques suivantes:

• GradientType.LINEAR
• Deux couleurs, vert et bleu, le tableau des rapports (ratios) correspondant à [0, 255]
• SpreadMethod.PAD
• InterpolationMethod.LINEAR_RGB

Les illustrations suivantes représentent des dégradés dans lesquels la matrice a été définie à l'aide de la méthode createGradientBox() et un paramétrage différent :

Paramètres createGradientBox()	Dégradé obtenu
width = 25; height = 25; rotation = 0; tx = 0; ty = 0;
width = 25; height = 25; rotation = 0; tx = 25; ty = 0;
width = 50; height = 50; rotation = 0; tx = 0; ty = 0;
width = 50; height = 50; rotation = Math.PI / 4; // 45 degrees tx = 0; ty = 0;

Paramètres

Voir aussi

package
{
    import flash.display.GradientType;
    import flash.display.Sprite;
    import flash.geom.Matrix;
    
    public class Matrix_createGradientBox extends Sprite
    {
        public function Matrix_createGradientBox()
        {
             var myMatrix:Matrix = new Matrix();
             trace(myMatrix.toString());          // (a=1, b=0, c=0, d=1, tx=0, ty=0)
             
             myMatrix.createGradientBox(200, 200, 0, 50, 50);
             trace(myMatrix.toString());          // (a=0.1220703125, b=0, c=0, d=0.1220703125, tx=150, ty=150)
             
             var colors:Array = [0xFF0000, 0x0000FF];
             var alphas:Array = [100, 100];
             var ratios:Array = [0, 0xFF];
             
             this.graphics.beginGradientFill(GradientType.LINEAR, colors, alphas, ratios, myMatrix);
             this.graphics.drawRect(0, 0, 300, 200);
        }
    }
}

Etant donné un point dans l'espace de coordonnées de prétransformation, cette méthode renvoie les coordonnées de ce point après la transformation. Contrairement à la transformation standard appliquée via la méthode transformPoint(), la transformation de la méthode deltaTransformPoint() ne prend pas en considération les paramètres de translation tx et ty.

Paramètres

Règle chaque propriété d'une matrice sur une valeur qui entraîne une transformation nulle. Un objet transformé par l'application d'une matrice d'identité est identique à l'objet d'origine.

Faisant suite à l'appel de la méthode identity(), la matrice obtenue présente les propriétés suivantes : a =1, b =0, c =0, d =1, tx =0, ty =0.

Dans la notation des matrices, la matrice d'identité a l'aspect suivant :

Effectue la transformation opposée de la matrice d'origine. Vous pouvez appliquer une matrice inversée à un objet pour annuler la transformation effectuée lors de l'application de la matrice d'origine.

package
{
    import flash.display.Shape;
    import flash.display.Sprite;
    import flash.geom.Matrix;
    import flash.geom.Transform;
    
    public class Matrix_invert extends Sprite
    {
        public function Matrix_invert()
        {
            var rect0:Shape = createRectangle(20, 80, 0xFF0000);   
            var rect1:Shape = createRectangle(20, 80, 0x00FF00);   
            var rect2:Shape = createRectangle(20, 80, 0x0000FF);
            var rect3:Shape = createRectangle(20, 80, 0x000000);
            
            var trans0:Transform = new Transform(rect0);
            var trans1:Transform = new Transform(rect1);
            var trans2:Transform = new Transform(rect2);
            var trans3:Transform = new Transform(rect3);
             
            var doubleScaleMatrix:Matrix = new Matrix(2, 0, 0, 2, 0, 0);
            trans0.matrix = doubleScaleMatrix;
            trace(doubleScaleMatrix.toString());  // (a=2, b=0, c=0, d=2, tx=0, ty=0)
             
            var noScaleMatrix:Matrix = new Matrix(1, 0, 0, 1, 0, 0);
            trans1.matrix = noScaleMatrix;
            rect1.x = 50;
            trace(noScaleMatrix.toString());  // (a=1, b=0, c=0, d=1, tx=0, ty=0)
             
            var halfScaleMatrix:Matrix = doubleScaleMatrix.clone();
            halfScaleMatrix.invert();
            trans2.matrix = halfScaleMatrix;
            rect2.x = 100;
            trace(halfScaleMatrix.toString());  // (a=0.5, b=0, c=0, d=0.5, tx=0, ty=0)
             
            var originalAndInverseMatrix:Matrix = doubleScaleMatrix.clone();
            originalAndInverseMatrix.concat(halfScaleMatrix);
            trans3.matrix = originalAndInverseMatrix;
            rect3.x = 150;
            trace(originalAndInverseMatrix.toString());  // (a=1, b=0, c=0, d=1, tx=0, ty=0)            
        }
        
        public function createRectangle(w:Number, h:Number, color:Number):Shape 
        {
            var rect:Shape = new Shape();
            rect.graphics.beginFill(color);
            rect.graphics.drawRect(0, 0, w, h);
            addChild(rect);
            return rect;
        }
    }
}

Applique une transformation de rotation à l'objet Matrix.

La méthode rotate() modifie les propriétés a, b, c et d de l'objet Matrix. Dans la notation des matrices, cela équivaut à concaténer la matrice actuelle et les matrices ci-dessous :

Paramètres

Voir aussi

Applique une transformation de redimensionnement à la matrice. L'axe des x est multiplié par sx, et l'axe des y par sy.

La méthode scale() modifie les propriétés a et d de l'objet Matrix. Dans la notation des matrices, cela équivaut à concaténer la matrice actuelle et les matrices ci-dessous :

Paramètres

Voir aussi

Renvoie une valeur de texte donnant la liste des propriétés de l'objet Matrix.

Renvoie le résultat de l'application de la transformation géométrique représentée par l'objet Matrix au point spécifié.

Paramètres

Translation de la matrice sur les axes x et y en fonction des paramètres dx et dy.

Paramètres

Voir aussi

1. L'application crée un nouvel objet Matrix myMatrix et utilise la méthode trace() pour produire les valeurs de propriété par défaut de l'objet myMatrix.
2. L'application appelle createGradientBox() avec les paramètres width et height définis sur 200 pixels ; il n'y a pas de rotation et la distance à translater sur les axes x et y est définie sur 50 pixels.
3. L'application imprime l'objet myMatrix une nouvelle fois pour signaler la modification après l'appel de createGradientBox().
4. L'application utilise trois variables pour contrôler le remplissage de la zone de dégradé :
   • colors : définit les couleurs de dégradé allant du rouge au bleu unis.
   • alphas : définit l'opacité sur uni.
   • ratios : définit une répartition des couleurs égale pour le rouge et le bleu.
5. L'application appelle la méthode Graphics beginGradientFill(), qui est active sur l'objet myMatrix, et la méthode lineTo(), qui se traduit par une zone de remplissage dégradée.

package {
    import flash.geom.Matrix;
    import flash.display.Sprite;
    import flash.display.GradientType;

    public class MatrixExample extends Sprite {

        public function MatrixExample() {
            var myMatrix:Matrix = new Matrix();
            trace(myMatrix.toString());    // (a=1, b=0, c=0, d=1, tx=0, ty=0)

            myMatrix.createGradientBox(200, 200, 0, 50, 50);
            trace(myMatrix.toString());    // (a=0.1220703125, b=0, c=0, d=0.1220703125, tx=150, ty=150)

            var colors:Array = [0xFF0000, 0x0000FF];
            var alphas:Array = [100, 100];
            var ratios:Array = [0, 0xFF];
            graphics.beginGradientFill(GradientType.LINEAR, colors, alphas, ratios, myMatrix);
            graphics.lineTo(0, 300);
            graphics.lineTo(300, 300);
            graphics.lineTo(300, 0);
            graphics.lineTo(0, 0);
        }
    }
}