[add] directed graph

requirements.txt

@@ -5,4 +5,5 @@ scipy
 mne
 h5py
 networkx
-python-louvain
+python-louvain
+tensorpac

src/loader.py

@@ -42,12 +42,123 @@ def same_stem(a_name: str, b_name: str) -> bool:
     return a_stem == b_stem
 
 
-def extract_electrode_positions_2d(set_path: str) -> np.ndarray:
+def extract_electrode_positions_from_hdf5(set_path: str) -> tuple:
     """
-    EEGLABファイルから電極位置（2D）を抽出。
+    HDF5形式のEEGLABファイルから電極位置を抽出。
     
     Returns:
-        pos: (C, 2) 電極の2D座標、取得できない場合はNone
+        tuple: (pos_2d, pos_3d)
+            pos_2d: (C, 2) 電極の2D座標、取得できない場合はNone
+            pos_3d: (C, 3) 電極の3D座標、取得できない場合はNone
+    """
+    if h5py is None:
+        return None, None
+    
+    try:
+        with h5py.File(set_path, "r") as f:
+            # EEGLABのchanlocs構造を探す
+            chanlocs_path = None
+            for path in ["EEG/chanlocs", "chanlocs"]:
+                if path in f:
+                    chanlocs_path = path
+                    break
+            
+            if chanlocs_path is None:
+                return None, None
+            
+            chanlocs = f[chanlocs_path]
+            
+            # X, Y, Z座標を取得
+            xs, ys, zs = [], [], []
+            
+            # パターン1: chanlocs/X, chanlocs/Y, chanlocs/Z が直接データの場合
+            if "X" in chanlocs and "Y" in chanlocs and "Z" in chanlocs:
+                x_data = chanlocs["X"][()]
+                y_data = chanlocs["Y"][()]
+                z_data = chanlocs["Z"][()]
+                
+                # 参照型の場合は各参照を辿る
+                if x_data.dtype == h5py.ref_dtype:
+                    for i in range(len(x_data)):
+                        try:
+                            x_val = f[x_data[i, 0]][()]
+                            y_val = f[y_data[i, 0]][()]
+                            z_val = f[z_data[i, 0]][()]
+                            
+                            # スカラー値を取得
+                            x_val = float(x_val.flat[0]) if hasattr(x_val, 'flat') else float(x_val)
+                            y_val = float(y_val.flat[0]) if hasattr(y_val, 'flat') else float(y_val)
+                            z_val = float(z_val.flat[0]) if hasattr(z_val, 'flat') else float(z_val)
+                            
+                            xs.append(x_val)
+                            ys.append(y_val)
+                            zs.append(z_val)
+                        except:
+                            # 読み込めない座標は0に
+                            xs.append(0.0)
+                            ys.append(0.0)
+                            zs.append(0.0)
+                else:
+                    # 直接数値データの場合
+                    xs = x_data.flatten().astype(float)
+                    ys = y_data.flatten().astype(float)
+                    zs = z_data.flatten().astype(float)
+            else:
+                return None, None
+            
+            # リストをnumpy配列に変換
+            xs = np.array(xs, dtype=float)
+            ys = np.array(ys, dtype=float)
+            zs = np.array(zs, dtype=float)
+            
+            if len(xs) == 0:
+                return None, None
+            
+            # NaN値をチェック（数値型に変換後）
+            valid_mask = ~(np.isnan(xs) | np.isnan(ys) | np.isnan(zs))
+            if not np.any(valid_mask):
+                return None, None
+            
+            # 無効な座標は平均値で置き換え
+            if not np.all(valid_mask):
+                xs[~valid_mask] = np.nanmean(xs)
+                ys[~valid_mask] = np.nanmean(ys)
+                zs[~valid_mask] = np.nanmean(zs)
+            
+            # 3D座標を構築
+            positions_3d = np.column_stack([xs, ys, zs])
+            
+            # 正規化
+            dists = np.sqrt(np.sum(positions_3d**2, axis=1))
+            max_dist_3d = np.max(dists[dists > 0]) if np.any(dists > 0) else 1.0
+            if max_dist_3d > 0:
+                positions_3d = positions_3d / max_dist_3d
+            
+            # 2D投影
+            pos_2d = positions_3d[:, :2]
+            dists_2d = np.sqrt(np.sum(pos_2d**2, axis=1))
+            max_dist_2d = np.max(dists_2d[dists_2d > 0]) if np.any(dists_2d > 0) else 1.0
+            if max_dist_2d > 0:
+                pos_2d = pos_2d / max_dist_2d * 0.85
+            
+            print(f"HDF5から電極位置を取得: {len(xs)} channels")
+            return pos_2d.astype(np.float32), positions_3d.astype(np.float32)
+            
+    except Exception as e:
+        print(f"HDF5から電極位置の抽出に失敗: {e}")
+        import traceback
+        traceback.print_exc()
+        return None, None
+
+
+def extract_electrode_positions_2d(set_path: str):
+    """
+    EEGLABファイルから電極位置（2D, 3D）を抽出。
+    
+    Returns:
+        tuple: (pos_2d, pos_3d)
+            pos_2d: (C, 2) 電極の2D座標、取得できない場合はNone
+            pos_3d: (C, 3) 電極の3D座標、取得できない場合はNone
     """
     try:
         # MNEで読み込み
@@ -55,43 +166,186 @@ def extract_electrode_positions_2d(set_path: str) -> np.ndarray:
         montage = raw.get_montage()
         
         if montage is None:
-            return None
+            return None, None
         
         # 3D座標を取得
-        pos_3d = montage.get_positions()['ch_pos']
+        pos_3d_dict = montage.get_positions()['ch_pos']
         
-        if not pos_3d:
-            return None
+        if not pos_3d_dict:
+            return None, None
         
         # チャンネル名順に並べ替え
         ch_names = raw.ch_names
-        positions = []
+        positions_3d = []
         for ch_name in ch_names:
-            if ch_name in pos_3d:
-                positions.append(pos_3d[ch_name])
+            if ch_name in pos_3d_dict:
+                positions_3d.append(pos_3d_dict[ch_name])
             else:
                 # 座標がないチャンネルは原点に配置
-                positions.append([0, 0, 0])
+                positions_3d.append([0, 0, 0])
         
-        positions = np.array(positions)
+        positions_3d = np.array(positions_3d)
+        
+        # 3D座標を正規化
+        max_dist_3d = np.max(np.sqrt(np.sum(positions_3d**2, axis=1)))
+        if max_dist_3d > 0:
+            positions_3d = positions_3d / max_dist_3d
         
         # 3D -> 2D 投影（上から見た図）
-        # x, y座標を使用し、正規化
-        pos_2d = positions[:, :2]
+        pos_2d = positions_3d[:, :2]
         
-        # 正規化: 最大距離が1になるようにスケーリング
-        max_dist = np.max(np.sqrt(np.sum(pos_2d**2, axis=1)))
-        if max_dist > 0:
-            pos_2d = pos_2d / max_dist * 0.85  # 0.85倍で頭の輪郭内に収める
+        # 2D座標を正規化: 最大距離が0.85になるようにスケーリング
+        max_dist_2d = np.max(np.sqrt(np.sum(pos_2d**2, axis=1)))
+        if max_dist_2d > 0:
+            pos_2d = pos_2d / max_dist_2d * 0.85
         
-        return pos_2d.astype(np.float32)
+        return pos_2d.astype(np.float32), positions_3d.astype(np.float32)
         
     except Exception as e:
         print(f"電極位置の抽出に失敗: {e}")
-        return None
+        return None, None
 
 
-def _load_eeglab_hdf5(set_path: str, fdt_path: Optional[str] = None, debug: bool = False) -> Tuple[np.ndarray, float]:
+def _load_eeglab_hdf5(set_path: str, fdt_path: Optional[str] = None, debug: bool = False):
+    """
+    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
     """
     EEGLABファイルから電極位置（2D）を抽出。
     
@@ -322,13 +576,15 @@ def load_eeglab_tc_from_bytes(
     set_name: str,
     fdt_bytes: Optional[bytes] = None,
     fdt_name: Optional[str] = None,
-) -> Tuple[np.ndarray, float, Optional[np.ndarray]]:
+):
     """
     Load EEGLAB .set (and optional .fdt) from bytes using MNE or h5py.
     Returns:
-      x_tc: (T, C) float32
-      fs: sampling rate (Hz)
-      electrode_pos: (C, 2) float32 or None - 電極の2D座標
+      tuple: (x_tc, fs, electrode_pos_2d, electrode_pos_3d)
+        x_tc: (T, C) float32
+        fs: sampling rate (Hz)
+        electrode_pos_2d: (C, 2) float32 or None - 電極の2D座標
+        electrode_pos_3d: (C, 3) float32 or None - 電極の3D座標
 
     Notes:
       - 多くのEEGLABは .set が .fdt を参照するため、同じディレクトリに同名で置く必要があります。
@@ -359,9 +615,13 @@ def load_eeglab_tc_from_bytes(
             x_tc = raw.get_data().T  # (T,C)
             
             # 電極位置を取得
-            electrode_pos = extract_electrode_positions_2d(set_path)
+            result = extract_electrode_positions_2d(set_path)
+            if result is not None:
+                electrode_pos_2d, electrode_pos_3d = result
+            else:
+                electrode_pos_2d, electrode_pos_3d = None, None
             
-            return x_tc.astype(np.float32), fs, electrode_pos
+            return x_tc.astype(np.float32), fs, electrode_pos_2d, electrode_pos_3d
 
         except Exception as e_raw:
             # 2) Epochsとして読む（エポックデータ用）
@@ -375,9 +635,13 @@ def load_eeglab_tc_from_bytes(
                 x_tc = x_mean.T           # (T,C)
                 
                 # 電極位置を取得（epochsからも取得可能）
-                electrode_pos = extract_electrode_positions_2d(set_path)
+                result = extract_electrode_positions_2d(set_path)
+                if result is not None:
+                    electrode_pos_2d, electrode_pos_3d = result
+                else:
+                    electrode_pos_2d, electrode_pos_3d = None, None
                 
-                return x_tc.astype(np.float32), fs, electrode_pos
+                return x_tc.astype(np.float32), fs, electrode_pos_2d, electrode_pos_3d
 
             except Exception as e_ep:
                 # 3) HDF5形式として読む（MATLAB v7.3）
@@ -388,20 +652,32 @@ def load_eeglab_tc_from_bytes(
                     import sys
                     if 'streamlit' in sys.modules:
                         debug = True
-                    x_tc, fs = _load_eeglab_hdf5(set_path, fdt_path=fdt_path, debug=debug)
                     
-                    # HDF5の場合は電極位置を取得できない（参照形式のため）
-                    electrode_pos = None
+                    try:
+                        x_tc, fs = _load_eeglab_hdf5(set_path, fdt_path=fdt_path, debug=debug)
+                    except Exception as e_hdf5_inner:
+                        import traceback
+                        print("HDF5読み込みの詳細エラー:")
+                        print(traceback.format_exc())
+                        raise e_hdf5_inner
+                    
+                    # HDF5の場合、電極位置をHDF5から直接取得を試みる
+                    electrode_pos_2d, electrode_pos_3d = extract_electrode_positions_from_hdf5(set_path)
+                    
+                    if debug and electrode_pos_2d is not None:
+                        print(f"HDF5から電極位置を取得しました: {electrode_pos_2d.shape}")
                     
-                    return x_tc, fs, electrode_pos
+                    return x_tc, fs, electrode_pos_2d, electrode_pos_3d
                 
                 except Exception as e_hdf5:
+                    import traceback
                     # すべて失敗した場合
                     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"
+                        f"\n詳細トレースバック:\n{traceback.format_exc()}"
                     )
                     raise RuntimeError(msg) from e_hdf5
 

src/metrics.py

@@ -0,0 +1,73 @@
+import numpy as np
+from scipy import stats
+
+def chatterjee_phase_to_amp(phi, amp, agg="max"):
+    """
+    phi: phase in radians (1D)
+    amp: amplitude (1D)
+    agg: 'max' | 'mean' | 'rss'
+    """
+    s = np.sin(phi)
+    c = np.cos(phi)
+
+    xi_s = stats.chatterjeexi(s, amp).statistic
+    xi_c = stats.chatterjeexi(c, amp).statistic
+
+    if agg == "max":
+        xi = np.nanmax([xi_s, xi_c])
+    elif agg == "mean":
+        xi = np.nanmean([xi_s, xi_c])
+    elif agg == "rss":
+        xi = np.sqrt(xi_s**2 + xi_c**2)
+        xi = float(np.clip(xi, 0.0, 1.0))
+    else:
+        raise ValueError("agg must be 'max', 'mean', or 'rss'")
+
+    return xi #, {"xi_sin": xi_s, "xi_cos": xi_c}
+
+def circular_correlation(rho, theta, mu=None, tau=None):
+    rho = np.asarray(rho)
+    theta = np.asarray(theta)
+
+    if mu is None:
+        mu = np.angle(np.mean(np.exp(1j * rho)))
+    if tau is None:
+        tau = np.angle(np.mean(np.exp(1j * theta)))
+
+    x = np.sin(rho - mu)
+    y = np.sin(theta - tau)
+
+    return np.mean(x * y) / np.sqrt(np.var(x) * np.var(y))
+
+
+def modulation_index(phase, amp, n_bins=18, eps=1e-12):
+    """
+    Tort et al. (2010) Modulation Index
+    phase : radians (-pi, pi]
+    amp   : amplitude envelope (>=0)
+    """
+    phase = np.asarray(phase).ravel()
+    amp = np.asarray(amp).ravel()
+    mask = np.isfinite(phase) & np.isfinite(amp)
+    phase = phase[mask]
+    amp = amp[mask]
+
+    # phase bins
+    edges = np.linspace(-np.pi, np.pi, n_bins + 1)
+    bins = np.digitize(phase, edges) - 1
+    bins = np.clip(bins, 0, n_bins - 1)
+
+    mean_amp = np.zeros(n_bins)
+    for k in range(n_bins):
+        if np.any(bins == k):
+            mean_amp[k] = amp[bins == k].mean()
+
+    if mean_amp.sum() == 0:
+        return np.nan
+
+    p = mean_amp / mean_amp.sum()
+    uniform = 1.0 / n_bins
+
+    kl = np.sum(p * np.log((p + eps) / uniform))
+    mi = kl / np.log(n_bins)
+    return mi

src/streamlit_app.py

@@ -22,6 +22,8 @@ from loader import (
     load_mat_candidates,
 )
 
+import metrics
+
 st.set_page_config(page_title="EEG Viewer + Network Estimation", layout="wide")
 
 
@@ -50,6 +52,19 @@ def ensure_tc(x: np.ndarray) -> np.ndarray:
         x = x.T
     return x
 
+def _quad_bezier_points(p0, p1, c, n=20):
+    """2次Bezierを点列にして返す (n点)"""
+    ts = np.linspace(0, 1, n)
+    pts = (1-ts)[:,None]**2 * p0 + 2*(1-ts)[:,None]*ts[:,None]*c + ts[:,None]**2 * p1
+    return pts  # shape (n,2)
+
+def _quad_bezier_point_and_tangent(p0, p1, c, t):
+    """2次Bezierの点と接線ベクトル（微分）を返す"""
+    # B(t) = (1-t)^2 p0 + 2(1-t)t c + t^2 p1
+    pt = (1-t)**2 * p0 + 2*(1-t)*t * c + t**2 * p1
+    # B'(t) = 2(1-t)(c-p0) + 2t(p1-c)
+    tan = 2*(1-t)*(c-p0) + 2*t*(p1-c)
+    return pt, tan
 
 # ============================================================
 # Signal processing
@@ -107,7 +122,7 @@ def preprocess_all_eeglab(
     EEGLAB bytes -> load -> auto preprocess (bandpass + hilbert).
     fsは読み込んだデータのものを使う。
     """
-    x_tc, fs, electrode_pos = load_eeglab_tc_from_bytes(
+    x_tc, fs, electrode_pos_2d, electrode_pos_3d = load_eeglab_tc_from_bytes(
         set_bytes=set_bytes,
         set_name=set_name,
         fdt_bytes=fdt_bytes,
@@ -117,8 +132,10 @@ def preprocess_all_eeglab(
     result = preprocess_tc(x_tc, cfg)
     
     # 電極位置を追加
-    if electrode_pos is not None:
-        result["electrode_pos"] = electrode_pos
+    if electrode_pos_2d is not None:
+        result["electrode_pos"] = electrode_pos_2d
+    if electrode_pos_3d is not None:
+        result["electrode_pos_3d"] = electrode_pos_3d
     
     return result
 
@@ -236,30 +253,103 @@ def estimate_network_envelope_corr(X_tc: np.ndarray) -> np.ndarray:
     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 (位相同期指標) を計算。
+    Phase の PLV を計算。
     Input: X_tc (T, C) - phase データ (ラジアン)
     Output: W (C, C) - circular correlation
     
-    Circular correlation は以下で計算:
+    circular correlationは以下で計算:
+    
+    """
+    T, C = X_tc.shape
+    W = np.zeros((C, C), dtype=np.float32)
+    
+    # 各チャンネルペアについて PLV を計算
+    for i in range(C):
+        for j in range(i + 1, C):
+            #Jammalamadaka–Sengupta circular correlation
+            corr = metrics.circular_correlation(X_tc[:, i], X_tc[:, j])
+            W[i, j] = corr
+            W[j, i] = corr
+    
+    return np.nan_to_num(W, nan=0.0, posinf=0.0, neginf=0.0).astype(np.float32)
+
+def estimate_network_phase_PLV(X_tc: np.ndarray, progress) -> np.ndarray:
+    """
+    Phase の PLV を計算。
+    Input: X_tc (T, C) - phase データ (ラジアン)
+    Output: W (C, C) - PLV
+    
+    PLV は以下で計算:
     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 を計算
+    # 各チャンネルペアについて PLV を計算
+    tmp_ = 0
     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
+            tmp_ += 1
+            progress.progress(tmp_ / (int(C*(C-1)/2)))
+
+    return np.nan_to_num(W, nan=0.0, posinf=0.0, neginf=0.0).astype(np.float32)
+
+
+def estimate_network_pac_tort(X_tc1, X_tc2, progress):
+    """
+    PACを目的としてModulation Indexを計算
+    Input: X_tc1 (T, C) - phase データ (ラジアン)
+    Input: X_tc2 (T, C) - envelope データ
+    Output: W (C, C) - Modulation Index
+    """
+    assert X_tc1.shape == X_tc2.shape
+    T, C = X_tc1.shape
+    W = np.zeros((C, C), dtype=np.float32)
     
+    # 各チャンネルペアについて Chatterjee correlation を計算
+    tmp_ = 0
+    for i in range(C):
+        for j in range(C):
+            if i == j:
+                continue
+            # Modulation Index from Tort et al.(2010)
+            mi_ = metrics.modulation_index(X_tc1[:, i], X_tc2[:, j])
+            W[i, j] = mi_
+            tmp_ += 1
+            progress.progress(tmp_ / (C*C))
+
+    return np.nan_to_num(W, nan=0.0, posinf=0.0, neginf=0.0).astype(np.float32)
+
+def estimate_network_pac_chatterjee(X_tc1, X_tc2, progress):
+    """
+    PACを目的としてChatterjee相関を計算
+    Input: X_tc1 (T, C) - phase データ (ラジアン)
+    Input: X_tc2 (T, C) - envelope データ
+    Output: W (C, C) - Chatterjee correlation from phase to envelope
+    """
+    assert X_tc1.shape == X_tc2.shape
+    T, C = X_tc1.shape
+    W = np.zeros((C, C), dtype=np.float32)
+    
+    # 各チャンネルペアについて Chatterjee correlation を計算
+    tmp_ = 0
+    for i in range(C):
+        for j in range(C):
+            if i == j:
+                continue
+            # Chatterjee相関係数
+            corr_ = metrics.chatterjee_phase_to_amp(X_tc1[:, i], X_tc2[:, j])
+            W[i, j] = corr_
+            tmp_ += 1
+            progress.progress(tmp_ / (C*C))
+
     return np.nan_to_num(W, nan=0.0, posinf=0.0, neginf=0.0).astype(np.float32)
 
 
@@ -275,18 +365,47 @@ def estimate_network_dummy(X_tc: np.ndarray) -> np.ndarray:
     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]]:
+def threshold_edges(
+    W: np.ndarray,
+    thr: float,
+) -> List[Tuple[int, int, float]]:
+    """
+    エッジ抽出関数
+
+    - W が対称 → 無向グラフとして i < j のみ抽出
+    - W が非対称 → 有向グラフとして i -> j をすべて抽出
+
+    Returns:
+        (i, j, w): 対称の場合は無向、非対称の場合は i→j
+    """
     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))
+
+    is_symmetric = np.allclose(W, W.T, atol=1e-12, rtol=0)
+
+    if is_symmetric:
+        # --- 無向グラフ ---
+        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))
+    else:
+        # --- 有向グラフ ---
+        for i in range(C):
+            for j in range(C):
+                if i == j:
+                    continue
+                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()
@@ -320,9 +439,9 @@ def compute_louvain_clusters(W: np.ndarray, thr: float) -> np.ndarray:
     
     # 閾値以上のエッジを追加
     for i in range(C):
-        for j in range(i + 1, C):
+        for j in range(C):
             if W[i, j] >= thr:
-                G.add_edge(i, j, weight=W[i, j])
+                G.add_edge(i, j, weight=max(W[i, j],W[j, i]))
     
     # Louvain法でコミュニティ検出
     partition = community_louvain.best_partition(G, weight='weight')
@@ -376,37 +495,101 @@ def get_electrode_positions(prep: dict) -> np.ndarray:
     ys = np.sin(angles)
     return np.column_stack([xs, ys])
 
-
-def get_head_outline() -> dict:
+def make_network_figure_3d(
+    W: np.ndarray,
+    thr: float,
+    electrode_pos_3d: np.ndarray,
+    use_louvain: bool = True,
+) -> go.Figure:
     """
-    脳の輪郭（頭のアウトライン）を生成。
-    
-    Returns:
-        outline: {'head': (x, y), 'nose': (x, y), 'ears': [(x_left, y_left), (x_right, y_right)]}
+    3Dネットワーク図を作成（ドラッグで回転可能）
     """
-    # 頭の円
-    theta = np.linspace(0, 2*np.pi, 100)
-    head_x = np.cos(theta)
-    head_y = np.sin(theta)
+    C = W.shape[0]
+    xs = electrode_pos_3d[:, 0]
+    ys = electrode_pos_3d[:, 1]
+    zs = electrode_pos_3d[:, 2]
     
-    # 鼻（上部の三角形）
-    nose_x = np.array([0, -0.1, 0.1, 0])
-    nose_y = np.array([1.0, 1.15, 1.15, 1.0])
+    edges = threshold_edges(W, thr)
+    fig = go.Figure()
     
-    # 耳（左右の突起）
-    ear_theta = np.linspace(-np.pi/4, np.pi/4, 20)
-    ear_left_x = -1.0 + 0.08 * np.cos(ear_theta)
-    ear_left_y = 0.08 * np.sin(ear_theta)
+    # エッジの重みの範囲を取得
+    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
     
-    ear_right_x = 1.0 - 0.08 * np.cos(ear_theta)
-    ear_right_y = 0.08 * np.sin(ear_theta)
+    # レインボーカラーマップ関数
+    def get_rainbow_color(norm_val):
+        import colorsys
+        hue = (1.0 - norm_val) * 0.67
+        r, g, b = colorsys.hsv_to_rgb(hue, 0.9, 0.95)
+        return f'rgb({int(255*r)}, {int(255*g)}, {int(255*b)})'
     
-    return {
-        'head': (head_x, head_y),
-        'nose': (nose_x, nose_y),
-        'ear_left': (ear_left_x, ear_left_y),
-        'ear_right': (ear_right_x, ear_right_y),
-    }
+    # エッジを描画
+    for (i, j, w) in edges:
+        norm_w = (w - min_w) / weight_range if weight_range > 0 else 0.5
+        color = get_rainbow_color(norm_w)
+        line_width = 1 + 4 * norm_w
+        
+        fig.add_trace(go.Scatter3d(
+            x=[xs[i], xs[j], None],
+            y=[ys[i], ys[j], None],
+            z=[zs[i], zs[j], None],
+            mode='lines',
+            line=dict(color=color, width=line_width),
+            hoverinfo='skip',
+            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.Scatter3d(
+        x=xs,
+        y=ys,
+        z=zs,
+        mode='markers+text',
+        text=[f"{k}" for k in range(C)],
+        textposition='top center',
+        textfont=dict(size=8),
+        marker=dict(
+            size=8,
+            color=node_colors,
+            line=dict(color='white', width=1),
+        ),
+        hoverinfo='text',
+        hovertext=[f"channel {k}<br>cluster: {clusters[k]}" for k in range(C)],
+        showlegend=False,
+    ))
+    
+    fig.update_layout(
+        title=f"3D Network (thr={thr:.3f})  edges={len(edges)}{title_suffix}",
+        height=700,
+        scene=dict(
+            xaxis=dict(visible=False),
+            yaxis=dict(visible=False),
+            zaxis=dict(visible=False),
+            bgcolor='rgba(0,0,0,0.9)',
+        ),
+        paper_bgcolor='rgba(0,0,0,0.9)',
+        margin=dict(l=0, r=0, t=50, b=0),
+    )
+    
+    return fig
 
 
 def make_network_figure(
@@ -414,7 +597,6 @@ def make_network_figure(
     thr: float, 
     use_louvain: bool = True,
     electrode_pos: np.ndarray = None,
-    show_head: bool = True,
 ) -> tuple[go.Figure, int]:
     C = W.shape[0]
     
@@ -451,68 +633,106 @@ def make_network_figure(
         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)'
 
-    # 脳の輪郭を描画
-    if show_head:
-        outline = get_head_outline()
-        
-        # 頭の円
-        fig.add_trace(go.Scatter(
-            x=outline['head'][0], y=outline['head'][1],
-            mode='lines',
-            line=dict(color='rgba(150,150,150,0.5)', width=2),
-            showlegend=False,
-            hoverinfo='skip',
-        ))
-        
-        # 鼻
-        fig.add_trace(go.Scatter(
-            x=outline['nose'][0], y=outline['nose'][1],
-            mode='lines',
-            line=dict(color='rgba(150,150,150,0.5)', width=2),
-            showlegend=False,
-            hoverinfo='skip',
-        ))
-        
-        # 左耳
-        fig.add_trace(go.Scatter(
-            x=outline['ear_left'][0], y=outline['ear_left'][1],
-            mode='lines',
-            line=dict(color='rgba(150,150,150,0.5)', width=2),
-            showlegend=False,
-            hoverinfo='skip',
-        ))
-        
-        # 右耳
-        fig.add_trace(go.Scatter(
-            x=outline['ear_right'][0], y=outline['ear_right'][1],
-            mode='lines',
-            line=dict(color='rgba(150,150,150,0.5)', width=2),
-            showlegend=False,
-            hoverinfo='skip',
-        ))
-
     # エッジを描画（重みに応じて色と太さを変える）
-    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]],
+    
+    # --- 有向のときだけ：矢印（三角マーカー）を終端側に置く ---
+    is_symmetric = np.allclose(W, W.T, atol=1e-12, rtol=0)
+    if (not is_symmetric):
+        curve_strength = 0.1   # 湾曲の強さ（要調整）
+        node_radius = 0.08      # ノード中心からどれくらい手前に終点/矢印を置くか（要調整）
+        bezier_n = 18           # 曲線の分割数（増やすほど滑らか）
+        t_arrow = 0.90          # 矢印を置く位置（0〜1）
+        for (i, j, w) in edges:
+            norm_w = (w - min_w) / weight_range if weight_range > 0 else 0.5
+            color = get_rainbow_color(norm_w)
+            line_width = 0.5 + 3.5 * norm_w
+
+            p0 = np.array([xs[i], ys[i]], dtype=float)
+            p1 = np.array([xs[j], ys[j]], dtype=float)
+
+            v = p1 - p0
+            dist = np.hypot(v[0], v[1])
+            if dist < 1e-9:
+                continue
+            u = v / dist
+
+            # ノードに重ならないよう端点を縮める
+            p0s = p0 + u * node_radius
+            p1s = p1 - u * node_radius
+
+            # 垂直方向（法線）
+            n = np.array([-u[1], u[0]])
+
+            # ★ 有向エッジは全部曲げる（規則的に）
+            sign = 1.0 #if i < j else -1.0
+
+            # 制御点
+            mid = 0.5 * (p0s + p1s)
+            c = mid + sign * curve_strength * dist * n
+
+            # 曲線点列
+            pts = _quad_bezier_points(p0s, p1s, c, n=bezier_n)
+
+            fig.add_trace(go.Scatter(
+                x=pts[:, 0],
+                y=pts[:, 1],
                 mode="lines",
                 hoverinfo="text",
-                hovertext=f"ch{i} - ch{j}<br>weight: {w:.4f}",
+                hovertext=f"ch{i} → ch{j}<br>weight: {w:.4f}",
                 line=dict(width=line_width, color=color),
                 showlegend=False,
+            ))
+
+            # 矢印（曲線接線方向）
+            pt, tan = _quad_bezier_point_and_tangent(p0s, p1s, c, t_arrow)
+
+            # 接線がゼロに近い場合の保険
+            tx, ty = float(tan[0]), float(tan[1])
+            if tx*tx + ty*ty < 1e-18:
+                tx, ty = float(p1s[0] - p0s[0]), float(p1s[1] - p0s[1])
+
+            theta = np.degrees(np.arctan2(ty, tx))  # 接線の角度（+x基準）
+            ANGLE_OFFSET = -90.0  # triangle-up(上向き) を接線方向に合わせる補正
+            ang = (theta + ANGLE_OFFSET) % 360
+
+            fig.add_trace(go.Scatter(
+                x=[pt[0]],
+                y=[pt[1]],
+                mode="markers",
+                hoverinfo="skip",
+                marker=dict(
+                    symbol="triangle-up",
+                    size=10,
+                    angle=-ang,
+                    angleref="up",
+                    color=color,
+                    line=dict(width=0),
+                ),
+                showlegend=False,
+            ))
+    else:
+        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:
@@ -607,8 +827,12 @@ 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)
+f_low_src = st.sidebar.number_input("Bandpass low (Hz)", min_value=0.0, value=4.0, step=1.0, key="low_src")
+f_high_src = st.sidebar.number_input("Bandpass high (Hz)", min_value=0.1, value=8.0, step=1.0, key="high_src")
+
+st.sidebar.header("if you use CFC+PAC:")
+f_low_tgt = st.sidebar.number_input("Bandpass low (Hz)", min_value=0.0, value=25.0, step=1.0, key="low_tgt")
+f_high_tgt = st.sidebar.number_input("Bandpass high (Hz)", min_value=0.1, value=40.0, step=1.0, key="high_tgt")
 
 st.sidebar.header("Viewer controls")
 win_sec = st.sidebar.number_input("Window length (sec)", min_value=0.1, value=5.0, step=0.1)
@@ -643,17 +867,26 @@ if input_mode.startswith("EEGLAB"):
         else:
             try:
                 with st.spinner("Loading EEGLAB + preprocessing (bandpass + hilbert)..."):
-                    prep = preprocess_all_eeglab(
+                    prep_src = 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_src),
+                            f_high=float(f_high_src),
+                        )
+                    prep_tgt = 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),
+                        f_low=float(f_low_tgt),
+                        f_high=float(f_high_tgt),
                     )
-                st.session_state["prep"] = prep
+                st.session_state["prep"] = prep_src
+                st.session_state["prep_tgt"] = prep_tgt
                 st.session_state["W"] = None
-                st.success(f"Loaded & preprocessed. (T,C)={prep['raw'].shape}  fs={prep['fs']:.2f}Hz")
+                st.success(f"Loaded & preprocessed. (T,C)={prep_src['raw'].shape}  fs={prep_src['fs']:.2f}Hz")
             except Exception as e:
                 st.session_state.pop("prep", None)
                 st.session_state["W"] = None
@@ -714,10 +947,13 @@ else:
                     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))
+                            cfg = PreprocessConfig(fs=float(fs_mat), f_low=float(f_low_src), f_high=float(f_high_src))
                             prep = preprocess_tc(x, cfg)
+                            cfg_tgt = PreprocessConfig(fs=float(fs_mat), f_low=float(f_low_tgt), f_high=float(f_high_tgt))
+                            prep_tgt = preprocess_tc(x, cfg_tgt)
 
                         st.session_state["prep"] = prep
+                        st.session_state["prep_tgt"] = prep_tgt
                         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:
@@ -866,7 +1102,7 @@ with col2:
     st.subheader("Data info")
     signal_desc = {
         "raw": "生信号（前処理なし）",
-        "filtered": f"バンドパスフィルタ後 ({f_low}-{f_high} Hz)",
+        "filtered": f"バンドパスフィルタ後 ({f_low_src}-{f_high_src} Hz)",
         "amplitude": "Hilbert振幅 (envelope)",
         "phase": "Hilbert位相 (-π ~ π)"
     }
@@ -894,20 +1130,29 @@ estimation_method = st.radio(
     "推定手法を選択",
     options=[
         "envelope_corr",
+        "phase_PLV",
         "phase_corr",
+        "pac_tort",
+        "pac_chatterjee"
     ],
     format_func=lambda x: {
-        "envelope_corr": "Envelope correlation (振幅の相関)",
-        "phase_corr": "Phase circular correlation (位相同期, PLV)",
+        "envelope_corr": "Envelope Pearson correlation (振幅の相関)",
+        "phase_PLV": "PLV（位相同期, PLV）",
+        "phase_corr": "Circular correlation",
+        "pac_tort": "Modulation Index（位相と振幅のPAC指標）",
+        "pac_chatterjee": "Chatterjee correlation（位相→振幅の相関）",
     }[x],
     horizontal=True,
-    help="envelope_corr: 振幅包絡線のPearson相関係数 | phase_corr: 位相の circular correlation (Phase Locking Value)",
+    help="envelope_corr: 振幅包絡線のPearson相関係数 | phase_PLV: 位相のPhase Locking Value | phase_corr: 位相の相関係数 | pac_tort: Modulation index | pac_chatterjee: 位相から振幅へのChatterjee相関",
 )
 
 # 推定手法の説明
 method_info = {
     "envelope_corr": "**Envelope correlation**: 振幅包絡線（Hilbert amplitude）間のPearson相関係数を計算します。振幅が同期して変動するチャンネル間の結合を検出します。",
-    "phase_corr": "**Phase circular correlation (PLV)**: 位相間の circular correlation を計算します。Phase Locking Value (PLV) とも呼ばれ、位相同期を検出します。0（非同期）〜1（完全同期）の値を取ります。",
+    "phase_PLV": "**PLV**: 位相間のPhase locking valueを計算します。位相同期を検出します。0（非同期）〜1（完全同期）の値を取ります。",
+    "phase_corr": "**Circular correlation**: 位相間の相関係数を計算します。位相同期を検出します。0（非同期）〜1（完全同期）の値を取ります。",
+    "pac_tort": "Modulation Index（位相と振幅のPAC指標）",
+    "pac_chatterjee": "Chatterjee correlation（位相→振幅の相関）",
 }
 st.info(method_info[estimation_method])
 
@@ -919,13 +1164,27 @@ W = st.session_state.get("W")
 need_estimation = (W is None) or (last_method != estimation_method)
 
 if need_estimation:
+    progress = st.progress(0.0)
     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_PLV":
+            X_in = prep["phase"]
+            W = estimate_network_phase_PLV(X_in, progress)
         elif estimation_method == "phase_corr":
             X_in = prep["phase"]
             W = estimate_network_phase_corr(X_in)
+        elif estimation_method == "pac_tort":
+            X_in_low_phase = prep["phase"]
+            prep_tgt = st.session_state["prep_tgt"]
+            X_in_high_amplitude = prep_tgt["amplitude"]
+            W = estimate_network_pac_tort(X_in_low_phase,X_in_high_amplitude,progress)
+        elif estimation_method == "pac_chatterjee":
+            X_in_low_phase = prep["phase"]
+            prep_tgt = st.session_state["prep_tgt"]
+            X_in_high_amplitude = prep_tgt["amplitude"]
+            W = estimate_network_pac_chatterjee(X_in_low_phase,X_in_high_amplitude,progress)
         else:
             st.error("未知の推定手法です")
             st.stop()
@@ -941,13 +1200,13 @@ else:
 # 閾値スライダーとネットワーク図の表示
 wmax = float(np.max(W)) if np.isfinite(np.max(W)) else 1.0
 
-col_thr1, col_thr2, col_thr3 = st.columns([2, 1, 1])
+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),
+        value=wmax/2,
         step=max(wmax / 200, 0.001),
     )
 with col_thr2:
@@ -957,21 +1216,28 @@ with col_thr2:
         disabled=not LOUVAIN_AVAILABLE,
         help="ノードの色をコミュニティ検出結果で塗り分けます"
     )
-with col_thr3:
-    show_head = st.checkbox(
-        "脳の輪郭を表示",
-        value=True,
-        help="頭部のアウトラインを表示します"
-    )
 
 # 電極位置を取得
 electrode_pos = prep.get("electrode_pos", None)
+# 2D座標を90度左回転（上が正面になる向きに）
+if electrode_pos is not None:
+    electrode_pos = np.asarray(electrode_pos, dtype=np.float32)
+    if electrode_pos.ndim == 2 and electrode_pos.shape[1] >= 2:
+        pos2 = electrode_pos[:, :2]
+        electrode_pos = np.column_stack([-pos2[:, 1], pos2[:, 0]])
+electrode_pos_3d = prep.get("electrode_pos_3d", None)
 
 if electrode_pos is not None:
     st.info(f"✓ 電極位置を使用してネットワークを配置 ({electrode_pos.shape[0]} channels)")
 else:
     st.info("ℹ️ 電極位置が取得できなかったため、円形配置を使用します")
 
+# 3D座標の有無を表示
+if electrode_pos_3d is not None:
+    st.success(f"✓ 3D電極座標を取得しました ({electrode_pos_3d.shape[0]} channels) - 下部に3Dビューアを表示します")
+else:
+    st.info("ℹ️ 3D電極座標が取得できませんでした - 2D表示のみです")
+
 net_col1, net_col2 = st.columns([2, 1])
 with net_col1:
     fig_net, edge_n = make_network_figure(
@@ -979,10 +1245,31 @@ with net_col1:
         float(thr), 
         use_louvain=use_louvain, 
         electrode_pos=electrode_pos,
-        show_head=show_head,
     )
     st.plotly_chart(fig_net)
+    # 3Dネットワーク表示（3D座標がある場合のみ）
+    if electrode_pos_3d is not None:
+        electrode_pos_3d = np.asarray(electrode_pos_3d, dtype=np.float32)
+        if electrode_pos_3d.ndim == 2 and electrode_pos_3d.shape[0] == W.shape[0] and electrode_pos_3d.shape[1] == 3:
+            st.subheader("3D Viewer")
+            fig_3d = make_network_figure_3d(
+                W=W,
+                thr=float(thr),
+                electrode_pos_3d=electrode_pos_3d,
+                use_louvain=use_louvain,
+            )
+            st.plotly_chart(
+                fig_3d,
+                width="stretch",
+                config={"displayModeBar": True, "scrollZoom": True},
+            )
+        else:
+            st.warning(f"3D座標のshapeが不正です: {electrode_pos_3d.shape}（期待: (C,3), C={W.shape[0]}）")
 
 with net_col2:
     st.metric("Edges", edge_n)
-    st.plotly_chart(make_edgecount_curve(W))
+    st.plotly_chart(make_edgecount_curve(W))
+
+
+st.write("# Hypothesis testing")
+st.write("Coming soon ...")