Delete app2.py

app2.py

@@ -1,337 +0,0 @@
-import plotly.graph_objects as go
-import numpy as np
-import gradio as gr
-from pathlib import Path
-
-# -----------------------------
-# Configuration (Updated for YOUR data)
-# -----------------------------
-
-FREQ_BANDS = {
-    'Delta': (1, 4),
-    'Theta': (4, 8),
-    'Alpha': (8, 12),
-    'Low_Beta': (12, 20),
-    'High_Beta': (20, 30),
-    'Low_Gamma': (30, 50),
-    'High_Gamma': (50, 100)
-}
-
-# ✅ Only 3 real conditions — no ON/OFF
-condition_labels = {
-    'bima_activity': 'Bima Task',
-    'rest_eyes_open': 'Rest (Eyes Open)',
-    'rest_eyes_closed': 'Rest (Eyes Closed)'
-}
-
-# 🎨 One distinct color per condition
-condition_colors = {
-    'bima_activity':   'red',   # Fiery 
-    'rest_eyes_open':  '#38A169',   # Green
-    'rest_eyes_closed': '#805AD5',  # Purple
-}
-
-band_colors = {
-    'Delta': 'lightsalmon', 'Theta': 'wheat', 'Alpha': 'mediumpurple',
-    'Low_Beta': 'skyblue', 'High_Beta': 'lightcoral',
-    'Low_Gamma': 'lightgreen', 'High_Gamma': 'plum'
-}
-
-METHOD_DISPLAY = {"multitaper": "Multitaper", "welch": "Welch"}
-
-# -----------------------------
-# PSD Analyzer Class (Fixed for your data)
-# -----------------------------
-
-class PSDAnalyzer:
-    def __init__(self, data_file):
-        data_file = Path(data_file)
-        if not data_file.exists():
-            raise FileNotFoundError(f"Data file not found: {data_file}")
-
-        loaded = np.load(data_file, allow_pickle=True)
-        self.all_data = loaded['data'].tolist()
-
-        # Extract clean metadata — ignore med_state (always 'unknown')
-        self.subjects_list = sorted({d['subject'] for d in self.all_data})
-        self.conditions_list = sorted({d['condition'] for d in self.all_data})  # ✅ no _unknown
-        self.region_names = self.all_data[0]['region_names']
-
-        # Precompute traces
-        self.traces = self._precompute_traces()
-
-        print(f"✅ Loaded {len(self.all_data)} subject-condition combinations")
-        print(f"Subjects: {len(self.subjects_list)} | Conditions: {len(self.conditions_list)} | Regions: {len(self.region_names)}")
-
-    def _precompute_traces(self):
-        """Precompute traces grouped by region → condition → method."""
-        traces = {
-            region: {
-                cond: {'multitaper': [], 'welch': [], 'subjects': []}
-                for cond in self.conditions_list
-            }
-            for region in self.region_names
-        }
-
-        for entry in self.all_data:
-            subject = entry['subject']
-            cond_key = entry['condition']  # ✅ clean key, no med_state
-            for result in entry['results']:
-                region_name = result['region_name']
-                for method in ['multitaper', 'welch']:
-                    psd_data = result['psd_dual'].get(method)
-                    if psd_data is not None:
-                        freqs, psd = psd_data['freqs'], psd_data['psd']
-                        traces[region_name][cond_key][method].append({
-                            'freqs': freqs, 'psd': psd, 'subject': subject
-                        })
-                        if subject not in traces[region_name][cond_key]['subjects']:
-                            traces[region_name][cond_key]['subjects'].append(subject)
-        return traces
-
-    def create_plot(self, region, method, selected_conditions, selected_subjects, log_scale, show_bands, align_by_gamma):
-        """Generate Plotly figure."""
-        fig = go.Figure()
-        freq_range = (1, 100)
-
-        if not selected_conditions:
-            fig.add_annotation(
-                text="Please select at least one condition",
-                x=0.5, y=0.5, showarrow=False, xref="paper", yref="paper"
-            )
-            return fig
-
-        plotted_conditions = []
-
-        for condition in selected_conditions:
-            if condition not in self.traces.get(region, {}):
-                continue
-
-            data = self.traces[region][condition][method]
-            if not data:
-                continue
-
-            # Filter to global freq range
-            filtered_data = []
-            for item in data:
-                mask = (item['freqs'] >= freq_range[0]) & (item['freqs'] <= freq_range[1])
-                if np.any(mask):
-                    filtered_data.append({
-                        'freqs': item['freqs'][mask],
-                        'psd': item['psd'][mask],
-                        'subject': item['subject']
-                    })
-
-            if not filtered_data:
-                continue
-
-            color = condition_colors.get(condition, 'gray')
-
-            if "All Subjects" in selected_subjects:
-                # Mean across subjects
-                freqs = filtered_data[0]['freqs']
-                psds = np.array([item['psd'] for item in filtered_data])
-
-                if align_by_gamma:
-                    delta_mask = (freqs >= 30) & (freqs <= 100)
-                    if np.any(delta_mask):
-                        delta_mean = np.mean(psds[:, delta_mask], axis=1, keepdims=True)
-                        delta_mean[delta_mean == 0] = 1e-9
-                        psds = psds / delta_mean
-                    else:
-                        psds = psds / (psds.mean(axis=1, keepdims=True) + 1e-9)
-
-                mean_psd = np.mean(psds, axis=0)
-                label = f"{condition_labels.get(condition, condition)} (Mean)"
-                if align_by_gamma:
-                    label += " [Δ-norm]"
-                fig.add_trace(go.Scatter(
-                    x=freqs, y=mean_psd,
-                    mode='lines',
-                    name=label,
-                    line=dict(color=color, width=3),
-                    opacity=0.9
-                ))
-            else:
-                available_subjects = [s for s in selected_subjects if s != "All Subjects"]
-                subject_data = [item for item in filtered_data if item['subject'] in available_subjects]
-                if not subject_data:
-                    continue
-
-                for item in subject_data:
-                    freqs, psd = item['freqs'], item['psd']
-
-                    if align_by_gamma:
-                        delta_mask = (freqs >= 1) & (freqs <= 4)
-                        if np.any(delta_mask):
-                            psd = psd / np.mean(psd[delta_mask])
-                        else:
-                            psd = psd / (np.mean(psd) + 1e-9)
-
-                    label = f"{condition_labels.get(condition, condition)} - {item['subject']}"
-                    if align_by_gamma:
-                        label += " [Δ-norm]"
-
-                    fig.add_trace(go.Scatter(
-                        x=freqs, y=psd,
-                        mode='lines',
-                        name=label,
-                        line=dict(color=color, width=2),
-                        opacity=0.7
-                    ))
-
-            plotted_conditions.append(condition)
-
-        if not plotted_conditions:
-            fig.add_annotation(
-                text="No data for selected conditions/subjects",
-                x=0.5, y=0.5, showarrow=False, xref="paper", yref="paper"
-            )
-            return fig
-
-        # Frequency band shading
-        if show_bands:
-            for band, (low, high) in FREQ_BANDS.items():
-                if high < freq_range[0] or low > freq_range[1]:
-                    continue
-                band_low = max(low, freq_range[0])
-                band_high = min(high, freq_range[1])
-                fig.add_shape(
-                    type="rect",
-                    x0=band_low, x1=band_high,
-                    y0=0, y1=1,
-                    xref="x", yref="paper",
-                    fillcolor=band_colors[band],
-                    opacity=0.15,
-                    layer="below",
-                    line_width=0,
-                )
-                center_x = (band_low + band_high) / 2
-                fig.add_annotation(
-                    x=center_x, y=1.02,
-                    text=band,
-                    showarrow=False,
-                    font=dict(size=9, color="dimgray"),
-                    xanchor="center", yanchor="bottom",
-                    xref="x", yref="paper",
-                    opacity=0.85,
-                )
-
-            seen_edges = set()
-            for low, high in FREQ_BANDS.values():
-                for edge in [low, high]:
-                    if freq_range[0] < edge < freq_range[1] and edge not in seen_edges:
-                        fig.add_vline(x=edge, line=dict(color="lightgray", dash="dot"), opacity=0.5)
-                        seen_edges.add(edge)
-
-        # Final layout
-        yaxis_title = "Power"
-        if align_by_gamma:
-            yaxis_title = "Power (norm. to gamma)"
-            if log_scale:
-                yaxis_title += " [log]"
-        elif log_scale:
-            yaxis_title += " (log)"
-
-        fig.update_layout(
-            title=f"PSD - {region} | {METHOD_DISPLAY[method]}",
-            xaxis_title="Frequency (Hz)",
-            yaxis_title=yaxis_title,
-            yaxis_type="log" if log_scale else "linear",
-            template="plotly_white",
-            height=650,
-            legend=dict(
-                y=0.99, yanchor="top", x=1.02, xanchor="left",
-                bgcolor="rgba(255,255,255,0.8)", font_size=11
-            ),
-            margin=dict(r=160, t=60, b=80, l=60),
-            hovermode='x unified',
-            xaxis=dict(
-                range=[freq_range[0], freq_range[1]],
-                fixedrange=True,
-                showgrid=True, gridwidth=1, gridcolor='rgba(128,128,128,0.2)',
-                showline=True, linewidth=1, linecolor='gray'
-            ),
-            yaxis=dict(
-                fixedrange=True,
-                showgrid=True, gridwidth=1, gridcolor='rgba(128,128,128,0.2)',
-                showline=True, linewidth=1, linecolor='gray'
-            )
-        )
-
-        return fig
-
-
-# -----------------------------
-# Gradio Interface
-# -----------------------------
-
-def create_app(analyzer: PSDAnalyzer):
-    with gr.Blocks(
-        theme=gr.themes.Soft(),
-        title="PSD Analysis Dashboard",
-        css=".big-plot { height: 700px; }"
-    ) as demo:
-        gr.Markdown("# 📊 Power Spectral Density Analysis Dashboard")
-        gr.Markdown("""
-> **Conditions**:  
-> - 🔥 **Bima Task**  
-> - 🟢 **Rest (Eyes Open)**  
-> - 🟣 **Rest (Eyes Closed)**
->
-> 💡 Tip: Use _'Align by Delta'_ to compare spectral shapes across conditions.
-""")
-
-        with gr.Row():
-            with gr.Column(scale=1):
-                subjects = gr.CheckboxGroup(
-                    choices=["All Subjects"] + analyzer.subjects_list,
-                    value=["All Subjects"],
-                    label="Subjects",
-                    interactive=True
-                )
-            with gr.Column(scale=1):
-                conditions = gr.CheckboxGroup(
-                    choices=analyzer.conditions_list,
-                    value=analyzer.conditions_list[:2],
-                    label="Conditions",
-                    interactive=True
-                )
-
-        with gr.Row():
-            plot_output = gr.Plot(label="PSD Plot", elem_classes="big-plot")
-
-        with gr.Row():
-            log_scale = gr.Checkbox(value=True, label="Use Log Scale (Y-axis)")
-            show_bands = gr.Checkbox(value=True, label="Show Frequency Bands")
-            align_by_gamma = gr.Checkbox(value=False, label="Align by gamma")
-
-        with gr.Row():
-            method = gr.Radio(
-                choices=["multitaper", "welch"],
-                value="multitaper",
-                label="PSD Method"
-            )
-            region = gr.Dropdown(
-                choices=analyzer.region_names,
-                value=analyzer.region_names[0],
-                label="Brain Region"
-            )
-
-        inputs = [region, method, conditions, subjects, log_scale, show_bands, align_by_gamma]
-        for comp in inputs:
-            comp.change(fn=analyzer.create_plot, inputs=inputs, outputs=plot_output)
-        demo.load(fn=analyzer.create_plot, inputs=inputs, outputs=plot_output)
-
-    return demo
-
-
-# -----------------------------
-# Launch App
-# -----------------------------
-
-if __name__ == "__main__":
-    DATA_PATH = "psd_voxel_all_data.npz"
-    analyzer = PSDAnalyzer(DATA_PATH)
-    app = create_app(analyzer)
-    app.launch(share=True, show_error=True)