Mehrere logische Bedingungen testen

lion1981

Hallo Community,
ich bin ganz neu hier und hoffe, mir kann jemand diese einfach Frage beantworten?!?

Für meinen Code ist es notwendig 4 Bedingen zu überprüfen. Schematisch sieht das so aus:

Horizontal =1;
Vertikal = 1;
Check_result =1;

if (   ((Object[0].x < a)  ||   (Object[3].x ) >= b) ){                   // Bedingung 1 und 2
		Horizontal= 0;

    if (  ( Object[0].y < a )  ||  ( (Object[1].y)  >= c) ) {              // Bedingung 3 und 4
		Vertikal = 0;
    }
}

if (Horizontal ==0 || Vertikal == 0){
    Check_result=0;
}

return Check_result;

Leider bekomme ich mit dieser Vorgehensweise keine richtigen Ergebnisse für meinen "Vertikal" Anteil.

Kann mir jemand helfen?!?

Vielen Dank im Voraus. :xmas1:

Horizontal =1;
Vertikal = 1;
Check_result =1;

if (   ((Object[0].x < a)  ||   (Object[3].x >= b) ){                   // Bedingung 1 und 2
		Horizontal= 0;

    if (  ( Object[0].y < a )  ||   (Object[1].y  >= c) ) {              // Bedingung 3 und 4
		Vertikal = 0;
    }
}

if (Horizontal ==0 || Vertikal == 0){
    Check_result=0;
}

return Check_result;

Probier das mal

lion1981

Vielen Dank für Deine schnelle Antwort aber in deinem angegebenen Code erkenne ich keinen Unterschied zu meinem Ausgangscode.
Bin ich blind, ich sitze vermutlich shcon zu lang vor dem vermutlich "easy" Problem...

Xagen

Hi lion1981,

kann es sein, dass im diesem Teil

if (  ( Object[0].y < a )  ||  ( (Object[1].y)  >= c) ) {              // Bedingung 3 und 4

anstatt Object[1].y Object[3].y stehen soll? sowie bei x auswertung...

LG, Xagen.

lion1981

Hi,
Bedingung 1 und 2 überprüft "horizontale Abstände" Bed. 3 und 4 beziehen sich auf "vertikale Abstände".

Ich kann zwar auch Object[3].y anstatt Object[1].y schreiben, bring allerdings keine Verbesserung...

mgaeckler

lion1981 schrieb:

Hi,
Bedingung 1 und 2 überprüft "horizontale Abstände" Bed. 3 und 4 beziehen sich auf "vertikale Abstände".

Ich kann zwar auch Object[3].y anstatt Object[1].y schreiben, bring allerdings keine Verbesserung...

Du weißt schon, daß Bedingung 3 und 4 nur dann geprüft wird, wenn bed. 1 oder 2 war sind.

Ist das Absicht?

mfg Martin

lion1981

Richtig, wenn eine der Bedingungen 1 und 2 falsch ist, soll Bedingung 3 und 4 nicht überprüft werden. Das ist eigentlich das, was ich ausdrücken möchte.

Ich habe auch schon versucht die beiden if-Anweisungen nacheinander laufen zu lassen, erhlate da aber eine Endlosschleife.... Mein verwendeter Code sah so aus. Wäre das richtig?!?

Horizontal =1;
Vertikal = 1;
Check_result =1;

if (   ((Object[0].x < a)  ||   (Object[3].x ) >= b) ){                   // Bedingung 1 und 2
        Horizontal= 0;
}
if (  ( Object[0].y < a )  ||  ( (Object[1].y)  >= c) ) {              // Bedingung 3 und 4
        Vertikal = 0;
}

if (Horizontal ==0 || Vertikal == 0){
    Check_result=0;
}

return Check_result;

Versuch mal so. Bei mir hat Vertikal die richtige (zu erwartende) Werte ausgegeben.

if ((Object[0].x < a) || (Object[3].x >= b))     // Bedingung 1 und 2
	{														 
        Horizontal = 0; 

		if (( Object[0].y < a ) || ( Object[1].y >= c)) // Bedingung 3 und 4
		{               
			Vertikal = 0; 
		} 
	}

Allerdings habe ich einige runde Klammern entfernt.

lion1981

Leider habe ich mit weniger Klammern keinen Erfolg.

Vielleicht ist es ja ein genereller Denkfehler von mir. Ich habe folgendes Problem:
Ich habe ein äußeres und ein inneres (kleines) Rechteck. Jetzt möchte ich überprüfen, ob allseitig zwischen dem kleinen und großen Rechteck ein Sicherheitsabstand x eingehalten ist, dieser Abstand ist zwingend erforderlich.
Daher muss ich zwei Abstände horizontal und zwei Abstände vertikal mit meinem Sicherheitsabstand x vergleichen. Meinen dazu entwickelten Code habe ich oben aufgeführt.

Wird jetzt vielleicht klarer was ich meine?!? Ist mein Ansatz mit den verschachtelten if-Anweisungen falsch?!?

Vielen Dank!

lion1981 schrieb:

Richtig, wenn eine der Bedingungen 1 und 2 falsch ist, soll Bedingung 3 und 4 nicht überprüft werden. Das ist eigentlich das, was ich ausdrücken möchte.

Dann brauchst du eine && Verknüpfung und kein ||

mgaeckler

lion1981 schrieb:

Leider habe ich mit weniger Klammern keinen Erfolg.

Vielleicht ist es ja ein genereller Denkfehler von mir. Ich habe folgendes Problem:
Ich habe ein äußeres und ein inneres (kleines) Rechteck. Jetzt möchte ich überprüfen, ob allseitig zwischen dem kleinen und großen Rechteck ein Sicherheitsabstand x eingehalten ist, dieser Abstand ist zwingend erforderlich.
Daher muss ich zwei Abstände horizontal und zwei Abstände vertikal mit meinem Sicherheitsabstand x vergleichen. Meinen dazu entwickelten Code habe ich oben aufgeführt.

Wird jetzt vielleicht klarer was ich meine?!? Ist mein Ansatz mit den verschachtelten if-Anweisungen falsch?!?

Vielen Dank!

Nix wird klar. (zumindest ich steh' auf dem Schlauch)?

Was steht im Objektarray? Das scheinen x y Koordinaten zu sein? Da sind offensichtlich 4 Punkte enthalten (Objekt[0] - Objekt[3])

Was sind die Werte a, b und c?

Die Entfernung eines Punktes zu einer Gerade lässt sich relativ leicht berechnen (auch wenn ich die erforderliche Formel jetzt nicht im Kopf habe).

Ich würde von jedem der 3 Eckpunkte des inneren Dreiecks den Abstand zu jedem der 3 Kanten des äußeren Dreiecks berechnen. Wenn einer dieser 9 Abstände zu klein ist, hat deine Figur verloren. Ich weiß nicht, wie die beiden Dreiecke ermittelt werden. Möglicherweise kannst Du das ganze so optimieren, daß nicht alle 9 Abstände berechnet werden müssen. Wenn beispielsweise die Kanten grundsätzlich parallel sind, genügt es natürlich nur die Anstände der einzelnen Kanten zum jeweiligen Pendant auszurechnen. Die Abstände zweier paralleler Geraden, wenn jeweils 2 Punkte bekannt sind, sollten auch leicht berechenbar sein.

mfg Martin

hiho

wie wärs damit?

bool Check (int x, int x1, int a)
{
	int b = x - x1;

	if (b < 0)
		b *= -1;

	if (b < a)
		return false;
	else
		return true;
}

wo
x = die Koordinaten vom ersten Rechteck ( x oder y)
x1 = die Koordinaten vom zweiten Rechteck ( x oder y)
a = die benötigte Abstand

mgaeckler

mgaeckler schrieb:

Nix wird klar. (zumindest ich steh' auf dem Schlauch)?

...

Ich würde von jedem der 3 Eckpunkte des inneren Dreiecks den Abstand zu jedem der 3 Kanten des äußeren Dreiecks berechnen.

Oh Mann, mein OCR-System war gestern deffekt.

Meine Antwort muß natürlich für Rechtecke angepasst werden. Sollte aber kein Problem sein.

mfg Martin

lion1981

Sorry, ich bin ja neu hier im Forum, merke aber, dass meine bis jetzt gestellten Fragen zu unklar waren. Hier nochmal mein richtiger Code:

int Check_Safety_Factor (ObjectNodes Object, const float safety_factor, const float end_coordinate_horizontal, const float end_coordinate_vertikal  ){

	int Safety_Factor_OK, 	Safety_Factor_OK_Horizontal, Safety_Factor_OK_Vertical;

	Safety_Factor_OK_Horizontal = 1;
	Safety_Factor_OK_Vertical = 1;
	Safety_Factor_OK = 1;

	if (   (Object[0].x < safety_factor)  ||   (Object[3].x  >= end_coordinate_horizontal  - safety_factor  )       ){
		Safety_Factor_OK_Horizontal = 0;
			if (  ( Object[0].y < safety_factor )  ||  ( (Object[3].y)  >= end_coordinate_vertikal   - safety_factor) ) {
			Safety_Factor_OK_Vertical = 0;
			}
	}
if ( Safety_Factor_OK_Horizontal !=1 || Safety_Factor_OK_Vertical == 0){
		Safety_Factor_OK=0;
	}

		return Safety_Factor_OK;
}

Dann verwende ich den Safety_Factor_OK in folgender Routine:

for	( i = 0; i < num_windows; i++ ){
		while ( Safety_Factor_OK !=1){
			Generate_Nodes_Window ( &Window[i], direction, x_end, y_end, distance_nodes);
			Safety_Factor_OK = Check_Safety_Factor( Window[i], safety_factor_x, x_end, y_end );
}
	for ( j = 0; j < 4; j++ ){
				printf("Window %i node %i: %f\t %f\t %f\n", i+1, j+1, Window[i][j].x, Window[i][j].y, Window[i][j].z );
			}
			Safety_Factor_OK_Horizontal = 0;
			Safety_Factor_OK_Vertical = 0;
			Safety_Factor_OK = 0;
			}

Ich erzeuge mir automatisch generierte Fenster, die ich im Anschluss auf den Mindestabstand (Safety_Factor) überprüfen möchte.

Vielen Dank und nochmals sorry... Man lernt nie aus. :xmas2:

mgaeckler

lion1981 schrieb:

Sorry, ich bin ja neu hier im Forum, merke aber, dass meine bis jetzt gestellten Fragen zu unklar waren. Hier nochmal mein richtiger Code:

int Check_Safety_Factor (ObjectNodes Object, const float safety_factor, const float end_coordinate_horizontal, const float end_coordinate_vertikal  ){

	int Safety_Factor_OK, 	Safety_Factor_OK_Horizontal, Safety_Factor_OK_Vertical;

	Safety_Factor_OK_Horizontal = 1;
	Safety_Factor_OK_Vertical = 1;
	Safety_Factor_OK = 1;

	if (   (Object[0].x < safety_factor)  ||   (Object[3].x  >= end_coordinate_horizontal  - safety_factor  )       ){
		Safety_Factor_OK_Horizontal = 0;
			if (  ( Object[0].y < safety_factor )  ||  ( (Object[3].y)  >= end_coordinate_vertikal   - safety_factor) ) {
			Safety_Factor_OK_Vertical = 0;
			}
	}
if ( Safety_Factor_OK_Horizontal !=1 || Safety_Factor_OK_Vertical == 0){
		Safety_Factor_OK=0;
	}

		return Safety_Factor_OK;
}

Dann verwende ich den Safety_Factor_OK in folgender Routine:

for	( i = 0; i < num_windows; i++ ){
		while ( Safety_Factor_OK !=1){
			Generate_Nodes_Window ( &Window[i], direction, x_end, y_end, distance_nodes);
			Safety_Factor_OK = Check_Safety_Factor( Window[i], safety_factor_x, x_end, y_end );
}
	for ( j = 0; j < 4; j++ ){
				printf("Window %i node %i: %f\t %f\t %f\n", i+1, j+1, Window[i][j].x, Window[i][j].y, Window[i][j].z );
			}
			Safety_Factor_OK_Horizontal = 0;
			Safety_Factor_OK_Vertical = 0;
			Safety_Factor_OK = 0;
			}

Ich erzeuge mir automatisch generierte Fenster, die ich im Anschluss auf den Mindestabstand (Safety_Factor) überprüfen möchte.

Vielen Dank und nochmals sorry... Man lernt nie aus. :xmas2:

Ich glaube, ich verstehe jetzt, was Du willst.

Der horrizontale Abstand muß unabhängig vom vertikalen Abstand geprüft werden. Allerdings, wenn der horizontale schon nicht passt, interessiert der vertikale nicht mehr. Du beachtest den vertikalen Abnstand dann und nur dann, wenn der horizontale Abstand nicht passt. Wie wäre es mit so einer Lösung:

return ( Object[0].x < safety_factor
|| (Object[3].x  >= end_coordinate_horizontal - safety_factor  )
|| Object[0].y < safety_factor
|| (Object[3].y  >= end_coordinate_vertikal   - safety_factor) )
    ? 0 : 1
;

Hier wird eine 0 zurückgeliefert sobald einer der Abstände zu klein ist. Ich denke, das ist das was Du brauchst.

mfg Martin

lion1981

"Der horrizontale Abstand muß unabhängig vom vertikalen Abstand geprüft werden. Allerdings, wenn der horizontale schon nicht passt, interessiert der vertikale nicht mehr. Du beachtest den vertikalen Abnstand dann und nur dann, wenn der horizontale Abstand nicht passt. Wie wäre es mit so einer Lösung:"

Fast richtig: Der vertikale Abstand soll nur dann überprüft werden, wenn der horizontale Abstand passt.
Am Ende soll sowohl der horizontale als auch der vertikale Abstand überprüft und wenn die Bedingungen erfüllt sind, ausgegeben werden.

return ( Object[0].x < safety_factor
|| (Object[3].x  >= end_coordinate_horizontal - safety_factor  )
|| Object[0].y < safety_factor
|| (Object[3].y  >= end_coordinate_vertikal   - safety_factor) )
    ? 0 : 1
;

Einen ähnlichen Ansatz habe ich ganz am Anfang verwendet aber leider habe ich mir mit den 3 ODER ( ||) Zeichen eine Endlosschleife erzeugt.
Falls es da einen brauchbaren Ansatz (mit Verwendung der 3 ODER Beziehungen wäre ich euch sehr dankbar.

Mit dieser Einfachen if-Anweisung wollte ich mein Problem lösen:

if (   ((Object[0].x < safety_factor)  ||   (Object[3].x ) >= (end_coordinate_horizontal  - safety_factor ))
			|| (( Object[0].y < safety_factor )  ||  ( (Object[1].y)  >= (end_coordinate_vertikal   - safety_factor)) )   ){
		Safety_Factor_OK = 0;
	}

mgaeckler

lion1981 schrieb:

Fast richtig: Der vertikale Abstand soll nur dann überprüft werden, wenn der horizontale Abstand passt.

Genau das habe ich geschrieben.

lion1981 schrieb:

return ( Object[0].x < safety_factor
|| (Object[3].x  >= end_coordinate_horizontal - safety_factor  )
|| Object[0].y < safety_factor
|| (Object[3].y  >= end_coordinate_vertikal   - safety_factor) )
    ? 0 : 1
;
Einen ähnlichen Ansatz habe ich ganz am Anfang verwendet aber leider habe ich mir mit den 3 ODER ( ||) Zeichen eine Endlosschleife erzeugt.

Wenn Du damit eine Endlosschleife produzierst, dann erzeugt halt die Funktion Generate_Nodes_Window immer ein falsches Rechteck. Dann würde ich dort mal schauen, wie sie auf einen Fehler reagiert.

lion1981 schrieb:

Mit dieser Einfachen if-Anweisung wollte ich mein Problem lösen:

if (   ((Object[0].x < safety_factor)  ||   (Object[3].x ) >= (end_coordinate_horizontal  - safety_factor ))
			|| (( Object[0].y < safety_factor )  ||  ( (Object[1].y)  >= (end_coordinate_vertikal   - safety_factor)) )   ){
		Safety_Factor_OK = 0;
	}

Damit löst Du aber offensichtlich nicht Dein eigentliches Problem.

mfg Martin

Brauchst du ein else?

Deine Bedingung ( (Object[0].x < safety_factor) || (Object[3].x >= end_coordinate_horizontal - safety_factor ) wird doch nur wahr, wenn die horizontale Abstand nicht in Ordnung ist.
Und dann wird der if-Zweig ausgeführt. Und darin ist die vertikale Überprüfung.
Und das willst du ja nicht.

lion1981

Vielen Dank an alle, ihr hattet völlig recht!
Mein Programm läuft jetzt ohne Probleme, ein absolut dummer (und von mir nicht entdeckter Fehler) hat mir die letzten zwei Tage gekostet...

Jetzt habe ich mein Problem gelöst und bin glücklich. :p

Vielen Dank an die Helfer und frohes Fest!

lion1981

Oh mein Gott, einen smiley, der euch die Zunge raus steckt wollte ich nicht anfügen!! SORYY, für den blöden smiley.