Update app.py

app.py

@@ -4,7 +4,7 @@ import numpy as np
 from pathlib import Path
 
 # -----------------------------
-# Configuration
+# Configuration (Updated for YOUR data)
 # -----------------------------
 
 FREQ_BANDS = {
@@ -17,27 +17,18 @@ FREQ_BANDS = {
     'High_Gamma': (50, 100)
 }
 
+# ✅ Only 3 real conditions — no ON/OFF
 condition_labels = {
-    'bima_activity_on': 'Bima Activity (ON)',
-    'bima_activity_off': 'Bima Activity (OFF)',
-    'hands_move_on': 'Left Hand Moves (ON)',
-    'hands_move_off': 'Left Hand Moves (OFF)',
-    'rest_eyes_closed_on': 'Rest Eyes Closed (ON)',
-    'rest_eyes_closed_off': 'Rest Eyes Closed (OFF)',
-    'rest_eyes_open_on': 'Rest Eyes Open (ON)',
-    'rest_eyes_open_off': 'Rest Eyes Open (OFF)'
+    'bima_activity': 'Bima Task',
+    'rest_eyes_open': 'Rest (Eyes Open)',
+    'rest_eyes_closed': 'Rest (Eyes Closed)'
 }
 
-# 🎨 Separate colors for ON and OFF states
+# 🎨 One distinct color per condition
 condition_colors = {
-    'bima_activity_on':   '#FF6B35',   # Fiery Orange
-    'bima_activity_off':  '#4A90E2',   # Cool Blue
-    'hands_move_on':      '#E53E3E',   # Bold Red
-    'hands_move_off':     '#38B2AC',   # Teal
-    'rest_eyes_closed_on': '#805AD5',  # Purple
-    'rest_eyes_closed_off': '#D69E2E', # Golden Yellow
-    'rest_eyes_open_on':   '#38A169',  # Green
-    'rest_eyes_open_off':  '#D6336C',  # Magenta
+    'bima_activity':   '#FF6B35',   # Fiery Orange
+    'rest_eyes_open':  '#38A169',   # Green
+    'rest_eyes_closed': '#805AD5',  # Purple
 }
 
 band_colors = {
@@ -49,7 +40,7 @@ band_colors = {
 METHOD_DISPLAY = {"multitaper": "Multitaper", "welch": "Welch"}
 
 # -----------------------------
-# PSD Analyzer Class
+# PSD Analyzer Class (Fixed for your data)
 # -----------------------------
 
 class PSDAnalyzer:
@@ -61,9 +52,9 @@ class PSDAnalyzer:
         loaded = np.load(data_file, allow_pickle=True)
         self.all_data = loaded['data'].tolist()
 
-        # Extract metadata
+        # Extract clean metadata — ignore med_state (always 'unknown')
         self.subjects_list = sorted({d['subject'] for d in self.all_data})
-        self.conditions_list = sorted({f"{d['condition']}_{d['med_state']}" 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
@@ -84,7 +75,7 @@ class PSDAnalyzer:
 
         for entry in self.all_data:
             subject = entry['subject']
-            cond_key = f"{entry['condition']}_{entry['med_state']}"
+            cond_key = entry['condition']  # ✅ clean key, no med_state
             for result in entry['results']:
                 region_name = result['region_name']
                 for method in ['multitaper', 'welch']:
@@ -98,9 +89,8 @@ class PSDAnalyzer:
                             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_delta):
-        """Generate Plotly figure with optional Delta-band alignment."""
+        """Generate Plotly figure."""
         fig = go.Figure()
         freq_range = (1, 100)
 
@@ -114,18 +104,21 @@ class PSDAnalyzer:
         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 data within global frequency range
+            # Filter to global freq range
             filtered_data = []
             for item in data:
-                mask_full = (item['freqs'] >= freq_range[0]) & (item['freqs'] <= freq_range[1])
-                if np.any(mask_full):
+                mask = (item['freqs'] >= freq_range[0]) & (item['freqs'] <= freq_range[1])
+                if np.any(mask):
                     filtered_data.append({
-                        'freqs': item['freqs'][mask_full],
-                        'psd': item['psd'][mask_full],
+                        'freqs': item['freqs'][mask],
+                        'psd': item['psd'][mask],
                         'subject': item['subject']
                     })
 
@@ -139,20 +132,16 @@ class PSDAnalyzer:
                 freqs = filtered_data[0]['freqs']
                 psds = np.array([item['psd'] for item in filtered_data])
 
-                # Apply Delta band alignment?
                 if align_by_delta:
                     delta_mask = (freqs >= 1) & (freqs <= 4)
                     if np.any(delta_mask):
                         delta_mean = np.mean(psds[:, delta_mask], axis=1, keepdims=True)
-                        # Avoid division by zero
                         delta_mean[delta_mean == 0] = 1e-9
                         psds = psds / delta_mean
                     else:
-                        # Fallback: normalize by global mean
                         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_delta:
                     label += " [Δ-norm]"
@@ -172,13 +161,12 @@ class PSDAnalyzer:
                 for item in subject_data:
                     freqs, psd = item['freqs'], item['psd']
 
-                    # Apply Delta band normalization per subject
                     if align_by_delta:
                         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)  # Prevent division by zero
+                            psd = psd / (np.mean(psd) + 1e-9)
 
                     label = f"{condition_labels.get(condition, condition)} - {item['subject']}"
                     if align_by_delta:
@@ -201,65 +189,42 @@ class PSDAnalyzer:
             )
             return fig
 
-        # ==============================
-        # Frequency Band Visualization
-        # ==============================
+        # Frequency band shading
         if show_bands:
-            # Add shaded band regions using paper coordinates (so they don't affect scaling)
             for band, (low, high) in FREQ_BANDS.items():
-                # Only show band if it overlaps with visible freq range
                 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])
-
-                # Add shaded rectangle in paper space (full height, behind data)
                 fig.add_shape(
                     type="rect",
-                    x0=band_low,
-                    x1=band_high,
-                    y0=0,
-                    y1=1,
-                    xref="x",
-                    yref="paper",
+                    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,
                 )
-
-                # Add label above the plot (outside the plotting area)
                 center_x = (band_low + band_high) / 2
                 fig.add_annotation(
-                    x=center_x,
-                    y=1.02,  # Just above the top of the plot
+                    x=center_x, y=1.02,
                     text=band,
                     showarrow=False,
                     font=dict(size=9, color="dimgray"),
-                    xanchor="center",
-                    yanchor="bottom",
-                    xref="x",
-                    yref="paper",
+                    xanchor="center", yanchor="bottom",
+                    xref="x", yref="paper",
                     opacity=0.85,
                 )
 
-            # Add vertical dotted lines at band boundaries (only once per edge)
             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", width=1, dash="dot"),
-                            opacity=0.5,
-                            layer="below"
-                        )
+                        fig.add_vline(x=edge, line=dict(color="lightgray", dash="dot"), opacity=0.5)
                         seen_edges.add(edge)
 
-        # ==============================
-        # ✅ FIXED: Lock axis ranges to prevent distortion
-        # ==============================
+        # Final layout
         yaxis_title = "Power"
         if align_by_delta:
             yaxis_title = "Power (norm. to Delta)"
@@ -281,15 +246,14 @@ class PSDAnalyzer:
             ),
             margin=dict(r=160, t=60, b=80, l=60),
             hovermode='x unified',
-            # 🔒 CRITICAL: Lock axis ranges to prevent visual distortion
             xaxis=dict(
                 range=[freq_range[0], freq_range[1]],
-                fixedrange=True,  # Prevents zoom/pan from UI, but more importantly — stops auto-resize
+                fixedrange=True,
                 showgrid=True, gridwidth=1, gridcolor='rgba(128,128,128,0.2)',
                 showline=True, linewidth=1, linecolor='gray'
             ),
             yaxis=dict(
-                fixedrange=True,  # Stops Plotly from auto-resizing y-axis when shapes are added
+                fixedrange=True,
                 showgrid=True, gridwidth=1, gridcolor='rgba(128,128,128,0.2)',
                 showline=True, linewidth=1, linecolor='gray'
             )
@@ -310,14 +274,14 @@ def create_app(analyzer: PSDAnalyzer):
     ) as demo:
         gr.Markdown("# 📊 Power Spectral Density Analysis Dashboard")
         gr.Markdown("""
-> **Color Guide**:  
-> - **Bold/Dark colors** = ON state  
-> - **Lighter colors** = OFF state
+> **Conditions**:  
+> - 🔥 **Bima Task**  
+> - 🟢 **Rest (Eyes Open)**  
+> - 🟣 **Rest (Eyes Closed)**
 >
 > 💡 Tip: Use _'Align by Delta'_ to compare spectral shapes across conditions.
 """)
 
-        # TOP ROW: Data Selection
         with gr.Row():
             with gr.Column(scale=1):
                 subjects = gr.CheckboxGroup(
@@ -334,40 +298,26 @@ def create_app(analyzer: PSDAnalyzer):
                     interactive=True
                 )
 
-        # CENTER: BIG PSD PLOT
         with gr.Row():
-            plot_output = gr.Plot(
-                label="PSD Plot",
-                elem_classes="big-plot"
-            )
+            plot_output = gr.Plot(label="PSD Plot", elem_classes="big-plot")
 
-        # BOTTOM ROW: Display Options
         with gr.Row():
-            with gr.Column():
-                log_scale = gr.Checkbox(value=True, label="Use Log Scale (Y-axis)")
-            with gr.Column():
-                show_bands = gr.Checkbox(value=True, label="Show Frequency Bands")
-            with gr.Column():
-                align_by_delta = gr.Checkbox(value=False, label="Align by Delta (1–4 Hz)")
-
-        # BOTTOM ROW: Method and Region
+            log_scale = gr.Checkbox(value=True, label="Use Log Scale (Y-axis)")
+            show_bands = gr.Checkbox(value=True, label="Show Frequency Bands")
+            align_by_delta = gr.Checkbox(value=False, label="Align by Delta (1–4 Hz)")
+
         with gr.Row():
-            with gr.Column(min_width=200):
-                method = gr.Radio(
-                    choices=["multitaper", "welch"],
-                    value="multitaper",
-                    label="PSD Method",
-                    interactive=True
-                )
-            with gr.Column(min_width=200):
-                region = gr.Dropdown(
-                    choices=analyzer.region_names,
-                    value=analyzer.region_names[0],
-                    label="Brain Region",
-                    interactive=True
-                )
+            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"
+            )
 
-        # Update plot whenever any input changes
         inputs = [region, method, conditions, subjects, log_scale, show_bands, align_by_delta]
         for comp in inputs:
             comp.change(fn=analyzer.create_plot, inputs=inputs, outputs=plot_output)
@@ -381,7 +331,7 @@ def create_app(analyzer: PSDAnalyzer):
 # -----------------------------
 
 if __name__ == "__main__":
-    DATA_PATH = "psd_voxel_all_data.npz"
+    DATA_PATH = "/home/jaizor/jaizor/xtra/derivatives/psd_voxel_cache/psd_voxel_all_data.npz"
     analyzer = PSDAnalyzer(DATA_PATH)
     app = create_app(analyzer)
     app.launch(share=True, show_error=True)