关于python:PythonOpenCV实现自动扫雷创造属于自己的世界记录

咱们一起来玩扫雷吧。用 Python+OpenCV 实现了主动扫雷，冲破世界记录，咱们先来看一下成果吧。

​

中级 – 0.74 秒 3BV/S=60.81

置信许多人很早就晓得有扫雷这么一款经典的游（显卡测试）戏（软件），更是有不少人曾据说过中国雷圣，也是中国扫雷第一、世界综合排名第二的郭蔚嘉的顶顶小名。扫雷作为一款在 Windows9x 时代就曾经诞生的经典游戏，从过来到当初仍然都有着它独特的魅力：快节奏高精准的鼠标操作要求、疾速的反馈能力、刷新纪录的快感，这些都是扫雷给雷友们带来的、只属于扫雷的举世无双的兴奋点。

▍0x00 筹备

筹备入手制作一套扫雷自动化软件之前，你须要筹备如下一些工具 / 软件 / 环境

开发环境

1. Python3 环境 – 举荐 3.6 或者以上 [更加举荐 Anaconda3，以下很多依赖库无需装置]
2. numpy 依赖库 [如有 Anaconda 则无需装置]
3. PIL 依赖库 [如有 Anaconda 则无需装置]
4. opencv-python
5. win32gui、win32api 依赖库
6. 反对 Python 的 IDE [可选，如果你能忍耐用文本编辑器写程序也能够]

扫雷软件

Minesweeper Arbiter 下载地址（必须应用 MS-Arbiter 来进行扫雷！）

好啦，那么咱们的筹备工作曾经全副实现了！让咱们开始吧~

▍0x01 实现思路

在去做一件事件之前最重要的是什么？是将要做的这件事件在心中搭建一个步骤框架。只有这样，能力保障在去做这件事的过程中，尽可能的做到三思而行，使得最终有个好的后果。咱们写程序也要尽可能做到在正式开始开发之前，在心中有个大抵的思路。

对于本我的项目而言，大抵的开发过程是这样的：

1. 实现窗体内容截取局部
2. 实现雷块分割部分
3. 实现雷块类型辨认局部
4. 实现扫雷算法

好啦，既然咱们有了个思路，那就撸起袖子鼎力干！

01 窗体截取

其实对于本我的项目而言，窗体截取是一个逻辑上简略，实现起来却相当麻烦的局部，而且还是必不可少的局部。咱们通过 Spy++ 失去了以下两点信息：

class_name = "TMain"
title_name = "Minesweeper Arbiter"

• ms_arbiter.exe 的主窗体类别为 ”TMain”
• ms_arbiter.exe 的主窗体名称为 ”Minesweeper Arbiter “

留神到了么？主窗体的名称前面有个空格。正是这个空格让笔者困扰了一会儿，只有加上这个空格，win32gui 才可能失常的获取到窗体的句柄。

本我的项目采纳了 win32gui 来获取窗体的地位信息，具体代码如下：​​​​​​​

hwnd = win32gui.FindWindow(class_name, title_name)
if hwnd:
left, top, right, bottom = win32gui.GetWindowRect(hwnd)

通过以上代码，咱们失去了窗体绝对于整块屏幕的地位。之后咱们须要通过 PIL 来进行扫雷界面的棋盘截取。

咱们须要先导入 PIL 库

from PIL import ImageGrab

而后进行具体的操作。​​​​​​​

left += 15
top += 101
right -= 15
bottom -= 43

rect = (left, top, right, bottom)
img = ImageGrab.grab().crop(rect)

聪慧的你必定一眼就发现了那些奇奇怪怪的 Magic Numbers，没错，这确实是 Magic Numbers，是咱们通过一点点轻微调节失去的整个棋盘绝对于窗体的地位。

留神：这些数据仅在 Windows10 下测试通过，如果在别的 Windows 零碎下，不保障绝对地位的正确性，因为老版本的零碎可能有不同宽度的窗体边框。

​

橙色的区域是咱们所须要的

好啦，棋盘的图像咱们有了，下一步就是对各个雷块进行图像宰割了~

02 雷块宰割

​

在进行雷块宰割之前，咱们当时须要理解雷块的尺寸以及它的边框大小。通过笔者的测量，在 ms_arbiter 下，每一个雷块的尺寸为 16px*16px。

晓得了雷块的尺寸，咱们就能够进行每一个雷块的裁剪了。首先咱们须要晓得在横和竖两个方向上雷块的数量。​​​​​​​

block_width, block_height = 16, 16
  blocks_x = int((right - left) / block_width)
  blocks_y = int((bottom - top) / block_height)

之后，咱们建设一个二维数组用于存储每一个雷块的图像，并且进行图像宰割，保留在之前建设的数组中。​​​​​​​

def crop_block(hole_img, x, y):
        x1, y1 = x * block_width, y * block_height
        x2, y2 = x1 + block_width, y1 + block_height
return hole_img.crop((x1, y1, x2, y2))

blocks_img = [[0 for i in range(blocks_y)] for i in range(blocks_x)]

for y in range(blocks_y):
for x in range(blocks_x):
        blocks_img[x][y] = crop_block(img, x, y)

将整个图像获取、宰割的局部封装成一个库，随时调用就 OK 啦~ 在笔者的实现中，咱们将这一部分封装成了 imageProcess.py，其中函数 get_frame() 用于实现上述的图像获取、宰割过程。

03 雷块辨认

这一部分可能是整个我的项目里除了扫雷算法自身之外最重要的局部了。笔者在进行雷块检测的时候采纳了比较简单的特色，高效并且能够满足要求。​​​​​​​

def analyze_block(self, block, location):
    block = imageProcess.pil_to_cv(block)

    block_color = block[8, 8]
    x, y = location[0], location[1]

    # -1:Not opened
    # -2:Opened but blank
    # -3:Un initialized

    # Opened
if self.equal(block_color, self.rgb_to_bgr((192, 192, 192))):
if not self.equal(block[8, 1], self.rgb_to_bgr((255, 255, 255))):
self.blocks_num[x][y] = -2
self.is_started = True
else:
self.blocks_num[x][y] = -1

    elif self.equal(block_color, self.rgb_to_bgr((0, 0, 255))):
self.blocks_num[x][y] = 1

    elif self.equal(block_color, self.rgb_to_bgr((0, 128, 0))):
self.blocks_num[x][y] = 2

    elif self.equal(block_color, self.rgb_to_bgr((255, 0, 0))):
self.blocks_num[x][y] = 3

    elif self.equal(block_color, self.rgb_to_bgr((0, 0, 128))):
self.blocks_num[x][y] = 4

    elif self.equal(block_color, self.rgb_to_bgr((128, 0, 0))):
self.blocks_num[x][y] = 5

    elif self.equal(block_color, self.rgb_to_bgr((0, 128, 128))):
self.blocks_num[x][y] = 6

    elif self.equal(block_color, self.rgb_to_bgr((0, 0, 0))):
if self.equal(block[6, 6], self.rgb_to_bgr((255, 255, 255))):
            # Is mine
self.blocks_num[x][y] = 9
        elif self.equal(block[5, 8], self.rgb_to_bgr((255, 0, 0))):
            # Is flag
self.blocks_num[x][y] = 0
else:
self.blocks_num[x][y] = 7

    elif self.equal(block_color, self.rgb_to_bgr((128, 128, 128))):
self.blocks_num[x][y] = 8
else:
self.blocks_num[x][y] = -3
self.is_mine_form = False

if self.blocks_num[x][y] == -3 or not self.blocks_num[x][y] == -1:
self.is_new_start = False

能够看到，咱们采纳了读取每个雷块的中心点像素的形式来判断雷块的类别，并且针对插旗、未点开、已点开然而空白等状况进行了进一步判断。具体色值是笔者间接取色失去的，并且屏幕截图的色调也没有通过压缩，所以通过核心像素联合其余特色点来判断类别曾经足够了，并且做到了高效率。

在本我的项目中，咱们实现的时候采纳了如下标注形式：

• 1-8：示意数字 1 到 8
• 9：示意是地雷
• 0：示意插旗
• -1：示意未关上
• -2：示意关上然而空白
• -3：示意不是扫雷游戏中的任何方块类型

通过这种简略疾速又无效的形式，咱们胜利实现了高效率的图像识别。

04 扫雷算法实现

这可能是本篇文章最激动人心的局部了。在这里咱们须要先阐明一下具体的扫雷算法思路：

1. 遍历每一个曾经有数字的雷块，判断在它四周的九宫格内未被关上的雷块数量是否和自身数字雷同，如果雷同则表明四周九宫格内全部都是地雷，进行标记。
2. 再次遍历每一个有数字的雷块，取九宫格范畴内所有未被关上的雷块，去除曾经被上一次遍历标记为地雷的雷块，记录并且点开。
3. 如果以上形式无奈持续进行，那么阐明遇到了死局，抉择在以后所有未关上的雷块中随机点击。（当然这个办法不是最优的，有更加优良的解决方案，然而实现绝对麻烦）

根本的扫雷流程就是这样，那么让咱们来亲手实现它吧~

首先咱们须要一个可能找出一个雷块的九宫格范畴的所有方块地位的办法。因为扫雷游戏的特殊性，在棋盘的四边是没有九宫格的边缘局部的，所以咱们须要筛选来排除掉可能超过边界的拜访。​​​​​​​

def generate_kernel(k, k_width, k_height, block_location):

     ls = []
     loc_x, loc_y = block_location[0], block_location[1]

for now_y in range(k_height):
for now_x in range(k_width):
if k[now_y][now_x]:
                 rel_x, rel_y = now_x - 1, now_y - 1
                 ls.append((loc_y + rel_y, loc_x + rel_x))
return ls

 kernel_width, kernel_height = 3, 3

# Kernel mode:[Row][Col]
 kernel = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]

# Left border
if x == 0:
for i in range(kernel_height):
         kernel[i][0] = 0

# Right border
if x == self.blocks_x - 1:
for i in range(kernel_height):
         kernel[i][kernel_width - 1] = 0

# Top border
if y == 0:
for i in range(kernel_width):
         kernel[0][i] = 0

# Bottom border
if y == self.blocks_y - 1:
for i in range(kernel_width):
         kernel[kernel_height - 1][i] = 0

# Generate the search map
 to_visit = generate_kernel(kernel, kernel_width, kernel_height, location)

咱们在这一部分通过检测以后雷块是否在棋盘的各个边缘来进行核的删除（在核中，1 为保留，0 为舍弃），之后通过 generate_kernel 函数来进行最终坐标的生成。​​​​​​​

def count_unopen_blocks(blocks):
    count = 0
for single_block in blocks:
if self.blocks_num[single_block[1]][single_block[0]] == -1:
            count += 1
return count

def mark_as_mine(blocks):
for single_block in blocks:
if self.blocks_num[single_block[1]][single_block[0]] == -1:
self.blocks_is_mine[single_block[1]][single_block[0]] = 1

unopen_blocks = count_unopen_blocks(to_visit)
if unopen_blocks == self.blocks_num[x][y]:
     mark_as_mine(to_visit)

在实现核的生成之后，咱们有了一个须要去检测的雷块“地址簿”：to_visit。之后，咱们通过 count_unopen_blocks 函数来统计四周九宫格范畴的未关上数量，并且和以后雷块的数字进行比对，如果相等则将所有九宫格内雷块通过 mark_as_mine 函数来标注为地雷。

def mark_to_click_block(blocks):
for single_block in blocks:

# Not Mine
if not self.blocks_is_mine[single_block[1]][single_block[0]] == 1:
# Click-able
if self.blocks_num[single_block[1]][single_block[0]] == -1:

# Source Syntax: [y][x] - Converted
if not (single_block[1], single_block[0]) in self.next_steps:
self.next_steps.append((single_block[1], single_block[0]))

def count_mines(blocks):
    count = 0
for single_block in blocks:
if self.blocks_is_mine[single_block[1]][single_block[0]] == 1:
            count += 1
return count

mines_count = count_mines(to_visit)

if mines_count == block:
    mark_to_click_block(to_visit)

扫雷流程中的第二步咱们也采纳了和第一步相近的办法来实现。先用和第一步齐全一样的办法来生成须要拜访的雷块的核，之后生成具体的雷块地位，通过 count_mines 函数来获取九宫格范畴内所有雷块的数量，并且判断以后九宫格内所有雷块是否曾经被检测进去。

如果是，则通过 mark_to_click_block 函数来排除九宫格内曾经被标记为地雷的雷块，并且将残余的平安雷块退出 next_steps 数组内。

# Analyze the number of blocks
self.iterate_blocks_image(BoomMine.analyze_block)

# Mark all mines
self.iterate_blocks_number(BoomMine.detect_mine)

# Calculate where to click
self.iterate_blocks_number(BoomMine.detect_to_click_block)

if self.is_in_form(mouseOperation.get_mouse_point()):
for to_click in self.next_steps:
         on_screen_location = self.rel_loc_to_real(to_click)
         mouseOperation.mouse_move(on_screen_location[0], on_screen_location[1])
         mouseOperation.mouse_click()

在最终的实现内，笔者将几个过程都封装成为了函数，并且能够通过 iterate_blocks_number 办法来对所有雷块都应用传入的函数来进行解决，这有点相似 Python 中 Filter 的作用。

之后笔者做的工作就是判断以后鼠标地位是否在棋盘之内，如果是，就会主动开始辨认并且点击。具体的点击局部，笔者采纳了作者为 ”wp” 的一份代码（从互联网收集而得），外面实现了基于 win32api 的窗体音讯发送工作，进而实现了鼠标挪动和点击的操作。具体实现封装在 mouseOperation.py 中，有趣味能够在文末的 Github Repo 中查看。

​

我的项目残缺代码 /GitHub 地址 | ArtrixTech/BoomMine

最近整顿了一套编程学习材料分享给大家，全是干货内容，蕴含教程视频、电子书、源码笔记、学习路线图、实战我的项目、面试题等等，关注 gzh【Python 编程学习圈】就能收费获取，回复关键词【学习材料】即可，抓紧时间吧！