AWT drawArc/ fillArc Problem mit Benutzung

[Gelöschtes Mitglied 16778]

Guten Abend,

ich hatte an der Uni nen Mathe-Java-Crashkurs und zum Abschluss muss jeder nen kleines mathematisches Programm mit AWT-Oberfläche machen.

Ich zeichne nen Dreieck, die Eckpunkte können gezogen werden und das Dreieck wird sofort neu gezeichnet und die Winkel neu Berechnet.

Jetzt möchte ich die Winkel auch einzeichen, jedoch bereitet mir fillArc so einige Probleme

        //Angle at A
        Vector2 v = c.getVector();
        g.fillArc(
            (int)A.getX() - 10, (int)A.getY() -10,
            20, 20,
            -(int)v.getY(), (int)alpha);
//fillArc(    int x, int y,
//            int width, int height,
//            int startAngle, int arcAngle)

Eigentlich ist mein Problem nur die 3. Zeile, der startAngle- und der arcAngle-Wert.
Mit den ersten beiden Zeilen definiere ich meinen Eckpunkt als "Kreismittelpunkt" vom Kreisbogen.
Jedoch wie ich die 3.Zeile korrekt berechne ist mir ein Rätsel.
Problem ist, dass ich nen Winkel angeben muss, jedoch muss ich den ja irgendwie berechnen aus dem Punkt auf der Strecke c im Abstand (hier) 20 ...
Vielleicht könnt ihr mir da helfen?

Falls benötigt:
Ich hab mir folgende mathematische Klassen geschrieben, heißt dass ich die Elemente als mathematische Objekte behandle und die Werte als double berechne:
Matrix2x2 - 2x2 Matrizen behandeln
Vector2 - 2-Dim Vektor
Point - Punkt (x, y)
Line - Gerade durch 2 Punkte
LineSegment - Strecke von A nach B
Triangle - Dreieck, definiert durch die Eckpunkte

 

[0x7F800000]

Was sind "A v c alpha"? Vor allem: wieso ist "A" großgeschrieben, wenn es doch anscheinend eine Instanz von irgendwas ist?
Mir ist irgendwie unklar, was du hier erwartest. Hellsehen können wir hier nicht. Wenn du irgendeine rein geometrische Frage hast, dann wäre eine genaue erklärung oder eine Skizze ganz hilfreich, aus diesen drei zeilen code kann ich mir leider kein Bild machen.

Ich möchte aber schonmal drauf hinweisen, dass die drawArc-methoden der Graphics klassen nicht die Winkeln, sondern die werte der winkeln in Gradmaß erwarten. Wenn dein Alpha also im normalen Bogenmaß gespeichert ist, wirst du höchstwahrscheinlich nichts sehen, weil diese methode einen Wert erwartet, der um faktor 180/PI größer ist. Da hilft allerdings Math.toDegrees() ganz gut aus, wenn man sich unsicher ist... In der Math klasse sind auch die ganzen Arkus-funktionen drin...

 

[Marco13]

Für den Start- und Arcwinkel (falls das die Frage war) gilt grob:
startWinkel = Winkel der ersten Dreiecksseite zur x-Achse
arcWinkel = Winkel der zweiten Dreiecksseite zur x-Achse - startWinkel
(das ganze natürlich modulo irgendwelcher Vorzeichen )

 

[Gelöschtes Mitglied 16778]

@0x7F800000
Entschuldige bitte, hatte mir gestern Abend wohl nicht zuviel Mühe gemacht, hier ein paar Bilder:
Startzustand (sieht noch gut aus):

Wenn ich A (unten links) verschoben habe:

Wenn ich B (unten rechts) verschoben hab, ist der Winkel hin:

Wenn ich C (oben) verschoben hab und über die 180° Grenze komme ist es auch wieder kaputt, bis dahin war aber alles noch gut:


Meine benutzen Variablen sind folgende:

//Corners
private Point A, B, C;
//Sides/ Edges
private LineSegment a, b, c;
//Angles
private double alpha, beta, gamma;

Wobei A, B, C die Eckpunkte sind,
a, b, c die den Eckpunkten gegenüberliegenden Seiten, also a = Strecke BC,
alpha, beta, gamma die Winkel an den Punkten, wie folgt berechnet:

public void computeAngles() {
		double a, b, c;
		a = this.a.length();
		//[...]
		//angle at A
		alpha	= Math.acos(((b * b) + (c * c) - (a * a)) / (2 * b * c));
		alpha 	= Math.toDegrees(alpha);
		//[...]
}

@Marco13
Werde das mal ausprobieren, klingt vielversprechend.

 

[0x7F800000]

Jajaja, okay, alles klar.
War eigentlich zu erwarten, dass das Problem so ähnlich aussieht, aber wie konkret habe ich mir irgendwie nicht zusammenreimen können.

Also, zur Lösung deines Problems gibt's in java.lang.Math zum Glück schon eine Methode, die alle möglichen Richtungen berücksichtigt, und einen Winkel aus dem bereich [-Pi, Pi) rausspuckt, das ist der sogenannte atan2:
Math (Java Platform SE 6)

Was es tut, ist im prinzip sehr einfach: wenn du einen Punkt in der ebene hast, etwa (x,y) und die Polardarstellung von dem Punkt ist (x,y)=(r*cos(alpha), r*sin(alpha)) dann liefert atan2(x,y) genau das alpha.
Das ist exakt das was du hier ja haben willst.

Am beispiel vom Punkt A:
1) welcher Winkel zeigt in richtung B? Das ist

double alpha_B=Math.atan2(B.x-A.x,B.y-A.y);

2) im welchen Winkel zeigt die Strecke aus A in richtung C?

double alpha_C=Math.atan2(C.x-A.x,C.y-A.y);

3) Was ist der startwinkel, wo der blaue segment anfängt? Das hängt davon ab, wie das dreieck orientiert ist (sind ABC im Uhrzeigersinn, oder gegen den Uhrzeigersinn?)
Die orientierung berechnest du ganz einfach durch Vorzeichen von der Dritten Komponente des Kreuzproduktes

 (B-A)x(C-A)[3]=(B.x-A.x)*(C.y-A.y)-(B.y-A.y)*(C.x-A.x) >0 <0 ?

ob da jetzt bei + oder bei - links oder rechts ist, kann ich dir grad im kopf nicht sagen, einfach ausprobieren, guggen... Jedenfalls fängst du bei einem der beiden oben berechneten winkeln an zu zeichnen.
4) breite des gezeichneten bogen brauchen wir noch. Das ist etwas blöd, weil es nach einer umdrehung immer um 2Pi versetzt wird. Wenn du also differenz zwischen zwei winkeln ausrechnen willst, muss du das etwa so machen:

// gibt an, um wie welchen winkel man von "from" im mathematischen drehsinn laufen muss, um zu "to" zu kommen
double angleDifference(double from, double to){
   double result=to-from;
   if(result<0){
      result+=Math.PI*2;
   }
   return result;
}

So. Damit solltest du die beiden benötigten winkeln ausrechnen können. Nochmal erinnerung: drawArc erwartet das in grad umgerechnet, also Math.toDegrees() davorschalten. Viel Spaß.
[solltest du das nicht hinbekommen, dann bitte ich um kompilierbaren code, im kopf kann ich sowas auch nicht]

 

[Gelöschtes Mitglied 16778]

Okay, mit dem atan2() klappt das recht gut, der klebt jetzt an meinen beiden Seiten, jedoch Wechselt der Bogen nicht auf die innenseite, wenn ich über 180° gehe:


Zu beachten ist auch, dass man entweder 90° oder (PI / 2) abziehen muss, um an der richtigen Stelle anzukommen:

		double alpha_B=Math.atan2(B.getX() - A.getX(), B.getY() - A.getY());
		//alpha_B = Math.toDegrees(alpha_B) - 90;
		alpha_B -= Math.PI / 2;

ansonsten sieht es so aus:


Edit:
Wenn ich mir so die Werte anschaue die bei den berechneten alpha_B & alpha_C rauskommen, sowie beim alpha, dann seh ich da keine Grundlage zur Berechnung, ob ich schon über 180° liege oder nicht.
Ich glaube ich muss meine Winkelberechnung umstellen und die Winkel der Vektoren berechnen, dann müsste ich ja über 180° kommen und könnte das darüber abfangen, ...

Ich hoffe das klappt so, ansonsten muss ich sicherstellen, dass das Dreieck in seiner traditionellen Form nur verschoben werden kann.