Mehrere logische Bedingungen testen

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.

mgaeckler

lion1981 schrieb:

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!

Bitte sehr, aber laß uns nicht dumm sterben: Was war nun der Fehler?

mfg Martin

lion1981

Hi,
also mein Fehler war folgender:
Ich nutze meinen Check für die Überprüfung von zwei Arten von Objekten ( einfache Quadrate) sowie ein äußeres Quadrat zur Begrenzung meiner Fläche.

Das äußere Quadrat wird sowohl in der x als auch in der y-Achse automatisch erzeugt, im Anschluss werden die zwei Arten von Quadraten erzeugt.

Das erste Quadrat hat keine Randbedingung (Automatische Erzeugung der x als auch y Koordinate).
Das zweite Quadrat hat die Randbedingung dass nur die x Koordinate automatisch erzeugt wird, die y Koordinate wird gleich 0 gesetzt.

Somit bekam ich ständig eine Endlosschleife, da der Check des zweiten Quadrates nie erfüllt wurde. (y=0 ist immer kleiner als mein Randabstand)

Peinlich, ich weiß. Bitte nicht lachen... (schmunzeln ist allerdings erlaubt)

mgaeckler

lion1981 schrieb:

Peinlich, ich weiß. Bitte nicht lachen... (schmunzeln ist allerdings erlaubt)

Hallo,

das muß Dir nicht peinlich sein, solche Fehler passieren mir auch noch trotz >30 Jahre Entwicklungserfahrung.

Warum es aber so lange gebraucht hat, den Fehler zu finden, sollte Dir bewusst sein:

Du hast auf Teufel komm raus versucht, Deiner Prüfroutine beizubringen, eine 1 zurückzuliefern. Du bist aber nicht auf die Idee gekommen, die Eingangsparameter der Funktion zu überprüfen. Zur Fehleranalyse gehört aber immer zuerst die Eingangsparameter zu verifizieren. Dann hättest Du nämlich festgestellt, daß die Prüfroutine gemäß ihrer Spezifikation korrekt funktioniert hat, woraus gefolgert werden kann, daß entweder die Spek falsch ist oder der Zulieferer einen Fehler hat. Das darf Dir dann aber wirklich peinlich sein, denn das lernt man im ersten Semester.

mfg Martin