Add files using upload-large-folder tool

LICENSE

@@ -0,0 +1,14 @@
+VidLLVIP License Notice
+
+VidLLVIP is an unofficial processed video dataset derived from the raw visible-infrared videos of LLVIP.
+
+The use of VidLLVIP is subject to the original LLVIP Terms of Use and License:
+https://github.com/bupt-ai-cz/LLVIP
+
+Users must:
+1. Follow the original LLVIP Terms of Use and License.
+2. Use the data only for non-commercial research or educational purposes.
+3. Cite the original LLVIP paper.
+4. Cite the VidLLVIP dataset if they use the processed paired video clips, preprocessing pipeline, or registration matrices.
+
+VidLLVIP does not grant any rights beyond those permitted by the original LLVIP Terms of Use and License.

README.md

@@ -1,5 +1,284 @@
----
-license: other
-license_name: license
-license_link: LICENSE
----
+<p align="center">
+  <img src="figs/vidllvip_title.svg" alt="VidLLVIP" width="560">
+</p>
+
+<p align="center">
+  <strong>Temporally and Spatially Aligned Infrared-Visible Video Dataset</strong>
+</p>
+
+<p align="center">
+  English | <a href="README_zh-CN.md">简体中文</a>
+</p>
+
+<p align="center">
+  <a href="https://github.com/jianfeng0369/VidLLVIP"><img alt="VidLLVIP GitHub" src="https://img.shields.io/badge/VidLLVIP-GitHub-181717?style=for-the-badge&logo=github&logoColor=ffffff"></a>
+  <a href="https://huggingface.co/datasets/jianfeng0369/VidLLVIP"><img alt="Hugging Face Dataset" src="https://img.shields.io/badge/VidLLVIP-Hugging%20Face-FFD21E?style=for-the-badge&logo=huggingface&logoColor=000000"></a>
+  <a href="https://pan.quark.cn/s/e3abe425aa5f?pwd=E5gv"><img alt="Quark Drive Download" src="https://img.shields.io/badge/Quark%20Drive-Download-14A7F5?style=for-the-badge&logo=icloud&logoColor=ffffff"></a>
+  <a href="https://arxiv.org/abs/2108.10831"><img alt="LLVIP Paper" src="https://img.shields.io/badge/LLVIP-Paper-B31B1B?style=for-the-badge&logo=arxiv&logoColor=ffffff"></a>
+  <a href="https://github.com/bupt-ai-cz/LLVIP"><img alt="LLVIP GitHub" src="https://img.shields.io/badge/LLVIP-GitHub-181717?style=for-the-badge&logo=github&logoColor=ffffff"></a>
+  <a href="https://doi.org/10.1016/j.inffus.2026.104212"><img alt="CMVF Paper" src="https://img.shields.io/badge/CMVF-Paper-FF6C00?style=for-the-badge&logo=elsevier&logoColor=ffffff"></a>
+  <a href="https://github.com/jianfeng0369/CMVF"><img alt="CMVF GitHub" src="https://img.shields.io/badge/CMVF-GitHub-181717?style=for-the-badge&logo=github&logoColor=ffffff"></a>
+</p>
+
+VidLLVIP is an unofficial processed paired infrared-visible video dataset derived from the raw [LLVIP](https://github.com/bupt-ai-cz/LLVIP) videos. The dataset provides temporally aligned, spatially registered, quality-checked, 5-second video pairs for video fusion, cross-modal registration, and multimodal video understanding.
+
+![VidLLVIP overview](figs/01_overview.jpg)
+
+> VidLLVIP is derived from LLVIP. Please follow the original LLVIP license and citation requirements when using or redistributing this dataset.
+
+## 📰 News
+
+- 🚀 **2026-05-06**: We released the [VidLLVIP dataset](https://github.com/jianfeng0369/VidLLVIP).
+- 🎉 **2026-02-05**: Our multimodal video fusion paper [CMVF](https://doi.org/10.1016/j.inffus.2026.104212) was accepted by *Information Fusion*. The code is available in the [CMVF GitHub repository](https://github.com/jianfeng0369/CMVF).
+
+## Download
+
+The large video files are distributed separately:
+
+- Option 1: Download from [Hugging Face](https://huggingface.co/datasets/jianfeng0369/VidLLVIP)
+- Option 2: Download from [Quark Drive](https://pan.quark.cn/s/e3abe425aa5f?pwd=E5gv)
+
+After downloading, if you want to reproduce the full pipeline, extract `datamaker.zip` and `matrix.zip` and place them under the corresponding `datamaker/` directory; extract `raw.zip` and place it under the corresponding `raw/` directory. If you only want to use the final dataset directly, extract `dataset.zip` and place it under the corresponding `dataset/` directory.
+
+## Highlights
+
+- Built from `14` source infrared-visible video pairs, numbered `01` to `14`.
+- Provides `894` final 5-second paired clips with one IR video and one VI video per sample.
+- Uses same-name files under `dataset/ir` and `dataset/vi` as the pairing rule.
+- Final clip format: `1280 x 1024`, `25 FPS`, `125` frames, no audio.
+- Includes scripts for temporal alignment, spatial registration, checkerboard quality inspection, and 5-second clip generation.
+
+## Dataset Snapshot
+
+| Item | Value |
+| --- | --- |
+| Source | LLVIP raw infrared-visible videos |
+| Processed source pairs | 14 pairs, IDs `01`-`14` |
+| Final paired clips | 894 pairs |
+| Modalities | Infrared (`ir`) and visible (`vi`) |
+| Clip length | 5 seconds |
+| Resolution | `1280 x 1024` |
+| Frame rate | 25 FPS |
+| Frames per clip | 125 |
+| Pairing rule | Same file name under `dataset/ir` and `dataset/vi` |
+
+![Representative infrared-visible sample pairs](figs/02_sample_pairs.jpg)
+
+## Repository Layout
+
+```text
+VidLLVIP/
+  README.md
+  README_zh-CN.md
+  raw/
+    videos/{ir,vi}/        # Original LLVIP videos before alignment
+  datamaker/
+    01_time_align.py       # Temporal alignment
+    02_space_align.py      # Spatial registration
+    03_checkerboard.py     # Checkerboard QA videos
+    04_split_5s_videos.py  # 5-second clip generation
+    requirements.txt
+    matrix/                # 3x3 perspective matrices for IDs 01-14
+    01_align/              # Time-aligned full videos and timestamp sheets
+    02_warp/               # Spatially registered full videos
+    03_ckboard/            # Checkerboard QA videos
+  dataset/
+    ir/                    # Final infrared clips
+    vi/                    # Final visible clips
+  figs/                    # README figures
+```
+
+![Dataset construction pipeline](figs/03_pipeline.jpg)
+
+## Data Format
+
+Final clips are stored as paired files:
+
+```text
+dataset/
+  ir/01_0000_0005.mp4
+  vi/01_0000_0005.mp4
+```
+
+The file name format is:
+
+```text
+{source_id}_{start_second}_{end_second}.mp4
+```
+
+For example, `01_0000_0005.mp4` means source video `01`, from `0s` to `5s`. The same file name in `dataset/ir` and `dataset/vi` forms one paired sample.
+
+![Dataset structure and pairing rule](figs/04_dataset_structure.jpg)
+
+## Quick Start
+
+If you only need the final paired clips, read `dataset/ir` and `dataset/vi` directly:
+
+```python
+from pathlib import Path
+
+root = Path("dataset")
+
+for ir_path in sorted((root / "ir").glob("*.mp4")):
+    vi_path = root / "vi" / ir_path.name
+    assert vi_path.exists(), f"Missing visible pair: {vi_path}"
+    # Load ir_path and vi_path with your video reader.
+```
+
+To reproduce the preprocessing pipeline, install the Python dependencies:
+
+```bash
+cd datamaker
+conda create -n vidllvip python=3.10 -y
+conda activate vidllvip
+pip install -r requirements.txt
+```
+
+The system also needs `ffmpeg` and `ffprobe` on `PATH`.
+
+## Reproduce the Dataset
+
+### 1. Temporal Alignment
+
+```bash
+python 01_time_align.py
+```
+
+Inputs:
+
+- `raw/videos/ir/{id}.mp4`
+- `raw/videos/vi/{id}.mp4`
+
+Outputs:
+
+- `datamaker/01_align/{id}/ir.mp4`
+- `datamaker/01_align/{id}/vi.mp4`
+- `datamaker/01_align/{id}/timestamp.xlsx`
+
+The script reads frame timestamps, chooses the shorter stream as the base, and matches the other modality with monotone nearest-frame matching. The default maximum timestamp gap is `0.08s`.
+
+### 2. Spatial Registration
+
+```bash
+python 02_space_align.py
+```
+
+Inputs:
+
+- `datamaker/01_align/{id}/ir.mp4`
+- `datamaker/01_align/{id}/vi.mp4`
+- `datamaker/matrix/{id}.csv`
+
+Outputs:
+
+- `datamaker/02_warp/{id}/ir.mp4`
+- `datamaker/02_warp/{id}/vi.mp4`
+
+The script warps IR frames into the VI coordinate system with a 3x3 perspective matrix, then crops both modalities to `1280 x 1024`.
+
+![Temporal and spatial alignment quality](figs/05_alignment_quality.jpg)
+
+### 3. Checkerboard QA
+
+```bash
+python 03_checkerboard.py
+```
+
+Inputs:
+
+- `datamaker/02_warp/{id}/ir.mp4`
+- `datamaker/02_warp/{id}/vi.mp4`
+
+Outputs:
+
+- `datamaker/03_ckboard/{id}.mp4`
+
+The checkerboard videos alternate IR and VI blocks, making edge continuity and object alignment easier to inspect by eye.
+
+### 4. Split Into 5-Second Clips
+
+```bash
+python 04_split_5s_videos.py
+```
+
+Inputs:
+
+- `datamaker/02_warp/{id}/ir.mp4`
+- `datamaker/02_warp/{id}/vi.mp4`
+
+Outputs:
+
+- `dataset/ir/{id}_{start}_{end}.mp4`
+- `dataset/vi/{id}_{start}_{end}.mp4`
+
+The default window and stride are both `5s`. Tails shorter than `5s` are skipped.
+
+## Suggested Uses
+
+- Video fusion: use same-name clips from `dataset/ir` and `dataset/vi`.
+- Cross-modal registration: use `datamaker/01_align` as temporally aligned but spatially unregistered input, and `datamaker/02_warp` as the registered reference.
+- Joint fusion and registration: train registration on `datamaker/01_align`, then train or evaluate fusion on `datamaker/02_warp` or `dataset/`.
+
+## Figures
+
+The `figs/` directory is ordered by first appearance in this README:
+
+| File | Purpose |
+| --- | --- |
+| [`figs/01_overview.jpg`](figs/01_overview.jpg) | Dataset overview and key statistics. |
+| [`figs/02_sample_pairs.jpg`](figs/02_sample_pairs.jpg) | Representative IR/VI/fusion frame examples. |
+| [`figs/03_pipeline.jpg`](figs/03_pipeline.jpg) | End-to-end construction pipeline. |
+| [`figs/04_dataset_structure.jpg`](figs/04_dataset_structure.jpg) | Released file structure and pairing rule. |
+| [`figs/05_alignment_quality.jpg`](figs/05_alignment_quality.jpg) | Temporal and spatial alignment quality checks. |
+
+## Citation
+
+VidLLVIP is an unofficial processed version derived from the raw LLVIP infrared and visible videos. If you use VidLLVIP or the processing scripts, registration matrices, or paired video clips in this repository, please also follow the original LLVIP license and citation requirements.
+
+### 1. Original Dataset Citation
+
+VidLLVIP is derived from LLVIP. When using this dataset, please first cite the original LLVIP dataset:
+
+```bibtex
+@inproceedings{jia2021llvip,
+  title     = {LLVIP: A visible-infrared paired dataset for low-light vision},
+  author    = {Jia, Xinyu and Zhu, Chuang and Li, Minzhen and Tang, Wenqi and Zhou, Wenli},
+  booktitle = {Proceedings of the IEEE/CVF International Conference on Computer Vision},
+  pages     = {3496--3504},
+  year      = {2021}
+}
+```
+
+### 2. VidLLVIP Citation
+
+If you use the processed VidLLVIP dataset, registration matrices, or preprocessing pipeline provided by this project, please also cite VidLLVIP:
+
+```bibtex
+@dataset{ding2026vidllvip,
+  author  = {Ding, Jianfeng},
+  title   = {VidLLVIP: A visible-infrared paired video dataset for low-light vision},
+  year    = {2026},
+  version = {v1.0.0},
+  url     = {https://github.com/jianfeng0369/VidLLVIP}
+}
+```
+
+### 3. Related Paper Citation
+
+CMVF is an infrared and visible video fusion method based on spatio-temporal consistency and designed for unregistered inputs. If your research uses the CMVF method or code, or is related to infrared and visible video fusion, please also consider citing the following paper:
+
+```bibtex
+@article{cmvf2026ding,
+  title   = {CMVF: Cross-modal unregistered video fusion via spatio-temporal consistency},
+  journal = {Information Fusion},
+  volume  = {132},
+  pages   = {104212},
+  year    = {2026},
+  issn    = {1566-2535},
+  author  = {Jianfeng Ding and Hao Zhang and Zhongyuan Wang and Jinsheng Xiao and Xin Tian and Zhen Han and Jiayi Ma}
+}
+```
+
+## Contact
+
+If you have any questions, please contact: <jianfeng0369@gmail.com>.

README_zh-CN.md

@@ -0,0 +1,284 @@
+<p align="center">
+  <img src="figs/vidllvip_title.svg" alt="VidLLVIP" width="560">
+</p>
+
+<p align="center">
+  <strong>时间与空间对齐的红外与可见光视频数据集</strong>
+</p>
+
+<p align="center">
+  <a href="README.md">English</a> | 简体中文
+</p>
+
+<p align="center">
+  <a href="https://github.com/jianfeng0369/VidLLVIP"><img alt="VidLLVIP GitHub 仓库" src="https://img.shields.io/badge/VidLLVIP-GitHub-181717?style=for-the-badge&logo=github&logoColor=ffffff"></a>
+  <a href="https://huggingface.co/datasets/jianfeng0369/VidLLVIP"><img alt="Hugging Face Dataset" src="https://img.shields.io/badge/VidLLVIP-Hugging%20Face-FFD21E?style=for-the-badge&logo=huggingface&logoColor=000000"></a>
+  <a href="https://pan.quark.cn/s/e3abe425aa5f?pwd=E5gv"><img alt="夸克网盘下载" src="https://img.shields.io/badge/Quark%20Drive-Download-14A7F5?style=for-the-badge&logo=icloud&logoColor=ffffff"></a>
+  <a href="https://arxiv.org/abs/2108.10831"><img alt="LLVIP 论文" src="https://img.shields.io/badge/LLVIP-Paper-B31B1B?style=for-the-badge&logo=arxiv&logoColor=ffffff"></a>
+  <a href="https://github.com/bupt-ai-cz/LLVIP"><img alt="LLVIP GitHub 仓库" src="https://img.shields.io/badge/LLVIP-GitHub-181717?style=for-the-badge&logo=github&logoColor=ffffff"></a>
+  <a href="https://doi.org/10.1016/j.inffus.2026.104212"><img alt="CMVF 论文" src="https://img.shields.io/badge/CMVF-Paper-FF6C00?style=for-the-badge&logo=elsevier&logoColor=ffffff"></a>
+  <a href="https://github.com/jianfeng0369/CMVF"><img alt="CMVF GitHub 仓库" src="https://img.shields.io/badge/CMVF-GitHub-181717?style=for-the-badge&logo=github&logoColor=ffffff"></a>
+</p>
+
+VidLLVIP 是基于 [LLVIP](https://github.com/bupt-ai-cz/LLVIP) 原始红外/可见光视频整理得到的非官方处理版成对视频数据集。本项目完成了时间对齐、空间配准、质量检查和 5 秒切片，适用于视频融合、跨模态配准和多模态视频理解等任务。
+
+![VidLLVIP 数据集总览](figs/01_overview.jpg)
+
+> VidLLVIP 来源于 LLVIP。使用或再分发本数据集时，请遵守 LLVIP 原始数据许可和引用要求。
+
+## 📰 新闻
+
+- 🚀 **2026-05-06**：我们发布了 [VidLLVIP 数据集](https://github.com/jianfeng0369/VidLLVIP)。
+- 🎉 **2026-02-05**：我们的多模态视频融合论文 [CMVF](https://doi.org/10.1016/j.inffus.2026.104212) 被 *Information Fusion* 接收，代码已发布在 [CMVF GitHub 仓库](https://github.com/jianfeng0369/CMVF)。
+
+## 数据下载
+
+大体量视频文件单独发布：
+
+- 方式一：通过 [Hugging Face](https://huggingface.co/datasets/jianfeng0369/VidLLVIP) 下载
+- 方式二：通过 [夸克网盘](https://pan.quark.cn/s/e3abe425aa5f?pwd=E5gv) 下载
+
+下载后，如果需要复现完整处理流程，请将 `datamaker.zip` 和 `matrix.zip` 文件解压后放入对应的 `datamaker/` 目录；将 `raw.zip` 文件解压后放入对应的 `raw/` 目录。如果想直接使用最终数据集，请将 `dataset.zip` 文件解压后放入对应的 `dataset/` 目录。
+
+## 主要特点
+
+- 基于 `14` 组红外/可见光源视频对构建，编号为 `01` 到 `14`。
+- 最终提供 `894` 组 5 秒配对片段，每个样本包含一个 IR 视频和一个 VI 视频。
+- `dataset/ir` 与 `dataset/vi` 下同名文件构成一组配对样本。
+- 最终片段规格为 `1280 x 1024`、`25 FPS`、`125` 帧、无音频。
+- 提供时间对齐、空间配准、棋盘格质量检查和 5 秒切片的完整处理脚本。
+
+## 数据集概览
+
+| 项目 | 数值 |
+| --- | --- |
+| 数据来源 | LLVIP 原始红外/可见光视频 |
+| 已处理源视频对 | 14 组，编号 `01`-`14` |
+| 最终配对片段 | 894 组 |
+| 模态 | 红外（`ir`）和可见光（`vi`） |
+| 片段长度 | 5 秒 |
+| 分辨率 | `1280 x 1024` |
+| 帧率 | 25 FPS |
+| 每段帧数 | 125 |
+| 配对规则 | `dataset/ir` 与 `dataset/vi` 下文件名相同 |
+
+![红外/可见光样例对](figs/02_sample_pairs.jpg)
+
+## 仓库结构
+
+```text
+VidLLVIP/
+  README.md
+  README_zh-CN.md
+  raw/
+    videos/{ir,vi}/        # 对齐前的 LLVIP 原始视频
+  datamaker/
+    01_time_align.py       # 时间对齐
+    02_space_align.py      # 空间配准
+    03_checkerboard.py     # 棋盘格质量检查视频
+    04_split_5s_videos.py  # 5 秒片段切分
+    requirements.txt
+    matrix/                # 编号 01-14 的 3x3 透视变换矩阵
+    01_align/              # 时间对齐后的完整视频和时间戳表
+    02_warp/               # 空间配准后的完整视频
+    03_ckboard/            # 棋盘格质量检查视频
+  dataset/
+    ir/                    # 最终红外片段
+    vi/                    # 最终可见光片段
+  figs/                    # README 图片
+```
+
+![数据集构建流程](figs/03_pipeline.jpg)
+
+## 数据格式
+
+最终片段以成对文件形式存放：
+
+```text
+dataset/
+  ir/01_0000_0005.mp4
+  vi/01_0000_0005.mp4
+```
+
+文件名格式为：
+
+```text
+{source_id}_{start_second}_{end_second}.mp4
+```
+
+例如，`01_0000_0005.mp4` 表示源视频 `01` 中从 `0s` 到 `5s` 的片段。`dataset/ir` 和 `dataset/vi` 下文件名相同的两个视频构成一组配对样本。
+
+![数据集结构与配对规则](figs/04_dataset_structure.jpg)
+
+## 快速开始
+
+如果只需要使用最终配对片段，可直接读取 `dataset/ir` 和 `dataset/vi`：
+
+```python
+from pathlib import Path
+
+root = Path("dataset")
+
+for ir_path in sorted((root / "ir").glob("*.mp4")):
+    vi_path = root / "vi" / ir_path.name
+    assert vi_path.exists(), f"Missing visible pair: {vi_path}"
+    # 使用你的视频读取工具加载 ir_path 和 vi_path。
+```
+
+如需复现预处理流程，先安装 Python 依赖：
+
+```bash
+cd datamaker
+conda create -n vidllvip python=3.10 -y
+conda activate vidllvip
+pip install -r requirements.txt
+```
+
+系统还需要在 `PATH` 中提供 `ffmpeg` 和 `ffprobe`。
+
+## 数据集复现流程
+
+### 1. 时间对齐
+
+```bash
+python 01_time_align.py
+```
+
+输入：
+
+- `raw/videos/ir/{id}.mp4`
+- `raw/videos/vi/{id}.mp4`
+
+输出：
+
+- `datamaker/01_align/{id}/ir.mp4`
+- `datamaker/01_align/{id}/vi.mp4`
+- `datamaker/01_align/{id}/timestamp.xlsx`
+
+脚本读取逐帧时间戳，选择较短的视频流作为基准，并用单调最近帧匹配方式对齐另一模态。默认最大时间差为 `0.08s`。
+
+### 2. 空间配准
+
+```bash
+python 02_space_align.py
+```
+
+输入：
+
+- `datamaker/01_align/{id}/ir.mp4`
+- `datamaker/01_align/{id}/vi.mp4`
+- `datamaker/matrix/{id}.csv`
+
+输出：
+
+- `datamaker/02_warp/{id}/ir.mp4`
+- `datamaker/02_warp/{id}/vi.mp4`
+
+脚本使用 3x3 透视变换矩阵将 IR 帧映射到 VI 坐标系，并将两个模态裁剪为 `1280 x 1024`。
+
+![时间与空间对齐质量](figs/05_alignment_quality.jpg)
+
+### 3. 棋盘格质量检查
+
+```bash
+python 03_checkerboard.py
+```
+
+输入：
+
+- `datamaker/02_warp/{id}/ir.mp4`
+- `datamaker/02_warp/{id}/vi.mp4`
+
+输出：
+
+- `datamaker/03_ckboard/{id}.mp4`
+
+棋盘格视频交替显示 IR 和 VI 图像块，便于人工检查边缘连续性和目标对齐效果。
+
+### 4. 切分为 5 秒片段
+
+```bash
+python 04_split_5s_videos.py
+```
+
+输入：
+
+- `datamaker/02_warp/{id}/ir.mp4`
+- `datamaker/02_warp/{id}/vi.mp4`
+
+输出：
+
+- `dataset/ir/{id}_{start}_{end}.mp4`
+- `dataset/vi/{id}_{start}_{end}.mp4`
+
+默认窗口长度和步长均为 `5s`，不足 `5s` 的尾部片段会被跳过。
+
+## 推荐用途
+
+- 视频融合：使用 `dataset/ir` 和 `dataset/vi` 下同名片段。
+- 跨模态配准：使用 `datamaker/01_align` 作为时间对齐但空间未配准的输入，使用 `datamaker/02_warp` 作为配准参考。
+- 融合与配准联合任务：先在 `datamaker/01_align` 上训练配准，再在 `datamaker/02_warp` 或 `dataset/` 上训练或评估融合方法。
+
+## 图片说明
+
+`figs/` 目录中的文件已按本 README 中的首次出现顺序编号：
+
+| 文件 | 说明 |
+| --- | --- |
+| [`figs/01_overview.jpg`](figs/01_overview.jpg) | 数据集总览和关键统计信息。 |
+| [`figs/02_sample_pairs.jpg`](figs/02_sample_pairs.jpg) | 代表性 IR/VI/融合帧示例。 |
+| [`figs/03_pipeline.jpg`](figs/03_pipeline.jpg) | 从原始视频到最终片段的完整构建流程。 |
+| [`figs/04_dataset_structure.jpg`](figs/04_dataset_structure.jpg) | 发布文件结构和配对规则。 |
+| [`figs/05_alignment_quality.jpg`](figs/05_alignment_quality.jpg) | 时间与空间对齐质量检查。 |
+
+## 引用
+
+VidLLVIP 是基于 LLVIP 原始红外和可见光视频整理得到的非官方处理版本。如果您使用 VidLLVIP 或本仓库中的处理脚本、配准矩阵、配对视频片段，请同时遵守 LLVIP 原始数据许可和引用要求。
+
+### 1. 原始数据集引用
+
+VidLLVIP 来源于 LLVIP。使用本数据集时，请首先引用原始 LLVIP 数据集：
+
+```bibtex
+@inproceedings{jia2021llvip,
+  title     = {LLVIP: A visible-infrared paired dataset for low-light vision},
+  author    = {Jia, Xinyu and Zhu, Chuang and Li, Minzhen and Tang, Wenqi and Zhou, Wenli},
+  booktitle = {Proceedings of the IEEE/CVF International Conference on Computer Vision},
+  pages     = {3496--3504},
+  year      = {2021}
+}
+```
+
+### 2. VidLLVIP 引用
+
+如果您使用本项目整理得到的 VidLLVIP 处理版数据、配准矩阵或预处理流程，请同时引用 VidLLVIP：
+
+```bibtex
+@dataset{ding2026vidllvip,
+  author  = {Ding, Jianfeng},
+  title   = {VidLLVIP: A visible-infrared paired video dataset for low-light vision},
+  year    = {2026},
+  version = {v1.0.0},
+  url     = {https://github.com/jianfeng0369/VidLLVIP}
+}
+```
+
+### 3. 相关论文引用
+
+CMVF 是一个基于时空一致性和面向未配准的红外与可见光视频融合方法。如果您的研究使用了 CMVF 方法或代码，或者和红外与可见光视频融合任务相关，请同时考虑引用以下论文：
+
+```bibtex
+@article{cmvf2026ding,
+  title   = {CMVF: Cross-modal unregistered video fusion via spatio-temporal consistency},
+  journal = {Information Fusion},
+  volume  = {132},
+  pages   = {104212},
+  year    = {2026},
+  issn    = {1566-2535},
+  author  = {Jianfeng Ding and Hao Zhang and Zhongyuan Wang and Jinsheng Xiao and Xin Tian and Zhen Han and Jiayi Ma}
+}
+```
+
+## 联系方式
+
+如有任何问题，请通过以下邮箱联系：<jianfeng0369@gmail.com>。

datamaker/01_time_align.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import subprocess
+from pathlib import Path
+from typing import Optional, Sequence
+
+import cv2
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+
+
+# =========================
+# Parameters
+# =========================
+DATAMAKER_DIR = Path(__file__).resolve().parent
+PROJECT_ROOT = DATAMAKER_DIR.parent
+
+RAW_IR_DIR = PROJECT_ROOT / "raw" / "videos" / "ir"
+RAW_VI_DIR = PROJECT_ROOT / "raw" / "videos" / "vi"
+OUTPUT_DIR = DATAMAKER_DIR / "01_align"
+
+VIDEO_IDS = [f"{idx:02d}" for idx in range(1, 15)]
+MAX_GAP_SECONDS = 0.08
+SAVE_EXCEL = True
+FOURCC = "mp4v"
+OVERWRITE = True
+# =========================
+
+
+def get_frame_timestamps(video_path: Path) -> list[float]:
+    cmd = [
+        "ffprobe",
+        "-v",
+        "error",
+        "-select_streams",
+        "v:0",
+        "-show_entries",
+        "frame=pkt_pts_time,best_effort_timestamp_time",
+        "-of",
+        "csv=p=0",
+        str(video_path),
+    ]
+    try:
+        result = subprocess.run(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as exc:
+        raise RuntimeError(f"ffprobe failed for {video_path}: {exc.stderr}") from exc
+
+    timestamps: list[float] = []
+    for line in result.stdout.splitlines():
+        for value in line.split(","):
+            value = value.strip()
+            if not value or value == "N/A":
+                continue
+            try:
+                timestamps.append(float(value))
+                break
+            except ValueError:
+                continue
+    if not timestamps:
+        raise RuntimeError(f"No frame timestamps found in {video_path}")
+    return timestamps
+
+
+def build_monotone_map(
+    base_ts: Sequence[float],
+    src_ts: Sequence[float],
+    max_gap: float,
+) -> list[int]:
+    if not base_ts or not src_ts:
+        raise ValueError("Timestamp lists must not be empty.")
+
+    mapping: list[int] = []
+    src_idx = 0
+    for timestamp in base_ts:
+        while (
+            src_idx + 1 < len(src_ts)
+            and abs(src_ts[src_idx + 1] - timestamp) < abs(src_ts[src_idx] - timestamp)
+        ):
+            src_idx += 1
+        mapping.append(src_idx if abs(src_ts[src_idx] - timestamp) <= max_gap else -1)
+    return mapping
+
+
+def make_black_frame(cap: cv2.VideoCapture) -> np.ndarray:
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    return np.zeros((height, width, 3), dtype=np.uint8)
+
+
+def make_writers(
+    cap_base: cv2.VideoCapture,
+    cap_src: cv2.VideoCapture,
+    out_base: Path,
+    out_src: Path,
+) -> tuple[cv2.VideoWriter, cv2.VideoWriter]:
+    fps = cap_base.get(cv2.CAP_PROP_FPS)
+    base_size = (
+        int(cap_base.get(cv2.CAP_PROP_FRAME_WIDTH)),
+        int(cap_base.get(cv2.CAP_PROP_FRAME_HEIGHT)),
+    )
+    src_size = (
+        int(cap_src.get(cv2.CAP_PROP_FRAME_WIDTH)),
+        int(cap_src.get(cv2.CAP_PROP_FRAME_HEIGHT)),
+    )
+    fourcc = cv2.VideoWriter_fourcc(*FOURCC)
+    out_base.parent.mkdir(parents=True, exist_ok=True)
+    out_src.parent.mkdir(parents=True, exist_ok=True)
+
+    writer_base = cv2.VideoWriter(str(out_base), fourcc, fps, base_size)
+    writer_src = cv2.VideoWriter(str(out_src), fourcc, fps, src_size)
+    if not writer_base.isOpened() or not writer_src.isOpened():
+        raise IOError(f"Failed to open output writers: {out_base}, {out_src}")
+    return writer_base, writer_src
+
+
+def align_videos(
+    ir_path: Path,
+    vi_path: Path,
+    out_ir: Path,
+    out_vi: Path,
+    excel_path: Optional[Path],
+) -> None:
+    if not ir_path.exists() or not vi_path.exists():
+        raise FileNotFoundError(f"Missing input pair: {ir_path}, {vi_path}")
+    if not OVERWRITE and (out_ir.exists() or out_vi.exists()):
+        raise FileExistsError(f"Output exists and OVERWRITE=False: {out_ir}, {out_vi}")
+
+    ir_ts = get_frame_timestamps(ir_path)
+    vi_ts = get_frame_timestamps(vi_path)
+
+    if len(ir_ts) <= len(vi_ts):
+        base_ts, src_ts = ir_ts, vi_ts
+        base_path, src_path = ir_path, vi_path
+        out_base, out_src = out_ir, out_vi
+        base_label, src_label = "IR", "VI"
+    else:
+        base_ts, src_ts = vi_ts, ir_ts
+        base_path, src_path = vi_path, ir_path
+        out_base, out_src = out_vi, out_ir
+        base_label, src_label = "VI", "IR"
+
+    src_indices = build_monotone_map(base_ts, src_ts, MAX_GAP_SECONDS)
+
+    cap_base = cv2.VideoCapture(str(base_path))
+    cap_src = cv2.VideoCapture(str(src_path))
+    if not cap_base.isOpened() or not cap_src.isOpened():
+        raise IOError(f"Failed to open videos: {base_path}, {src_path}")
+
+    writer_base, writer_src = make_writers(cap_base, cap_src, out_base, out_src)
+
+    ok_src, frame_src = cap_src.read()
+    src_idx_prev = 0 if ok_src else -1
+    black_src = make_black_frame(cap_src)
+
+    for base_idx in tqdm(
+        range(len(base_ts)),
+        desc=f"Align {ir_path.stem}",
+        unit="frame",
+        position=1,
+        leave=False,
+    ):
+        ok_base, frame_base = cap_base.read()
+        if not ok_base:
+            break
+
+        mapped_idx = src_indices[base_idx]
+        if mapped_idx < 0:
+            frame_to_write = black_src
+        else:
+            while src_idx_prev < mapped_idx:
+                ok_src, frame_src = cap_src.read()
+                src_idx_prev += 1
+            frame_to_write = frame_src if ok_src and frame_src is not None else black_src
+
+        writer_base.write(frame_base)
+        writer_src.write(frame_to_write)
+
+    cap_base.release()
+    cap_src.release()
+    writer_base.release()
+    writer_src.release()
+
+    if SAVE_EXCEL and excel_path is not None:
+        excel_path.parent.mkdir(parents=True, exist_ok=True)
+        matched_src_ts = [src_ts[idx] if idx >= 0 else None for idx in src_indices]
+        diffs = [
+            base_time - src_time if src_time is not None else None
+            for base_time, src_time in zip(base_ts, matched_src_ts)
+        ]
+        pd.DataFrame(
+            {
+                "Base_Idx": range(len(base_ts)),
+                f"{base_label}_ts(s)": base_ts,
+                f"{src_label}_nearest_ts(s)": matched_src_ts,
+                "DeltaT(s)": diffs,
+            }
+        ).to_excel(excel_path, index=False)
+
+
+def main() -> None:
+    with tqdm(
+        total=len(VIDEO_IDS),
+        desc="Total align",
+        unit="video",
+        position=0,
+    ) as progress:
+        for video_id in VIDEO_IDS:
+            progress.set_postfix(video=video_id)
+            out_dir = OUTPUT_DIR / video_id
+            align_videos(
+                ir_path=RAW_IR_DIR / f"{video_id}.mp4",
+                vi_path=RAW_VI_DIR / f"{video_id}.mp4",
+                out_ir=out_dir / "ir.mp4",
+                out_vi=out_dir / "vi.mp4",
+                excel_path=out_dir / "timestamp.xlsx" if SAVE_EXCEL else None,
+            )
+            tqdm.write(f"Aligned {video_id} -> {out_dir}")
+            progress.update(1)
+
+
+if __name__ == "__main__":
+    main()

datamaker/02_space_align.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from pathlib import Path
+
+import cv2
+import numpy as np
+from tqdm import tqdm
+
+
+# =========================
+# Parameters
+# =========================
+DATAMAKER_DIR = Path(__file__).resolve().parent
+
+INPUT_DIR = DATAMAKER_DIR / "01_align"
+MATRIX_DIR = DATAMAKER_DIR / "matrix"
+OUTPUT_DIR = DATAMAKER_DIR / "02_warp"
+
+VIDEO_IDS = [f"{idx:02d}" for idx in range(1, 15)]
+TARGET_WIDTH = 1280
+TARGET_HEIGHT = 1024
+OFFSET_WIDTH = -40
+OFFSET_HEIGHT = 0
+MATRIX_TRANSPOSE = True
+INTERPOLATION = cv2.INTER_CUBIC
+FOURCC = "mp4v"
+OVERWRITE = True
+# =========================
+
+
+def load_matrix(matrix_path: Path) -> np.ndarray:
+    if not matrix_path.exists():
+        raise FileNotFoundError(f"Matrix not found: {matrix_path}")
+
+    matrix = np.genfromtxt(matrix_path, delimiter=",")
+    if matrix.shape != (3, 3):
+        raise ValueError(f"Matrix must be 3x3: {matrix_path}")
+    return matrix.T if MATRIX_TRANSPOSE else matrix
+
+
+def get_crop_region(frame_shape: tuple[int, ...]) -> tuple[int, int]:
+    height, width = frame_shape[:2]
+    height_start = int((height - TARGET_HEIGHT) / 2) + OFFSET_HEIGHT
+    width_start = int((width - TARGET_WIDTH) / 2) + OFFSET_WIDTH
+
+    if (
+        height_start < 0
+        or width_start < 0
+        or height_start + TARGET_HEIGHT > height
+        or width_start + TARGET_WIDTH > width
+    ):
+        raise ValueError(
+            "Crop region is out of bounds. "
+            f"frame=({width}x{height}), crop=({TARGET_WIDTH}x{TARGET_HEIGHT}), "
+            f"start=({width_start},{height_start})"
+        )
+    return height_start, width_start
+
+
+def warp_pair(
+    ir_path: Path,
+    vi_path: Path,
+    matrix_path: Path,
+    out_ir_path: Path,
+    out_vi_path: Path,
+) -> None:
+    if not ir_path.exists() or not vi_path.exists():
+        raise FileNotFoundError(f"Missing input pair: {ir_path}, {vi_path}")
+    if not OVERWRITE and (out_ir_path.exists() or out_vi_path.exists()):
+        raise FileExistsError(
+            f"Output exists and OVERWRITE=False: {out_ir_path}, {out_vi_path}"
+        )
+
+    matrix = load_matrix(matrix_path)
+    cap_ir = cv2.VideoCapture(str(ir_path))
+    cap_vi = cv2.VideoCapture(str(vi_path))
+    if not cap_ir.isOpened() or not cap_vi.isOpened():
+        raise IOError(f"Failed to open videos: {ir_path}, {vi_path}")
+
+    ok_first_vi, first_vi = cap_vi.read()
+    if not ok_first_vi:
+        raise IOError(f"Failed to read first VI frame: {vi_path}")
+    vi_height, vi_width = first_vi.shape[:2]
+    height_start, width_start = get_crop_region(first_vi.shape)
+
+    out_ir_path.parent.mkdir(parents=True, exist_ok=True)
+    out_vi_path.parent.mkdir(parents=True, exist_ok=True)
+
+    fps = cap_vi.get(cv2.CAP_PROP_FPS)
+    fourcc = cv2.VideoWriter_fourcc(*FOURCC)
+    out_ir = cv2.VideoWriter(
+        str(out_ir_path), fourcc, fps, (TARGET_WIDTH, TARGET_HEIGHT), False
+    )
+    out_vi = cv2.VideoWriter(
+        str(out_vi_path), fourcc, fps, (TARGET_WIDTH, TARGET_HEIGHT), True
+    )
+    if not out_ir.isOpened() or not out_vi.isOpened():
+        raise IOError(f"Failed to open output writers: {out_ir_path}, {out_vi_path}")
+
+    total_frames = min(
+        int(cap_ir.get(cv2.CAP_PROP_FRAME_COUNT)),
+        int(cap_vi.get(cv2.CAP_PROP_FRAME_COUNT)),
+    )
+    cap_vi.set(cv2.CAP_PROP_POS_FRAMES, 0)
+
+    for _ in tqdm(
+        range(total_frames),
+        desc=f"Warp {ir_path.parent.name}",
+        unit="frame",
+        position=1,
+        leave=False,
+    ):
+        ok_ir, frame_ir = cap_ir.read()
+        ok_vi, frame_vi = cap_vi.read()
+        if not ok_ir or not ok_vi:
+            break
+
+        if len(frame_ir.shape) == 3:
+            frame_ir = cv2.cvtColor(frame_ir, cv2.COLOR_BGR2GRAY)
+
+        ir_warp = cv2.warpPerspective(
+            frame_ir,
+            matrix,
+            (vi_width, vi_height),
+            flags=INTERPOLATION,
+        )
+        ir_output = ir_warp[
+            height_start : height_start + TARGET_HEIGHT,
+            width_start : width_start + TARGET_WIDTH,
+        ]
+        vi_output = frame_vi[
+            height_start : height_start + TARGET_HEIGHT,
+            width_start : width_start + TARGET_WIDTH,
+        ]
+
+        out_ir.write(ir_output)
+        out_vi.write(vi_output)
+
+    cap_ir.release()
+    cap_vi.release()
+    out_ir.release()
+    out_vi.release()
+
+
+def main() -> None:
+    with tqdm(
+        total=len(VIDEO_IDS),
+        desc="Total warp",
+        unit="video",
+        position=0,
+    ) as progress:
+        for video_id in VIDEO_IDS:
+            progress.set_postfix(video=video_id)
+            out_dir = OUTPUT_DIR / video_id
+            warp_pair(
+                ir_path=INPUT_DIR / video_id / "ir.mp4",
+                vi_path=INPUT_DIR / video_id / "vi.mp4",
+                matrix_path=MATRIX_DIR / f"{video_id}.csv",
+                out_ir_path=out_dir / "ir.mp4",
+                out_vi_path=out_dir / "vi.mp4",
+            )
+            tqdm.write(f"Warped {video_id} -> {out_dir}")
+            progress.update(1)
+
+
+if __name__ == "__main__":
+    main()

datamaker/03_checkerboard.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from pathlib import Path
+
+import cv2
+import numpy as np
+from tqdm import tqdm
+
+
+# =========================
+# Parameters
+# =========================
+DATAMAKER_DIR = Path(__file__).resolve().parent
+
+INPUT_DIR = DATAMAKER_DIR / "02_warp"
+OUTPUT_DIR = DATAMAKER_DIR / "03_ckboard"
+
+VIDEO_IDS = [f"{idx:02d}" for idx in range(1, 15)]
+BLOCK_SIZE = 50
+FOURCC = "mp4v"
+OVERWRITE = True
+# =========================
+
+
+def create_checkerboard_mask(height: int, width: int, block_size: int) -> np.ndarray:
+    x = np.arange(width)
+    y = np.arange(height)
+    x_grid, y_grid = np.meshgrid(x, y)
+    mask = np.mod(x_grid // block_size + y_grid // block_size, 2)
+    return mask.astype(bool)
+
+
+def fuse_checkerboard(
+    ir_frame: np.ndarray,
+    vi_frame: np.ndarray,
+    block_size: int,
+) -> np.ndarray:
+    if len(ir_frame.shape) == 2:
+        ir_frame = cv2.cvtColor(ir_frame, cv2.COLOR_GRAY2BGR)
+    if ir_frame.shape[:2] != vi_frame.shape[:2]:
+        raise ValueError(
+            f"Frame sizes differ: IR={ir_frame.shape[:2]}, VI={vi_frame.shape[:2]}"
+        )
+
+    height, width = ir_frame.shape[:2]
+    mask = create_checkerboard_mask(height, width, block_size)
+    mask_3d = np.stack([mask] * 3, axis=2)
+    return np.where(mask_3d, ir_frame, vi_frame)
+
+
+def make_checkerboard(ir_path: Path, vi_path: Path, out_path: Path) -> None:
+    if not ir_path.exists() or not vi_path.exists():
+        raise FileNotFoundError(f"Missing input pair: {ir_path}, {vi_path}")
+    if not OVERWRITE and out_path.exists():
+        raise FileExistsError(f"Output exists and OVERWRITE=False: {out_path}")
+
+    cap_ir = cv2.VideoCapture(str(ir_path))
+    cap_vi = cv2.VideoCapture(str(vi_path))
+    if not cap_ir.isOpened() or not cap_vi.isOpened():
+        raise IOError(f"Failed to open videos: {ir_path}, {vi_path}")
+
+    width = int(cap_ir.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap_ir.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps = cap_ir.get(cv2.CAP_PROP_FPS)
+    total_frames = min(
+        int(cap_ir.get(cv2.CAP_PROP_FRAME_COUNT)),
+        int(cap_vi.get(cv2.CAP_PROP_FRAME_COUNT)),
+    )
+
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    writer = cv2.VideoWriter(
+        str(out_path),
+        cv2.VideoWriter_fourcc(*FOURCC),
+        fps,
+        (width, height),
+    )
+    if not writer.isOpened():
+        raise IOError(f"Failed to open output writer: {out_path}")
+
+    for _ in tqdm(
+        range(total_frames),
+        desc=f"Checkerboard {ir_path.parent.name}",
+        unit="frame",
+        position=1,
+        leave=False,
+    ):
+        ok_ir, frame_ir = cap_ir.read()
+        ok_vi, frame_vi = cap_vi.read()
+        if not ok_ir or not ok_vi:
+            break
+        writer.write(fuse_checkerboard(frame_ir, frame_vi, BLOCK_SIZE))
+
+    cap_ir.release()
+    cap_vi.release()
+    writer.release()
+
+
+def main() -> None:
+    with tqdm(
+        total=len(VIDEO_IDS),
+        desc="Total checkerboard",
+        unit="video",
+        position=0,
+    ) as progress:
+        for video_id in VIDEO_IDS:
+            progress.set_postfix(video=video_id)
+            out_path = OUTPUT_DIR / f"{video_id}.mp4"
+            make_checkerboard(
+                ir_path=INPUT_DIR / video_id / "ir.mp4",
+                vi_path=INPUT_DIR / video_id / "vi.mp4",
+                out_path=out_path,
+            )
+            tqdm.write(f"Checkerboard {video_id} -> {out_path}")
+            progress.update(1)
+
+
+if __name__ == "__main__":
+    main()

datamaker/04_split_5s_videos.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import json
+import math
+import subprocess
+from pathlib import Path
+
+from tqdm import tqdm
+
+
+# =========================
+# Parameters
+# =========================
+DATAMAKER_DIR = Path(__file__).resolve().parent
+PROJECT_ROOT = DATAMAKER_DIR.parent
+
+INPUT_DIR = DATAMAKER_DIR / "02_warp"
+OUTPUT_DIR = PROJECT_ROOT / "dataset"
+
+VIDEO_IDS = [f"{idx:02d}" for idx in range(1, 15)]
+WINDOW_LEN_SECONDS = 5
+STRIDE_SECONDS = 5
+KEEP_AUDIO = False
+TOLERANCE_SECONDS = 0.02
+OVERWRITE = True
+# =========================
+
+
+def probe(video_path: Path) -> tuple[float, int]:
+    cmd = [
+        "ffprobe",
+        "-v",
+        "error",
+        "-count_frames",
+        "-select_streams",
+        "v:0",
+        "-show_entries",
+        "stream=nb_read_frames,nb_frames,duration:format=duration",
+        "-print_format",
+        "json",
+        str(video_path),
+    ]
+    raw = subprocess.check_output(cmd, stderr=subprocess.DEVNULL, text=True)
+    info = json.loads(raw)
+    stream = info["streams"][0]
+    duration = float(stream.get("duration") or info.get("format", {}).get("duration"))
+    frames_raw = stream.get("nb_read_frames") or stream.get("nb_frames")
+    if frames_raw is None:
+        raise RuntimeError(f"Could not read frame count: {video_path}")
+    return duration, int(frames_raw)
+
+
+def segment_count(duration: float) -> int:
+    if duration < WINDOW_LEN_SECONDS:
+        return 0
+    return math.floor((duration - WINDOW_LEN_SECONDS) / STRIDE_SECONDS) + 1
+
+
+def pad_seconds(seconds: int) -> str:
+    return f"{seconds:04d}"
+
+
+def clip_video(src: Path, dst: Path, start: int, duration: int) -> None:
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    cmd = ["ffmpeg", "-hide_banner", "-loglevel", "error", "-nostats"]
+    cmd.append("-y" if OVERWRITE else "-n")
+    cmd += [
+        "-ss",
+        str(start),
+        "-i",
+        str(src),
+        "-t",
+        str(duration),
+        "-c:v",
+        "copy",
+    ]
+    cmd += ["-c:a", "copy"] if KEEP_AUDIO else ["-an"]
+    cmd.append(str(dst))
+    subprocess.run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+
+
+def collect_valid_pairs() -> list[tuple[str, Path, Path, float]]:
+    valid_pairs: list[tuple[str, Path, Path, float]] = []
+    for video_id in tqdm(VIDEO_IDS, desc="Probe videos", unit="video"):
+        ir_path = INPUT_DIR / video_id / "ir.mp4"
+        vi_path = INPUT_DIR / video_id / "vi.mp4"
+        if not ir_path.exists() or not vi_path.exists():
+            raise FileNotFoundError(f"Missing input pair: {ir_path}, {vi_path}")
+
+        ir_duration, ir_frames = probe(ir_path)
+        vi_duration, vi_frames = probe(vi_path)
+        if abs(ir_duration - vi_duration) >= TOLERANCE_SECONDS:
+            raise ValueError(
+                f"{video_id}: duration mismatch "
+                f"ir={ir_duration:.3f}s vi={vi_duration:.3f}s"
+            )
+        if ir_frames != vi_frames:
+            raise ValueError(
+                f"{video_id}: frame mismatch ir={ir_frames} vi={vi_frames}"
+            )
+
+        valid_pairs.append((video_id, ir_path, vi_path, ir_duration))
+    return valid_pairs
+
+
+def main() -> None:
+    valid_pairs = collect_valid_pairs()
+    total_clips = sum(2 * segment_count(duration) for _, _, _, duration in valid_pairs)
+    if total_clips == 0:
+        tqdm.write("No valid 5-second clips found.")
+        return
+
+    (OUTPUT_DIR / "ir").mkdir(parents=True, exist_ok=True)
+    (OUTPUT_DIR / "vi").mkdir(parents=True, exist_ok=True)
+
+    with tqdm(
+        total=len(valid_pairs),
+        desc="Total split",
+        unit="video",
+        position=0,
+    ) as video_progress, tqdm(
+        total=total_clips,
+        desc="Split clips",
+        unit="clip",
+        position=1,
+        leave=False,
+    ) as clip_progress:
+        for video_id, ir_path, vi_path, duration in valid_pairs:
+            video_progress.set_postfix(video=video_id)
+            start = 0
+            while start + WINDOW_LEN_SECONDS <= duration:
+                end = start + WINDOW_LEN_SECONDS
+                name = f"{video_id}_{pad_seconds(start)}_{pad_seconds(end)}.mp4"
+                clip_video(ir_path, OUTPUT_DIR / "ir" / name, start, WINDOW_LEN_SECONDS)
+                clip_progress.update(1)
+                clip_video(vi_path, OUTPUT_DIR / "vi" / name, start, WINDOW_LEN_SECONDS)
+                clip_progress.update(1)
+                start += STRIDE_SECONDS
+
+            if start < duration:
+                skipped = duration - start
+                tqdm.write(
+                    f"{video_id}: skipped tail {skipped:.2f}s "
+                    f"(< {WINDOW_LEN_SECONDS}s)"
+                )
+            video_progress.update(1)
+
+    tqdm.write(f"Dataset clips written to {OUTPUT_DIR}")
+
+
+if __name__ == "__main__":
+    main()

datamaker/README.md

@@ -0,0 +1,52 @@
+# datamaker
+
+This directory stores the VidLLVIP preprocessing scripts, registration matrices, and intermediate processing results. The repository only keeps the scripts by default; large video files and matrix files should be downloaded separately.
+
+## Download
+
+- Option 1: Download from [Hugging Face](https://huggingface.co/datasets/jianfeng0369/VidLLVIP)
+- Option 2: Download from [Quark Drive](https://pan.quark.cn/s/e3abe425aa5f?pwd=E5gv)
+
+After downloading, extract `datamaker.zip` and `matrix.zip` into this directory so that it matches the structure below.
+
+## Expected File Structure
+
+```text
+datamaker/
+  README.md
+  requirements.txt
+  01_time_align.py
+  02_space_align.py
+  03_checkerboard.py
+  04_split_5s_videos.py
+  matrix/
+    01.csv
+    02.csv
+    ...
+    14.csv
+  01_align/
+    01/
+      ir.mp4
+      vi.mp4
+      timestamp.xlsx
+    ...
+    14/
+      ir.mp4
+      vi.mp4
+      timestamp.xlsx
+  02_warp/
+    01/
+      ir.mp4
+      vi.mp4
+    ...
+    14/
+      ir.mp4
+      vi.mp4
+  03_ckboard/
+    01.mp4
+    02.mp4
+    ...
+    14.mp4
+```
+
+`matrix/` stores the 3x3 perspective transformation matrices for IDs `01` to `14`; `01_align/` stores the temporally aligned full videos; `02_warp/` stores the spatially registered full videos; and `03_ckboard/` stores checkerboard videos for quality inspection.

datamaker/datamaker.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:894ba17eb56b84d97104b717e5b19f2cb2aa408edd1fab407f783df3dafe679a
+size 18571821199

datamaker/matrix.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff4df8326c19dda203352d5b71bd95607a5d355bdb559589071934a149e0cb1d
+size 4079

datamaker/requirements.txt

@@ -0,0 +1,8 @@
+# Recommended Python: 3.10.x
+# External tools required on PATH: ffmpeg, ffprobe
+
+numpy>=1.26,<2.0
+opencv-python>=4.9,<5.0
+pandas>=2.2,<3.0
+openpyxl>=3.1,<4.0
+tqdm>=4.66,<5.0

dataset/README.md

@@ -0,0 +1,35 @@
+# dataset
+
+This directory stores the final released VidLLVIP paired infrared-visible video clips. The repository does not include large video files by default, so please download them separately.
+
+## Download
+
+- Option 1: Download from [Hugging Face](https://huggingface.co/datasets/jianfeng0369/VidLLVIP)
+- Option 2: Download from [Quark Drive](https://pan.quark.cn/s/e3abe425aa5f?pwd=E5gv)
+
+After downloading, extract `dataset.zip` into this directory so that it matches the structure below.
+
+## Expected File Structure
+
+```text
+dataset/
+  README.md
+  ir/
+    01_0000_0005.mp4
+    01_0005_0010.mp4
+    ...
+  vi/
+    01_0000_0005.mp4
+    01_0005_0010.mp4
+    ...
+```
+
+Videos with the same file name under `ir/` and `vi/` form one paired sample. For example, `ir/01_0000_0005.mp4` and `vi/01_0000_0005.mp4` are the infrared and visible videos from the same time interval.
+
+The file name format is:
+
+```text
+{source_id}_{start_second}_{end_second}.mp4
+```
+
+The final dataset contains `894` paired 5-second clips. Each clip is `1280 x 1024`, `25 FPS`, `125` frames, and has no audio.

dataset/dataset.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5a01effbdd54dd1d368401ffe2408edccf3fef335993fe95ffe66e7ebe1ab480
+size 6631687357

raw/README.md

@@ -0,0 +1,30 @@
+# raw
+
+This directory stores the original LLVIP infrared-visible videos before preprocessing. The repository does not include large raw video files by default, so please download them separately.
+
+## Download
+
+- Option 1: Download from [Hugging Face](https://huggingface.co/datasets/jianfeng0369/VidLLVIP)
+- Option 2: Download from [Quark Drive](https://pan.quark.cn/s/e3abe425aa5f?pwd=E5gv)
+
+After downloading, extract `raw.zip` into this directory so that it matches the structure below.
+
+## Expected File Structure
+
+```text
+raw/
+  README.md
+  videos/
+    ir/
+      01.mp4
+      02.mp4
+      ...
+      14.mp4
+    vi/
+      01.mp4
+      02.mp4
+      ...
+      14.mp4
+```
+
+Videos with the same ID under `videos/ir/` and `videos/vi/` form one original infrared-visible source pair.

raw/raw.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:468cc00b9b462fbdd0e8ad9a66dc119a331309d92fec1d2f6a30be96378d34cc
+size 3724002696