Files
douyin_guaji-main/tools/simple_region_selector.py
T
Your Name 223c127e11 chore: Clean up and refactor codebase for improved maintainability
- Removed obsolete command-line test parameters from `run_cli.py` to streamline functionality.
- Introduced a new `ocr_preprocess.py` module for unified OCR image preprocessing, enhancing recognition stability.
- Updated various components to utilize the new preprocessing function, improving code organization and readability.
- Adjusted configuration values in `config.json` for better performance and consistency.
- Added comprehensive technical documentation for the Douyin project, detailing code modification standards and operational guidelines.
- Cleaned up excessive blank lines across multiple files to enhance overall readability.
2025-12-30 23:11:34 +08:00

700 lines
26 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env python3
"""
简化版区域选择器 - 专门用于抖音挂机项目
用于选择直播间图标区域并统计白色像素
"""
import sys
import os
from pathlib import Path
from typing import Optional
import json
try:
import tkinter as tk
from tkinter import filedialog, messagebox
except ImportError:
print("错误: tkinter不可用。请确保Python安装时包含了tkinter。")
print("在Windows上,请重新安装Python并勾选'tcl/tk and IDLE'选项。")
sys.exit(1)
from PIL import Image, ImageTk, ImageDraw
import numpy as np
class SimpleRegionSelector:
def __init__(self, image_path=None):
self.image_path = image_path
self.img = None
self.photo = None
self.scale = 1.0
self.offset_x = 0
self.offset_y = 0
# 选择相关
self.polygon_points = [] # 多边形顶点列表
self.polygon_id = None # 画布上的多边形ID
# 缩放和平移相关
self.scale = 1.0
self.min_scale = 0.1
self.max_scale = 10.0
self.offset_x = 0
self.offset_y = 0
self.is_dragging = False
self.drag_start_x = 0
self.drag_start_y = 0
# 结果存储
self.regions = []
self.setup_ui()
if image_path:
self.load_image(image_path)
else:
self.ask_for_image()
def setup_ui(self):
"""设置用户界面"""
self.root = tk.Tk()
self.root.title("抖音区域选择器 - 白色像素统计")
self.root.geometry("1000x700")
# 菜单栏
menubar = tk.Menu(self.root)
file_menu = tk.Menu(menubar, tearoff=0)
file_menu.add_command(label="打开图片", command=self.ask_for_image, accelerator="Ctrl+O")
file_menu.add_command(label="保存区域", command=self.save_regions, accelerator="Ctrl+S")
file_menu.add_command(label="加载区域", command=self.load_regions, accelerator="Ctrl+L")
file_menu.add_separator()
file_menu.add_command(label="退出", command=self.root.quit)
menubar.add_cascade(label="文件", menu=file_menu)
edit_menu = tk.Menu(menubar, tearoff=0)
edit_menu.add_command(label="清除选择", command=self.clear_selection, accelerator="Del")
edit_menu.add_command(label="分析区域", command=self.analyze_region, accelerator="Enter")
edit_menu.add_command(label="显示所有", command=self.show_all_regions)
edit_menu.add_command(label="清除所有", command=self.clear_all_regions)
menubar.add_cascade(label="编辑", menu=edit_menu)
# 移除视图菜单,不需要放大缩小功能
# 视图菜单
view_menu = tk.Menu(menubar, tearoff=0)
view_menu.add_command(label="放大 (+)", command=self.zoom_in, accelerator="+")
view_menu.add_command(label="缩小 (-)", command=self.zoom_out, accelerator="-")
view_menu.add_command(label="重置缩放 (1:1)", command=self.reset_zoom, accelerator="Ctrl+0")
view_menu.add_command(label="适应窗口", command=self.fit_to_window, accelerator="Ctrl+F")
menubar.add_cascade(label="视图", menu=view_menu)
self.root.config(menu=menubar)
# 绑定快捷键
self.root.bind("<Control-o>", lambda e: self.ask_for_image())
self.root.bind("<Control-s>", lambda e: self.save_regions())
self.root.bind("<Control-l>", lambda e: self.load_regions())
self.root.bind("<Delete>", lambda e: self.clear_selection())
self.root.bind("<Return>", lambda e: self.analyze_region())
# 视图相关快捷键
self.root.bind("<plus>", lambda e: self.zoom_in())
self.root.bind("<equal>", lambda e: self.zoom_in())
self.root.bind("<minus>", lambda e: self.zoom_out())
self.root.bind("<Control-0>", lambda e: self.reset_zoom())
self.root.bind("<Control-f>", lambda e: self.fit_to_window())
# 主框架
main_frame = tk.Frame(self.root)
main_frame.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
# 左侧控制面板
left_panel = tk.Frame(main_frame, width=250, bg='#f0f0f0')
left_panel.pack(side=tk.LEFT, fill=tk.Y, padx=(0,5))
# 右侧画布区域
right_panel = tk.Frame(main_frame)
right_panel.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)
# 控制面板内容
self.setup_control_panel(left_panel)
# 画布
self.canvas = tk.Canvas(right_panel, bg='#404040')
self.canvas.pack(fill=tk.BOTH, expand=True)
# 状态栏
self.status_var = tk.StringVar()
self.status_var.set("请打开图片,然后用滚轮缩放、右键拖拽调整视图,依次点击多个点围成x图标区域")
status_bar = tk.Label(right_panel, textvariable=self.status_var,
anchor="w", bg='#e0e0e0', relief=tk.SUNKEN)
status_bar.pack(fill=tk.X, side=tk.BOTTOM)
# 绑定画布事件
self.canvas.bind("<Button-1>", self.on_canvas_click) # 左键添加点
self.canvas.bind("<Button-3>", self.on_canvas_right_click) # 右键完成多边形
self.canvas.bind("<B3-Motion>", self.on_canvas_drag) # 右键拖拽
self.canvas.bind("<MouseWheel>", self.on_mousewheel) # 滚轮缩放
self.root.bind("<space>", self.finish_polygon) # 空格键完成多边形
self.root.bind("<BackSpace>", self.remove_last_point) # 退格键删除最后一个点
def setup_control_panel(self, parent):
"""设置控制面板"""
# 标题
title = tk.Label(parent, text="区域选择器", font=("Arial", 12, "bold"), bg='#f0f0f0')
title.pack(pady=10)
# 当前选择信息
select_frame = tk.LabelFrame(parent, text="当前选择", bg='#f0f0f0')
select_frame.pack(fill=tk.X, padx=5, pady=5)
self.select_info = tk.StringVar()
self.select_info.set("未选择区域")
tk.Label(select_frame, textvariable=self.select_info, anchor="w", bg='#f0f0f0',
justify=tk.LEFT, wraplength=220).pack(fill=tk.X, padx=5, pady=5)
# 分析结果
result_frame = tk.LabelFrame(parent, text="分析结果", bg='#f0f0f0')
result_frame.pack(fill=tk.X, padx=5, pady=5)
self.result_text = tk.Text(result_frame, height=10, width=25, font=("Courier", 9))
scrollbar = tk.Scrollbar(result_frame, command=self.result_text.yview)
self.result_text.config(yscrollcommand=scrollbar.set)
self.result_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=5, pady=5)
scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
# 按钮区域
btn_frame = tk.Frame(parent, bg='#f0f0f0')
btn_frame.pack(fill=tk.X, padx=5, pady=5)
tk.Button(btn_frame, text="分析区域", command=self.analyze_region,
bg='#4CAF50', fg='white').pack(fill=tk.X, pady=2)
tk.Button(btn_frame, text="清除选择", command=self.clear_selection,
bg='#f44336', fg='white').pack(fill=tk.X, pady=2)
tk.Button(btn_frame, text="显示所有", command=self.show_all_regions,
bg='#2196F3', fg='white').pack(fill=tk.X, pady=2)
tk.Button(btn_frame, text="清除所有", command=self.clear_all_regions,
bg='#FF9800', fg='white').pack(fill=tk.X, pady=2)
# 添加使用说明
help_frame = tk.LabelFrame(parent, text="多边形选择说明", bg='#f0f0f0')
help_frame.pack(fill=tk.X, padx=5, pady=5)
help_text = """操作步骤:
1. 打开图片
2. 滚轮缩放,右键拖拽调整视图
3. 依次点击多个点围成x图标
4. 右键或按Space完成选择
5. 按Enter分析区域
快捷键:
Space: 完成多边形
BackSpace: 删除最后一个点
+/-: 放大缩小
Ctrl+0: 重置缩放
Ctrl+F: 适应窗口"""
tk.Label(help_frame, text=help_text, anchor="w", bg='#f0f0f0',
justify=tk.LEFT, font=("Arial", 9)).pack(fill=tk.X, padx=5, pady=5)
def ask_for_image(self):
"""选择图片文件"""
filetypes = [("图片文件", "*.png *.jpg *.jpeg *.bmp *.webp"), ("所有文件", "*.*")]
filename = filedialog.askopenfilename(title="选择图片", filetypes=filetypes)
if filename:
self.load_image(filename)
def load_image(self, path):
"""加载图片"""
try:
self.image_path = path
self.img = Image.open(path).convert("RGB")
self.w, self.h = self.img.size
self.scale = 1.0
self.offset_x = 0
self.offset_y = 0
self.clear_selection()
self.clear_all_regions()
self.update_display()
self.root.title(f"多边形区域选择器 - {Path(path).name} ({self.w}x{self.h}) | 缩放: {self.scale:.2f}x")
self.status_var.set("图片已加载,请依次点击多个点围成x图标区域")
except Exception as e:
messagebox.showerror("错误", f"加载图片失败: {e}")
def update_display(self):
"""更新显示"""
if not self.img:
return
# 获取canvas尺寸
canvas_w = self.canvas.winfo_width()
canvas_h = self.canvas.winfo_height()
if canvas_w <= 1 or canvas_h <= 1:
return
# 计算显示尺寸
disp_w = int(self.w * self.scale)
disp_h = int(self.h * self.scale)
# 缩放图片
if self.scale != 1.0:
try:
resample = Image.Resampling.LANCZOS if hasattr(Image, 'Resampling') else Image.LANCZOS
except:
resample = Image.BICUBIC
resized = self.img.resize((disp_w, disp_h), resample)
else:
resized = self.img
self.photo = ImageTk.PhotoImage(resized)
self.canvas.config(scrollregion=(0, 0, disp_w, disp_h))
self.canvas.delete("image")
self.canvas.create_image(-self.offset_x, -self.offset_y, anchor=tk.NW,
image=self.photo, tags="image")
# 重新绘制多边形
self.redraw_polygon()
# 更新标题
if self.image_path:
self.root.title(f"多边形区域选择器 - {Path(self.image_path).name} ({self.w}x{self.h}) | 缩放: {self.scale:.2f}x")
def redraw_polygon(self):
"""重新绘制多边形"""
self.canvas.delete("polygon")
if not self.polygon_points:
return
# 绘制多边形边线
if len(self.polygon_points) >= 2:
canvas_points = []
for img_x, img_y in self.polygon_points:
canvas_x = img_x * self.scale - self.offset_x
canvas_y = img_y * self.scale - self.offset_y
canvas_points.extend([canvas_x, canvas_y])
# 如果多边形已完成,绘制闭合多边形
if len(self.polygon_points) >= 3:
# 连接最后一个点到第一个点
first_x = self.polygon_points[0][0] * self.scale - self.offset_x
first_y = self.polygon_points[0][1] * self.scale - self.offset_y
canvas_points.extend([first_x, first_y])
# 绘制填充的多边形
self.polygon_id = self.canvas.create_polygon(
canvas_points,
outline='red', fill='red', stipple='gray50',
width=2, tags="polygon"
)
else:
# 绘制开放的多边形线条
self.polygon_id = self.canvas.create_line(
canvas_points,
fill='red', width=2, tags="polygon"
)
# 绘制顶点
for i, (img_x, img_y) in enumerate(self.polygon_points):
canvas_x = img_x * self.scale - self.offset_x
canvas_y = img_y * self.scale - self.offset_y
# 绘制点(根据缩放调整大小)
radius = max(3, int(3 / self.scale)) if self.scale > 0 else 3
self.canvas.create_oval(
canvas_x - radius, canvas_y - radius,
canvas_x + radius, canvas_y + radius,
fill='blue', outline='white', width=1, tags="polygon"
)
# 绘制点编号(根据缩放调整字体大小)
font_size = max(8, int(10 / self.scale)) if self.scale > 0 else 8
self.canvas.create_text(
canvas_x, canvas_y - radius - 5,
text=str(i+1), fill='white', font=('Arial', font_size, 'bold'),
tags="polygon"
)
def canvas_to_image_coords(self, canvas_x, canvas_y):
"""画布坐标转图片坐标"""
if self.scale == 0:
return 0, 0
img_x = int((canvas_x + self.offset_x) / self.scale)
img_y = int((canvas_y + self.offset_y) / self.scale)
return max(0, min(img_x, self.w-1)), max(0, min(img_y, self.h-1))
def on_canvas_click(self, event):
"""画布点击 - 添加多边形顶点"""
if not self.img:
return
img_x, img_y = self.canvas_to_image_coords(event.x, event.y)
# 添加新点到多边形
self.polygon_points.append((img_x, img_y))
self.redraw_polygon()
point_num = len(self.polygon_points)
self.status_var.set(f"已添加第{point_num}个点: ({img_x}, {img_y}) | 右键或按空格完成多边形")
print(f"点 {point_num}: ({img_x}, {img_y})")
def on_canvas_right_click(self, event):
"""右键点击 - 完成多边形"""
self.finish_polygon()
def finish_polygon(self, event=None):
"""完成多边形选择"""
if len(self.polygon_points) < 3:
messagebox.showwarning("警告", "需要至少3个点才能构成多边形")
return
# 关闭多边形(连接最后一个点到第一个点)
self.redraw_polygon()
self.update_selection_info()
point_count = len(self.polygon_points)
self.status_var.set(f"多边形已完成 ({point_count}个顶点),按Enter分析区域")
print(f"多边形完成,共{point_count}个顶点")
def remove_last_point(self, event=None):
"""删除最后一个点"""
if self.polygon_points:
removed_point = self.polygon_points.pop()
self.redraw_polygon()
point_count = len(self.polygon_points)
if point_count > 0:
self.status_var.set(f"已删除最后一个点,还剩{point_count}个点")
print(f"删除点: {removed_point},还剩{point_count}个点")
else:
self.status_var.set("已清除所有点,请重新选择")
print("已清除所有点")
else:
self.status_var.set("没有点可以删除")
def on_mousewheel(self, event):
"""鼠标滚轮缩放"""
if not self.img:
return
# Windows用event.delta,Linux用event.num
if event.delta > 0 or event.num == 4: # 放大
self.zoom_at_point(event.x, event.y, 1.2)
elif event.delta < 0 or event.num == 5: # 缩小
self.zoom_at_point(event.x, event.y, 0.8)
def on_canvas_drag(self, event):
"""右键拖拽图片"""
if not self.img:
return
if not self.is_dragging:
self.is_dragging = True
self.drag_start_x = event.x
self.drag_start_y = event.y
return
# 计算拖拽距离
dx = event.x - self.drag_start_x
dy = event.y - self.drag_start_y
# 更新偏移
self.offset_x += dx
self.offset_y += dy
# 限制拖拽范围
self.limit_offsets()
# 更新拖拽起始点
self.drag_start_x = event.x
self.drag_start_y = event.y
# 重新显示
self.update_display()
self.status_var.set(f"拖拽中... 偏移: ({self.offset_x:.0f}, {self.offset_y:.0f})")
def zoom_at_point(self, canvas_x, canvas_y, factor):
"""在指定点缩放"""
if not self.img:
return
old_scale = self.scale
new_scale = max(self.min_scale, min(self.max_scale, old_scale * factor))
if abs(new_scale - old_scale) < 0.01:
return
# 计算缩放中心点在图像中的位置
img_x = (canvas_x + self.offset_x) / old_scale
img_y = (canvas_y + self.offset_y) / old_scale
# 更新缩放
self.scale = new_scale
# 调整偏移使缩放点保持在原位
self.offset_x = img_x * new_scale - canvas_x
self.offset_y = img_y * new_scale - canvas_y
# 限制偏移范围
self.limit_offsets()
# 重新显示
self.update_display()
self.status_var.set(f"缩放: {self.scale:.2f}x")
def limit_offsets(self):
"""限制偏移范围,防止图片拖拽出视野"""
if not self.img:
return
canvas_w = self.canvas.winfo_width()
canvas_h = self.canvas.winfo_height()
if canvas_w <= 1 or canvas_h <= 1:
return
disp_w = self.w * self.scale
disp_h = self.h * self.scale
# 计算最大偏移
max_offset_x = max(0, disp_w - canvas_w)
max_offset_y = max(0, disp_h - canvas_h)
# 限制偏移
self.offset_x = max(-canvas_w // 2, min(self.offset_x, max_offset_x + canvas_w // 2))
self.offset_y = max(-canvas_h // 2, min(self.offset_y, max_offset_y + canvas_h // 2))
def zoom_in(self):
"""放大"""
if self.img:
canvas_w = self.canvas.winfo_width()
canvas_h = self.canvas.winfo_height()
center_x = canvas_w // 2
center_y = canvas_h // 2
self.zoom_at_point(center_x, center_y, 1.5)
def zoom_out(self):
"""缩小"""
if self.img:
canvas_w = self.canvas.winfo_width()
canvas_h = self.canvas.h // 2
center_x = canvas_w // 2
center_y = canvas_h // 2
self.zoom_at_point(center_x, center_y, 0.67)
def reset_zoom(self):
"""重置缩放"""
if self.img:
self.scale = 1.0
self.offset_x = 0
self.offset_y = 0
self.update_display()
self.status_var.set("已重置缩放")
def fit_to_window(self):
"""适应窗口"""
if not self.img:
return
self.canvas.update()
canvas_w = self.canvas.winfo_width()
canvas_h = self.canvas.winfo_height()
if canvas_w > 0 and canvas_h > 0:
scale_x = canvas_w / self.w
scale_y = canvas_h / self.h
self.scale = min(scale_x, scale_y) * 0.9
self.offset_x = 0
self.offset_y = 0
self.update_display()
self.status_var.set(f"适应窗口,缩放: {self.scale:.2f}x")
def update_selection_info(self):
"""更新选择信息"""
if self.polygon_points:
point_count = len(self.polygon_points)
if point_count >= 3:
self.select_info.set(f"多边形: {point_count}个顶点\n状态: 已完成")
else:
self.select_info.set(f"多边形: {point_count}个顶点\n状态: 未完成(需要至少3个点)")
else:
self.select_info.set("未选择区域")
def clear_selection(self):
"""清除选择"""
self.polygon_points = []
self.canvas.delete("polygon")
self.update_selection_info()
if self.img:
self.status_var.set("已清除多边形,请重新依次点击多个点围成区域")
else:
self.status_var.set("请先打开图片")
def analyze_region(self):
"""分析多边形区域"""
if not self.img or len(self.polygon_points) < 3:
messagebox.showwarning("警告", "请先选择一个完整的多边形区域(至少3个点)")
return
# 创建多边形mask
mask = Image.new('L', (self.w, self.h), 0)
draw = ImageDraw.Draw(mask)
# 将多边形点转换为整数坐标
polygon_coords = [(int(x), int(y)) for x, y in self.polygon_points]
# 绘制多边形(填充为白色)
draw.polygon(polygon_coords, fill=255)
# 将mask转换为numpy数组
mask_array = np.array(mask)
# 获取原始图像的像素数据
img_array = np.array(self.img)
# 计算多边形内部的总像素数
total_pixels = np.sum(mask_array > 0)
if total_pixels == 0:
messagebox.showwarning("警告", "多边形区域为空,请重新选择")
return
# 计算多边形内部的白色像素
white_count = 0
for y in range(self.h):
for x in range(self.w):
if mask_array[y, x] > 0: # 在多边形内部
r, g, b = img_array[y, x]
if r >= 240 and g >= 240 and b >= 240: # 白色阈值
white_count += 1
white_ratio = white_count / total_pixels if total_pixels > 0 else 0
# 计算置信度(基于与0.5的距离)
confidence = 1 - abs(white_ratio - 0.5) * 2
# 保存结果
region_data = {
'polygon_points': self.polygon_points.copy(),
'total_pixels': total_pixels,
'white_pixels': white_count,
'white_ratio': white_ratio,
'confidence': confidence,
'image_path': str(self.image_path) if self.image_path else None
}
self.regions.append(region_data)
# 显示结果
result_text = f"多边形区域分析结果:\n"
result_text += f"顶点数量: {len(self.polygon_points)}\n"
result_text += f"顶点坐标:\n"
for i, (x, y) in enumerate(self.polygon_points):
result_text += f" {i+1}: ({x:.0f}, {y:.0f})\n"
result_text += f"总像素: {total_pixels}\n"
result_text += f"白色像素: {white_count}\n"
result_text += f"白色比例: {white_ratio:.3f}\n"
result_text += f"置信度: {confidence:.3f}\n"
# 判断是否可能是直播图标
if white_ratio < 0.3:
result_text += f"判断: 可能是直播图标 (白色像素较少)\n"
elif white_ratio > 0.7:
result_text += f"判断: 可能不是直播图标 (白色像素较多)\n"
else:
result_text += f"判断: 不确定 (白色比例适中)\n"
self.result_text.delete(1.0, tk.END)
self.result_text.insert(tk.END, result_text)
print(f"\n=== 多边形区域分析结果 ===")
print(f"顶点: {self.polygon_points}")
print(result_text)
print(f"结果已保存 (共{len(self.regions)}个区域)")
def show_all_regions(self):
"""显示所有区域"""
if not self.regions:
messagebox.showinfo("信息", "没有保存的区域数据")
return
result_text = f"所有多边形区域数据 (共{len(self.regions)}个):\n\n"
for i, region in enumerate(self.regions, 1):
result_text += f"区域 {i}:\n"
result_text += f" 顶点数: {len(region['polygon_points'])}\n"
result_text += f" 顶点坐标:\n"
for j, (x, y) in enumerate(region['polygon_points']):
result_text += f" {j+1}: ({x:.0f}, {y:.0f})\n"
result_text += f" 白色像素: {region['white_pixels']}/{region['total_pixels']}\n"
result_text += f" 比例: {region['white_ratio']:.3f}, 置信度: {region['confidence']:.3f}\n\n"
self.result_text.delete(1.0, tk.END)
self.result_text.insert(tk.END, result_text)
def clear_all_regions(self):
"""清除所有区域"""
self.regions.clear()
self.result_text.delete(1.0, tk.END)
self.result_text.insert(tk.END, "已清除所有区域数据")
def save_regions(self):
"""保存区域数据"""
if not self.regions:
messagebox.showwarning("警告", "没有区域数据可以保存")
return
filename = filedialog.asksaveasfilename(
title="保存区域数据",
defaultextension=".json",
filetypes=[("JSON文件", "*.json"), ("所有文件", "*.*")]
)
if filename:
try:
with open(filename, 'w', encoding='utf-8') as f:
json.dump(self.regions, f, indent=2, ensure_ascii=False)
messagebox.showinfo("成功", f"区域数据已保存到: {filename}")
except Exception as e:
messagebox.showerror("错误", f"保存失败: {e}")
def load_regions(self):
"""加载区域数据"""
filename = filedialog.askopenfilename(
title="加载区域数据",
filetypes=[("JSON文件", "*.json"), ("所有文件", "*.*")]
)
if filename:
try:
with open(filename, 'r', encoding='utf-8') as f:
self.regions = json.load(f)
messagebox.showinfo("成功", f"已加载 {len(self.regions)} 个区域数据")
self.show_all_regions()
except Exception as e:
messagebox.showerror("错误", f"加载失败: {e}")
def run(self):
"""运行主循环"""
self.root.mainloop()
def main():
"""主函数"""
# 如果有命令行参数,使用它作为图片路径
image_path = sys.argv[1] if len(sys.argv) > 1 else None
if image_path and not os.path.exists(image_path):
print(f"错误: 找不到图片文件 {image_path}")
image_path = None
try:
app = SimpleRegionSelector(image_path)
app.run()
except Exception as e:
print(f"启动失败: {e}")
import traceback
traceback.print_exc()
if __name__ == "__main__":
main()