EEGCrystalMaker.py

#!/usr/bin/env python3
"""

EEG Crystal Maker

=================



Standalone GUI for growing neural crystal lattices from EEG data.



Features:

- Load any EDF file

- Set resolution (32x32 to 2048x2048)

- Watch crystallization in real-time

- Save crystal state + pin map

- Load and continue growing



The crystal lattice is a 2D Izhikevich neuron sheet with STDP plasticity.

EEG electrodes inject current at mapped positions (the "pins").

Over time, the coupling weights crystallize into a structure that

reflects the EEG's spatiotemporal patterns.



Output:

- .npz file containing:

  - weights (4 directional coupling matrices)

  - pin_coords (electrode positions on grid)

  - pin_names (electrode labels)

  - metadata (resolution, training steps, etc.)



Author: Built for Antti's consciousness crystallography research

"""

import sys
import os
import re
import json
import numpy as np
from datetime import datetime

from PyQt6.QtWidgets import (
    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
    QPushButton, QLabel, QSpinBox, QDoubleSpinBox, QFileDialog,
    QProgressBar, QGroupBox, QGridLayout, QComboBox, QCheckBox,
    QSlider, QFrame, QMessageBox, QStatusBar
)
from PyQt6.QtCore import Qt, QTimer
from PyQt6.QtGui import QImage, QPixmap, QPainter, QColor, QFont

import cv2

try:
    import mne
    MNE_AVAILABLE = True
except ImportError:
    MNE_AVAILABLE = False
    print("Warning: MNE not installed. EEG loading will not work.")


class CrystalLattice:
    """The neural crystal - Izhikevich sheet with STDP."""
    
    def __init__(self, grid_size=64):
        self.grid_size = grid_size
        self.init_arrays()
        
        # Izhikevich parameters
        self.a = 0.02
        self.b = 0.2
        self.c = -65.0
        self.d = 8.0
        self.dt = 0.5
        
        # STDP parameters
        self.learning_rate = 0.005
        self.trace_decay = 0.95
        self.weight_max = 2.0
        self.weight_min = 0.01
        
        # Coupling strength - how much neighbors influence each other
        self.coupling_strength = 5.0  # Higher = more spread
        
        # Statistics
        self.total_spikes = 0
        self.learning_steps = 0
        
    def init_arrays(self):
        """Initialize all arrays to current grid_size."""
        n = self.grid_size
        
        # Neural state
        self.v = np.ones((n, n), dtype=np.float32) * -65.0
        self.u = self.v * 0.2
        
        # Crystal weights (4 directions)
        self.weights_up = np.ones((n, n), dtype=np.float32) * 0.5
        self.weights_down = np.ones((n, n), dtype=np.float32) * 0.5
        self.weights_left = np.ones((n, n), dtype=np.float32) * 0.5
        self.weights_right = np.ones((n, n), dtype=np.float32) * 0.5
        
        # Spike trace for STDP
        self.spike_trace = np.zeros((n, n), dtype=np.float32)
        
    def resize(self, new_size):
        """Resize the lattice (resets state)."""
        self.grid_size = new_size
        self.init_arrays()
        self.total_spikes = 0
        self.learning_steps = 0
        
    def step(self, input_current, learning=True):
        """One simulation step with optional STDP learning."""
        v = self.v
        u = self.u
        I = input_current
        
        # Clamp input to prevent explosion
        I = np.clip(I, -100, 100)
        
        # Neighbor coupling
        v_up = np.roll(v, -1, axis=0)
        v_down = np.roll(v, 1, axis=0)
        v_left = np.roll(v, -1, axis=1)
        v_right = np.roll(v, 1, axis=1)
        
        neighbor_influence = (
            self.weights_up * v_up +
            self.weights_down * v_down +
            self.weights_left * v_left +
            self.weights_right * v_right
        )
        total_weight = (self.weights_up + self.weights_down + 
                       self.weights_left + self.weights_right)
        neighbor_avg = neighbor_influence / (total_weight + 1e-6)
        
        I_coupling = self.coupling_strength * (neighbor_avg - v)
        I_coupling = np.clip(I_coupling, -50, 50)  # Prevent coupling explosion
        
        # Izhikevich dynamics
        dv = (0.04 * v * v + 5.0 * v + 140.0 - u + I + I_coupling) * self.dt
        du = self.a * (self.b * v - u) * self.dt
        
        v = v + dv
        u = u + du
        
        # Clamp voltage to sane range (prevents NaN cascade)
        v = np.clip(v, -100, 50)
        u = np.clip(u, -50, 50)
        
        # Handle any NaN that slipped through
        v = np.nan_to_num(v, nan=self.c, posinf=30.0, neginf=-100.0)
        u = np.nan_to_num(u, nan=self.c * self.b, posinf=20.0, neginf=-20.0)
        
        # Spikes
        spikes = v >= 30.0
        v[spikes] = self.c
        u[spikes] += self.d
        
        self.v = v
        self.u = u
        self.total_spikes += np.sum(spikes)
        
        # STDP
        if learning and self.learning_rate > 0:
            self.learning_steps += 1
            
            self.spike_trace *= self.trace_decay
            self.spike_trace[spikes] = 1.0
            
            trace_up = np.roll(self.spike_trace, -1, axis=0)
            trace_down = np.roll(self.spike_trace, 1, axis=0)
            trace_left = np.roll(self.spike_trace, -1, axis=1)
            trace_right = np.roll(self.spike_trace, 1, axis=1)
            
            spike_float = spikes.astype(np.float32)
            lr = self.learning_rate
            
            # Potentiation
            dw_up = lr * spike_float * trace_up
            dw_down = lr * spike_float * trace_down
            dw_left = lr * spike_float * trace_left
            dw_right = lr * spike_float * trace_right
            
            # Depression
            spike_up = np.roll(spike_float, -1, axis=0)
            spike_down = np.roll(spike_float, 1, axis=0)
            spike_left = np.roll(spike_float, -1, axis=1)
            spike_right = np.roll(spike_float, 1, axis=1)
            
            dw_up -= 0.5 * lr * self.spike_trace * spike_up
            dw_down -= 0.5 * lr * self.spike_trace * spike_down
            dw_left -= 0.5 * lr * self.spike_trace * spike_left
            dw_right -= 0.5 * lr * self.spike_trace * spike_right
            
            self.weights_up = np.clip(self.weights_up + dw_up, self.weight_min, self.weight_max)
            self.weights_down = np.clip(self.weights_down + dw_down, self.weight_min, self.weight_max)
            self.weights_left = np.clip(self.weights_left + dw_left, self.weight_min, self.weight_max)
            self.weights_right = np.clip(self.weights_right + dw_right, self.weight_min, self.weight_max)
        
        return spikes
    
    def get_energy(self):
        """Total weight energy."""
        return float(np.sum(self.weights_up) + np.sum(self.weights_down) + 
                    np.sum(self.weights_left) + np.sum(self.weights_right))
    
    def get_entropy(self):
        """Weight distribution entropy."""
        all_weights = np.concatenate([
            self.weights_up.flatten(),
            self.weights_down.flatten(),
            self.weights_left.flatten(),
            self.weights_right.flatten()
        ])
        w_norm = all_weights / (np.sum(all_weights) + 1e-9)
        return float(-np.sum(w_norm * np.log(w_norm + 1e-9)))
    
    def render_activity(self, size=256):
        """Render activity as image."""
        disp = np.clip(self.v, -90.0, 40.0)
        disp = np.nan_to_num(disp, nan=-65.0, posinf=40.0, neginf=-90.0)
        norm = ((disp + 90.0) / 130.0 * 255.0).astype(np.uint8)
        heat = cv2.applyColorMap(norm, cv2.COLORMAP_INFERNO)
        heat = cv2.resize(heat, (size, size), interpolation=cv2.INTER_NEAREST)
        return cv2.cvtColor(heat, cv2.COLOR_BGR2RGB)
    
    def render_crystal(self, size=256):
        """Render crystal structure as image."""
        horizontal = (self.weights_left + self.weights_right) / 2
        vertical = (self.weights_up + self.weights_down) / 2
        
        h_norm = (horizontal - self.weight_min) / (self.weight_max - self.weight_min)
        v_norm = (vertical - self.weight_min) / (self.weight_max - self.weight_min)
        anisotropy = np.abs(h_norm - v_norm)
        
        img = np.zeros((self.grid_size, self.grid_size, 3), dtype=np.uint8)
        img[:, :, 0] = (h_norm * 255).astype(np.uint8)
        img[:, :, 1] = ((1 - anisotropy) * 255).astype(np.uint8)
        img[:, :, 2] = (v_norm * 255).astype(np.uint8)
        
        return cv2.resize(img, (size, size), interpolation=cv2.INTER_NEAREST)


class EEGSource:
    """Handles EEG loading and electrode mapping."""
    
    STANDARD_MAP = {
        "FP1": (0.30, 0.10), "FP2": (0.70, 0.10),
        "F7": (0.10, 0.30), "F3": (0.30, 0.30), "FZ": (0.50, 0.25),
        "F4": (0.70, 0.30), "F8": (0.90, 0.30),
        "T7": (0.10, 0.50), "T3": (0.10, 0.50),  # T3 alias
        "C3": (0.30, 0.50), "CZ": (0.50, 0.50),
        "C4": (0.70, 0.50), "T8": (0.90, 0.50), "T4": (0.90, 0.50),  # T4 alias
        "P7": (0.10, 0.70), "T5": (0.10, 0.70),  # T5 alias
        "P3": (0.30, 0.70), "PZ": (0.50, 0.75),
        "P4": (0.70, 0.70), "P8": (0.90, 0.70), "T6": (0.90, 0.70),  # T6 alias
        "O1": (0.35, 0.90), "OZ": (0.50, 0.90), "O2": (0.65, 0.90),
        "A1": (0.05, 0.50), "A2": (0.95, 0.50),  # Ear references
    }
    
    def __init__(self):
        self.raw = None
        self.data = None
        self.sfreq = 256.0
        self.ch_names = []
        self.current_idx = 0
        self.amplification = 1e9  # Default amplification (Medium)
        
        # Pin mapping
        self.pin_coords = []  # (row, col) for each channel
        self.pin_names = []   # Channel names
        self.pin_indices = [] # Channel indices in data
        
    def load(self, filepath):
        """Load EDF file."""
        if not MNE_AVAILABLE:
            raise RuntimeError("MNE not installed")
        
        raw = mne.io.read_raw_edf(filepath, preload=True, verbose=False)
        
        try:
            raw.pick_types(eeg=True, meg=False, eog=False, ecg=False, 
                          emg=False, misc=False, stim=False)
        except:
            pass
        
        if raw.info["sfreq"] > 256:
            raw.resample(256, npad="auto", verbose=False)
        
        self.raw = raw
        self.data = raw.get_data()
        self.sfreq = float(raw.info["sfreq"])
        self.ch_names = list(raw.ch_names)
        self.current_idx = 0
        
        return len(self.ch_names), self.data.shape[1]
    
    def map_electrodes(self, grid_size):
        """Map electrodes to grid positions."""
        self.pin_coords = []
        self.pin_names = []
        self.pin_indices = []
        
        for idx, name in enumerate(self.ch_names):
            clean = re.sub(r'[^A-Z0-9]', '', name.upper())
            
            pos = None
            # Try exact match first
            for std_name, std_pos in self.STANDARD_MAP.items():
                if std_name in clean or clean in std_name:
                    pos = std_pos
                    break
            
            # Try prefix match
            if pos is None:
                for std_name, std_pos in self.STANDARD_MAP.items():
                    if len(clean) >= 2 and clean[:2] == std_name[:2]:
                        pos = std_pos
                        break
            
            if pos:
                grid_r = int(pos[1] * (grid_size - 1))
                grid_c = int(pos[0] * (grid_size - 1))
                self.pin_coords.append((grid_r, grid_c))
                self.pin_names.append(name)
                self.pin_indices.append(idx)
        
        return len(self.pin_coords)
    
    def get_input_current(self, grid_size):
        """Get input current for one timestep."""
        if self.data is None:
            return np.zeros((grid_size, grid_size), dtype=np.float32)
        
        n_samples = self.data.shape[1]
        sample_idx = self.current_idx % n_samples
        self.current_idx += 1
        
        I = np.zeros((grid_size, grid_size), dtype=np.float32)
        
        # Small spread - electrodes are injection points
        # The coupling between neurons spreads activity, not the electrode radius
        spread_radius = max(2, grid_size // 128)  # ~8 at 1024, ~2 at 256
        spread_sigma = max(1.0, spread_radius / 2.0)
        
        # Pre-compute Gaussian kernel once
        kernel_size = spread_radius * 2 + 1
        y, x = np.ogrid[-spread_radius:spread_radius+1, -spread_radius:spread_radius+1]
        kernel = np.exp(-(x*x + y*y) / (2 * spread_sigma * spread_sigma)).astype(np.float32)
        
        for i, ch_idx in enumerate(self.pin_indices):
            if i < len(self.pin_coords):
                r, c = self.pin_coords[i]
                val = self.data[ch_idx, sample_idx]
                
                # Scale EEG
                scaled = float(val) * self.amplification
                scaled = np.clip(scaled, -500, 500)
                
                # Calculate bounds for kernel placement
                r_start = max(0, r - spread_radius)
                r_end = min(grid_size, r + spread_radius + 1)
                c_start = max(0, c - spread_radius)
                c_end = min(grid_size, c + spread_radius + 1)
                
                # Corresponding kernel bounds
                kr_start = r_start - (r - spread_radius)
                kr_end = kernel_size - ((r + spread_radius + 1) - r_end)
                kc_start = c_start - (c - spread_radius)
                kc_end = kernel_size - ((c + spread_radius + 1) - c_end)
                
                # Add weighted kernel to input
                I[r_start:r_end, c_start:c_end] += scaled * kernel[kr_start:kr_end, kc_start:kc_end]
        
        return I


class CrystalMakerWindow(QMainWindow):
    """Main GUI window."""
    
    def __init__(self):
        super().__init__()
        self.setWindowTitle("EEG Crystal Maker")
        self.setMinimumSize(1000, 700)
        
        # Core objects
        self.crystal = CrystalLattice(64)
        self.eeg = EEGSource()
        
        # State
        self.is_running = False
        self.eeg_loaded = False
        self.edf_path = ""
        
        # Timer for simulation
        self.timer = QTimer()
        self.timer.timeout.connect(self.simulation_step)
        
        self.setup_ui()
        self.update_display()
        
    def setup_ui(self):
        """Build the UI."""
        central = QWidget()
        self.setCentralWidget(central)
        layout = QHBoxLayout(central)
        
        # Left panel - controls
        left_panel = QVBoxLayout()
        layout.addLayout(left_panel, stretch=1)
        
        # EEG Loading
        eeg_group = QGroupBox("EEG Source")
        eeg_layout = QVBoxLayout(eeg_group)
        
        self.edf_label = QLabel("No file loaded")
        self.edf_label.setWordWrap(True)
        eeg_layout.addWidget(self.edf_label)
        
        load_btn = QPushButton("Load EDF File...")
        load_btn.clicked.connect(self.load_edf)
        eeg_layout.addWidget(load_btn)
        
        self.eeg_info = QLabel("Channels: -\nSamples: -\nPins mapped: -")
        eeg_layout.addWidget(self.eeg_info)
        
        left_panel.addWidget(eeg_group)
        
        # Crystal Settings
        crystal_group = QGroupBox("Crystal Settings")
        crystal_layout = QGridLayout(crystal_group)
        
        crystal_layout.addWidget(QLabel("Resolution:"), 0, 0)
        self.resolution_combo = QComboBox()
        self.resolution_combo.addItems(["32", "64", "128", "256", "512", "1024"])
        self.resolution_combo.setCurrentText("64")
        self.resolution_combo.currentTextChanged.connect(self.on_resolution_changed)
        crystal_layout.addWidget(self.resolution_combo, 0, 1)
        
        crystal_layout.addWidget(QLabel("Learning Rate:"), 1, 0)
        self.lr_spin = QDoubleSpinBox()
        self.lr_spin.setRange(0.0001, 0.1)
        self.lr_spin.setSingleStep(0.001)
        self.lr_spin.setValue(0.005)
        self.lr_spin.valueChanged.connect(self.on_lr_changed)
        crystal_layout.addWidget(self.lr_spin, 1, 1)
        
        crystal_layout.addWidget(QLabel("EEG Amplification:"), 2, 0)
        self.amp_combo = QComboBox()
        self.amp_combo.addItems(["1e8 (Low)", "1e9 (Medium)", "1e10 (High)", "1e11 (Very High)"])
        self.amp_combo.setCurrentIndex(1)  # Default to Medium
        self.amp_combo.currentIndexChanged.connect(self.on_amp_changed)
        crystal_layout.addWidget(self.amp_combo, 2, 1)
        
        crystal_layout.addWidget(QLabel("Coupling Strength:"), 3, 0)
        self.coupling_spin = QDoubleSpinBox()
        self.coupling_spin.setRange(0.1, 20.0)
        self.coupling_spin.setSingleStep(0.5)
        self.coupling_spin.setValue(5.0)
        self.coupling_spin.valueChanged.connect(self.on_coupling_changed)
        crystal_layout.addWidget(self.coupling_spin, 3, 1)
        
        crystal_layout.addWidget(QLabel("Target Steps:"), 4, 0)
        self.target_steps_spin = QSpinBox()
        self.target_steps_spin.setRange(100, 100000)
        self.target_steps_spin.setSingleStep(100)
        self.target_steps_spin.setValue(800)
        crystal_layout.addWidget(self.target_steps_spin, 4, 1)
        
        left_panel.addWidget(crystal_group)
        
        # Simulation Control
        control_group = QGroupBox("Simulation")
        control_layout = QVBoxLayout(control_group)
        
        btn_layout = QHBoxLayout()
        self.start_btn = QPushButton("▶ Start")
        self.start_btn.clicked.connect(self.toggle_simulation)
        btn_layout.addWidget(self.start_btn)
        
        self.reset_btn = QPushButton("↺ Reset")
        self.reset_btn.clicked.connect(self.reset_crystal)
        btn_layout.addWidget(self.reset_btn)
        control_layout.addLayout(btn_layout)
        
        # Speed slider
        speed_layout = QHBoxLayout()
        speed_layout.addWidget(QLabel("Speed:"))
        self.speed_slider = QSlider(Qt.Orientation.Horizontal)
        self.speed_slider.setRange(1, 100)
        self.speed_slider.setValue(50)
        self.speed_slider.valueChanged.connect(self.on_speed_changed)
        speed_layout.addWidget(self.speed_slider)
        control_layout.addLayout(speed_layout)
        
        # Progress
        self.progress_bar = QProgressBar()
        self.progress_bar.setRange(0, 800)
        control_layout.addWidget(self.progress_bar)
        
        left_panel.addWidget(control_group)
        
        # Statistics
        stats_group = QGroupBox("Statistics")
        stats_layout = QVBoxLayout(stats_group)
        
        self.stats_label = QLabel("Steps: 0\nSpikes: 0\nEnergy: 0\nEntropy: 0")
        self.stats_label.setFont(QFont("Monospace", 10))
        stats_layout.addWidget(self.stats_label)
        
        left_panel.addWidget(stats_group)
        
        # Save/Load
        file_group = QGroupBox("File Operations")
        file_layout = QVBoxLayout(file_group)
        
        save_btn = QPushButton("💾 Save Crystal...")
        save_btn.clicked.connect(self.save_crystal)
        file_layout.addWidget(save_btn)
        
        load_crystal_btn = QPushButton("📂 Load Crystal...")
        load_crystal_btn.clicked.connect(self.load_crystal)
        file_layout.addWidget(load_crystal_btn)
        
        left_panel.addWidget(file_group)
        
        left_panel.addStretch()
        
        # Right panel - visualization
        right_panel = QVBoxLayout()
        layout.addLayout(right_panel, stretch=2)
        
        # Activity view
        activity_group = QGroupBox("Neural Activity")
        activity_layout = QVBoxLayout(activity_group)
        self.activity_label = QLabel()
        self.activity_label.setMinimumSize(400, 400)
        self.activity_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.activity_label.setStyleSheet("background-color: #1a1a1a;")
        activity_layout.addWidget(self.activity_label)
        right_panel.addWidget(activity_group)
        
        # Crystal view
        crystal_view_group = QGroupBox("Crystal Structure")
        crystal_view_layout = QVBoxLayout(crystal_view_group)
        self.crystal_label = QLabel()
        self.crystal_label.setMinimumSize(400, 400)
        self.crystal_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.crystal_label.setStyleSheet("background-color: #1a1a1a;")
        crystal_view_layout.addWidget(self.crystal_label)
        right_panel.addWidget(crystal_view_group)
        
        # Status bar
        self.status_bar = QStatusBar()
        self.setStatusBar(self.status_bar)
        self.status_bar.showMessage("Ready - Load an EDF file to begin")
        
    def load_edf(self):
        """Load EDF file dialog."""
        filepath, _ = QFileDialog.getOpenFileName(
            self, "Open EDF File", "", "EDF Files (*.edf);;All Files (*)"
        )
        if filepath:
            try:
                n_channels, n_samples = self.eeg.load(filepath)
                n_pins = self.eeg.map_electrodes(self.crystal.grid_size)
                
                self.edf_path = filepath
                self.eeg_loaded = True
                
                fname = os.path.basename(filepath)
                self.edf_label.setText(f"Loaded: {fname}")
                self.eeg_info.setText(
                    f"Channels: {n_channels}\n"
                    f"Samples: {n_samples}\n"
                    f"Pins mapped: {n_pins}"
                )
                self.status_bar.showMessage(f"Loaded {fname} - {n_pins} electrodes mapped")
                
            except Exception as e:
                QMessageBox.critical(self, "Error", f"Failed to load EDF:\n{str(e)}")
    
    def on_resolution_changed(self, text):
        """Handle resolution change."""
        new_size = int(text)
        if new_size != self.crystal.grid_size:
            self.crystal.resize(new_size)
            if self.eeg_loaded:
                n_pins = self.eeg.map_electrodes(new_size)
                self.eeg_info.setText(
                    f"Channels: {len(self.eeg.ch_names)}\n"
                    f"Samples: {self.eeg.data.shape[1]}\n"
                    f"Pins mapped: {n_pins}"
                )
            self.update_display()
            self.status_bar.showMessage(f"Resolution changed to {new_size}x{new_size}")
    
    def on_lr_changed(self, value):
        """Handle learning rate change."""
        self.crystal.learning_rate = value
    
    def on_amp_changed(self, index):
        """Handle amplification change."""
        amp_values = [1e8, 1e9, 1e10, 1e11]
        self.eeg.amplification = amp_values[index]
        self.status_bar.showMessage(f"Amplification set to {amp_values[index]:.0e}")
    
    def on_coupling_changed(self, value):
        """Handle coupling strength change."""
        self.crystal.coupling_strength = value
    
    def on_speed_changed(self, value):
        """Handle speed slider change."""
        if self.is_running:
            # Map 1-100 to 100ms-1ms interval
            interval = max(1, 101 - value)
            self.timer.setInterval(interval)
    
    def toggle_simulation(self):
        """Start/stop simulation."""
        if not self.eeg_loaded:
            QMessageBox.warning(self, "Warning", "Please load an EDF file first.")
            return
        
        if self.is_running:
            self.timer.stop()
            self.is_running = False
            self.start_btn.setText("▶ Start")
            self.status_bar.showMessage("Simulation paused")
        else:
            interval = max(1, 101 - self.speed_slider.value())
            self.timer.start(interval)
            self.is_running = True
            self.start_btn.setText("⏸ Pause")
            self.status_bar.showMessage("Simulation running...")
    
    def simulation_step(self):
        """One step of simulation."""
        I = self.eeg.get_input_current(self.crystal.grid_size)
        self.crystal.step(I, learning=True)
        
        # Update progress
        target = self.target_steps_spin.value()
        self.progress_bar.setMaximum(target)
        self.progress_bar.setValue(min(self.crystal.learning_steps, target))
        
        # Update display every few steps for performance
        if self.crystal.learning_steps % 5 == 0:
            self.update_display()
        
        # Auto-stop at target
        if self.crystal.learning_steps >= target:
            self.toggle_simulation()
            self.status_bar.showMessage(f"Completed {target} steps - Crystal ready to save!")
    
    def reset_crystal(self):
        """Reset crystal to initial state."""
        self.crystal.init_arrays()
        self.crystal.total_spikes = 0
        self.crystal.learning_steps = 0
        if self.eeg_loaded:
            self.eeg.current_idx = 0
        self.update_display()
        self.status_bar.showMessage("Crystal reset")
    
    def update_display(self):
        """Update visualization."""
        # Activity
        activity_img = self.crystal.render_activity(400)
        
        # Draw electrode pins on activity
        if self.eeg_loaded:
            scale = 400 / self.crystal.grid_size
            for r, c in self.eeg.pin_coords:
                x, y = int(c * scale), int(r * scale)
                cv2.circle(activity_img, (x, y), 3, (0, 255, 0), -1)
        
        h, w, ch = activity_img.shape
        qimg = QImage(activity_img.data, w, h, w * ch, QImage.Format.Format_RGB888)
        self.activity_label.setPixmap(QPixmap.fromImage(qimg))
        
        # Crystal
        crystal_img = self.crystal.render_crystal(400)
        h, w, ch = crystal_img.shape
        qimg = QImage(crystal_img.data, w, h, w * ch, QImage.Format.Format_RGB888)
        self.crystal_label.setPixmap(QPixmap.fromImage(qimg))
        
        # Stats
        self.stats_label.setText(
            f"Steps: {self.crystal.learning_steps}\n"
            f"Spikes: {self.crystal.total_spikes:,}\n"
            f"Energy: {self.crystal.get_energy():.1f}\n"
            f"Entropy: {self.crystal.get_entropy():.2f}"
        )
        
        self.progress_bar.setValue(self.crystal.learning_steps)
    
    def save_crystal(self):
        """Save crystal to file."""
        if self.crystal.learning_steps == 0:
            QMessageBox.warning(self, "Warning", "No crystal to save - run some training first.")
            return
        
        default_name = f"crystal_{self.crystal.grid_size}x{self.crystal.grid_size}_{self.crystal.learning_steps}steps.npz"
        filepath, _ = QFileDialog.getSaveFileName(
            self, "Save Crystal", default_name, "NumPy Archive (*.npz);;All Files (*)"
        )
        
        if filepath:
            try:
                # Prepare pin data
                pin_coords = np.array(self.eeg.pin_coords) if self.eeg.pin_coords else np.array([])
                pin_names = np.array(self.eeg.pin_names) if self.eeg.pin_names else np.array([])
                
                np.savez(filepath,
                    # Weights
                    weights_up=self.crystal.weights_up,
                    weights_down=self.crystal.weights_down,
                    weights_left=self.crystal.weights_left,
                    weights_right=self.crystal.weights_right,
                    # Pin map
                    pin_coords=pin_coords,
                    pin_names=pin_names,
                    # Metadata
                    grid_size=self.crystal.grid_size,
                    learning_steps=self.crystal.learning_steps,
                    total_spikes=self.crystal.total_spikes,
                    learning_rate=self.crystal.learning_rate,
                    edf_source=os.path.basename(self.edf_path) if self.edf_path else "",
                    created=datetime.now().isoformat()
                )
                
                self.status_bar.showMessage(f"Saved crystal to {os.path.basename(filepath)}")
                
            except Exception as e:
                QMessageBox.critical(self, "Error", f"Failed to save:\n{str(e)}")
    
    def load_crystal(self):
        """Load crystal from file."""
        filepath, _ = QFileDialog.getOpenFileName(
            self, "Load Crystal", "", "NumPy Archive (*.npz);;All Files (*)"
        )
        
        if filepath:
            try:
                data = np.load(filepath, allow_pickle=True)
                
                # Get grid size and resize
                grid_size = int(data['grid_size'])
                self.crystal.resize(grid_size)
                self.resolution_combo.setCurrentText(str(grid_size))
                
                # Load weights
                self.crystal.weights_up = data['weights_up']
                self.crystal.weights_down = data['weights_down']
                self.crystal.weights_left = data['weights_left']
                self.crystal.weights_right = data['weights_right']
                
                # Load stats
                self.crystal.learning_steps = int(data['learning_steps'])
                self.crystal.total_spikes = int(data['total_spikes'])
                if 'learning_rate' in data:
                    self.crystal.learning_rate = float(data['learning_rate'])
                    self.lr_spin.setValue(self.crystal.learning_rate)
                
                # Load pin map
                if 'pin_coords' in data and len(data['pin_coords']) > 0:
                    self.eeg.pin_coords = [tuple(c) for c in data['pin_coords']]
                    self.eeg.pin_names = list(data['pin_names'])
                
                self.update_display()
                self.status_bar.showMessage(f"Loaded crystal from {os.path.basename(filepath)}")
                
            except Exception as e:
                QMessageBox.critical(self, "Error", f"Failed to load:\n{str(e)}")


def main():
    app = QApplication(sys.argv)
    app.setStyle("Fusion")
    
    # Dark theme
    palette = app.palette()
    palette.setColor(palette.ColorRole.Window, QColor(53, 53, 53))
    palette.setColor(palette.ColorRole.WindowText, QColor(255, 255, 255))
    palette.setColor(palette.ColorRole.Base, QColor(25, 25, 25))
    palette.setColor(palette.ColorRole.AlternateBase, QColor(53, 53, 53))
    palette.setColor(palette.ColorRole.ToolTipBase, QColor(255, 255, 255))
    palette.setColor(palette.ColorRole.ToolTipText, QColor(255, 255, 255))
    palette.setColor(palette.ColorRole.Text, QColor(255, 255, 255))
    palette.setColor(palette.ColorRole.Button, QColor(53, 53, 53))
    palette.setColor(palette.ColorRole.ButtonText, QColor(255, 255, 255))
    palette.setColor(palette.ColorRole.BrightText, QColor(255, 0, 0))
    palette.setColor(palette.ColorRole.Link, QColor(42, 130, 218))
    palette.setColor(palette.ColorRole.Highlight, QColor(42, 130, 218))
    palette.setColor(palette.ColorRole.HighlightedText, QColor(0, 0, 0))
    app.setPalette(palette)
    
    window = CrystalMakerWindow()
    window.show()
    
    sys.exit(app.exec())


if __name__ == "__main__":
    main()