Files
douyi_guaji_main/tools/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

765 lines
29 KiB
Python

#!/usr/bin/env python3
"""
区域选择和白色像素统计工具
用于选择图片区域,圈出边框,并统计区域内白色像素数量
"""
import sys
from pathlib import Path
from typing import Optional, Tuple, Any
import json
from PIL import Image, ImageTk, ImageDraw
try:
import tkinter as tk
from tkinter import filedialog, messagebox
except Exception as e:
raise SystemExit(f"tkinter 不可用:{e}\n请安装带 tkinter 的 Python。")
# 尝试导入拖放支持库
try:
from tkinterdnd2 import DND_FILES, TkinterDnD # type: ignore[import]
HAS_DND = True
except ImportError:
HAS_DND = False
DND_FILES: Any = None
TkinterDnD: Any = None
def clamp(v: float, lo: float, hi: float) -> float:
return lo if v < lo else hi if v > hi else v
class RegionSelector:
def __init__(self, image_path: Optional[Path]):
self.image_path: Optional[Path] = None
self.img: Optional[Image.Image] = None
self.w = 0
self.h = 0
self.scale = 1.0
self.min_scale = 0.1 # 最小缩放比例
self.max_scale = 10.0 # 最大缩放比例
self.disp_w = 0
self.disp_h = 0
self.tk_img = None
self.file_list: list[Path] = []
self.file_idx: int = -1
self.zoom_center_x = 0 # 缩放中心点
self.zoom_center_y = 0
self.scroll_offset_x = 0 # 滚动偏移
self.scroll_offset_y = 0
# 区域选择相关
self.selection_rect = None # 当前选择的矩形 (x1, y1, x2, y2)
self.selection_canvas_id = None # Canvas中的矩形ID
self.is_selecting = False
self.select_start_x = 0
self.select_start_y = 0
self.select_end_x = 0
self.select_end_y = 0
# 拖拽相关
self.is_dragging = False
self.drag_start_x = 0
self.drag_start_y = 0
# 结果存储
self.white_pixel_regions = [] # 存储区域和白色像素统计结果
# 使用 TkinterDnD 支持拖放(如果可用)
if HAS_DND:
self.root = TkinterDnD.Tk()
else:
self.root = tk.Tk()
self.root.title("区域选择器 - 白色像素统计工具")
self.root.geometry("1200x800")
# 创建菜单
self._create_menu()
# 创建主界面
self._create_ui()
if image_path is None:
if not self.open_dialog():
raise SystemExit(2)
else:
self.set_image(image_path, update_list=True)
def _create_menu(self):
"""创建菜单栏"""
menubar = tk.Menu(self.root)
file_menu = tk.Menu(menubar, tearoff=0)
file_menu.add_command(label="打开...", command=self.open_dialog, accelerator="Ctrl+O")
file_menu.add_command(label="上一张", command=self.prev_image, accelerator="← / PageUp")
file_menu.add_command(label="下一张", command=self.next_image, accelerator="→ / PageDown")
file_menu.add_separator()
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.destroy)
menubar.add_cascade(label="文件", menu=file_menu)
view_menu = tk.Menu(menubar, tearoff=0)
view_menu.add_command(label="放大 (+)", command=self.zoom_in, accelerator="+ / Ctrl+滚轮上")
view_menu.add_command(label="缩小 (-)", command=self.zoom_out, accelerator="- / Ctrl+滚轮下")
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)
region_menu = tk.Menu(menubar, tearoff=0)
region_menu.add_command(label="清除选择", command=self.clear_selection, accelerator="Delete")
region_menu.add_command(label="分析区域", command=self.analyze_region, accelerator="Enter")
region_menu.add_separator()
region_menu.add_command(label="显示所有区域", command=self.show_all_regions, accelerator="Ctrl+A")
region_menu.add_command(label="清除所有区域", command=self.clear_all_regions)
menubar.add_cascade(label="区域", menu=region_menu)
self.root.config(menu=menubar)
# 绑定快捷键
self.root.bind_all("<Control-o>", lambda e: self.open_dialog())
self.root.bind("<Left>", lambda e: self.prev_image())
self.root.bind("<Right>", lambda e: self.next_image())
self.root.bind("<Prior>", lambda e: self.prev_image()) # PageUp
self.root.bind("<Next>", lambda e: self.next_image()) # PageDown
self.root.bind("<plus>", lambda e: self.zoom_in())
self.root.bind("<equal>", lambda e: self.zoom_in()) # 无Shift的+键
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())
self.root.bind("<Delete>", lambda e: self.clear_selection())
self.root.bind("<Return>", lambda e: self.analyze_region())
self.root.bind("<Control-s>", lambda e: self.save_regions())
self.root.bind("<Control-l>", lambda e: self.load_regions())
self.root.bind("<Control-a>", lambda e: self.show_all_regions())
def _create_ui(self):
"""创建用户界面"""
# 主框架
main_frame = tk.Frame(self.root)
main_frame.pack(fill=tk.BOTH, expand=True)
# 左侧控制面板
left_panel = tk.Frame(main_frame, width=300, bg='#f0f0f0')
left_panel.pack(side=tk.LEFT, fill=tk.Y, padx=5, pady=5)
# 右侧画布区域
right_panel = tk.Frame(main_frame)
right_panel.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)
# 控制面板内容
self._create_control_panel(left_panel)
# 画布
self.canvas = tk.Canvas(right_panel, bg='#404040')
self.canvas.pack(fill=tk.BOTH, expand=True)
self._canvas_image_id = self.canvas.create_image(0, 0, anchor=tk.NW)
# 状态栏
self.status = tk.StringVar()
if HAS_DND:
self.status.set("拖拽选择区域;滚轮缩放;右键拖拽平移;Enter分析区域;Ctrl+O打开图片;或直接拖放图片")
else:
self.status.set("拖拽选择区域;滚轮缩放;右键拖拽平移;Enter分析区域;Ctrl+O打开图片")
status_label = tk.Label(right_panel, textvariable=self.status, anchor="w", bg='#e0e0e0')
status_label.pack(fill=tk.X, side=tk.BOTTOM)
# 绑定事件
self.canvas.bind("<Motion>", self.on_move)
self.canvas.bind("<Button-1>", self.on_left_click)
self.canvas.bind("<B1-Motion>", self.on_left_drag)
self.canvas.bind("<ButtonRelease-1>", self.on_left_release)
self.canvas.bind("<Button-3>", self.on_right_click) # 右键开始拖拽
self.canvas.bind("<B3-Motion>", self.on_right_drag) # 右键拖拽
self.canvas.bind("<ButtonRelease-3>", self.on_right_release)
self.canvas.bind("<MouseWheel>", self.on_mousewheel) # Windows/Linux
self.canvas.bind("<Button-4>", self.on_mousewheel) # Linux
self.canvas.bind("<Button-5>", self.on_mousewheel) # Linux
self.canvas.bind("<Control-MouseWheel>", self.on_mousewheel_ctrl) # Ctrl+滚轮
# 添加拖放支持
if HAS_DND:
self.root.drop_target_register(DND_FILES)
self.root.dnd_bind('<<Drop>>', self.on_drop)
self.canvas.drop_target_register(DND_FILES)
self.canvas.dnd_bind('<<Drop>>', self.on_drop)
def _create_control_panel(self, parent):
"""创建控制面板"""
# 标题
title_label = tk.Label(parent, text="区域选择器", font=("Arial", 14, "bold"), bg='#f0f0f0')
title_label.pack(pady=10)
# 当前选择信息
selection_frame = tk.LabelFrame(parent, text="当前选择", bg='#f0f0f0')
selection_frame.pack(fill=tk.X, padx=5, pady=5)
self.selection_info = tk.StringVar()
self.selection_info.set("未选择区域")
selection_label = tk.Label(selection_frame, textvariable=self.selection_info,
anchor="w", bg='#f0f0f0', justify=tk.LEFT)
selection_label.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_info = tk.Text(result_frame, height=8, width=35, font=("Courier", 9))
scrollbar = tk.Scrollbar(result_frame, command=self.result_info.yview)
self.result_info.config(yscrollcommand=scrollbar.set)
self.result_info.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=5, pady=5)
scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
# 按钮区域
button_frame = tk.Frame(parent, bg='#f0f0f0')
button_frame.pack(fill=tk.X, padx=5, pady=5)
tk.Button(button_frame, text="分析区域", command=self.analyze_region,
bg='#4CAF50', fg='white').pack(fill=tk.X, pady=2)
tk.Button(button_frame, text="清除选择", command=self.clear_selection,
bg='#f44336', fg='white').pack(fill=tk.X, pady=2)
tk.Button(button_frame, text="显示所有", command=self.show_all_regions,
bg='#2196F3', fg='white').pack(fill=tk.X, pady=2)
tk.Button(button_frame, text="清除所有", command=self.clear_all_regions,
bg='#FF9800', fg='white').pack(fill=tk.X, pady=2)
def _refresh_file_list(self, current: Path) -> None:
"""刷新当前目录下的图片列表"""
exts = {".png", ".jpg", ".jpeg", ".bmp", ".webp"}
try:
files = [p for p in current.parent.iterdir() if p.suffix.lower() in exts and p.is_file()]
files.sort()
self.file_list = files
try:
self.file_idx = self.file_list.index(current)
except ValueError:
self.file_idx = -1
except Exception:
self.file_list = []
self.file_idx = -1
def set_image(self, image_path: Path, update_list: bool = False) -> None:
"""设置当前图片"""
image_path = Path(image_path)
self.image_path = image_path
self.img = Image.open(image_path).convert("RGB")
self.w, self.h = self.img.size
if update_list:
self._refresh_file_list(image_path)
# 清除之前的选择
self.clear_selection()
self.clear_all_regions()
# 显示用缩放
self._update_display()
self.root.title(f"区域选择器: {image_path.name} ({self.w}x{self.h}) | 缩放: {self.scale:.2f}x")
def open_dialog(self) -> bool:
"""打开文件选择对话框"""
initial_dir = None
try:
if self.image_path and self.image_path.parent.exists():
initial_dir = str(self.image_path.parent)
except Exception:
initial_dir = None
filename = filedialog.askopenfilename(
title="选择图片",
initialdir=initial_dir,
filetypes=[
("Images", "*.png;*.jpg;*.jpeg;*.bmp;*.webp"),
("All files", "*.*"),
],
)
if not filename:
return False
try:
self.set_image(Path(filename), update_list=True)
return True
except Exception as e:
messagebox.showerror("错误", f"打开图片失败: {e}")
return False
def _to_image_xy(self, event) -> tuple[int, int]:
"""将canvas坐标转换为图像坐标"""
if not self.img or self.w <= 0 or self.h <= 0:
return 0, 0
# 考虑缩放和滚动偏移
canvas_x = event.x + self.scroll_offset_x
canvas_y = event.y + self.scroll_offset_y
x = int(clamp(canvas_x / self.scale, 0, self.w - 1))
y = int(clamp(canvas_y / self.scale, 0, self.h - 1))
return x, y
def _to_canvas_xy(self, img_x: int, img_y: int) -> tuple[int, int]:
"""将图像坐标转换为canvas坐标"""
canvas_x = img_x * self.scale - self.scroll_offset_x
canvas_y = img_y * self.scale - self.scroll_offset_y
return int(canvas_x), int(canvas_y)
def _update_display(self):
"""更新显示"""
if not self.img:
return
# 获取canvas实际大小
self.root.update_idletasks()
canvas_w = max(1, self.canvas.winfo_width())
canvas_h = max(1, self.canvas.winfo_height())
# 计算显示尺寸
self.disp_w = int(self.w * self.scale)
self.disp_h = int(self.h * self.scale)
# 限制滚动偏移
max_offset_x = max(0, self.disp_w - canvas_w)
max_offset_y = max(0, self.disp_h - canvas_h)
self.scroll_offset_x = max(0, min(self.scroll_offset_x, max_offset_x))
self.scroll_offset_y = max(0, min(self.scroll_offset_y, max_offset_y))
# 生成显示图像
try:
resample = Image.Resampling.BICUBIC if hasattr(Image, 'Resampling') else Image.BICUBIC
except Exception:
resample = Image.BICUBIC
if self.scale != 1.0:
# 如果放大,只显示可见区域以提高性能
if self.scale > 1.0 and canvas_w < self.disp_w and canvas_h < self.disp_h:
# 计算原图中要显示的区域
src_x1 = max(0, int(self.scroll_offset_x / self.scale))
src_y1 = max(0, int(self.scroll_offset_y / self.scale))
src_x2 = min(self.w, src_x1 + int(canvas_w / self.scale) + 2)
src_y2 = min(self.h, src_y1 + int(canvas_h / self.scale) + 2)
# 裁剪并放大
crop_img = self.img.crop((src_x1, src_y1, src_x2, src_y2))
crop_w, crop_h = crop_img.size
disp_img = crop_img.resize((int(crop_w * self.scale), int(crop_h * self.scale)), resample)
else:
# 缩小或完全显示
disp_img = self.img.resize((self.disp_w, self.disp_h), resample)
else:
disp_img = self.img
self.tk_img = ImageTk.PhotoImage(disp_img)
# 更新canvas滚动区域
self.canvas.config(scrollregion=(0, 0, self.disp_w, self.disp_h))
# 更新图像位置
self.canvas.coords(self._canvas_image_id, -self.scroll_offset_x, -self.scroll_offset_y)
self.canvas.itemconfig(self._canvas_image_id, image=self.tk_img)
# 重新绘制选择矩形
self._redraw_selection_rect()
# 更新标题
if self.image_path:
self.root.title(f"区域选择器: {self.image_path.name} ({self.w}x{self.h}) | 缩放: {self.scale:.2f}x")
def _redraw_selection_rect(self):
"""重新绘制选择矩形"""
# 删除旧的矩形
if self.selection_canvas_id:
self.canvas.delete(self.selection_canvas_id)
self.selection_canvas_id = None
# 绘制新的矩形
if self.selection_rect:
x1, y1, x2, y2 = self.selection_rect
canvas_x1, canvas_y1 = self._to_canvas_xy(x1, y1)
canvas_x2, canvas_y2 = self._to_canvas_xy(x2, y2)
self.selection_canvas_id = self.canvas.create_rectangle(
canvas_x1, canvas_y1, canvas_x2, canvas_y2,
outline='red', width=2, dash=(5, 5)
)
def on_move(self, event):
"""鼠标移动事件"""
if self.is_selecting:
# 更新选择矩形
self.select_end_x, self.select_end_y = self._to_image_xy(event)
self._update_selection_rect()
elif self.is_dragging:
# 拖拽平移
dx = event.x - self.drag_start_x
dy = event.y - self.drag_start_y
self.scroll_offset_x -= dx
self.scroll_offset_y -= dy
self.drag_start_x = event.x
self.drag_start_y = event.y
self._update_display()
def on_left_click(self, event):
"""左键点击"""
if not self.img:
return
img_x, img_y = self._to_image_xy(event)
self.select_start_x = img_x
self.select_start_y = img_y
self.select_end_x = img_x
self.select_end_y = img_y
self.is_selecting = True
self._update_selection_rect()
def on_left_drag(self, event):
"""左键拖拽"""
if self.is_selecting:
self.select_end_x, self.select_end_y = self._to_image_xy(event)
self._update_selection_rect()
def on_left_release(self, event):
"""左键释放"""
if self.is_selecting:
self.select_end_x, self.select_end_y = self._to_image_xy(event)
self._update_selection_rect()
self.is_selecting = False
# 更新选择信息
self._update_selection_info()
def on_right_click(self, event):
"""右键点击开始拖拽"""
self.drag_start_x = event.x
self.drag_start_y = event.y
self.is_dragging = True
def on_right_drag(self, event):
"""右键拖拽"""
if self.is_dragging:
dx = event.x - self.drag_start_x
dy = event.y - self.drag_start_y
self.scroll_offset_x -= dx
self.scroll_offset_y -= dy
self.drag_start_x = event.x
self.drag_start_y = event.y
self._update_display()
def on_right_release(self, event):
"""右键释放"""
self.is_dragging = False
def _update_selection_rect(self):
"""更新选择矩形"""
x1 = min(self.select_start_x, self.select_end_x)
y1 = min(self.select_start_y, self.select_end_y)
x2 = max(self.select_start_x, self.select_end_x)
y2 = max(self.select_start_y, self.select_end_y)
self.selection_rect = (x1, y1, x2, y2)
self._redraw_selection_rect()
def _update_selection_info(self):
"""更新选择信息显示"""
if self.selection_rect:
x1, y1, x2, y2 = self.selection_rect
width = x2 - x1 + 1
height = y2 - y1 + 1
self.selection_info.set(f"区域: ({x1}, {y1}) - ({x2}, {y2})\n尺寸: {width}x{height}")
else:
self.selection_info.set("未选择区域")
def analyze_region(self):
"""分析当前选择的区域"""
if not self.img or not self.selection_rect:
messagebox.showwarning("警告", "请先选择一个区域")
return
x1, y1, x2, y2 = self.selection_rect
# 统计白色像素
white_count = 0
total_pixels = 0
region_img = self.img.crop((x1, y1, x2+1, y2+1))
# 将图像转换为numpy数组进行分析
import numpy as np
region_array = np.array(region_img)
# 计算白色像素(RGB值都接近255的像素)
white_threshold = 240 # 白色阈值
white_pixels = np.all(region_array >= white_threshold, axis=2)
white_count = np.sum(white_pixels)
total_pixels = region_array.shape[0] * region_array.shape[1]
white_ratio = white_count / total_pixels if total_pixels > 0 else 0
# 生成结果文本
result_text = f"区域分析结果:\n"
result_text += f"坐标: ({x1}, {y1}) - ({x2}, {y2})\n"
result_text += f"尺寸: {(x2-x1+1)}x{(y2-y1+1)}\n"
result_text += f"总像素: {total_pixels}\n"
result_text += f"白色像素: {white_count}\n"
result_text += f"白色比例: {white_ratio:.3f}\n"
result_text += f"置信度: {(1 - abs(white_ratio - 0.5) * 2):.3f}"
# 保存到结果列表
region_data = {
'coordinates': (x1, y1, x2, y2),
'size': (x2-x1+1, y2-y1+1),
'total_pixels': total_pixels,
'white_pixels': white_count,
'white_ratio': white_ratio,
'image_path': str(self.image_path) if self.image_path else None
}
self.white_pixel_regions.append(region_data)
# 显示结果
self.result_info.delete(1.0, tk.END)
self.result_info.insert(tk.END, result_text)
# 打印到控制台
print(f"\n=== 区域分析结果 ===")
print(result_text)
print(f"结果已保存到内存中 (共{len(self.white_pixel_regions)}个区域)")
def clear_selection(self):
"""清除当前选择"""
self.selection_rect = None
if self.selection_canvas_id:
self.canvas.delete(self.selection_canvas_id)
self.selection_canvas_id = None
self._update_selection_info()
def clear_all_regions(self):
"""清除所有保存的区域"""
self.white_pixel_regions.clear()
self.result_info.delete(1.0, tk.END)
self.result_info.insert(tk.END, "已清除所有区域数据")
def show_all_regions(self):
"""显示所有保存的区域"""
if not self.white_pixel_regions:
messagebox.showinfo("信息", "没有保存的区域数据")
return
result_text = f"所有区域数据 (共{len(self.white_pixel_regions)}个):\n\n"
for i, region in enumerate(self.white_pixel_regions, 1):
x1, y1, x2, y2 = region['coordinates']
result_text += f"区域 {i}:\n"
result_text += f" 坐标: ({x1}, {y1}) - ({x2}, {y2})\n"
result_text += f" 尺寸: {region['size'][0]}x{region['size'][1]}\n"
result_text += f" 白色像素: {region['white_pixels']}/{region['total_pixels']} "
result_text += f"({region['white_ratio']:.3f})\n\n"
self.result_info.delete(1.0, tk.END)
self.result_info.insert(tk.END, result_text)
def save_regions(self):
"""保存区域数据到文件"""
if not self.white_pixel_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.white_pixel_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.white_pixel_regions = json.load(f)
messagebox.showinfo("成功", f"已加载 {len(self.white_pixel_regions)} 个区域数据")
self.show_all_regions()
except Exception as e:
messagebox.showerror("错误", f"加载失败: {e}")
def on_mousewheel(self, event):
"""鼠标滚轮缩放"""
if event.state & 0x4: # Ctrl键按下
return # 交给on_mousewheel_ctrl处理
delta = 0
if event.num == 4 or event.delta > 0: # 向上滚动
delta = 1
elif event.num == 5 or event.delta < 0: # 向下滚动
delta = -1
if delta != 0:
img_x, img_y = self._to_image_xy(event)
self._zoom_at_point(img_x, img_y, delta * 0.1)
def on_mousewheel_ctrl(self, event):
"""Ctrl+滚轮缩放"""
delta = 0
if event.num == 4 or event.delta > 0: # 向上滚动
delta = 1
elif event.num == 5 or event.delta < 0: # 向下滚动
delta = -1
if delta != 0:
img_x, img_y = self._to_image_xy(event)
self._zoom_at_point(img_x, img_y, delta * 0.1)
def _zoom_at_point(self, img_x: int, img_y: int, delta: float):
"""在指定点缩放"""
if not self.img:
return
old_scale = self.scale
new_scale = clamp(old_scale + delta, self.min_scale, self.max_scale)
if abs(new_scale - old_scale) < 0.01:
return
# 计算缩放中心点在图像中的位置
# 调整滚动偏移,使缩放点保持在屏幕上的同一位置
scale_ratio = new_scale / old_scale
self.scroll_offset_x = img_x * new_scale - (img_x * old_scale - self.scroll_offset_x) * scale_ratio
self.scroll_offset_y = img_y * new_scale - (img_y * old_scale - self.scroll_offset_y) * scale_ratio
self.scale = new_scale
self._update_display()
def zoom_in(self):
"""放大"""
if not self.img:
return
center_x = self.w // 2
center_y = self.h // 2
self._zoom_at_point(center_x, center_y, 0.2)
def zoom_out(self):
"""缩小"""
if not self.img:
return
center_x = self.w // 2
center_y = self.h // 2
self._zoom_at_point(center_x, center_y, -0.2)
def reset_zoom(self):
"""重置缩放"""
if not self.img:
return
self.scale = 1.0
self.scroll_offset_x = 0
self.scroll_offset_y = 0
self._update_display()
def fit_to_window(self):
"""适应窗口大小"""
if not self.img:
return
self.root.update_idletasks()
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.scroll_offset_x = 0
self.scroll_offset_y = 0
self._update_display()
def _load_by_index(self, idx: int) -> bool:
"""按索引加载图片"""
if not self.file_list:
return False
idx = idx % len(self.file_list)
try:
self.set_image(self.file_list[idx], update_list=False)
self.file_idx = idx
return True
except Exception as e:
messagebox.showerror("错误", f"切换图片失败: {e}")
return False
def next_image(self) -> None:
"""下一张图片"""
if self.file_list:
if self._load_by_index(self.file_idx + 1):
self.status.set(f"下一张: {self.image_path.name if self.image_path else ''}")
def prev_image(self) -> None:
"""上一张图片"""
if self.file_list:
if self._load_by_index(self.file_idx - 1):
self.status.set(f"上一张: {self.image_path.name if self.image_path else ''}")
def on_drop(self, event) -> None:
"""处理拖放事件"""
if not HAS_DND:
return
try:
# 获取拖放的文件路径
files = self.root.tk.splitlist(event.data)
if not files:
return
# 取第一个文件
file_path = files[0]
# 移除可能的花括号(Windows 拖放可能包含)
file_path = file_path.strip('{}')
path = Path(file_path)
if not path.exists():
self.status.set(f"文件不存在: {path}")
return
# 检查是否为图片文件
exts = {".png", ".jpg", ".jpeg", ".bmp", ".webp"}
if path.suffix.lower() not in exts:
self.status.set(f"不是支持的图片格式: {path.suffix}")
return
# 加载图片
self.set_image(path, update_list=True)
self.status.set(f"已加载: {path.name}")
except Exception as e:
self.status.set(f"拖放失败: {e}")
def run(self):
"""运行主循环"""
self.root.mainloop()
def main(argv: list[str]) -> int:
"""主函数"""
p: Optional[Path] = None
if len(argv) >= 2:
p = Path(argv[1]).expanduser()
if p and not p.is_absolute():
p = (Path(__file__).resolve().parent.parent / p).resolve()
if p and not p.exists():
print(f"找不到图片: {p}")
print("将弹出文件选择框,请手动选择图片。")
p = None
else:
print("未传入图片路径,将弹出文件选择框。")
RegionSelector(p).run()
return 0
if __name__ == "__main__":
raise SystemExit(main(sys.argv))