Matrix 90 Grad um Z-Achse drehen

[Bjoerk]

Ich hab eine Matrix, die sieht so aus. Diese Matrix ist bezüglich dieses KOO definiert.

Code:

 Z
 |     Y
 |   .
 | .
-|------ X

Delphi-Quellcode:

function TZzBeamTools.BeamSmLc(const E, G, Iy, It, x1, y1, x2, y2: double): TZzFloatMat1212;
var
  I, J: integer;
  S, SS, SSS, EIy, GIt : double;
begin
  GIt := G * It;
  EIy := E * Iy;

  S := Sqrt(Sqr(x2 - x1) + Sqr(y2 - y1)); // z1 = z2 = 0;
  SS := S * S;
  SSS := SS * S;

  for I := 1 to 12 do
    for J := 1 to 12 do
      Result[I, J] := 0;

  // Result[I, J] = Schnittkraft Si infolge Vj;
  // Si: Q = Querkraft, M = Moment;
  // Vj: V = Verschiebung, Phi = Verdrehung;

  Result[3, 3] := 12 * EIy / SSS; // S3(= Q.Z.L) infolge V3(= V.Z.L) = 1;
  Result[3, 5] := -6 * EIy / SS; // S3(= Q.Z.L) infolge V5(= Phi.Y.L) = 1;
  Result[3, 9] := -12 * EIy / SSS; // S3(= Q.Z.L) infolge V9(= V.Z.R) = 1;
  Result[3, 11] := -6 * EIy / SS; // S3(= Q.Z.L) infolge V11(= Phi.Y.R) = 1;

  Result[4, 4] := GIt / S; // S4(= M.X.L) infolge V4(= Phi.X.L) = 1;
  Result[4, 10] := -GIt / S; // S4(= M.X.L) infolge V10(= Phi.X.R) = 1;

  Result[5, 5] := 4 * EIy / S; // S5(= M.Y.L) infolge V5(= Phi.Y.L) = 1;
  Result[5, 9] := 6 * EIy / SS; // S5(= M.Y.L) infolge V9(= V.Z.R) = 1;
  Result[5, 11] := 2 * EIy / S; // S5(= M.Y.L) infolge V11(= Phi.Y.R) = 1;

  Result[9, 9] := 12 * EIy / SSS; // S9(= Q.Z.R) infolge V9(= V.Z.R) = 1;
  Result[9, 11] := 6 * EIy / SS; // S9(= Q.Z.R) infolge V11(= Phi.Y.R) = 1;

  Result[10, 10] := GIt / S; // S10(= M.X.R) infolge V10(= Phi.X.R) = 1;

  Result[11, 11] := 4 * EIy / S; // S11(= M.Y.R) infolge V11(= Phi.Y.R) = 1;

  for I := 1 to 11 do
    for J := I + 1 to 12 do
      Result[J, I] := Result[I, J]; // Symmetrisch ergänzen;
end;

Damit ich diese Matrix weiterverarbeiten kann, brauche ich sie bezüglich dieses KOO-Systems.

Code:

       Z
       |     X
       |   .
       | .
Y -----|-

Nun wollte ich die Matrix 90 Grad um die Z-Achse drehen. Weiß jemand wie das geht?

[Memnarch]

Ewig her, deswegen bekomm ich nicht mehr alles auf die Kette. Aber für meinen SoftwareRenderer habe ich mir seinerzeit ne Unit mit entsprechenden Klassen geschrieben.
https://github.com/Memnarch/Software...ter/Math3D.pas

Dort kannst du eine Matrix als Rotationsmatrix initialisieren (X, Y oder Z). Diese ließe sich dann mit deiner Matrix multiplizieren.

Vielleicht kann es dir (etwas helfen). Meine Z-Achse müsste ebenfalls UP-Orientiert gewesen sein.

MFG
Memnarch

[Namenloser]

Zitat von Bjoerk:

Nun wollte ich die Matrix 90 Grad um die Z-Achse drehen. Weiß jemand wie das geht?

Drehmatrix?

Bin etwas verwirrt von deiner Frage. Die Skizze von deinem Koordinatensystem hat drei Dimensionen, aber die Matrix in deinem Code ist offenbar 12-dimensional. Bei mehr als drei Dimensionen kann man nicht um eine "Achse" rotieren, sondern muss in einer Ebene rotieren. Wie das geht, steht aber auch in dem Wikipedia-Artikel im Abschnitt Drehmatrizen des Raumes R^n.

[Memnarch]

Zitat von Namenloser:

[...] aber die Matrix in deinem Code ist offenbar 12-dimensional[...]

Da war ich mal wieder nicht aufmerksam. Wie passt den dass mit dem 3D-Bild o.O

[himitsu]

Ist seine Matrix nicht 2-dimensional, mit je 12 Einheiten pro Achse?

Aber zum Glück weiß ja keiner wie TZzFloatMat1212 definiert ist.

[Zacherl]

Sieht für mich eher nach 12x12 aus .. wobei da unten wird irgendwie noch symmetrisch ergänzt

[Bjoerk]

Ist 3-dimenional und ein array 12 x 12. Zz ist meine persönliche Abkürzung für Zienkiewicz. Die 12 kommen aus drei Verschiebungen und drei Verdrehungen links und rechts am Element.

Code:

v.x.left
v.y.left
v.z.left
p.x.left
p.y.left
p.z.left
v.x.right
v.y.right
v.z.right
p.x.right
p.y.right
p.z.right

[Bjoerk]

Habs jetzt. Man kann hier einfach die Koordinaten X und Y vertauschen (X = -Y, Y = X). Die Matrix muß eh später in ein globales Bezugssystem transformiert werden, damit kann man es erledigen.

Delphi-Quellcode:

function TZzBeamTools.SmGc(const E, G, Iy, It, x1, y1, x2, y2: double): TZzFloatMat66; // Unterzüge: z1 = z2 = 0;
var
  I, J: integer;
  ASmLc, ASmGc, T: TZzFloatMat1212; // SmLc = StiffnessMatrixLocalCoordinates, SmGc = .. Global Coo.
begin
  for I := 1 to 6 do
    for J := 1 to 6 do
      Result[I, J] := 0;
  if (Iy > 1E-8) and (It > 1E-8) and (Sqrt(Sqr(x2 - x1) + Sqr(y2 - y1)) > 1E-8) then
  begin
    ASmLc := BeamSmLc(E, G, Iy, It, x1, y1, x2, y2); // 12x12 XYZ;
    T := TransformationMatrix(-y1, x1, -y2, x2); // *** T bezügl. YXZ ***
    ASmGc := SmLcToSmGc(ASmLc, T); // SmLc * T,trans * T; 12x12 XYZ to 12x12 YXZ
    Result := BeamSmGcToPlateSmGc(ASmGc); // 12x12 YXZ to 6x6 YXZ;
  end;
end;

[Medium]

Der Vollständigkeit halbar ein Mal kurz Klughscheißmodus:
Du wolltest gar nicht eine Matrix drehen. Du wolltest 4 Vektoren drehen, die du bloß ziemlich ungewöhnlich in ein Array geschrieben hast. (Edit: Ich vermute diese Matrixform brauchst du später für etwas anderes, aber eine 3D-Matrix die man in einer Operation drehen könnte ist es nicht. Du willst viel mehr die einzelnen Vektoren, aus denen deine Matirx gebildet wird drehen.) Und bei 3D-Vektoren kann man in der Tat sehr einfach (90° um eine Achse*) drehen, in dem man die beiden Koordinaten die nicht zur Drehachse gehören vertauscht und einen davon negiert. (Geht auch in 2D, da einfach beide Koords tauschen und einen negieren.) Dasselbe passiert in diesen Fällen auch bei Anwendung einer Drehmatrix.

*) Will man um einen beliebigen Vektor und/oder beliebigen Winkel drehen, kommt o.g. Drehmatrix zwangsläufig ins Spiel. Mit der muss dann der zu drehende Vektor multipliziert werden.

[Bjoerk]

Ok. Dank dir für die Info. Diese Schreibweise ist für solche Probleme jedoch üblich. Man passt lieber die Transformationsmatrix an.

Code:

E11 E12 E13
E21 E22 E23                      Null
E31 E32 E33
           E11 E12 E13
           E21 E22 E23
           E31 E32 E33
                      E11 E12 E13
                      E21 E22 E23
                      E31 E32 E33
                                 E11 E12 E13
Null                             E21 E22 E23
                                 E31 E32 E33