205 lines
5.9 KiB
Python
205 lines
5.9 KiB
Python
from typing import List, Optional, Tuple
|
||
|
||
import numpy as np
|
||
|
||
|
||
# EAN-13 编码表（L/G/R 模式），每个数字对应 4 个模块（7 宽度）内的宽窄模式
|
||
# 采用 7 位宽度单元，1 表示黑，0 表示白。此处用字符串仅做查表，不做模拟。
|
||
L_CODES = {
|
||
"0": "0001101",
|
||
"1": "0011001",
|
||
"2": "0010011",
|
||
"3": "0111101",
|
||
"4": "0100011",
|
||
"5": "0110001",
|
||
"6": "0101111",
|
||
"7": "0111011",
|
||
"8": "0110111",
|
||
"9": "0001011",
|
||
}
|
||
|
||
G_CODES = {
|
||
"0": "0100111",
|
||
"1": "0110011",
|
||
"2": "0011011",
|
||
"3": "0100001",
|
||
"4": "0011101",
|
||
"5": "0111001",
|
||
"6": "0000101",
|
||
"7": "0010001",
|
||
"8": "0001001",
|
||
"9": "0010111",
|
||
}
|
||
|
||
R_CODES = {
|
||
"0": "1110010",
|
||
"1": "1100110",
|
||
"2": "1101100",
|
||
"3": "1000010",
|
||
"4": "1011100",
|
||
"5": "1001110",
|
||
"6": "1010000",
|
||
"7": "1000100",
|
||
"8": "1001000",
|
||
"9": "1110100",
|
||
}
|
||
|
||
# 左侧 6 位的奇偶模式用来编码首位数字
|
||
LEADING_PARITY_TO_FIRST = {
|
||
"LLLLLL": "0",
|
||
"LLGLGG": "1",
|
||
"LLGGLG": "2",
|
||
"LLGGGL": "3",
|
||
"LGLLGG": "4",
|
||
"LGGLLG": "5",
|
||
"LGGGLL": "6",
|
||
"LGLGLG": "7",
|
||
"LGLGGL": "8",
|
||
"LGGLGL": "9",
|
||
}
|
||
|
||
|
||
def _normalize_run_lengths(line: np.ndarray, total_modules: int) -> Tuple[np.ndarray, List[int]]:
|
||
# 将行强度阈值化为黑白，再统计 run-length，然后按照总模块数归一化为 95 个模块
|
||
# 使用中位数作为阈值以抵抗亮度变化
|
||
threshold = np.median(line)
|
||
binary = (line < threshold).astype(np.uint8) # 黑为 1
|
||
# run-length 编码
|
||
values = binary.tolist()
|
||
runs: List[int] = []
|
||
last = values[0]
|
||
length = 1
|
||
for v in values[1:]:
|
||
if v == last:
|
||
length += 1
|
||
else:
|
||
runs.append(length)
|
||
last = v
|
||
length = 1
|
||
runs.append(length)
|
||
# 放缩为 total_modules 模块
|
||
total_pixels = float(sum(runs))
|
||
if total_pixels <= 0:
|
||
return binary, runs
|
||
scale = total_modules / total_pixels
|
||
scaled = [max(1, int(round(r * scale))) for r in runs]
|
||
# 对齐长度
|
||
diff = total_modules - sum(scaled)
|
||
if diff != 0:
|
||
# 简单补偿到首个 run
|
||
scaled[0] = max(1, scaled[0] + diff)
|
||
# 展开为模块级二进制
|
||
expanded = []
|
||
color = binary[0] # 起始颜色
|
||
for r in scaled:
|
||
expanded.extend([color] * r)
|
||
color = 1 - color
|
||
return np.array(expanded[:total_modules], dtype=np.uint8), scaled
|
||
|
||
|
||
def _find_guards(bits: np.ndarray, tol: float) -> Optional[Tuple[int, int, int, int]]:
|
||
# 守卫位模式：左 101，中 01010，右 101
|
||
# 以模块位寻找
|
||
s = ''.join('1' if b else '0' for b in bits.tolist())
|
||
# 直接匹配应对理想情况，否则滑窗匹配
|
||
# 找左 101
|
||
left_pos = s.find('101')
|
||
if left_pos == -1:
|
||
return None
|
||
# 找中间 01010（需位于左与右之间）
|
||
mid_pos = s.find('01010', left_pos + 3)
|
||
if mid_pos == -1:
|
||
return None
|
||
# 找右 101
|
||
right_pos = s.find('101', mid_pos + 5)
|
||
if right_pos == -1:
|
||
return None
|
||
return left_pos, mid_pos, right_pos, right_pos + 3
|
||
|
||
|
||
def _bits_to_digit(bits: np.ndarray, tables: List[Tuple[str, dict]]) -> Optional[Tuple[str, str]]:
|
||
pattern = ''.join('1' if b else '0' for b in bits.tolist())
|
||
for parity, table in tables:
|
||
for d, code in table.items():
|
||
if pattern == code:
|
||
return d, parity
|
||
return None
|
||
|
||
|
||
def decode_ean13_from_row(bits_row: np.ndarray) -> Optional[str]:
|
||
# 输入为 0/1 模块位数组，长度应为 95
|
||
if bits_row.size != 95:
|
||
return None
|
||
guards = _find_guards(bits_row, tol=0.35)
|
||
if not guards:
|
||
return None
|
||
left_start, mid_start, right_start, right_end = guards
|
||
# 划分区域
|
||
left_data = bits_row[left_start + 3 : mid_start]
|
||
right_data = bits_row[mid_start + 5 : right_start]
|
||
# 左右各 6 个数字，每个 7 位
|
||
if left_data.size != 6 * 7 or right_data.size != 6 * 7:
|
||
return None
|
||
digits_left: List[str] = []
|
||
parity_seq: List[str] = []
|
||
for i in range(6):
|
||
seg = left_data[i * 7 : (i + 1) * 7]
|
||
ret = _bits_to_digit(seg, [("L", L_CODES), ("G", G_CODES)])
|
||
if not ret:
|
||
return None
|
||
d, parity = ret
|
||
digits_left.append(d)
|
||
parity_seq.append(parity)
|
||
parity_str = ''.join(parity_seq)
|
||
first_digit = LEADING_PARITY_TO_FIRST.get(parity_str)
|
||
if first_digit is None:
|
||
return None
|
||
digits_right: List[str] = []
|
||
for i in range(6):
|
||
seg = right_data[i * 7 : (i + 1) * 7]
|
||
ret = _bits_to_digit(seg, [("R", R_CODES)])
|
||
if not ret:
|
||
return None
|
||
d, _ = ret
|
||
digits_right.append(d)
|
||
code_12 = first_digit + ''.join(digits_left) + ''.join(digits_right[:-1])
|
||
check_digit = int(digits_right[-1])
|
||
# 校验位计算
|
||
s = 0
|
||
for idx, ch in enumerate(code_12):
|
||
v = int(ch)
|
||
if (idx + 1) % 2 == 0:
|
||
s += v * 3
|
||
else:
|
||
s += v
|
||
calc = (10 - (s % 10)) % 10
|
||
if calc != check_digit:
|
||
return None
|
||
return code_12 + str(check_digit)
|
||
|
||
|
||
def sample_and_decode(warped_gray: np.ndarray, sample_rows: List[float], total_modules: int) -> Optional[str]:
|
||
h, w = warped_gray.shape[:2]
|
||
results: List[str] = []
|
||
for r in sample_rows:
|
||
row_y = min(h - 1, max(0, int(round(h * r))))
|
||
line = warped_gray[row_y, :].astype(np.float32)
|
||
# 直方图均衡增强对比
|
||
line_eq = line
|
||
# 归一化为 0..255
|
||
if line_eq.max() > line_eq.min():
|
||
line_eq = (line_eq - line_eq.min()) / (line_eq.max() - line_eq.min()) * 255.0
|
||
bits, _ = _normalize_run_lengths(line_eq, total_modules)
|
||
if bits.size != total_modules:
|
||
continue
|
||
code = decode_ean13_from_row(bits)
|
||
if code:
|
||
results.append(code)
|
||
if not results:
|
||
return None
|
||
# 取众数
|
||
vals, counts = np.unique(np.array(results), return_counts=True)
|
||
return vals[int(np.argmax(counts))]
|
||
|
||
|