[add] app files

requirements.txt

@@ -1,3 +1,7 @@
-altair
-pandas
-streamlit
+streamlit
+numpy
+plotly
+scipy
+mne
+h5py
+networkx

src/loader.py

@@ -0,0 +1,393 @@
+from __future__ import annotations
+
+from typing import List, Tuple, Optional, Dict, Any
+import io
+import os
+import tempfile
+
+import numpy as np
+
+import mne
+from scipy.io import loadmat
+
+try:
+    import h5py  # MAT v7.3 (HDF5)
+except Exception:  # pragma: no cover
+    h5py = None
+
+
+# ============================================================
+# EEGLAB loader (.set + .fdt)
+# ============================================================
+def pick_set_fdt(files) -> Tuple[Optional[object], Optional[object]]:
+    """
+    Streamlitの accept_multiple_files=True で受け取ったfilesから .set と .fdt を拾う。
+    Returns: (set_file, fdt_file)
+    """
+    set_file = None
+    fdt_file = None
+    for f in files:
+        name = (getattr(f, "name", "") or "").lower()
+        if name.endswith(".set"):
+            set_file = f
+        elif name.endswith(".fdt"):
+            fdt_file = f
+    return set_file, fdt_file
+
+
+def same_stem(a_name: str, b_name: str) -> bool:
+    """Check if two filenames have the same stem (basename without extension)."""
+    a_stem = os.path.splitext(os.path.basename(a_name))[0]
+    b_stem = os.path.splitext(os.path.basename(b_name))[0]
+    return a_stem == b_stem
+
+
+def _load_eeglab_hdf5(set_path: str, fdt_path: Optional[str] = None, debug: bool = False) -> Tuple[np.ndarray, float]:
+    """
+    Load EEGLAB .set file saved in MATLAB v7.3 (HDF5) format using h5py.
+    Returns: (x_tc, fs) where x_tc is (T, C)
+    """
+    if h5py is None:
+        raise RuntimeError("EEGLAB .set ファイルが MATLAB v7.3 (HDF5) 形式ですが、h5py がインストールされていません。pip install h5py を実行してください。")
+    
+    with h5py.File(set_path, "r") as f:
+        # デバッグ: ファイル構造を表示
+        if debug:
+            print("=== HDF5 file structure ===")
+            def print_structure(name, obj):
+                if isinstance(obj, h5py.Dataset):
+                    print(f"Dataset: {name}, shape: {obj.shape}, dtype: {obj.dtype}")
+                elif isinstance(obj, h5py.Group):
+                    print(f"Group: {name}")
+            f.visititems(print_structure)
+            print("===========================")
+        
+        # サンプリングレートを取得
+        fs = None
+        for path in ["EEG/srate", "srate"]:
+            if path in f:
+                srate_data = f[path]
+                if isinstance(srate_data, h5py.Dataset):
+                    val = srate_data[()]
+                    # 配列の場合は最初の要素を取得
+                    fs = float(val.flat[0]) if hasattr(val, 'flat') else float(val)
+                    break
+        
+        if fs is None:
+            raise ValueError("サンプリングレート (srate) が見つかりません")
+        
+        # チャンネル数を取得
+        nbchan = None
+        for path in ["EEG/nbchan", "nbchan"]:
+            if path in f:
+                nbchan_data = f[path]
+                if isinstance(nbchan_data, h5py.Dataset):
+                    val = nbchan_data[()]
+                    nbchan = int(val.flat[0]) if hasattr(val, 'flat') else int(val)
+                    break
+        
+        # サンプル数を取得
+        pnts = None
+        for path in ["EEG/pnts", "pnts"]:
+            if path in f:
+                pnts_data = f[path]
+                if isinstance(pnts_data, h5py.Dataset):
+                    val = pnts_data[()]
+                    pnts = int(val.flat[0]) if hasattr(val, 'flat') else int(val)
+                    break
+        
+        if debug:
+            print(f"nbchan: {nbchan}, pnts: {pnts}, fs: {fs}")
+        
+        # データを取得 - まず .set 内を確認
+        data = None
+        data_shape = None
+        
+        if debug:
+            print(f"Checking for data, fdt_path provided: {fdt_path is not None}")
+            if fdt_path:
+                print(f"fdt_path exists: {os.path.exists(fdt_path)}")
+        
+        # パターン1: EEG/data が参照配列の場合、各参照を辿る
+        if "EEG" in f and "data" in f["EEG"]:
+            data_ref = f["EEG"]["data"]
+            if isinstance(data_ref, h5py.Dataset):
+                if debug:
+                    print(f"EEG/data dtype: {data_ref.dtype}, shape: {data_ref.shape}, size: {data_ref.size}")
+                
+                if data_ref.dtype == h5py.ref_dtype:
+                    # 参照の場合 - 通常は .fdt ファイルを指す
+                    if debug:
+                        print("EEG/data is reference type - data should be in .fdt file")
+                    # .fdt ファイルが必要
+                    if fdt_path is not None and os.path.exists(fdt_path):
+                        data = _load_fdt_file(fdt_path, nbchan, pnts, debug=debug)
+                    else:
+                        raise ValueError(".fdt ファイルが必要ですが見つかりません。.set と .fdt の両方をアップロードしてください。")
+                elif data_ref.size > 100:  # 参照配列ではなく実データ
+                    data = data_ref[()]
+                    data_shape = data.shape
+                    if debug:
+                        print(f"EEG/data contains actual data, shape: {data_shape}")
+                else:
+                    # 小さい配列 = 参照リスト、.fdtファイルが必要
+                    if debug:
+                        print(f"EEG/data is small array (size={data_ref.size}), assuming reference to .fdt")
+                    if fdt_path is not None and os.path.exists(fdt_path):
+                        data = _load_fdt_file(fdt_path, nbchan, pnts, debug=debug)
+                    else:
+                        raise ValueError(".fdt ファイルが必要ですが見つかりません。.set と .fdt の両方をアップロードしてください。")
+        
+        # パターン2: 直接 data
+        if data is None and "data" in f:
+            data_obj = f["data"]
+            if isinstance(data_obj, h5py.Dataset):
+                data = data_obj[()]
+                data_shape = data.shape
+        
+        if data is None:
+            raise ValueError("EEGデータが見つかりません。.fdt ファイルが必要な可能性があります。")
+        
+        if debug:
+            print(f"Data shape: {data.shape if hasattr(data, 'shape') else 'loaded from fdt'}")
+        
+        # データの形状を調整
+        if data.ndim != 2:
+            raise ValueError(f"予期しないデータ次元: {data.ndim}")
+        
+        dim0, dim1 = data.shape
+        
+        # nbchan情報があればそれを使う
+        if nbchan is not None:
+            if dim0 == nbchan:
+                # (C, T) 形式
+                x_tc = data.T.astype(np.float32)
+            elif dim1 == nbchan:
+                # (T, C) 形式
+                x_tc = data.astype(np.float32)
+            else:
+                # nbchanと一致しない場合は小さい方をチャンネル数と仮定
+                if dim0 < dim1:
+                    x_tc = data.T.astype(np.float32)
+                else:
+                    x_tc = data.astype(np.float32)
+        else:
+            # 一般的な判定: 小さい方がチャンネル数
+            if dim0 < dim1:
+                x_tc = data.T.astype(np.float32)
+            else:
+                x_tc = data.astype(np.float32)
+        
+        if debug:
+            print(f"Final shape (T, C): {x_tc.shape}")
+        
+        return x_tc, fs
+
+
+def _load_fdt_file(fdt_path: str, nbchan: Optional[int], pnts: Optional[int], debug: bool = False) -> np.ndarray:
+    """
+    Load .fdt file (raw binary float32 data).
+    EEGLAB .fdt files are stored as float32 in (C, T) order.
+    """
+    if debug:
+        print(f"Loading .fdt file: {fdt_path}")
+    
+    # .fdt ファイルは float32 のバイナリデータ
+    data = np.fromfile(fdt_path, dtype=np.float32)
+    
+    if debug:
+        print(f"Loaded {data.size} float32 values from .fdt")
+    
+    # チャンネル数とサンプル数がわかっている場合はリシェイプ
+    if nbchan is not None and pnts is not None:
+        expected_size = nbchan * pnts
+        if data.size == expected_size:
+            # EEGLAB は (C, T) 順で保存
+            data = data.reshape(nbchan, pnts)
+            if debug:
+                print(f"Reshaped to ({nbchan}, {pnts})")
+        else:
+            if debug:
+                print(f"Warning: expected {expected_size} values but got {data.size}")
+            # 可能な限りリシェイプを試みる
+            if data.size % nbchan == 0:
+                data = data.reshape(nbchan, -1)
+            elif data.size % pnts == 0:
+                data = data.reshape(-1, pnts)
+            else:
+                raise ValueError(f"Cannot reshape data of size {data.size} with nbchan={nbchan}, pnts={pnts}")
+    else:
+        raise ValueError("nbchan と pnts の情報が必要です")
+    
+    return data
+
+
+def load_eeglab_tc_from_bytes(
+    set_bytes: bytes,
+    set_name: str,
+    fdt_bytes: Optional[bytes] = None,
+    fdt_name: Optional[str] = None,
+) -> Tuple[np.ndarray, float]:
+    """
+    Load EEGLAB .set (and optional .fdt) from bytes using MNE or h5py.
+    Returns:
+      x_tc: (T, C) float32
+      fs: sampling rate (Hz)
+
+    Notes:
+      - 多くのEEGLABは .set が .fdt を参照するため、同じディレクトリに同名で置く必要があります。
+      - .set単体で完結している場合は fdt_* を省略可能にしています。
+      - MATLAB v7.3 (HDF5) 形式の .set にも対応しています。
+    """
+    if fdt_bytes is not None or fdt_name is not None:
+        if fdt_bytes is None or fdt_name is None:
+            raise ValueError("fdt_bytes と fdt_name は両方指定してください。")
+        if not same_stem(set_name, fdt_name):
+            raise ValueError(f".set と .fdt のファイル名（拡張子除く）が一致していません: {set_name} vs {fdt_name}")
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        set_path = os.path.join(tmpdir, os.path.basename(set_name))
+        with open(set_path, "wb") as f:
+            f.write(set_bytes)
+
+        fdt_path = None  # 初期化
+        if fdt_bytes is not None and fdt_name is not None:
+            fdt_path = os.path.join(tmpdir, os.path.basename(fdt_name))
+            with open(fdt_path, "wb") as f:
+                f.write(fdt_bytes)
+
+        # 1) Rawとして読む（通常のEEGLAB形式）
+        try:
+            raw = mne.io.read_raw_eeglab(set_path, preload=True, verbose=False)
+            fs = float(raw.info["sfreq"])
+            x_tc = raw.get_data().T  # (T,C)
+            return x_tc.astype(np.float32), fs
+
+        except Exception as e_raw:
+            # 2) Epochsとして読む（エポックデータ用）
+            try:
+                epochs = mne.io.read_epochs_eeglab(set_path, verbose=False, montage_units="cm")
+                fs = float(epochs.info["sfreq"])
+                x = epochs.get_data(copy=True)  # (n_epochs, n_channels, n_times)
+
+                # ここは方針を選ぶ：平均 or 連結
+                x_mean = x.mean(axis=0)   # (C,T)
+                x_tc = x_mean.T           # (T,C)
+                return x_tc.astype(np.float32), fs
+
+            except Exception as e_ep:
+                # 3) HDF5形式として読む（MATLAB v7.3）
+                try:
+                    # デバッグモードを有効化（環境変数で制御可能）
+                    debug = os.environ.get("EEGLAB_DEBUG", "0") == "1"
+                    # Streamlit環境では常にデバッグ情報を表示
+                    import sys
+                    if 'streamlit' in sys.modules:
+                        debug = True
+                    x_tc, fs = _load_eeglab_hdf5(set_path, fdt_path=fdt_path, debug=debug)
+                    return x_tc, fs
+                
+                except Exception as e_hdf5:
+                    # すべて失敗した場合
+                    msg = (
+                        "EEGLABの読み込みに失敗しました。\n"
+                        f"- read_raw_eeglab error: {e_raw}\n"
+                        f"- read_epochs_eeglab error: {e_ep}\n"
+                        f"- HDF5読み込み error: {e_hdf5}\n"
+                    )
+                    raise RuntimeError(msg) from e_hdf5
+
+
+
+# ============================================================
+# MAT loader (.mat)
+# ============================================================
+def _mat_keys_loadmat(mat_dict: Dict[str, Any]) -> List[str]:
+    return sorted([k for k in mat_dict.keys() if not k.startswith("__")])
+
+
+def _try_get_numeric_arrays_loadmat(mat_dict: Dict[str, Any]) -> Dict[str, np.ndarray]:
+    """
+    loadmatで読んだdictから、1D/2Dの数値ndarrayだけ抽出して返す。
+    3次元配列も含める（エポックデータの可能性）。
+    """
+    out: Dict[str, np.ndarray] = {}
+    for k in _mat_keys_loadmat(mat_dict):
+        v = mat_dict[k]
+        if isinstance(v, np.ndarray) and v.size > 0:
+            # 数値型かどうかチェック
+            if np.issubdtype(v.dtype, np.number):
+                if v.ndim in (1, 2):
+                    out[k] = v
+                elif v.ndim == 3:
+                    # 3次元配列の場合は (epochs, channels, time) の可能性
+                    # 平均を取って2次元にする、または連結する
+                    out[k + "_mean"] = v.mean(axis=0)  # (C, T)
+                    out[k + "_concat"] = v.reshape(-1, v.shape[-1])  # (epochs*C, T)
+    return out
+
+
+def _load_mat_v72(bytes_data: bytes) -> Dict[str, Any]:
+    # v7.2以前のMAT（一般的なMAT）
+    return loadmat(io.BytesIO(bytes_data), squeeze_me=False, struct_as_record=False)
+
+
+def _load_mat_v73_candidates(bytes_data: bytes) -> Dict[str, np.ndarray]:
+    """
+    v7.3(HDF5)のMATから、数値1D/2D/3D dataset を拾って返す。
+    keyは HDF5内のパスになります（例: 'group/data'）。
+    
+    修正: h5pyの新しいバージョンに対応。BytesIOではなく一時ファイルを使用。
+    """
+    if h5py is None:
+        raise RuntimeError("MAT v7.3(HDF5) 形式の可能性がありますが、h5py が入っていません。pip install h5py を実行してください。")
+
+    out: Dict[str, np.ndarray] = {}
+    
+    # h5pyの新しいバージョンではBytesIOから直接開けない場合があるため、一時ファイルを使用
+    with tempfile.NamedTemporaryFile(suffix='.mat', delete=False) as tmp:
+        tmp.write(bytes_data)
+        tmp_path = tmp.name
+    
+    try:
+        with h5py.File(tmp_path, "r") as f:
+
+            def visitor(name, obj):
+                if not isinstance(obj, h5py.Dataset):
+                    return
+                try:
+                    arr = obj[()]
+                except Exception:
+                    return
+
+                # MATLABの文字列/参照等は除外して、数値だけ
+                if isinstance(arr, np.ndarray) and arr.size > 0 and np.issubdtype(arr.dtype, np.number):
+                    if arr.ndim in (1, 2):
+                        out[name] = arr
+                    elif arr.ndim == 3:
+                        # 3次元配列も含める
+                        out[name + "_mean"] = arr.mean(axis=0)
+                        out[name + "_concat"] = arr.reshape(-1, arr.shape[-1])
+
+            f.visititems(lambda name, obj: visitor(name, obj))
+    finally:
+        # 一時ファイルを削除
+        try:
+            os.unlink(tmp_path)
+        except Exception:
+            pass
+
+    return out
+
+
+def load_mat_candidates(bytes_data: bytes) -> Dict[str, np.ndarray]:
+    """
+    Return dict: variable_name -> ndarray(1D/2D numeric)
+    Tries v7.2 (scipy.io.loadmat). If it fails, tries v7.3 (h5py).
+    """
+    try:
+        md = _load_mat_v72(bytes_data)
+        cands = _try_get_numeric_arrays_loadmat(md)
+        return cands
+    except Exception:
+        return _load_mat_v73_candidates(bytes_data)

src/preprocess.py

@@ -0,0 +1,59 @@
+# preprocessing.py
+from __future__ import annotations
+from dataclasses import dataclass
+import numpy as np
+import mne
+
+
+@dataclass(frozen=True)
+class PreprocessConfig:
+    fs: float
+    f_low: float
+    f_high: float
+
+
+def to_time_channel(x: np.ndarray) -> np.ndarray:
+    if x.ndim == 1:
+        return x[:, None]
+    if x.ndim != 2:
+        raise ValueError(f"Expected 1D or 2D array, got {x.shape}")
+    T, C = x.shape
+    if T <= 256 and C > T:
+        x = x.T
+    return x
+
+
+def bandpass_tc(x_tc: np.ndarray, cfg: PreprocessConfig) -> np.ndarray:
+    info = mne.create_info(
+        ch_names=[f"ch{i}" for i in range(x_tc.shape[1])],
+        sfreq=cfg.fs,
+        ch_types="eeg",
+    )
+    raw = mne.io.RawArray(x_tc.T, info, verbose=False)
+    raw_filt = raw.copy().filter(cfg.f_low, cfg.f_high, verbose=False)
+    return raw_filt.get_data().T
+
+
+def hilbert_envelope_tc(x_tc: np.ndarray) -> np.ndarray:
+    Xf = np.fft.fft(x_tc, axis=0)
+    N = Xf.shape[0]
+    h = np.zeros(N)
+    if N % 2 == 0:
+        h[0] = h[N // 2] = 1
+        h[1:N // 2] = 2
+    else:
+        h[0] = 1
+        h[1:(N + 1) // 2] = 2
+    env = np.abs(np.fft.ifft(Xf * h[:, None], axis=0))
+    return env.astype(np.float32)
+
+
+def preprocess_pipeline(x: np.ndarray, cfg: PreprocessConfig):
+    x_tc = to_time_channel(x)
+    x_filt = bandpass_tc(x_tc, cfg)
+    env = hilbert_envelope_tc(x_filt)
+    return {
+        "raw": x_tc,
+        "filtered": x_filt,
+        "envelope": env,
+    }

src/streamlit_app.py

@@ -1,40 +1,856 @@
-import altair as alt
+import io
+from dataclasses import dataclass
+from typing import List, Tuple
+
 import numpy as np
-import pandas as pd
 import streamlit as st
+import plotly.graph_objects as go
+import mne
+from scipy.signal import hilbert
+
+try:
+    import community as community_louvain
+    import networkx as nx
+    LOUVAIN_AVAILABLE = True
+except ImportError:
+    LOUVAIN_AVAILABLE = False
+    st.warning("⚠️ Louvainクラスタリングを使用するには `pip install python-louvain networkx` を実行してください。")
+
+from loader import (
+    pick_set_fdt,
+    load_eeglab_tc_from_bytes,
+    load_mat_candidates,
+)
+
+st.set_page_config(page_title="EEG Viewer + Network Estimation", layout="wide")
+
+
+# ============================================================
+# Preprocess config
+# ============================================================
+@dataclass(frozen=True)
+class PreprocessConfig:
+    fs: float
+    f_low: float
+    f_high: float
+
+
+# ============================================================
+# Helpers
+# ============================================================
+def ensure_tc(x: np.ndarray) -> np.ndarray:
+    """Ensure array is (T,C). Accept (T,), (T,C), (C,T) with heuristic transpose."""
+    x = np.asarray(x)
+    if x.ndim == 1:
+        return x[:, None]
+    if x.ndim != 2:
+        raise ValueError(f"2次元配列のみ対応です: shape={x.shape}")
+    T, C = x.shape
+    if T <= 256 and C > T:  # heuristic transpose
+        x = x.T
+    return x
+
+
+# ============================================================
+# Signal processing
+# ============================================================
+def bandpass_tc(x_tc: np.ndarray, cfg: PreprocessConfig) -> np.ndarray:
+    """Bandpass filter each channel using MNE RawArray. Input/Output: (T,C)."""
+    info = mne.create_info(
+        ch_names=[f"ch{i}" for i in range(x_tc.shape[1])],
+        sfreq=float(cfg.fs),
+        ch_types="eeg",
+    )
+    raw = mne.io.RawArray(x_tc.T, info, verbose=False)  # (C,T)
+    raw_filt = raw.copy().filter(l_freq=cfg.f_low, h_freq=cfg.f_high, verbose=False)
+    return raw_filt.get_data().T.astype(np.float32)
+
+
+def hilbert_envelope_tc(x_tc: np.ndarray) -> np.ndarray:
+    """Hilbert envelope per channel using SciPy. Input/Output: (T,C)."""
+    analytic = hilbert(x_tc, axis=0)
+    return np.abs(analytic).astype(np.float32)
+
+
+def hilbert_phase_tc(x_tc: np.ndarray) -> np.ndarray:
+    """Hilbert phase per channel using SciPy. Input/Output: (T,C)."""
+    analytic = hilbert(x_tc, axis=0)
+    return np.angle(analytic).astype(np.float32)
+
+
+def preprocess_tc(x_tc: np.ndarray, cfg: PreprocessConfig) -> dict:
+    """raw(T,C) -> filtered/envelope/phase をまとめて返す"""
+    x_tc = ensure_tc(x_tc).astype(np.float32)
+    x_filt = bandpass_tc(x_tc, cfg)
+    env = hilbert_envelope_tc(x_filt)
+    phase = hilbert_phase_tc(x_filt)
+    return {
+        "fs": float(cfg.fs), 
+        "raw": x_tc, 
+        "filtered": x_filt, 
+        "envelope": env,
+        "amplitude": env,  # envelope のエイリアス
+        "phase": phase
+    }
+
+
+@st.cache_data(show_spinner=False)
+def preprocess_all_eeglab(
+    set_bytes: bytes,
+    fdt_bytes: bytes,
+    set_name: str,
+    fdt_name: str,
+    f_low: float,
+    f_high: float,
+) -> dict:
+    """
+    EEGLAB bytes -> load -> auto preprocess (bandpass + hilbert).
+    fsは読み込んだデータのものを使う。
+    """
+    x_tc, fs = load_eeglab_tc_from_bytes(
+        set_bytes=set_bytes,
+        set_name=set_name,
+        fdt_bytes=fdt_bytes,
+        fdt_name=fdt_name,
+    )
+    cfg = PreprocessConfig(fs=float(fs), f_low=float(f_low), f_high=float(f_high))
+    return preprocess_tc(x_tc, cfg)
+
+
+@st.cache_data(show_spinner=False)
+def load_mat_candidates_cached(mat_bytes: bytes) -> dict:
+    """MAT candidatesをキャッシュ（UI操作で毎回読まない）"""
+    return load_mat_candidates(mat_bytes)
+
+
+# ============================================================
+# Viewer
+# ============================================================
+def window_slice(X_tc: np.ndarray, start_idx: int, end_idx: int, decim: int) -> np.ndarray:
+    start_idx = max(0, min(start_idx, X_tc.shape[0] - 1))
+    end_idx = max(start_idx + 1, min(end_idx, X_tc.shape[0]))
+    decim = max(1, int(decim))
+    return X_tc[start_idx:end_idx:decim, :]
+
+
+def make_timeseries_figure(
+    X_tc: np.ndarray,
+    selected_channels: List[int],
+    fs: float,
+    start_sec: float,
+    win_sec: float,
+    decim: int,
+    offset_mode: bool,
+    show_rangeslider: bool,
+    signal_type: str = "filtered",
+) -> go.Figure:
+    start_idx = int(round(start_sec * fs))
+    end_idx = int(round((start_sec + win_sec) * fs))
+
+    Xw = window_slice(X_tc, start_idx, end_idx, decim)
+    Tw = Xw.shape[0]
+    t = (np.arange(Tw) * decim + start_idx) / fs
+
+    fig = go.Figure()
+
+    if not selected_channels:
+        fig.update_layout(
+            title="Timeseries (no channel selected)",
+            height=450,
+            xaxis_title="time (s)",
+            yaxis_title="amplitude",
+        )
+        return fig
+
+    # 位相データの場合は特別な処理
+    is_phase = signal_type == "phase"
+
+    if offset_mode and len(selected_channels) > 1 and not is_phase:
+        per_ch_std = np.std(Xw[:, selected_channels], axis=0)
+        base = float(np.median(per_ch_std)) if np.isfinite(np.median(per_ch_std)) and np.median(per_ch_std) > 0 else 1.0
+        offset = 5.0 * base
+
+        for k, ch in enumerate(selected_channels):
+            y = Xw[:, ch] + k * offset
+            fig.add_trace(go.Scatter(x=t, y=y, mode="lines", name=f"ch{ch}", line=dict(width=1)))
+        ylab = "amplitude (offset)"
+    else:
+        for ch in selected_channels:
+            fig.add_trace(go.Scatter(x=t, y=Xw[:, ch], mode="lines", name=f"ch{ch}", line=dict(width=1)))
+        
+        if is_phase:
+            ylab = "phase (rad)"
+        else:
+            ylab = "amplitude"
+
+    # rangeslider の高さを考慮して調整
+    plot_height = 550 if show_rangeslider else 450
+    bottom_margin = 150 if show_rangeslider else 80
+
+    title_text = f"Timeseries: {signal_type}  (window={win_sec:.2f}s, start={start_sec:.2f}s, decim={decim})"
+
+    fig.update_layout(
+        title=title_text,
+        height=plot_height,
+        xaxis_title="time (s)",
+        yaxis_title=ylab,
+        legend=dict(orientation="h"),
+        margin=dict(l=60, r=20, t=80, b=bottom_margin),
+    )
+    
+    # 位相の場合は y軸の範囲を -π ~ π に固定
+    if is_phase:
+        fig.update_yaxes(range=[-np.pi - 0.5, np.pi + 0.5])
+    
+    if show_rangeslider:
+        fig.update_xaxes(
+            rangeslider=dict(
+                visible=True,
+                thickness=0.05,
+            )
+        )
+    else:
+        fig.update_xaxes(rangeslider=dict(visible=False))
+    
+    return fig
+
+
+# ============================================================
+# Network (multiple methods) + export
+# ============================================================
+def estimate_network_envelope_corr(X_tc: np.ndarray) -> np.ndarray:
+    """
+    Envelope (amplitude) の Pearson 相関係数を計算。
+    Input: X_tc (T, C) - envelope データ
+    Output: W (C, C) - 相関係数の絶対値
+    """
+    X = X_tc - X_tc.mean(axis=0, keepdims=True)
+    corr = np.corrcoef(X, rowvar=False)
+    W = np.abs(corr)
+    np.fill_diagonal(W, 0.0)
+    return np.nan_to_num(W, nan=0.0, posinf=0.0, neginf=0.0).astype(np.float32)
+
+
+def estimate_network_phase_corr(X_tc: np.ndarray) -> np.ndarray:
+    """
+    Phase の circular correlation (位相同期指標) を計算。
+    Input: X_tc (T, C) - phase データ (ラジアン)
+    Output: W (C, C) - circular correlation
+    
+    Circular correlation は以下で計算:
+    r_ij = |⟨exp(i*(θ_i - θ_j))⟩_t|
+    これは Phase Locking Value (PLV) とも呼ばれます。
+    """
+    T, C = X_tc.shape
+    W = np.zeros((C, C), dtype=np.float32)
+    
+    # 各チャンネルペアについて circular correlation を計算
+    for i in range(C):
+        for j in range(i + 1, C):
+            # 位相差
+            phase_diff = X_tc[:, i] - X_tc[:, j]
+            # PLV: |mean(exp(i*phase_diff))|
+            plv = np.abs(np.mean(np.exp(1j * phase_diff)))
+            W[i, j] = plv
+            W[j, i] = plv
+    
+    return np.nan_to_num(W, nan=0.0, posinf=0.0, neginf=0.0).astype(np.float32)
+
+
+def estimate_network_dummy(X_tc: np.ndarray) -> np.ndarray:
+    """
+    ダミー実装: 単純な相関係数の絶対値
+    (後方互換性のため残す)
+    """
+    X = X_tc - X_tc.mean(axis=0, keepdims=True)
+    corr = np.corrcoef(X, rowvar=False)
+    W = np.abs(corr)
+    np.fill_diagonal(W, 0.0)
+    return np.nan_to_num(W, nan=0.0, posinf=0.0, neginf=0.0).astype(np.float32)
+
+
+def threshold_edges(W: np.ndarray, thr: float) -> List[Tuple[int, int, float]]:
+    C = W.shape[0]
+    edges: List[Tuple[int, int, float]] = []
+    for i in range(C):
+        for j in range(i + 1, C):
+            w = float(W[i, j])
+            if w >= thr:
+                edges.append((i, j, w))
+    edges.sort(key=lambda x: x[2], reverse=True)
+    return edges
+
+
+def adjacency_at_threshold(W: np.ndarray, thr: float, weighted: bool) -> np.ndarray:
+    if weighted:
+        A = W.copy()
+        A[A < thr] = 0.0
+        np.fill_diagonal(A, 0.0)
+        return A
+    A = (W >= thr).astype(int)
+    np.fill_diagonal(A, 0)
+    return A
+
+
+def compute_louvain_clusters(W: np.ndarray, thr: float) -> np.ndarray:
+    """
+    Louvain法でクラスタリングを実行。
+    
+    Args:
+        W: 重み行列 (C, C)
+        thr: 閾値（これ以下のエッジは削除）
+    
+    Returns:
+        clusters: クラスタID配列 (C,)
+    """
+    if not LOUVAIN_AVAILABLE:
+        # Louvainが使えない場合は全ノードを同じクラスタに
+        return np.zeros(W.shape[0], dtype=int)
+    
+    # NetworkXグラフを作成
+    G = nx.Graph()
+    C = W.shape[0]
+    G.add_nodes_from(range(C))
+    
+    # 閾値以上のエッジを追加
+    for i in range(C):
+        for j in range(i + 1, C):
+            if W[i, j] >= thr:
+                G.add_edge(i, j, weight=W[i, j])
+    
+    # Louvain法でコミュニティ検出
+    partition = community_louvain.best_partition(G, weight='weight')
+    
+    # クラスタIDの配列に変換
+    clusters = np.array([partition[i] for i in range(C)])
+    
+    return clusters
+
+
+def get_cluster_colors(clusters: np.ndarray) -> List[str]:
+    """
+    クラスタIDから色のリストを生成。
+    
+    Args:
+        clusters: クラスタID配列 (C,)
+    
+    Returns:
+        colors: 色のリスト
+    """
+    import colorsys
+    
+    n_clusters = len(np.unique(clusters))
+    
+    # クラスタ数に応じて色相を均等に分割
+    colors = []
+    for cluster_id in clusters:
+        hue = cluster_id / max(n_clusters, 1)
+        r, g, b = colorsys.hsv_to_rgb(hue, 0.8, 0.95)
+        colors.append(f'rgb({int(255*r)}, {int(255*g)}, {int(255*b)})')
+    
+    return colors
+
+
+def make_network_figure(W: np.ndarray, thr: float, use_louvain: bool = True) -> tuple[go.Figure, int]:
+    C = W.shape[0]
+    angles = np.linspace(0, 2 * np.pi, C, endpoint=False)
+    xs = np.cos(angles)
+    ys = np.sin(angles)
+
+    edges = threshold_edges(W, thr)
+    fig = go.Figure()
+
+    # エッジの重みの範囲を取得（色と太さのスケーリング用）
+    if edges:
+        weights = [w for _, _, w in edges]
+        min_w = min(weights)
+        max_w = max(weights)
+        weight_range = max_w - min_w if max_w > min_w else 1.0
+    else:
+        min_w = 0
+        max_w = 1
+        weight_range = 1.0
+
+    # レインボーカラーマップ関数 (0=青 → 0.5=緑/黄 → 1=赤)
+    def get_rainbow_color(norm_val):
+        """正規化された値 (0-1) からレインボーカラーを生成"""
+        import colorsys
+        # HSVのHue: 240°(青) → 0°(赤) に変換
+        hue = (1.0 - norm_val) * 0.67  # 0.67 ≈ 240/360 (青)
+        r, g, b = colorsys.hsv_to_rgb(hue, 0.9, 0.95)
+        return f'rgba({int(255*r)}, {int(255*g)}, {int(255*b)}, 0.7)'
+
+    # エッジを描画（重みに応じて色と太さを変える）
+    for (i, j, w) in edges:
+        # 正規化された重み (0-1)
+        norm_w = (w - min_w) / weight_range if weight_range > 0 else 0.5
+        
+        # レインボーカラー: 弱い(青) → 中間(緑/黄) → 強い(赤)
+        color = get_rainbow_color(norm_w)
+        
+        # 太さ: 重みに比例 (0.5-4の範囲)
+        line_width = 0.5 + 3.5 * norm_w
+        
+        fig.add_trace(
+            go.Scatter(
+                x=[xs[i], xs[j]],
+                y=[ys[i], ys[j]],
+                mode="lines",
+                hoverinfo="text",
+                hovertext=f"ch{i} - ch{j}<br>weight: {w:.4f}",
+                line=dict(width=line_width, color=color),
+                showlegend=False,
+            )
+        )
+
+    # Louvainクラスタリング
+    if use_louvain and LOUVAIN_AVAILABLE:
+        clusters = compute_louvain_clusters(W, thr)
+        node_colors = get_cluster_colors(clusters)
+        n_clusters = len(np.unique(clusters))
+        title_suffix = f"  |  Louvain clusters: {n_clusters}"
+    else:
+        node_colors = ['#FFD700'] * C  # デフォルトのゴールド
+        clusters = np.zeros(C, dtype=int)
+        title_suffix = ""
+
+    # ノードを描画
+    fig.add_trace(
+        go.Scatter(
+            x=xs,
+            y=ys,
+            mode="markers+text",
+            text=[f"{k}" for k in range(C)],
+            textposition="bottom center",
+            marker=dict(
+                size=14, 
+                color=node_colors,
+                line=dict(width=2, color='white')
+            ),
+            hoverinfo="text",
+            hovertext=[f"channel {k}<br>cluster: {clusters[k]}" for k in range(C)],
+            showlegend=False,
+        )
+    )
+
+    fig.update_layout(
+        title=f"Estimated Network (thr={thr:.3f})  edges={len(edges)}{title_suffix}",
+        height=500,
+        xaxis=dict(visible=False),
+        yaxis=dict(visible=False),
+        margin=dict(l=10, r=10, t=50, b=10),
+        paper_bgcolor='rgba(0,0,0,0.9)',
+        plot_bgcolor='rgba(0,0,0,0.9)',
+    )
+    fig.update_yaxes(scaleanchor="x", scaleratio=1)
+    
+    # カラーバー的な説明を追加
+    if edges:
+        fig.add_annotation(
+            text=f"Edge color/width: weak (blue/thin) → medium (green/yellow) → strong (red/thick)<br>Weight range: {min_w:.3f} - {max_w:.3f}",
+            xref="paper", yref="paper",
+            x=0.5, y=-0.05,
+            showarrow=False,
+            font=dict(size=10, color='white'),
+            xanchor='center',
+        )
+    
+    return fig, len(edges)
+
+
+def make_edgecount_curve(W: np.ndarray) -> go.Figure:
+    vals = np.sort(W[np.triu_indices(W.shape[0], k=1)])
+    thr_grid = np.linspace(float(vals.max()), float(vals.min()), 120) if vals.size else np.array([0.0])
+    counts = [len(threshold_edges(W, float(thr))) for thr in thr_grid]
+
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=thr_grid, y=counts, mode="lines"))
+    fig.update_layout(
+        title="Edge count vs threshold (lower thr => more edges)",
+        xaxis_title="threshold",
+        yaxis_title="edge count",
+        height=300,
+    )
+    return fig
+
+
+def to_csv_bytes_matrix(mat: np.ndarray, fmt: str) -> bytes:
+    buf = io.StringIO()
+    np.savetxt(buf, mat, delimiter=",", fmt=fmt)
+    return buf.getvalue().encode("utf-8")
+
+
+def to_csv_bytes_edges(edges: List[Tuple[int, int, float]]) -> bytes:
+    buf = io.StringIO()
+    buf.write("source,target,weight\n")
+    for i, j, w in edges:
+        buf.write(f"{i},{j},{w:.6f}\n")
+    return buf.getvalue().encode("utf-8")
+
+
+# ============================================================
+# Sidebar UI
+# ============================================================
+st.sidebar.header("Input format")
+input_mode = st.sidebar.radio("データ形式", ["EEGLAB (.set + .fdt)", "MATLAB (.mat)"], index=0)
+
+st.sidebar.header("Preprocess (auto)")
+f_low = st.sidebar.number_input("Bandpass low (Hz)", min_value=0.0, value=8.0, step=0.5)
+f_high = st.sidebar.number_input("Bandpass high (Hz)", min_value=0.1, value=12.0, step=0.5)
+
+st.sidebar.header("Viewer controls")
+win_sec = st.sidebar.number_input("Window length (sec)", min_value=0.1, value=5.0, step=0.1)
+decim = st.sidebar.selectbox("Decimation (間引き)", options=[1, 2, 5, 10, 20, 50], index=1)
+offset_mode = st.sidebar.checkbox("重ね描画のオフセット表示", value=True)
+show_rangeslider = st.sidebar.checkbox("Plotly rangesliderを表示", value=False)
+signal_view = st.sidebar.radio(
+    "表示する信号", 
+    ["raw", "filtered", "amplitude", "phase"],
+    index=1,
+    help="raw: 生信号, filtered: バンドパス後, amplitude: Hilbert振幅(envelope), phase: Hilbert位相"
+)
+
+st.title("EEG timeseries viewer + network estimation")
+
+
+# ============================================================
+# Load + preprocess (EEGLAB / MAT)
+# ============================================================
+if input_mode.startswith("EEGLAB"):
+    st.sidebar.header("Upload (.set + .fdt)")
+    uploaded_files = st.sidebar.file_uploader(
+        "Upload EEGLAB files",
+        type=["set", "fdt"],
+        accept_multiple_files=True,
+    )
+
+    if uploaded_files:
+        set_file, fdt_file = pick_set_fdt(uploaded_files)
+        if set_file is None or fdt_file is None:
+            st.warning("`.set` と `.fdt` の両方をアップロードしてください。")
+        else:
+            try:
+                with st.spinner("Loading EEGLAB + preprocessing (bandpass + hilbert)..."):
+                    prep = preprocess_all_eeglab(
+                        set_bytes=set_file.getvalue(),
+                        fdt_bytes=fdt_file.getvalue(),
+                        set_name=set_file.name,
+                        fdt_name=fdt_file.name,
+                        f_low=float(f_low),
+                        f_high=float(f_high),
+                    )
+                st.session_state["prep"] = prep
+                st.session_state["W"] = None
+                st.success(f"Loaded & preprocessed. (T,C)={prep['raw'].shape}  fs={prep['fs']:.2f}Hz")
+            except Exception as e:
+                st.session_state.pop("prep", None)
+                st.session_state["W"] = None
+                st.error(f"読み込み/前処理エラー: {e}")
+
+else:
+    st.sidebar.header("Upload (.mat)")
+    mat_file = st.sidebar.file_uploader("Upload .mat", type=["mat"])
+
+    if mat_file is not None:
+        mat_bytes = mat_file.getvalue()
+        try:
+            cands = load_mat_candidates_cached(mat_bytes)
+            if not cands:
+                st.error("数値の1D/2D配列が見つかりませんでした。")
+                st.info("MATファイルの構造を確認しています...")
+                
+                # デバッグ: MATファイルの中身を表示
+                try:
+                    from scipy.io import loadmat
+                    mat_data = loadmat(io.BytesIO(mat_bytes))
+                    st.write("**MATファイルに含まれる変数:**")
+                    for k, v in mat_data.items():
+                        if not k.startswith('__'):
+                            if isinstance(v, np.ndarray):
+                                st.write(f"- `{k}`: shape={v.shape}, dtype={v.dtype}, ndim={v.ndim}")
+                            else:
+                                st.write(f"- `{k}`: type={type(v).__name__}")
+                except Exception as e:
+                    st.write(f"デバッグ情報の取得に失敗: {e}")
+                    
+                    # HDF5形式の場合も試す
+                    try:
+                        import h5py
+                        import tempfile
+                        with tempfile.NamedTemporaryFile(suffix='.mat', delete=False) as tmp:
+                            tmp.write(mat_bytes)
+                            tmp_path = tmp.name
+                        
+                        st.write("**HDF5形式として読み込み中...**")
+                        with h5py.File(tmp_path, 'r') as f:
+                            def show_structure(name, obj):
+                                if isinstance(obj, h5py.Dataset):
+                                    st.write(f"- `{name}`: shape={obj.shape}, dtype={obj.dtype}")
+                            f.visititems(show_structure)
+                        
+                        import os
+                        os.unlink(tmp_path)
+                    except Exception as e2:
+                        st.write(f"HDF5としても読み込めませんでした: {e2}")
+            else:
+                key = st.sidebar.selectbox("EEG配列（変数）を選択", options=list(cands.keys()))
+                fs_mat = st.sidebar.number_input("Sampling rate (Hz)", min_value=0.1, value=256.0, step=0.1)
+
+                # 変数が選択されたら自動的に前処理を実行
+                if key:
+                    x = cands[key]
+                    st.sidebar.write(f"選択した配列: shape={x.shape}, dtype={x.dtype}")
+                    try:
+                        with st.spinner("Preprocessing (bandpass + hilbert)..."):
+                            cfg = PreprocessConfig(fs=float(fs_mat), f_low=float(f_low), f_high=float(f_high))
+                            prep = preprocess_tc(x, cfg)
+
+                        st.session_state["prep"] = prep
+                        st.session_state["W"] = None
+                        st.success(f"Loaded MAT '{key}'. (T,C)={prep['raw'].shape}  fs={prep['fs']:.2f}Hz")
+                    except Exception as e:
+                        st.session_state.pop("prep", None)
+                        st.session_state["W"] = None
+                        st.error(f"前処理エラー: {e}")
+                        import traceback
+                        st.code(traceback.format_exc())
+        except Exception as e:
+            st.session_state.pop("prep", None)
+            st.session_state["W"] = None
+            st.error(f".mat 読み込みエラー: {e}")
+            import traceback
+            st.code(traceback.format_exc())
+
+
+if "prep" not in st.session_state:
+    st.info("左のサイドバーからデータをアップロードしてください。")
+    st.stop()
+
+
+# ============================================================
+# Viewer
+# ============================================================
+prep = st.session_state["prep"]
+fs = float(prep["fs"])
+X_tc = prep[signal_view]
+T, C = X_tc.shape
+
+duration_sec = (T - 1) / fs if T > 1 else 0.0
+max_start = max(0.0, float(duration_sec - win_sec))
+
+start_sec = st.sidebar.slider(
+    "Start time (sec)",
+    min_value=0.0,
+    max_value=float(max_start),
+    value=0.0,
+    step=float(max(0.01, win_sec / 200)),
+)
+
+st.sidebar.header("Channels")
+
+# チャンネル選択の便利機能
+col_ch1, col_ch2 = st.sidebar.columns(2)
+with col_ch1:
+    select_all = st.button("全選択")
+with col_ch2:
+    deselect_all = st.button("全解除")
+
+# 範囲選択
+with st.sidebar.expander("📊 範囲で選択"):
+    range_start = st.number_input("開始ch", min_value=0, max_value=C-1, value=0, step=1)
+    range_end = st.number_input("終了ch", min_value=0, max_value=C-1, value=min(C-1, 7), step=1)
+    if st.button("範囲を選択"):
+        st.session_state["selected_channels"] = list(range(int(range_start), int(range_end) + 1))
+
+# プリセット選択
+with st.sidebar.expander("⚡ プリセット"):
+    preset_col1, preset_col2 = st.columns(2)
+    with preset_col1:
+        if st.button("前頭部 (0-15)"):
+            st.session_state["selected_channels"] = list(range(min(16, C)))
+    with preset_col2:
+        if st.button("頭頂部 (16-31)"):
+            st.session_state["selected_channels"] = list(range(16, min(32, C)))
+    preset_col3, preset_col4 = st.columns(2)
+    with preset_col3:
+        if st.button("側頭部 (32-47)"):
+            st.session_state["selected_channels"] = list(range(32, min(48, C)))
+    with preset_col4:
+        if st.button("後頭部 (48-63)"):
+            st.session_state["selected_channels"] = list(range(48, min(64, C)))
+
+# セッションステートの初期化
+if "selected_channels" not in st.session_state:
+    st.session_state["selected_channels"] = list(range(min(C, 8)))
+
+# ボタンによる選択の処理
+if select_all:
+    st.session_state["selected_channels"] = list(range(C))
+if deselect_all:
+    st.session_state["selected_channels"] = []
+
+# メインの選択UI（最大表示数を制限）
+max_display = 20  # multiselect で一度に表示する数を制限
+if C <= max_display:
+    selected_channels = st.sidebar.multiselect(
+        f"表示するチャンネル（全{C}ch）",
+        options=list(range(C)),
+        default=st.session_state["selected_channels"],
+        key="ch_select",
+    )
+else:
+    # 大量のチャンネルがある場合は、選択済みのものだけ表示
+    st.sidebar.caption(f"選択中: {len(st.session_state['selected_channels'])} / {C} channels")
+    
+    # 個別追加
+    add_ch = st.sidebar.number_input(
+        "チャンネルを追加", 
+        min_value=0, 
+        max_value=C-1, 
+        value=0, 
+        step=1,
+        key="add_ch_input"
+    )
+    col_add, col_remove = st.sidebar.columns(2)
+    with col_add:
+        if st.button("➕ 追加"):
+            if add_ch not in st.session_state["selected_channels"]:
+                st.session_state["selected_channels"].append(int(add_ch))
+                st.session_state["selected_channels"].sort()
+    with col_remove:
+        if st.button("➖ 削除"):
+            if add_ch in st.session_state["selected_channels"]:
+                st.session_state["selected_channels"].remove(int(add_ch))
+    
+    # 現在の選択を表示
+    if st.session_state["selected_channels"]:
+        selected_str = ", ".join(map(str, st.session_state["selected_channels"][:10]))
+        if len(st.session_state["selected_channels"]) > 10:
+            selected_str += f", ... (+{len(st.session_state['selected_channels']) - 10})"
+        st.sidebar.text(f"選択済み: {selected_str}")
+    
+    selected_channels = st.session_state["selected_channels"]
+
+# セッションステートを更新（multiselectを使った場合）
+if C <= max_display:
+    st.session_state["selected_channels"] = selected_channels
+
+col1, col2 = st.columns([2, 1])
+with col1:
+    fig_ts = make_timeseries_figure(
+        X_tc=X_tc,
+        selected_channels=selected_channels,
+        fs=fs,
+        start_sec=float(start_sec),
+        win_sec=float(win_sec),
+        decim=int(decim),
+        offset_mode=bool(offset_mode),
+        show_rangeslider=bool(show_rangeslider),
+        signal_type=signal_view,
+    )
+    st.plotly_chart(fig_ts)
+
+with col2:
+    st.subheader("Data info")
+    signal_desc = {
+        "raw": "生信号（前処理なし）",
+        "filtered": f"バンドパスフィルタ後 ({f_low}-{f_high} Hz)",
+        "amplitude": "Hilbert振幅 (envelope)",
+        "phase": "Hilbert位相 (-π ~ π)"
+    }
+    st.write(f"- view: **{signal_view}** ({signal_desc.get(signal_view, '')})")
+    st.write(f"- fs: **{fs:.2f} Hz**")
+    st.write(f"- T: {T} samples")
+    st.write(f"- C: {C} channels")
+    st.write(f"- duration: {duration_sec:.2f} sec")
+    
+    if signal_view == "phase":
+        st.caption("※ 位相は -π (rad) から π (rad) の範囲で表示されます")
+    
+    st.caption("※ 大規模データは window + decimation 推奨。rangesliderは重い場合OFF。")
+
+st.divider()
+
+
+# ============================================================
+# Estimation
+# ============================================================
+st.subheader("Network estimation")
+
+# 推定手法の選択
+estimation_method = st.radio(
+    "推定手法を選択",
+    options=[
+        "envelope_corr",
+        "phase_corr",
+    ],
+    format_func=lambda x: {
+        "envelope_corr": "Envelope correlation (振幅の相関)",
+        "phase_corr": "Phase circular correlation (位相同期, PLV)",
+    }[x],
+    horizontal=True,
+    help="envelope_corr: 振幅包絡線のPearson相関係数 | phase_corr: 位相の circular correlation (Phase Locking Value)",
+)
+
+# 推定手法の説明
+method_info = {
+    "envelope_corr": "**Envelope correlation**: 振幅包絡線（Hilbert amplitude）間のPearson相関係数を計算します。振幅が同期して変動するチャンネル間の結合を検出します。",
+    "phase_corr": "**Phase circular correlation (PLV)**: 位相間の circular correlation を計算します。Phase Locking Value (PLV) とも呼ばれ、位相同期を検出します。0（非同期）〜1（完全同期）の値を取ります。",
+}
+st.info(method_info[estimation_method])
+
+# セッションステートから前回の手法と W を取得
+last_method = st.session_state.get("last_estimation_method")
+W = st.session_state.get("W")
+
+# 推定が必要かチェック（初回 or 手法変更）
+need_estimation = (W is None) or (last_method != estimation_method)
+
+if need_estimation:
+    with st.spinner(f"推定中... ({estimation_method})"):
+        if estimation_method == "envelope_corr":
+            X_in = prep["amplitude"]
+            W = estimate_network_envelope_corr(X_in)
+        elif estimation_method == "phase_corr":
+            X_in = prep["phase"]
+            W = estimate_network_phase_corr(X_in)
+        else:
+            st.error("未知の推定手法です")
+            st.stop()
+        
+        # セッションステートに保存
+        st.session_state["W"] = W
+        st.session_state["last_estimation_method"] = estimation_method
+        st.success(f"✅ 推定完了: {estimation_method} (ネットワークサイズ: {W.shape[0]} nodes)")
+else:
+    st.success(f"✓ 推定済み: **{estimation_method}** (ネットワークサイズ: {W.shape[0]} nodes)")
+
+# この時点で W は必ず存在する
+# 閾値スライダーとネットワーク図の表示
+wmax = float(np.max(W)) if np.isfinite(np.max(W)) else 1.0
+
+col_thr1, col_thr2 = st.columns([3, 1])
+with col_thr1:
+    thr = st.slider(
+        "閾値 (threshold)  ※下げるほどエッジが増えます",
+        min_value=0.0,
+        max_value=max(0.0001, wmax),
+        value=min(0.5, wmax),
+        step=max(wmax / 200, 0.001),
+    )
+with col_thr2:
+    use_louvain = st.checkbox(
+        "Louvainクラスタリング", 
+        value=True, 
+        disabled=not LOUVAIN_AVAILABLE,
+        help="ノードの色をコミュニティ検出結果で塗り分けます"
+    )
+
+net_col1, net_col2 = st.columns([2, 1])
+with net_col1:
+    fig_net, edge_n = make_network_figure(W, float(thr), use_louvain=use_louvain)
+    st.plotly_chart(fig_net)
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+with net_col2:
+    st.metric("Edges", edge_n)
+    st.plotly_chart(make_edgecount_curve(W))