Professional Documents
Culture Documents
Relatore
Candidato
Stefano Dobrilla
Matricola n. 177725
INDICE
1INTRODUZIONE...................................................................................................................................................................1
1.1ORIGINI DELLA SINTESI GRANULARE.........................................................................................................................................1
1.2 LA COMPOSIZIONE BASATA SULLA SINTESI GRANULARE.............................................................................................................1
1.3POSSIBILI APPROCCI ALLA SINTESI GRANULARE..........................................................................................................................2
1.4GEOGRAPHY.........................................................................................................................................................................4
1.5SCOPO DELLA TESI.................................................................................................................................................................6
2ANALISI DI GEOGRAPHY................................................................................................................................................7
2.1IL LIVELLO-1........................................................................................................................................................................7
2.1.1Definizione 1: Evento...............................................................................................................................................7
2.1.2Definizione 2: Track.................................................................................................................................................8
2.1.3Definizione 3: Grain Generator..............................................................................................................................8
2.1.4Definizione 4: Vertice..............................................................................................................................................9
2.1.5Definizione 5: Arco..................................................................................................................................................9
2.1.6Definizione 6: Peso di un arco................................................................................................................................9
2.1.7Definizione 7: Graph Actant.................................................................................................................................10
2.1.8Esempio di Grain Generator.................................................................................................................................10
2.1.9Processo di generazione di track..........................................................................................................................10
2.1.10Conclusioni...........................................................................................................................................................12
2.2IL LIVELLO-2......................................................................................................................................................................12
2.2.1Definizione 8: Control Space................................................................................................................................12
2.2.2Definizione 10: Traiettoria....................................................................................................................................12
2.2.3Definizione 11: Space Actant................................................................................................................................12
2.2.4Definizione 12: Angolo di orientamento di sa.....................................................................................................13
2.2.5Esempi di control space.........................................................................................................................................14
2.3LA GENERAZIONE DELLO SCORE............................................................................................................................................15
2.3.1Definizione 13: Grano...........................................................................................................................................16
2.3.2Definizione 14: Score.............................................................................................................................................17
2.3.3Esecuzione del control space................................................................................................................................17
2.3.4Esempio di score....................................................................................................................................................19
2.3.5Conclusioni.............................................................................................................................................................20
2.4CONCLUSIONI GENERALI.......................................................................................................................................................20
3OBJECT ORIENTED ANALYSIS (OBJECT MODELING)......................................................................................21
3.1LIVELLO-1..........................................................................................................................................................................21
3.1.1Oggetti.....................................................................................................................................................................21
3.1.2Strutture..................................................................................................................................................................21
3.1.3Attributi...................................................................................................................................................................21
3.1.4Associazioni............................................................................................................................................................22
3.1.5Servizi......................................................................................................................................................................22
3.2LIVELLO-2..........................................................................................................................................................................22
3.2.1Oggetti.....................................................................................................................................................................22
3.2.2Strutture..................................................................................................................................................................23
3.2.3Attributi...................................................................................................................................................................23
3.2.4Associazioni............................................................................................................................................................24
3.2.5Servizi......................................................................................................................................................................24
4REQUIREMENTS SPECIFICATION DOCUMENT...................................................................................................27
4.1 INTRODUCTION...................................................................................................................................................................27
4.1.1Purpose...................................................................................................................................................................27
4.1.2Definitions, Acronyms, Abbreviations..................................................................................................................27
4.1.3Notational Conventions.........................................................................................................................................27
4.2OVERALL DESCRIPTION........................................................................................................................................................27
4.2.1Product Perspective...............................................................................................................................................27
4.2.2Product Functions Overview.................................................................................................................................28
4.3SPECIFIC REQUIREMENTS......................................................................................................................................................28
4.3.1Inputs and Outputs.................................................................................................................................................28
4.3.2Functional Requirements.......................................................................................................................................37
1Introduzione
1.1 Origini della sintesi granulare
noto che la luce caratterizzata da una natura duale, cio pu essere descritta in termini di
propriet ondulatorie o in termini di propriet particellari: nel primo caso, la luce vista come
unonda, nel secondo caso, viene vista come un insieme di particelle (fotoni).
Oggi sappiamo che il suono non caratterizzato da una tale natura duale (il suono unonda); in
passato, per, sono state avanzate visioni atomistiche del suono come particelle sonore: lo studioso
olandese I. Beekman (1588-1637) nel 1616 propose una teoria corpuscolare del suono (vedi [3], e
[7]), secondo la quale qualunque oggetto in grado di vibrare e di emettere un suono (ad esempio
una corda) taglierebbe laria circostante in corpuscoli sferici di aria proiettati in tutte le direzioni;
sempre secondo Beekman, quando questi corpuscoli urtano contro il timpano, si percepisce il
suono.
Sebbene questa teoria delle particelle sonore non abbia attualmente valenza scientifica, essa
importante perch pone le basi per la definizione e la comprensione della sintesi granulare.
La nozione di un approccio granulare (o quantistico) al suono compare per la prima volta nel
1946-47 in due articoli del fisico britannico D. Gabor (vedi [10], [11]), nei quali viene avanzata una
nuova teoria, ispirata dalla fisica quantistica, secondo la quale qualunque suono pu essere descritto
da una rappresentazione granulare, ovvero da unappropriata sequenza di unit di informazione
acustica di durata quasi istantanea. Questa ipotesi fu verificata matematicamente da M. Bastiaans
negli anni Ottanta (vedi [1], [2]).
Negli anni Sessanta, anche linventore della cibernetica N. Wiener [31], e il teorico
dellinformazione A. Moles [19] hanno avanzato non solo rappresentazioni granulari del suono, ma
anche ipotesi sulla natura discreta della percezione e del campo sonoro.
Ad unorigine teorica della sintesi granulare, si affianca unorigine estetica: nel 1960, I. Xenakis fu
il primo a definire una teoria per la composizione basata sui grani, che nasceva dal seguente lemma:
Qualunque suono, anche una variazione musicale continua, concepito come un assemblaggio di
un gran numero di suoni elementari adeguatamente disposti nel tempo. Nellattacco, sostegno e
decadimento di un suono complesso, appaiono migliaia di suoni puri in un pi o meno breve
intervallo di tempo t [32]. Nonostante Xenakis fosse riuscito a riprodurre suoni granulari per
mezzo di generatori di tono analogici (si ascolti la composizione Analogique A-B per orchestra
darchi e nastro magnetico), la sua visione non pot attuarsi per la mancanza della tecnologia
necessaria.
Solo pi tardi, nel 1974, il ricercatore e compositore C. Roads sviluppa la prima implementazione
per calcolatore della sintesi granulare [21], in cui il metodo di lavoro composizionale pu essere
paragonato alla tecnica pittorica pointilliste, dove ai puntini di colore corrispondono i grani (di
suono).Roads usa questa implementazione in molte sue composizioni, tra le quali citiamo nscore
(1980), Field (1981), e Clang-tint (1993). In seguito, sono state proposte diverse
implementazioni della sintesi granulare: oltre a Roads, importante citare il compositore canadese
B. Truax, per il contributo dato per la definizione di tecniche alternative per il controllo della sintesi
granulare. Le tecniche proposte da Xenakis, Roads e Truax saranno descritte nel paragrafo 1.3.
1.2
elementi sonori elementari, i grani, di durata molto breve (tipicamente dai 5 ai 150 millisecondi).
Le ristrette dimensioni di un grano lo rendono appena percepibile allorecchio umano: diventa
difficile catturare e distinguere le caratteristiche di durata, frequenza, ampiezza e forma donda di
un grano.
Per comprendere in che cosa consiste una composizione musicale basata sulla sintesi granulare,
utile ricorrere ad una metafora, immaginando una tela pointilliste, dove ciascun puntino di colore
rappresenta un singolo grano della composizione. Quando la fruizione di un quadro siffatto avviene
ad una opportuna distanza, losservatore percepisce la composizione nel suo insieme, dimenticando
la struttura puntiforme; analogamente, nella composizione musicale basata sulla sintesi granulare,
quando i grani si susseguono a breve distanza temporale, lascoltatore percepisce un suono
continuo.
Daltro canto, in entrambi i casi, sia in campo pittorico, sia in campo musicale, il risultato finale
risente della particolare tecnica usata: un quadro puntinista mantiene pur sempre un certo effetto di
rarefazione dellimmagine, mentre una composizione musicale basata sulla sintesi granulare, in
generale d origine a materiali sonori molto densi e pulviscolari (si pensi ad un rullo di tamburo).
Continuando la metafora, chiaro che il pittore puntinista, oltre a concentrarsi sul singolo puntino
di colore, deve soprattutto concentrarsi sulla composizione nel suo insieme.
Nellambito della sintesi granulare, questa difficolt del muoversi dal livello del singolo grano (la
microstruttura della composizione), al livello composizionale (la macrostruttura della
composizione), possibilmente passando attraverso il livello delle note (la ministruttura della
composizione) e il livello del ritmo (la mesostruttura della composizione), una delle principali
difficolt che incontra il compositore [32].
Infatti, la complessit del suono generato dalla sintesi granulare deriva dalla quantit di dati
necessari per descrivere i singoli grani di cui il suono stesso composto: se n il numero di
parametri per ciascun grano, e d il numero medio di grani al secondo (densit media), occorrono
dn valori di parametro per specificare un secondo di musica [23]. Dal momento che d tipicamente
varia dallordine della decina allordine della migliaia, chiaro che per lo scopo di controllo sulla
macrostruttura della composizione, diventa necessaria ununit di alto livello per lorganizzazione
dei grani (cio, ununit di controllo che va oltre i dettagli microstrutturali dalla composizione), con
lo scopo di aiutare il compositore a comporre in modo intuitivo e relativamente immediato grandi
quantit di grani, e ad avere una visione dinsieme del prodotto compositivo.
Ciascuna di tali unit di controllo implementa quindi una particolare tecnica/metodo di
organizzazione del processo compositivo basato sulla sintesi granulare. Nel prossimo paragrafo
descriveremo brevente le principali tecniche proposte.
quindi spazio in tutte quelle applicazioni che si limitano a granularizzare oggetti sonori
preesistenti, come i moduli grain-based di applicazioni DSP [23].
Contrariamente allapproccio notale, lapproccio stocastico alla sintesi granulare fa s che nel
processo di sintesi sia gi insita una propria valenza formale a livello compositivo: il principio di
tale approccio sta nellunire suono e struttura ([29]: 120), annullando la netta linea di confine tra
microstruttura e macrostruttura. Diverse sono le metodologie stocastiche per il controllo della
sintesi granulare proposte da autori come Xenakis, Truax e Roads; al fine di dare una visione
dinsieme di tali metodologie, utile per comprendere pi a fondo il caso di studio di questa tesi,
introduciamo in modo intuitivo le tecniche proposte da tali autori.
La tecnica di Xenakis, descritta in [32], si basa sul concetto di screen: uno screen una griglia che
modella il campo delludibile in modo simile al diagramma di Fletcher-Munson (vedi la Figura 1).
In uno screen ogni colonna rappresenta un intervallo di frequenza, e ogni riga indica unintensit
sonora: in questo caso, un grano risulta essere una singola cella dello screen. In uno screen vengono
quindi disseminati i grani. Una sequenza di screen (detta book), in cui ciascuno screen ha una
durata di tempo fissa, forma levoluzione di un suono complesso. In generale, per riempire gli
screen con i grani possono essere usati algoritmi generativi di ogni tipo; la tecnica di Xenakis
prevede che i grani siano sparsi in modo casuale allinterno di ciascuno screen, e che nuovi screen
possano essere costruiti attraverso operazioni simili alle operazioni insiemistiche (intersezione,
unione, complemento, ecc.).
Figura 1: il grafico a sinistra il diagramma di Fletcher-Munson, detto anche delle curve isofone, in cui le ascisse sono
le frequenze (in Hz), le ordinate sono le intensit (in dB). Considerando convenzionalmente con valore 0 dB la pressione
necessaria per raggiungere la soglia di udibilit per la frequenza di 1000 HZ, il diagramma esprime come lintensit
della sensazione uditiva (soggettiva) per le diverse frequenze vari in modo non lineare rispetto al variare della pressione
acustica (da [23]:1057). A destra mostrato come uno screen modella il campo delludibile allinterno del diagramma di
Fletcher-Munson: le celle nere di tale screen sono grani, ciascuno dei quali rientra in un certo intervallo di frequenza
(F) e di intensit (G) (da [32]).
La tecnica proposta da Truax (vedi [28] e [29]), rientra in ci che in letteratura viene definita QuasiSynchronous Granular Synthesis (QSGS, [22], [23], [24]), secondo la quale una composizione
formata da uno o pi flussi di grani, in cui i grani sono separati da un intervallo di tempo variabile,
irregolare. I parametri di ogni flusso di grani sono controllati mediante maschere di tendenza, che
specificano landamento qualitativo dei parametri nello scorrere del tempo: ad esempio, lintervallo
di frequenza o ampiezza in cui rientrano i grani del flusso, la densit dei grani nel flusso (numero di
grani nellunit di tempo), linsieme di forme donda dei grani nel flusso, ecc. La forza di questa
tecnica sta nel fatto che il controllo viene definito a livello dei flussi (non dei grani), rendendo il
processo compositivo semplice ed intuitivo: analogamente a quanto viene tradizionalmente fatto
3
1.4 GeoGraphy
GeoGraphy (o GeoGrafia) un sistema formale per il controllo algoritmico della composizione
elettroacustica basata sulla sintesi granulare. Esso stato definito da A. Valle e V. Lombardo in
[30].
GeoGraphy presenta due livelli: un primo livello (livello-1), che prevede una rappresentazione in
grafi nei quali i vertici rappresentano i grani e gli archi relazioni temporali tra gli stessi, ed un
secondo livello (livello-2) che distribuisce i grafi del primo livello in uno spazio di controllo.
Una composizione una traiettoria nello spazio di controllo, opportunamente interpretata per
controllare un insieme di parametri di rilevanza acustica e musicale.
Per dare una descrizione concettuale e immediata del sistema, utile ricorrere alla metafora dei
percussionisti: un grafo pu essere pensato come set di percussioni in cui ciascuna percussione
corrisponde ad un vertice del grafo stesso. Su ciascun set di percussioni (grafo) possono suonare
contemporaneamente pi percussionisti; lordine seguito dai batteristi nel suonare le percussioni
della batteria corrisponde ad un determinato percorso seguito attraverso gli archi del grafo.
Immaginiamo ora di porre un ascoltatore e diversi set di percussioni (grafi), e relativi percussionisti,
in una sala relativamente grande (spazio di controllo). Lascoltatore inizier a muoversi ad una certa
velocit, percorrendo una data traiettoria allinterno della sala mentre i percussionisti stanno
suonando. La composizione risultante pu essere pensata come quanto ascoltato dallattante nel
percorrere la traiettoria.
Questa strutturazione del sistema nei due livelli permette al compositore di concentrarsi, prima,
sulla microstruttura della composizione (sui singoli grani) e sulle relazioni tra i tempi di attacco di
gruppi di grani, definendo i grafi nel primo livello, e in un secondo tempo sulla macrostruttura della
stessa composizione, andando a distribuire i grafi e definendo una traiettoria nello spazio di
controllo.
Nel costruire i grafi, il compositore definisce quindi il materiale sonoro, anche complesso, che verr
utilizzato nella composizione. La disposizione dei grafi e la definizione di una traiettoria in uno
spazio sostanzialmente unoperazione di orchestrazione: il materiale sonoro di base generato dai
grafi viene filtrato, controllato e organizzato dal sistema sulla base della traiettoria definita e della
disposizione dei grafi nello spazio di controllo.
4
G1
G3
1
2
1
5
Fine
4
3
Ascoltatore
G2
G4
La struttura dei grafi in Figura 2 d immediatamente uninformazione sul tipo di materiale sonoro
generato dai grafi stessi: ad esempio, se consideriamo a livello-1 il primo grafo incontrato
dallattante nel percorrere la traiettoria (G1) siamo in grado di dire che esso generer un suono
ripetitivo, costituito da una sequenza di grani identici tra loro (si pensi ad un martello pneumatico, o
ad una erre tenuta), perch generati sempre e solo dallo stesso vertice 1. Se consideriamo invece
lo stesso grafo a livello-2, cio nel contesto della configurazione rappresentata in Figura 2, il suono
da esso generato non pi del tutto ripetitivo: infatti, sebbene il suono mantenga una base uniforme
e costante, la traiettoria produce un controllo diretto sui parametri dei grani costituenti il suono
stesso.
Se immaginiamo ad esempio che lintensit dei grani generati sia inversamente proporzionale alla
distanza tra il vertice e lascoltatore che percorre la traiettoria, allora risulta evidente che, a mano a
mano che lascoltatore prosegue nella navigazione della traiettoria, il suono va via via scemando,
dal momento che, in generale, lascoltatore si allontana dal vertice del grafo in questione.
Come da una configurazione possibile ricavare informazioni sia sul materiale sonoro di base
scelto (sulla microstruttura della composizione), sia sullorganizzazione di tale materiale allinterno
della composizione (sulla macrostruttura della composizione), cos da unidea musicale pi o meno
precisa possibile dedurre una configurazione (seppur approssimativa) che meglio delle altre
realizzi quellidea. Questa sorta di relazione biunivoca tra idea musicale e configurazione
allinterno dello spazio di controllo, non solo raggiunge lobbiettivo di facilitare il processo
compositivo basato sulla sintesi granulare, ma rappresenta per il compositore motivo di ispirazione
musicale.
Questa nuova tecnica di composizione basata sulla sintesi granulare possiede quindi una
interessante forza compositiva, e costituisce uno strumento di controllo di facile utilizzo.
5
Control
Space
GeoGraphy
Score
Interprete
Score interpretato
Modulo di
Sintesi
Audio
Figura 3: Rappresentazione del processo di elaborazione dello spazio di controllo (Control Space):
GeoGraphy traduce il Control Space in uno Score (una partitura, sotto forma di sequenza di eventi
sonori); un Interprete si preoccupa di tradurre lo Score nella forma specifica per il Modulo di Sintesi, che
eseguir lo Score Interpretato, producendo il suono (Audio).
Lattivit di sviluppo seguir il modello a cascata di processo software: il motivo di questa scelta
risiede sia nella semplicit e linearit proprie di tale modello, sia nella caratteristica di abbondante
produzione di documentazione di cui gode il processo a cascata.
I successivi capitoli sono i documenti prodotti nelle seguenti attivit del processo software: analisi
del problema, object modeling, specifica del problema, progettazione orientata agli oggetti,
progettazione di dettaglio.
2Analisi di GeoGraphy
In questo capitolo definiamo tutte le entit coinvolte nel sistema GeoGraphy. Le definizioni date
sono frutto di unanalisi dettagliata di [30]. Ogni definizione accompagnata da unintroduzione
intuitiva, al fine di rendere pi facile comprensione la trattazione.
Useremo i seguenti insiemi numerici: linsieme N = {0, 1, 2, } dei numeri naturali; linsieme dei
numeri reali non strettamente positivi R+ = [0, +) . Indicheremo con linsieme vuoto,
con d(A, B) la distanza [(x1-x2)2 + (y1-y2)2] tra i due punti A = (x1, y1), B = (x2, y2)R2,
con |I| la cardinalit di I, dove I un qualche insieme, e con J \ I linsieme complementare di J in I
{xJ: xI}, dove I e J sono due insiemi. Il tempo sar dato in secondi, e lo spazio in metri.
Come gi accennato nel precedente capitolo introduttivo, GeoGraphy un sistema a due livelli per
il controllo algoritmico della composizione elettroacustica basata sulla sintesi granulare.
Nei seguenti paragrafi affrontiamo separatamente i due livelli del sistema.
2.1 Il Livello-1
Il Livello-1 fornisce il materiale sonoro di base al processo compositivo. Per rendere pi chiara
lidea, possiamo ricorrere al linguaggio metaforico, considerando una composizione come
una torta; il Livello-1 fornisce gli ingredienti necessari per cucinare la torta.
Ogni ingrediente sonoro fornito dal Livello-1 detto track, e presenta una struttura granulare:
cio una sequenza di grani, o meglio di eventi, cio unit di informazione acustica.
Anche se la distinzione tra grani ed eventi sar pi chiara quando si andr ad analizzare il secondo
livello, cerchiamo comunque di capire che tipo di differenza c tra grani ed eventi, e nel
contempo cerchiamo di chiarire la relazione tra track ed eventi. A questo scopo, riprendendo
la metafora culinaria, possiamo pensare alle track come ingredienti pulviscolari crudi
(zucchero, sale, farina, pepe, ecc); un evento come un singolo granello dellingrediente (un
granello di zucchero, di sale, di pepe, ecc.). Al secondo livello avverr la cottura e la mistura
di tali ingredienti (lesecuzione della ricetta). La cottura modifica gli ingredienti, rendendoli
commestibili. Analogamente, la generazione di una composizione a Livello-2 trasforma gli
eventi in grani: a differenza degli eventi, i grani contengono tutte le informazioni prodotte dal
sistema, sia a Livello-1, sia a Livello-2.
Un evento descritto da un certo insieme di informazioni, di parametri di rilevanza acustica e
musicale; il minimo insieme di parametri necessario per definire un evento composto dalle
seguenti quattro informazioni: il tempo di attacco dellevento (listante in cui levento viene
emesso), la durata dellevento, lampiezza donda dellevento, e la posizione stereofonica
dellevento.
In realt, questultimo parametro (detto anche pan) non necessario per definire un evento (ad
esempio, se si lavora con un unico speaker), ma dal momento che, come sar pi chiaro
quando presenteremo il Livello-2, concettualmente GeoGraphy organizza il materiale sonoro
fornito dal Livello-1 in uno spazio bidimensionale, risulta naturale aggiungere agli eventi
linformazione relativa alla posizione stereofonica degli stessi.
Diamo quindi le definizioni di evento e track.
2.1.1 Definizione 1: Evento
Sia mN, m4. Un evento e una tupla (p1, p2, , pm), dove:
T1={ ,
ti
di+1
ei
di
, }
ei+1
ti+1
tempo
di+1
T2={ ,
ei
ti/ ti+1
ei+1
, }
tempo
di
Figura 4: Descrizione intuitiva di due track T1 , T2: nella prima levento ei+1 attacca (al tempo ti+1)
prima che levento ei abbia terminato la propria emissione. In T2 levento ei+1 attacca (al tempo ti+1)
nello stesso tempo di attacco (ti) dellevento ei. di e di+1 sono la durata di ei, ei+1, rispettivamente.
Vediamo ora come il Livello-1 genera le track. Per fare questo, tale livello si serve di grafi, detti
grain generator, in cui, intuitivamente, i vertici possono essere definiti come dei generatori
di eventi, mentre gli archi definiscono le relazioni temporali tra gli eventi generati dai
vertici.
Sui grain generator sono posti dei cosiddetti graph actant (attanti di grafo), che possiamo
immaginare come degli esserini che, quando raggiungono un vertice (attraversando un arco),
si preoccupano di attivare il vertice raggiunto, affinch questultimo generi un evento.
Nel suo navigare, un graph actant genera una track: quindi, il numero di track generate da un grain
generator pari al numero di graph actant posti nello stesso grain generator.
Definiamo ora tutte le entit contemplate in questa breve descrizione intuitiva del processo di
generazione delle track attuato a Livello-1; in seguito daremo una specifica formale di tale
processo.
2.1.3 Definizione 3: Grain Generator
Un grain generator G un (multi)grafo orientato, pesato e non necessariamente connesso, ovvero G
una quadrupla (V, E, w, A), dove:
8
essere pensato come la lunghezza dellarco, posto che tutti i graph actant circolino nei
grain generator ad una data velocit costante fissata); la distribuzione di probabilit tra gli
archi uscenti da uno stesso vertice, usata dai graph actant per la selezione del prossimo
arco da attraversare.
Andando a incidere sulla navigazione dei graph actant, il peso degli archi incide in modo diretto sul
processo di generazione di track, dal momento che questultimo realizzato dal moto dei
graph actant allinterno dei grain generator: la topologia dei grain generator e il peso
degli archi degli stessi determina quindi il tipo di materiale sonoro che il compositore ha
a disposizione.
2.1.7 Definizione 7: Graph Actant
Sia G = (V, E, w, A) un grain generator.
Un graph actant gaiA un elemento indiciato (v0)i, dove:
v0V il vertice di partenza di gai;
iN l indice di gai, in modo tale che (v0)i = (v0)j i = j.
Intuitivamente, v0 definisce il vertice su cui inizialmente posto il graph actant, e dal quale
questultimo inizia a muoversi attraversando gli archi del grain generator a cui appartiene v 0.
E chiaro che, secondo quanto fin qua definito, i graph actant non sono ancora in grado di muoversi
allinterno di un grain generator: affinch questo sia supportato dalla nostra definizione formale del
sistema, occorrer introdurre una funzione di transizione, che definiremo quando andremo ad
analizzare il processo di generazione di track.
Analogamente a quanto detto per gli archi, ometteremo lindice i di un graph actant
(v0)i o quando si parla di un generico graph actant, o quando esso lunico ad avere v0 come vertice
di partenza.
Prima di analizzare il processo di generazione di track, diamo un esempio di grain generator.
2.1.8 Esempio di Grain Generator
La Figura 5 una rappresentazione grafica di un grain generator G = (V, E, w, A) con:
insieme di vertici V = {1, 2, 3, 4, 5} (i numeri sono le etichette dei vertici);
insieme di archi E = {(1, 2)0, (1, 2)1, (2, 2)0, (2, 2)1, (1, 3), (4, 3), (4, 4), (5, 5)};
funzione peso w, che diamo di seguito in formato tabellare:
iE
(, )
(1, 2)0
(1, 2)1
(1, 3)
(2, 2)0
(2, 2)1
(4, 3)
(4, 4)
(5, 5)
(.02, .2)
(.021, .7)
(0, .1)
(.0001, .01)
(.001, .99)
(0, .5)
(1, .5)
(.02, 1)
Ogni graph actant gaA, nel suo circolare allinterno di G, genera una ed una sola track: si ha
quindi che || = |A|, ovvero verranno generate tante track quanti sono i graph actant definiti
in G.
(0.0001, 0.01)
(0.02, 0.2)
0
0
1
(0.021, 0.7)
(0.001, 0.99)
(0, 0.1)
(1, 0.5)
4
(0.02, 1)
(0, 0.5)
Figura 5: rappresentazione grafica del grain-generator G sopra introdotto. Le etichette dei vertici sono poste in
grande allesterno dei vertici stessi. I graph actant sono rappresentati dai cerchiolini allinterno dei vertici:
quando necessario, in essi sono indicati gli indici degli stessi graph actant. Le coppie che etichettano gli archi
sono il peso degli archi stessi. I numeri in piccolo in prossimit dei punti da cui gli archi escono dai vertici
rappresentano lindice degli archi, e sono specificati solo se necessario. Si noti infine che il grain generator qui
rappresentato il grafo G3 in Figura 2.
Affinch i graph actant siano in grado di navigare dentro il grafo, definiamo la seguente funzione di
transizione:
La funzione next: AVR+ V determina le transizioni dei graph actant allinterno dei grain
generator: next(ga, v, t) restituisce il successivo vertice raggiunto dal graph actant gaA, che
al tempo tR+ posto nel vertice vV.
next(ga, v, t) seleziona in A uno tra gli archi uscenti da v, secondo la distribuzione di probabilit
definita dalle probabilit di percorrenza di tali archi ().
Possiamo ora descrivere il processo di generazione di track nel seguente modo:
Sia <e1, e2, , en> una track in , e gaA il corrispondente graph actant generatore della track;
si ha che:
e1 levento sonoro generato dal vertice v 0 (il vertice di partenza di ga) al tempo 0.
ei (2 i n) levento sonoro generato dal vertice v i = next(ga, vi-1, ti-1) al tempo
ti = ti-1 + tempo di percorrenza ( ) tra v i-1 e vi sullarco scelto,
dove: vi-1 il vertice generatore di ei-1;
ti-1 il tempo di attacco di ei-1.
Intuitivamente, durante il processo di generazione delle track di un grain generator G, ciascun graph
actant in G naviga tra i vertici di G (attraverso gli archi di G) iniziando il suo percorso dal vertice su
cui inizialmente posto (v0); il successivo vertice raggiunto determinato dalla funzione di
transizione next. Ogni vertice raggiunto da un graph actant genera un evento nello stesso istante in
cui esso raggiunto dal graph actant. La sequenza degli eventi generati dai vertici raggiunti da uno
stesso graph actant la track risultante dalla navigazione di G da parte del graph actant.
11
2.1.10 Conclusioni
Dalle definizioni date in questo paragrafo possiamo concludere che il Livello-1 un generatore
graph-based di track: esso fornisce il materiale sonoro di base al processo compositivo,
permettendo di definire i dettagli microstrutturali della composizione finale.
2.2 Il Livello-2
Il Livello-2 realizza il controllo dei parametri degli eventi generati a Livello-1, ovvero un sistema
che determina la definizione dei generatori di eventi dei vertici dei grain generator definiti a
Livello-1.
Di seguito definiamo tutte le entit appartenenti a tale livello, e infine descriveremo GeoGraphy a
livello operativo.
2.2.1
T la traiettoria di CS.
Intuitivamente, un control space pu essere pensato come un piano nel quale vengono posti i grain
generator definiti a Livello-1, e nel quale pu essere definita una traiettoria (vedi le figure 7, 8 e
9).
2.2.2 Definizione 10: Traiettoria
Sia CS = (G, , , a, T) un control space. Sia nN.
Data una sequenza di n+1 punti <(x0, y0), (x1, y1), (x2, y2), , (x n, yn)>, la traiettoria T di CS
linsieme dei punti { ( x i + t(xi+1-x0), yi + t(yi+1-yi) )(R+)2: 0 i n-1, t[0, 1] }.
2.2.2.1 Intuitivamente, ponendo n 1, presa una sequenza <P0, P1, , Pn> di n+1 punti in un
piano (il control space), la corrispondente traiettoria il tracciato descritto dai segmenti
compresi tra i punti Pi e Pi+1.
2.2.2.2 Se n = 0, la traiettoria T composta dal solo punto (x0, y0): in tal caso T detta traiettoria
nulla.
Dal momento che, data una sequenza di punti, identificata una ed una sola traiettoria, per
comodit indicheremo una traiettoria con la corrispondente sequenza di punti.
2.2.3 Definizione 11: Space Actant
Sia CS = (G, , , sa, T) un control space. Sia T = <(x0, y0), (x1, y1), , (x n, yn)>, nN.
Lo space actant sa di CS una quadrupla (q0, v, q(t, v, T), r), dove:
12
q0(R+)2 la posizione iniziale di sa: q0 (x0, y0), cio la posizione iniziale dello space actant
coincide con il primo punto della traiettoria T.
q(t, T)(R+)2 la posizione attuale di sa, che dipende dallistante tR+, e da T, ed definita da:
q0 , se T una traiettoria nulla;
q(t, T) = (x, y)T, punto raggiunto da sa, allistante t e a velocit v, lungo la traiettoria T
a distanza vt da (x0, y0), se un tale (x, y) esiste;
indef., altrimenti;
Intuitivamente, nel control space, che immaginiamo come un piano, insieme ai grain generator e ad
una traiettoria, presente un ulteriore attante (oltre agli attanti di grafo presenti nei grain
generator posizionati nel control space): lo space actant, che possiamo immaginare come un
esserino in grado di muoversi lungo la traiettoria solo a velocit costante (v), e dotato di orecchie in
grado di sentire entro un certo raggio di udibilit (r).
2.2.4 Definizione 12: Angolo di orientamento di sa
Sia CS = (G, , , sa, T) un control space.
Supponiamo T = <P0, P1, , P n> non nulla, e consideriamo un istante di tempo t per cui la posizione
attuale q(t, T) di sa un punto del segmento Pi Pi+1, 0 i < n. (Per comodit indichiamo q(t,
T) con q, omettendo le variabili t e T)
Preso un qualunque vertice v di un qualche grain generator in G, l angolo di orientamento di sa
langolo positivo (t, (v)), che dipende dallistante di tempo t e dalla posizione (v) di v,
descritto dalla rotazione in senso antiorario del segmento q Pi+1, intorno a q, fino a
sovrapporsi al segmento q (v).
Se T una traiettoria nulla q(t, T) = (v), langolo di orientamento di sa (t, (v)) = 0, tR+.
La Figura 6 mostra il significato geometrico dellangolo di orientamento di sa, mostrando come
esso varia rispetto al verso del vettore spostamento t.
(v)
P0
Pi+1
P1
Pi
Analogamente a quanto fatto nella precedente trattazione del Livello-1, facciamo qualche esempio
di grain generator, al fine di fissare parte delle definizioni fin qua date.
13
aA
(a)
10
11
2.1
1.5
2.5
q3 = (1.5, 1.5)
(0.0001, 0.01)
(0.02, 0.2)
(0.021, 0.7)
1.5
q0 = (4.5, 2)
(0.001, 0.99)
(0.02, 1)
5
(0, 0.1)
sa
q1 = (3.5, 1.5)
q2 = (0.5, 1)
(0, 0.5)
(1, 0.5)
0.5
0.5
1.5
2.5
3.5
4.5
Figura 7: Rappresentazione grafica del control space CS1 sopra introdotto. La traiettoria <q0, q1, q2, q3, q4>
viene percorsa dallo space actant sa, la cui posizione attuale q(t,T) = (3.25, 1.375). Il raggio di udibilit di sa
rappresentato dalla circonferenza in rosso.
1
2
3
4
5
vV
(v) (0.5, 1) (1.5, 1) (2.5, 1) (3.5, 1) (4.5, 1)
(abbiamo identificato i
1.5
(0.02, 0.2)
(0.0001, 0.01)
(1, 0.5)
sa
1
q0 = (2, 4.5)
(0.021, 0.7)
(0.001, 0.99)
(0.02, 1)
q1 = (4.5, 1)
(0, 0.5)
0.5
(0, 0.1)
0.5
1.5
2.5
3.5
4.5
Figura 8: Rappresentazione grafica del control space CS2 sopra introdotto. La traiettoria composta da un
unico segmento di estremi q0=(2, 4.5), q1=(4.5, 1); essa viene percorsa dallo space actant sa, la cui
posizione attuale q(t,T) = (3, 1), e il cui raggio di udibilit nullo (r=0).
traiettoria T = .
2
(0.0001, 0.01)
(0.001, 0.99)
0.
7)
(0
.0
21
,
(0
.0
2,
0.
2)
1.5
(1, 0.5)
SAct
sa
(0.02, 1)
,0
(0
,0
.5
)
(0
)
.1
0.5
0.5
1.5
2.5
Figura 9: Rappresentazione grafica del control space CS3 sopra introdotto. La traiettoria
nulla, pertanto lo space actant sa immobile. Il raggio di udibilit rappresentato dalla
circonferenza in rosso con centro in q0 = (1,1), e di raggio r = 1. Si noti che il vertice 5
posizionato al di fuori del raggio di udibilit.
16
p2(0,+) la durata di g;
p3[0,1] l ampiezza di g;
p4[-1,1] il pan di g;
p5 = d(q(t, v, T), (v)) la distanza tra la posizione attuale di sa e la posizione del vertice v, che
ha generato il grano g;
p5, , p m[0,1] .
la funzione rand( ), detta funzione random che seleziona casualmente un valore allinterno del
dominio (che si suppone essere chiuso e limitato) del parametro da generare; dal momento che il
parametro di durata ha dominio illimitato (0, +), per tale parametro occorre poter restringere il
dominio ad un intervallo chiuso e limitato;
map(x) = min + [(max min) / 2] (x + 1) la funzione che mappa x[-1, 1] nel dominio
chiuso e limitato del parametro da generare (anche qui, dal momento che il parametro di
durata ha dominio illimitato (0, +), per tale parametro occorre poter restringere il
dominio ad un intervallo chiuso e limitato);
la funzione dist-funct( d(q(t, T), (v)) ), detta funzione della distanza, una qualche funzione della
distanza tra la posizione attuale q(t, T) dell sa e la posizione (v) del vertice v su cui stata
invocata ev-gen.
18
Adesso per, come gi detto, il Livello-2 vede grani, non eventi: che fine fanno dunque gli
eventi generati a Livello-1 durante lesecuzione del control space?
Ad ogni evento e generato a Livello-1 viene applicata la funzione m(e) = ge, che trasforma e nel
corrispondente grano ge aggiungendo ad e le seguenti due informazioni:
la distanza d(q(t, T), (v)) tra la posizione attuale di sa e la posizione del vertice v che ha
generato e;
La funzione composta m
A mano a mano che, durante lesecuzione di CS, vengono generati i grani, essi vengono inseriti
nello score S, che loutput dellesecuzione di CS.
Lesecuzione di CS termina o quando viene interrotta dallesterno, o quando sa ha percorso tutta la
traiettoria T, se T una traiettoria nulla.
2.3.4
Esempio di score
La Figura 10 raffigura uno score generato dal control space CS1 (vedi il primo esempio di control
space del paragrafo 2.2, e la Figura 7): in tale figura la freccia orizzontale rappresenta il
tempo, e per ciascun graph actant (indicato con letichetta del vertice di partenza)
rappresentata la corrispondente track, in cui ciascun evento un pallino al cui interno
indicata letichetta del vertice che ha generato levento stesso.
.021
10
.001
.0001
.001
.001
.001
11
.02
.02
.02
1.12
4
3
1.5
2.1
2.3
2.5
3.5
6.66
7.56 time
Figura 10: Rappresentazione di uno score: la freccia orizzontale rappresenta il tempo; per ciascun graph actant
specificata la track (rappresentata dalla corrispondente sequenza di pallini) generata durante lesecuzione del control
space CS1 in Figura 6; i grani dello score sono i pallini rossi, al cui interno specificata letichetta del vertice che ha
generato il grano. I pallini grigi sono i grani mancati, cio quelli scartati via raggio di udibilit. I grani posti su di
una stessa linea verticale (cio, sovrapposti verticalmente) sono generati nel medesimo istante (si vedano i grani 1 e
3 della track relativa al graph actant 1 1, e i grani 4 e 3 (emessi allistante 3.5) della track relativa al graph actant 4.
Ogni numero tra due eventi (pallini) successivi indica lintervallo di tempo che separa tali eventi.
Quando viene avviata lesecuzione del control space CS1, lunico graph actant che al primo istante
di esecuzione inizia il processo di generazione di track (cio a navigare nel grafo) quello
inizialmente posto nel vertice 5: dal momento che lo space actant sa ha raggio di udibilita r
= 1, per tutto il periodo di tempo in cui il vertice 5 rientra in tale raggio di udibilit (cio, il
tempo necessario a sa per percorrere il primo segmento della traiettoria), che va
19
Conclusioni
Dallanalisi svolta possiamo concludere che il Livello-2 un control space, cio un contesto nel
quale vengono immersi i grain generator definiti a Livello-1 che permette di definire in
modo intuitivo e contestuale un generatore di grani per ogni vertice in esso schierato.
20
3.1 Livello-1
Dal momento che il generatore di eventi dei vertici viene definito precisamente solo a Livello-2,
ignoreremo la possibilit di generare track a Livello-1, e ci preoccuperemo del processo di
generazione di track nel prossimo paragrafo, quando andremo a modellare il Livello-2.
Identifichiamo nellordine gli oggetti, le strutture, gli attributi, le associazioni, i servizi.
3.1.1 Oggetti
Dallanalisi svolta nel precedente capitolo, a Livello-1 identifichiamo immediatamente le se guenti
object class: Level_1, GGen, Vertex, Edge, GAct, che modellano, rispettivamente, le seguenti
entit: Livello-1, grain generator, vertice, arco, e graph actant.
3.1.2
Strutture
Attributi
Dal momento che occorre identificare i GGen, introduciamo lattributo name, che identificatore
univoco per i GGen contenuti in Level_1.
I Vertex sono invece identificati dalla loro etichetta label.
Lattributo numberOfOthersParams di Vertex mantiene il numero m-4, dove m il numero di
parametri del vertice, ovvero il numero di parametri esclusi il parametro di durata,
ampiezza, tempo di attacco, e pan.
Di qui in avanti chiameremo altro parametro un parametro che non sia la durata, lampiezza, il
tempo di attacco, o il pan.
Gli attributi identificati per Edge sono:
temporalDistance, che mantiene il tempo di percorrenza in secondi dell Edge, nel caso in cui
la funzione che restituisce l intervallo di percorrenza sia una funzione costante.
routeProbability, che mantiene la probabilit di percorrenza dell Edge.
Non identifichiamo alcun attributo per GAct e Level_1.
21
3.1.4
Associazioni
Oltre alle relazioni gi identificate, a Livello-1 non vi sono relazioni particolari tra le object class
fin qua identificate.
3.1.5
Servizi
Dal momento che, come gi detto, a Livello-1 ignoriamo la possibilit di generare track, gli unici
servizi fin qua identificabili sono quelli occur, cio quelli per creare, distruggere e
mantenere gli oggetti e i loro attributi, che diamo per impliciti.
Il modello fin qua identificato rappresentato dallobject diagram mostrato in Figura 11.
GAct
Level_1
GGen
name
Vertex
label
numberOfOthersParams
Edge
temporalDistance
routeProbability
Figura 11: Object diagram che rappresenta lobject-model del sistema a Livello-1.
3.2 Livello-2
Chiaramente, il modello costruito nel precedente paragrafo forma la base per il modello da costruire
per il Livello-2: modificheremo quindi lobject model identificato a Livello-1, in modo tale
che esso supporti lesecuzione del control space.
Identifichiamo nellordine gli oggetti, le strutture, gli attributi, le associazioni, i servizi.
3.2.1
Oggetti
Dalla precedente analisi svolta nel secondo capitolo, a Livello-2 identifichiamo immediatamente le
seguenti object class: ControlSpace, Trajectory, Grain, Score, e ActivationInterval, che
modellano, rispettivamente, le seguenti entit: control space, traiettoria, grano, score, e
intervallo di attivazione.
ControlSpace ingloba lobject class Level_1: infatti, dal momento che ignoriamo la possibilit di
generare track a Livello-1, definire un GGen a Livello-1 ha senso soltanto nel momento in
cui esso viene posto nel ControlSpace. Level_1 quindi eliminata dallobject model.
Dal momento che c uno stretto rapporto tra la traiettoria e lo space actant, Trajectory modella
entrambe tali due entit.
Modelliamo inoltre ciascun segmento della traiettoria con la classe ShiftingVector, che fornir tutte le
operazioni da compiere a livello di segmento (mentre Trajectory fornir tutte le operazioni da
compiere a livello di traiettoria e space actant).
22
Dalle definizioni di generatore di eventi ev-gen e di generatore di parametro, chiaro che per ogni
parametro pi (ad esclusione del tempo di attacco) degli eventi generati da un qualunque
Vertex, occorre poter definire il corrispondente generatore di parametro: affinch il modello
supporti i quattro tipi di generatori di parametro ( const( ), rand( ), pan( ), e dist-funct( ) ),
introduciamo le seguenti object class:
Parameter, che modella il generico parametro degli eventi generati dal Vertex;
Duration, Amplitude, e Pan, che modellano, rispettivamente, i parametri di durata, ampiezza, e
pan.
OtherParam, che modella un altro parametro (come gi detto, un parametro che non sia la
Dal momento che al parametro tempo di attacco pu essere associata soltanto la funzione di
identit, risulta inutile per i nostri scopi modellare tale parametro con unobject class.
3.2.2
Strutture
La struttura che intercorre tra le classi rappresentata dallobject diagram in Figura 12.
3.2.3
Attributi
Dal momento che, come gi detto, lobject class Trajectory modella entrambe le entit traiettoria e
SAct, Trajectory ha gli attributi:
initialPoint, che mantiene la posizione iniziale dellSAct;
speed, che mantiene la velocit di navigazione dellSAct;
audibilityRadius, che mantiene il raggio di udibilit dellSAct;
ShiftingVector ha gli attributi head e tail, che mantengono, rispettivamente, il primo e lultimo punto
esterno del segmento di traittoria modellato, rispetto allordine in cui tali punti sono contenuti nella
traiettoria.
Un attributo da aggiungere a Vertex a Livello-2 vertexPosition, che mantiene la posizione del
Vertex nel ControlSpace.
Al fine di supportare il tipo di generatore di parametro costante, introduciamo lattributo
constantValue nellobject class Parameter.
Come espresso dalla definizione di funzione rand( ) e di funzione pan( ), occorre restringere il
dominio (0,+) del parametro durata in un intervallo chiuso e limitato I, nel caso in cui tale
23
parametro sia generato dalla funzione random o pan, appunto. Introduciamo quindi lattributo
domainRestriction alla classe Duration, che mantiene tale intervallo I.
Gli attributi di ActivationInterval sono firstInstant, lastInstant, rispettivamente per il minimo e il
massimo istante di attivazione dell ActivationInterval.
Affinch il modello supporti il caso cui il vertice attivo per ogni istante di esecuzione,
introduciamo lattributo alwaysActive a Vertex, un booleano che, se vero, indica che il Vertex
sempre attivo.
Aggiungiamo a GAct lattributo startTime che rappresenta il tempo di avvio dello stesso GAct a
partire dallinizio.
Ciascun Grain deve mantenere tutte le informazioni che definiscono un grano: aggiungiamo quindi i
seguenti attributi allobject-class Grain: attackInstant, durationValue, amplitudeValue, panValue,
distance, angle, e otherParamValues, che mantengono, rispettivamente, il tempo di attacco, la
durata, lampiezza, il pan, la distanza tra la posizione attuale dello space actant e la posizione del
vertice generante il grano, langolo e langolo di orientamento dello space actant (vedi la def. 12 a
pag. 13), i valori dei restanti parametri.
3.2.4
Associazioni
I vertici generano grani, quindi tra le istanze delle classi Vertex e Grain esiste una relazione,
unassociazione zero a molti, dal momento che un vertice pu generare zero o pi grani
durante lesecuzione del control space.
Inoltre, lo stato di attivit di un vertice dipende dalla traiettoria: esiste perci una relazione tra le
istanze della classe Vertex e la Trajectory: tale associazione chiaramente uno a molti, dal
momento che ogni vertice in relazione con la traiettoria.
Altre associazioni potranno essere identificate durante lidentificazione dei servizi, che segue.
3.2.5
Servizi
Eviteremo di specificare i servizi occur, cio quelli per creare, distruggere e mantenere gli oggetti
e i loro attributi, che saranno considerati impliciti.
Lobject class ControlSpace deve fornire un servizio per avviare lesecuzione del control space:
introciamo quindi il servizio startPerformance( ) a ControlSpace, che realizza appunto tale
funzionalit.
Affinch per ogni vertice di un grain generator caricato nel control space possano essere calcolati
tutti gli intervalli di attivazione, introduciamo il servizio computeVxActivationIntervals( ) alla
classe GGen. E chiaro che tale funzione dipende dallo stato della Trajectory. C quindi una
relazione tra le istanze della classe GGen e loggetto Trajectory: aggiungiamo al modello
unassociazione uno a molti (1:N) tra tali oggetti.
Il calcolo vero e proprio degli ActivationInterval dovr essere svolto dai singoli Vertex;
computeVxActivationIntervals( ) ha solo il compito di chiedere ad ogni Vertex di svolgere
tale calcolo: introduciamo quindi computeActivationIntervals( ) allinterfaccia della classe
Vertex, servizio che si preoccupa di calcolare tutti gli ActivationInterval del Vertex.
Ovviamente anche computeActivationIntervals( ) dipende dalla Trajectory, e tale relazione gi
stata modellata con lassociazione tra le istanze delle object class Vertex e Trajectory.
Affinch computeActivationIntervals( ) possa calcolare tutti gli intervalli di attivazione di un Vertex,
occorre:
sapere se lo space actant ha velocit di navigazione speed = 0: tale servizio, che chiamiamo
isImmovableSAct( ), chiaramente offerto da Trajectory;
24
verificare se un vertice sempre attivo o meno, nel caso in cui lo space actant abbia velocit
di
navigazione
speed
=
0:
anche
tale
servizio,
che
chiamiamo
isAudiblePointFromInitialPosition( ), offerto da Trajectory;
ottenere listante di tempo in cui lo space actant si trova in un dato punto della traiettoria
(altro non , che la funzione inversa della posizione attuale dello space actant): tale servizio,
che chiamiamo getInstantToPoint( ), offerto da Trajectory;
verificare se il Vertex attivo rispetto almeno uno dei punti di uno ShiftingVector (un
segmento della traiettoria): tale servizio, che chiamiamo isAudiblePoint( ), chiaramente
offerto dalla classe ShiftingVector;
ottenere i punti estremi del segmento appartenente ad uno ShiftingVector in cui il Vertex
attivo, se tale segmento esiste: tale servizio, che chiamiamo getActivationPoints( ), offerto
da ShiftingVector.
Una volta calcolati tutti gli ActivationInterval associati ad un Vertex, occorre poter verificare se in un
dato istante il Vertex attivo o meno: il servizio isActive( ) dellobject class Vertex fornisce tale
informazione.
Modelliamo il processo di generazione di track con il servizio startTrackGenerationProcess( ), fornito
dalla classe GAct. Durante tale processo occorre poter scegliere casualmente uno tra gli Edge uscenti
dal Vertex in cui si trova il GAct: tale operazione realizzata dal servizio chooseEdge( ), fornito dalla
classe Vertex.
Modelliamo il generatore di grani di un vertice con il servizio grainGenerator( ), fornito ovviamente
dalla classe Vertex. grainGenerator( ) si serve del servizio getValue( ), fornito da ParamGenerator, per
generare i singoli parametri del grano da generare.
Altri servizi che deve fornire Trajectory sono getDistance( ) e getAngle( ), che restituiscono
rispettivamente la distanza tra la posizione attuale dellSAct e la vertexPosition di un Vertex (si
ricordi che Trajectory modella anche lSAct), e langolo (per questultimo, vedi la definizione 12).
Di uno ShiftingVector occorre sapere la lunghezza, e se un dato punto appartiene o meno allo stesso
ShiftingVector: introduciamo quindi i servizi getLength( ) e isMyPoint( ) a ShiftingVector, che realizzano
queste due funzionalit.
Infine, lo Score deve effrire un servizio per inserire in esso un Grain, e un servizio per scrivere i
Grain in esso contenuti in un file. Tali servizi li chiamiamo insertGrain( ), e writeInTheScoreFile( ).
Lobject model risultante dallobject modeling in Figura 12.
ControlSpace
startPerformance ( )
GAct
startTime
startTrackGeneratorProcess ( )
Trajectory
GGen
25
audibilityRadius
isImmovableSAct ( )
isAudiblePointFromInitialPosition ( )
getInstantToPoint ( )
getDistance ( )
getAngle ( )
ShiftingVector
head
tail
isAudiblePoint ( )
getActivationPoints ( )
getLength ( )
isMyPoint ( )
Vertex
label
numberOfOthersParams
vertexPosition
alwaysActive
computeActivationIntervals ( )
isActive ( )
chooseEdge ( )
grainGenerator ( )
Grain
attackInstant
durationValue
amplitudeValue
panValue
distance
angle
otherParamValues
ActivationInterval
firstInstant
lastInstant
Score
Edge
temporalDistance
routeProbability
insertGrain ( )
writeInTheScoreFile ( )
Amplitude
Pan
Duration
domainRestriction
OtherParam
RandFunct
Parameter
constantValue
getParamValue ( )
PanFunct
ParamGenerator
getValue ( )
DistFunct
26
4.1
Introduction
4.1.1
Purpose
Chiamiamo GeoGraphy il suddetto sistema. Inoltre, vengono considerate tutte le definizioni date
nel capitolo.
4.1.3
Notational Conventions
Tutti i requisiti specificati in questo documento sono descritti in prosa, in una Backus Naur Form
(BNF) estesa, specificata in [4]:8-10 (adottiamo quella usata nellRFC 1945), o con Data Flow
Diagram (DFD), secondo la notazione data in [15]:88.
Product Perspective
GeoGraphy parte di un sistema pi grande, descritto dal diagramma di contesto in Figura 13.
Implementation
Boundary
Control Space File
User
Score FIle
User
*
Command Line
Grains
GeoGraphy
Audio
Grains
Interpreter
Interpreted Score
Synthesis
Module
Error Messages
GGen Files
User
Figura 13: Data Flow Diagram che descrive il flusso di dati tra le varie componenti del sistema di cui parte
GeoGraphy. Tutto ci che contenuto nellimplementation boundary (nel cerchio) dovr essere implementato.
27
Il formato degli input e output di GeoGraphy sono dati in (4.3.1). Il formato dei restanti flussi di
dati (Interpreted Score e Audio) non oggetto di questo documento, in quanto tali flussi sono al di fuori
dellimplementation boundary (che contiene la parte del sistema che deve essere implementata).
Come si pu vedere nel DFD in Figura 13, GeoGraphy si interfaccia con un modulo di sintesi
(Synthesis Module) per mezzo di un interprete (Interpreter). Linterprete il processo che si preoccupa
di tradurre loutput di GeoGraphy (Score File) nella forma specifica per il modulo di sintesi
(Interpreted Score), in modo tale che questultimo possa suonare lo Score generato da GeoGraphy.
Per questa implementazione non richiesto un interprete, ma la possibilit di generare
immediatamente uno score specifico per Csound (vedi [12] e [18]), evitando cos lelaborazione
dello Score File da parte dellinterprete per Csound.
4.2.2
Il sistema permette allutente di definire graph generator e control space e di eseguire il control
space da lui stesso specificato via linea di comando. Tale esecuzione genera uno score.
Il sistema ha due tipi di file in input e produce due tipi di output. Il formato di tali input e output
di seguito descritto:
4.3.1.1 GGen File
E il file di input che contiene la definizione di un grain generator. Il suo formato il seguente:
GGen_File
= Vertexes
[Edges]
Gacts
*comment
Vertexes
= *comment
"Vertexes:" 1#vertex LWS ";"
vertex
label
other-params
Edges
= *comment
"Edges:" 1#(edge [weight])LWS
edge
weight
route-interval
= interval | "rand"
interval
time-unit
factor
route-prob
= prob | "auto"
prob
GActs
= *comment
"GActs:" 1#vx-gacts
LWS ";"
vx-gacts
";"
28
gact-number
comment
vertex-ID
ALPHA
= UPALPHA | LOALPHA
UPALPHA
LOALPHA
decimal
DIGIT
TEXT
= <US-ASCII 32-126>
LWS
= *(NL|SP|HT)
SP
NL
HT
Ogni GGen file risulta quindi essere composto da tre campi, descritti dalle regole Vertexes, Edges
(opzionale) e GActs.
Il primo di tali campi specifica linsieme dei vertici del grain generator specificato nel GGen-file.
Come si pu vedere dalla regola label, le etichette che indentificano i vertici possono essere anche
stringhe di caratteri (vedi vertex-ID). Ovviamente, in quanto identificatori, i vertex-ID devono
essere diversi tra loro. other-params specifica il numero di altri parametri associati al
corrispondente vertice (ricordiamo che chiamiamo altro parametro un parametro che non sia la
durata, lampiezza, il tempo di attacco, o il pan). Se per un vertice other-params non viene
specificato, il numero di altri parametri di quel vertice 0.
Il campo Edges specifica linsieme degli archi e la funzione peso del grain generator definito nel
GGen-file. I due vertex-ID specificati in edge devono essere tra quelli specificati nel campo
Vertexes.
weight specifica il peso dell edge corrispondente: route-interval specifica la funzione che
determina lintervallo di percorrenza, e route-prob specifica la probabilit di percorrenza.
Ovviamente, le route-prob dei vari weight devono soddisfare la condizione per la quale la somma
delle probabilit di percorrenza degli archi uscenti da uno stesso vertice uguale a 1.
In route-interval, se viene specificato un interval, la funzione che determina lintervallo di
percorrenza una funzione costante, mentre se viene specificato "rand", la stessa funzione la
funzione casuale con spazio di probabilit uniforme nellintervallo [0,1]. Queste sono le uniche due
funzioni per la determinazione dellintervallo di percorrenza supportate. Si noti che se in un
interval non viene specificato una time-unit, lunit di misura considerata sar il millisecondo.
In route-prob pu essere specificata una probabilit (vedi la regola prob), o pu essere specificato
"auto": nel secondo caso, la probabilit di percorrenza verr determinata in modo automatico sulla
base della condizione per la quale la somma delle probabilit di percorrenza degli archi uscenti da
uno stesso vertice uguale a 1.
Se weight non specificato per un qualche edge, il peso dell edge "(rand,auto)".
Il campo GActs specifica linsieme di graph actant del grain generator definito nel GGen-file:
ciascun vertex-ID contenuto in tale campo deve essere uno tra quelli specificati nel campo
Vertexes. gact-number specifica il numero di graph actant posti sul vertice vertex-ID
corrispondente; se gact-number non specificato, si ritiene gact-number = "1", mentre i vertex29
ID nel campo Vertexes non specificati nel campo GActs hanno gact-number = "0". Se ci sono
due o pi vx-gacts con medesimo vertex-ID, il numero di graph actant associati a quel vertice
uguale alla somma dei gact-number di tali vx-gacts.
// - - - - - - - - - - - - - - - - - - - - - //
edges:
,
,
// _-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_-_ //
GaCtS:
1<-, 1<- , 4<-1 GAct, 5<-;
// N.B.: sul vertice 1 sono stati posti 2 gact;
//
si poteva anche scrivere 1<-2.
/////////////////// EOF ///////////////////////
Tutti i GGen-file devono essere contenuti nella directory Level_1 interna allapplicazione.
4.3.1.2 Control Space File
E il file di input che contiene la definizione di un control-space. Il suo formato il seguente:
Control_Space_File= [ LWS "Csound" ]
GGen-Set
Positions
[Start-Times]
SAct
Generator-Defs
[Trajectory]
*comment
GGen-Set
= *comment
"GGen-set:" 1#(GGen-filename [ggen-number]) LWS ";"
GGen-filename
= filename
filename
= <UNIX/Windows filename>
ggen-number
= LWS 1*DIGIT
Positions
= *comment
"Vertex-positions:" 1*GGen-position LWS ";"
GGen-position
= *comment
LWS GGen-ID ":" 1#vertex-position ";"
GGen-ID
= GGen-filename [ggen-index]
ggen-index
= "_" 1*DIGIT
30
vertex-position
Start-Times
= *comment
"Start-times:" 1*GGen-times LWS ";"
GGen-times
= *comment
LWS GGen-ID ":" 1#GAct-time ";"
GAct-time
GAct-ID
= vertex-ID [Gact-index]
Gact-index
= "_" 1*DIGIT
SAct
= *comment
"SAct:"
*comment initial-position LWS ","
*comment speed LWS ","
*comment audio-radius LWS ";"
speed-unit
space-unit
audio-radius
Generator-Defs
= *comment
"Generator-Defs:" 1*GGen-generators LWS ";"
GGen-generators
= *comment
LWS GGen-ID ":" 1*vertex-generator
LWS ";"
vertex-generator = *comment
LWS vertex-ID ":"
duration
amplitude
pan
*other-param
duration
amplitude
pan
other-param-index = 1*DIGIT
generator
constant
pan-funct
= "pan-function"
rand-funct
= "random-function"
dist-funct
= 2#funct-couple
Trajectory
= *comment
"Trajectory:" 2#point ";"
point
funct-couple
31
f(X)
Ogni Control Space file risulta quindi essere composto da sei campi, descritti dalle regole GGenSet, Positions, Start-Times (opzionale), SAct, Generator-Defs, e Trajectory (opzionale).
Prima di tali campi pu essere specificata la parola chiave "Csound", che avverte il sistema che
deve essere generato un Csound-score, cio uno score specifico per Csound, il cui formato dato
oltre.
Il campo GGen-Set specifica linsieme di grain generator del control space specificato dal Control
Space file. ggen-number specifica il numero di istanze del (tipo di) grain generator definito nel file
GGen-filename; se ggen-number non specificato, il grain generator verr istanziato una sola
volta, ovvero ggen-number = "1". Se viene ripetuto pi volte uno stesso GGen-filename, il
corrispondente ggen-number sar la somma dei ggen-number specificati nelle varie ripetizioni.
Prima di affrontare i restanti campi, diciamo che GGen-ID identifica una delle istanze di grain
generator contenute in GGen-Set: ggen-index specifica il numero dellistanza del grain generator
speficato nel file GGen-filename. Se il grain generator definito nel file "MyGGen" (vedi lesempio
di sopra) viene istanziato 2 volte in uno stesso control space, la prima istanza identificata dal
GGen-ID "MyGGen_0", la seconda da "MyGGen_1". Se ggen-index non viene specificato viene
considerata la prima istanza, ovvero ggen-index = "_0".
Il campo Positions specifica la funzione posizione del control space specificato dal Control Space
file. I GGen-ID specificati in 1*GGen-position devono riferirsi a tutti e solo i grain generator
istanziati nel control space (secondo quanto specificato nel campo GGen-Set). Ovviamente, occorre
specificare una ed una sola vertex-position per ogni vertice di ogni grain generator istanziato nel
control space.
Il campo Start-Times specifica la funzione di avvio del control space specificato dal Control
Space file. Se tale campo mancante, la funzione di avvio costante a 0. GAct-ID identifica i graph
actant in modo analogo a come GGen-ID identifica i grain generator istanziati in un control space. I
grain generator o i graph actant per i quali non stato specificato espressamente un tempo di avvio
avranno tempo di avvio uguale a 0.
Il campo SAct specifica lo space actant del control space specificato dal Control Space file: in
particolare, initial-position specifica la posizione iniziale dellSAct, audio-radius specifica il
raggio di udibilit dellSAct, e speed specifica la velocit di navigazione dellSact. Questultima
deve rispettare la condizione secondo la quale se la traiettoria nulla (cio, priva di vettori
spostamento), allora lSAct immobile (cio, ha velocit nulla).
Il campo Generator-Defs specifica la funzione di definizione dei generatori di eveni del control
space specificato dal Control Space file. I GGen-ID specificati in 1*GGen-generators devono
riferirsi a tutti e solo i grain generator istanziati nel control space (secondo quanto specificato nel
campo GGen-Set). In ciascun GGen-generators occorre specificare uno ed un solo vertexgenerator per ogni vertice di ciascun grain generator istanziato nel control space. vertexgenerator specifica il generatore di eventi del vertice identificato dal vertex-ID. In ciascun
vertex-generator, duration, amplitude, pan e *other-param specificano un generatore di
parametro rispettivamente per i parametri di durata, ampiezza, pan e i restanti parametri associati al
vertice. Questi ultimi (gli altri parametri) sono identificati da other-param-ID, e devono essere
specificati in ordine crescente rispetto all other-param-index (analogamente a ggen-index e
Gact-index, other-param-index parte da 0).
In domain-restrictn il primo interval deve essere minore o uguale al secondo interval.
In pan, se il generator di tipo constant, la costante specificata deve essere compresa in modo
non stretto tra -1 e 1; se il generator di tipo dist-funct, i valori acquistati da tale funzione
devono appartenere allintervallo [-1, 1].
32
sact:
generator-defs:
MyGGen:
1:
duration = pan-function domain=[1.618,1.618sec];
amplitude = random ;
pan = (0,0), (0.025 ,1), (0.05,0),
(0.075 ,-1), (0.1,0);
other-param_1 = random;
op2 = (0.0,0), (0.1cm,1) ;
op3 = pan ;
2:
duration = random [1.618,1.618sec];
amplitude = (0,1), (r,0) ;
pan = pan-function;
3:
duration = (0,1.618centisec), (r,1.618sec);
amplitude = constant = 0.1618;
pan = random;
4:
duration = 1.618 microsec;
amplitude = (0,0), (r,1) ;
33
pan = pan-function;
5:
Tutti i Control-Space file devono essere contenuti nella directory Level_2 interna allapplicazione.
4.3.1.3 Score File
E il file di output che contiene i grani generati dal sistema. Il suo formato il seguente:
Score File
= ( Generic-Score | Csound-Score )
Generic-Score = *generic-grain
Csound-Score
= *csound-grain
= decimal
ampl-value
pan-value
distance
= decimal
angle
= decimal
; angle 2*
34
Vertex-Positions
Error 2.3.2:the grain generator GGen-ID in the field Vertex-Positions doesn't refer to a
Error 2.3.4:not all the vertexes of the grain generator GGen-ID appear in the field Vertex-
Positions
Error 2.4.2:the graph actant Gact-ID doesn't belong to the grain generatorGGen-ID
Error 2.4.3:the graph actant Gact-ID reports to a not existent vertex in the grain
generator GGen-ID specified in the field Start-Times
Error 2.5:generator-defs has error
Error 2.5.1:not all the grain generators in the GGen-Set have been declared in the field
Generator-Defs
Error 2.5.4:not all the vertexes of the grain generator GGen-ID appear in the field
Generator-Defs
35
Error 2.5.7:the amplitude constant generator in (row: 1*DIGIT, column: 1*DIGIT) has to
Error 2.5.8:the pan constant generator in (row: 1*DIGIT, column: 1*DIGIT) has to be
wrong
sact
Error 2.6.2:if the trajectory exists, at least two points must be specifies for it
Error 3:the GGen file filename has error
Error 3.1:syntax error in the GGen file GGen-filename at (row: 1*DIGIT, column: 1*DIGIT)
Error 3.2:the field edges has error
Error 3.3:the probability 1*DIGIT specified in the GGen file GGen-filename at (row:
1*DIGIT, column: 1*DIGIT) is great of 1
Error 3.4:the sum of the probabilities of the arcs outgoing from the vertex vertex-ID in the
GGen file GGen-filename is great of 1
Error 3.5:the gact in GGen file GGen-filename at (row: 1*DIGIT, column: 1*DIGIT) has
Error 3.6:a grain generator cannot be defined devoid of gacts: such error occur in the GGen
file GGen-filename
Error 4:command error: the SAct is immovable. It is necessary to specify a performance-term
4.3.2
Functional Requirements
1. Generare uno score eseguendo il control space definito nel file specificato dallutente.
36
4.3.3.1 User Interface: E richiesto soltanto un comando utente, il cui formato il seguente:
Command_Line
CS-name
= filename
performance-term = interval ; se time-unit non specificato sono min
CS-name specifica il Control-Space file nel quale definito il control space che si vuole eseguire.
performance-term specifica la durata di tempo di tale esecuzione. Questultimo parametro
Design Contraints
37
Intervals costruisce gli oggetti GGen_obj 1, , GGen_obj n, rispettivamente sulla base delle strutture
dati Ggen_struct 1, , Ggen_struct n in input; inoltre, sulla base dello stato delloggetto
Trajectory_obj, Build GGens and compute Activation Intervals calcola gli intervalli di attivazione di
ciascun vertice di ciascun GGen_obj. Lultimo processo, Perform Control-Space, avvia il processo di
generazione dei Grains a Livello-2, ovvero lesecuzione del control space: tale processo perdura fino
allo scadere del performance-term (input necessario se lSAct immobile), se tale input stato
fornito dallentit User (lutente). I Grains generati vengono memorizzati dal data store Score,
User
Parsing
Control Space
File
SAct + Trajectory
Build SAct
and Trajectory
performance-term
Trajectory_obj
Positions +
Start-times +
Generator-Defs +
audio-radius
GGen-Set
*
Trajectory_obj
Perform
Control-Space
GGen_obj 1
GGen_File 1
GGen_File 1
Get
GGen Files
GGen_File 2
*
*
GGen_File n
Parsing
GGen File
GGen_File 2
*
GGen_File n
Validate CS-File
Ggen_struct 2
GGen_obj 2
Ggen_struct 1
Build Ggens
and compute
Activation
Intervals
Ggen_struct n
Grains
GGen_obj n
Score
GGen_File 1 +
GGen_File 2 +
+ GGen_File n
Level-1
Figura 14: Data flow diagram che rappresenta il functional model del sistema.
Il functional model fin qua descritto mostra, prima, come il Control-Space file e i vari GGen file
debbano essere analizzati singolarmente, poi, come debba essere verificata la consistenza tra il
Control-Space-file e i vari GGen-file. Come gi accennato nel dynamic modeling, aggiungiamo una
nuova object-class al modello che supporti tali funzionalit di controllo sugli input: tale classe la
chiamiamo Validator; essa offre quindi il servizio validateInputFiles( ), che realizza le funzionalit
espresse dai data process Parsing Control Space File, Get GGen Files, Parsing GGen File, e Validate CSFile.
Il functional model mostra anche la necessit di introdurre operazioni per la costruzione degli
oggetti: aggiungiamo quindi un servizio per tale funzionalit ad ogni classe che deve essere
costruita sulla base delle informazioni contenute nei file di input al sistema. Tali classi sono quindi
le seguenti: ControlSpace, Trajectory, ShiftingVector, GGen, Vertex, Edge, GAct, OtherParam, Pan,
Duration, Amplitude, DistFunct, e Grain. Il nome di tale servizio sar della forma buildclassName( ).
Linput di tale servizio varia al variare della classe che lo offre, ma in generale una opportuna
struttura dati intermedia, costruita dal Validator durante loperazione di validazione degli input.
Le operazioni per il calcolo degli intervalli di attivazione e per lesecuzione del control space sono
gi state valutate durante lobject modeling.
39
40
5.5.1
GAct
Algoritmo 1
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
start(Trajectory, performanceTerm )
Vertex
Edge
Grain
Float
FALSE, altrimenti.
audibilityRa
Punti udibili
41
C =
ax0+by0+c/(a2+b2)
y0-y1 (= y0-y2)
,se y1y2
,se y1=y2
x0-x1 = x0-x2
,se x0=x1
dove a, b, c sono i coefficienti della retta passante per i punti tail e head.
getActivationPoints( ) ha come parametri:
un punto (x0,y0);
getListeningPoints( ) ritorna:
i punti estremi del segmento allinterno dello ShiftingVector in cui lSAct pu sentire i
grani eventualmente generati nel punto (x0,y0) (il punto in input), ovvero ritorna i punti o
il singolo punto di intersezione tra la retta passante per i punti tail, head (attributi dello
ShiftingVector) e la circonferenza di centro (x0,y0) e di raggio audibilityRadius (come
rappresentato in Figura 16), se tali/e punti/o esistono/esiste;
NULL, altrimenti.
audibilityRadius
(x0,y0)
(x2,y2)
(x1,y1)
42
dove :
ax+by+c = 0
= -2x0 ;
= -2y0 ;
= (x0)2+(y0)2(audibilityRadius)2 .
dove = (2bcab+a2)2-4(a2+b2)(c2-ac+a2).
Ovviamente,
se >0 ci sono due punti di intersezione (x1,y1), (x2,y2);
se =0 c un solo punto di intersezione (x1,y1);
se <0 non c nessun punto di intersezione, e quindi getListeningPoints( ) ritorna
NULL.
Verificare attraverso il servizio isMyPoint( ) offerto da ShiftingVector se il punto o i punti
determinati al passo precedente appartengono o meno allo stesso ShiftingVector. I casi possibili
sono presentati in Figura 17: saranno ritornati solo i punti in rosso.
getPointToLength( ) prende in input una lunghezza L, e ritorna:
il punto appartenente allo ShiftingVector e che dista L da tail dello stesso vettore, se L0 e
L minore o uguale alla lunghezza del vettore.
NULL, altrimenti.
Supponendo che L sia positivo e minore o uguale alla lunghezza dello ShiftingVector, per ottenere
il corretto risultato da ritornare, getPointToLength( ) deve:
1) risolvere il seguente sistema, il cui significato geometrico dato in Figura 18:
audibilityRadius
audibilityRadius
(x0,y0)
(x ,y )
(x2,y2)
(x0,y0)
(x ,y )
(x2,y2)
43
Caso 1
Caso 2
audibilityRadius
(x0,y0)
audibilityRadius
0
(x2,y2)
(x0,y0)
(x1,y1)
(x1,y1)
Caso 3
Caso 4
audibilityRadius
(x0,y0)
(x2,y2)
(x2,y2)
audibilityRadius
0
(x2,y2)
(x0,y0)
(x1,y1)
(x1,y1)
Caso 5
Caso 6
Figura 17: Possibili casi che la funzione getListeningPoints( ) deve valutare, nel caso
in cui i punti di intersezione calcolati dalla stessa sono due ((x1,y1), (x2,y2)).
(x2,y2)
L
(x0,y0)
(x1,y1)
(xx0)2+(yy0)2 = L2
aX+by+c = 0
44
dove a, b, c sono i coefficienti della retta passante per i punti tail e head; ovvero,
x2+y2+x+y+ = 0
ax+by+c = 0
dove :
= -2x0 ;
= -2y0 ;
= (x0)2+(y0)2(L)2 .
FALSE, altrimenti.
45
5.5.3
Trajectory
Algoritmo 2
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
getInstantToPoint( Point )
/* -----------------------------------------------------------------------------------------------------------------Post.: ritorna -1, se lSAct immobile o se point non appartiene alla traiettoria
ritorna il tempo che impiega l'SAct a raggiungere Point, altrimenti
------------------------------------------------------------------------------------------------------------------ */
INTEGER
FLOAT
i := 0 ;
length := 0;
Algoritmo 3
1.
2.
3.
4.
5.
6.
7.
8.
9.
getSActActualPosition( instant )
FLOAT
SHIFTINGVECTOR s
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
totalPathLength, partialPathLength := 0
END
Analizziamo ora getAngle( ). I suoi input sono: un istante di tempo t e un punto (x0,y0).
46
(x3,y3)
vertexPosition
(x0,y0)
(x1,y1)
SAct
(x2,y2)
arctg(m)
/2
+arctg(m)
+arctg(m)
(3/2)
2+arctg(m)
2
,se
,se
,se
,se
,se
,se
,se
,se
x0>x1
x0=x1
x0<x1
x0<x1
x0<x1
x0=x1
x0>x1
x0>x1
y0>y1
y0>y1
y0>y1
y0=y1
y0<y1
y0<y1
y0<y1
y0=y1
47
, se
2-(-)
, se <
Se x2=x3
Se y2=y3
-(2+)
, se (2+)
, se <(2+)
=/2
-/2
, se
+(3/2)
, se <
, se <2
, se =2
=0
=
48
5.5.4
Vertex
Algoritmo 4
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
computeActivationIntervals ( Trajectory )
IF ( LSAct immobile ) THEN
IF ( il csPoint un punto udibile dallSAct ) THEN
alwaysActive := TRUE;
ELSE
11.
12.
13.
14.
15.
16.
17.
ENDDO
5.6 Conclusioni
In questo capitolo abbiamo visto la progettazione object oriented del caso di studio proposto da
questa tesi, adottando la metodologia di progettazione OMT (Object Modeling Technique) [25].
Nei vari paragrafi del capitolo sono state descritte brevemente le varie fasi dellattivit di design:
object modeling, dynamic modeling, functional modeling, implementation concerns, e detailed
design.
49
6Conclusioni
In questa tesi stato presentato un sistema formale (GeoGraphy) alternativo ai correnti approcci
alla composizione elettroacustica basata sulla sintesi granulare.
Rispetto alle tradizionali strategie per il controllo della sintesi granulare (vedi nellintroduzione
quelle proposte da Xenakis, Truax e Roads), GeoGraphy d una nuova prospettiva al processo di
composizione, andando a ricoprire i due principali approcci alla sintesi granulare, il note approach e
lo stochastic approach [30].
Attraverso i due livelli di Geography infatti possibile simulare entrambi gli approcci: il primo
livello permette di lavorare sugli oggetti sonori, realizzando un controllo sulla microstruttura,
nonch sulla ministruttura della composizione [32]; nel secondo livello, al contrario del primo, gi
insita una propria valenza formale a livello compositivo, pertanto esso definisce e realizza
chiaramente una strategia per il controllo della sintesi granulare.
Queste considerazioni, insieme alla forza compositiva, fanno di GeoGraphy unimplementazione
della sintesi granulare con un forte potere espressivo.
Per quanto riguarda lesperienza di lavoro di sviluppo del prototipo che implementa GeoGraphy, si
potuto osservare limportanza dellattivit di analisi, alla quale stata infatti dedicata la gran parte
del tempo. Nelle successive fasi (object modeling e progettazione) si cercato di modellare il
sistema, seguendo lapproccio orientato agli oggetti, con lo scopo di definire classi riutilizzabili in
una eventuale ulteriore esperienza di sviluppo: per fare questo, stata separata lelaborazione degli
input forniti dallutente dalle classi proprie di GeoGraphy (non della sua specifica
implementazione).
50
7Bibliografia
[1]
[2]
[3]
I. Beekman, Journal tenu par Issac Beekman de 1604 1634, four volumes, C. de Waard,
ed. 1953, The Hague, 1604-1634.
[4]
[5]
[6]
[7]
[8]
[9]
8Appendice
Di seguito data la specifica delle classi e di tutte le strutture dati identificate in fase di
progettazione (vedi capitolo 5). Tale specifica data in C++.
/* ----------------------------------------------------------------------------class_definitions.h:
definisce tutte le classi fin qua identificate, eccetto Validator.
----------------------------------------------------------------------------- */
#ifndef CLASS_DEFINITIONS_H
#define CLASS_DEFINITIONS_H
#include
#include
#include
#include
#include
<stdio.h>
<stdlib.h>
<string.h>
<math.h>
<stdarg.h>
#include "error_messages.h"
#include "cs_struct.h"
};
class Trajectory {
53
public:
Trajectory( );
void buildTrajectory( Traj_Struct trajectory_struct );
inline bool isImmovableSAct( ) { return (sactSpeed == 0); }
bool isAudiblePointFromInitialPosition( Point position );
ShiftingVector* getNextShiftingVector( );
inline void resetSVectorPt( ) { sVectorPt = 0; }
inline double getSActAudibilityRadius( ) { return sactAudibilityRadius; }
double getInstantToPoint( Point point );
double getTotalTrajectoryNavigationTime( );
double getDistance( double instant, Point point );
double getAngle( double instant, Point point );
private:
Point sactInitialPosition;
double sactSpeed;
double sactAudibilityRadius;
unsigned long int numberOfShiftingVectors, sVectorPt;
ShiftingVector* shiftingVectors;
void getSActActualPosition( double instant, Point* &sactActualPos,
ShiftingVector* &sactActualSV );
inline double distance( Point p1, Point p2 )
{ return sqrt( pow((p1.x - p2.x), 2) + pow((p1.y - p2.y), 2) ); }
};
class Score {
public:
void insertGrain( Grain* grain );
/* il grain viene inserito al fondo della lista */
void writeInTheScoreFile( char* ScoreFilename );
private:
54
};
class ParamGenerator {
public:
virtual double getValue( unsigned int noOfArgs, ... ) = 0;
};
55
};
class Vertex {
public:
Vertex( );
void buildVertex( Vx_Struct vertex_definition );
inline char* getLabel( ) { return label; }
inline unsigned long int getNumberOfEdges( ) { return numberOfEdges; }
void attachEdge( IngoingVertex arrival_vertex, double temporal_distance,
double route_probability );
inline void resetEdgePt( ) { edgePt = 0; }
void computeActivationIntervals( Trajectory trajectory );
bool isActive( double instant );
Grain* grainGenerator( double instant, Trajectory trajectory );
Edge* chooseEdge( );
private:
char* label;
Point vertexPosition;
Duration duration;
Amplitude amplitude;
Pan pan;
unsigned long int numberOfOtherParams;
OtherParam* OtherParams;
unsigned long int numberOfEdges, edgePt;
Edge* edges;
bool alwaysActive;
ActivationIntervals activationIntervals;
};
class GAct {
public:
GAct( );
void buildGAct( Vertex* beginning_vertex, double start_time );
void startTrackGenerationProcess( Trajectory trajectory,
double performance_term );
private:
Vertex* beginningVertex;
double startTime;
};
class GGen {
public:
56
GGen( );
void buildGGen( GGen_Struct ggen_definition );
void computeVxActivationIntervals( Trajectory trajectory );
void startGActs( Trajectory trajectory, double performance_term );
private:
char* ggenName;
unsigned long int numberOfVertexes;
Vertex* vertexSet;
unsigned long int numberOfGActs;
GAct* gactSet;
Vertex* getVertex( char* vx_label );
};
class ControlSpace {
public:
ControlSpace( );
void buildControlSpace( char* CS_filename, double performance_term );
void startPerformance( );
private:
char* controlSpaceName;
double performanceTerm;
unsigned long int ggenSetCardinality;
GGen* ggenSet;
Trajectory trajectory;
};
#endif
57
/* ----------------------------------------------------------------------------ifiles_validator.h:
definisce tutte le classi fin qua identificate, eccetto Validator.
----------------------------------------------------------------------------- */
#ifndef IFILES_VALIDATOR_H
#define IFILES_VALIDATOR_H
#include "csf_struct.h"
#include "ggenf_struct.h"
#include "cs_struct.h"
typedef struct file_position {
unsigned long int row;
unsigned long int column;
} File_Position;
class Validator {
public:
Validator( );
~Validator( );
void validateInputFiles( char* cs_filename );
CS_Struct* getCSstruct( );
void destroyCSstruct( CS_Struct* cs_struct );
private:
/* ======= variabili d'istanza ======= */
CtrlSpace_File*
cs_file_struct;
char*
cs_file_string;
char*
cs_pt;
char*
ggen_file_name;
char*
ggen_file_string;
char*
gs_pt;
File_Position*
cs_file_position;
File_Position*
ggen_file_position;
/* ========= funzioni private ========= */
void ggen_set( );
void positions( );
void start_times( );
void sact( );
void generator_defs( );
void trajectory( );
void validateGGenFile( char* ggen_filename, GGen_File* ggen_file_struct );
void vertexes( Vertexes* vxs );
void edges( Edges** edges_pp );
void gacts( Vertexes* vxs_p );
void fill_field( char* c_1, char* c_2, char** str_pt );
/* ecc. ... */
/* In generale ci sar una funzione privata per ogni regola data in (4.3.1) */
};
#endif
58
/* ----------------------------------------------------------------------------csf_struct.h:
definisce la struttura CtrlSpace_File usata da Validator
----------------------------------------------------------------------------- */
#ifndef CSF_STRUCT_H
#define CSF_STRUCT_H
#include "ggenf_struct.h"
/* ---------------------------------------------------------GGen-Set
= *comment
"GGen-set:" 1#GGen-filename *SP field-term
GGen-filename
= filename
filename
= <UNIX/Windows filename>
---------------------------------------------------------- */
typedef struct ggens* Next_GGen;
typedef struct ggens
{
char*
unsigned long int
GGen_File
Next_GGen
} GGens;
ggen_name;
ggen_number;
ggen_file;
next, prev;
ggens;
ggens_number;
/* ---------------------------------------------------------------Positions
= *comment
"Vertex-positions:" 1*GGen-position
GGen-position
= *comment
*LWS GGen-filename ":" 1#vertex-position
*SP field-term
vertex-position
point
ggen_poss;
next_pos, prev_pos;
59
Position*
unsigned long int
} Positions;
posit;
ggens_number;
/* ----------------------------------------------------------------Start-Times
= *comment
"Start-times:" 1*GGen-times
GGen-times
= *comment
*LWS GGen-filename ":" 1#GAct-time
*SP field-term
GAct-time
= GAct-ID *SP "-->" *SP interval
GAct-ID
= vertex-ID ["_" 1*DIGIT]
----------------------------------------------------------------- */
typedef struct gact_id
{
char*
unsigned long int
} GAct_ID;
vx_ID;
index;
speed
speed-unit
space-unit
= *comment
*LWS GGen-filename ":" 1*vertex-generator
vertex-generator
= *comment
*LWS vertex-ID ":"
duration
amplitude
60
pan
*other-param
duration
pan
other-param
other-param-ID
generator
constant
pan-funct
rand-funct
dist-funct
=
=
=
=
=
funct-point
----------------------------------------------------------------- */
typedef struct dist_funct* Next_Couple;
typedef struct dist_funct
{
Point
couple;
Next_Couple next_couple, prev_couple;
} Dist_Funct;
typedef struct domain_restr
{
double min;
double max;
} Domain_Restr;
typedef union dur_gen
{
Domain_Restr domain;
double
constant;
Dist_Funct* dist_funct;
} Dur_Gen;
typedef union gen
{
double
Dist_Funct*
} Gen;
constant;
dist_funct;
61
Gen_Type
Gen
Next_Hpam
} Hpam_Gen;
gen_type;
gen;
next_hpam;
vx_ID;
dur_gen;
ampl_gen;
pan_gen;
other_pam_gen;
Hpam_number;
next_vx, prev_vx;
62
/* ----------------------------------------------------------------------------ggenf_struct.h:
definisce la struttura dati GGen_File (usata da Validator) che mantiene le info
di un GGen File
----------------------------------------------------------------------------- */
#ifndef GGENF_STRUCT_H
#define GGENF_STRUCT_H
/* ---------------------------------------------------Vertexes
= *comment
"Vertexes:" 1#vertex *SP field-term
vertex
label
other-params
vertex-ID
ALPHA
UPALPHA
LOALPHA
=
=
=
=
=
=
GActs
= *comment
"GActs:" 1#(vertex-ID "<-" [gact-number])
*SP field-term
vx;
vx_number;
/* ----------------------------------------------------------------Edges
= *comment
"Edges:" 1#(edge [*SP "-->" *SP weight])*SP field-term
edge
weight
route-interval
= interval | "rand"
interval
time-unit
factor
ruote-prob
= prob | "auto"
prob
= "1" | "0" ["." 1*DIGIT]
----------------------------------------------------------------- */
typedef struct weight
{
double route_interval;
double route_prob;
} Weight;
// -1 = "rand"
// -1 = "auto"
63
/* ------------------GGen_File
= Vertexes
[Edges]
Gacts
*comment
------------------- */
typedef struct ggen_file
{
Vertexes
vertexes;
Edges*
edges;
} GGen_File;
#endif
64
/* ----------------------------------------------------------------------------cs_struct.h:
definisce la struttura dati CS_Struct ritornata dal servizio getCSstruct( )
offerto dalla classe Validator
----------------------------------------------------------------------------- */
#ifndef CS_STRUCT_H
#define CS_STRUCT_H
#include "csf_struct.h"
typedef struct generators_struct
{
Duration_Gen*
duration;
Ampl_Gen*
amplitude;
Pan_Gen*
pan;
Hpam_Gen*
hpams;
} Generators_Struct;
typedef struct edge_struct
{
char* to_vx;
double temporal_dist;
double route_prob;
} Edge_Struct;
typedef struct edges_struct
{
unsigned long int edges_number;
Edge_Struct*
edges_vector;
} Edges_Struct;
typedef struct vx_struct
{
char*
Point*
unsigned long int
Generators_Struct*
unsigned long int
double*
Edges_Struct
label;
position;
other_pam_number;
generators;
gact_number;
gacts_start_times_vector;
edges;
} Vx_Struct;
typedef struct ggen_struct
{
char*
ggen_name;
unsigned long int vx_number;
Vx_Struct*
vxs_vector;
unsigned long int gact_number;
} GGen_Struct;
typedef struct GGens_Struct
{
unsigned long int ggen_number;
GGen_Struct*
ggens_vector;
} GGens_Struct;
typedef struct traj_struct
{
Point*
sact_initial_position;
double
sact_speed;
double
sact_audibility_radius;
unsigned long int point_number;
Point**
points_vector;
} Traj_Struct;
typedef struct cs_struct
{
GGens_Struct ggens;
Traj_Struct trajectory;
} CS_Struct;
65
#endif
66