Python的GUI应用，用于实时监控屏幕区域的图片变化

如何使用Python监控屏幕变化并截图

1、导入所需模块

首先，我们需要导入一些Python模块，包括PIL（Python Imaging Library）、numpy、os和time。这些模块将帮助我们截取屏幕图像，并进行文件和时间相关的操作。

from PIL import ImageGrab  # 导入ImageGrab模块，用于截取屏幕图像
import numpy as np  # 导入numpy模块，用于处理图像数据
import os  # 导入os模块，用于文件和文件夹操作
import time  # 导入time模块，用于时间相关操作

2、设置截图保存路径

接下来，我们将设置截图保存的路径。在本例中，我们将截图保存到用户桌面的一个名为“Screenshots”的文件夹中。

desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")  # 获取当前用户的桌面路径
screenshot_folder = os.path.join(desktop_path, "Screenshots")  # 设置截图保存文件夹路径
os.makedirs(screenshot_folder, exist_ok=True)  # 创建截图保存文件夹，如果文件夹已存在则忽略

3、定义监控区域

我们需要定义要监控的屏幕区域的左上角和右下角坐标。在这个示例中，我们选择了一个800x600像素的区域

monitor_region = (0, 0, 800, 600)  # 示例：左上角(0, 0)，右下角(800, 600)

4、初始化上一次截图

我们将使用一个变量来保存上一次的屏幕截图，以便与当前截图进行比较，以检测屏幕是否发生了变化。

last_screenshot = ImageGrab.grab(bbox=monitor_region)  # 截取指定区域的屏幕图像，并赋值给last_screenshot变量

5、监控屏幕变化并截图

现在，我们将进入一个无限循环，在循环中持续监控屏幕的变化。当检测到屏幕发生变化时，我们将进行截图并保存。

try:
    while True:  # 进入无限循环，持续监控屏幕变化
        # 获取当前屏幕截图
        current_screenshot = ImageGrab.grab(bbox=monitor_region)  # 截取指定区域的屏幕图像，并赋值给current_screenshot变量

        # 将图像转换为 NumPy 数组...

        # 计算监控区域的像素值差异...

        # 检查像素值差异是否超过阈值...

        # 保存截图...

        # 输出截图信息...

        # 更新上一次截图...

        # 每隔一定时间进行一次截图...
except KeyboardInterrupt:  # 捕获键盘中断异常，用于停止监控
    print("Monitoring stopped.")  # 打印停止监控的提示信息

6、完整代码

from PIL import ImageGrab  # 导入ImageGrab模块，用于截取屏幕图像
import numpy as np  # 导入numpy模块，用于处理图像数据
import os  # 导入os模块，用于文件和文件夹操作
import time  # 导入time模块，用于时间相关操作

# 设置截图保存路径
desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")  # 获取当前用户的桌面路径
screenshot_folder = os.path.join(desktop_path, "Screenshots")  # 设置截图保存文件夹路径
os.makedirs(screenshot_folder, exist_ok=True)  # 创建截图保存文件夹，如果文件夹已存在则忽略

# 定义监控区域的左上角和右下角坐标
monitor_region = (0, 0, 800, 600)  # 示例：左上角(0, 0)，右下角(800, 600)

# 初始化上一次截图
last_screenshot = ImageGrab.grab(bbox=monitor_region)  # 截取指定区域的屏幕图像，并赋值给last_screenshot变量

try:
    while True:  # 进入无限循环，持续监控屏幕变化
        # 获取当前屏幕截图
        current_screenshot = ImageGrab.grab(bbox=monitor_region)  # 截取指定区域的屏幕图像，并赋值给current_screenshot变量

        # 将图像转换为 NumPy 数组
        current_screenshot_array = np.array(current_screenshot)  # 将当前截图转换为NumPy数组
        last_screenshot_array = np.array(last_screenshot)  # 将上一次截图转换为NumPy数组

        # 计算监控区域的像素值差异
        pixel_diff = np.sum(current_screenshot_array != last_screenshot_array)  # 计算两张截图像素差异的总和

        # 检查像素值差异是否超过阈值（根据具体情况调整阈值）
        threshold = 1000  # 示例阈值，根据实际情况调整
        if pixel_diff > threshold:  # 如果像素值差异超过阈值，则表示屏幕发生了变化
            # 生成截图文件名
            screenshot_filename = f"screenshot_{int(time.time())}.png"  # 根据当前时间生成截图文件名
            screenshot_path = os.path.join(screenshot_folder, screenshot_filename)  # 拼接截图文件路径

            # 保存截图
            current_screenshot.save(screenshot_path)  # 将当前截图保存为图片文件

            # 输出截图信息
            print(f"Screenshot saved: {screenshot_path}")  # 打印截图保存路径

            # 更新上一次截图
            last_screenshot = current_screenshot  # 将当前截图赋值给上一次截图，以便下一次比较

        # 每隔一定时间进行一次截图
        time.sleep(5)  # 5秒钟检查一次屏幕变化，可根据需要调整
except KeyboardInterrupt:  # 捕获键盘中断异常，用于停止监控
    print("Monitoring stopped.")  # 打印停止监控的提示信息

分类: Python , Windows , 自动截屏

标签: python , 开发语言

监控一个界面的内容变化，以确保自己能第一时间留意到，总不能一直看着吧？
于是我写了一个Python脚本去帮我看。原理就是实时获取界面像素，只要像素变化，代表界面有变化。

jiankong.py

[Python] 纯文本查看 复制代码

from PIL import ImageGrab
import numpy as np
import time
import requests  # Import the requests library
 
def get_screen_region_screenshot(region):
    """
    获取屏幕指定区域的截图
    """
    screenshot = ImageGrab.grab(bbox=region)
    return np.array(screenshot)
 
def send_http_request():
    """
    发送HTTP请求的函数
    """
    # 替换接收通知的Url，我这里使用的是iOS的Bark App
    url = "https://xxxxxxxxxxxxxxxx"
    payload = {"key": "value"}
    headers = {"Content-Type": "application/json"}
 
    response = requests.post(url, json=payload, headers=headers)
 
    # 打印结果
    print("HTTP Response:", response.text)
 
def monitor_screen_region_changes(region, polling_interval=1):
    """
    监控屏幕指定区域的像素变化
    """
    previous_screenshot = get_screen_region_screenshot(region)
 
    while True:
        current_screenshot = get_screen_region_screenshot(region)
 
        if not np.array_equal(previous_screenshot, current_screenshot):
            print("指定区域的像素发生变化")
            # 发送HTTP请求
            send_http_request()
 
            # 更新前一次的截图
            previous_screenshot = current_screenshot
 
        time.sleep(polling_interval)
 
if __name__ == "__main__":
 
    # 替换为要监控的区域坐标 (left, top, right, bottom)
    # left：左上角距离屏幕左侧的距离（像素）
    # top：左上角距离屏幕上方的距离（像素）
    # right：右下角距离屏幕左侧的距离（像素）
    # bottom：右下角距离屏幕上方的距离（像素）
    region_to_monitor = (0, 0, 100, 100) 
     
    monitor_screen_region_changes(region_to_monitor)

如何获得坐标？截图软件一般都有标注像素。

运行

接收通知：

Python的GUI应用，用于实时监控屏幕区域的图片变化，并通过图像哈希比较来检测相似度变化，触发警报。它利用Tkinter、PyAutoGUI和PIL库进行图像处理，以及pygame库处理声音。

摘要由CSDN通过智能技术生成

代码拿走就能跑

很乱才开始学

import sys
import tkinter as tk
#创建图形用户界面（GUI）的标准库
import time
import cv2
#图片处理库
#import numpy as np
import pyautogui
#键鼠库
import pygame
#播放声音用，这个库有点大，但是我测试其他3个库都不好使，只能用这个
from PIL import Image, ImageTk
#图像处理库
import threading
#线程库
from datetime import datetime
#时间库
start_x, start_y, end_x, end_y = None, None, None, None
#选取的区域坐标
from imagehash import average_hash
pinlv=2 #监控频率第二版是把图片读取到内存操作所以可以每秒一次
import io
should_exit = False
im0imagehas=0 #选区的hash值用全局
isarm=False
i=0
def print_to_text(*args):
global i
global isarm
i=i+1
if 8 < i :
text_widget.delete(1.0, tk.END)#执行8次后清空一下txt，让txt一直滚动方便进行监控
i=0
for arg in args:

if not isarm:
text_widget.tag_configure('red_text', foreground='blue')#正常字体
if isarm :
text_widget.tag_configure('red_text', foreground='red')#报警为红色
text_widget.insert('end', str(arg), 'red_text' )
text_widget.insert('end','\n')
text_widget.yview_scroll(1, 'units') # 向下滚动一格
# 将print的输出重定向到text_widget
print = print_to_text.__get__(None, print)
# 这将全局print函数绑定到text_widget

#按坐标获取切图
def qie_tu(img01=None):
global start_x, start_y, end_x, end_y
global disktoptu

# 使用pyautogui进行屏幕截图
screenshot = pyautogui.screenshot()
#screenshot.save('temp.png', format='png')
# 使用BytesIO将图像保持到内存中
crop_bytes0 = io.BytesIO()
screenshot.save(crop_bytes0, format='png')
# 读取到内存中的图像数据
crop_bytes0 = crop_bytes0.getvalue()
# 打开图像
img = Image.open(io.BytesIO(crop_bytes0))
# 截取部分图像
disktoptu=img
crop = img.crop((start_x,start_y ,end_x, end_y))
# 使用BytesIO将图像保持到内存中
crop_bytes = io.BytesIO()
crop.save(crop_bytes, format='png')
# 读取到内存中的图像数据
crop_bytes = crop_bytes.getvalue()
# 对内存中的图像进行处理，例如调整大小
# 这里使用的是PIL库的Image类，你可以根据需要进行其他操作
im0 = Image.open(io.BytesIO(crop_bytes))
# 如果需要，你可以在此处进行其他操作，例如旋转、裁剪等。
# 在完成所有操作后，你可以使用下面的代码将图像保存到磁盘。

imimagehash=average_hash(im0)#image hash
img.save('desktop_screenshot.png', format='png') # 将处理后的图像保存到磁盘
if img01 != None:
im0.save(img01, format='png') # 将处理后的图像保存到磁盘
return (str(imimagehash))

#鼠标选区并截取
def select_screen_region():
load_alarm_sound("警报声.mp3")#放到这里防止错误提示终止运行
text_widget.delete(1.0, tk.END)
print('点击选区后，进入选区模式,'+'\n''最下面出现红色按钮才可以开始选区,'+'\n''选区后点击红色按钮退出选区模式')
btn_xq.config(state=tk.DISABLED)#点击开始选区后不可以重复点击，需要暂停后再次启动
btn_start.config(state=tk.DISABLED)#开始按键停用

global start_x, start_y, end_x, end_y
global im0imagehas

def on_press(event):
global start_x, start_y
start_x, start_y = event.x, event.y

def on_move(event):
global end_x, end_y
end_x, end_y = event.x, event.y
canvas.coords(rect, start_x, start_y, end_x, end_y)

def on_release(event):
global end_x, end_y
end_x, end_y = event.x, event.y
canvas.coords(rect, start_x, start_y, end_x, end_y)

root1 = tk.Toplevel(root)
root1.title("选择监控区域")
root1.attributes('-fullscreen', True) #设置全屏模式

screenshot = pyautogui.screenshot() #截屏
screenshot.save('desktop_screenshot.png', format='png')

canvas = tk.Canvas(root1, bg='white') #创建画布
canvas.pack(fill=tk.BOTH, expand=True)#添加画布并填充

desktop_image = ImageTk.PhotoImage(file='desktop_screenshot.png')#创建图片对象
canvas.create_image(0, 0, anchor=tk.NW, image=desktop_image)#在画布上添加图片

rect = canvas.create_rectangle(0, 0, 0, 0, outline='red')#创建矩形对象

canvas.bind("<ButtonPress-1>", on_press)
canvas.bind("<B1-Motion>", on_move)
canvas.bind("<ButtonRelease-1>", on_release)

def close_window(): # 新增的关闭窗口函数
global im0imagehas
if start_x== None:
text_widget.delete(1.0, tk.END)
print("请选定区域后再退出"+'\n'+'\n')
print('点击选区后，进入选区模式,'+'\n''最下面出现红色按钮才可以开始选区,'+'\n''选区后点击红色按钮退出选区模式。')
else:
#im0imagehas = qie_tu('0.png') 在这里切图会再次抓屏把那条红线抓进来
img = Image.open('desktop_screenshot.png')
crop = img.crop((start_x,start_y ,end_x, end_y))
#crop.save('0.png', format='png')
# 使用BytesIO将图像保持到内存中
crop_bytes = io.BytesIO()
crop.save(crop_bytes, format='png')
im0imagehas=average_hash(crop)
text_widget.delete(1.0, tk.END)
print('成功抓取所选区域可以开始监控')
btn_start.config(state=tk.NORMAL)#成功抓取区域图片后，才可以开始监控
root1.destroy() # 使用Tkinter的destroy()方法关闭窗口

button_close = tk.Button(root1, text="，选择需要监控的区域后，点击此关闭", fg="red", command=close_window) # 创建关闭按钮
button_close.pack()
root1.mainloop()

# 初始化pygame库
pygame.init()
pygame.mixer.init()

# 全局变量，加载MP3文件
def load_alarm_sound(file_path):
try:
pygame.mixer.music.load(file_path)
except pygame.error:
print(f"无法加载音频文件：{file_path}")

# 封装一个播放MP3警报的函数
def play_alarm():
try:
# 播放MP3文件
pygame.mixer.music.play()
except pygame.error:
print("播放警报音频失败")

def monitor(data_source):
global pinlv
global should_exit
global isarm
global im0imagehas

while not should_exit:
current_time = datetime.now()
time_string = current_time.strftime("%H:%M:%S")
#im1imagehas = qie_tu('1.png')
im1imagehas = qie_tu()

#print('im0imagehas:',str(im0imagehas))
#print('im1imagehas:',str(im1imagehas))

if str(im0imagehas) != str(im1imagehas) :
print(time_string,' 相似度有变化，进行报警！')
play_alarm()
isarm=True
else:
print(time_string,' 相似度没有变化')
isarm=False

time.sleep(pinlv) # 等待5秒后再获取下一帧

if should_exit and suspend :
print('暂停监控')
else :
cv2.destroyAllWindows()

def start_recognition():
btn_start.config(state=tk.DISABLED)
btn_suspend.config(state=tk.NORMAL)
global should_exit
global suspend
suspend = False
should_exit = False
print("开始监控")
th_monitor = threading.Thread(target=monitor, args=("screenshot",))
th_monitor.daemon = True
th_monitor.start()

def suspend_recognition():
btn_xq.config(state=tk.NORMAL)
btn_start.config(state=tk.NORMAL)
btn_suspend.config(state=tk.DISABLED)
global suspend
global should_exit
should_exit = True
suspend=True

def end_program():
global should_exit
should_exit = True
print("结束监控")
sys.exit(1)
# 创建主窗口
root = tk.Tk()
root.title("监控报警")
root.wm_attributes('-topmost', True)
root.protocol("WM_DELETE_WINDOW",end_program)

#计算屏幕中央的位置
x = int((root.winfo_screenwidth() - root.winfo_reqwidth()) / 2)
y = int((root.winfo_screenheight() - root.winfo_reqheight()) / 2)
#将窗口居中显示
root.geometry("+{}+{}".format(x, y))

text_widget = tk.Text(root, width=55, height=10) # 设置文本框的最小宽度为40个字符，最小高度为10行
#text_widget.grid(column=0, row=0, width=10) # 在grid中设置文本框的宽度为10个字符
text_widget.pack()

# 添加按钮
print('点击选区后，进入选区模式,'+'\n''最下面出现红色按钮才可以开始选区,'+'\n''选区后点击红色按钮退出选区模式。')
btn_xq = tk.Button(root, text="开始选区", command=select_screen_region)
btn_start = tk.Button(root, text="开始监控", command=start_recognition)
btn_suspend = tk.Button(root, text="暂停监控", command=suspend_recognition)
btn_end = tk.Button(root, text="结束监控", command=end_program)

#btn_start.config(state=tk.DISABLED)
# 使用pack布局并设置side参数为LEFT实现横向排列

btn_suspend.config(state=tk.DISABLED)#暂停按键停用
btn_start.config(state=tk.DISABLED)#开始按键停用

btn_xq.pack(side=tk.LEFT, padx=10, pady=10)
btn_start.pack(side=tk.LEFT, padx=10, pady=10)
btn_suspend.pack(side=tk.LEFT, padx=10, pady=10)
btn_end.pack(side=tk.LEFT, padx=10, pady=10)

# 创建一个下拉列表变量
root.var = tk.StringVar(root)
# 设置下拉列表的默认值
root.var.set("监控频率默认2秒次")
# 定义下拉列表的选项
options = ["1秒次", "5秒次", "10秒次", "20秒次", "30秒次"]
# 创建下拉列表
dropdown = tk.OptionMenu(root, root.var, *options)
# 将下拉列表放置到主窗口
dropdown.pack()

def option_selected(*args):
global pinlv
text_widget.delete(1.0, tk.END)
print(f"选项 {root.var.get()} 被选择了!")
if root.var.get() == "1秒次" :
pinlv=1
if root.var.get() == "5秒次" :
pinlv=5
if root.var.get() == "10秒次" :
pinlv=10
if root.var.get() == "20秒次" :
pinlv=20
if root.var.get() == "30秒次" :
pinlv=30
root.var.trace("w", option_selected)

# 进入事件循环
root.mainloop()

文章知识点与官方知识档案匹配，可进一步学习相关知识

Python实现指定区域桌面变化监控

原创

mob64ca12e36a1d2024-09-17 06:51:59©著作权

文章标签Python 代码示例 python文章分类Python 后端开发

我整理的一些关于【软考】的项目学习资料（附讲解～～）和大家一起分享、学习一下：

https://d.51cto.com/sYneOo

Python实现指定区域桌面变化监控

在现代化的办公环境中，监控桌面变化是一项颇具实用性的技术。无论是进行自动化测试，还是需要监控某个特定应用程序的状态，能够实时捕捉桌面区域的变化都显得尤为重要。本文将介绍如何使用Python进行桌面变化监控的具体实现，并通过代码示例帮助理解。

工具准备

在开始之前，我们需要确保已安装以下Python库：

opencv-python: 用于图像处理。
numpy: 用于数值计算。
Pillow: 处理图像的库。
pyautogui: 用于截取屏幕。

可以通过以下命令安装所需的库：

程序设计思路

我们将创建一个简单的监控程序，该程序会在指定区域内捕获桌面变化。主要的步骤如下：

定义监控区域的位置和大小。
使用循环不断地截取该区域的屏幕。
对比当前截取到的图像与上一个图像，如果变化超过预设阈值，则记录变化。

以下是实现这一功能的代码示例：

import cv2
import numpy as np
import pyautogui
import time

def monitor_region(region, threshold=1000):
    x, y, width, height = region
    previous_image = None

    while True:
        # 截取指定区域
        current_image = pyautogui.screenshot(region=region)
        current_image = cv2.cvtColor(np.array(current_image), cv2.COLOR_RGB2BGR)

        # 如果存在上一帧图像，进行比较
        if previous_image is not None:
            # 计算两帧之间的绝对差异
            difference = cv2.absdiff(previous_image, current_image)
            gray_diff = cv2.cvtColor(difference, cv2.COLOR_BGR2GRAY)
            _, thresh = cv2.threshold(gray_diff, 30, 255, cv2.THRESH_BINARY)
            non_zero_count = cv2.countNonZero(thresh)

            if non_zero_count > threshold:
                print("区域内容发生变化！")

        previous_image = current_image
        time.sleep(1)  # 设置截取间隔时间

if __name__ == "__main__":
    # 定义监控区域，位置（x, y）和大小（width, height）
    monitor_region((100, 100, 400, 300), threshold=1000)

代码解析

监控区域：我们以(x, y, width, height)的形式定义需要监控的位置和大小。
图像截取：使用pyautogui.screenshot()函数实时捕获指定区域的图像并转换为OpenCV格式。
图像比较：利用OpenCV计算两帧图像的绝对差异，通过设置阈值判断区域内是否有变化。

进一步思考

下面我们可以使用甘特图和关系图来展示项目的时间管理和架构关系。

甘特图

以下甘特图展示了项目的主要阶段和时间安排：

2023-10-012023-10-022023-10-032023-10-042023-10-052023-10-062023-10-072023-10-082023-10-092023-10-10安装依赖库设计程序结构编写代码测试与优化撰写文章数据准备编码实现项目总结项目时间计划

关系图

以下关系图展示了程序的主要组件与功能之间的关系：

USERstringnamestringemailSCREENstringcaptured_imagedatetimetimestampCHANGEstringchange_descriptionintseveritycapturesgenerates

结尾

通过本文的介绍，我们成功实现了一个基于Python的指定区域桌面变化监控程序，并提供了相应的代码示例和项目管理视图。这一技术不仅可以应用于自动化测试，还可以用于监控个人的生产效率。当然，程序的优化空间还是很大的，比如可以考虑更灵敏的变化检测机制，以及处理多个监控区域的能力。希望这个小项目能够激发你对桌面监控技术的兴趣，并为未来的开发提供帮助。

整理的一些关于【软考】的项目学习资料（附讲解～～），需要自取：

https://d.51cto.com/sYneOo