DGL • Thema anzeigen - Rechengenauigkeit und Matrizen

Rechengenauigkeit und Matrizen

Moderator: DGL-Team

Seite 1 von 1

[ 5 Beiträge ]

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Flo

Betreff des Beitrags: Rechengenauigkeit und Matrizen

Verfasst: Mo Okt 04, 2004 21:13

DGL Member

Registriert: Do Jun 19, 2003 10:44
Beiträge: 991
Wohnort: Karlsfeld (nahe München)

Eines vorne weg das wird zimlich mathematisch.

Ich wollte eine soche Matrix2 passend zu Matrix1 finden das gilt:

Zitat:

VektorA--Matrix1-->VertorA--Matrix2-->VektorA

Damit das ganze lösbar ist bin ich davon ausgegangen das die Matrix1 nur eine Inditäts- Matrix ist, welche mit OpenGL Befehlen wie glRotate,glTranslate und glScale manipuliert wurde.

Als Teilschritt auf eine solche Matrix hin habe ich mir überlegt wie man die Rotation mit Hilfe einer Matrix umkehren kann.
Folgenden Code habe ich dafür entworfen:

Code:

 
type
  Einheit = Double;
  TVektor = record X,Y,Z,W:Einheit end;
  TMatrix = array [0..3] of TVektor;
 
 
  function AntiRotMatrix(const Matrix:TMatrix):TMatrix;
  function MatrixaufVektoranwenden(Matrix:TMatrix;Vektor:TVektor):TVektor;
implementation
const
  X=0;
  Y=1;
  Z=2;
  W=3;
 
function Vektor(X,Y,Z,W:Einheit):TVektor;
begin
  Result.X := X;
  Result.Y := Y;
  Result.Z := Z;
  Result.W := W;
end;
 
function MatrixaufVektoranwenden(Matrix:TMatrix;Vektor:TVektor):TVektor;
begin
  Result.X := Vektor.X*Matrix[X].X + Vektor.Y*Matrix[Y].X + Vektor.Z*Matrix[Z].X + Vektor.W*Matrix[W].X;
  Result.Y := Vektor.X*Matrix[X].Y + Vektor.Y*Matrix[Y].Y + Vektor.Z*Matrix[Z].Y + Vektor.W*Matrix[W].Y;
  Result.Z := Vektor.X*Matrix[X].Z + Vektor.Y*Matrix[Y].Z + Vektor.Z*Matrix[Z].Z + Vektor.W*Matrix[W].Z;
  Result.W := Vektor.X*Matrix[X].W + Vektor.Y*Matrix[Y].W + Vektor.Z*Matrix[Z].W + Vektor.W*Matrix[W].W;
end;
 
function AntiRotMatrix(const Matrix:TMatrix):TMatrix;
var
  RMatrix:TMatrix;
  MatrixYZRot:TMatrix;
  MatrixXZRot:TMatrix;
  MatrixXYRot:TMatrix;
 
  ZAchse:TVektor;
  XAchse:TVektor absolute ZAchse;
  L:Einheit;
begin
 
  // ZAchse holen
  ZAchse := Matrix[Z];
  // Nur Y-Z Betrachten
  ZAchse.X := 0;
  //Zum Einheitsvektor machen:
  L := Sqrt(Sqr(ZAchse.Y)+Sqr(ZAchse.Z));
  ZAchse.Y := ZAchse.Y / L;
  ZAchse.Z := ZAchse.Z / L;
  RMatrix := Matrix;
 
  MatrixYZRot[X] := Vektor(1,0,0,0);
  MatrixYZRot[Y] := Vektor(0, ZAchse.Z, ZAchse.Y, 0);
  MatrixYZRot[Z] := Vektor(0, -ZAchse.Y, ZAchse.Z, 0);
  MatrixYZRot[W] := Vektor(0, 0, 0, 1);
 
  //Ausgangsmatrix mit Rotationsmatrix rotieren.
  RMatrix[0] := MatrixaufVektoranwenden(MatrixYZRot,Matrix[0]);
  RMatrix[1] := MatrixaufVektoranwenden(MatrixYZRot,Matrix[1]);
  RMatrix[2] := MatrixaufVektoranwenden(MatrixYZRot,Matrix[2]);
  RMatrix[3] := MatrixaufVektoranwenden(MatrixYZRot,Matrix[3]);
 
  // Nach dieser Rotation ist von der wirklichen ZAchse die Y Koordinate gleich 0
  // Es kann nun in XZ Richtung gedreht werden.
 
  // Die (neue) ZAchse holen
  ZAchse := RMatrix[Z];
  //Zum Einheitsvektor machen:
  L := Sqrt(Sqr(ZAchse.X)+Sqr(ZAchse.Z));
  ZAchse.X := ZAchse.X / L;
  ZAchse.Z := ZAchse.Z / L;
 
  MatrixXZRot[X] := Vektor(ZAchse.Z,0 ,ZAchse.X , 0);
  MatrixXZRot[Y] := Vektor(0,1,0,0);
  MatrixXZRot[Z] := Vektor(-ZAchse.X, 0, ZAchse.Z, 0);
  MatrixXZRot[W] := Vektor(0, 0, 0, 1);
 
  //Ausgangsmatrix mit Rotationsmatrix rotieren.
  RMatrix[0] := MatrixaufVektoranwenden(MatrixXZRot,RMatrix[0]);
  RMatrix[1] := MatrixaufVektoranwenden(MatrixXZRot,RMatrix[1]);
  RMatrix[2] := MatrixaufVektoranwenden(MatrixXZRot,RMatrix[2]);
  RMatrix[3] := MatrixaufVektoranwenden(MatrixXZRot,RMatrix[3]);
 
  //Nun ist die Z Achse in der richigen Position und es kann um sie rotiert werden
 
  XAchse := RMatrix[X];
  L := Sqrt(Sqr(XAchse.X)+Sqr(XAchse.Y));
  //XAchse.X := XAchse.X / L;
  //XAchse.Z := XAchse.Z / L;
 
  MatrixXYRot[X] := Vektor( XAchse.X,-XAchse.Y ,0 , 0);
  MatrixXYRot[Y] := Vektor( XAchse.Y, XAchse.X ,0 , 0);
  MatrixXYRot[Z] := Vektor(0, 0, 1, 0);
  MatrixXYRot[W] := Vektor(0, 0, 0, 1);
 
  {$IFDEF DEBUG}
  RMatrix[0] := MatrixaufVektoranwenden(MatrixXYRot,RMatrix[0]);
  RMatrix[1] := MatrixaufVektoranwenden(MatrixXYRot,RMatrix[1]);
  RMatrix[2] := MatrixaufVektoranwenden(MatrixXYRot,RMatrix[2]);
  RMatrix[3] := MatrixaufVektoranwenden(MatrixXYRot,RMatrix[3]);
  {$ENDIF DEBUG}
 
  Result := MatrixYZRot;
 
 
  Result[0] := MatrixaufVektoranwenden(MatrixXZRot,Result[0]);
  Result[1] := MatrixaufVektoranwenden(MatrixXZRot,Result[1]);
  Result[2] := MatrixaufVektoranwenden(MatrixXZRot,Result[2]);
  Result[3] := MatrixaufVektoranwenden(MatrixXZRot,Result[3]);
 
  Result[0] := MatrixaufVektoranwenden(MatrixXYRot,Result[0]);
  Result[1] := MatrixaufVektoranwenden(MatrixXYRot,Result[1]);
  Result[2] := MatrixaufVektoranwenden(MatrixXYRot,Result[2]);
  Result[3] := MatrixaufVektoranwenden(MatrixXYRot,Result[3]);
 
end;
 

Das ganze funktioniert zwar allerdings mit einer mißerrablen Genauikeit. Selbst die 3 Stelle nach dem Kommar stimmt manchmal nicht.

Darum meine Frage an euch:
Hat schon jemand so eine Art AntiMatrix Routine programmiert und wie soll ich da weiter vorgehen. Im Prinzip muss ich ja noch eine Scallierung und eine Verschiebung rückgängig machen und dann hätte ich es ja. Allerdings ist müßte ich davor erstmal die Genauikeit verbessern...

Wäre vielleicht doch Cos und Sin Funktionen besser dafür geeignet?
Hat einer von euch schonmal so etwas gemacht?

MfG
IFlo

_________________
Danke an alle, die mir (und anderen) geholfen haben.
So weit... ...so gut

Nach oben

Delphic

Betreff des Beitrags:

Verfasst: Di Okt 05, 2004 10:04

DGL Member

Registriert: Do Mai 30, 2002 18:48
Beiträge: 1617

Das was du suchst heist Matrizeninversion - das erklär ich jetzt aber nicht, das ist nämlich nicht so ganz trivial. Kannst dich dann ja im Internet mal schlau machen, wies funktioniert und dann einen Blick in die geometry.pas von GlScene werfen, dort haben die das recht schnell gelöst.

Nach oben

Sascha Willems

Betreff des Beitrags:

Verfasst: Di Okt 05, 2004 10:54

DGL Member

Registriert: Mo Sep 23, 2002 19:27
Beiträge: 5812
Programmiersprache: C++

Hier steht drin wie man die inverse Matrix berechnet, und auch vieles mehr. Dieses Matrix-FAQ sollte sich jeder Interessierte auf der Platte ablegen, da werden nämlich so gut wie alle Fragen abgeklärt.

_________________
www.SaschaWillems.de | GitHub | Twitter | GPU Datenbanken (Vulkan, GL, GLES)

Nach oben

Flo

Betreff des Beitrags:

Verfasst: Di Okt 05, 2004 13:46

DGL Member

Registriert: Do Jun 19, 2003 10:44
Beiträge: 991
Wohnort: Karlsfeld (nahe München)

Danke für den Link.
Warum der alldings alles so monoton gehalten hat ist mir ein Rätzel
MfG
IFlo

_________________
Danke an alle, die mir (und anderen) geholfen haben.
So weit... ...so gut

Nach oben

Flash

Betreff des Beitrags:

Verfasst: Di Okt 05, 2004 13:54

Guitar Hero

Registriert: Do Sep 25, 2003 15:56
Beiträge: 7810
Wohnort: Sachsen - ERZ / C
Programmiersprache: Java (, Pascal)

Is bestimmt ein Mathematiker. Bei denen is das normal. :wink:

_________________
Blog: kevin-fleischer.de und fbaingermany.com

Nach oben

Seite 1 von 1

[ 5 Beiträge ]

Foren-Übersicht » Programmierung » OpenGL

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.