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)
#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)
dsg.disegna_canny(canny, filepath=path_obj.filepath)
dsg.disegna_hough(img_rgb, walls, filepath=path_obj.filepath)
lines = lay.flip_lines(walls, img_rgb.shape[0] - 1)
walls = lay.crea_muri(lines)
if par.DISEGNA:
#disegno linee
dsg.disegna_segmenti(walls) #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)
if par.DISEGNA:
dsg.disegna_contorno(vertici,
xmin,
ymin,
xmax,
ymax,
filepath=path_obj.filepath)
#-------------------------------------------------------------------------------------
#---------------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')
#-------------------------------------------------------------------------------------
#---------------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
#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")
#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)
#gestire gli outliers
#in sostanza devo unire al cluster piu' vicino ogni segmento di outlier
#lay.set_cluster_spaziale_to_outliers(walls, outliers, segmenti_rappresentanti)
# print cluster_spaziali
# print len(cluster_spaziali)
# print len(set(cluster_spaziali))
#
# angolari = []
# for ang in set(cluster_angolari):
# row =[]
# for s in walls:
# if s.cluster_angolare == ang:
# row.append(s)
# angolari.append(row)
#
# cluster=[]
# for s in angolari[0]:
# cluster.append(s.cluster_spaziale)
# print len(set(cluster))
#
# cluster=[]
# for s in angolari[1]:
# cluster.append(s.cluster_spaziale)
# print len(set(cluster))
if par.DISEGNA:
dsg.disegna_cluster_spaziali(cluster_spaziali,
walls,
filepath=path_obj.filepath)
dsg.disegna_cluster_mura(cluster_mura,
walls,
filepath=path_obj.filepath,
savename='5d_cluster_mura')
#-------------------------------------------------------------------------------------
#-------------------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)
#-------------------------------------------------------------------------------------
#-------------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)
#-------------------------------------------------------------------------------------
#----------------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)
else:
colori = dsg.get_colors(clustersCelle)
#-------------------------------------------------------------------------------------
#------------------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)
#-------------------------------------------------------------------------------------
#--------------------------------fine layout------------------------------------------
#------------------------------GRAFO TOPOLOGICO---------------------------------------
#costruisco il grafo
(stanze_collegate, doorsVertices, distanceMap, points,
b3) = 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')
#------------------------------------------------------------------------------------
if par.DISEGNA:
dsg.disegna_distance_transform(distanceMap, filepath=path_obj.filepath)
dsg.disegna_medial_axis(points, b3, filepath=path_obj.filepath)
dsg.plot_nodi_e_stanze(colori,
estremi,
G,
pos,
stanze,
stanze_collegate,
filepath=path_obj.filepath)
#-----------------------------fine GrafoTopologico------------------------------------
#-------------------------------------------------------------------------------------
#DA QUI PARTE IL NUOVO PEZZO
#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)
#faccio una prova a caso per settare una cella come parziale
for s in spazi:
for celletta in s.cells:
celletta.set_celletta_parziale(True)
# contorno e' il contorno dell'intera mappa
for s in spazi:
print s.cells[0].parziale
exit()
#spazi = sp.trova_spazi_parziali(spazi)
dsg.disegna_spazi(spazi,
colori,
xmin,
ymin,
xmax,
ymax,
filepath=path_obj.filepath,
savename='13_spazi')
#------------------------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)
if par.DISEGNA:
dsg.disegna_grafici_per_accuracy(stanze,
stanze_gt,
filepath=path_obj.filepath)
print "Fine calcolare metriche"
else:
#setto results a 0, giusto per ricordarmi che non ho risultati per le mappe parziali
results = 0
#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
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)
#------------------1.1_CANNY E HOUGH PER TROVARE MURI---------------------------------
walls, canny = lay.start_canny_ed_hough(
thresh1, parametri_obj.minVal, parametri_obj.maxVal, parametri_obj.rho,
parametri_obj.theta, parametri_obj.thresholdHough,
parametri_obj.minLineLength, parametri_obj.maxLineGap)
if par.DISEGNA:
#disegna mappa iniziale, canny ed hough
dsg.disegna_map(img_rgb, filepath=path_obj.filepath)
dsg.disegna_canny(canny, filepath=path_obj.filepath)
dsg.disegna_hough(img_rgb, walls, filepath=path_obj.filepath)
lines = lay.flip_lines(walls, img_rgb.shape[0] - 1)
walls = lay.crea_muri(lines)
if par.DISEGNA:
#disegno linee
dsg.disegna_segmenti(walls) #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.minVal,
parametri_obj.maxVal,
xmin,
xmax,
ymin,
ymax,
path_obj.metricMap,
filepath=path_obj.filepath,
m=parametri_obj.m)
if par.DISEGNA:
dsg.disegna_contorno(vertici,
xmin,
ymin,
xmax,
ymax,
filepath=path_obj.filepath)
#-------------------------------------------------------------------------------------
#---------------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)
#-------------------------------------------------------------------------------------
#---------------1.5_CLUSTER SPAZIALI--------------------------------------------------
cluster_spaziali = lay.cluster_spaz(parametri_obj.minLateralSeparation,
walls,
filepath=path_obj.filepath)
if par.DISEGNA:
dsg.disegna_cluster_spaziali(cluster_spaziali,
walls,
filepath=path_obj.filepath)
#-------------------------------------------------------------------------------------
#-------------------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)
#-------------------------------------------------------------------------------------
#-------------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:
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)
else:
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)
#-------------------------------------------------------------------------------------
#------------------CREO LE MATRICI L, D, D^-1, ED M = D^-1 * L------------------------
(matrice_l, matrice_d, matrice_d_inv, X) = lay.crea_matrici(celle)
#-------------------------------------------------------------------------------------
#----------------DBSCAN PER TROVARE CELLE NELLA STESSA STANZA-------------------------
clustersCelle = lay.DB_scan(parametri_obj.eps,
parametri_obj.minPts,
X,
celle,
celle_poligoni,
xmin,
ymin,
xmax,
ymax,
edges,
contours,
filepath=path_obj.filepath)
#questo va disegnato per forza perche' restituisce la lista dei colori
colori, fig, ax = dsg.disegna_dbscan(clustersCelle,
celle,
celle_poligoni,
xmin,
ymin,
xmax,
ymax,
edges,
contours,
filepath=path_obj.filepath)
#-------------------------------------------------------------------------------------
#------------------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)
#-------------------------------------------------------------------------------------
#------fine layout--------------------------------------------------------------------
#funzione per eliminare stanze che sono dei buchi interni
print 'PLEASE CAMBIARE QUESTA COSA :|'
#stanze = ac.elimina_stanze(stanze,estremi)
#funzione per calcolare accuracy fc e bc
print "Inizio a calcolare metriche"
results = ac.calcola_accuracy(path_obj.nome_gt, estremi, stanze,
path_obj.metricMap, path_obj.filepath,
parametri_obj.flip_dataset)
print "Fine calcolare metriche"
#creo i file pickle per il layout delle stanze
print("creo pickle layout")
pk.crea_pickle((stanze, clustersCelle, estremi, colori, spazi),
path_obj.filepath_pickle_layout)
#-------------------------------------------------------------------------------------
#------------------------------GRAFO TOPOLOGICO---------------------------------------
#costruisco il grafo
(G, pos, collegate,
doorsVertices) = gtop.get_grafo(path_obj.metricMap,
stanze,
estremi,
colori,
filepath=path_obj.filepath)
#creo i file pickle per il grafo topologico
print("creo pickle grafoTopologico")
pk.crea_pickle((stanze, clustersCelle, estremi, colori),
path_obj.filepath_pickle_grafoTopologico)
#in questa fase il grafo non e' ancora stato classificato con le label da dare ai vai nodi.
#-------------------------------------------------------------------------------------
par.to_XML(parameteri_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
