首次提交

Author: howlclat

.idea/vcs.xml

@@ -0,0 +1,237 @@
+# -*- coding: utf-8 -*-
+import cv2
+import numpy as np
+import plotCVImg
+
+IMAGE_WIDTH = 40
+IMAGE_HEIGHT = 40
+SUDOKU_SIZE = 9
+N_MIN_ACTIVE_PIXELS = 30
+SIZE_PUZZLE = IMAGE_WIDTH * SUDOKU_SIZE
+DEBUG = 0
+
+
+def correct(img_original):
+    # 灰度化
+    img_gray = cv2.cvtColor(img_original, cv2.COLOR_BGR2GRAY)
+    if DEBUG:
+        plotCVImg.plotImg(img_gray, "gray")
+
+    # 中值滤波
+    img_blur = cv2.medianBlur(img_gray, 1)
+    if DEBUG:
+        plotCVImg.plotImg(img_blur, "median Blur")
+
+    # 高斯滤波
+    img_blur = cv2.GaussianBlur(img_blur, (3, 3), 0)
+    if DEBUG:
+        plotCVImg.plotImg(img_blur, "Gaussian Blur")
+
+    # 将每个像素除以闭操作后的像素，可以调整图像亮度
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (11, 11))
+    close = cv2.morphologyEx(img_blur, cv2.MORPH_CLOSE, kernel)
+    div = np.float32(img_blur) / close
+    img_brightness_adjust = np.uint8(cv2.normalize(div, div, 0, 255, cv2.NORM_MINMAX))
+    if DEBUG:
+        plotCVImg.plotImg(img_brightness_adjust, "brightness adjust")
+
+    # 自适应阈值二值化，注意其返回值只有一个
+    img_thresh = cv2.adaptiveThreshold(img_brightness_adjust, 255,
+                                       cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+                                       cv2.THRESH_BINARY_INV, 11, 7)
+    if DEBUG:
+        img_thresh = cv2.medianBlur(img_thresh, 3)
+        plotCVImg.plotImg(img_thresh, "adaptive Threshold")
+
+    # 寻找轮廓
+    binary, contours, hierarchy = cv2.findContours(img_thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if DEBUG:
+        img_contours = img_original.copy()
+        cv2.drawContours(img_contours, contours, -1, (0, 0, 255), 2)
+        plotCVImg.plotImg(img_contours, "contours")
+
+    # 找到最大轮廓
+    max_area = 0
+    biggest_contour = None
+    for cnt in contours:
+        area = cv2.contourArea(cnt)
+        if area > max_area:
+            max_area = area
+            biggest_contour = cnt
+
+    # mask操作
+    mask = np.zeros(img_brightness_adjust.shape, np.uint8)
+    cv2.drawContours(mask, [biggest_contour], 0, 255, cv2.FILLED)
+    cv2.drawContours(mask, [biggest_contour], 0, 0, 2)
+    image_with_mask = cv2.bitwise_and(img_brightness_adjust, mask)
+    if DEBUG:
+        plotCVImg.plotImg(image_with_mask, "image_with_mask")
+
+    # 角点检测
+    dst = cv2.cornerHarris(image_with_mask, 2, 3, 0.04)
+    if DEBUG:
+        plotCVImg.plotImg(dst, "image_cornerHarris")
+
+    # x方向Sobel算子，膨胀操作连接断线，边缘检测找出竖线
+    dx = cv2.Sobel(image_with_mask, cv2.CV_16S, 1, 0)
+    dx = cv2.convertScaleAbs(dx)
+    cv2.normalize(dx, dx, 0, 255, cv2.NORM_MINMAX)
+    ret, close = cv2.threshold(dx, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+    kernelx = cv2.getStructuringElement(cv2.MORPH_RECT, (2, 10))
+    close = cv2.morphologyEx(close, cv2.MORPH_DILATE, kernelx, iterations=1)
+
+    binary, contour, hierarchy = cv2.findContours(close, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    for cnt in contour:
+        x, y, w, h = cv2.boundingRect(cnt)
+        if h / w > 5:
+            cv2.drawContours(close, [cnt], 0, 255, -1)
+        else:
+            cv2.drawContours(close, [cnt], 0, 0, -1)
+
+    close = cv2.morphologyEx(close, cv2.MORPH_CLOSE, None, iterations=2)
+    closex = close.copy()
+
+    # Y方向，找出横线
+    dy = cv2.Sobel(image_with_mask, cv2.CV_16S, 0, 2)
+    dy = cv2.convertScaleAbs(dy)
+    cv2.normalize(dy, dy, 0, 255, cv2.NORM_MINMAX)
+    retVal, close = cv2.threshold(dy, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+    kernely = cv2.getStructuringElement(cv2.MORPH_RECT, (10, 2))
+    close = cv2.morphologyEx(close, cv2.MORPH_DILATE, kernely)
+
+    binary, contour, hierarchy = cv2.findContours(close, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    for cnt in contour:
+        x, y, w, h = cv2.boundingRect(cnt)
+        if w / h > 5:
+            cv2.drawContours(close, [cnt], 0, 255, -1)
+        else:
+            cv2.drawContours(close, [cnt], 0, 0, -1)
+
+    close = cv2.morphologyEx(close, cv2.MORPH_DILATE, None, iterations=2)
+    closey = close.copy()
+
+    # 求x,y交点
+    res = cv2.bitwise_and(closex, closey)
+    if DEBUG:
+        plotCVImg.plotImg(res, "dots")
+
+    # 查找轮廓，求每个轮廓的质心centroids
+    img_dots = cv2.cvtColor(img_brightness_adjust, cv2.COLOR_GRAY2BGR)
+    binary, contour, hierarchy = cv2.findContours(res, cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
+    centroids = []
+    for cnt in contour:
+        if cv2.contourArea(cnt) > 20:
+            mom = cv2.moments(cnt)
+            (x, y) = int(mom['m10'] / mom['m00']), int(mom['m01'] / mom['m00'])
+            cv2.circle(img_dots, (x, y), 4, (0, 255, 0), -1)
+            centroids.append((x, y))
+    centroids = np.array(centroids, dtype=np.float32)
+    c = centroids.reshape((100, 2))
+    c2 = c[np.argsort(c[:, 1])]
+
+    b = np.vstack([c2[i * 10:(i + 1) * 10][np.argsort(c2[i * 10:(i + 1) * 10, 0])] for i in range(10)])
+    bm = b.reshape((10, 10, 2))
+
+    res2 = cv2.cvtColor(img_brightness_adjust, cv2.COLOR_GRAY2BGR)
+    output = np.zeros((450, 450, 3), np.uint8)
+    for i, j in enumerate(b):
+        ri = i // 10
+        ci = i % 10
+        if ci != 9 and ri != 9:
+            src = bm[ri:ri + 2, ci:ci + 2, :].reshape((4, 2))
+            dst = np.array([[ci * 50, ri * 50], [(ci + 1) * 50 - 1, ri * 50], [ci * 50, (ri + 1) * 50 - 1],
+                            [(ci + 1) * 50 - 1, (ri + 1) * 50 - 1]], np.float32)
+            retval = cv2.getPerspectiveTransform(src, dst)
+            warp = cv2.warpPerspective(res2, retval, (450, 450))
+            output[ri * 50:(ri + 1) * 50 - 1, ci * 50:(ci + 1) * 50 - 1] = warp[ri * 50:(ri + 1) * 50 - 1,
+                                                                           ci * 50:(ci + 1) * 50 - 1].copy()
+    img_correct = cv2.cvtColor(output, cv2.COLOR_BGR2GRAY)
+    img_puzzle = cv2.adaptiveThreshold(img_correct, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY_INV, 5, 7)
+    img_puzzle = cv2.resize(img_puzzle, (SIZE_PUZZLE, SIZE_PUZZLE), interpolation=cv2.INTER_LINEAR)
+    return img_puzzle
+
+
+def correct2(img_original):
+
+    if DEBUG:
+        plotCVImg.plotImg(img_original, "original")
+
+    # gray image
+    img_gray = cv2.cvtColor(img_original, cv2.COLOR_BGR2GRAY)
+    if DEBUG:
+        plotCVImg.plotImg(img_gray, "gray")
+
+    # median Blur
+    img_Blur = cv2.medianBlur(img_gray, 5)
+    if DEBUG:
+        plotCVImg.plotImg(img_Blur, "median Blur")
+
+    # Gaussian Blur
+    img_Blur = cv2.GaussianBlur(img_gray, (3, 3), 0)
+    if DEBUG:
+        plotCVImg.plotImg(img_Blur, "GaussianBlur")
+
+    # adaptive threshold
+    img_thresh = cv2.adaptiveThreshold(img_Blur, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 11, 2)
+    if DEBUG:
+        plotCVImg.plotImg(img_thresh, "adaptiveThreshold")
+
+    # find the contours RETR_EXTERNAL
+    binary, contours, hierarchy = cv2.findContours(img_thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if DEBUG:
+        img_contours = img_original.copy()
+        cv2.drawContours(img_contours, contours, -1, (0, 0, 255), 2)
+        plotCVImg.plotImg(img_contours, "contours")
+
+    # find the biggest contours
+    size_rectangle_max = 0
+    index_biggest = 0
+    for i in range(len(contours)):
+        size_rectangle = cv2.contourArea(contours[i])
+        # store the index of the biggest
+        if size_rectangle > size_rectangle_max:
+            size_rectangle_max = size_rectangle
+            index_biggest = i
+
+    # 多边形拟合
+    epsilon = 0.1 * cv2.arcLength(contours[index_biggest], True)
+    biggest_rectangle = cv2.approxPolyDP(contours[index_biggest], epsilon, True)
+
+    if DEBUG:
+        # copy the original image to show the border
+        img_border = img_original.copy()
+        # 画出数独方格的边界
+        for x in range(len(biggest_rectangle)):
+            cv2.line(img_border,
+                     (biggest_rectangle[(x % 4)][0][0], biggest_rectangle[(x % 4)][0][1]),
+                     (biggest_rectangle[((x + 1) % 4)][0][0], biggest_rectangle[((x + 1) % 4)][0][1]),
+                     (255, 0, 0), 2)
+        plotCVImg.plotImg(img_border, "border")
+
+    # sort the corners to remap the image
+    def sortCornerPoints(rcCorners):
+        point = rcCorners.reshape((4, 2))
+        mean = rcCorners.sum() / 8
+        cornerPoint = np.zeros((4, 2), dtype=np.float32)
+        for i in range(len(point)):
+            if point[i][0] < mean:
+                if point[i][1] < mean:
+                    cornerPoint[0] = point[i]
+                else:
+                    cornerPoint[2] = point[i]
+            else:
+                if point[i][1] < mean:
+                    cornerPoint[1] = point[i]
+                else:
+                    cornerPoint[3] = point[i]
+        return cornerPoint
+
+    # 透视变换
+    cornerPoints = sortCornerPoints(biggest_rectangle)
+    puzzlePoints = np.float32([[0, 0], [SIZE_PUZZLE, 0], [0, SIZE_PUZZLE], [SIZE_PUZZLE, SIZE_PUZZLE]])
+    PerspectiveMatrix = cv2.getPerspectiveTransform(cornerPoints, puzzlePoints)
+    img_puzzle = cv2.warpPerspective(img_thresh, PerspectiveMatrix, (SIZE_PUZZLE, SIZE_PUZZLE))
+    if DEBUG:
+        plotCVImg.plotImg(img_puzzle, "puzzle")
+
+    return img_puzzle

correction.py

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+import cv2
+import numpy as np
+
+# 标准方格大小
+GRID_WIDTH = 40
+GRID_HEIGHT = 40
+# 标准数字大小
+NUM_WIDTH = 20
+NUM_HEIGHT = 20
+# 判定非零像素书最小阈值
+N_MIN_ACTIVE_PIXELS = 30
+
+
+def extract_grid(im_number):
+    """
+    将校正后图像划分为9x9的棋盘，取出小方格；二值化；去除离中心较远的像素（排除边框干扰）；统计非零像素数（判断方格中是否有数字）
+    :param im_number: 方格图像
+    :param x: 方格横坐标 (0~9)
+    :param y: 方格纵坐标 (0~9)
+    :return: im_number_thresh: 二值化及处理后图像
+             n_active_pixels: 非零像素数
+    """
+
+    # 二值化
+    retVal, im_number_thresh = cv2.threshold(im_number, 150, 255, cv2.THRESH_BINARY)
+
+    # 去除离中心较远的像素点（排除边框干扰）
+    for i in range(im_number.shape[0]):
+        for j in range(im_number.shape[1]):
+            dist_center = np.sqrt(np.square(GRID_WIDTH // 2 - i) + np.square(GRID_HEIGHT // 2 - j))
+            if dist_center > GRID_WIDTH // 2 - 2:
+                im_number_thresh[i, j] = 0
+
+    # 统计非零像素数，以判断方格中是否有数字
+    n_active_pixels = cv2.countNonZero(im_number_thresh)
+
+    return [im_number_thresh, n_active_pixels]
+
+
+def find_biggest_bounding_box(im_number_thresh):
+    """
+    找出小方格中外接矩形面积最大的轮廓，返回其外接矩形参数
+    :param im_number_thresh: 当前方格的二值化及处理后图像
+    :return: 外接矩形参数（左上坐标及长和宽）
+    """
+    # 轮廓检测
+    b, contour, hierarchy1 = cv2.findContours(im_number_thresh.copy(),
+                                              cv2.RETR_EXTERNAL,
+                                              cv2.CHAIN_APPROX_SIMPLE)
+    # 找出外接矩形面积最大的轮廓
+    biggest_bound_rect = []
+    bound_rect_max_size = 0
+    for i in range(len(contour)):
+        bound_rect = cv2.boundingRect(contour[i])
+        size_bound_rect = bound_rect[2] * bound_rect[3]
+        if size_bound_rect > bound_rect_max_size:
+            bound_rect_max_size = size_bound_rect
+            biggest_bound_rect = bound_rect
+
+    # 将外接矩形扩大一个像素
+    x_b, y_b, w, h = biggest_bound_rect
+    x_b = x_b - 1
+    y_b = y_b - 1
+    w = w + 2
+    h = h + 2
+    return [x_b, y_b, w, h]
+
+
+def recognize_number(im_number, x, y):
+    """
+    判断当前方格是否存在数字并存储该数字
+    :param im_number: 方格图像
+    :param x: 方格横坐标 (0~9)
+    :param y: 方格纵坐标 (0~9)
+    :return: 数字的一维数组
+    """
+    # 提取并处理方格图像
+    [im_number_thresh, n_active_pixels] = extract_grid(im_number)
+
+    # 条件1：非零像素大于设定的最小值
+    if n_active_pixels > N_MIN_ACTIVE_PIXELS:
+
+        # 找出外接矩形
+        [x_b, y_b, w, h] = find_biggest_bounding_box(im_number_thresh)
+
+        # 计算矩形中心与方格中心距离
+        cX = x_b + w // 2
+        cY = y_b + h // 2
+        d = np.sqrt(np.square(cX - GRID_WIDTH // 2) + np.square(cY - GRID_HEIGHT // 2))
+
+        # 条件2: 外接矩形中心与方格中心距离足够小
+        if d < GRID_WIDTH // 4:
+
+            # 取出方格中数字
+            number_roi = im_number[y_b:y_b + h, x_b:x_b + w]
+
+            # 扩充数字图像为正方形，边长取长宽较大者
+            h1, w1 = np.shape(number_roi)
+            if h1 > w1:
+                number = np.zeros(shape=(h1, h1))
+                number[:, (h1 - w1) // 2:(h1 - w1) // 2 + w1] = number_roi
+            else:
+                number = np.zeros(shape=(w1, w1))
+                number[(w1 - h1) // 2:(w1 - h1) // 2 + h1, :] = number_roi
+
+            # 将数字缩放为标准大小
+            number = cv2.resize(number, (NUM_WIDTH, NUM_HEIGHT), interpolation=cv2.INTER_LINEAR)
+
+            retVal, number = cv2.threshold(number, 50, 255, cv2.THRESH_BINARY)
+
+            # 转换为1维数组并返回
+            return True, number.reshape(1, NUM_WIDTH * NUM_HEIGHT)
+
+    # 没有数字，则返回全零1维数组
+    return False, np.zeros(shape=(1, NUM_WIDTH * NUM_HEIGHT))
+