#include <assert.h>		
/*i precedenti due sono nuovi: gestione liste*/
#include <termios.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <dirent.h>
#include <string.h>
/*far puntare a dove risiede la libreria G*/
#include </home/freddy3/Desktop/TESI/vis6/AISAiboYCrCbColorSeg.h>
/*inserisce la libreria per fitting della palla*/
#include </home/freddy3/Desktop/TESI/CircleFittingClass/CircleFittingClass.h>

#include <sys/signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdlib.h>
#include <math.h>


FILE *input_file;	/*file di input*/
FILE *matrix;		/*file di output --- matrice che rappresenta l'immagine con i suoi colori*/
FILE *matx;			/*file output --- rappresenta l'immagine trattata*/
FILE *regx;			/*file output --- immagine con regioni*/
FILE *inter;		/*file output --- passo intermedio*/

#define PI 3.14159265
#define alt 160		//la y dell'immagine
#define lar 208		//la x dell'immagine
#define al alt-1	//per partire dal pixel non di bordo dell'immagine = 159
#define la lar-1	//sono le coordinate cui sopra -1 = 207

/*elemento della matrice matr*/
typedef struct punto {
	unsigned int val_col;
	unsigned int regione;
	};

/*struttura per analisi dei pixel*/
typedef struct colore {
	unsigned int tipo;
	unsigned int occorrenza;
	};

/*-----------------------------------------------------------------*/
/*struttura per elementi della coda di memorizzazione delle regioni*/
/*-----------------------------------------------------------------*/

typedef struct per_elem {			//elemento della coda per i pixel del perimetro della regione
	unsigned int coord_x;				//coordinata x
	unsigned int coord_y;				//coordinata y
	struct per_elem* next;				//puntatore al prox elemento della coda 
};

typedef struct per_reg {			//per lista dei pixel del perimetro
	struct per_elem* first;				//puntatore al primo elemento della coda perimetro
	struct per_elem* last;				//puntatore all'ultimmo elemento della coda perimetro
};

typedef struct region {				//Elemento della coda di memorizzazione delle regioni
	unsigned int id;					//identifictivo della regione
	unsigned int color;					//tipo di colore presente
	unsigned int fpixel_coord_x;		//coordinata x del primo pixel
	unsigned int fpixel_coord_y;		//cordinata y del primo pixel
	double	perimeter;					//lungh. del perimetro
	double centroid_x;					//coordinata x del centroide
	double centroid_y;					//coordinata y del centroide
	double circ;						//fattore di circolarità (distingue il cerchio dal quadrato
	unsigned int area;					//area della regione
/*servono per il confronto con la riga dell'orizzonte*/
	unsigned int high_y;				//coordinata y del pixel + alto
	unsigned int low_y;					//coordinata y del pixel + basso
	struct region* next;				//puntatore al prox elemento della coda delle regioni
	int max_y;							//coordinate maggiori e minori dei pixel della regione
	int min_y;
	int max_x;
	int min_x;
	unsigned int green;					//è a 1 se la regione confina con pixel verdi
	unsigned int white;					//è a 1 se la regione confina con pixel bianchi  
	unsigned int height;				//pseudo larghezza della regione
	unsigned int width;					//pseudo altezza della regione
};

typedef struct queue {				//Coda delle regioni
	int cnt;						//contatore del numero di elementi
	struct region* front;			//puntatore al primo elemento
};

/*struttura per la rappresentazione degli aibo*/
typedef struct aibo_reg {			
	region* aibo_mk;				//puntatore alla regione rossa/blu
	struct aibo_reg* next;			//puntatore alla prox regione
};

/*struttura per la rappresentazione delle righe del campo*/
typedef struct white_st {
	region* whst;						//puntatore alla regione bianca
	struct white_st* next;			//puntatore alla prox regione
};

//elenco funzioni del programma - vedere descrizioni più avanti, al codice di ognuna.

//N.B.: notare il passagio per riferimento del puntatore qui ed in analizer
//N.B.: in analizer il puntatore alla palla è solo per valore
//double ori_coord (); per le coord. dei punti dell'orizzonte.

void line_finder (queue obj, white_st*& ws);

double distance (double cy1, double cx1, double cy2, double cx2);

void ball_finder (queue obj, region*& ball);

double minore (double p1, double p2, double p3, double p4);

void marker_door_finder (queue obj, region* ball, region*& m1_pink, region*& m1_color, region*& m2_pink, region*& m2_color, region*& m3_pink, region*& m3_color, region*& m4_pink, region*& m4_color, region*& y_door, region*& b_door);

void aibo_finder (queue obj, aibo_reg*& aibo_r, aibo_reg*& aibo_b);

void perimeter(punto m[][lar], int h, int k, double* dr, double* xc, double* yc, double* per, double* circ, int* green, int* white);

void corr_col (punto m[][lar], punto mat[][lar], int h, int k, colore ne, colore bi, colore ro, colore az, colore gi, colore ros, colore blu, colore ara, colore ver);

void canc_reg (punto m[][lar], int h, int k, unsigned int reg); 

colore maggiore (colore ne, colore bi, colore ro, colore az, colore gi, colore ros, colore blu, colore ara, colore ver);

unsigned int ric_reg (punto m[][lar], int h, int k, unsigned int reg, unsigned int num_reg, int maxY, int* maxX, int* minY, int* minX);


/*-------------------------------------------------------------------------------------------*/
/* --- CODICE -------------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------*/


//MAIN
int main(int Parm_Count, char *Parms[]){

/*qui file x nome immagine da elaborare*/
/*l'immagine è un .raw!!!*/
  	input_file = fopen("1.RAW", "r");
 	if(input_file == NULL) return 0;

/*file di risultato*/
/*individua i colori*/
	matrix = fopen("matrix.txt", "w+");
	if (matrix == NULL) return 0;

/*individua le regioni*/
	matx = fopen("matx.txt", "w+");
	if (matx == NULL) return 0;

/*individua le regioni*/
	regx = fopen("regx.txt", "w+");
	if (regx == NULL) return 0;

/*individua le regioni*/
	inter = fopen("inter.txt", "w+");
	if (inter == NULL) return 0;

/*costruttore*/
 	AISAiboYCrCbColorSeg seg(208,160);	//agisce su un'immagine di XxY Pixel
  	unsigned char* image;				//puntatore all'immagine
  	long lSize;							//dimensione immagine
  	const unsigned int* ptr; 			//puntatore all'immagine segmentata da elaborare
     
/*ottiene la grandezza del file*/
  	fseek (input_file , 0 , SEEK_END);
  	lSize = ftell (input_file);
  	rewind (input_file);

/*alloca la memoria per contenere il file*/
  	image  = (unsigned char*) calloc (1,lSize);
  	if (image == NULL) exit (2);
  
/*copia il file nel buffer*/
  	fread (image,1,lSize,input_file);

/*--- --- --- ------------------------------------------ --- --- --- */
/*--- --- --- Inizializzazione valori Cr e Cb dei Colori --- --- --- */
/*--- --- --- ------------------------------------------ --- --- --- */

/*i valori di cb e cr sono stati ricavati attraverso la loro misurazione
in 3 distinte condizioni di illuminazione nel laboratorio con luce artificiale*/

/*--- l0 --- bianco: colore righe del campo*/
/*nella matrice i punti con valore 1*/
	unsigned char CbMinl0 = 87;
  	unsigned char CrMinl0 = 121;
  	unsigned char CbMaxl0 = 124;
  	unsigned char CrMaxl0 = 145;

  	for(int i=0;i<254;i++){
    	seg.setColor(AISAiboYCrCbColorSeg::l0, i, CrMinl0,CrMaxl0,CbMinl0,CbMaxl0);
 	}

/*--- l1 --- rosa: colore palla */
/*nella matrice i punti con valore 2*/
	unsigned char CbMinl1 = 120;		
	unsigned char CrMinl1 = 151;	
	unsigned char CbMaxl1 = 250;		
	unsigned char CrMaxl1 = 250;	

	for(int i=0;i<254;i++){
		seg.setColor(AISAiboYCrCbColorSeg::l1, i, CrMinl1,CrMaxl1,CbMinl1,CbMaxl1);
	}

/*--- l2 --- azzurro: colore porta e marcatori n°2*/
/*nella matrice i punti con valore 4*/
	unsigned char CbMinl2 = 138;
  	unsigned char CrMinl2 = 1;
  	unsigned char CbMaxl2 = 250;
  	unsigned char CrMaxl2 = 114;

  	for(int i=0;i<254;i++){
    	seg.setColor(AISAiboYCrCbColorSeg::l2, i, CrMinl2,CrMaxl2,CbMinl2,CbMaxl2);
  	}

/*-- l3 --- giallo: colore marker e porta*/
/*nella matrice i punti con valore 8*/
    unsigned char CbMinl3 = 1;
  	unsigned char CrMinl3 = 110;
  	unsigned char CbMaxl3 = 85;
  	unsigned char CrMaxl3 = 164;

  	for(int i=0;i<254;i++){
    		seg.setColor(AISAiboYCrCbColorSeg::l3, i, CrMinl3,CrMaxl3,CbMinl3,CbMaxl3);
  	}

/*--- l4 --- rosso: colore tute aibo*/
/*nella matrice i punti con valore 16*/
    unsigned char CbMinl4 = 88;
  	unsigned char CrMinl4 = 150;
  	unsigned char CbMaxl4 = 118;
  	unsigned char CrMaxl4 = 250;

  	for(int i=0;i<254;i++){
    		seg.setColor(AISAiboYCrCbColorSeg::l4, i, CrMinl4,CrMaxl4,CbMinl4,CbMaxl4);
  	}

/*--- l5 --- blu: colore tute aibo*/
/* nella matrice i punti di valore 32*/
	unsigned char CbMinl5 = 138;
  	unsigned char CrMinl5 = 115;
  	unsigned char CbMaxl5 = 250;
  	unsigned char CrMaxl5 = 130;

  	for(int i=0;i<254;i++){
    		seg.setColor(AISAiboYCrCbColorSeg::l5, i, CrMinl5,CrMaxl5,CbMinl5,CbMaxl5);
  	}

/*--- l6 --- arancione : colore della palla nella robocup*/
/* nella matrice i punti di valore 64*/
	unsigned char CbMinl6 = 1;
  	unsigned char CrMinl6 = 165;
  	unsigned char CbMaxl6 = 85;
  	unsigned char CrMaxl6 = 250;

  	for(int i=0;i<254;i++){
    		seg.setColor(AISAiboYCrCbColorSeg::l6, i, CrMinl6,CrMaxl6,CbMinl6,CbMaxl6);
  	}

/*--- l7 --- verde : colore del campo nella robocup*/
/* nella matrice i punti di valore 128*/
	unsigned char CbMinl7 = 87;
  	unsigned char CrMinl7 = 85;
  	unsigned char CbMaxl7 = 135;
  	unsigned char CrMaxl7 = 115;

  	for(int i=0;i<254;i++){
    		seg.setColor(AISAiboYCrCbColorSeg::l7, i, CrMinl7,CrMaxl7,CbMinl7,CbMaxl7);
  	}

  	ptr = seg.processImage(image);

//MODIFICARE USANDO I PUNTATORI//

/*N.B.: le matrici sono Y x X, quindi la coordinata di un punto è da intendersi matr[y][x]*/

 	punto matr[alt][lar];	/*array di variabili tipo "punto" che conterrà l'immagine segmentata e successivamente 
							le immagini intermedie durante l'elaborazione*/
	punto mat[alt][lar];

	int z = 0;				/*variabile ausiliaria per la copia dell'immagine su matrice statica (alt X lar)*/

/*--- --- --- stringa necessaria per visualizzazione con octave che nel prog. cancellerò  --- ---*/

	fprintf(matrix,"# Created by Octave 2.1.72, Mon Oct 16 15:50:58 2006 CEST\n# name: mat\n# type: matrix\n# rows: %d\n# columns: %d\n", 160, 208);

	fprintf(matx,"# Created by Octave 2.1.72, Mon Oct 16 15:50:58 2006 CEST\n# name: matx\n# type: matrix\n# rows: %d\n# columns: %d\n", 160, 208);

	fprintf(regx,"# Created by Octave 2.1.72, Mon Oct 16 15:50:58 2006 CEST\n# name: regx\n# type: matrix\n# rows: %d\n# columns: %d\n", 160, 208);

	fprintf(inter,"# Created by Octave 2.1.72, Mon Oct 16 15:50:58 2006 CEST\n# name: int\n# type: matrix\n# rows: %d\n# columns: %d\n", 160, 208);

/*--------------------------------------------------------------------------------------------------------------*/
/*1° for: la memorizzazione nell'array matrice del risultato della segmentazione con controllo in file di output*/
/*--------------------------------------------------------------------------------------------------------------*/

	printf("creazione della matrice matr dalla segmentazione\n");
	for (int r=0; r<alt; r++){
		for (int c=0; c<lar; c++){

	/*copia valori ottenuti dalla segmentazione nella matrice che reppresenta l'immagine*/
	/*il bordo marcato come pixel neri, anche in presenza di colore, onde eviatere il crash*/

			if(r == al || c == la || r == 0 || c == 0){
				matr[r][c].val_col = 0; //metti 0 per evitare che cercando la successiva parte del bordo esca dall'array
				matr[r][c].regione = 0;	//regione ancora incognita, cioe' == 0
      		}
			else {
				matr[r][c].val_col = *(ptr+z);
/*da eliminare: solo per test sul bianco: ci sono valori troppo alti e non si vede su octave -------- */
		/*		if (matr[r][c].val_col == 128){
					matr[r][c].val_col = 5;
				}*/
/*--------------------------------------------------------------------*/

				matr[r][c].regione = 0;							//regione ancora incognita, cioè == 0
			}
			z++;
		}
	}

/*ciclo stampa su file risultato della segmentazione*/
	for (int m=0; m<alt; m++){
		fprintf(matrix, "\n");
		for (int n=0; n<lar; n++){
			fprintf(matrix, "%u ", matr[m][n].val_col);
		}
	}
/*---------------------------------------------------------------------------------------------*/	
/*2° pulizia dell'immagine attenuta dalla segmentazione con elemento strutturale a stella amp.5*/
/*---------------------------------------------------------------------------------------------*/

	printf("inizio elaborazione dell'immagine\n");
	
	colore ne, bi, ro, az, gi, ros, blu, ara, ver, max;		//variabili per il calcolo delle occorrenze dei colori

/*inizializzazione variabili riconoscimento colori*/	
	max.tipo = 0;				//il valore di colore che assegnerò ai pixel delle regioni troppo piccole
	ne.tipo = 0;
	bi.tipo = 1;
	ro.tipo = 2;
	az.tipo = 4;
	gi.tipo = 8;
	ros.tipo = 16;
	blu.tipo = 32;
	ara.tipo = 64;
	ver.tipo = 128;
	
/*ciclo per la pulizia dell'immagine: applico un elemento strutturale a stella per eliminare 
tutto quello che c'è in eccesso*/

	for (int h=1; h<al; h++){
		for (int k=1; k<la; k++){
		//inizializzazione variabili locali
			ne.occorrenza = 0;
			bi.occorrenza = 0;
			ro.occorrenza = 0;
			az.occorrenza = 0;
			gi.occorrenza = 0;
			ros.occorrenza = 0;
			blu.occorrenza = 0;
			ara.occorrenza = 0;
			ver.occorrenza = 0;

/*eliminazione pixel isolati*/
/*controllo degli 8_vicini di un pixel: assegno al pixel il valore di colore più presente nell'elemento
 strutturale a "stella"*/
			
			corr_col (matr, mat, h, k, ne, bi, ro, az, gi, ros, blu, ara, ver);
		}
	}

/*ciclo per la stampa del risultato intermedio della ripulitura*/
for (int ui=0; ui<alt; ui++){
		fprintf(inter, "\n");
		for (int oi=0; oi<lar; oi++){
			fprintf(inter, "%u ", mat[ui][oi].val_col);
		}
	}

/*--------------------------------------------------------------------*/
/*3° - operazione di region growing e memorizzazione in lista dinamica*/
/*--------------------------------------------------------------------*/
	
	unsigned int reg = 1;				//identificatore delle regioni
	unsigned int num_reg = 0;			//misura la numerosità della regione in numero di pixel, in praica
										//l'area.
	double xcentroid;					//variabili per il calcolo del centroide
	double ycentroid;					
	double per;						//var per calcolo del perimetro
	double diam;					//var per il calcolo del diametro
	double circolarity;				//var per il calcolo della circolarità
	int green, white;				//per tenere traccia delleregioni confinanti
	int maxY, maxX, minY, minX;		//per ogni regione, i valori delle coordinate x e y maggiori e minori
	/*-------------------N.B.: ricordarsi che y maggiore è + in basso nell'immagine!!!-----------------*/

/*creazione e inizializzazione della coda per le regioni trovate*/
	
	queue obj;						//nome della coda delle regioni/oggetti da riconoscere
	obj.cnt = 0;					//contatore del numero di regioni
	obj.front = NULL;				//puntatore all'inizio della regione
	
	region* pn = NULL;				//puntatore ausiliario per creazione elemento per lista regioni

	region* ball = NULL;			//puntatore alla regione identificata come palla

/*puntatori ai dati dei marker*/
	region* m1_pink = NULL;					
	region* m1_color = NULL;
	region* m2_pink = NULL;					
	region* m2_color = NULL;
	region* m3_pink = NULL;					
	region* m3_color = NULL;
	region* m4_pink = NULL;					
	region* m4_color = NULL;

/*puntatori relativi agli altri Aibo*/
	aibo_reg* aibo_r = NULL;
	aibo_reg* aibo_b = NULL;
	
/*puntatori alle porte*/
	region* y_door = NULL;			
	region* b_door = NULL;		

/*puntatore alle righe*/
	white_st* ws = NULL;	

/*puntatori alle righe del campo*/
/*vedere come fare qui, per le righe*/

	/*ciclo per l'assegnazione del valore regione*/
	//printf("ciclo for per correzione immagine, calcolo regioni e analisi delle stesse\n");
	for (int p=1; p<al; p++){
		for (int l=1; l<la; l++){

		//inizializzazione delle variabili x occorrenza colori, coordinate centroide, diametro
		//e coordinate max e minime.
			max.occorrenza = 0;
			ne.occorrenza = 0;
			bi.occorrenza = 0;
			ro.occorrenza = 0;
			az.occorrenza = 0;
			gi.occorrenza = 0;
			ros.occorrenza = 0;
			blu.occorrenza = 0;
			ara.occorrenza = 0;
			ver.occorrenza = 0;

			xcentroid = 0;
			ycentroid = 0;
			
			green = 0;
			white = 0;
			diam = 0;
		
			maxY = p;
			maxX = 0;
			minY = 0;
			minX = 0;

/*la procedura ric_reg entra in funzione solo sul pixel il cui colore è riconosciuto (non nero) e la cui regione non è
ancora stata assegnata: ric_reg è una procedura ricorsiva quindi marcherà tutti i pixel colorati contigui 
partendo dal primo che incontra durante la scansione dell'immagine: viene utilizzata la 8 vicinanaza*/

/*mat è la matrice che mi ritorna come risultato la procedura corr_col di eliminazione del rumore preliminare*/
			if ((mat[p][l].val_col != 0)&&(mat[p][l].regione == 0)){
				//printf("cerco regione nella mia immagine a partire da pixel colorati\n");
				num_reg = ric_reg(mat, p, l, reg, 0, maxY, &maxX, &minY, &minX);
				
				if (num_reg <= 35){   //settare il valore, ma dovrebbe essere ok...
					canc_reg (mat, p, l, reg); 	
				}
				else {
					pn = (region*) malloc(sizeof(region));
		/*pn è il puntatore ad un oggetto di tipo region grazie al cast*/
					pn->id = reg;						
					pn->color = mat[p][l].val_col;		
					pn->fpixel_coord_x = l;				//coord pixcel iniziale 
					pn->fpixel_coord_y = p;
				//	printf("%u, %u ", p->fpixel_coord_x, p->fpixel_coord_y);
					pn->area = num_reg;					//area della regione	
					pn->max_y = p;
					pn->max_x = maxX;
					pn->min_y = minY;
					pn->min_x = minX;			
		//inserimento dell'elemento nella lista delle regioni		
					pn->next = obj.front;
					obj.front = pn;
		//aggiorno il valore progressivo di regione e il contatore di queste ultime nella coda.
					reg++;
					obj.cnt++;

				}
/*se la regione trovata è di colore rosa, azzurro, giallo e arancione allora cerco il centroide e tutto il resto*/
				if ((mat[p][l].val_col ==2)||(mat[p][l].val_col == 4)||(mat[p][l].val_col == 8)||(mat[p][l].val_col == 16)||(mat[p][l].val_col == 32)||(mat[p][l].val_col == 64)){

					perimeter(mat, p, l, &diam, &xcentroid, &ycentroid, &per, &circolarity, &green, &white);
					
					pn->centroid_x = xcentroid;
					pn->centroid_y = ycentroid;
					pn->circ = circolarity;
					pn->perimeter = per;
					pn->green = green;
					pn->white = white;		
					pn->height = maxX-minX;
					pn->width = minY-maxY;


				//	printf ("regione n° %d , primo pixel x = %d, y = %d di colore %d, centroide x= %f y= %f\n, perimetro %f, area %d, circolarità %f\n", pn->id, pn->fpixel_coord_x, pn->fpixel_coord_y, pn->color, pn->centroid_x, pn->centroid_y, pn->perimeter, pn->area, pn->circ);

//verifica la posizione del centroide sull'immagine "stampando" sull'immagine un pixel di color diverso da tutti
					mat[(int)ycentroid][(int)xcentroid].val_col = 200;
				}
			}		
		}//end for
	}//end for

/*ciclo per la stampa su file: ultimo passaggio perchè così posso annotare i cambiamenti*/
/*va eliminato nel "prodotto finale"*/	
	printf("cicli per la stampa a file\n");
	printf("\n");

	for (int q=0; q<alt; q++){
		fprintf(matx, "\n");
		fprintf(regx, "\n");
		for (int w=0; w<lar; w++){
			fprintf(matx, "%u ", mat[q][w].val_col);
			fprintf(regx, "%u ", mat[q][w].regione);		
		}
	}


	fclose (input_file);
	fclose (matrix);
	fclose (matx);
	fclose (regx);
	free (image);
	
	ball_finder (obj, ball);
	

	marker_door_finder (obj, ball, m1_pink, m1_color, m2_pink, m2_color, m3_pink, m3_color, m4_pink, m4_color, y_door, b_door);

	aibo_finder (obj, aibo_r, aibo_b);
		
	line_finder (obj, ws);

	region* r;
	aibo_reg* ars;
	aibo_reg* abs;
	white_st* wts;
	ars = NULL;
	abs = NULL;
	wts = NULL;

	r = obj.front;
	
	//ciclo per la stampa finale a video
	printf("RISULTATI FINALI: \n");
	printf("\n");
	
	while (r!=NULL){
		printf ("regione n° %d , primo pixel x = %d, y = %d di colore %d, maxY: %d, maxX: %d, minY: %d, minX: %d  maxcentroide x= %f y= %f\n, perimetro = %f, area = %d, circolarità = %f, larghezza = %d, altezza = %d, green = %d, white = %d\n", r->id, r->fpixel_coord_x, r->fpixel_coord_y, r->color, r->max_y, r->max_x, r->min_y, r->min_x, r->centroid_x, r->centroid_y, r->perimeter, r->area, r->circ, r->height, r->width, r->green, r->white);
		printf("\n");
		printf("\n");
		r = r->next;
	}
	
	printf("Analisi regioni: \n");
	printf("\n");
	printf("La palla:"); 
	if (ball != NULL){
		printf("x=%f, y=%f\n", ball->centroid_x, ball->centroid_y);
		printf("perimetro = %f, area = %u, circolarità = %f\n", ball->perimeter, ball->area, ball->circ);
		printf("\n");
	}
	else {
		printf("Non Presente\n");
		printf("\n");
	}
	
	printf("Marker n°1 regione rosa:\n");
	if (m1_pink != NULL){
		printf("x=%f, y=%f\n", m1_pink->centroid_x, m1_pink->centroid_y);
		printf("perimetro = %f, area = %u, circolarità = %f\n", m1_pink->perimeter, m1_pink->area, m1_pink->circ);
		printf("\n");
	}
	else{
		printf("Non Presente\n");
		printf("\n");
	}

	printf("Marker n°1 regione colore:\n");
	if (m1_color != NULL){
		printf("x=%f, y=%f, colore = %d\n", m1_color->centroid_x, m1_color->centroid_y, m1_color->color);
		printf("perimetro = %f, area = %u, circolarità = %f\n", m1_color->perimeter, m1_color->area, m1_color->circ);
		printf("\n");
	}
	else{
		printf("Non Presente\n");
		printf("\n");
	}
		
	printf("Marker n°2 regione rosa:\n");
	if (m2_pink != NULL){
		printf("x=%f, y=%f\n", m2_pink->centroid_x, m2_pink->centroid_y);
		printf("perimetro = %f, area = %u, circolarità = %f\n", m2_pink->perimeter, m2_pink->area, m2_pink->circ);
		printf("\n");
  	}
	else{
		printf("Non Presente\n");
		printf("\n");
	}

	printf("Marker n°2 regione colore:\n");
	if (m2_color != NULL){
		printf("x=%f, y=%f, colore = %d\n", m2_color->centroid_x, m2_color->centroid_y, m2_color->color);
		printf("perimetro = %f, area = %u, circolarità = %f\n", m2_color->perimeter, m2_color->area, m2_color->circ);
		printf("\n");
	}
	else{
		printf("Non Presente\n");
		printf("\n");
	}

	printf("Marker n°3 regione rosa:\n");
	if (m3_pink != NULL){
		printf("x=%f, y=%f\n", m3_pink->centroid_x, m3_pink->centroid_y);
		printf("perimetro = %f, area = %u, circolarità = %f\n", m3_pink->perimeter, m3_pink->area, m3_pink->circ);
		printf("\n");
	}
	else{
		printf("Non Presente\n");
		printf("\n");
	}
	
	printf("Marker n°3 regione colore:\n");
	if (m3_color != NULL){
		printf("x=%f, y=%f, colore = %d\n", m3_color->centroid_x, m3_color->centroid_y, m3_color->color);
		printf("perimetro = %f, area = %u, circolarità = %f\n", m3_color->perimeter, m3_color->area, m3_color->circ);
		printf("\n");
	}
	else{
		printf("Non Presente\n");
		printf("\n");
	}
	
	printf("Marker n°4 regione rosa:\n");
	if (m4_pink != NULL){
		printf("x=%f, y=%f\n", m4_pink->centroid_x, m4_pink->centroid_y);
		printf("perimetro = %f, area = %u, circolarità = %f\n", m4_pink->perimeter, m4_pink->area, m4_pink->circ);
		printf("\n");
	}
	else{
		printf("Non Presente\n");
		printf("\n");
	}
	
	printf("Marker n°4 regione colore:\n");
	if (m4_color != NULL){
		printf("x=%f, y=%f, colore = %d\n", m4_color->centroid_x, m4_color->centroid_y, m4_color->color);
		printf("perimetro = %f, area = %u, circolarità = %f\n", m4_color->perimeter, m4_color->area, m4_color->circ);
		printf("\n");
	}
	else{
		printf("Non Presente\n");
		printf("\n");
	}

	printf("Porta Gialla:\n");
	if (y_door != NULL){
		printf("x=%f, y=%f, colore = %d\n", y_door->centroid_x, y_door->centroid_y, y_door->color);
		printf("perimetro = %f, area = %u, circolarità = %f\n", y_door->perimeter, y_door->area, y_door->circ);
		printf("\n");
	}
	else{
		printf("Non Presente\n");
		printf("\n");
	}

	printf("Porta Azzurra:\n");
	if (b_door != NULL){
		printf("x=%f, y=%f, colore = %d\n", b_door->centroid_x, b_door->centroid_y, b_door->color);
		printf("perimetro = %f, area = %u, circolarità = %f\n", b_door->perimeter, b_door->area, b_door->circ);
		printf("\n");
	}
	else{
		printf("Non Presente\n");
		printf("\n");
	}

	printf("Aibo Rossi:\n");
	if (aibo_r != NULL){
		ars = aibo_r;
		while (ars != NULL){
			printf("x=%f, y=%f, colore = %d\n", ars->aibo_mk->centroid_x, ars->aibo_mk->centroid_y, ars->aibo_mk->color);
			printf("perimetro = %f, area = %u, circolarità = %f\n", ars->aibo_mk->perimeter, ars->aibo_mk->area, ars->aibo_mk->circ);
			printf("\n");
			ars = ars->next;
		}
	}
	else{
		printf("Non Presente\n");
		printf("\n");
	}
	
	printf("Aibo Blu:\n");
	if (aibo_b != NULL){
		abs = aibo_b;
		while (abs != NULL){
			printf("x=%f, y=%f, colore = %d\n", abs->aibo_mk->centroid_x, abs->aibo_mk->centroid_y, abs->aibo_mk->color);
			printf("perimetro = %f, area = %u, circolarità = %f\n", abs->aibo_mk->perimeter, abs->aibo_mk->area, abs->aibo_mk->circ);
			printf("\n");
			abs = abs->next;
		}
	}
	else{
		printf("Non Presente\n");
		printf("\n");
	}

	printf("Linee Bianche:\n");
	if (ws != NULL){
		wts = ws;
		while (wts != NULL){
			printf("colore = %d\n", wts->whst->color);
			printf("area = %u",wts->whst->area);
			printf("\n");
			wts = wts->next;
		}
	}
	else{
		printf("Non Presente\n");
		printf("\n");
	}

	printf("+++ Fine elaborazione +++\n");
	
  	return 0; //introdurre la restituzione in uscita dei dati raccolti una volta messo su Aibo.
  
}//end main


/*procedura che elimina i pixel singoli: sia quelli contornati da nero che quelli contornati da colore*/
/*calcola tra gli 8 vicini il colore predominante e lo assegna al pixel*/
void corr_col (punto m[][lar], punto mat[][lar], int h, int k, colore ne, colore bi, colore ro, colore az, colore gi, colore ros, colore blu, colore ara, colore ver){
/*applico un elemento strutturale a stella di ampiezza 5*/
	colore max4; 
	colore maxX;								//conterranno il max per il colore a seconda dei due el. strutt.

	max4.tipo = 0;
	maxX.tipo = 0;
	max4.occorrenza = 0;
	maxX.occorrenza = 0;

/*pixel sopra*/
	switch (m[h+1][k].val_col){
		case(0):
			ne.occorrenza = ne.occorrenza +1;
		break;
		case(1):
			bi.occorrenza = bi.occorrenza +1;
		break;
		case(2):
			ro.occorrenza = ro.occorrenza +1;
		break;
		case(4):
			az.occorrenza = az.occorrenza +1;
		break;
		case(8):
			gi.occorrenza = gi.occorrenza +1;
		break;
		case(16):
			ros.occorrenza = ros.occorrenza +1;
		break;
		case (32):
			blu.occorrenza = blu.occorrenza + 1;
		break;
		case (64):
			ara.occorrenza = ara.occorrenza +1;
		break;
		case (128):
			ver.occorrenza = ver.occorrenza +1;
		break;
	}
/*pixel sopra +1*/
	switch (m[h+2][k].val_col){
		case(0):
			ne.occorrenza = ne.occorrenza +1;
		break;
		case(1):
			bi.occorrenza = bi.occorrenza +1;
		break;
		case(2):
			ro.occorrenza = ro.occorrenza +1;
		break;
		case(4):
			az.occorrenza = az.occorrenza +1;
		break;
		case(8):
			gi.occorrenza = gi.occorrenza +1;
		break;
		case(16):
			ros.occorrenza = ros.occorrenza +1;
		break;
		case (32):
			blu.occorrenza = blu.occorrenza + 1;
		break;
		case (64):
			ara.occorrenza = ara.occorrenza +1;
		break;
		case (128):
			ver.occorrenza = ver.occorrenza +1;
		break;
	}
/*pixel laterali*/
/*sx*/
	switch (m[h][k-1].val_col){
		case(0):
			ne.occorrenza = ne.occorrenza +1;
		break;
		case(1):
			bi.occorrenza = bi.occorrenza +1;
		break;
		case(2):
			ro.occorrenza = ro.occorrenza +1;
		break;
		case(4):
			az.occorrenza = az.occorrenza +1;
		break;
		case(8):
			gi.occorrenza = gi.occorrenza +1;
		break;
		case(16):
			ros.occorrenza = ros.occorrenza +1;
		break;
		case (32):
			blu.occorrenza = blu.occorrenza + 1;
		break;
		case (64):
			ara.occorrenza = ara.occorrenza +1;
		break;
		case (128):
			ver.occorrenza = ver.occorrenza +1;
		break;
	}
/*sx +1*/
	switch (m[h][k-2].val_col){
		case(0):
			ne.occorrenza = ne.occorrenza +1;
		break;
		case(1):
			bi.occorrenza = bi.occorrenza +1;
		break;
		case(2):
			ro.occorrenza = ro.occorrenza +1;
		break;
		case(4):
			az.occorrenza = az.occorrenza +1;
		break;
		case(8):
			gi.occorrenza = gi.occorrenza +1;
		break;
		case(16):
			ros.occorrenza = ros.occorrenza +1;
		break;
		case (32):
			blu.occorrenza = blu.occorrenza + 1;
		break;
		case (64):
			ara.occorrenza = ara.occorrenza +1;
		break;
		case (128):
			ver.occorrenza = ver.occorrenza +1;
		break;
	}
/*dx*/
	switch (m[h][k+1].val_col){
		case(0):
			ne.occorrenza = ne.occorrenza +1;
		break;
		case(1):
			bi.occorrenza = bi.occorrenza +1;
		break;
		case(2):
			ro.occorrenza = ro.occorrenza +1;
		break;
		case(4):
			az.occorrenza = az.occorrenza +1;
		break;
		case(8):
			gi.occorrenza = gi.occorrenza +1;
		break;
		case(16):
			ros.occorrenza = ros.occorrenza +1;
		break;
		case (32):
			blu.occorrenza = blu.occorrenza + 1;
		break;
		case (64):
			ara.occorrenza = ara.occorrenza +1;
		break;
		case (128):
			ver.occorrenza = ver.occorrenza +1;
		break;
	}
/*dx +1*/
	switch (m[h][k+2].val_col){
		case(0):
			ne.occorrenza = ne.occorrenza +1;
		break;
		case(1):
			bi.occorrenza = bi.occorrenza +1;
		break;
		case(2):
			ro.occorrenza = ro.occorrenza +1;
		break;
		case(4):
			az.occorrenza = az.occorrenza +1;
		break;
		case(8):
			gi.occorrenza = gi.occorrenza +1;
		break;
		case(16):
			ros.occorrenza = ros.occorrenza +1;
		break;
		case (32):
			blu.occorrenza = blu.occorrenza + 1;
		break;
		case (64):
			ara.occorrenza = ara.occorrenza +1;
		break;
		case (128):
			ver.occorrenza = ver.occorrenza +1;
		break;
	}
/*pixel sotto*/
	switch (m[h+1][k].val_col){
		case(0):
			ne.occorrenza = ne.occorrenza +1;
		break;
		case(1):
			bi.occorrenza = bi.occorrenza +1;
		break;
		case(2):
			ro.occorrenza = ro.occorrenza +1;
		break;
		case(4):
			az.occorrenza = az.occorrenza +1;
		break;
		case(8):
			gi.occorrenza = gi.occorrenza +1;
		break;
		case(16):
			ros.occorrenza = ros.occorrenza +1;
		break;
		case (32):
			blu.occorrenza = blu.occorrenza + 1;
		break;
		case (64):
			ara.occorrenza = ara.occorrenza +1;
		break;
		case (128):
			ver.occorrenza = ver.occorrenza +1;
		break;
	}
/*pixel sotto +1*/
	switch (m[h+2][k].val_col){
		case(0):
			ne.occorrenza = ne.occorrenza +1;
		break;
		case(1):
			bi.occorrenza = bi.occorrenza +1;
		break;
		case(2):
			ro.occorrenza = ro.occorrenza +1;
		break;
		case(4):
			az.occorrenza = az.occorrenza +1;
		break;
		case(8):
			gi.occorrenza = gi.occorrenza +1;
		break;
		case(16):
			ros.occorrenza = ros.occorrenza +1;
		break;
		case (32):
			blu.occorrenza = blu.occorrenza + 1;
		break;
		case (64):
			ara.occorrenza = ara.occorrenza +1;
		break;
		case (128):
			ver.occorrenza = ver.occorrenza +1;
		break;
	}
/*pixel centrale --- sei sicuro di volerlo tenere???*/  
/*	switch (m[h][k].val_col){
		case(0):
			ne.occorrenza = ne.occorrenza +1;
		break;
		case(1):
			bi.occorrenza = bi.occorrenza +1;
		break;
		case(2):
			ro.occorrenza = ro.occorrenza +1;
		break;
		case(4):
			az.occorrenza = az.occorrenza +1;
		break;
		case(8):
			gi.occorrenza = gi.occorrenza +1;
		break;
		case(16):
			ros.occorrenza = ros.occorrenza +1;
		break;
		case (32):
			blu.occorrenza = blu.occorrenza + 1;
		break;
		case (64):
			ara.occorrenza = ara.occorrenza +1;
		break;
	}*/

/*pixel diagonali*/
/*alto sx*/
	switch (m[h-1][k-1].val_col){
		case(0):
			ne.occorrenza = ne.occorrenza +1;
		break;
		case(1):
			bi.occorrenza = bi.occorrenza +1;
		break;
		case(2):
			ro.occorrenza = ro.occorrenza +1;
		break;
		case(4):
			az.occorrenza = az.occorrenza +1;
		break;
		case(8):
			gi.occorrenza = gi.occorrenza +1;
		break;
		case(16):
			ros.occorrenza = ros.occorrenza +1;
		break;
		case (32):
			blu.occorrenza = blu.occorrenza + 1;
		break;
		case (64):
			ara.occorrenza = ara.occorrenza +1;
		break;
		case (128):
			ver.occorrenza = ver.occorrenza +1;
		break;
	}

/*alto sx sx*/
	switch (m[h-2][k-2].val_col){
		case(0):
			ne.occorrenza = ne.occorrenza +1;
		break;
		case(1):
			bi.occorrenza = bi.occorrenza +1;
		break;
		case(2):
			ro.occorrenza = ro.occorrenza +1;
		break;
		case(4):
			az.occorrenza = az.occorrenza +1;
		break;
		case(8):
			gi.occorrenza = gi.occorrenza +1;
		break;
		case(16):
			ros.occorrenza = ros.occorrenza +1;
		break;
		case (32):
			blu.occorrenza = blu.occorrenza + 1;
		break;
		case (64):
			ara.occorrenza = ara.occorrenza +1;
		break;
		case (128):
			ver.occorrenza = ver.occorrenza +1;
		break;
	}

/*alto dx*/
	switch (m[h-1][k+1].val_col){
		case(0):
			ne.occorrenza = ne.occorrenza +1;
		break;
		case(1):
			bi.occorrenza = bi.occorrenza +1;
		break;
		case(2):
			ro.occorrenza = ro.occorrenza +1;
		break;
		case(4):
			az.occorrenza = az.occorrenza +1;
		break;
		case(8):
			gi.occorrenza = gi.occorrenza +1;
		break;
		case(16):
			ros.occorrenza = ros.occorrenza +1;
		break;
		case (32):
			blu.occorrenza = blu.occorrenza + 1;
		break;
		case (64):
			ara.occorrenza = ara.occorrenza +1;
		break;
		case (128):
			ver.occorrenza = ver.occorrenza +1;
		break;
	}

/*alto dx dx*/
	switch (m[h-2][k+2].val_col){
		case(0):
			ne.occorrenza = ne.occorrenza +1;
		break;
		case(1):
			bi.occorrenza = bi.occorrenza +1;
		break;
		case(2):
			ro.occorrenza = ro.occorrenza +1;
		break;
		case(4):
			az.occorrenza = az.occorrenza +1;
		break;
		case(8):
			gi.occorrenza = gi.occorrenza +1;
		break;
		case(16):
			ros.occorrenza = ros.occorrenza +1;
		break;
		case (32):
			blu.occorrenza = blu.occorrenza + 1;
		break;
		case (64):
			ara.occorrenza = ara.occorrenza +1;
		break;
		case (128):
			ver.occorrenza = ver.occorrenza +1;
		break;
	}

/*basso sx*/
	switch (m[h+1][k-1].val_col){
		case(0):
			ne.occorrenza = ne.occorrenza +1;
		break;
		case(1):
			bi.occorrenza = bi.occorrenza +1;
		break;
		case(2):
			ro.occorrenza = ro.occorrenza +1;
		break;
		case(4):
			az.occorrenza = az.occorrenza +1;
		break;
		case(8):
			gi.occorrenza = gi.occorrenza +1;
		break;
		case(16):
			ros.occorrenza = ros.occorrenza +1;
		break;
		case (32):
			blu.occorrenza = blu.occorrenza + 1;
		break;
		case (64):
			ara.occorrenza = ara.occorrenza +1;
		break;
		case (128):
			ver.occorrenza = ver.occorrenza +1;
		break;
	}

/*basso sx sx*/
	switch (m[h+2][k-2].val_col){
		case(0):
			ne.occorrenza = ne.occorrenza +1;
		break;
		case(1):
			bi.occorrenza = bi.occorrenza +1;
		break;
		case(2):
			ro.occorrenza = ro.occorrenza +1;
		break;
		case(4):
			az.occorrenza = az.occorrenza +1;
		break;
		case(8):
			gi.occorrenza = gi.occorrenza +1;
		break;
		case(16):
			ros.occorrenza = ros.occorrenza +1;
		break;
		case (32):
			blu.occorrenza = blu.occorrenza + 1;
		break;
		case (64):
			ara.occorrenza = ara.occorrenza +1;
		break;
		case (128):
			ver.occorrenza = ver.occorrenza +1;
		break;
	}

/*basso dx*/
	switch (m[h+1][k+1].val_col){
		case(0):
			ne.occorrenza = ne.occorrenza +1;
		break;
		case(1):
			bi.occorrenza = bi.occorrenza +1;
		break;
		case(2):
			ro.occorrenza = ro.occorrenza +1;
		break;
		case(4):
			az.occorrenza = az.occorrenza +1;
		break;
		case(8):
			gi.occorrenza = gi.occorrenza +1;
		break;
		case(16):
			ros.occorrenza = ros.occorrenza +1;
		break;
		case (32):
			blu.occorrenza = blu.occorrenza + 1;
		break;
		case (64):
			ara.occorrenza = ara.occorrenza +1;
		break;
		case (128):
			ver.occorrenza = ver.occorrenza +1;
		break;
	}

/*basso dx dx*/
	switch (m[h+2][k+2].val_col){
		case(0):
			ne.occorrenza = ne.occorrenza +1;
		break;
		case(1):
			bi.occorrenza = bi.occorrenza +1;
		break;
		case(2):
			ro.occorrenza = ro.occorrenza +1;
		break;
		case(4):
			az.occorrenza = az.occorrenza +1;
		break;
		case(8):
			gi.occorrenza = gi.occorrenza +1;
		break;
		case(16):
			ros.occorrenza = ros.occorrenza +1;
		break;
		case (32):
			blu.occorrenza = blu.occorrenza + 1;
		break;
		case (64):
			ara.occorrenza = ara.occorrenza +1;
		break;
		case (128):
			ver.occorrenza = ver.occorrenza +1;
		break;
	}


	max4 = maggiore (ne, bi, ro, az, gi, ros, blu, ara, ver);
	mat[h][k].val_col = max4.tipo;

}//end corr_col

/*calcola il maggiore tra 9 valori di tipo colore e lo restituisce */
colore maggiore (colore ne, colore bi, colore ro, colore az, colore gi, colore ros, colore blu, colore ara, colore ver){
	colore max1, max2, max3, max4, max5, max6;

/*controllo ne e bi*/
			if (ne.occorrenza > bi.occorrenza){
				max1.occorrenza = ne.occorrenza;
				max1.tipo = 0;
			}
			else {
				max1.occorrenza = bi.occorrenza;
				max1.tipo = 1;
			}	
/*controllo ro e az*/
			if (ro.occorrenza > az.occorrenza){
				max2.occorrenza = ro.occorrenza;
				max2.tipo = 2;
			}
			else {
				max2.occorrenza = az.occorrenza;
				max2.tipo = 4;
			}
/*controllo gi e ros*/
			if (gi.occorrenza > ros.occorrenza){
				max3.occorrenza = gi.occorrenza;
				max3.tipo = 8;
			}
			else {
				max3.occorrenza = ros.occorrenza;
				max3.tipo = 16;
			}
/*controllo blu e ara*/
			if (blu.occorrenza > ara.occorrenza){
				max4.occorrenza = blu.occorrenza;
				max4.tipo = 32;
			}
			else {
				max4.occorrenza = ara.occorrenza;
				max4.tipo = 64;
			}
/*controllo maggiore tra max1 e max2 salvato in max5*/
			if (max1.occorrenza > max2.occorrenza){
				max5.occorrenza = max1.occorrenza;
				max5.tipo = max1.tipo;
			}
			else {
				max5.occorrenza = max2.occorrenza;
				max5.tipo = max2.tipo;
			}
/*controllo maggiore tra max3 e max4 salvato in max6*/
			if (max3.occorrenza > max4.occorrenza){
				max6.occorrenza = max3.occorrenza;
				max6.tipo = max3.tipo;
			}
			else {
				max6.occorrenza = max4.occorrenza;
				max6.tipo = max4.tipo;
			}
/*controllo maggiore tra i max*/

/*controllo maggiore tra max5 e max6 salvato in max6*/
/*controllo max5 e max6*/
			if (max5.occorrenza > max6.occorrenza){
				max6.occorrenza = max5.occorrenza;
				max6.tipo = max5.tipo;
			}

			if (ver.occorrenza > max6.occorrenza){
				max6.occorrenza = ver.occorrenza;
				max6.tipo = ver.tipo;
			}
/*ritorno max6 che contiene il maggiore di tutti i colori*/
	return (max6);
}

/*funzione per il calcolo delle regioni dello stesso colore - uso 8 cammino*/
unsigned int ric_reg (punto m[][lar], int h, int k, unsigned int reg, unsigned int num_reg, int maxY, int* maxX, int* minY, int* minX ){
	
		
/*aggiorno il valore della regioni del pixel corrente*/	
		m[h][k].regione = reg; 
/*misura la numerosità della regione*/
		num_reg++;	

/*controllo le coordinate dei punti per scoprire quelle estreme*/

		if (*maxX < k){
			*maxX = k;
		}
		if ((*minY == 0)||((*minY < h)&&(h > maxY))){ 
			*minY = h;
		}
		if ((*minX == 0)||(*minX > k)){
			*minX = k;
		}


/*controllo su valore del colore e se la regione è ancora da assegnare --- 
fatto per ogni pixel su cui è chiamata la funzione*/

/*pixel dx*/
		if ((h<=al)&&(k<=la)){
			if((m[h][k+1].val_col == m[h][k].val_col)&&(m[h][k+1].regione == 0)){
				m[h][k+1].regione = m[h][k].regione;
				num_reg = ric_reg (m, h, k+1, reg, num_reg, maxY, maxX, minY, minX);
			}
		}
/*pixel basso dx*/
		if ((h<=al)&&(k<=la)){
			if((m[h+1][k+1].val_col == m[h][k].val_col)&&(m[h+1][k+1].regione == 0)){
				m[h+1][k+1].regione = m[h][k].regione;
				num_reg = ric_reg (m, h+1, k+1, reg, num_reg, maxY, maxX, minY, minX);
			}
		}
/*pixel alto dx*/
		if ((h<=al)&&(k<=la)){
			if((m[h-1][k+1].val_col == m[h][k].val_col)&&(m[h-1][k+1].regione == 0)){
				m[h-1][k+1].regione = m[h][k].regione;
				num_reg = ric_reg (m, h-1, k+1, reg, num_reg, maxY, maxX, minY, minX);
			}
		}
/*pixel sx*/
		if ((h<=al)&&(k<=la)){
			if((m[h][k-1].val_col == m[h][k].val_col)&&(m[h][k-1].regione == 0)){
				m[h][k-1].regione = m[h][k].regione;
				num_reg = ric_reg (m, h, k-1, reg, num_reg, maxY, maxX, minY, minX);
			}	
		}
/*pixel basso sx*/
		if ((h<=al)&&(k<=la)){
			if((m[h+1][k-1].val_col == m[h][k].val_col)&&(m[h+1][k-1].regione == 0)){
				m[h+1][k-1].regione = m[h][k].regione;
				num_reg = ric_reg (m, h+1, k-1, reg, num_reg, maxY, maxX, minY, minX);
			}
		}
/*pixel alto sx*/
		if ((h<=al)&&(k<=la)){
			if((m[h-1][k-1].val_col == m[h][k].val_col)&&(m[h-1][k-1].regione == 0)){
				m[h-1][k-1].regione = m[h][k].regione;
				num_reg = ric_reg (m, h-1, k-1, reg, num_reg, maxY, maxX, minY, minX);
			}		
		}
/*pixel sopra*/
		if ((h<=al)&&(k<=la)){	
			if((m[h-1][k].val_col == m[h][k].val_col)&&(m[h-1][k].regione == 0)){
				m[h-1][k].regione = m[h][k].regione;
				num_reg = ric_reg (m, h-1, k, reg, num_reg, maxY, maxX, minY, minX);
			}
		}
/*pixel sotto*/
		if ((h<=al)&&(k<=la)){
			if((m[h+1][k].val_col == m[h][k].val_col)&&(m[h+1][k].regione == 0)){
				m[h+1][k].regione = m[h][k].regione;
				num_reg = ric_reg (m, h+1, k, reg, num_reg, maxY, maxX, minY, minX);
			}
		}
		return(num_reg);
}


/*pone a 0 i valori di colore e di regione delle regioni trova ma troppo piccole
per essere considerate*/

void canc_reg (punto m[][lar], int h, int k, unsigned int reg){ 


/*aggiorno la regione del pixel passato*/
	m[h][k].regione = 0;
	m[h][k].val_col = 0;
	
/*controllo dei pixel vicini a quello passato*/
/*se il valore della regione combacia con quello passato allora richiamo la procedura
sul pixel corrente*/

/*pixel alto sx*/
/*se il pixel vicino appartiene alla mia regione*/
	if (m[h-1][k-1].regione == reg){
		canc_reg(m, h-1, k-1, reg);
	}
				
/*pixel alto*/
	if (m[h][k-1].regione == reg){
		canc_reg(m, h-1, k, reg);
	}
	
/*pixel alto dx*/
	if (m[h+1][k-1].regione == reg){
		canc_reg(m, h+1, k-1, reg);
	}	

/*pixel sx*/
	if (m[h-1][k].regione == reg){
		canc_reg(m, h-1, k, reg);
	}	

/*pixel dx*/
	if (m[h+1][k].regione == reg){
		canc_reg(m, h+1, k, reg);
	}
	
/*pixel basso sx*/
	if (m[h-1][k+1].regione == reg){
		canc_reg(m, h-1, k+1, reg);
	}
	
/*pixel basso*/
	if (m[h][k+1].regione == reg){
		canc_reg(m, h, k+1, reg);
	}
	
/*pixel basso dx*/
	if (m[h+1][k+1].regione == reg){
		canc_reg(m, h+1, k+1, reg);
	}
	
}//end canc_reg

/*calcola il perimetro in numero di pixel delle regioni, il diametro, le coord. del centroide
e il coeff. di circolarità (di Haralick)*/
 
void perimeter (punto m[][lar], int h, int k, double* drd, double* xc, double* yc, double* per, double* circ, int* green, int* white){

/*assegno il valore delle coordinate del punto a queste var ausiliarie come da testo dell'algoritmo*/

	struct coord{				//elementi dell'array che corrispondono alle coordinate di un punto
		unsigned int line;		//necessarie per la scansione dei vicini in senso orario a seconda di 
		unsigned int column;	//un punto di partenza diverso
	};

	coord position[8];			//array con le posizioni da scandire 

	per_elem* aus;				//puntatore ausiliario per aggiungere il pixel del perimetro

	double dr =0;
	int search_pos = 0;			//posizione corrente nella ricerca del prox pixel

	int a, b, a1, b1;
	a=h;						//y
	b=k;						//x
	a1=h;
	b1=k;

	int pos = 0;				//identifica la posizione del pixel precedente
	int l=0;
	int c=0;
	double npixels = 0;
	
	CircleFittingClass* oCircleFitting;				//puntatore di tipo CircleFittingClass
  	oCircleFitting = new CircleFittingClass();		//costruttore
  	oCircleFitting->mResetPoints();					//inizializz. variabili
	
	per_reg round;
	round.first = NULL;
	round.last = NULL;
	//per coda memorizzazione elementi del perimetro	

/*passo preliminare: 
1- ho il primo pixel della regione trovato per scansione sequenziale, quindi devo controllare
solo i pixel dal vicino di destra.
2- la scansione avviene in senso orario sui pixel 8 vicini del mio non esclusi dal passo 
preliminare (dx, sotto dx, sotto e sotto sx)
3- al ciclo dovrò passare il primo pixel dello stesso colore che trovo e il suo predecessore
*/

/*controllo i vicini */
	/*vicino dx*/
	if (m[a][b].val_col == m[a][b+1].val_col){
		pos = 2;
		dr = dr +1;
		a=a;
		b=b+1;
		npixels++;
		oCircleFitting->mAddPoint((double)b,(double)a);
	}
	else {

		if (m[a][b+1].val_col == 1){
			*white = 1;
		}
		else {
			if (m[a][b+1].val_col == 128){
				*green = 1;
			}
		}

		/*vicino sotto dx*/
		if (m[a][b].val_col == m[a+1][b+1].val_col){
			pos = 2;
			dr = dr +1;
			a=a+1;
			b=b+1;
			npixels++;
			oCircleFitting->mAddPoint((double)b,(double)a);
		}
		else {
		
			if (m[a+1][b+1].val_col == 1){
				*white = 1;
			}
			else {
				if (m[a+1][b+1].val_col == 128){
					*green = 1;
				}
			}

		
			/*vicino sotto*/
			if (m[a][b].val_col == m[a+1][b].val_col){
				pos = 4;
				dr = dr +1;
				a=a+1;
				b=b;
				npixels++;
				oCircleFitting->mAddPoint((double)b,(double)a);
			}
			else {

				if (m[a+1][b+1].val_col == 1){
					*white = 1;
				}
				else {
					if (m[a+1][b+1].val_col == 128){
						*green = 1;
					}
				}
		
				/*vicino sotto sx*/
				if (m[a][b].val_col == m[a+1][b-1].val_col){
					pos = 4;
					dr = dr +1;
					a=a+1;
					b=b-1;
					npixels++;
					oCircleFitting->mAddPoint((double)b,(double)a);
				}
				
				if (m[a+1][b+1].val_col == 1){
					*white = 1;
				}
				else {
					if (m[a+1][b+1].val_col == 128){
						*green = 1;
					}
				}
			}
		}
	}
	
	aus = (per_elem*) malloc(sizeof(per_elem));
	aus->coord_y = a;
	aus->coord_x = b;
	aus->next = NULL;
	round.first = aus;
	round.last = aus;
	aus = NULL;
	
/*passo di elaborazione: una volta eseguito il passo preliminare, eseguo l'algoritmo iniziando dai valori
da lui ritornati*/

/*n.b.: pos è il pixel precedente!!!*/
	
	while (a!=h || b!=k){

/*inizializzazine array position*/
		position[0].column= b-1;
		position[0].line = a;

		position[1].column = b-1;
		position[1].line = a-1;

		position[2].column = b;
		position[2].line = a-1;

		position[3].column = b+1;
		position[3].line = a-1;

		position[4].column = b+1;
		position[4].line = a;

		position[5].column = b+1;
		position[5].line = a+1;

		position[6].column = b;
		position[6].line = a+1;

		position[7].column = b-1;
		position[7].line = a+1;
		
		for (int i=0; i<=7; i++){
			search_pos = ((pos+i)%8);	//conti fatti in modulo 8 per ricadere nelle posizioni in modo ciclico		
		//n.b.: search pos contiene la posizione del primo pixel uguale trovato durante la scansione
		
			l = position[search_pos].line;
			c = position[search_pos].column;
			
			/*controllo se la regione è vicina ad altre verdi o bianche*/
				if (m[l][c].val_col == 1){
					*white = 1;
				}
				else {
					if (m[l][c].val_col == 128){
						*green = 1;
					}
				}
			
			if (m[a][b].val_col == m[l][c].val_col){
				dr = dr+1;	//aggiorno il valore del perimetro
				b=c;
				a=l;
		
				//devo trovare il numero del pixel precedente nella scansione
				if ((search_pos==4)||(search_pos==5)){
					pos = 2;
				}
				else {
					if ((search_pos==2)||(search_pos==3)){
						pos = 0;
					}
					else {
						if ((search_pos==6)||(search_pos==7)){
							pos = 4;
						}
						else {
							if ((search_pos==0)||(search_pos==1)){
								pos = 6;
							}
						}
					}
				}
				npixels++;
				oCircleFitting->mAddPoint((double)b,(double)a);
				
				//pixel trovato, creo un nuovo elemento della lista e la accodo alla fine
				
				aus = (per_elem*) malloc(sizeof(per_elem));
				aus->coord_y = a;
				aus->coord_x = b;
				aus->next = NULL;

				//metto nella coda				
				round.last->next = aus;
				round.last = aus;
				aus = NULL;
				break;
				
			}
		}
	}//end while

/*calcolo del centroide usa le classe oCircleFitting che servirà poi per il fitting della palla*/

	if (npixels!=0){
		oCircleFitting->mEdgeBaricenterCircleFitting();
   	 	//oCircleFitting->mOMaMaCircleFitting_DownhillSimplex(0.4);	 //default 0.5
    	*xc  = oCircleFitting->mGetCenterX(); 
    	*yc  = oCircleFitting->mGetCenterY(); 
    	*drd = oCircleFitting->mGetRadius()/PI;
		
    }
	*per = dr;

/*-------------------------------------------------------------------------------------------------*/
/*calcolo della circolarità di Haralick della regione di colore: effettuata per tutte le regioni,così 
posso sfruttare il dato per diversificarle---------------------------------------------------------*/
/*-------------------------------------------------------------------------------------------------*/

	int diff_1, diff_2, counter;
	double x, y, tot_s, tot_d, sum, circolarity;
	x = *xc;
	y = *yc;
	diff_1 = 0;
	diff_2 = 0;
	sum = 0;
	tot_s = 0;	
	counter = 0;
	circolarity = 0;

	aus = round.first;

/*-----------------------*/
/*calcolo del valor medio*/
/*-----------------------*/

//	if (m[h][k].val_col == 2){
		while (aus!=NULL){		
		/*calcolo delle differenze*/
			diff_1 = ((aus->coord_x)-(int)x);
			diff_2 = ((aus->coord_y)-(int)y);
		/*elevo al quadrato le diff_n e le sommo*/
			diff_1 = diff_1*diff_1;
			diff_2 = diff_2*diff_2;
			sum = diff_1 + diff_2;
		/*radice quadrata di sum*/
			sum = sqrt(sum);
		/*aggiorno il contatore totale*/
			tot_s = tot_s + sum;
		/*aggiorno il contatore del numero di pixel del perimetro*/
			counter++;
		/*per proseguire nella scansione*/
			aus = aus->next;
		}
/*tot_s contiene il valore medio*/
		tot_s = tot_s/counter;

/*---------------------------------*/
/*calcolo della deviazione standard*/
/*---------------------------------*/

/*inizializzo le variabili*/
		diff_1 = 0;
		diff_2 = 0;
		sum = 0;
		tot_d = 0;
		counter = 0;
		aus = round.first;
	
		while(aus!=NULL){
		/*calcolo delle differenze*/
			diff_1 = ((aus->coord_x)-(int)x);
			diff_2 = ((aus->coord_y)-(int)y);
		/*elevo al quadrato le diff_n e le sommo*/
			diff_1 = diff_1*diff_1;
			diff_2 = diff_2*diff_2;	
			sum = diff_1 + diff_2;
		/*radice quadrata di sum*/
			sum = sqrt(sum);
		/*tolgo il valore medio ed elevo al quadrato*/
			sum = sum - tot_s;
			sum = sum*sum;
		/*aggiorno il contatore totale*/
			tot_d = tot_d + sum;
		/*aggiorno il contatore del numero di pixel del perimetro*/
			counter++;
		/*per proseguire nella scansione*/
			aus = aus->next;
		}
		if (tot_d>0){
			tot_d = tot_d/counter;
			*circ = tot_s/tot_d;
		}	
		else {
			*circ = tot_s/tot_d;
		}	

	round.first = NULL;
	round.last = NULL;

}//end procedure


/*funzione che identifica la palla nel mentre vengono scoperte le varie regioni rosa: nella robocup 
il colore della palla è arancione, quindi una volta trovato la regione arancione, la procedura non è più
richiamata*/

void ball_finder (queue obj, region*& ball){
	
	int min_circ;
	region* pn;
	region* pr;
	min_circ = 8;
	pn = obj.front;
	pr = obj.front;
	
/*scansione della lista delle regioni rilevate*/
	while (pn != NULL){
		
/*uso il centroide per il posizionamento sotto la linea dell'orizzonte*/
/*vedere se ok o se è meglio usare le coordinate del primo pixel*/ 

/*in caso sono in robocup, la regione arancione è l'unica che può essere la palla*/
/*essa va rilevata solo se è al di sotto della riga dell'orizzonte*/

 		if ((pn->color == 64)/*&&(pn->centroid_y >= 80)*/){
	/*in teoria la palla arancione è l'unica regione di quel colore perciò
	  sarà sempre sotto la linea dell'orizzonte e quindi la consizione non è necessaria...forse*/	
			printf("palla arancio\n");
			if (ball == NULL){
				ball = pn;
			}
			else {
	/*nel malaugurato caso che ci siano due regioni arancioni uso quella con circolrità maggiore*/
				if (ball->circ < pn->circ){
					ball = pn;
				}
			}
		}
		else {
/*caso in cui ho la palla rosa (no robocup): essa è la regione rosa con circolarità maggiore*/
/*come nel caso precedente, va rilevata solo se al di sotto della riga dell'orizzonte*/
			if ((pn->color == 2)&&(pn->circ >= min_circ)/*&&(pn->centroid_y >= 80)*/){
	/*caso in cui non ho ancora trovato la palla*/
				if ((ball == NULL)){
					ball = pn;
				}
				else {
	/*in caso ho due regioni rosa uso quella con circolarità maggiore*/
					if ((ball->circ < pn->circ)){
						ball = pn;
					}
				}
			}
		}
		pn = pn->next;
	}//ens while
	
}//end procedura


/*funzione che rileva la presenza dei marker*/
/*parte dalle regioni rosa che non sono la palla e cerca quelle colorate gialle o azzurre più vicine: assieme formeranno il marker.
ATTENZIONE ALLA DISTANZA TRA LE DUE: posso confondere le regioni azzurre o gialle che non sono parte del marker ma sporco*/
void marker_door_finder (queue obj, region* ball, region*& m1_pink, region*& m1_color, region*& m2_pink, region*& m2_color, region*& m3_pink, region*& m3_color, region*& m4_pink, region*& m4_color, region*& y_door, region*& b_door){

	region* pn;
	pn = obj.front;

/*memorizzare la distanza*/
	double dis, dis_p;
	double mult;
	dis = 0;
	dis_p = 0;
	mult = 1.5;
	unsigned int count_c= 0;
	double circ;
	unsigned int id;
	
	
	if (ball == NULL){
			circ = 10;
			id = 0;
	}
	else {
		circ = ball->circ;
		id = ball->id;
	}
	

/*primo ciclo per rilevazione dei marker*/

	while (pn != NULL){
/*cerco le regioni rosa che sono diverse dalla palla*/
		if (pn->circ < circ){ //se è meno circolare della palla allora è un mk

			if ((pn->color == 2)&&(pn->id != id)&&(m1_pink == NULL)){
				m1_pink = pn;
			}
			else {
				if ((pn->color == 2)&&(pn->id != id)&&(m2_pink == NULL)){
					m2_pink = pn;
				}
				else {
					if ((pn->color == 2)&&(pn->id != id)&&(m3_pink == NULL)){
					m3_pink = pn;
					}
					else {
						if ((pn->color == 2)&&(pn->id != id)&&(m4_pink == NULL)){
							m4_pink = pn;
						}
					}
				}
			}
		}
		pn = pn->next;
	}//end 1° while - ricerca parti rosa
	
/*ricerca delle regioni colorate vicine alla mia*/

	pn = obj.front;

/*ciclo while per m1_pink*/
	if (m1_pink != NULL){
		while (pn != NULL){
			if ((pn->color == 4)||(pn->color == 8)){
				dis = distance (m1_pink->centroid_y, m1_pink->centroid_x, pn->centroid_y, pn->centroid_x);
				if (dis_p == 0){
					dis_p = dis;
					m1_color = pn;
				} 
				else {
					if (dis<dis_p){
						dis_p = dis;
						m1_color = pn;
					}
				}
			}
			pn = pn->next;
		}//end while

/*controllo se il centroide della regione che identifico come parte colorata del mk (quella più vicina a quella rosa)
sta ad una distanza tale che possa essere il suo marker: questa distanza è calcolate sfruttando l'altezza 
della regione rosa (ma usare la larghezza era uguale perchè sono uguali 10x10cm) moltiplicata per 1,5*/

		if (((m1_pink->width)*mult)< dis_p){
			m1_color = NULL;
		} 
	}	

	if (m1_color != NULL){
		count_c++;
	}

	pn = obj.front;
	dis_p = 0;
	
/*ciclo while per m2_pink*/
	if (m2_pink != NULL){
		while (pn != NULL){
			if (((pn->color == 4)||(pn->color == 8))&&(pn != m1_color)){
					dis = distance (m2_pink->centroid_y, m2_pink->centroid_x, pn->centroid_y, pn->centroid_x);
					if (dis_p == 0){
						dis_p = dis;
						m2_color = pn;
					} 
					else {
						if (dis<dis_p){
							dis_p = dis;
							m2_color = pn;
						}	
					}
			}
			pn = pn->next;
			
		}//end while 
		if (((m2_pink->width)*mult)< dis_p){
			m2_color = NULL;
		}
	}
	
	if (m2_color != NULL){
		count_c++;
	}


	pn = obj.front;
	dis_p = 0;

/*ciclo while per m3_pink*/
	if (m3_pink != NULL){
		while (pn != NULL){
			if ((pn->color == 4)||(pn->color == 8)){
				dis = distance (m3_pink->centroid_y, m3_pink->centroid_x, pn->centroid_y, pn->centroid_x);
				if (dis_p == 0){
					dis_p = dis;
					m3_color = pn;
				} 
				else {
					if (dis<dis_p){
						dis_p = dis;
						m3_color = pn;
					}	
				}
			}
			pn = pn->next;
		}//end while
		if (((m3_pink->width)*mult)< dis_p){
			m3_color = NULL;
		}
	}

	if (m3_color != NULL){
		count_c++;
	}

	pn = obj.front;
	dis_p = 0;

/*ciclo while per m4_pink*/
	if (m4_pink != NULL){
		while (pn != NULL){
			if ((pn->color == 4)||(pn->color == 8)){
				dis = distance (m4_pink->centroid_y, m4_pink->centroid_x, pn->centroid_y, pn->centroid_x);
				if (dis_p == 0){
					dis_p = dis;
					m4_color = pn;
				} 
				else {
					if (dis<dis_p){
						dis_p = dis;
						m4_color = pn;
					}
				}
			}
			pn = pn->next;
		}//end while 
		if (((m4_pink->width)*mult)< dis_p){
			m4_color = NULL;
		}
	}

	if (m4_color != NULL){
		count_c++;
	}
	
	pn = obj.front;
	dis_p = 0;

	printf("count = %d\n", count_c);

/*ricerca dei marker colorati che non hanno la parte rosa se non ne ho trovati alcuni*/
	if (count_c < 4){ //se = 4 non devo cercare altri marker	
		while (pn != NULL){
			if ((pn->color == 4)&&(pn->white == 1)&&(pn->green == 0)/*&&(pn->id != m1_color->id)&&(pn->id != m2_color->id)&&(pn->id != m3_color->id)&&(pn->id != m4_color->id)*/){

				if ((m1_pink == NULL)&&(m1_color == NULL)){
					m1_color = pn;
				}
				else{
					if ((m2_pink == NULL)&&(m2_color == NULL)/*&&(pn->id != m1_color->id)&&(pn->id != m1_color->id)&&(pn->id != m2_color->id)&&(pn->id != m3_color->id)&&(pn->id != m4_color->id)*/){
						m2_color = pn;
					}
					else{
						if ((m3_pink == NULL)&&(m3_color == NULL)/*&&(pn->id != m1_color->id)&&(pn->id != m2_color->id)&&(pn->id != m3_color->id)&&(pn->id != m4_color->id)*/){
							m3_color = pn;
						}
						else {
							if ((m4_pink == NULL)&&(m4_color == NULL)/*&&(pn->id != m1_color->id)&&(pn->id != m2_color->id)&&(pn->id != m3_color->id)&&(pn->id != m4_color->id)*/){
								m4_color = pn;
							}
						}
					}
				}
			}
			if ((pn->color == 8)&&(pn->white == 1)&&(pn->green == 0)){
				if ((m1_pink == NULL)&&(m1_color == NULL)/*&&(pn->id != m1_color->id)&&(pn->id != m2_color->id)&&(pn->id != m3_color->id)&&(pn->id != m4_color->id)*/){
					m1_color = pn;
				}
				else{
					if ((m2_pink == NULL)&&(m2_color == NULL)/*&&(pn->id != m1_color->id)&&(pn->id != m2_color->id)&&(pn->id != m3_color->id)&&(pn->id != m4_color->id)*/){
						m2_color = pn;
					}
					else{
						if ((m3_pink == NULL)&&(m3_color == NULL)/*&&(pn->id != m1_color->id)&&(pn->id != m2_color->id)&&(pn->id != m3_color->id)&&(pn->id != m4_color->id)*/){
							m3_color = pn;
						}
						else {
							if ((m4_pink == NULL)&&(m4_color == NULL)/*&&(pn->id != m1_color->id)&&(pn->id != m2_color->id)&&(pn->id != m3_color->id)&&(pn->id != m4_color->id)*/){
								m4_color = pn;
							}
						}
					}
				}
			}
			pn = pn->next;
		}//end while
	}//end if

	pn = obj.front;

/*ricerca delle porte*/
/*la porta è quella più vicine al verde - può vederle anche entrambe*/
/*LE PORTE SONO LE REGIONI COLORATE 4 e 8 PIU' VICINE A QUELLE VERDI!!!!*/
/*quindi basta calcolre la regione colorata più vicina a quelle verdi e area più grande per trovare la porta: le altre le trovo per esclusione*/

/*ATTENZIONE: le porte nella robocup hanno il loro interno verde, quindi, oltre alla riga bianca davanti, devo considerare anche l'interno*/

/*Attivare il controllo green quando faccio le foto con le nuove porte --- valutare se attivare anche il white*/

	while (pn != NULL){
		if (pn->color == 4){
			if ((pn != m1_color)&&(pn != m2_color)&&(pn != m3_color)&&(pn != m4_color)&&(pn->green == 1)/*&&(pn->white == 1)*/){
				b_door = pn;
			}
		}
		if (pn->color == 8){
			if ((pn != m1_color)&&(pn != m2_color)&&(pn != m3_color)&&(pn != m4_color)&&(pn->green == 1)/*&&(pn->white == 1)*/){
				y_door = pn;
			}
		}
		pn = pn->next;
	}//end while
printf("end procedeure\n");
}//end procedure


double distance (double cy1, double cx1, double cy2, double cx2){
	
	return(sqrt((cx1-cx2)*(cx1-cx2)+(cy1-cy2)*(cy1-cy2)));

}//end procedure

/*funzione che trova gli altri aibo*/
/*cerca le zone rosse e blu più grandi: possibile aggiunta il fatto di accumunare allo stesso aibo le regioni rosse vicine usando il buonding box e calcolando le sistanze minime*/

/* in pratica calcolo il buonding box della regione rossa/blu più grande, poi inserisco come parti dello stesso robot quelle regioni che rientrano del bounding box di questa e quelle che sono vicine meno di una certa soglia colcolata tipo quella che ho usato con i marker*/

/*chiedere proff se devo aggiungere anche questo aspetto*/

void aibo_finder (queue obj, aibo_reg*& aibo_r, aibo_reg*& aibo_b){
	
	region* pn;
	pn = obj.front;
	aibo_reg* ar;
	
	while (pn != NULL){
/*aibo rossi*/
		if ((pn->color == 16)&&(pn->white ==1)){
			if (aibo_r == NULL){
				ar = (aibo_reg*) malloc(sizeof(aibo_reg));	
				aibo_r = ar;
				aibo_r->aibo_mk = pn;
				aibo_r->next = NULL;
				ar = NULL;
			}
			else {
				ar = (aibo_reg*) malloc(sizeof(aibo_reg));
			/*inserimento in testa*/
				ar->aibo_mk = pn;
				ar->next = aibo_r;
				aibo_r = ar;
				ar = NULL;
			} 			
		}	
/*aibo blu*/
		if ((pn->color == 32)&&(pn->white == 1)){
			if (aibo_b == NULL){
				ar = (aibo_reg*) malloc(sizeof(aibo_reg));	
				aibo_b = ar;
				aibo_b->aibo_mk = pn;
				aibo_b->next = NULL;
				ar = NULL;
			}
			else {
				ar = (aibo_reg*) malloc(sizeof(aibo_reg));
			/*inserimento in testa*/
				ar->aibo_mk = pn;
				ar->next = aibo_b;
				aibo_b = ar;
				ar = NULL;
			} 	
		}
		pn = pn->next;
	}//end while	
}//end procedure

/*procedura che estrae le regioni che rappresentano le linee del campo*/
void line_finder (queue obj, white_st*& ws){
	
	region* pn;
	white_st* aus;
	pn = obj.front;
	aus = NULL;
		
	while(pn != NULL){
		if (pn->color == 1){
			if (ws == NULL){
				aus = (white_st*) malloc(sizeof(white_st));
				ws = aus;
				ws->whst = pn;
				ws->next = NULL;
				aus = NULL;
				}
			else {
				aus = (white_st*) malloc(sizeof(white_st));
				aus->whst = pn;
				aus->next = ws;
				ws = aus;
				aus = NULL;
			}
		}
		pn = pn->next;
	}
}//end procedure
