C++ grafische Ausgabe von einem Rechteck

[Gerno (Gast)]

Guten Tag,

unter C++ kann ich ein Rechteck grafisch ausgebe.

Übergabeparamter: x1,y1,x2,y2
rechteck(x1,y1,x2,y2);

Nun möchte ich, das Rechteck um 45 Grad oder auch -45 Grad drehen.
Nun weiss ich nicht wie ich dies implementieren könnte.

[Rufus Τ. F. (rufus)]

Du kannst das Ausgeben des Rechtecks selbst implementieren, in dem Du 
viermal eine Funktion zum Zeichnen einer Linie aufrufst.

Dazu musst Du zunächst aus den zwei übergebenen Koordinaten vier machen 
- eine für jede Ecke.

x1, y1, x2, y2 -->

x1, y1 | x1, y2 | x2, y1 | x2, y2

Wenn Du eine solche Zeichenfunktion erstellt hast, musst Du jetzt die 
Koordinaten nach Deiner Abbildungsvorschrift (Rotation) transformieren.

Dazu wäre zu klären, wie die Rotation zu erfolgen hat; wo ist der 
Mittelpunkt der Drehung? In der Mitte des Rechtecks oder an einer der 
vier Ecken?

Mit etwas Trigonometrie kannst Du dann die neuen Eckkoordinaten 
berechnen.

Mit den so berechneten Koordinaten kannst Du das Rechteck mit Deiner 
Vier-Eckpunkte-Zeichenfunktion ausgeben.


Alternativ zeichnest Du das Rechteck mit der vorhandenen Ausgabefunktion 
und rotierst dann das resultierende Bitmap-Image.

Letzteres setzt aber detailliertere Kenntnisse des verwendeten 
Graphiksubsystems voraus und ist bei manchen auch gar nicht möglich (wie 
z.B. Plotter). Auch kommt es zu Störungen, wenn die Bitmap bereits 
andere Infomationen enthält als nur das gezeichnete Rechteck - die 
sollen ja vermutlich nicht mitrotiert werden

[Gerno (Gast)]

Mit dier Funktion
>>get_windowsize(&scrsizeX,&scrsizeY);
bekomme ich die Länge der X- Koordinate und Y- Koordinate.
Puhhh... ich hab da keine Ahnung wie ich deinen Vorschlag umsetzen 
könnte.

[Karl H. (kbuchegg)]

Gerno wrote:
> Mit dier Funktion
>>>get_windowsize(&scrsizeX,&scrsizeY);
> bekomme ich die Länge der X- Koordinate und Y- Koordinate.
> Puhhh... ich hab da keine Ahnung wie ich deinen Vorschlag umsetzen
> könnte.

Zuallererst:
C++ kennt keine Grafik.
Wenn du Grafik machen kannst, dann deshalb, weil jemand
dafür eine Bibliothek geschrieben hat, die wir aber nicht
kennen.

Das heist: In erster Linie solltest du mal in der Doku
zu dieser Bibliothek nachsehen, ob es da ev. etwas
gibt.

Wenn du das Rechteck drehen willst, dann hilft dir wahrscheinlich
die rechteck Funktion nicht weiter, weil diese immer ein
achsparallels Rechteck zeichnet. (Von diversen Möglichkeiten
wie Koordinatensystemtransformation sehe ich jetzt mal ab)

Dir bleibt also nichts anderes übrig, als dein Rechteck selbst
mit Linien zu zeichnen.
Das ist ja auch nicht weiter schwer.

                                   x2/y2
   #--------------------------------#
   |                                |
   |                                |
   |                                |
   #--------------------------------#
  x1/y1

Wenn du die Koordinaten des Punktes links/unten und der Punktes
rechts/oben kennst, dann kannst du ja die fehlenden 2 Eckpunkte
ganz leicht ermitteln und da du jetzt weist, welche Koordinaten
die 4 Punkte haben, kannst du 4 Linien zeichnen, die wieder
ein Rechteck ergeben.

Soweit so gut.
Aber jetzt willst du das Rechteck drehen.
Dazu musst du noch 2 Dinge wissen:
Um welchen Punkt soll das Rechteck gedreht werden?
Und um wieviele Grad soll es gedreht werden?

Der Rest ist dann reine Geometrie:
Um einen Punkt P um einen Punkt T zu drehen, genügt
es, zunächst mal alles so hinzudrehen, dass T in den
0-Punkt kommt. Dazu wird einfach von P der Punkt T abgezogen.

Danach dreht man den neuen Punkt P' soweit wie es der Winkel
vorgiebt und erhält einen neuen Punkt P'', welcher der
gedrehte Punkt ist.

Da man aber im ersten Schritt in den 0-Punkt verschoben hat,
muss diese Verschiebeung wieder rückgängig gemacht werden,
indem man zu P'' den T wieder dazuzählt und erhält P'''

Fertig. P''' sind die Koordinaten des Punktes P, wenn P um T
um einen Winkel a gedreht wurde.

Also nochmal:

Du hast:  Px, Py     Tx, Ty     und     a
          ( P ist der zu drehende Punkt
            T ist das Rotationszentrum
            a ist der Winkel )

    Px' = Px - Tx       // in den Ursprung verschieben
    Py' = Py - Ty

    Px'' = Px' * cos(a) - Py' * sin(a)   // drehen um den Ursprung
    Py'' = Px' * sin(a) + Py' * cos(a)

    Px''' = Px'' + Tx   // und wieder zurückschieben
    Py''' = Px'' + Ty


Damit kannst du 1 Punkt bearbeiten.
Du hast aber nicht 1 Punkt, du hast deren 4. Nämlich die
4 Eckpunkte deines (ungedrehten) Rechtecks. Also machst
du diese Drehoperation für jeden Eckpunkt des Rechtecks
und verbindest nachher die 4 rotierten Punkte wieder mit
Linien. Genauso wie du es beim nichtrotierten Rechteck
auch gemacht hast.

PS: vergiss nicht, dass sin / cos in C den Winkel in
Radianten haben möchte und nicht in Grad.

[Kai G. (runtimeterror)]

Zeichne dir ein Koordinatensystem auf kariertes Papier und zeichne das 
gewünschte Quadrat. Dann dasselbe mit einer anderen Größe.

Ist quasi ein grafischer Schreibtischtest ;)

Die vier Linien, die das Quadrat begrenzen musst du über dein Programm 
selbst zeichnen. Kann sein, dass es auch deiner Plattform fertige 
Funktionen gibt, aber ich denke mal, danach hast du schon gesucht.

Ich glaube nicht, dass man das noch viel einfacher formulieren kann...

Nur der Vollständigkkeit halber: Ein Quadrat mit der Kantenlänge x, 
welches um den Ursprung um den Winkel a gedreht wurde hat folgende 
Eckpunkte:
A(x / sqrt(2) * cos(a + 0.25 * pi), x / sqrt(2) * sin(a + 0.25 * pi))
B(x / sqrt(2) * cos(a + 0.75 * pi), x / sqrt(2) * sin(a + 0.75 * pi))
C(x / sqrt(2) * cos(a + 1.25 * pi), x / sqrt(2) * sin(a + 1.25 * pi))
D(x / sqrt(2) * cos(a + 1.75 * pi), x / sqrt(2) * sin(a + 1.75 * pi))

Die Linien müssen dann zwischen den Punkten
A und B
B und C
C und D
D und A
gezogen werden.

Ist jetzt aus dem Kopf - Fehler vorbehalten ;)

[Kai G. (runtimeterror)]

Woops... Rechteck ungleich Quadrat - Rufus Variante ist da angebrachter.