[HaBo]

   |
 8 |      +-------------------------+
   |      |                         |
   |      |                         |
   |      |   +-----------------+   |
   |      |   |                 |   |
   |      |   |     +------+    |   |
   |      |   |     |      |    |   |
   |      |   |     +------+    |   |
   |      |   |                 |   |
   |      |   |                 |   |
   |      |   +-----------------+   |
   |      |                         |
   |      |                         |
 2 |      +-------------------------+
   |
   |______2_________________________8_____________

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>

struct koordinaten{

    double x;
    double y;
};
struct eckdaten{
    
    double xmin;
    double xmax;
    double ymin;
    double ymax;
};

const int RECHTECKE = 20;
const int MAXE = 10;

void sort(struct koordinaten *array);
double A (struct eckdaten r);
double flaeche_von_schnittmengen(struct eckdaten *r, int durchlaeufe);
struct eckdaten gib_schnittmenge_von(struct eckdaten r, struct eckdaten s);
    
int main()
{
    struct koordinaten ecke[4];
    struct eckdaten rechteck[RECHTECKE];
    int i, j;
    double flaeche, ergebnis, temp;
    char input[MAXE], c;

    flaeche = 0;    
    for (j = 0; j < MAXE; j++){
        printf ("\nGebe die Eckpunkte des %i.ten Rechtecks ein.\n", j + 1);  
        for (i = 0; i < 4; i++){
            printf ("x-Koordinate von Ecke %i: ", i+1);
            ecke[i].x = atoi (fgets (input, MAXE, stdin));
            printf ("y-Koordinate von Ecke %i: ", i+1);
            ecke[i].y = atoi (fgets (input, MAXE, stdin));    
        }
        sort(ecke);
        rechteck[j].xmax = ecke[0].x;
        rechteck[j].xmin = ecke[3].x;
        rechteck[j].ymax = ecke[0].y;
        rechteck[j].ymin = ecke[3].y;
        flaeche += A (rechteck[j]);
        ergebnis = flaeche;        
        ergebnis -= flaeche_von_schnittmengen(rechteck, j); 
        printf ("Die mit den Rechtecken bedeckte Flaeche betraegt: %f\n", ergebnis);        
        printf("Noch ein Rechteck?\n");
        while (1){
            printf("J fuer Ja oder N fuer Nein: ");
            c = (char)toupper(getchar());
            while (getchar() != '\n');
            if (c == 'J' || c == 'N')
                break;
        }
        if (c == 'N')
            j = MAXE;         
    }
        
    return 0;
}

void sort(struct koordinaten *array){
//soritert varaiblen vom Typ struct koordinaten vor für die Übergabe in Typ struct eckdaten.

    int i, j;
    struct koordinaten temp;
    
    for (i = 0; i < 4; i++){
        for (j = i + 1; j < 4; j++){
            if (array[i].x < array[j].x){
                temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
    }
    if (array[0].y < array[1].y)
        array[0] = array[1];
    if (array[2].y < array[3].y)
        array[3] = array[2];
}        
double A (struct eckdaten r){
// berechnet Flaechninhalt

    double breite, laenge, a;
    
    breite = r.ymax - r.ymin;
    laenge = r.xmax - r.xmin;
    a = breite * laenge;

    return a;    
}
double flaeche_von_schnittmengen(struct eckdaten *r, int durchlaeufe){    
// summiert Schnittmengen und subtrahiert mehrfache Schnittmengen

   	int i, j, k;	
	double a, m;
	struct eckdaten schnitt[MAXE];

	a = 0; m = 0; k = 0;	

	for (i = 0; i < durchlaeufe; i++){
		for (j = i + 1; j <= durchlaeufe; j++){
				schnitt[k] = gib_schnittmenge_von(r[i], r[j]);
				m = A (schnitt[k]);
				if (m == 0){
					schnitt[k] = gib_schnittmenge_von(r[j], r[i]);
					m = A (schnitt[k]);
				}
				if (m != 0)
					k++;
				a += m;
		}
	printf("\n");
		a -=  flaeche_von_schnittmengen(schnitt, (durchlaeufe - 1));
	}
	return a;
}

struct eckdaten gib_schnittmenge_von(struct eckdaten r, struct eckdaten s){
// ermittelt Art der Schnittmenge und gibt entsprechende Eckdaten zurueck
	int a;
	struct eckdaten schnitt; 

	a = 0;
	//Links-Unten drin
	if (r.xmin >= s.xmin && r.xmin < s.xmax){
		if (r.ymin >= s.ymin && r.ymin < s.ymax)
			a += 1;
	}
	//Rechts-Oben drin
	if (r.xmax <= s.xmax && r.xmax > s.xmin){
		if (r.ymax <= s.ymax && r.ymax > s.ymin)
			a += 10;
	}
	//Links-Oben drin
	if (r.xmin >= s.xmin && r.xmin < s.xmax){
		if (r.ymax <= s.ymax && r.ymax > s.ymin)
			a += 100;
	}
	//Rechts-Unten drin
	if (r.xmax <= s.xmax && r.xmax > s.xmin){
		if (r.ymin >= s.ymin && r.ymin < s.ymax)
			a += 1000;
	}  
	// schnitt ohne Ecken drin
	if (r.xmin >= s.xmin && r.xmin < s.xmax){
		if (r.xmax <= s.xmax && r.xmax > s.xmin)
			if (s.ymin >= r.ymin && s.ymin < r.ymax)	
				if (s.ymax <= r.ymax && s.ymax > r.ymin)
			a = 2;
	}
	printf("case %i", a);
	switch (a){
		case 1:
			schnitt.xmin = r.xmin; 
			schnitt.xmax = s.xmax;
			schnitt.ymin = r.ymin;
			schnitt.ymax = s.ymax;
			break;
		case 2:
			schnitt.xmin = r.xmin; 
			schnitt.xmax = r.xmax;
			schnitt.ymin = s.ymin;
			schnitt.ymax = s.ymax;
			break;
		case 10:
			schnitt.xmin = s.xmin; 
			schnitt.xmax = r.xmax;
			schnitt.ymin = s.ymin;
			schnitt.ymax = r.ymax;
			break;
		case 1111:		//11 == 111 == 1011 == 1111
		case 1100:
		case 1101:
			schnitt.xmin = r.xmin; 
			schnitt.xmax = r.xmax;
			schnitt.ymin = r.ymin;
			schnitt.ymax = r.ymax;
			break;
		case 100:
			schnitt.xmin = r.xmin; 
			schnitt.xmax = s.xmax;
			schnitt.ymin = s.ymin;
			schnitt.ymax = r.ymax;
			break;
		case 101:
			schnitt.xmin = r.xmin; 
			schnitt.xmax = s.xmax;
			schnitt.ymin = r.ymin;
			schnitt.ymax = r.ymax;
			break;
		case 110:
			schnitt.xmin = r.xmin; 
			schnitt.xmax = r.xmax;
			schnitt.ymin = s.ymin;
			schnitt.ymax = r.ymax;
			break;
		case 1000:
			schnitt.xmin = s.xmin; 
			schnitt.xmax = r.xmax;
			schnitt.ymin = r.ymin;
			schnitt.ymax = s.ymax;
			break;
		case 1001:
			schnitt.xmin = r.xmin; 
			schnitt.xmax = r.xmax;
			schnitt.ymin = r.ymin;
			schnitt.ymax = s.ymax;
			break;
		case 1010:
			schnitt.xmin = s.xmin; 
			schnitt.xmax = r.xmax;
			schnitt.ymin = r.ymin;
			schnitt.ymax = r.ymax;
			break;
		default:
			schnitt.xmin = 0; 
			schnitt.xmax = 0;
			schnitt.ymin = 0;
			schnitt.ymax = 0;
	}
	return schnitt;
}