ISBN识别
学校三级项目需要批量识别ISBN中的数字
实现的大致思路如下：
对原始图片按尺寸自动调整大小，高斯滤波去噪，灰度化，二值化，边缘检测后闭操作，查找最大轮廓，获取最小外接矩形及旋转角度，旋转摆正图片，水平投影，提取字符区域，用pytesseract识别字符
项目代码存放在三个文件中
1.工具类ocr_tool.py
import re
from difflib import SequenceMatcher
# 提取字符串中的数字
def obtain_digit(data):
s = re.findall(r"\d+", data)
return ''.join(s)
# 统计正确识别的数字个数
def crct_digit_cnt(crct_isbn, recog_isbn):
return SequenceMatcher(None, crct_isbn, recog_isbn).find_longest_match(0, len(crct_isbn), 0, len(recog_isbn)).size
2.图片预处理相关函数img_process_tool.py
from math import fabs, sin, radians, cos
import cv2 as cv
import numpy as np
def img_show_wait(img, window_name, duration=100):
"""
显示图片
:param img:输入图片
:param window_name: 显示图片的窗口名称
:param duration: 显示图片的时长，默认等待键入任意按键，不自动关闭窗口
"""
cv.imshow(window_name, img)
cv.waitKey(duration)
def get_projection_list(binary_img, direction='horizontal'):
"""
获取指定方向的投影
:param binary_img: 输入的二值图
:param direction: 投影方向
:return: 投影方向上的像素统计图
"""
h, w = binary_img.shape[:2]
row_list = [0] * h
col_list = [0] * w
for row in range(h):
for col in range(w):
if binary_img[row, col] == 255: # 统计白色像素点个数
row_list[row] = row_list[row] + 1
col_list[col] = col_list[col] + 1
if direction == 'horizontal':
return row_list
else:
return col_list
def draw_projection(data_list, rows, cols, direction='horizontal'):
"""
绘制指定方向上的投影图并返回
:param data_list: 用于绘制投影的数据
:param rows: 原始图像的行数
:param cols: 原始图像的列数
:param direction: 指定水平或者垂直方向投影
:return: 投影图像
"""
img_proj = np.ones(shape=(rows, cols), dtype=np.uint8) * 255
row_max = np.max(data_list)
if direction == 'horizontal':
# 绘制水平投影图
weight = cols / row_max
for row in range(rows):
pt1 = (0, row)
pt2 = (int(weight * data_list[row]), row)
cv.line(img_proj, pt1, pt2, (0,), 1)
img_show_wait(img_proj, 'horizontal projection')
else:
# 绘制垂直投影图
weight = rows / row_max
for col in range(cols):
pt1 = (col, rows - 1)
pt2 = (col, rows - 1 - int(weight * data_list[col]))
cv.line(img_proj, pt1, pt2, (0,), 1)
img_show_wait(img_proj, 'vertical projection')
return img_proj
def split_projection_list(proj_list: list, min_val=0):
"""
将投影得到的像素统计区间分割出像素集中区域，返回ROI区域的坐标区间
:param proj_list: 投影统计数据
:param min_val: 用于划定区间的一个阈值
:return: ROI区域的坐标区间
"""
start = 0
end = None
split_list = []
for idx, value in enumerate(proj_list):
if value > min_val:
end = idx
else:
if end is not None:
split_list.append((start, end))
end = None
start = idx
return split_list
def img_rotate(img, degree):
"""
对图片进行旋转
:param img:输入图片
:param degree: 旋转角度
:return:
"""
height, width = img.shape[:2]
heightNew = int(width * fabs(sin(radians(degree))) + height * fabs(cos(radians(degree)))) # 扩充画布
widthNew = int(height * fabs(sin(radians(degree))) + width * fabs(cos(radians(degree)))) # 扩充画布
matRotation = cv.getRotationMatrix2D((width // 2, height // 2), degree, 1) # 获取旋转矩阵
matRotation[0, 2] += (widthNew - width) // 2 # 旋转后平移
matRotation[1, 2] += (heightNew - height) // 2 # 旋转后平移
imgRotation = cv.warpAffine(img, matRotation, (widthNew, heightNew), borderValue=(255, 255, 255)) # 获取旋转后的图片
return imgRotation, matRotation
def draw_box(img, box):
"""
在指定图片上画矩形框
:param img: 输入图片
:param box: 矩形框的坐标，一个长度为8的坐标序列
:return:
"""
cv.line(img, (box[0], box[1]), (box[2], box[3]), (0, 255, 0), 3)
cv.line(img, (box[2], box[3]), (box[4], box[5]), (0, 255, 0), 3)
cv.line(img, (box[0], box[1]), (box[6], box[7]), (0, 255, 0), 3)
cv.line(img, (box[4], box[5]), (box[6], box[7]), (0, 255, 0), 3)
return img
def img_resize(img_original):
"""
根据给定图片的尺寸自动调整为相应的大小
:param img_original: 输入图片
:return:
"""
rows, cols = img_original.shape[:2]
if rows > 1300:
img_original = cv.resize(img_original, None, fx=0.25, fy=0.25, interpolation=cv.INTER_CUBIC) # 调整大小
elif 750 < rows <= 1300:
img_original = cv.resize(img_original, None, fx=0.5, fy=0.5, interpolation=cv.INTER_CUBIC) # 调整大小
elif 500 < rows <= 750:
img_original = cv.resize(img_original, None, fx=0.75, fy=0.75, interpolation=cv.INTER_CUBIC) # 调整大小
return img_original
def adaptive_threshold(gray, block_size=5, c=10, inv=False):
"""
对给定图片进行二值化处理
:param gray: 输入的灰度图
:param block_size: 卷积核大小
:param c:
:param inv: 是否反转，默认情况下，不反转，字符区域显示为白色，不相关区域显示为黑色
:return: 返回二值化后的图像
"""
if not inv:
thresholdType = cv.THRESH_BINARY
else:
thresholdType = cv.THRESH_BINARY_INV
# 自适应阈值化能够根据图像不同区域亮度分布，改变阈值
binary_img = cv.adaptiveThreshold(
gray, 255, cv.ADAPTIVE_THRESH_GAUSSIAN_C, thresholdType, block_size, c)
return binary_img
def img_preprocess(img, kernel=None):
"""
对图片进行预处理,包括高斯滤波去噪，转为灰度图，自适应二值化处理，闭运算处理
:param img: 输入图片
:param kernel: 卷积核
:return: 预处理后得到的图像
"""
img_blur = cv.GaussianBlur(img, (3, 3), 0) # 高斯滤波进行去噪
img_gray = cv.cvtColor(img_blur, cv.COLOR_BGR2GRAY) # 转为灰度图
ret, img_bin = cv.threshold(img_gray, 0, 255, cv.THRESH_BINARY_INV + cv.THRESH_OTSU) # 自适应二值化
img_canny = cv.Canny(img_bin, 50, 50) # 边缘检测
if kernel is None:
kernel = cv.getStructuringElement(cv.MORPH_RECT, (5, 5), (-1, -1))
img_close = cv.morphologyEx(img_canny, cv.MORPH_CLOSE, kernel) # 先膨胀后腐蚀，减少连通区域（闭运算）
img_show_wait(img_close, 'original img close')
return img_close
if __name__ == '__main__':
# 测试图片切割序列
path_to_img = r'D:\projects_python\workingon\isbnocr\pageocr\xxx.png'
img_original = cv.imread(path_to_img)
img_pre = img_preprocess(img_original)
horizontal_projection_list = get_projection_list(img_pre, 'horizontal')
rows, cols = img_pre.shape[:2]
draw_projection(horizontal_projection_list, rows, cols, 'horizontal')
3.核心代码isbnocr.py
import os
from os import listdir
import pytesseract
from img_process_tool import *
from ocr_tool import *
def img_isbn_area(img_original):
"""
对原始图片倾斜摆正后提取出原始图片中的字符区域
:param img_original: 输入图片
:return: 提取出的字符区域
"""
kernel = cv.getStructuringElement(cv.MORPH_RECT, (100, 5), (-1, -1))
img_pre = img_preprocess(img_original, kernel)
# 查找最大轮廓
contours, hierarchy, = cv.findContours(img_pre, 1, 2)
length = len(contours)
index = 0 # 存放最大轮廓的索引
max_area = cv.contourArea(contours[index]) # 存放最大轮廓的面积
for i in range(length):
cnt = contours[i]
area = cv.contourArea(cnt)
if area > max_area:
index = i
max_area = area
# 利用最大轮廓计算倾斜角度，将图片摆正
cnt = contours[index]
min_area_rect = cv.minAreaRect(cnt) # 获取最小外接矩形，返回一个rect，ndarray类型
angle = min_area_rect[2] # 获取旋转角度
if angle > 80:
angle = min_area_rect[2] - 90 # 调整旋转角度
img_rotated, mat_rotation = img_rotate(img_original, angle) # 开始旋转
img_rotated_pre = img_preprocess(img_rotated, kernel)
# 水平投影
proj_list = get_projection_list(img_rotated_pre)
split_list = split_projection_list(proj_list, 0)
img_h, img_w = img_rotated_pre.shape[:2]
x, y, w, h = 0, 0, img_w, img_h
for start, end in split_list:
if end - start > img_h * 0.5:
continue
x, y, w, h = 0, start, img_w, end - start
roi = img_rotated[y:y + h, x:x + w]
img_show_wait(roi, 'roi')
proj_list = get_projection_list(img_rotated_pre, 'vertical')
split_vertical_list = split_projection_list(proj_list, 0)
if len(split_vertical_list) < 12:
continue
return img_rotated[y:y + h, x:x + w]
def split_digits(img_text):
"""
对提取出的字符区域进行垂直投影，切割出单个字符区域
:param img_text: 输入图像
:return: 单个字符区域
"""
isbn_gray = cv.cvtColor(img_text, cv.COLOR_BGR2GRAY)
ret, isbn_bin = cv.threshold(isbn_gray, 0, 255, cv.THRESH_OTSU + cv.THRESH_BINARY_INV)
img_show_wait(isbn_bin, 'isbn area bin')
ver_proj_list = get_projection_list(isbn_bin, 'vertical')
rows, cols = img_text.shape[:2]
draw_projection(ver_proj_list, rows, cols, 'vertical')
digit_col_list = split_projection_list(ver_proj_list)
digits = []
for i in range(len(digit_col_list)):
digit_col = digit_col_list[i]
digits.append(img_text[:, digit_col[0]:digit_col[1]])
return digits
def digit_recog(path_to_image):
"""
识别单张图片中的ISBN编号
:param path_to_image: 图片绝对路径
:return:
"""
img_original = cv.imread(path_to_image)
img_resized = img_resize(img_original)
isbn_area = img_isbn_area(img_resized)
recog_isbn = obtain_digit(pytesseract.image_to_string(isbn_area))
print(f'【图片{os.path.basename(path_to_image)}】的识别结果为：{recog_isbn}')
if isbn_area is not None:
digits = split_digits(isbn_area)
if digits is not None:
for i in range(len(digits)):
img_show_wait(digits[i], 'digit')
def digit_recog_batch(path_to_images):
"""
批量识别图片
:param path_to_images: 图片存放的文件夹绝对路径
:return:
"""
img_cnt = 0 # 图片数量
digit_cnt = 0 # 数字数量
digit_recognized = 0 # 正确识别数字
isbn_recognized = 0 # 正确识别完整ISBN
for file in listdir(path_to_images):
img_abs_path = os.path.join(path_to_images, file) # 图像的绝对路径
img_basename = os.path.basename(img_abs_path) # 图片的文件名
original_image = cv.imread(img_abs_path, cv.IMREAD_COLOR)
isbn_area = img_isbn_area(img_resize(original_image)) # 获取图片中的字符区域
if isbn_area is not None:
recog_isbn = obtain_digit(pytesseract.image_to_string(isbn_area))
print(f'【图片{img_basename}】的识别结果为：{recog_isbn}')
if recog_isbn:
img_cnt += 1
digit_cnt += len(obtain_digit(img_basename))
digit_recognized += crct_digit_cnt(obtain_digit(img_basename), recog_isbn)
isbn_recognized += 1 if recog_isbn.find(obtain_digit(file)) != -1 else 0
print("正确识别的ISBN个数：" + str(isbn_recognized) + "/" + str(img_cnt))
print("正确识别的数字个数：" + str(digit_recognized) + "/" + str(digit_cnt))
print("识别正确率：" + str(isbn_recognized / img_cnt))
print("识别准确率：" + str(digit_recognized / digit_cnt))
# todo：字符识别可以用神经网络或者模板匹配
if __name__ == "__main__":
pytesseract.pytesseract.tesseract_cmd = r"D:\software\Tesseract-OCR\tesseract.exe"
path_to_image = r'D:\projects_python\workingon\isbnocr\isbn_recognition\ISBN 978-7-5099-1125-9.png'
path_to_images = r'D:\projects_python\workingon\isbnocr\isbn_recognition\images'
# digit_recog(path_to_image) # 识别单张图片
digit_recog_batch(path_to_images) # 批量识别图片中的ISBN编号
这个项目，坐下来感觉比较有参考价值的还是图片预处理的思路和相关实现，至于字符识别，由于时间关系没来得及写，就用了比较粗陋的方法实现，后面有时间改成模板匹配或者神经网络识别字符。
图片的源代码和数据集都同步到gitee上了，地址在这里isbn-ocr: 计算机视觉课程设计 识别ISBN中的数字 (gitee.com)