---
license: mit
task_categories:
  - image-segmentation
language:
  - zh
tags:
  - chinese-calligraphy
  - stroke-segmentation
  - brush-calligraphy
  - handwriting
  - semantic-segmentation
pretty_name: Brush Calligraphy Stroke Segmentation (BCSS)
size_categories:
  - 1K<n<10K
configs:
  - config_name: train_val
    data_files:
      - split: train
        path: data/train_val/train-*.parquet
      - split: validation
        path: data/train_val/validation-*.parquet
      - split: test
        path: data/train_val/test-*.parquet
  - config_name: external_test
    data_files:
      - split: test
        path: data/external_test/test-*.parquet
---

# Brush Calligraphy Stroke Segmentation Dataset (BCSS) 🖌️

[![GitHub](https://img.shields.io/badge/GitHub-Rvosuke%2FBCSS-181717?logo=github)](https://github.com/Rvosuke/BCSS)
[![Paper](https://img.shields.io/badge/Paper-IET%20Image%20Processing-brightgreen)](https://doi.org/10.1049/ipr2.13255)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)

> This dataset card mirrors and is cross-linked with the project's GitHub repository: **[github.com/Rvosuke/BCSS](https://github.com/Rvosuke/BCSS)**.

## Introduction

The **Brush Calligraphy Stroke Segmentation Dataset (BCSS)** is a resource for the task of Chinese brush-calligraphy stroke segmentation. It is derived from the Evaluated Chinese Calligraphy Copies (E3C) dataset — an aesthetic-evaluation dataset for Chinese brush calligraphy — and augmented with additional images from diverse sources to enhance diversity and support the evaluation of model generalization.

Each character image is paired with a set of per-stroke binary masks, enabling **multi-label** stroke segmentation where intersecting strokes can overlap. A per-character *prior-knowledge vector* (stroke-count metadata) is also provided.

## What's in this HuggingFace copy

The full BCSS dataset described in the paper contains **1,322 images and 10,653 annotated strokes**. This HuggingFace release packages the segmentation-ready split that ships with the reference implementation:

| Subset | Images | Notes |
|---|---|---|
| Training + Validation | **1,082** | Each image has 6 per-stroke masks + a prior-knowledge vector row |
| External Testing | **130** | Held-out generalization images (input images only) |
| **Total** | **1,212** | Segmentation-ready subset |

> **Note on counts:** The paper reports 1,322 images (1,022 train/val + 300 external test) and 10,653 strokes over the *complete* collection. This packaged, segmentation-ready subset contains 1,082 train/val images and 130 external-test images. Some raw/reference material (raw instances and label source files) is hosted on the [GitHub repository](https://github.com/Rvosuke/BCSS) under `instances/` and `labels/`.

All images are **400 × 400** PNGs.

## Repository Layout

To keep the repo efficient (thousands of small PNGs are packed into a few archives), the image/mask files are shipped as ZIP archives, while metadata is left as plain browsable files:

```
.
├── README.md                     # This dataset card
├── LICENSE                       # MIT License
├── train_val_images.zip          # images/<id>.png            (1,082 files, 400x400)
├── train_val_masks.zip           # masks/<id>/{1..6}.png       (1,082 folders x 6 masks)
├── train_val_info.csv            # prior-knowledge vector, 1 row per train/val image
├── external_test_images.zip      # images/<id>.png            (130 files)
├── external_test_info.csv        # prior-knowledge vector for external test
└── splits/
    ├── train.txt                 # 944 ids
    ├── val.txt                   # 98 ids
    ├── test.txt                  # 40 ids (internal held-out)
    └── train_test.txt            # 10 ids (small smoke-test subset)
```

After extraction, each archive expands to an `images/` or `masks/` directory:

```
train_val_images.zip   ->  images/<id>.png
train_val_masks.zip    ->  masks/<id>/1.png ... 6.png
external_test_images.zip -> images/<id>.png
```

### Image ↔ mask correspondence

- An image `images/<id>.png` (from `train_val_images.zip`) corresponds to the mask folder `masks/<id>/` (from `train_val_masks.zip`).
- Each mask folder holds **6 binary PNGs** (`1.png` … `6.png`), one per stroke class. During training these are thresholded (`> 150 → 1`) and stacked into a multi-channel label tensor, so overlapping/intersecting strokes are preserved as independent channels rather than a single argmax label map.
- IDs, images, and masks are 1:1 aligned — every one of the 1,082 images has both an image file and a 6-mask folder (verified: 0 orphans on either side).

### `*_info.csv` — prior-knowledge vector

Each `info.csv` has one row per image, comma-separated, no header:

```
<id>,v1,v2,v3,v4,v5,v6,v7
```

- **`id`** — image identifier (matches `images/<id>.png` and `masks/<id>/`).
- **`v1…v7`** — integer prior-knowledge / stroke-statistic values used by the model as a *Prior Knowledge Vector* to guide segmentation. Observed value ranges in this release: `v1 ∈ [0,26]`, `v2 ∈ [0,4]`, `v3 ∈ [0,10]`, `v4 ∈ [0,6]`, `v5 ∈ [0,5]`, `v6 ∈ [0,1]`, `v7 ∈ [0,3]`. `external_test_info.csv` follows the same format.

### Splits

The `splits/*.txt` files list image IDs (one per line) for reproducing the reference train/val/test partition used in the Stroke-Seg paper:

- `train.txt` — 944 ids
- `val.txt` — 98 ids
- `test.txt` — 40 ids (internal held-out)
- `train_test.txt` — 10 ids (small smoke-test subset)

The external-test subset is a separate generalization benchmark (different character styles / handwriting) and is not covered by these split files.

## Usage

Download and extract the archives, then load images + multi-label masks with `Pillow`/`NumPy`:

```python
import os, csv, zipfile, numpy as np
from PIL import Image
from huggingface_hub import hf_hub_download

REPO = "Rvosuke/BCSS"

def fetch_and_extract(filename, dest="."):
    path = hf_hub_download(REPO, filename, repo_type="dataset")
    with zipfile.ZipFile(path) as z:
        z.extractall(dest)

# download archives once
fetch_and_extract("train_val_images.zip")   # -> ./images/<id>.png
fetch_and_extract("train_val_masks.zip")    # -> ./masks/<id>/{1..6}.png
info_path = hf_hub_download(REPO, "train_val_info.csv", repo_type="dataset")
split_path = hf_hub_download(REPO, "splits/train.txt", repo_type="dataset")

# read prior-knowledge vectors
info = {}
with open(info_path, errors="ignore") as f:
    for row in csv.reader(f):
        info[row[0]] = list(map(int, row[1:]))

def load_sample(img_id, size=(400, 400)):
    img = np.array(Image.open(f"images/{img_id}.png").convert("RGB").resize(size))
    mask_dir = f"masks/{img_id}"
    channels = []
    for fn in sorted(os.listdir(mask_dir)):                 # 1.png .. 6.png
        m = Image.open(os.path.join(mask_dir, fn)).convert("L").resize(size)
        channels.append((np.array(m) > 150).astype(np.uint8))
    label = np.stack(channels, axis=0)                      # (6, H, W) multi-label
    return img, label, info[img_id]

ids = [l.strip() for l in open(split_path) if l.strip()]
img, label, prior = load_sample(ids[0])
print(img.shape, label.shape, prior)   # (400,400,3) (6,400,400) [...]
```

## Applications

BCSS can be used to train and evaluate models for brush-calligraphy stroke segmentation. It offers a rich variety of Chinese character styles and a dedicated external test set for measuring generalization across writing styles. The reference framework, **Stroke-Seg**, is built on DeepLab v3 and introduces a Prior Knowledge Vector, a multi-label output strategy for intersecting strokes, and a boundary-aware loss (BDLoss).

## Data Sources & Composition (per paper)

- **Training/Validation (1,022 in paper):** images from the **E3C** dataset.
- **External Testing (300 in paper):**
  - 90 E3C images with character types unseen in train/val;
  - 113 handwritten images from the **CCSE-W** dataset;
  - 97 images of various Chinese character styles (regular printed and brush calligraphy forms, e.g. Clerical Script).

## License

Released under the **MIT License** for research purposes. See `LICENSE`.

## Citation

If you use this dataset, code, or methods, please cite:

```bibtex
@article{gong2024stroke,
  title={Stroke-Seg: A Deep Learning-Based Framework for Chinese Stroke Segmentation},
  author={Gong, Xinyu and Bai, Zeyang and Nie, Haitao and Xie, Bin},
  journal={IET Image Processing},
  volume={18},
  number={13},
  pages={4341--4355},
  year={2024},
  publisher={Wiley Online Library},
  doi={10.1049/ipr2.13255}
}
```

## References

1. Sun, M., et al. (2023). *SRAFE: Siamese Regression Aesthetic Fusion Evaluation for Chinese Calligraphic Copy.* CAAI Transactions on Intelligent Technology, 8(3), 1077–1086.
2. Liu, L., Lin, K., Huang, S., Li, Z., Li, C., Cao, Y., & Zhou, Q. (2022). *Instance Segmentation for Chinese Character Stroke Extraction: Datasets and Benchmarks.* arXiv:2210.13826.
3. Long, J., Shelhamer, E., & Darrell, T. (2015). *Fully Convolutional Networks for Semantic Segmentation.* CVPR, 3431–3440.
4. Chen, L. C., Papandreou, G., Schroff, F., & Adam, H. (2017). *Rethinking Atrous Convolution for Semantic Image Segmentation.* arXiv:1706.05587.

## Contact

For inquiries about the dataset, please contact:

- zeyangbai.rvo@gmail.com
- xiebin@csu.edu.cn

---

*Related resources — Dataset: [github.com/Rvosuke/BCSS](https://github.com/Rvosuke/BCSS) · Paper: [IET Image Processing](https://doi.org/10.1049/ipr2.13255)*