def Q_split(edge_in_comune):
'''
calcola il Q_split come definito nel paper di mura. rappresenta la qualita' dello splitting
'''
num = 0
den = 0
for e in edge_in_comune:
num = num + (e.weight * sg.lunghezza(e.x1, e.y1, e.x2, e.y2))
den = den + sg.lunghezza(e.x1, e.y1, e.x2, e.y2)
q_split = num / den
return q_split
def indici_da_eliminare(num_min, lunghezza_min, cluster_centers, lista_muri):
'''
trova gli indici di posizione dei cluster angolari causati da un numero di muri < num_min, e con ognuno di questi muri con
lunghezza < lunghezza_min. Questi cluster angolari sono quindi causati da muri che possono essere considerati rumore, quindi elimino
i cluster angolari e i rispetivi muri (indice cluster angolare in cluster_centers = indice muro in lista_muri)
'''
indexes = []
for c in set(cluster_centers):
if (
cluster_centers.count(c) <= num_min
): #se il cluster angolare compare meno di tot volte nella lista cluster_centers
lunghezze = []
candidati = []
for index, c1 in enumerate(cluster_centers):
if c == c1: #per ogni cluster uguale al cluster in questione (con meno di tot occorrenze)
candidati.append(index)
#prendo il rispettivo muro (index cluster_centers = index lista_muri)
m = lista_muri[index]
lunghezze.append(sg.lunghezza(m.x1, m.y1, m.x2, m.y2))
if tutti_corti(lunghezze, lunghezza_min
): #se tutte le lunghezze sono <= lunghezza_min
for i in candidati:
indexes.append(i)
del candidati[:]
del lunghezze[:]
diag = indici_diagonali(cluster_centers)
indexes = indexes + diag
return set(indexes)
def cluster_ang(h, minOffset, walls, num_min = 3, lunghezza_min = 3, diagonali= True): ''' crea i cluster angolari ''' #creo i cluster centers tramite mean shift cluster_centers = ms.mean_shift(h, minOffset, walls) #ci sono dei cluster angolari che sono causati da pochi e piccoli line_segments, che sono solamente rumore. Questi cluster li elimino dalla lista cluster_centers ed elimino anche i rispettivi segmenti dalla walls. indici = ms.indici_da_eliminare(num_min, lunghezza_min, cluster_centers, walls, diagonali) #ora che ho gli indici di clusters angolari e di muri da eliminare, elimino da walls e cluster_centers, partendo dagli indici piu alti for i in sorted(indici, reverse=True): del walls[i] del cluster_centers[i] #ci sono dei cluster che si somigliano ma non combaciano per una differenza infinitesima, e non ho trovato parametri del mean shift che rendano il clustering piu' accurato di cosi', quindi faccio una media normalissima, tanto la differenza e' insignificante. unito = ms.unisci_cluster_simili(cluster_centers) while(unito): unito = ms.unisci_cluster_simili(cluster_centers) #assegno i cluster ai muri di walls walls = sg.assegna_cluster_angolare(walls, cluster_centers) #creo lista di cluster_angolari cluster_angolari = [] for muro in walls: cluster_angolari.append(muro.cluster_angolare) return (indici, walls, cluster_angolari)
def mean_shift(h, minOffset, walls):
'''
calcola i center_clusters tramite mean_shift. Vengono clusterizzate le inclinazioni in radianti dei muri
'''
#per ogni muro setto l'inclinazione
for muro in walls:
d = sg.inclinazione_radianti(muro.x1, muro.y1, muro.x2, muro.y2)
if (d < 0):
d += math.pi
elif d > math.pi:
d -= math.pi
muro.set_direction(d)
#disegna(walls)
#creo lista delle inclinazioni degli edges
directions = []
for muro in walls:
directions.append(muro.direction)
#inizialmente i cluster centers sono tutte le inclinazioni
cluster_centers = directions[:]
new_cluster_centers = calcola_new_cluster_centers(h, cluster_centers,
directions)
max_diff = massima_differenza(cluster_centers, new_cluster_centers)
cluster_centers = new_cluster_centers[:]
del new_cluster_centers[:]
while (max_diff > minOffset):
new_cluster_centers = calcola_new_cluster_centers(
h, cluster_centers, directions)
max_diff = massima_differenza(cluster_centers, new_cluster_centers)
cluster_centers = new_cluster_centers[:]
del new_cluster_centers[:]
return cluster_centers
def crea_muri(linee): ''' trasforma le linee in oggetti di tipo Segmento, e ne restituisce la lista. ''' walls = [] for muro in linee: x1 = float(muro[0]) y1 = float(muro[1]) x2 = float(muro[2]) y2 = float(muro[3]) walls.append(sg.Segmento(x1,y1,x2,y2)) return walls
def cluster_spaz(minLateralSeparation, walls,filepath = '.'): ''' crea i cluester spaziali ''' #setto i cluster spaziali a tutti i muri di walls walls = sg.spatialClustering(minLateralSeparation, walls) #creo lista di cluster spaziali cluster_spaziali = [] for muro in walls: cluster_spaziali.append(muro.cluster_spaziale) #disegno cluster spaziali(posso anche eliminarlo, a me non servono tanto i disegni) #---- quarto plot --> disegno i cluster spaziali relativi ai segmenti #dsg.disegna_cluster_spaziali(cluster_spaziali, walls,filepath = filepath) return cluster_spaziali
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 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)
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)
print "lines", len(lines), len(walls)
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)
(contours, vertici) = lay.contorno_esterno_versione_tre(img_rgb)
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 #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")
#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)
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, 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)
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)
#-------------------------------------------------------------------------------------
#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)
#exit()
#--------------------------------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
#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
#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)
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')
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)
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, savename='0a_frontiere')
#-------------------------------------------------------------------------------------
#---------------------------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')
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')
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')
#-------------------------------------------------------------------------------------
#------------------------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)
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)#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
#ora che ho un insieme di cluster relativi ai muri voglio andare ad unire quelli molto vicini
#ottengo i rappresentanti dei cluster
segmenti_rappresentanti = lay.get_rappresentanti(walls, cluster_mura)
if par.DISEGNA:
dsg.disegna_segmenti(segmenti_rappresentanti, savename = "5c_segmenti_rappresentanti")
#classifico i rappresentanti
#qui va settata la soglia con cui voglio separare i cluster
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)
'''
#creo lista di cluster spaziali
cluster_spaziali = []
for muro in walls:
if muro.cluster_spaziale !=None:
cluster_spaziali.append(muro.cluster_spaziale)
for spaz in list(set(cluster_spaziali)):
#raccolgo i cluster muri che hanno stesso cluster spaziale
cluster_mura_uguali = []
for segmento in segmenti_rappresentanti:
if segmento.cluster_spaziale == spaz:
cluster_mura_uguali.append(segmento.cluster_muro)
cluster_mura_uguali = list(set(cluster_mura_uguali))
for segmento in walls:
if segmento.cluster_muro in cluster_mura_uguali:
segmento.set_cluster_spaziale(spaz)
dsg.disegna_cluster_mura(cluster_mura, walls,filepath = path_obj.filepath, savename= '5d_cluster_mura')
'''
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)
print "la lunghezza diextended segments: ", len(set(extended_segments))
print "i cluster spaziali sono: ", len(set(cluster_spaziali))
print "extended_lines: ", len(set(extended_lines))
exit()
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--------------------------------------------------------------------
#adesso questo mi conviene calcolarlo alla fine di tutto, dato che ho spostato il calcolo delle stanze reali dopo aver calcolato il grafo topologico
'''
#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, 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)
print "Fine calcolare metriche"
'''
#-------------------------------------------------------------------------------------
#------------------------------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)
#------------------------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.
#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, 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"
#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 separaUndersegmentazione(plan_o, critical_points, parametri_obj, path_obj,
xmin, ymin, xmax, ymax):
'''
permette di separare le stanze undersegmentate.
in primis una stanza e' stata undersegmentata se esistono almeno 2 celle che la compongono che si toccano ed il peso di quella cella e' superiore a 0.3.
'''
print "il numero di critical points e '", len(critical_points)
stanze = plan_o.spazi
conta = 0
#in sostanza vado a chiudere le porte
for stanza in stanze:
#queste due liste mi servono per ricordarmi il vecchio valore dell'edge per poi risettarlo
vecchio_valore_edge = [] #lista dei velori numerici dei singoli edge
edge_modificato = [] #oggetto di tipo edge
cellette_stanza = stanza.cells
trovato = False #controllo per vedere se la stanza e' stata undersegmentata
for c1 in cellette_stanza:
for c2 in cellette_stanza:
if fc.adiacenti(c1.c, c2.c) and c1 != c2:
if (
fc.edge_comune(c1.c, c2.c)[0].weight >= 0.3
): #il bordo in comune non deve essere supportato da segmenti(se questo avviene in una stanza significa che e' stata eliminata una parete che in teoria era stata gia' vista)
trovato = True
if trovato == True:
#in questo punto va lo splitting della stanza
#1) trovo l'edge su cui si trova il critical point
#2) setto un peso alto su quell'edge e ricompunto DBSCAN
porte_colleganti = []
celle_collegate = []
for index, p in enumerate(critical_points):
coppia = []
for celletta in cellette_stanza:
if (celletta.cella.boundary).distance(
Point(p[0], p[1])
) < 0.2: # se il contorno della cella dista meno di 0,2 dal critical points(nel caso non basti aumentare questo parametro )
porte_colleganti.append(Point(p[0], p[1]))
if celletta not in coppia:
coppia.append(celletta)
if len(coppia) == 2:
if fc.adiacenti(coppia[0].c,
coppia[1].c) and coppia[0] != coppia[1]:
print "ho trovato le 2 celle che si toccano per questo pixel ", index
edge_comune = fc.edge_comune(coppia[0].c,
coppia[1].c)[0]
#assegno un peso alto a quell'edge (e come se ci fosse la porta chiusa)
for edge1 in coppia[0].c.bordi:
if edge1 == edge_comune:
print "la lunghezza del segmento e' :", sg.lunghezza(
edge1.x1, edge1.y1, edge1.x2, edge1.y2)
edge_modificato.append(
edge1
) #mi salvo il vecchio valore dell'edge
vecchio_valore_edge.append(edge1.weight)
edge1.set_weight(1)
for edge2 in coppia[1].c.bordi:
if edge2 == edge_comune:
edge2.set_weight(1)
#ora che ho chiuso le porte posso ricomputare DBSCAN
#TODO: controllare questa parte da qui in giu', che non vengono settate bene le cose(frontiere etc)
#in questo punto adesso per ogni stanza che ne ha bisogno ricomputo DBSCAN come all'inizio
#metti qui tutto il DBSCAN
#------------------CREO LE MATRICI L, D, D^-1, ED M = D^-1 * L------------------------
#ci si riferisce alla stanza corrente presa in consierazione
celle = []
celle_poligoni = []
for celletta in stanza.cells:
celle.append(celletta.c)
celle_poligoni.append(celletta.cella)
(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)
print "la lunghezza di clustersCelle e' ", len(clustersCelle)
colori = dsg.get_colors(clustersCelle)
stanze, spazi_nuovi = lay.crea_spazio(clustersCelle,
celle,
celle_poligoni,
colori,
xmin,
ymin,
xmax,
ymax,
filepath=path_obj.filepath)
#elimino la vecchia stanza da plan_o ed inserisco quelle nuove
print "il numero di stanze appena create e' ", len(spazi_nuovi)
#TODO: controllare che le stanze appena create siano correntte(intendo le celle parziali etc)
elimina_spazio(stanza, plan_o)
for spaz in spazi_nuovi:
aggiungi_spazio(spaz, plan_o)
#-----finito DBScan rimetto a posto i valori degli edge(riapro le porte)-----------------
for index, e in enumerate(edge_modificato):
for celletta in cellette_stanza:
edge_celletta = celletta.c.bordi
for eb in edge_celletta:
if e == eb:
e.set_weight(vecchio_valore_edge[index])
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.
#-------------------------------------------------------------------------------------
#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)#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
def extractLayout(parametri_obj, path_obj):
start_time_main = time.time()
# load parameters
parametri_obj.minLateralSeparation = int(
round(parametri_obj.minLateralSeparationFactor /
parametri_obj.imageScale))
parametri_obj.minLineLength = int(
round(parametri_obj.minLineLengthFactor / parametri_obj.imageScale))
parametri_obj.maxLineGap = int(
round(parametri_obj.maxLineGapFactor / parametri_obj.imageScale))
parametri_obj.sogliaLateraleClusterMura = int(
round(parametri_obj.sogliaLateraleClusterMuraFactor /
parametri_obj.imageScale))
#----------------------------1.0_COMPUTING LAYOUT----------------------------------
# read the original image
img_rgb = cv2.imread(path_obj.metricMap)
img_ini = img_rgb.copy()
y_span, x_span, channels = img_rgb.shape
# cleaning
ret, thresh1 = cv2.threshold(img_rgb, parametri_obj.cv2thresh, 250,
cv2.THRESH_BINARY)
#------------------1.1_WALL IDENTIFICATION WITH CANNY AND HOUGH---------------------------------
walls, canny = lay.start_canny_ed_hough(thresh1, parametri_obj)
lines = lay.flip_lines(walls, img_rgb.shape[0] - 1)
old_walls = walls
walls = lay.crea_muri(lines)
#------------1.2_IDENTIFICATION OF WALL EXTREMES-----------------------------------
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
# if drawing is enabled, draw the initial map and the results of the application of Canny and Hough
if par.DISEGNA:
dsg.disegna_map(img_rgb,
filepath=path_obj.actualOutputFolder,
format='png',
x_span=x_span,
y_span=y_span,
xmin=xmin,
xmax=xmax,
ymin=ymin,
ymax=ymax)
dsg.disegna_canny(canny,
filepath=path_obj.actualOutputFolder,
format='png',
x_span=x_span,
y_span=y_span,
xmin=xmin,
xmax=xmax,
ymin=ymin,
ymax=ymax)
dsg.disegna_hough(img_rgb,
old_walls,
filepath=path_obj.actualOutputFolder,
format='png',
x_span=x_span,
y_span=y_span,
xmin=xmin,
xmax=xmax,
ymin=ymin,
ymax=ymax)
# if drawing is enabled, draw the image with the identified walls
if par.DISEGNA:
#disegno linee
dsg.disegna_segmenti(walls,
filepath=path_obj.actualOutputFolder,
format='png',
x_span=x_span,
y_span=y_span,
xmin=xmin,
xmax=xmax,
ymin=ymin,
ymax=ymax)
#---------------1.3_EXTERNAL CONTOUR--------------------------------------------------
(contours, vertici) = lay.contorno_esterno_versione_tre(img_rgb)
if par.DISEGNA:
dsg.disegna_contorno(vertici,
xmin,
ymin,
xmax,
ymax,
filepath=path_obj.actualOutputFolder,
format='png',
x_span=x_span,
y_span=y_span)
#---------------1.4_MEAN SHIFT FOR THE IDENTIFICATION OF ANGULAR CLUSTERS---------------------------
(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_corretto(
walls,
cluster_angolari,
filepath=path_obj.actualOutputFolder,
savename='5b_cluster_angolari',
format='png',
x_span=x_span,
y_span=y_span,
xmin=xmin,
xmax=xmax,
ymin=ymin,
ymax=ymax)
#---------------1.5_SPATIAL CLUSTERS IDENTIFICATION (Valerio Arcerito's method)------------------------------------------
# cluster walls together, -1 denotes a false cluster that should not be considered for processing
cluster_mura = lay.get_cluster_mura(walls, cluster_angolari, parametri_obj)
cluster_mura_senza_outliers = []
for c in cluster_mura:
if c != -1:
cluster_mura_senza_outliers.append(c)
# merge clusters that are very close to each other in a single representative
segmenti_rappresentanti = lay.get_rappresentanti(
walls, cluster_mura_senza_outliers)
if par.DISEGNA:
dsg.disegna_segmenti(segmenti_rappresentanti,
filepath=path_obj.actualOutputFolder,
savename="5c_segmenti_rappresentanti",
format='png',
x_span=x_span,
y_span=y_span,
xmin=xmin,
xmax=xmax,
ymin=ymin,
ymax=ymax)
# segment classification
segmenti_rappresentanti = sg.spatialClustering(
parametri_obj.sogliaLateraleClusterMura, segmenti_rappresentanti)
cluster_spaziali = lay.new_cluster_spaziale(walls, segmenti_rappresentanti,
parametri_obj)
if par.DISEGNA:
dsg.disegna_cluster_spaziali(cluster_spaziali,
walls,
filepath=path_obj.actualOutputFolder,
format='png',
x_span=x_span,
y_span=y_span,
xmin=xmin,
xmax=xmax,
ymin=ymin,
ymax=ymax)
dsg.disegna_cluster_mura(cluster_mura,
walls,
filepath=path_obj.actualOutputFolder,
savename='5d_cluster_mura',
format='png',
x_span=x_span,
y_span=y_span,
xmin=xmin,
xmax=xmax,
ymin=ymin,
ymax=ymax)
#-------------------1.6_EXTENDED_LINES CREATION-------------------------------------------
(extended_lines,
extended_segments) = lay.extend_line(cluster_spaziali,
walls,
xmin,
xmax,
ymin,
ymax,
filepath=path_obj.actualOutputFolder)
if par.DISEGNA:
dsg.disegna_extended_segments(extended_segments,
walls,
filepath=path_obj.actualOutputFolder,
format='png',
x_span=x_span,
y_span=y_span,
xmin=xmin,
xmax=xmax,
ymin=ymin,
ymax=ymax)
#-------------1.7_CREATE EDGES BY INTERSECTION OF EXTENDED LINES--------------
edges = sg.crea_edges(extended_segments)
#----------------------1.8_SET EDGE WEIGHT-------------------------------------
edges = sg.setPeso(edges, walls)
#----------------1.9_IDENTIFY SPATIAL CELLS----------------------------------------
celle = fc.crea_celle(edges)
#----------------CELL CLASSIFICATION-----------------------------------------------------
global centroid
#verificare funzioni
if par.metodo_classificazione_celle == 1:
(celle, celle_out, celle_poligoni, indici, celle_parziali, contorno,
centroid, punti) = lay.classificazione_superfici(vertici, celle)
elif par.metodo_classificazione_celle == 2:
(celle_out, celle, centroid, punti, celle_poligoni, indici,
celle_parziali) = lay.classifica_celle_con_percentuale(
vertici, celle, img_ini)
#--------------------------BUILD CELL POLYGONS---------------------------------------------
(celle_poligoni, out_poligoni, parz_poligoni,
centroid) = lay.crea_poligoni_da_celle(celle, celle_out, celle_parziali)
dsg.disegna_poligoni_interni_esterni(celle_poligoni,
out_poligoni,
parz_poligoni,
xmin,
ymin,
xmax,
ymax,
format='png',
x_span=x_span,
y_span=y_span,
filepath=path_obj.actualOutputFolder,
savename='8_d_celle_in_out')
(matrice_l, matrice_d, matrice_d_inv,
X) = lay.crea_matrici(celle, sigma=parametri_obj.sigma)
#----------------IDENTIFICATION OF CELLS BELONGING TO THE SAME SPACE/ROOM WITH DBSCAN-------------------------
clustersCelle = lay.DB_scan(parametri_obj.eps, parametri_obj.minPts, X,
celle_poligoni)
if par.DISEGNA:
colori, fig, ax = dsg.disegna_dbscan(
clustersCelle,
celle,
celle_poligoni,
xmin,
ymin,
xmax,
ymax,
edges,
contours,
filepath=path_obj.actualOutputFolder,
format='png',
x_span=x_span,
y_span=y_span)
else:
colori = dsg.get_colors(clustersCelle,
format='png',
x_span=x_span,
y_span=y_span,
xmin=xmin,
xmax=xmax,
ymin=ymin,
ymax=ymax)
#------------------BUILD SPACE/ROOM POLYGONS--------------------------------------------
stanze, spazi = lay.crea_spazio(clustersCelle,
celle,
celle_poligoni,
colori,
xmin,
ymin,
xmax,
ymax,
filepath=path_obj.actualOutputFolder)
if par.DISEGNA:
dsg.disegna_stanze(stanze,
colori,
xmin,
ymin,
xmax,
ymax,
filepath=path_obj.actualOutputFolder,
format='png',
x_span=x_span,
y_span=y_span)
#--------------------------------SUMMARY OUTPUT------------------------------------------
dsg.disegno_mura_segmenti_stanze(stanze,
colori,
xmin,
ymin,
xmax,
ymax,
cluster_spaziali,
walls,
format='png',
x_span=x_span,
y_span=y_span,
filepath=path_obj.actualOutputFolder,
savename='14_tutto')
dsg.disegna_pareti(edges,
format='png',
x_span=x_span,
y_span=y_span,
xmin=xmin,
xmax=xmax,
ymin=ymin,
ymax=ymax,
filepath=path_obj.actualOutputFolder,
savename='14_pareti')
wallEnlargement = parametri_obj.wallEnlargementFactor / parametri_obj.imageScale
G, pos, connectedRooms = tg.createGraph(path_obj.metricMap, spazi,
wallEnlargement)
dsg.plot_nodi_e_stanze(colori,
estremi,
G,
pos,
spazi,
connectedRooms,
filepath=path_obj.actualOutputFolder,
format='png',
x_span=x_span,
y_span=y_span,
xmin=xmin,
xmax=xmax,
ymin=ymin,
ymax=ymax)
# create XML
id_stanze = xmlutils.crea_xml(path_obj.outputFileName, spazi,
parametri_obj.imageScale, vertici,
connectedRooms)
def get_layout(metricMap, minVal, maxVal, rho, theta, thresholdHough, minLineLength, maxLineGap, eps, minPts, h, minOffset, minLateralSeparation,filepath, cv2thresh=127, diagonali=True, m = 20, metodo_classificazione_celle = True):
'''
Genera il layout delle stanze
INPUT: mappa metrica, i parametri di canny, hough, mean-shift, dbscan, distanza per clustering spaziale.
OUTPUT: la lista di poligoni shapely che costituiscono le stanze, la lista di cluster corrispondenti, la lista estremi che contiene [minx,maxx,miny,maxy] e la lista di colori.
'''
#leggo l'immagine originale in scala di grigio e la sistemo con il thresholding
img_rgb = cv2.imread(metricMap)
img_ini = img_rgb.copy() #copio l'immagine
#scansione dei bordi
#img_rgb = scan_bordo(img_rgb)
# 127 per alcuni dati, 255 per altri
ret,thresh1 = cv2.threshold(img_rgb,cv2thresh,255,cv2.THRESH_BINARY)
#img_ini = thresh1.copy()
#------------------CANNY E HOUGH PER TROVARE MURI-----------------------------------
walls , canny = start_canny_ed_hough(thresh1,minVal,maxVal,rho,theta,thresholdHough,minLineLength,maxLineGap)
#questo lo posso anche eliminare alla fine
#----primo plot-->richiedo il disegno delle hough lines
dsg.disegna_map(img_rgb,filepath = filepath )
dsg.disegna_canny(canny,filepath = filepath)
dsg.disegna_hough(img_rgb,walls,filepath = filepath)
lines = flip_lines(walls, img_rgb.shape[0]-1)
walls = crea_muri(lines)
#anche questo lo posso eliminare
#disegno i muri
#----secondo plot --> disegna i muri corrispondenti ai segmenti individuati in precedenza
#dsg.disegna_segmenti(walls)#solo un disegno poi lo elimino
#-----------------------------------------------------------------------------------
#------------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
#-----------------------------------------------------------------------------------
#---------------CONTORNO ESTERNO----------------------------------------------------
(contours, vertici) = contorno_esterno(img_rgb, minVal, maxVal, xmin, xmax, ymin, ymax, metricMap,filepath = filepath, m = m)
#-----------------------------------------------------------------------------------
#---------------MEAN SHIFT PER TROVARE CLUSTER ANGOLARI-----------------------------
(indici, walls, cluster_angolari) = cluster_ang(h, minOffset, walls, diagonali= diagonali) #probabilmente indici non serve veraente
#-----------------------------------------------------------------------------------
#---------------CLUSTER SPAZIALI----------------------------------------------------
cluster_spaziali = cluster_spaz(minLateralSeparation, walls,filepath = filepath)
#-----------------------------------------------------------------------------------
#-------------------CREO EXTENDED_LINES---------------------------------------------
(extended_lines, extended_segments) = extend_line(cluster_spaziali, walls, xmin, xmax, ymin, ymax,filepath = filepath)
#-----------------------------------------------------------------------------------
#-------------CREO GLI EDGES TRAMITE INTERSEZIONI TRA EXTENDED_LINES----------------
edges = sg.crea_edges(extended_segments)
#-----------------------------------------------------------------------------------
#----------------------SETTO PESI DEGLI EDGES---------------------------------------
#non so a cosa serva
edges = sg.setPeso(edges, walls)
#-----------------------------------------------------------------------------------
#----------------CREO LE CELLE DAGLI EDGES------------------------------------------
celle = fc.crea_celle(edges)
#-----------------------------------------------------------------------------------
#----------------------------------problemi---------------------------------------------
#TODO: questi due pezzi di codice hanno un problema, per ora non ho capito cosa. Ci sono gia' i metodi in fondo
'''
#questa non va
#----------------CLASSIFICO CELLE---------------------------------------------------
(celle, celle_out, celle_poligoni, indici, celle_parziali, contorno, centroid, punti) = classificazione_superfici(vertici, celle)
#-----------------------------------------------------------------------------------
#questo non va
#--------------------------POLIGONI CELLE-------------------------------------------
#TODO: questo medodo non e' di questa classe ma e' della classe Sapzio, in sostanza gli passi le celle e lui crea lo spazio che poi potro classificare come stanza o corridoio
(celle_poligoni, out_poligoni, parz_poligoni) = crea_poligoni_da_celle(celle, celle_out, celle_parziali)
#-----------------------------------------------------------------------------------
'''
#se voglio classifica le celle con il metodo di matteo metti TRUE, altrimenti se vuoi classificare con il metodo di Valerio con le percentuali metti False
if metodo_classificazione_celle:
print "sono entrato qui dentro hahahahahah"
#----------------CLASSIFICO CELLE---------------------------------------------------
#creo poligono del contorno
contorno = Polygon(vertici)
celle_poligoni = []
indici = []
celle_out = []
celle_parziali = []
for index,f in enumerate(celle):
punti = []
for b in f.bordi:
punti.append([float(b.x1),float(b.y1)])
punti.append([float(b.x2),float(b.y2)])
#ottengo i vertici della cella senza ripetizioni
punti = sort_and_deduplicate(punti)
#ora li ordino in senso orario
x = [p[0] for p in punti]
y = [p[1] for p in punti]
global centroid
centroid = (sum(x) / len(punti), sum(y) / len(punti))
punti.sort(key=algo)
#dopo averli ordinati in senso orario, creo il poligono della cella.
cella = Polygon(punti)
#se il poligono della cella non interseca quello del contorno esterno della mappa, la cella e' fuori.
if cella.intersects(contorno)==False:
#indici.append(index)
f.set_out(True)
f.set_parziale(False)
celle_out.append(f)
#se il poligono della cella interseca il contorno esterno della mappa
if (cella.intersects(contorno)):
#se l'intersezione e' piu' grande di una soglia la cella e' interna
if(cella.intersection(contorno).area >= cella.area/2):
f.set_out(False)
#altrimenti e' esterna
else:
f.set_out(True)
f.set_parziale(False)
celle_out.append(f)
'''
#le celle che non sono state messe come out, ma che sono adiacenti al bordo dell'immagine (hanno celle adiacenti < len(bordi)) sono per forza parziali
a=0
for f in celle:
for f2 in celle:
if (f!=f2) and (fc.adiacenti(f,f2)):
a += 1
if (a<len(f.bordi)):
#print("ciao")
if not (f.out):
f.set_out(True)
f.set_parziale(True)
celle_parziali.append(f)
a = 0
#le celle adiacenti ad una cella out tramite un edge che pesa poco, sono parziali.
a = 1
while(a!=0):
a = 0
for f in celle:
for f2 in celle:
if (f!=f2) and (f.out==False) and (f2.out==True) and (fc.adiacenti(f,f2)):
if(fc.edge_comune(f,f2)[0].weight < 0.2):
f.set_out(True)
f.set_parziale(True)
celle_parziali.append(f)
a = 1
'''
#tolgo dalle celle out le parziali
celle_out = list(set(celle_out)-set(celle_parziali))
#tolgo dalle celle quelle out e parziali
celle = list(set(celle)-set(celle_out))
celle = list(set(celle)-set(celle_parziali))
else:
print "uffffa ################################"
#sto classificando le celle con il metodo delle percentuali
(celle_out, celle, centroid, punti,celle_poligoni, indici, celle_parziali) = classifica_celle_con_percentuale(vertici, celle, img_ini)
#--------------------------POLIGONI CELLE-------------------------------------------------
#adesso creo i poligoni delle celle (celle = celle interne) e delle celle esterne e parziali
#poligoni celle interne
celle_poligoni = []
for f in celle:
punti = []
for b in f.bordi:
punti.append([float(b.x1),float(b.y1)])
punti.append([float(b.x2),float(b.y2)])
punti = sort_and_deduplicate(punti)
x = [p[0] for p in punti]
y = [p[1] for p in punti]
centroid = (sum(x) / len(punti), sum(y) / len(punti))
punti.sort(key=algo)
cella = Polygon(punti)
celle_poligoni.append(cella)
#poligoni celle esterne
out_poligoni = []
for f in celle_out:
punti = []
for b in f.bordi:
punti.append([float(b.x1),float(b.y1)])
punti.append([float(b.x2),float(b.y2)])
punti = sort_and_deduplicate(punti)
x = [p[0] for p in punti]
y = [p[1] for p in punti]
centroid = (sum(x) / len(punti), sum(y) / len(punti))
punti.sort(key=algo)
cella = Polygon(punti)
out_poligoni.append(cella)
#poligoni celle parziali
parz_poligoni = []
for f in celle_parziali:
punti = []
for b in f.bordi:
punti.append([float(b.x1),float(b.y1)])
punti.append([float(b.x2),float(b.y2)])
punti = sort_and_deduplicate(punti)
x = [p[0] for p in punti]
y = [p[1] for p in punti]
centroid = (sum(x) / len(punti), sum(y) / len(punti))
punti.sort(key=algo)
cella = Polygon(punti)
parz_poligoni.append(cella)
#----------------------------fine problemi----------------------------------------------
#------------------CREO LE MATRICI L, D, D^-1, ED M = D^-1 * L----------------------
(matrice_l, matrice_d, matrice_d_inv, X) = crea_matrici(celle)
#-----------------------------------------------------------------------------------
#----------------DBSCAN PER TROVARE CELLE NELLA STESSA STANZA----------------------
colori, fig, ax, clustersCelle = DB_scan(eps, minPts, X, celle, celle_poligoni, xmin, ymin, xmax, ymax, edges, contours,filepath = filepath)
#-----------------------------------------------------------------------------------
#------------------POLIGONI STANZE(spazio)------------------------------------------
stanze, spazi = crea_spazio(clustersCelle, celle, celle_poligoni, colori, xmin, ymin, xmax, ymax, filepath = filepath)
#-----------------------------------------------------------------------------------
return (stanze, clustersCelle, estremi, colori, spazi)
def get_layout_parziale(metricMap, minVal, maxVal, rho, theta, thresholdHough, minLineLength, maxLineGap, eps, minPts, h, minOffset, minLateralSeparation, diagonali=True):
'''
prende in input la mappa metrica, i parametri di canny, hough, mean-shift, dbscan, distanza per clustering spaziale. Genera il layout delle stanze e ritorna la lista di poligoni shapely che costituiscono le stanze, la lista di cluster corrispondenti, la lista estremi che contiene [minx,maxx,miny,maxy] e la lista di colori.
'''
img_rgb = cv2.imread(metricMap)
ret,thresh1 = cv2.threshold(img_rgb,127,255,cv2.THRESH_BINARY)
#------------------CANNY E HOUGH PER TROVARE MURI----------------------------------
#canny
cannyEdges = cv2.Canny(thresh1,minVal,maxVal,apertureSize = 5)
#hough
walls = cv2.HoughLinesP(cannyEdges,rho,theta,thresholdHough,minLineLength,maxLineGap)
if cv2.__version__[0] == '3' :
walls = [i[0]for i in walls]
elif cv2.__version__[0] == '2' :
walls = walls[0]
else :
raise EnvironmentError('Opencv Version Error. You should have OpenCv 2.* or 3.*')
dsg.disegna_hough(img_rgb,walls)
lines = flip_lines(walls, img_rgb.shape[0]-1)
walls = crea_muri(lines)
#disegno i muri
sg.disegna_segmenti(walls)
#------------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
#---------------CONTORNO ESTERNO-------------------------------------------------------
#creo il contorno esterno facendo prima canny sulla mappa metrica.
cannyEdges = cv2.Canny(img_rgb,minVal,maxVal,apertureSize = 5)
t=1 #threshold di hough
m=21 #maxLineGap di hough
hough_contorni, contours = im.trova_contorno(t,m,cannyEdges, metricMap)
#dsg.disegna_hough(cannyEdges, hough_contorni)
contours = flip_contorni(contours, img_rgb.shape[0]-1)
#disegno contorno esterno
vertici = []
for c1 in contours:
for c2 in c1:
vertici.append([float(c2[0][0]),float(c2[0][1])])
dsg.disegna_contorno(vertici,xmin,ymin,xmax,ymax)
#-------------------MEAN SHIFT PER TROVARE CLUSTER ANGOLARI---------------------------------------
#creo i cluster centers tramite mean shift
cluster_centers = ms.mean_shift(h, minOffset, walls)
#ci sono dei cluster angolari che sono causati da pochi e piccoli line_segments, che sono solamente rumore. Questi cluster li elimino dalla lista cluster_centers ed elimino anche i rispettivi segmenti dalla walls.
num_min = 3
lunghezza_min = 3
indici = ms.indici_da_eliminare(num_min, lunghezza_min, cluster_centers, walls, diagonali)
#ora che ho gli indici di clusters angolari e di muri da eliminare, elimino da walls e cluster_centers, partendo dagli indici piu alti
for i in sorted(indici, reverse=True):
del walls[i]
del cluster_centers[i]
#ci son dei cluster che si somigliano ma non combaciano per una differenza infinitesima, e non ho trovato parametri del mean shift che rendano il clustering piu' accurato di cosi', quindi faccio una media normalissima, tanto la differenza e' insignificante.
unito = ms.unisci_cluster_simili(cluster_centers)
while(unito):
unito = ms.unisci_cluster_simili(cluster_centers)
#assegno i cluster ai muri di walls
walls = sg.assegna_cluster_angolare(walls, cluster_centers)
#creo lista di cluster_angolari
cluster_angolari = []
for muro in walls:
cluster_angolari.append(muro.cluster_angolare)
#---------------CLUSTER SPAZIALI--------------------------------------------------------------------
#setto i cluster spaziali a tutti i muri di walls
walls = sg.spatialClustering(minLateralSeparation, walls)
#disegno i cluster angolari
#sg.disegna_cluster_angolari(cluster_centers, walls, cluster_angolari)
#creo lista di cluster spaziali
cluster_spaziali = []
for muro in walls:
cluster_spaziali.append(muro.cluster_spaziale)
#disegno cluster spaziali
sg.disegna_cluster_spaziali(cluster_spaziali, walls)
#-------------------CREO EXTENDED_LINES---------------------------------------------------------
extended_lines = rt.crea_extended_lines(cluster_spaziali, walls, xmin, ymin)
#extended_lines hanno punto, cluster_angolare e cluster_spaziale, per disegnarle pero' mi servono 2 punti. Creo lista di segmenti
extended_segments = ext.crea_extended_segments(xmin,xmax,ymin,ymax, extended_lines)
#disegno le extended_lines in rosso e la mappa in nero
ext.disegna_extended_segments(extended_segments, walls)
#-------------CREO GLI EDGES TRAMITE INTERSEZIONI TRA EXTENDED_LINES-------------------------------
edges = sg.crea_edges(extended_segments)
#sg.disegna_segmenti(edges)
#----------------------SETTO PESI DEGLI EDGES------------------------------------------------------
edges = sg.setPeso(edges, walls)
#sg.disegna_pesanti(edges, peso_min)
#----------------CREO LE CELLE DAGLI EDGES----------------------------------------------------------
print("creando le celle")
celle = fc.crea_celle(edges)
print("celle create")
#fc.disegna_celle(celle)
#----------------CLASSIFICO CELLE----------------------------------------------
#creo poligono del contorno
contorno = Polygon(vertici)
celle_poligoni = []
indici = []
celle_out = []
celle_parziali = []
for index,f in enumerate(celle):
punti = []
for b in f.bordi:
punti.append([float(b.x1),float(b.y1)])
punti.append([float(b.x2),float(b.y2)])
#ottengo i vertici della cella senza ripetizioni
punti = sort_and_deduplicate(punti)
#ora li ordino in senso orario
x = [p[0] for p in punti]
y = [p[1] for p in punti]
global centroid
centroid = (sum(x) / len(punti), sum(y) / len(punti))
punti.sort(key=algo)
#dopo averli ordinati in senso orario, creo il poligono della cella.
cella = Polygon(punti)
#se il poligono della cella non interseca quello del contorno esterno della mappa, la cella e' fuori.
if cella.intersects(contorno)==False:
#indici.append(index)
f.set_out(True)
f.set_parziale(False)
celle_out.append(f)
#se il poligono della cella interseca il contorno esterno della mappa
if (cella.intersects(contorno)):
#se l'intersezione e' piu' grande di una soglia la cella e' interna
if(cella.intersection(contorno).area >= cella.area/2):
f.set_out(False)
#altrimenti e' esterna
else:
f.set_out(True)
f.set_parziale(False)
celle_out.append(f)
#le celle che non sono state messe come out, ma che sono adiacenti al bordo dell'immagine (hanno celle adiacenti < len(bordi)) sono per forza parziali
a=0
for f in celle:
for f2 in celle:
if (f!=f2) and (fc.adiacenti(f,f2)):
a += 1
if (a<len(f.bordi)):
#print("ciao")
if not (f.out):
f.set_out(True)
f.set_parziale(True)
celle_parziali.append(f)
a = 0
#le celle adiacenti ad una cella out tramite un edge che pesa poco, sono parziali.
a = 1
while(a!=0):
a = 0
for f in celle:
for f2 in celle:
if (f!=f2) and (f.out==False) and (f2.out==True) and (fc.adiacenti(f,f2)):
if(fc.edge_comune(f,f2)[0].weight < 0.1): #qua nella funzione normale c'e' 0.2
f.set_out(True)
f.set_parziale(True)
celle_parziali.append(f)
a = 1
#tolgo dalle celle out le parziali
celle_out = list(set(celle_out)-set(celle_parziali))
#tolgo dalle celle quelle out e parziali
celle = list(set(celle)-set(celle_out))
celle = list(set(celle)-set(celle_parziali))
#--------------------------POLIGONI CELLE-------------------------------------------------
#adesso creo i poligoni delle celle (celle = celle interne) e delle celle esterne e parziali
#poligoni celle interne
celle_poligoni = []
for f in celle:
punti = []
for b in f.bordi:
punti.append([float(b.x1),float(b.y1)])
punti.append([float(b.x2),float(b.y2)])
punti = sort_and_deduplicate(punti)
x = [p[0] for p in punti]
y = [p[1] for p in punti]
centroid = (sum(x) / len(punti), sum(y) / len(punti))
punti.sort(key=algo)
cella = Polygon(punti)
celle_poligoni.append(cella)
#poligoni celle esterne
out_poligoni = []
for f in celle_out:
punti = []
for b in f.bordi:
punti.append([float(b.x1),float(b.y1)])
punti.append([float(b.x2),float(b.y2)])
punti = sort_and_deduplicate(punti)
x = [p[0] for p in punti]
y = [p[1] for p in punti]
centroid = (sum(x) / len(punti), sum(y) / len(punti))
punti.sort(key=algo)
cella = Polygon(punti)
out_poligoni.append(cella)
#poligoni celle parziali
parz_poligoni = []
for f in celle_parziali:
punti = []
for b in f.bordi:
punti.append([float(b.x1),float(b.y1)])
punti.append([float(b.x2),float(b.y2)])
punti = sort_and_deduplicate(punti)
x = [p[0] for p in punti]
y = [p[1] for p in punti]
centroid = (sum(x) / len(punti), sum(y) / len(punti))
punti.sort(key=algo)
cella = Polygon(punti)
parz_poligoni.append(cella)
#------------------CREO LE MATRICI L, D, D^-1, ED M = D^-1 * L---------------------------------------
sigma = 0.1
val = 0
matrice_l = mtx.crea_matrice_l(celle, sigma, val)
matrice_d = mtx.crea_matrice_d(matrice_l)
matrice_d_inv = matrice_d.getI()
matrice_m = matrice_d_inv.dot(matrice_l)
matrice_m = mtx.simmetrizza(matrice_m)
X = 1-matrice_m
#----------------DBSCAN PER TROVARE CELLE NELLA STESSA STANZA-----------------------------------------
clustersCelle = []
clustersCelle = clustering_dbscan_celle(eps, minPts, X)
colori, fig, ax = dsg.disegna_dbscan(clustersCelle, celle, celle_poligoni, xmin, ymin, xmax, ymax, edges, contours)
'''
#plotto le celle esterne
for f_poly in out_poligoni:
f_patch = PolygonPatch(f_poly,fc='#ffffff',ec='BLACK')
ax.add_patch(f_patch)
ax.set_xlim(xmin,xmax)
ax.set_ylim(ymin,ymax)
ax.text(f_poly.representative_point().x,f_poly.representative_point().y,str("out"),fontsize=8)
'''
#plotto le celle parziali
for f_poly in parz_poligoni:
f_patch = PolygonPatch(f_poly,fc='#d3d3d3',ec='BLACK')
ax.add_patch(f_patch)
ax.set_xlim(xmin,xmax)
ax.set_ylim(ymin,ymax)
ax.text(f_poly.representative_point().x,f_poly.representative_point().y,str("parz"),fontsize=8)
plt.show()
#------------------POLIGONI STANZE-------------------------------------------------------------------
#creo i poligoni delle stanze (unione dei poligoni delle celle con stesso cluster).
stanze = []
stanze = unisciCelle(clustersCelle, celle, celle_poligoni, False)
#disegno layout stanze.
fig, ax = dsg.disegna_stanze(stanze, colori, xmin, ymin, xmax, ymax)
#plotto le celle parziali, questo per funzionare ha bisogno che si commenti riga 127 di disegna.py (#plt.show()).
for f_poly in parz_poligoni:
f_patch = PolygonPatch(f_poly,fc='#d3d3d3',ec='BLACK')
ax.add_patch(f_patch)
ax.set_xlim(xmin,xmax)
ax.set_ylim(ymin,ymax)
plt.show()
return (stanze, clustersCelle, estremi, colori)