Giulio Romano De Mattia

Ricordando giornalmente la nascita

8 minute read

Introduzione

Delta-Engine è un sistema di composizione algoritmica basato su un meccanismo di transizione tra stati musicali. Il sistema utilizza numerose tabelle per memorizzare, manipolare e analizzare parametri musicali a diversi livelli di astrazione. Questo documento analizza in dettaglio tutte le tabelle definite nei file first.orc e second.orc, spiegando la loro funzione, il flusso di dati e le interrelazioni nel processo compositivo.

1. Sistema di Intonazione

gi_Intonazione ftgen 0, 0, 2001, -2, 0
  • Scopo: Memorizza il sistema di frequenze pitagoriche generato all’inizio della composizione.
  • Scrittura:
    • GenPythagFreqs.udo attraverso l’opcode GenPythagFreqs che popola la tabella
    • Inizializzata in Generatore all’inizio della composizione
  • Lettura:
    • pfield_freq.udo attraverso l’opcode calcFrequenza per determinare le altezze
    • Usata indirettamente da Comportamento.orc per generare le note
  • Dimensione: 2001 elementi per ospitare frequenze attraverso le ottave e gli intervalli definiti da $INTERVALLI e $OTTAVE
  • Caratteristiche: Le frequenze vengono generate secondo un sistema di intonazione pitagorico, che utilizza il rapporto di 3/2 (quinta perfetta) per definire gli intervalli successivi.

2. Tabelle degli Eventi Sonori

gi_eve_attacco ftgen 0, 0, gi_NUMEVENTI, -2, 0     
gi_eve_durata ftgen 0, 0, gi_NUMEVENTI, -2, 0     
gi_eve_ampiezza ftgen 0, 0, gi_NUMEVENTI, -2, 0    
gi_eve_frequenza1 ftgen 0, 0, gi_NUMEVENTI, -2, 0  
gi_eve_frequenza2 ftgen 0, 0, gi_NUMEVENTI, -2, 0  
gi_eve_posizione ftgen 0, 0, gi_NUMEVENTI, -2, 0   
gi_eve_hr ftgen 0, 0, gi_NUMEVENTI, -2, 0          
gi_eve_ifn ftgen 0, 0, gi_NUMEVENTI, -2, 0         
gi_eve_comportamento ftgen 0, 0, gi_NUMEVENTI, -2, 0
  • Scopo: Ciascuna tabella memorizza un parametro specifico per tutti gli eventi sonori individuali.
  • Scrittura:
    • Principalmente riempite dallo strumento Comportamento in Comportamento.orc durante la generazione
    • gi_eve_attacco riceve i tempi di attacco calcolati in base al ritmo corrente
    • gi_eve_durata memorizza la durata di ogni evento, influenzata da suggestDurationFactor in calcDurationFactor.udo
    • gi_eve_ampiezza immagazzina valori di ampiezza calcolati da calcAmpiezza in pfield_amp.udo
    • gi_eve_frequenza1/2 ricevono le frequenze calcolate da calcFrequenza in pfield_freq.udo
    • gi_eve_posizione memorizza la posizione spaziale dell’evento
    • gi_eve_hr (harmonic ratio) memorizza il valore ritmico usato per la spazializzazione
    • gi_eve_ifn memorizza l’indice della funzione di forma d’onda
    • gi_eve_comportamento collega ogni evento al comportamento che l’ha generato
  • Lettura:
    • Lette da eventoSonoro in eventoSonoro.orc per generare i suoni concreti
    • Analizzate continuamente da Analizzatore in Analizzatore.orc per monitorare sovrapposizioni
    • Lette da AnalisiFinale in AnalisiFinale.orc per le statistiche finali
    • Lette da logEventParams in debug_log.orc per la registrazione dei dati
  • Dimensione: gi_NUMEVENTI (1000) elementi ciascuna, rappresentante la capacità massima di eventi
  • Caratteristiche: Queste tabelle rappresentano il livello più basso della gerarchia compositiva, memorizzando i parametri concreti di sintesi per ogni evento sonoro.

3. Tabelle dei Comportamenti

gi_comp_ATTACCO ftgen 0, 0, gi_NUMComportamenti, -2, 0       
gi_comp_RITMO_LEN ftgen 0, 0, gi_NUMComportamenti, -2, 3     
gi_comp_RITMO_VAL ftgen 0, 0, gi_NUMComportamenti*5, -2, 4,5,3
gi_comp_DURARMONICA ftgen 0, 0, gi_NUMComportamenti, -2, 10    
gi_comp_DURATA ftgen 0, 0, gi_NUMComportamenti, -2, 20.0    
gi_comp_AMPIEZZA ftgen 0, 0, gi_NUMComportamenti, -2, -20    
gi_comp_OTTAVA ftgen 0, 0, gi_NUMComportamenti, -2, 3       
gi_comp_REGISTRO ftgen 0, 0, gi_NUMComportamenti, -2, 4     
gi_comp_POS_LEN ftgen 0, 0, gi_NUMComportamenti, -2, 3      
gi_comp_POSIZIONE ftgen 0, 0, gi_NUMComportamenti*5, -2, 0,0,0
  • Scopo: Definiscono i parametri per i generatori di comportamento musicale, che rappresentano pattern di alto livello.
  • Scrittura:
    • Inizializzate in Generatore con valori di base
    • Modificate da BehaviorGenerator in TransitionController.orc attraverso generateTransitionBehavior
    • I parametri interpolati vengono generati dalle funzioni in parameterInterpolation.udo
    • gi_comp_RITMO_VAL e gi_comp_POSIZIONE contengono array di valori per ogni comportamento
  • Lettura:
    • Lette da GeneraComportamenti in GeneraComportamenti.orc
    • Validate da Validator in validator.udo prima dell’uso
    • Utilizzate indirettamente da stateMapping.udo per tradurre gli stati in parametri
  • Dimensione: gi_NUMComportamenti (100) elementi, con tabelle di ritmo e posizione aventi capacità 5x
  • Caratteristiche: Rappresentano il livello intermedio della gerarchia compositiva, traducendo gli stati musicali astratti in parametri concreti di generazione sonora.

4. Tabelle del Sistema di Analisi

gi_analysis_active_events ftgen 0, 0, gi_analysis_buffer_size, -2, 0
gi_analysis_timepoints ftgen 0, 0, gi_analysis_buffer_size, -2, 0
  • Scopo: Memorizzano dati di analisi in tempo reale degli eventi attivi per monitorare l’evoluzione della composizione.
  • Scrittura:
    • Aggiornate dallo strumento Analizzatore in Analizzatore.orc a k-rate (10Hz)
    • gi_analysis_active_events registra quanti eventi sono attivi in ogni istante
    • gi_analysis_timepoints registra i timestamp corrispondenti
    • Utilizza un buffer circolare definito da gk_analysis_index
  • Lettura:
    • Lette da AnalisiFinale per generare statistiche e file CSV
    • Consultate da recordCurrentState in transControllerUtils.udo per determinare lo stato corrente
  • Dimensione: gi_analysis_buffer_size (100.000) elementi per un tracciamento esteso
  • Caratteristiche: Questo sistema permette di analizzare la densità di eventi nel tempo, fornendo feedback essenziale per il sistema di transizione di stato.

5. Tabelle della Memoria Compositiva

gi_memory_overlap ftgen 0, 0, gi_memory_size, -2, 0
gi_memory_events ftgen 0, 0, gi_memory_size, -2, 0
  • Scopo: Memorizzano la storia temporale della composizione, fungendo da “memoria a lungo termine” del sistema.
  • Scrittura:
    • Aggiornate dallo strumento Analizzatore a intervalli regolari (ogni gi_memory_resolution secondi)
    • gi_memory_overlap registra la sovrapposizione di eventi nel tempo
    • gi_memory_events conta il numero di eventi attivi
  • Lettura:
    • Consultate da suggestDurationFactor in calcDurationFactor.udo per adattare le durate
    • Lette da analyzeCompositionMemory per analizzare periodi temporali
    • Esportate da AnalisiFinale in file CSV per analisi offline
  • Dimensione: gi_memory_size (480 elementi per 480 secondi con risoluzione di 1 secondo)
  • Caratteristiche: Questa memoria consente al sistema di adattare i nuovi eventi basandosi sulla storia compositiva, evitando sovrapposizioni eccessive o vuoti prolungati.

6. Tabelle di Tracciamento Armonico

gi_active_octaves ftgen 0, 0, $OTTAVE, -2, 0
gi_active_registers ftgen 0, 0, $REGISTRI, -2, 0
gi_octave_register_matrix ftgen 0, 0, $OTTAVE * $REGISTRI, -2, 0
gi_memory_harmonic_density ftgen 0, 0, gi_memory_size, -2, 0
gi_memory_octave_spread ftgen 0, 0, gi_memory_size, -2, 0
gi_memory_spectral_centroid ftgen 0, 0, gi_memory_size, -2, 0
gi_memory_spatial_movement ftgen 0, 0, gi_memory_size, -2, 0
gi_cumulative_octave_register_matrix ftgen 0, 0, $OTTAVE * $REGISTRI, -2, 0
  • Scopo: Tracciano distribuzione armonica e caratteristiche di movimento per analizzare l’evoluzione spettrale della composizione.
  • Scrittura:
    • Aggiornate in tempo reale da Analizzatore in Analizzatore.orc
    • active_octaves/registers: Contano eventi in ogni ottava/registro
    • octave_register_matrix: Matrice distribuzione bidimensionale (10x10)
    • Le tabelle memory_* registrano metriche armoniche nel tempo
    • cumulative_octave_register_matrix: Accumula distribuzione nell’intera composizione
  • Lettura:
    • Lette da determineCurrentState in determineState.udo per classificare lo stato
    • Utilizzate da analyzeHarmonicMemory in calcDurationFactor.udo
    • Consultate da predictNextState in adaptiveStatePrediction.udo
    • Esportate da AnalisiFinale per visualizzazioni
  • Dimensione: Varie dimensioni basate su ottave (10), registri (10) o dimensione memoria (480)
  • Caratteristiche: Queste tabelle forniscono informazioni dettagliate sulla distribuzione spettrale e il movimento spaziale, essenziali per le decisioni di transizione tra stati.

7. Sistema di Classificazione degli Stati

gi_density_thresholds ftgen 0, 0, 4, -2, 0, 3, 7, 1000
gi_register_thresholds ftgen 0, 0, 4, -2, 0, 0.3, 0.7, 1.001
gi_movement_thresholds ftgen 0, 0, 4, -2, 0, 0.2, 0.5, 1.001
gi_state_history_density ftgen 0, 0, gi_state_history_size, -2, 0
gi_state_history_register ftgen 0, 0, gi_state_history_size, -2, 0
gi_state_history_movement ftgen 0, 0, gi_state_history_size, -2, 0
gi_memory_state_density ftgen 0, 0, gi_memory_size, -2, 0
gi_memory_state_register ftgen 0, 0, gi_memory_size, -2, 0
gi_memory_state_movement ftgen 0, 0, gi_memory_size, -2, 0
gi_transition_matrix ftgen 0, 0, 27*27, -2, 0
  • Scopo: Definiscono e tracciano il sistema di stati musicali e le loro transizioni.
  • Scrittura:
    • *_thresholds: Inizializzate staticamente in first.orc per definire confini tra stati
    • state_history_*: Aggiornate da recordCurrentState in transControllerUtils.udo
    • memory_state_*: Scritte da Analizzatore per tracciare gli stati nel tempo
    • transition_matrix: Inizializzata da initTransitionMatrix in stateTransition.udo e aggiornata da updateTransitionMatrix in adaptiveStatePrediction.udo
  • Lettura:
    • *_thresholds: Lette da determineCurrentState in determineState.udo
    • state_history_*: Consultate da TransitionDecider per decisioni di transizione
    • transition_matrix: Letta da selectNextState in stateTransition.udo
    • Tutte esportate da SaveTransitionMatrix e EnhancedSaveTransitionMatrix per analisi
  • Dimensione: Varie dimensioni (soglie=4, storia=10, memoria=480, matrice=729)
  • Caratteristiche: Il cuore del sistema di composizione basato su stati, con 27 stati totali (3 livelli di densità × 3 livelli di registro × 3 livelli di movimento) e una matrice di transizione 27×27.

8. Tabelle del Controller di Transizione (da second.orc)

gi_tc_past_states ftgen 0, 0, 24, -2, 0
gi_tc_expected_state_table ftgen 0, 0, 100, -2, 0
gi_tc_actual_state_table ftgen 0, 0, 100, -2, 0
  • Scopo: Supportano la valutazione della qualità delle transizioni e l’apprendimento adattivo.
  • Scrittura:
    • past_states: Popolata da recordCurrentState in transControllerUtils.udo
    • expected_state_table: Scritta da initializeTransition per prevedere il percorso di transizione
    • actual_state_table: Aggiornata durante le transizioni da recordCurrentState
  • Lettura:
    • Lette da assessTransitionQuality per valutare l’efficacia delle transizioni
    • Consultate da adaptTransitionParameters per migliorare le future transizioni
    • Utilizzate da predictNextState in adaptiveStatePrediction.udo per l’apprendimento adattivo
  • Dimensione: Dimensioni variabili per diversi scopi di tracciamento (stati passati=24, punti di transizione=100)
  • Caratteristiche: Implementano un sistema di apprendimento che migliora le transizioni nel tempo basandosi sui risultati passati.

9. Tabelle per l’Apprendimento Adattivo

gi_asp_transition_history ftgen 0, 0, 100*7, -2, 0
gi_asp_context_features ftgen 0, 0, 10, -2, 0
  • Scopo: Supportano il sistema di apprendimento adattivo per migliorare le decisioni di transizione.
  • Scrittura:
    • transition_history: Aggiornata da recordTransition in adaptiveStatePrediction.udo
    • context_features: Memorizza caratteristiche del contesto musicale attuale
  • Lettura:
    • Utilizzate da predictNextState per selezionare stati target basati su esperienze passate
    • Consultate da calculateContextSimilarity per trovare contesti musicali simili
  • Dimensione: La storia delle transizioni memorizza 100 transizioni (7 valori ciascuna)
  • Caratteristiche: Implementano un sistema di apprendimento per migliorare progressivamente le decisioni di transizione basandosi sui risultati passati.

Relazioni tra i Gruppi di Tabelle

Le tabelle in Delta-Engine formano una gerarchia interconnessa che opera a diversi livelli:

Livello Alto: Sistema di Stati

  • Tabelle primarie: gi_transition_matrix, gi_*_thresholds, gi_state_history_*
  • Funzione: Definisce lo stato musicale globale e le regole di transizione
  • Implementazione: TransitionController.orc, stateTransition.udo, determineState.udo
  • Processo: Determina quando e come effettuare transizioni tra stati musicali

Livello Intermedio: Parametri di Comportamento

  • Tabelle primarie: gi_comp_*
  • Funzione: Traduce gli stati astratti in pattern musicali specifici
  • Implementazione: GeneraComportamenti.orc, BehaviorGenerator, stateMapping.udo
  • Processo: Converte un determinato stato (es. “densità alta, registro medio, movimento statico”) in parametri concreti di generazione sonora

Livello Basso: Parametri degli Eventi

  • Tabelle primarie: gi_eve_*
  • Funzione: Memorizza parametri per eventi sonori individuali
  • Implementazione: Comportamento.orc, eventoSonoro.orc
  • Processo: Crea eventi sonori concreti con parametri specifici di sintesi

Sistema di Feedback: Analisi e Adattamento

  • Tabelle primarie: gi_analysis_*, gi_memory_*, gi_asp_transition_history
  • Funzione: Monitora l’output musicale e fornisce feedback per future decisioni
  • Implementazione: Analizzatore.orc, AnalisiFinale.orc, adaptiveStatePrediction.udo
  • Processo: Analizza continuamente la composizione, impara dai risultati e adatta le future decisioni

Flusso dei Dati nel Sistema di Tabelle

  1. Lo strumento Analizzatore monitora continuamente gli eventi attivi, aggiornando le tabelle di analisi e memoria
  2. Il TransitionController usa queste informazioni per determinare lo stato musicale corrente
  3. TransitionDecider decide quando avviare una transizione verso un nuovo stato
  4. initializeTransition seleziona uno stato target e pianifica una traiettoria di transizione
  5. BehaviorGenerator genera comportamenti con parametri interpolati tra stato origine e destinazione
  6. GeneraComportamenti converte questi parametri in uno strumento Comportamento
  7. Comportamento genera molteplici eventi sonori, memorizzandoli nelle tabelle gi_eve_*
  8. eventoSonoro legge queste tabelle per produrre il suono effettivo
  9. Analizzatore rileva questi nuovi eventi, completando il ciclo

Questo sistema circolare di generazione, analisi e adattamento permette a Delta-Engine di creare composizioni musicali complesse, coerenti ed evolutive attraverso il suo sofisticato meccanismo di transizione tra stati.

You May Also Enjoy