Files |  Tutorials |  Articles |  Links |  Home |  Team |  Forum |  Wiki |  Impressum

Aktuelle Zeit: Do Mär 28, 2024 21:58

Foren-Übersicht » Programmierung » Mathematik-Forum
Unbeantwortete Themen | Aktive Themen



Ein neues Thema erstellen Auf das Thema antworten  [ 12 Beiträge ] 
Autor Nachricht
 Betreff des Beitrags: Matrizen global transformieren
BeitragVerfasst: Fr Mai 27, 2011 23:01 
Offline
DGL Member

Registriert: So Mär 22, 2009 22:28
Beiträge: 26
Hi,

Also, die Transformation der Matrix berechne ich so...
Code:
  1.     t.x := x*this[0][0] + y*this[1][0] + z*this[2][0] + this[3][0]
  2.     t.y := x*this[0][1] + y*this[1][1] + z*this[2][1] + this[3][1]
  3.     t.z := x*this[0][2] + y*this[1][2] + z*this[2][2] + this[3][2]
  4.     return t

...was ist aber jetzt wenn ich diese (globalen) Koordinaten in eine Matrix einsetzen will, aber die Rotation, Skalierung, etc. nicht verändern will.
Das ganze bräuchte ich um die Bones meines Modells zu bewegen.
Ich will damit sozusagen die Childbones eines Bones (das rotiert oder verschoben wurde) neu anordnen.
Daher die Umrechnung in globale koordinaten und für die Childbones wieder zurück.
Ich habs mal so versucht:
Code:
  1.     this[3][0] := x*this[0][0] + y*this[1][0] + z*this[2][0]
  2.     this[3][1] := x*this[0][1] + y*this[1][1] + z*this[2][1]
  3.     this[3][2] := x*this[0][2] + y*this[1][2] + z*this[2][2]

...führt allerdings nicht zum gewünschten ergebniss.

Was muss ich also machen damit ich eine Matrix global verschieben kann?
(ich bin kein Mathegenie, aber ich hoffe ich konnte mein Problem ordentlich erklähren)

vielen dank schonmal


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Matrizen global transformieren
BeitragVerfasst: Sa Mai 28, 2011 09:28 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java
Code:
  1. t.x := x*this[0][0] + y*this[1][0] + z*this[2][0] + this[3][0]
  2. t.y := x*this[0][1] + y*this[1][1] + z*this[2][1] + this[3][1]
  3. t.z := x*this[0][2] + y*this[1][2] + z*this[2][2] + this[3][2]


Verstehe ich das richtig? Du möchtest, dass deine neue Matrix den Punkt (0,0,0) auf den Punkt t abbildet?

In dem Fall müsste es das folgende sein:
Code:
  1. this[3][0]  := x*this[0][0] + y*this[1][0] + z*this[2][0] + this[3][0]
  2. this[3][1]  := x*this[0][1] + y*this[1][1] + z*this[2][1] + this[3][1]
  3. this[3][2]  := x*this[0][2] + y*this[1][2] + z*this[2][2] + this[3][2]

Dies ist äquivalent mit einer von rechts multiplizierten Transformationsmatrix um den Vektor t:
Code:
  1. this = this * transform

wobei transform die Einheitsmatrix ist bis auf transform[3][012] = t.xyz.

Aber bist du sicher das du Rotation und Skalierung nicht verändern willst? Normalerweise würde man wohl immer die Matrizen der Elternknoten der Reihe nach von rechts dran multiplizieren:
Code:
  1. v := v * child;
  2. v := v * parent;
  3. v := v * parentsParent;

ist das gleiche wie:
Code:
  1. v := v * (child * parent * parentsParent);




P.S. Bezüglich der unterstrichenen "rechts": Ich gehe davon aus das deine Matrix der üblichen Schreibweise entspricht, also this[Zeile][Spalte]. Sollte es this[Spalte][Zeile] sein ersetze "rechts" durch "links".

_________________
Yeah! :mrgreen:


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Matrizen global transformieren
BeitragVerfasst: Sa Mai 28, 2011 09:58 
Offline
DGL Member

Registriert: So Mär 22, 2009 22:28
Beiträge: 26
Also wenn ich dich richtig verstanden habe sollte es folgendermaßen funktionieren...
(methode)
Code:
  1.   rotateBone(angle, x, y, z, affectChilds=1)
  2.   {
  3.     this.armatureSpace.rotate(angle, x, y, z)
  4.     if (affectChilds)
  5.     {
  6.       i := 0
  7.       Loop, % this.childs
  8.       {
  9.         this.child[i].armatureSpace.multMatrix(this.armatureSpace)
  10.         i ++
  11.       }
  12.     }
  13.     return
  14.   }

... oder so ähnlich (dass zumindest die nächsten Childs angeordnet werden)
Aber es funktioniert nicht.
Die Childs sind dann irgendwo, aber nicht da wo ich sie haben will und falsch rotiert.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Matrizen global transformieren
BeitragVerfasst: Sa Mai 28, 2011 10:07 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java
Die Koordinatensysteme der Kinder müssen natürlich relativ zum Eltern-Bone sein. Etwa die Translation für einen Kind-Bone ist im selben Koordinatensystem wie die Vertices des Eltern-Bone.

_________________
Yeah! :mrgreen:


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Matrizen global transformieren
BeitragVerfasst: Sa Mai 28, 2011 10:15 
Offline
DGL Member

Registriert: So Mär 22, 2009 22:28
Beiträge: 26
Und gäbe es dann irgendeine möglichkeit die relativen Koordinaten zu errechnen?

(Sorry, für meine dummen Fragen, aber es ist das erste mal dass ich soetwas mit Matrizen anstellen will.)


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Matrizen global transformieren
BeitragVerfasst: Sa Mai 28, 2011 11:23 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java
Zitat:
Und gäbe es dann irgendeine möglichkeit die relativen Koordinaten zu errechnen?

Gut, ich was davon ausgegangen das du die schon hast....und daraus dann was globales berechnet hast ;) Ich habe noch nichts mit Bone-Animation gemacht aber ich würde sagen man hängt ein Child ja irgendwie an einen Bone dran: "Der Child-Bone soll um (0,0,5) verschoben zum Ursprung des Eltern-Bone sein."

Wenn du globale Daten hast, dann benutze die auch direkt wie du es zuerst vorhattest.

_________________
Yeah! :mrgreen:


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Matrizen global transformieren
BeitragVerfasst: Sa Mai 28, 2011 11:44 
Offline
DGL Member

Registriert: So Mär 22, 2009 22:28
Beiträge: 26
Ja eigentlich hattest du recht, dass ich die relativen Koordinaten verwenden soll.
Da man ja bsp. auch einen Knochen skalieren kann.
Würde man das Kind dann mit der relativen Matrix des Elternelements (am Knochenende) multiplizieren, müsste eigentlich verschiebung, rotation, skalierung und scherung passen.
Würde ich es mit dem Ansatz vom ersten Post anstellen würde nur die verschiebung passen.
Insofern meine Denkweise stimmt bräuchte ich also nur die relativen Koordinaten irgendwie errechnen.
Bleibt also für mich nur noch die Frage zu klären wie ich die absolute Matrix der Knochen in relative (in Bezug zum Elternelement) umrechnen kann.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Matrizen global transformieren
BeitragVerfasst: Sa Mai 28, 2011 12:34 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java
Zitat:
Bleibt also für mich nur noch die Frage zu klären wie ich die absolute Matrix der Knochen in relative (in Bezug zum Elternelement) umrechnen kann.

Die Ziel ist:
Code:
  1. globalChild = localChild * globalParent

Also:
Code:
  1.   globalChild
  2. = globalChild * identity
  3. = globalChild * (globalParent^-1 * globalParent)
  4. = (globalChild * globalParent^-1) * globalParent
  5. = localChild * globalParent


Dabei ist globalParent^-1 die sog. Inverse von globalParent. Im CoolMath-Projekt findest du Code um eine 4x4-Matrix zu invertieren:
viewtopic.php?f=13&t=9296

_________________
Yeah! :mrgreen:


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Matrizen global transformieren
BeitragVerfasst: Sa Mai 28, 2011 13:31 
Offline
DGL Member

Registriert: So Mär 22, 2009 22:28
Beiträge: 26
Ok ich hab mal versucht dein Beispiel in Code umzusetzen...
Code:
  1.   rotateBone(angle, x, y, z)
  2.   {
  3.     this.armatureSpace.rotate(angle, x, y, z)
  4.     i := 0
  5.     Loop, % this.childs
  6.     {
  7.       parent := this.armatureSpace.copyMatrix()
  8.       parent.translate(0, this.boneLength, 0)
  9.       invParent := parent.copyMatrix()
  10.       invParent.invert()
  11.       this.child[i].armatureSpace.multMatrix(invParent)
  12.       this.child[i].armatureSpace.multMatrix(parent)
  13.       i ++
  14.     }
  15.     return
  16.   }

... bisher allerdings ohne Erfolg.

Mit invertieren der Matrix ist gemeint m und n zu vertauschen, oder?
bsp:
Code:
  1. neu[0][1] = alt[1][0]
  2. neu[0][2] = alt[2][0]
  3. neu[0][3] = alt[3][0]
  4. neu[1][0] = alt[0][1]
  5. ...

Wenn ja, macht das die Methode invert.


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Matrizen global transformieren
BeitragVerfasst: Sa Mai 28, 2011 14:38 
Offline
DGL Member
Benutzeravatar

Registriert: Do Dez 29, 2005 12:28
Beiträge: 2249
Wohnort: Düsseldorf
Programmiersprache: C++, C#, Java
Zitat:
Mit invertieren der Matrix ist gemeint m und n zu vertauschen, oder?

Nein, das ist ne recht aufwendige Berechnung. Was du meinst heißt "transponieren" (auf Englisch: transpose).
Unter bestimmten Umständen ist die transponierte Matrix tatsächlich auch die inverse Matrix, aber nur unter diesen Umständen die bei dir nicht gegeben sind.

Nimm einfach den Code aus CoolMath und übersetze ihn in deine Sprache (was ist das eigentlich?). Verstehen was da passiert musst du nicht unbedingt. Ich habe den Code selbst aus einem Paper von Intel übernommen (steht auch als Kommentar im Code).

<snip>
Code:
  1. template<typename T, int N, int M>
  2. Matrix<T,N,N> Matrix<T,N,M>::inverse() const
  3. {
  4.     STATIC_ASSERT(N == M && N==4, "Operation only implemented for 4x4 matrices.");
  5.  
  6.     /* 4x4-matrix inversion based on Cramer's Rule
  7.      * based on this Intel article:
  8.      * "AP-928 Streaming SIMD Extensions -Inverse of 4x4 Matrix"
  9.      *
  10.      * File: 24504301.pdf
  11.  
  12.     float tmp[12];     // temp array for pairs
  13.     float src[16];     // transposed source matrix
  14.     Matrix<T,N,N> dst; // result
  15.  
  16.     /* transpose matrix */
  17.     for (int i=0; i<4; i++) {
  18.         src[i     ] = matrix[i*4];
  19.         src[i +  4] = matrix[i*4 + 1];
  20.         src[i +  8] = matrix[i*4 + 2];
  21.         src[i + 12] = matrix[i*4 + 3];
  22.     }
  23.    
  24.     /* calculate pairs for first 8 elements (cofactors) */
  25.     tmp[ 0] = src[10] * src[15];
  26.     tmp[ 1] = src[11] * src[14];
  27.     tmp[ 2] = src[ 9] * src[15];
  28.     tmp[ 3] = src[11] * src[13];
  29.     tmp[ 4] = src[ 9] * src[14];
  30.     tmp[ 5] = src[10] * src[13];
  31.     tmp[ 6] = src[ 8] * src[15];
  32.     tmp[ 7] = src[11] * src[12];
  33.     tmp[ 8] = src[ 8] * src[14];
  34.     tmp[ 9] = src[10] * src[12];
  35.     tmp[10] = src[ 8] * src[13];
  36.     tmp[11] = src[ 9] * src[12];
  37.  
  38.     /* calculate first 8 elements (cofactors) */
  39.     dst[ 0]  = tmp[ 0]*src[ 5] + tmp[ 3]*src[ 6] + tmp[ 4]*src[ 7];
  40.     dst[ 0] -= tmp[ 1]*src[ 5] + tmp[ 2]*src[ 6] + tmp[ 5]*src[ 7];
  41.     dst[ 1]  = tmp[ 1]*src[ 4] + tmp[ 6]*src[ 6] + tmp[ 9]*src[ 7];
  42.     dst[ 1] -= tmp[ 0]*src[ 4] + tmp[ 7]*src[ 6] + tmp[ 8]*src[ 7];
  43.     dst[ 2]  = tmp[ 2]*src[ 4] + tmp[ 7]*src[ 5] + tmp[10]*src[ 7];
  44.     dst[ 2] -= tmp[ 3]*src[ 4] + tmp[ 6]*src[ 5] + tmp[11]*src[ 7];
  45.     dst[ 3]  = tmp[ 5]*src[ 4] + tmp[ 8]*src[ 5] + tmp[11]*src[ 6];
  46.     dst[ 3] -= tmp[ 4]*src[ 4] + tmp[ 9]*src[ 5] + tmp[10]*src[ 6];
  47.     dst[ 4]  = tmp[ 1]*src[ 1] + tmp[ 2]*src[ 2] + tmp[ 5]*src[ 3];
  48.     dst[ 4] -= tmp[ 0]*src[ 1] + tmp[ 3]*src[ 2] + tmp[ 4]*src[ 3];
  49.     dst[ 5]  = tmp[ 0]*src[ 0] + tmp[ 7]*src[ 2] + tmp[ 8]*src[ 3];
  50.     dst[ 5] -= tmp[ 1]*src[ 0] + tmp[ 6]*src[ 2] + tmp[ 9]*src[ 3];
  51.     dst[ 6]  = tmp[ 3]*src[ 0] + tmp[ 6]*src[ 1] + tmp[11]*src[ 3];
  52.     dst[ 6] -= tmp[ 2]*src[ 0] + tmp[ 7]*src[ 1] + tmp[10]*src[ 3];
  53.     dst[ 7]  = tmp[ 4]*src[ 0] + tmp[ 9]*src[ 1] + tmp[10]*src[ 2];
  54.     dst[ 7] -= tmp[ 5]*src[ 0] + tmp[ 8]*src[ 1] + tmp[11]*src[ 2];
  55.  
  56.     /* calculate pairs for second 8 elements (cofactors) */
  57.     tmp[ 0] = src[ 2]*src[ 7];
  58.     tmp[ 1] = src[ 3]*src[ 6];
  59.     tmp[ 2] = src[ 1]*src[ 7];
  60.     tmp[ 3] = src[ 3]*src[ 5];
  61.     tmp[ 4] = src[ 1]*src[ 6];
  62.     tmp[ 5] = src[ 2]*src[ 5];
  63.     tmp[ 6] = src[ 0]*src[ 7];
  64.     tmp[ 7] = src[ 3]*src[ 4];
  65.     tmp[ 8] = src[ 0]*src[ 6];
  66.     tmp[ 9] = src[ 2]*src[ 4];
  67.     tmp[10] = src[ 0]*src[ 5];
  68.     tmp[11] = src[ 1]*src[ 4];
  69.  
  70.     /* calculate second 8 elements (cofactors) */
  71.     dst[ 8]  = tmp[ 0]*src[13] + tmp[ 3]*src[14] + tmp[ 4]*src[15];
  72.     dst[ 8] -= tmp[ 1]*src[13] + tmp[ 2]*src[14] + tmp[ 5]*src[15];
  73.     dst[ 9]  = tmp[ 1]*src[12] + tmp[ 6]*src[14] + tmp[ 9]*src[15];
  74.     dst[ 9] -= tmp[ 0]*src[12] + tmp[ 7]*src[14] + tmp[ 8]*src[15];
  75.     dst[10]  = tmp[ 2]*src[12] + tmp[ 7]*src[13] + tmp[10]*src[15];
  76.     dst[10] -= tmp[ 3]*src[12] + tmp[ 6]*src[13] + tmp[11]*src[15];
  77.     dst[11]  = tmp[ 5]*src[12] + tmp[ 8]*src[13] + tmp[11]*src[14];
  78.     dst[11] -= tmp[ 4]*src[12] + tmp[ 9]*src[13] + tmp[10]*src[14];
  79.     dst[12]  = tmp[ 2]*src[10] + tmp[ 5]*src[11] + tmp[ 1]*src[ 9];
  80.     dst[12] -= tmp[ 4]*src[11] + tmp[ 0]*src[ 9] + tmp[ 3]*src[10];
  81.     dst[13]  = tmp[ 8]*src[11] + tmp[ 0]*src[ 8] + tmp[ 7]*src[10];
  82.     dst[13] -= tmp[ 6]*src[10] + tmp[ 9]*src[11] + tmp[ 1]*src[ 8];
  83.     dst[14]  = tmp[ 6]*src[ 9] + tmp[11]*src[11] + tmp[ 3]*src[ 8];
  84.     dst[14] -= tmp[10]*src[11] + tmp[ 2]*src[ 8] + tmp[ 7]*src[ 9];
  85.     dst[15]  = tmp[10]*src[10] + tmp[ 4]*src[ 8] + tmp[ 9]*src[ 9];
  86.     dst[15] -= tmp[ 8]*src[ 9] + tmp[11]*src[10] + tmp[ 5]*src[ 8];
  87.  
  88.     /* calculate determinant */
  89.     T det = src[0]*dst[0]+src[1]*dst[1]+src[2]*dst[2]+src[3]*dst[3];
  90.     /* calculate matrix inverse */
  91.     return dst / det;       // einfach nur alle Elemente der Matrix durch "det" teilen
  92. }

_________________
Yeah! :mrgreen:


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Matrizen global transformieren
BeitragVerfasst: Sa Mai 28, 2011 15:04 
Offline
DGL Member

Registriert: So Mär 22, 2009 22:28
Beiträge: 26
Ja dann sag ich mal herzlichen Dank.
Ich werde versuchen es zu übersetzen und berichte sobald ich ein Ergebniss habe.
Die Sprache ist übrigens AutoHotkey v1.1 (allerdings aufgrund der performanz nicht sonderlich für OpenGL geeignet)
Ich schreib mir halt einfach alles zuerst in AHK (AutoHotkey) bevor ich es für C++ übersetze (ist leichter/schneller für mich, da AHK nicht so streng ist)


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: Matrizen global transformieren
BeitragVerfasst: Sa Mai 28, 2011 22:57 
Offline
DGL Member

Registriert: So Mär 22, 2009 22:28
Beiträge: 26
Tja, danke nochmal Coolcat...
Hat zwar ne menge Hirnschmalz gefordert, aber ich hab die Lösung:
(Die beiden Methoden rotateBone und affectChilds aus der cGroup-Klasse (Vertexgruppen))
Code:
  1.   rotateBone(angle, x, y, z)
  2.   {
  3.     prevMat := this.armatureSpace.copyMatrix()
  4.     this.armatureSpace.rotate(angle, x, y, z)
  5.     this.affectChilds(prevMat)
  6.     return 1
  7.   }
  8.   affectChilds(prevMat)
  9.   {
  10.     prevMat.invert()
  11.     newMat := this.armatureSpace.copyMatrix()
  12.     i := 0
  13.     Loop, % this.childs
  14.     {
  15.       childPrevMat := this.child[i].armatureSpace.copyMatrix()
  16.       this.child[i].armatureSpace.multMatrix(prevMat)
  17.       this.child[i].armatureSpace.multMatrix(newMat)
  18.       this.child[i].affectChilds(childPrevMat)
  19.       i ++
  20.     }
  21.     return 1
  22.   }

Und dann noch die Methode zum invertieren der Matrix von der cMatrix-Klasse... (ist allerdings nur die Übersetzung, nichts weiter)
Code:
  1.   invert()
  2.   {
  3.     tmp := Object()
  4.     dst := this.copyMatrix()
  5.     src := this.copyMatrix()
  6.     src.transpose()
  7.    
  8.     tmp[0]  := src[2][2] * src[3][3]
  9.     tmp[1]  := src[2][3] * src[3][2]
  10.     tmp[2]  := src[2][1] * src[3][3]
  11.     tmp[3]  := src[2][3] * src[3][1]
  12.     tmp[4]  := src[2][1] * src[3][2]
  13.     tmp[5]  := src[2][2] * src[3][1]
  14.     tmp[6]  := src[2][0] * src[3][3]
  15.     tmp[7]  := src[2][3] * src[3][0]
  16.     tmp[8]  := src[2][0] * src[3][2]
  17.     tmp[9]  := src[2][2] * src[3][0]
  18.     tmp[10] := src[2][0] * src[3][1]
  19.     tmp[11] := src[2][1] * src[3][0]
  20.  
  21.     dst[0][0] := (tmp[0]*src[1][1] + tmp[3]*src[1][2] + tmp[4] *src[1][3]) - (tmp[1]*src[1][1] + tmp[2]*src[1][2] + tmp[5] *src[1][3])
  22.     dst[0][1] := (tmp[1]*src[1][0] + tmp[6]*src[1][2] + tmp[9] *src[1][3]) - (tmp[0]*src[1][0] + tmp[7]*src[1][2] + tmp[8] *src[1][3])
  23.     dst[0][2] := (tmp[2]*src[1][0] + tmp[7]*src[1][1] + tmp[10]*src[1][3]) - (tmp[3]*src[1][0] + tmp[6]*src[1][1] + tmp[11]*src[1][3])
  24.     dst[0][3] := (tmp[5]*src[1][0] + tmp[8]*src[1][1] + tmp[11]*src[1][2]) - (tmp[4]*src[1][0] + tmp[9]*src[1][1] + tmp[10]*src[1][2])
  25.     dst[1][0] := (tmp[1]*src[0][1] + tmp[2]*src[0][2] + tmp[5] *src[0][3]) - (tmp[0]*src[0][1] + tmp[3]*src[0][2] + tmp[4] *src[0][3])
  26.     dst[1][1] := (tmp[0]*src[0][0] + tmp[7]*src[0][2] + tmp[8] *src[0][3]) - (tmp[1]*src[0][0] + tmp[6]*src[0][2] + tmp[9] *src[0][3])
  27.     dst[1][2] := (tmp[3]*src[0][0] + tmp[6]*src[0][1] + tmp[11]*src[0][3]) - (tmp[2]*src[0][0] + tmp[7]*src[0][1] + tmp[10]*src[0][3])
  28.     dst[1][3] := (tmp[4]*src[0][0] + tmp[9]*src[0][1] + tmp[10]*src[0][2]) - (tmp[5]*src[0][0] + tmp[8]*src[0][1] + tmp[11]*src[0][2])
  29.  
  30.     tmp[0]  := src[0][2] * src[1][3]
  31.     tmp[1]  := src[0][3] * src[1][2]
  32.     tmp[2]  := src[0][1] * src[1][3]
  33.     tmp[3]  := src[0][3] * src[1][1]
  34.     tmp[4]  := src[0][1] * src[1][2]
  35.     tmp[5]  := src[0][2] * src[1][1]
  36.     tmp[6]  := src[0][0] * src[1][3]
  37.     tmp[7]  := src[0][3] * src[1][0]
  38.     tmp[8]  := src[0][0] * src[1][2]
  39.     tmp[9]  := src[0][2] * src[1][0]
  40.     tmp[10] := src[0][0] * src[1][1]
  41.     tmp[11] := src[0][1] * src[1][0]
  42.  
  43.     dst[2][0]  := (tmp[0] *src[3][1] + tmp[3] *src[3][2] + tmp[4] *src[3][3]) - (tmp[1] *src[3][1] + tmp[2] *src[3][2] + tmp[5] *src[3][3])
  44.     dst[2][1]  := (tmp[1] *src[3][0] + tmp[6] *src[3][2] + tmp[9] *src[3][3]) - (tmp[0] *src[3][0] + tmp[7] *src[3][2] + tmp[8] *src[3][3])
  45.     dst[2][2] := (tmp[2] *src[3][0] + tmp[7] *src[3][1] + tmp[10]*src[3][3]) - (tmp[3] *src[3][0] + tmp[6] *src[3][1] + tmp[11]*src[3][3])
  46.     dst[2][3] := (tmp[5] *src[3][0] + tmp[8] *src[3][1] + tmp[11]*src[3][2]) - (tmp[4] *src[3][0] + tmp[9] *src[3][1] + tmp[10]*src[3][2])
  47.     dst[3][0] := (tmp[2] *src[2][2] + tmp[5] *src[2][3] + tmp[1] *src[2][1]) - (tmp[4] *src[2][3] + tmp[0] *src[2][1] + tmp[3] *src[2][2])
  48.     dst[3][1] := (tmp[8] *src[2][3] + tmp[0] *src[2][0] + tmp[7] *src[2][2]) - (tmp[6] *src[2][2] + tmp[9] *src[2][3] + tmp[1] *src[2][0])
  49.     dst[3][2] := (tmp[6] *src[2][1] + tmp[11]*src[2][3] + tmp[3] *src[2][0]) - (tmp[10]*src[2][3] + tmp[2] *src[2][0] + tmp[7] *src[2][1])
  50.     dst[3][3] := (tmp[10]*src[2][2] + tmp[4] *src[2][0] + tmp[9] *src[2][1]) - (tmp[8] *src[2][1] + tmp[11]*src[2][2] + tmp[5] *src[2][0])
  51.  
  52.     det := src[0][0]*dst[0][0] + src[0][1]*dst[0][1] + src[0][2]*dst[0][2] + src[0][3]*dst[0][3]
  53.  
  54.     m := 0
  55.     Loop, 4
  56.     {
  57.       n := 0
  58.       Loop, 4
  59.       {
  60.         this[m][n] := dst[m][n] / det
  61.         n ++
  62.       }
  63.       m ++
  64.     }
  65.     return 1
  66.   }


Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  [ 12 Beiträge ] 
Foren-Übersicht » Programmierung » Mathematik-Forum


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 7 Gäste


Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.

Suche nach:
Gehe zu:  
cron
  Powered by phpBB® Forum Software © phpBB Group
Deutsche Übersetzung durch phpBB.de
[ Time : 0.064s | 17 Queries | GZIP : On ]