feat: 特殊车牌生成管线 + C++/多进程/色温校正
This commit is contained in:
kirl committed
1 parent
3808b9f035
commit
3101992f51
29 files changed
+2336
-80
No files matched your search
@@ -0,0 +1,24 @@
|
||||
cmake_minimum_required(VERSION 3.16)
|
||||
project(ice_plate_swap LANGUAGES CXX)
|
||||
|
||||
set(CMAKE_CXX_STANDARD 17)
|
||||
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
||||
|
||||
# OpenCV
|
||||
find_package(OpenCV REQUIRED)
|
||||
|
||||
# 源文件
|
||||
add_executable(plate_swap
|
||||
main.cpp
|
||||
plate_swap.cpp
|
||||
plate_swap.hpp
|
||||
)
|
||||
|
||||
target_link_libraries(plate_swap ${OpenCV_LIBS})
|
||||
|
||||
# 优化选项
|
||||
if(MSVC)
|
||||
target_compile_options(plate_swap PRIVATE /O2 /arch:AVX2 /utf-8)
|
||||
else()
|
||||
target_compile_options(plate_swap PRIVATE -O3 -march=native -fopenmp)
|
||||
endif()
|
||||
@@ -0,0 +1,42 @@
|
||||
# C++ 管线编译脚本
|
||||
# 前置条件: Visual Studio 2022 + C++ workload + OpenCV
|
||||
# OpenCV 安装: 下载 https://opencv.org/releases/ 解压到 C:\opencv
|
||||
|
||||
param(
|
||||
[string]$OpenCVDir = "C:\opencv\build"
|
||||
)
|
||||
|
||||
$ErrorActionPreference = "Stop"
|
||||
|
||||
Write-Host "=== ICE C++ Plate Swap 编译 ===" -ForegroundColor Cyan
|
||||
|
||||
# 检查 OpenCV
|
||||
if (-not (Test-Path "$OpenCVDir\OpenCVConfig.cmake")) {
|
||||
Write-Host "[ERROR] OpenCV 未找到: $OpenCVDir" -ForegroundColor Red
|
||||
Write-Host " 请从 https://opencv.org/releases/ 下载 Windows 版"
|
||||
Write-Host " 解压到 C:\opencv 或使用 -OpenCVDir 指定路径"
|
||||
exit 1
|
||||
}
|
||||
|
||||
# 创建 build 目录
|
||||
$buildDir = "build"
|
||||
if (Test-Path $buildDir) { Remove-Item -Recurse -Force $buildDir }
|
||||
New-Item -ItemType Directory $buildDir | Out-Null
|
||||
|
||||
# CMake 配置 (使用 VS 2022 生成器)
|
||||
Write-Host "CMake 配置..."
|
||||
cmake -B $buildDir -G "Visual Studio 17 2022" -A x64 `
|
||||
-DOpenCV_DIR="$OpenCVDir"
|
||||
|
||||
# 编译 Release
|
||||
Write-Host "编译 Release..."
|
||||
cmake --build $buildDir --config Release --parallel
|
||||
|
||||
Write-Host ""
|
||||
Write-Host "=== 编译完成 ===" -ForegroundColor Green
|
||||
Write-Host "可执行文件: $buildDir\Release\plate_swap.exe"
|
||||
|
||||
# 使用示例
|
||||
Write-Host ""
|
||||
Write-Host "用法示例:"
|
||||
Write-Host " .\build\Release\plate_swap.exe --ccpd-dir ./CCPD/CCPD2019/ccpd_base --plate-type police --plate-pool ./output/plate_pool --num 500 --workers 32 --fast"
|
||||
@@ -0,0 +1,123 @@
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
预生成合成车牌池 (供 C++ 管线使用)
|
||||
===================================
|
||||
为每种特殊车牌类型批量生成纯车牌图，C++ 运行时直接读内存池，
|
||||
避免每张 CCPD 原图都重新渲染车牌。
|
||||
|
||||
用法:
|
||||
python gen_plate_pool.py --num 5000 --output ./output/plate_pool
|
||||
|
||||
输出目录结构:
|
||||
plate_pool/
|
||||
yellow/ 教练车牌 (440x140)
|
||||
green_truck/ 新能源车牌 (480x140)
|
||||
white/ 警车车牌
|
||||
white_army/ 军车车牌
|
||||
black/ 港澳/领馆车牌
|
||||
black_shi/ 使馆车牌
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
import argparse
|
||||
from pathlib import Path
|
||||
|
||||
import cv2
|
||||
import numpy as np
|
||||
from tqdm import tqdm
|
||||
|
||||
# 路径
|
||||
_SCRIPT_DIR = Path(__file__).resolve().parent
|
||||
_PROJECT_DIR = _SCRIPT_DIR.parent.parent
|
||||
_GENERATOR_DIR = _PROJECT_DIR / 'chinese_license_plate_generator'
|
||||
sys.path.insert(0, str(_GENERATOR_DIR))
|
||||
|
||||
from generate_multi_plate import MultiPlateGenerator
|
||||
from plate_number import (
|
||||
generate_plate_number_white,
|
||||
generate_plate_number_army,
|
||||
generate_plate_number_black_gangao,
|
||||
generate_plate_number_black_shi_old,
|
||||
generate_plate_number_black_shi_new,
|
||||
generate_plate_number_black_ling_old,
|
||||
generate_plate_number_black_ling_new,
|
||||
generate_plate_number_yellow_xue,
|
||||
generate_plate_number_blue,
|
||||
)
|
||||
|
||||
# 类型配置
|
||||
PLATE_TYPES = [
|
||||
('police', 'white', generate_plate_number_white),
|
||||
('army', 'white_army', generate_plate_number_army),
|
||||
('gangao', 'black', generate_plate_number_black_gangao),
|
||||
('shiguan_old', 'black_shi', generate_plate_number_black_shi_old),
|
||||
('shiguan_new', 'black_shi', generate_plate_number_black_shi_new),
|
||||
('lingguan_old','black', generate_plate_number_black_ling_old),
|
||||
('lingguan_new','black', generate_plate_number_black_ling_new),
|
||||
('coach', 'yellow', generate_plate_number_yellow_xue),
|
||||
('new_energy', 'green_truck', lambda: generate_plate_number_blue(length=8)),
|
||||
]
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description='预生成合成车牌池')
|
||||
parser.add_argument('--num', type=int, default=5000,
|
||||
help='每种类型生成数量 (默认: 5000)')
|
||||
parser.add_argument('--output', type=str, default='./output/plate_pool',
|
||||
help='输出根目录')
|
||||
args = parser.parse_args()
|
||||
|
||||
# 初始化生成器
|
||||
pm = str(_GENERATOR_DIR / 'plate_model')
|
||||
fm = str(_GENERATOR_DIR / 'font_model')
|
||||
gen = MultiPlateGenerator(pm, fm)
|
||||
|
||||
for plate_type, bg_color, num_func in PLATE_TYPES:
|
||||
out_dir = Path(args.output) / bg_color
|
||||
out_dir.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
existing = len(list(out_dir.glob('*.jpg')))
|
||||
if existing >= args.num:
|
||||
print(f"[SKIP] {plate_type:12s} ({bg_color:12s}): 已有 {existing} 张")
|
||||
continue
|
||||
|
||||
need = args.num - existing
|
||||
print(f"[GEN] {plate_type:12s} ({bg_color:12s}): {need} 张...", end=' ', flush=True)
|
||||
|
||||
success = 0
|
||||
pbar = tqdm(total=need, desc=f'{plate_type}', unit='张', leave=False)
|
||||
attempts = 0
|
||||
while success < need and attempts < need * 3:
|
||||
attempts += 1
|
||||
try:
|
||||
number = num_func()
|
||||
plate = gen.generate_plate_special(
|
||||
number, bg_color, is_double=False, enhance=False
|
||||
)
|
||||
# 用 imencode 支持中文文件名
|
||||
fname = f"{number}.jpg"
|
||||
ok, buf = cv2.imencode('.jpg', plate, [cv2.IMWRITE_JPEG_QUALITY, 95])
|
||||
if ok:
|
||||
with open(str(out_dir / fname), 'wb') as f:
|
||||
f.write(buf.tobytes())
|
||||
success += 1
|
||||
pbar.update(1)
|
||||
except Exception:
|
||||
pass
|
||||
pbar.close()
|
||||
print(f"OK ({success} 张)")
|
||||
|
||||
print(f"\n完成! 输出: {args.output}")
|
||||
# 统计
|
||||
for bg_color in ['yellow','green_truck','white','white_army','black','black_shi']:
|
||||
d = Path(args.output) / bg_color
|
||||
count = len(list(d.glob('*.jpg'))) if d.is_dir() else 0
|
||||
print(f" {bg_color:15s}: {count} 张")
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
import os
|
||||
os.chdir(str(_PROJECT_DIR))
|
||||
main()
|
||||
@@ -0,0 +1,145 @@
|
||||
# ICE Plate Swap — C++ 高性能特殊车牌替换引擎
|
||||
|
||||
基于 CCPD 真实街景照片，将普通蓝牌替换为 9 种特殊车牌。
|
||||
C++ / OpenCV 实现，32 线程满血，~53 张/秒。
|
||||
|
||||
---
|
||||
|
||||
## 快速开始
|
||||
|
||||
### 1. 环境要求
|
||||
|
||||
| 组件 | 说明 |
|
||||
|------|------|
|
||||
| Windows 10/11 x64 | — |
|
||||
| [Visual Studio 2022 BuildTools](https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2022) | 含 C++ 桌面开发 workload |
|
||||
| [OpenCV 4.10.0](https://github.com/opencv/opencv/releases/tag/4.10.0) | 解压到 `C:\opencv` |
|
||||
|
||||
### 2. 预编译版 (推荐)
|
||||
|
||||
直接下载 `plate_swap.exe`（已通过 Git LFS 管理）：
|
||||
|
||||
```powershell
|
||||
# 设置 OpenCV DLL 路径
|
||||
$env:PATH = "C:\opencv\build\x64\vc16\bin;$env:PATH"
|
||||
|
||||
# 运行
|
||||
.\install\plate_swap.exe --help
|
||||
```
|
||||
|
||||
### 3. 从源码编译
|
||||
|
||||
```powershell
|
||||
# 打开 VS Developer Command Prompt
|
||||
# 然后:
|
||||
cd CCPD_SPE_GEN\cpp_pipeline
|
||||
cmake -B build -G "Visual Studio 17 2022" -A x64 -DOpenCV_DIR=C:\opencv\build
|
||||
cmake --build build --config Release --parallel
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 用法
|
||||
|
||||
```powershell
|
||||
$env:PATH = "C:\opencv\build\x64\vc16\bin;$env:PATH"
|
||||
|
||||
.\plate_swap.exe `
|
||||
--ccpd-dir ./CCPD/CCPD2019/ccpd_base,./CCPD/CCPD2019/ccpd_tilt `
|
||||
--plate-type police `
|
||||
--plate-pool ./output/plate_pool_v2 `
|
||||
--output ./CCPD_SPE `
|
||||
--num 1000 `
|
||||
--workers 24
|
||||
```
|
||||
|
||||
### 参数
|
||||
|
||||
| 参数 | 必需 | 默认 | 说明 |
|
||||
|------|------|------|------|
|
||||
| `--ccpd-dir` | ✅ | — | CCPD 图片目录，多个用逗号分隔 |
|
||||
| `--plate-type` | ✅ | — | 特殊车牌类型 |
|
||||
| `--plate-pool` | ✅ | — | 预生成车牌池路径（含 `pool.bin`） |
|
||||
| `--output` | ✅ | — | 输出根目录 |
|
||||
| `--num` | | 500 | 生成图片数量 |
|
||||
| `--workers` | | 全部核心 | 并行线程数 |
|
||||
| `--seed` | | 42 | 随机种子 |
|
||||
| `--fast` | | false | 快速模式（跳过退化模拟，不建议） |
|
||||
| `--h-shift` | | 0 | 底板色相偏移 (GUI调色) |
|
||||
| `--s-scale` | | 100 | 底板饱和度缩放% |
|
||||
| `--v-scale` | | 100 | 底板明度缩放% |
|
||||
|
||||
### 支持的类型
|
||||
|
||||
```
|
||||
police 警用车牌 (白底, JING)
|
||||
army 军车/武警 (白底)
|
||||
gangao 港澳入出境 (黑底, GANG/AO)
|
||||
shiguan_old 使馆旧版 (黑底, SHI)
|
||||
shiguan_new 使馆新版 (黑底)
|
||||
lingguan_old 领馆旧版 (黑底, LING)
|
||||
lingguan_new 领馆新版 (黑底)
|
||||
coach 教练车 (黄底, XUE)
|
||||
new_energy 大型新能源 (黄绿双拼, 8位)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 预生成车牌池
|
||||
|
||||
```powershell
|
||||
cd ICE_Dataset
|
||||
python CCPD_SPE_GEN\cpp_pipeline\gen_plate_pool.py --num 1000 --output ./output/plate_pool_v2
|
||||
```
|
||||
|
||||
生成 `pool.bin` (~1.6GB)，含 9 种类型各 1000 张 + 车牌号元数据。
|
||||
|
||||
---
|
||||
|
||||
## 输出结构
|
||||
|
||||
```
|
||||
CCPD_SPE/
|
||||
├── ccpd_base/
|
||||
│ ├── police/
|
||||
│ ├── gangao/
|
||||
│ └── ...
|
||||
├── ccpd_tilt/
|
||||
└── ...
|
||||
```
|
||||
|
||||
文件名: `{CCPD原名}__{类型}__{车牌号拼音}.jpg`
|
||||
|
||||
---
|
||||
|
||||
## 性能
|
||||
|
||||
| 指标 | 值 |
|
||||
|------|-----|
|
||||
| 单线程 | ~7 张/秒 |
|
||||
| 24 线程 | ~53 张/秒 |
|
||||
| 35.5 万张全量 | ~1.9 小时 |
|
||||
|
||||
---
|
||||
|
||||
## 调色 GUI
|
||||
|
||||
```powershell
|
||||
python CCPD_SPE_GEN\cv_pipeline\color_tuner.py
|
||||
```
|
||||
|
||||
H/S/V 滑块实时预览 → 按 `S` 保存 → `plate_color_profile.py` → C++ 管线 `--h-shift` `--s-scale` `--v-scale` 读取。
|
||||
|
||||
---
|
||||
|
||||
## 构建
|
||||
|
||||
```powershell
|
||||
# 安装 OpenCV
|
||||
Invoke-WebRequest "https://github.com/opencv/opencv/releases/download/4.10.0/opencv-4.10.0-windows.exe" -OutFile "$env:TEMP\opencv.exe"
|
||||
Start-Process "$env:TEMP\opencv.exe" -Args "-oC:\opencv -y" -Wait
|
||||
|
||||
# 编译
|
||||
cd CCPD_SPE_GEN\cpp_pipeline
|
||||
.\build.ps1
|
||||
```
|
||||
Binary file not shown.
@@ -0,0 +1,203 @@
|
||||
#include "plate_swap.hpp"
|
||||
#include <iostream>
|
||||
#include <thread>
|
||||
#include <mutex>
|
||||
#include <atomic>
|
||||
#include <chrono>
|
||||
#include <filesystem>
|
||||
|
||||
namespace fs = std::filesystem;
|
||||
using namespace std;
|
||||
using namespace ice;
|
||||
|
||||
// ── 配置 ──
|
||||
struct Config {
|
||||
vector<string> ccpd_dirs;
|
||||
string plate_type;
|
||||
string output_dir;
|
||||
string plate_pool_dir;
|
||||
int num_images = 500;
|
||||
unsigned workers = thread::hardware_concurrency();
|
||||
bool fast = false;
|
||||
int seed = 42;
|
||||
int h_shift = 0, s_scale = 100, v_scale = 100;
|
||||
};
|
||||
|
||||
// ── 参数解析 ──
|
||||
Config parse_args(int argc, char* argv[]) {
|
||||
Config cfg;
|
||||
cfg.workers = thread::hardware_concurrency();
|
||||
|
||||
for (int i = 1; i < argc; i++) {
|
||||
string arg = argv[i];
|
||||
if (arg == "--ccpd-dir" && i+1 < argc) {
|
||||
string dirs = argv[++i];
|
||||
size_t pos = 0;
|
||||
while (pos < dirs.size()) {
|
||||
size_t comma = dirs.find(',', pos);
|
||||
string d = (comma == string::npos) ? dirs.substr(pos) : dirs.substr(pos, comma-pos);
|
||||
// trim
|
||||
while (!d.empty() && d.front() == ' ') d.erase(0,1);
|
||||
while (!d.empty() && d.back() == ' ') d.pop_back();
|
||||
if (!d.empty()) cfg.ccpd_dirs.push_back(d);
|
||||
if (comma == string::npos) break;
|
||||
pos = comma + 1;
|
||||
}
|
||||
}
|
||||
else if (arg == "--plate-type" && i+1 < argc) cfg.plate_type = argv[++i];
|
||||
else if (arg == "--output" && i+1 < argc) cfg.output_dir = argv[++i];
|
||||
else if (arg == "--plate-pool" && i+1 < argc) cfg.plate_pool_dir = argv[++i];
|
||||
else if (arg == "--num" && i+1 < argc) cfg.num_images = stoi(argv[++i]);
|
||||
else if (arg == "--workers" && i+1 < argc) cfg.workers = stoi(argv[++i]);
|
||||
else if (arg == "--seed" && i+1 < argc) cfg.seed = stoi(argv[++i]);
|
||||
else if (arg == "--fast") cfg.fast = true;
|
||||
else if (arg == "--h-shift" && i+1 < argc) cfg.h_shift = stoi(argv[++i]);
|
||||
else if (arg == "--s-scale" && i+1 < argc) cfg.s_scale = stoi(argv[++i]);
|
||||
else if (arg == "--v-scale" && i+1 < argc) cfg.v_scale = stoi(argv[++i]);
|
||||
}
|
||||
|
||||
return cfg;
|
||||
}
|
||||
|
||||
// ── 收集并预解析 CCPD 图片（过滤无效，预存角点） ──
|
||||
struct IndexedImage {
|
||||
string path;
|
||||
CCPDMeta meta;
|
||||
};
|
||||
|
||||
vector<IndexedImage> collect_and_index(const vector<string>& dirs, mt19937& rng) {
|
||||
vector<IndexedImage> result;
|
||||
for (auto& d : dirs) {
|
||||
error_code ec;
|
||||
if (!fs::is_directory(d, ec)) {
|
||||
cerr << "[WARN] Dir not found: " << d << endl;
|
||||
continue;
|
||||
}
|
||||
for (auto& entry : fs::directory_iterator(d, ec)) {
|
||||
if (ec) break;
|
||||
if (!entry.is_regular_file()) continue;
|
||||
string ext = entry.path().extension().string();
|
||||
for (auto& c : ext) c = (char)tolower(c);
|
||||
if (ext != ".jpg" && ext != ".jpeg" && ext != ".png") continue;
|
||||
|
||||
string fname = entry.path().filename().string();
|
||||
CCPDMeta meta = parse_ccpd_filename(fname);
|
||||
if (!meta.valid) continue;
|
||||
|
||||
IndexedImage ii;
|
||||
ii.path = entry.path().string();
|
||||
ii.meta = meta;
|
||||
result.push_back(ii);
|
||||
}
|
||||
}
|
||||
shuffle(result.begin(), result.end(), rng);
|
||||
return result;
|
||||
}
|
||||
|
||||
// ── 主函数 ──
|
||||
int main(int argc, char* argv[]) {
|
||||
Config cfg = parse_args(argc, argv);
|
||||
|
||||
if (cfg.ccpd_dirs.empty() || cfg.plate_type.empty()) {
|
||||
cerr << "Usage: plate_swap --ccpd-dir <dirs> --plate-type <type> [options]" << endl;
|
||||
cerr << " --plate-pool <dir> Plate pool directory (required)" << endl;
|
||||
cerr << " --num <N> Number of images (default 500)" << endl;
|
||||
cerr << " --workers <N> Thread count (default all cores)" << endl;
|
||||
cerr << " --fast Fast mode (skip degradation)" << endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
cout << "=== ICE C++ Plate Swap ===" << endl;
|
||||
cout << "Type: " << cfg.plate_type << endl;
|
||||
cout << "Threads: " << cfg.workers << endl;
|
||||
cout << "Target: " << cfg.num_images << " images" << endl;
|
||||
cout << "Fast: " << (cfg.fast ? "yes" : "no") << endl;
|
||||
|
||||
if (cfg.plate_pool_dir.empty()) {
|
||||
cerr << "[ERROR] --plate-pool is required" << endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Load plate pool
|
||||
auto t0 = chrono::steady_clock::now();
|
||||
cout << "Loading plate pool..." << flush;
|
||||
PlatePool pool;
|
||||
string bin_path = cfg.plate_pool_dir + "/pool.bin";
|
||||
if (fs::exists(bin_path))
|
||||
pool.load_bin(bin_path);
|
||||
else
|
||||
pool.load(cfg.plate_pool_dir);
|
||||
size_t pool_count = pool.count(cfg.plate_type);
|
||||
auto t1 = chrono::steady_clock::now();
|
||||
cout << " (" << pool_count << " available, "
|
||||
<< chrono::duration<double>(t1-t0).count() << "s)" << endl;
|
||||
if (pool_count == 0) {
|
||||
cerr << "[ERROR] No plates of type " << cfg.plate_type << " in pool" << endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
// Collect & pre-parse CCPD (filter invalid, store corners)
|
||||
mt19937 rng(cfg.seed);
|
||||
cout << "Scanning & indexing CCPD..." << flush;
|
||||
vector<IndexedImage> images = collect_and_index(cfg.ccpd_dirs, rng);
|
||||
auto t2 = chrono::steady_clock::now();
|
||||
cout << " (" << images.size() << " valid, "
|
||||
<< chrono::duration<double>(t2-t1).count() << "s)" << endl;
|
||||
if (images.empty()) {
|
||||
cerr << "[ERROR] No valid CCPD images found" << endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
fs::create_directories(cfg.output_dir);
|
||||
|
||||
SwapConfig swap_cfg;
|
||||
swap_cfg.plate_type = cfg.plate_type;
|
||||
swap_cfg.output_dir = cfg.output_dir;
|
||||
swap_cfg.fast_mode = cfg.fast;
|
||||
swap_cfg.h_shift = cfg.h_shift;
|
||||
swap_cfg.s_scale = cfg.s_scale;
|
||||
swap_cfg.v_scale = cfg.v_scale;
|
||||
|
||||
// Parallel processing with pre-parsed metadata
|
||||
atomic<int> success{0}, failed{0};
|
||||
atomic<int> idx{0};
|
||||
int total = min((int)images.size(), cfg.num_images);
|
||||
mutex cout_mtx;
|
||||
|
||||
auto t_proc = chrono::steady_clock::now();
|
||||
|
||||
vector<thread> threads;
|
||||
for (unsigned t = 0; t < cfg.workers; t++) {
|
||||
threads.emplace_back([&](unsigned seed_offset) {
|
||||
mt19937 local_rng(cfg.seed + seed_offset * 10007);
|
||||
|
||||
while (true) {
|
||||
int i = idx.fetch_add(1);
|
||||
if (i >= total) break;
|
||||
|
||||
bool ok = process_single(images[i].path, swap_cfg, pool,
|
||||
local_rng, &images[i].meta);
|
||||
if (ok) {
|
||||
int s = success.fetch_add(1) + 1;
|
||||
if (s % 100 == 0 || s == total) {
|
||||
lock_guard<mutex> lk(cout_mtx);
|
||||
cout << "\rProgress: " << s << "/" << total << flush;
|
||||
}
|
||||
} else {
|
||||
failed.fetch_add(1);
|
||||
}
|
||||
}
|
||||
}, t);
|
||||
}
|
||||
|
||||
for (auto& th : threads) th.join();
|
||||
|
||||
auto t_done = chrono::steady_clock::now();
|
||||
double elapsed = chrono::duration<double>(t_done - t_proc).count();
|
||||
|
||||
cout << "\rDone! Success: " << success << ", Failed: " << failed << endl;
|
||||
cout << "Process time: " << elapsed << "s (" << (success/max(elapsed,0.01)) << " img/s)" << endl;
|
||||
cout << "Output: " << cfg.output_dir << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,692 @@
|
||||
#include "plate_swap.hpp"
|
||||
#include <fstream>
|
||||
#include <algorithm>
|
||||
#include <numeric>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include <filesystem>
|
||||
|
||||
namespace fs = std::filesystem;
|
||||
using namespace cv;
|
||||
using namespace std;
|
||||
|
||||
namespace ice {
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// CCPD 文件名解析
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
CCPDMeta parse_ccpd_filename(const string& filename) {
|
||||
CCPDMeta meta;
|
||||
meta.valid = false;
|
||||
|
||||
// 提取不带扩展名的部分
|
||||
fs::path p(filename);
|
||||
string stem = p.stem().string();
|
||||
|
||||
// 按 '-' 分割
|
||||
vector<string> parts;
|
||||
size_t pos = 0;
|
||||
while (pos < stem.size()) {
|
||||
size_t dash = stem.find('-', pos);
|
||||
if (dash == string::npos) {
|
||||
parts.push_back(stem.substr(pos));
|
||||
break;
|
||||
}
|
||||
parts.push_back(stem.substr(pos, dash - pos));
|
||||
pos = dash + 1;
|
||||
}
|
||||
|
||||
if (parts.size() < 5) return meta;
|
||||
|
||||
try {
|
||||
// parts[3] = 4角点
|
||||
string& coords = parts[3];
|
||||
vector<Point2f> pts;
|
||||
size_t start = 0;
|
||||
while (start < coords.size()) {
|
||||
size_t us = coords.find('_', start);
|
||||
string pt = (us == string::npos) ? coords.substr(start) : coords.substr(start, us - start);
|
||||
size_t amp = pt.find('&');
|
||||
if (amp == string::npos) break;
|
||||
float x = stof(pt.substr(0, amp));
|
||||
float y = stof(pt.substr(amp + 1));
|
||||
pts.push_back({x, y});
|
||||
if (us == string::npos) break;
|
||||
start = us + 1;
|
||||
}
|
||||
|
||||
if (pts.size() != 4) return meta;
|
||||
|
||||
// 几何排序: TL=min(x+y), TR=max(x-y), BR=max(x+y), BL=min(x-y)
|
||||
float sums[4], diffs[4];
|
||||
for (int i = 0; i < 4; i++) {
|
||||
sums[i] = pts[i].x + pts[i].y;
|
||||
diffs[i] = pts[i].x - pts[i].y;
|
||||
}
|
||||
int tl = (int)(min_element(sums, sums+4) - sums);
|
||||
int tr = (int)(max_element(diffs, diffs+4) - diffs);
|
||||
int br = (int)(max_element(sums, sums+4) - sums);
|
||||
int bl = (int)(min_element(diffs, diffs+4) - diffs);
|
||||
|
||||
meta.corners[0] = pts[tl];
|
||||
meta.corners[1] = pts[tr];
|
||||
meta.corners[2] = pts[br];
|
||||
meta.corners[3] = pts[bl];
|
||||
meta.valid = true;
|
||||
} catch (...) {
|
||||
meta.valid = false;
|
||||
}
|
||||
|
||||
return meta;
|
||||
}
|
||||
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// 合成车牌池
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
void PlatePool::load(const string& dir) {
|
||||
// Fallback: load from directory
|
||||
for (auto& entry : fs::directory_iterator(dir)) {
|
||||
if (!entry.is_directory()) continue;
|
||||
string bg_color = entry.path().filename().string();
|
||||
vector<PlateEntry>& vec = pools_[bg_color];
|
||||
|
||||
for (auto& f : fs::directory_iterator(entry.path())) {
|
||||
if (!f.is_regular_file()) continue;
|
||||
string ext = f.path().extension().string();
|
||||
if (ext != ".jpg" && ext != ".png" && ext != ".PNG") continue;
|
||||
|
||||
Mat img = imread_unicode(f.path().string());
|
||||
if (img.empty()) continue;
|
||||
|
||||
PlateEntry pe;
|
||||
pe.image = img;
|
||||
vec.push_back(pe);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void PlatePool::load_bin(const string& bin_path) {
|
||||
ifstream f(bin_path, ios::binary);
|
||||
if (!f) { cerr << "[WARN] pool.bin not found" << endl; return; }
|
||||
|
||||
char magic[4];
|
||||
f.read(magic, 4);
|
||||
if (memcmp(magic, "IPPL", 4) != 0) { cerr << "[WARN] bad magic" << endl; return; }
|
||||
|
||||
uint32_t num_types;
|
||||
f.read((char*)&num_types, 4);
|
||||
|
||||
for (uint32_t ti = 0; ti < num_types; ti++) {
|
||||
uint32_t name_len;
|
||||
f.read((char*)&name_len, 4);
|
||||
string plate_type(name_len, 0);
|
||||
f.read(&plate_type[0], name_len);
|
||||
|
||||
uint32_t count;
|
||||
f.read((char*)&count, 4);
|
||||
|
||||
vector<PlateEntry>& vec = pools_[plate_type];
|
||||
vec.reserve(count);
|
||||
|
||||
for (uint32_t pi = 0; pi < count; pi++) {
|
||||
uint32_t w, h, data_len;
|
||||
f.read((char*)&w, 4);
|
||||
f.read((char*)&h, 4);
|
||||
f.read((char*)&data_len, 4);
|
||||
|
||||
vector<uint8_t> buf(data_len);
|
||||
f.read((char*)buf.data(), data_len);
|
||||
|
||||
PlateEntry pe;
|
||||
pe.image = Mat(h, w, CV_8UC3, buf.data()).clone();
|
||||
|
||||
// Read plate number metadata
|
||||
uint32_t num_len;
|
||||
f.read((char*)&num_len, 4);
|
||||
pe.plate_number.resize(num_len);
|
||||
f.read(&pe.plate_number[0], num_len);
|
||||
|
||||
vec.push_back(pe);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const PlateEntry& PlatePool::random(const string& plate_type, mt19937& rng) {
|
||||
auto& vec = pools_[plate_type];
|
||||
if (vec.empty()) {
|
||||
for (auto& [k, v] : pools_) {
|
||||
if (!v.empty()) {
|
||||
uniform_int_distribution<size_t> dist(0, v.size()-1);
|
||||
return v[dist(rng)];
|
||||
}
|
||||
}
|
||||
throw runtime_error("PlatePool is empty");
|
||||
}
|
||||
uniform_int_distribution<size_t> dist(0, vec.size()-1);
|
||||
return vec[dist(rng)];
|
||||
}
|
||||
|
||||
size_t PlatePool::count(const string& plate_type) const {
|
||||
auto it = pools_.find(plate_type);
|
||||
return (it != pools_.end()) ? it->second.size() : 0;
|
||||
}
|
||||
|
||||
|
||||
// Helper: plate_type → bg_color for color matching
|
||||
static string bg_color_of(const string& plate_type) {
|
||||
if (plate_type == "police") return "white";
|
||||
if (plate_type == "army") return "white_army";
|
||||
if (plate_type == "gangao") return "black";
|
||||
if (plate_type == "shiguan_old" || plate_type == "shiguan_new") return "black_shi";
|
||||
if (plate_type == "lingguan_old" || plate_type == "lingguan_new") return "black";
|
||||
if (plate_type == "coach") return "yellow";
|
||||
if (plate_type == "new_energy") return "green_truck";
|
||||
return "white";
|
||||
}
|
||||
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// Unicode 文件读写
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
Mat imread_unicode(const string& path) {
|
||||
ifstream f(fs::path(path), ios::binary);
|
||||
if (!f) return Mat();
|
||||
vector<uint8_t> data((istreambuf_iterator<char>(f)), istreambuf_iterator<char>());
|
||||
return imdecode(data, IMREAD_COLOR);
|
||||
}
|
||||
|
||||
bool imwrite_unicode(const string& path, const Mat& img, const vector<int>& params) {
|
||||
vector<uint8_t> buf;
|
||||
fs::path p(path);
|
||||
string ext = p.extension().string();
|
||||
if (!imencode(ext, img, buf, params)) return false;
|
||||
// Use fs::path directly for proper Unicode support on Windows
|
||||
ofstream f(p, ios::binary);
|
||||
if (!f) return false;
|
||||
f.write(reinterpret_cast<const char*>(buf.data()), buf.size());
|
||||
return f.good();
|
||||
}
|
||||
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// 透视提取车牌 ROI
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
Mat extract_plate_roi(const Mat& img, const Point2f corners[4],
|
||||
int plate_w, int plate_h) {
|
||||
Point2f dst[4] = {
|
||||
{0, 0},
|
||||
{(float)(plate_w - 1), 0},
|
||||
{(float)(plate_w - 1), (float)(plate_h - 1)},
|
||||
{0, (float)(plate_h - 1)}
|
||||
};
|
||||
Mat M = getPerspectiveTransform(corners, dst);
|
||||
Mat roi;
|
||||
warpPerspective(img, roi, M, Size(plate_w, plate_h),
|
||||
INTER_LINEAR, BORDER_REPLICATE);
|
||||
return roi;
|
||||
}
|
||||
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// 色温匹配
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
Mat match_plate_color(const Mat& synthetic, const Mat& orig_roi,
|
||||
const string& bg_color) {
|
||||
Mat syn, orig;
|
||||
synthetic.convertTo(syn, CV_32F);
|
||||
orig_roi.convertTo(orig, CV_32F);
|
||||
|
||||
// 尺寸对齐
|
||||
if (syn.size() != orig.size())
|
||||
resize(syn, syn, orig.size(), 0, 0, INTER_LINEAR);
|
||||
|
||||
if (bg_color == "black" || bg_color == "black_shi") {
|
||||
Mat orig_gray;
|
||||
cvtColor(orig_roi, orig_gray, COLOR_BGR2GRAY);
|
||||
double thresh_val;
|
||||
{
|
||||
Mat sorted;
|
||||
orig_gray.reshape(1, 1).copyTo(sorted);
|
||||
cv::sort(sorted, sorted, SORT_EVERY_ROW + SORT_ASCENDING);
|
||||
int idx = (int)(sorted.cols * 0.90);
|
||||
thresh_val = sorted.at<uint8_t>(0, idx);
|
||||
}
|
||||
Mat white_mask = orig_gray > thresh_val;
|
||||
if (countNonZero(white_mask) < 50) return synthetic;
|
||||
|
||||
Scalar white_ref = mean(orig, white_mask);
|
||||
float ref_mean = (float)(white_ref[0] + white_ref[1] + white_ref[2]) / 3.0f;
|
||||
if (ref_mean < 10) return synthetic;
|
||||
|
||||
Scalar color_cast(white_ref[0]/ref_mean, white_ref[1]/ref_mean, white_ref[2]/ref_mean);
|
||||
Scalar amplified(1.0f + (color_cast[0]-1.0f), 1.0f+(color_cast[1]-1.0f), 1.0f+(color_cast[2]-1.0f));
|
||||
amplified[0] = std::clamp((double)amplified[0], 0.85, 1.15);
|
||||
amplified[1] = std::clamp((double)amplified[1], 0.85, 1.15);
|
||||
amplified[2] = std::clamp((double)amplified[2], 0.85, 1.15);
|
||||
|
||||
Mat syn_gray;
|
||||
cvtColor(synthetic, syn_gray, COLOR_BGR2GRAY);
|
||||
Mat alpha;
|
||||
syn_gray.convertTo(alpha, CV_32F, 1.0/128.0);
|
||||
alpha = max(0.0f, min(1.0f, alpha));
|
||||
|
||||
Mat result = syn.clone();
|
||||
for (int c = 0; c < 3; c++) {
|
||||
Mat ch_syn, ch_res;
|
||||
extractChannel(syn, ch_syn, c);
|
||||
ch_res = ch_syn.mul(1.0f + ((float)amplified[c] - 1.0f) * alpha);
|
||||
ch_res.setTo(0, ch_res < 0);
|
||||
ch_res.setTo(255, ch_res > 255);
|
||||
insertChannel(ch_res, result, c);
|
||||
}
|
||||
result.convertTo(result, CV_8U);
|
||||
return result;
|
||||
}
|
||||
|
||||
// 亮底牌：提取白参考
|
||||
Mat orig_gray;
|
||||
cvtColor(orig_roi, orig_gray, COLOR_BGR2GRAY);
|
||||
double thresh_val;
|
||||
{
|
||||
Mat sorted;
|
||||
orig_gray.reshape(1, 1).copyTo(sorted);
|
||||
cv::sort(sorted, sorted, SORT_EVERY_ROW + SORT_ASCENDING);
|
||||
int idx = (int)(sorted.cols * 0.90);
|
||||
thresh_val = sorted.at<uint8_t>(0, idx);
|
||||
}
|
||||
Mat white_mask = orig_gray > thresh_val;
|
||||
if (countNonZero(white_mask) < 50) return synthetic;
|
||||
|
||||
Scalar white_ref = mean(orig, white_mask);
|
||||
float ref_mean = (float)(white_ref[0] + white_ref[1] + white_ref[2]) / 3.0f;
|
||||
if (ref_mean < 10) return synthetic;
|
||||
|
||||
if (bg_color == "yellow") {
|
||||
Scalar gain = white_ref / 255.0;
|
||||
gain[0] = std::clamp((float)gain[0], 0.6f, 1.3f);
|
||||
gain[1] = std::clamp((float)gain[1], 0.6f, 1.3f);
|
||||
gain[2] = std::clamp((float)gain[2], 0.6f, 1.3f);
|
||||
Mat res;
|
||||
multiply(syn, gain, res);
|
||||
res.setTo(0, res < 0);
|
||||
res.setTo(255, res > 255);
|
||||
res.convertTo(res, CV_8U);
|
||||
return res;
|
||||
}
|
||||
|
||||
// 白/绿牌
|
||||
Scalar color_cast(white_ref[0]/ref_mean, white_ref[1]/ref_mean, white_ref[2]/ref_mean);
|
||||
float strength = (bg_color == "green_truck") ? 1.5f : 1.0f;
|
||||
Scalar amplified(1.0f + (color_cast[0]-1.0f)*strength, 1.0f+(color_cast[1]-1.0f)*strength, 1.0f+(color_cast[2]-1.0f)*strength);
|
||||
amplified[0] = std::clamp((float)amplified[0], 0.85f, 1.15f);
|
||||
amplified[1] = std::clamp((float)amplified[1], 0.85f, 1.15f);
|
||||
amplified[2] = std::clamp((float)amplified[2], 0.85f, 1.15f);
|
||||
|
||||
Mat syn_gray;
|
||||
cvtColor(synthetic, syn_gray, COLOR_BGR2GRAY);
|
||||
Mat alpha;
|
||||
syn_gray.convertTo(alpha, CV_32F, 1.0/128.0);
|
||||
alpha = max(0.0f, min(1.0f, alpha));
|
||||
|
||||
Mat result = syn.clone();
|
||||
for (int c = 0; c < 3; c++) {
|
||||
Mat ch_syn, ch_res;
|
||||
extractChannel(syn, ch_syn, c);
|
||||
ch_res = ch_syn.mul(1.0f + (amplified[c] - 1.0f) * alpha);
|
||||
ch_res.setTo(0, ch_res < 0);
|
||||
ch_res.setTo(255, ch_res > 255);
|
||||
insertChannel(ch_res, result, c);
|
||||
}
|
||||
result.convertTo(result, CV_8U);
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// 底板色校正
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
Mat fix_bg_color(const Mat& plate, const string& bg_color,
|
||||
int h_shift, int s_scale, int v_scale) {
|
||||
if (h_shift == 0 && s_scale == 100 && v_scale == 100)
|
||||
return plate;
|
||||
|
||||
int h_lo = 0, h_hi = 180;
|
||||
if (bg_color == "yellow") { h_lo = 15; h_hi = 50; }
|
||||
else if (bg_color == "green_truck") { h_lo = 40; h_hi = 85; }
|
||||
|
||||
Mat hsv;
|
||||
cvtColor(plate, hsv, COLOR_BGR2HSV);
|
||||
hsv.convertTo(hsv, CV_32F);
|
||||
|
||||
vector<Mat> ch(3);
|
||||
split(hsv, ch);
|
||||
Mat &H = ch[0], &S = ch[1], &V = ch[2];
|
||||
|
||||
Mat bg_mask = (H > h_lo) & (H < h_hi) & (S > 80) & (V > 100);
|
||||
if (countNonZero(bg_mask) < 200) return plate;
|
||||
|
||||
// 距离变换羽化
|
||||
Mat bg_u8, dist;
|
||||
bg_mask.convertTo(bg_u8, CV_8U, 255);
|
||||
distanceTransform(bg_u8, dist, DIST_L2, DIST_MASK_PRECISE);
|
||||
Mat soft;
|
||||
dist.convertTo(soft, CV_32F, 1.0/4.0);
|
||||
soft = max(0.0f, min(1.0f, soft));
|
||||
|
||||
H = H + h_shift * soft;
|
||||
S = S.mul(1.0f + (s_scale / 100.0f - 1.0f) * soft);
|
||||
V = V.mul(1.0f + (v_scale / 100.0f - 1.0f) * soft);
|
||||
|
||||
H.setTo(0, H < 0); H.setTo(180, H > 180);
|
||||
S.setTo(0, S < 0); S.setTo(255, S > 255);
|
||||
V.setTo(0, V < 0); V.setTo(255, V > 255);
|
||||
|
||||
Mat result;
|
||||
merge(ch, hsv);
|
||||
hsv.convertTo(hsv, CV_8U);
|
||||
cvtColor(hsv, result, COLOR_HSV2BGR);
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// 透视回贴
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
pair<Mat, Mat> warp_plate_back(const Mat& plate, const Point2f dst_corners[4],
|
||||
Size output_size) {
|
||||
int h = plate.rows, w = plate.cols;
|
||||
Point2f src[4] = {
|
||||
{0, 0}, {(float)(w-1), 0}, {(float)(w-1), (float)(h-1)}, {0, (float)(h-1)}
|
||||
};
|
||||
|
||||
Mat M = getPerspectiveTransform(src, dst_corners);
|
||||
Mat warped, mask_warped;
|
||||
warpPerspective(plate, warped, M, output_size, INTER_LINEAR, BORDER_CONSTANT, Scalar(0,0,0));
|
||||
|
||||
Mat mask(h, w, CV_8UC1, Scalar(255));
|
||||
warpPerspective(mask, mask_warped, M, output_size, INTER_LINEAR, BORDER_CONSTANT, Scalar(0));
|
||||
|
||||
return {warped, mask_warped};
|
||||
}
|
||||
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// 羽化贴合
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
Mat feather_blend(const Mat& original, const Mat& warped,
|
||||
const Mat& mask, int edge_width) {
|
||||
Mat mask_u8;
|
||||
mask.convertTo(mask_u8, CV_8U);
|
||||
|
||||
if (countNonZero(mask_u8) < 100) {
|
||||
Mat result = original.clone();
|
||||
warped.copyTo(result, mask_u8);
|
||||
return result;
|
||||
}
|
||||
|
||||
// Fast blend: erode mask slightly for edge transition, no expensive distanceTransform
|
||||
Mat eroded;
|
||||
int ksize = max(3, edge_width) | 1; // ensure odd
|
||||
Mat kernel = getStructuringElement(MORPH_ELLIPSE, Size(ksize, ksize));
|
||||
erode(mask_u8, eroded, kernel);
|
||||
|
||||
Mat alpha;
|
||||
eroded.convertTo(alpha, CV_32F, 1.0/255.0);
|
||||
// Soften edges with a small blur
|
||||
GaussianBlur(alpha, alpha, Size(ksize, ksize), ksize/3.0);
|
||||
|
||||
Mat result(original.size(), CV_32FC3);
|
||||
Mat warped_f, orig_f;
|
||||
warped.convertTo(warped_f, CV_32F);
|
||||
original.convertTo(orig_f, CV_32F);
|
||||
|
||||
for (int c = 0; c < 3; c++) {
|
||||
Mat wc, oc;
|
||||
extractChannel(warped_f, wc, c);
|
||||
extractChannel(orig_f, oc, c);
|
||||
Mat rc = wc.mul(alpha) + oc.mul(1.0f - alpha);
|
||||
rc.setTo(0, rc < 0);
|
||||
rc.setTo(255, rc > 255);
|
||||
insertChannel(rc, result, c);
|
||||
}
|
||||
result.convertTo(result, CV_8U);
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// 噪声匹配
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
Mat match_noise(const Mat& blended, const Mat& original, const Mat& mask) {
|
||||
Mat mask_u8;
|
||||
mask.convertTo(mask_u8, CV_8U);
|
||||
if (countNonZero(mask_u8) < 100) return blended;
|
||||
|
||||
// Crop plate region for noise estimation (like Python's plate_crop)
|
||||
vector<Point> pts;
|
||||
findNonZero(mask_u8, pts);
|
||||
if (pts.size() < 200) return blended;
|
||||
|
||||
int bw = blended.cols, bh = blended.rows;
|
||||
int xmin = bw, xmax = 0, ymin = bh, ymax = 0;
|
||||
for (auto& p : pts) {
|
||||
if (p.x < xmin) xmin = p.x;
|
||||
if (p.x > xmax) xmax = p.x;
|
||||
if (p.y < ymin) ymin = p.y;
|
||||
if (p.y > ymax) ymax = p.y;
|
||||
}
|
||||
int x1 = max(0, xmin - 5), x2 = min(bw, xmax + 5);
|
||||
int y1 = max(0, ymin - 5), y2 = min(bh, ymax + 5);
|
||||
Mat plate_crop = original(Rect(x1, y1, x2-x1, y2-y1));
|
||||
|
||||
// 1) Noise sigma from original plate crop
|
||||
Mat crop_blurred, crop_residual;
|
||||
GaussianBlur(plate_crop, crop_blurred, Size(5,5), 1.0);
|
||||
Mat crop_f32, blur_f32;
|
||||
plate_crop.convertTo(crop_f32, CV_32F);
|
||||
crop_blurred.convertTo(blur_f32, CV_32F);
|
||||
crop_residual = crop_f32 - blur_f32;
|
||||
Scalar stddev;
|
||||
meanStdDev(crop_residual, Scalar(), stddev);
|
||||
float noise_sigma = (float)max(stddev[0], max(stddev[1], max(stddev[2], 1.5)));
|
||||
|
||||
// 2) Blur sigma from original plate crop
|
||||
Mat crop_gray;
|
||||
cvtColor(plate_crop, crop_gray, COLOR_BGR2GRAY);
|
||||
Mat lap;
|
||||
Laplacian(crop_gray, lap, CV_64F);
|
||||
Scalar lap_m, lap_s;
|
||||
meanStdDev(lap, lap_m, lap_s);
|
||||
float lap_var = (float)(lap_s[0] * lap_s[0]);
|
||||
float blur_sigma = 0;
|
||||
if (lap_var < 50) blur_sigma = 2.0f;
|
||||
else if (lap_var < 200) blur_sigma = 1.2f;
|
||||
else if (lap_var < 500) blur_sigma = 0.5f;
|
||||
|
||||
// Apply blur to plate area
|
||||
Mat result = blended.clone();
|
||||
if (blur_sigma > 0.1f) {
|
||||
Mat blurred_full;
|
||||
GaussianBlur(result, blurred_full, Size(0,0), blur_sigma);
|
||||
blurred_full.copyTo(result, mask_u8);
|
||||
}
|
||||
|
||||
// Add noise to plate area only
|
||||
Mat result_f;
|
||||
result.convertTo(result_f, CV_32F);
|
||||
Mat noise(result.size(), CV_32FC3);
|
||||
randn(noise, Scalar(0,0,0), Scalar(noise_sigma, noise_sigma, noise_sigma));
|
||||
Mat noisy = result_f + noise;
|
||||
|
||||
// Alpha blend: noise in plate area, clean outside
|
||||
Mat alpha;
|
||||
mask_u8.convertTo(alpha, CV_32F, 1.0/255.0);
|
||||
Mat alpha_3;
|
||||
merge(vector<Mat>{alpha, alpha, alpha}, alpha_3);
|
||||
Mat one_minus_a;
|
||||
subtract(Scalar::all(1.0), alpha_3, one_minus_a);
|
||||
noisy = noisy.mul(alpha_3) + result_f.mul(one_minus_a);
|
||||
|
||||
// Clip AFTER blend (matching Python np.clip order)
|
||||
noisy.setTo(0, noisy < 0);
|
||||
noisy.setTo(255, noisy > 255);
|
||||
noisy.convertTo(result, CV_8U);
|
||||
return result;
|
||||
}
|
||||
|
||||
Mat degrade_plate(const Mat& plate) {
|
||||
Mat result = plate.clone();
|
||||
|
||||
// JPEG 极限压缩
|
||||
vector<uint8_t> buf;
|
||||
imencode(".jpg", result, buf, {IMWRITE_JPEG_QUALITY, 2});
|
||||
result = imdecode(buf, IMREAD_COLOR);
|
||||
|
||||
// 降采样升采样
|
||||
int w = result.cols, h = result.rows;
|
||||
Mat small;
|
||||
resize(result, small, Size(w/4, h/4), 0, 0, INTER_LINEAR);
|
||||
resize(small, result, Size(w, h), 0, 0, INTER_NEAREST);
|
||||
|
||||
// 模糊
|
||||
GaussianBlur(result, result, Size(5,5), 1.5);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
// 单张处理
|
||||
// ═══════════════════════════════════════════════════════════
|
||||
|
||||
bool process_single(const string& img_path, const SwapConfig& cfg,
|
||||
PlatePool& pool, mt19937& rng, const CCPDMeta* pre_meta) {
|
||||
// 1. 解析文件名 (use pre-parsed if available)
|
||||
fs::path fp(img_path);
|
||||
CCPDMeta meta;
|
||||
if (pre_meta && pre_meta->valid) {
|
||||
meta = *pre_meta;
|
||||
} else {
|
||||
meta = parse_ccpd_filename(fp.filename().string());
|
||||
if (!meta.valid) return false;
|
||||
}
|
||||
|
||||
// 2. 读原图
|
||||
Mat img_orig = imread_unicode(img_path);
|
||||
if (img_orig.empty()) return false;
|
||||
|
||||
int h_img = img_orig.rows, w_img = img_orig.cols;
|
||||
|
||||
// 校验角点
|
||||
for (int i = 0; i < 4; i++) {
|
||||
auto& c = meta.corners[i];
|
||||
if (c.x < 0 || c.y < 0 || c.x > w_img*1.5 || c.y > h_img*1.5)
|
||||
return false;
|
||||
}
|
||||
|
||||
// 3. Pick from pool
|
||||
string bg_color = bg_color_of(cfg.plate_type);
|
||||
const PlateEntry& entry = pool.random(cfg.plate_type, rng);
|
||||
Mat synthetic = entry.image.clone();
|
||||
int plate_w = synthetic.cols, plate_h = synthetic.rows;
|
||||
string plate_number = entry.plate_number;
|
||||
|
||||
// 4. Extract original ROI
|
||||
Mat orig_roi = extract_plate_roi(img_orig, meta.corners, plate_w, plate_h);
|
||||
|
||||
|
||||
// 5. Fix bg color
|
||||
synthetic = fix_bg_color(synthetic, bg_color,
|
||||
cfg.h_shift, cfg.s_scale, cfg.v_scale);
|
||||
|
||||
// 6. Color match
|
||||
Mat matched = match_plate_color(synthetic, orig_roi, bg_color);
|
||||
|
||||
// 7. Brightness match
|
||||
Mat orig_gray, matched_gray;
|
||||
cvtColor(orig_roi, orig_gray, COLOR_BGR2GRAY);
|
||||
cvtColor(matched, matched_gray, COLOR_BGR2GRAY);
|
||||
|
||||
auto p95 = [](const Mat& m) -> float {
|
||||
Mat sorted;
|
||||
m.reshape(1,1).copyTo(sorted);
|
||||
cv::sort(sorted, sorted, SORT_EVERY_ROW + SORT_ASCENDING);
|
||||
return sorted.at<uint8_t>(0, (int)(sorted.cols * 0.95));
|
||||
};
|
||||
float target_w = p95(orig_gray);
|
||||
float current_w = p95(matched_gray);
|
||||
|
||||
if (current_w > 10 && abs(target_w - current_w) > 10) {
|
||||
float l_ratio = target_w / current_w;
|
||||
float min_c = 0.5f, max_c = 1.1f;
|
||||
if (bg_color == "green_truck" || bg_color == "yellow") { min_c = 0.4f; max_c = 1.0f; }
|
||||
else if (bg_color == "black" || bg_color == "black_shi") { min_c = 0.3f; max_c = 1.2f; }
|
||||
l_ratio = std::clamp(l_ratio, min_c, max_c);
|
||||
|
||||
Mat alpha;
|
||||
matched_gray.convertTo(alpha, CV_32F, 1.0/128.0);
|
||||
alpha = max(0.3f, min(1.0f, alpha));
|
||||
|
||||
Mat matched_f;
|
||||
matched.convertTo(matched_f, CV_32F);
|
||||
for (int c = 0; c < 3; c++) {
|
||||
Mat ch;
|
||||
extractChannel(matched_f, ch, c);
|
||||
ch = ch.mul(1.0f + (l_ratio - 1.0f) * alpha);
|
||||
ch.setTo(0, ch < 0); ch.setTo(255, ch > 255);
|
||||
insertChannel(ch, matched_f, c);
|
||||
}
|
||||
matched_f.convertTo(matched, CV_8U);
|
||||
}
|
||||
|
||||
// 8. Degradation
|
||||
if (!cfg.fast_mode)
|
||||
matched = degrade_plate(matched);
|
||||
|
||||
// 9-11. Warp + blend + noise
|
||||
auto [warped, mask] = warp_plate_back(matched, meta.corners, Size(w_img, h_img));
|
||||
Mat blended = feather_blend(img_orig, warped, mask);
|
||||
Mat final = match_noise(blended, img_orig, mask);
|
||||
|
||||
// 12. Save with pinyin tags
|
||||
string stem = fp.stem().string();
|
||||
// Convert Chinese plate markers to ASCII tags
|
||||
string tag = plate_number;
|
||||
// Manual pinyin mapping for common plate characters (UTF-8 byte sequences)
|
||||
// 港=E6B8AF 澳=E6BEB3 警=E8ADA6 使=E4BDBF 领=E9A286 学=E5ADA6
|
||||
struct { const char* utf8; const char* py; } map[] = {
|
||||
{"\xE6\xB8\xAF", "GANG"}, {"\xE6\xBE\xB3", "AO"},
|
||||
{"\xE8\xAD\xA6", "JING"}, {"\xE4\xBD\xBF", "SHI"},
|
||||
{"\xE9\xA2\x86", "LING"}, {"\xE5\xAD\xA6", "XUE"},
|
||||
};
|
||||
for (auto& m : map) {
|
||||
size_t pos = 0;
|
||||
while ((pos = tag.find(m.utf8, pos)) != string::npos) {
|
||||
tag.replace(pos, 3, m.py);
|
||||
pos += strlen(m.py);
|
||||
}
|
||||
}
|
||||
// Remove any remaining non-ASCII
|
||||
string clean;
|
||||
for (char c : tag) {
|
||||
if ((unsigned char)c < 128) clean += c;
|
||||
}
|
||||
string out_name = stem + "__" + cfg.plate_type + "__" + clean + ".jpg";
|
||||
string ccpd_subdir = fp.parent_path().filename().string();
|
||||
fs::path out_dir = fs::path(cfg.output_dir) / ccpd_subdir / cfg.plate_type;
|
||||
fs::create_directories(out_dir);
|
||||
|
||||
return imwrite_unicode((out_dir / out_name).string(), final, {IMWRITE_JPEG_QUALITY, 75});
|
||||
}
|
||||
|
||||
} // namespace ice
|
||||
@@ -0,0 +1,80 @@
|
||||
#pragma once
|
||||
#include <opencv2/opencv.hpp>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <random>
|
||||
#include <unordered_map>
|
||||
|
||||
namespace ice {
|
||||
|
||||
// ── CCPD 角点解析 ──
|
||||
struct CCPDMeta {
|
||||
cv::Point2f corners[4]; // TL, TR, BR, BL
|
||||
bool valid = false;
|
||||
};
|
||||
CCPDMeta parse_ccpd_filename(const std::string& filename);
|
||||
|
||||
// ── 合成车牌池 ──
|
||||
struct PlateEntry {
|
||||
cv::Mat image; // BGR
|
||||
std::string plate_number; // 车牌号 (e.g. "粤Z1234港")
|
||||
};
|
||||
class PlatePool {
|
||||
public:
|
||||
void load(const std::string& dir);
|
||||
void load_bin(const std::string& bin_path);
|
||||
const PlateEntry& random(const std::string& plate_type, std::mt19937& rng);
|
||||
size_t count(const std::string& plate_type) const;
|
||||
private:
|
||||
std::unordered_map<std::string, std::vector<PlateEntry>> pools_;
|
||||
};
|
||||
|
||||
// ── 管线核心 ──
|
||||
struct SwapConfig {
|
||||
std::string plate_type;
|
||||
std::string output_dir;
|
||||
int h_shift = 0, s_scale = 100, v_scale = 100;
|
||||
bool fast_mode = false;
|
||||
};
|
||||
|
||||
// 单张处理 (pre-parsed meta 避免重复解析)
|
||||
bool process_single(const std::string& img_path,
|
||||
const SwapConfig& cfg,
|
||||
PlatePool& pool,
|
||||
std::mt19937& rng,
|
||||
const CCPDMeta* pre_meta = nullptr);
|
||||
|
||||
// 透视提取车牌ROI
|
||||
cv::Mat extract_plate_roi(const cv::Mat& img, const cv::Point2f corners[4],
|
||||
int plate_w, int plate_h);
|
||||
|
||||
// 色温匹配
|
||||
cv::Mat match_plate_color(const cv::Mat& synthetic, const cv::Mat& orig_roi,
|
||||
const std::string& bg_color);
|
||||
|
||||
// 底板色校正
|
||||
cv::Mat fix_bg_color(const cv::Mat& plate, const std::string& bg_color,
|
||||
int h_shift, int s_scale, int v_scale);
|
||||
|
||||
// 透视回贴: 返回 (warped, mask)
|
||||
std::pair<cv::Mat, cv::Mat> warp_plate_back(const cv::Mat& plate,
|
||||
const cv::Point2f dst_corners[4],
|
||||
cv::Size output_size);
|
||||
|
||||
// 羽化贴合
|
||||
cv::Mat feather_blend(const cv::Mat& original, const cv::Mat& warped,
|
||||
const cv::Mat& mask, int edge_width = 8);
|
||||
|
||||
// 噪声匹配
|
||||
cv::Mat match_noise(const cv::Mat& blended, const cv::Mat& original,
|
||||
const cv::Mat& mask);
|
||||
|
||||
// 退化模拟
|
||||
cv::Mat degrade_plate(const cv::Mat& plate);
|
||||
|
||||
// ── 工具 ──
|
||||
cv::Mat imread_unicode(const std::string& path);
|
||||
bool imwrite_unicode(const std::string& path, const cv::Mat& img,
|
||||
const std::vector<int>& params = {});
|
||||
|
||||
} // namespace ice
|
||||
Reference in new issue
Block a user