• python 自动化学习(三） 句柄获取、模拟按键、opencv安装

    一、什么是句柄

         句柄是在操作系统中的一种标识符，相当于我们每个人的身份证一样，句柄在电脑中也是有唯一性的，我们启动的每一个程序都有自己的句柄号，表示自己的身份

        为什么要说句柄，我们如果想做自动化操作时，肯定也不想程序占用了我们整个电脑，稍微操作一下程序步骤就乱掉了，更加希望自动化程序在运行的时候能够只针对某个窗口或者某个程序进行操作，即使我们把自动化的程序放入都后台时也不影响两边的操作，这里就需要用到句柄了

    所需的包

    1. #配置清华镜像源
    2. pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
    3. pip config set global.trusted-host pypi.tuna.tsinghua.edu.cn
    4.  
    5. #安装依赖库
    6. pip install pywin32

    基本使用

    1. #部分参考文档
    2. https://huaweicloud.csdn.net/63803058dacf622b8df86819.html?spm=1001.2101.3001.6661.1&utm_medium=distribute.pc_relevant_t0.none-task-blog-2~default~BlogCommendFromBaidu~activity-1-122498299-blog-111083068.pc_relevant_vip_default&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-2~default~BlogCommendFromBaidu~activity-1-122498299-blog-111083068.pc_relevant_vip_default&utm_relevant_index=1

    1、获取鼠标所在位置程序的句柄

    1. import time
    2. import win32api
    3. import win32gui
    4.  
    5.  
    6. time.sleep(2)
    7.  
    8. point = win32api.GetCursorPos()  #win32api.GetCursorPos 获取鼠标当前的坐标(x,y)
    9.  
    10. hwnd = win32gui.WindowFromPoint(point)  #查看坐标位置窗口的句柄
    11.  
    12. print(hwnd)  #输出句柄

    如下图，我执行了3遍分别在执行后将鼠标放在文本、桌面、idea上面，返回了句柄ID

     

    2、通过句柄获取类名

     我们每次关闭重新打开一个程序会发现句柄值变了，每次都从头找句柄就太麻烦了

    每一个程序在开发之初就存在着一个叫"类名"的概念，类名和句柄每次变更不同，它在定义后几乎是不会发生变化的，所以我们最好是先找到一个程序的类名，后续直接通过类名找到句柄，然后在通过句柄进行真正所需要的操作

     vi main.py

    1. import time
    2. import win32api
    3. import win32gui
    4.  
    5. # 通过句柄获取窗口类名
    6. def get_clasname(hwnd):
    7.     clasname = win32gui.GetClassName(hwnd)
    8.     print('窗口类名:%s' % (clasname))
    9.     return clasname
    10.  
    11.  
    12.  
    13. time.sleep(2)
    14. point = win32api.GetCursorPos()
    15. hwnd = win32gui.WindowFromPoint(point)
    16.  
    17. #查看窗口类名
    18. get_clasname(hwnd)

     可以看到上面我们获取到了文档窗口的类名，现在开始我们直接通过类名去获取句柄

    3、通过类名获取句柄

    没有找到特定的方法，我们下面大概的思路就是先把主机上所有的句柄id都拿到，通过循环把所有句柄id的类名拿出来然后做对比，对的上的id都留在列表中，所以说如果开启了多个相同程序的窗口，我们也会获取到多个句柄

    1. import time
    2. import win32api
    3. import win32gui
    4.  
    5. #获取当前主机上的所有句柄id
    6. def get_all_windows():
    7.     all_window_handles = []
    8.  
    9.     # 枚举所有窗口句柄，添加到列表中
    10.     def enum_windows_proc(hwnd, param):
    11.         param.append(hwnd)
    12.         return True
    13.  
    14.     # 调用枚举窗口API
    15.     win32gui.EnumWindows(enum_windows_proc, all_window_handles)
    16.  
    17.     return all_window_handles  #返回的是一个句柄id的列表
    18.  
    19.  
    20. #查询传入的句柄id、类名
    21. def get_title(window_handle, class_name):
    22.     #查询句柄的类名
    23.     window_class = win32gui.GetClassName(window_handle)
    24.  
    25.     #判断窗口类名是否和指定的类名相同，如果相同则返回该窗口句柄，否则返回空值
    26.     if window_class == class_name:
    27.         return window_handle
    28.  
    29. #遍历窗口句柄的所有子窗口
    30. def get_child_windows(parent_window_handle):
    31.     child_window_handles = []
    32.     def enum_windows_proc(hwnd, param):
    33.         param.append(hwnd)
    34.         return True
    35.     #win32gui.EnumChildWindows    遍历窗口句柄的所有子窗口
    36.     win32gui.EnumChildWindows(parent_window_handle, enum_windows_proc, child_window_handles)
    37.     return child_window_handles
    38.  
    39.  
    40. # 根据标题查找窗口句柄
    41. def find_hwnd_by_title(title):
    42.     all_windows = get_all_windows()  #查询所有句柄
    43.     matched_windows = []      #存放所有匹配类名的句柄id
    44.  
    45.     # 在所有窗口中查找标题匹配的窗口句柄
    46.     for window_handle in all_windows:
    47.         #get_title方法  检查传入句柄对应的类名和我们实际的类名是否对应
    48.         window_title = get_title(window_handle, title)
    49.         if window_title:
    50.             matched_windows.append(window_title) #如果对应就写入列表
    51.  
    52.     # 如果没有匹配到，则在所有子窗口中查找标题匹配的窗口句柄
    53.     if matched_windows:
    54.         return matched_windows
    55.     else:
    56.         child_window_handles = []
    57.         for parent_window_handle in all_windows:
    58.             #不论子窗口是否有数据都追加到列表
    59.             child_window_handles.extend(get_child_windows(parent_window_handle))
    60.         for child_window_handle in child_window_handles:
    61.             if get_title(child_window_handle, title):
    62.                 matched_windows.append(get_title(child_window_handle, title))
    63.     return matched_windows
    64.  
    65. if __name__ == '__main__':
    66.     hwnd = find_hwnd_by_title("Edit")
    67.     print(hwnd)

     可以看到我们能够直接取到相同类名下所有已经打开的窗口句柄，这样我们甚至可以做个循环加多线程，来实现一个窗口并发的效果

    二、模拟按键

    上面我们已经拿到了文本文档的一个句柄信息，通过句柄我们可以做很多事情，最常见的就是模拟鼠标和键盘的按键操作，每个操作可能都较为细小琐碎，我们定义一个class类来存放

    常见消息类型和标识

    1. #官方参考
    2. https://learn.microsoft.com/zh-cn/windows/win32/inputdev/wm-lbuttondown
    消息类型作用消息标识作用
    WM_MOUSEMOVE鼠标 移动移动通用左键右键标识
    WM_RBUTTONDOWN鼠标 右键按下MK_RBUTTON左键按下
    WM_RBUTTONUP鼠标 右键释放None释放时无需标识
    WM_LBUTTONDOWN鼠标 左键按下MK_LBUTTON右键按下
    WM_LBUTTONUP鼠标 左键释放None释放时无需标识

     当按键需要被按下时，需要先声明消息类型，然后标明按键状态
      如果鼠标按键需要被释放时，可以直接通过释放按钮来释放
      如果指定消息类型是移动时，可以当作已经声明了消息类型，可以直接使用按键标识

    使用语法

    1. #在win32api下有个函数PostMessage，是用来与windows api交互的，参数如下
    2. 1、要发送消息的目标窗口的句柄
    3. 2、发送的消息类型
    4. 3、以及消息的参数 
    5.  
    6.  
    7. win32api.PostMessage(句柄id, 消息类型, 消息标识, 具体的坐标(x,y))

    获取目标坐标

    1. #获取坐标
    2. time.sleep(3)
    3. print(win32api.GetCursorPos())

    返回

    (328, 250)

     

    鼠标按键案例

          下面定义了一个类，先去接受我们上面获取到的句柄id，在使用鼠标按键的时候调用win32api.PostMessage函数 去发送给句柄所在的窗口按键信息

       在左右键按下的时候才需要定义标识，比如模拟左键时会使用WM_LBUTTONDOWN和MK_LBUTTON  ，而松开时使用WM_LBUTTONUP和None

       变量pos 是只鼠标按键的坐标，需要通过win32api.MAKELONG 转换数据类型后才能调用

    1.  
    2. #声明鼠标操作的类
    3. class WinMouse(object):
    4.  
    5.     #初始化函数，接受传入的句柄id
    6.     def __init__(self, handle_num: int):
    7.         self.handle = handle_num  
    8.  
    9.     #鼠标左键按下
    10.     def left_button_down(self, pos):
    11.             win32api.PostMessage(self.handle, win32con.WM_LBUTTONDOWN, win32con.MK_LBUTTON, pos)
    12.  
    13.     #鼠标左键释放
    14.     def left_button_up(self, pos):
    15.         win32api.PostMessage(self.handle, win32con.WM_LBUTTONUP, None, pos)
    16.  
    17.  
    18.  
    19. if __name__ == '__main__':
    20.     hwnd = find_hwnd_by_title("Edit")   #通过类名获取句柄
    21.     bd = WinMouse(hwnd[0])              #实例化WinMouse 类,传入句柄值
    22.  
    23.     pos = win32api.MAKELONG(328, 250)   #将正常的x，y坐标值转换为特定的数据结构，
    24.                                        #给win32api.PostMessage调用
    25.  
    26.     #按下、等待1s、松开
    27.     bd.left_button_down(pos)  
    28.     time.sleep(1)             
    29.     bd.left_button_up(pos)

    可以看到在下图中，我们运行程序后，不论文本文档是否在前台还是后台，哪怕被遮挡住后也会照常进行鼠标点击(数字太多看不清，大致就是我把鼠标放到末尾，程序在我上面取坐标的地方点一下左键）

    其他按键补全

    1.     #按下鼠标左键并移动
    2.     def mouse_move(self, pos):
    3.         win32api.PostMessage(self.handle, win32con.WM_MOUSEMOVE, win32con.MK_LBUTTON, pos)
    4.  
    5.     #按下鼠标右键并移动
    6.     def right_button_move(self, pos):
    7.         win32api.PostMessage(self.handle, win32con.WM_MOUSEMOVE, win32con.MK_RBUTTON, pos)
    8.  
    9.     #指定坐标按下右键
    10.     def right_button_down(self, pos):
    11.         win32api.PostMessage(self.handle, win32con.WM_RBUTTONDOWN, win32con.MK_RBUTTON, pos)
    12.     #右键释放
    13.     def right_button_up(self, pos):
    14.         win32api.PostMessage(self.handle, win32con.WM_RBUTTONUP, None, pos)
    15.  
    16.     #模拟左键双击
    17.     def left_double_click(self, x_pos:int, y_pos:int, click=2, wait=0.4):
    18.         wait = wait / click  #click 表示点击次数，wait是的等待时间，意思是双击的间隔
    19.         point = win32api.MAKELONG(x_pos, y_pos)
    20.         for i in range(click):
    21.             self.left_button_down(point)
    22.             time.sleep(wait)
    23.             self.left_button_up(point)
    24.     #右键双击
    25.     def right_doubleClick(self, x, y, click=2, wait=0.4):
    26.         wait = wait / click
    27.         pos = win32api.MAKELONG(x, y)
    28.         for i in range(click):
    29.             self.right_button_down(pos)
    30.             time.sleep(wait)
    31.             self.right_button_up(pos)

    按键组合函数

    上面用一个按左键都要好几行，我们这里在给封装一下

    1.     #让他可以直接接收x，y坐标，wait是松开按键的间隔，一般默认即可
    2.     #左键单击
    3.     def left_click(self, x_pos:int, y_pos:int, wait=0.2):
    4.         point = win32api.MAKELONG(x_pos, y_pos)
    5.         self.left_button_down(point)
    6.         time.sleep(wait)
    7.         self.left_button_up(point)
    8.  
    9.     #右键单击
    10.     def right_click(self, x_pos:int, y_pos:int, wait=0.2):
    11.         point = win32api.MAKELONG(x_pos, y_pos)
    12.         self.right_button_down(point)
    13.         time.sleep(wait)
    14.         self.right_button_up(point)
    15.  
    16.     #模拟左键双击
    17.     def left_double_click(self, x_pos:int, y_pos:int, click=2, wait=0.4):
    18.         wait = wait / click  #click 表示点击次数，wait是的等待时间，意思是双击的间隔
    19.         point = win32api.MAKELONG(x_pos, y_pos)
    20.         for i in range(click):
    21.             self.left_button_down(point)
    22.             time.sleep(wait)
    23.             self.left_button_up(point)
    24.     #右键双击
    25.     def right_doubleClick(self, x, y, click=2, wait=0.4):
    26.         wait = wait / click
    27.         pos = win32api.MAKELONG(x, y)
    28.         for i in range(click):
    29.             self.right_button_down(pos)
    30.             time.sleep(wait)
    31.             self.right_button_up(pos)

    鼠标滑动拖拽

    添加偏移值

     vi main.py

    1. #计算鼠标从起始点到目标点的偏移过程
    2. def getPointOnLine(start_x, start_y, end_x, end_y, ratio):
    3.     x = ((end_x - start_x) * ratio) + start_x
    4.     y = ((end_y - start_y) * ratio) + start_y
    5.     return int(round(x)), int(round(y))
    6.  
    7.  
    8. class WinMouse(object):
    9.  
    10.     def __init__(self, handle_num: int, num_of_steps=80): #添加num_of_steps=80
    11.         self.handle = handle_num
    12.         self.num_of_steps = num_of_steps  #添加偏移值

    添加左右键拖动方法

    1.     #模拟点击并拖拽目标，接受两对坐标值
    2.     def left_click_move(self, x1:int, y1:int, x2:int, y2:int, wait=2):
    3.         point1 = win32api.MAKELONG(x1, y1)
    4.         self.left_button_down(point1)  #起始点按下鼠标左键
    5.         #获取我们在init初始化时定义的偏移值
    6.         steps = self.num_of_steps
    7.  
    8.         #调用我们上面的方法返回具体，循环0-80的值
    9.         #你看这里的循环值是80，也就说会做80次循环操作
    10.         #我们传入了起始坐标和目标坐标，而i / steps就相当于起始到结束的偏移位置
    11.         #可以理解为从左上角到右下角的点
    12.         points = [getPointOnLine(x1, y1, x2, y2,  i / steps) for i in range(steps)]
    13.         points.append((x2, y2))
    14.         wait_time = wait / steps
    15.         unique_points = list(set(points))
    16.         unique_points.sort(key=points.index)
    17.         for point in unique_points:
    18.             x, y = point
    19.             point = win32api.MAKELONG(x, y)
    20.             self.mouse_move(point)
    21.             time.sleep(wait_time)
    22.         self.left_button_up(point)
    23.     #右键单击并滑动批量勾选（与上方函数同理）
    24.     def right_click_move(self, start_x, start_y, end_x, end_y, wait=2):
    25.         pos = win32api.MAKELONG(start_x, start_y)
    26.         self.right_button_down(pos)
    27.         steps = self.num_of_steps
    28.         points = [getPointOnLine(start_x, start_y, end_x, end_y, i / steps) for i in range(steps)]
    29.         points.append((end_x, end_y))
    30.         time_per_step = wait / steps
    31.         distinct_points = list(set(points))
    32.         distinct_points.sort(key=points.index)
    33.         for point in distinct_points:
    34.             x, y = point
    35.             pos = win32api.MAKELONG(x, y)
    36.             self.right_button_move(pos)
    37.             time.sleep(time_per_step)
    38.         self.right_button_up(pos)

    演示

        bd.left_click_move(109,180,232,341)

    全量代码

    1.  
    2. import time
    3. import win32api
    4. import win32con
    5. import win32gui
    6.  
    7.  
    8.  
    9.  
    10. #---------------------------------------------------句柄配置的分割线
    11. #获取当前主机上的所有句柄id
    12. def get_all_windows():
    13.     all_window_handles = []
    14.  
    15.     # 枚举所有窗口句柄，添加到列表中
    16.     def enum_windows_proc(hwnd, param):
    17.         param.append(hwnd)
    18.         return True
    19.  
    20.     # 调用枚举窗口API
    21.     win32gui.EnumWindows(enum_windows_proc, all_window_handles)
    22.  
    23.     return all_window_handles  #返回的是一个句柄id的列表
    24.  
    25. #查询传入的句柄id、类名
    26. def get_title(window_handle, class_name):
    27.     #查询句柄的类名
    28.     window_class = win32gui.GetClassName(window_handle)
    29.  
    30.     #判断窗口类名是否和指定的类名相同，如果相同则返回该窗口句柄，否则返回空值
    31.     if window_class == class_name:
    32.         return window_handle
    33.  
    34. #遍历窗口句柄的所有子窗口
    35. def get_child_windows(parent_window_handle):
    36.     child_window_handles = []
    37.     def enum_windows_proc(hwnd, param):
    38.         param.append(hwnd)
    39.         return True
    40.     #win32gui.EnumChildWindows    遍历窗口句柄的所有子窗口
    41.     win32gui.EnumChildWindows(parent_window_handle, enum_windows_proc, child_window_handles)
    42.     return child_window_handles
    43.  
    44. # 根据标题查找窗口句柄
    45. def find_hwnd_by_title(title):
    46.     all_windows = get_all_windows()  #查询所有句柄
    47.     matched_windows = []      #存放所有匹配类名的句柄id
    48.  
    49.     # 在所有窗口中查找标题匹配的窗口句柄
    50.     for window_handle in all_windows:
    51.         #get_title方法  检查传入句柄对应的类名和我们实际的类名是否对应
    52.         window_title = get_title(window_handle, title)
    53.         if window_title:
    54.             matched_windows.append(window_title) #如果对应就写入列表
    55.  
    56.     # 如果没有匹配到，则在所有子窗口中查找标题匹配的窗口句柄
    57.     if matched_windows:
    58.         return matched_windows
    59.     else:
    60.         child_window_handles = []
    61.         for parent_window_handle in all_windows:
    62.             #不论子窗口是否有数据都追加到列表
    63.             child_window_handles.extend(get_child_windows(parent_window_handle))
    64.         for child_window_handle in child_window_handles:
    65.             if get_title(child_window_handle, title):
    66.                 matched_windows.append(get_title(child_window_handle, title))
    67.     return matched_windows
    68.  
    69. #-----------------------------------------------------句柄配置的分割线
    70.  
    71.  
    72. def getPointOnLine(start_x, start_y, end_x, end_y, ratio):
    73.     x = ((end_x - start_x) * ratio) + start_x
    74.     y = ((end_y - start_y) * ratio) + start_y
    75.     return int(round(x)), int(round(y))
    76.  
    77. #声明鼠标操作的类
    78. class WinMouse(object):
    79.  
    80.     #初始化函数，接受传入的句柄id
    81.     def __init__(self, handle_num: int, num_of_steps=80):
    82.         self.handle = handle_num
    83.         self.num_of_steps = num_of_steps
    84.  
    85.         #鼠标左键按下
    86.     def left_button_down(self, pos):
    87.         win32api.PostMessage(self.handle, win32con.WM_LBUTTONDOWN, win32con.MK_LBUTTON, pos)
    88.  
    89.     #鼠标左键释放
    90.     def left_button_up(self, pos):
    91.         win32api.PostMessage(self.handle, win32con.WM_LBUTTONUP, None, pos)
    92.  
    93.     #按下鼠标左键并移动
    94.     def mouse_move(self, pos):
    95.         win32api.PostMessage(self.handle, win32con.WM_MOUSEMOVE, win32con.MK_LBUTTON, pos)
    96.  
    97.     #按下鼠标右键并移动
    98.     def right_button_move(self, pos):
    99.         win32api.PostMessage(self.handle, win32con.WM_MOUSEMOVE, win32con.MK_RBUTTON, pos)
    100.  
    101.     #指定坐标按下右键
    102.     def right_button_down(self, pos):
    103.         win32api.PostMessage(self.handle, win32con.WM_RBUTTONDOWN, win32con.MK_RBUTTON, pos)
    104.     #右键释放
    105.     def right_button_up(self, pos):
    106.         win32api.PostMessage(self.handle, win32con.WM_RBUTTONUP, None, pos)
    107.  
    108.     #--------------------------------------------------------封装按键方法的分割线
    109.  
    110.     #让他可以直接接收x，y坐标，wait是松开按键的间隔，一般默认即可
    111.     #左键单击
    112.     def left_click(self, x_pos:int, y_pos:int, wait=0.2):
    113.         point = win32api.MAKELONG(x_pos, y_pos)
    114.         self.left_button_down(point)
    115.         time.sleep(wait)
    116.         self.left_button_up(point)
    117.  
    118.     #右键单击
    119.     def right_click(self, x_pos:int, y_pos:int, wait=0.2):
    120.         point = win32api.MAKELONG(x_pos, y_pos)
    121.         self.right_button_down(point)
    122.         time.sleep(wait)
    123.         self.right_button_up(point)
    124.  
    125.     #模拟左键双击
    126.     def left_double_click(self, x_pos:int, y_pos:int, click=2, wait=0.4):
    127.         wait = wait / click  #click 表示点击次数，wait是的等待时间，意思是双击的间隔
    128.         point = win32api.MAKELONG(x_pos, y_pos)
    129.         for i in range(click):
    130.             self.left_button_down(point)
    131.             time.sleep(wait)
    132.             self.left_button_up(point)
    133.     #右键双击
    134.     def right_doubleClick(self, x, y, click=2, wait=0.4):
    135.         wait = wait / click
    136.         pos = win32api.MAKELONG(x, y)
    137.         for i in range(click):
    138.             self.right_button_down(pos)
    139.             time.sleep(wait)
    140.             self.right_button_up(pos)
    141.  
    142.  
    143.     #模拟点击并拖拽目标，接受两对坐标值
    144.     #模拟点击并拖拽目标，接受两对坐标值
    145.     def left_click_move(self, x1:int, y1:int, x2:int, y2:int, wait=2):
    146.         point1 = win32api.MAKELONG(x1, y1)
    147.         self.left_button_down(point1)  #起始点按下鼠标左键
    148.         #获取我们在init初始化时定义的偏移值
    149.         steps = self.num_of_steps
    150.  
    151.         #调用我们上面的方法返回具体，循环0-80的值
    152.         #你看这里的循环值是80，也就说会做80次循环操作
    153.         #我们传入了起始坐标和目标坐标，而i / steps就相当于起始到结束的偏移位置
    154.         #可以理解为从左上角到右下角的点
    155.         points = [getPointOnLine(x1, y1, x2, y2,  i / steps) for i in range(steps)]
    156.         points.append((x2, y2))
    157.         wait_time = wait / steps
    158.         unique_points = list(set(points))
    159.         unique_points.sort(key=points.index)
    160.         for point in unique_points:
    161.             x, y = point
    162.             point = win32api.MAKELONG(x, y)
    163.             self.mouse_move(point)
    164.             time.sleep(wait_time)
    165.         self.left_button_up(point)
    166.     #右键单击并滑动批量勾选（与上方函数同理）
    167.     def right_click_move(self, start_x, start_y, end_x, end_y, wait=2):
    168.         pos = win32api.MAKELONG(start_x, start_y)
    169.         self.right_button_down(pos)
    170.         steps = self.num_of_steps
    171.         points = [getPointOnLine(start_x, start_y, end_x, end_y, i / steps) for i in range(steps)]
    172.         points.append((end_x, end_y))
    173.         time_per_step = wait / steps
    174.         distinct_points = list(set(points))
    175.         distinct_points.sort(key=points.index)
    176.         for point in distinct_points:
    177.             x, y = point
    178.             pos = win32api.MAKELONG(x, y)
    179.             self.right_button_move(pos)
    180.             time.sleep(time_per_step)
    181.         self.right_button_up(pos)
    182.  
    183. if __name__ == '__main__':
    184.     hwnd = find_hwnd_by_title("Edit")   #通过类名获取句柄
    185.     bd = WinMouse(hwnd[0])              #实例化WinMouse 类,传入句柄值
    186.  
    187.     bd.left_click_move(109,180,232,341)

    三、准备opencv环境

    我们上面简单的实现了鼠标后台模拟操作，但是存在一个问题，坐标都是我们固定好的，而在实际使用中，我们的要点击的坐标一定是多变的，我们更希望当我们要做自动化操作的时候，给他一个图片，然后就能拿到对应点击位置的一个坐标

    安装模块

    1. pip install opencv-python
    2. pip install pillow
    3. pip install opencv-contrib-python
    4. pip install numpy
    5. pip install PIL

    我这边在安装上opencv-python 后调用cv2下任意方法都提示报黄，没有代码提示，下面列出解决方法

    1. (venv) PS C:\Users\Administrator\IdeaProjects\test> pip install opencv-python
    2. Looking in indexes: https://pypi.tuna.tsinghua.edu.cn/simple
    3. Requirement already satisfied: opencv-python in c:\users\administrator\ideaprojects\test\venv\lib\site-packages (4.7.0.72)
    4. Requirement already satisfied: numpy>=1.21.2 in c:\users\administrator\ideaprojects\test\venv\lib\site-packages (from opencv-python) (1.24.3)

    我们在安装成功opencv-python模块后会返回一个安装路径，登录这个路径，进入cv2的目录下，将cv2.pyd 文件放到下面的路径下，重启编辑器即可

    c:\users\administrator\ideaprojects\test\venv\lib\site-packages

     

    1.  pip install opencv-contrib-python
    2.  
    3. 后来发现 单独装这个，不装opencv也可以用，还剩的复制文件，先看看，没问题就改

    测试语句

    1. import cv2
    2. # 加载一张图片
    3. img = cv2.imread('11.png', 1)   #脚本文件旁边自行准备一个图片
    4.  
    5. # 显示图片
    6. cv2.imshow('image', img)
    7. cv2.waitKey(0)
    8. cv2.destroyAllWindows()

    1、添加截图函数

    首先，我们想要获取想要获取小图所在的坐标，要先拿到大图的信息，这里我们以桌面为案例，通过获取桌面的句柄信息，然后进行截图

    vi main.py

    1. def capture_window(hwnd,img):
    2.     # 获取句柄窗口位置
    3.     left, top, right, bottom = win32gui.GetWindowRect(hwnd)
    4.     width = right - left
    5.     height = bottom - top
    6.  
    7.     # 获取窗口DC
    8.     hwndDC = win32gui.GetWindowDC(hwnd)
    9.     mfcDC = win32ui.CreateDCFromHandle(hwndDC)
    10.     saveDC = mfcDC.CreateCompatibleDC()
    11.  
    12.     # 创建位图对象
    13.     saveBitMap = win32ui.CreateBitmap()
    14.     saveBitMap.CreateCompatibleBitmap(mfcDC, width, height)
    15.  
    16.     saveDC.SelectObject(saveBitMap)
    17.  
    18.     # 截取窗口内容
    19.     saveDC.BitBlt((0, 0), (width, height), mfcDC, (0, 0), win32con.SRCCOPY)
    20.  
    21.     # 保存位图到内存中
    22.     bmpinfo = saveBitMap.GetInfo()
    23.     bmpstr = saveBitMap.GetBitmapBits(True)
    24.  
    25.     # 将位图数据转换为OpenCV格式
    26.     image = np.frombuffer(bmpstr, dtype='uint8')
    27.     image.shape = (height, width, 4)
    28.  
    29.     # 释放资源
    30.     win32gui.DeleteObject(saveBitMap.GetHandle())
    31.     saveDC.DeleteDC()
    32.     mfcDC.DeleteDC()
    33.     win32gui.ReleaseDC(hwnd, hwndDC)
    34.  
    35.  
    36.     #文件保存
    37.     # 转换为BGR格式
    38.     bgr_image = cv2.cvtColor(image, cv2.COLOR_BGRA2BGR)
    39.  
    40.     # 保存图像到文件
    41.     cv2.imwrite(img, bgr_image)
    42.  
    43.     return cv2.cvtColor(image, cv2.COLOR_BGRA2BGR)

    vi main.py

    1. if __name__ == '__main__':
    2.     hwnd = find_hwnd_by_title("SysListView32")   
    3.  
    4.  
    5.     #调用截取特定句柄窗口截图
    6.     capture_window(hwnd[0])

    不知道是不是我服务器配置太低了，图片生成查不到20s左右，不过没关系，这里出图只是看一眼，后面不用

    2、对比小图片在句柄窗口坐标

    这里我们截一张句柄窗口内的截图，范围越小，误差越小  这里命名为111.png文件，那个大图文件不用管他

    1. def EtachImage(mix_img,large_image):
    2.     # 选择匹配方法
    3.     method = cv2.TM_SQDIFF_NORMED
    4.     # method = cv2.TM_CCOEFF_NORMED
    5.  
    6.     # 读取小图
    7.     small_image = cv2.imread(mix_img)
    8.  
    9.     # 使用模板匹配
    10.     result = cv2.matchTemplate(small_image, large_image, method)
    11.     mn, _, mnLoc, _ = cv2.minMaxLoc(result)
    12.  
    13.     # 提取最佳匹配的坐标
    14.     MPx, MPy = mnLoc
    15.     #print("矩形框左上角坐标：({}, {})".format(MPx, MPy))
    16.  
    17.     # 获取小图尺寸
    18.     trows, tcols = small_image.shape[:2]
    19.  
    20.     # 在大图上绘制矩形框
    21.     cv2.rectangle(large_image, (MPx, MPy), (MPx + tcols, MPy + trows), (0, 0, 255), 2)
    22.  
    23.     #显示大图，没居中之前的矩形
    24.     # cv2.imshow('output', large_image)
    25.     # cv2.waitKey(0)
    26.     # cv2.destroyAllWindows()
    27.  
    28.  
    29.     # 计算矩形框中心点坐标
    30.     center_x = int(MPx + tcols / 2)
    31.     center_y = int(MPy + trows / 2)
    32.  
    33.     # 在大图上绘制中心点
    34.     cv2.circle(large_image, (center_x, center_y), 5, (255, 0, 0), -1)
    35.  
    36.     # 显示带有中心点的大图
    37.     cv2.imshow('output', large_image)
    38.     cv2.waitKey(0)
    39.     cv2.destroyAllWindows()
    40.  
    41.     # 返回中心点坐标
    42.     return center_x, center_y

    vi main.py

    1. if __name__ == '__main__':
    2.     hwnd = find_hwnd_by_title("SysListView32")
    3.  
    4.  
    5.     # 获取大图截图
    6.     large_image = capture_window(hwnd[0],"asdf.png")
    7.  
    8.     # 匹配小图所处的大图坐标
    9.     x, y = EtachImage('111.png',large_image)
    10.     print(x, y)

    3、验证获取的坐标是否准确

    这里为了方便查看，将显示图片的那个注释掉了

    1. def EtachImage(mix_img,large_image):
    2.     。。。
    3.  
    4.  
    5.     # 显示带有中心点的大图
    6.     # cv2.imshow('output', large_image)
    7.     # cv2.waitKey(0)
    8.     # cv2.destroyAllWindows()
    9.  
    10.     # 返回中心点坐标
    11.     return center_x, center_y

    vi test.py

    1. import cv2
    2. import pyautogui
    3.  
    4. # 将鼠标移动到矩形框中心点坐标处
    5. pyautogui.moveTo(425, 161, duration=1)
    6.  
    7. # 输出提示信息
    8. print("鼠标已移动到矩形框中心点坐标处")
    9.  
    10. # 等待一段时间
    11. cv2.waitKey(3000)  # 暂停3秒，方便观察

    ok 坐标能拿到了，剩下的就靠发挥想象力喽

     （我碰到的一个bug，我是win server主机，如果把图标放到最下面哪一行，就会出现无法识别了，看截图也是截不到的区域，感觉是分辨率问题，不知道pc端有没有相似问题，注意一下）

  • 相关阅读:
    学习pytorch15 优化器
    力扣 1668. 最大重复子字符串
    从多表连接视图对比人大金仓和Oracle
    灰色和测试环境打包串台
    java spring cloud 企业电子招标采购系统源码:营造全面规范安全的电子招投标环境，促进招投标市场健康可持续发展
    Python制作炫酷的个人足迹地图
    高性能设计要点
    NewStarCTF2023week2-include 0。0
    Seaborn绘制热力图的子图
    2022-08-01
  • 原文地址：https://blog.csdn.net/qq_42883074/article/details/130825811