Ingegneria della conoscenza e sistemi esperti
Moduli di Visione e percezione e Apprendimento
Clusterizzazione di prati e alberi secondo misture
di gaussiane con parametri appresi tramite
algoritmo EM
Cesare Guariniello
i
Abstract
This work about the clustering of trees and meadows can be divided into two parts
which have been carried on almost independently: first of all, supposed that the
"trees and meadows" RGB components belong to a Gaussian mixture (GM)
probability distribution function (pdf), the parameters of this GM pdf have been
learned with the EM algorythm, which allows to solve the problem of learning in
presence of hidden variables. In fact, we want to perform unsupervised clustering,
by recovering a gaussian mixture model when we know neither the assignment of
any data point to a given component, nor the parameters of any component of the
mixture. Two different data sets have been used, thus generating two different sets
of parameters. From each data set, composed by 44100 RGB components vectors
(ten 70-by-70 images), GMs with 3 up to 11 components have been learned. The
learned sets of parameters have been used in the second part of this work, that is the
creation of a Graphic User Interface (GUI) that allows to open images and choose
the learning data set and the parameters for clustering, and calculates the trees and
meadows clusters in the selected image basing on the GM pdf learned in the first
part.
ii
Sommario:
Clusterizzazione di prati e alberi secondo misture di gaussiane con parametri appresi tramite
algoritmo EM ........................................................................................................................................ i
Abstract ............................................................................................................................................ ii
1
L’apprendimento dei parametri delle misture di gaussiane tramite l’algoritmo EM
(Expectation Maximization) ............................................................................................................ 1
1.1
Le misture di gaussiane.................................................................................................... 1
1.2
L’algoritmo EM ............................................................................................................... 1
1.3
Le immagini e i dati di apprendimento ............................................................................ 2
1.4
Le funzioni di apprendimento .......................................................................................... 3
1.4.1
gmem.m.................................................................................................................... 3
1.4.2
fcm.m........................................................................................................................ 4
1.4.3
covfixer.m................................................................................................................. 4
1.4.4
mvnpdf.m.................................................................................................................. 5
1.4.5
emstime.mat.............................................................................................................. 5
2
L’utilizzo delle misture di gaussiane per la clusterizzazione ................................................... 5
2.1
Scelta del numero di componenti della mistura ............................................................... 5
2.2
Scelta della soglia di appartenenza .................................................................................. 6
2.3
Gestione delle immagini .................................................................................................. 6
2.4
Le funzioni di clusterizzazione ........................................................................................ 6
2.4.1
gmpdf.m.................................................................................................................... 6
2.4.2
gmcluster.m.............................................................................................................. 7
3
L’interfaccia grafica ................................................................................................................. 7
3.1
Il layout ............................................................................................................................ 8
3.2
I menu e l’utilizzo dell’interfaccia grafica ....................................................................... 8
3.2.1
Il menu File .............................................................................................................. 8
3.2.2
Il menu View............................................................................................................. 9
3.2.3
Il menu Help............................................................................................................. 9
3.2.4
I menu contestuali delle immagini ........................................................................... 9
3.2.5
Il pannello Learning set ........................................................................................... 9
3.2.6
Il pannello Parameters........................................................................................... 10
3.2.7
Il pannello Single points removal e il tasto Update............................................... 10
3.3
Le funzioni dell’interfaccia grafica................................................................................ 10
3.3.1
EM.m ed EM.fig ..................................................................................................... 10
3.3.2
modalabout.m e modalabout.fig ............................................................................ 13
3.3.3
modalguide.m e modalguide.fig ............................................................................. 13
3.3.4
modalmenu.m e modalmenu.fig ............................................................................. 13
3.3.5
modalbox.m e modalbox.fig ................................................................................... 14
4
Listati delle funzioni matlab .................................................................................................. 15
4.1
gmem.m.......................................................................................................................... 15
4.2
fcm.m ............................................................................................................................. 17
iii
4.3
covfixer.m ...................................................................................................................... 18
4.4
mvnpdf.m....................................................................................................................... 19
4.5
gmpdf.m......................................................................................................................... 21
4.6
gmcluster.m.................................................................................................................... 22
4.7
EM.m.............................................................................................................................. 23
4.8
modalabout.m................................................................................................................. 32
4.9
modalguide.m................................................................................................................. 34
4.10 modalmenu.m................................................................................................................. 37
4.11 modalbox.m.................................................................................................................... 40
5
Bibliografia e risorse online ................................................................................................... 44
Indice analitico ............................................................................................................................... 45
iv
1
L’apprendimento dei parametri delle misture di gaussiane tramite
l’algoritmo EM (Expectation Maximization)
1.1
Le misture di gaussiane
Le misture di gaussiane sono funzioni di distribuzione di probabilità formate dalla somma di
funzioni di distribuzione di tipo gaussiano, chiamate componenti della mistura, ciascuna con
un suo peso.
I parametri caratterizzanti una mistura di gaussiane, dato il numero di componenti k e la
dimensione d, sono di tre tipi:
Ÿ i momenti µ, che sono k vettori di dimensione d, uno per ciascuna componente
Ÿ le covarianze S , che sono k matrici di dimensione d*d, una per ciascuna componente
Ÿ il vettore dei pesi, di dimensione k.
La probabilità della mistura è data da
k
P( x) = å P( x | C = i )P (C = i )
i=1
dove P(C=i), ossia la probabilità che la componente sia la i- esima, è proprio il peso della iesima componente, mentre P(x|C=i) = P(x| Si, µi) è la gaussiana i-esima calcolata in x.
1.2
L’algoritmo EM
L’algoritmo “Expectatio n Maximization” permette l’apprendimento con set di dati
incompleti o con set di dati generati da misture di distribuzioni di probabilità nel caso in cui
non si conoscano né i parametri delle funzioni di distribuzione, né l’appartenenza di ciascun
dato ad una data funzione di distribuzione. Nel caso delle misture di gaussiane, l’idea base
dell’algoritmo EM è assumere di conoscere i parametri dei modelli, e quindi calcolare la
probabilità che ciascun dato appartenga a ciascuna componente. A questo punto, si
riadattano le componenti ai dati, e per ciascuna componente si pesano tutti i dati con la
probabilità che appartengano a questa componente. I due passi prendono rispettivamente il
nome di “passo di speranza”, o di aspettativa (Expectation step, E-step) e “passo di
massimizzazione” (Maximization step, M-step).
Nell’E-step, calcoliamo il valore atteso di variabili fittizie nascoste Zij, che indicano la
probabilità che il dato xj sia stato generato dalla -i esima componente. Calcoliamo quindi
Pij=P(C=i| xj ). Applicando la regola di Bayes, abbiamo Pij=aP(xj|C=i)P(C=i). a è un fattore di
normalizzazione, il termine P(xj|C=i) è la probabilità della i- esima gaussiana, calcolata nel
punto xj e il termine P(C=i) è semplicemente il peso della i- esima gaussiana. Definiamo poi
Pi = å Pij .
j
Nell’M-step, calcoliamo i nuovi valori dei parametri delle gaussiane che massimizzano il
log- likelihood dei dati, secondo le seguenti formule:
1
µi ¬¾¾
S i ¬¾¾
åpx
j
ij
j
pi
å p (x -µ )(x -µ )
j
ij
j
i
j
T
i
pi
w i ¬¾¾
pi
N
dove µi sono i momenti, Si le covarianze, wi pesi ed N il numero di dati.
L’algoritmo EM fa aumentare il log- likelihood dei dati ad ogni iterazione, quindi
generalmente raggiunge un massimo locale. Raramente raggiunge un punto di sella oppure
un punto di minimo locale.
La forma generale dell’algoritmo EM è data da
J (i+1) =argmax å z P(Z=z|x,J (i) )L(x,Z=z|J )
J
Dove ? sono tutti i parametri del modello che stiamo apprendendo, x sono i dati, Z sono le
variabili nascoste e L il likelihood.
1.3
Le immagini e i dati di apprendimento
Le immagini utilizzate per l’apprendimento sono le seguenti:
Queste prime otto immagini sono presenti in entrambi i set di apprendimento. Si può notare
che sono stati scelti alberi, prati e foglie di colore differente, alcuni con zone d’ombra, altri
con foschia. Per la nona immagine, nel primo set è stata inserita quella di un prato secco, che
tuttavia ha presentato alcuni problemi, poiché in immagini con la presenza di pixel di colore
2
chiaro (bianco sporco), questi sono marcati come pixel generati dalla mistura di gaussiane
appresa. Per questo motivo, nel secondo set la nona immagine è quella di un prato
ravvicinato.
Le immagini sono state importate in matlab come array di dimensioni 70*70*3, dove
ciascuna delle tre matrici è formata da numeri interi compresi tra 0 e 255, che indicano
l’intensità rispettivamente del rosso, del verde e del blu. Le matrici sono state poi “aperte” in
vettori di 4900 elementi, e affiancate in tre colonne. Mettendo poi in successione i vettori di
tutte le immagini, si è ottenuto per ogni set di immagini una matrice con tre colonne (rosso,
verde e blu) di 44100 elementi, utilizzata poi nelle funzioni di apprendimento.
1.4
Le funzioni di apprendimento
In questo paragrafo verranno descritte le funzioni matlab utilizzate per l’apprendimento. I
listati, all’interno dei quali si trovano ulteriori commenti alle funzioni, sono consultabili nel
capitolo 4.
1.4.1
gmem.m
La funzione gmem (gaussian mixture expectation maximization) accetta in ingresso una
matrice di dati di dimensioni NxD, dove N è il numero di punti e D la dimensione della
mistura di gaussiane che vogliamo ottenere in uscita, e restituisce una struttura contenente
una matrice di momenti mu, di dimensioni DxC, dove C è il numero di componenti nella
mistura di gaussiane, un array di covarianze sigma, di dimensioni DxDxC e un vettore di
pesi weight, di lunghezza C. Tra i parametri di ingresso, possono essere anche indicati il
numero massimo di interazioni (100 per default), la soglia di convergenza (10-6 per default),
il numero di componenti nella mistura di gaussiane (3 per default), la visualizzazione o
meno di messaggi indicanti il progresso dell’algoritmo (no per default) e l’inizializzazione
dell’algoritmo, mediante una struttura contenente le matrici mu e sigma con le quali si
intende inizializzare l’algoritmo ([] per default).
La funzione inizia con l’assegnazione dei parametri di default e il parsing degli eventuali
parametri passati in ingresso.
Si passa poi all’inizializzazione di mu, sigma e weight. Nel caso in cui l’utente non abbia
fornito una propria inizializzazione, se le componenti della mistura sono almeno 2, si è
scelto di inizializzare i centri tramite la funzione fcm, basato sul clustering fuzzy c- mean;
questa scelta permette di mantenere un certo grado di casualità, scegliendo però comunque
un metodo di calcolo dei centri di cluster. Se la mistura è in realtà il calcolo di una semplice
distribuzione gaussiana, mu viene inizializzato calcolando la media dei dati. La covarianza,
3
invece, viene inizializzata per ciascuna componente come la matrice diagonale avente come
valori quelli della diagonale della covarianza calcolata sui dati. A questo punto viene
invocata la funzione covfixer, che forza la matrice appena calcolata ad essere una valida
matrice di covarianza. I pesi vengono inizializzati semplicemente assegnando a ciascuna
delle C componenti un peso pari a 1/C.
Il log- likelihood viene inizializzato con il massimo valore negativo.
A questo punto inizia la fase di calcolo. Per ciascuna componente, il prodotto
p(xj |C=i)p(C=i) viene calcolato dalla funzione gmprob, che invoca la funzione preesistente
in matlab mvnpdf per calcola re la probabilità di un punto in una gaussiana multivariata e poi
la pesa con l’attuale peso della componente, passato come parametro di ingresso insieme ai
dati, alla matrice mu e all’array sigma. Viene poi effettuata la normalizzazione dei risultati, e
questo conclude il passo E. Nel passo M vengono calcolate le nuove stime dei pesi, di mu e
di sigma, sempre poi verificato dalla funzione covfixer. Alla fine di ogni ciclo viene
ricalcolato il prodotto p(xj|C=i)p(C=i), e quindi il log- likelihood dei dati. Se la variazione del
log- likelihood è minore della soglia di convergenza, le iterazioni vengono interrotte, come
anche se il numero di iterazioni ha superato il massimo numero consentito; altrimenti, il
ciclo riprende dalla normalizzazione dei risultati. Al termine dell’iterazione, viene creata la
struttura che verrà passata in uscita.
1.4.2
fcm.m
La funzione fcm è preesistente in matlab. Il primo elemento che restituisce è proprio il
vettore di centri dei cluster. La invochiamo richiedendo C centri e inserendo opportuni
parametri, ottenendo così una buona inizializzazione per le matrici mu della mistura di
gaussiane.
1.4.3
covfixer.m
La funzione covfixer forza una matrice ad essere una valida matrice di covarianza
(simmetrica, definita positiva, con valori reali sulla diagonale). Per prima cosa viene forzata
la simmetria della matrice, poi vengono eliminate le parti immaginarie di eventuali numeri
complessi presenti sulla diagonale; nel caso queste parti immaginarie abbiano valori
superiori a 10-3 viene emesso un messaggio di avviso.
Viene poi utilizzata la funzione isspd, estratta dal file mvnpdf.m, che restituisce un valore
booleano che indica se la matrice in ingresso è simmetrica definita positiva. Nel caso in cui
non lo sia, si producono lievi modifiche per cercare di ottenere una matrice definita positiva:
se gli elementi della diagonale sono tutti negativi, viene sommato ad essi l’1% del massimo
valore assoluto degli elementi della diagonale; altrimenti, ogni elemento della diagonale
viene aumentato dell’1%.
4
1.4.4
mvnpdf.m
La funzione mvnpdf è preesistente in matlab. Fornisce la probabilità della distribuzione
gaussiana multivariata, determinata dai parametri mu e sigma, calcolata nei punti contenuti
nel vettore X, passato in ingresso.
1.4.5
emstime.mat
In questo file di dati sono contenuti i due set di parametri delle misture di gaussiane apprese.
Per ciascun set di dati di apprendimento, sono stati calcolati i mu, sigma e weight di misture
aventi un numero di componenti compreso tra 3 e 11.
2
L’utilizzo delle misture di gaussiane per la clusterizzazione
2.1
Scelta del numero di componenti della mistura
Durante la fase di studio del problema, per la scelta del numero di componenti da inserire
nella mistura di gaussiane al fine di ottenere il modello che maggiormente si avvicinasse alla
distribuzione che potrebbe generare tutte le possibili immagini di prati e alberi, sono stati
tentati diversi approcci. Il primo, più semplice ma anche dai minori risultati, è stato quello di
tracciare un grafico tridimensionale di punti, rappresentanti ciascuno le tre componenti dei
44100 dati di apprendimento. A causa dell’enorme numero di punti, tuttavia, si è creata una
gran sovrapposizione degli ellissoidi di addensamento che sarebbero stati indice di una
componente della mistura; da rotazioni del grafico, sono risultate evidenti 6-8 zone di
addensamento dei punti. Il grafico è salvato nella cartella dati di apprendimento, sotto il
nome di grafico1.fig. A questo punto, il secondo passo è stato quello di tentare di
semplificare il problema, riducendolo in sottoproblemi. Per questo motivo, nel file
apprendimento.mat, sempre nella cartella dati di apprendimento, sono presenti a titolo di
esempio le matrici greenblue, redgreen e redblue, che indicano quanti punti, tra quelli di
apprendimento, presentano le coppie [x,y] di verde e blu, di rosso e verde, di rosso e blu. In
tal modo, invocando le funzioni surf, mesh, o semplicemente image su queste matrici,
possiamo individuare le zone di addensamento per coppie di componenti cromatiche. Poiché
il blu è più omogeneo delle altre due componenti nelle immagini di prati e alberi, si è dato
maggior peso alla matrice redgreen, che presenta 5-6 zone di addensamento (grafico2.fig e
grafico3.fig). Tuttavia, le altre due matrici presentano ben 8-9 zone di addensamento
(grafico4.fig e grafico5.fig). Pertanto, in vista della creazione dell’interfaccia grafica per il
riconoscimento di prati e alberi, si è deciso di apprendere le misture di gaussiane con un
numero di componenti variabile da 3 a 11, ma il valore consigliato è di 5-7 componenti.
5
2.2
Scelta della soglia di appartenenza
Per quanto riguarda la soglia di appartenenza di un punto alla mistura di gaussiane, sono stati
effettuati vari test, calcolando le probabilità delle misture apprese in tutti i punti di varie
immagini, con e senza presenza di prati e alberi. I punti appartenenti a prati e alberi sono
generalmente caratterizzati da valori di probabilità compresi tra 10-9 e 10-6 ; pertanto, i valori
consigliati sono dell’ordine di 10-7 , e nell’interfaccia grafica è consentita la scelta di un
valore di soglia compreso tra i due estremi individuati mediante gli esperimenti.
Ovviamente, la scelta di una soglia più alta garantisce la diminuzione di errori positivi (ossia
la diminuzione di punti marcati come appartenenti alla mistura, ma in realtà non tali), ma
alcuni punti appartenenti alla mistura non verranno marcati come tali. La scelta di una soglia
più bassa comporta l’esatto opposto, poiché tende ad includere un maggior numero di punti.
2.3
Gestione delle immagini
Tutte le immagini riconosciute da matlab (principalmente ci si è concentrati su gif, jpeg e
bitmap) vengono importate in matlab come matrici di intensità di colori rosso, verde e blu.
Nel caso di immagini in toni di grigio, anziché un array di dimensioni m*n*3, verrà creata
una matrice di dimensioni m*n. Tuttavia, si è preferito non inserire la gestione di tali
immagini, che produrranno quindi semplicemente un errore nel caso si tentasse di applicare
la clusterizzazione a questo tipo di immagini.
2.4
Le funzioni di clusterizzazione
In questo paragrafo verranno descritte le funzioni matlab utilizzate per la clusterizzazione. I
listati, all’interno dei quali si trovano ulteriori commenti alle funzioni, sono consultabili nel
capitolo 4.
2.4.1
gmpdf.m
La funzione è molto semplice: accetta in ingresso un vettore di punti D-dimensionali e i
parametri di una mistura di gaussiane. I controlli su mu e sigma verranno effettuati dalla
funzione invocata mvnpdf, mentre un errore sulla dimensione del peso genererà un errore di
calcolo, in quanto proprio la lunghezza del vettore weight determina il numero di
componenti della mistura, oppure un errore nella finestra dei comandi di matlab, nel caso in
cui le dimensioni di mu e sigma siano minori di quella richiesta dal vettore weight.
La funzione calcola la probabilità della mistura di gaussiane in ciascun punto del vettore in
ingresso, invocando la funzione mvnpdf per calcolare la probabilità di ciascuna componente
nel punto, pesando tale probabilità col il peso della rispettiva componente, e sommando tra
loro tutti i valori trovati per ciascuna componente.
6
2.4.2
gmcluster.m
La funzione gmcluster produce un’immagine delle stesse dimensioni dell’immagine passata
in ingresso, nella quale intendiamo riconoscere prati e alberi basandoci sulle misture di
gaussiane apprese nella prima fase. L’immagine in uscita, in toni di grigio, ha marcati di
bianco (valore 255) tutti i pixel riconosciuti come generati dalla mistura di gaussiane scelta
per la clusterizzazione. In ingresso devono essere forniti i valori medi e le covarianze e i pesi
delle gaussiane della mistura. Possono anche essere passati due parametri opzionali: la
soglia di appartenenza, che per default è pari a 4*10-7 , e un valore booleano, il cui valore di
default è di verità, che indica se effettuare o meno la rimozione di punti isolati.
La funzione inizia con il controllo sul numero dei parametri passati in ingresso e sulle
dimensioni dei dati: l’immagine deve essere una valida immagine a colori, quindi un array di
dimensioni n*m*3, con n ed m non nulli; la matrice dei valori medi deve avere dimensioni
3*C e l’array delle covarianze 3*3*C, dove C indica il numero di componenti della mistura
di gaussiane; il vettore dei pesi deve avere lunghezza C.
Terminato il controllo dei dati in ingresso, viene eseguito il parsing dei parametri facoltativi.
A questo punto, viene generata una nuova immagine, completamente nera (tutti i pixel con
valore 0) e avente le dimensioni dell’immagine in ingresso. Ciascuna colonna dell’immagine
in ingresso viene convertita a valori reali, e sul vettore risultate viene invocata la funzione
gmpdf, per calcolare la probabilità, passando come parametri i valori medi, covarianze e pesi
passati dall’utente alla funzione gmcluster. Successivamente, per ogni punto della colonna,
la probabilità calcolata viene confrontata con la soglia di appartenenza: se la probabilità
risulta strettamente maggiore della soglia, il pixel corrispondente viene marcato come
generato dalla mistura di gaussiane, e settato ad un valore di 255.
Infine, se la variabile che indica l’esecuzione della rimozione di punti isolati ha un valore di
verità positivo, per ogni punto dell’immagine risultante, eccetto quelli lungo il bordo, se un
pixel nero è circondato da 6, 7 o 8 pixel bianchi (somma dei valori degli 8 pixel circostanti
maggiore di 1400), viene settato a 255. Allo stesso modo, se un pixel bianco è circondato da
6, 7 o 8 pixel neri (somma dei valori degli 8 pixel circostanti minore di 520), viene settato a
0. L’immagine risultante viene restituita in uscita.
3
L’interfaccia grafica
In questo capitolo, verrà presentata l’interfaccia grafica “EM” per il riconoscimento di
cluster di prati e alberi, sviluppata in ambiente matlab. Dopo la descrizione del layout
dell’interfaccia, verrà descritto l’utilizzo dei menu e pannelli presenti nell’interfaccia, e
infine saranno presentate le funzioni che compongono l’interfaccia.
Per visualizzare e utilizzare l’interfaccia, è sufficiente avviare matlab, digitare nella finestra
dei comandi “EM” e premere il tasto invio, ovviamente dopo aver aggiunto la cartella
contenente tutti i file di questo lavoro al percorso delle cartelle di matlab.
7
3.1
Il layout
Nella parte alta della finestra si trova la barra dei menu, contenente i menu “File”, “View”
ed “Help”, le cui funzioni e il cui utilizzo sono descritti in 3.2.1, 3.2.2 e 3.2.3.
Nella zona centrale, sono presenti le due
finestre delle immagini: a sinistra,
l’immagine caricata in ingresso, nella
quale si intendono riconoscere i cluster di
prati e alberi; a destra, l’immagine
risultante, che presenta in bianco i pixel
attribuiti ai suddetti cluster. Sugli assi sono
riportate le dimensioni in pixel. Cliccando
con il tasto destro sugli assi, si possono
utilizzari i menu contestuali delle
immagini, descritti in 3.2.4.
Nella parte inferiore della finestra vi sono i
pannelli per la scelta dei parametri, due
con pulsanti di scelta esclusiva e uno con
due cursori a scorrimento con relativa box di testo; in basso a destra, il pulsante “Update”,
che permette di aggiornare il risultato. Per l’utilizzo di questi controlli, si rimanda a 3.2.5,
3.2.6 e 3.2.7.
3.2
3.2.1
I menu e l’utilizzo dell’interfaccia grafica
Il menu File
Posto all’inizio della barra dei menu, presenta una sola voce (in quanto non esistono
comandi per il salvataggio di risultati dall’interfaccia grafica, per poter salvare le immagini
si utilizzano i comandi dei menu contestuali, descritti in 3.2.4): “Open image”. Tale
comando apre una finestra con la lista dei file presenti nella cartella corrente. Il punto
singolo (.) aggiorna il contenuto della cartella corrente, mentre il punto doppio (..) ha la
funzione di tornare indietro di un passo nel percorso della cartella corrente. Tutti gli altri file
possono essere selezionati con un clic singolo e aperti successivamente cliccando sul
pulsante “Yes”, oppure aperti direttamente, con un doppio clic. Solo file di immagini gif
(*.gif, *.GIF), jpeg (*.jpg, *.JPG, *.jpeg, *.JPEG) e bitmap (*.bmp, *.BMP) verranno
accettati e caricati nella finestra immagine di sinistra, al posto dell’immagine corrente. Altri
tipi di file genereranno una finestra modale (ossia in attesa di risposta dell’utente) di errore.
Il comando “Open image” può essere selezionato anche tramite la combinazione di tasti
CTR+O.
8
3.2.2
Il menu View
Posto sulla barra dei menu, presenta due voci: selezionando la prima, “Default” (CTRL+D),
l’interfaccia verrà riportata nello stato iniziale, con l’immagine e i parametri di default; la
seconda voce permette, mediante un sottomenu, di decidere il colore dei pixel del cluster
nell’immagine risultante; i colori possibili sono bianco (CTRL+H), grigio (CTRL+G) e
sfumature di grigio calcolate in base all’intensità del pixel nell’immagine iniziale
(CTRL+P).
3.2.3
Il menu Help
Posto sulla barra dei menu, presenta due voci: la prima, “Guide”, dà vita ad un sottomenu di
due voci; “Layout” (CTRL+L) apre una finestra modale contenente una breve spiegazione
del layout dell’interfaccia; “Menu” (CTRL+M) apre una finestra modale contenente una
breve guida ai menu della barra e ai menu contestuali. La seconda voce del menu Help,
“About” (CTRL+B), apre una finestra modale contenente i crediti dell’autore
dell’interfaccia.
3.2.4
I menu contestuali delle immagini
Si attivano con il clic del tasto destro sugli assi di ciascuna delle due immagini. Per
l’immagine di sinistra viene attivato un menu contestuale di due voci: il comando “Open”
apre la stessa finestra che si ottiene con il comando “Open image” del menu file (si rimanda
a 3.2.1); il comando “Zoom” apre una nuova finestra contenente l’immagine fortemente
ingrandita. Questa nuova finestra consente anche di salvare l’immagine. Il menu contestuale
dell’immagine di destra, invece, contiene solo la voce “Zoom” con la stessa funzione di
aprire una nuova finestra contenente l’immagine risultante ingrandita. In tal modo, possiamo
salvare i risultati dell’applicazione dell’algoritmo.
3.2.5
Il pannello Learning set
Posto nella zona inferiore sinistra dell’interfaccia, presenta due pulsanti mutuamente
esclusivi, che consentono di scegliere il set di apprendimento con il quale sono state ottenute
le misture di gaussiane che si vogliono utilizzare per il clustering. Il set numero 1 è quello in
cui la nona immagine di apprendimento (11,1% dei dati di apprendimento) è quella di un
prato secco; il set numero 2 è quello in cui la nona immagine di apprendimento (11,1% dei
dati di apprendimento) è quella di un prato fotografato da breve distanza.
9
3.2.6
Il pannello Parameters
Posto al centro della zona inferiore, il pannello presenta due cursori scorrevoli con due
relative caselle di testo. Il cursore superiore permette di scegliere il numero di componenti
presenti nella mistura di gaussiane che intendiamo utilizzare per la clusterizzazione ; il
numero scelto può variare da 3 a 11, e può essere modificato trascinando il cursore,
cliccando sullo scivolo ai lati del cursore oppure cliccando sulle frecce; la modifica della
variabile sarà immediatamente riportata nella casella di testo; la variabile può essere
modificata anche inserendo un valore numerico nella casella; un valore che ecceda i limiti
consentiti non produrrà alcun cambiamento, mentre un valore non intero verrà arrotondato al
più vicino valore intero. Il cursore inferiore permette di scegliere la soglia di appartenenza
dei pixel alla mistura; il numero scelto sarà moltiplicato per 10-9 , e può variare da 1 (soglia
10-9 ) a 1001 (soglia 1,001*10-6 ). Il cursore può essere trascinato sul punto desiderato; un clic
sulle frecce laterali produrrà una variazione unitaria della variabile, mentre un clic sullo
scivolo ai lati del cursore produrrà una variazione di 50 unità; la modifica della variabile
sarà immediatamente riportata nella casella di testo; la variabile può essere modificata anche
inserendo un valore numerico nella casella: un valore che ecceda i limiti consentiti non
produrà alcun cambiamento, mentre un valore non intero verrà arrotondato al più vicino
intero.
3.2.7
Il pannello Single points removal e il tasto Update
Sono entrambi situati nella parte inferiore destra della finestra dell’interfaccia grafica. Il
pannello presenta due pulsanti mutuamente esclusivi, che consentono di decidere se
effettuare o meno la rimozione dei punti isolati dall’immagine risultante (descritta in 2.4.2).
Il tasto “Update” è quello che avvia il calcolo del cluster di prati e alberi: una volta caricata
l’immagine che si intende clusterizzare e scelti il set di apprendimento, il numero di
componenti della mistura, la soglia di appartenenza e la rimozione o meno dei punti isolati,
la pressione del tasto “Update” cancella l’immagine risultante, sostituendola con una
temporanea di attesa, raccoglie i parametri scelti e avvia il calcolo basato su di essi,
disegnando alla fine la nuova immagine risultante.
3.3
Le funzioni dell’interfaccia grafica
In questo paragrafo verranno descritte le funzioni matlab utilizzate per la creazione e la
gestione dell’interfaccia grafica. I listati, all’interno dei quali si trovano ulteriori commenti
alle funzioni, sono consultabili nel capitolo 4.
3.3.1
EM.m ed EM.fig
La struttura principale del file .m e l’intero file .fig sono stati generati automaticamente
tramite l’utilità “Guide” di matlab, che permette di creare interfacce grafiche;
10
successivamente, l’intera interfaccia è stata programmata e gestita scrivendo il corpo delle
numerose funzioni presenti nel file .m, che verrà ora descritto.
La parte iniziale è generata automaticamente, e gestisce le proprietà dell’interfaccia; subito
dopo, la funzione EM_OpeningFcn, che viene eseguita prima che l’interfaccia venga resa
visibile su schermo, si occupa di inizializzare i valori di default, caricare l’immagine
iniziale, invocare per la prima volta la funzione gmcluster e disegnare l’immagine risultante
nella seconda finestra. Alla fine di ciascuna funzione, il comando guidata(hObject, handles)
ha il compito di aggiornare la struttura contenente i parametri condivisi tra le funzioni
all’interno dell’interfaccia. A questo punto l’interfaccia viene posta in attesa;
successivamente, dopo la funzione di output che ha scarsa importanza in questo contesto,
iniziano le funzioni di callback e di creazione di ciascun oggetto: le prime sono invocate
ogni volta che un oggetto viene utilizzato o attivato dall’utente; le altre sono invocate al
momento dell’apertura della finestra dell’interfaccia grafica.
La funzione slider1_Callback viene attivata dallo spostamento del cursore superiore del
pannello dei parametri: legge il nuovo valore segnato dal cursore, e sceglie il set di
parametri corrispondente alla scelta fatta; infine, setta il valore della casella di testo
corrispondente pari al nuovo valore scelto dall’utente tramite il cursore.
La funzione slide1_CreateFcn ha in questo caso solo il compito di impostare il colore di
sfondo dei cursori.
La funzione slider2_Callback viene attivata dallo spostamento del cursore inferiore del
pannello dei parametri: legge il nuovo valore segnato dal cursore, lo moltiplica per 10-9 e
pone la soglia di appartenenza corrente pari alla quantità appena calcolata; infine, setta il
valore della casella di testo corrispondente pari al nuovo valore scelto dall’utente tramite il
cursore.
Anche in questo caso, la funzione slide2_CreateFcn ha il solo compito di impostare il colore
di sfondo dei cursori.
La funzione gmctext_Callback viene attivata quando l’utente modifica il contenuto della
casella di testo corrispondente al numero di componenti nella mistura di gaussiane; se il
valore immesso è numerico e rientra nel range consentito, il cursore corrispondente verrà
portato su questo valore, e sarà scelto il set corrispondente di parametri della mistura; in
caso contrario, il valore del cursore, il quale non è stato modificato dall’utente, verrà usato
per ripristinare il valore precedente della casella di testo.
La funzione gmctext_CreateFcn ha il compito di impostare il colore di sfondo della casella
di testo, in base al sistema operativo utilizzato.
La funzione threshtext_Callback viene attivata quando l’utente modifica il contenuto della
casella di testo corrispondente alla soglia di appartenenza ; se il valore immesso è numerico e
rientra nel range consentito, il cursore corrispondente verrà portato su questo valore, il
quale, moltiplicato per 10-9 , diventerà la soglia corrente; altrimenti, il valore del cursore, il
quale non è stato modificato dall’utente, verrà usato per ripristinare il valore precedente
della casella di testo.
La funzione threshtext_CreateFcn ha il compito di impostare il colore di sfondo della casella
di testo, in base al sistema operativo utilizzato.
La funzione pushbutton1_Callback viene invocata dalla pressione del tasto “Update” nella
finestra dell’interfaccia; immediatamente viene disegnata sulla seconda finestra
un’immagine di attesa; viene poi invocata la funzione gmcluster passando come parametri
l’immagine corrente, il set di apprendimento e i parametri della mistura di gaussiane
selezionata dall’utente, la soglia corrente e la scelta se rimuovere o meno i punti isolati;
ottenuta l’immagine risultante, questa viene disegnata nella seconda finestra.
11
La funzione white_Callback, attivata dalla voce “White” del menu “View/Cluster color”,
pone a 255 (bianco) tutti i pixel dell’immagine risultante che sono marcati come generati
dalla mistura di gaussiane.
La funzione gray_Callback, attivata dalla voce “Gray” del menu “View/Cluster color”, pone
a 40 (tono di grigio scuro) tutti i pixel dell’immagine risultante che sono marcati come
generati dalla mistura di gaussiane.
La funzione pix_Callback, attivata dalla voce “Original pixel intensity” del menu
“View/Cluster color”, calcola il valore di intensità dei pixel dell’immagine originali marcati
come generati dalla mistura di gaussiane, calcolando la media della metà delle intensità di
rosso, verde e blu; imposta poi l’intensità di grigio del corrispondente pixel nell’immagine
risultant e pari al valore appena calcolato.
La funzione open_Callback, invocata dalla voce “Open image” del menu “File” e dalla voce
“Open” del menu contestuale dell’immagine iniziale, chiama la funzione modalbox
(descritta in 3.3.5) e attende la risposta dell’utente: se la risposta è “Close”, non compie
nessuna azione; se la risposta è “No”, viene generata una finestra con un messaggio di
errore; se la risposta è il nome di un file, nel caso in cui il file sia di uno dei tipi di immagine
riconosciuti, viene impostato come immagine corrente e disegnato nella prima finestra;
altrimenti, viene generato un messaggio di errore.
La funzione defa_Callback, invocata dalla scelta della voce “Default” dal menu “View”,
carica l’immagine di default e la disegna nella prima finestra, imposta tutti i parametri ai
valori di default, aggiornando cursori, pulsanti e caselle di testo, calcola nuovamente
l’immagine risultante e la disegna nella seconda finestra.
La funzione about_Callback, attivata dalla voce “About” del menu “Help” chiama la
funzione modalabout (descritta in 3.3.2) e non compie nessuna azione, una volta ricevuta la
risposta dell’utente, non importante in questo caso.
La funzione zoom_Callback, attivata dalla voce “Zoom” del menu contestuale
dell’immagine di sinistra, apre una nuova finestra, di dimensioni leggermente inferiori a
quelle dello schermo, e vi disegna l’immagine corrente.
La funzione zoom2_Callback, attivata dalla voce “Zoom” del menu contestuale
dell’immagine di destra, apre una nuova finestra, di dimensioni leggermente inferiori a
quelle dello schermo, e vi disegna l’immagine risultante corrente.
La funzione buttonset1_Callback, attivata dalla selezione del pulsante “Set 1” nel pannello
di sinistra, imposta come array corrente dei vari parametri di mistura di gaussiane quello
ottenuto col il set di apprendimento numero 1.
La funzione buttonset2_Callback, attivata dalla selezione del pulsante “Set 2” nel pannello
di sinistra, imposta come array corrente dei vari parametri di mistura di gaussiane quello
ottenuto col il set di apprendimento numero 2.
La funzione panelset_SelectionChangeFcn svolge lo stesso ruolo delle due funzioni appena
descritte, supervisionando l’esclusività mutua dei due pulsanti.
La funzione buttonon_Callback, attivata dalla selezione del pulsante “On” nel pannello di
destra, imposta a 1 il valore della variabile che indica se effettuare la rimozione dei punti
isolati nell’immagine di destra.
La funzione buttonoff_Callback, attivata dalla selezione del pulsante “Off” nel pannello di
destra, imposta a 0 il valore della variabile che indica se effettuare la rimozione dei punti
isolati nell’immagine di destra.
La funzione panelrem_SelectionChangeFcn svolge lo stesso ruolo delle due funzioni appena
descritte, supervisionando l’esclusività mutua dei due pulsanti.
12
La funzione lay_Callback, attivata dalla voce “Layout” del menu “Help/Guide” chiama la
funzione modalguide (descritta in 3.3.3) e non compie nessuna azione, una volta ricevuta la
risposta dell’utente, non importante in questo caso.
La funzione menu_Callback, attivata dalla voce “Menu” del menu “Help/Guide” chiama la
funzione modalmenu (descritta in 3.3.4) e non compie nessuna azione, una volta ricevuta la
risposta dell’utente, non importante in questo caso.
3.3.2
modalabout.m e modalabout.fig
I due file sono stati generati quasi del tutto automaticamente, tramite l’utilità “Guide” di
matlab, e gestiscono la finestra modale contenente i crediti dell’autore dell’interfaccia
grafica. Il testo che compare nella finestra è una proprietà inserita tramite “Guide” e inclusa
nel file .fig, mentre il file .m gestisce la creazione e la chiusura della finestra. Un solo tasto è
disponibile, e permette di chiudere la finestra e tornare a quella principale; lo stesso risultato
può essere ottenuto chiudendo la finestra col tasto di chiusura in alto a destra o premendo il
tasto Escape sulla tastiera. Come già scritto precedentemente, il valore passato dall’utente
alla funzione chiamante EM.m non è rilevante in questo caso.
3.3.3
modalguide.m e modalguide.fig
Anche in questo caso, i due file sono stati generati automaticamente, tramite “Guide”, e
gestiscono la finestra modale di guida al layout dell’interfaccia grafica. Il testo che compare
nella finestra è una proprietà inserita tramite “Guide” e inclusa nel file .fig, mentre il file .m
gestisce la creazione della finestra, l’inserimento dell’icona di aiuto e del pulsante di
chiusura nella parte a sinistra della casella di testo e la chiusura della finestra. La pressione
del pulsante di chiusura della finestra, del tasto di chiusura in alto a destra o del tasto Escape
sulla tastiera, provocano la chiusura della finestra e il passaggio del valore di output alla
funzione chiamante; anche in questo caso, tale valore non è rilevante.
3.3.4
modalmenu.m e modalmenu.fig
Anche in questo caso, i due file sono stati generati automaticamente, tramite “Guide”, e
gestiscono la finestra modale di guida ai menu contestuali e della barra dei menu
dell’interfaccia grafica. Il testo che compare nella finestra è una proprietà inserita tramite
“Guide” e inclusa nel file .fig, mentre il file .m gestisce la creazione della finestra,
l’inserimento dell’icona di aiuto e del pulsante di chiusura nella parte a sinistra della casella
di testo e la chiusura della finestra. La pressione del pulsante di chiusura della finestra, del
tasto di chiusura in alto a destra o del tasto Escape sulla tastiera, provocano la chiusura della
finestra e il passaggio del valore di output alla funzione chiamante; anche in questo caso,
tale valore non è rilevante.
13
3.3.5
modalbox.m e modalbox.fig
Il file .fig e la struttura di base del file .m sono stati generati automaticamente tramite
“Guide”, e gestiscono l’apertura della finestra che elenca il contenuto della cartella corrente,
e il caricamento di file; il valore passato in uscita dall’utente sarà il nome di un file, oppure
le stringhe “No” e “Close”, che producono risultati diversi nella funzione chiamante (si
rimanda a 3.3.1).
Dopo la parte di codice relativa alla creazione della finestra, la funzione
modalbox_OpeningFcn imposta l’output di default a “Clo se”, poi legge la cartella corrente,
ordina il contenuto per nome attribuendo ad ogni riga (nome di cartella o di file) un indice
numerico e mostra l’elenco dei file in una listbox.
Seguono a questo punto le funzioni di posizionamento della finestra, di disegno dell’icona di
aiuto, di impostazione della finestra a modale e di attesa.
La funzione pushbutton1_Callback, invocata dalla pressione del pulsante “Yes”, legge il
valore attualmente selezionato nella lista; se si tratta di una cartella, imposta il nuovo valore
della cartella corrente pari a questo valore attualmente selezionato, e carica il nuovo
contenuto, allo stesso modo di prima: legge la cartella corrente, ordina il contenuto per nome
attribuendo ad ogni riga un indice numerico e mostra l’elenco dei file nella listbox. Se
invece si tratta di un file, il valore di output viene posto uguale al nome del file, e il
comando uiresume interrompe l’attesa e invoca la funzione di uscita, che passerà il nome del
file alla funzione chiamante e chiuderà la finestra modale di caricamento dei file.
La funzione pushbutton2_Callback, invocata dalla pressione del pulsante “No”, passa la
stringa “Close” come valore di uscita.
La prossima funzione che è stata modificata, è la listbox1_Callback, invocata ogni volta che
l’utente modifica la sua selezione all’interno della listbox. Se si tratta di un clic singolo, la
funzione si occupa solo di leggere il nuovo valore della stringa selezionata e di impostare il
valore della variabile che indica se si tratta di una cartella (1) o di un file (0); se invece si
tratta di un doppio clic, se la riga selezionata è quella di una cartella, la funzione imposta il
nuovo valore della cartella corrente pari a questo valore attualmente selezionato, e carica il
nuovo contenuto, allo stesso modo di prima: legge la cartella corrente, ordina il contenuto
per nome attribuendo ad ogni riga un indice numerico e mostra l’elenco dei file nella listbox.
Se invece si tratta di un file, il valore di output viene posto uguale al nome del file, e il
comando uiresume interrompe l’attesa e invoca la funzione di uscita, che passerà il nome del
file alla funzione chiamante e chiuderà la finestra modale di caricamento dei file.
La funzione load_listbox, suggerita nella guida all’utilizzo di “Guide”, è stata lasciata nel
listato ma non è più invocata, in quanto provocava errori: considerata una funzione esterna
all’interfaccia, non aveva la possibilità di modificare variabili condivise dalle funzioni
interne dell’interfaccia; per questo motivo, alle sue chiamate è stato sostituito l’intero corpo
della funzione.
La funzione listbox1_CreateFcn ha il solo compito di impostare i colori della listbox.
14
4
Listati delle funzioni matlab
Per semplicità e per motivi di spazio, le righe vuote sono state eliminate. I commenti sono
riportati in corsivo.
4.1
gmem.m
% GMEM - Gaussian mixture parameters with EM exstimation
% par=gmem(data)
% par=gmem(data,<params>)
% [par,stats] = gmmb_em(...)
% data=NxD matrix, N points, D dimensions.
% params is a list of ('field',value) pairs.
% stats is a matrix (loops, final log-likelihood).
% parameters - default value between ():
% maxloops maximum number of loops. (100)
% thr
convergence threshold: when the log-likelihood change
%
reaches this value, looping stops. Set a negative value
%
to use only the maxloops condition. (1e-6)
% components number of components in Gaussian mixture. (3)
% verbose if 1, progress messages will be printed. (0)
% init
structure with two components, init.mu=DxC matrix,
%
init.sigma=DxDxC array, C=number of components in GM.
%
if not empty, GM parameters will be initialized with
%
these values. ([])
% Example:
% par=gmem(data, 'components', 5, 'thr', 1e-8)
% Author: Cesare Guariniello <[email protected]>
% 01/09/2004
function [estimate,varargout] = gmem(data,varargin);
% default parameters
max_loops=100;
em_threshold=1e-6;
C=3;
verbose=0;
init=[];
% parameter parsing
argc = nargin-1;
for argl = 1:2:(argc-1)
switch lower(varargin{argl}) %conversion to lowercase letters
case 'maxloops'
max_loops=varargin{argl
case 'thr'
em_threshold=varargin{argl+1};
case 'components'
C=varargin{argl+1};
case 'verbose'
verbose=varargin{argl+1};
case 'init'
init=varargin{argl+1};
otherwise
disp(['unknown parameter ' varargin{argl}]);
end
end
N=size(data,1);
D=size(data,2);
if isempty(init)
% mu initialization. Fcm initialization has been choosen because it has
% a random nature (so result will vary), but it's a somehow
% "intelligent" way to initialize our parameters, because it's however
15
% a cluster-center-choosing method, based on fuzzy c-mean clustering.
if C>1
mu=fcm(data, C, [2.0 100 1e-3 verbose]).';
else
% in case of unidimensional distribution, mu is simply the mean value
% of the data.
mu=mean(data, 1).';
end
% covariances initialization. For each component, it's the diagonal
% matrix having the values of the diagonal of covariance calculated on
% the data. The covfixer function forces a matrix to be a valid
% covariance matrix.
sigmat=covfixer(diag(diag(cov(data))));
sigma=zeros(D,D,C);
for i=1:C
sigma(:,:,i)=sigmat;
end
else
C=size(init.mu, 2);
mu=init.mu;
sigma=zeros(D,D,C);
for i=1:C
sigma(:,:,i)=covfixer(init.sigma(:,:,i));
end
end
% weights initialization
weight=ones(C,1)*(1/C);
% values for stopping condition initialization
old_loglike=-realmax;
loops=1;
prob=gmprob(data, mu, sigma, weight); % p(Xj|C=i)p(C=i)
while 1
% one EM cycle
pij = prob ./ (sum(prob,2)*ones(1,C)); %normalization with "alfa"
for i = 1:C
% calculate new estimates
psum=sum(pij(:,i)); %pi
% weights
weight(i) = 1/N*psum; %normalized weights
% mu
nmu=sum(data.*(pij(:,i)*ones(1,D)), 1).' ./ psum;
% .* is array multiply, element by element
mu(:,i)=nmu;
% covariances
moddata = (data - ones(N,1)*(nmu.')) .* (sqrt(pij(:,i))*ones(1,D));
% sqrt(pij) is because it will be squared back
nsigma = (moddata' * moddata) ./ psum;
% covariance matrix goodness forcing
sigma(:,:,i)=covfixer(nsigma);
end
% finish test
prob=gmprob(data, mu, sigma, weight);
loglike=sum(log(sum(prob, 2)));
if verbose
disp([ 'log-likelihood change is ' num2str(loglike-old_loglike) ' on round ' num2str(loops) ]);
end
if abs(loglike-old_loglike)<em_threshold
break;
end
if loops>=max_loops
break;
end
loops=loops+1;
old_loglike=loglike;
end
16
estimate=struct('mu', mu,...
'sigma', sigma,...
'weight', weight);
if(nargout>1)
varargout(1)={[loops loglike]};
end
% -----------------------------------------function prob=gmprob(data, mu, sigma, weight);
N=size(data, 1);
C=size(weight,1);
pxcomp=zeros(N,C);
for i=1:C
pxcomp(:,i)=mvnpdf(data, mu(:,i).', sigma(:,:,i)); %p(Xj|C=i)
end
prob=pxcomp.*repmat(weight.', N,1);
4.2
fcm.m
function [center, U, obj_fcn] = fcm(data, cluster_n, options)
%FCM Data set clustering using fuzzy c-means clustering.
% [CENTER, U, OBJ_FCN] = FCM(DATA, N_CLUSTER) finds N_CLUSTER number of
% clusters in the data set DATA. DATA is size M-by-N, where M is the number of
% data points and N is the number of coordinates for each data point. The
% coordinates for each cluster center are returned in the rows of the matrix
% CENTER. The membership function matrix U contains the grade of membership of
% each DATA point in each cluster. The values 0 and 1 indicate no membership
% and full membership respectively. Grades between 0 and 1 indicate that the
% data point has partial membership in a cluster. At each iteration, an
% objective function is minimized to find the best location for the clusters
% and its values are returned in OBJ_FCN.
% [CENTER, ...] = FCM(DATA,N_CLUSTER,OPTIONS) specifies a vector of options
% for the clustering process:
%
OPTIONS(1): exponent for the matrix U
(default: 2.0)
%
OPTIONS(2): maximum number of iterations
(default: 100)
%
OPTIONS(3): minimum amount of improvement
(default: 1e-5)
%
OPTIONS(4): info display during iteration
(default: 1)
% The clustering process stops when the maximum number of iterations
% is reached, or when the objective function improvement between two
% consecutive iterations is less than the minimum amount of improvement
% specified. Use NaN to select the default value.
% Example
%
data = rand(100,2);
%
[center,U,obj_fcn] = fcm(data,2);
%
plot(data(:,1), data(:,2),'o');
%
hold on;
%
maxU = max(U);
%
% Find the data points with highest grade of membership in cluster 1
%
index1 = find(U(1,:) == maxU);
%
% Find the data points with highest grade of membership in cluster 2
%
index2 = find(U(2,:) == maxU);
%
line(data(index1,1),data(index1,2),'marker','*','color','g');
%
line(data(index2,1),data(index2,2),'marker','*','color','r');
%
% Plot the cluster centers
%
plot([center([1 2],1)],[center([1 2],2)],'*','color','k')
%
hold off;
% See also FCMDEMO, INITFCM, IRISFCM, DISTFCM, STEPFCM.
% Roger Jang, 12-13-94, N. Hickey 04-16-01
% Copyright 1994-2002 The MathWorks, Inc.
% $Revision: 1.13 $ $Date: 2002/04/14 22:20:38 $
if nargin ~= 2 & nargin ~= 3,
error('Too many or too few input arguments!');
17
end
data_n = size(data, 1);
in_n = size(data, 2);
% Change the following to set default options
default_options = [2;
% exponent for the partition matrix U
100;
% max. number of iteration
1e-5;
% min. amount of improvement
1];
% info display during iteration
if nargin == 2,
options = default_options;
else
% If "options" is not fully specified, pad it with default values.
if length(options) < 4,
tmp = default_options;
tmp(1:length(options)) = options;
options = tmp;
end
% If some entries of "options" are nan's, replace them with defaults.
nan_index = find(isnan(options)==1);
options(nan_index) = default_options(nan_index);
if options(1) <= 1,
error('The exponent should be greater than 1!');
end
end
expo = options(1);
% Exponent for U
max_iter = options(2);
% Max. iteration
min_impro = options(3);
% Min. improvement
display = options(4);
% Display info or not
obj_fcn = zeros(max_iter, 1); % Array for objective function
U = initfcm(cluster_n, data_n);
% Initial fuzzy partition
% Main loop
for i = 1:max_iter,
[U, center, obj_fcn(i)] = stepfcm(data, U, cluster_n, expo);
if display,
fprintf('Iteration count = %d, obj. fcn = %f\n', i, obj_fcn(i));
end
% check termination condition
if i > 1,
if abs(obj_fcn(i) - obj_fcn(i-1)) < min_impro, break; end,
end
end
iter_n = i;
% Actual number of iterations
obj_fcn(iter_n+1:max_iter) = [];
4.3
covfixer.m
function nsigma = covfixer(sigma);
% COVFIXER forces matrix to be a valid covariance matrix
% covmatrix=COVFIXER(matrix)
% Matrix is forced to be (complex conjugate) symmetric,
% positive definite and its diagonal real valued.
% isspd() function is taken from the file mvnpdf.m.
D=size(sigma,1);
covfixmat=ones(D)+0.01*diag(ones(D,1));
nsigma=imagfixer(sigma);
while isspd(nsigma)==0
% covariance matrix is not positive definite
% fix it
if any(diag(nsigma)<=0)
% any value of diag is negative
% add 1% of max of diag to diag
18
nsigma=nsigma+(covfixmat-1)*max(abs(diag(nsigma))+realmin);
% realmin is against looping
else
% increase diagonal values by 1 percent
nsigma=nsigma .* covfixmat;
end
end
% -----------------function [t,R] = isspd(Sigma)
% ISSPD Test if a matrix is positive definite symmetric
% T=ISSPD(SIGMA) returns a logical indicating whether the matrix SIGMA is
% square, symmetric, and positive definite, i.e., it is a valid full rank
% covariance matrix.
%
% [T,R]=ISSPD(SIGMA) returns the cholesky factor of SIGMA in R. If SIGMA
% is not square symmetric, ISSPD returns [] in R.
% Test for square, symmetric
[n,m] = size(Sigma);
if (n == m) & all(all(abs(Sigma - Sigma') < 10*eps*max(abs(diag(Sigma)))));
% Test for positive definiteness
[R,p] = chol(Sigma);
if p == 0
t = 1;
else
t = 0;
end
else
R = [];
t = 0;
end
% -----------------function nsigma=imagfixer(sigma);
% force symmetric
nsigma=sigma-(sigma-sigma')/2;
% delete imag
del=imag(diag(nsigma));
nsigma=nsigma-diag(del)*sqrt(-1);
if max(del)>1e-3
WARNING('Big imaginary components removed from the diagonal');
end
4.4
mvnpdf.m
function y = mvnpdf(X, Mu, Sigma)
%MVNPDF Multivariate normal probability density function (pdf).
% Y = MVNPDF(X) returns the n-by-1 vector Y, containing the probability
% density of the multivariate normal distribution with zero mean and
% identity covariance matrix, evaluated at each row of the n-by-d matrix
% X. Rows of X correspond to observations and columns correspond to
% variables or coordinates.
% Y = MVNPDF(X,MU) returns the density of the multivariate normal
% distribution with mean MU and identity covariance matrix, evaluated
% at each row of X. MU is a 1-by-d vector, or an n-by-d matrix, in which
% case the density is evaluated for each row of X with the corresponding
% row of MU. MU can also be a scalar value, which MVNPDF replicates to
% match the size of X.
% Y = MVNPDF(X,MU,SIGMA) returns the density of the multivariate normal
% distribution with mean MU and covariance SIGMA, evaluated at each row
% of X. SIGMA is a d-by-d matrix, or an d-by-d-by-n array, in which case
% the density is evaluated for each row of X with the corresponding page
% of SIGMA, i.e., MVNPDF computes Y(I) using X(I,:) and SIGMA(:,:,I).
19
%
%
%
%
%
%
%
%
%
%
%
%
Pass in the empty matrix for MU to use its default value when you want
to only specify SIGMA.
If X is a 1-by-d vector, MVNPDF replicates it to match the leading
dimension of MU or the trailing dimension of SIGMA.
Example:
mu = [1 -1];
Sigma = [.9 .4; .4 .3];
X = mvnrnd(mu, Sigma, 10);
p = mvnpdf(X, mu, Sigma);
See also MVNRND, NORMPDF.
Copyright 1993-2004 The MathWorks, Inc.
$Revision: 1.2.4.2 $ $Date: 2004/01/16 20:09:41 $
if nargin < 1 | isempty(X)
error('stats:mvnpdf:InputSizeMismatch','Requires the input argument X.');
elseif ndims(X) > 2
error('stats:mvnpdf:InvalidData','X must be a matrix.');
end
% Get size of data. Column vectors provisionally interpreted as multiple scalar data.
[n,d] = size(X);
% Assume zero mean, data are already centered
if nargin < 2 | isempty(Mu)
X0 = X;
% Get scalar mean, and use it to center data
elseif prod(size(Mu)) == 1
X0 = X - Mu;
% Get vector mean, and use it to center data
elseif ndims(Mu) == 2
[n2,d2] = size(Mu);
if d2 ~= d % has to have same number of coords as X
error('stats:mvnpdf:InputSizeMismatch',...
'X and MU must have the same number of columns.');
elseif n2 == n % lengths match
X0 = X - Mu;
elseif n2 == 1 % mean is a single row, rep it out to match data
X0 = X - repmat(Mu,n,1);
elseif n == 1 % data is a single row, rep it out to match mean
n = n2;
X0 = repmat(X,n2,1) - Mu;
else % sizes don't match
error('stats:mvnpdf:InputSizeMismatch',...
'X or MU must be a row vector, or X and MU must have the same number of rows.');
end
else
error('stats:mvnpdf:BadMu','MU must be a matrix.');
end
% Assume identity covariance, data are already standardized
if nargin < 3 | isempty(Sigma)
% Special case: if Sigma isn't supplied, then interpret X
% and Mu as row vectors if they were both column vectors
if d == 1 & prod(size(X)) > 1
X0 = X0';
[n,d] = size(X0);
end
xRinv = X0;
sqrtInvDetSigma = 1;
% Single covariance matrix
elseif ndims(Sigma) == 2
% Special case: if Sigma is supplied, then use it to try to interpret
% X and Mu as row vectors if they were both column vectors.
if (d == 1 & prod(size(X)) > 1) & size(Sigma,1) == n
X0 = X0';
[n,d] = size(X0);
end
% Make sure Sigma is the right size
if size(Sigma,1) ~= d | size(Sigma,2) ~= d
20
error('stats:mvnpdf:BadSigma',...
'SIGMA must be a square matrix with size equal to the number of columns in X.');
else
% Make sure Sigma is a valid covariance matrix
[spd,R] = isspd(Sigma);
if spd
% Create array of standardized data, vector of inverse det
xRinv = X0 / R;
sqrtInvDetSigma = 1 / prod(diag(R));
else
error('stats:mvnpdf:BadSigma',...
'SIGMA must be symmetric and positive definite.');
end
end
% Multiple covariance matrices
elseif ndims(Sigma) == 3
% Special case: if Sigma is supplied, then use it to try to interpret
% X and Mu as row vectors if they were both column vectors.
if (d == 1 & prod(size(X)) > 1) & size(Sigma,1) == n
X0 = X0';
[n,d] = size(X0);
end
% Data and mean are a single row, rep them out to match covariance
if n == 1 % already know size(Sigma,3) > 1
n = size(Sigma,3);
X0 = repmat(X0,n,1); % rep centered data out to match cov
end
% Make sure Sigma is the right size
if size(Sigma,1) ~= d | size(Sigma,2) ~= d
error('stats:mvnpdf:InputSizeMismatch',...
'Each page of SIGMA must be a square matrix with size equal to the number of columns in X.');
elseif size(Sigma,3) ~= n
error('stats:mvnpdf:InputSizeMismatch',...
'SIGMA must have one page for each row of X.');
else
% Create array of standardized data, vector of inverse det
xRinv = zeros(n,d);
sqrtInvDetSigma = zeros(n,1);
for i = 1:n
% Make sure Sigma is a valid covariance matrix
[spd,R] = isspd(Sigma(:,:,i));
if spd
xRinv(i,:) = X0(i,:) / R;
sqrtInvDetSigma(i) = 1 / prod(diag(R));
else
error('stats:mvnpdf:BadSigma',...
'SIGMA must be symmetric and positive definite.');
end
end
end
elseif ndims(Sigma) > 3
error('stats:mvnpdf:BadSigma',...
'SIGMA must be a matrix or a 3 dimensional array.');
end
% Exponents in pdf are the inner products of the standardized data
quadform = sum(xRinv.^2, 2);
y = sqrt((2*pi)^(-d)) * sqrtInvDetSigma .* exp(-0.5*quadform);
4.5
gmpdf.m
% GMPDF Gaussian mixture probability distribution function
% Calculates the probability of each (D-dimensional) point of a vector x
21
% on a C-components Gaussian mixture pdf.
% p = gmpdf (x, mu, sigma, weight)
% x = N x D matrix
% mu = D x C matrix
% sigma = D x D x C array
% weight = C x 1 vector
% p = N x 1 vector
% D dimensions, N points, C components
% Author: Cesare Guariniello <[email protected]>
% 01/09/2004
function [p] = gmpdf(x, mu, sigma, weight);
N=size(x,1);
C=size(weight,1);
p=zeros(N,1);
for i=1:C,
p=p+weight(i)*mvnpdf(x,mu(:,i).',sigma(:,:,i));
end
4.6
gmcluster.m
% GMCLUSTER - Image clustering with gaussian mixture
% imgout=gmcluster(imgin, mu, sigma, weight)
% imgout=gmcluster(imgin, mu, sigma, weight, <params>)
% imgin=HxWx3 array, H height, W width. 16 million colors RGB image
% (can be imported from a .bmp, .jpg, .gif file).
% mu=3xC matrix, C=number of components in GM.
% sigma=3x3xC array.
% weight=Cx1 vector.
% params is a list of ('field',value) pairs.
% function returns imgout=HxW array. 256 tones Gray scale (only B/W used).
% parameters - default between ():
% thr belonging threshold (0<=thr<=1). If the probability density
%
of the GM, evaluated at pixel (i,j) of imgin is higher than
%
threshold, the value of the correspondant pixel of imgout
%
is set at 255, so that this pixel is marked as generated
%
by the GM. (4e-7).
% spr single points removal. If 1, the removal of single black or
%
white pixels from imgout will be performed. (1)
% Example:
% imgout=gmcluster(imgin, mu, sigma, weight, 'thr', 8e-8)
% Author: Cesare Guariniello <[email protected]>
% 03/09/2004
function imgout=gmcluster(imgin,mu,sigma,weight,varargin);
% default parameters
threshold=4e-7;
removal=1;
% Size of data control
if nargin < 4
error('InputSizeMismatch. Requires at least 4 input arguments.');
elseif ndims(imgin) ~= 3 | size(imgin,1)==0 | size(imgin,2)==0 | size(imgin,3) ~= 3
error('InvalidData. First input argument must be a HxWx3 array.');
elseif ndims(mu) ~= 2 | ndims(sigma)~=3 | ndims(weight)~=2| size(mu,1) ~=3 | size(sigma,1)~=3|size(sigma,2)~=3|...
size(weight,2)~=1|size(mu,2)~=size(sigma,3)|size(mu,2)~=size(weight,1)
error('InvalidData. Mu must be a 3xC matrix, sigma must be a 3x3xC array, weight must be a Cx1 vector.');
end
% Parameter parsing
argc = nargin-4;
for argl=1:2:(argc-1)
switch lower(varargin{argl}) %conversion to lowercase letters
case 'thr'
if varargin{argl+1}>=0 & varargin{argl+1}<=1
threshold=varargin{argl+1};
22
else warning('OutOfRange threshold.');
end
case 'spr'
removal=varargin{argl+1};
otherwise
disp(['unknown parameter ' varargin{argl}]);
end
end
H=size(imgin,1);
W=size(imgin,2);
result=zeros(H,W);
for i=1:W,
x=double([imgin(:,i,1),imgin(:,i,2),imgin(:,i,3)]);
p=gmpdf(x, mu, sigma, weight);
for j=1:H,
if p(j)>threshold
result(j,i)=255;
end
end
end
if removal
for i=2:H-1,
for j=2:W-1,
if result(i,j)==0
if (result(i-1,j-1)+result(i-1,j)+result(i-1,j+1)+result(i,j-1)+...
result(i,j+1)+result(i+1,j-1)+result(i+1,j)+result(i+1,j+1))>1400
result(i,j)=255;
end
end
end
end
for i=2:H-1,
for j=2:W-1,
if result(i,j)==255
if (result(i-1,j-1)+result(i-1,j)+result(i-1,j+1)+result(i,j-1)+...
result(i,j+1)+result(i+1,j-1)+result(i+1,j)+result(i+1,j+1))<520
result(i,j)=0;
end
end
end
end
end
imgout=result;
4.7
EM.m
function varargout = EM(varargin)
% EM M-file for EM.fig
%
EM, by itself, creates a new EM or raises the existing
%
singleton*.
%
H = EM returns the handle to a new EM or the handle to
% the existing singleton*.
% EM('CALLBACK',hObject,eventData,handles,...) calls the local
%
function named CALLBACK in EM.M with the given input arguments.
% EM('Property','Value',...) creates a new EM or raises the
%
existing singleton*. Starting from the left, property value pairs are
23
% applied to the GUI before EM_OpeningFunction gets called. An
% unrecognized property name or invalid value makes property application
%
stop. All inputs are passed to EM_OpeningFcn via varargin.
% *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one
% instance to run (singleton)".
% See also: GUIDE, GUIDATA, GUIHANDLES
% Copyright 2002-2003 The MathWorks, Inc.
% Edit the above text to modify the response to help EM
% Last Modified by GUIDE v2.5 06-Sep-2004 01:18:56
% Begin initialization code - DO NOT EDIT
gui_Singleton = 1;
gui_State = struct('gui_Name',
mfilename, ...
'gui_Singleton', gui_Singleton, ...
'gui_OpeningFcn', @EM_OpeningFcn, ...
'gui_OutputFcn', @EM_OutputFcn, ...
'gui_LayoutFcn', [] , ...
'gui_Callback', []);
if nargin && ischar(varargin{1})
gui_State.gui_Callback = str2func(varargin{1});
end
if nargout
[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
gui_mainfcn(gui_State, varargin{:});
end
% End initialization code - DO NOT EDIT
% --- Executes just before EM is made visible.
function EM_OpeningFcn(hObject, eventdata, handles, varargin)
% This function has no output args, see OutputFcn.
% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% varargin command line arguments to EM (see VARARGIN)
load('emstime.mat');
handles.currentimage=imread('DSC00837.jpg');
axes(handles.fig1);
image(handles.currentimage);
handles.currentcomp='st05';
handles.currentthr=3e-7;
handles.currentset=stima2;
handles.currentrem=1;
handles.currentresult=gmcluster(handles.currentimage, handles.currentset.(handles.currentcomp).mu, ...
handles.currentset.(handles.currentcomp).sigma, handles.currentset.(handles.currentcomp).weight, 'thr', handles.currentthr, ...
'spr', handles.currentrem);
axes(handles.fig2);
image(handles.currentresult);colormap(gray);
% Choose default command line output for EM
handles.output = hObject;
% Update handles structure
guidata(hObject, handles);
% UIWAIT makes EM wait for user response (see UIRESUME)
% uiwait(handles.figure1);
% --- Outputs from this function are returned to the command line.
function varargout = EM_OutputFcn(hObject, eventdata, handles)
% varargout cell array for returning output args (see VARARGOUT);
% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Get default command line output from handles structure
varargout{1} = handles.output;
% --- Executes on slider movement.
function slider1_Callback(hObject, eventdata, handles)
% hObject handle to slider1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
temp=uint8(get(hObject, 'Value'));
24
switch temp
case 3
handles.currentcomp='st03';
case 4
handles.currentcomp='st04';
case 5
handles.currentcomp='st05';
case 6
handles.currentcomp='st06';
case 7
handles.currentcomp='st07';
case 8
handles.currentcomp='st08';
case 9
handles.currentcomp='st09';
case 10
handles.currentcomp='st10';
case 11
handles.currentcomp='st11';
end
set(handles.gmctext,'String', int2str(temp));
guidata(hObject, handles);
% Hints: get(hObject,'Value') returns position of slider
%
get(hObject,'Min') and get(hObject,'Max') to determine range of slider
% --- Executes during object creation, after setting all properties.
function slider1_CreateFcn(hObject, eventdata, handles)
% hObject handle to slider1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns called
% Hint: slider controls usually have a light gray background, change
%
'usewhitebg' to 0 to use default. See ISPC and COMPUTER.
usewhitebg = 1;
if usewhitebg
set(hObject,'BackgroundColor',[.9 .9 .9]);
else
set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
end
% --- Executes on slider movement.
function slider2_Callback(hObject, eventdata, handles)
% hObject handle to slider2 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
handles.currentthr=1e-9*get(hObject,'Value');
set(handles.threshtext,'String', int2str(uint16(get(hObject,'Value'))));
guidata(hObject, handles);
% Hints: get(hObject,'Value') returns position of slider
%
get(hObject,'Min') and get(hObject,'Max') to determine range of slider
% --- Executes during object creation, after setting all properties.
function slider2_CreateFcn(hObject, eventdata, handles)
% hObject handle to slider2 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns called
% Hint: slider controls usually have a light gray background, change
%
'usewhitebg' to 0 to use default. See ISPC and COMPUTER.
usewhitebg = 1;
if usewhitebg
set(hObject,'BackgroundColor',[.9 .9 .9]);
else
set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
end
function gmctext_Callback(hObject, eventdata, handles)
% hObject handle to edit1 (see GCBO)
25
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Hints: get(hObject,'String') returns contents of edit1 as text
%
str2double(get(hObject,'String')) returns contents of edit1 as a double
val = uint8(str2double(get(hObject,'String')));
if isnumeric(val) & ...
val >= get(handles.gmcslid,'Min') & ...
val <= get(handles.gmcslid,'Max')
set(handles.gmcslid,'Value',val);
set(hObject,'String', num2str(val));
switch val
case 3
handles.currentcomp='st03';
case 4
handles.currentcomp='st04';
case 5
handles.currentcomp='st05';
case 6
handles.currentcomp='st06';
case 7
handles.currentcomp='st07';
case 8
handles.currentcomp='st08';
case 9
handles.currentcomp='st09';
case 10
handles.currentcomp='st10';
case 11
handles.currentcomp='st11';
end
else
set(hObject,'String', int2str(uint8(get(handles.gmcslid, 'Value'))));
end
guidata(hObject, handles);
% --- Executes during object creation, after setting all properties.
function gmctext_CreateFcn(hObject, eventdata, handles)
% hObject handle to edit1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns called
% Hint: edit controls usually have a white background on Windows.
%
See ISPC and COMPUTER.
if ispc
set(hObject,'BackgroundColor','white');
else
set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
end
function threshtext_Callback(hObject, eventdata, handles)
% hObject handle to edit2 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Hints: get(hObject,'String') returns contents of edit2 as text
%
str2double(get(hObject,'String')) returns contents of edit2 as a double
val = uint16(str2double(get(hObject,'String')));
if isnumeric(val) & ...
val >= get(handles.slider2,'Min') & ...
val <= get(handles.slider2,'Max')
set(handles.slider2,'Value',val);
set(hObject,'String', num2str(val));
handles.currentthr=1e-9*str2double(get(hObject,'Value'));
else
set(hObject,'String', int2str(uint16(get(handles.slider2, 'Value'))));
end
guidata(hObject, handles);
26
% --- Executes during object creation, after setting all properties.
function threshtext_CreateFcn(hObject, eventdata, handles)
% hObject handle to edit2 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns called
% Hint: edit controls usually have a white background on Windows.
%
See ISPC and COMPUTER.
if ispc
set(hObject,'BackgroundColor','white');
else
set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
end
% --- Executes on button press in pushbutton1.
function pushbutton1_Callback(hObject, eventdata, handles)
% hObject handle to pushbutton1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
A=imread('wait.jpg');
axes(handles.fig2);
image(A);
drawnow;
handles.currentresult=gmcluster(handles.currentimage, handles.currentset.(handles.currentcomp).mu, ...
handles.currentset.(handles.currentcomp).sigma, handles.currentset.(handles.currentcomp).weight, 'thr', handles.currentthr, ...
'spr', handles.currentrem);
axes(handles.fig2);
image(handles.currentresult);colormap(gray);
guidata(hObject, handles);
% -------------------------------------------------------------------function white_Callback(hObject, eventdata, handles)
% hObject handle to white (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
A=imread('wait.jpg');
axes(handles.fig2);
image(A);
drawnow;
for i=1:size(handles.currentresult, 1)
for j=1:size(handles.currentresult, 2)
if handles.currentresult(i,j)>0
handles.currentresult(i,j)=255;
end
end
end
axes(handles.fig2);
image(handles.currentresult);colormap(gray);
% -------------------------------------------------------------------function gray_Callback(hObject, eventdata, handles)
% hObject handle to green (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
A=imread('wait.jpg');
axes(handles.fig2);
image(A);
drawnow;
for i=1:size(handles.currentresult, 1)
for j=1:size(handles.currentresult, 2)
if handles.currentresult(i,j)>0
handles.currentresult(i,j)=40;
end
end
end
axes(handles.fig2);
image(handles.currentresult);colormap(gray);
% -------------------------------------------------------------------function pix_Callback(hObject, eventdata, handles)
27
% hObject handle to pix (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
A=imread('wait.jpg');
axes(handles.fig2);
image(A);
drawnow;
for i=1:size(handles.currentresult, 1)
for j=1:size(handles.currentresult, 2)
if handles.currentresult(i,j)>0
handles.currentresult(i,j)=uint8((handles.currentimage(i,j,1)+...
handles.currentimage(i,j,2)+handles.currentimage(i,j,3))/6);
end
end
end
axes(handles.fig2);
image(handles.currentresult);colormap(gray);
% -------------------------------------------------------------------function open_Callback(hObject, eventdata, handles)
% hObject handle to open (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
pos_size = get(handles.figure1,'Position');
% Call modaldlg with the argument 'Position'.
user_response = modalbox('Title','Load');
switch user_response
case 'Close'
case 'No'
errordlg('Error while loading file', 'File error');
otherwise
[path,name,ext,ver] = fileparts(user_response);
switch ext
case '.jpg'
handles.currentimage=imread(user_response);
axes(handles.fig1);
image(handles.currentimage);
case '.JPG'
handles.currentimage=imread(user_response);
axes(handles.fig1);
image(handles.currentimage);
case '.jpeg'
handles.currentimage=imread(user_response);
axes(handles.fig1);
image(handles.currentimage);
case '.JPEG'
handles.currentimage=imread(user_response);
axes(handles.fig1);
image(handles.currentimage);
case '.bmp'
handles.currentimage=imread(user_response);
axes(handles.fig1);
image(handles.currentimage);
case '.BMP'
handles.currentimage=imread(user_response);
axes(handles.fig1);
image(handles.currentimage);
case '.gif'
handles.currentimage=imread(user_response);
axes(handles.fig1);
image(handles.currentimage);
case '.GIF'
handles.currentimage=imread(user_response);
axes(handles.fig1);
image(handles.currentimage);
otherwise
errordlg('Error while loading file', 'File error');
28
end
end
guidata(hObject,handles);
% -------------------------------------------------------------------function defa_Callback(hObject, eventdata, handles)
% hObject handle to defa (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
load('emstime.mat');
handles.currentimage=imread('DSC00837.jpg');
axes(handles.fig1);
image(handles.currentimage);
handles.currentcomp='st05';
handles.currentthr=3e-7;
handles.currentset=stima2;
handles.currentrem=1;
A=imread('wait.jpg');
axes(handles.fig2);
image(A);
drawnow;
handles.currentresult=gmcluster(handles.currentimage, handles.currentset.(handles.currentcomp).mu, ...
handles.currentset.(handles.currentcomp).sigma, handles.currentset.(handles.currentcomp).weight, 'thr', handles.currentthr, ...
'spr', handles.currentrem);
axes(handles.fig2);
image(handles.currentresult);colormap(gray);
set(handles.gmctext,'String', 5);
set(handles.gmcslid,'Value', 5);
set(handles.threshtext,'String', 300);
set(handles.slider2,'Value', 300);
set(handles.buttonset2,'Value',get(handles.buttonset2, 'Max'));
set(handles.buttonon,'Value',get(handles.buttonon, 'Max'));
guidata(hObject, handles);
% -------------------------------------------------------------------function clus_Callback(hObject, eventdata, handles)
% hObject handle to clus (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% -------------------------------------------------------------------function gud_Callback(hObject, eventdata, handles)
% hObject handle to guide (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% -------------------------------------------------------------------function about_Callback(hObject, eventdata, handles)
% hObject handle to about (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
pos_size = get(handles.figure1,'Position');
% Call modaldlg with the argument 'Position'.
user_response = modalabout('Title','About');
switch user_response
case {'Close'}
end
% -------------------------------------------------------------------function file_Callback(hObject, eventdata, handles)
% hObject handle to file (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% -------------------------------------------------------------------function view_Callback(hObject, eventdata, handles)
% hObject handle to view (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% -------------------------------------------------------------------function help_Callback(hObject, eventdata, handles)
% hObject handle to help (see GCBO)
29
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% -------------------------------------------------------------------function zoom_Callback(hObject, eventdata, handles)
% hObject handle to zoom (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
scrsz = get(0,'ScreenSize');
figure('Position',[30 scrsz(4)-80 scrsz(3)-130 scrsz(4)-130]);
image(handles.currentimage);
% -------------------------------------------------------------------function zoom2_Callback(hObject, eventdata, handles)
% hObject handle to zoom2 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
scrsz = get(0,'ScreenSize');
figure('Position',[30 scrsz(4)-80 scrsz(3)-130 scrsz(4)-130]);
image(handles.currentresult);colormap(gray);
% -------------------------------------------------------------------function context_1_Callback(hObject, eventdata, handles)
% hObject handle to context_1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% -------------------------------------------------------------------function context_2_Callback(hObject, eventdata, handles)
% hObject handle to context_2 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% --- Executes on button press in buttonset1.
function buttonset1_Callback(hObject, eventdata, handles)
% hObject handle to buttonset1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
if get(hObject, 'Value')==get(hObject, 'Max')
load('emstime.mat');
handles.currentset=stima;
guidata(hObject, handles);
end
% Hint: get(hObject,'Value') returns toggle state of buttonset1
% --- Executes on button press in buttonset2.
function buttonset2_Callback(hObject, eventdata, handles)
% hObject handle to buttonset2 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
if get(hObject, 'Value')==get(hObject, 'Max')
load('emstime.mat');
handles.currentset=stima2;
guidata(hObject, handles);
end
% Hint: get(hObject,'Value') returns toggle state of buttonset2
% -------------------------------------------------------------------function panelset_SelectionChangeFcn(hObject, eventdata, handles)
% hObject handle to panelset (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
selection = get(hObject,'SelectedObject');
switch get(selection,'Tag')
case 'buttonset1'
load('emstime.mat');
handles.currentset=stima;
% code piece when radiobutton1 is selected goes here
case 'buttonset2'
load('emstime.mat');
handles.currentset=stima2;
30
% code piece when radiobutton2 is selected goes here
% ...
end
guidata(hObject, handles);
% --- Executes on button press in buttonon.
function buttonon_Callback(hObject, eventdata, handles)
% hObject handle to buttonon (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
if get(hObject, 'Value')==get(hObject, 'Max')
handles.currentrem=1;
guidata(hObject, handles);
end
% Hint: get(hObject,'Value') returns toggle state of buttonon
% --- Executes on button press in buttonoff.
function buttonoff_Callback(hObject, eventdata, handles)
% hObject handle to buttonoff (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
if get(hObject, 'Value')==get(hObject, 'Max')
handles.currentrem=0;
guidata(hObject, handles);
end
% Hint: get(hObject,'Value') returns toggle state of buttonoff
% -------------------------------------------------------------------function panelrem_SelectionChangeFcn(hObject, eventdata, handles)
% hObject handle to panelrem (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
selection = get(hObject,'SelectedObject');
switch get(selection,'Tag')
case 'buttonon'
handles.currentset=1;
% code piece when radiobutton1 is selected goes here
case 'buttonoff'
handles.currentrem=0;
% code piece when radiobutton2 is selected goes here
% ...
end
guidata(hObject, handles);
% -------------------------------------------------------------------function lay_Callback(hObject, eventdata, handles)
% hObject handle to lay (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
pos_size = get(handles.figure1,'Position');
% Call modaldlg with the argument 'Position'.
user_response = modalguide('Title','Layout guide');
switch user_response
case {'Close'}
end
% -------------------------------------------------------------------function menu_Callback(hObject, eventdata, handles)
% hObject handle to menu (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
pos_size = get(handles.figure1,'Position');
% Call modaldlg with the argument 'Position'.
user_response = modalmenu('Title','Menu guide');
switch user_response
case {'Close'}
end
31
4.8
modalabout.m
function varargout = modalabout(varargin)
% MODALABOUT M-file for modalabout.fig
%
MODALABOUT by itself, creates a new MODALABOUT or raises the
% existing singleton*.
% H = MODALABOUT returns the handle to a new MODALABOUT or the handle to
% the existing singleton*.
% MODALABOUT('CALLBACK',hObject,eventData,handles,...) calls the local
% function named CALLBACK in MODALABOUT.M with the given input arguments.
%
MODALABOUT('Property','Value',...) creates a new MODALABOUT or raises the
%
existing singleton*. Starting from the left, property value pairs are
% applied to the GUI before modalabout_OpeningFunction gets called. An
% unrecognized property name or invalid value makes property application
%
stop. All inputs are passed to modalabout_OpeningFcn via varargin.
%
*See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one
%
instance to run (singleton)".
% See also: GUIDE, GUIDATA, GUIHANDLES
% Copyright 2002-2003 The MathWorks, Inc.
% Edit the above text to modify the response to help modalabout
% Last Modified by GUIDE v2.5 25-Mar-2002 12:19:15
% Begin initialization code - DO NOT EDIT
gui_Singleton = 1;
gui_State = struct('gui_Name',
mfilename, ...
'gui_Singleton', gui_Singleton, ...
'gui_OpeningFcn', @modalabout_OpeningFcn, ...
'gui_OutputFcn', @modalabout_OutputFcn, ...
'gui_LayoutFcn', [] , ...
'gui_Callback', []);
if nargin && ischar(varargin{1})
gui_State.gui_Callback = str2func(varargin{1});
end
if nargout
[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
gui_mainfcn(gui_State, varargin{:});
end
% End initialization code - DO NOT EDIT
% --- Executes just before modalabout is made visible.
function modalabout_OpeningFcn(hObject, eventdata, handles, varargin)
% This function has no output args, see OutputFcn.
% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% varargin command line arguments to modalabout (see VARARGIN)
% Choose default command line output for modalabout
handles.output = 'Yes';
% Update handles structure
guidata(hObject, handles);
% Insert custom Title and Text if specified by the user
% Hint: when choosing keywords, be sure they are not easily confused
% with existing figure properties. See the output of set(figure) for
% a list of figure properties.
if(nargin > 3)
for index = 1:2:(nargin-3),
if nargin-3==index, break, end
switch lower(varargin{index})
case 'title'
set(hObject, 'Name', varargin{index+1});
32
case 'string'
set(handles.text1, 'String', varargin{index+1});
end
end
end
% Determine the position of the dialog - centered on the callback figure
% if available, else, centered on the screen
FigPos=get(0,'DefaultFigurePosition');
OldUnits = get(hObject, 'Units');
set(hObject, 'Units', 'pixels');
OldPos = get(hObject,'Position');
FigWidth = OldPos(3);
FigHeight = OldPos(4);
if isempty(gcbf)
ScreenUnits=get(0,'Units');
set(0,'Units','pixels');
ScreenSize=get(0,'ScreenSize');
set(0,'Units',ScreenUnits);
FigPos(1)=1/2*(ScreenSize(3)-FigWidth);
FigPos(2)=2/3*(ScreenSize(4)-FigHeight);
else
GCBFOldUnits = get(gcbf,'Units');
set(gcbf,'Units','pixels');
GCBFPos = get(gcbf,'Position');
set(gcbf,'Units',GCBFOldUnits);
FigPos(1:2) = [(GCBFPos(1) + GCBFPos(3) / 2) - FigWidth / 2, ...
(GCBFPos(2) + GCBFPos(4) / 2) - FigHeight / 2];
end
FigPos(3:4)=[FigWidth FigHeight];
set(hObject, 'Position', FigPos);
set(hObject, 'Units', OldUnits);
% Make the GUI modal
set(handles.figure1,'WindowStyle','modal')
% UIWAIT makes modalabout wait for user response (see UIRESUME)
uiwait(handles.figure1);
% --- Outputs from this function are returned to the command line.
function varargout = modalabout_OutputFcn(hObject, eventdata, handles)
% varargout cell array for returning output args (see VARARGOUT);
% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Get default command line output from handles structure
varargout{1} = handles.output;
% The figure can be deleted now
delete(handles.figure1);
% --- Executes on button press in pushbutton1.
function pushbutton1_Callback(hObject, eventdata, handles)
% hObject handle to pushbutton1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
handles.output = get(hObject,'String');
% Update handles structure
guidata(hObject, handles);
% Use UIRESUME instead of delete because the OutputFcn needs
% to get the updated handles structure.
uiresume(handles.figure1);
% --- Executes on button press in pushbutton2.
function pushbutton2_Callback(hObject, eventdata, handles)
% hObject handle to pushbutton2 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
handles.output = get(hObject,'String');
% Update handles structure
guidata(hObject, handles);
% Use UIRESUME instead of delete because the OutputFcn needs
% to get the updated handles structure.
33
uiresume(handles.figure1);
% --- Executes when user attempts to close figure1.
function figure1_CloseRequestFcn(hObject, eventdata, handles)
% hObject handle to figure1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
if isequal(get(handles.figure1, 'waitstatus'), 'waiting')
% The GUI is still in UIWAIT, us UIRESUME
uiresume(handles.figure1);
else
% The GUI is no longer waiting, just close it
delete(handles.figure1);
end
% --- Executes on key press over figure1 with no controls selected.
function figure1_KeyPressFcn(hObject, eventdata, handles)
% hObject handle to figure1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Check for "enter" or "escape"
if isequal(get(hObject,'CurrentKey'),'escape')
% User said no by hitting escape
handles.output = 'No';
% Update handles structure
guidata(hObject, handles);
uiresume(handles.figure1);
end
if isequal(get(hObject,'CurrentKey'),'return')
uiresume(handles.figure1);
end
4.9
modalguide.m
function varargout = modalguide(varargin)
% MODALGUIDE M-file for modalguide.fig
%
MODALGUIDE by itself, creates a new MODALGUIDE or raises the
% existing singleton*.
%
H = MODALGUIDE returns the handle to a new MODALGUIDE or the handle to
% the existing singleton*.
%
MODALGUIDE('CALLBACK',hObject,eventData,handles,...) calls the local
% function named CALLBACK in MODALGUIDE.M with the given input arguments.
% MODALGUIDE('Property','Value',...) creates a new MODALGUIDE or raises the
%
existing singleton*. Starting from the left, property value pairs are
% applied to the GUI before modalguide_OpeningFunction gets called. An
%
unrecognized property name or invalid value makes property application
%
stop. All inputs are passed to modalguide_OpeningFcn via varargin.
% *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one
%
instance to run (singleton)".
% See also: GUIDE, GUIDATA, GUIHANDLES
% Copyright 2002-2003 The MathWorks, Inc.
% Edit the above text to modify the response to help modalguide
% Last Modified by GUIDE v2.5 25-Mar-2002 12:19:15
% Begin initialization code - DO NOT EDIT
gui_Singleton = 1;
gui_State = struct('gui_Name',
mfilename, ...
'gui_Singleton', gui_Singleton, ...
'gui_OpeningFcn', @modalguide_OpeningFcn, ...
'gui_OutputFcn', @modalguide_OutputFcn, ...
'gui_LayoutFcn', [] , ...
34
'gui_Callback', []);
if nargin && ischar(varargin{1})
gui_State.gui_Callback = str2func(varargin{1});
end
if nargout
[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
gui_mainfcn(gui_State, varargin{:});
end
% End initialization code - DO NOT EDIT
% --- Executes just before modalguide is made visible.
function modalguide_OpeningFcn(hObject, eventdata, handles, varargin)
% This function has no output args, see OutputFcn.
% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% varargin command line arguments to modalguide (see VARARGIN)
% Choose default command line output for modalguide
handles.output = 'Yes';
% Update handles structure
guidata(hObject, handles);
% Insert custom Title and Text if specified by the user
% Hint: when choosing keywords, be sure they are not easily confused
% with existing figure properties. See the output of set(figure) for
% a list of figure properties.
if(nargin > 3)
for index = 1:2:(nargin-3),
if nargin-3==index, break, end
switch lower(varargin{index})
case 'title'
set(hObject, 'Name', varargin{index+1});
case 'string'
set(handles.text1, 'String', varargin{index+1});
end
end
end
% Determine the position of the dialog - centered on the callback figure
% if available, else, centered on the screen
FigPos=get(0,'DefaultFigurePosition');
OldUnits = get(hObject, 'Units');
set(hObject, 'Units', 'pixels');
OldPos = get(hObject,'Position');
FigWidth = OldPos(3);
FigHeight = OldPos(4);
if isempty(gcbf)
ScreenUnits=get(0,'Units');
set(0,'Units','pixels');
ScreenSize=get(0,'ScreenSize');
set(0,'Units',ScreenUnits);
FigPos(1)=1/2*(ScreenSize(3)-FigWidth);
FigPos(2)=2/3*(ScreenSize(4)-FigHeight);
else
GCBFOldUnits = get(gcbf,'Units');
set(gcbf,'Units','pixels');
GCBFPos = get(gcbf,'Position');
set(gcbf,'Units',GCBFOldUnits);
FigPos(1:2) = [(GCBFPos(1) + GCBFPos(3) / 2) - FigWidth / 2, ...
(GCBFPos(2) + GCBFPos(4) / 2) - FigHeight / 2];
end
FigPos(3:4)=[FigWidth FigHeight];
set(hObject, 'Position', FigPos);
set(hObject, 'Units', OldUnits);
% Show a question icon from dialogicons.mat - variables questIconData
35
% and questIconMap
load dialogicons.mat
IconData=questIconData;
questIconMap(256,:) = get(handles.figure1, 'Color');
IconCMap=questIconMap;
Img=image(IconData, 'Parent', handles.axes1);
set(handles.figure1, 'Colormap', IconCMap);
set(handles.axes1, ...
'Visible', 'off', ...
'YDir' , 'reverse'
, ...
'XLim' , get(Img,'XData'), ...
'YLim' , get(Img,'YData') ...
);
% Make the GUI modal
set(handles.figure1,'WindowStyle','modal')
% UIWAIT makes modalguide wait for user response (see UIRESUME)
uiwait(handles.figure1);
% --- Outputs from this function are returned to the command line.
function varargout = modalguide_OutputFcn(hObject, eventdata, handles)
% varargout cell array for returning output args (see VARARGOUT);
% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Get default command line output from handles structure
varargout{1} = handles.output;
% The figure can be deleted now
delete(handles.figure1);
% --- Executes on button press in pushbutton1.
function pushbutton1_Callback(hObject, eventdata, handles)
% hObject handle to pushbutton1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
handles.output = get(hObject,'String');
% Update handles structure
guidata(hObject, handles);
% Use UIRESUME instead of delete because the OutputFcn needs
% to get the updated handles structure.
uiresume(handles.figure1);
% --- Executes on button press in pushbutton2.
function pushbutton2_Callback(hObject, eventdata, handles)
% hObject handle to pushbutton2 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
handles.output = get(hObject,'String');
% Update handles structure
guidata(hObject, handles);
% Use UIRESUME instead of delete because the OutputFcn needs
% to get the updated handles structure.
uiresume(handles.figure1);
% --- Executes when user attempts to close figure1.
function figure1_CloseRequestFcn(hObject, eventdata, handles)
% hObject handle to figure1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
if isequal(get(handles.figure1, 'waitstatus'), 'waiting')
% The GUI is still in UIWAIT, us UIRESUME
uiresume(handles.figure1);
else
% The GUI is no longer waiting, just close it
delete(handles.figure1);
end
% --- Executes on key press over figure1 with no controls selected.
function figure1_KeyPressFcn(hObject, eventdata, handles)
% hObject handle to figure1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
36
% Check for "enter" or "escape"
if isequal(get(hObject,'CurrentKey'),'escape')
% User said no by hitting escape
handles.output = 'No';
% Update handles structure
guidata(hObject, handles);
uiresume(handles.figure1);
end
if isequal(get(hObject,'CurrentKey'),'return')
uiresume(handles.figure1);
end
4.10
modalmenu.m
function varargout = modalmenu(varargin)
% MODALMENU M-file for modalmenu.fig
% MODALMENU by itself, creates a new MODALMENU or raises the
% existing singleton*.
%
H = MODALMENU returns the handle to a new MODALMENU or the handle to
% the existing singleton*.
% MODALMENU('CALLBACK',hObject,eventData,handles,...) calls the local
%
function named CALLBACK in MODALMENU.M with the given input arguments.
%
MODALMENU('Property','Value',...) creates a new MODALMENU or raises the
%
existing singleton*. Starting from the left, property value pairs are
% applied to the GUI before modalmenu_OpeningFunction gets called. An
% unrecognized property name or invalid value makes property application
%
stop. All inputs are passed to modalmenu_OpeningFcn via varargin.
% *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one
%
instance to run (singleton)".
% See also: GUIDE, GUIDATA, GUIHANDLES
% Copyright 2002-2003 The MathWorks, Inc.
% Edit the above text to modify the response to help modalmenu
% Last Modified by GUIDE v2.5 25-Mar-2002 12:19:15
% Begin initialization code - DO NOT EDIT
gui_Singleton = 1;
gui_State = struct('gui_Name',
mfilename, ...
'gui_Singleton', gui_Singleton, ...
'gui_OpeningFcn', @modalmenu_OpeningFcn, ...
'gui_OutputFcn', @modalmenu_OutputFcn, ...
'gui_LayoutFcn', [] , ...
'gui_Callback', []);
if nargin && ischar(varargin{1})
gui_State.gui_Callback = str2func(varargin{1});
end
if nargout
[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
gui_mainfcn(gui_State, varargin{:});
end
% End initialization code - DO NOT EDIT
% --- Executes just before modalmenu is made visible.
function modalmenu_OpeningFcn(hObject, eventdata, handles, varargin)
% This function has no output args, see OutputFcn.
% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% varargin command line arguments to modalmenu (see VARARGIN)
37
% Choose default command line output for modalmenu
handles.output = 'Yes';
% Update handles structure
guidata(hObject, handles);
% Insert custom Title and Text if specified by the user
% Hint: when choosing keywords, be sure they are not easily confused
% with existing figure properties. See the output of set(figure) for
% a list of figure properties.
if(nargin > 3)
for index = 1:2:(nargin-3),
if nargin-3==index, break, end
switch lower(varargin{index})
case 'title'
set(hObject, 'Name', varargin{index+1});
case 'string'
set(handles.text1, 'String', varargin{index+1});
end
end
end
% Determine the position of the dialog - centered on the callback figure
% if available, else, centered on the screen
FigPos=get(0,'DefaultFigurePosition');
OldUnits = get(hObject, 'Units');
set(hObject, 'Units', 'pixels');
OldPos = get(hObject,'Position');
FigWidth = OldPos(3);
FigHeight = OldPos(4);
if isempty(gcbf)
ScreenUnits=get(0,'Units');
set(0,'Units','pixels');
ScreenSize=get(0,'ScreenSize');
set(0,'Units',ScreenUnits);
FigPos(1)=1/2*(ScreenSize(3)-FigWidth);
FigPos(2)=2/3*(ScreenSize(4)-FigHeight);
else
GCBFOldUnits = get(gcbf,'Units');
set(gcbf,'Units','pixels');
GCBFPos = get(gcbf,'Position');
set(gcbf,'Units',GCBFOldUnits);
FigPos(1:2) = [(GCBFPos(1) + GCBFPos(3) / 2) - FigWidth / 2, ...
(GCBFPos(2) + GCBFPos(4) / 2) - FigHeight / 2];
end
FigPos(3:4)=[FigWidth FigHeight];
set(hObject, 'Position', FigPos);
set(hObject, 'Units', OldUnits);
% Show a question icon from dialogicons.mat - variables questIconData
% and questIconMap
load dialogicons.mat
IconData=questIconData;
questIconMap(256,:) = get(handles.figure1, 'Color');
IconCMap=questIconMap;
Img=image(IconData, 'Parent', handles.axes1);
set(handles.figure1, 'Colormap', IconCMap);
set(handles.axes1, ...
'Visible', 'off', ...
'YDir' , 'reverse'
, ...
'XLim' , get(Img,'XData'), ...
'YLim' , get(Img,'YData') ...
);
% Make the GUI modal
set(handles.figure1,'WindowStyle','modal')
% UIWAIT makes modalmenu wait for user response (see UIRESUME)
uiwait(handles.figure1);
% --- Outputs from this function are returned to the command line.
38
function varargout = modalmenu_OutputFcn(hObject, eventdata, handles)
% varargout cell array for returning output args (see VARARGOUT);
% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Get default command line output from handles structure
varargout{1} = handles.output;
% The figure can be deleted now
delete(handles.figure1);
% --- Executes on button press in pushbutton1.
function pushbutton1_Callback(hObject, eventdata, handles)
% hObject handle to pushbutton1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
handles.output = get(hObject,'String');
% Update handles structure
guidata(hObject, handles);
% Use UIRESUME instead of delete because the OutputFcn needs
% to get the updated handles structure.
uiresume(handles.figure1);
% --- Executes on button press in pushbutton2.
function pushbutton2_Callback(hObject, eventdata, handles)
% hObject handle to pushbutton2 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
handles.output = get(hObject,'String');
% Update handles structure
guidata(hObject, handles);
% Use UIRESUME instead of delete because the OutputFcn needs
% to get the updated handles structure.
uiresume(handles.figure1);
% --- Executes when user attempts to close figure1.
function figure1_CloseRequestFcn(hObject, eventdata, handles)
% hObject handle to figure1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
if isequal(get(handles.figure1, 'waitstatus'), 'waiting')
% The GUI is still in UIWAIT, us UIRESUME
uiresume(handles.figure1);
else
% The GUI is no longer waiting, just close it
delete(handles.figure1);
end
% --- Executes on key press over figure1 with no controls selected.
function figure1_KeyPressFcn(hObject, eventdata, handles)
% hObject handle to figure1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Check for "enter" or "escape"
if isequal(get(hObject,'CurrentKey'),'escape')
% User said no by hitting escape
handles.output = 'No';
% Update handles structure
guidata(hObject, handles);
uiresume(handles.figure1);
end
if isequal(get(hObject,'CurrentKey'),'return')
uiresume(handles.figure1);
end
39
4.11
modalbox.m
function varargout = modalbox(varargin)
% MODALBOX M-file for modalbox.fig
%
MODALBOX by itself, creates a new MODALBOX or raises the
% existing singleton*.
% H = MODALBOX returns the handle to a new MODALBOX or the handle to
% the existing singleton*.
% MODALBOX('CALLBACK',hObject,eventData,handles,...) calls the local
%
function named CALLBACK in MODALBOX.M with the given input arguments.
% MODALBOX('Property','Value',...) creates a new MODALBOX or raises the
%
existing singleton*. Starting from the left, property value pairs are
% applied to the GUI before modalbox_OpeningFunction gets called. An
% unrecognized property name or invalid value makes property application
%
stop. All inputs are passed to modalbox_OpeningFcn via varargin.
%
*See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one
%
instance to run (singleton)".
% See also: GUIDE, GUIDATA, GUIHANDLES
% Copyright 2002-2003 The MathWorks, Inc.
% Edit the above text to modify the response to help modalbox
% Last Modified by GUIDE v2.5 06-Sep-2004 17:19:03
% Begin initialization code - DO NOT EDIT
gui_Singleton = 1;
gui_State = struct('gui_Name',
mfilename, ...
'gui_Singleton', gui_Singleton, ...
'gui_OpeningFcn', @modalbox_OpeningFcn, ...
'gui_OutputFcn', @modalbox_OutputFcn, ...
'gui_LayoutFcn', [] , ...
'gui_Callback', []);
if nargin && ischar(varargin{1})
gui_State.gui_Callback = str2func(varargin{1});
end
if nargout
[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
gui_mainfcn(gui_State, varargin{:});
end
% End initialization code - DO NOT EDIT
% --- Executes just before modalbox is made visible.
function modalbox_OpeningFcn(hObject, eventdata, handles, varargin)
% This function has no output args, see OutputFcn.
% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% varargin command line arguments to modalbox (see VARARGIN)
% Choose default command line output for modalbox
handles.output = 'No';
handles.file = 'No';
handles.dir=1;
guidata(hObject,handles);
cd (pwd);
dir_struct = dir(pwd);
[sorted_names,sorted_index] = sortrows({dir_struct.name}');
handles.file_names = sorted_names;
handles.is_dir = [dir_struct.isdir];
handles.sorted_index = [sorted_index];
guidata(hObject,handles);
set(handles.listbox1,'String',handles.file_names,...
'Value',1);
set(handles.text1,'String',pwd);
40
guidata(hObject, handles);
handles.index_selected = get(handles.listbox1,'Value');
handles.file_list = get(handles.listbox1,'String');
handles.filename = handles.file_list{handles.index_selected};
% Update handles structure
guidata(hObject, handles);
% Insert custom Title and Text if specified by the user
% Hint: when choosing keywords, be sure they are not easily confused
% with existing figure properties. See the output of set(figure) for
% a list of figure properties.
if(nargin > 3)
for index = 1:2:(nargin-3),
if nargin-3==index, break, end
switch lower(varargin{index})
case 'title'
set(hObject, 'Name', varargin{index+1});
case 'string'
set(handles.text1, 'String', varargin{index+1});
end
end
end
% Determine the position of the dialog - centered on the callback figure
% if available, else, centered on the screen
FigPos=get(0,'DefaultFigurePosition');
OldUnits = get(hObject, 'Units');
set(hObject, 'Units', 'pixels');
OldPos = get(hObject,'Position');
FigWidth = OldPos(3);
FigHeight = OldPos(4);
if isempty(gcbf)
ScreenUnits=get(0,'Units');
set(0,'Units','pixels');
ScreenSize=get(0,'ScreenSize');
set(0,'Units',ScreenUnits);
FigPos(1)=1/2*(ScreenSize(3)-FigWidth);
FigPos(2)=2/3*(ScreenSize(4)-FigHeight);
else
GCBFOldUnits = get(gcbf,'Units');
set(gcbf,'Units','pixels');
GCBFPos = get(gcbf,'Position');
set(gcbf,'Units',GCBFOldUnits);
FigPos(1:2) = [(GCBFPos(1) + GCBFPos(3) / 2) - FigWidth / 2, ...
(GCBFPos(2) + GCBFPos(4) / 2) - FigHeight / 2];
end
FigPos(3:4)=[FigWidth FigHeight];
set(hObject, 'Position', FigPos);
set(hObject, 'Units', OldUnits);
% Show a question icon from dialogicons.mat - variables questIconData
% and questIconMap
load dialogicons.mat
IconData=helpIconData;
questIconMap(256,:) = get(handles.figure1, 'Color');
IconCMap=helpIconMap;
Img=image(IconData, 'Parent', handles.axes1);
set(handles.figure1, 'Colormap', IconCMap);
set(handles.axes1, ...
'Visible', 'off', ...
'YDir' , 'reverse'
, ...
'XLim' , get(Img,'XData'), ...
'YLim' , get(Img,'YData') ...
);
% Make the GUI modal
set(handles.figure1,'WindowStyle','modal')
41
% UIWAIT makes modalbox wait for user response (see UIRESUME)
uiwait(handles.figure1);
% --- Outputs from this function are returned to the command line.
function varargout = modalbox_OutputFcn(hObject, eventdata, handles)
% varargout cell array for returning output args (see VARARGOUT);
% hObject handle to figure
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Get default command line output from handles structure
varargout{1} = handles.output;
% The figure can be deleted now
delete(handles.figure1);
% --- Executes on button press in pushbutton1.
function pushbutton1_Callback(hObject, eventdata, handles)
% hObject handle to pushbutton1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
if handles.dir==1;
cd(handles.filename);
%load_listbox(pwd,handles);
dir_struct = dir(pwd);
[sorted_names,sorted_index] = sortrows({dir_struct.name}');
handles.file_names = [sorted_names];
handles.is_dir = [dir_struct.isdir];
handles.sorted_index = [sorted_index];
guidata(hObject,handles);
set(handles.listbox1,'String',handles.file_names,...
'Value',1);
set(handles.text1,'String',pwd);
guidata(hObject,handles);
else
handles.output = handles.filename;
uiresume(handles.figure1);
end
% Update handles structure
guidata(hObject, handles);
% Use UIRESUME instead of delete because the OutputFcn needs
% to get the updated handles structure.
% --- Executes on button press in pushbutton2.
function pushbutton2_Callback(hObject, eventdata, handles)
% hObject handle to pushbutton2 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
handles.output = 'Close';
% Update handles structure
guidata(hObject, handles);
% Use UIRESUME instead of delete because the OutputFcn needs
% to get the updated handles structure.
uiresume(handles.figure1);
% --- Executes when user attempts to close figure1.
function figure1_CloseRequestFcn(hObject, eventdata, handles)
% hObject handle to figure1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
if isequal(get(handles.figure1, 'waitstatus'), 'waiting')
% The GUI is still in UIWAIT, us UIRESUME
uiresume(handles.figure1);
else
% The GUI is no longer waiting, just close it
delete(handles.figure1);
end
42
% --- Executes on key press over figure1 with no controls selected.
function figure1_KeyPressFcn(hObject, eventdata, handles)
% hObject handle to figure1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Check for "enter" or "escape"
if isequal(get(hObject,'CurrentKey'),'escape')
% User said no by hitting escape
handles.output = 'Close';
% Update handles structure
guidata(hObject, handles);
uiresume(handles.figure1);
end
if isequal(get(hObject,'CurrentKey'),'return')
uiresume(handles.figure1);
end
% --- Executes on selection change in listbox1.
function listbox1_Callback(hObject, eventdata, handles)
% hObject handle to listbox1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles structure with handles and user data (see GUIDATA)
% Hints: contents = get(hObject,'String') returns listbox1 contents as cell array
%
contents{get(hObject,'Value')} returns selected item from listbox1
get(handles.figure1,'SelectionType');
if strcmp(get(handles.figure1,'SelectionType'),'normal')
handles.index_selected = get(handles.listbox1,'Value');
handles.file_list = get(handles.listbox1,'String');
handles.filename = handles.file_list{handles.index_selected};
if handles.is_dir(handles.sorted_index(handles.index_selected))
handles.dir=1;
else handles.dir=0;
end
guidata(hObject,handles);
end
if strcmp(get(handles.figure1,'SelectionType'),'open')
index_selected = get(handles.listbox1,'Value');
file_list = get(handles.listbox1,'String');
filename = file_list{index_selected};
if handles.is_dir(handles.sorted_index(index_selected))
cd(filename);
%load_listbox(pwd,handles);
dir_struct = dir(pwd);
[sorted_names,sorted_index] = sortrows({dir_struct.name}');
handles.file_names = [sorted_names];
handles.is_dir = [dir_struct.isdir];
handles.sorted_index = [sorted_index];
guidata(hObject,handles);
set(handles.listbox1,'String',handles.file_names,...
'Value',1);
set(handles.text1,'String',pwd);
guidata(hObject,handles);
else
handles.output=handles.filename;
uiresume(handles.figure1);
end
end
guidata(hObject, handles);
% -----------------------------------------------------------% Read the current directory and sort the names
% -----------------------------------------------------------function load_listbox(dir_path,handles)
cd (dir_path);
dir_struct = dir(dir_path);
43
[sorted_names,sorted_index] = sortrows({dir_struct.name}');
handles.file_names = [sorted_names];
handles.is_dir = [dir_struct.isdir];
handles.sorted_index = [sorted_index];
guidata(handles.figure1,handles);
set(handles.listbox1,'String',handles.file_names,...
'Value',1);
set(handles.text1,'String',pwd);
guidata(handles.figure1,handles);
% --- Executes during object creation, after setting all properties.
function listbox1_CreateFcn(hObject, eventdata, handles)
% hObject handle to listbox1 (see GCBO)
% eventdata reserved - to be defined in a future version of MATLAB
% handles empty - handles not created until after all CreateFcns called
% Hint: listbox controls usually have a white background on Windows.
%
See ISPC and COMPUTER.
if ispc
set(hObject,'BackgroundColor','white');
else
set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor'));
end
5
Bibliografia e risorse online
Ÿ
Stuart J. Russel, Peter Norvig - Artificial Intelligence, A Modern Approach. International
Edition. (Prentice Hall, second edition, 2003).
Ÿ
Fiora Pirri - Dispense del corso di Apprendimento, A.A. 2003/2004. Distribuite agli studenti
frequentanti il corso.
Ÿ
http://www-2.cs.cmu.edu/~awm/tutorials/gmm.html - Dispense sui modelli di misture di
gaussiane e sull’algoritmo EM.
Ÿ
http://dsp.ucsd.edu/students/present-students/mik/matlabgui - Guida rapida alla creazione di
interfacce grafiche in ambiente matlab.
Ÿ
http://www.mathworks.com/access/helpdesk_r13/help/pdf_doc/matlab/buildgui.pdf - Guida
completa alle interfacce grafiche in ambiente matlab. (The Mathworks, inc. – 184 pagine).
Ÿ
The Mathworks, inc. - Matlab 7 Reference Book - Guida ed help dell’ambiente Matlab 7.
44
Indice analitico (in corsivo le funzioni matlab):
A
algoritmo EM .......................................................................1
apprendimento dei parametri.............................................1
dati di apprendimento....................................................2
funzioni di apprendimento............................................3
covfixer.m ...................................................................4
listato ...................................................................18
emstime.mat ...............................................................5
fcm.m
listato ...................................................................17
gmem.m.......................................................................4
listato ...................................................................15
mvnpdf.m ....................................................................5
listato ...................................................................19
immagini di apprendimento..........................................2
B
bibliografia ..........................................................................44
C
clusterizzazione....................................................................5
funzioni di clusterizzazione..........................................6
gmcluster.m................................................................7
listato ...................................................................22
gmpdf.m ......................................................................6
listato ...................................................................21
immagini..........................................................................6
interfaccia grafica...........................................................7
covfixer.m..............................................................................4
listato..............................................................................18
modalbox.m...................................................................14
listato.........................................................................40
modalguide.fig..............................................................13
modalguide.m................................................................13
listato.........................................................................34
modalmenu.fig ..............................................................13
modalmenu.m................................................................13
listato.........................................................................37
funzioni di apprendimento.................................................3
covfixer.m ........................................................................4
listato.........................................................................18
emstime.mat.....................................................................5
fcm.m
listato.........................................................................17
gmem.m............................................................................4
listato.........................................................................15
mvnpdf.m..........................................................................5
listato.........................................................................19
funzioni di clusterizzazione ...............................................6
gmcluster.m .....................................................................7
listato.........................................................................22
gmpdf.m............................................................................6
listato.........................................................................21
G
gmcluster.m ..........................................................................7
listato..............................................................................22
gmem.m .................................................................................4
listato..............................................................................15
gmpdf.m .................................................................................6
listato..............................................................................21
D
I
dati di apprendimento .........................................................2
immagini di apprendimento...............................................2
interfaccia grafica ................................................................7
caricamento delle immagini .................................. 8; 14
crediti......................................................................... 9; 13
funzioni dell'interfaccia grafica .................................10
EM.fig .......................................................................10
EM.m .........................................................................10
listato ...................................................................23
modalabout.fig.........................................................13
modalabout.m..........................................................13
listato ...................................................................32
modalbox.fig............................................................14
modalbox.m..............................................................14
listato ...................................................................40
modalguide.fig.........................................................13
modalguide.m ..........................................................13
listato ...................................................................34
modalmenu.fig.........................................................13
modalmenu.m...........................................................13
listato ...................................................................37
guida.......................................................................... 9; 13
ingrandimento delle immagini.....................................9
E
EM..........................................................................................1
EM.fig ..................................................................................10
EM.m....................................................................................10
listato..............................................................................23
emstime.mat..........................................................................5
F
fcm.m
listato..............................................................................17
funzioni
listati...............................................................................15
funzioni dell'interfaccia grafica.......................................10
EM.fig.............................................................................10
EM.m ..............................................................................10
listato.........................................................................23
modalabout.fig..............................................................13
modalabout.m ...............................................................13
listato.........................................................................32
modalbox.fig..................................................................14
45
layout................................................................................8
menu .................................................................................8
menu contestuali .......................................................9
menu File ....................................................................8
menu Help ..................................................................9
menu View.................................................................9
pannello Learning set ....................................................9
pannello Parameters .....................................................10
pannello single points removal ..................................10
salvataggio delle immagini...........................................9
utilizzo ..............................................................................8
layout dell'interfaccia grafica ............................................8
listati delle funzioni...........................................................15
utilizzo per la clusterizzazione.....................................5
modalabout.fig...................................................................13
modalabout.m.....................................................................13
listato..............................................................................32
modalbox.fig.......................................................................14
modalbox.m ........................................................................14
listato..............................................................................40
modalguide.fig....................................................................13
modalguide.m.....................................................................13
listato..............................................................................34
modalmenu.fig....................................................................13
modalmenu.m .....................................................................13
listato..............................................................................37
mvnpdf.m ...............................................................................5
listato..............................................................................19
M
R
menu dell'interfaccia grafica..............................................8
menu contestuali.............................................................9
menu File .........................................................................8
menu Help .......................................................................9
menu View......................................................................9
misture di gaussiane............................................................1
numero di componenti............................................ 5; 10
soglia di appartenenza ............................................ 6; 10
risorse online ......................................................................44
L
S
set di apprendimento.......................................................2; 9
U
utilizzo dell'interfaccia grafica ..........................................8
46