eeg_disease_data_simulator.py

# -*- coding: utf-8 -*-
"""EEG_Disease_Data_Simulator.ipynb

Automatically generated by Colab.

Original file is located at
    https://colab.research.google.com/drive/14MOVYamY-kfqxHcf1vNrwnLwrGaBPFj1
"""

import warnings
warnings.filterwarnings("ignore")
import logging

# import numpy as np


# # Spike and EMG burst generator
# def add_advanced_noise(signal, fs, t, ch_name, global_artifacts=None):
#     if global_artifacts:
#         signal += global_artifacts["eye_blink"]
#         signal += global_artifacts["nonstationary_drift"]
#         signal += global_artifacts["line_noise"]

#     # High-frequency EMG burst
#     if np.random.rand() < 0.8:
#         burst_start = np.random.uniform(0.5, 2.5)
#         burst_duration = np.random.uniform(0.1, 0.5)
#         emg_freq = np.random.uniform(60, 120)
#         burst = np.sin(2 * np.pi * emg_freq * t) * np.random.normal(0, 0.5, len(t))
#         mask = (t > burst_start) & (t < burst_start + burst_duration)
#         signal[mask] += burst[mask]

#     # Spike/sharp wave
#     if np.random.rand() < 0.5:
#         spike_time = np.random.uniform(1.0, 2.5)
#         spike_width = np.random.uniform(0.01, 0.05)
#         spike_height = np.random.uniform(3, 7)
#         spike = np.exp(-((t - spike_time) ** 2) / spike_width) * spike_height
#         signal += spike

#     # Channel dropout simulation
#     if np.random.rand() < 0.2:
#         drop_start = np.random.uniform(0.2, 2.0)
#         drop_duration = np.random.uniform(0.3, 0.6)
#         mask = (t > drop_start) & (t < drop_start + drop_duration)
#         signal[mask] = 0.2 * np.random.normal(0, 1, np.sum(mask))

#     return signal

# # Global artifact generator
# def generate_global_artifacts(t, fs):
#     blink = np.zeros_like(t)
#     for bt in np.random.uniform(0.5, 3.5, size=3):
#         blink += np.exp(-((t - bt) ** 2) / 0.01) * 2.5

#     # Nonstationary drift
#     drift = np.zeros_like(t)
#     for i in range(0, len(t), fs * 2):
#         drift_freq = np.random.uniform(0.1, 0.5)
#         drift[i:i + fs * 2] += np.sin(2 * np.pi * drift_freq * t[i:i + fs * 2]) * 0.6

#     # Powerline noise burst
#     line = np.zeros_like(t)
#     line_mask = (t > 1.5) & (t < 2.5)
#     line[line_mask] += 0.25 * np.sin(2 * np.pi * 50 * t[line_mask])

#     return {
#         "eye_blink": blink,
#         "nonstationary_drift": drift,
#         "line_noise": line
#     }

# # EEG generator
# def generate_biological_eeg(channels, fs, duration, stimulus):
#     eeg_data = {}
#     t = np.linspace(0, duration, int(fs * duration))
#     global_artifacts = generate_global_artifacts(t, fs)

#     for ch in channels:
#         # Use noisy baseline (not sine waves)
#         signal = np.random.normal(0, 0.2, len(t))

#         # Add stimulus-related bump for specific areas
#         if stimulus == 'working_memory' and ch in ['F3', 'F4']:
#             theta = np.random.uniform(5.5, 7.5)
#             signal += 0.6 * np.sin(2 * np.pi * theta * t)

#         # Add complex artifacts
#         signal = add_advanced_noise(signal, fs, t, ch, global_artifacts)
#         eeg_data[ch] = signal

#     return t, eeg_data

# # Config
# stimulus_options = {
#     "Resting - Eyes Closed": "resting_ec",
#     "Resting - Eyes Open": "resting_eo",
#     "Working Memory": "working_memory",
#     "Visual Stimulation": "visual",
#     "Auditory Task": "auditory"
# }

# selected_stimulus = "Working Memory"
# stimulus_key = stimulus_options[selected_stimulus]
# selected_channels = ["Fp1", "Fp2", "F3", "F4", "C3", "C4", "P3", "P4", "O1", "O2"]
# sampling_rate = 256
# duration_seconds = 10

# # Generate EEG
# time_vector, eeg_signals = generate_biological_eeg(
#     selected_channels,
#     sampling_rate,
#     duration_seconds,
#     stimulus=stimulus_key
# )

import numpy as np
import matplotlib.pyplot as plt
import ipywidgets as widgets
from IPython.display import display

# Channel Systems
channel_systems = {
    "10-20 (19)": ["Fp1", "Fp2", "F3", "F4", "C3", "C4", "P3", "P4", "O1", "O2", "F7", "F8", "T3", "T4", "T5", "T6", "Fz", "Cz", "Pz"],
    "10-10 (32)": ["Fp1", "Fpz", "Fp2", "AF3", "AF4", "F3", "Fz", "F4", "FC5", "FC6", "T7", "C3", "Cz", "C4", "T8", "CP5", "CP6",
                   "P7", "P3", "Pz", "P4", "P8", "PO3", "PO4", "O1", "Oz", "O2", "FT9", "FT10", "TP9", "TP10", "Iz"],
    "Clinical ICU (14)": ["Fp1", "Fp2", "F3", "F4", "C3", "C4", "P3", "P4", "O1", "O2", "Fz", "Cz", "Pz", "Oz"],
    "Pediatric (12)": ["Fp1", "Fp2", "F3", "F4", "C3", "C4", "O1", "O2", "T3", "T4", "Fz", "Cz"],
    "Minimal (8)": ["Fp1", "Fp2", "C3", "C4", "P3", "P4", "O1", "O2"]
}

# Stimulus tasks
stimulus_labels = {
    "resting_ec": "Resting - Eyes Closed",
    "resting_eo": "Resting - Eyes Open",
    "working_memory": "Working Memory",
    "visual_oddball": "Visual Oddball",
    "auditory_oddball": "Auditory Oddball",
    "motor_imagery_lh": "Motor Imagery (Left Hand)",
    "motor_imagery_rh": "Motor Imagery (Right Hand)",
    "mental_arithmetic": "Mental Arithmetic",
    "visual_search": "Visual Search",
    "emotion": "Emotion Induction"
}

# Global artifact generator
def generate_global_artifacts(t, fs):
    blink = sum([np.exp(-((t - bt) ** 2) / 0.01) * 2.5 for bt in np.random.uniform(0.5, 3.5, size=3)])
    drift = np.zeros_like(t)
    for i in range(0, len(t), fs * 2):
        freq = np.random.uniform(0.1, 0.5)
        drift[i:i + fs * 2] += np.sin(2 * np.pi * freq * t[i:i + fs * 2]) * 0.6
    line = np.zeros_like(t)
    line_mask = (t > 1.5) & (t < 2.5)
    line[line_mask] += 0.25 * np.sin(2 * np.pi * 50 * t[line_mask])
    return {"eye_blink": blink, "nonstationary_drift": drift, "line_noise": line}

# Channel-specific noise
def add_advanced_noise(signal, fs, t, ch_name, global_artifacts):
    signal += global_artifacts["eye_blink"] + global_artifacts["nonstationary_drift"] + global_artifacts["line_noise"]
    if ch_name in ["Fp1", "Fp2"]:
        emg = np.sin(2 * np.pi * np.random.uniform(80, 120) * t) * np.random.normal(0, 0.8, len(t))
        signal += emg * ((t > 1) & (t < 2))
    else:
        if np.random.rand() < 0.5:
            emg = np.sin(2 * np.pi * np.random.uniform(60, 100) * t) * np.random.normal(0, 0.4, len(t))
            signal += emg * ((t > 1) & (t < 2))
    return signal

# EEG Generator
def generate_eeg(channels, fs, duration, stimulus):
    eeg_data = {}
    t = np.linspace(0, duration, int(fs * duration))
    global_artifacts = generate_global_artifacts(t, fs)
    phase_base = np.sin(2 * np.pi * 6 * t + np.pi / 4 * np.random.randn())

    for ch in channels:
        signal = np.random.normal(0, 0.2, len(t))
        if ch in ['F3', 'F4', 'P3', 'P4'] and np.random.rand() > 0.3:
            signal += phase_base
        if stimulus in ['visual_oddball', 'auditory_oddball'] and ch in ['Pz', 'Cz', 'Fz']:
            erp_t = 1.5
            erp_wave = np.exp(-((t - erp_t) ** 2) / 0.005) * 3.0
            signal += erp_wave
        eeg_data[ch] = add_advanced_noise(signal, fs, t, ch, global_artifacts)
    return t, eeg_data

# Interactive UI for Colab
channel_selector = widgets.Dropdown(options=channel_systems.keys(), description='Channel System:')
stimulus_selector = widgets.Dropdown(options=stimulus_labels.keys(), description='Stimulus:')
fs_slider = widgets.IntSlider(value=256, min=128, max=1024, step=64, description='Sampling Hz:')
duration_slider = widgets.IntSlider(value=10, min=5, max=30, step=1, description='Duration (s):')

def on_generate_button_clicked(b):
    global eeg_data, time_vector, sampling_rate  # <-- Add this
    selected_channels = channel_systems[channel_selector.value]
    stim_key = stimulus_selector.value
    sampling_rate = fs = fs_slider.value
    duration = duration_slider.value
    time_vector, eeg_data = generate_eeg(selected_channels, fs, duration, stim_key)

    plt.figure(figsize=(14, 8))
    offset = 7
    samples_to_plot = int(min(3, duration) * fs)

    for i, ch in enumerate(reversed(selected_channels)):
        sig = eeg_data[ch][:samples_to_plot]
        plt.plot(time_vector[:samples_to_plot], sig + i * offset, label=ch, linewidth=1.2)

    plt.yticks(np.arange(len(selected_channels)) * offset, list(reversed(selected_channels)), fontsize=14)
    plt.xticks(fontsize=14)
    plt.xlabel("Time (s)", fontsize=16)
    plt.ylabel("Channels", fontsize=16)
    plt.grid(True)
    plt.tight_layout()

    # Save as PDF
    plt.savefig("eeg_plot.pdf", format="pdf")

    plt.show()


generate_button = widgets.Button(description="Generate EEG")
generate_button.on_click(on_generate_button_clicked)

display(channel_selector, stimulus_selector, fs_slider, duration_slider, generate_button)

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.signal import welch

# ------------------------------
# AD Pattern Injector
def inject_ad_pattern(eeg_data, t, fs, severity="Moderate"):
    """
    Injects Alzheimer-specific EEG alterations into EEG data.
    - Decrease Alpha (8–12 Hz)
    - Increase Theta (4–7 Hz)
    - Affects parietal and occipital channels only
    """
    modified_eeg = {}
    alpha_band = (8, 12)
    theta_band = (4, 7)

    # Define severity scale
    alpha_scale = {"Mild": 0.9, "Moderate": 0.7, "Severe": 0.5}
    theta_scale = {"Mild": 1.1, "Moderate": 1.4, "Severe": 1.8}

    for ch, signal in eeg_data.items():
        modified = np.copy(signal)
        if ch in ['P3', 'P4', 'Pz', 'O1', 'O2']:
            alpha = np.sin(2 * np.pi * np.random.uniform(*alpha_band) * t) * alpha_scale[severity]
            theta = np.sin(2 * np.pi * np.random.uniform(*theta_band) * t) * theta_scale[severity]
            modified += theta
            modified *= alpha_scale[severity]
        modified_eeg[ch] = modified

    return modified_eeg

# ------------------------------
# Power Band Calculator
def compute_band_power(signal, fs, band):
    f, Pxx = welch(signal, fs, nperseg=fs*2)
    band_mask = (f >= band[0]) & (f <= band[1])
    return np.trapz(Pxx[band_mask], f[band_mask])

# ------------------------------
# Visualization of Injection Effect
def visualize_ad_injection(original_eeg, modified_eeg, t, fs, title="Alzheimer's Disease (AD) Injection"):
    """
    - Plots original vs modified signals for a few channels
    - Displays Alpha and Theta power + Alpha/Theta ratio
    """
    example_channels = ['P3', 'P4', 'O1', 'O2'] if 'P3' in original_eeg else list(original_eeg.keys())[:4]
    samples_to_plot = min(len(t), fs * 3)

    # Time-domain plot
    fig, axs = plt.subplots(len(example_channels), 2, figsize=(14, 8), sharex=True)
    for i, ch in enumerate(example_channels):
        axs[i, 0].plot(t[:samples_to_plot], original_eeg[ch][:samples_to_plot])
        axs[i, 0].set_title(f"{ch} - Original")
        axs[i, 1].plot(t[:samples_to_plot], modified_eeg[ch][:samples_to_plot], color='darkred')
        axs[i, 1].set_title(f"{ch} - With AD Injection")
    plt.suptitle(title)
    plt.tight_layout()
    plt.show()

    # Power spectrum summary
    alpha_band = (8, 12)
    theta_band = (4, 7)
    alpha_orig = np.mean([compute_band_power(original_eeg[ch], fs, alpha_band) for ch in example_channels])
    theta_orig = np.mean([compute_band_power(original_eeg[ch], fs, theta_band) for ch in example_channels])
    alpha_mod = np.mean([compute_band_power(modified_eeg[ch], fs, alpha_band) for ch in example_channels])
    theta_mod = np.mean([compute_band_power(modified_eeg[ch], fs, theta_band) for ch in example_channels])

    # Comparison Bar Chart
    sns.set(style="whitegrid")
    labels = ["Alpha Power", "Theta Power", "Alpha/Theta Ratio"]
    original_vals = [alpha_orig, theta_orig, alpha_orig / theta_orig]
    modified_vals = [alpha_mod, theta_mod, alpha_mod / theta_mod]

    x = np.arange(len(labels))
    width = 0.35

    plt.figure(figsize=(8, 4))
    plt.bar(x - width/2, original_vals, width, label='Original')
    plt.bar(x + width/2, modified_vals, width, label='Modified', color='darkred')
    plt.xticks(x, labels)
    plt.ylabel("Power")
    plt.title("Band Power Comparison: Original vs AD Modified EEG")
    plt.legend()
    plt.tight_layout()
    plt.show()


# Inject AD pattern
ad_severity = "Moderate"  # Can be "Mild", "Moderate", "Severe"
modified_eeg = inject_ad_pattern(eeg_data, time_vector, sampling_rate, severity=ad_severity)

# Visualize results
visualize_ad_injection(eeg_data, modified_eeg, time_vector, sampling_rate)

pip install mne

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.signal import welch
from scipy.stats import entropy
from sklearn.preprocessing import normalize
import pandas as pd
import mne
from mne.viz import plot_topomap
from IPython.display import display, Markdown

# Power Band Calculator
def compute_band_power(signal, fs, band):
    f, Pxx = welch(signal, fs, nperseg=fs*2)
    band_mask = (f >= band[0]) & (f <= band[1])
    return np.trapz(Pxx[band_mask], f[band_mask])

# Advanced Metrics
def spectral_entropy(signal, fs):
    freqs, psd = welch(signal, fs)
    psd_norm = psd / np.sum(psd)
    return entropy(psd_norm)

def spectral_edge_frequency(signal, fs, edge=0.9):
    freqs, psd = welch(signal, fs)
    cumulative = np.cumsum(psd)
    total_power = cumulative[-1]
    idx = np.where(cumulative >= edge * total_power)[0][0]
    return freqs[idx]

# AD Pattern Injector
def inject_ad_pattern(eeg_data, t, fs, severity="Moderate"):
    modified_eeg = {}
    alpha_band = (8, 12)
    theta_band = (4, 7)
    alpha_scale = {"Mild": 0.9, "Moderate": 0.7, "Severe": 0.5}
    theta_scale = {"Mild": 1.1, "Moderate": 1.4, "Severe": 1.8}
    affected_channels = ['P3', 'P4', 'Pz', 'O1', 'O2']

    for ch, signal in eeg_data.items():
        modified = np.copy(signal)
        if ch in affected_channels:
            alpha = np.sin(2 * np.pi * np.random.uniform(*alpha_band) * t) * alpha_scale[severity]
            theta = np.sin(2 * np.pi * np.random.uniform(*theta_band) * t) * theta_scale[severity]
            modified += theta
            modified *= alpha_scale[severity]
        modified_eeg[ch] = modified
    return modified_eeg, affected_channels

# Visualization
def visualize_ad_injection(original_eeg, modified_eeg, t, fs, affected_channels, title="AD Injection Visualization"):
    samples_to_plot = min(len(t), fs * 3)
    fig, axs = plt.subplots(len(affected_channels), 2, figsize=(16, 2.5 * len(affected_channels)), sharex=True)
    for i, ch in enumerate(affected_channels):
        axs[i, 0].plot(t[:samples_to_plot], original_eeg[ch][:samples_to_plot], color='royalblue')
        axs[i, 0].set_title(f"{ch} - Original EEG", fontsize=10)
        axs[i, 1].plot(t[:samples_to_plot], modified_eeg[ch][:samples_to_plot], color='darkred')
        axs[i, 1].set_title(f"{ch} - AD Modified EEG", fontsize=10)
    plt.suptitle(title, fontsize=16, fontweight='bold')
    plt.xlabel("Time (s)")
    plt.tight_layout()
    plt.savefig("AD patterns.pdf", format="pdf")
    plt.show()

    # Topographic Power Map
    montage = mne.channels.make_standard_montage('standard_1020')
    all_channels = list(original_eeg.keys())
    alpha_band = (8, 12)

    def get_topo_data(eeg, fs):
        powers = {}
        for ch in all_channels:
            powers[ch] = compute_band_power(eeg[ch], fs, alpha_band)
        return powers

    orig_powers = get_topo_data(original_eeg, fs)
    mod_powers = get_topo_data(modified_eeg, fs)

    pos, orig_vals, mod_vals = [], [], []
    for ch in all_channels:
        if ch in montage.get_positions()['ch_pos']:
            pos.append(montage.get_positions()['ch_pos'][ch][:2])
            orig_vals.append(orig_powers[ch])
            mod_vals.append(mod_powers[ch])

    fig, ax = plt.subplots(1, 2, figsize=(14, 6))
    plot_topomap(orig_vals, np.array(pos), axes=ax[0], show=False, cmap='coolwarm')
    ax[0].set_title('Original EEG Power (Alpha)', fontsize=12)
    plot_topomap(mod_vals, np.array(pos), axes=ax[1], show=False, cmap='plasma')
    ax[1].set_title('Modified EEG Power (Alpha - AD)', fontsize=12)
    plt.suptitle("Topographic Map of EEG Power (Alpha Band)", fontsize=14, fontweight='bold')
    plt.tight_layout()
    plt.savefig("ad_topo.pdf", format="pdf")
    plt.show()

    # Clinical-style Summary Report
    theta_band = (4, 7)
    def safe_ratio(a, b): return a / (b + 1e-8)

    alpha_orig = np.mean([compute_band_power(original_eeg[ch], fs, alpha_band) for ch in affected_channels])
    alpha_mod = np.mean([compute_band_power(modified_eeg[ch], fs, alpha_band) for ch in affected_channels])
    theta_orig = np.mean([compute_band_power(original_eeg[ch], fs, theta_band) for ch in affected_channels])
    theta_mod = np.mean([compute_band_power(modified_eeg[ch], fs, theta_band) for ch in affected_channels])
    entropy_orig = np.mean([spectral_entropy(original_eeg[ch], fs) for ch in affected_channels])
    entropy_mod = np.mean([spectral_entropy(modified_eeg[ch], fs) for ch in affected_channels])
    edge_orig = np.mean([spectral_edge_frequency(original_eeg[ch], fs) for ch in affected_channels])
    edge_mod = np.mean([spectral_edge_frequency(modified_eeg[ch], fs) for ch in affected_channels])

    metrics_summary = {
        "Metric": [
            "Alpha Band Power (8–12 Hz)",
            "Theta Band Power (4–7 Hz)",
            "Alpha/Theta Ratio",
            "Spectral Entropy",
            "Spectral Edge Frequency (90%)"
        ],
        "Original (μ)": [round(alpha_orig, 3), round(theta_orig, 3), round(safe_ratio(alpha_orig, theta_orig), 3),
                         round(entropy_orig, 3), round(edge_orig, 3)],
        "Modified (μ)": [round(alpha_mod, 3), round(theta_mod, 3), round(safe_ratio(alpha_mod, theta_mod), 3),
                         round(entropy_mod, 3), round(edge_mod, 3)],
        "% Change": [round((m - o) / (o + 1e-8) * 100, 2)
                     for o, m in zip([alpha_orig, theta_orig, safe_ratio(alpha_orig, theta_orig),
                                      entropy_orig, edge_orig],
                                     [alpha_mod, theta_mod, safe_ratio(alpha_mod, theta_mod),
                                      entropy_mod, edge_mod])]
    }

    df = pd.DataFrame(metrics_summary)
    display(Markdown("### 🧾 Clinical Report Summary – Alzheimer's Injection"))
    display(df.style.set_properties(**{'text-align': 'center'}).set_table_styles(
        [{'selector': 'th', 'props': [('font-size', '12pt'), ('text-align', 'center'), ('font-weight', 'bold')]}]
    ))

modified_eeg, affected_channels = inject_ad_pattern(eeg_data, time_vector, sampling_rate, severity="Severe")
visualize_ad_injection(eeg_data, modified_eeg, time_vector, sampling_rate, affected_channels)

import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import welch
from scipy.stats import entropy
import pandas as pd
import mne
from mne.viz import plot_topomap
from IPython.display import display, Markdown

# --------------------------------------------
# Utility functions
def compute_band_power(signal, fs, band):
    from numpy import trapezoid
    f, Pxx = welch(signal, fs, nperseg=fs*2)
    band_mask = (f >= band[0]) & (f <= band[1])
    return trapezoid(Pxx[band_mask], f[band_mask])

def spectral_entropy(signal, fs):
    freqs, psd = welch(signal, fs)
    psd_norm = psd / np.sum(psd)
    return entropy(psd_norm)

def spectral_edge_frequency(signal, fs, edge=0.9):
    freqs, psd = welch(signal, fs)
    cumulative = np.cumsum(psd)
    total_power = cumulative[-1]
    idx = np.where(cumulative >= edge * total_power)[0][0]
    return freqs[idx]

# --------------------------------------------
# PD Pattern Injection
def inject_pd_pattern(eeg_data, t, fs, severity="Moderate"):
    modified_eeg = {}
    beta_band = (13, 30)
    mu_band = (8, 12)
    beta_scale = {"Mild": 1.1, "Moderate": 1.3, "Severe": 1.6}
    mu_scale = {"Mild": 0.9, "Moderate": 0.7, "Severe": 0.5}
    affected_channels = ['F3', 'F4', 'Fz', 'C3', 'C4']

    for ch, signal in eeg_data.items():
        modified = np.copy(signal)
        if ch in affected_channels:
            beta = np.sin(2 * np.pi * np.random.uniform(*beta_band) * t) * beta_scale[severity]
            mu = np.sin(2 * np.pi * np.random.uniform(*mu_band) * t) * mu_scale[severity]
            modified += beta
            modified *= mu_scale[severity]
        modified_eeg[ch] = modified
    return modified_eeg, affected_channels

# --------------------------------------------
# PD Visualization
def visualize_pd_injection(original_eeg, modified_eeg, t, fs, affected_channels, title="PD Injection Visualization"):
    samples_to_plot = min(len(t), fs * 3)
    fig, axs = plt.subplots(len(affected_channels), 2, figsize=(16, 2.5 * len(affected_channels)), sharex=True)
    for i, ch in enumerate(affected_channels):
        axs[i, 0].plot(t[:samples_to_plot], original_eeg[ch][:samples_to_plot], color='royalblue')
        axs[i, 0].set_title(f"{ch} - Original EEG", fontsize=10)
        axs[i, 1].plot(t[:samples_to_plot], modified_eeg[ch][:samples_to_plot], color='darkgreen')
        axs[i, 1].set_title(f"{ch} - PD Modified EEG", fontsize=10)
    plt.suptitle(title, fontsize=16, fontweight='bold')
    plt.xlabel("Time (s)")
    plt.tight_layout()
    plt.savefig("PD Patterns.pdf", format="pdf")
    plt.show()

    # Topographic EEG Power Map (Beta Band)
    montage = mne.channels.make_standard_montage('standard_1020')
    all_channels = list(original_eeg.keys())
    beta_band = (13, 30)

    def get_topo_data(eeg):
        return {ch: compute_band_power(eeg[ch], fs, beta_band) for ch in all_channels}

    orig_powers = get_topo_data(original_eeg)
    mod_powers = get_topo_data(modified_eeg)

    pos, orig_vals, mod_vals = [], [], []
    for ch in all_channels:
        if ch in montage.get_positions()['ch_pos']:
            pos.append(montage.get_positions()['ch_pos'][ch][:2])
            orig_vals.append(orig_powers[ch])
            mod_vals.append(mod_powers[ch])

    pos = np.array(pos)
    orig_vals = np.array(orig_vals)
    mod_vals = np.array(mod_vals)

    # Plot both topomaps with colorbars
    fig, axes = plt.subplots(1, 2, figsize=(14, 6))
    im0, _ = plot_topomap(orig_vals, pos, axes=axes[0], cmap='coolwarm', show=False)
    axes[0].set_title("Original EEG Power (Beta)", fontsize=12)
    cbar0 = plt.colorbar(im0, ax=axes[0], orientation='vertical', shrink=0.8, pad=0.05)

    im1, _ = plot_topomap(mod_vals, pos, axes=axes[1], cmap='plasma', show=False)
    axes[1].set_title("Modified EEG Power (Beta - PD)", fontsize=12)
    cbar1 = plt.colorbar(im1, ax=axes[1], orientation='vertical', shrink=0.8, pad=0.05)

    plt.suptitle("Topographic Map of EEG Power (Beta Band)", fontsize=14, fontweight='bold')
    plt.tight_layout()
    plt.savefig("pd_topo.pdf", format="pdf")
    plt.show()

    # ----------------------------------------
    # Clinical Summary Table
    mu_band = (8, 12)
    def safe_ratio(a, b): return a / (b + 1e-8)

    beta_orig = np.mean([compute_band_power(original_eeg[ch], fs, beta_band) for ch in affected_channels])
    beta_mod = np.mean([compute_band_power(modified_eeg[ch], fs, beta_band) for ch in affected_channels])
    mu_orig = np.mean([compute_band_power(original_eeg[ch], fs, mu_band) for ch in affected_channels])
    mu_mod = np.mean([compute_band_power(modified_eeg[ch], fs, mu_band) for ch in affected_channels])
    entropy_orig = np.mean([spectral_entropy(original_eeg[ch], fs) for ch in affected_channels])
    entropy_mod = np.mean([spectral_entropy(modified_eeg[ch], fs) for ch in affected_channels])
    edge_orig = np.mean([spectral_edge_frequency(original_eeg[ch], fs) for ch in affected_channels])
    edge_mod = np.mean([spectral_edge_frequency(modified_eeg[ch], fs) for ch in affected_channels])

    metrics_summary = {
        "Metric": [
            "Beta Band Power (13–30 Hz)",
            "Mu Band Power (8–12 Hz)",
            "Beta/Mu Ratio",
            "Spectral Entropy",
            "Spectral Edge Frequency (90%)"
        ],
        "Original (μ)": [round(beta_orig, 3), round(mu_orig, 3), round(safe_ratio(beta_orig, mu_orig), 3),
                         round(entropy_orig, 3), round(edge_orig, 3)],
        "Modified (μ)": [round(beta_mod, 3), round(mu_mod, 3), round(safe_ratio(beta_mod, mu_mod), 3),
                         round(entropy_mod, 3), round(edge_mod, 3)],
        "% Change": [round((m - o) / (o + 1e-8) * 100, 2)
                     for o, m in zip([beta_orig, mu_orig, safe_ratio(beta_orig, mu_orig),
                                      entropy_orig, edge_orig],
                                     [beta_mod, mu_mod, safe_ratio(beta_mod, mu_mod),
                                      entropy_mod, edge_mod])]
    }

    df = pd.DataFrame(metrics_summary)
    display(Markdown("### 🧾 Clinical Report Summary – Parkinson's Disease Injection"))
    display(df.style.set_properties(**{'text-align': 'center'}).set_table_styles(
        [{'selector': 'th', 'props': [('font-size', '12pt'), ('text-align', 'center'), ('font-weight', 'bold')]}]
    ))

modified_eeg, affected_channels = inject_pd_pattern(eeg_data, time_vector, sampling_rate, severity="Moderate")
visualize_pd_injection(eeg_data, modified_eeg, time_vector, sampling_rate, affected_channels)

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from scipy.signal import welch
from scipy.stats import entropy
import mne
from mne.viz import plot_topomap
from IPython.display import display, Markdown

# --- Utility Functions ---
def compute_band_power(signal, fs, band):
    from numpy import trapezoid
    f, Pxx = welch(signal, fs, nperseg=fs * 2)
    band_mask = (f >= band[0]) & (f <= band[1])
    return trapezoid(Pxx[band_mask], f[band_mask])

def spectral_entropy(signal, fs):
    freqs, psd = welch(signal, fs)
    psd_norm = psd / np.sum(psd)
    return entropy(psd_norm)

def spectral_edge_frequency(signal, fs, edge=0.9):
    freqs, psd = welch(signal, fs)
    cumulative = np.cumsum(psd)
    total_power = cumulative[-1]
    idx = np.where(cumulative >= edge * total_power)[0][0]
    return freqs[idx]

# --- Schizophrenia Pattern Injection ---
def inject_schizo_pattern(eeg_data, t, fs, severity="Moderate"):
    modified_eeg = {}
    gamma_band = (30, 45)
    theta_band = (4, 7)
    gamma_scale = {"Mild": 1.2, "Moderate": 1.5, "Severe": 2.0}
    theta_scale = {"Mild": 1.1, "Moderate": 1.3, "Severe": 1.6}
    affected_channels = ['F3', 'F4', 'Fz', 'Cz', 'Pz']

    for ch, signal in eeg_data.items():
        modified = np.copy(signal)
        if ch in affected_channels:
            gamma = np.sin(2 * np.pi * np.random.uniform(*gamma_band) * t) * gamma_scale[severity]
            theta = np.sin(2 * np.pi * np.random.uniform(*theta_band) * t) * theta_scale[severity]
            modified += gamma + theta
        modified_eeg[ch] = modified
    return modified_eeg, affected_channels

# --- Visualization ---
def visualize_schizo_injection(original_eeg, modified_eeg, t, fs, affected_channels, title="Schizophrenia Injection Visualization"):
    samples_to_plot = min(len(t), fs * 3)
    fig, axs = plt.subplots(len(affected_channels), 2, figsize=(16, 2.5 * len(affected_channels)), sharex=True)
    for i, ch in enumerate(affected_channels):
        axs[i, 0].plot(t[:samples_to_plot], original_eeg[ch][:samples_to_plot], color='royalblue')
        axs[i, 0].set_title(f"{ch} - Original EEG", fontsize=10)
        axs[i, 1].plot(t[:samples_to_plot], modified_eeg[ch][:samples_to_plot], color='firebrick')
        axs[i, 1].set_title(f"{ch} - Schizo Modified EEG", fontsize=10)
    plt.suptitle(title, fontsize=16, fontweight='bold')
    plt.xlabel("Time (s)")
    plt.tight_layout()
    plt.savefig("Scizo Patterns.pdf", format="pdf")
    plt.show()

    # --- Topographic Map ---
    montage = mne.channels.make_standard_montage('standard_1020')
    all_channels = list(original_eeg.keys())
    gamma_band = (30, 45)

    def get_topo_data(eeg):
        return {ch: compute_band_power(eeg[ch], fs, gamma_band) for ch in all_channels}

    orig_powers = get_topo_data(original_eeg)
    mod_powers = get_topo_data(modified_eeg)

    pos, orig_vals, mod_vals = [], [], []
    for ch in all_channels:
        if ch in montage.get_positions()['ch_pos']:
            pos.append(montage.get_positions()['ch_pos'][ch][:2])
            orig_vals.append(orig_powers[ch])
            mod_vals.append(mod_powers[ch])

    pos = np.array(pos)
    orig_vals = np.array(orig_vals)
    mod_vals = np.array(mod_vals)

    fig, axes = plt.subplots(1, 2, figsize=(14, 6))
    im0, _ = plot_topomap(orig_vals, pos, axes=axes[0], cmap='coolwarm', show=False)
    axes[0].set_title("Original EEG Power (Gamma)", fontsize=12)
    plt.colorbar(im0, ax=axes[0], orientation='vertical', shrink=0.8, pad=0.05)

    im1, _ = plot_topomap(mod_vals, pos, axes=axes[1], cmap='magma', show=False)
    axes[1].set_title("Modified EEG Power (Gamma - Schizo)", fontsize=12)
    plt.colorbar(im1, ax=axes[1], orientation='vertical', shrink=0.8, pad=0.05)

    plt.suptitle("Topographic Map of EEG Power (Gamma Band)", fontsize=14, fontweight='bold')
    plt.tight_layout()
    plt.savefig("schizo_topo.pdf", format="pdf")
    plt.show()

    # --- Clinical Table ---
    theta_band = (4, 7)
    def safe_ratio(a, b): return a / (b + 1e-8)

    gamma_orig = np.mean([compute_band_power(original_eeg[ch], fs, gamma_band) for ch in affected_channels])
    gamma_mod = np.mean([compute_band_power(modified_eeg[ch], fs, gamma_band) for ch in affected_channels])
    theta_orig = np.mean([compute_band_power(original_eeg[ch], fs, theta_band) for ch in affected_channels])
    theta_mod = np.mean([compute_band_power(modified_eeg[ch], fs, theta_band) for ch in affected_channels])
    entropy_orig = np.mean([spectral_entropy(original_eeg[ch], fs) for ch in affected_channels])
    entropy_mod = np.mean([spectral_entropy(modified_eeg[ch], fs) for ch in affected_channels])
    edge_orig = np.mean([spectral_edge_frequency(original_eeg[ch], fs) for ch in affected_channels])
    edge_mod = np.mean([spectral_edge_frequency(modified_eeg[ch], fs) for ch in affected_channels])

    metrics_summary = {
        "Metric": [
            "Gamma Band Power (30–45 Hz)",
            "Theta Band Power (4–7 Hz)",
            "Gamma/Theta Ratio",
            "Spectral Entropy",
            "Spectral Edge Frequency (90%)"
        ],
        "Original (μ)": [round(gamma_orig, 3), round(theta_orig, 3), round(safe_ratio(gamma_orig, theta_orig), 3),
                         round(entropy_orig, 3), round(edge_orig, 3)],
        "Modified (μ)": [round(gamma_mod, 3), round(theta_mod, 3), round(safe_ratio(gamma_mod, theta_mod), 3),
                         round(entropy_mod, 3), round(edge_mod, 3)],
        "% Change": [round((m - o) / (o + 1e-8) * 100, 2)
                     for o, m in zip([gamma_orig, theta_orig, safe_ratio(gamma_orig, theta_orig),
                                      entropy_orig, edge_orig],
                                     [gamma_mod, theta_mod, safe_ratio(gamma_mod, theta_mod),
                                      entropy_mod, edge_mod])]
    }

    df = pd.DataFrame(metrics_summary)
    display(Markdown("### 🧾 Clinical Report Summary – Schizophrenia Pattern Injection"))
    display(df.style.set_properties(**{'text-align': 'center'}).set_table_styles(
        [{'selector': 'th', 'props': [('font-size', '12pt'), ('text-align', 'center'), ('font-weight', 'bold')]}]
    ))

modified_eeg, affected_channels = inject_schizo_pattern(eeg_data, time_vector, sampling_rate, severity="Moderate")
visualize_schizo_injection(eeg_data, modified_eeg, time_vector, sampling_rate, affected_channels)

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from scipy.signal import welch
from scipy.stats import entropy
import mne
from mne.viz import plot_topomap
from IPython.display import display, Markdown

# --- Utility Functions ---
def compute_band_power(signal, fs, band):
    from numpy import trapezoid
    f, Pxx = welch(signal, fs, nperseg=fs * 2)
    band_mask = (f >= band[0]) & (f <= band[1])
    return trapezoid(Pxx[band_mask], f[band_mask])

def spectral_entropy(signal, fs):
    freqs, psd = welch(signal, fs)
    psd_norm = psd / np.sum(psd)
    return entropy(psd_norm)

def spectral_edge_frequency(signal, fs, edge=0.9):
    freqs, psd = welch(signal, fs)
    cumulative = np.cumsum(psd)
    total_power = cumulative[-1]
    idx = np.where(cumulative >= edge * total_power)[0][0]
    return freqs[idx]

# --- Epilepsy Pattern Injection ---
def inject_epilepsy_pattern(eeg_data, t, fs, severity="Moderate"):
    modified_eeg = {}
    affected_channels = ['T3', 'T4', 'F7', 'F8', 'Cz']
    spike_scale = {"Mild": 0.7, "Moderate": 1.2, "Severe": 2.0}
    n_spikes = {"Mild": 2, "Moderate": 4, "Severe": 6}
    spike_width = 0.02  # seconds

    for ch, signal in eeg_data.items():
        modified = np.copy(signal)
        if ch in affected_channels:
            for _ in range(n_spikes[severity]):
                center = np.random.uniform(1, t[-1] - 1)
                spike = np.exp(-((t - center) ** 2) / (2 * spike_width**2)) * spike_scale[severity]
                modified += spike
        modified_eeg[ch] = modified
    return modified_eeg, affected_channels

# --- Visualization Function ---
def visualize_epilepsy_injection(original_eeg, modified_eeg, t, fs, affected_channels, title="Epilepsy Injection Visualization"):
    samples_to_plot = min(len(t), fs * 3)
    fig, axs = plt.subplots(len(affected_channels), 2, figsize=(16, 2.5 * len(affected_channels)), sharex=True)
    for i, ch in enumerate(affected_channels):
        axs[i, 0].plot(t[:samples_to_plot], original_eeg[ch][:samples_to_plot], color='navy')
        axs[i, 0].set_title(f"{ch} - Original EEG", fontsize=10)
        axs[i, 1].plot(t[:samples_to_plot], modified_eeg[ch][:samples_to_plot], color='crimson')
        axs[i, 1].set_title(f"{ch} - Epileptic Modified EEG", fontsize=10)
    plt.suptitle(title, fontsize=16, fontweight='bold')
    plt.xlabel("Time (s)")
    plt.tight_layout()
    plt.savefig("Epil Pattenrs.pdf", format="pdf")
    plt.show()

    # --- Topographic Power (Delta Band) ---
    montage = mne.channels.make_standard_montage('standard_1020')
    all_channels = list(original_eeg.keys())
    delta_band = (1, 4)

    def get_topo_data(eeg):
        return {ch: compute_band_power(eeg[ch], fs, delta_band) for ch in all_channels}

    orig_powers = get_topo_data(original_eeg)
    mod_powers = get_topo_data(modified_eeg)

    pos, orig_vals, mod_vals = [], [], []
    for ch in all_channels:
        if ch in montage.get_positions()['ch_pos']:
            pos.append(montage.get_positions()['ch_pos'][ch][:2])
            orig_vals.append(orig_powers[ch])
            mod_vals.append(mod_powers[ch])

    pos = np.array(pos)
    fig, axes = plt.subplots(1, 2, figsize=(14, 6))
    im0, _ = plot_topomap(orig_vals, pos, axes=axes[0], cmap='Blues', show=False)
    axes[0].set_title("Original EEG Power (Delta)", fontsize=12)
    plt.colorbar(im0, ax=axes[0], orientation='vertical', shrink=0.8, pad=0.05)

    im1, _ = plot_topomap(mod_vals, pos, axes=axes[1], cmap='hot', show=False)
    axes[1].set_title("Modified EEG Power (Delta - Epilepsy)", fontsize=12)
    plt.colorbar(im1, ax=axes[1], orientation='vertical', shrink=0.8, pad=0.05)

    plt.suptitle("Topographic Map of EEG Power (Delta Band)", fontsize=14, fontweight='bold')
    plt.tight_layout()
    plt.savefig("epil_topo.pdf", format="pdf")
    plt.show()

    # --- Clinical Report ---
    theta_band = (4, 7)
    def safe_ratio(a, b): return a / (b + 1e-8)

    delta_orig = np.mean([compute_band_power(original_eeg[ch], fs, delta_band) for ch in affected_channels])
    delta_mod = np.mean([compute_band_power(modified_eeg[ch], fs, delta_band) for ch in affected_channels])
    theta_orig = np.mean([compute_band_power(original_eeg[ch], fs, theta_band) for ch in affected_channels])
    theta_mod = np.mean([compute_band_power(modified_eeg[ch], fs, theta_band) for ch in affected_channels])
    entropy_orig = np.mean([spectral_entropy(original_eeg[ch], fs) for ch in affected_channels])
    entropy_mod = np.mean([spectral_entropy(modified_eeg[ch], fs) for ch in affected_channels])
    edge_orig = np.mean([spectral_edge_frequency(original_eeg[ch], fs) for ch in affected_channels])
    edge_mod = np.mean([spectral_edge_frequency(modified_eeg[ch], fs) for ch in affected_channels])

    metrics_summary = {
        "Metric": [
            "Delta Band Power (1–4 Hz)",
            "Theta Band Power (4–7 Hz)",
            "Delta/Theta Ratio",
            "Spectral Entropy",
            "Spectral Edge Frequency (90%)"
        ],
        "Original (μ)": [round(delta_orig, 3), round(theta_orig, 3), round(safe_ratio(delta_orig, theta_orig), 3),
                         round(entropy_orig, 3), round(edge_orig, 3)],
        "Modified (μ)": [round(delta_mod, 3), round(theta_mod, 3), round(safe_ratio(delta_mod, theta_mod), 3),
                         round(entropy_mod, 3), round(edge_mod, 3)],
        "% Change": [round((m - o) / (o + 1e-8) * 100, 2)
                     for o, m in zip([delta_orig, theta_orig, safe_ratio(delta_orig, theta_orig),
                                      entropy_orig, edge_orig],
                                     [delta_mod, theta_mod, safe_ratio(delta_mod, theta_mod),
                                      entropy_mod, edge_mod])]
    }

    df = pd.DataFrame(metrics_summary)
    display(Markdown("### 🧾 Clinical Report Summary – Epilepsy Pattern Injection"))
    display(df.style.set_properties(**{'text-align': 'center'}).set_table_styles(
        [{'selector': 'th', 'props': [('font-size', '12pt'), ('text-align', 'center'), ('font-weight', 'bold')]}]
    ))

modified_eeg, affected_channels = inject_epilepsy_pattern(eeg_data, time_vector, sampling_rate, severity="Moderate")
visualize_epilepsy_injection(eeg_data, modified_eeg, time_vector, sampling_rate, affected_channels)

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from scipy.signal import welch
from scipy.stats import entropy
import mne
from mne.viz import plot_topomap
from IPython.display import display, Markdown

# Utility Functions
def compute_band_power(signal, fs, band):
    from numpy import trapezoid
    f, Pxx = welch(signal, fs, nperseg=fs*2)
    band_mask = (f >= band[0]) & (f <= band[1])
    return trapezoid(Pxx[band_mask], f[band_mask])

def spectral_entropy(signal, fs):
    freqs, psd = welch(signal, fs)
    psd_norm = psd / np.sum(psd)
    return entropy(psd_norm)

def spectral_edge_frequency(signal, fs, edge=0.9):
    freqs, psd = welch(signal, fs)
    cumulative = np.cumsum(psd)
    total_power = cumulative[-1]
    idx = np.where(cumulative >= edge * total_power)[0][0]
    return freqs[idx]

# FTD Pattern Injection
def inject_ftd_pattern(eeg_data, t, fs, severity="Moderate"):
    modified_eeg = {}
    affected_channels = ['F3', 'F4', 'F7', 'F8', 'Fp1', 'Fp2']
    theta_band = (4, 7)
    gamma_band = (30, 45)
    theta_scale = {"Mild": 1.1, "Moderate": 1.4, "Severe": 1.8}
    gamma_scale = {"Mild": 0.95, "Moderate": 0.8, "Severe": 0.6}

    for ch, signal in eeg_data.items():
        modified = np.copy(signal)
        if ch in affected_channels:
            theta = np.sin(2 * np.pi * np.random.uniform(*theta_band) * t) * theta_scale[severity]
            gamma = np.sin(2 * np.pi * np.random.uniform(*gamma_band) * t) * gamma_scale[severity]
            modified += theta
            modified *= gamma_scale[severity]
        modified_eeg[ch] = modified
    return modified_eeg, affected_channels

# Visualization
def visualize_ftd_injection(original_eeg, modified_eeg, t, fs, affected_channels, title="FTD Injection Visualization"):
    samples_to_plot = min(len(t), fs * 3)
    fig, axs = plt.subplots(len(affected_channels), 2, figsize=(16, 2.5 * len(affected_channels)), sharex=True)
    for i, ch in enumerate(affected_channels):
        axs[i, 0].plot(t[:samples_to_plot], original_eeg[ch][:samples_to_plot], color='blue')
        axs[i, 0].set_title(f"{ch} - Original EEG", fontsize=10)
        axs[i, 1].plot(t[:samples_to_plot], modified_eeg[ch][:samples_to_plot], color='orange')
        axs[i, 1].set_title(f"{ch} - FTD Modified EEG", fontsize=10)
    plt.suptitle(title, fontsize=16, fontweight='bold')
    plt.xlabel("Time (s)")
    plt.tight_layout()
    plt.savefig("FTD Patterns.pdf", format="pdf")
    plt.show()

    # Topographic Map (Theta Band)
    montage = mne.channels.make_standard_montage('standard_1020')
    all_channels = list(original_eeg.keys())
    theta_band = (4, 7)

    def get_topo_data(eeg):
        return {ch: compute_band_power(eeg[ch], fs, theta_band) for ch in all_channels}

    orig_powers = get_topo_data(original_eeg)
    mod_powers = get_topo_data(modified_eeg)

    pos, orig_vals, mod_vals = [], [], []
    for ch in all_channels:
        if ch in montage.get_positions()['ch_pos']:
            pos.append(montage.get_positions()['ch_pos'][ch][:2])
            orig_vals.append(orig_powers[ch])
            mod_vals.append(mod_powers[ch])

    pos = np.array(pos)
    fig, axes = plt.subplots(1, 2, figsize=(14, 6))
    im0, _ = plot_topomap(orig_vals, pos, axes=axes[0], cmap='Greens', show=False)
    axes[0].set_title("Original EEG Power (Theta)", fontsize=12)
    plt.colorbar(im0, ax=axes[0], orientation='vertical', shrink=0.8, pad=0.05)

    im1, _ = plot_topomap(mod_vals, pos, axes=axes[1], cmap='Oranges', show=False)
    axes[1].set_title("Modified EEG Power (Theta - FTD)", fontsize=12)
    plt.colorbar(im1, ax=axes[1], orientation='vertical', shrink=0.8, pad=0.05)

    plt.suptitle("Topographic Map of EEG Power (Theta Band)", fontsize=14, fontweight='bold')
    plt.tight_layout()
    plt.savefig("ftd_topo.pdf", format="pdf")
    plt.show()

    # Clinical Summary Report
    gamma_band = (30, 45)
    def safe_ratio(a, b): return a / (b + 1e-8)

    theta_orig = np.mean([compute_band_power(original_eeg[ch], fs, theta_band) for ch in affected_channels])
    theta_mod = np.mean([compute_band_power(modified_eeg[ch], fs, theta_band) for ch in affected_channels])
    gamma_orig = np.mean([compute_band_power(original_eeg[ch], fs, gamma_band) for ch in affected_channels])
    gamma_mod = np.mean([compute_band_power(modified_eeg[ch], fs, gamma_band) for ch in affected_channels])
    entropy_orig = np.mean([spectral_entropy(original_eeg[ch], fs) for ch in affected_channels])
    entropy_mod = np.mean([spectral_entropy(modified_eeg[ch], fs) for ch in affected_channels])
    edge_orig = np.mean([spectral_edge_frequency(original_eeg[ch], fs) for ch in affected_channels])
    edge_mod = np.mean([spectral_edge_frequency(modified_eeg[ch], fs) for ch in affected_channels])

    metrics_summary = {
        "Metric": [
            "Theta Band Power (4–7 Hz)",
            "Gamma Band Power (30–45 Hz)",
            "Theta/Gamma Ratio",
            "Spectral Entropy",
            "Spectral Edge Frequency (90%)"
        ],
        "Original (μ)": [round(theta_orig, 3), round(gamma_orig, 3), round(safe_ratio(theta_orig, gamma_orig), 3),
                         round(entropy_orig, 3), round(edge_orig, 3)],
        "Modified (μ)": [round(theta_mod, 3), round(gamma_mod, 3), round(safe_ratio(theta_mod, gamma_mod), 3),
                         round(entropy_mod, 3), round(edge_mod, 3)],
        "% Change": [round((m - o) / (o + 1e-8) * 100, 2)
                     for o, m in zip([theta_orig, gamma_orig, safe_ratio(theta_orig, gamma_orig),
                                      entropy_orig, edge_orig],
                                     [theta_mod, gamma_mod, safe_ratio(theta_mod, gamma_mod),
                                      entropy_mod, edge_mod])]
    }

    df = pd.DataFrame(metrics_summary)
    display(Markdown("### 🧾 Clinical Report Summary – Frontotemporal Dementia (FTD) Injection"))
    display(df.style.set_properties(**{'text-align': 'center'}).set_table_styles(
        [{'selector': 'th', 'props': [('font-size', '12pt'), ('text-align', 'center'), ('font-weight', 'bold')]}]
    ))

modified_eeg, affected_channels = inject_ftd_pattern(eeg_data, time_vector, sampling_rate, severity="Moderate")
visualize_ftd_injection(eeg_data, modified_eeg, time_vector, sampling_rate, affected_channels)

import numpy as np

# Define parameters
n_samples_per_disease = 100
sampling_rate = 256  # Hz
duration_sec = 10    # seconds
n_channels = 19
n_times = sampling_rate * duration_sec
time_vector = np.linspace(0, duration_sec, n_times)

# Use real or placeholder 41-channel names
channel_names = [f'Ch{i+1}' for i in range(n_channels)]

# Generate baseline EEG as dict
def generate_baseline_eeg_dict():
    return {ch: np.random.randn(n_times) * 10 for ch in channel_names}

# Disease injection map
disease_map = {
    "AD": inject_ad_pattern,
    "PD": inject_pd_pattern,
    "SCZ": inject_schizo_pattern,
    "EPI": inject_epilepsy_pattern,
    "FTD": inject_ftd_pattern,
}

# Store results
all_modified_eeg = []
all_labels = []

# Generate data
for disease_code, injection_func in disease_map.items():
    for severity in ["Mild", "Severe"]:
        for _ in range(n_samples_per_disease // 2):  # 50 Mild, 50 Severe
            eeg_dict = generate_baseline_eeg_dict()
            modified_dict, affected_channels = injection_func(
                eeg_dict, time_vector, sampling_rate, severity=severity
            )

            # Convert dict back to array format (n_channels, n_times)
            modified_eeg_array = np.array([modified_dict[ch] for ch in channel_names])
            all_modified_eeg.append(modified_eeg_array)
            all_labels.append(f"{disease_code}_{severity}")

# Convert to array
all_modified_eeg = np.array(all_modified_eeg)  # shape: (1000, 41, n_times)
all_labels = np.array(all_labels)

print("Shape of consolidated EEG data:", all_modified_eeg.shape)
print("Shape of labels:", all_labels.shape)

np.unique(all_labels)

pip install mne umap-learn antropy networkx

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.stats import f_oneway, kruskal
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from statsmodels.multivariate.manova import MANOVA
from sklearn.manifold import TSNE
import itertools
import umap
from math import pi

# === Assuming all_modified_eeg and all_labels already defined ===
n_samples, n_channels, n_times = all_modified_eeg.shape

channels = ["Fp1", "Fp2", "F3", "F4", "C3", "C4", "P3", "P4", "O1", "O2",
            "F7", "F8", "T3", "T4", "T5", "T6", "Fz", "Cz", "Pz"]

# === Feature Extraction: Mean Power ===
features = []
for i in range(n_samples):
    sample = all_modified_eeg[i]
    power = np.mean(sample ** 2, axis=1)
    features.append(power)
features = np.array(features)

# === Create DataFrame ===
df = pd.DataFrame(features, columns=channels)
df['label'] = all_labels
df['disease'] = df['label'].apply(lambda x: x.split('_')[0])
df['severity'] = df['label'].apply(lambda x: x.split('_')[1])

# === MANOVA ===
manova = MANOVA.from_formula(f"{'+'.join(channels)} ~ severity", data=df)
print("\nMANOVA Results (Severity):")
print(manova.mv_test())

# === ANOVA (Severity Differences) ===
print("\nANOVA Results (Mild vs Severe - All Channels Combined):")
mild_data = df[df['severity'] == 'Mild'][channels]
severe_data = df[df['severity'] == 'Severe'][channels]
for ch in channels:
    stat, p = f_oneway(mild_data[ch], severe_data[ch])
    print(f"{ch}: F={stat:.4f}, p={p:.4f}")

# === Kruskal-Wallis by Disease Type ===
print("\nKruskal-Wallis Test by Channel (Between Diseases):")
for ch in channels:
    groups = [df[df['disease'] == d][ch] for d in df['disease'].unique()]
    stat, p = kruskal(*groups)
    print(f"{ch}: H={stat:.4f}, p={p:.4f}")

# === Mahalanobis Distance Matrix ===
group_means = df.groupby('label')[channels].mean()
cov = np.cov(df[channels].values.T)
cov_inv = np.linalg.pinv(cov)
mahalanobis_matrix = pd.DataFrame(index=group_means.index, columns=group_means.index)
for a, b in itertools.product(group_means.index, repeat=2):
    diff = group_means.loc[a] - group_means.loc[b]
    d = np.sqrt(np.dot(np.dot(diff, cov_inv), diff.T))
    mahalanobis_matrix.loc[a, b] = d

print("\nMahalanobis Distance Matrix (Label vs Label):")
print(mahalanobis_matrix.round(2))

# === PCA Visualization ===
scaler = StandardScaler()
X_scaled = scaler.fit_transform(features)
pca = PCA(n_components=2)
pca_result = pca.fit_transform(X_scaled)
df['PCA1'], df['PCA2'] = pca_result[:, 0], pca_result[:, 1]

plt.figure(figsize=(8, 6))
sns.scatterplot(data=df, x='PCA1', y='PCA2', hue='label', palette='tab10')
plt.title("PCA of EEG Channel Power")
plt.tight_layout()
plt.show()

# === t-SNE Visualization ===
tsne = TSNE(n_components=2, random_state=42, perplexity=30)
tsne_result = tsne.fit_transform(X_scaled)
df['TSNE1'], df['TSNE2'] = tsne_result[:, 0], tsne_result[:, 1]

plt.figure(figsize=(8, 6))
sns.scatterplot(data=df, x='TSNE1', y='TSNE2', hue='label', palette='tab10')
plt.title("t-SNE of EEG Channel Power")
plt.tight_layout()
plt.show()

# === Boxplot for All Diseases (Grouped View) ===
plt.figure(figsize=(14, 6))
sns.boxplot(data=df, x='label', y='Fp1', palette='Set2')
plt.xticks(rotation=45)
plt.title("Boxplot of EEG Power at Channel Fp1 by Disease Condition")
plt.tight_layout()
plt.show()

# Compute correlation matrix
correlation_matrix = df[channels].corr()

# Plot heatmap
plt.figure(figsize=(11, 9))
sns.heatmap(
    correlation_matrix,
    cmap='coolwarm',
    annot=True,
    fmt=".2f",
    linewidths=0.5,
    linecolor='gray',
    square=True,
    cbar_kws={"shrink": 0.75},
    annot_kws={"size": 8}  # Smaller font size
)

# Formatting
plt.xticks(rotation=45, ha='right', fontsize=9)
plt.yticks(rotation=0, fontsize=9)
plt.title('Inter-Channel Correlation Matrix', fontsize=14, fontweight='bold', pad=20)
plt.tight_layout()
plt.savefig("correlation_matrix.pdf", format="pdf")
plt.show()

from math import pi
import matplotlib.pyplot as plt
import seaborn as sns

# Compute mean EEG power by label
mean_power_by_label = df.groupby('label')[channels].mean()
mean_power_by_label['severity'] = mean_power_by_label.index.str.split('_').str[1]
mean_power_by_label['disease'] = mean_power_by_label.index.str.split('_').str[0]

# Z-score normalization
normalized_power = mean_power_by_label[channels]
normalized_power = (normalized_power - normalized_power.mean()) / normalized_power.std()
normalized_power['severity'] = mean_power_by_label['severity']
normalized_power['disease'] = mean_power_by_label['disease']

# Separate groups
mild_group = normalized_power[normalized_power['severity'] == 'Mild'].drop(columns=['severity', 'disease'])
severe_group = normalized_power[normalized_power['severity'] == 'Severe'].drop(columns=['severity', 'disease'])

# Radar chart setup
angles = np.linspace(0, 2 * np.pi, len(channels), endpoint=False).tolist()
angles += angles[:1]

def plot_pretty_radar(data, title, name):
    plt.figure(figsize=(10, 8))
    ax = plt.subplot(111, polar=True)

    # Enhanced color palette
    palette = sns.color_palette("tab10", len(data))
    ax.set_facecolor("#f8f8f8")  # light background

    # Grid styling
    ax.grid(color='lightgray', linestyle='dashed', linewidth=0.8)
    ax.set_ylim(-2.2, 2.2)
    ax.set_yticks([-2, -1, 0, 1, 2])
    ax.set_yticklabels(['-2', '-1', '0', '1', '2'], fontsize=9, color='gray')

    # Plot each line
    for idx, (label, row) in enumerate(data.iterrows()):
        values = row.tolist()
        values += values[:1]
        ax.plot(angles, values, label=label, color=palette[idx], linewidth=2.5, alpha=0.9)
        ax.fill(angles, values, color=palette[idx], alpha=0.07)

    # Channel labels
    ax.set_xticks(angles[:-1])
    ax.set_xticklabels(channels, fontsize=11, fontweight='bold')

    # Legend
    plt.title(title, fontsize=15, fontweight='bold', pad=20)
    plt.legend(loc='upper right', bbox_to_anchor=(1.2, 1.05), fontsize=9, frameon=False)
    plt.tight_layout()
    plt.savefig(name, format="pdf")
    plt.show()

# Final visual radar plots
plot_pretty_radar(mild_group, "Radar Chart of Z-Scored EEG Power for Mild Disease Conditions", "radar1.pdf")
plot_pretty_radar(severe_group, "Radar Chart of Z-Scored EEG Power for Severe Disease Conditions", "radar2.pdf")

import numpy as np
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import classification_report, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.utils import shuffle

# Input Data
X = all_modified_eeg  # Shape: (samples, 19, time_steps)
y = all_labels

X, y = shuffle(all_modified_eeg, all_labels, random_state=42)


# === Data Augmentation: Add noise (std=0.0001) and repeat samples twice ===
def augment_with_noise(data, labels, std=0.00001, repeats=2):
    augmented_data = [data]
    augmented_labels = [labels]
    for _ in range(repeats):
        noise = np.random.normal(0, std, data.shape)
        augmented_data.append(data + noise)
        augmented_labels.append(labels)
    return np.concatenate(augmented_data), np.concatenate(augmented_labels)

X, y = augment_with_noise(X, y, std=0.0001, repeats=5)


# Encode labels
le = LabelEncoder()
y_encoded = le.fit_transform(y)
class_names = le.classes_
num_classes = len(class_names)

# One-hot encoding
y_onehot = tf.keras.utils.to_categorical(y_encoded, num_classes)

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(X, y_onehot, test_size=0.2, random_state=42, stratify=y_onehot)
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.1, random_state=42, stratify=y_train)


# Normalize EEG: per sample (zero mean, unit std over time)
def normalize_eeg(data):
    # data shape: (samples, channels, time)
    mean = np.mean(data, axis=-1, keepdims=True)
    std = np.std(data, axis=-1, keepdims=True) + 1e-8
    return (data - mean) / std


X_train = normalize_eeg(X_train)
X_val = normalize_eeg(X_val)
X_test = normalize_eeg(X_test)


# Reshape for CNN input: (samples, channels, time, 1)
X_train = X_train[..., np.newaxis]
X_val = X_val[..., np.newaxis]
X_test = X_test[..., np.newaxis]

# === CNN + Attention Model ===
def build_model(input_shape, num_classes):
    inputs = tf.keras.Input(shape=input_shape)

    x = tf.keras.layers.Conv2D(32, (3, 5), activation='relu', padding='same')(inputs)
    x = tf.keras.layers.BatchNormalization()(x)
    x = tf.keras.layers.MaxPooling2D((2, 2))(x)

    x = tf.keras.layers.Conv2D(64, (3, 3), activation='relu', padding='same')(x)
    x = tf.keras.layers.BatchNormalization()(x)
    x = tf.keras.layers.MaxPooling2D((2, 2))(x)

    x = tf.keras.layers.Reshape((-1, x.shape[-1]))(x)

    attention = tf.keras.layers.MultiHeadAttention(num_heads=4, key_dim=16)(x, x)
    x = tf.keras.layers.GlobalAveragePooling1D()(attention)

    x = tf.keras.layers.Dense(128, activation='relu')(x)
    x = tf.keras.layers.Dropout(0.3)(x)

    outputs = tf.keras.layers.Dense(num_classes, activation='softmax')(x)

    model = tf.keras.Model(inputs, outputs)
    return model

model = build_model(X_train.shape[1:], num_classes)
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
model.summary()

# === Training ===
history = model.fit(
    X_train, y_train,
    validation_data=(X_val, y_val),
    epochs=30,
    batch_size=16,
    verbose=1
)

# === Plot training and validation curves ===
plt.figure(figsize=(10, 5))
plt.plot(history.history['accuracy'], label='Train Accuracy')
plt.plot(history.history['val_accuracy'], label='Val Accuracy')
plt.plot(history.history['loss'], label='Train Loss', linestyle='--')
plt.plot(history.history['val_loss'], label='Val Loss', linestyle='--')
plt.title('Training & Validation Metrics')
plt.xlabel('Epochs')
plt.ylabel('Value')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.savefig("train.pdf", format="pdf")
plt.show()

# === Evaluation ===
y_pred_probs = model.predict(X_test)
y_pred = np.argmax(y_pred_probs, axis=1)
y_true = np.argmax(y_test, axis=1)

print("\nClassification Report:")
print(classification_report(y_true, y_pred, target_names=class_names))

# === Confusion Matrix ===
cm = confusion_matrix(y_true, y_pred)
plt.figure(figsize=(10, 8))
sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", xticklabels=class_names, yticklabels=class_names)
plt.title("Confusion Matrix")
plt.xlabel("Predicted")
plt.ylabel("Actual")
plt.tight_layout()
plt.savefig("conf.pdf", format="pdf")
plt.show()

from scipy.signal import welch
from scipy.stats import entropy
from mne.viz import plot_topomap
import mne
import pandas as pd

def compute_band_power(signal, fs, band):
    f, Pxx = welch(signal, fs, nperseg=fs * 2)
    band_mask = (f >= band[0]) & (f <= band[1])
    return np.trapz(Pxx[band_mask], f[band_mask])

def apply_ad_pattern(eeg_data, t, fs, severity="Moderate"):
    alpha_band = (8, 12)
    theta_band = (4, 7)
    affected = ['P3', 'P4', 'O1', 'O2']
    alpha_scale = {"Mild": 0.9, "Moderate": 0.7, "Severe": 0.5}
    theta_scale = {"Mild": 1.1, "Moderate": 1.4, "Severe": 1.8}

    modified = {}
    for ch, signal in eeg_data.items():
        altered = np.copy(signal)
        if ch in affected:
            theta = np.sin(2 * np.pi * 6 * t) * theta_scale[severity]
            altered += theta
            altered *= alpha_scale[severity]
        modified[ch] = altered
    return modified, affected

def show_all_visuals(original_eeg, modified_eeg, t, fs, stim_text, disease, severity, affected_chs):
    # 1. Full EEG Plot
    samples_to_plot = fs * 3
    offset = 6
    plt.figure(figsize=(14, 6))
    for i, ch in enumerate(reversed(list(original_eeg.keys()))):
        plt.plot(t[:samples_to_plot], original_eeg[ch][:samples_to_plot] + i * offset)
    plt.yticks(np.arange(len(original_eeg)) * offset, list(reversed(list(original_eeg.keys()))))
    plt.title(f"📊 Original EEG - {stim_text}")
    plt.xlabel("Time (s)")
    plt.grid(True, linestyle="--")
    plt.tight_layout()
    plt.show()

    # 2 & 3: Focused disease impact
    for ch in affected_chs[:2]:
        plt.figure(figsize=(10, 2))
        plt.plot(t[:samples_to_plot], original_eeg[ch][:samples_to_plot], label='Original', color='steelblue')
        plt.plot(t[:samples_to_plot], modified_eeg[ch][:samples_to_plot], label='Modified', color='darkred')
        plt.title(f"{ch} - Signal Before & After {disease} Injection ({severity})")
        plt.xlabel("Time (s)")
        plt.legend()
        plt.tight_layout()
        plt.show()

    # 4 & 5: Topographic maps
    montage = mne.channels.make_standard_montage('standard_1020')
    alpha_band = (8, 12)
    chs = list(original_eeg.keys())

    def get_topo(eeg):
        return [compute_band_power(eeg[ch], fs, alpha_band) for ch in chs]

    pos = []
    for ch in chs:
        if ch in montage.get_positions()['ch_pos']:
            pos.append(montage.get_positions()['ch_pos'][ch][:2])
        else:
            pos.append((0, 0))  # dummy

    orig_vals = get_topo(original_eeg)
    mod_vals = get_topo(modified_eeg)

    fig, ax = plt.subplots(1, 2, figsize=(14, 5))
    plot_topomap(orig_vals, np.array(pos), axes=ax[0], show=False, cmap='coolwarm')
    ax[0].set_title("Original Alpha Power")

    plot_topomap(mod_vals, np.array(pos), axes=ax[1], show=False, cmap='plasma')
    ax[1].set_title(f"Modified Alpha Power ({disease})")

    plt.suptitle("🧠 Topographic Maps of EEG Alpha Band", fontsize=13)
    plt.tight_layout()
    plt.show()

    # 6. Bar Chart for band powers
    theta_band = (4, 7)
    def power_stats(eeg):
        alpha = np.mean([compute_band_power(eeg[ch], fs, alpha_band) for ch in affected_chs])
        theta = np.mean([compute_band_power(eeg[ch], fs, theta_band) for ch in affected_chs])
        return alpha, theta, alpha / (theta + 1e-8)

    a1, t1, r1 = power_stats(original_eeg)
    a2, t2, r2 = power_stats(modified_eeg)

    labels = ["Alpha", "Theta", "Alpha/Theta"]
    x = np.arange(len(labels))
    width = 0.35

    plt.figure(figsize=(8, 4))
    plt.bar(x - width/2, [a1, t1, r1], width, label="Original", color='gray')
    plt.bar(x + width/2, [a2, t2, r2], width, label="Modified", color='crimson')
    plt.xticks(x, labels)
    plt.ylabel("Power")
    plt.title("📈 Band Power Comparison")
    plt.legend()
    plt.tight_layout()
    plt.show()

import ipywidgets as widgets
from IPython.display import display, Markdown, clear_output
import matplotlib.pyplot as plt
import numpy as np
# logging.getLogger('matplotlib').setLevel(logging.ERROR')


# ----------------------------
# EEG Setup & Disease Metadata
# ----------------------------

channel_systems = {
    "10-20 System (19)": ["Fp1", "Fp2", "F3", "F4", "C3", "C4", "P3", "P4", "O1", "O2", "F7", "F8", "T3", "T4", "T5", "T6", "Fz", "Cz", "Pz"],
    "Minimal (8)": ["Fp1", "Fp2", "C3", "C4", "P3", "P4", "O1", "O2"]
}

stimulus_labels = {
    "resting_ec": "🧘‍♂️ Resting - Eyes Closed",
    "working_memory": "🧠 Working Memory",
    "visual_oddball": "👁️ Visual Oddball",
    "auditory_oddball": "🎧 Auditory Oddball"
}

disease_options = ["None", "Alzheimer's (AD)", "Parkinson's (PD)", "Epilepsy (EPI)", "Frontotemporal Dementia (FTD)", "Schizophrenia (SCZ)"]
severity_levels = ["Mild", "Moderate", "Severe"]

# ----------------------------
# EEG Generator
# ----------------------------

def simulate_eeg(channels, fs, duration, stimulus_key, disease=None, severity="Moderate"):
    t = np.linspace(0, duration, int(fs * duration))
    eeg_data = {}
    for ch in channels:
        signal = np.random.normal(0, 0.2, len(t))
        if stimulus_key == "working_memory" and ch in ["F3", "F4"]:
            signal += 0.5 * np.sin(2 * np.pi * 6 * t)

        # Disease modification (simplified placeholder)
        if disease == "Alzheimer's (AD)" and ch in ["P3", "P4", "O1", "O2"]:
            alpha_scale = {"Mild": 0.9, "Moderate": 0.7, "Severe": 0.5}[severity]
            theta_scale = {"Mild": 1.1, "Moderate": 1.4, "Severe": 1.8}[severity]
            theta = np.sin(2 * np.pi * 5 * t) * theta_scale
            signal += theta
            signal *= alpha_scale

        eeg_data[ch] = signal
    return t, eeg_data

# ----------------------------
# Plotting Function
# ----------------------------

def plot_eeg_signals(t, eeg_data, channels, duration, fs, stim_text, disease, severity):
    samples_to_plot = int(min(3, duration) * fs)
    offset = 6

    plt.figure(figsize=(14, 7))
    for i, ch in enumerate(reversed(channels)):
        plt.plot(t[:samples_to_plot], eeg_data[ch][:samples_to_plot] + i * offset, label=ch)

    plt.yticks(np.arange(len(channels)) * offset, list(reversed(channels)))
    title = f"📊 EEG Simulation - {stim_text}"
    if disease != "None":
        title += f" | Disease: {disease} ({severity})"
    plt.title(title, fontsize=14, fontweight='bold')
    plt.xlabel("Time (s)")
    plt.ylabel("EEG Channels")
    plt.grid(True, linestyle='--', alpha=0.6)
    plt.tight_layout()
    plt.show()

# ----------------------------
# Widget Controls
# ----------------------------

channel_selector = widgets.Dropdown(
    options=channel_systems.keys(), description='EEG Setup:', layout=widgets.Layout(width='300px'))

stimulus_selector = widgets.Dropdown(
    options=stimulus_labels.keys(), description='Stimulus:', layout=widgets.Layout(width='300px'))

disease_selector = widgets.Dropdown(
    options=disease_options, description='Disease:', layout=widgets.Layout(width='300px'))

severity_selector = widgets.Dropdown(
    options=severity_levels, description='Severity:', layout=widgets.Layout(width='300px'))

fs_slider = widgets.IntSlider(value=256, min=128, max=1024, step=64,
                              description='Sampling Rate', layout=widgets.Layout(width='400px'))

duration_slider = widgets.IntSlider(value=10, min=5, max=30, step=1,
                                    description='Duration (s)', layout=widgets.Layout(width='400px'))

generate_button = widgets.Button(description='🎬 Generate EEG', button_style='success',
                                 layout=widgets.Layout(width='200px', height='40px'))

output_area = widgets.Output()

# ----------------------------
# Button Callback
# ----------------------------

def on_generate_clicked(b):
    with output_area:
        clear_output(wait=True)

        # Config
        channels = channel_systems[channel_selector.value]
        stim_key = stimulus_selector.value
        stim_text = stimulus_labels[stim_key]
        fs = fs_slider.value
        duration = duration_slider.value
        disease = disease_selector.value
        severity = severity_selector.value

        # Simulate EEG
        t, eeg_data = simulate_eeg(channels, fs, duration, stim_key, disease, severity)

        if disease == "Alzheimer's (AD)":
            modified_eeg, affected_chs = apply_ad_pattern(eeg_data, t, fs, severity)
        else:
            modified_eeg = eeg_data.copy()
            affected_chs = channels[:2]  # fallback

        # Plot layout: 10x6 inches total
        fig, axs = plt.subplots(2, 2, figsize=(10, 6))
        fig.subplots_adjust(hspace=0.4, wspace=0.3)
        fig.suptitle(f"EEG Simulation: {stim_text} | {disease} ({severity})", fontsize=10)

        samples = fs * min(3, duration)
        offset = 6

        # Subplot 1: Raw EEG
        for i, ch in enumerate(reversed(channels)):
            axs[0, 0].plot(t[:samples], eeg_data[ch][:samples] + i * offset, linewidth=0.6)
        axs[0, 0].set_yticks(np.arange(len(channels)) * offset)
        axs[0, 0].set_yticklabels(list(reversed(channels)), fontsize=6)
        axs[0, 0].set_title("Raw EEG", fontsize=8)
        axs[0, 0].tick_params(axis='x', labelsize=6)
        axs[0, 0].grid(True, alpha=0.3)

        # Subplots 2 & 3: Focus channels
        for i, ch in enumerate(affected_chs[:2]):
            ax = axs[0, 1] if i == 0 else axs[1, 0]
            ax.plot(t[:samples], eeg_data[ch][:samples], label='Original', color='blue', linewidth=0.6)
            ax.plot(t[:samples], modified_eeg[ch][:samples], label='Modified', color='darkred', linewidth=0.6)
            ax.set_title(f"{ch} - Modified", fontsize=8)
            ax.tick_params(axis='both', labelsize=6)
            ax.legend(fontsize=6)

        # Subplot 4: Topographic Alpha Power
        from mne.viz import plot_topomap
        montage = mne.channels.make_standard_montage('standard_1020')
        alpha_band = (8, 12)

        def compute_band_power(sig, fs, band):
            f, Pxx = welch(sig, fs)
            mask = (f >= band[0]) & (f <= band[1])
            return np.trapz(Pxx[mask], f[mask])

        def get_topo(eeg):
            vals, pos = [], []
            for ch in channels:
                vals.append(compute_band_power(eeg[ch], fs, alpha_band))
                pos.append(montage.get_positions()['ch_pos'].get(ch, (0, 0))[:2])
            return vals, np.array(pos)

        vals1, pos = get_topo(eeg_data)
        vals2, _ = get_topo(modified_eeg)
        diff_vals = np.array(vals2) - np.array(vals1)

        plot_topomap(diff_vals, pos, axes=axs[1, 1], show=False, cmap='bwr', contours=0)
        axs[1, 1].set_title("Topographic Δ Alpha", fontsize=8)

        # Final adjustments
        for ax in axs.flatten():
            ax.set_xlabel("")
            ax.set_ylabel("")
        plt.tight_layout(rect=[0, 0, 1, 0.94])
        plt.show()




generate_button.on_click(on_generate_clicked)

# ----------------------------
# Display GUI Layout
# ----------------------------

display(Markdown("## 🎛️ EEG Simulation Interface"))

controls_box = widgets.VBox([
    widgets.HTML("<h4 style='color:darkblue'>🧠 Configuration</h4>"),
    widgets.HBox([channel_selector, stimulus_selector]),
    widgets.HBox([disease_selector, severity_selector]),
    widgets.HBox([fs_slider, duration_slider]),
    generate_button
])

gui_layout = widgets.VBox([
    controls_box,
    widgets.HTML("<hr>"),
    output_area
])

export_buttons = widgets.HBox([
    widgets.Button(description='📤 Export as EDF', button_style='info', layout=widgets.Layout(width='150px')),
    widgets.Button(description='📤 Export as CSV', button_style='info', layout=widgets.Layout(width='150px')),
    widgets.Button(description='📤 Export as MAT', button_style='info', layout=widgets.Layout(width='150px'))
])

# Add compact style spacing
final_layout = widgets.VBox([
    gui_layout,
    widgets.HTML("<hr style='margin-top: 10px;'>"),
    widgets.HTML("<h4 style='color:darkgreen'>📁 Export Simulated EEG Data</h4>"),
    export_buttons
])

display(final_layout)

# display(gui_layout)