@brainpilot/skills 0.0.6 → 0.0.7

package/skills/08_Computational_Neuroscience/dipy-tool/scripts/roi_stats_reference.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import nibabel as nib
+import numpy as np
+import pandas as pd
+
+
+def roi_stats(metric_path: Path, roi_path: Path, label_path: Path | None, out_csv: Path, min_voxels: int) -> None:
+    metric = nib.load(str(metric_path)).get_fdata()
+    roi = nib.load(str(roi_path)).get_fdata().astype(int)
+
+    labels = None
+    if label_path is not None:
+        labels = [line.strip() for line in label_path.read_text(encoding="utf-8", errors="ignore").splitlines() if line.strip()]
+
+    rows = []
+    for label_id in np.unique(roi):
+        if label_id == 0:
+            continue
+        values = metric[roi == label_id]
+        values = values[np.isfinite(values)]
+        if values.size < min_voxels:
+            continue
+
+        rows.append(
+            {
+                "label": int(label_id),
+                "label_name": labels[int(label_id) - 1] if labels is not None and int(label_id) - 1 < len(labels) else "",
+                "n_vox": int(values.size),
+                "mean": float(values.mean()),
+                "median": float(np.median(values)),
+                "std": float(values.std(ddof=1)) if values.size > 1 else 0.0,
+                "p05": float(np.percentile(values, 5)),
+                "p95": float(np.percentile(values, 95)),
+            }
+        )
+
+    pd.DataFrame(rows).sort_values("label").to_csv(out_csv, index=False)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Reference DIPY snippet for atlas-based ROI statistics on tensor metrics.")
+    parser.add_argument("--metric", type=Path, required=True, help="Input metric NIfTI such as FA.nii.gz.")
+    parser.add_argument("--roi", type=Path, required=True, help="Atlas or ROI label NIfTI in the same space as the metric.")
+    parser.add_argument("--output", type=Path, required=True, help="Output CSV path.")
+    parser.add_argument("--labels", type=Path, default=None, help="Optional atlas label text file.")
+    parser.add_argument("--min-voxels", type=int, default=10, help="Minimum voxel count for a region to be reported.")
+    args = parser.parse_args()
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    roi_stats(args.metric, args.roi, args.labels, args.output, args.min_voxels)
+    print(f"Saved ROI statistics to: {args.output}")
+
+
+if __name__ == "__main__":
+    main()

package/skills/08_Computational_Neuroscience/fm_app/SKILL.md

@@ -0,0 +1,195 @@
+---
+name: fm_app
+description: "Use this model doc whenever the user wants to run FM-APP for phenotype prediction using fMRI ROI features and optional sMRI features. This document provides model-level usage and delegates preprocessing to fmri-skill and smri-skill."
+license: MIT License (NeuroClaw custom skill - freely modifiable within the project)
+layer: base
+skill_type: model
+dependencies:
+  - fmri-skill
+  - smri-skill
+  - run_models
+---
+# FM-APP Model Doc
+
+## Overview
+FM-APP is a multi-stage framework for phenotype prediction via fMRI to sMRI knowledge transfer.
+
+- Paper: He Z, Li W, Liu Y, et al. FM-APP, IEEE TMI, 2024, 44(10): 4010-4022
+- Official code: https://github.com/ZhibinHe/FM-APP
+- Primary input: fMRI ROI connectivity features
+- Additional input: sMRI ROI structural features (required in Stage 2)
+- Primary output: multi-phenotype prediction and zero-shot phenotype reconstruction
+
+In NeuroClaw, this is model-level guidance. Upstream preparation should be delegated to:
+- `fmri-skill` for fMRI preprocessing and ROI extraction
+- `smri-skill` for structural ROI feature extraction
+- `hcpya-skill` if HCP Young Adult download/orchestration is needed
+
+**Research use only.**
+
+---
+
+## Quick Start (From git clone)
+
+### 1) Clone repository
+```bash
+git clone https://github.com/ZhibinHe/FM-APP.git
+cd FM-APP
+```
+
+### 2) Create environment and install dependencies
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -r requirements.txt
+```
+
+If using GPU, install CUDA-compatible PyTorch and graph-related packages first.
+
+### 3) Prepare required data
+Before training, ensure these are ready:
+- fMRI ROI/connectivity features from `fmri-skill`
+- sMRI ROI structural features from `smri-skill` (for Stage 2)
+- phenotype CSV files and text feature tensors in `data/`
+
+### 4) Run staged pipeline
+```bash
+# Stage 0: data preparation (example scripts)
+python 00-create-folder_hcp_4fmri.py
+python 01-fetch_data_hcp_4fmri.py
+python 02-process_data_hcp_4fmri.py
+
+# Stage 1: fMRI model training
+python 101-main_stage1_fmri_HCP.py
+
+# Stage 2: fMRI-T1w alignment
+python 102-main_stage2_fmri_t1w_HCP.py
+
+# Stage 3: decoder and zero-shot inference
+python 103-main_stage3_t1w_HCP.py
+```
+
+---
+
+## Pipeline Definition
+
+| Stage | Script pattern | Purpose | Core output |
+|---|---|---|---|
+| Stage 0 | `00-*`, `01-*`, `02-*` | Data folder setup, ROI connectivity extraction, HDF5 packaging | `raw/*.h5`, processed inputs |
+| Stage 1 | `101-main_stage1_fmri_HCP.py` | fMRI feature extraction and phenotype regression | `model/stage1_*.pth`, `model/stage1_dataset_*.pt` |
+| Stage 2 | `102-main_stage2_fmri_t1w_HCP.py` | fMRI-T1w feature alignment (Sinkhorn-RPM) | `model/stage2_*.pth` |
+| Stage 3 | `103-main_stage3_t1w_HCP.py` | masked decoder training and zero-shot phenotype inference | stage-3 checkpoints and inference outputs |
+
+Run order must be: Stage 0 -> Stage 1 -> Stage 2 -> Stage 3.
+
+---
+
+## Stage Inputs and Outputs
+
+### Stage 0 (Data Preparation)
+Required inputs:
+- subject lists and dataset files (HCP/HCPA)
+- phenotype CSV files under `data/`
+- pre-encoded text feature tensors (`*.pt`)
+
+Main outputs:
+- per-subject connectivity features (corr/pcorr)
+- HDF5 packaged samples for model training
+
+### Stage 1 (fMRI Training)
+Required inputs:
+- Stage 0 packaged features
+- phenotype text features
+
+Main outputs:
+- best checkpoint: `model/stage1_fmri_best_*.pth`
+- stage1 feature package: `model/stage1_dataset_*.pt`
+
+### Stage 2 (fMRI-sMRI Alignment)
+Required inputs:
+- frozen Stage 1 model/features
+- sMRI ROI features (e.g., 333x9 per subject)
+
+Main outputs:
+- best checkpoint: `model/stage2_fmri_to_t1w_best_*.pth`
+
+### Stage 3 (Decoder and Zero-shot)
+Required inputs:
+- Stage 1 fused features and regression weights
+- masks / phenotype supervision setup
+
+Main outputs:
+- decoder checkpoints
+- reconstructed masked phenotype representations
+
+---
+
+## Typical Configuration Notes
+
+- Atlas: Gordon333 (333 ROIs)
+- Stage 1 typical settings: Adam, lr=0.0005, batch size=8, long-epoch training
+- Stage 2 includes Sinkhorn matching; runtime is usually higher than Stage 1
+- Stage 3 supports zero-shot phenotype inference using masked reconstruction
+
+---
+
+## Recommended Directory Layout
+
+```text
+FM-APP/
+  data/
+    HCP_train_phenotype.csv
+    HCP_test_phenotype.csv
+    HCP_all_phenotype.csv
+    HCPA_train_phenotype.csv
+    HCPA_test_phenotype.csv
+    phenotype_text_feature_tr.pt
+    phenotype_text_feature_te.pt
+    HCPA_phenotype_text_feature_tr.pt
+    HCPA_phenotype_text_feature_te.pt
+  raw/
+    *.h5
+  model/
+    stage1_*.pth
+    stage2_*.pth
+    stage1_dataset_*.pt
+  net/
+  imports/
+  loss_function/
+  util/
+  requirements.txt
+```
+
+---
+
+## NeuroClaw Delegation Rules
+
+- fMRI preprocessing and ROI extraction: `fmri-skill`
+- sMRI feature extraction: `smri-skill`
+- HCP data orchestration: `hcpya-skill` (or `hcpa-skill` / `hcpd-skill` / `hcpep-skill` for other HCP variants)
+- dependency management: `dependency-planner` + `conda-env-manager`
+- command execution: `claw-shell`
+
+No execution before explicit plan confirmation.
+
+---
+
+## Limitations and Notes
+
+- CUDA-capable GPU is strongly recommended for training.
+- Stage 2 depends on valid Stage 1 artifacts and sMRI features.
+- Stage 3 depends on `stage1_dataset_*.pt` and proper masking setup.
+- Keep train/val/test split strict to avoid leakage.
+- Verify phenotype column counts and subject ID alignment before Stage 1.
+
+---
+
+## Reference
+
+- He Z, Li W, Liu Y, et al. FM-APP: Foundation model for any phenotype prediction via fMRI to sMRI knowledge transfer. IEEE Transactions on Medical Imaging, 2024, 44(10): 4010-4022.
+- Official repository: https://github.com/ZhibinHe/FM-APP
+- NeuroSTORM HCP download scripts: https://github.com/CUHK-AIM-Group/NeuroSTORM/tree/main/scripts/dataset_download
+
+Created At: 2026-03-28 20:03 HKT
+Last Updated At: 2026-03-28 20:03 HKT
+Author: chengwang96

package/skills/08_Computational_Neuroscience/neurostorm/SKILL.md

@@ -0,0 +1,151 @@
+---
+name: neurostorm
+description: "Use this skill whenever the user wants to preprocess fMRI data, pretrain or fine-tune NeuroSTORM, run inference, or benchmark on fMRI tasks (age/gender prediction, phenotype prediction, disease diagnosis, fMRI retrieval, task fMRI state classification). Triggers include: 'fMRI', 'NeuroSTORM', 'fMRI preprocessing', 'fMRI foundation model', 'brain imaging', 'HCP', 'ABCD', 'UKB', 'ADHD200', 'COBRE', 'UCLA', 'NSD', 'BOLD5000', 'disease diagnosis from fMRI', 'pretrain fMRI model', 'fine-tune fMRI', or any request involving .nii/.nii.gz fMRI volume files."
+license: MIT
+layer: base
+skill_type: model
+dependencies:
+  - fmri-skill
+  - smri-skill
+  - run_models
+---
+# NeuroSTORM Skill
+## Overview
+`neurostorm-skill` covers all workflows for the **NeuroSTORM fMRI foundation model**: data downloading, preprocessing, pre-training, fine-tuning, and inference.
+**Supported tasks:**
+| ID | Task |
+|----|------|
+| 1 | Age & Gender Prediction |
+| 2 | Phenotype Prediction |
+| 3 | Disease Diagnosis |
+| 4 | fMRI Retrieval |
+| 5 | Task fMRI State Classification |
+**Supported datasets:** HCP1200, ABCD, UKB, Cobre, ADHD200, HCPA, HCPD, UCLA, HCPEP, HCPTASK, GOD, NSD, BOLD5000
+---
+
+## Installation
+```bash
+# 1. Create conda environment
+conda create -n neurostorm python=3.11
+conda activate neurostorm
+# 2. Install PyTorch (CUDA 12.8 example)
+pip install torch==2.7.1 torchvision==0.22.1 torchaudio==2.7.1 \
+    --index-url https://download.pytorch.org/whl/cu128
+# 3. Install remaining dependencies
+pip install tensorboard tensorboardX tqdm ipdb nvitop monai \
+    pytorch-lightning==1.9.4 neptune nibabel nilearn numpy
+# 4. (Optional) Install Mamba SSM for NeuroSTORM backbone
+git clone https://github.com/Dao-AILab/causal-conv1d.git && cd causal-conv1d
+TORCH_CUDA_ARCH_LIST="12.0" pip install --no-build-isolation -e .
+git clone https://github.com/state-spaces/mamba.git && cd mamba
+TORCH_CUDA_ARCH_LIST="12.0" pip install --no-build-isolation -e .
+```
+Alternatively, use the provided Docker image:
+```bash
+docker build -t neurostorm:latest .
+docker run --gpus all -it --rm \
+    -v $(pwd):/workspace \
+    -v /path/to/data:/workspace/data \
+    --shm-size=8g neurostorm:latest
+```
+---
+## Workflows
+
+### 1. Data Preprocessing
+**Input:** Raw fMRI volumes in MNI152 space (`.nii` / `.nii.gz`)  
+**Output:** Per-frame `.pt` tensor files ready for model input
+```bash
+# Brain extraction (requires FSL)
+bash datasets/brain_extraction.sh /path/to/raw /path/to/extracted
+# Convert to 4D volume tensors (background removal, resampling, Z-normalization)
+python datasets/preprocessing_volume.py \
+    --dataset_name hcp \
+    --load_root ./data/hcp \
+    --save_root ./processed_data/hcp \
+    --num_processes 8
+# (Optional) Convert to 2D ROI time series or functional correlation matrix
+python datasets/generate_roi_data_from_nii.py \
+    --atlas_names aal3 cc200 \
+    --dataset_names hcp \
+    --output_dir ./processed_data \
+    --num_processes 8
+```
+---
+
+### 2. Pre-training
+**Input:** Preprocessed `.pt` volume files  
+**Output:** Pre-trained model checkpoint (`.ckpt`)
+```bash
+# MAE-based pre-training on HCP-YA
+python main.py \
+    --pretraining \
+    --use_mae \
+    --model neurostorm \
+    --dataset_name HCP1200 \
+    --image_path ./processed_data/hcp \
+    --mask_ratio 0.5 \
+    --batch_size 8 \
+    --learning_rate 1e-4 \
+    --max_epochs 100 \
+    --loggername tensorboard \
+    --project_name pt_neurostorm_mae
+```
+See `scripts/hcp_pretrain/` for ready-made pre-training scripts.
+---
+
+### 3. Fine-tuning
+**Input:** Preprocessed `.pt` files + pre-trained checkpoint  
+**Output:** Fine-tuned checkpoint (`.ckpt`) + TensorBoard logs
+```bash
+# Example: gender classification on HCP-YA
+python main.py \
+    --model neurostorm \
+    --dataset_name HCP1200 \
+    --image_path ./processed_data/hcp \
+    --load_model_path ./pretrained_models/neurostorm_mae.ckpt \
+    --downstream_task_id 1 \
+    --downstream_task_type classification \
+    --task_name sex \
+    --batch_size 12 \
+    --learning_rate 5e-5 \
+    --max_epochs 30 \
+    --loggername tensorboard \
+    --project_name ft_neurostorm_gender
+```
+See `scripts/hcp_downstream/` and other `*_downstream/` folders for task-specific scripts.
+---
+
+### 4. Inference / Demo
+**Input:** HCP-YA dataset + fine-tuned checkpoint  
+**Output:** Prediction results printed to stdout
+```bash
+# Quick demo (age, gender, phenotype)
+sh scripts/run_demo.sh
+# Or directly:
+python demo.py \
+    --ckpt_path /path/to/gender.ckpt \
+    --task gender \
+    --image_path /path/to/HCP1200 \
+    --devices 1 \
+    --precision 32
+```
+---
+
+## Input / Output Summary
+| Stage | Input | Output |
+|-------|-------|--------|
+| Preprocessing | `.nii` / `.nii.gz` volumes in MNI152 space | Per-frame `.pt` tensors |
+| Pre-training | Preprocessed `.pt` files | Model checkpoint `.ckpt` |
+| Fine-tuning | `.pt` files + pre-trained `.ckpt` | Fine-tuned `.ckpt` + logs |
+| Inference | `.pt` files + fine-tuned `.ckpt` | Predictions (stdout / CSV) |
+---
+
+## Reference
+- Paper: *Towards a General-Purpose Foundation Model for fMRI Analysis* (Nature Biomedical Engineering, 2026)
+- Project: https://cuhk-aim-group.github.io/NeuroSTORM/
+- GitHub: https://github.com/CUHK-AIM-Group/NeuroSTORM
+---
+
+Created At: 2026-04-02 00:23 HKT
+Last Updated At: 2026-04-02 00:23 HKT
+Author: chengwang96

package/skills/13_Visualization/brain-visualization/SKILL.md

@@ -0,0 +1,191 @@
+---
+name: brain-visualization
+description: "Use this skill whenever the user wants to visualize neuroimaging analysis results, including 3D brain connectivity networks, atlas-based regional activation summaries, or FreeSurfer cortical surface meshes with anatomical colors. Triggers include: 'brain visualization', 'visualize connectome', '3D brain network', 'zALFF visualization', 'brain activation map', 'FreeSurfer PLY export', 'surface mesh rendering', or any request to turn neuroimaging outputs into interpretable figures or 3D models."
+license: MIT License (NeuroClaw custom skill - freely modifiable within the project)
+layer: base
+skill_type: tool
+dependencies:
+  - nibabel-skill
+  - nilearn-tool
+---
+# Brain Visualization
+
+## Overview
+
+`brain-visualization` is the NeuroClaw skill for turning processed neuroimaging outputs into publication-friendly figures and 3D assets.
+
+It focuses on three common visualization tasks drawn from the methods demonstrated in the referenced rs-fMRI tutorial:
+- 3D brain connectivity visualization from atlas coordinates and ROI-to-ROI connectivity matrices
+- atlas-based brain region activation ranking and coordinate export from zALFF-like volumetric maps
+- FreeSurfer cortical surface export to colored PLY meshes for downstream 3D rendering
+
+This skill is intended for analysis outputs that already exist. It does not replace preprocessing or statistical modeling skills such as `fmri-skill`, `nilearn-tool`, `freesurfer-tool`, or `fsl-tool`.
+
+## Agent Reference Rule
+
+When implementing or adapting visualization workflows, the agent should first consult the curated reference snippets in `skills/brain-visualization/scripts/` instead of copying directly from the tutorial scripts with hard-coded paths.
+
+Reference snippets available:
+- `scripts/connectome_reference.py` -> atlas coordinate extraction + strongest-edge connectome plotting
+- `scripts/zalff_summary_reference.py` -> MNI resampling + zALFF regional summary + coordinate export
+- `scripts/freesurfer_ply_reference.py` -> FreeSurfer surface + annotation to colored PLY export
+
+These snippets are distilled from `rs-fMRI-Pipeline-Tutorial/` and are intended as the preferred starting point for new agent-generated code in this skill.
+
+## Quick Reference
+
+| Task | What needs to be visualized | Typical input | Expected output |
+|------|-----------------------------|---------------|-----------------|
+| 3D connectome figure | strongest ROI-to-ROI connections on a template brain | atlas NIfTI + connectivity matrix (`.npy` / `.csv`) + template T1 | static network figure (`.png`) |
+| Regional activation summary | top active atlas regions with MNI coordinates | BOLD-derived zALFF or similar volumetric map + atlas + labels | ranked CSV table + coordinate table |
+| FreeSurfer surface export | anatomical cortical mesh with region colors | `lh.pial` / `rh.pial` + `.annot` files | colored mesh (`.ply`) |
+| Publication-ready snapshots | compact figures for reports or manuscripts | any of the above | PNG figures and tabular summaries |
+
+## Core Visualization Patterns
+
+### 1. 3D Brain Network Visualization
+
+Recommended when the user has a connectivity matrix and wants an interpretable whole-brain figure.
+
+Typical approach:
+- Load an atlas image such as AAL3 and derive ROI coordinates with Nilearn.
+- Load a symmetric functional connectivity matrix.
+- Zero the diagonal and keep only the strongest edges for readability.
+- Plot the network on a standard-space template using `nilearn.plotting.plot_connectome`.
+
+Typical Python stack:
+- `numpy`
+- `nibabel`
+- `matplotlib`
+- `nilearn`
+
+Example command pattern:
+
+```bash
+python skills/brain-visualization/scripts/connectome_reference.py \
+	--atlas path/to/AAL3v1.nii \
+	--template path/to/mni_icbm152_t1_tal_nlin_sym_09a.nii \
+	--matrix path/to/fc_matrix.npy \
+	--output outputs/3D_brain_network.png
+```
+
+Recommended outputs:
+- `3D_brain_network_AAL166_strongest.png`
+
+### 2. Atlas-Based Regional Activation Summary
+
+Recommended when the user wants a ranked list of active regions rather than only a voxelwise map.
+
+Typical approach:
+- Resample BOLD-derived data into MNI space.
+- Compute ALFF or zALFF-like summary statistics.
+- Use `NiftiLabelsMasker` to extract atlas-level regional values.
+- Rank regions and export the top regions with MNI coordinates.
+
+Typical Python stack:
+- `numpy`
+- `pandas`
+- `nibabel`
+- `nilearn`
+
+Example command pattern:
+
+```bash
+python skills/brain-visualization/scripts/zalff_summary_reference.py \
+	--bold path/to/rest_bold.nii.gz \
+	--atlas path/to/AAL3v1.nii \
+	--labels path/to/AAL3v1.nii.txt \
+	--mask path/to/mni_mask.nii.gz \
+	--output-dir outputs/active_brain_results
+```
+
+Recommended outputs:
+- `TOP10_active_regions.csv`
+- `top10_coordinates.csv`
+- `all_brain_regions_activity.csv`
+
+### 3. FreeSurfer Colored Surface Export
+
+Recommended when the user needs a mesh that can be opened in Blender, MeshLab, or downstream 3D pipelines.
+
+Typical approach:
+- Read FreeSurfer geometry from `lh.pial` / `rh.pial`.
+- Read anatomical labels from `lh.aparc.annot` / `rh.aparc.annot`.
+- Map vertex labels to RGB colors from the annotation color table.
+- Export ASCII PLY with per-vertex color fields.
+
+Typical Python stack:
+- `nibabel`
+- `numpy`
+
+Example command pattern:
+
+```bash
+python skills/brain-visualization/scripts/freesurfer_ply_reference.py \
+	--surf path/to/lh.pial \
+	--annot path/to/lh.aparc.annot \
+	--output outputs/lh_colored.ply
+```
+
+Recommended outputs:
+- left hemisphere colored mesh (`.ply`)
+- right hemisphere colored mesh (`.ply`)
+
+## Installation
+
+Install the common visualization dependencies in the existing `neuroclaw` environment:
+
+```bash
+conda activate neuroclaw
+conda install -n neuroclaw -c conda-forge numpy pandas nibabel nilearn matplotlib networkx -y
+```
+
+Optional packages depending on workflow:
+
+```bash
+conda install -n neuroclaw -c conda-forge scipy seaborn plotly -y
+```
+
+If FreeSurfer surface export is needed, ensure FreeSurfer outputs already exist and `nibabel` can access the surface and annotation files.
+
+## When to Call This Skill
+
+- The user has already produced a connectivity matrix and wants a 3D connectome figure.
+- The user needs atlas-level summaries of resting-state activation metrics such as zALFF.
+- The user wants to export FreeSurfer cortical surfaces into colored 3D meshes.
+- The user is preparing figures or supplementary materials for papers, presentations, or reports.
+
+## Complementary / Related Skills
+
+- `fmri-skill` -> preprocessing and fMRI workflow planning
+- `nilearn-tool` -> ROI extraction, connectivity computation, seed maps, GLM support
+- `freesurfer-tool` -> anatomical reconstruction and parcellation generation
+- `paper-writing` -> convert generated figures/tables into manuscript assets
+
+## Important Notes & Limitations
+
+- This skill is for visualization and result packaging, not raw image preprocessing.
+- Connectivity figures should usually threshold or sparsify edges; plotting full dense matrices produces unreadable figures.
+- Atlas labels, atlas volume, and connectivity matrix dimensions must match.
+- MNI-space summary workflows assume the volume has already been aligned or resampled appropriately.
+- FreeSurfer colored PLY export depends on valid `.annot` files; missing or mismatched annotations will degrade vertex coloring.
+
+## Reference
+
+This skill is adapted from the visualization ideas and example workflows in:
+- rs-fMRI-Pipeline-Tutorial: https://github.com/Karcen/rs-fMRI-Pipeline-Tutorial
+
+Key referenced methods in the local tutorial copy:
+- 3D brain network plotting with AAL atlas and Nilearn
+- MNI152 zALFF regional activation ranking
+- FreeSurfer colored cortical surface export to PLY
+
+Curated reference snippets in this skill:
+- `skills/brain-visualization/scripts/connectome_reference.py`
+- `skills/brain-visualization/scripts/zalff_summary_reference.py`
+- `skills/brain-visualization/scripts/freesurfer_ply_reference.py`
+
+---
+Created At: 2026-04-14 00:15 HKT  
+Last Updated At: 2026-04-14 00:40 HKT  
+Author: chengwang96