cydms 0.1.0__tar.gz

cydms-0.1.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: cydms
+Version: 0.1.0
+Summary: EEG + MRI source localization library — no FreeSurfer required
+Requires-Python: >=3.8
+Requires-Dist: numpy
+Requires-Dist: nibabel
+Requires-Dist: scipy
+Requires-Dist: scikit-image
+Requires-Dist: mne
+Requires-Dist: pandas
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

cydms-0.1.0/cydms/__init__.py

@@ -0,0 +1,3 @@
+from .analyze import analyze
+
+__all__ = ['analyze']

cydms-0.1.0/cydms/analyze.py

@@ -0,0 +1,51 @@
+"""
+cydms.analyze
+-------------
+Main entry point — รับ MRI + EEG path คืน dict ผลลัพธ์ครบชุด
+"""
+from .mri import process_mri
+from .eeg import load_eeg
+from .source import compute_source_localization, compute_clinical_findings
+
+DISCLAIMER = (
+    "WARNING: This is a preliminary AI-based analysis only. "
+    "Reference ranges are general estimates and may vary by age, condition, "
+    "and recording equipment. Must be confirmed by a qualified physician."
+)
+
+
+def analyze(mri_path, eeg_path, tsv_elec_path=None, **kwargs):
+    debug_log = []
+    warnings  = []
+
+    debug_log.append("🧠 Processing MRI...")
+    mri_result = process_mri(mri_path)
+    debug_log.append(f"🧠 MRI voxel size: {mri_result['voxel_size']:.2f}mm → threshold: {mri_result['threshold_pct']}%")
+
+    debug_log.append("📡 Loading EEG...")
+    raw, eeg_logs, eeg_warnings = load_eeg(eeg_path, tsv_elec_path=tsv_elec_path)
+    debug_log.extend(eeg_logs)
+    warnings.extend(eeg_warnings)
+
+    debug_log.append("🔬 Computing source localization (sLORETA)...")
+    results, waveform, src_logs = compute_source_localization(raw, debug_log=debug_log)
+    debug_log.extend(src_logs)
+
+    findings = compute_clinical_findings(
+        results,
+        mri_result['thickness'],
+        mri_result['asymmetry']
+    )
+
+    return {
+        'verts':             mri_result['verts'],
+        'faces':             mri_result['faces'],
+        'results':           results,
+        'waveform':          waveform,
+        'thickness':         mri_result['thickness'],
+        'asymmetry':         mri_result['asymmetry'],
+        'clinical_findings': findings,
+        'warnings':          warnings,
+        'debug_log':         debug_log,
+        'disclaimer':        DISCLAIMER,
+    }

cydms-0.1.0/cydms/eeg.py

@@ -0,0 +1,277 @@
+"""
+cydms.eeg
+---------
+EEG loading, montage setup, channel matching
+"""
+import numpy as np
+import mne
+import pandas as pd
+import re
+import os
+
+
+def load_eeg(eeg_path, tsv_elec_path=None):
+    debug_log = []
+    warnings = []
+
+    eeg_ext = os.path.splitext(eeg_path)[1].lower()
+    if eeg_ext == '.vhdr':
+        raw = mne.io.read_raw_brainvision(eeg_path, preload=True, verbose=False)
+        debug_log.append("📄 EEG format: BrainVision (.vhdr)")
+    elif eeg_ext == '.edf':
+        raw = mne.io.read_raw_edf(eeg_path, preload=True, verbose=False)
+        debug_log.append("📄 EEG format: EDF (.edf)")
+    elif eeg_ext == '.bdf':
+        raw = mne.io.read_raw_bdf(eeg_path, preload=True, verbose=False)
+        debug_log.append("📄 EEG format: BioSemi (.bdf)")
+    else:
+        try:
+            raw = mne.io.read_raw_eeglab(eeg_path, preload=True, verbose=False)
+            debug_log.append("📄 EEG format: EEGLAB (.set) — raw")
+        except Exception as e_raw:
+            if 'number of trials' in str(e_raw).lower() or 'epochs' in str(e_raw).lower():
+                epochs = mne.io.read_epochs_eeglab(eeg_path, verbose=False)
+                raw = mne.EpochsArray(epochs.get_data(), epochs.info).average().interpolate_bads()
+                raw = mne.io.RawArray(np.tile(raw.data, (1, 10)), raw.info)
+                debug_log.append(f"📄 EEG format: EEGLAB (.set) — epoched ({len(epochs)} trials)")
+                warnings.append("⚠️ Epoched data detected — converted to continuous automatically")
+            else:
+                raise e_raw
+
+    has_builtin_pos = False
+    try:
+        builtin_pos = {ch['ch_name']: ch['loc'][:3] for ch in raw.info['chs']
+                      if not np.all(ch['loc'][:3] == 0) and not np.any(np.isnan(ch['loc'][:3]))}
+        if len(builtin_pos) >= 3:
+            has_builtin_pos = True
+            debug_log.append(f"✅ พบพิกัดในไฟล์ EEG เลย: {len(builtin_pos)} channels — ไม่ต้องใช้ TSV")
+    except:
+        pass
+
+    debug_log.append(f"⏱️ ใช้ข้อมูลทั้งหมด {raw.times[-1]:.1f}s")
+
+    for ch in raw.ch_names:
+        if any(x in ch.lower() for x in ['heog', 'veog']):
+            raw.set_channel_types({ch: 'eog'})
+
+    applied_tsv = False
+    raw_names_before = list(raw.ch_names)
+
+    if has_builtin_pos:
+        applied_tsv = True
+
+    if not applied_tsv and tsv_elec_path:
+        try:
+            def try_parse_no_separator(lines):
+                rows = []
+                pat = re.compile(
+                    r'([A-Za-z]+\d{1,4}|[A-Za-z]{1,4}\d{0,4})'
+                    r'.*?'
+                    r'(-?\d{1,3}\.\d{1,4})'
+                    r'[\s,]*'
+                    r'(-?\d{1,3}\.\d{1,4})'
+                    r'[\s,]*'
+                    r'(-?\d{1,3}\.\d{1,4})',
+                    re.IGNORECASE
+                )
+                for line in lines:
+                    line = line.strip()
+                    if not line: continue
+                    m = pat.search(line)
+                    if m:
+                        rows.append([m.group(1), m.group(2), m.group(3), m.group(4)])
+                if not rows:
+                    return None
+                df = pd.DataFrame(rows, columns=['name', 'x', 'y', 'z'])
+                return df.replace(['n/a', 'N/A', 'nan'], np.nan)
+
+            def load_file(enc):
+                with open(tsv_elec_path, 'r', encoding=enc, errors='ignore') as f:
+                    lines = [l.strip() for l in f.readlines() if l.strip()]
+                parsed = [list(filter(None, re.split(r'\s+', l))) for l in lines]
+                data_rows = [p for p in parsed if p and str(p[0]).upper() not in ['NAME','LABEL','N/A']]
+                looks_no_sep = data_rows and all(len(p) < 3 for p in data_rows[:5])
+                if looks_no_sep:
+                    df_try = try_parse_no_separator(lines)
+                    if df_try is not None and len(df_try) > 0:
+                        return df_try
+                if not parsed: return pd.DataFrame()
+                df = pd.DataFrame(parsed)
+                first_row = [str(x).lower() for x in parsed[0]]
+                if any(c in first_row for c in ['x', 'y', 'z', 'name', 'label']):
+                    df.columns = df.iloc[0]
+                    df = df[1:].reset_index(drop=True)
+                else:
+                    df.columns = ['name', 'x', 'y', 'z'] + [f'extra_{i}' for i in range(len(df.columns)-4)]
+                return df.replace(['n/a','N/A','nan'], np.nan)
+
+            try:
+                df_elec = load_file('utf-8-sig')
+            except:
+                df_elec = load_file('cp874')
+
+            debug_log.append(f"📄 TSV: อ่านได้ {len(df_elec)} แถว | คอลัมน์: {', '.join(map(str, df_elec.columns.tolist()))}")
+
+            cols_lower = [str(c).lower().strip() for c in df_elec.columns]
+            has_header = any(re.fullmatch(r'x|y|z|name|label|pos_x|pos_y|pos_z', c) for c in cols_lower)
+
+            if not has_header:
+                df_elec = pd.read_csv(tsv_elec_path, sep=None, engine='python', header=None, na_values=['n/a','N/A','nan'])
+                if len(df_elec.columns) <= 1:
+                    df_elec = pd.read_csv(tsv_elec_path, sep=r'\s+', engine='python', header=None, na_values=['n/a','N/A','nan'])
+                df_elec.columns = ['name', 'x', 'y', 'z'] + [f'extra_{i}' for i in range(len(df_elec.columns)-4)]
+
+            cols = {str(c).lower().strip(): c for c in df_elec.columns}
+            name_col = next((cols[c] for c in ['name', 'label', 'channel', 'ch_name', 'electrode'] if c in cols), df_elec.columns[0])
+            x_col = next((cols[c] for c in ['x', 'pos_x', 'coordinate_x', 'left-right'] if c in cols), None)
+            y_col = next((cols[c] for c in ['y', 'pos_y', 'coordinate_y', 'posterior-anterior'] if c in cols), None)
+            z_col = next((cols[c] for c in ['z', 'pos_z', 'coordinate_z', 'inferior-superior'] if c in cols), None)
+
+            if x_col is None and len(df_elec.columns) >= 4:
+                x_col, y_col, z_col = df_elec.columns[1], df_elec.columns[2], df_elec.columns[3]
+
+            if not all([x_col, y_col, z_col]):
+                col_names = ", ".join(map(str, df_elec.columns))
+                raise ValueError(f"ระบบหาตำแหน่ง x, y, z ในไฟล์ไม่พบครับ\n\n📍 ตารางที่ตรวจพบ: {col_names}")
+
+            def normalize(name):
+                s = str(name).upper().strip()
+                s = re.sub(r'^(EEG|CH|ELE|REF|EOG)\s*0*', '', s)
+                s = re.sub(r'[-_\s](EEG|CH|ELE|REF|EOG)$', '', s)
+                return s
+
+            def get_digits(name):
+                digits = "".join(re.findall(r'\d+', str(name)))
+                return str(int(digits)) if digits else ""
+
+            final_ch_pos = {}
+            rename_map = {}
+            tsv_samples = []
+
+            for _, row in df_elec.iterrows():
+                tsv_name_raw = str(row[name_col]).strip()
+                if tsv_name_raw.lower() in ['n/a', 'nan', '']: continue
+                tsv_samples.append(tsv_name_raw)
+
+                matched_raw = None
+                for r_name in raw_names_before:
+                    if r_name.upper() == tsv_name_raw.upper():
+                        matched_raw = r_name; break
+                if not matched_raw:
+                    tsv_norm = normalize(tsv_name_raw)
+                    for r_name in raw_names_before:
+                        if normalize(r_name) == tsv_norm:
+                            matched_raw = r_name; break
+                if not matched_raw:
+                    tsv_digits = get_digits(tsv_name_raw)
+                    if tsv_digits:
+                        for r_name in raw_names_before:
+                            if get_digits(r_name) == tsv_digits:
+                                matched_raw = r_name; break
+
+                if matched_raw:
+                    try:
+                        px, py, pz = float(row[x_col]), float(row[y_col]), float(row[z_col])
+                    except (ValueError, TypeError):
+                        continue
+                    pos = np.array([px, py, pz]) / 100.0
+                    final_ch_pos[tsv_name_raw] = pos
+                    rename_map[matched_raw] = tsv_name_raw
+
+            if rename_map:
+                raw.rename_channels(rename_map)
+                raw.set_channel_types({ch: 'eeg' for ch in rename_map.values()})
+                std_1020 = mne.channels.make_standard_montage('standard_1020')
+                fid_pos = std_1020.get_positions()
+                montage = mne.channels.make_dig_montage(
+                    ch_pos=final_ch_pos,
+                    nasion=fid_pos.get('nasion'), lpa=fid_pos.get('lpa'), rpa=fid_pos.get('rpa'),
+                    coord_frame='head'
+                )
+                raw.set_montage(montage, on_missing='warn')
+                applied_tsv = True
+                debug_log.append(f"✅ จับคู่ชื่อสำเร็จ: {len(rename_map)} electrodes")
+            else:
+                valid_rows = []
+                for _, row in df_elec.iterrows():
+                    try:
+                        px, py, pz = float(row[x_col]), float(row[y_col]), float(row[z_col])
+                        valid_rows.append((px, py, pz))
+                    except (ValueError, TypeError):
+                        valid_rows.append(None)
+
+                order_ch_pos = {}
+                order_rename = {}
+                paired = 0
+                for i, r_name in enumerate(raw_names_before):
+                    if i >= len(valid_rows): break
+                    if valid_rows[i] is None: continue
+                    px, py, pz = valid_rows[i]
+                    tsv_name_order = str(df_elec.iloc[i][name_col]).strip()
+                    order_ch_pos[tsv_name_order] = np.array([px, py, pz]) / 100.0
+                    order_rename[r_name] = tsv_name_order
+                    paired += 1
+
+                if paired >= 3:
+                    raw.rename_channels(order_rename)
+                    raw.set_channel_types({ch: 'eeg' for ch in order_rename.values()})
+                    std_1020 = mne.channels.make_standard_montage('standard_1020')
+                    fid_pos = std_1020.get_positions()
+                    montage = mne.channels.make_dig_montage(
+                        ch_pos=order_ch_pos,
+                        nasion=fid_pos.get('nasion'), lpa=fid_pos.get('lpa'), rpa=fid_pos.get('rpa'),
+                        coord_frame='head'
+                    )
+                    raw.set_montage(montage, on_missing='warn')
+                    applied_tsv = True
+                    debug_log.append(f"⚠️ จับคู่ด้วยลำดับ: {paired} electrodes")
+                    warnings.append(f"⚠️ ระบบจับคู่ขั้วไฟฟ้าด้วยลำดับ เนื่องจากชื่อไม่ตรงกัน")
+                else:
+                    raise ValueError(f"ไม่สามารถจับคู่ขั้วไฟฟ้าได้ครับ")
+
+        except Exception as e_tsv:
+            if isinstance(e_tsv, ValueError): raise e_tsv
+            debug_log.append(f"❌ TSV error: {str(e_tsv)[:200]}")
+
+    matched_std = []
+    if not applied_tsv:
+        std = mne.channels.make_standard_montage('standard_1020')
+        std_names_upper = [ch.upper() for ch in std.ch_names]
+        matched_std = [ch for ch in raw.ch_names if ch.upper() in std_names_upper]
+
+        if len(matched_std) >= 3:
+            raw.set_montage(std, on_missing='ignore')
+            debug_log.append(f"✅ ใช้ standard_1020: match ได้ {len(matched_std)} channels")
+        else:
+            std_ch_names = std.ch_names
+            ch_pos_std = {ch: std.get_positions()['ch_pos'][ch] for ch in std_ch_names}
+            order_ch_pos = {}
+            order_rename = {}
+            for i, r_name in enumerate(raw.ch_names):
+                if i >= len(std_ch_names): break
+                std_name = std_ch_names[i]
+                order_ch_pos[std_name] = ch_pos_std[std_name]
+                order_rename[r_name] = std_name
+
+            if len(order_rename) >= 3:
+                raw.rename_channels(order_rename)
+                raw.set_montage(std, on_missing='ignore')
+                applied_tsv = True
+                warnings.append(f"⚠️ ไม่มีไฟล์ TSV — ระบบจับคู่ด้วยลำดับกับ standard_1020")
+                debug_log.append(f"⚠️ order-based กับ standard_1020: {len(order_rename)} channels")
+            else:
+                raise ValueError(f"ชื่อขั้วไฟฟ้าในไฟล์ไม่ตรงกับมาตรฐาน 10-20 และไม่มีไฟล์พิกัดที่ใช้งานได้ครับ")
+
+    raw.filter(1, 45, verbose=False)
+    raw.pick_types(eeg=True, exclude='bads')
+
+    valid_chs = [ch['ch_name'] for ch in raw.info['chs']
+                 if not np.all(ch['loc'][:3] == 0) and not np.any(np.isnan(ch['loc'][:3]))]
+
+    if len(valid_chs) < 3:
+        raise ValueError(f"พบขั้วไฟฟ้าที่มีพิกัดน้อยเกินไป (พบแค่ {len(valid_chs)} จุด)")
+
+    raw.pick_channels(valid_chs)
+    raw.set_eeg_reference('average', projection=True).apply_proj()
+
+    return raw, debug_log, warnings

cydms-0.1.0/cydms/mri.py

@@ -0,0 +1,80 @@
+"""
+cydms.mri
+---------
+MRI processing — skull stripping, mesh generation, cortical thickness
+"""
+import numpy as np
+import nibabel as nib
+import gc
+from scipy import ndimage
+from scipy.ndimage import label
+from skimage import measure
+
+
+def process_mri(mri_path):
+    img = nib.load(mri_path)
+    m_data = img.get_fdata().astype(np.float32)
+    m_ds = m_data[::1, ::1, ::1]
+
+    voxel_size = np.abs(img.header.get_zooms()[:3])
+    min_vox = float(np.min(voxel_size))
+    lo_pct = 77 if min_vox >= 0.9 else 50
+    lo_thresh = np.percentile(m_ds[m_ds > 0], lo_pct)
+    hi_thresh = np.percentile(m_ds[m_ds > 0], 98)
+
+    brain_mask = (m_ds > lo_thresh) & (m_ds < hi_thresh)
+    brain_mask = ndimage.binary_fill_holes(brain_mask)
+    brain_mask = ndimage.binary_erosion(brain_mask, iterations=5)
+    brain_mask = ndimage.binary_dilation(brain_mask, iterations=2)
+    brain_mask = ndimage.binary_fill_holes(brain_mask)
+
+    labeled, n = label(brain_mask)
+    if n > 0:
+        sizes = [np.sum(labeled == i) for i in range(1, n+1)]
+        brain_mask = labeled == (np.argmax(sizes) + 1)
+
+    m_clean = m_ds * brain_mask.astype(np.float32)
+    del m_data; gc.collect()
+
+    verts, all_faces, _, _ = measure.marching_cubes(m_clean, level=np.percentile(m_clean[m_clean > 0], 40))
+    v_center = (verts.min(axis=0) + verts.max(axis=0)) / 2
+    verts_final = (verts - v_center) * 2.0
+    del m_clean; gc.collect()
+
+    # Cortical thickness
+    from scipy import ndimage as ndi
+    img_thick = nib.load(mri_path)
+    mri_thick = img_thick.get_fdata().astype(np.float32)
+    mri_ds = mri_thick[::4, ::4, ::4]
+
+    lo_t = np.percentile(mri_ds[mri_ds > 0], 20)
+    hi_t = np.percentile(mri_ds[mri_ds > 0], 98)
+    mask_t = (mri_ds > lo_t) & (mri_ds < hi_t)
+    mask_t = ndi.binary_fill_holes(mask_t)
+    mask_t = ndi.binary_erosion(mask_t, iterations=1)
+
+    def get_lobe_mask(arr, lobe):
+        h = arr.shape
+        if lobe == 'frontal':   return arr[:, int(h[1]*0.6):, :]
+        if lobe == 'occipital': return arr[:, :int(h[1]*0.2), :]
+        if lobe == 'temporal':  return arr[:, int(h[1]*0.2):int(h[1]*0.5), :int(h[2]*0.4)]
+        return arr[:, int(h[1]*0.2):int(h[1]*0.6), int(h[2]*0.3):]
+
+    thickness = {}
+    for lobe in ['frontal', 'occipital', 'temporal', 'parietal']:
+        lobe_mask = get_lobe_mask(mask_t, lobe)
+        thickness[lobe] = float(np.sum(lobe_mask)) / max(lobe_mask.size, 1) * 100
+
+    left_sum  = float(np.sum(mask_t[:mask_t.shape[0]//2, :, :]))
+    right_sum = float(np.sum(mask_t[mask_t.shape[0]//2:, :, :]))
+    asymmetry = abs(left_sum - right_sum) / max(left_sum + right_sum, 1)
+    del mri_thick, mri_ds, mask_t; gc.collect()
+
+    return {
+        'verts': verts_final.tolist(),
+        'faces': all_faces.tolist(),
+        'thickness': thickness,
+        'asymmetry': round(asymmetry * 100, 2),
+        'voxel_size': min_vox,
+        'threshold_pct': lo_pct,
+    }

cydms-0.1.0/cydms/source.py

@@ -0,0 +1,276 @@
+"""
+cydms.source
+------------
+Forward solution, inverse solution (sLORETA), band power, clean segment selection
+"""
+import numpy as np
+import mne
+
+
+BANDS = {
+    'Delta': (1, 4),
+    'Theta': (4, 8),
+    'Alpha': (8, 13),
+    'Beta':  (13, 30),
+    'Gamma': (30, 45),
+}
+
+COLORS = {
+    'Delta': '#ff3333',
+    'Theta': '#ffcc00',
+    'Alpha': '#33ff33',
+    'Beta':  '#3333ff',
+    'Gamma': '#ff33ff',
+}
+
+NORMAL_RANGES = {
+    'Delta': (5, 25),
+    'Theta': (5, 25),
+    'Alpha': (25, 45),
+    'Beta':  (10, 30),
+    'Gamma': (2, 15),
+}
+
+DIAG_MAP = {
+    'Delta': {
+        'high':   '⚠️ สูงกว่าปกติ: เสี่ยง ADHD, บาดเจ็บสมอง, หรือง่วงมาก',
+        'normal': '✅ ปกติ: สมองพักผ่อนหรือนอนหลับลึก',
+        'low':    '⚠️ ต่ำกว่าปกติ: อาจนอนหลับไม่พอ',
+    },
+    'Theta': {
+        'high':   '⚠️ สูงกว่าปกติ: เสี่ยง ADHD, วิตกกังวล, หรือซึมเศร้า',
+        'normal': '✅ ปกติ: ผ่อนคลาย ใกล้หลับ',
+        'low':    '⚠️ ต่ำกว่าปกติ: ตื่นตัวสูงมากผิดปกติ',
+    },
+    'Alpha': {
+        'high':   '✅ สูงกว่าปกติ: ผ่อนคลายดีเยี่ยม สมาธิดี',
+        'normal': '✅ ปกติ: สมองทำงานสมดุล',
+        'low':    '⚠️ ต่ำกว่าปกติ: เครียด วิตกกังวล หรือสมาธิลดลง',
+    },
+    'Beta': {
+        'high':   '⚠️ สูงกว่าปกติ: เครียดสูง วิตกกังวล หรือ OCD',
+        'normal': '✅ ปกติ: ตื่นตัว ทำงานได้ดี',
+        'low':    '⚠️ ต่ำกว่าปกติ: ง่วงนอน หรือขาดสมาธิ',
+    },
+    'Gamma': {
+        'high':   '⚠️ สูงกว่าปกติ: Hyperactivity หรือเครียดสูงมาก',
+        'normal': '✅ ปกติ: ประมวลผลข้อมูลดี',
+        'low':    '⚠️ ต่ำกว่าปกติ: การประมวลผลสมองช้าลง',
+    },
+}
+
+
+def get_lobe_name(pos):
+    y, z = pos[1], pos[2]
+    if y > 25:   return "Frontal Lobe"
+    elif y < -45: return "Occipital Lobe"
+    elif z < -15: return "Temporal Lobe"
+    else:         return "Parietal Lobe"
+
+
+def find_clean_segment(band_data, sfreq, win_sec=25.0, step_sec=5.0, debug_log=None):
+    n_samples = band_data.shape[1]
+    win  = int(win_sec * sfreq)
+    step = int(step_sec * sfreq)
+    if n_samples <= win:
+        return None, 'low'
+
+    wins, variances = [], []
+    for i in range(0, n_samples - win, step):
+        seg = band_data[:, i:i+win]
+        wins.append(i)
+        variances.append(float(np.var(seg)))
+
+    variances  = np.array(variances)
+    median_var = np.median(variances)
+    diffs      = np.abs(variances - median_var)
+    best_idx   = np.argmin(diffs)
+
+    if diffs[best_idx] > median_var * 2:
+        if debug_log is not None:
+            debug_log.append("⚠️ ไฟล์ noisy มาก — ใช้ทั้งไฟล์แทน")
+        return None, 'low'
+
+    start = wins[best_idx]
+    return (start, start + win), 'normal'
+
+
+def compute_source_localization(raw, debug_log=None):
+    if debug_log is None:
+        debug_log = []
+    src_logs = []
+
+    fs_dir      = mne.datasets.fetch_fsaverage(verbose=False)
+    subjects_dir = __import__('os').path.dirname(fs_dir)
+    src = mne.setup_source_space('fsaverage', spacing='oct2',
+                                  subjects_dir=subjects_dir, add_dist=False, verbose=False)
+    bem = __import__('os').path.join(fs_dir, 'bem', 'fsaverage-5120-5120-5120-bem-sol.fif')
+
+    try:
+        fwd = mne.make_forward_solution(raw.info, trans='fsaverage', src=src,
+                                         bem=bem, eeg=True, mindist=2.0,
+                                         ignore_ref=False, verbose=False)
+    except Exception as e_fwd:
+        err_msg = str(e_fwd)
+        if "No EEG channels" in err_msg:
+            err_msg += " (Make sure your SET file contains EEG channels)"
+        raise RuntimeError(f"Forward solution failed: {err_msg}")
+
+    inv  = mne.minimum_norm.make_inverse_operator(raw.info, fwd,
+                                                    mne.make_ad_hoc_cov(raw.info),
+                                                    verbose=False)
+    sfreq      = raw.info['sfreq']
+    final_results = {}
+    total_pwr  = 0
+    raw_results = []
+
+    for name, (fmin, fmax) in BANDS.items():
+        raw_filtered = raw.copy().filter(fmin, fmax, verbose=False)
+        band_data    = raw_filtered.get_data()
+
+        seg_range, conf = find_clean_segment(band_data, sfreq, debug_log=src_logs)
+        if seg_range:
+            clean_data = band_data[:, seg_range[0]:seg_range[1]]
+            src_logs.append(f"✅ {name}: ใช้ช่วง {seg_range[0]/sfreq:.1f}s-{seg_range[1]/sfreq:.1f}s")
+        else:
+            clean_data = band_data
+            src_logs.append(f"{'⚠️' if conf=='low' else '✅'} {name}: ใช้ทั้งไฟล์ (confidence: {conf})")
+
+        stc    = mne.minimum_norm.apply_inverse_raw(raw_filtered, inv,
+                                                     lambda2=1.0/9.0,
+                                                     method='sLORETA', verbose=False)
+        d_mean = np.mean(np.abs(stc.data), axis=1)
+        pk     = np.argmax(d_mean)
+        n_lh   = len(src[0]['rr'])
+        p_std  = src[0]['rr'][pk] if pk < n_lh else src[1]['rr'][pk - n_lh]
+
+        pwr = float(np.mean(np.abs(clean_data)))
+        total_pwr += pwr
+        raw_results.append({
+            'name': name,
+            'pos': (p_std * 100 * 2.5).tolist(),
+            'pos_raw': (p_std * 100).tolist(),
+            'pwr': pwr,
+            'confidence': conf,
+        })
+
+    for item in raw_results:
+        pct  = round((item['pwr'] / (total_pwr if total_pwr > 0 else 1)) * 100, 2)
+        lobe = get_lobe_name(item['pos_raw'])
+        name = item['name']
+        lo, hi = NORMAL_RANGES.get(name, (10, 30))
+        status = 'high' if pct > hi else ('low' if pct < lo else 'normal')
+        diag   = DIAG_MAP.get(name, {}).get(status, '')
+        final_results[name] = {
+            'val': pct,
+            'pos': item['pos'],
+            'color': COLORS[name],
+            'lobe': lobe,
+            'status': status,
+            'diag': diag,
+            'confidence': item.get('confidence', 'normal'),
+        }
+
+    # Waveform
+    waveform = {}
+    try:
+        ds       = max(1, int(sfreq // 50))
+        waveform['times'] = raw.times[::ds].tolist()
+        for band_name, (fmin, fmax) in BANDS.items():
+            band_data = raw.copy().filter(fmin, fmax, verbose=False).get_data()
+            avg = np.mean(band_data, axis=0)[::ds]
+            mx  = np.max(np.abs(avg)) or 1
+            waveform[band_name] = (avg / mx).tolist()
+    except:
+        pass
+
+    return final_results, waveform, src_logs
+
+
+def compute_clinical_findings(results, thickness, asymmetry_pct):
+    asymmetry = asymmetry_pct / 100.0
+
+    delta_pct  = results.get('Delta', {}).get('val', 0)
+    theta_pct  = results.get('Theta', {}).get('val', 0)
+    alpha_pct  = results.get('Alpha', {}).get('val', 0)
+    beta_pct   = results.get('Beta',  {}).get('val', 0)
+    gamma_pct  = results.get('Gamma', {}).get('val', 0)
+
+    delta_st = results.get('Delta', {}).get('status', 'normal')
+    theta_st = results.get('Theta', {}).get('status', 'normal')
+    alpha_st = results.get('Alpha', {}).get('status', 'normal')
+    beta_st  = results.get('Beta',  {}).get('status', 'normal')
+    gamma_st = results.get('Gamma', {}).get('status', 'normal')
+    delta_lobe = results.get('Delta', {}).get('lobe', '')
+
+    mean_thick      = np.mean(list(thickness.values()))
+    mri_focal_thick = any(v > mean_thick * 1.3 for v in thickness.values())
+    mri_focal_thin  = any(v < mean_thick * 0.7 for v in thickness.values())
+    mri_asymmetry   = asymmetry > 0.08
+
+    findings = []
+
+    if delta_st == 'high' and mri_focal_thick:
+        findings.append({
+            'condition': 'Suspected Brain Tumor',
+            'confidence': 'HIGH' if delta_pct > 30 else 'MEDIUM',
+            'evidence': [f'Delta abnormally high ({delta_pct}%) at {delta_lobe}', 'MRI shows abnormal cortical thickness'],
+            'recommend': 'Recommend MRI with contrast for further evaluation',
+        })
+    elif delta_st == 'high':
+        findings.append({
+            'condition': 'Possible Brain Tumor',
+            'confidence': 'LOW',
+            'evidence': [f'Delta abnormally high ({delta_pct}%) at {delta_lobe}', 'No clear MRI thickness abnormality'],
+            'recommend': 'Follow up and further examination recommended',
+        })
+
+    if delta_st == 'high' and (mri_focal_thin or mri_asymmetry):
+        findings.append({
+            'condition': 'Suspected Epilepsy',
+            'confidence': 'HIGH' if (mri_focal_thin and mri_asymmetry) else 'MEDIUM',
+            'evidence': [f'Delta abnormally high ({delta_pct}%)',
+                         'MRI shows cortical thinning or asymmetry' if mri_focal_thin else 'MRI shows asymmetry'],
+            'recommend': 'Recommend prolonged EEG monitoring and neurology consult',
+        })
+    elif delta_st == 'high' and not mri_focal_thick:
+        findings.append({
+            'condition': 'Possible Epilepsy',
+            'confidence': 'LOW',
+            'evidence': [f'Delta abnormally high ({delta_pct}%)', 'No clear MRI abnormality'],
+            'recommend': 'Monitor symptoms and consult a physician',
+        })
+
+    if theta_st == 'high' and alpha_st == 'low':
+        findings.append({
+            'condition': 'Suspected ADHD',
+            'confidence': 'MEDIUM',
+            'evidence': [f'Theta elevated ({theta_pct}%)', f'Beta elevated ({beta_pct}%)', f'Alpha low ({alpha_pct}%)'],
+            'recommend': 'Recommend psychological assessment and physician consult',
+        })
+
+    if delta_st == 'high' and theta_st == 'high' and alpha_st == 'low':
+        findings.append({
+            'condition': 'Suspected Cognitive Decline / Dementia',
+            'confidence': 'MEDIUM',
+            'evidence': [f'Delta elevated ({delta_pct}%)', f'Theta elevated ({theta_pct}%)', f'Alpha low ({alpha_pct}%)'],
+            'recommend': 'Recommend cognitive and memory evaluation',
+        })
+
+    if beta_st == 'high' and gamma_st == 'high':
+        findings.append({
+            'condition': 'Suspected Anxiety / OCD',
+            'confidence': 'LOW',
+            'evidence': [f'Beta elevated ({beta_pct}%)', f'Gamma elevated ({gamma_pct}%)'],
+            'recommend': 'Recommend mental health evaluation',
+        })
+
+    if not findings:
+        findings.append({
+            'condition': 'No significant abnormal pattern detected',
+            'confidence': 'NORMAL',
+            'evidence': ['All brainwave bands within normal range', 'No clear MRI abnormality'],
+            'recommend': 'Results appear normal. Please confirm with a specialist.',
+        })
+
+    return findings

cydms-0.1.0/cydms.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: cydms
+Version: 0.1.0
+Summary: EEG + MRI source localization library — no FreeSurfer required
+Requires-Python: >=3.8
+Requires-Dist: numpy
+Requires-Dist: nibabel
+Requires-Dist: scipy
+Requires-Dist: scikit-image
+Requires-Dist: mne
+Requires-Dist: pandas
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

cydms-0.1.0/cydms.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+setup.py
+cydms/__init__.py
+cydms/analyze.py
+cydms/eeg.py
+cydms/mri.py
+cydms/source.py
+cydms.egg-info/PKG-INFO
+cydms.egg-info/SOURCES.txt
+cydms.egg-info/dependency_links.txt
+cydms.egg-info/requires.txt
+cydms.egg-info/top_level.txt

cydms-0.1.0/cydms.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cydms-0.1.0/cydms.egg-info/requires.txt

@@ -0,0 +1,6 @@
+numpy
+nibabel
+scipy
+scikit-image
+mne
+pandas

cydms-0.1.0/cydms.egg-info/top_level.txt

@@ -0,0 +1 @@
+cydms

cydms-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cydms-0.1.0/setup.py

@@ -0,0 +1,17 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='cydms',
+    version='0.1.0',
+    description='EEG + MRI source localization library — no FreeSurfer required',
+    packages=find_packages(),
+    install_requires=[
+        'numpy',
+        'nibabel',
+        'scipy',
+        'scikit-image',
+        'mne',
+        'pandas',
+    ],
+    python_requires='>=3.8',
+)