ready for deply

.gitignore

@@ -1,31 +1,10 @@
 # Python
 __pycache__/
 *.py[cod]
-*$py.class
 *.so
-.Python
-env/
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
 
 # Virtual Environment
 .venv/
-venv/
-ENV/
-env/
 
 # IDE
 .vscode/
@@ -36,26 +15,16 @@ env/
 
 # OS
 .DS_Store
-.DS_Store?
-._*
-.Spotlight-V100
-.Trashes
-ehthumbs.db
-Thumbs.db
 
 # Project specific
 *.wav
 *.mp3
 *.pth
-
-
-# Data files
-data/
 *.mat
-
-otherfiles/
-
 app.log
 
-source/
-sounds/
+# Data and generated folders
+data/
+sounds/
+otherfiles/
+source/

app.log

@@ -1,452 +0,0 @@
-🧠 EEG Motor Imagery Music Composer
-==================================================
-Starting Gradio application...
-🎯 New random sequence (5 movements): Left Leg → Right Leg → Right Hand → Left Hand → Tongue
-Loaded sound for left_hand: 1_SoundHelix-Song-6_(Bass).wav
-Loaded sound for right_hand: 1_SoundHelix-Song-6_(Drums).wav
-Loaded sound for left_leg: 1_SoundHelix-Song-6_(Other).wav
-Loaded sound for tongue: 1_SoundHelix-Song-6_(Vocals).wav
-Loaded sound for right_leg: 1_SoundHelix-Song-6_(Bass).wav
-Dropped auxiliary channels [np.str_('X5')]. Remaining channels: 21
-Creating RawArray with float64 data, n_channels=21, n_times=667600
-    Range : 0 ... 667599 =      0.000 ...  3337.995 secs
-Ready.
-Not setting metadata
-959 matching events found
-No baseline correction applied
-0 projection items activated
-Using data from preloaded Raw for 959 events and 301 original time points ...
-0 bad epochs dropped
-Dropped auxiliary channels [np.str_('X5')]. Remaining channels: 21
-Creating RawArray with float64 data, n_channels=21, n_times=681400
-    Range : 0 ... 681399 =      0.000 ...  3406.995 secs
-Ready.
-Not setting metadata
-958 matching events found
-No baseline correction applied
-0 projection items activated
-Using data from preloaded Raw for 958 events and 301 original time points ...
-0 bad epochs dropped
-Dropped auxiliary channels [np.str_('X5')]. Remaining channels: 21
-Creating RawArray with float64 data, n_channels=21, n_times=813600
-    Range : 0 ... 813599 =      0.000 ...  4067.995 secs
-Ready.
-Not setting metadata
-960 matching events found
-No baseline correction applied
-0 projection items activated
-Using data from preloaded Raw for 960 events and 301 original time points ...
-0 bad epochs dropped
-Not setting metadata
-2877 matching events found
-No baseline correction applied
-✅ Pre-trained model loaded successfully from shallow_weights_all.pth
-✅ Pre-trained model loaded successfully from shallow_weights_all.pth
-Pre-trained Demo: 2877 samples from 3 subjects
-Available sound classes: ['left_hand', 'right_hand', 'neutral', 'left_leg', 'tongue', 'right_leg']
-* Running on local URL:  http://0.0.0.0:7867
-* To create a public link, set `share=True` in `launch()`.
-🎯 New random sequence (5 movements): Right Leg → Tongue → Right Hand → Left Hand → Left Leg
-🔄 Starting Cycle 2
-💪 Let's create your first brain-music composition!
-DEBUG start_automatic_composition: current target = right_leg
-DEBUG: Added layer 1, total layers now: 1
-DEBUG: Composition layers: ['left_leg']
-DEBUG: Current composition has 1 layers: ['left_leg']
-DEBUG: Audio files to mix: ['1_SoundHelix-Song-6_(Other).wav']
-DEBUG: Using base audio file as fallback: 1_SoundHelix-Song-6_(Vocals).wav (FILE SAVING DISABLED)
-✓ Cycle 2: Added 1_SoundHelix-Song-6_(Other).wav for left_leg (1/5 complete)
-DEBUG start_automatic_composition: predicted=left_leg, confidence=0.413, sound_added=True
-DEBUG: Available sounds: ['left_hand', 'right_hand', 'left_leg', 'tongue', 'right_leg']
-DEBUG: Completed movements: {'left_leg'}
-DEBUG: Showing individual sounds that will layer together: ['left_leg']
-DEBUG: Left leg playing: /Users/sofiafregni/Downloads/portfolio_ML_project/Gradio/sounds/1_SoundHelix-Song-6_(Other).wav
-DEBUG: 1 individual sounds will play together creating layered composition
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG: Added layer 2, total layers now: 2
-DEBUG: Composition layers: ['left_leg', 'left_hand']
-DEBUG: Current composition has 2 layers: ['left_leg', 'left_hand']
-DEBUG: Audio files to mix: ['1_SoundHelix-Song-6_(Other).wav', '1_SoundHelix-Song-6_(Bass).wav']
-DEBUG: Using base audio file as fallback: 1_SoundHelix-Song-6_(Vocals).wav (FILE SAVING DISABLED)
-✓ Cycle 2: Added 1_SoundHelix-Song-6_(Bass).wav for left_hand (2/5 complete)
-DEBUG continue: Available sounds: ['left_hand', 'right_hand', 'left_leg', 'tongue', 'right_leg']
-DEBUG continue: Completed movements: {'left_hand', 'left_leg'}
-DEBUG continue: Showing individual sounds that will layer together: ['left_hand', 'left_leg']
-DEBUG continue: Left hand playing: /Users/sofiafregni/Downloads/portfolio_ML_project/Gradio/sounds/1_SoundHelix-Song-6_(Bass).wav
-DEBUG continue: Left leg playing: /Users/sofiafregni/Downloads/portfolio_ML_project/Gradio/sounds/1_SoundHelix-Song-6_(Other).wav
-DEBUG continue: 2 individual sounds will play together creating layered composition
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG: Added layer 3, total layers now: 3
-DEBUG: Composition layers: ['left_leg', 'left_hand', 'right_hand']
-DEBUG: Current composition has 3 layers: ['left_leg', 'left_hand', 'right_hand']
-DEBUG: Audio files to mix: ['1_SoundHelix-Song-6_(Other).wav', '1_SoundHelix-Song-6_(Bass).wav', '1_SoundHelix-Song-6_(Drums).wav']
-DEBUG: Using base audio file as fallback: 1_SoundHelix-Song-6_(Vocals).wav (FILE SAVING DISABLED)
-✓ Cycle 2: Added 1_SoundHelix-Song-6_(Drums).wav for right_hand (3/5 complete)
-DEBUG continue: Available sounds: ['left_hand', 'right_hand', 'left_leg', 'tongue', 'right_leg']
-DEBUG continue: Completed movements: {'left_hand', 'left_leg', 'right_hand'}
-DEBUG continue: Showing individual sounds that will layer together: ['left_hand', 'left_leg', 'right_hand']
-DEBUG continue: Left hand playing: /Users/sofiafregni/Downloads/portfolio_ML_project/Gradio/sounds/1_SoundHelix-Song-6_(Bass).wav
-DEBUG continue: Right hand playing: /Users/sofiafregni/Downloads/portfolio_ML_project/Gradio/sounds/1_SoundHelix-Song-6_(Drums).wav
-DEBUG continue: Left leg playing: /Users/sofiafregni/Downloads/portfolio_ML_project/Gradio/sounds/1_SoundHelix-Song-6_(Other).wav
-DEBUG continue: 3 individual sounds will play together creating layered composition
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG: Added layer 4, total layers now: 4
-DEBUG: Composition layers: ['left_leg', 'left_hand', 'right_hand', 'right_leg']
-DEBUG: Current composition has 4 layers: ['left_leg', 'left_hand', 'right_hand', 'right_leg']
-DEBUG: Audio files to mix: ['1_SoundHelix-Song-6_(Other).wav', '1_SoundHelix-Song-6_(Bass).wav', '1_SoundHelix-Song-6_(Drums).wav', '1_SoundHelix-Song-6_(Bass).wav']
-DEBUG: Using base audio file as fallback: 1_SoundHelix-Song-6_(Vocals).wav (FILE SAVING DISABLED)
-✓ Cycle 2: Added 1_SoundHelix-Song-6_(Bass).wav for right_leg (4/5 complete)
-DEBUG continue: Available sounds: ['left_hand', 'right_hand', 'left_leg', 'tongue', 'right_leg']
-DEBUG continue: Completed movements: {'left_hand', 'left_leg', 'right_leg', 'right_hand'}
-DEBUG continue: Showing individual sounds that will layer together: ['left_hand', 'left_leg', 'right_leg', 'right_hand']
-DEBUG continue: Left hand playing: /Users/sofiafregni/Downloads/portfolio_ML_project/Gradio/sounds/1_SoundHelix-Song-6_(Bass).wav
-DEBUG continue: Right hand playing: /Users/sofiafregni/Downloads/portfolio_ML_project/Gradio/sounds/1_SoundHelix-Song-6_(Drums).wav
-DEBUG continue: Left leg playing: /Users/sofiafregni/Downloads/portfolio_ML_project/Gradio/sounds/1_SoundHelix-Song-6_(Other).wav
-DEBUG continue: Right leg playing: /Users/sofiafregni/Downloads/portfolio_ML_project/Gradio/sounds/1_SoundHelix-Song-6_(Bass).wav
-DEBUG continue: 4 individual sounds will play together creating layered composition
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG: Added layer 5, total layers now: 5
-DEBUG: Composition layers: ['left_leg', 'left_hand', 'right_hand', 'right_leg', 'tongue']
-DEBUG: Current composition has 5 layers: ['left_leg', 'left_hand', 'right_hand', 'right_leg', 'tongue']
-DEBUG: Audio files to mix: ['1_SoundHelix-Song-6_(Other).wav', '1_SoundHelix-Song-6_(Bass).wav', '1_SoundHelix-Song-6_(Drums).wav', '1_SoundHelix-Song-6_(Bass).wav', '1_SoundHelix-Song-6_(Vocals).wav']
-DEBUG: Using base audio file as fallback: 1_SoundHelix-Song-6_(Vocals).wav (FILE SAVING DISABLED)
-✓ Cycle 2: Added 1_SoundHelix-Song-6_(Vocals).wav for tongue (5/5 complete)
-🎵 Cycle 2 complete! All 5 movements successfully classified!
-📀 Using existing audio as mixed composition: /Users/sofiafregni/Downloads/portfolio_ML_project/Gradio/sounds/1_SoundHelix-Song-6_(Bass).wav (FILE SAVING DISABLED)
-🎵 Composition Complete! Transitioning to DJ Effects Phase...
-🎧 You are now the DJ! Use movements to control effects:
-   👈 Left Hand: Volume Fade
-   👉 Right Hand: High Pass Filter
-   🦵 Left Leg: Reverb Effect
-   🦵 Right Leg: Low Pass Filter
-   👅 Tongue: Bass Boost
-DEBUG: Successfully transitioned to DJ phase with 5 completed movements
-DEBUG continue: DJ mode - NEW mixed composition loaded: /Users/sofiafregni/Downloads/portfolio_ML_project/Gradio/sounds/1_SoundHelix-Song-6_(Bass).wav
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: ON
-🎛️ Audio processed with effects: rev (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: OFF
-🎛️ Audio processed with effects: clean (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: ON
-🎛️ Audio processed with effects: hpf (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: ON
-🎛️ Audio processed with effects: hpf_rev (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: OFF
-🎛️ Audio processed with effects: rev (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Bass Boost: ON
-🎛️ Audio processed with effects: rev_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: ON
-🎛️ Audio processed with effects: hpf_rev_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Bass Boost: OFF
-🎛️ Audio processed with effects: hpf_rev (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎵 Cycle 2 complete! All 5 movements successfully classified!
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG start_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: OFF
-🎛️ Low Pass Filter: ON
-🎛️ Audio processed with effects: rev_lpf (FILE SAVING DISABLED)/Users/sofiafregni/Downloads/portfolio_ML_project/Gradio/app.py:729: RuntimeWarning: More than 20 figures have been opened. Figures created through the pyplot interface (`matplotlib.pyplot.figure`) are retained until explicitly closed and may consume too much memory. (To control this warning, see the rcParam `figure.max_open_warning`). Consider using `matplotlib.pyplot.close()`.
-  fig, axes = plt.subplots(2, 2, figsize=(12, 8))
-
-🎛️ Audio processed with effects: rev_lpf (FILE SAVING DISABLED)
-DEBUG start_automatic_composition: predicted=right_hand, confidence=0.424, sound_added=True
-DEBUG DJ: Playing mixed composition with effects: /Users/sofiafregni/Downloads/portfolio_ML_project/Gradio/sounds/1_SoundHelix-Song-6_(Bass).wav
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: OFF
-🎛️ Audio processed with effects: lpf (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: ON
-🎛️ Audio processed with effects: rev_lpf (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Bass Boost: ON
-🎛️ Audio processed with effects: rev_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: ON
-🎛️ Audio processed with effects: hpf_rev_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: OFF
-🎛️ Audio processed with effects: hpf_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: OFF
-🎛️ Audio processed with effects: lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: ON
-🎛️ Audio processed with effects: hpf_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Low Pass Filter: OFF
-🎛️ Audio processed with effects: hpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: ON
-🎛️ Audio processed with effects: hpf_rev_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: OFF
-🎛️ Audio processed with effects: rev_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Bass Boost: OFF
-🎛️ Audio processed with effects: rev (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: OFF
-🎛️ Audio processed with effects: clean (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: ON
-🎛️ Audio processed with effects: rev (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: ON
-🎛️ Audio processed with effects: hpf_rev (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Bass Boost: ON
-🎛️ Audio processed with effects: hpf_rev_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: OFF
-🎛️ Audio processed with effects: rev_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Low Pass Filter: ON
-🎛️ Audio processed with effects: rev_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Bass Boost: OFF
-🎛️ Audio processed with effects: rev_lpf (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Bass Boost: ON
-🎛️ Audio processed with effects: rev_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Low Pass Filter: OFF
-🎛️ Audio processed with effects: rev_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: OFF
-🎛️ Audio processed with effects: bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Bass Boost: OFF
-🎛️ Audio processed with effects: clean (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Bass Boost: ON
-🎛️ Audio processed with effects: bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: ON
-🎛️ Audio processed with effects: hpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Bass Boost: OFF
-🎛️ Audio processed with effects: hpf (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: ON
-🎛️ Audio processed with effects: hpf_rev (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Bass Boost: ON
-🎛️ Audio processed with effects: hpf_rev_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Low Pass Filter: ON
-🎛️ Audio processed with effects: hpf_rev_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: OFF
-🎛️ Audio processed with effects: rev_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: ON
-🎛️ Audio processed with effects: hpf_rev_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: OFF
-🎛️ Audio processed with effects: rev_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: ON
-🎛️ Audio processed with effects: hpf_rev_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Volume Fade: ON
-🎛️ Audio processed with effects: fade_hpf_rev_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Bass Boost: OFF
-🎛️ Audio processed with effects: fade_hpf_rev_lpf (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Low Pass Filter: OFF
-🎛️ Audio processed with effects: fade_hpf_rev (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: OFF
-🎛️ Audio processed with effects: fade_rev (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: ON
-🎛️ Audio processed with effects: fade_hpf_rev (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: OFF
-🎛️ Audio processed with effects: fade_hpf (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: OFF
-🎛️ Audio processed with effects: fade (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Volume Fade: OFF
-🎛️ Audio processed with effects: clean (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Bass Boost: ON
-🎛️ Audio processed with effects: bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: ON
-🎛️ Audio processed with effects: hpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Volume Fade: ON
-🎛️ Audio processed with effects: fade_hpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Volume Fade: OFF
-🎛️ Audio processed with effects: hpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: ON
-🎛️ Audio processed with effects: hpf_rev_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Volume Fade: ON
-🎛️ Audio processed with effects: fade_hpf_rev_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Low Pass Filter: ON
-🎛️ Audio processed with effects: fade_hpf_rev_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Low Pass Filter: OFF
-🎛️ Audio processed with effects: fade_hpf_rev_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Volume Fade: OFF
-🎛️ Audio processed with effects: hpf_rev_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Bass Boost: OFF
-🎛️ Audio processed with effects: hpf_rev (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Low Pass Filter: ON
-🎛️ Audio processed with effects: hpf_rev_lpf (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: OFF
-🎛️ Audio processed with effects: hpf_lpf (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: OFF
-🎛️ Audio processed with effects: lpf (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Low Pass Filter: OFF
-🎛️ Audio processed with effects: clean (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: ON
-🎛️ Audio processed with effects: rev (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: ON
-🎛️ Audio processed with effects: hpf_rev (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Bass Boost: ON
-🎛️ Audio processed with effects: hpf_rev_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: OFF
-🎛️ Audio processed with effects: hpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: ON
-🎛️ Audio processed with effects: hpf_rev_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Volume Fade: ON
-🎛️ Audio processed with effects: fade_hpf_rev_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Volume Fade: OFF
-🎛️ Audio processed with effects: hpf_rev_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: OFF
-🎛️ Audio processed with effects: hpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Low Pass Filter: ON
-🎛️ Audio processed with effects: hpf_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: OFF
-🎛️ Audio processed with effects: lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Volume Fade: ON
-🎛️ Audio processed with effects: fade_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: ON
-🎛️ Audio processed with effects: fade_rev_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Low Pass Filter: OFF
-🎛️ Audio processed with effects: fade_rev_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Bass Boost: OFF
-🎛️ Audio processed with effects: fade_rev (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎵 Cycle 2 complete! All 5 movements successfully classified!
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Low Pass Filter: ON
-🎛️ Audio processed with effects: fade_rev_lpf (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Volume Fade: OFF
-🎛️ Audio processed with effects: rev_lpf (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: ON
-🎛️ Audio processed with effects: hpf_rev_lpf (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Low Pass Filter: OFF
-🎛️ Audio processed with effects: hpf_rev (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Volume Fade: ON
-🎛️ Audio processed with effects: fade_hpf_rev (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Low Pass Filter: ON
-🎛️ Audio processed with effects: fade_hpf_rev_lpf (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: OFF
-🎛️ Audio processed with effects: fade_hpf_lpf (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Bass Boost: ON
-🎛️ Audio processed with effects: fade_hpf_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: OFF
-🎛️ Audio processed with effects: fade_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: ON
-🎛️ Audio processed with effects: fade_rev_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Volume Fade: OFF
-🎛️ Audio processed with effects: rev_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: ON
-🎛️ Audio processed with effects: hpf_rev_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: OFF
-🎛️ Audio processed with effects: hpf_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Volume Fade: ON
-🎛️ Audio processed with effects: fade_hpf_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Volume Fade: OFF
-🎛️ Audio processed with effects: hpf_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ High Pass Filter: OFF
-🎛️ Audio processed with effects: lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Bass Boost: OFF
-🎛️ Audio processed with effects: lpf (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Volume Fade: ON
-🎛️ Audio processed with effects: fade_lpf (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Reverb Effect: ON
-🎛️ Audio processed with effects: fade_rev_lpf (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Volume Fade: OFF
-🎛️ Audio processed with effects: rev_lpf (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Bass Boost: ON
-🎛️ Audio processed with effects: rev_lpf_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Low Pass Filter: OFF
-🎛️ Audio processed with effects: rev_bass (FILE SAVING DISABLED)
-DEBUG continue_automatic_composition: current target = right_leg
-🎛️ Low Pass Filter: ON
-🎛️ Audio processed with effects: rev_lpf_bass (FILE SAVING DISABLED)

app.py

@@ -34,9 +34,9 @@ classifier = MotorImageryClassifier()
 # Load demo data
 existing_files = [f for f in DEMO_DATA_PATHS if os.path.exists(f)]
 if existing_files:
-    app_state['demo_data'], app_state['demo_labels'] = data_processor.process_files(existing_files)
+    app_state['demo_data'], app_state['demo_labels'], app_state['ch_names'] = data_processor.process_files(existing_files)
 else:
-    app_state['demo_data'], app_state['demo_labels'] = None, None
+    app_state['demo_data'], app_state['demo_labels'], app_state['ch_names'] = None, None, None
 
 if app_state['demo_data'] is not None:
     classifier.load_model(n_chans=app_state['demo_data'].shape[1], n_times=app_state['demo_data'].shape[2])
@@ -45,6 +45,14 @@ if app_state['demo_data'] is not None:
 def get_movement_sounds() -> Dict[str, str]:
     """Get the current sound files for each movement."""
     sounds = {}
+    # Add a static cache for audio file paths per movement and effect state
+    if not hasattr(get_movement_sounds, 'audio_cache'):
+        get_movement_sounds.audio_cache = {m: {False: None, True: None} for m in ['left_hand', 'right_hand', 'left_leg', 'right_leg']}
+        get_movement_sounds.last_effect_state = {m: None for m in ['left_hand', 'right_hand', 'left_leg', 'right_leg']}
+    # Add a static counter to track how many times each movement's audio is played
+    if not hasattr(get_movement_sounds, 'play_counter'):
+        get_movement_sounds.play_counter = {m: 0 for m in ['left_hand', 'right_hand', 'left_leg', 'right_leg']}
+        get_movement_sounds.total_calls = 0
     from sound_manager import AudioEffectsProcessor
     import tempfile
     import soundfile as sf
@@ -55,33 +63,69 @@ def get_movement_sounds() -> Dict[str, str]:
             if sound_file is not None:
                 sound_path = sound_manager.sound_dir / sound_file
                 if sound_path.exists():
-                    if dj_mode and sound_manager.active_effects.get(movement, False):
-                        # Load audio, apply effect, save to temp file
+                    # Sticky effect for all movements: if effect was ON, keep returning processed audio until next ON
+                    effect_on = dj_mode and sound_manager.active_effects.get(movement, False)
+                    # If effect just turned ON, update sticky state
+                    if effect_on:
+                        get_movement_sounds.last_effect_state[movement] = True
+                    # If effect is OFF, but sticky is set, keep using processed audio
+                    elif get_movement_sounds.last_effect_state[movement]:
+                        effect_on = True
+                    else:
+                        effect_on = False
+                    # Check cache for this movement/effect state
+                    cached_path = get_movement_sounds.audio_cache[movement][effect_on]
+                    # Only regenerate if cache is empty or effect state just changed
+                    if cached_path is not None and get_movement_sounds.last_effect_state[movement] == effect_on:
+                        sounds[movement] = cached_path
+                    else:
+                        # Load audio
                         data, sr = sf.read(str(sound_path))
                         if len(data.shape) > 1:
                             data = np.mean(data, axis=1)
-                        processed = AudioEffectsProcessor.process_layer_with_effects(
-                            data, sr, movement, sound_manager.active_effects
-                        )
-                        # Save to temp file
-                        tmp = tempfile.NamedTemporaryFile(delete=False, suffix='.wav')
-                        sf.write(tmp.name, processed, sr)
-                        print(f"DEBUG: Playing PROCESSED audio for {movement}: {tmp.name}")
-                        sounds[movement] = tmp.name
-                    else:
-                        print(f"DEBUG: Playing ORIGINAL audio for {movement}: {sound_path.resolve()}")
-                        sounds[movement] = str(sound_path.resolve())
+                        # Fade-in: apply to all audio on restart (0.5s fade for more gradual effect)
+                        fade_duration = 10  # seconds
+                        fade_samples = int(fade_duration * sr)
+                        if fade_samples > 0 and fade_samples < len(data):
+                            fade_curve = np.linspace(0, 1, fade_samples)
+                            data[:fade_samples] = data[:fade_samples] * fade_curve
+                        if effect_on:
+                            # Apply effect
+                            processed = AudioEffectsProcessor.process_layer_with_effects(
+                                data, sr, movement, sound_manager.active_effects
+                            )
+                            # Save to temp file (persistent for this effect state)
+                            tmp = tempfile.NamedTemporaryFile(delete=False, suffix=f'_{movement}_effect.wav')
+                            sf.write(tmp.name, processed, sr)
+                            print(f"DEBUG: Playing PROCESSED audio for {movement}: {tmp.name}")
+                            get_movement_sounds.audio_cache[movement][True] = tmp.name
+                            sounds[movement] = tmp.name
+                        else:
+                            print(f"DEBUG: Playing ORIGINAL audio for {movement}: {sound_path.resolve()}")
+                            get_movement_sounds.audio_cache[movement][False] = str(sound_path.resolve())
+                            sounds[movement] = str(sound_path.resolve())
+                        get_movement_sounds.last_effect_state[movement] = effect_on
+                    get_movement_sounds.play_counter[movement] += 1
+    get_movement_sounds.total_calls += 1
+    # Print summary every 20 calls
+    if get_movement_sounds.total_calls % 20 == 0:
+        print("AUDIO PLAY COUNTS (DJ mode):", dict(get_movement_sounds.play_counter))
     return sounds
 
-def create_eeg_plot(eeg_data: np.ndarray, target_movement: str, predicted_name: str, confidence: float, sound_added: bool) -> plt.Figure:
+def create_eeg_plot(eeg_data: np.ndarray, target_movement: str, predicted_name: str, confidence: float, sound_added: bool, ch_names=None) -> plt.Figure:
+    '''Create a plot of EEG data with annotations. Plots C3 and C4 channels by name.'''
+    if ch_names is None:
+        ch_names = ['C3', 'C4']
+    # Find indices for C3 and C4
+    idx_c3 = ch_names.index('C3') if 'C3' in ch_names else 0
+    idx_c4 = ch_names.index('C4') if 'C4' in ch_names else 1
     fig, axes = plt.subplots(1, 2, figsize=(10, 4))
     axes = axes.flatten()
     time_points = np.arange(eeg_data.shape[1]) / 200
-    channel_names = ['C3', 'C4']
-    for i in range(min(2, eeg_data.shape[0])):
+    for i, idx in enumerate([idx_c3, idx_c4]):
         color = 'green' if sound_added else 'blue'
-        axes[i].plot(time_points, eeg_data[i], color=color, linewidth=1)
-        axes[i].set_title(f'{channel_names[i] if i < len(channel_names) else f"Channel {i+1}"}')
+        axes[i].plot(time_points, eeg_data[idx], color=color, linewidth=1)
+        axes[i].set_title(f'{ch_names[idx] if idx < len(ch_names) else f"Channel {idx+1}"}')
         axes[i].set_xlabel('Time (s)')
         axes[i].set_ylabel('Amplitude (µV)')
         axes[i].grid(True, alpha=0.3)
@@ -92,6 +136,8 @@ def create_eeg_plot(eeg_data: np.ndarray, target_movement: str, predicted_name:
     return fig
 
 def format_composition_summary(composition_info: Dict) -> str:
+    '''Format the composition summary for display.
+    '''
     if not composition_info.get('layers_by_cycle'):
         return "No composition layers yet"
     summary = []
@@ -141,7 +187,7 @@ def start_composition():
         result = sound_manager.process_classification(predicted_name, confidence, CONFIDENCE_THRESHOLD, force_add=True)
     else:
         result = {'sound_added': False}
-    fig = create_eeg_plot(epoch_data, true_label_name, predicted_name, confidence, result['sound_added'])
+    fig = create_eeg_plot(epoch_data, true_label_name, predicted_name, confidence, result['sound_added'], app_state.get('ch_names'))
     
     # Only play completed movement sounds (layered)
     sounds = get_movement_sounds()
@@ -153,24 +199,17 @@ def start_composition():
     left_leg_audio = sounds.get('left_leg') if 'left_leg' in completed_movements else None
     right_leg_audio = sounds.get('right_leg') if 'right_leg' in completed_movements else None
 
-    print("DEBUG: movement sound paths:", sounds)
-    print("DEBUG: completed movements:", completed_movements)
-    print("DEBUG: left_hand_audio:", left_hand_audio, "exists:", os.path.exists(left_hand_audio) if left_hand_audio else None)
-    print("DEBUG: right_hand_audio:", right_hand_audio, "exists:", os.path.exists(right_hand_audio) if right_hand_audio else None)
-    print("DEBUG: left_leg_audio:", left_leg_audio, "exists:", os.path.exists(left_leg_audio) if left_leg_audio else None)
-    print("DEBUG: right_leg_audio:", right_leg_audio, "exists:", os.path.exists(right_leg_audio) if right_leg_audio else None)
-    
-
-
-
     # 2. Movement Commands: show mapping for all movements
     movement_emojis = {
-        "left_hand": "👈",
-        "right_hand": "👉",
+        "left_hand": "🫲",
+        "right_hand": "🫱",
         "left_leg": "🦵",
         "right_leg": "🦵",
     }
+
     movement_command_lines = []
+    # Show 'Now Playing' for all completed movements (layers that are currently playing)
+    completed_movements = sound_manager.movements_completed
     for movement in ["left_hand", "right_hand", "left_leg", "right_leg"]:
         sound_file = sound_manager.current_sound_mapping.get(movement, "")
         instrument_type = ""
@@ -179,13 +218,21 @@ def start_composition():
                 instrument_type = key if key != "instruments" else "instrument"
                 break
         pretty_movement = movement.replace("_", " ").title()
-        pretty_instrument = instrument_type.capitalize() if instrument_type else "--"
+        # Always use 'Instruments' (plural) for the left hand stem
+        if movement == "left_hand" and instrument_type.lower() == "instrument":
+            pretty_instrument = "Instruments"
+        else:
+            pretty_instrument = instrument_type.capitalize() if instrument_type else "--"
         emoji = movement_emojis.get(movement, "")
-        movement_command_lines.append(f"{emoji} {pretty_movement}: {pretty_instrument}")
-    movement_command_text = "🎼 Composition Mode - Movement to Layers Mapping\n" + "\n".join(movement_command_lines)
+        # Add 'Now Playing' indicator for all completed movements
+        if movement in completed_movements:
+            movement_command_lines.append(f"{emoji} {pretty_movement}: {pretty_instrument}  ▶️ Now Playing")
+        else:
+            movement_command_lines.append(f"{emoji} {pretty_movement}: {pretty_instrument}")
+    movement_command_text = "🎼 Composition Mode - Movement to Stems Mapping\n" + "\n".join(movement_command_lines)
 
-    # 3. Next Trial: will be set dynamically in timer_tick
-    next_trial_text = ""
+    # 3. Next Trial: always prompt user
+    next_trial_text = "Imagine next movement"
 
     composition_info = sound_manager.get_composition_info()
     status_text = format_composition_summary(composition_info)
@@ -201,29 +248,75 @@ def start_composition():
     )
 
 def continue_dj_phase():
+    ''' Continue in DJ phase, applying effects and always playing all layered sounds.
+    '''
     global app_state
     print(f"DEBUG: [continue_dj_phase] Entered DJ mode. current_phase={sound_manager.current_phase}")
     if not app_state['composition_active']:
         return "❌ Not active", "❌ Not active", "❌ Not active", None, None, None, None, None, None, "Click 'Start Composing' first"
     if app_state['demo_data'] is None:
         return "❌ No data", "❌ No data", "❌ No data", None, None, None, None, None, None, "No EEG data available"
-    # DJ phase: classify and apply effects, but always play all layered sounds
+    # DJ phase: enforce strict DJ effect order
     epoch_data, true_label = data_processor.simulate_real_time_data(app_state['demo_data'], app_state['demo_labels'], mode="class_balanced")
     predicted_class, confidence, probabilities = classifier.predict(epoch_data)
     predicted_name = classifier.class_names[predicted_class]
-    # Toggle effect if confidence is high
-    if confidence > CONFIDENCE_THRESHOLD:
-        print(f"DEBUG: [continue_dj_phase] Toggling DJ effect for movement: {predicted_name}")
-        sound_manager.toggle_dj_effect(predicted_name, brief=True, duration=1.0)
-    true_label_name = classifier.class_names[true_label]
-    # Only turn plot green if effect is actually toggled (applied)
+    # Strict DJ order: right_hand, right_leg, left_leg, left_hand
+    if not hasattr(continue_dj_phase, 'dj_order'):
+        continue_dj_phase.dj_order = ["right_hand", "right_leg", "left_leg", "left_hand"]
+        continue_dj_phase.dj_index = 0
+    # Find the next movement in the DJ order that hasn't been toggled yet (using effect counters)
+    while continue_dj_phase.dj_index < 4:
+        next_movement = continue_dj_phase.dj_order[continue_dj_phase.dj_index]
+        # Only proceed if the predicted movement matches the next in order
+        if predicted_name == next_movement:
+            break
+        else:
+            # Ignore this prediction, do not apply effect
+            next_trial_text = "Imagine next movement"
+            # UI update: show which movement is expected
+            # Always play all completed movement sounds (layered)
+            sounds = get_movement_sounds()
+            completed_movements = sound_manager.movements_completed
+            left_hand_audio = sounds.get('left_hand') if 'left_hand' in completed_movements else None
+            right_hand_audio = sounds.get('right_hand') if 'right_hand' in completed_movements else None
+            left_leg_audio = sounds.get('left_leg') if 'left_leg' in completed_movements else None
+            right_leg_audio = sounds.get('right_leg') if 'right_leg' in completed_movements else None
+            movement_map = {
+                "left_hand": {"effect": "Fade In/Out", "instrument": "Instruments"},
+                "right_hand": {"effect": "Low Pass", "instrument": "Bass"},
+                "left_leg": {"effect": "Compressor", "instrument": "Drums"},
+                "right_leg": {"effect": "Echo", "instrument": "Vocals"},
+            }
+            emoji_map = {"left_hand": "🫲", "right_hand": "🫱", "left_leg": "🦵", "right_leg": "🦵"}
+            movement_command_lines = []
+            for m in ["left_hand", "right_hand", "left_leg", "right_leg"]:
+                status = "ON" if sound_manager.active_effects.get(m, False) else "off"
+                movement_command_lines.append(f"{emoji_map[m]} {m.replace('_', ' ').title()}: {movement_map[m]['effect']} [{'ON' if status == 'ON' else 'off'}] → {movement_map[m]['instrument']}")
+            target_text = "🎧 DJ Mode - Movement to Effect Mapping\n" + "\n".join(movement_command_lines)
+            composition_info = sound_manager.get_composition_info()
+            status_text = format_composition_summary(composition_info)
+            fig = create_eeg_plot(epoch_data, classifier.class_names[true_label], predicted_name, confidence, False, app_state.get('ch_names'))
+            return (
+                target_text,            # Movement Commands (textbox)
+                next_trial_text,         # Next Trial (textbox)
+                fig,                    # EEG Plot (plot)
+                left_hand_audio,        # Left Hand (audio)
+                right_hand_audio,       # Right Hand (audio)
+                left_leg_audio,         # Left Leg (audio)
+                right_leg_audio,        # Right Leg (audio)
+                status_text,            # Composition Status (textbox)
+                gr.update(),            # Timer (update object)
+                gr.update()             # Continue DJ Button (update object)
+            )
+    # If correct movement, apply effect and advance order
     effect_applied = False
-    if confidence > CONFIDENCE_THRESHOLD:
+    if confidence > CONFIDENCE_THRESHOLD and predicted_name == continue_dj_phase.dj_order[continue_dj_phase.dj_index]:
         result = sound_manager.toggle_dj_effect(predicted_name, brief=True, duration=1.0)
         effect_applied = result.get("effect_applied", False)
+        continue_dj_phase.dj_index += 1
     else:
         result = None
-    fig = create_eeg_plot(epoch_data, true_label_name, predicted_name, confidence, effect_applied)
+    fig = create_eeg_plot(epoch_data, classifier.class_names[true_label], predicted_name, confidence, effect_applied, app_state.get('ch_names'))
     # Always play all completed movement sounds (layered)
     sounds = get_movement_sounds()
     completed_movements = sound_manager.movements_completed
@@ -233,17 +326,18 @@ def continue_dj_phase():
     right_leg_audio = sounds.get('right_leg') if 'right_leg' in completed_movements else None
     # Show DJ effect mapping for each movement with ON/OFF status and correct instrument mapping
     movement_map = {
-        "left_hand": {"effect": "Echo", "instrument": "Instrument"},
+        "left_hand": {"effect": "Fade In/Out", "instrument": "Instruments"},
         "right_hand": {"effect": "Low Pass", "instrument": "Bass"},
         "left_leg": {"effect": "Compressor", "instrument": "Drums"},
-        "right_leg": {"effect": "High Pass", "instrument": "Vocals"},
+        "right_leg": {"effect": "Echo", "instrument": "Vocals"},
     }
-    emoji_map = {"left_hand": "👈", "right_hand": "👉", "left_leg": "🦵", "right_leg": "🦵"}
+    emoji_map = {"left_hand": "🫲", "right_hand": "🫱", "left_leg": "🦵", "right_leg": "🦵"}
     # Get effect ON/OFF status from sound_manager.active_effects
     movement_command_lines = []
     for m in ["left_hand", "right_hand", "left_leg", "right_leg"]:
+        # Show [ON] only if effect is currently active (True), otherwise [off]
         status = "ON" if sound_manager.active_effects.get(m, False) else "off"
-        movement_command_lines.append(f"{emoji_map[m]} {m.replace('_', ' ').title()}: {movement_map[m]['effect']} [{status}] → {movement_map[m]['instrument']}")
+        movement_command_lines.append(f"{emoji_map[m]} {m.replace('_', ' ').title()}: {movement_map[m]['effect']} [{'ON' if status == 'ON' else 'off'}] → {movement_map[m]['instrument']}")
     target_text = "🎧 DJ Mode - Movement to Effect Mapping\n" + "\n".join(movement_command_lines)
     # In DJ mode, Next Trial should only show the prompt, not the predicted/target movement
     predicted_text = "Imagine next movement"
@@ -266,23 +360,22 @@ def continue_dj_phase():
 
 # --- Gradio UI ---
 def create_interface():
+    ''' Create the Gradio interface.
+    '''
     with gr.Blocks(title="EEG Motor Imagery Music Composer", theme=gr.themes.Citrus()) as demo:
         with gr.Tabs():
-            with gr.TabItem("Automatic Music Composition"):
-                gr.Markdown("# 🧠🎵 EEG Motor Imagery Rehabilitation Composer")
-                #gr.Markdown("**Therapeutic Brain-Computer Interface for Motor Recovery**\n\nCreate beautiful music compositions using your brain signals! This rehabilitation tool helps strengthen motor imagery skills while creating personalized musical pieces.")
+            with gr.TabItem("🎵 Automatic Music Composer"):
+                gr.Markdown("# 🧠 NeuroMusic Studio: An accessible, easy to use motor rehabilitation device.")
                 gr.Markdown("""
-                **How the Task Works**
-
-                This app has **two stages**:
+                **How it works:**
 
-                1. **Music Composition Stage**: Use your motor imagery (imagine moving your left hand, right hand, left leg, or right leg) to add musical layers. Each correct, high-confidence brain signal prediction adds a new sound to your composition. The system will prompt you with a movement to imagine, and you should focus on that movement until the next prompt.
+                1. **Compose:** Imagine moving your left hand, right hand, left leg, or right leg to add musical layers. Each correct, high-confidence prediction adds a sound. Just follow the prompts.
 
-                2. **DJ Effects Stage**: After all four movements are completed, you enter DJ mode. Here, you can apply effects and control playback of your own composition using new commands. The interface and available controls will change to let you experiment with your music.
+                2. **DJ Mode:** After all four layers are added, you can apply effects and remix your composition using new brain commands.
 
-                > **Note:** In DJ mode, each effect is only triggered every 4th time you perform the same movement. This prevents tracks from reloading too frequently.
+                > **Tip:** In DJ mode, each effect is triggered only every 4th time you repeat a movement, to keep playback smooth.
 
-                **Commands and controls will change between stages.** Follow the on-screen instructions for each phase.
+                Commands and controls update as you progress. Just follow the on-screen instructions!
                 """)
                 
                 with gr.Row():
@@ -295,13 +388,14 @@ def create_interface():
                         timer_display = gr.Textbox(label="⏱️ Next Trial", interactive=False, value="--")
                         eeg_plot = gr.Plot(label="EEG Data Visualization")
                     with gr.Column(scale=1):
-                        left_hand_sound = gr.Audio(label="👈 Left Hand", interactive=False, autoplay=True, visible=True)
-                        right_hand_sound = gr.Audio(label="👉 Right Hand", interactive=False, autoplay=True, visible=True)
+                        left_hand_sound = gr.Audio(label="🫲 Left Hand", interactive=False, autoplay=True, visible=True)
+                        right_hand_sound = gr.Audio(label="🫱 Right Hand", interactive=False, autoplay=True, visible=True)
                         left_leg_sound = gr.Audio(label="🦵 Left Leg", interactive=False, autoplay=True, visible=True)
                         right_leg_sound = gr.Audio(label="🦵 Right Leg", interactive=False, autoplay=True, visible=True)
                         composition_status = gr.Textbox(label="Composition Status", interactive=False, lines=5)
-
                 def start_and_activate_timer():
+                    ''' Start composing and activate timer for trials.
+                    '''
                     result = start_composition()
                     last_trial_result[:] = result  # Initialize with first trial result
                     if "DJ Mode" not in result[0]:
@@ -313,6 +407,8 @@ def create_interface():
                 timer_counter = {"count": 0}
                 last_trial_result = [None] * 9  # Adjust length to match your outputs
                 def timer_tick():
+                    ''' Timer tick handler for ITI and trials.
+                    '''
                     # 0,1,2: blank, 3: prompt, 4: trial
                     if timer_counter["count"] < 3:
                         timer_counter["count"] += 1
@@ -357,6 +453,8 @@ def create_interface():
                             raise ValueError(f"Unexpected result length in timer_tick: {len(result)}")
                 
                 def continue_dj():
+                    ''' Continue DJ phase from button click.
+                    '''
                     result = continue_dj_phase()
                     if len(result) == 8:
                         return (*result, gr.update(active=False), gr.update(visible=True))
@@ -375,10 +473,28 @@ def create_interface():
                             left_hand_sound, right_hand_sound, left_leg_sound, right_leg_sound, composition_status, timer, continue_btn]
                 )
                 def stop_composing():
+                    ''' Stop composing and reset state (works in both building and DJ mode). '''
                     timer_counter["count"] = 0
-                    last_trial_result[:] = ["--"] * 9
                     app_state['composition_active'] = False  # Ensure new cycle on next start
-                    # Clear UI and deactivate timer, hide continue button
+                    # Reset sound_manager state for new session
+                    sound_manager.current_phase = "building"
+                    sound_manager.composition_layers = {}
+                    sound_manager.movements_completed = set()
+                    sound_manager.active_effects = {m: False for m in ["left_hand", "right_hand", "left_leg", "right_leg"]}
+                    # Clear static audio cache in get_movement_sounds
+                    if hasattr(get_movement_sounds, 'audio_cache'):
+                        for m in get_movement_sounds.audio_cache:
+                            get_movement_sounds.audio_cache[m][True] = None
+                            get_movement_sounds.audio_cache[m][False] = None
+                    if hasattr(get_movement_sounds, 'last_effect_state'):
+                        for m in get_movement_sounds.last_effect_state:
+                            get_movement_sounds.last_effect_state[m] = None
+                    if hasattr(get_movement_sounds, 'play_counter'):
+                        for m in get_movement_sounds.play_counter:
+                            get_movement_sounds.play_counter[m] = 0
+                        get_movement_sounds.total_calls = 0
+                    # Clear UI and deactivate timer, hide continue button, clear all audio
+                    last_trial_result[:] = ["--", "Stopped", None, None, None, None, None, "Stopped"]
                     return ("--", "Stopped", None, None, None, None, None, "Stopped", gr.update(active=False), gr.update(visible=False))
 
                 stop_btn.click(
@@ -393,8 +509,8 @@ def create_interface():
                             left_hand_sound, right_hand_sound, left_leg_sound, right_leg_sound, composition_status, timer, continue_btn]
                 )
 
-            with gr.TabItem("Manual Classifier"):
-                gr.Markdown("# 🧑‍💻 Manual Classifier Test")
+            with gr.TabItem("📝 Manual Classifier"):
+                gr.Markdown("# Manual Classifier")
                 gr.Markdown("Select a movement and run the classifier manually on a random epoch for that movement. Results will be accumulated below.")
                 movement_dropdown = gr.Dropdown(choices=["left_hand", "right_hand", "left_leg", "right_leg"], label="Select Movement")
                 manual_btn = gr.Button("Run Classifier", variant="primary")
@@ -409,6 +525,8 @@ def create_interface():
                 session_confmat = defaultdict(lambda: defaultdict(int))
 
                 def manual_classify(selected_movement):
+                    ''' Manually classify a random epoch for the selected movement.
+                    '''
                     import matplotlib.pyplot as plt
                     import numpy as np
                     if app_state['demo_data'] is None or app_state['demo_labels'] is None:
@@ -452,7 +570,7 @@ def create_interface():
                     ax_probs.set_ylim(0, 1)
                     fig_probs.tight_layout()
                     # EEG plot
-                    fig = create_eeg_plot(epoch_data, selected_movement, predicted_name, confidence, False)
+                    fig = create_eeg_plot(epoch_data, selected_movement, predicted_name, confidence, False, app_state.get('ch_names'))
                     # Close all open figures to avoid warnings
                     plt.close(fig_confmat)
                     plt.close(fig_probs)

classifier.py

@@ -10,9 +10,8 @@ import torch.nn as nn
 import numpy as np
 from braindecode.models.shallow_fbcsp import ShallowFBCSPNet
 from braindecode.modules.layers import Ensure4d  # necessary for loading
-from typing import Dict, Tuple, Optional
+from typing import Dict, Tuple
 import os
-from sklearn.metrics import accuracy_score
 from data_processor import EEGDataProcessor
 from config import DEMO_DATA_PATHS
 
@@ -36,7 +35,9 @@ class MotorImageryClassifier:
         self.is_loaded = False
         
     def load_model(self, n_chans: int, n_times: int, n_outputs: int = 6):
-        """Load the pre-trained ShallowFBCSPNet model."""
+        """Load the pre-trained ShallowFBCSPNet model.
+        If model file not found or incompatible, fallback to LOSO training.
+        """
         try:
             self.model = ShallowFBCSPNet(
                 n_chans=n_chans,

config.py

@@ -5,59 +5,17 @@ Configuration settings for the EEG Motor Imagery Music Composer
 import os
 from pathlib import Path
 
-# Application settings
-APP_NAME = "EEG Motor Imagery Music Composer"
-VERSION = "1.0.0"
-
 # Data paths
 BASE_DIR = Path(__file__).parent
 DATA_DIR = BASE_DIR / "data"
 SOUND_DIR = BASE_DIR / "sounds"
 MODEL_DIR = BASE_DIR
 
-# Model settings
-MODEL_PATH = MODEL_DIR / "model.pth"
-# Model architecture: Always uses ShallowFBCSPNet from braindecode
-# If pre-trained weights not found, will train using LOSO on available data
-
-# EEG Data settings
-SAMPLING_RATE = 200  # Hz
-EPOCH_DURATION = 1.5  # seconds
-N_CHANNELS = 19 # without ground and reference 19 electrodes
-N_CLASSES = 6 # or 4
 
 # Classification settings
-CONFIDENCE_THRESHOLD = 0.3  # Minimum confidence to add sound layer (lowered for testing)
-MAX_COMPOSITION_LAYERS = 6  # Maximum layers in composition
-
-# Sound settings
-SOUND_MAPPING = {
-    "left_hand": "1_SoundHelix-Song-6_(Bass).wav",
-    "right_hand": "1_SoundHelix-Song-6_(Drums).wav", 
-    "neutral": None,  # No sound for neutral/rest state
-    "left_leg": "1_SoundHelix-Song-6_(Other).wav",
-    "tongue": "1_SoundHelix-Song-6_(Vocals).wav",
-    "right_leg": "1_SoundHelix-Song-6_(Bass).wav"  # Can be remapped by user
-}
-
-# Motor imagery class names
-CLASS_NAMES = {
-    0: "left_hand",
-    1: "right_hand", 
-    2: "neutral",
-    3: "left_leg",
-    4: "tongue",
-    5: "right_leg"
-}
+CONFIDENCE_THRESHOLD = 0.7  # Minimum confidence to add sound layer (lowered for testing)
+MAX_COMPOSITION_LAYERS = 4  # Maximum layers in composition
 
-CLASS_DESCRIPTIONS = {
-    "left_hand": "🤚 Left Hand Movement",
-    "right_hand": "🤚 Right Hand Movement", 
-    "neutral": "😐 Neutral/Rest State",
-    "left_leg": "🦵 Left Leg Movement",
-    "tongue": "👅 Tongue Movement",
-    "right_leg": "🦵 Right Leg Movement"
-}
 
 # Demo data paths (optional) - updated with available files
 DEMO_DATA_PATHS = [
@@ -65,29 +23,3 @@ DEMO_DATA_PATHS = [
     "data/HaLTSubjectA1603086StLRHandLegTongue.mat",
     "data/HaLTSubjectA1603106StLRHandLegTongue.mat",
 ]
-
-# Gradio settings
-GRADIO_PORT = 7860
-GRADIO_HOST = "0.0.0.0"
-GRADIO_SHARE = False  # Set to True to create public links
-
-# Logging settings
-LOG_LEVEL = "INFO"
-LOG_FILE = BASE_DIR / "logs" / "app.log"
-
-# Create necessary directories
-def create_directories():
-    """Create necessary directories if they don't exist."""
-    directories = [
-        DATA_DIR,
-        SOUND_DIR,
-        MODEL_DIR,
-        LOG_FILE.parent
-    ]
-    
-    for directory in directories:
-        directory.mkdir(parents=True, exist_ok=True)
-        
-if __name__ == "__main__":
-    create_directories()
-    print("Configuration directories created successfully!")

data_processor.py

@@ -8,11 +8,8 @@ Adapted from the original eeg_motor_imagery.py script.
 import scipy.io
 import numpy as np
 import mne
-import torch
 import pandas as pd
-from typing import List, Tuple, Dict, Optional
-from pathlib import Path
-from scipy.signal import butter, lfilter
+from typing import List, Tuple
 
 class EEGDataProcessor:
     """
@@ -96,7 +93,7 @@ class EEGDataProcessor:
         )
         return epochs
     
-    def process_files(self, file_paths: List[str]) -> Tuple[np.ndarray, np.ndarray]:
+    def process_files(self, file_paths: List[str]) -> Tuple[np.ndarray, np.ndarray, List[str]]:
         """Process multiple EEG files and return combined data."""
         all_epochs = []
         allowed_labels = {1, 2, 4, 6}
@@ -110,18 +107,18 @@ class EEGDataProcessor:
             events = events[np.isin(events[:, -1], list(allowed_labels))]
             # create epochs only for allowed labels
             epochs = self.create_epochs(raw, events, event_id=allowed_event_id)
-            all_epochs.append(epochs)
+            all_epochs.append((epochs, channels))
         
         if len(all_epochs) > 1:
-            epochs_combined = mne.concatenate_epochs(all_epochs)
+            epochs_combined = mne.concatenate_epochs([ep for ep, _ in all_epochs])
+            ch_names = all_epochs[0][1]  # Assume same channel order for all files
         else:
-            epochs_combined = all_epochs[0]
-        
+            epochs_combined = all_epochs[0][0]
+            ch_names = all_epochs[0][1]
         # Convert to arrays for model input
         X = epochs_combined.get_data().astype("float32")
         y = (epochs_combined.events[:, -1] - 1).astype("int64")  # classes 0..5
-        
-        return X, y
+        return X, y, ch_names
     
     def load_continuous_data(self, file_paths: List[str]) -> Tuple[np.ndarray, int]:
         """
@@ -232,31 +229,4 @@ class EEGDataProcessor:
             
         return X[idx], y[idx]
     
-    # def simulate_continuous_stream(self, raw_data: np.ndarray, fs: int, window_size: float = 1.5) -> np.ndarray:
-    #     """
-    #     Simulate continuous EEG stream by extracting sliding windows from raw data.
-        
-    #     Args:
-    #         raw_data: Continuous EEG data [n_channels, n_timepoints]
-    #         fs: Sampling frequency
-    #         window_size: Window size in seconds
-            
-    #     Returns:
-    #         Single window of EEG data [n_channels, window_samples]
-    #     """
-    #     window_samples = int(window_size * fs)  # e.g., 1.5s * 200Hz = 300 samples
-        
-    #     # Ensure we don't go beyond the data
-    #     max_start = raw_data.shape[1] - window_samples
-    #     if max_start <= 0:
-    #         return raw_data  # Return full data if too short
-        
-    #     # Random starting point in the continuous stream
-    #     start_idx = np.random.randint(0, max_start)
-    #     end_idx = start_idx + window_samples
-        
-    #     # Extract window
-    #     window = raw_data[:, start_idx:end_idx]
-        
-    #     return window
 

demo.py

@@ -1,96 +0,0 @@
-#!/usr/bin/env python3
-"""
-Demo script for the EEG Motor Imagery Music Composer
-"""
-
-import sys
-import os
-from pathlib import Path
-
-# Add the current directory to Python path
-current_dir = Path(__file__).parent
-sys.path.insert(0, str(current_dir))
-
-from data_processor import EEGDataProcessor
-from classifier import MotorImageryClassifier
-from sound_library import SoundManager
-from utils import setup_logging, create_classification_summary
-import numpy as np
-
-def run_demo():
-    """Run a simple demo of the system components."""
-    print("🧠 EEG Motor Imagery Music Composer - Demo")
-    print("=" * 50)
-    
-    # Initialize components
-    print("Initializing components...")
-    data_processor = EEGDataProcessor()
-    classifier = MotorImageryClassifier()
-    sound_manager = SoundManager()
-    
-    # Create mock data for demo
-    print("Creating mock EEG data...")
-    mock_data = np.random.randn(10, 32, 384).astype(np.float32)  # 10 samples, 32 channels, 384 time points
-    mock_labels = np.random.randint(0, 6, 10)
-    
-    # Initialize classifier
-    print("Loading classifier...")
-    classifier.load_model(n_chans=32, n_times=384)
-    
-    print(f"Available sounds: {sound_manager.get_available_sounds()}")
-    print()
-    
-    # Run classification demo
-    print("Running classification demo...")
-    print("-" * 30)
-    
-    for i in range(5):
-        # Get random sample
-        sample_idx = np.random.randint(0, len(mock_data))
-        eeg_sample = mock_data[sample_idx]
-        true_label = mock_labels[sample_idx]
-        
-        # Classify
-        predicted_class, confidence, probabilities = classifier.predict(eeg_sample)
-        predicted_name = classifier.class_names[predicted_class]
-        true_name = classifier.class_names[true_label]
-        
-        # Create summary
-        summary = create_classification_summary(predicted_name, confidence, probabilities)
-        
-        print(f"Sample {i+1}:")
-        print(f"  True class: {true_name}")
-        print(f"  Predicted: {summary['emoji']} {predicted_name} ({summary['confidence_percent']})")
-        
-        # Add to composition if confidence is high
-        if confidence > 0.7 and predicted_name != 'neutral':
-            sound_manager.add_layer(predicted_name, confidence)
-            print(f"  ♪ Added to composition: {predicted_name}")
-        else:
-            print(f"  - Not added (low confidence or neutral)")
-        
-        print()
-    
-    # Show composition summary
-    composition_info = sound_manager.get_composition_info()
-    print("Final Composition:")
-    print("-" * 20)
-    if composition_info:
-        for i, layer in enumerate(composition_info, 1):
-            print(f"{i}. {layer['class']} (confidence: {layer['confidence']:.2f})")
-    else:
-        print("No composition layers created")
-    
-    print()
-    print("Demo completed! 🎵")
-    print("To run the full Gradio interface, execute: python app.py")
-
-if __name__ == "__main__":
-    try:
-        run_demo()
-    except KeyboardInterrupt:
-        print("\nDemo interrupted by user")
-    except Exception as e:
-        print(f"Error running demo: {e}")
-        import traceback
-        traceback.print_exc()

enhanced_utils.py

@@ -1,236 +0,0 @@
-"""
-Enhanced utilities incorporating useful functions from the original src/ templates
-"""
-
-import torch
-import numpy as np
-import matplotlib.pyplot as plt
-import seaborn as sns
-from sklearn.metrics import confusion_matrix, classification_report, accuracy_score
-from typing import Dict, List, Tuple, Optional
-import logging
-
-def evaluate_model_performance(model, dataloader, device, class_names: List[str]) -> Dict:
-    """
-    Comprehensive model evaluation with metrics and visualizations.
-    Enhanced version of src/evaluate.py
-    """
-    model.eval()
-    all_preds = []
-    all_labels = []
-    all_probs = []
-
-    with torch.no_grad():
-        for inputs, labels in dataloader:
-            inputs = inputs.to(device)
-            labels = labels.to(device)
-
-            outputs = model(inputs)
-            probs = torch.softmax(outputs, dim=1)
-            _, preds = torch.max(outputs, 1)
-            
-            all_preds.extend(preds.cpu().numpy())
-            all_labels.extend(labels.cpu().numpy())
-            all_probs.extend(probs.cpu().numpy())
-
-    # Calculate metrics
-    accuracy = accuracy_score(all_labels, all_preds)
-    cm = confusion_matrix(all_labels, all_preds)
-    report = classification_report(all_labels, all_preds, target_names=class_names, output_dict=True)
-    
-    return {
-        'accuracy': accuracy,
-        'predictions': all_preds,
-        'labels': all_labels,
-        'probabilities': all_probs,
-        'confusion_matrix': cm,
-        'classification_report': report
-    }
-
-def plot_confusion_matrix(cm: np.ndarray, class_names: List[str], title: str = "Confusion Matrix") -> plt.Figure:
-    """
-    Plot confusion matrix with proper formatting.
-    Enhanced version from src/visualize.py
-    """
-    fig, ax = plt.subplots(figsize=(8, 6))
-    
-    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
-                xticklabels=class_names, yticklabels=class_names, ax=ax)
-    
-    ax.set_title(title)
-    ax.set_ylabel('True Label')
-    ax.set_xlabel('Predicted Label')
-    
-    plt.tight_layout()
-    return fig
-
-def plot_classification_probabilities(probabilities: np.ndarray, class_names: List[str], 
-                                    sample_indices: Optional[List[int]] = None) -> plt.Figure:
-    """
-    Plot classification probabilities for selected samples.
-    """
-    if sample_indices is None:
-        sample_indices = list(range(min(10, len(probabilities))))
-    
-    fig, ax = plt.subplots(figsize=(12, 6))
-    
-    x = np.arange(len(class_names))
-    width = 0.8 / len(sample_indices)
-    
-    for i, sample_idx in enumerate(sample_indices):
-        offset = (i - len(sample_indices)/2) * width
-        ax.bar(x + offset, probabilities[sample_idx], width, 
-               label=f'Sample {sample_idx}', alpha=0.8)
-    
-    ax.set_xlabel('Motor Imagery Classes')
-    ax.set_ylabel('Probability')
-    ax.set_title('Classification Probabilities')
-    ax.set_xticks(x)
-    ax.set_xticklabels(class_names, rotation=45)
-    ax.legend()
-    ax.grid(True, alpha=0.3)
-    
-    plt.tight_layout()
-    return fig
-
-def plot_training_history(history: Dict[str, List[float]]) -> plt.Figure:
-    """
-    Plot training history (loss and accuracy).
-    Enhanced version from src/visualize.py
-    """
-    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))
-    
-    # Plot accuracy
-    if 'train_accuracy' in history and 'val_accuracy' in history:
-        ax1.plot(history['train_accuracy'], label='Train', linewidth=2)
-        ax1.plot(history['val_accuracy'], label='Validation', linewidth=2)
-        ax1.set_title('Model Accuracy')
-        ax1.set_xlabel('Epoch')
-        ax1.set_ylabel('Accuracy')
-        ax1.legend()
-        ax1.grid(True, alpha=0.3)
-    
-    # Plot loss
-    if 'train_loss' in history and 'val_loss' in history:
-        ax2.plot(history['train_loss'], label='Train', linewidth=2)
-        ax2.plot(history['val_loss'], label='Validation', linewidth=2)
-        ax2.set_title('Model Loss')
-        ax2.set_xlabel('Epoch')
-        ax2.set_ylabel('Loss')
-        ax2.legend()
-        ax2.grid(True, alpha=0.3)
-    
-    plt.tight_layout()
-    return fig
-
-def plot_eeg_channels(eeg_data: np.ndarray, channel_names: Optional[List[str]] = None, 
-                     sample_rate: int = 256, title: str = "EEG Channels") -> plt.Figure:
-    """
-    Plot multiple EEG channels.
-    Enhanced visualization for EEG data.
-    """
-    n_channels, n_samples = eeg_data.shape
-    time_axis = np.arange(n_samples) / sample_rate
-    
-    # Determine subplot layout
-    n_rows = int(np.ceil(np.sqrt(n_channels)))
-    n_cols = int(np.ceil(n_channels / n_rows))
-    
-    fig, axes = plt.subplots(n_rows, n_cols, figsize=(15, 10))
-    if n_channels == 1:
-        axes = [axes]
-    else:
-        axes = axes.flatten()
-    
-    for i in range(n_channels):
-        ax = axes[i]
-        ax.plot(time_axis, eeg_data[i], 'b-', linewidth=1)
-        
-        channel_name = channel_names[i] if channel_names else f'Channel {i+1}'
-        ax.set_title(channel_name)
-        ax.set_xlabel('Time (s)')
-        ax.set_ylabel('Amplitude')
-        ax.grid(True, alpha=0.3)
-    
-    # Hide unused subplots
-    for i in range(n_channels, len(axes)):
-        axes[i].set_visible(False)
-    
-    plt.suptitle(title)
-    plt.tight_layout()
-    return fig
-
-class EarlyStopping:
-    """
-    Early stopping utility from src/types/index.py
-    """
-    def __init__(self, patience=7, min_delta=0, restore_best_weights=True, verbose=False):
-        self.patience = patience
-        self.min_delta = min_delta
-        self.restore_best_weights = restore_best_weights
-        self.verbose = verbose
-        self.best_loss = None
-        self.counter = 0
-        self.best_weights = None
-
-    def __call__(self, val_loss, model):
-        if self.best_loss is None:
-            self.best_loss = val_loss
-            self.save_checkpoint(model)
-        elif val_loss < self.best_loss - self.min_delta:
-            self.best_loss = val_loss
-            self.counter = 0
-            self.save_checkpoint(model)
-        else:
-            self.counter += 1
-
-        if self.counter >= self.patience:
-            if self.verbose:
-                print(f'Early stopping triggered after {self.counter} epochs of no improvement')
-            if self.restore_best_weights:
-                model.load_state_dict(self.best_weights)
-            return True
-        return False
-
-    def save_checkpoint(self, model):
-        """Save model when validation loss decreases."""
-        if self.restore_best_weights:
-            self.best_weights = model.state_dict().copy()
-
-def create_enhanced_evaluation_report(model, test_loader, class_names: List[str], 
-                                    device, save_plots: bool = True) -> Dict:
-    """
-    Create a comprehensive evaluation report with plots and metrics.
-    """
-    # Get evaluation results
-    results = evaluate_model_performance(model, test_loader, device, class_names)
-    
-    # Create visualizations
-    plots = {}
-    
-    # Confusion Matrix
-    plots['confusion_matrix'] = plot_confusion_matrix(
-        results['confusion_matrix'], class_names, 
-        title="Motor Imagery Classification - Confusion Matrix"
-    )
-    
-    # Classification Probabilities (sample)
-    plots['probabilities'] = plot_classification_probabilities(
-        np.array(results['probabilities']), class_names, 
-        sample_indices=list(range(min(5, len(results['probabilities']))))
-    )
-    
-    if save_plots:
-        for plot_name, fig in plots.items():
-            fig.savefig(f'{plot_name}.png', dpi=300, bbox_inches='tight')
-    
-    return {
-        'metrics': results,
-        'plots': plots,
-        'summary': {
-            'accuracy': results['accuracy'],
-            'n_samples': len(results['labels']),
-            'n_classes': len(class_names),
-            'class_names': class_names
-        }
-    }

requirements.txt

@@ -1,14 +1,11 @@
-gradio
-pandas
-numpy
-scipy
-matplotlib
-torch
-torchvision
-mne
-braindecode
-scikit-learn
-pydub
-soundfile
-librosa
-threading
+gradio==5.47.0
+numpy==2.3.3
+pandas==2.3.2
+matplotlib==3.10.6
+mne==1.10.1
+soundfile==0.13.1
+scipy==1.16.2
+torch==2.8.0
+torchaudio==2.8.0
+braindecode==1.2.0
+scikit-learn==1.7.2

sound_manager.py

@@ -7,12 +7,21 @@ Supports seamless transition from building (layering) to DJ (effects) phase.
 
 import numpy as np
 import soundfile as sf
-import os
-from typing import Dict, Optional, List
+from typing import Dict
 from pathlib import Path
 
 class AudioEffectsProcessor:
     @staticmethod
+    def apply_fade_in_out(data: np.ndarray, samplerate: int, fade_duration: float = 0.5) -> np.ndarray:
+        fade_samples = int(fade_duration * samplerate)
+        data = np.copy(data)
+        if fade_samples > 0 and fade_samples * 2 < len(data):
+            fade_in_curve = np.linspace(0, 1, fade_samples)
+            fade_out_curve = np.linspace(1, 0, fade_samples)
+            data[:fade_samples] = data[:fade_samples] * fade_in_curve
+            data[-fade_samples:] = data[-fade_samples:] * fade_out_curve
+        return data
+    @staticmethod
     def apply_high_pass_filter(data: np.ndarray, samplerate: int, cutoff: float = 800.0) -> np.ndarray:
         from scipy import signal
         nyquist = samplerate / 2
@@ -60,23 +69,26 @@ class AudioEffectsProcessor:
     def process_layer_with_effects(audio_data: np.ndarray, samplerate: int, movement: str, active_effects: Dict[str, bool]) -> np.ndarray:
         processed_data = np.copy(audio_data)
         effect_map = {
-            "left_hand": AudioEffectsProcessor.apply_echo,           # Echo
+            "left_hand": AudioEffectsProcessor.apply_fade_in_out,      # Fade in/out
             "right_hand": AudioEffectsProcessor.apply_low_pass_filter, # Low Pass
-            "left_leg": AudioEffectsProcessor.apply_compressor,     # Compressor
-            "right_leg": AudioEffectsProcessor.apply_high_pass_filter, # High Pass
+            "left_leg": AudioEffectsProcessor.apply_compressor,        # Compressor
+            "right_leg": AudioEffectsProcessor.apply_echo,             # Echo (vocals)
         }
         effect_func = effect_map.get(movement)
         if active_effects.get(movement, False) and effect_func:
-            processed_data = effect_func(processed_data, samplerate)
+            if movement == "left_hand":
+                processed_data = effect_func(processed_data, samplerate, fade_duration=0.5)
+            else:
+                processed_data = effect_func(processed_data, samplerate)
         return processed_data
 
 class SoundManager:
     def __init__(self, sound_dir: str = "sounds"):
         self.available_sounds = [
-            "SoundHelix-Song-4_bass.wav",
-            "SoundHelix-Song-4_drums.wav",
-            "SoundHelix-Song-4_instruments.wav",
-            "SoundHelix-Song-4_vocals.wav"
+            "SoundHelix-Song-6_bass.wav",
+            "SoundHelix-Song-6_drums.wav",
+            "SoundHelix-Song-6_instruments.wav",
+            "SoundHelix-Song-6_vocals.wav"
         ]
         self.sound_dir = Path(sound_dir)
         self.current_cycle = 0
@@ -125,12 +137,17 @@ class SoundManager:
         self._load_sound_files()
 
     def get_current_target_movement(self) -> str:
-        # Randomly select a movement from those not yet completed
-        import random
+        # Always process left_hand last in DJ mode
         incomplete = [m for m in self.active_movements if m not in self.movements_completed]
         if not incomplete:
             print("DEBUG: All movements completed, cycle complete.")
             return "cycle_complete"
+        # If in DJ mode, left_hand should be last
+        if getattr(self, 'current_phase', None) == 'dj_effects':
+            # Remove left_hand from incomplete unless it's the only one left
+            if 'left_hand' in incomplete and len(incomplete) > 1:
+                incomplete = [m for m in incomplete if m != 'left_hand']
+        import random
         movement = random.choice(incomplete)
         print(f"DEBUG: Next target is {movement}, completed: {self.movements_completed}")
         return movement
@@ -198,15 +215,16 @@ class SoundManager:
             return {"effect_applied": False, "message": "Not in DJ effects phase"}
         if movement not in self.active_effects:
             return {"effect_applied": False, "message": f"Unknown movement: {movement}"}
-        # Only toggle effect every 4th time this movement is detected
+        # Only toggle effect at counts 1, 4, 8, ... (i.e., 1 and then every multiple of 4)
         self.dj_effect_counters[movement] += 1
-        if self.dj_effect_counters[movement] % 4 != 0:
-            print(f"🎛️ {movement}: Skipped effect toggle (count={self.dj_effect_counters[movement]})")
-            return {"effect_applied": False, "message": f"Effect for {movement} only toggled every 4th time (count={self.dj_effect_counters[movement]})"}
+        count = self.dj_effect_counters[movement]
+        if count != 1 and (count - 1) % 4 != 0:
+            print(f"🎛️ {movement}: Skipped effect toggle (count={count})")
+            return {"effect_applied": False, "message": f"Effect for {movement} only toggled at 1, 4, 8, ... (count={count})"}
         # Toggle effect ON
         self.active_effects[movement] = True
         effect_status = "ON"
-        print(f"🎛️ {movement}: {effect_status} (brief={brief}) [count={self.dj_effect_counters[movement]}]")
+        print(f"🎛️ {movement}: {effect_status} (brief={brief}) [count={count}]")
         # Schedule effect OFF after duration if brief
         def turn_off_effect():
             self.active_effects[movement] = False
@@ -215,7 +233,7 @@ class SoundManager:
             timer = threading.Timer(duration, turn_off_effect)
             timer.daemon = True
             timer.start()
-        return {"effect_applied": True, "effect_name": movement, "effect_status": effect_status, "count": self.dj_effect_counters[movement]}
+        return {"effect_applied": True, "effect_name": movement, "effect_status": effect_status, "count": count}
 
     def get_composition_info(self) -> Dict:
         layers_by_cycle = {0: []}

utils.py

@@ -1,226 +0,0 @@
-"""
-Utility functions for the EEG Motor Imagery Music Composer
-"""
-
-import numpy as np
-import logging
-import time
-from pathlib import Path
-from typing import Dict, List, Optional, Tuple
-import json
-
-from config import LOG_LEVEL, LOG_FILE, CLASS_NAMES, CLASS_DESCRIPTIONS
-
-def setup_logging():
-    """Set up logging configuration."""
-    LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
-    
-    logging.basicConfig(
-        level=getattr(logging, LOG_LEVEL),
-        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-        handlers=[
-            logging.FileHandler(LOG_FILE),
-            logging.StreamHandler()
-        ]
-    )
-    
-    return logging.getLogger(__name__)
-
-def validate_eeg_data(data: np.ndarray) -> bool:
-    """
-    Validate EEG data format and dimensions.
-    
-    Args:
-        data: EEG data array
-        
-    Returns:
-        bool: True if data is valid, False otherwise
-    """
-    if not isinstance(data, np.ndarray):
-        return False
-        
-    if data.ndim not in [2, 3]:
-        return False
-        
-    if data.ndim == 2 and data.shape[0] == 0:
-        return False
-        
-    if data.ndim == 3 and (data.shape[0] == 0 or data.shape[1] == 0):
-        return False
-        
-    return True
-
-def format_confidence(confidence: float) -> str:
-    """Format confidence score as percentage string."""
-    return f"{confidence * 100:.1f}%"
-
-def format_timestamp(timestamp: float) -> str:
-    """Format timestamp for display."""
-    return time.strftime("%H:%M:%S", time.localtime(timestamp))
-
-def get_class_emoji(class_name: str) -> str:
-    """Get emoji representation for motor imagery class."""
-    emoji_map = {
-        "left_hand": "🤚",
-        "right_hand": "🤚",
-        "neutral": "😐",
-        "left_leg": "🦵",
-        "tongue": "👅",
-        "right_leg": "🦵"
-    }
-    return emoji_map.get(class_name, "❓")
-
-def create_classification_summary(
-    predicted_class: str,
-    confidence: float,
-    probabilities: Dict[str, float],
-    timestamp: Optional[float] = None
-) -> Dict:
-    """
-    Create a formatted summary of classification results.
-    
-    Args:
-        predicted_class: Predicted motor imagery class
-        confidence: Confidence score (0-1)
-        probabilities: Dictionary of class probabilities
-        timestamp: Optional timestamp
-        
-    Returns:
-        Dict: Formatted classification summary
-    """
-    if timestamp is None:
-        timestamp = time.time()
-        
-    return {
-        "predicted_class": predicted_class,
-        "confidence": confidence,
-        "confidence_percent": format_confidence(confidence),
-        "probabilities": probabilities,
-        "timestamp": timestamp,
-        "formatted_time": format_timestamp(timestamp),
-        "emoji": get_class_emoji(predicted_class),
-        "description": CLASS_DESCRIPTIONS.get(predicted_class, predicted_class)
-    }
-
-def save_session_data(session_data: Dict, filepath: str) -> bool:
-    """
-    Save session data to JSON file.
-    
-    Args:
-        session_data: Dictionary containing session information
-        filepath: Path to save the file
-        
-    Returns:
-        bool: True if successful, False otherwise
-    """
-    try:
-        with open(filepath, 'w') as f:
-            json.dump(session_data, f, indent=2, default=str)
-        return True
-    except Exception as e:
-        logging.error(f"Error saving session data: {e}")
-        return False
-
-def load_session_data(filepath: str) -> Optional[Dict]:
-    """
-    Load session data from JSON file.
-    
-    Args:
-        filepath: Path to the JSON file
-        
-    Returns:
-        Dict or None: Session data if successful, None otherwise
-    """
-    try:
-        with open(filepath, 'r') as f:
-            return json.load(f)
-    except Exception as e:
-        logging.error(f"Error loading session data: {e}")
-        return None
-
-def calculate_classification_statistics(history: List[Dict]) -> Dict:
-    """
-    Calculate statistics from classification history.
-    
-    Args:
-        history: List of classification results
-        
-    Returns:
-        Dict: Statistics summary
-    """
-    if not history:
-        return {"total": 0, "class_counts": {}, "average_confidence": 0.0}
-    
-    class_counts = {}
-    total_confidence = 0.0
-    
-    for item in history:
-        class_name = item.get("predicted_class", "unknown")
-        confidence = item.get("confidence", 0.0)
-        
-        class_counts[class_name] = class_counts.get(class_name, 0) + 1
-        total_confidence += confidence
-    
-    return {
-        "total": len(history),
-        "class_counts": class_counts,
-        "average_confidence": total_confidence / len(history),
-        "most_common_class": max(class_counts, key=class_counts.get) if class_counts else None
-    }
-
-def create_progress_bar(value: float, max_value: float = 1.0, width: int = 20) -> str:
-    """
-    Create a text-based progress bar.
-    
-    Args:
-        value: Current value
-        max_value: Maximum value
-        width: Width of progress bar in characters
-        
-    Returns:
-        str: Progress bar string
-    """
-    percentage = min(value / max_value, 1.0)
-    filled = int(width * percentage)
-    bar = "█" * filled + "░" * (width - filled)
-    return f"[{bar}] {percentage * 100:.1f}%"
-
-def validate_audio_file(file_path: str) -> bool:
-    """
-    Validate if an audio file exists and is readable.
-    
-    Args:
-        file_path: Path to audio file
-        
-    Returns:
-        bool: True if file is valid, False otherwise
-    """
-    path = Path(file_path)
-    if not path.exists():
-        return False
-        
-    if not path.is_file():
-        return False
-        
-    # Check file extension
-    valid_extensions = ['.wav', '.mp3', '.flac', '.ogg']
-    if path.suffix.lower() not in valid_extensions:
-        return False
-        
-    return True
-
-def generate_composition_filename(prefix: str = "composition") -> str:
-    """
-    Generate a unique filename for composition exports.
-    
-    Args:
-        prefix: Filename prefix
-        
-    Returns:
-        str: Unique filename with timestamp
-    """
-    timestamp = time.strftime("%Y%m%d_%H%M%S")
-    return f"{prefix}_{timestamp}.wav"
-
-# Initialize logger when module is imported
-logger = setup_logging()