• Python tkinter: 开发一个目标检测GUI小程序

    程序提供了一个用户友好的界面，允许用户选择图片或文件夹，使用行人检测模型进行处理，并在GUI中显示检测结果。用户可以通过点击画布上的检测结果来获取更多信息，并使用键盘快捷键来浏览不同的图片。

    一. 基本功能介绍

    1. 界面布局：程序使用tkinter库创建一个窗口界面，包括标题栏、可调整大小的画布以及底部的操作按钮。

    2. 图片加载：用户可以通过点击“选择文件夹”或“选择图片”按钮来加载需要检测的图片。支持多种图片格式，如JPG、JPEG、PNG等。

    3. 目标检测：程序内置了一个检测器（例如YOLOv8），用于识别图片中的行人，并在图片上绘制矩形框和置信度标签。

    4. 进度显示：在处理多张图片时，程序会显示一个进度条，告知用户当前的检测进度。

    5. 结果展示：检测完成后，程序会在GUI中展示第一张图片的检测结果，并允许用户通过键盘操作（A键上一张，D键下一张）浏览所有图片。

    6. 交互反馈：用户点击画布上的检测框时，程序会弹出一个消息框显示选中目标的类别和置信度。

    7. 图片缩放：程序能够根据窗口大小调整图片的显示尺寸，确保图片在不同分辨率的屏幕上都能清晰显示。

    8. 日志记录：程序使用logging模块记录操作日志，便于问题追踪和调试。

    9. 多线程处理：为了不阻塞GUI操作，图片的检测处理在后台线程中进行。

    10. 配置灵活：程序允许用户通过参数配置检测器的行为，例如模型路径、图片尺寸、置信度阈值等。

    二. 主要方法介绍

    1. __init__: 类的构造函数，用于初始化GUI窗口、设置窗口属性、创建组件和绑定事件。

    2. load_dir: 允许用户通过文件对话框选择一个文件夹，程序会加载该文件夹下的所有支持格式的图片。

    3. load_imgs: 使用文件对话框让用户选择一个或多个图片文件，并将这些文件的路径添加到图片列表中。

    4. show_progress_window: 显示进度条窗口，用于在处理图片时提供用户反馈。

    5. process_files: 在后台线程中处理所有选中的图片，对每张图片运行检测算法，并更新进度条。

    6. run_detect: 对单张图片运行检测器，返回检测结果。

    7. draw_result: 在原始图片上绘制检测结果，如边界框和置信度标签。

    8. draw_detections: 在GUI的画布上绘制检测结果，包括边界框和文本标签。

    9. remove_progress_bar: 在所有图片处理完毕后，移除进度条和相关组件。

    10. display_image: 在GUI中显示当前选中的图片及其检测结果。

    11. on_canvas_click: 绑定到画布的点击事件，用于检测用户点击的位置是否在检测框内，并显示选中目标的详细信息。

    12. win_change: 响应窗口大小变化事件，调整图片的显示大小以适应窗口。

    13. on_win_change: 处理窗口大小变化事件，调用win_change方法。

    14. on_key_press: 绑定到窗口的键盘按键事件，允许用户通过按键浏览图片。

    15. cv2pil: 将使用OpenCV加载的BGR格式图片转换为PIL图像，以便在Tkinter中显示。

    三. 代码

    1. import tkinter as tk
    2. from tkinter import ttk
    3. from tkinter import filedialog, messagebox
    4. import cv2
    5. import math
    6. import json
    7. import time
    8. import os
    9. import threading
    10. from PIL import Image, ImageTk
    11. import logging
    12. logging.basicConfig(level=logging.INFO)
    13.  
    14. from person_detection import api
    15.  
    16.  
    17. class MyGUI(tk.Tk):
    18.     def __init__(self, det_kwargs):
    19.         super().__init__()
    20.         self.title('行人检测小程序')
    21.         self.geometry('600x400')
    22.         self.resizable(width=True, height=True)
    23.         self.label = tk.Label(self)
    24.         self.bind('', self.on_win_change)
    25.         self.bind('', self.on_key_press)
    26.  
    27.         # 创建检测器
    28.         self.detector = api.YOLOv8(**det_kwargs) if det_kwargs else None
    29.         self.classes = {0: 'person'}
    30.  
    31.         # 用于记录当前的图片数据
    32.         self.raw_img_file_path = None
    33.         self.visual_image = None
    34.         self.photo_image = None
    35.  
    36.         # 创建按钮框架
    37.         self.button_frame = tk.Frame(self)
    38.         self.button_frame.pack(side=tk.BOTTOM, fill=tk.X, expand=False)
    39.         # 创建按钮
    40.         self.load_dir_button = tk.Button(self.button_frame, text="选择文件夹", command=self.load_dir)
    41.         self.load_dir_button.pack(side=tk.LEFT, padx=10, pady=10, expand=False)
    42.         self.load_imgs_button = tk.Button(self.button_frame, text="选择图片", command=self.load_imgs)
    43.         self.load_imgs_button.pack(side=tk.LEFT, padx=10, pady=10, expand=False)
    44.         # 创建用于显示图片的Canvas
    45.         self.image_canvas = tk.Canvas(self, bg='white')
    46.         self.image_canvas.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
    47.         self.image_id = self.image_canvas.create_image(
    48.             0, 0, image=self.photo_image, anchor='nw'
    49.         )
    50.         # 创建进度条窗口和进度条
    51.         self.bar_frame = None
    52.         self.progress_window = None
    53.         self.progress_bar = None
    54.         self.processing_label = None
    55.  
    56.         # 为Canvas绑定鼠标点击事件
    57.         self.image_canvas.bind("", self.on_canvas_click)
    58.         # 为窗口绑定大小和位置变化事件的监听
    59.         self.bind("", self.on_win_change)
    60.  
    61.         # 记录每次加载的图片路径列表，检测结果，以及当前的图片索引
    62.         self.img_list = []
    63.         self.result_list = []
    64.         self.index = 0
    65.  
    66.         # 初始化缩放比例属性
    67.         self.scale_width = 1.0
    68.         self.scale_height = 1.0
    69.  
    70.     def load_dir(self):
    71.         """
    72.         选择文件夹，从中加载图片
    73.         """
    74.         # 选择图片
    75.         file_dir = filedialog.askdirectory(title='选择文件夹')
    76.         logging.info("选择的文件夹: {}".format(file_dir))
    77.         if file_dir != ():
    78.             for i, file in enumerate(os.listdir(file_dir)):
    79.                 if file.endswith(('.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.webp')):
    80.                     img_path = os.path.join(file_dir, file)
    81.                     self.img_list.append(img_path)
    82.             # 显示进度条窗口
    83.             self.show_progress_window(self.img_list)
    84.  
    85.     def load_imgs(self):
    86.         """
    87.         选择单个或多个文件以加载图片
    88.         """
    89.         file_paths = filedialog.askopenfilenames(
    90.             title='选择图片文件', filetypes=[('图像文件', '*.jpg *.jpeg *.png *.bmp *.tiff *.webp'), ('所有文件', '*.*')])
    91.         logging.info("选择的文件: {}".format(file_paths))
    92.         if file_paths != ():
    93.             for img_path in file_paths:
    94.                 self.img_list.append(img_path)
    95.             # 显示进度条窗口
    96.             self.show_progress_window(self.img_list)
    97.  
    98.     def show_progress_window(self, img_list):
    99.         # 创建进度条框架
    100.         self.bar_frame = tk.Frame(self)
    101.         self.bar_frame.pack(side=tk.TOP, fill=tk.Y, pady=20, expand=False)
    102.         # 创建正在处理的文本标签和进度条
    103.         self.processing_label = tk.Label(self.bar_frame, text="正在处理...")
    104.         self.processing_label.pack(side=tk.BOTTOM, fill=tk.Y, pady=0, expand=False)
    105.         self.progress_bar = ttk.Progressbar(self.bar_frame, orient='horizontal', length=300, mode='determinate')
    106.         self.progress_bar.pack(side=tk.BOTTOM, pady=0, expand=False)
    107.  
    108.         # 设置最大值为文件数量
    109.         total_files = len(img_list)
    110.         self.progress_bar['maximum'] = total_files
    111.  
    112.         # 更新初始进度
    113.         self.progress_bar['value'] = 0
    114.  
    115.         # 在新线程中处理文件以避免阻塞GUI
    116.         threading.Thread(target=self.process_files, args=(img_list,)).start()
    117.         # 使用阻塞的方式处理文件
    118.         # self.process_files(file_dir)
    119.  
    120.     def process_files(self, img_list):
    121.         for i, img_path in enumerate(img_list):
    122.             # 模拟处理文件的耗时操作
    123.             logging.info("处理文件: {}".format(img_path))
    124.             img = cv2.imread(img_path)
    125.             self.result_list.append(self.run_detect(img))
    126.  
    127.             # 更新进度条
    128.             self.progress_bar['value'] = i + 1  # 更新进度条
    129.  
    130.         # 处理完成后，显示消息框并移除进度条
    131.         # self.after(100, self.remove_progress_bar)  # 稍后执行
    132.         self.remove_progress_bar()  # 立即执行
    133.  
    134.         # 显示图片到Canvas
    135.         self.display_image()
    136.  
    137.         # 调整图片至窗口大小
    138.         self.win_change()
    139.  
    140.     def run_detect(self, img):
    141.         return self.detector.detect([img])
    142.  
    143.     def draw_result(self, img, result):
    144.         img = img.copy()
    145.         dets = result['data'][0]['dets']
    146.         for det in dets:
    147.             id, score, bbox = det['id'], det['score'], det['bbox']
    148.             x1, y1, x2, y2 = map(int, bbox)
    149.             cv2.rectangle(img, (x1, y1), (x2, y2), (0, 255, 0), 2)
    150.             cv2.putText(img, '%.2f' % score, (x1, y1 - 4),
    151.                         cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 0, 255), thickness=1, lineType=cv2.LINE_AA)
    152.         return img
    153.  
    154.     def draw_detections(self, result):
    155.         dets = result['data'][0]['dets']
    156.         for det in dets:
    157.             id, score, bbox = det['id'], det['score'], det['bbox']
    158.             x1, y1, x2, y2 = map(int, bbox)
    159.             x1 = int(x1 / self.scale_width)
    160.             y1 = int(y1 / self.scale_height)
    161.             x2 = int(x2 / self.scale_width)
    162.             y2 = int(y2 / self.scale_height)
    163.             self.image_canvas.create_rectangle(x1, y1, x2, y2, outline='red', width=2)
    164.             self.image_canvas.create_text(x1, y1 - 10, text=f'{score:.2f}', fill='red', font=('Arial', 8))
    165.  
    166.     def remove_progress_bar(self):
    167.         """
    168.         移除进度条，进行一些销毁与重置的操作
    169.         """
    170.         # 显示消息框
    171.         messagebox.showinfo("完成", "文件处理完成！")
    172.         # 从主窗体中移除进度条
    173.         if self.progress_bar is not None:
    174.             self.progress_bar.pack_forget()  # 隐藏进度条
    175.             self.progress_bar.destroy()  # 销毁进度条对象
    176.  
    177.         # 从主窗体中移除进度条标签
    178.         if hasattr(self, 'processing_label') and self.processing_label is not None:
    179.             self.processing_label.pack_forget()  # 隐藏进度条
    180.             self.processing_label.destroy()  # 销毁进度条对象
    181.  
    182.         # 从主窗体中移除进度条框架
    183.         if self.bar_frame is not None:
    184.             self.bar_frame.destroy()  # 销毁进度条框架
    185.  
    186.     def display_image(self):
    187.         if len(self.img_list) == 0:
    188.             return
    189.         image = cv2.imread(self.img_list[self.index])
    190.         image = self.draw_result(image, self.result_list[self.index])
    191.         # 将OpenCV图像转换为PIL图像，然后转换为PhotoImage
    192.         pil_image = self.cv2pil(image)
    193.         self.photo_image = ImageTk.PhotoImage(pil_image)
    194.  
    195.         # 显示图片
    196.         self.image_canvas.delete("all")  # 删除旧的图片
    197.         self.image_id = self.image_canvas.create_image(
    198.             0, 0, image=self.photo_image, anchor='nw'
    199.         )
    200.         self.image_canvas.image = self.photo_image  # 保持对图像的引用
    201.  
    202.     def on_canvas_click(self, event):
    203.         # 使用缩放比例将画布坐标转换为图像坐标
    204.         canvas_x = event.x
    205.         canvas_y = event.y
    206.         img_x = int(canvas_x / self.scale_width)
    207.         img_y = int(canvas_y / self.scale_height)
    208.  
    209.         # 初始化最近目标的距离和索引
    210.         min_distance = float('inf')  # 正无穷大，用于比较
    211.         closest_index = -1
    212.         closest_id = None
    213.         closest_score = None
    214.  
    215.         # 检查点击坐标是否在检测结果的边界框内
    216.         if len(self.result_list) > 0:
    217.             dets = self.result_list[self.index]['data'][0]['dets']
    218.             for i, det in enumerate(dets):
    219.                 id, score, bbox = det['id'], det['score'], det['bbox']
    220.                 x1, y1, x2, y2 = map(int, bbox)  # 边界框的坐标
    221.  
    222.                 # 计算边界框的中心点坐标
    223.                 center_x = (x1 + x2) / 2
    224.                 center_y = (y1 + y2) / 2
    225.  
    226.                 if x1 <= img_x <= x2 and y1 <= img_y <= y2:
    227.                     # 计算点击位置到边界框中心的欧氏距离
    228.                     distance = math.sqrt((img_x - center_x) ** 2 + (img_y - center_y) ** 2)
    229.  
    230.                     # 更新最近目标的距离和索引
    231.                     if distance < min_distance:
    232.                         min_distance = distance
    233.                         closest_index = i
    234.                         closest_id = id
    235.                         closest_score = score
    236.  
    237.             # 如果找到最近的目标，则显示信息
    238.             if closest_index != -1:
    239.                 messagebox.showinfo("检测到的目标", f"标签: {self.classes[closest_id]}\n置信度: {closest_score:.2f}")
    240.             # else:
    241.             #     messagebox.showinfo("点击区域", "未检测到目标")
    242.  
    243.     def win_change(self):
    244.         if len(self.result_list) > 0:  # 确保图像不为空
    245.             image = cv2.imread(self.img_list[self.index])
    246.             visual_image = self.draw_result(image, self.result_list[self.index])
    247.             # 保存原始图像尺寸和画布尺寸
    248.             self.orig_width = visual_image.shape[1]
    249.             self.orig_height = visual_image.shape[0]
    250.             canvas_width = self.image_canvas.winfo_width()
    251.             canvas_height = self.image_canvas.winfo_height()
    252.  
    253.             # 计算缩放比例
    254.             self.scale_width = canvas_width / self.orig_width
    255.             self.scale_height = canvas_height / self.orig_height
    256.  
    257.             # 根据缩放比例调整图像大小
    258.             new_width = int(self.orig_width * self.scale_width)
    259.             new_height = int(self.orig_height * self.scale_height)
    260.             resized_image = cv2.resize(visual_image, (new_width, new_height))
    261.  
    262.             # 显示调整大小后的图像
    263.             pil_image = self.cv2pil(resized_image)
    264.             self.photo_image = ImageTk.PhotoImage(pil_image)
    265.             self.image_canvas.itemconfig(self.image_id, image=self.photo_image)
    266.  
    267.     def on_win_change(self, event):
    268.         """
    269.         监控窗口大小和位置的变化
    270.         :param event:
    271.         :return:
    272.         """
    273.         self.win_change()
    274.  
    275.     def on_key_press(self, event):
    276.         """
    277.         监控键盘按键的按下事件，根据按键进行index增减，以进行图片浏览切换
    278.         设定规则：
    279.             A：上一张
    280.             D：下一张
    281.         """
    282.         if len(self.result_list) == 0:
    283.             return
    284.         if event.keysym in ['A', 'a']:
    285.             if self.index == 0:
    286.                 messagebox.showinfo("提示", "已经是第一张图片了")
    287.             self.index = max(0, self.index - 1)
    288.         elif event.keysym in ['D', 'd']:
    289.             if self.index == len(self.img_list) - 1:
    290.                 messagebox.showinfo("提示", "已经是最后一张图片了")
    291.             self.index = min(len(self.img_list)-1, self.index + 1)
    292.         else:
    293.             messagebox.showinfo("提示", "请按 A 或 D 键进行图片上翻/下翻")
    294.         self.display_image()
    295.         self.win_change()
    296.  
    297.     def cv2pil(self, cv2_img):
    298.         # 转换图片至RGB颜色空间
    299.         image = cv2.cvtColor(cv2_img, cv2.COLOR_BGR2RGB)
    300.  
    301.         # 转换图片至PIL格式
    302.         return Image.fromarray(image)
    303.  
    304.     def get_filename(self, file_path):
    305.         return os.path.splitext(os.path.split(file_path)[-1])[0]
    306.  
    307.  
    308. if __name__ == '__main__':
    309.     det_kwargs = dict(
    310.         model_path='/home/leon/Nextcloud/ChengDu_Research/computer_vision/algorithms/human/person_detection/1.0.1/person_detection_1.0.1.onnx',
    311.         img_size=(640, 384),
    312.         mode=api.ie.MODE_ORT,
    313.         conf_thresh=0.5,
    314.         providers=['CUDAExecutionProvider'],  # if no GPU, use 'CPUExecutionProvider'
    315.         # half=True,
    316.     )
    317.     app = MyGUI(det_kwargs)
    318.     app.mainloop()

    请注意：在代码中，我用到了一个目标检测器，你需要替换为你自己的检测器，从而实现不同目标的检测！

    代码中和检测相关方法/变量如下：

    方法:

    1. run_detect(self, img): 使用检测器对提供的图像进行检测。
    2. draw_result(self, img, result): 在图像上绘制检测结果，如边界框和分数。
    3. process_files(self, img_list): 处理一个图片列表，对每张图片执行检测。
    4. display_image(self): 在GUI上显示当前选中的图片和其检测结果。
    5. draw_detections(self, result): 在Canvas上绘制检测结果。
    6. show_progress_window(self, img_list): 显示进度条窗口，准备开始处理图片列表。
    7. remove_progress_bar(self): 完成图片处理后，移除进度条。

    变量:

    1. self.detector: 用于存储检测器实例，例如api.YOLOv8。
    2. self.classes: 一个字典，用于将检测到的类别ID映射到类别名称。
    3. self.img_list: 存储加载的图片路径列表。
    4. self.result_list: 存储每张图片的检测结果。
    5. self.index: 当前显示图片的索引。
    6. self.raw_img_file_path: 记录当前处理的原始图片文件路径。
    7. self.visual_image: 用于存储绘制了检测结果的图像。
    8. self.photo_image: 用于存储Tkinter能够显示的图像对象。
    9. self.image_id: 存储Canvas上图像的ID，用于更新显示的图像。
    10. self.scale_width 和 self.scale_height: 存储图像的缩放比例。

    对于我的检测器，这里贴出来一个输出示例：

    1. {
    2.   "code": "0",
    3.   "message": "",
    4.   "data": [
    5.     {
    6.       "dets": [
    7.         {
    8.           "id": 0,
    9.           "score": 0.7589585781097412,
    10.           "bbox": [
    11.             873.7188720703125,
    12.             236.35150146484375,
    13.             910.048095703125,
    14.             335.6061706542969
    15.           ]
    16.         },
    17.         {
    18.           "id": 0,
    19.           "score": 0.716355562210083,
    20.           "bbox": [
    21.             447.7972717285156,
    22.             278.9081726074219,
    23.             521.7301025390625,
    24.             421.3373718261719
    25.           ]
    26.         }
    27.       ]
    28.     }
    29.   ]
    30. }

    参考：

    tkinter — Python interface to Tcl/Tk — Python 3.12.4 documentation

  • 相关阅读:
    labview与stm32通信
    对渗透新人的几点建议
    AIGC笔记--Maya提取和修改FBX动作文件
    MySQL进阶07_存储过程/存储函数
    Unity学习笔记--详细介绍CacheServer、部署方法、以及在Unity中的位置
    python虚拟环境创建问题：You will need to adjust your conda configuration to proceed.
    牛X，试用了下 GitHub 上 2 万 Star 的第一抢票神器，3 秒钟抢到！
    数据分析之Logistic回归分析（二元逻辑回归、多元有序逻辑回归、多元无序逻辑回归）
    亚马逊云科技 云技能孵化营——我的云技能之旅
    【MySQL篇】约束语法及演示总结（全）
  • 原文地址：https://blog.csdn.net/oYeZhou/article/details/140041726