先木

用微信小程序 + Flask 做一个党费管理系统

Thu, 16 Apr 2026 00:00:00 GMT

从”每次收党费都得挨个发消息追”到”党员自己打开微信就缴了”，做了这个小工具，顺手开源出来。
GitHub：party-fee-manager

背景#

每到收党费，流程大概是这样：管理员群里发通知，等一圈，再发一遍，有人现金、有人转账、有人说”我上次交了吧”，月底对账发现台账和实际金额对不上。

解决方案其实不复杂——做个小程序，党员自己进来缴费，记录自动生成，管理员实时看进度。

界面预览#

党员端#

首页

身份绑定

缴费记录

修改个人信息

管理端#

超级管理员看板

支部管理员看板

成员管理

信息审核

功能#

党员端#

首次使用需要输入工号 / 学号 + 手机号完成身份绑定，系统将微信 OpenID 与党员信息关联，之后打开直接识别身份，不用重复操作。每个微信只能绑一个人，每个人也只能绑一个微信。

绑定后可以看到自己所有期次的缴费状态，未缴的高亮提示，点击直接跳到支付页面。支持微信支付，同时内置了 mock 模式，不需要真实商户号也能跑通完整缴费流程，方便演示。

如果需要修改手机号、党员身份、所在支部等信息，可以在小程序内提交变更申请，管理员审核通过后生效，防止信息被随意修改。

管理端#

系统设计了两级角色：超级管理员管全院，支部管理员只看自己支部，两者数据严格隔离。

超管看板用环形图展示全院整体缴费比例，下方按支部分组显示进度条，支持按期次和支部筛选。“一键确认到账”可以批量将已支付记录标记为到账，不用逐条处理。成员管理支持单条录入和 Excel 批量导入。

信息审核页面以变更对比的方式展示每条申请，旧值划线、新值加粗标红，管理员能直观看出改了什么，点击批准或驳回即可。

技术实现#

整体结构#

1
微信小程序（WXML / WXSS / JS）
2
         ↕ wx.request / HTTPS
3
Flask REST API（Python）
4
         ↕
5
SQLite 数据库（单文件）

前后端完全分离，小程序只负责渲染和交互，业务逻辑全在后端。

鉴权：两套并行#

管理员走用户名 + 密码，登录后后端签发 JWT，payload 里带 role（super / branch）和 branch_id，后续请求通过 Authorization: Bearer <token> 鉴权。权限装饰器从 token 中读取角色，支部管理员调全院接口直接返回 403。

1
def require_super(f):
2
    @wraps(f)
3
    def decorated(*args, **kwargs):
4
        token = request.headers.get("Authorization", "").replace("Bearer ", "")
5
        payload = jwt.decode(token, JWT_SECRET, algorithms=["HS256"])
6
        if payload["role"] != "super":
7
            return jsonify({"code": 403, "msg": "权限不足"})
8
        g.admin_id = payload["sub"]
9
        return f(*args, **kwargs)
10
    return decorated

党员走微信 OpenID 体系：小程序调 wx.login() 拿到临时 code，后端用 APPID + AppSecret 向微信换取 OpenID，查库匹配党员记录后签发党员专用 JWT。OpenID 是微信给每个用户在特定小程序下的唯一标识，不会变、不会失效，用来做持久化身份绑定很合适。

数据隔离同样在后端保证：支部管理员的所有查询都自动追加 WHERE branch_id = ?，从 SQL 层面隔开，不依赖前端传参。

路由按角色拆文件#

1
routes/
2
├── admin_login.py    # 管理员登录（flask-limiter 频率限制，防爆破）
3
├── super_admin.py    # 超管：成员 CRUD、期数、支部、账号、导出 Excel
4
├── branch_admin.py   # 支部管理员：成员查询、审核
5
├── payment.py        # 微信支付回调 & 确认到账
6
└── user.py           # 党员端：登录、查记录、提交申请

数据库选型#

用户量有限（数十到数百人），SQLite 的几个特点很适合这个场景：零配置、单文件便于备份、开启 WAL 模式后支持读写并发。如果未来规模扩大，把 get_db() 换成 PostgreSQL 连接，其余代码基本不用动。

前端请求封装#

小程序用原生开发，没有引入 UI 框架。utils/api.js 统一处理鉴权头、401 过期跳转和错误提示，各页面只需调用 api.post / api.get：

1
const res = await api.post("/admin/login", { username, password });

请求头里带了 ngrok-skip-browser-warning: true，跳过 ngrok 免费版在浏览器侧插入的提示页，真机调试不受影响。

部署#

环境要求#

工具	说明
Python 3.10+	后端运行环境
微信开发者工具	最新稳定版，用于小程序调试
微信小程序 AppID	在微信公众平台 → 开发管理 → 开发设置中获取，个人测试号即可
ngrok	真机调试时做内网穿透（可选）

后端#

Terminal window

1
git clone https://github.com/cairangxianmu/party-fee-manager.git
2
cd party-fee-manager/backend
3

4
pip install -r requirements.txt
5

6
# 初始化数据库
7
python -c "from database import init_db; init_db()"
8

9
# 写入演示数据（可选，会清空现有数据）
10
python seed_demo.py
11

12
python app.py
13
# → http://localhost:5000

演示数据包含 2 个支部、5 名在册党员（张三 / 李四 / 王五等匿名示例）和 2 个缴费期次，部分已缴、部分未缴，可以直接看到看板上的统计效果。

演示账号：

账号	密码	角色
admin	admin123	超级管理员
branch01	branch123	支部管理员（第一支部）

凭证推荐通过环境变量注入，避免写入代码：

Terminal window

1
export APPID=wxxxxxxxxxxx
2
export APP_SECRET=xxxxxxxxxxxxxxxx
3
python app.py

也可以直接在 backend/config.py 填写默认值，仅限本地调试。

微信开发者工具#

打开微信开发者工具，选择「小程序」→「导入项目」，目录选择 miniprogram/
在 miniprogram/project.config.json 填入你的 AppID
详情 → 本地设置 → 勾选**「不校验合法域名」**，否则 localhost 请求会被拦截
点击编译（Ctrl+B）

miniprogram/app.js 里的 baseUrl 默认指向 http://localhost:5000，模拟器调试直接可用。

真机调试#

微信真机预览要求后端使用 HTTPS，本地可以用 ngrok 做内网穿透。注册账号、下载安装后完成 authtoken 配置，然后：

Terminal window

1
ngrok http 5000
2
# 输出类似：Forwarding  https://xxxx.ngrok-free.app -> http://localhost:5000

将该地址填入 miniprogram/app.js 的 baseUrl，重新编译后点击「预览」扫码，即可在真机上体验完整流程，包括微信授权登录和支付。

注意 ngrok 免费版每次重启地址会变，重启后需要更新 baseUrl 并重新编译。

正式上线#

日常演示和开发不需要关注这部分，有实际上线需求时参考：

微信支付：config.py 中 PAY_MODE 默认为 mock。接入真实支付需要开通微信商户号，获取 MCHID、APIV3_KEY、商户 API 证书（apiclient_key.pem）和 SERIAL_NO，填入配置后将 PAY_MODE 改为 real，并配置公网 HTTPS 回调地址 NOTIFY_URL。

JWT 密钥：将 JWT_SECRET 替换为随机字符串：

Terminal window

1
python -c "import secrets; print(secrets.token_hex(32))"

服务器部署：用 gunicorn + nginx 替代 Flask 开发服务器，配置 Let’s Encrypt SSL 证书（微信小程序正式版强制要求 HTTPS）。SQLite 适合中小规模，数据量大时可迁移到 PostgreSQL。

TibetanHWR 系列三：CNN 训练与 Web 部署——手写识别在线演示实现

Thu, 16 Apr 2026 00:00:00 GMT

本文是 TibetanCharacter 系列的第三篇，也是终章。前两篇分别解决了「数据从哪来」和「数据怎么清洗」的问题，本篇把数据喂进模型，再把模型搬进浏览器。

项目资源
📊 数据集：百度网盘（提取码：4ata）
💻 项目代码：cairangxianmu/tibetan-hwr
🌐 Web 演示：cairangxianmu-tibetan-hwr.hf.space
📄 论文：DOI 10.16229/j.cnki.issn1001-7542.2019.04.006

一、整体架构#

把「手写识别」拆成可以独立迭代的三个模块：数据、模型、服务。

1
dataset/                 ImageFolder 组织的 PNG 集合
2
   │
3
   ▼
4
recognition/             PyTorch 训练管线
5
   ├── dataset.py        DataLoader 工厂 + 字符映射表
6
   ├── model.py          DigitCNN / LetterCNN
7
   └── train.py          训练入口（日志 / 曲线 / 权重保存）
8
         │
9
         ▼
10
checkpoint/{mode}_best.pth
11
         │
12
         ▼
13
web/                     FastAPI + Canvas
14
   ├── app.py            懒加载模型 · /predict 接口
15
   └── static/           Canvas 画板 + 逐笔撤销

展开收起

两个任务走完全相同的管线，只由 --mode digit|letter 这一个开关切换数据源、模型结构和类别数。这让代码可以大部分共用，同时各自有针对性的设计。

二、模型设计#

2.1 为什么要两个网络#

	数字	字母
输入尺寸	28×28	64×64
类别数	10	30
图像面积	1×	5.2×
字形复杂度	简单	较复杂

字母任务的信息量（面积 × 类别）是数字任务的十几倍，共用一套小网络会欠拟合，共用一套大网络对数字又是浪费。因此按任务复杂度分别设计。

2.2 DigitCNN（10 类）#

LeNet 风格，两层卷积 + 两层全连接，参数量 ~420K：

1
输入 1×28×28
2
  Conv(1→32, 3×3, pad=1) → BN → ReLU → MaxPool(2)   →  32×14×14
3
  Conv(32→64, 3×3, pad=1) → BN → ReLU → MaxPool(2)  →  64×7×7
4
  Flatten → FC(3136→128) → ReLU → Dropout(0.5)
5
  FC(128→10)

CPU 上单张推理 < 5 ms，训练 30 epoch 在笔记本上约 5 分钟。

2.3 LetterCNN（30 类）#

在 DigitCNN 基础上增加第三个卷积块，并在每层卷积后加 BatchNorm，参数量 ~2.3M：

1
输入 1×64×64
2
  Conv(1→32,  3×3) → BN → ReLU → MaxPool(2)   →  32×32×32
3
  Conv(32→64, 3×3) → BN → ReLU → MaxPool(2)   →  64×16×16
4
  Conv(64→128,3×3) → BN → ReLU → MaxPool(2)   →  128×8×8
5
  Flatten → FC(8192→256) → ReLU → Dropout(0.5)
6
  FC(256→30)

BatchNorm 在这里做两件事：

加速收敛——实测达到相同验证准确率所需 epoch 数减少约 30%；
稳定训练——缓解内部协变量偏移，缩小训练 / 验证准确率差距。

两个模型都通过 get_model(mode) 工厂函数统一调用，训练、推理、权重加载全部复用同一套入口。

三、训练管线#

3.1 数据加载#

数据集按 ImageFolder 约定组织（子目录名即类别），通过 get_dataloaders() 一行获取 train/val DataLoader：

1
train_loader, val_loader, num_classes = get_dataloaders(
2
    mode="letter",   # 或 "digit"
3
    batch_size=64,
4
    val_split=0.2,   # 固定随机种子 42，保证划分可复现
5
)

3.2 预处理与数据增强#

二值化预处理是训练和推理共用的第一步：对灰度图先做高斯模糊（σ=1），再用 Otsu 算法自动确定阈值进行二值化。相比直接 Otsu，模糊步骤先消除抗锯齿噪点，让笔画边缘更连续，实测效果明显优于多种其他方案（纯 Otsu、自适应阈值、形态学闭运算等）。

训练集在二值化前还施加几何增强，顺序很关键：几何变换必须在二值化之前做。若先二值化再做仿射变换，双线性插值会在纯 0/255 的图上产生灰色污染像素，破坏二值一致性。正确的流水线：

1
Grayscale → Resize
2
  → RandomRotation(±15°)
3
  → RandomAffine(translate=8%, scale=±15%, shear=±8°)
4
  → RandomPerspective(distortion=0.2, p=0.4)
5
  → GaussianBinarize（σ=1 + Otsu）
6
  → ToTensor → Normalize(0.5, 0.5)
7
  → RandomErasing(p=0.3)          ← Tensor 级别，模拟笔画断裂

fill=255 保证所有几何变换露出的区域为白色背景，与训练数据一致。

不做翻转。这一点专门针对藏文：多个字母互为镜像（如 ག / ད），水平或垂直翻转会直接污染标签。这是「通用视觉增强」在专门领域需要让位于先验知识的典型案例。

3.3 优化与调度#

1
优化器：Adam，lr=1e-3，weight_decay=1e-4
2
调度器：CosineAnnealingLR，T_max=epochs，eta_min=1e-6
3
损失：  CrossEntropyLoss(label_smoothing=0.1)
4
早停：  patience=10，验证准确率连续无改善时恢复最优权重并停止
5
建议：  digit → 30 epoch，letter → 50 epoch（batch 128）

标签平滑（label_smoothing=0.1）让模型对自己的预测不过度自信，缓解在小数据集上的过拟合。

早停监控验证准确率，连续 patience 个 epoch 无改善时触发，并自动恢复精度最高时的权重——既防止过拟合，又省去手动盯训练曲线的麻烦。训练结束或早停后，每隔 5 个 epoch 的周期检查点也会保留最近 3 个，便于回退。

Cosine 退火的直觉：前期大 lr 快速下降到低损失盆地，后期小 lr 精细探索盆底，避免在最优解附近震荡。相比 StepLR，在同等 epoch 下通常能多挤出 0.5–1 个百分点。

3.4 日志与可视化#

每次训练在 runs/{mode}_{timestamp}/ 下自动生成四件套：

文件	用途
`args.json`	超参数快照 + 原始命令，复现实验
`metrics.csv`	逐 epoch 指标，便于后处理分析
`events.out.*`	TensorBoard 事件文件
`training_curves.png`	训练结束时的总览图

训练结束后自动生成训练曲线（Loss / Accuracy）：

数字模型（30 epoch）

数字模型训练曲线

字母模型（50 epoch）

字母模型训练曲线

3.5 权重保存#

不止保存权重，还把元数据一起存进 checkpoint，让推理侧加载时无需再传参：

1
torch.save({
2
    "epoch":            epoch,
3
    "mode":             args.mode,      # "digit" / "letter"
4
    "num_classes":      num_classes,
5
    "model_state_dict": model.state_dict(),
6
    "val_acc":          val_acc,
7
}, "checkpoint/{mode}_best.pth")

四、Web 在线演示#

4.1 后端：FastAPI + 懒加载#

三个路由就够了：

路由	方法	说明
`/`	GET	返回前端页面
`/health`	GET	健康检查，返回推理设备
`/predict`	POST	接收 base64 图像 + 模式，返回识别结果

模型懒加载是一个值得单独提的设计：服务启动不触碰权重文件，首次收到某模式请求时才读盘加载，之后缓存在内存中。好处是启动秒级响应、内存占用按需增长；如果只识别数字，字母模型永远不会被加载。

1
_model_cache: dict = {}
2

3
def _load_model(mode: str) -> torch.nn.Module:
4
    if mode in _model_cache:
5
        return _model_cache[mode]
6
    checkpoint = torch.load(ckpt_path, map_location=_device)
7
    model = get_model(mode, num_classes=checkpoint["num_classes"])
8
    model.load_state_dict(checkpoint["model_state_dict"])
9
    model.eval()
10
    _model_cache[mode] = model
11
    return model

4.2 前端：Canvas + 逐笔撤销#

前端不依赖任何框架，核心是一个 400×400 的 Canvas。鼠标和触屏统一处理，真正想讲的是 逐笔撤销的实现——不存像素，而是存每一笔落笔前的快照：

1
function startDraw(e) {
2
  // 落笔前拍快照
3
  currentStroke = ctx.getImageData(0, 0, canvas.width, canvas.height);
4
  ctx.beginPath();
5
  ctx.moveTo(x, y);
6
}
7

8
function endDraw() {
9
  strokeHistory.push(currentStroke); // 抬笔后入栈
10
}
11

12
undoBtn.addEventListener("click", () => {
13
  const prev = strokeHistory.pop();
14
  ctx.putImageData(prev, 0, 0); // 还原到上一笔之前
15
});

展开收起

这样任意笔画数都能无损撤销，且实现比维护笔画向量列表简单得多。代价是内存占用随撤销栈线性增长，对小画板无伤大雅。

其它交互细节：

图片上传（点击 / 拖放），自动居中缩放填充画板；
Ctrl+Z 撤销、Enter 识别；
切换数字 / 字母模式时清空画板。

识别请求就是把 Canvas toDataURL 编码为 base64 发过去，响应体携带 Top-5 候选：

1
{
2
  "label":      3,
3
  "character":  "༣",
4
  "confidence": 97.42,
5
  "top5": [
6
    {"label": 3, "character": "༣", "confidence": 97.42},
7
    {"label": 8, "character": "༨", "confidence":  1.83},
8
    ...
9
  ]
10
}

4.3 关键细节：训练—推理分布对齐#

这是本项目调试中收益最高的一步，值得单独拎出来讲。

上线后首轮体验识别率很低。原因是：训练样本里字符几乎铺满整帧（28×28 或 64×64 都是紧贴字符边缘），但推理时用户在 400×400 画板上写一个字，字符只占中心一小块，周围大片白边。直接缩放，字符就被压成了一小坨，模型从未见过这种尺度。

解决办法：在推理预处理里先做紧边界框裁剪，再缩放。流程图：

1
Canvas 400×400（白底 + 一小块字符）
2
    │
3
    ▼  _tight_crop：找暗像素边界框 → 扩 15% padding → 裁剪 → 填充为正方形
4
字符铺满帧的图像
5
    │
6
    ▼  Grayscale → Resize（28×28 或 64×64）
7
    ▼  GaussianBinarize：高斯模糊（σ=1）→ Otsu 二值化
8
    ▼  ToTensor → Normalize(0.5, 0.5)
9
模型输入（与训练验证集分布一致）

核心代码：

1
def _tight_crop(img_gray, pad_ratio=0.15):
2
    arr  = np.array(img_gray)
3
    mask = arr < 200                      # 暗像素掩码
4
    rows, cols = np.any(mask, 1), np.any(mask, 0)
5
    if not rows.any():                    # 画板为空
6
        return img_gray
7

8
    rmin, rmax = np.where(rows)[0][[0, -1]]
9
    cmin, cmax = np.where(cols)[0][[0, -1]]
10
    pad = max(4, int(max(rmax - rmin, cmax - cmin) * pad_ratio))
11
    # 外扩 padding 后裁剪，不越界
12
    ...
13
    cropped = img_gray.crop((cmin, rmin, cmax + 1, rmax + 1))
14
    # 填充为正方形白背景，避免后续 Resize 拉伸
15
    side   = max(cropped.size)
16
    square = Image.new("L", (side, side), 255)
17
    square.paste(cropped, ((side - cw) // 2, (side - ch) // 2))
18
    return square

展开收起

加入这一步后，识别率显著提升。经验：训练和推理的数据分布不一致，即使模型本身没问题也会表现得「模型很差」——定位这类问题比调模型本身更重要。手写画板和上传图片走同一条预处理路径，保证两种输入的表现一致。

五、快速上手#

Terminal window

1
# 1. 依赖
2
pip install -r requirements.txt
3

4
# 2. 下载预训练模型（推荐）
5
#    从 GitHub Releases 下载 digit_best.pth 和 letter_best.pth，放入 checkpoint/
6
#    https://github.com/cairangxianmu/tibetan-hwr/releases/latest
7

8
# 3. 启动 Web 服务
9
cd web
10
uvicorn app:app --port 8000
11
# 浏览器打开 http://localhost:8000，书写或上传图片后点击「识别」

如需自行训练（需先准备数据集，见系列一）：

Terminal window

1
cd recognition
2
python train.py --mode digit  --epochs 30                              # ~5 min CPU
3
python train.py --mode letter --epochs 50 --batch-size 128 --patience 10  # ~5 min GPU

六、小结#

本篇把数据变成了一个可交互的 Demo，沿途的关键选择：

按任务复杂度差异化设计模型：DigitCNN 与 LetterCNN 均含 BatchNorm，LetterCNN 额外多一层卷积块，避免一刀切；
预处理统一二值化：高斯模糊（σ=1）+ Otsu，训练与推理完全一致；几何增强必须在二值化之前做，否则插值会污染二值图；
增强策略服从先验：藏文镜像字禁用翻转；增加透视变换和随机擦除以拟合手写板的书写风格；
标签平滑 + 早停：防止小数据集过拟合，无需手动盯训练曲线；
懒加载服务：启动快、内存按需增长，适合多模型共享后端的场景；
训练—推理分布对齐：Canvas 空白多、训练样本铺满帧，靠 _tight_crop 拉平差距，实测收益最高。

三篇合在一起，完整覆盖了这套系统数据采集（系列一）→ 图像预处理（系列二）→ 模型训练与在线演示（本篇） 的全链路。没有用到任何预训练模型，从零开始、轻量部署，可作为理解手写识别端到端链路的入门实践。

TibetanHWR 系列一：TibetanCharacter 数据集——藏文手写数字与字母图像集

Wed, 15 Apr 2026 00:00:00 GMT

项目资源
📊 数据集：百度网盘（提取码：4ata）
💻 项目代码：cairangxianmu/tibetan-hwr
🌐 Web 演示：cairangxianmu-tibetan-hwr.hf.space
📄 论文：DOI 10.16229/j.cnki.issn1001-7542.2019.04.006

一、项目简介#

本文介绍两个专为藏文手写体识别任务构建的开源数据集：

TibetanMNIST：藏文手写数字数据集，共 17768 张图像，涵盖藏文 0–9 共 10 个数字类别
TibetanLetter：藏文手写字母数据集，共 77636 张图像，覆盖 30 个藏文辅音字母

两个数据集均由本人在本科期间带队制作，是目前为数不多的藏文手写体公开数据集，填补了该领域数据空白，适合用于藏文识别相关的机器学习入门任务。

	TibetanMNIST	TibetanLetter
类别数	10（数字 0–9）	30（辅音字母）
样本数	17,768	77,636
图像尺寸	28×28	64×64
通道	灰度图	灰度图

二、背景与起源#

2.1 从 MNIST 到 TibetanMNIST#

MNIST 数据集是机器学习领域的里程碑——由美国国家标准与技术研究所（NIST）发起，收录了 250 位书写者的手写数字，自发布以来被广泛用于检验各类算法，推动了机器学习领域的长足发展，当之无愧是历史上最具影响力的数据集之一。

然而，现有手写体数据集几乎清一色面向英文、中文、阿拉伯文等强势语言，少数民族语言的数据资源极度匮乏。藏文作为拥有数百万使用者的语言，在公开数据集层面几乎是空白。这一现状不仅限制了藏文智能输入、文档数字化等实际应用的发展，也使藏文相关的学术研究举步维艰。

TibetanMNIST 正是在这一背景下诞生的。数据集按照 MNIST 的格式规范制作，图像尺寸同为 28×28 像素灰度图，可直接套用为 MNIST 设计的模型框架进行训练，大大降低了研究者的上手门槛。书写者为本校藏族同学，经过严格的质量筛选，最终整理出 17768 张高清图像——据我们所知，这是全球第一个公开的藏文手写数字图像数据集。

2.2 从数字到字母的扩展#

数字数据集的顺利完成，让团队看到了进一步拓展的可能。藏文数字仅有 10 个类别，而藏文字母有 30 个辅音字母，是构成藏文文本的核心单元，其识别难度与应用价值都更高。

为此，我们组织了更大规模的数据采集：邀请本校 150 名藏族大学生参与手写，在统一规范的方格纸上书写全部 30 个辅音字母，原始采集量约 100000 例。经人工逐一核查清洗后，最终形成 TibetanLetter 数据集，包含 77636 张 64×64 像素的标准化字母图像。

两个数据集合并发布，统称 TibetanCharacter，希望为藏文手写体识别研究提供一个坚实的数据基础。

三、TibetanMNIST 数字数据集#

3.1 藏文数字介绍#

藏文数字是藏语书写体系中独立使用的计数符号，与阿拉伯数字一一对应，共 10 个，分别表示 0 到 9。它们并非藏文字母的一部分，而是在语言中单独成体，形态简洁、笔画清晰，具有较高的可辨识度。从字形上看，藏文数字自成风格，与汉字数字或阿拉伯数字均无直接渊源，是藏族文化中独特的符号系统：

阿拉伯数字	藏文数字	阿拉伯数字	藏文数字
0	༠	5	༥
1	༡	6	༦
2	༢	7	༧
3	༣	8	༨
4	༤	9	༩

3.2 数据采集#

数据采集以纸质手写为主，书写者涵盖学生与研究人员。为保证样本质量，我们对书写规范做了统一要求：字体大小须适中、笔画完整清晰、书写在规定区域内，避免连笔或涂改。

采集完成后，所有原始图像均经过扫描数字化，再由团队成员对每张图像进行人工复核，经过 300 余次人工筛选，剔除书写不规范、字迹模糊、尺寸异常等无效样本，最终保留 17768 例有效图像，平均每个类别约 1777 张。

3.3 类别分布#

10 个数字类别整体分布较为均衡，每类约 1300–2100 张，无明显类别失衡问题，可直接用于有监督学习训练，无需额外做类别重采样：

TibetanMNIST 类别分布

3.4 数据示例#

下图展示了每个类别的若干手写样本，可以看到不同书写者在笔画风格、粗细、倾斜程度上存在自然差异，这正是手写体识别的挑战所在：

TibetanMNIST 数据示例

原始图像命名规则： {类别标签}_{纸张编号}_{纸张内序号}.png，例如 3_12_05.png 表示数字 3、第 12 张纸、第 5 个样本。

四、TibetanLetter 字母数据集#

4.1 藏文字母介绍#

藏文是一种拼音文字，其书写体系由辅音字母与元音符号组合而成。现代藏文共有 30 个辅音字母和 4 个元音符号，书写时以辅音字母为基础，通过垂直方向的叠加（上加字、下加字）和水平方向的拼接（前加字、后加字、再后加字），加上元音符号构成一个完整的藏文音节。

每个音节在视觉上呈现为一个紧凑的字块，结构层次丰富，书写风格因人而异，这也使得藏文手写体识别在技术上颇具挑战性。本数据集聚焦于最基本的构成单元，收录了手写形式的 30 个辅音字母：

30 个藏文辅音字母

4.2 数据采集#

为保证数据一致性，我们统一制定了书写规范：书写载体为红色格线方格纸（8 行 × 12 列），每格书写一个字母，通过格线约束个体书写差异，保证字母大小和位置相对一致。

共有本校 150 名藏族大学生参与书写，每人完成全部 30 个字母的书写任务，采集原始样本约 100000 例。所有纸张经高精度扫描后，由团队成员对每个字母图像进行逐一核查，删除字迹不清、书写越格、字母混淆等无效样本，最终保留有效数据 77636 例。

4.3 类别分布#

30 个字母类别分布相对均衡，每类约 2000 余个样本。少数字母因字形复杂、书写难度较高，有效率略低于其他类别，但整体样本量仍可满足模型训练需求：

TibetanLetter 类别分布

4.4 数据示例#

下图为部分藏文辅音字母的手写样本展示，每行对应一个字母类别，可以直观看到同一字母在不同书写者手下的风格差异：

TibetanLetter 数据示例

4.5 图像预处理#

由于书写纸张使用红色格线，原始扫描图像中格线与字母内容混叠，无法直接使用。我们设计了如下自动化预处理流程，将原始整张纸面图像切分并标准化为单张字母图像：

1
原始扫描图像
2
  ↓ HSV 颜色提取（分离红色格线）
3
  ↓ 中值滤波（去除噪声线条）
4
  ↓ 轮廓检测（定位字母区域）
5
  ↓ 字母提取（裁剪单个字母）
6
  ↓ 统一尺寸（归一化图像大小）
7
最终输出：标准化字母图像（64×64 灰度图）

其中，HSV 颜色空间下对红色通道的精准提取是关键步骤——红色在 HSV 空间中分布在色调（H）的两端，需要分段掩膜合并处理。轮廓检测基于 OpenCV 的外轮廓提取，结合面积与长宽比过滤，排除杂点干扰，准确定位每个字母单元格。

具体实现细节见：TibetanHWR 系列二：图像预处理

五、小结#

TibetanCharacter 数据集由 TibetanMNIST（17,768 张手写数字）与 TibetanLetter（77,636 张手写字母）两部分组成，填补了藏文手写体公开数据集的空白。系列后续两篇将分别介绍如何用 Python + OpenCV 对原始扫描图进行自动化预处理（系列二），以及如何训练 CNN 模型并部署为 Web 在线演示（系列三）。

六、引用#

如在研究中使用本数据集，请引用以下论文：

周毛克,才让先木,龙从军,等.基于卷积神经网络的藏文手写数字和字母识别研究[J].青海师范大学学报(自然科学版),2019,35(04):34-39.DOI:10.16229/j.cnki.issn1001-7542.2019.04.006.

1
@article{zhou2019tibetan,
2
  title   = {基于卷积神经网络的藏文手写数字和字母识别研究},
3
  author  = {周毛克 and 才让先木 and 龙从军 and others},
4
  journal = {青海师范大学学报(自然科学版)},
5
  volume  = {35},
6
  number  = {04},
7
  pages   = {34--39},
8
  year    = {2019},
9
  doi     = {10.16229/j.cnki.issn1001-7542.2019.04.006}
10
}

TibetanHWR 系列二：图像预处理——从红格纸扫描图到单字母图像

Tue, 14 Apr 2026 00:00:00 GMT

项目资源
📊 数据集：百度网盘（提取码：4ata）
💻 项目代码：cairangxianmu/tibetan-hwr
🌐 Web 演示：cairangxianmu-tibetan-hwr.hf.space
📄 论文：DOI 10.16229/j.cnki.issn1001-7542.2019.04.006

一、项目概述#

手写藏文字母识别是一项具有民族特色的任务，藏文字母笔画复杂、书写风格多样，目前没有相关公开数据集。本项目是藏文字母识别系统的图像预处理模块，负责将志愿者手写并扫描的表格型文字图像自动处理为可供模型训练的单字母图像。

表格采用红色框线划分格子，每个格子内手写一个藏文字母。图像预处理需要完成以下工作：提取红色框线定位表格区域、矫正扫描时产生的倾斜偏差、按格子裁剪并批量保存各字母图像，最终消除残余的红色噪声。

项目构成：

main.py：主流程，读取扫描图像，依次执行颜色提取、滤波、直线检测、轮廓定位、旋转矫正、裁剪保存
replace.py：后处理，逐像素替换残余红色框线为白色背景

二、依赖安装#

Terminal window

1
pip install numpy opencv-python pillow

三、图像处理流程#

原始图像如下，为带有红色格线的手写表格：

原始图像

1. HSV 颜色提取#

separate_color_red 函数提取图像中的红色框线。将图像从 BGR 转换为 HSV 色彩空间后，通过 cv2.inRange 指定颜色范围进行掩膜提取。

HSV 颜色范围参考：点击查看各颜色 HSV 分量范围

函数说明：cv2.inRange(hsv, lowerb, upperb)

参数	说明
`hsv`	输入图像，需先转换为 HSV 格式
`lowerb`	H、S、V 分量的最低值
`upperb`	H、S、V 分量的最高值

1
hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)  # 转换为 HSV 色彩空间
2
lower_hsv = np.array([0, 43, 46])            # 红色 HSV 下界
3
high_hsv  = np.array([10, 255, 255])         # 红色 HSV 上界
4
mask = cv2.inRange(hsv, lowerb=lower_hsv, upperb=high_hsv)

提取效果：

HSV 颜色提取结果

2. 中值滤波#

medianBlur 用于过滤掉除最外层框线以外的噪声线条，保留主体轮廓。

函数说明：cv2.medianBlur(img, ksize)

参数	说明
`img`	输入图像
`ksize`	滤波核大小，必须为大于 1 的奇数（如 3、5、7、19）

1
mediu = cv2.medianBlur(img, 19)

滤波效果：

中值滤波结果

3. 概率霍夫直线检测#

调用 HoughLinesP 前需先执行 Canny 边缘检测，将图像二值化。

cv2.Canny(img, threshold1, threshold2)

参数	说明
`threshold1`	低阈值，用于连接间断边缘
`threshold2`	高阈值，用于检测明显边缘

cv2.HoughLinesP(img, rho, theta, threshold, lines, minLineLength, maxLineGap)

参数	说明
`img`	输入图像，须为 Canny 边缘检测后的二值图
`rho`	直线半径精度，建议设为 1
`theta`	角度步长，通常为 `np.pi / 180`
`threshold`	累加器阈值
`minLineLength`	最短直线长度，短于此值的直线被忽略
`maxLineGap`	同一直线上点的最大间隔，超过则视为两条线

1
img_canny = cv2.Canny(img, 20, 250)
2
lines = cv2.HoughLinesP(
3
    img_canny, 1, np.pi / 180, 120,
4
    lines=4, minLineLength=50, maxLineGap=150
5
)
6
lines1 = lines[:, 0, :]  # 降维处理
7
for x1, y1, x2, y2 in lines1:
8
    cv2.line(img, (x1, y1), (x2, y2), (255, 255, 255), 2)

4. 轮廓检测#

findContours 用于检测最外层矩形框，并获取其偏转角度，供后续旋转矫正使用。

cv2.findContours(img, mode, method)

参数	可选值	说明
`mode`	`cv2.RETR_EXTERNAL`	只检测最外层轮廓
	`cv2.RETR_LIST`	检测所有轮廓，不建立层级关系
	`cv2.RETR_CCOMP`	建立两层轮廓（外边界 + 内孔）
	`cv2.RETR_TREE`	建立完整层级树
`method`	`cv2.CHAIN_APPROX_NONE`	存储所有轮廓点
	`cv2.CHAIN_APPROX_SIMPLE`	只保留方向端点，压缩冗余点

1
image, contours, hier = cv2.findContours(
2
    img, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE
3
)
4
for c in contours:
5
    rect  = cv2.minAreaRect(c)   # 最小外接矩形
6
    box_  = cv2.boxPoints(rect)
7
    h = abs(box_[3, 1] - box_[1, 1])
8
    w = abs(box_[3, 0] - box_[1, 0])
9

10
    # 过滤掉不符合尺寸的轮廓
11
    if h > 3000 or w > 2200:
12
        continue
13
    if h < 2500 or w < 1500:
14
        continue
15

16
    box   = np.int0(cv2.boxPoints(rect))
17
    angle = rect[2]
18

19
    # 角度归一化到 [0, 45] 范围
20
    if abs(angle) > 45:
21
        angle = 90 - abs(angle)

展开收起

5. 旋转矫正#

将倾斜的图像旋转至水平方向。

cv2.getRotationMatrix2D(center, angle, scale)

参数	说明
`center`	旋转基点（通常为图像中心）
`angle`	旋转角度
`scale`	缩放因子，1 表示不缩放

cv2.warpAffine(img, M, dsize)

参数	说明
`M`	由 `getRotationMatrix2D` 得到的变换矩阵
`dsize`	输出图像尺寸 `(width, height)`

1
(h, w) = img.shape[:2]
2
center = (w // 2, h // 2)
3
M = cv2.getRotationMatrix2D(center, angle, 1)
4
rotated = cv2.warpAffine(img, M, (w, h))

矫正效果：

旋转矫正结果

6. 图像裁剪#

沿外层矩形框裁剪：

沿边框裁剪

1
# 利用轮廓坐标裁剪
2
x1, y1 = box[1]
3
x2, y2 = box[3]
4
img_cut = img[y1 + 10:y2 - 10, x1 + 10:x2 - 10]

按格子裁剪并批量保存：

1
# 数组切片裁剪（需用 cv2.imread 加载图像）
2
img[y1:y2, x1:x2]

裁剪效果：

按格子裁剪结果

7. 消除多余红色框线#

使用 PIL 逐像素替换，将红色像素替换为白色。

注意：此操作须使用 Image.open() 加载图像，而非 cv2.imread()。

1
from PIL import Image
2

3
img2 = Image.open(path)
4
img2 = img2.convert('RGBA')
5
pixdata = img2.load()
6

7
for y in range(img2.size[1]):
8
    for x in range(img2.size[0]):
9
        if pixdata[x, y][0] > 220:  # 判断为红色像素
10
            pixdata[x, y] = (255, 255, 255, 255)  # 替换为白色
11

12
img2 = img2.convert('RGB')
13
img2.save(path)

处理效果：

消除多余框线结果

四、完整代码#

1. main.py#

1
import cv2
2
import numpy as np
3
import os
4
import replace
5

6

7
def separate_color_red(img):
8
    """提取图像中的红色区域（HSV 颜色提取）"""
9
    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
10
    lower_hsv = np.array([0, 43, 46])
11
    high_hsv  = np.array([10, 255, 255])
12
    mask = cv2.inRange(hsv, lowerb=lower_hsv, upperb=high_hsv)
13
    print("颜色提取完成")
14
    return mask
15

16

17
def salt(img, n):
18
    """椒盐噪声滤波"""
19
    for k in range(n):
20
        i = int(np.random.random() * img.shape[1])
21
        j = int(np.random.random() * img.shape[0])
22
        if img.ndim == 2:
23
            img[j, i] = 255
24
        elif img.ndim == 3:
25
            img[j, i, 0] = 255
26
            img[j, i, 1] = 255
27
            img[j, i, 2] = 255
28
    return img
29

30

31
def cut(img, box, label, save_path):
32
    """按格子裁剪并保存图像"""
33
    x1, y1 = box[1]
34
    x2, y2 = box[3]
35
    img_cut = img[y1 + 10:y2 - 10, x1 + 10:x2 - 10]
36

37
    row = 8   # 行数
38
    col = 12  # 列数
39
    h, w = img_cut.shape[:2]
40
    cell_h = h // row
41
    cell_w = w // col
42

43
    os.makedirs(save_path, exist_ok=True)
44
    for r in range(row):
45
        for c in range(col):
46
            cell = img_cut[r * cell_h:(r + 1) * cell_h,
47
                           c * cell_w:(c + 1) * cell_w]
48
            filename = os.path.join(save_path, f"{label}_{r}_{c}.png")
49
            cv2.imwrite(filename, cell)
50
            replace.replace_red(filename)
51

52

53
def process(img_path, label, save_path):
54
    img = cv2.imread(img_path)
55
    # 1. 颜色提取
56
    mask = separate_color_red(img)
57
    # 2. 中值滤波
58
    mediu = cv2.medianBlur(mask, 19)
59
    # 3. 霍夫直线检测
60
    img_canny = cv2.Canny(mediu, 20, 250)
61
    lines = cv2.HoughLinesP(img_canny, 1, np.pi / 180, 120,
62
                            lines=4, minLineLength=50, maxLineGap=150)
63
    if lines is None:
64
        print(f"[警告] 未检测到直线：{img_path}")
65
        return
66
    lines1 = lines[:, 0, :]
67
    for x1, y1, x2, y2 in lines1:
68
        cv2.line(mediu, (x1, y1), (x2, y2), (255, 255, 255), 2)
69
    # 4. 轮廓检测
70
    _, contours, _ = cv2.findContours(
71
        mediu, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
72
    for c in contours:
73
        rect  = cv2.minAreaRect(c)
74
        box_  = cv2.boxPoints(rect)
75
        h = abs(box_[3, 1] - box_[1, 1])
76
        w = abs(box_[3, 0] - box_[1, 0])
77
        if h > 3000 or w > 2200:
78
            continue
79
        if h < 2500 or w < 1500:
80
            continue
81
        box   = np.int0(cv2.boxPoints(rect))
82
        angle = rect[2]
83
        if abs(angle) > 45:
84
            angle = 90 - abs(angle)
85
        # 5. 旋转矫正
86
        (ih, iw) = img.shape[:2]
87
        center = (iw // 2, ih // 2)
88
        M = cv2.getRotationMatrix2D(center, angle, 1)
89
        rotated = cv2.warpAffine(img, M, (iw, ih))
90
        # 6. 裁剪并保存
91
        cut(rotated, box, label, save_path)
92

93

94
if __name__ == "__main__":
95
    import sys
96
    img_path  = sys.argv[1]
97
    label     = sys.argv[2]
98
    save_path = sys.argv[3]
99
    process(img_path, label, save_path)

展开收起

2. replace.py#

1
from PIL import Image
2

3

4
def replace_red(path):
5
    """将图像中的红色像素替换为白色"""
6
    img = Image.open(path).convert('RGBA')
7
    pixdata = img.load()
8
    for y in range(img.size[1]):
9
        for x in range(img.size[0]):
10
            r, g, b, a = pixdata[x, y]
11
            if r > 220 and g < 100 and b < 100:
12
                pixdata[x, y] = (255, 255, 255, 255)
13
    img.convert('RGB').save(path)

五、小结#

通过七步流水线——HSV 颜色提取、中值滤波、霍夫直线检测、轮廓检测、旋转矫正、图像裁剪、红色框线消除——将志愿者手写扫描表格图像自动转化为标准化单字母图像（64×64 灰度图），构成了 TibetanLetter 数据集的基础。这批图像可直接用于卷积神经网络训练，详见系列三：CNN 训练与 Web 部署。