Dreieck um Punkt auf der Hypotenuse drehen

[w4rheart]

Hallo!

Ich hab folgendes vor: Ich möchte ein Dreieck um den Mittelpunkt der Hypotenuse Drehen:
http://img339.imageshack.us/img339/7599/unbenanntia.jpg

Ich kenne die Punkte des Dreiecks, und die winkel, so z.B.:

Delphi-Quellcode:

A:=Point(100,100);
B:=Point(100,150);
C:=Point(250,125);
canvas.Polygon([A,B,C]);

Ich möchte das Dreieck um jeden beliebigen Winkel drehen können, wie genau kann ich sowas in Delphi machen?
Bzw. wie kann ich die neuen Punkte (Ax,Bx,Cx) bestimmen?
Ich meine zu wissen, dass es da irgendeine Formel mit sin, cos und den Winkeln oder ähnlichem gibt, weiss aber nicht genau wie die lautet und wie genau die funktioniert =(

Könnte mir jemand Weiterhelfen und Erklären, wie ich die neuen Punkte nach einer Rotation bestimmen, und so das das neue Dreieck zeichnen kann?
Wäre super, wenn ihr mir da weiterhelfen könntet ;)

MfG
w4rheat

[jmd anders]

das ist ein zweidimensionales problem, also brauchst du eine zweidimensionale drehmatrix(kannst du bei wikipedia nachlesen) stellst deine punkte einfach als vektoren dar und wendest auf alle die drehmatrix an.
je nachdem in welchen punkt du deinen koordinatenurspung legst, wird um diesen punkt gedreht.

[w4rheart]

Erstmal danke für die schnelle Antwort!

Aber ehrlich gesagt versteh ich deine Ausführungen nicht genau.
Hab mir den Artikel über Drehmatrizen bei wikipedia nal durchgelesen, aber nicht genau verstanden =(
(Hab auch noch nicht mit Matrizen oder Vektoren gearbeitet)
Bei wikipedia wird das ganze immer nur für 2 Punkte berechnet, wie mach ich das denn mit 3en? Wenn ich das Dreieck also um einen Punkt spiegeln will, der ja keine Eckpunkt des Dreiecks, sondern, wie oben beschrieben, der Mittelpunkt der Hypotenuse sein soll?

Könntest du evtl. noch mal etwas genauer versuchen mir das zu erklären, vll. auf eine einfachere Art und Weise?
Also vll. wo ich da wie dieses +- sin cos nehmen muss?
Wäre super =)

MfG

[jmd anders]

hm, wenn du dich nicht mit vektoren und matrizen auskennst, ist das auch nicht so schlimm, hier dann die Lösung.
um einen punkt von deinem dreieck um den koordinaten ursprung zu drehen benutzt du folgendes


Pneux = cos(alpha) * Px - sin(alpha) * Py
Pneuy = sin(alpha) * Px + cos(alpha) * Py

wobei Pneux und Pneuy die Koordinaten deines gedrehten Punkts sind und px und py, die deines ausgangspunkts.

diese operation musst du nun für alle drei punkte ausführen.
wenn du nun um einen bestimmten punkt drehen willst, musst du alle punkte von diesem bestimmten punkt aus beschreiben ( koordinatensytem verschieben)

[w4rheart]

Danke für die Antwort!

Hab es jetzt folgendermaßen umgesetzt:

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
var Ax,Bx,Cx,Ay,By,Cy:integer;
begin
winkel:=strtoint(Edit1.Text);//(45)

Ax := round(cos(radtodeg(winkel)) * A.x - sin(radtodeg(winkel)) * A.y);
Ay := round(sin(radtodeg(winkel)) * A.x + cos(radtodeg(winkel)) * A.y);
A:=Point(Ax,Ay);

Bx := round(cos(radtodeg(winkel)) * B.x - sin(radtodeg(winkel)) * B.y);
By := round(sin(radtodeg(winkel)) * B.x + cos(radtodeg(winkel)) * B.y);
B:=Point(Bx,By);

Cx := round(cos(radtodeg(winkel)) * C.x - sin(radtodeg(winkel)) * C.y);
Cy := round(sin(radtodeg(winkel)) * C.x + cos(radtodeg(winkel)) * C.y);
C:=Point(Cx,Cy);

Image1.Canvas.Polygon([A,B,C]);
end;

Allerdings funktioniert das nicht so wie es soll. Es wird kein Dreieck gezeichnet, und die Werte für z.B. Bx liegen bei -100...
Was mache ich falsch?

Hab auch noch das Test-Projekt als Attachement hinzugefügt, vll. wird dadurch eher klar wie ich mir das vorstelle^^

MfG

[jmd anders]

Es funktioniert an sich wunderbar ;) Das einzige Problem ist nun, dass dein Drehpunkt im Koordinatenursprung liegt (links oben).
Es wird also um diesen Punkt gedreht, daraus folgt, dass du bei deiner Voreinstellung(45°) so weit drehst, dass es die Koordinaten nicht mehr auf deinem Image angezeigt werden. Wenn man dreimal drückt sollte man sehen, dass das Dreieck auftaucht, wenn man noch viel öfter drückt sieht man die Kreisbahn.

Dein Problem ist nun die Drehung um einen vorgegebenen Punkt. Dazu tust du am besten so, als wäre der Drehpunkt dein Koordinatenursprung. Du beschreibst nun deine drei Eckpunkte ausgehend von dem Drehpunkt. Dann führst du mit diesen Koordinaten deine Drehung durch und verschiebst nun das gedrehte Dreieck an den Punkt, wo du es gerne hättest, zb Mitte des Timage.

[w4rheart]

Hey, ja so hab ich das jetzt auch gemacht =) :

Delphi-Quellcode:

winkel:=strtoint(Edit1.Text);//(45)

Ax := round(cos(degtorad(winkel)) * (A.x-xpos) - sin(degtorad(winkel)) * (A.y-ypos));
Ay := round(sin(degtorad(winkel)) * (A.x-xpos) + cos(degtorad(winkel)) * (A.y-ypos));
A:=Point(xpos+Ax,ypos+Ay);

Bx := round(cos(degtorad(winkel)) * (B.x-xpos) - sin(degtorad(winkel)) * (B.y-ypos));
By := round(sin(degtorad(winkel)) * (B.x-xpos) + cos(degtorad(winkel)) * (B.y-ypos));
B:=Point(xpos+Bx,ypos+By);

Cx := round(cos(degtorad(winkel)) * (C.x-xpos) - sin(degtorad(winkel)) * (C.y-ypos));
Cy := round(sin(degtorad(winkel)) * (C.x-xpos) + cos(degtorad(winkel)) * (C.y-ypos));
C:=Point(xpos+Cx,ypos+Cy);

Image1.Canvas.Polygon([A,B,C]);

Jetzt bleiben nur noch 2 Probleme:
1. Wie kann ich das alte Dreieck vorher löschen? Also ich will das nicht mit z.B. weiss nochmal übermalen (falls das überhaupt geht),
sondern einfach löschen, so dass immer n ur 1 Dreieck angezeigt wird, geht das?
2. Wenn ich auf vorwärts gehen klicke, dann soll das dreieck um 10 nach vorne springen, allerdings in die jeweilige richtung in der es gedreht ist.
Z.B. 90 drehen, dann 10 vorwärts -> 10 schritte nach rechts.

Hast du da evtl. auch eine Lösung für mich parat? =)
Übrigens echt super wie einem hier in diesem Forum geholfen wird, lobt sich sowas ;)

MfG

[Lumpiluk]

Zitat:

Wie kann ich das alte Dreieck vorher löschen? Also ich will das nicht mit z.B. weiss nochmal übermalen (falls das überhaupt geht),
sondern einfach löschen, geht das?

Eigentlich nicht wirklich...

Worauf zeichnest du denn? (TImage oder TPaintBox?)
Löschen könntest du auf jeden Fall mit Canvas.FillRect(0,0,Width,Height);, aber am besten führst du solche Zeichnungen sowieso immer im OnPaint aus. Dann kannst du auch einfach mit dem Befehl 'Refresh' alles neu zeichnen.

[w4rheart]

^ auf einem TImage. Was hat den Paintbox für Vorteile?
Und wie genau meinst du:"eigentlich nicht wirklich..." ? :mrgreen:

MfG

[jmd anders]

zur 2ten Frage:
Das ist eine Bewegung entlang einer Gerade. Der Winkel der Geraden ist gegeben(durch deine Drehungsvorgabe).
einfach Dreiecksbeziehung:

x = cos(alpha) * Verschiebung + x;
y = sin(alpha) * Verschiebung + y;

für jeden Punkt ausführen, sollte die Punkte verschieben. falls nicht einfach mal ein Blatt Papier benutzen ;)

[w4rheart]

Also das mit dem löschen hab ich jetzt über Image1.Canvas.Pen.Mode:=pmnotxor; hinbekommen.

Allerdings das mit dem verschieben... Es ist zum Haare ausreissen^^
Es springt einfach immer in die falsche richtung! Bzw je nachdem was ich einstelle um 90° bzw. 180° in die falsche richtung.
und wenn ich dann erneut auf drehen klicke, rotiert das rechteck wieder um den mittelpunkt :evil:
Ich bekomme nicht heraus woran es liegt.
Blatt Papier und Stift hab nix gnützt... =(

Bitte schau sich das noch einmal einer an.
MfG

//Edit: das mit dem drehen ist mir jetzt klar, ich hab die xpos und ypos nicht verändert. Ist nur noch die Frage um welchen wert ich die jeweils bei welcher drehung verändern muss...

//Edit2:

Delphi-Quellcode:

ypos:= ypos + round(cos(degtorad(winkel)) * strtoint(Edit1.text));
xpos:= xpos + round(sin(degtorad(winkel)) * strtoint(Edit1.text));

tuts leider nicht, weiss jemand wieso?

//Edit3: doch tuts wohl :D... letztes Problem (diesmal wirklich): der geht immernoch in die falsche richtung. immer nach unten rechts...

Delphi-Quellcode:

  Ax := round(cos(degtorad(winkel)) * strtoint(edit1.Text) + A.x);
  Ay := round(sin(degtorad(winkel)) * strtoint(edit1.Text) + A.y);
  A:=Point(Ax,Ay);

  Bx := round(cos(degtorad(winkel)) * strtoint(edit1.Text) + B.x);
  By := round(sin(degtorad(winkel)) * strtoint(edit1.Text) + B.y);
  B:=Point(Bx,By);

  Cx := round(cos(degtorad(winkel)) * strtoint(edit1.Text) + C.x);
  Cy := round(sin(degtorad(winkel)) * strtoint(edit1.Text) + C.y);
  C:=Point(Cx,Cy);

hierran muss irgendetwas nicht stimmen...
Komischerweise: bei 3*45 Drehung (135)+ vorwärts, funktionierts !? warum...?

[jmd anders]

du musst natürlich noch speichern, wie groß der winkel aktuell ist. durch drücken des knopfs sollte dann immer nur eine addition zu dem winkel stattfinden

[w4rheart]

stimmt, natürluch :pale:
so jetzt zeichnet der meine Linie richtig, aber das Dreieck an der falschen stelle, bzw immer verschoben...
Wäre super, wenn du dir das nochmal angucken könntest :oops: :lol:

[ensaron]

Bastel dir doch mal eine Procedure, die das Dreieck im angegebenen Winkel an einem zu übergebenen Punkt neuzeichnet.
Die Verschiebung deines Punktes funktioniert ja und dann müsstest du nur noch das Dreieck an der neuen Position des Punktes im jeweils aktuellen Winkel neu zeichnen.

[Panthrax]

Ich habe eine Lösung mal ausgehend von obigem Programm (#13) und mithilfe meiner eigenen Mathe-Unit angefertigt. Eigentlich ist vom ursprünglichen Programm nicht viel übrig geblieben. Allerdings hat sich auch der Mathewald gelichtet und die eigentlichen Operationen sind klarer erkennbar. Die wesentlichen Teile meiner Unit habe ich in die Unit1.pas kopiert, ob Du die Unit allerdings kompilieren kannst, hängt von der verwendeten Delphi-Version ab. Ggf. müssen die Record-Methoden in Routinen umgeschrieben werden. Du könntest Deine Delphi-Version im Profil angeben, das würde Deinen Helfern helfen. :zwinker:

[w4rheart]

^ Danke für deine Mühe! =)
Also Ich benutzt Delphi 7, und konnte es, wie du schon richtig vermutet hast, nicht kompilieren :(
(Records konnten nicht kompiliert werden)

Wie muss ich die verändern?

[Panthrax]

Das hier müsste gehen, ist aber freihand getippt.

Delphi-Quellcode:

type
  TVector2D = record
    X, Y: Extended;
  end;

{ TVector2D }

function Vector2DAdd(const Left,
  Right: TVector2D): TVector2D;
begin
  Result.X := Left.X + Right.X;
  Result.Y := Left.Y + Right.Y;
end;

function Vector2DToPoint(const Value: TVector2D): TPoint;
begin
  Result.X := Round(Value.X);
  Result.Y := Round(Value.Y);
end;

function Vector2DNew(const X, Y: Extended): TVector2D;
begin
  Result.X := X;
  Result.Y := Y;
end;

procedure Vector2DRotate(var Vector: TVector2D; const Alpha: Extended);
var
  S, C, T: Extended;
begin
  C := Cos(Alpha);
  S := Sin(Alpha);
  T := X;
  Vector.X := C * Vector.X - S * Vector.Y;
  Vector.Y := S * T + C * Vector.Y;
end;

function Vector2DRotated(const Vector: TVector2D; const Alpha: Extended): TVector2D;
begin
  Result.X := Vector.X;
  Result.Y := Vector.Y;
  Vector2DRotate(Result, Alpha);
end;

{ TForm1 }

begin
  X := Vector2DNew(-80, 0);
  // ...

  U := Vector2DToPoint(Vector2DAdd(O, Vector2DRotated(X, Alpha)));
  // ...
end;

[shmia]

Schau mal hier, damit wirst du bestimmt zurechtkommen.

Also du hast deine drei Punkte des Dreiecks (a,b,c) und den roten Drehpunkt (dreh).
Dann muss das Dreieck so verschoben werden, dass der Drehpunkt in den Ursprung (0,0) fällt.
Nun wird gedreht und anschliessend das Polygon wieder zurückverschoben.
Man kann das Verschieben, Drehen und Zurückverschieben auch mit einer 2D-Matrix berechnen,
aber so ist es leichter verständlich.

Delphi-Quellcode:

var
  dreieck : array[0..2] of TPoint;
  dreh, t : TPoint;
begin
  // Anfangspunkte setzen
  dreieck[0] := Point(..,..);
  dreieck[1] := Point(..,..);
  dreieck[2] := Point(..,..);
  dreh := Point(...,...);

  // Dreieck in den Ursprung verschieben
  t := Point(-dreh.x,-dreh.y);
  Translate2Darray(dreieck, t);

  // Dreieck drehen
  Rotate2Darray(dreieck, DegToRad(30));  // Drehung 30 Grad

  // zurück in den Drehpunkt schieben
  Translate2Darray(dreieck, dreh);

[Panthrax]

Shmia, da werden sich die Rundungsfehler aufaddieren.

Zitat:

Zitat von shmia

Man kann das Verschieben, Drehen und Zurückverschieben auch mit einer 2D-Matrix berechnen, (...)

Das geht nicht, (Schieben, Drehen) ist etwas anderes als (Drehen, Schieben). Dies Operationen können nicht zusammengafasst werden, wie etwa 2*X + 3*X = 5*X.

[Medium]

Doch, können sie. Die Matrixmultiplikation ist nicht Kommutativ, was eben genau diesen Umstand so wunderbar herrlich anschaulich wiederspiegelt. Und man verknüpft Transformationen via Multiplikation, nicht Addition ;)

[Panthrax]

Zitat:

Zitat von Medium

Doch, können sie.

Das glaube ich erst, wenn ich es sehe, denn:

Zitat:

Zitat von Medium

Die Matrixmultiplikation ist nicht Kommutativ, (...)

Multiplizieren ist kommutativ. Hier wird aber nicht nur multipliziert: Die Operationen können nicht vertauscht werden. (Schieben, Drehen) ist etwas anderes als (Drehen, Schieben). -- Man nehme einen Stift und mache einen Punkt auf einem Blatt Papier. Nun fixiere man das Blatt mit dem Stift an einem zweiten Punkt auf dem Tisch. Das ist die Auslangslage. Nun: (1) Blatt 90° im Uhrzeigersinn drehen, dann 10cm nach Osten schieben. (2) Blatt 10cm nach Osten schieben (unter dem Drehpunkt verschieben), dann 90° im Uhrzeigersinn drehen. Ergebnis, der Punkt endet an unterschiedlichen Positionen.

Zitat:

Zitat von Medium

(...)via Multiplikation, nicht Addition ;)

Mensch, das war ein Beispiel, in dem man Operationen "zusammenfassen" kann. :roll:

[jfheins]

Zitat:

Zitat von Panthrax

Zitat:

Zitat von Medium

Doch, können sie.

Das glaube ich erst, wenn ich es sehe, denn:

Ich hab mich auch gewndert, musste dann aber an Homogene Koordinaten denken, mit denen geht das.
Damit wird im 2-dim. Fall eine 3x3 Matrix benötigt, aber dann kommt man mit nur einer Matrizenmultiplikation aus ;)

Zitat:

Zitat:

Zitat von Medium

Die Matrixmultiplikation ist nicht Kommutativ, (...)

Multiplizieren ist kommutativ.

Bei reellen Zahlen ja, aber Matrizenmultiplikation ist nicht kommutativ.

P.S.: Hab das mal kurz duchgerechnet, es kommt das gleiche raus. Die Matrix ist dann wie im Anhang ;)

\begin{pmatrix}x' \\ y' \\ 1 \end{pmatrix}
=
\begin{pmatrix}
cos\ \gamma & -sin\ \gamma & -x_0\ cos\ \gamma+y_0\ sin\ \gamma+x_0\\
sin\ \gamma & cos\ \gamma & -x_0\ sin\ \gamma-y_0\ cos\ \gamma+y_0\\
0 & 0 & 1
\end{pmatrix}
*
\begin{pmatrix}x \\ y \\ 1 \end{pmatrix}

[w4rheart]

Hello again!
Also dank eurer Hilfe hab ich jetzt soweit das meiste hingekriegt!
Allerdings zeigen sich jetzt bei dem Programm die von euch oben angesprochen Rundungsfehler.
Das ist meine DrehFunktion:

Delphi-Quellcode:

var
  Ax,Bx,Cx,Ay,By,Cy,winkelx:integer;
  Sn,Cs:extended;
begin
  deldreieck;  //altes Dreieck löschen
  winkel:=winkel-alpha;

  Cs:= cos(degtorad(alpha));
  Sn:= sin(degtorad(alpha));

  //Neue Punkte errechnen(nachRotation)
  Ax := round(Cs * (A.x-xpos) - Sn * (A.y-ypos));
  Ay := round(Sn * (A.x-xpos) + Cs * (A.y-ypos));
  A:=Point(xpos+Ax,ypos+Ay);

  Bx := round(Cs * (B.x-xpos) - Sn * (B.y-ypos));
  By := round(Sn * (B.x-xpos) + Cs * (B.y-ypos));
  B:=Point(xpos+Bx,ypos+By);

  Cx := round(Cs * (C.x-xpos) - Sn * (C.y-ypos));
  Cy := round(Sn * (C.x-xpos) + Cs * (C.y-ypos));
  C:=Point(xpos+Cx,ypos+Cy);

  Image1.Canvas.Polygon([A,B,C]);  // Neues Dreieck Zeichnen

(A,B,C,xpos,ypos sind globale Integer Variablen)

Bei Kleineren Winkeln funktioniert das Ganze nicht! -> Rundungsfehler?
Die Version von Panthrax funktioniert, allerdings habe ich da noch nicht ganz durchgeblickt,
und weiss nicht genau wie ich das auf meien Prozedur oben anwenden soll.

Hab im Anhang nochmal das Programm beifügt.
(Beim löschen des alten Dreiecks gibt es immmernoch Probleme... ist aber erstmal nicht ganz so wichtig)

MfG
w4rheart

//EDIT: Hat sich erledigt. hab jetzt alles mit reals gerechnet und nicht mehr mit integern, jetzt tuts eig. alles (Programm im Anhang).
Bis auf 1. Sache (Das wird aber wahrscheinlch durch das Canva sbedingt nicht lösbar sein, glaub ich):
Wenn ein neues Dreieck gezeichnet wird, muss das alte vorher gelöscht werden. Wenn das Dreieck aber jetzt auf einer linie Mit einem gezeichneten Strich liegt, wird dieser Auch gelöscht, so entsehen Lücken! - Und die will ich weghaben^^
Ist evtl möglich 2 Timage.Canvas übereinander zulegen, und 1 Transparent zu machen? So könnte man auf einem nur die Dreiecke Zeichnen, und auf dem anderen die linien :)
Mh, Probier ich mal aus...

[Medium]

Zitat:

Zitat von Panthrax

Das glaube ich erst, wenn ich es sehe

Sei A eine Translationsmatrix mit A =

Code:

|x 0 0|
|0 y 0|
|0 0 1|

und B eine Rotationsmatrix mit B =

Code:

|cos -sin 0|
|sin  cos 0|
| 0   0   1|

Dann ist X = A*B =

Code:

|x*cos -x*sin 0|
|y*sin  y*cos 0|
|  0      0   1|

Und X' = B*A =

Code:

|x*cos -y*sin 0|
|x*sin  y*cos 0|
|  0      0   1|

Und offensichtlich ist X != X'

[w4rheart]

Weiss hier zufälligerweise jemand, wie ich eine Bitmap auf transparent bekomme?

Delphi-Quellcode:

  Image2.canvas.Brush.Style := bsClear;
  Image2.Canvas.FillRect(Rect(0,0,300,300));
  Image2.Transparent := True;
  Image1.Picture.Bitmap.Transparent:=true;
    with Image1.Picture.Bitmap do begin
    TransparentColor := CLWHITE;
    TransparentMode := tmFixed;
    end;
  Image2.Picture.Bitmap.TransparentColor := Image2.Picture.Bitmap.Canvas.Pixels[1,1];
  Image2.picture.Bitmap.TransparentMode:=tmAuto;  
  A.x:=xpos-10;

Hat alles nichts genützt!
Hilfe, wie geht das? :-D

MfG

//EDIT: einfahc transparent auf true setzen, bei delphi 5 funktionierts, bei delphi 7 nicht, da wirds weiss, seltsam.
Hab jetzt auf jedenfall alles hingekriegt!
Nochmals vielen Dank an alle für die Hilfe =)

[Panthrax]

Zur Transparenz: Bei mir funktioniert das wunderbar:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
begin
  with Image1 do
  begin
    Canvas.Brush.Color := clBlue;
    Canvas.FillRect(Rect(Point(0,0), Point(Width, Height)));
    Canvas.Brush.Color := clNavy;
    Canvas.FillRect(Rect(Point(20,20), Point(Width-20, Height-20)));
  end;
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  with Image1 do
  begin
//    Picture.Bitmap.TransparentColor := clYellow;
    Transparent := True;

    Canvas.Brush.Color := clYellow;
    Canvas.FillRect(Rect(Point(40,40), Point(Width-40, Height-40)));
  end;
end;

In der Delphi-Hilfe steht aber auch: "Anmerkung: Transparent wirkt sich nur dann aus, wenn in der Eigenschaft Picture ein TBitmap-Objekt enthalten ist."

Zum Rundungsproblem: Solange die berechneten Werte die Parameter für die nächste Berechnung sind, werden sich die Rundungsfehler aufaddieren. Mit höherer Genauigkeit wird der Verformungseffekt nur verlangsamt. Warum nicht nur den Winkel ändern und mit den ursprüglichen Werten rechen, die das Dreieck beschreiben?

Zu den Matrizen :

Zitat:

Zitat von Medium

Zitat:

Zitat von Panthrax

Zitat:

Zitat von Medium

Zitat:

Zitat von Panthrax

Zitat:

Zitat von shmia

Man kann das Verschieben, Drehen und Zurückverschieben auch mit einer 2D-Matrix berechnen, (...)

Das geht nicht, (...)

Doch, können sie. (...)

Das glaube ich erst, wenn ich es sehe, (...)

Sei A (...)

Und dann kommt er mich ja doch mit einer 3x3-Matrix... aber ich seh' schon, wir haben uns da missverstanden. Und über die Vertauschbarkeit der Operationen hat ja auch nie jemand etwas anderes behauptet... Am Ende enthalten die Matrizen dieselben Formeln, denn sie enthalten immernoch die Variablen. Mit zunehmender Komplexität der Operationen werden die Berechnungen auch teurer, als bei der schrittweisen Berechnung, da mehr Multiplikationen erzeugt werden. Die schrittweise Berechnung kann man auch nach langer Zeit und ohne Dokumentation wieder intuitiv verstehen. Solange man auf die Matrizen verzichten kann... sollte man das tun.

[Medium]

Macht der Gewohnheit, ich denke nur in homogenen Koordinaten :oops:. Für 2x2 Matrizen schaut das aber ganz genau so aus, da die 3. Zeile/Spalte auch wieder nur die Identität in der 3. Dimension ist.
Aber wie du schon sagst, ist es meist nicht sinnvoll alle Transformationen zusammenzuziehen, da man letztlich bei mindestens genau so vielen Operationen landet wie bei der schrittweisen Anwendung, und es doch eher selten ist, dass man hunderte Male genau die selbe Transformation ausführt. Aber gehen tut es, in egal wie vielen Dimensionen ;)

[w4rheart]

Hallo!

Ich melde mich hier nochmal!
Leider immernoch das Problem der Tranzparaenz eines Image, und des dadrauf gezeichneten Canvas.

Ich habe "transparent" des oben liegenden canvas auf "true" gesetzt;
Kurz und Knapp: Auf machen Rechnern wird das Image transparent, auf anderen wiederum nicht!
Ich habe zum teil sogar nicht neu kompiliert, sondern eifnach die exe kopiert:
selbes Ergebnis, auf manchen Rechnern (selbst gleiches Betriebsystem etc.) wird das Image nicht transparent!

Woran kann das liegen? Für mich hört sich das sehr absurd an...
Kann mir jemand weiterhelfen? Gibt es noch weitere Methoden ein Image/Canvas transpartent zu machen?

MfG

[w4rheart]

bump

Hab noch immer keinen plan warum es nur auf manchen PCs funktioniert...

EDIT: hat sich erledigt^^ das von panthrax hat geholfen =)