使用Python和TensorFlow编写的自动点击脚本，助您轻松开启托儿所

python开局托儿所自动点击脚本

屏幕截图

python 屏幕截图可以使用pyautogui或者PIL。我使用的是PIL中的ImageGrab(要授权)。

image = ImageGrab.grab(bbox=(0, 0, tool.static_window_width, tool.static_window_height))
image = np.array(image.getdata(), np.uint8).reshape(image.size[1], image.size[0], 4)
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

先上连接：开局托儿所
将截取的图片转成灰度图后就是下面这个样子。

接下来将每个数字截取出来。16行10列，共有160个数字。

for i in range(16):
			x_start = self.x_start
			x_end = x_start + self.num_width
			imgelist = list()
			center_pos = []
			for j in range(10):
				every_num = image[y_start:y_end,x_start:x_end]
				every_num = cv2.resize(every_num, (28, 28), interpolation=cv2.INTER_AREA)
				_, every_num = cv2.threshold(every_num, 127, 255, cv2.THRESH_BINARY)
				
				center_pos.append((x_start + self.num_width/2,y_start + self.num_width/2))
				imgelist.append(every_num)
				x_start += x_dis
				x_end   += x_dis

			self.imagelists.append(imgelist)
			self.center_pos.append(center_pos)
			y_start += y_dis
			y_end   += y_dis

图片数字识别

裁剪好图片就可以使用深度学习模型进行数字识别，这里也是使用经典的LeNet模型。首先要手动标注一部分数字作为训练集进行训练。（github链接包含我手动标注的训练集，可以直接使用）

有了训练集就可以开始训练模型。LeNet 网络结构：

def buildModel(self):
        self.model.add(Conv2D(input_shape=(28,28,1),filters=6, kernel_size=(5,5), strides=(1,1), padding='same', activation='relu'))
        self.model.add(MaxPool2D(pool_size=(2,2), strides=(2,2),padding='same'))
        self.model.add(Conv2D(filters=16, kernel_size=(5,5), strides=(1,1), padding='valid', activation='relu'))
        self.model.add(MaxPool2D(pool_size=(2,2), strides=(2,2),padding='same'))
        self.model.add(Conv2D(filters=120, kernel_size=(5,5), strides=(1,1), padding='valid', activation='relu'))
        self.model.add(MaxPool2D(pool_size=(2,2), strides=(2,2),padding='same'))
        self.model.add(Flatten())
        self.model.add(Dense(84, activation='relu'))
        self.model.add(Dense(9, activation='softmax'))
         # 形成网络（同时添加优化器）
        self.model.compile(loss='categorical_crossentropy',
                      optimizer=RMSprop(),
                      metrics=['accuracy'])

        self.load_model()
        # 查看网络结构，输出形状，参数个数
        print(self.model.summary())

训练好模型就可以对数字图片进行识别，

 def predict(self,imgs):
        predict = self.model.predict(imgs)
        index = np.argmax(predict,axis = 1)
        index=index.reshape(16,10)
        index += 1

        print(index)
        return index

消除算法

识别好图片后接下来就是消除了，算法思路是从左上角开始优先列遍历，贪心思想，只要遇到相加为10的就消除。step是一各栈结构，记录每一步，循环遍历，直到找不到解时候在回退。这里采用的固定回溯，每次回溯当前步数的4/5。在20s的时间内如果没有搜索完所有可能也要退出。

def comput_ij(self,i,j):
	yend = i 
	xend = j
	res = []
	while yend < len(self.map):
		sum = 0
		xend = j
		while xend < len(self.map[0]):
			for k in range(i,yend+1):
				sum += self.map[k][xend]
			if sum == 10:
				res.append((yend,xend))
			elif sum >10:
				if yend != i and xend == j :
					 return res
				else:
					break
			xend += 1
		yend += 1

	return res

def kjtes(self):
	time_start = time.time()
	time_end = time.time()

	while (time_end - time_start) <20:
		if not self.setps.is_empty():
			for t in range(int(self.setps.size() / 5 * 4)):
				self.backup()

		isfind = True
		while isfind:
			isfind = False
			i = 0
			while i < len(self.map):
				j = 0
				while j < len(self.map[0]):
					results = self.comput_ij(i,j)
					if len(results) >0 :
						for res in results:
							if(self.set_steps(i,j,res[0],res[1]) == True):
								isfind = True
								break
					j += 1
				i += 1
		
		new_map = np.array(self.map)
		cnt_array = np.where(new_map,0,1)
		score = np.sum(cnt_array)
		if score > self.score:
			print("------",score)
			self.score = score
			self.result = copy.deepcopy(self.current_result.items)

		time_end = time.time()
		if int(time_end- time_start ) % 10 == 0:
			print("耗时....",(time_end- time_start),self.score,self.max_size,self.min_size)
			print("------",self.score)

未完。。。明天继续

自动点击