Example #1
0
def start_main(parametri_obj, path_obj):	
	#----------------------------1.0_LAYOUT DELLE STANZE----------------------------------
	#------inizio layout
	#leggo l'immagine originale in scala di grigio e la sistemo con il thresholding
	img_rgb = cv2.imread(path_obj.metricMap)
	img_ini = img_rgb.copy() #copio l'immagine
	# 127 per alcuni dati, 255 per altri
	ret,thresh1 = cv2.threshold(img_rgb,parametri_obj.cv2thresh,255,cv2.THRESH_BINARY)#prova
	
	#------------------1.1_CANNY E HOUGH PER TROVARE MURI---------------------------------
	walls , canny = lay.start_canny_ed_hough(thresh1,parametri_obj)
	print "walls: ", len(walls)

	#walls , canny = lay.start_canny_ed_hough(img_rgb,parametri_obj)
	
	if par.DISEGNA:
		#disegna mappa iniziale, canny ed hough
		dsg.disegna_map(img_rgb,filepath = path_obj.filepath, format='png')
		dsg.disegna_canny(canny,filepath = path_obj.filepath, format='png')
		dsg.disegna_hough(img_rgb,walls,filepath = path_obj.filepath, format='png')

	lines = lay.flip_lines(walls, img_rgb.shape[0]-1)
	walls = lay.crea_muri(lines)
	print "lines", len(lines), len(walls)
	if par.DISEGNA:
		#disegno linee
		dsg.disegna_segmenti(walls, format='png')#solo un disegno poi lo elimino
	
	#------------1.2_SETTO XMIN YMIN XMAX YMAX DI walls-----------------------------------
	#tra tutti i punti dei muri trova l'ascissa e l'ordinata minima e massima.
	estremi = sg.trova_estremi(walls)
	xmin = estremi[0]
	xmax = estremi[1]
	ymin = estremi[2]
	ymax = estremi[3]
	offset = 20
	xmin -= offset
	xmax += offset
	ymin -= offset
	ymax += offset
	#-------------------------------------------------------------------------------------
	#---------------1.3_CONTORNO ESTERNO--------------------------------------------------
	
	#(contours, vertici) = lay.contorno_esterno(img_rgb, parametri_obj, path_obj)
	(contours, vertici) = lay.contorno_esterno_versione_tre(img_rgb)#MIO METODO
	
	if par.DISEGNA:
		dsg.disegna_contorno(vertici,xmin,ymin,xmax,ymax,filepath = path_obj.filepath, format='png')
	#-------------------------------------------------------------------------------------
	#---------------1.4_MEAN SHIFT PER TROVARE CLUSTER ANGOLARI---------------------------
	(indici, walls, cluster_angolari) = lay.cluster_ang(parametri_obj.h, parametri_obj.minOffset, walls, diagonali= parametri_obj.diagonali)
	if par.DISEGNA:	
		#dsg.disegna_cluster_angolari(walls, cluster_angolari, filepath = path_obj.filepath,savename = '5b_cluster_angolari')
		dsg.disegna_cluster_angolari_corretto(walls, cluster_angolari, filepath = path_obj.filepath,savename = '5b_cluster_angolari',format='png')
	
	#-------------------------------------------------------------------------------------

	#---------------1.5_CLUSTER SPAZIALI--------------------------------------------------
	#questo metodo e' sbagliato, fai quella cosa con il hierarchical clustering per classificarli meglio.e trovare in sostanza un muro
	#cluster_spaziali = lay.cluster_spaz(parametri_obj.minLateralSeparation, walls)
	#inserisci qui il nuovo Cluster_spaz
	nuovo_clustering = 2 #1 metodo di matteo, 2 mio
	#in walls ci sono tutti i segmenti
	if nuovo_clustering == 1:
		cluster_spaziali = lay.cluster_spaz(parametri_obj.minLateralSeparation, walls)#metodo di matteo 
	elif nuovo_clustering ==2:
		cluster_mura = lay.get_cluster_mura(walls, cluster_angolari, parametri_obj)#metodo di valerio

		cluster_mura_senza_outliers = []
		for c in cluster_mura:	
			if c!=-1:
				cluster_mura_senza_outliers.append(c)
		# ottengo gli outliers
# 		outliers = []
# 		for s in walls:
# 			if s.cluster_muro == -1:
# 				outliers.append(s)
# 		dsg.disegna_segmenti(outliers, savename = "outliers")

		
		#ora che ho un insieme di cluster relativi ai muri voglio andare ad unire quelli molto vicini
		#ottengo i rappresentanti dei cluster (tutti tranne gli outliers)
		#segmenti_rappresentanti = lay.get_rappresentanti(walls, cluster_mura)
		segmenti_rappresentanti = lay.get_rappresentanti(walls, cluster_mura_senza_outliers)
	
			
		if par.DISEGNA:
			dsg.disegna_segmenti(segmenti_rappresentanti,filepath = path_obj.filepath, savename = "5c_segmenti_rappresentanti", format='png')

		#classifico i rappresentanti
		#qui va settata la soglia con cui voglio separare i cluster muro
		
		#segmenti_rappresentanti = segmenti_rappresentanti
		segmenti_rappresentanti = sg.spatialClustering(parametri_obj.sogliaLateraleClusterMura, segmenti_rappresentanti)
		#in questo momento ho un insieme di segmenti rappresentanti che hanno il cluster_spaziale settato correttamente, ora setto anche gli altri che hanno lo stesso cluster muro
		cluster_spaziali = lay.new_cluster_spaziale(walls, segmenti_rappresentanti, parametri_obj)
			
		
	if par.DISEGNA:
		dsg.disegna_cluster_spaziali(cluster_spaziali, walls,filepath = path_obj.filepath, format='png')
		dsg.disegna_cluster_mura(cluster_mura, walls,filepath = path_obj.filepath, savename= '5d_cluster_mura', format='png')
	#-------------------------------------------------------------------------------------

	#-------------------1.6_CREO EXTENDED_LINES-------------------------------------------
	(extended_lines, extended_segments) = lay.extend_line(cluster_spaziali, walls, xmin, xmax, ymin, ymax,filepath = path_obj.filepath)
	
	if par.DISEGNA:
		dsg.disegna_extended_segments(extended_segments, walls,filepath = path_obj.filepath, format='png')		
	#-------------------------------------------------------------------------------------

	#-------------1.7_CREO GLI EDGES TRAMITE INTERSEZIONI TRA EXTENDED_LINES--------------
	edges = sg.crea_edges(extended_segments)
	#-------------------------------------------------------------------------------------
	
	#----------------------1.8_SETTO PESI DEGLI EDGES-------------------------------------
	edges = sg.setPeso(edges, walls)
	
	#-------------------------------------------------------------------------------------

	#----------------1.9_CREO LE CELLE DAGLI EDGES----------------------------------------
	celle = fc.crea_celle(edges)
	#-------------------------------------------------------------------------------------

	#----------------CLASSIFICO CELLE-----------------------------------------------------
	global centroid
	#verificare funzioni
	if par.metodo_classificazione_celle ==1:
		print "1.metodo di classificazione ", par.metodo_classificazione_celle
		(celle, celle_out, celle_poligoni, indici, celle_parziali, contorno, centroid, punti) = lay.classificazione_superfici(vertici, celle)
	elif par.metodo_classificazione_celle==2:
		print "2.metodo di classificazione ", par.metodo_classificazione_celle
		#sto classificando le celle con il metodo delle percentuali
		(celle_out, celle, centroid, punti,celle_poligoni, indici, celle_parziali) = lay.classifica_celle_con_percentuale(vertici, celle, img_ini)
	#-------------------------------------------------------------------------------------
		
	#--------------------------POLIGONI CELLE---------------------------------------------	
	(celle_poligoni, out_poligoni, parz_poligoni, centroid) = lay.crea_poligoni_da_celle(celle, celle_out, celle_parziali)
	
	#ora vorrei togliere le celle che non hanno senso, come ad esempio corridoi strettissimi, il problema e' che lo vorrei integrare con la stanza piu' vicina ma per ora le elimino soltanto 
	
	#RICORDA: stai pensando solo a celle_poligoni
	#TODO: questo metodo non funziona benissimo(sbagli ad eliminare le celle)
	#celle_poligoni, celle = lay.elimina_celle_insensate(celle_poligoni,celle, parametri_obj)#elimino tutte le celle che hanno una forma strana e che non ha senso siano stanze
	#-------------------------------------------------------------------------------------
		
	
	#------------------CREO LE MATRICI L, D, D^-1, ED M = D^-1 * L------------------------
	(matrice_l, matrice_d, matrice_d_inv, X) = lay.crea_matrici(celle, sigma = parametri_obj.sigma)
	#-------------------------------------------------------------------------------------

	#----------------DBSCAN PER TROVARE CELLE NELLA STESSA STANZA-------------------------
	clustersCelle = lay.DB_scan(parametri_obj.eps, parametri_obj.minPts, X, celle_poligoni)
	#questo va disegnato per forza perche' restituisce la lista dei colori
	if par.DISEGNA:
		colori, fig, ax = dsg.disegna_dbscan(clustersCelle, celle, celle_poligoni, xmin, ymin, xmax, ymax, edges, contours,filepath = path_obj.filepath, format='png')
	else:
		colori = dsg.get_colors(clustersCelle, format='png')
	#-------------------------------------------------------------------------------------

	#------------------POLIGONI STANZE(spazio)--------------------------------------------
	stanze, spazi = lay.crea_spazio(clustersCelle, celle, celle_poligoni, colori, xmin, ymin, xmax, ymax, filepath = path_obj.filepath) 
	if par.DISEGNA:
		dsg.disegna_stanze(stanze, colori, xmin, ymin, xmax, ymax,filepath = path_obj.filepath, format='png')
	#-------------------------------------------------------------------------------------
		
	#cerco le celle parziali
	coordinate_bordi = [xmin, ymin, xmax, ymax]
	celle_parziali, parz_poligoni = lay.get_celle_parziali(celle, celle_out, coordinate_bordi)#TODO: non ho controllato bene ma mi pare che questa cosa possa essere inserita nel metodo 1 che crca le celle parziali 
	#creo i poligoni relativi alle celle_out
	out_poligoni = lay.get_poligoni_out(celle_out)
	
# 	TODO: questo blocco e' da eliminare, mi serviva solo per risolvere un bug
# 	l = []
# 	for i,p in enumerate(out_poligoni):
# 		l.append(i)
# 	col_prova = dsg.get_colors(l)
# 	dsg.disegna_stanze(out_poligoni, col_prova, xmin, ymin, xmax, ymax,filepath = path_obj.filepath, savename='0a_prova')
# 	exit()
# 		
		
		
	#--------------------------------fine layout------------------------------------------
	
	#------------------------------GRAFO TOPOLOGICO---------------------------------------
	
	#costruisco il grafo 
	(stanze_collegate, doorsVertices, distanceMap, points, b3, b4, critical_points) = gtop.get_grafo(path_obj.metricMap, stanze, estremi, colori, parametri_obj)
	(G, pos) = gtop.crea_grafo(stanze, stanze_collegate, estremi, colori)
	#ottengo tutte quelle stanze che non sono collegate direttamente ad un'altra, con molta probabilita' quelle non sono stanze reali
	stanze_non_collegate = gtop.get_stanze_non_collegate(stanze, stanze_collegate)
	
	#ottengo le stanze reali, senza tutte quelle non collegate
	stanze_reali, colori_reali = lay.get_stanze_reali(stanze, stanze_non_collegate, colori)
	if par.DISEGNA:
		#sto disegnando usando la lista di colori originale, se voglio la lista della stessa lunghezza sostituire colori con colori_reali
		dsg.disegna_stanze(stanze_reali, colori_reali, xmin, ymin, xmax, ymax,filepath = path_obj.filepath, savename = '8_Stanze_reali', format='png')	
	#------------------------------------------------------------------------------------
	if par.DISEGNA:
		dsg.disegna_distance_transform(distanceMap, filepath = path_obj.filepath, format='png')
		dsg.disegna_medial_axis(points, b3, filepath = path_obj.filepath, format='png')
		dsg.plot_nodi_e_stanze(colori,estremi, G, pos, stanze, stanze_collegate, filepath = path_obj.filepath, format='png')
	
	#-----------------------------fine GrafoTopologico------------------------------------
	
	
	#-------------------------------------------------------------------------------------
	#DA QUI PARTE IL NUOVO PEZZO
	
	
	#disegno le porte
	#b4 rappresentano i punti del medial axis che sono potenzialmente delle porte, e sono messi nella lista critical_points
	dsg.disegna_medial_axis(points, b4, filepath = path_obj.filepath, format='png', savename='11_b_porte')
	
	#IDEA:
	#1) trovo le celle parziali(uno spazio e' parziali se almeno una delle sue celle e' parziale) e creo l'oggetto Plan
	#2) postprocessing per capire se le celle out sono realmente out
	#3) postprocessing per unire gli spazi che dovrebbero essere uniti 
	#4) separare gli spazi che non dovevano essere uniti.
	
	#creo l'oggetto plan che contiene tutti gli spazi, ogni stanza contiene tutte le sue celle, settate come out, parziali o interne. 	
	
	#setto gli spazi come out se non sono collegati a nulla.	
	spazi = sp.get_spazi_reali(spazi, stanze_reali) #elimino dalla lista di oggetti spazio quegli spazi che non sono collegati a nulla.
		
	#---------------------------trovo le cellette parziali--------------------------------
	#se voglio il metodo che controlla le celle metto 1, 
	#se voglio il confronto di un intera stanza con l'esterno metto 2
	#se volgio il confronto di una stanza con quelli che sono i pixel classificati nella frontiera metto 3
	trova_parziali=3 
	
	if par.mappa_completa ==False and trova_parziali==1:
		#QUESTO METODO OGNI TANTO SBAGLIA PER VIA DELLA COPERTURA DEI SEGMANTI, verifico gli errori con il postprocessing per le stanze parziali.
		#TODO: Questo deve essere fatto solo se sono in presenza di mappe parziali
		sp.set_cellette_parziali(spazi, parz_poligoni)#trovo le cellette di uno spazio che sono parziali 
		spazi = sp.trova_spazi_parziali(spazi)#se c'e' almeno una celletta all'interno di uno spazio che e' parziale, allora lo e' tutto lo spazio.
		
	#creo l'oggetto Plan
	#faccio diventare la lista di out_poligoni delle cellette
	cellette_out = []
	for p,c in zip(out_poligoni, celle_out):	
		celletta = sp.Celletta(p,c)
		celletta.set_celletta_out(True)
		cellette_out.append(celletta)
	
	
	plan_o = plan.Plan(spazi, contorno, cellette_out) #spazio = oggetto Spazio. contorno = oggetto Polygon, cellette_out = lista di Cellette
	dsg.disegna_spazi(spazi, colori, xmin, ymin, xmax, ymax,filepath = path_obj.filepath, savename = '13_spazi', format='png')
	
	if par.mappa_completa ==False and trova_parziali==2:
		#secondo metodo per trovare gli spazi parziali. Fa una media pesata. migliore rispetto al primo ma bisogna fare tuning del parametro
		plan.trova_spazi_parziali_due(plan_o)
		
	if par.mappa_completa == False and trova_parziali==3:
		#terzo metodo per trovare le celle parziali basato sulla ricerca delle frontiere.
		immagine_cluster, frontiere, labels, lista_pixel_frontiere = fr.ottieni_frontire_principali(img_ini)
		
		if len(labels) > 0:
			plan.trova_spazi_parziali_da_frontiere(plan_o, lista_pixel_frontiere, immagine_cluster, labels)
			spazi = sp.trova_spazi_parziali(plan_o.spazi)
		
		if par.DISEGNA:
			dsg.disegna_map(immagine_cluster,filepath = path_obj.filepath, savename = '0a_frontiere', format='png')
	
	#-------------------------------------------------------------------------------------	
	
	#-----------------------------calcolo peso per extended_segments----------------------
	
	#calcolo il peso di un extended segment in base alla copertura sei segmenti. Ovviamente non potra' mai essere 100%.
	extended_segments = sg.setPeso(extended_segments, walls)#TODO:controllare che sia realmente corretto
	#calcolo per ogni extended segment quante sono le stanze che tocca(la copertura)
	lay.calcola_copertura_extended_segment(extended_segments, plan_o.spazi)
	plan_o.set_extended_segments(extended_segments)
	
	#-------------------------------------------------------------------------------------	


	#---------------------------unisco spazi oversegmentati ------------------------------
	
	#unisco le spazi che sono state divisi erroneamente
	#fa schifissimo come metodo(nel caso lo utilizziamo per MCMCs)
	uniciStanzeOversegmentate = 2
	#1) primo controlla cella per cella 
	#2) unisce facendo una media pesata
	#3) non unisce le stanze, non fa assolutamente nulla, usato per mappe parziali se non voglio unire stanze
	if uniciStanzeOversegmentate ==1:
		#fa schifissimo come metodo(nel caso lo utilizziamo per MCMCs)

		#unione stanze
		#provo ad usare la distance transforme
		#dsg.disegna_distance_transform_e_stanze(distanceMap,stanze,colori, filepath = path_obj.filepath, savename = 'distance_and_stanze')
		
		#se esistono due spazi che sono collegati tramite un edge di una cella che ha un peso basso allora unisco quegli spazi
		plan.unisci_stanze_oversegmentate(plan_o)
		#cambio anche i colori
		dsg.disegna_spazi(plan_o.spazi, dsg.get_colors(plan_o.spazi), xmin, ymin, xmax, ymax,filepath = path_obj.filepath, savename = '13b_spazi_nuovo', format='png')	
	elif uniciStanzeOversegmentate == 2:
		#TODO: questo metodo funziona meglio del primo, vedere se vale la pena cancellare il primo
		#metodo molto simile a quello di Mura per il postprocessing		
		plan.postprocessing(plan_o, parametri_obj)
		dsg.disegna_spazi(plan_o.spazi, dsg.get_colors(plan_o.spazi), xmin, ymin, xmax, ymax,filepath = path_obj.filepath, savename = '13b_spazi_nuovo', format='png')	
	else:
		#se non voglio unire le stanze, ad esempio e' utile quando sto guardando le mappe parziali
		dsg.disegna_spazi(plan_o.spazi, dsg.get_colors(plan_o.spazi), xmin, ymin, xmax, ymax,filepath = path_obj.filepath, savename = '13b_spazi_nuovo', format='png')	
	#-------------------------------------------------------------------------------------	

	#-----------------------------separo spazi undersegmentati ---------------------------
	separaStanzeUndersegmentate=1
	if separaStanzeUndersegmentate ==1:
		plan.separaUndersegmentazione(plan_o, critical_points)
		
		prova_celle = []
		prova_celle_poligoni = []
		for spazio in plan_o.spazi:
			for celletta in spazio.cells:
				prova_celle.append(celletta.c)
				prova_celle_poligoni.append(celletta.cella)
		
		dsg.disegna_dbscan(clustersCelle, prova_celle, prova_celle_poligoni, xmin, ymin, xmax, ymax, edges, contours,filepath = path_obj.filepath, format='png', savename = '6b_DBSCAN_segmento')
		
	
	
	#-------------------------------------------------------------------------------------	

	
	#------------------------------PREDIZIONE GEOMETRICA----------------------------------	
	#da qui comincia la parte di predizione, io la sposterei in un altro file
	
	#ricavo gli spazi parziali
	cellette_out = plan_o.cellette_esterne
	spazi_parziali = []
	for s in plan_o.spazi:
		if s.parziale == True:
			spazi_parziali.append(s)	
	
	
	import copy	
	plan_o_2 = copy.deepcopy(plan_o)#copio l'oggetto per poter eseguire le azioni separatamente
	plan_o_3 = copy.deepcopy(plan_o)
	
	
	#metodo di predizione scelto. 
	#se MCMC == True si vuole predirre con il MCMC, altrimenti si fanno azioni geometriche molto semplici
	
	if par.MCMC ==True:
		# TODO:da eliminare, mi serviva solo per delle immagini e per controllare di aver fatto tutto giusto
		
		
		#TODO: MCMC rendilo una funzione privata o di un altro modulo, che se continui a fare roba qua dentro non ci capisci piu' nulla.
		
		#guardo quali sono gli extended che sto selezionando
		for index,s in enumerate(spazi_parziali):
			celle_di_altre_stanze = []
			for s2 in plan_o.spazi:
				if s2 !=s:
					for c in s2.cells:
						celle_di_altre_stanze.append(c)	
			
			#-----non serve(*)
			celle_circostanti = celle_di_altre_stanze + cellette_out #creo una lista delle celle circostanti ad una stanza
	
			a = sp.estrai_extended_da_spazio(s, plan_o.extended_segments, celle_circostanti)
			tot_segment = list(set(a))
			#dsg.disegna_extended_segments(tot_segment, walls,filepath = path_obj.filepath, format='png', savename = '7a_extended'+str(index))	
		
			#extended visti di una stanza parziale.
			b= sp.estrai_solo_extended_visti(s, plan_o.extended_segments, celle_circostanti)#estraggo solo le extended sicuramente viste
			tot_segment_visti = list(set(b))
			#dsg.disegna_extended_segments(tot_segment_visti, walls,filepath = path_obj.filepath, format='png', savename = '7b_extended'+str(index))	
			#-----fine(*)
			
			
			#computo MCMC sulla stanza in considerazione
			mcmc.computa_MCMC(s, plan_o, celle_di_altre_stanze, index,  xmin, ymin, xmax, ymax, path_obj)
		dsg.disegna_spazi(plan_o.spazi, dsg.get_colors(plan_o.spazi), xmin, ymin, xmax, ymax,filepath = path_obj.filepath, savename = '14_MCMC', format='png')	

	
	if par.azione_complessa == True:
		#1) FACCIO AZIONE SEMPLICE 1 PER AGGIUNGERE CELLE VISTE DAL LASER
		#2) FACCIO AZIONE COMPLESSA: nel quale vado a creare l'intero spazio degli stati fino ad una certa iterazione.
		
		#-------------------------------AZIONE GEOMETRICA 1)----------------------------------
		#-----AGGIUNGO CELLE OUT A CELLE PARZIALI SOLO SE QUESTE CELLE OUT SONO STATE TOCCANTE DAL BEAM DEL LASER
		
		for s in spazi_parziali:
			celle_confinanti = pgeom.estrai_celle_confinanti_alle_parziali(plan_o, s)#estraggo le celle confinanti alle celle interne parziali delle stanze parziali.
			print "le celle confinanti sono: ", len(celle_confinanti)	
		
			#unisco solo se le celle sono state toccate dal beam del laser
			celle_confinanti = plan.trova_celle_toccate_dal_laser_beam(celle_confinanti, immagine_cluster)
		
			#delle celle confinanti non devo unire quelle che farebbero sparire una parete.
			celle_confinanti = pgeom.elimina_celle_con_parete_vista(celle_confinanti, s)
		
		
			#faccio una prova per unire una cella che e' toccata dal beam del laser.
			print "le celle confinanti che vorrei aggiungere con l'azione geometrica 1 sono: ", len(set(celle_confinanti))
			if len(celle_confinanti)>0:
				#unisco la cella allo spazio
				for cella in celle_confinanti:
					if cella.vedo_frontiera == True:
						sp.aggiungi_cella_a_spazio(s, cella, plan_o)
				
		dsg.disegna_spazi(plan_o.spazi, dsg.get_colors(plan_o.spazi), xmin, ymin, xmax, ymax,filepath = path_obj.filepath, savename = '13c_azione_geom_1', format='png')
		
		#-----------------------------AZIONE COMPLESSA--------------------------------
		for index,s in enumerate(spazi_parziali):
			#estraggo le celle delle altre stanze
			celle_di_altre_stanze = plan.estrai_celle_di_altre_stanze(s,plan_o)
									
			#creo il mio spazio degli stati
			level= 1 #questa e la profondita' con la quale faccio la mia ricerca, oltre al secondo livello non vado a ricercare le celle.
			
			elementi = pgeom.estrai_spazio_delle_celle(s, plan_o, level)
			elementi = pgeom.elimina_spazi_sul_bordo_da_candidati(elementi, plan_o) #per ora non considero elementi che toccano il bordo, perche' tanto non voglio aggiungerli e mi ingrandiscono lo spazio degli stati per nulla.
			
			
			print "gli elementi sono:", len(elementi)
			print "-------inizio calcolo permutazioni-------"
			permutazioni = pgeom.possibili_permutazioni(elementi)
			print "-------fine calcolo permutazioni-------"
			print "il numero di permutazioni sono:", len(permutazioni)
			
			if len(permutazioni)>0:
				#per ogni permutazione degli elementi devo controllare il costo che avrebbe il layout con l'aggiunta di tutte le celle di quella permutazione.
				permutazioni_corrette = []
				score_permutazioni_corrette = []
				for indice,permutazione in enumerate(permutazioni):
					ok=False
				
					pgeom.aggiunge_celle_permutazione(permutazione, plan_o, s)#aggiungo le celle della permutazione corrente alla stanza
				
					#calcolo score
					score2_dopo = val.score2(s, plan_o, celle_di_altre_stanze)
					#calcolo penalita'
					penal1_dopo = val.penalita1(s)#piu' questo valore e' alto peggio e', valori prossimi allo zero indicano frome convesse.
					penal4_dopo = val.penalita4(s, plan_o, celle_di_altre_stanze)#conto il numero di extended che ci sono dopo aver aggiungere la permutazione, sfavorisce i gradini
				
					# il risultato potrebbe portare ad una stanza non Polygon, allora quella permutazione non e' valida 
					if type(s.spazio)== Polygon:
						ok = True
						permutazioni_corrette.append(permutazione)
						
						#elimino dalla lista delle permutazioni tutte quelle permutazioni che hanno gli stessi elementi
						for p in permutazioni:
							vuoto= list(set(p)-set(permutazione))
							if len(vuoto)==0 and len(p)== len(permutazione) and p!= permutazione:
								permutazioni.remove(p)
						
						#------------valuto il layout con permutazione aggiunta---------------
				
						score = val.score_function(score2_dopo, penal1_dopo, penal4_dopo)#non ancora implementata fino alla fine
						score_permutazioni_corrette.append(score)
				
						#----------------------fine valutazione-----------------------------------
					
						#disegno 
						#dsg.disegna_spazi(plan_o.spazi, dsg.get_colors(plan_o.spazi), xmin, ymin, xmax, ymax,filepath = path_obj.filepath, savename = 'permutazioni/14_stanza'+str(index)+'permutazioni_'+str(indice)+'_a', format='png')#TODO:DECOMMENTA SE NON SEI IN BATCH
					else:
						#elimina la permutazione perche' non e' valida
						permutazioni.remove(permutazione)
				
					#------			
					pgeom.elimina_celle_permutazione(permutazione, plan_o, s)
					if ok ==True:
						a=0
						#dsg.disegna_spazi(plan_o.spazi, dsg.get_colors(plan_o.spazi), xmin, ymin, xmax, ymax,filepath = path_obj.filepath, savename = 'permutazioni/14_stanza'+str(index)+'permutazioni_'+str(indice)+'_b', format='png')#TODO:DECOMMENTA SE NON SEI IN BATCH
					#------	
					print "permutazione", indice
			
				#valuto la permutazione che mi permette di minimizzare lo score
				if len(score_permutazioni_corrette)>0:
					#min_score = np.amin(score_permutazioni_corrette)
					max_score = np.amax(score_permutazioni_corrette)#ADDED
					#print "min_core", min_score
					print "max_score", max_score
					#posizione_permutazione = score_permutazioni_corrette.index(min_score)
					posizione_permutazione = score_permutazioni_corrette.index(max_score)#ADDED
					permutazione_migliore = permutazioni_corrette[posizione_permutazione]
			
					#ottenuto lo score migliore lo confronto con lo score del layout originale e guardo quale a' migliore
					#calcolo score del layout originale, senza previsioni
					score2_prima = val.score2(s, plan_o, celle_di_altre_stanze)
					penal1_prima = val.penalita1(s)#piu' questo valore e' alto peggio e', valori prossimi allo zero indicano frome convesse.	
					penal4_prima = val.penalita4(s, plan_o, celle_di_altre_stanze)#conto il numero di extended che ci sono prima di aggiungere la permutazione
					score_originale = val.score_function(score2_prima, penal1_prima, penal4_prima)#non ancora implementata fino alla fine
					print "score_originale", score_originale
			
					# if min_score<=score_originale:
# 						#preferisco fare una previsione
# 						permutazione_migliore = permutazione_migliore
# 						pgeom.aggiunge_celle_permutazione(permutazione_migliore, plan_o, s)
# 					else:
# 						#il layout originale ottenuto e' migliore di tutti gli altri, non faccio nessuana previsione per la stanza corrente
# 						pass
					if max_score >= score_originale:
						#preferisco fare una previsione
						permutazione_migliore = permutazione_migliore
						pgeom.aggiunge_celle_permutazione(permutazione_migliore, plan_o, s)
					else:
						#il layout originale ottenuto e' migliore di tutti gli altri, non faccio nessuana previsione per la stanza corrente
						pass
				else:
					#non ho trovato permutazioni che hanno senso, allora lascio tutto come e'
					pass
				
			
			#disegno le computazioni migliori TODO: momentaneo, solo perche' in questo momento uso solo la penalita' della convessita'		
			dsg.disegna_spazi(plan_o.spazi, dsg.get_colors(plan_o.spazi), xmin, ymin, xmax, ymax,filepath = path_obj.filepath, savename = '14_stanza'+str(index)+'azione_complessa', format='png')
			
			#---------------------------FINE AZIONE COMPLESSA-----------------------------		
			
# 			for r in permutazioni:
# 				print r
# 			print "\n\n"
# 			
# 			poligoni= []
# 			colori=[]
# 			pari =0
# 			for ele in elementi:
# 				poligoni.append(ele.cella)
# 				if pari%2 ==0:
# 					colori.append('#800000')
# 				else:
# 					colori.append('#A00000')
# 			print "il nuemro di poligoni all'esterno sono: ", len(poligoni)
# 			dsg.disegna_stanze(poligoni,colori , xmin, ymin, xmax, ymax,filepath = path_obj.filepath, savename = '15_poligoni_esterni_stanza'+str(index), format='png')	

			#-----------------------------AZIONE COMPLESSA--------------------------------
	#stampo il layout finale
	dsg.disegna_spazi(plan_o.spazi, dsg.get_colors(plan_o.spazi), xmin, ymin, xmax, ymax,filepath = path_obj.filepath, savename = '15_azione_complessa', format='png')

			
		
	if par.azioni_semplici==True:
		#------------------------------AZIONE GEOMETRICA 1)+2)--------------------------------	
	
		#-------------------------------AZIONE GEOMETRICA 1)----------------------------------
		#-----AGGIUNGO CELLE OUT A CELLE PARZIALI SOLO SE QUESTE CELLE OUT SONO STATE TOCCANTE DAL BEAM DEL LASER
		
		celle_candidate = []
		for s in spazi_parziali:
			celle_confinanti = pgeom.estrai_celle_confinanti_alle_parziali(plan_o, s)#estraggo le celle confinanti alle celle interne parziali delle stanze parziali.
			print "le celle confinanti sono: ", len(celle_confinanti)	
		
			#unisco solo se le celle sono state toccate dal beam del laser
			celle_confinanti = plan.trova_celle_toccate_dal_laser_beam(celle_confinanti, immagine_cluster)
		
			#delle celle confinanti non devo unire quelle che farebbero sparire una parete.
			celle_confinanti = pgeom.elimina_celle_con_parete_vista(celle_confinanti, s)
		
		
			#faccio una prova per unire una cella che e' toccata dal beam del laser.
			if len(celle_confinanti)>0:
				#unisco la cella allo spazio
				for cella in celle_confinanti:
					if cella.vedo_frontiera == True:
						sp.aggiungi_cella_a_spazio(s, cella, plan_o)
				
		dsg.disegna_spazi(plan_o.spazi, dsg.get_colors(plan_o.spazi), xmin, ymin, xmax, ymax,filepath = path_obj.filepath, savename = '13c_azione_geom_1', format='png')	

		#-------------------------------AZIONE GEOMETRICA 2)-----------------------------------	
		#--UNISCO LE CELLE IN BASE ALLE PARETI CHE CONDIVIDONO CON ALTRE STANZE 
	
		for s in spazi_parziali:
			#estraggo le celle out che confinano con le celle parziali
			celle_confinanti = pgeom.estrai_celle_confinanti_alle_parziali(plan_o, s)#estraggo le celle confinanti alle celle interne parziali delle stanze parziali.
			print "le celle confinanti sono: ", len(celle_confinanti)
		
			#delle celle confinanti appena estratte devo prendere solamente quelle che hanno tutti i lati supportati da una extended line
			celle_confinanti = pgeom.estrai_celle_supportate_da_extended_segmement(celle_confinanti, s, plan_o.extended_segments)
		
			#delle celle confinanti non devo unire quelle che farebbero sparire una parete.
			celle_confinanti = pgeom.elimina_celle_con_parete_vista(celle_confinanti, s)
		
		
			#unisco solo quelle selezionate
			#TODO questa parte e' da cancellare
			if len(celle_confinanti)>0:
				#unisco la cella allo spazio
				for cella in celle_confinanti:
					sp.aggiungi_cella_a_spazio(s, cella, plan_o)
		
		dsg.disegna_spazi(plan_o.spazi, dsg.get_colors(plan_o.spazi), xmin, ymin, xmax, ymax,filepath = path_obj.filepath, savename = '13e_azione_geom_1_piu_geom_2', format='png')	


		#----------------------------------FINE 1)+2)-----------------------------------------
		
	
		#----------------------------FACCIO SOLO AZIONE GEOM 2)-------------------------------
		#questa azione la faccio su una copia di plan
	
		#ricavo gli spazi parziali dalla copia di plan_o che sono esattamente una copia di spazi_parziali precedente.
		cellette_out = plan_o_2.cellette_esterne
		spazi_parziali = []
		for s in plan_o_2.spazi:
			if s.parziale == True:
				spazi_parziali.append(s)
		
		cella_prova =None#eli
		spp = None#eli
		for s in spazi_parziali:
			#estraggo le celle out che confinano con le celle parziali
			celle_confinanti = pgeom.estrai_celle_confinanti_alle_parziali(plan_o_2, s)#estraggo le celle confinanti alle celle interne parziali delle stanze parziali.
			print "le celle confinanti sono: ", len(celle_confinanti)
		
			#delle celle confinanti appena estratte devo prendere solamente quelle che hanno tutti i lati supportati da una extended line
			celle_confinanti = pgeom.estrai_celle_supportate_da_extended_segmement(celle_confinanti, s, plan_o_2.extended_segments)
			print "le celle confinanti sono2: ", len(celle_confinanti)
			#delle celle confinanti non devo unire quelle che farebbero sparire una parete.
			celle_confinanti = pgeom.elimina_celle_con_parete_vista(celle_confinanti, s)
			print "le celle confinanti sono3: ", len(celle_confinanti)
			#unisco solo quelle selezionate
			#TODO questa parte e' da cancellare
			if len(celle_confinanti)>0:
				#unisco la cella allo spazio
				for cella in celle_confinanti:
					sp.aggiungi_cella_a_spazio(s, cella, plan_o_2)
					cella_prova = cella#elimina
					spp = s#elimina
		
		dsg.disegna_spazi(plan_o_2.spazi, dsg.get_colors(plan_o_2.spazi), xmin, ymin, xmax, ymax,filepath = path_obj.filepath, savename = '13d_azione_geom_2', format='png')	
		#----------------------------------FINE SOLO AZIONE GEOM 2)--------------------------
		
	
	
		
	#------------------------CREO PICKLE--------------------------------------------------
	#creo i file pickle per il layout delle stanze
	print("creo pickle layout")
	pk.crea_pickle((stanze, clustersCelle, estremi, colori, spazi, stanze_reali, colori_reali), path_obj.filepath_pickle_layout)
	print("ho finito di creare i pickle del layout")
	#creo i file pickle per il grafo topologico
	print("creo pickle grafoTopologico")
	pk.crea_pickle((stanze, clustersCelle, estremi, colori), path_obj.filepath_pickle_grafoTopologico)
	print("ho finito di creare i pickle del grafo topologico")
	
	#-----------------------CALCOLO ACCURACY----------------------------------------------
	#L'accuracy e' da controllare, secondo me non e' corretta.
	
	
	if par.mappa_completa:
		#funzione per calcolare accuracy fc e bc
		print "Inizio a calcolare metriche"
		results, stanze_gt = ac.calcola_accuracy(path_obj.nome_gt,estremi,stanze_reali, path_obj.metricMap,path_obj.filepath, parametri_obj.flip_dataset)	
		#results, stanze_gt = ac.calcola_accuracy(path_obj.nome_gt,estremi,stanze, path_obj.metricMap,path_obj.filepath, parametri_obj.flip_dataset)	

		if par.DISEGNA:
			dsg.disegna_grafici_per_accuracy(stanze, stanze_gt, filepath = path_obj.filepath, format='png')
		print "Fine calcolare metriche"
	
	else:
		#setto results a 0, giusto per ricordarmi che non ho risultati per le mappe parziali 
		results = 0
		stanze_gt = ac.get_stanze_gt(path_obj.nome_gt, estremi, flip_dataset = False)
		if par.DISEGNA:
			#raccolgo i poligoni
			stanze_acc = []
			for spazio in plan_o.spazi:
				stanze_acc.append(spazio.spazio)
			dsg.disegna_grafici_per_accuracy(stanze_acc, stanze_gt, filepath = path_obj.filepath, format='png')
	
	#in questa fase il grafo non e' ancora stato classificato con le label da dare ai vai nodi.
	#-------------------------------------------------------------------------------------	
	#creo il file xml dei parametri 
	par.to_XML(parametri_obj, path_obj)
	
	
	
	#-------------------------prova transitional kernels----------------------------------
	
	#splitto una stanza e restituisto la nuova lista delle stanze
	#stanze, colori = tk.split_stanza_verticale(2, stanze, colori,estremi) 
	#stanze, colori = tk.split_stanza_orizzontale(3, stanze, colori,estremi)
	#stanze, colori = tk.slit_all_cell_in_room(spazi, 1, colori, estremi) #questo metodo e' stato fatto usando il concetto di Spazio, dunque fai attenzione perche' non restituisce la cosa giusta.
	#stanze, colori = tk.split_stanza_reverce(2, len(stanze)-1, stanze, colori, estremi) #questo unisce 2 stanze precedentemente splittate, non faccio per ora nessun controllo sul fatto che queste 2 stanze abbiano almeno un muro in comune, se sono lontani succede un casino

	#-----------------------------------------------------------------------------------

	
	#-------------------------MAPPA SEMANTICA-------------------------------------------
	'''
	#in questa fase classifico i nodi del grafo e conseguentemente anche quelli della mappa.
	
	#gli input di questa fase non mi sono ancora molto chiari 
	#per ora non la faccio poi se mi serve la copio/rifaccio, penso proprio sia sbagliata.

	#stanze ground truth
	(stanze_gt, nomi_stanze_gt, RC, RCE, FCES, spaces, collegate_gt) = sema.get_stanze_gt(nome_gt, estremi)

	#corrispondenze tra gt e segmentate (backward e forward)
	(indici_corrispondenti_bwd, indici_gt_corrispondenti_fwd) = sema.get_corrispondenze(stanze,stanze_gt)

	#creo xml delle stanze segmentate
	id_stanze = sema.crea_xml(nomeXML,stanze,doorsVertices,collegate,indici_gt_corrispondenti_fwd,RCE,nomi_stanze_gt)

	#parso xml creato, va dalla cartella input alla cartella output/xmls, con feature aggiunte
	xml_output = sema.parsa(dataset_name, nomeXML)


	#classifico
	predizioniRCY = sema.classif(dataset_name,xml_output,'RC','Y',30)
	predizioniRCN = sema.classif(dataset_name,xml_output,'RC','N',30)
	predizioniFCESY = sema.classif(dataset_name,xml_output,'RCES','Y',30)
	predizioniFCESN = sema.classif(dataset_name,xml_output,'RCES','N',30)

	#creo mappa semantica segmentata e ground truth e le plotto assieme
	
	sema.creaMappaSemantica(predizioniRCY, G, pos, stanze, id_stanze, estremi, colori, clustersCelle, collegate)
	sema.creaMappaSemanticaGt(stanze_gt, collegate_gt, RC, estremi, colori)
	plt.show()
	sema.creaMappaSemantica(predizioniRCN, G, pos, stanze, id_stanze, estremi, colori, clustersCelle, collegate)
	sema.creaMappaSemanticaGt(stanze_gt, collegate_gt, RC, estremi, colori)
	plt.show()
	sema.creaMappaSemantica(predizioniFCESY, G, pos, stanze, id_stanze, estremi, colori, clustersCelle, collegate)
	sema.creaMappaSemanticaGt(stanze_gt, collegate_gt, FCES, estremi, colori)
	plt.show()
	sema.creaMappaSemantica(predizioniFCESN, G, pos, stanze, id_stanze, estremi, colori, clustersCelle, collegate)
	sema.creaMappaSemanticaGt(stanze_gt, collegate_gt, FCES, estremi, colori)
	plt.show()
	'''
	#-----------------------------------------------------------------------------------
	
	
	print "to be continued..."
	return results
Example #2
0
def computa_MCMC(stanza, plan_o, celle_di_altre_stanze, index_stanza,  xmin, ymin, xmax, ymax, path_obj):
	'''
	'''
	celle_out = plan_o.cellette_esterne
	celle_confinanti = pgeom.estrai_celle_confinanti_alle_parziali(plan_o, stanza) #insieme iniziale delle celle che potrei aggiungere
	#elimino quelle celle candidate che mi andrebbero ad eliminare una parete gia' vista
	celle_confinanti, celle_elimina_pareti = pgeom.elimina_celle_con_parete_vista(celle_confinanti, stanza)
	
	#---------------------------------PASSI----------------------------
	
	C_unite = []#insieme delle celle unite durante l'algoritmo	
	indice = 0
	n_iter =1
	count = 0#serve per calcolare la probabilita', piu' siamo avanti con le iterazioni meno probabilita' ho di aggiungere una cella.
	while(len(celle_confinanti)>0 and count<=2):
		print "stanza n ", index_stanza	
		
		for index_cella,cella in enumerate(set(celle_confinanti)):	
			#1) computo la funzione di costo iniziale del layout
			penal1_prima = val.penalita1(stanza)
			penal2_prima = val.penalita2(stanza, plan_o, celle_di_altre_stanze)
		
			penal4_prima = val.penalita4(stanza, plan_o, celle_di_altre_stanze)
			print "prima di aggiungere_pen1", penal1_prima
			print "prima di aggiungere_pen2", penal2_prima
			print "prima di aggiungere_pen4", penal4_prima
			
			cost_function_prima = val.cost_funzion(penal1_prima, penal2_prima, penal4_prima)
			b_e_prima = val.Boltzman_equation(cost_function_prima)
			print "costo_prima = ", cost_function_prima
			print "boltzman eq prima= ", b_e_prima
		
			#2)unisco la cella -----------------------------------------------------------
			sp.aggiungi_cella_a_spazio(stanza, cella, plan_o)
			#C_unite.append(cella)
			#crea cartella per visualizzare quello che stai facendo
			salva_risultati_parziali(plan_o, path_obj, index_stanza, index_cella + indice, xmin, ymin, xmax, ymax)
			#-----------------------------------------------------------------------------
		
			#3)ricomputo la funzione costo con la cella unita
			penal1_dopo= val.penalita1(stanza)
			penal2_dopo= val.penalita2(stanza, plan_o, celle_di_altre_stanze)
		
			penal4_dopo = val.penalita4(stanza, plan_o, celle_di_altre_stanze)
			print "dopo aver aggiunto_pen1", penal1_dopo
			print "dopo aver aggiunto_pen2", penal2_dopo
			print "dopo aver aggiunto_pen4", penal4_dopo
			cost_function_dopo = val.cost_funzion(penal1_dopo, penal2_dopo, penal4_dopo)
			b_e_dopo= val.Boltzman_equation(cost_function_dopo)
			print "costo_dopo = ", cost_function_dopo
			print "boltzman eq dopo= ", b_e_dopo
			
			n_iter +=1 #serve solo per salvare le immagini in sequenza
			
			#valuto con acceptance probability------------------------------------
			acc = min(1, b_e_prima/b_e_dopo)
			print "b_e_prima/b_e_dopo = ", b_e_prima/b_e_dopo
			print "acc ", acc
			if random_coin(acc):
				#accetto la mossa e vado avanti
				C_unite.append(cella)
			else:
				#non accetto la mossa
				sp.elimina_cella_da_spazio(stanza, cella, plan_o)
			
			
	
		if len(C_unite)>=0 :
			#le iterazioni successive vogliono come spazio delle soluzione tutte le celle confinanti a quelle appena aggiunte.
			celle_confinanti =[]
			celle_confinanti = pgeom.estrai_celle_esterne_confinanti_con_lista_celle(plan_o, C_unite)
			#elimino quelle celle candidate che mi andrebbero ad eliminare una parete gia' vista
			celle_confinanti, celle_elimina_pareti = pgeom.elimina_celle_con_parete_vista(celle_confinanti, stanza)
			#svuoto la lista
			C_unite = []
			
		indice = n_iter #serve solo per salvare le immagini in sequenza
		count += 1