Matrix.Multiply Methode

Definition

Multipliziert diese Matrix mit dem angegebenen Matrix, indem die angegebene Matrixvorausgestellt wird.

Überlädt

Multiply(Matrix)

Multipliziert diese Matrix mit der im matrix Parameter angegebenen Matrix, indem die angegebene Matrixvorausgestellt wird.

Multiply(Matrix, MatrixOrder)

Multipliziert diese Matrix mit der im matrix Parameter angegebenen Matrix und in der im order Parameter angegebenen Reihenfolge.

Multiply(Matrix)

Quelle:
Matrix.cs
Quelle:
Matrix.cs
Quelle:
Matrix.cs
Quelle:
Matrix.cs
Quelle:
Matrix.cs

Multipliziert diese Matrix mit der im matrix Parameter angegebenen Matrix, indem die angegebene Matrixvorausgestellt wird.

public:
 void Multiply(System::Drawing::Drawing2D::Matrix ^ matrix);
public void Multiply (System.Drawing.Drawing2D.Matrix matrix);
member this.Multiply : System.Drawing.Drawing2D.Matrix -> unit
Public Sub Multiply (matrix As Matrix)

Parameter

matrix
Matrix

Die Matrix, mit der diese Matrix multipliziert werden soll.

Beispiele

Ein Beispiel finden Sie unter Multiply.

Gilt für:

Multiply(Matrix, MatrixOrder)

Quelle:
Matrix.cs
Quelle:
Matrix.cs
Quelle:
Matrix.cs
Quelle:
Matrix.cs
Quelle:
Matrix.cs

Multipliziert diese Matrix mit der im matrix Parameter angegebenen Matrix und in der im order Parameter angegebenen Reihenfolge.

public:
 void Multiply(System::Drawing::Drawing2D::Matrix ^ matrix, System::Drawing::Drawing2D::MatrixOrder order);
public void Multiply (System.Drawing.Drawing2D.Matrix matrix, System.Drawing.Drawing2D.MatrixOrder order);
member this.Multiply : System.Drawing.Drawing2D.Matrix * System.Drawing.Drawing2D.MatrixOrder -> unit
Public Sub Multiply (matrix As Matrix, order As MatrixOrder)

Parameter

matrix
Matrix

Die Matrix, mit der diese Matrix multipliziert werden soll.

order
MatrixOrder

Die MatrixOrder, die die Reihenfolge der Multiplikation darstellt.

Beispiele

Das folgende Codebeispiel wurde für die Verwendung mit Windows Forms entwickelt und erfordert PaintEventArgse, ein Paint-Ereignisobjekt. Der Code führt die folgenden Aktionen aus:

  • Erstellt drei Matrizen.

  • Listet den Inhalt der Matrix 1 auf dem Bildschirm auf.

  • Multipliziert Matrix 1 mit Matrix 2 und speichert das Ergebnis in Matrix 1.

  • Listet den Inhalt der Matrix 1 auf dem Bildschirm auf.

  • Multipliziert das in Matrix 1 gespeicherte Ergebnis mit Matrix 3 und speichert das Ergebnis erneut in Matrix 1.

  • Listet den Inhalt der Matrix 1 auf dem Bildschirm auf.

  • Zeichnet ein Rechteck auf den Bildschirm, bevor die Matrix 1-Transformation angewendet wird (das blaue Rechteck).

  • Wendet die Transformation auf das Rechteck an.

  • Zeichnet das transformierte Rechteck auf den Bildschirm (das rote Rechteck), wobei die gleichen Koordinaten wie das vorherige Rechteck verwendet werden.

Beachten Sie, dass das rote Rechteck um einen Faktor von zwei in horizontaler Richtung skaliert wurde, dann um 90 Grad gedreht und dann 250 Punkt in x-Richtung und 50 Punkt in der Y-Richtung verschoben (übersetzt) wurde.

public:
   void MultiplyExample( PaintEventArgs^ e )
   {
      Pen^ myPen = gcnew Pen( Color::Blue,1.0f );
      Pen^ myPen2 = gcnew Pen( Color::Red,1.0f );

      // Set up the matrices.
      Matrix^ myMatrix1 = gcnew Matrix( 2.0f,0.0f,0.0f,1.0f,0.0f,0.0f );
      Matrix^ myMatrix2 = gcnew Matrix( 0.0f,1.0f,-1.0f,0.0f,0.0f,0.0f );
      Matrix^ myMatrix3 = gcnew Matrix( 1.0f,0.0f,0.0f,1.0f,250.0f,50.0f );

      // Display the elements of the starting matrix.
      ListMatrixElements( e, myMatrix1, "Beginning Matrix", 6, 40 );

      // Multiply Matrix1 by Matrix 2.
      myMatrix1->Multiply( myMatrix2, MatrixOrder::Append );

      // Display the result of the multiplication of Matrix1 and
      // Matrix2.
      ListMatrixElements( e, myMatrix1, "Matrix After 1st Multiplication", 6, 60 );

      // Multiply the result from the previous multiplication by
      // Matrix3.
      myMatrix1->Multiply( myMatrix3, MatrixOrder::Append );

      // Display the result of the previous multiplication
      // multiplied by Matrix3.
      ListMatrixElements1( e, myMatrix1, "Matrix After 2nd Multiplication", 6, 80 );

      // Draw the rectangle prior to transformation.
      e->Graphics->DrawRectangle( myPen, 0, 0, 100, 100 );

      // Make the transformation.
      e->Graphics->Transform = myMatrix1;

      // Draw the rectangle after transformation.
      e->Graphics->DrawRectangle( myPen2, 0, 0, 100, 100 );
   }

   //-------------------------------------------------------
   // The following function is a helper function to
   // list the contents of a matrix.
   //-------------------------------------------------------
   void ListMatrixElements1( PaintEventArgs^ e, Matrix^ matrix, String^ matrixName, int numElements, int y )
   {
      // Set up variables for drawing the array
      // of points to the screen.
      int i;
      float x = 20,X = 200;
      System::Drawing::Font^ myFont = gcnew System::Drawing::Font( "Arial",8 );
      SolidBrush^ myBrush = gcnew SolidBrush( Color::Black );

      // Draw the matrix name to the screen.
      e->Graphics->DrawString( String::Concat( matrixName, ":  " ), myFont, myBrush, (float)x, (float)y );

      // Draw the set of path points and types to the screen.
      for ( i = 0; i < numElements; i++ )
      {
         e->Graphics->DrawString( String::Concat( matrix->Elements[ i ], ", " ), myFont, myBrush, (float)X, (float)y );
         X += 30;
      }
   }
public void MultiplyExample(PaintEventArgs e)
{
    Pen myPen = new Pen(Color.Blue, 1);
    Pen myPen2 = new Pen(Color.Red, 1);
             
    // Set up the matrices.
    Matrix myMatrix1 = new Matrix(
        2.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);  
    
    Matrix myMatrix2 = new Matrix(
        0.0f, 1.0f, -1.0f, 0.0f, 0.0f, 0.0f); 
  
    Matrix myMatrix3 = new Matrix(
        1.0f, 0.0f, 0.0f, 1.0f, 250.0f, 50.0f);  

    // Display the elements of the starting matrix.
    ListMatrixElements(e, myMatrix1, "Beginning Matrix", 6, 40);
             
    // Multiply Matrix1 by Matrix 2.
    myMatrix1.Multiply(myMatrix2, MatrixOrder.Append);
             
    // Display the result of the multiplication of Matrix1 and
             
    // Matrix2.
    ListMatrixElements(e,
        myMatrix1,
        "Matrix After 1st Multiplication",
        6,
        60);
             
    // Multiply the result from the pervious multiplication by
    // Matrix3.
    myMatrix1.Multiply(myMatrix3, MatrixOrder.Append);
             
    // Display the result of the previous multiplication
    // multiplied by Matrix3.
    ListMatrixElements1(e,
        myMatrix1,
        "Matrix After 2nd Multiplication",
        6,
        80);
             
    // Draw the rectangle prior to transformation.
    e.Graphics.DrawRectangle(myPen, 0, 0, 100, 100);
             
    // Make the transformation.
    e.Graphics.Transform = myMatrix1;
             
    // Draw the rectangle after transformation.
    e.Graphics.DrawRectangle(myPen2, 0, 0, 100, 100);
}
             
//-------------------------------------------------------
// The following function is a helper function to
// list the contents of a matrix.
//-------------------------------------------------------
public void ListMatrixElements1(
    PaintEventArgs e,
    Matrix matrix,
    string matrixName,
    int numElements,
    int y)
{
             
    // Set up variables for drawing the array
    // of points to the screen.
    int i;
    float x = 20, X = 200;
    Font myFont = new Font("Arial", 8);
    SolidBrush myBrush = new SolidBrush(Color.Black);
             
    // Draw the matrix name to the screen.
    e.Graphics.DrawString(
        matrixName + ":  ",
        myFont,
        myBrush,
        x,
        y);
             
    // Draw the set of path points and types to the screen.
    for(i=0; i<numElements; i++)
    {
        e.Graphics.DrawString(
            matrix.Elements[i].ToString() + ", ",
            myFont,
            myBrush,
            X,
            y);
        X += 30;
    }
}
Public Sub MultiplyExample(ByVal e As PaintEventArgs)
    Dim myPen As New Pen(Color.Blue, 1)
    Dim myPen2 As New Pen(Color.Red, 1)

    ' Set up the matrices.
    Dim myMatrix1 As New Matrix(2.0F, 0.0F, 0.0F, 1.0F, 0.0F, 0.0F)

    ' Scale.
    Dim myMatrix2 As New Matrix(0.0F, 1.0F, -1.0F, 0.0F, 0.0F, 0.0F)

    ' Rotate 90.
    Dim myMatrix3 As New Matrix(1.0F, 0.0F, 0.0F, 1.0F, 250.0F, 50.0F)

    ' Display the elements of the starting matrix.
    ListMatrixElementsHelper(e, myMatrix1, "Beginning Matrix", 6, 40)

    ' Multiply Matrix1 by Matrix 2.
    myMatrix1.Multiply(myMatrix2, MatrixOrder.Append)

    ' Display the result of the multiplication of Matrix1 and
    ' Matrix2.
    ListMatrixElementsHelper(e, myMatrix1, _
    "Matrix After 1st Multiplication", 6, 60)

    ' Multiply the result from the pervious multiplication by
    ' Matrix3.
    myMatrix1.Multiply(myMatrix3, MatrixOrder.Append)

    ' Display the result of the previous multiplication
    ' multiplied by Matrix3.
    ListMatrixElementsHelper1(e, myMatrix1, _
    "Matrix After 2nd Multiplication", 6, 80)

    ' Draw the rectangle prior to transformation.
    e.Graphics.DrawRectangle(myPen, 0, 0, 100, 100)
    e.Graphics.Transform = myMatrix1

    ' Draw the rectangle after transformation.
    e.Graphics.DrawRectangle(myPen2, 0, 0, 100, 100)
End Sub

' A helper function to list the contents of a matrix.
Public Sub ListMatrixElementsHelper1(ByVal e As PaintEventArgs, _
ByVal matrix As Matrix, ByVal matrixName As String, ByVal numElements As Integer, _
ByVal y As Integer)

    ' Set up variables for drawing the array

    ' of points to the screen.
    Dim i As Integer
    Dim x As Single = 20
    Dim j As Single = 200
    Dim myFont As New Font("Arial", 8)
    Dim myBrush As New SolidBrush(Color.Black)

    ' Draw the matrix name to the screen.
    e.Graphics.DrawString(matrixName + ":  ", myFont, myBrush, x, y)

    ' Draw the set of path points and types to the screen.
    For i = 0 To numElements - 1
        e.Graphics.DrawString(matrix.Elements(i).ToString() + ", ", _
        myFont, myBrush, j, y)
        j += 30
    Next i
End Sub

Hinweise

Wenn die angegebene Reihenfolge Prependist, wird diese Matrix mit der angegebenen Matrix in einer vordefinierten Reihenfolge multipliziert. Wenn die angegebene Reihenfolge Appendist, wird diese Matrix mit der angegebenen Matrix in einer angefügten Reihenfolge multipliziert.

Gilt für: