Problem bei Winkelbestimmung

[babuschka]

Hallo!

Ich als absolute Java-Niete habe ein Problem bei der Bestimmung des korrekten Winkels.

zuerst die Randbedingungen:

ich habe eine Wand, die beliebig in der Ebene liegt. Da ich keine Ahnung von affinen Transformationen habe, musste ich die Wand über 4 Geraden implementieren, die dann über Winkelbeziehungen bestimmt wurden.
Das heißt, mein Konstruktor besteht aus 4 Punkten.
Die Klasse Wand soll darüber hinaus noch eine contains-Methode enthalten, die überprüft, ob ein beliebiger Punkt in der Wand liegt.

was ich bisher gemacht habe:
1. alle Längen bestimmt
2. Winkel zwischen Punkt und Wandseiten

public class Wand {
	Punkt2D A;
	Punkt2D B;
	Punkt2D C;
	Punkt2D D;
	
	public Wand (Punkt2D A, Punkt2D B, Punkt2D C, Punkt2D D){
		this.A = A;
		this.B = B;
		this.C = C;
		this.D = D;
	}
	
	public boolean contains (Punkt2D punkt){
		double dx_a = punkt.x - A.x;
		double dy_a = punkt.y - A.y;
		
		double dx_b = punkt.x - B.x;
		double dy_b = punkt.y - B.y;
		
		double dx_c = punkt.x - C.x;
		double dy_c = punkt.y - C.y;
		
		double dx_d = punkt.x - D.x;
		double dy_d = punkt.y - D.y;
		
		double AP = A.getAbstand(punkt.x, punkt.y);
		double BP = B.getAbstand(punkt.x, punkt.y);
		double CP = C.getAbstand(punkt.x, punkt.y);
		double DP = D.getAbstand(punkt.x, punkt.y);
		
		double AB = A.getAbstand(B.x, B.y);
		double BC = B.getAbstand(C.x, C.y);
		double CD = C.getAbstand(D.x, D.y);
		double DA = D.getAbstand(A.x, A.y);
		
		double gamma_a = Math.atan(dy_a / dx_a);
 		double gamma_b = Math.atan(dy_b / dx_b);
		double gamma_c = Math.atan(dy_c / dx_c);
		double gamma_d = Math.atan(dy_d / dx_d);

// Problem: nur positive Längen
// Hier Winkelbestimmung über Cosinus-satz

 		double alpha_a = Math.acos(((AP*AP + DA*DA - DP*DP)/(2*AP*DA)));
		double alpha_b = Math.acos(((BC*BC + BP*BP - CP*CP)/(2*BC*BP)));
		double alpha_c = Math.acos(((CP*CP + BC*BC - BP*BP)/(2*CP*BC)));
		double alpha_d = Math.acos(((DA*DA + DP*DP - AP*AP)/(2*DA*DP)));
		
		//Winkel der Gerade
		double phi = Math.atan((A.x-B.x)/A.y-B.y);
		
		double pi = Math.PI;

//		if ( dx_a <= pi/2 && dx_d <= pi/2 ) {
//Winkelbestimmungen hier mit Sinus-Satz
//			double alpha_1 = Math.asin(DP*Math.sin(gamma_a-gamma_d)/DA);
//			double alpha_2 = Math.asin(CP*Math.sin(gamma_b-gamma_c)/BC);
//		}
//		if ( dx_a >= pi/2 && dx_d >= pi/2 ) {
//			double delta_1 = Math.asin(AP*Math.sin(gamma_a-gamma_d)/DA);
//			double delta_2 = Math.asin(BP*Math.sin(gamma_b-gamma_c)/BC);
//		}		

		if (( alpha_a <= (pi/2) && alpha_b <= (pi/2)) || (alpha_c <= (pi/2) && alpha_d <= (pi/2) )){
			return true;
		}
		return false;
		

	}
}

anbei eine Zeichnung des Problems:




Mit der 3. if-Schleife soll überprüft werden, ob die Winkel, die mit den schmalen Seiten der Wand und der Gerade zum Punkt eingeschlossen sind, kleiner als 90° sind.
Mathematisch ist diese Lösung korrekt, nur Java erkennt das nicht (bzw. will nicht so wie ich will).

Wo starten die Winkel und in welche Richtung zeigen sie?
zeigen sie von der X-Achse in Richtung Y-Achse?
wie liegen diese Achsen in der Grafik?
erkennt Java die Lage des Winkels? und wenn nicht, muss da die Lage des Winkels mit dem Winkel der Gerade ausgeglichen werden?
geht es unter Umständen einfacher, die affine Transformation durchzuführen und das Koordinatensystem zu drehen? und wenn es einfacher geht, wie geht es?

Grütze,
Motzroff

 

[Marco13]

Ja nachdem, was das Ziel ist: Aus den Punkten kannst du einen GeneralPath erstellen, der eine contains-Methode anbietet. Wenn's das nicht ist, muss man vielleicht versuchen, die Zeichnung zu entschlüsseln :wink:

 

[0x7F800000]

1) Solange es nicht explizit um drehungen geht, ist verwendung von winkeln zu irgendwelchen zwecken grundsätzlich sehr verdächtig. es ist sehr rechenintensiv, unübersichtlich, und meistens unnötig.

2) Wand = Rechteck? 2d-Umgfk im 3d-Raum sind nullmengen, die wahrscheinlichkeit, dass du irgendeinen Punkt findest, der genau "in der Wand" liegt ist ziemlich genau 0, wenn man von rundungsfehlern absieht. So einen contains-test kannst du dir also sparen, dieser wird wohl bei jedem millionsten punkt funktionieren, und bei 999999 anderen, die einen halben digitalen nanometer von der wand entfernt sind, übersehen, wozu ist das also gut?

 

[babuschka]

naja, die problematik ist, dass wenn ich nur ein rechteck über g.drawRect() mache, dass nur in koordinatenrichtung gezeichnet werden kann. deshalb habe ich 4 punkte, die über geraden dargestellt werden.

@marco:
was hat es mit dem generalPath aufsich und wie sähe da eine implementierung aus? schreibe ich mir diesen generalPath in die containsmethode rein oder muss meine Klasse Wand nochmal komplett umgestellt werden?

 

[Marco13]

Ja, je nachdem wie du das machen wolltest. EINE Möglichkeit wäre (ganz grob) in der contains-Methode einen GeneralPath zu erstellen, dort dann mit moveTo/lineTo/close die Punkte hinzuzufügen, und auf diesem GeneralPath dann "contains" aufzurufen.