functioning app

.gitignore

@@ -47,13 +47,15 @@ Thumbs.db
 *.wav
 *.mp3
 *.pth
-mixed_composition_*.wav
-*_fx_*.wav
-app_old.py
-app_new.py
-test_mixed.wav
-silent.wav
+
 
 # Data files
 data/
-*.mat
+*.mat
+
+otherfiles/
+
+app.log
+
+source/
+sounds/

app.py

@@ -1,1098 +1,471 @@
 """
-EEG Motor Imagery Music Composer - Redesigned Interface
-=======================================================
-Brain-Computer Interface that creates music compositions based on imagined movements.
+EEG Motor Imagery Music Composer - Clean Transition Version
+=========================================================
+This version implements a clear separation between the building phase (layering sounds) and the DJ phase (effect control),
+with seamless playback of all layered sounds throughout both phases.
 """
 
-import gradio as gr
-import numpy as np
+# Set matplotlib backend to non-GUI for server/web use
+import matplotlib
+matplotlib.use('Agg')  # Set backend BEFORE importing pyplot
 import matplotlib.pyplot as plt
-import time
-import threading
 import os
-from typing import Dict, Tuple, Any, List
-
-# Import our custom modules
-from sound_library import SoundManager
+import gradio as gr
+import numpy as np
+from typing import Dict
+from sound_manager import SoundManager
 from data_processor import EEGDataProcessor
 from classifier import MotorImageryClassifier
-from config import DEMO_DATA_PATHS, CLASS_NAMES, CONFIDENCE_THRESHOLD
-
-def validate_data_setup() -> str:
-    """Validate that required data files are available."""
-    missing_files = []
-    
-    for subject_id, path in DEMO_DATA_PATHS.items():
-        try:
-            import os
-            if not os.path.exists(path):
-                missing_files.append(f"Subject {subject_id}: {path}")
-        except Exception as e:
-            missing_files.append(f"Subject {subject_id}: Error checking {path}")
-    
-    if missing_files:
-        return f"❌ Missing data files:\n" + "\n".join(missing_files)
-    return "✅ All data files found"
+from config import DEMO_DATA_PATHS, CONFIDENCE_THRESHOLD
 
-# Global app state
+# --- Initialization ---
 app_state = {
     'is_running': False,
     'demo_data': None,
     'demo_labels': None,
-    'classification_history': [],
     'composition_active': False,
     'auto_mode': False
 }
 
-# Initialize components
-print("🧠 EEG Motor Imagery Music Composer")
-print("=" * 50)
-print("Starting Gradio application...")
+sound_manager = SoundManager()
+data_processor = EEGDataProcessor()
+classifier = MotorImageryClassifier()
 
-try:
-    sound_manager = SoundManager()
-    data_processor = EEGDataProcessor()
-    classifier = MotorImageryClassifier()
-    
-    # Load demo data
-    import os
-    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)
-    else:
-        app_state['demo_data'], app_state['demo_labels'] = None, None
-    
-    if app_state['demo_data'] is not None:
-        # Initialize classifier with proper dimensions
-        classifier.load_model(n_chans=app_state['demo_data'].shape[1], n_times=app_state['demo_data'].shape[2])
-        print(f"✅ Pre-trained model loaded successfully from {classifier.model_path}")
-        print(f"Pre-trained Demo: {len(app_state['demo_data'])} samples from {len(existing_files)} subjects")
-    else:
-        print("⚠️  No demo data loaded - check your .mat files")
-        
-    print(f"Available sound classes: {list(sound_manager.current_sound_mapping.keys())}")
-    
-except Exception as e:
-    print(f"❌ Error during initialization: {e}")
-    raise RuntimeError(
-        "Cannot initialize app without real EEG data. "
-        "Please check your data files and paths."
-    )
+# 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)
+else:
+    app_state['demo_data'], app_state['demo_labels'] = 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])
 
+# --- Helper Functions ---
 def get_movement_sounds() -> Dict[str, str]:
     """Get the current sound files for each movement."""
     sounds = {}
+    from sound_manager import AudioEffectsProcessor
+    import tempfile
+    import soundfile as sf
+    # If in DJ mode, use effect-processed file if effect is ON
+    dj_mode = getattr(sound_manager, 'current_phase', None) == 'dj_effects'
     for movement, sound_file in sound_manager.current_sound_mapping.items():
-        if movement in ['left_hand', 'right_hand', 'left_leg', "right_leg"]:  # Only show main movements
-            if sound_file is not None:  # Check if sound_file is not None
+        if movement in ['left_hand', 'right_hand', 'left_leg', 'right_leg']:
+            if sound_file is not None:
                 sound_path = sound_manager.sound_dir / sound_file
                 if sound_path.exists():
-                    # Convert to absolute path for Gradio audio components
-                    sounds[movement] = str(sound_path.resolve())
+                    if dj_mode and sound_manager.active_effects.get(movement, False):
+                        # Load audio, apply effect, save to temp file
+                        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())
     return sounds
 
+def create_eeg_plot(eeg_data: np.ndarray, target_movement: str, predicted_name: str, confidence: float, sound_added: bool) -> plt.Figure:
+    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])):
+        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].set_xlabel('Time (s)')
+        axes[i].set_ylabel('Amplitude (µV)')
+        axes[i].grid(True, alpha=0.3)
+    title = f"Target: {target_movement.replace('_', ' ').title()} | Predicted: {predicted_name.replace('_', ' ').title()} ({confidence:.2f})"
+    fig.suptitle(title, fontsize=12, fontweight='bold')
+    fig.tight_layout()
+    plt.close(fig)
+    return fig
+
+def format_composition_summary(composition_info: Dict) -> str:
+    if not composition_info.get('layers_by_cycle'):
+        return "No composition layers yet"
+    summary = []
+    for cycle, layers in composition_info['layers_by_cycle'].items():
+        summary.append(f"Cycle {cycle + 1}: {len(layers)} layers")
+        for layer in layers:
+            movement = layer.get('movement', 'unknown')
+            confidence = layer.get('confidence', 0)
+            summary.append(f"  • {movement.replace('_', ' ').title()} ({confidence:.2f})")
+    # DJ Effects Status removed from status tab as requested
+    return "\n".join(summary) if summary else "No composition layers"
+
+# --- Main Logic ---
 def start_composition():
-    """Start the composition process and perform initial classification."""
+    '''
+    Start the composition process.
+    '''
     global app_state
-    
-    # Only start new cycle if not already active
     if not app_state['composition_active']:
         app_state['composition_active'] = True
-        sound_manager.start_new_cycle()  # Reset composition only when starting fresh
-    
+        sound_manager.start_new_cycle()
+    print(f"DEBUG: [start_composition] current_phase={sound_manager.current_phase}, movements_completed={sound_manager.movements_completed}")
     if app_state['demo_data'] is None:
         return "❌ No data", "❌ No data", "❌ No data", None, None, None, None, None, None, "No EEG data available"
-    
-    # Get current target
-    target_movement = sound_manager.get_current_target_movement()
-    print(f"DEBUG start_composition: current target = {target_movement}")
-    
-    # Check if cycle is complete
-    if target_movement == "cycle_complete":
-        return "🎵 Cycle Complete!", "🎵 Complete", "Remap sounds to continue", None, None, None, None, None, None, "Cycle complete - remap sounds to continue"
-    
-    # Perform initial EEG classification
-    epoch_data, true_label = data_processor.simulate_real_time_data(
-        app_state['demo_data'], app_state['demo_labels'], mode="class_balanced"
-    )
-    
-    # Classify the epoch
+    # Force first trial to always be left_hand/instrumental
+    if len(sound_manager.movements_completed) == 0:
+        next_movement = 'left_hand'
+        left_hand_label = [k for k, v in classifier.class_names.items() if v == 'left_hand'][0]
+        import numpy as np
+        matching_indices = np.where(app_state['demo_labels'] == left_hand_label)[0]
+        chosen_idx = np.random.choice(matching_indices)
+        epoch_data = app_state['demo_data'][chosen_idx]
+        true_label = left_hand_label
+        true_label_name = 'left_hand'
+    else:
+        epoch_data, true_label = data_processor.simulate_real_time_data(app_state['demo_data'], app_state['demo_labels'], mode="class_balanced")
+        true_label_name = classifier.class_names[true_label]
+        next_movement = sound_manager.get_current_target_movement()
+    if next_movement == "cycle_complete":
+        print("DEBUG: [start_composition] Transitioning to DJ mode!")
+        return continue_dj_phase()
     predicted_class, confidence, probabilities = classifier.predict(epoch_data)
     predicted_name = classifier.class_names[predicted_class]
-    
-    # Process classification
-    result = sound_manager.process_classification(predicted_name, confidence, CONFIDENCE_THRESHOLD)
-
-    # Debug: Print composition layers before DJ mode transition
-    print(f"DEBUG: composition_layers before DJ check: {[layer['sound_file'] for layer in sound_manager.composition_layers]}")
-    # Always check for DJ mode transition after classification
-    dj_transitioned = sound_manager.transition_to_dj_phase()
-    print(f"DEBUG: DJ mode transitioned: {dj_transitioned}, current_phase: {sound_manager.current_phase}")
-
-    # Stop EEG visualization if all 4 unique sound layers are present
-    unique_sounds = set([layer['sound_file'] for layer in sound_manager.composition_layers if layer.get('sound_file')])
-    if len(unique_sounds) >= 4 and sound_manager.current_phase != "dj_effects":
-        fig = None
-        print("DEBUG: EEG visualization stopped (all sounds present)")
-    else:
-        fig = create_eeg_plot(epoch_data, target_movement, predicted_name, confidence, result['sound_added'])
-        if sound_manager.current_phase == "dj_effects":
-            print("DEBUG: EEG visualization restarted for DJ mode")
-    
-    # Initialize all audio components to None (no sound by default)
-    left_hand_audio = None
-    right_hand_audio = None
-    left_leg_audio = None
-    right_leg_audio = None
-    #tongue_audio = None
-    
-    # Debug: Print classification result
-    print(f"DEBUG start_composition: predicted={predicted_name}, confidence={confidence:.3f}, sound_added={result['sound_added']}")
-    
-    # Only play the sound if it was just added and matches the prediction
-    if result['sound_added']: # might add confidence threshold for sound output here
-        sounds = get_movement_sounds()
-        print(f"DEBUG: Available sounds: {list(sounds.keys())}")
-        if predicted_name == 'left_hand' and 'left_hand' in sounds:
-            left_hand_audio = sounds['left_hand']
-            print(f"DEBUG: Setting left_hand_audio to {sounds['left_hand']}")
-        elif predicted_name == 'right_hand' and 'right_hand' in sounds:
-            right_hand_audio = sounds['right_hand']
-            print(f"DEBUG: Setting right_hand_audio to {sounds['right_hand']}")
-        elif predicted_name == 'left_leg' and 'left_leg' in sounds:
-            left_leg_audio = sounds['left_leg']
-            print(f"DEBUG: Setting left_leg_audio to {sounds['left_leg']}")
-        elif predicted_name == 'right_leg' and 'right_leg' in sounds:
-            right_leg_audio = sounds['right_leg']
-            print(f"DEBUG: Setting right_leg_audio to {sounds['right_leg']}")
-        # elif predicted_name == 'tongue' and 'tongue' in sounds:
-        #     tongue_audio = sounds['tongue']
-        #     print(f"DEBUG: Setting tongue_audio to {sounds['tongue']}")
+    print(f"TRIAL: true_label={true_label_name}, presented_target={next_movement}, predicted={predicted_name}")
+    # Only add sound if confidence > threshold, predicted == true label, and true label matches the prompt
+    if confidence > CONFIDENCE_THRESHOLD and predicted_name == true_label_name:
+        result = sound_manager.process_classification(predicted_name, confidence, CONFIDENCE_THRESHOLD, force_add=True)
     else:
-        print("DEBUG: No sound added - confidence too low or other issue")
-    
-    # Format next target with progress information
-    next_target = sound_manager.get_current_target_movement()
-    completed_count = len(sound_manager.movements_completed)
-    total_count = len(sound_manager.current_movement_sequence)
-    
-    if next_target == "cycle_complete":
-        target_text = "🎵 Cycle Complete!"
-    else:
-        target_text = f"🎯 Any Movement ({completed_count}/{total_count} complete) - Use 'Classify Epoch' button to continue"
-    
-    predicted_text = f"🧠 Predicted: {predicted_name.replace('_', ' ').title()} ({confidence:.2f})"
+        result = {'sound_added': False}
+    fig = create_eeg_plot(epoch_data, true_label_name, predicted_name, confidence, result['sound_added'])
     
-    # Get composition info
-    composition_info = sound_manager.get_composition_info()
-    status_text = format_composition_summary(composition_info)
-    
-    return (
-        target_text,
-        predicted_text,
-        "2-3 seconds",
-        fig,
-        left_hand_audio,
-        right_hand_audio, 
-        left_leg_audio,
-        right_leg_audio,
-        #tongue_audio,
-        status_text
-    )
+    # Only play completed movement sounds (layered)
+    sounds = get_movement_sounds()
+    completed_movements = sound_manager.movements_completed
 
-def stop_composition():
-    """Stop the composition process."""
-    global app_state
-    app_state['composition_active'] = False
-    app_state['auto_mode'] = False
-    return (
-        "Composition stopped. Click 'Start Composing' to begin again",
-        "--",
-        "--",
-        "Stopped - click Start to resume"
-    )
+    # Assign audio paths only for completed movements
+    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
 
-def start_automatic_composition():
-    """Start automatic composition with continuous classification."""
-    global app_state
+    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)
     
-    # Only start new cycle if not already active
-    if not app_state['composition_active']:
-        app_state['composition_active'] = True
-        app_state['auto_mode'] = True
-        sound_manager.start_new_cycle()  # Reset composition only when starting fresh
 
-    if app_state['demo_data'] is None:
-        return "❌ No data", "❌ No data", "❌ No data", "❌ No data", None, None, None, None, None, None, "No EEG data available", gr.update(visible=True), gr.update(visible=False)
 
-    # Get current target
-    target_movement = sound_manager.get_current_target_movement()
-    print(f"DEBUG start_automatic_composition: current target = {target_movement}")
-    
-    # Check if cycle is complete
-    if target_movement == "cycle_complete":
-        # Mark current cycle as complete
-        sound_manager.complete_current_cycle()
-        
-        # Check if rehabilitation session should end
-        if sound_manager.should_end_session():
-            app_state['auto_mode'] = False  # Stop automatic mode
-            return (
-                "🎉 Session Complete!", 
-                "🏆 Amazing Progress!", 
-                "Rehabilitation session finished!",
-                "🌟 Congratulations! You've created 2 unique brain-music compositions!\n\n" +
-                "💪 Your motor imagery skills are improving!\n\n" +
-                "🎵 You can review your compositions above, or start a new session anytime.\n\n" +
-                "Would you like to continue with more cycles, or take a well-deserved break?",
-                None, None, None, None, None, None, 
-                f"✅ Session Complete: {sound_manager.completed_cycles}/{sound_manager.max_cycles} compositions finished!"
-            )
-        else:
-            # Start next cycle automatically
-            sound_manager.start_new_cycle()
-            print("🔄 Cycle completed! Starting new cycle automatically...")
-            target_movement = sound_manager.get_current_target_movement()  # Get new target
-    
-    # Show user prompt - encouraging start message
-    cycle_num = sound_manager.current_cycle
-    if cycle_num == 1:
-        prompt_text = "🌟 Welcome to your rehabilitation session! Let's start with any movement you can imagine..."
-    elif cycle_num == 2:
-        prompt_text = "💪 Excellent work on your first composition! Ready for composition #2?"
-    else:
-        prompt_text = "🧠 Let's continue - imagine any movement now..."
-    
-    # Perform initial EEG classification
-    epoch_data, true_label = data_processor.simulate_real_time_data(
-        app_state['demo_data'], app_state['demo_labels'], mode="class_balanced"  
-    )
-    
-    # Classify the epoch
-    predicted_class, confidence, probabilities = classifier.predict(epoch_data)
-    predicted_name = classifier.class_names[predicted_class]
-    
-    # Handle DJ effects or building phase
-    if sound_manager.current_phase == "dj_effects" and confidence > CONFIDENCE_THRESHOLD:
-        # DJ Effects Mode - toggle effects instead of adding sounds
-        dj_result = sound_manager.toggle_dj_effect(predicted_name)
-        result = {
-            'sound_added': dj_result['effect_applied'],
-            'mixed_composition': dj_result.get('mixed_composition'),
-            'effect_name': dj_result.get('effect_name', ''),
-            'effect_status': dj_result.get('effect_status', '')
-        }
-    else:
-        # Building Mode - process classification normally
-        result = sound_manager.process_classification(predicted_name, confidence, CONFIDENCE_THRESHOLD)
-    
-    # Create visualization
-    fig = create_eeg_plot(epoch_data, target_movement, predicted_name, confidence, result['sound_added'])
-    
-    
-    # Initialize all audio components to None (no sound by default)
-    left_hand_audio = None
-    right_hand_audio = None
-    left_leg_audio = None
-    right_leg_audio = None
-    #tongue_audio = None
-    
-    # Debug: Print classification result
-    print(f"DEBUG start_automatic_composition: predicted={predicted_name}, confidence={confidence:.3f}, sound_added={result['sound_added']}")
-    
-    # Handle audio display based on current phase
-    if sound_manager.current_phase == "dj_effects":
-        # DJ Effects Phase - continue showing individual sounds in their players
-        sounds = get_movement_sounds()
-        # Always check for phase transition to DJ effects after each classification
-        sound_manager.transition_to_dj_phase()
-        completed_movements = sound_manager.movements_completed
-        # Display each completed movement sound in its respective player (same as building mode)
-        if 'left_hand' in completed_movements and 'left_hand' in sounds:
-            left_hand_audio = sounds['left_hand']
-            print(f"DEBUG DJ: Left hand playing: {sounds['left_hand']}")
-        if 'right_hand' in completed_movements and 'right_hand' in sounds:
-            right_hand_audio = sounds['right_hand']
-            print(f"DEBUG DJ: Right hand playing: {sounds['right_hand']}")
-        if 'left_leg' in completed_movements and 'left_leg' in sounds:
-            left_leg_audio = sounds['left_leg']
-            print(f"DEBUG DJ: Left leg playing: {sounds['left_leg']}")
-        if 'right_leg' in completed_movements and 'right_leg' in sounds:
-            right_leg_audio = sounds['right_leg']
-            print(f"DEBUG DJ: Right leg playing: {sounds['right_leg']}")
-        # if 'tongue' in completed_movements and 'tongue' in sounds:
-        #     tongue_audio = sounds['tongue']
-        #     print(f"DEBUG DJ: Tongue playing: {sounds['tongue']}")
-        print(f"DEBUG DJ: {len(completed_movements)} individual sounds playing with effects applied")
-    else:
-        # Building Phase - create and show layered composition
-        sounds = get_movement_sounds()
-        completed_movements = sound_manager.movements_completed
-        print(f"DEBUG: Available sounds: {list(sounds.keys())}")
-        print(f"DEBUG: Completed movements: {completed_movements}")
-        
-        # Display individual sounds in their respective players for layered composition
-        # All completed movement sounds will play simultaneously, creating natural layering
-        if len(completed_movements) > 0:
-            print(f"DEBUG: Showing individual sounds that will layer together: {list(completed_movements)}")
-            
-            # Display each completed movement sound in its respective player
-            if 'left_hand' in completed_movements and 'left_hand' in sounds:
-                left_hand_audio = sounds['left_hand']
-                print(f"DEBUG: Left hand playing: {sounds['left_hand']}")
-            if 'right_hand' in completed_movements and 'right_hand' in sounds:
-                right_hand_audio = sounds['right_hand']
-                print(f"DEBUG: Right hand playing: {sounds['right_hand']}")
-            if 'left_leg' in completed_movements and 'left_leg' in sounds:
-                left_leg_audio = sounds['left_leg']
-                print(f"DEBUG: Left leg playing: {sounds['left_leg']}")
-            if 'right_leg' in completed_movements and 'right_leg' in sounds:
-                right_leg_audio = sounds['right_leg']
-                print(f"DEBUG: Right leg playing: {sounds['right_leg']}")
-            # if 'tongue' in completed_movements and 'tongue' in sounds:
-            #     tongue_audio = sounds['tongue']
-            #     print(f"DEBUG: Tongue playing: {sounds['tongue']}")
-                
-            print(f"DEBUG: {len(completed_movements)} individual sounds will play together creating layered composition")
-    
-    # Check for phase transition to DJ effects
-    completed_count = len(sound_manager.movements_completed)
-    total_count = len(sound_manager.current_movement_sequence)
-    
-    # Transition to DJ effects if all movements completed but still in building phase
-    if completed_count >= total_count and sound_manager.current_phase == "building":
-        sound_manager.transition_to_dj_phase()
-    
-    # Format display based on current phase
-    if sound_manager.current_phase == "dj_effects":
-        target_text = "🎧 DJ Mode Active - Use movements to control effects!"
-    else:
-        next_target = sound_manager.get_current_target_movement()
-        if next_target == "cycle_complete":
-            target_text = "🎵 Composition Complete!"
-        else:
-            target_text = f"🎯 Building Composition ({completed_count}/{total_count} layers)"
-    
-    # Update display text based on phase
-    if sound_manager.current_phase == "dj_effects":
-        if result.get('effect_name') and result.get('effect_status'):
-            predicted_text = f"🎛️ {result['effect_name']}: {result['effect_status']}"
-        else:
-            predicted_text = f"🧠 Detected: {predicted_name.replace('_', ' ').title()} ({confidence:.2f})"
-        timer_text = "🎧 DJ Mode - Effects updating every 3 seconds..."
-    else:
-        predicted_text = f"🧠 Predicted: {predicted_name.replace('_', ' ').title()} ({confidence:.2f})"
-        timer_text = "⏱️ Next trial in 2-3 seconds..."
-    
-    # Get composition info
-    composition_info = sound_manager.get_composition_info()
-    status_text = format_composition_summary(composition_info)
-    
-    # Phase-based instruction visibility
-    building_visible = sound_manager.current_phase == "building"
-    dj_visible = sound_manager.current_phase == "dj_effects"
-    
-    return (
-        target_text,
-        predicted_text,
-        timer_text,
-        prompt_text,
-        fig,
-        left_hand_audio,
-        right_hand_audio, 
-        left_leg_audio,
-        right_leg_audio,
-        #tongue_audio,
-        status_text,
-        gr.update(visible=building_visible),  # building_instructions
-        gr.update(visible=dj_visible)         # dj_instructions
-    )
 
-def manual_classify():
-    """Manual classification for testing purposes."""
-    global app_state
-    
-    if app_state['demo_data'] is None:
-        return "❌ No data", "❌ No data", "Manual mode", None, "No EEG data available", None, None, None, None, None
-    
-    # Get EEG data sample
-    epoch_data, true_label = data_processor.simulate_real_time_data(
-        app_state['demo_data'], app_state['demo_labels'], mode="class_balanced"
-    )
-    
-    # Classify the epoch
-    predicted_class, confidence, probabilities = classifier.predict(epoch_data)
-    predicted_name = classifier.class_names[predicted_class]
-    
-    # Create visualization (without composition context)
-    fig = create_eeg_plot(epoch_data, "manual_test", predicted_name, confidence, False)
-    
-    # Format results
-    target_text = "🎯 Manual Test Mode"
-    predicted_text = f"🧠 {predicted_name.replace('_', ' ').title()} ({confidence:.2f})"
-    
-    # Update results log
-    import time
-    timestamp = time.strftime("%H:%M:%S")
-    result_entry = f"[{timestamp}] Predicted: {predicted_name.replace('_', ' ').title()} (confidence: {confidence:.3f})"
-    
-    # Get sound files for preview (no autoplay)
-    sounds = get_movement_sounds()
-    left_hand_audio = sounds.get('left_hand', None)
-    right_hand_audio = sounds.get('right_hand', None)
-    left_leg_audio = sounds.get('left_leg', None)
-    right_leg_audio = sounds.get('right_leg', None)
-    #tongue_audio = sounds.get('tongue', None)
-    
-    return (
-        target_text,
-        predicted_text,
-        "Manual mode - click button to classify",
-        fig,
-        result_entry,
-        left_hand_audio,
-        right_hand_audio,
-        left_leg_audio,
-        right_leg_audio,
-        #tongue_audio
-    )
+    # 2. Movement Commands: show mapping for all movements
+    movement_emojis = {
+        "left_hand": "👈",
+        "right_hand": "👉",
+        "left_leg": "🦵",
+        "right_leg": "🦵",
+    }
+    movement_command_lines = []
+    for movement in ["left_hand", "right_hand", "left_leg", "right_leg"]:
+        sound_file = sound_manager.current_sound_mapping.get(movement, "")
+        instrument_type = ""
+        for key in ["bass", "drums", "instruments", "vocals"]:
+            if key in sound_file.lower():
+                instrument_type = key if key != "instruments" else "instrument"
+                break
+        pretty_movement = movement.replace("_", " ").title()
+        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)
 
-def clear_manual():
-    """Clear manual testing results."""
-    return (
-        "🎯 Manual Test Mode",
-        "--",
-        "Manual mode",
-        None,
-        "Manual classification results cleared...",
-        None, None, None, None, None
-    )
+    # 3. Next Trial: will be set dynamically in timer_tick
+    next_trial_text = ""
 
-def continue_automatic_composition():
-    """Continue automatic composition - called for subsequent trials."""
-    global app_state
-    
-    if not app_state['composition_active'] or not app_state['auto_mode']:
-        return "🛑 Stopped", "--", "--", "Automatic composition stopped", None, None, None, None, None, None, "Stopped", gr.update(visible=True), gr.update(visible=False)
-    
-    if app_state['demo_data'] is None:
-        return "❌ No data", "❌ No data", "❌ No data", "❌ No data", None, None, None, None, None, None, "No EEG data available", gr.update(visible=True), gr.update(visible=False)
-    
-    # Get current target
-    target_movement = sound_manager.get_current_target_movement()
-    print(f"DEBUG continue_automatic_composition: current target = {target_movement}")
-    
-    # Check if cycle is complete
-    if target_movement == "cycle_complete":
-        # Mark current cycle as complete
-        sound_manager.complete_current_cycle()
-        
-        # Check if rehabilitation session should end
-        if sound_manager.should_end_session():
-            app_state['auto_mode'] = False  # Stop automatic mode
-            return (
-                "🎉 Session Complete!", 
-                "🏆 Amazing Progress!", 
-                "Rehabilitation session finished!",
-                "🌟 Congratulations! You've created 2 unique brain-music compositions!\n\n" +
-                "💪 Your motor imagery skills are improving!\n\n" +
-                "🎵 You can review your compositions above, or start a new session anytime.\n\n" +
-                "Would you like to continue with more cycles, or take a well-deserved break?",
-                None, None, None, None, None, None, 
-                f"✅ Session Complete: {sound_manager.completed_cycles}/{sound_manager.max_cycles} compositions finished!",
-                gr.update(visible=True), gr.update(visible=False)
-            )
-        else:
-            # Start next cycle automatically
-            sound_manager.start_new_cycle()
-            print("🔄 Cycle completed! Starting new cycle automatically...")
-            target_movement = sound_manager.get_current_target_movement()  # Get new target
-    
-    # Show next user prompt - rehabilitation-focused messaging
-    prompts = [
-        "💪 Great work! Imagine your next movement...",
-        "🎯 You're doing amazing! Focus and imagine any movement...", 
-        "✨ Excellent progress! Ready for the next movement?",
-        "🌟 Keep it up! Concentrate and imagine now...",
-        "🏆 Fantastic! Next trial - imagine any movement..."
-    ]
-    import random
-    prompt_text = random.choice(prompts)
-    
-    # Add progress encouragement
-    completed_count = len(sound_manager.movements_completed)
-    total_count = len(sound_manager.current_movement_sequence)
-    if completed_count > 0:
-        prompt_text += f" ({completed_count}/{total_count} movements completed this cycle)"
-    
-    # Perform EEG classification
-    epoch_data, true_label = data_processor.simulate_real_time_data(
-        app_state['demo_data'], app_state['demo_labels'], mode="class_balanced"  
-    )
-    
-    # Classify the epoch
-    predicted_class, confidence, probabilities = classifier.predict(epoch_data)
-    predicted_name = classifier.class_names[predicted_class]
-    
-    # Handle DJ effects or building phase
-    if sound_manager.current_phase == "dj_effects" and confidence > CONFIDENCE_THRESHOLD:
-        # DJ Effects Mode - toggle effects instead of adding sounds
-        dj_result = sound_manager.toggle_dj_effect(predicted_name)
-        result = {
-            'sound_added': dj_result['effect_applied'],
-            'mixed_composition': dj_result.get('mixed_composition'),
-            'effect_name': dj_result.get('effect_name', ''),
-            'effect_status': dj_result.get('effect_status', '')
-        }
-    else:
-        # Building Mode - process classification normally
-        result = sound_manager.process_classification(predicted_name, confidence, CONFIDENCE_THRESHOLD)
-        
-        # Check if we should transition to DJ phase
-        completed_count = len(sound_manager.movements_completed)
-        if completed_count >= 5 and sound_manager.current_phase == "building":
-            if sound_manager.transition_to_dj_phase():
-                print(f"DEBUG: Successfully transitioned to DJ phase with {completed_count} completed movements")
-    
-    # Create visualization
-    fig = create_eeg_plot(epoch_data, target_movement, predicted_name, confidence, result['sound_added'])
-    
-    # Initialize all audio components to None (no sound by default)
-    left_hand_audio = None
-    right_hand_audio = None
-    left_leg_audio = None
-    right_leg_audio = None
-    #tongue_audio = None
-    
-    # Handle audio differently based on phase
-    if sound_manager.current_phase == "dj_effects":
-        # DJ Mode: Show only the full mixed track and route effects to it
-        mixed_track = sound_manager.get_current_mixed_composition()
-        print(f"DEBUG continue: DJ Mode - Showing full mixed track: {mixed_track}")
-        # Hide individual movement sounds by setting them to None
-        left_hand_audio = None
-        right_hand_audio = None
-        left_leg_audio = None
-        right_leg_audio = None
-        #tongue_audio = None
-        # The mixed_track will be shown in a dedicated gr.Audio component in the UI (update UI accordingly)
-    else:
-        # Building Mode: Display individual sounds in their respective players for layered composition
-        # All completed movement sounds will play simultaneously, creating natural layering
-        sounds = get_movement_sounds()
-        completed_movements = sound_manager.movements_completed
-        print(f"DEBUG continue: Available sounds: {list(sounds.keys())}")
-        print(f"DEBUG continue: Completed movements: {completed_movements}")
-        
-        if len(completed_movements) > 0:
-            # Track and print only the sounds that have been added
-            sounds_added = [sounds[m] for m in completed_movements if m in sounds]
-            print(f"DEBUG: Sounds added to composition: {sounds_added}")
-            # Display each completed movement sound in its respective player
-            if 'left_hand' in completed_movements and 'left_hand' in sounds:
-                left_hand_audio = sounds['left_hand']
-            if 'right_hand' in completed_movements and 'right_hand' in sounds:
-                right_hand_audio = sounds['right_hand']
-            if 'left_leg' in completed_movements and 'left_leg' in sounds:
-                left_leg_audio = sounds['left_leg']
-            if 'right_leg' in completed_movements and 'right_leg' in sounds:
-                right_leg_audio = sounds['right_leg']
-    
-    # Format display with progress information
-    completed_count = len(sound_manager.movements_completed)
-    total_count = len(sound_manager.current_movement_sequence)
-    
-    if sound_manager.current_phase == "dj_effects":
-        target_text = f"🎧 DJ Mode - Control Effects with Movements"
-        predicted_text = f"🧠 Predicted: {predicted_name.replace('_', ' ').title()} ({confidence:.2f})"
-        if result.get('effect_applied'):
-            effect_name = result.get('effect_name', '')
-            effect_status = result.get('effect_status', '')
-            timer_text = f"�️ {effect_name}: {effect_status}"
-        else:
-            timer_text = "🎵 Move to control effects..."
-    else:
-        target_text = f"�🎯 Any Movement ({completed_count}/{total_count} complete)"
-        predicted_text = f"🧠 Predicted: {predicted_name.replace('_', ' ').title()} ({confidence:.2f})"
-        timer_text = "⏱️ Next trial in 2-3 seconds..." if app_state['auto_mode'] else "Stopped"
-    
-    # Get composition info
     composition_info = sound_manager.get_composition_info()
     status_text = format_composition_summary(composition_info)
-    
-    # Phase-based instruction visibility
-    building_visible = sound_manager.current_phase == "building"
-    dj_visible = sound_manager.current_phase == "dj_effects"
-    
     return (
-        target_text,
-        predicted_text,
-        timer_text,
-        prompt_text,
+        movement_command_text,
+        next_trial_text,
         fig,
         left_hand_audio,
-        right_hand_audio, 
+        right_hand_audio,
         left_leg_audio,
         right_leg_audio,
-        #tongue_audio,
-        status_text,
-        gr.update(visible=building_visible),  # building_instructions
-        gr.update(visible=dj_visible)         # dj_instructions
+        status_text
     )
 
-def classify_epoch():
-    """Classify a single EEG epoch and update composition."""
+def continue_dj_phase():
     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"
-    
-    # Get current target
-    target_movement = sound_manager.get_current_target_movement()
-    print(f"DEBUG classify_epoch: current target = {target_movement}")
-    
-    if target_movement == "cycle_complete":
-        return "🎵 Cycle Complete!", "🎵 Complete", "Remap sounds to continue", None, None, None, None, None, None, "Cycle complete - remap sounds to continue"
-    
-    # Get EEG data sample
-    epoch_data, true_label = data_processor.simulate_real_time_data(
-        app_state['demo_data'], app_state['demo_labels'], mode="class_balanced"
-    )
-    
-    # Classify the epoch
+    # DJ phase: classify and apply effects, but always play all layered sounds
+    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]
-    
-    # Process classification
-    result = sound_manager.process_classification(predicted_name, confidence, CONFIDENCE_THRESHOLD)
-    
-    # Check if we should transition to DJ phase
-    completed_count = len(sound_manager.movements_completed)
-    if completed_count >= 5 and sound_manager.current_phase == "building":
-        if sound_manager.transition_to_dj_phase():
-            print(f"DEBUG: Successfully transitioned to DJ phase with {completed_count} completed movements")
-    
-    # Create visualization
-    fig = create_eeg_plot(epoch_data, target_movement, predicted_name, confidence, result['sound_added'])
-    
-    # Initialize all audio components to None (no sound by default)
-    left_hand_audio = None
-    right_hand_audio = None
-    left_leg_audio = None
-    right_leg_audio = None
-    #tongue_audio = None
-    
-    # Always assign all completed movement sounds to their respective audio slots
+    # 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)
+    effect_applied = False
+    if confidence > CONFIDENCE_THRESHOLD:
+        result = sound_manager.toggle_dj_effect(predicted_name, brief=True, duration=1.0)
+        effect_applied = result.get("effect_applied", False)
+    else:
+        result = None
+    fig = create_eeg_plot(epoch_data, true_label_name, predicted_name, confidence, effect_applied)
+    # Always play all completed movement sounds (layered)
     sounds = get_movement_sounds()
     completed_movements = sound_manager.movements_completed
-    if 'left_hand' in completed_movements and 'left_hand' in sounds:
-        left_hand_audio = sounds['left_hand']
-    if 'right_hand' in completed_movements and 'right_hand' in sounds:
-        right_hand_audio = sounds['right_hand']
-    if 'left_leg' in completed_movements and 'left_leg' in sounds:
-        left_leg_audio = sounds['left_leg']
-    if 'right_leg' in completed_movements and 'right_leg' in sounds:
-        right_leg_audio = sounds['right_leg']
-    # if 'tongue' in completed_movements and 'tongue' in sounds:
-    #     tongue_audio = sounds['tongue']
-    
-    # Format next target
-    next_target = sound_manager.get_current_target_movement()
-    target_text = f"🎯 Target: {next_target.replace('_', ' ').title()}" if next_target != "cycle_complete" else "🎵 Cycle Complete!"
-    
-    predicted_text = f"🧠 Predicted: {predicted_name.replace('_', ' ').title()} ({confidence:.2f})"
-    
-    # Get composition info
+    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
+    # Show DJ effect mapping for each movement with ON/OFF status and correct instrument mapping
+    movement_map = {
+        "left_hand": {"effect": "Echo", "instrument": "Instrument"},
+        "right_hand": {"effect": "Low Pass", "instrument": "Bass"},
+        "left_leg": {"effect": "Compressor", "instrument": "Drums"},
+        "right_leg": {"effect": "High Pass", "instrument": "Vocals"},
+    }
+    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"]:
+        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']}")
+    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"
     composition_info = sound_manager.get_composition_info()
     status_text = format_composition_summary(composition_info)
-    
+    # Ensure exactly 10 outputs: [textbox, textbox, plot, audio, audio, audio, audio, textbox, timer, button]
+    # Use fig for the plot, and fill all outputs with correct types
     return (
-        target_text,
-        predicted_text,
-        "2-3 seconds",
-        fig,
-        left_hand_audio,
-        right_hand_audio, 
-        left_leg_audio,
-        right_leg_audio,
-        ##tongue_audio,
-        status_text
+        target_text,            # Movement Commands (textbox)
+        predicted_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)
     )
 
-def create_eeg_plot(eeg_data: np.ndarray, target_movement: str, predicted_name: str, confidence: float, sound_added: bool) -> plt.Figure:
-    """Create EEG plot with target movement and classification result."""
-    fig, axes = plt.subplots(2, 2, figsize=(12, 8))
-    axes = axes.flatten()
-    
-    # Plot 4 channels
-    time_points = np.arange(eeg_data.shape[1]) / 200  # 200 Hz sampling rate
-    channel_names = ['C3', 'C4', 'T3', 'T4']  # Motor cortex channels
-    
-    for i in range(min(4, eeg_data.shape[0])):
-        color = 'green' if sound_added else 'blue'
-        axes[i].plot(time_points, eeg_data[i], color=color, linewidth=1)
-        
-        if i < len(channel_names):
-            axes[i].set_title(f'{channel_names[i]} (Ch {i+1})')
-        else:
-            axes[i].set_title(f'Channel {i+1}')
-            
-        axes[i].set_xlabel('Time (s)')
-        axes[i].set_ylabel('Amplitude (µV)')
-        axes[i].grid(True, alpha=0.3)
-    
-    # Add overall title with status
-    status = "✓ SOUND ADDED" if sound_added else "○ No sound"
-    title = f"Target: {target_movement.replace('_', ' ').title()} | Predicted: {predicted_name.replace('_', ' ').title()} ({confidence:.2f}) | {status}"
-    fig.suptitle(title, fontsize=12, fontweight='bold')
-    fig.tight_layout()
-    return fig
+# --- Gradio UI ---
+def create_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.")
+                gr.Markdown("""
+                **How the Task Works**
 
-def format_composition_summary(composition_info: Dict) -> str:
-    """Format composition information for display."""
-    if not composition_info.get('layers_by_cycle'):
-        return "No composition layers yet"
-    
-    summary = []
-    for cycle, layers in composition_info['layers_by_cycle'].items():
-        summary.append(f"Cycle {cycle + 1}: {len(layers)} layers")
-        for layer in layers:
-            movement = layer.get('movement', 'unknown')
-            confidence = layer.get('confidence', 0)
-            summary.append(f"  • {movement.replace('_', ' ').title()} ({confidence:.2f})")
-    
-    return "\n".join(summary) if summary else "No composition layers"
+                This app has **two stages**:
 
-# Create Gradio interface
-def create_interface():
-    with gr.Blocks(title="EEG Motor Imagery Music Composer", theme=gr.themes.Soft()) as demo:
-        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.Tabs() as tabs:
-            # Main Composition Tab
-            with gr.TabItem("🎵 Automatic Composition"):
+                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.
+
+                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.
+
+                > **Note:** In DJ mode, each effect is only triggered every 4th time you perform the same movement. This prevents tracks from reloading too frequently.
+
+                **Commands and controls will change between stages.** Follow the on-screen instructions for each phase.
+                """)
+                
                 with gr.Row():
-                    # Left side - Task and EEG information
                     with gr.Column(scale=2):
-                        # Task instructions - Building Phase
-                        with gr.Group() as building_instructions:
-                            gr.Markdown("### 🎯 Rehabilitation Session Instructions")
-                            gr.Markdown("""
-                            **Motor Imagery Training:**
-                            - **Imagine** opening or closing your **right or left hand**
-                            - **Visualize** briefly moving your **right or left leg or foot**  
-                            
-                            *🌟 Each successful imagination creates a musical layer!*
-                            
-                            **Session Structure:** Build composition, then control DJ effects
-                            *Press Start to begin your personalized rehabilitation session*
-                            """)
-                        
-                        # DJ Instructions - Effects Phase (initially hidden)
-                        with gr.Group(visible=False) as dj_instructions:
-                            gr.Markdown("### 🎧 DJ Controller Mode")
-                            gr.Markdown("""
-                            **🎉 Composition Complete! You are now the DJ!**
-                            
-                            **Use the same movements to control audio effects:**
-                            - 👈 **Left Hand**: Volume Fade On/Off
-                            - 👉 **Right Hand**: High Pass Filter On/Off  
-                            - 🦵 **Left Leg**: Reverb Effect On/Off
-                            - 🦵 **Right Leg**: Low Pass Filter On/Off
-                            
-                            
-                            *🎛️ Each movement toggles an effect - Mix your creation!*
-                            """)
-                        
-                        # Start button
-                        with gr.Row():
-                            start_btn = gr.Button("🎵 Start Composing", variant="primary", size="lg")
-                            continue_btn = gr.Button("⏭️ Continue", variant="primary", size="lg", visible=False)
-                            stop_btn = gr.Button("🛑 Stop", variant="secondary", size="lg")
-                        
-                        # Session completion options (shown after 2 cycles)
-                        with gr.Row(visible=False) as session_complete_row:
-                            new_session_btn = gr.Button("🔄 Start New Session", variant="primary", size="lg")
-                            extend_session_btn = gr.Button("➕ Continue Session", variant="secondary", size="lg")
-                        
-                        # Timer for automatic progression (hidden from user)
-                        timer = gr.Timer(value=3.0, active=False)  # 3 second intervals
-                        
-                        # User prompt display
-                        user_prompt = gr.Textbox(label="💭 User Prompt", interactive=False, value="Click 'Start Composing' to begin", 
-                                               elem_classes=["prompt-display"])
-                        
-                        # Current status
-                        with gr.Row():
-                            target_display = gr.Textbox(label="🎯 Current Target", interactive=False, value="Ready to start")
-                            predicted_display = gr.Textbox(label="🧠 Predicted", interactive=False, value="--") 
-                        
-                        timer_display = gr.Textbox(label="⏱️ Next Trial In", interactive=False, value="--")
-                        
+                        start_btn = gr.Button("🎵 Start Composing", variant="primary", size="lg")
+                        stop_btn = gr.Button("🛑 Stop", variant="stop", size="md")
+                        continue_btn = gr.Button("⏭️ Continue DJ Phase", variant="primary", size="lg", visible=False)
+                        timer = gr.Timer(value=1.0, active=False)  # 4 second intervals
+                        predicted_display = gr.Textbox(label="🧠 Movement Commands", interactive=False, value="--", lines=4)
+                        timer_display = gr.Textbox(label="⏱️ Next Trial", interactive=False, value="--")
                         eeg_plot = gr.Plot(label="EEG Data Visualization")
-                        
-                    # Right side - Compositional layers  
                     with gr.Column(scale=1):
-                        gr.Markdown("### 🎵 Compositional Layers")
-                        
-                        # Show 5 movement sounds 
                         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) 
+                        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)
-                        #tongue_sound = gr.Audio(label="👅 Tongue", interactive=False, autoplay=True, visible=True)
-                        
-                        # Composition status
                         composition_status = gr.Textbox(label="Composition Status", interactive=False, lines=5)
-            
-            # Manual Testing Tab 
-            with gr.TabItem("🧠 Manual Testing"):
-                with gr.Row():
-                    with gr.Column(scale=2):
-                        gr.Markdown("### 🔬 Manual EEG Classification Testing")
-                        gr.Markdown("Use this tab to manually test the EEG classifier without the composition system.")
-                        
-                        with gr.Row():
-                            classify_btn = gr.Button("🧠 Classify Single Epoch", variant="primary")
-                            clear_btn = gr.Button("�️ Clear", variant="secondary")
-                        
-                        # Manual status displays
-                        manual_target_display = gr.Textbox(label="🎯 Current Target", interactive=False, value="Ready")
-                        manual_predicted_display = gr.Textbox(label="🧠 Predicted", interactive=False, value="--")
-                        manual_timer_display = gr.Textbox(label="⏱️ Status", interactive=False, value="Manual mode")
-                        
-                        manual_eeg_plot = gr.Plot(label="EEG Data Visualization")
-                        
-                    with gr.Column(scale=1):
-                        gr.Markdown("### 📊 Classification Results")
-                        manual_results = gr.Textbox(label="Results Log", interactive=False, lines=10, value="Manual classification results will appear here...")
-                        
-                        # Individual sound previews (no autoplay in manual mode)
-                        gr.Markdown("### 🔊 Sound Preview")
-                        manual_left_hand_sound = gr.Audio(label="👈 Left Hand", interactive=False, autoplay=False, visible=True)
-                        manual_right_hand_sound = gr.Audio(label="👉 Right Hand", interactive=False, autoplay=False, visible=True)
-                        manual_left_leg_sound = gr.Audio(label="🦵 Left Leg", interactive=False, autoplay=False, visible=True)
-                        manual_right_leg_sound = gr.Audio(label="🦵 Right Leg", interactive=False, autoplay=False, visible=True)
-                        #manual_tongue_sound = gr.Audio(label="👅 Tongue", interactive=False, autoplay=False, visible=True)
-        
-        # Session management functions
-        def start_new_session():
-            """Reset everything and start a completely new rehabilitation session"""
-            global sound_manager
-            sound_manager.completed_cycles = 0
-            sound_manager.current_cycle = 0
-            sound_manager.movements_completed = set()
-            sound_manager.composition_layers = []
-            
-            # Start fresh session
-            result = start_automatic_composition()
-            return (
-                result[0],  # target_display
-                result[1],  # predicted_display  
-                result[2],  # timer_display
-                result[3],  # user_prompt
-                result[4],  # eeg_plot
-                result[5],  # left_hand_sound
-                result[6],  # right_hand_sound
-                result[7],  # left_leg_sound
-                result[8],  # right_leg_sound
-                #result[9],  # tongue_sound
-                result[9],  # composition_status
-                result[10], # building_instructions
-                result[11], # dj_instructions
-                gr.update(visible=True),   # continue_btn - show it
-                gr.update(active=True),    # timer - activate it
-                gr.update(visible=False)   # session_complete_row - hide it
-            )
-        
-        def extend_current_session():
-            """Continue current session beyond the 2-cycle limit"""
-            sound_manager.max_cycles += 2  # Add 2 more cycles
-            
-            # Continue with current session
-            result = continue_automatic_composition()
-            return (
-                result[0],  # target_display
-                result[1],  # predicted_display  
-                result[2],  # timer_display
-                result[3],  # user_prompt
-                result[4],  # eeg_plot
-                result[5],  # left_hand_sound
-                result[6],  # right_hand_sound
-                result[7],  # left_leg_sound
-                result[8],  # right_leg_sound
-                #result[9],  # tongue_sound
-                result[9],  # composition_status
-                result[10], # building_instructions
-                result[11], # dj_instructions
-                gr.update(visible=True),   # continue_btn - show it
-                gr.update(active=True),    # timer - activate it
-                gr.update(visible=False)   # session_complete_row - hide it
-            )
 
-        # Wrapper functions for timer control
-        def start_with_timer():
-            """Start composition and activate automatic timer"""
-            result = start_automatic_composition()
-            # Show continue button and activate timer
-            return (
-                result[0],  # target_display
-                result[1],  # predicted_display  
-                result[2],  # timer_display
-                result[3],  # user_prompt
-                result[4],  # eeg_plot
-                result[5],  # left_hand_sound
-                result[6],  # right_hand_sound
-                result[7],  # left_leg_sound
-                result[8],  # right_leg_sound
-                #result[9],  # tongue_sound
-                result[9], # composition_status
-                result[10], # building_instructions
-                result[11], # dj_instructions
-                gr.update(visible=True),  # continue_btn - show it
-                gr.update(active=True)    # timer - activate it
-            )
-        
-        def continue_with_timer():
-            """Continue composition and manage timer state"""
-            result = continue_automatic_composition()
-            
-            # Check if session is complete (rehabilitation session finished)
-            if "🎉 Session Complete!" in result[0]:
-                # Show session completion options
-                return (
-                    result[0],  # target_display
-                    result[1],  # predicted_display  
-                    result[2],  # timer_display
-                    result[3],  # user_prompt
-                    result[4],  # eeg_plot
-                    result[5],  # left_hand_sound
-                    result[6],  # right_hand_sound
-                    result[7],  # left_leg_sound
-                    result[8],  # right_leg_sound
-                    #result[9],  # tongue_sound
-                    result[9], # composition_status
-                    result[10], # building_instructions
-                    result[11], # dj_instructions
-                    gr.update(active=False),  # timer - deactivate it
-                    gr.update(visible=True)   # session_complete_row - show options
+                def start_and_activate_timer():
+                    result = start_composition()
+                    last_trial_result[:] = result  # Initialize with first trial result
+                    if "DJ Mode" not in result[0]:
+                        return (*result, gr.update(active=True), gr.update(visible=False))
+                    else:
+                        return (*result, gr.update(active=False), gr.update(visible=True))
+                
+                # ITI logic: 3s blank, 1s prompt, then trial
+                timer_counter = {"count": 0}
+                last_trial_result = [None] * 9  # Adjust length to match your outputs
+                def timer_tick():
+                    # 0,1,2: blank, 3: prompt, 4: trial
+                    if timer_counter["count"] < 3:
+                        timer_counter["count"] += 1
+                        # Show blank prompt, keep last outputs
+                        if len(last_trial_result) == 8:
+                            return (*last_trial_result, gr.update(active=True), gr.update(visible=False))
+                        elif len(last_trial_result) == 10:
+                            # DJ mode: blank prompt
+                            result = list(last_trial_result)
+                            result[1] = ""
+                            return tuple(result)
+                        else:
+                            raise ValueError(f"Unexpected last_trial_result length: {len(last_trial_result)}")
+                    elif timer_counter["count"] == 3:
+                        timer_counter["count"] += 1
+                        # Show prompt
+                        result = list(last_trial_result)
+                        result[1] = "Imagine next movement"
+                        if len(result) == 8:
+                            return (*result, gr.update(active=True), gr.update(visible=False))
+                        elif len(result) == 10:
+                            return tuple(result)
+                        else:
+                            raise ValueError(f"Unexpected result length in prompt: {len(result)}")
+                    else:
+                        timer_counter["count"] = 0
+                        # Run trial
+                        result = list(start_composition())
+                        last_trial_result[:] = result  # Save for next blanks/prompts
+                        if len(result) == 8:
+                            # Pre-DJ mode: add timer and button updates
+                            if any(isinstance(x, str) and "DJ Mode" in x for x in result):
+                                print("DEBUG: [timer_tick] DJ mode detected in outputs, stopping timer and showing continue button.")
+                                return (*result, gr.update(active=False), gr.update(visible=True))
+                            else:
+                                print("DEBUG: [timer_tick] Not in DJ mode, continuing trials.")
+                                return (*result, gr.update(active=True), gr.update(visible=False))
+                        elif len(result) == 10:
+                            print("DEBUG: [timer_tick] Already in DJ mode, returning result as is.")
+                            return tuple(result)
+                        else:
+                            raise ValueError(f"Unexpected result length in timer_tick: {len(result)}")
+                
+                def continue_dj():
+                    result = continue_dj_phase()
+                    if len(result) == 8:
+                        return (*result, gr.update(active=False), gr.update(visible=True))
+                    elif len(result) == 10:
+                        return result
+                    else:
+                        raise ValueError(f"Unexpected result length in continue_dj: {len(result)}")
+                start_btn.click(
+                    fn=start_and_activate_timer,
+                    outputs=[predicted_display, timer_display, eeg_plot,
+                            left_hand_sound, right_hand_sound, left_leg_sound, right_leg_sound, composition_status, timer, continue_btn]
+                )
+                timer_event = timer.tick(
+                    fn=timer_tick,
+                    outputs=[predicted_display, timer_display, eeg_plot,
+                            left_hand_sound, right_hand_sound, left_leg_sound, right_leg_sound, composition_status, timer, continue_btn]
+                )
+                def stop_composing():
+                    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
+                    return ("--", "Stopped", None, None, None, None, None, "Stopped", gr.update(active=False), gr.update(visible=False))
+
+                stop_btn.click(
+                    fn=stop_composing,
+                    outputs=[predicted_display, timer_display, eeg_plot,
+                            left_hand_sound, right_hand_sound, left_leg_sound, right_leg_sound, composition_status, timer, continue_btn],
+                    cancels=[timer_event]
                 )
-            # Check if composition is complete (old logic for other cases)
-            elif "🎵 Cycle Complete!" in result[0]:
-                # Stop the timer when composition is complete
-                return (
-                    result[0],  # target_display
-                    result[1],  # predicted_display  
-                    result[2],  # timer_display
-                    result[3],  # user_prompt
-                    result[4],  # eeg_plot
-                    result[5],  # left_hand_sound
-                    result[6],  # right_hand_sound
-                    result[7],  # left_leg_sound
-                    result[8],  # right_leg_sound
-                    #result[9],  # tongue_sound
-                    result[9], # composition_status
-                    result[10], # building_instructions
-                    result[11], # dj_instructions
-                    gr.update(active=False),  # timer - deactivate it
-                    gr.update(visible=False)  # session_complete_row - keep hidden
+                continue_btn.click(
+                    fn=continue_dj,
+                    outputs=[predicted_display, timer_display, eeg_plot,
+                            left_hand_sound, right_hand_sound, left_leg_sound, right_leg_sound, composition_status, timer, continue_btn]
                 )
-            else:
-                # Keep timer active for next iteration
-                return (
-                    result[0],  # target_display
-                    result[1],  # predicted_display  
-                    result[2],  # timer_display
-                    result[3],  # user_prompt
-                    result[4],  # eeg_plot
-                    result[5],  # left_hand_sound
-                    result[6],  # right_hand_sound
-                    result[7],  # left_leg_sound
-                    result[8],  # right_leg_sound
-                    #result[9],  # tongue_sound
-                    result[9], # composition_status
-                    result[10], # building_instructions
-                    result[11], # dj_instructions
-                    gr.update(active=True),   # timer - keep active
-                    gr.update(visible=False)  # session_complete_row - keep hidden
+
+            with gr.TabItem("Manual Classifier"):
+                gr.Markdown("# 🧑‍💻 Manual Classifier Test")
+                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")
+                manual_predicted = gr.Textbox(label="Predicted Class", interactive=False)
+                manual_confidence = gr.Textbox(label="Confidence", interactive=False)
+                manual_plot = gr.Plot(label="EEG Data Visualization")
+                manual_probs = gr.Plot(label="Class Probabilities")
+                manual_confmat = gr.Plot(label="Confusion Matrix (Session)")
+
+                # Session state for confusion matrix
+                from collections import defaultdict
+                session_confmat = defaultdict(lambda: defaultdict(int))
+
+                def manual_classify(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:
+                        return "No data", "No data", None, None, None
+                    label_idx = [k for k, v in classifier.class_names.items() if v == selected_movement][0]
+                    matching_indices = np.where(app_state['demo_labels'] == label_idx)[0]
+                    if len(matching_indices) == 0:
+                        return "No data for this movement", "", None, None, None
+                    chosen_idx = np.random.choice(matching_indices)
+                    epoch_data = app_state['demo_data'][chosen_idx]
+                    predicted_class, confidence, probs = classifier.predict(epoch_data)
+                    predicted_name = classifier.class_names[predicted_class]
+                    # Update confusion matrix
+                    session_confmat[selected_movement][predicted_name] += 1
+                    # Plot confusion matrix
+                    classes = ["left_hand", "right_hand", "left_leg", "right_leg"]
+                    confmat = np.zeros((4, 4), dtype=int)
+                    for i, true_m in enumerate(classes):
+                        for j, pred_m in enumerate(classes):
+                            confmat[i, j] = session_confmat[true_m][pred_m]
+                    fig_confmat, ax = plt.subplots(figsize=(4, 4))
+                    ax.imshow(confmat, cmap="Blues")
+                    ax.set_xticks(np.arange(4))
+                    ax.set_yticks(np.arange(4))
+                    ax.set_xticklabels(classes, rotation=45, ha="right")
+                    ax.set_yticklabels(classes)
+                    ax.set_xlabel("Predicted")
+                    ax.set_ylabel("True")
+                    for i in range(4):
+                        for j in range(4):
+                            ax.text(j, i, str(confmat[i, j]), ha="center", va="center", color="black")
+                    fig_confmat.tight_layout()
+                    # Plot class probabilities
+                    if isinstance(probs, dict):
+                        probs_list = [probs.get(cls, 0.0) for cls in classes]
+                    else:
+                        probs_list = list(probs)
+                    fig_probs, ax_probs = plt.subplots(figsize=(4, 2))
+                    ax_probs.bar(classes, probs_list)
+                    ax_probs.set_ylabel("Probability")
+                    ax_probs.set_ylim(0, 1)
+                    fig_probs.tight_layout()
+                    # EEG plot
+                    fig = create_eeg_plot(epoch_data, selected_movement, predicted_name, confidence, False)
+                    # Close all open figures to avoid warnings
+                    plt.close(fig_confmat)
+                    plt.close(fig_probs)
+                    plt.close(fig)
+                    return predicted_name, f"{confidence:.2f}", fig, fig_probs, fig_confmat
+
+                manual_btn.click(
+                    fn=manual_classify,
+                    inputs=[movement_dropdown],
+                    outputs=[manual_predicted, manual_confidence, manual_plot, manual_probs, manual_confmat]
                 )
-        
-        # Event handlers for automatic composition tab
-        start_btn.click(
-            fn=start_with_timer,
-            outputs=[target_display, predicted_display, timer_display, user_prompt, eeg_plot,
-                    left_hand_sound, right_hand_sound, left_leg_sound, right_leg_sound, composition_status,
-                    building_instructions, dj_instructions, continue_btn, timer]
-        )
-        
-        continue_btn.click(
-            fn=continue_with_timer,
-            outputs=[target_display, predicted_display, timer_display, user_prompt, eeg_plot,
-                    left_hand_sound, right_hand_sound, left_leg_sound, right_leg_sound, composition_status,
-                    building_instructions, dj_instructions, timer, session_complete_row]
-        )
-        
-        # Timer automatically triggers continuation
-        timer.tick(
-            fn=continue_with_timer,
-            outputs=[target_display, predicted_display, timer_display, user_prompt, eeg_plot,
-                    left_hand_sound, right_hand_sound, left_leg_sound, right_leg_sound, composition_status,
-                    building_instructions, dj_instructions, timer, session_complete_row]
-        )
-        
-        # Session completion event handlers
-        new_session_btn.click(
-            fn=start_new_session,
-            outputs=[target_display, predicted_display, timer_display, user_prompt, eeg_plot,
-                    left_hand_sound, right_hand_sound, left_leg_sound, right_leg_sound, composition_status,
-                    building_instructions, dj_instructions, continue_btn, timer, session_complete_row]
-        )
-        
-        extend_session_btn.click(
-            fn=extend_current_session,
-            outputs=[target_display, predicted_display, timer_display, user_prompt, eeg_plot,
-                    left_hand_sound, right_hand_sound, left_leg_sound, right_leg_sound, composition_status,
-                    building_instructions, dj_instructions, continue_btn, timer, session_complete_row]
-        )
-        
-        def stop_with_timer():
-            """Stop composition and deactivate timer"""
-            result = stop_composition()
-            return (
-                result[0],  # target_display
-                result[1],  # predicted_display
-                result[2],  # timer_display
-                result[3],  # user_prompt
-                gr.update(visible=False),  # continue_btn - hide it
-                gr.update(active=False)    # timer - deactivate it
-            )
-        
-        stop_btn.click(
-            fn=stop_with_timer,
-            outputs=[target_display, predicted_display, timer_display, user_prompt, continue_btn, timer]
-        )
-        
-        # Event handlers for manual testing tab
-        classify_btn.click(
-            fn=manual_classify,
-            outputs=[manual_target_display, manual_predicted_display, manual_timer_display, manual_eeg_plot, manual_results,
-                    manual_left_hand_sound, manual_right_hand_sound, manual_left_leg_sound, manual_right_leg_sound]
-        )
-        
-        clear_btn.click(
-            fn=clear_manual,
-            outputs=[manual_target_display, manual_predicted_display, manual_timer_display, manual_eeg_plot, manual_results,
-                    manual_left_hand_sound, manual_right_hand_sound, manual_left_leg_sound, manual_right_leg_sound] 
-        )
-        
-        # Note: No auto-loading of sounds to prevent playing all sounds on startup
-    
     return demo
 
 if __name__ == "__main__":
     demo = create_interface()
-    demo.launch(server_name="0.0.0.0", server_port=7867)
+    demo.launch(server_name="0.0.0.0", server_port=7867)

classifier.py

@@ -8,7 +8,8 @@ Based on the ShallowFBCSPNet architecture from the original eeg_motor_imagery.py
 import torch
 import torch.nn as nn
 import numpy as np
-from braindecode.models import ShallowFBCSPNet
+from braindecode.models.shallow_fbcsp import ShallowFBCSPNet
+from braindecode.modules.layers import Ensure4d  # necessary for loading
 from typing import Dict, Tuple, Optional
 import os
 from sklearn.metrics import accuracy_score
@@ -20,7 +21,7 @@ class MotorImageryClassifier:
     Motor imagery classifier using ShallowFBCSPNet model.
     """
     
-    def __init__(self, model_path: str = "shallow_weights_all.pth"):
+    def __init__(self, model_path: str = "model.pth"):
         self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
         self.model = None
         self.model_path = model_path
@@ -46,8 +47,27 @@ class MotorImageryClassifier:
             
             if os.path.exists(self.model_path):
                 try:
-                    state_dict = torch.load(self.model_path, map_location=self.device)
-                    self.model.load_state_dict(state_dict)
+                    # Load only the state_dict, using weights_only=True and allowlist ShallowFBCSPNet
+                    with torch.serialization.safe_globals([Ensure4d, ShallowFBCSPNet]):
+                        checkpoint = torch.load(
+                        self.model_path,
+                        map_location=self.device,
+                        weights_only=False  # must be False to allow objects
+                    )
+
+                    # If checkpoint is a state_dict (dict of tensors)
+                    if isinstance(checkpoint, dict) and all(isinstance(k, str) for k in checkpoint.keys()):
+                        self.model.load_state_dict(checkpoint)
+
+                    # If checkpoint is the full model object
+                    elif isinstance(checkpoint, ShallowFBCSPNet):
+                        self.model = checkpoint.to(self.device)
+
+                    else:
+                        raise ValueError("Unknown checkpoint format")
+
+
+                    #self.model.load_state_dict(state_dict)
                     self.model.eval()
                     self.is_loaded = True
                     print(f"✅ Pre-trained model loaded successfully from {self.model_path}")

config.py

@@ -16,7 +16,7 @@ SOUND_DIR = BASE_DIR / "sounds"
 MODEL_DIR = BASE_DIR
 
 # Model settings
-MODEL_PATH = MODEL_DIR / "shallow_weights_all.pth"
+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
 

data_processor.py

@@ -81,29 +81,35 @@ class EEGDataProcessor:
         return events
     
     def create_epochs(self, raw: mne.io.RawArray, events: np.ndarray, 
-                     tmin: float = 0, tmax: float = 1.5) -> mne.Epochs:
+                     tmin: float = 0, tmax: float = 1.5, event_id=None) -> mne.Epochs:
         """Create epochs from raw data and events."""
+        if event_id is None:
+             event_id = self.event_id
         epochs = mne.Epochs(
             raw,
             events=events,
-            event_id=self.event_id,
+            event_id=event_id,
             tmin=tmin,
             tmax=tmax,
             baseline=None,
             preload=True,
         )
-        
         return epochs
     
     def process_files(self, file_paths: List[str]) -> Tuple[np.ndarray, np.ndarray]:
         """Process multiple EEG files and return combined data."""
         all_epochs = []
-        
+        allowed_labels = {1, 2, 4, 6}
+        allowed_event_id = {k: v for k, v in self.event_id.items() if v in allowed_labels}
+
         for file_path in file_paths:
             signals, labels, channels, fs = self.load_mat_file(file_path)
             raw = self.create_raw_object(signals, channels, fs, drop_ground_electrodes=True)
             events = self.extract_events(labels)
-            epochs = self.create_epochs(raw, events)
+            # only keep allowed labels
+            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)
         
         if len(all_epochs) > 1:

sound_library.py

@@ -1,803 +0,0 @@
-"""
-Sound Management System for EEG Motor Imagery Classification
------------------------------------------------------------
-Handles sound mapping, layering, and music composition based on motor imagery predictions.
-Uses local SoundHelix audio files for different motor imagery classes.
-"""
-
-import numpy as np
-import soundfile as sf
-import os
-from typing import Dict, List, Optional, Tuple
-import threading
-import time
-from pathlib import Path
-import tempfile
-
-# Professional audio effects processor using scipy and librosa
-from scipy import signal
-import librosa
-
-class AudioEffectsProcessor:
-    @staticmethod
-    def apply_echo(data: np.ndarray, samplerate: int, delay_time: float = 0.3, feedback: float = 0.4) -> np.ndarray:
-        """Echo/delay effect (tempo-sync if delay_time is set to fraction of beat)."""
-        try:
-            delay_samples = int(delay_time * samplerate)
-            echo_data = np.copy(data)
-            for i in range(delay_samples, len(data)):
-                echo_data[i] += feedback * echo_data[i - delay_samples]
-            return 0.7 * data + 0.3 * echo_data
-        except Exception as e:
-            print(f"Echo failed: {e}")
-            return data
-    """Professional audio effects for DJ mode using scipy and librosa."""
-    
-    @staticmethod
-    def apply_high_pass_filter(data: np.ndarray, samplerate: int, cutoff: float = 800.0) -> np.ndarray:
-        """Apply high-pass filter to emphasize highs and cut lows."""
-        try:
-            # Design butterworth high-pass filter
-            nyquist = samplerate / 2
-            normalized_cutoff = cutoff / nyquist
-            b, a = signal.butter(4, normalized_cutoff, btype='high', analog=False)
-            
-            # Apply filter
-            filtered_data = signal.filtfilt(b, a, data)
-            return filtered_data
-        except Exception as e:
-            print(f"High-pass filter failed: {e}")
-            return data
-    
-    @staticmethod
-    def apply_low_pass_filter(data: np.ndarray, samplerate: int, cutoff: float = 1200.0) -> np.ndarray:
-        """Apply low-pass filter to emphasize lows and cut highs."""
-        try:
-            # Design butterworth low-pass filter
-            nyquist = samplerate / 2
-            normalized_cutoff = cutoff / nyquist
-            b, a = signal.butter(4, normalized_cutoff, btype='low', analog=False)
-            
-            # Apply filter
-            filtered_data = signal.filtfilt(b, a, data)
-            return filtered_data
-        except Exception as e:
-            print(f"Low-pass filter failed: {e}")
-            return data
-    
-    @staticmethod
-    def apply_reverb(data: np.ndarray, samplerate: int, room_size: float = 0.5) -> np.ndarray:
-        """Apply simple reverb effect using delay and feedback."""
-        try:
-            # Simple reverb using multiple delayed copies
-            delay_samples = int(0.08 * samplerate)  # 80ms delay
-            decay = 0.4 * room_size 
-            
-            # Create reverb buffer
-            reverb_data = np.copy(data)
-            
-            # Add delayed copies with decay
-            for i in range(3):
-                delay = delay_samples * (i + 1)
-                if delay < len(data):
-                    gain = decay ** (i + 1)
-                    reverb_data[delay:] += data[:-delay] * gain
-            
-            # Mix original with reverb
-            return 0.7 * data + 0.3 * reverb_data
-        except Exception as e:
-            print(f"Reverb effect failed: {e}")
-            return data
-    
-    @staticmethod
-    def apply_echo(data: np.ndarray, samplerate: int, delay_time: float = 0.3, feedback: float = 0.4) -> np.ndarray:
-        """Echo/delay effect (tempo-sync if delay_time is set to fraction of beat)."""
-        try:
-            delay_samples = int(delay_time * samplerate)
-            echo_data = np.copy(data)
-            for i in range(delay_samples, len(data)):
-                echo_data[i] += feedback * echo_data[i - delay_samples]
-            return 0.7 * data + 0.3 * echo_data
-        except Exception as e:
-            print(f"Echo failed: {e}")
-            return data
-    
-    @staticmethod
-    def apply_bass_boost(data: np.ndarray, samplerate: int, boost_db: float = 6.0) -> np.ndarray:
-        """Apply bass boost using low-frequency shelving filter."""
-        try:
-            # Design low-shelf filter for bass boost
-            freq = 200.0  # Bass frequency cutoff
-            nyquist = samplerate / 2
-            normalized_freq = freq / nyquist
-            
-            # Convert dB to linear gain
-            gain = 10 ** (boost_db / 20)
-            
-            # Simple bass boost: amplify low frequencies
-            b, a = signal.butter(2, normalized_freq, btype='low', analog=False)
-            low_freq = signal.filtfilt(b, a, data)
-            
-            # Mix boosted lows with original
-            boosted_data = data + (low_freq * (gain - 1))
-            
-            # Normalize to prevent clipping
-            max_val = np.max(np.abs(boosted_data))
-            if max_val > 0.95:
-                boosted_data = boosted_data * 0.95 / max_val
-            
-            return boosted_data
-        except Exception as e:
-            print(f"Bass boost failed: {e}")
-            return data
-    
-    # --- DJ MODE WRAPPER ---
-    @staticmethod
-    def process_layer_with_effects(audio_file: str, movement: str, active_effects: Dict[str, bool]) -> str:
-        """Process a single layer with its corresponding DJ effect if active."""
-        try:
-            if not audio_file or not os.path.exists(audio_file):
-                print(f"Invalid audio file: {audio_file}")
-                return audio_file
-            data, samplerate = sf.read(audio_file)
-            if len(data.shape) > 1:
-                data = np.mean(data, axis=1)
-            processed_data = np.copy(data)
-
-            # Map movement to effect
-            effect_map = {
-                "left_hand": AudioEffectsProcessor.apply_echo,
-                "right_hand": AudioEffectsProcessor.apply_high_pass_filter,
-                "left_leg": AudioEffectsProcessor.apply_reverb,
-                "right_leg": AudioEffectsProcessor.apply_low_pass_filter,
-            }
-            effect_names = {
-                "left_hand": "echo",
-                "right_hand": "hpf",
-                "left_leg": "rev",
-                "right_leg": "lpf",
-            }
-            effect_func = effect_map.get(movement)
-            effect_name = effect_names.get(movement, "clean")
-            if active_effects.get(movement, False) and effect_func:
-                processed_data = effect_func(processed_data, samplerate)
-                suffix = f"_fx_{effect_name}"
-            else:
-                suffix = "_fx_clean"
-
-            base_name = os.path.splitext(audio_file)[0]
-            processed_file = f"{base_name}{suffix}.wav"
-            try:
-                sf.write(processed_file, processed_data, samplerate)
-                print(f"🎛️ Layer processed: {os.path.basename(processed_file)}")
-                return os.path.abspath(processed_file)
-            except Exception as e:
-                print(f"Failed to save processed layer: {e}")
-                return os.path.abspath(audio_file)
-        except Exception as e:
-            print(f"Layer processing failed: {e}")
-            return os.path.abspath(audio_file) if audio_file else None
-
-class SoundManager:
-    """
-    Manages cyclic sound composition for motor imagery classification.
-    Supports full-cycle composition with user-customizable movement-sound mappings.
-    """
-    
-    def __init__(self, sound_dir: str = "sounds", include_neutral_in_cycle: bool = False):
-            # Available sound files (define FIRST)
-            self.available_sounds = [
-                "1_SoundHelix-Song-6_(Bass).wav",
-                "1_SoundHelix-Song-6_(Drums).wav", 
-                "1_SoundHelix-Song-6_(Other).wav",
-                "1_SoundHelix-Song-6_(Vocals).wav"
-            ]
-
-            self.sound_dir = Path(sound_dir)
-            self.include_neutral_in_cycle = include_neutral_in_cycle
-            
-            # Composition state
-            self.composition_layers = []  # All layers across all cycles
-            self.current_cycle = 0
-            self.current_step = 0  # Current step within cycle (0-5)
-            self.cycle_complete = False
-            self.completed_cycles = 0  # Track completed cycles for session management
-            self.max_cycles = 2  # Rehabilitation session limit
-            
-            # DJ Effects phase management
-            self.current_phase = "building"  # "building" or "dj_effects"
-            # self.mixed_composition_file = None  # Path to current mixed composition
-            self.active_effects = {  # Track which effects are currently active
-                "left_hand": False,    # Volume fade
-                "right_hand": False,   # Filter sweep
-                "left_leg": False,     # Reverb
-                "right_leg": False,    # Tempo modulation  
-                #"tongue": False        # Bass boost
-            }
-        
-            # All possible movements (neutral is optional for composition)
-            self.all_movements = ["left_hand", "right_hand", "neutral", "left_leg", "tongue", "right_leg"]
-            
-            # Active movements that contribute to composition (excluding neutral and tongue)
-            self.active_movements = ["left_hand", "right_hand", "left_leg", "right_leg"]
-            
-            # Current cycle's random movement sequence (shuffled each cycle)
-            self.current_movement_sequence = []
-            self.movements_completed = set()  # Track which movements have been successfully completed
-            self._generate_new_sequence()
-            
-            # User-customizable sound mapping (can be updated after each cycle)
-            # Assign each movement a unique sound file from available_sounds
-            import random
-            movements = ["left_hand", "right_hand", "left_leg", "right_leg"]
-            sounds = self.available_sounds.copy()
-            random.shuffle(sounds)
-            self.current_sound_mapping = {movement: sound for movement, sound in zip(movements, sounds)}
-            self.current_sound_mapping["neutral"] = None  # No sound for neutral/rest state
-            
-            # Available sound files
-            self.available_sounds = [
-                "1_SoundHelix-Song-6_(Bass).wav",
-                "1_SoundHelix-Song-6_(Drums).wav", 
-                "1_SoundHelix-Song-6_(Other).wav",
-                "1_SoundHelix-Song-6_(Vocals).wav"
-            ]
-            
-            # Load sound files
-            self.loaded_sounds = {}
-            self._load_sound_files()
-            
-            # Cycle statistics
-            self.cycle_stats = {
-                'total_cycles': 0,
-                'successful_classifications': 0,
-                'total_attempts': 0
-            }
-        
-    def _load_sound_files(self):
-        """Load all available sound files into memory."""
-        for class_name, filename in self.current_sound_mapping.items():
-            if filename is None:
-                continue
-                
-            file_path = self.sound_dir / filename
-            if file_path.exists():
-                try:
-                    data, sample_rate = sf.read(str(file_path))
-                    self.loaded_sounds[class_name] = {
-                        'data': data,
-                        'sample_rate': sample_rate,
-                        'file_path': str(file_path)
-                    }
-                    print(f"Loaded sound for {class_name}: {filename}")
-                except Exception as e:
-                    print(f"Error loading {filename}: {e}")
-            else:
-                print(f"Sound file not found: {file_path}")
-    
-    def get_sound_for_class(self, class_name: str) -> Optional[Dict]:
-        """Get sound data for a specific motor imagery class."""
-        return self.loaded_sounds.get(class_name)
-    
-    def _generate_new_sequence(self):
-        """Generate a new random sequence of movements for the current cycle."""
-        import random
-        # Choose which movements to include based on configuration
-        # Always use exactly 5 movements per cycle
-        movements_for_cycle = self.active_movements.copy()
-        random.shuffle(movements_for_cycle)
-        self.current_movement_sequence = movements_for_cycle[:5]
-        self.movements_completed = set()
-        cycle_size = len(self.current_movement_sequence)
-        print(f"🎯 New random sequence ({cycle_size} movements): {' → '.join([m.replace('_', ' ').title() for m in self.current_movement_sequence])}")
-        print(f"DEBUG: Movement sequence length = {len(self.current_movement_sequence)}")
-    
-    def get_current_target_movement(self) -> str:
-        """Get the current movement the user should imagine."""
-        if self.current_step < len(self.current_movement_sequence):
-            return self.current_movement_sequence[self.current_step]
-        return "cycle_complete"
-    
-    def get_next_random_movement(self) -> str:
-        """Get a random movement from those not yet completed in this cycle."""
-        # Use the same movement set as the current cycle
-        cycle_movements = self.all_movements if self.include_neutral_in_cycle else self.active_movements
-        remaining_movements = [m for m in cycle_movements if m not in self.movements_completed]
-        if not remaining_movements:
-            return "cycle_complete"
-        
-        import random
-        return random.choice(remaining_movements)
-    
-    def process_classification(self, predicted_class: str, confidence: float, threshold: float = 0.7) -> Dict:
-        """
-        Process a classification result in the context of the current cycle.
-        Uses random movement prompting - user can choose any movement at any time.
-        
-        Args:
-            predicted_class: The predicted motor imagery class
-            confidence: Confidence score
-            threshold: Minimum confidence to add sound layer
-            
-        Returns:
-            Dictionary with processing results and next action
-        """
-        self.cycle_stats['total_attempts'] += 1
-        
-        # Check if this movement was already completed in this cycle
-        already_completed = predicted_class in self.movements_completed
-        
-        result = {
-            'predicted_class': predicted_class,
-            'confidence': confidence,
-            'above_threshold': confidence >= threshold,
-            'already_completed': already_completed,
-            'sound_added': False,
-            'cycle_complete': False,
-            'next_action': 'continue',
-            'movements_remaining': len(self.current_movement_sequence) - len(self.movements_completed),
-            'movements_completed': list(self.movements_completed)
-        }
-        
-        # Check if prediction is above threshold and not already completed
-        if result['above_threshold'] and not already_completed:
-            # Get sound file for this movement
-            sound_file = self.current_sound_mapping.get(predicted_class)
-            
-            if sound_file is None:
-                # No sound for this movement (e.g., neutral), but still count as completed
-                self.movements_completed.add(predicted_class)
-                result['sound_added'] = False  # No sound, but movement completed
-                self.cycle_stats['successful_classifications'] += 1
-                cycle_size = len(self.current_movement_sequence)
-                print(f"✓ Cycle {self.current_cycle+1}: {predicted_class} completed (no sound) ({len(self.movements_completed)}/{cycle_size} complete)")
-            elif predicted_class in self.loaded_sounds:
-                # Add sound layer
-                layer_info = {
-                    'cycle': self.current_cycle,
-                    'step': len(self.movements_completed),  # Step based on number completed
-                    'movement': predicted_class,
-                    'sound_file': sound_file,
-                    'confidence': confidence,
-                    'timestamp': time.time(),
-                    'sound_data': self.loaded_sounds[predicted_class]
-                }
-                self.composition_layers.append(layer_info)
-                self.movements_completed.add(predicted_class)
-                result['sound_added'] = True
-                
-                print(f"DEBUG: Added layer {len(self.composition_layers)}, total layers now: {len(self.composition_layers)}")
-                print(f"DEBUG: Composition layers: {[layer['movement'] for layer in self.composition_layers]}")
-                
-                # Return individual sound file for this classification
-                sound_path = os.path.join(self.sound_dir, sound_file)
-                result['audio_file'] = sound_path if os.path.exists(sound_path) else None
-                
-                # Also create mixed composition for potential saving (but don't return it)
-                mixed_file = self.get_current_mixed_composition()
-                result['mixed_composition'] = mixed_file
-                
-                self.cycle_stats['successful_classifications'] += 1
-                cycle_size = len(self.current_movement_sequence)
-                print(f"✓ Cycle {self.current_cycle+1}: Added {sound_file} for {predicted_class} ({len(self.movements_completed)}/{cycle_size} complete)")
-        
-        # Check if cycle is complete (all movements in current sequence completed)
-        cycle_movements = self.all_movements if self.include_neutral_in_cycle else self.active_movements
-        if len(self.movements_completed) >= len(cycle_movements):
-            result['cycle_complete'] = True
-            result['next_action'] = 'remap_sounds'
-            self.cycle_complete = True
-            cycle_size = len(cycle_movements)
-            print(f"🎵 Cycle {self.current_cycle+1} complete! All {cycle_size} movements successfully classified!")
-        
-        return result
-    
-    def start_new_cycle(self, new_sound_mapping: Dict[str, str] = None):
-        """Start a new composition cycle with optional new sound mapping."""
-        if new_sound_mapping:
-            self.current_sound_mapping.update(new_sound_mapping)
-            print(f"Updated sound mapping for cycle {self.current_cycle+2}")
-        
-        self.current_cycle += 1
-        self.current_step = 0
-        self.cycle_complete = False
-        self.cycle_stats['total_cycles'] += 1
-        
-        # Generate new random sequence for this cycle
-        self._generate_new_sequence()
-        
-        print(f"🔄 Starting Cycle {self.current_cycle+1}")
-        if self.current_cycle == 1:
-            print("💪 Let's create your first brain-music composition!")
-        elif self.current_cycle == 2:
-            print("� Great progress! Let's create your second composition!")
-        else:
-            print("�🎯 Imagine ANY movement - you can choose the order!")
-    
-    def should_end_session(self) -> bool:
-        """Check if the rehabilitation session should end after max cycles."""
-        return self.completed_cycles >= self.max_cycles
-    
-    def complete_current_cycle(self):
-        """Mark current cycle as complete and track progress."""
-        self.completed_cycles += 1
-        print(f"✅ Cycle {self.current_cycle} completed! ({self.completed_cycles}/{self.max_cycles} compositions finished)")
-    
-    def transition_to_dj_phase(self):
-        """Transition from building phase to DJ effects phase."""
-        # Only start DJ mode if all 4 sound layers are present (not just movements completed)
-        unique_sounds = set()
-        for layer in self.composition_layers:
-            if layer.get('sound_file'):
-                unique_sounds.add(layer['sound_file'])
-        print(f"DEBUG: Unique sound files in composition_layers: {unique_sounds}")
-        print(f"DEBUG: Number of unique sounds: {len(unique_sounds)}")
-        if len(unique_sounds) >= 4:
-            self.current_phase = "dj_effects"
-            # self._create_mixed_composition() 
-            # just keep current stems running
-            print("🎵 Composition Complete! Transitioning to DJ Effects Phase...")
-            print("🎧 You are now the DJ! Use movements to control effects:")
-            print("   👈 Left Hand: Volume Fade")
-            print("   👉 Right Hand: High Pass Filter") 
-            print("   🦵 Left Leg: Reverb Effect")
-            print("   🦵 Right Leg: Low Pass Filter")
-            #print("   👅 Tongue: Bass Boost")
-            return True
-        else:
-            print("DEBUG: Not enough unique sounds to transition to DJ mode.")
-        return False
-    
-    # def _create_mixed_composition(self):
-    #     """Create a mixed audio file from all completed layers."""
-    #     try:
-    #         import hashlib
-    #         movement_hash = hashlib.md5(str(sorted(self.movements_completed)).encode()).hexdigest()[:8]
-    #         self.mixed_composition_file = os.path.abspath(f"mixed_composition_{movement_hash}.wav")
-            
-    #         # Try to use the first available completed movement's audio file
-    #         for movement in self.movements_completed:
-    #             if movement in self.current_sound_mapping and self.current_sound_mapping[movement] is not None:
-    #                 sound_file = os.path.join(self.sound_dir, self.current_sound_mapping[movement])
-    #                 if os.path.exists(sound_file):
-    #                     self.mixed_composition_file = os.path.abspath(sound_file)
-    #                     print(f"📀 Using existing audio as mixed composition: {self.mixed_composition_file}")
-    #                     return
-            
-    #         # If file already exists, use it
-    #         if os.path.exists(self.mixed_composition_file):
-    #             print(f"📀 Using existing mixed composition: {self.mixed_composition_file}")
-    #             return
-            
-    #         # Create actual mixed composition by layering completed sounds
-    #         mixed_data = None
-    #         sample_rate = 44100  # Default sample rate
-            
-    #         for movement in self.movements_completed:
-    #             if movement in self.current_sound_mapping and self.current_sound_mapping[movement] is not None:
-    #                 sound_file = os.path.join(self.sound_dir, self.current_sound_mapping[movement])
-    #                 if os.path.exists(sound_file):
-    #                     try:
-    #                         data, sr = sf.read(sound_file)
-    #                         sample_rate = sr
-                            
-    #                         # Convert stereo to mono
-    #                         if len(data.shape) > 1:
-    #                             data = np.mean(data, axis=1)
-                            
-    #                         # Initialize or add to mixed data
-    #                         if mixed_data is None:
-    #                             mixed_data = data * 0.8  # Reduce volume to prevent clipping
-    #                         else:
-    #                             # Ensure same length by padding shorter audio
-    #                             if len(data) > len(mixed_data):
-    #                                 mixed_data = np.pad(mixed_data, (0, len(data) - len(mixed_data)))
-    #                             elif len(mixed_data) > len(data):
-    #                                 data = np.pad(data, (0, len(mixed_data) - len(data)))
-                                
-    #                             # Mix the audio (layer them)
-    #                             mixed_data += data * 0.8
-    #                     except Exception as e:
-    #                         print(f"Error mixing {sound_file}: {e}")
-            
-    #         # Save mixed composition or create silent fallback
-    #         if mixed_data is not None:
-    #             # Normalize to prevent clipping
-    #             max_val = np.max(np.abs(mixed_data))
-    #             if max_val > 0.95:
-    #                 mixed_data = mixed_data * 0.95 / max_val
-                
-    #             sf.write(self.mixed_composition_file, mixed_data, sample_rate)
-    #             print(f"📀 Mixed composition created: {self.mixed_composition_file} (FILE SAVING ENABLED)")
-    #         else:
-    #             # Create silent fallback file
-    #             silent_data = np.zeros(int(sample_rate * 2))  # 2 seconds of silence
-    #             sf.write(self.mixed_composition_file, silent_data, sample_rate)
-    #             print(f"📀 Silent fallback composition created: {self.mixed_composition_file}")
-                
-    #     except Exception as e:
-    #         print(f"Error creating mixed composition: {e}")
-    #         # Create minimal fallback file with actual content
-    #         self.mixed_composition_file = os.path.abspath("mixed_composition_fallback.wav")
-    #         try:
-    #             # Create a short silent audio file as fallback
-    #             sample_rate = 44100
-    #             silent_data = np.zeros(int(sample_rate * 2))  # 2 seconds of silence
-    #             sf.write(self.mixed_composition_file, silent_data, sample_rate)
-    #             print(f"📀 Silent fallback composition created: {self.mixed_composition_file}")
-    #         except Exception as fallback_error:
-    #             print(f"Failed to create fallback file: {fallback_error}")
-    #             self.mixed_composition_file = None
-    
-    def toggle_dj_effect(self, movement: str) -> dict:
-        """Toggle a DJ effect for the given movement and process the corresponding layer."""
-        if self.current_phase != "dj_effects":
-            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}"}
-
-        # Toggle effect
-        self.active_effects[movement] = not self.active_effects[movement]
-        effect_status = "ON" if self.active_effects[movement] else "OFF"
-        effect_names = {
-            "left_hand": "Echo",
-            "right_hand": "High Pass Filter",
-            "left_leg": "Reverb Effect",
-            "right_leg": "Low Pass Filter",
-        }
-        effect_name = effect_names.get(movement, movement)
-        print(f"🎛️ {effect_name}: {effect_status}")
-
-        # Find the audio file for this movement
-        sound_file = self.current_sound_mapping.get(movement)
-        audio_path = os.path.join(self.sound_dir, sound_file) if sound_file else None
-        processed_file = None
-        if audio_path and os.path.exists(audio_path):
-            processed_file = AudioEffectsProcessor.process_layer_with_effects(
-                audio_path, movement, self.active_effects
-            )
-        else:
-            print(f"No audio file found for movement: {movement}")
-            processed_file = None
-
-        # For DJ phase, always play all base layers (with effects if toggled)
-        all_layers = {}
-        for m in self.active_movements:
-            sf_name = self.current_sound_mapping.get(m)
-            apath = os.path.join(self.sound_dir, sf_name) if sf_name else None
-            if apath and os.path.exists(apath):
-                all_layers[m] = AudioEffectsProcessor.process_layer_with_effects(
-                    apath, m, self.active_effects
-                )
-        return {
-            "effect_applied": True,
-            "effect_name": effect_name,
-            "effect_status": effect_status,
-            "processed_layer": processed_file,
-            "all_layers": all_layers
-        }
-        
-    def get_cycle_success_rate(self) -> float:
-        """Get success rate for current cycle."""
-        if self.cycle_stats['total_attempts'] == 0:
-            return 0.0
-        return self.cycle_stats['successful_classifications'] / self.cycle_stats['total_attempts']
-    
-    def clear_composition(self):
-        """Clear all composition layers."""
-        self.composition_layers = []
-        self.current_composition = None
-        print("Composition cleared")
-    
-    def _get_audio_file_for_gradio(self, movement):
-        """Get the actual audio file path for Gradio audio output"""
-        if movement in self.current_sound_mapping:
-            sound_file = self.current_sound_mapping[movement]
-            audio_path = os.path.join(self.sound_dir, sound_file)
-            if os.path.exists(audio_path):
-                return audio_path
-        return None
-
-    def _mix_audio_files(self, audio_files: List[str]) -> str:
-        """Mix multiple audio files into a single layered audio file."""
-        if not audio_files:
-            return None
-            
-        # Load all audio files and convert to mono
-        audio_data_list = []
-        sample_rate = None
-        max_length = 0
-        
-        for file_path in audio_files:
-            if os.path.exists(file_path):
-                data, sr = sf.read(file_path)
-                
-                # Ensure data is numpy array and handle shape properly
-                data = np.asarray(data)
-                
-                # Convert to mono if stereo/multi-channel
-                if data.ndim > 1:
-                    if data.shape[1] > 1:  # Multi-channel
-                        data = np.mean(data, axis=1)
-                    else:  # Single channel with extra dimension
-                        data = data.flatten()
-                
-                # Ensure final data is 1D
-                data = np.asarray(data).flatten()
-                
-                audio_data_list.append(data)
-                if sample_rate is None:
-                    sample_rate = sr
-                max_length = max(max_length, len(data))
-        
-        if not audio_data_list:
-            return None
-        
-        # Pad all audio to same length and mix
-        mixed_audio = np.zeros(max_length)
-        for data in audio_data_list:
-            # Ensure data is 1D (flatten any remaining multi-dimensional arrays)
-            data_flat = np.asarray(data).flatten()
-            
-            # Pad or truncate to match max_length
-            if len(data_flat) < max_length:
-                padded = np.pad(data_flat, (0, max_length - len(data_flat)), 'constant')
-            else:
-                padded = data_flat[:max_length]
-            
-            # Add to mix (normalize to prevent clipping)
-            mixed_audio += padded / len(audio_data_list)
-        
-        # Create a unique identifier for this composition
-        import hashlib
-        composition_hash = hashlib.md5(''.join(sorted(audio_files)).encode()).hexdigest()[:8]
-
-        # FILE SAVING ENABLED: Return first available audio file instead of creating mixed composition
-        mixed_audio_path = os.path.join(self.sound_dir, f"mixed_composition_{composition_hash}.wav")
-        
-        # Since file saving is disabled, use the first available audio file from the list
-        if audio_files:
-            # Use the first audio file as the "mixed" composition
-            first_audio_file = os.path.join(self.sound_dir, audio_files[0])
-            if os.path.exists(first_audio_file):
-                print(f"DEBUG: Using first audio file as mixed composition: {os.path.basename(first_audio_file)}")
-                # Estimate BPM from the mixed composition audio file
-                try:
-                    import librosa
-                    y, sr = librosa.load(first_audio_file, sr=None)
-                    tempo, _ = librosa.beat.beat_track(y=y, sr=sr)
-                    self.bpm = int(tempo)
-                    print(f"Estimated BPM from track: {self.bpm}")
-                except Exception as e:
-                    print(f"Could not estimate BPM: {e}")
-                return first_audio_file
-        
-        # Fallback: if mixed composition file already exists, use it
-        if os.path.exists(mixed_audio_path):
-            print(f"DEBUG: Reusing existing mixed audio file: {os.path.basename(mixed_audio_path)}")
-            return mixed_audio_path
-        
-        # Final fallback: return first available base audio file
-        base_files = ["1_SoundHelix-Song-6_(Vocals).wav", "1_SoundHelix-Song-6_(Drums).wav", "1_SoundHelix-Song-6_(Bass).wav", "1_SoundHelix-Song-6_(Other).wav"]
-        for base_file in base_files:
-            base_path = os.path.join(self.sound_dir, base_file)
-            if os.path.exists(base_path):
-                print(f"DEBUG: Using base audio file as fallback: {base_file} (FILE SAVING DISABLED)")
-                return base_path
-        
-        return mixed_audio_path
-
-    def get_current_mixed_composition(self) -> str:
-        """Get the current composition as a mixed audio file."""
-        # Get all audio files from current composition layers
-        audio_files = []
-        for layer in self.composition_layers:
-            movement = layer.get('movement')
-            if movement and movement in self.current_sound_mapping:
-                sound_file = self.current_sound_mapping[movement]
-                audio_path = os.path.join(self.sound_dir, sound_file)
-                if os.path.exists(audio_path):
-                    audio_files.append(audio_path)
-        
-        # Debug: print current composition state
-        print(f"DEBUG: Current composition has {len(self.composition_layers)} layers: {[layer.get('movement') for layer in self.composition_layers]}")
-        print(f"DEBUG: Audio files to mix: {[os.path.basename(f) for f in audio_files]}")
-        
-        return self._mix_audio_files(audio_files)
-
-    def get_composition_info(self) -> Dict:
-        """Get comprehensive information about current composition."""
-        layers_by_cycle = {}
-        for layer in self.composition_layers:
-            cycle = layer['cycle']
-            if cycle not in layers_by_cycle:
-                layers_by_cycle[cycle] = []
-            layers_by_cycle[cycle].append({
-                'step': layer['step'],
-                'movement': layer['movement'], 
-                'sound_file': layer['sound_file'],
-                'confidence': layer['confidence']
-            })
-        
-        # Also track completed movements without sounds (like neutral)
-        completed_without_sound = [mov for mov in self.movements_completed 
-                                 if self.current_sound_mapping.get(mov) is None]
-        
-        return {
-            'total_cycles': self.current_cycle + (1 if self.composition_layers else 0),
-            'current_cycle': self.current_cycle + 1,
-            'current_step': len(self.movements_completed) + 1,  # Current step in cycle
-            'target_movement': self.get_current_target_movement(),
-            'movements_completed': len(self.movements_completed),
-            'movements_remaining': len(self.current_movement_sequence) - len(self.movements_completed),
-            'cycle_complete': self.cycle_complete,
-            'total_layers': len(self.composition_layers),
-            'completed_movements': list(self.movements_completed),
-            'completed_without_sound': completed_without_sound,
-            'layers_by_cycle': layers_by_cycle,
-            'current_mapping': self.current_sound_mapping.copy(),
-            'success_rate': self.get_cycle_success_rate(),
-            'stats': self.cycle_stats.copy()
-        }
-    
-    def get_sound_mapping_options(self) -> Dict:
-        """Get available sound mapping options for user customization."""
-        return {
-            'movements': self.all_movements,  # All possible movements for mapping
-            'available_sounds': self.available_sounds,
-            'current_mapping': self.current_sound_mapping.copy()
-        }
-    
-    def update_sound_mapping(self, new_mapping: Dict[str, str]) -> bool:
-        """Update the sound mapping for future cycles."""
-        try:
-            # Validate that all sounds exist
-            for movement, sound_file in new_mapping.items():
-                if sound_file not in self.available_sounds:
-                    print(f"Warning: Sound file {sound_file} not available")
-                    return False
-                    
-            self.current_sound_mapping.update(new_mapping)
-            print("✓ Sound mapping updated successfully")
-            return True
-        except Exception as e:
-            print(f"Error updating sound mapping: {e}")
-            return False
-    
-    def reset_composition(self):
-        """Reset the entire composition to start fresh."""
-        self.composition_layers = []
-        self.current_cycle = 0
-        self.current_step = 0
-        self.cycle_complete = False
-        self.cycle_stats = {
-            'total_cycles': 0,
-            'successful_classifications': 0,
-            'total_attempts': 0
-        }
-        print("🔄 Composition reset - ready for new session")
-    
-    def save_composition(self, output_path: str = "composition.wav"):
-        """Save the current composition as a mixed audio file."""
-        if not self.composition_layers:
-            print("No layers to save")
-            return False
-            
-        try:
-            # For simplicity, we'll just save the latest layer
-            # In a real implementation, you'd mix multiple audio tracks
-            latest_layer = self.composition_layers[-1]
-            sound_data = latest_layer['sound_data']
-            
-            sf.write(output_path, sound_data['data'], sound_data['sample_rate'])
-            print(f"Composition saved to {output_path}")
-            return True
-            
-        except Exception as e:
-            print(f"Error saving composition: {e}")
-            return False
-    
-    def get_available_sounds(self) -> List[str]:
-        """Get list of available sound classes."""
-        return list(self.loaded_sounds.keys())

sound_manager.py

@@ -0,0 +1,237 @@
+"""
+Sound Management System for EEG Motor Imagery Classification (Clean Transition Version)
+-------------------------------------------------------------------------------
+Handles sound mapping, layering, and music composition based on motor imagery predictions.
+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 pathlib import Path
+
+class AudioEffectsProcessor:
+    @staticmethod
+    def apply_high_pass_filter(data: np.ndarray, samplerate: int, cutoff: float = 800.0) -> np.ndarray:
+        from scipy import signal
+        nyquist = samplerate / 2
+        normalized_cutoff = cutoff / nyquist
+        b, a = signal.butter(4, normalized_cutoff, btype='high', analog=False)
+        return signal.filtfilt(b, a, data)
+
+    @staticmethod
+    def apply_low_pass_filter(data: np.ndarray, samplerate: int, cutoff: float = 1200.0) -> np.ndarray:
+        from scipy import signal
+        nyquist = samplerate / 2
+        normalized_cutoff = cutoff / nyquist
+        b, a = signal.butter(4, normalized_cutoff, btype='low', analog=False)
+        return signal.filtfilt(b, a, data)
+
+    @staticmethod
+    def apply_reverb(data: np.ndarray, samplerate: int, room_size: float = 0.5) -> np.ndarray:
+        delay_samples = int(0.08 * samplerate)
+        decay = 0.4 * room_size
+        reverb_data = np.copy(data)
+        for i in range(3):
+            delay = delay_samples * (i + 1)
+            if delay < len(data):
+                gain = decay ** (i + 1)
+                reverb_data[delay:] += data[:-delay] * gain
+        return 0.7 * data + 0.3 * reverb_data
+
+    @staticmethod
+    def apply_echo(data: np.ndarray, samplerate: int, delay_time: float = 0.3, feedback: float = 0.4) -> np.ndarray:
+        delay_samples = int(delay_time * samplerate)
+        echo_data = np.copy(data)
+        for i in range(delay_samples, len(data)):
+            echo_data[i] += feedback * echo_data[i - delay_samples]
+        return 0.7 * data + 0.3 * echo_data
+
+    @staticmethod
+    def apply_compressor(data: np.ndarray, samplerate: int, threshold: float = 0.2, ratio: float = 4.0) -> np.ndarray:
+        # Simple compressor: reduce gain above threshold
+        compressed = np.copy(data)
+        over_threshold = np.abs(compressed) > threshold
+        compressed[over_threshold] = np.sign(compressed[over_threshold]) * (threshold + (np.abs(compressed[over_threshold]) - threshold) / ratio)
+        return compressed
+
+    @staticmethod
+    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
+            "right_hand": AudioEffectsProcessor.apply_low_pass_filter, # Low Pass
+            "left_leg": AudioEffectsProcessor.apply_compressor,     # Compressor
+            "right_leg": AudioEffectsProcessor.apply_high_pass_filter, # High Pass
+        }
+        effect_func = effect_map.get(movement)
+        if active_effects.get(movement, False) and effect_func:
+            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"
+        ]
+        self.sound_dir = Path(sound_dir)
+        self.current_cycle = 0
+        self.current_step = 0
+        self.cycle_complete = False
+        self.completed_cycles = 0
+        self.max_cycles = 2
+        self.composition_layers = {}
+        self.current_phase = "building"
+        self.active_effects = {m: False for m in ["left_hand", "right_hand", "left_leg", "right_leg"]}
+        self.active_movements = ["left_hand", "right_hand", "left_leg", "right_leg"]
+        self.current_movement_sequence = []
+        self.movements_completed = set()
+        self.active_layers: Dict[str, str] = {}
+        self.loaded_sounds = {}
+        self._generate_new_sequence()
+        self._load_sound_files()
+        # Provide mapping from movement to sound file name for compatibility
+        self.current_sound_mapping = {m: f for m, f in zip(self.active_movements, self.available_sounds)}
+        # Track DJ effect trigger counts for each movement
+        self.dj_effect_counters = {m: 0 for m in self.active_movements}
+        self.cycle_stats = {'total_cycles': 0, 'successful_classifications': 0, 'total_attempts': 0}
+
+    def _load_sound_files(self):
+        self.loaded_sounds = {}
+        for movement, filename in self.current_sound_mapping.items():
+            file_path = self.sound_dir / filename
+            if file_path.exists():
+                data, sample_rate = sf.read(str(file_path))
+                if len(data.shape) > 1:
+                    data = np.mean(data, axis=1)
+                self.loaded_sounds[movement] = {'data': data, 'sample_rate': sample_rate, 'sound_file': str(file_path)}
+
+    def _generate_new_sequence(self):
+        # Fixed movement order and mapping
+        self.current_movement_sequence = ["left_hand", "right_hand", "left_leg", "right_leg"]
+        self.current_sound_mapping = {
+            "left_hand": "SoundHelix-Song-4_instruments.wav",
+            "right_hand": "SoundHelix-Song-4_bass.wav",
+            "left_leg": "SoundHelix-Song-4_drums.wav",
+            "right_leg": "SoundHelix-Song-4_vocals.wav"
+        }
+        print(f"DEBUG: Fixed sound mapping for this cycle: {self.current_sound_mapping}")
+        self.movements_completed = set()
+        self.current_step = 0
+        self._load_sound_files()
+
+    def get_current_target_movement(self) -> str:
+        # Randomly select a movement from those not yet completed
+        import random
+        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"
+        movement = random.choice(incomplete)
+        print(f"DEBUG: Next target is {movement}, completed: {self.movements_completed}")
+        return movement
+
+
+    def process_classification(self, predicted_class: str, confidence: float, threshold: float = 0.7, force_add: bool = False) -> Dict:
+        result = {'sound_added': False, 'cycle_complete': False, 'audio_file': None}
+        # If force_add is True, allow adding sound for any valid movement not already completed
+        if force_add:
+            if (
+                confidence >= threshold and
+                predicted_class in self.loaded_sounds and
+                predicted_class not in self.composition_layers
+            ):
+                print(f"DEBUG: [FORCE] Adding sound for {predicted_class}")
+                sound_info = dict(self.loaded_sounds[predicted_class])
+                sound_info['confidence'] = confidence
+                self.composition_layers[predicted_class] = sound_info
+                self.movements_completed.add(predicted_class)
+                result['sound_added'] = True
+            else:
+                print("DEBUG: [FORCE] Not adding sound. Condition failed.")
+        else:
+            current_target = self.get_current_target_movement()
+            print(f"DEBUG: process_classification: predicted={predicted_class}, target={current_target}, confidence={confidence}, completed={self.movements_completed}")
+            if (
+                predicted_class == current_target and
+                confidence >= threshold and
+                predicted_class in self.loaded_sounds and
+                predicted_class not in self.composition_layers
+            ):
+                print(f"DEBUG: Adding sound for {predicted_class} (target={current_target})")
+                sound_info = dict(self.loaded_sounds[predicted_class])
+                sound_info['confidence'] = confidence
+                self.composition_layers[predicted_class] = sound_info
+                self.movements_completed.add(predicted_class)
+                result['sound_added'] = True
+            else:
+                print("DEBUG: Not adding sound. Condition failed.")
+        if len(self.movements_completed) >= len(self.active_movements):
+            result['cycle_complete'] = True
+            self.current_phase = "dj_effects"
+        return result
+
+    def start_new_cycle(self):
+        self.current_cycle += 1
+        self.current_step = 0
+        self.cycle_complete = False
+        self.cycle_stats['total_cycles'] += 1
+        self._generate_new_sequence()
+        self.composition_layers = {}  # Clear layers for new cycle
+        self.movements_completed = set()
+        self.current_phase = "building"
+        self.active_layers = {}
+
+    def transition_to_dj_phase(self):
+        if len(self.composition_layers) >= len(self.active_movements):
+            self.current_phase = "dj_effects"
+            return True
+        return False
+
+    def toggle_dj_effect(self, movement: str, brief: bool = True, duration: float = 1.0) -> dict:
+        import threading
+        if self.current_phase != "dj_effects":
+            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
+        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]})"}
+        # Toggle effect ON
+        self.active_effects[movement] = True
+        effect_status = "ON"
+        print(f"🎛️ {movement}: {effect_status} (brief={brief}) [count={self.dj_effect_counters[movement]}]")
+        # Schedule effect OFF after duration if brief
+        def turn_off_effect():
+            self.active_effects[movement] = False
+            print(f"🎛️ {movement}: OFF (auto)")
+        if brief:
+            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]}
+
+    def get_composition_info(self) -> Dict:
+        layers_by_cycle = {0: []}
+        for movement, layer_info in self.composition_layers.items():
+            confidence = layer_info.get('confidence', 0) if isinstance(layer_info, dict) else 0
+            layers_by_cycle[0].append({'movement': movement, 'confidence': confidence})
+        # Add DJ effect status for each movement
+        dj_effects_status = {m: self.active_effects.get(m, False) for m in self.active_movements}
+        return {'layers_by_cycle': layers_by_cycle, 'dj_effects_status': dj_effects_status}
+
+    def get_sound_mapping_options(self) -> Dict:
+        return {
+            'movements': self.active_movements,
+            'available_sounds': self.available_sounds,
+            'current_mapping': {m: self.loaded_sounds[m]['sound_file'] for m in self.loaded_sounds}
+        }
+
+    def get_all_layers(self):
+        return {m: info['sound_file'] for m, info in self.composition_layers.items() if 'sound_file' in info}

source/eeg_motor_imagery.py

@@ -103,7 +103,7 @@ model = ShallowFBCSPNet(
 ).to(device)
 
 # Load pretrained weights
-state_dict = torch.load("shallow_weights_all.pth", map_location=device)
+state_dict = torch.load("model.pth", map_location=device)
 model.load_state_dict(state_dict)
 
 # === 6. Training ===