image_classifier.py

#!/usr/bin/env python3

import sys
import subprocess
import shutil
import os

def check_and_install_dependencies():
    """检测依赖，Linux下不自动安装Pillow，仅提示"""
    
    print("\n" + "="*60)
    print("正在检测系统依赖...")
    print("="*60)
    
    try:
        import tkinter
        print("[✓] tkinter 已安装")
    except ImportError:
        if sys.platform == "linux":
            if os.path.exists("/etc/debian_version"):
                cmd = "sudo apt update && sudo apt install -y python3-tk"
                pkg = "python3-tk"
            elif os.path.exists("/etc/redhat-release"):
                cmd = "sudo dnf install -y python3-tkinter"
                pkg = "python3-tkinter"
            elif shutil.which("pacman"):
                cmd = "sudo pacman -S --noconfirm tk"
                pkg = "tk"
            else:
                cmd = "请手动安装系统对应的python3-tk包"
                pkg = "python3-tk"
            
            print(f"\n[✗] tkinter 未安装 (系统库)")
            print(f"\n检测到您的Linux系统需要手动安装tkinter:")
            print(f"  包名: {pkg}")
            print(f"  建议命令: {cmd}")
            print("\n注意：此步骤需要管理员权限，脚本无法自动完成。")
            print("请在另一个终端中运行上述命令后，重新启动本脚本。")
            print("="*60)
            sys.exit(1)
        else:
            print("[✗] tkinter 未安装")
            print("\n您的系统缺少tkinter，这通常意味着Python安装不完整。")
            print("请重新安装Python并确保包含 tcl/tk 支持。")
            print("="*60)
            input("\n按回车键退出...")
            sys.exit(1)
    
    try:
        from PIL import Image, ImageTk
        print("[✓] Pillow 已安装")
    except ImportError:
        print("[✗] Pillow 未安装")
        
        if sys.platform == "linux":
            if os.path.exists("/etc/debian_version"):
                cmd = "sudo apt install python3-pil"
                pkg = "python3-pil"
            elif os.path.exists("/etc/redhat-release"):
                cmd = "sudo dnf install python3-pillow"
                pkg = "python3-pillow"
            elif shutil.which("pacman"):
                cmd = "sudo pacman -S python-pillow"
                pkg = "python-pillow"
            else:
                cmd = "pip install Pillow"
                pkg = "Pillow"
            
            print(f"\n检测到您的系统需要手动安装Pillow:")
            print(f"  包名: {pkg}")
            print(f"  建议命令: {cmd}")
            print("\n对于Debian/Ubuntu等系统，建议使用系统包管理器安装。")
            print("安装完成后，请重新运行本脚本。")
            print("="*60)
            sys.exit(1)
        else:
            print("\nPillow可以通过pip安装:")
            print(f"  pip install Pillow")
            print("\n请安装完成后重新运行本脚本。")
            print("="*60)
            input("\n按回车键退出...")
            sys.exit(1)
    
    print("\n所有依赖检测通过！正在启动程序...\n")
    return True


if __name__ == "__main__":
    check_and_install_dependencies()

import json
from tkinter import *
from tkinter import filedialog, messagebox, ttk
from PIL import Image, ImageTk
import subprocess

class HintEntry(Entry):
    def __init__(self, master, hint='', **kw):
        super().__init__(master, **kw)
        self.hint = hint
        self.hint_color = 'grey'
        self.normal_color = self['fg']
        self.bind('<FocusIn>',  self._clear_hint)
        self.bind('<FocusOut>', self._show_hint)
        self._show_hint()

    def _clear_hint(self, *_):
        if self['fg'] == self.hint_color:
            self.delete(0, END)
            self.config(fg=self.normal_color)

    def _show_hint(self, *_):
        if not self.get():
            self.insert(0, self.hint)
            self.config(fg=self.hint_color)

    def set(self, text):
        self._clear_hint()
        self.insert(0, text)
        self.config(fg=self.normal_color)

class ImageClassifier:
    def __init__(self, root):
        self.root = root
        self.root.title("图片分类工具")
        
        self.windowed_height_ratio = 0.75
        self.windowed_geometry_set = False
        
        if sys.platform == 'win32':
            try:
                import ctypes
                ctypes.windll.shcore.SetProcessDpiAwareness(1)
            except:
                pass
            self.root.state('zoomed')
        
        elif sys.platform == 'darwin':
            root.geometry('%dx%d+%d+%d' % (root.winfo_screenwidth(), root.winfo_screenheight(), 0, 0))
        
        else:
            if root.winfo_screenwidth() > 1920:
                root.tk.call('tk', 'scaling', 1.5)
            root.attributes('-zoomed', True)
        
        import tkinter.font as tkfont
        self.default_font = tkfont.nametofont("TkDefaultFont")
        self.default_font.configure(size=20)
        self.root.option_add("*Font", self.default_font)

        self.config_file = "classifier_config.json"

        self.input_folder   = StringVar()
        self.inc_subfolders = BooleanVar(value=False)
        self.sort_method    = StringVar(value="name")
        self.reverse_sort   = BooleanVar(value=False)
        self.copy_mode      = BooleanVar(value=True)
        
        self.scale_mode     = StringVar(value="完整")
        self.dont_enlarge   = BooleanVar(value=True)

        self.output_folders = [
            {"name": "文件夹１(A)", "path": StringVar()},
            {"name": "文件夹２(S)", "path": StringVar()},
            {"name": "文件夹３(D)", "path": StringVar()}
        ]

        self.all_images = []
        self.ptr = 0
        self.history = []
        self.skip_stack = []

        self.img_ext = ('.jpg','.jpeg','.png','.gif','.bmp','.tiff','.ico')
        self.vid_ext = ('.mp4','.avi','.mov','.wmv','.flv','.mkv')
        self.swf_ext = ('.swf',)
        self.supported_formats = self.img_ext + self.vid_ext + self.swf_ext

        self.load_config()
        self.build_ui()
        self.root.after(100, lambda: self.root.focus_force())
        if self.input_folder.get() and os.path.exists(self.input_folder.get()):
            self.root.after(200, self.load_images)

    def build_ui(self):
        line1 = Frame(self.root)
        line1.pack(fill=X, padx=10, pady=5)
        Label(line1, text="输入路径：").pack(side=LEFT)
        self.input_entry = HintEntry(line1, textvariable=self.input_folder,
                                     hint='这里是需要处理的文件夹路径', state='readonly')
        self.input_entry.pack(side=LEFT, fill=X, expand=True, padx=5)
        Button(line1, text="浏览…", command=self.browse_input).pack(side=LEFT, padx=5)
        Checkbutton(line1, text="包含子文件夹", variable=self.inc_subfolders,
                   command=self.load_images).pack(side=LEFT, padx=5)

        line2 = Frame(self.root)
        line2.pack(fill=X, padx=10, pady=5)

        Label(line2, text="排序：").pack(side=LEFT, padx=(10,0))
        sort_frm = Frame(line2)
        sort_frm.pack(side=LEFT)
        for txt, val in [("时间-新的在前","time"),
                         ("大小-大的在前","size"),
                         ("名称-方向为正","name")]:
            Radiobutton(sort_frm, text=txt, variable=self.sort_method,
                       value=val, command=self.load_images).pack(side=LEFT, padx=5)
        Checkbutton(sort_frm, text="倒序", variable=self.reverse_sort,
                   command=self.load_images).pack(side=LEFT, padx=10)

        sep2 = Frame(sort_frm, width=2, bg="gray")
        sep2.pack(side=LEFT, fill=Y, padx=5)
        
        # 占位弹簧：将后面的控件推到右侧
        Frame(line2).pack(side=LEFT, fill=X, expand=True)
        
        Label(line2, text="缩放模式：").pack(side=LEFT, padx=(10,0))
        scale_frame = Frame(line2)
        scale_frame.pack(side=LEFT, padx=5)
        ttk.Combobox(scale_frame, textvariable=self.scale_mode, 
                    values=["完整", "填充", "原始"], 
                    state="readonly", width=4).pack(side=LEFT)
        self.scale_mode.trace_add('write', self.on_display_option_change)
        
        Checkbutton(line2, text="小图不放大", variable=self.dont_enlarge,
                   command=self.on_display_option_change).pack(side=LEFT, padx=5)
        
        sep = Frame(line2, width=2, bg="gray")
        sep.pack(side=LEFT, fill=Y, padx=10)
        
        mode_frm = Frame(line2)
        mode_frm.pack(side=LEFT)
        Radiobutton(mode_frm, text="复制模式", variable=self.copy_mode, value=True).pack(side=LEFT)
        Radiobutton(mode_frm, text="移动模式", variable=self.copy_mode, value=False).pack(side=LEFT)

        sep_undo = Frame(line2, width=2, bg="gray")
        sep_undo.pack(side=LEFT, fill=Y, padx=10)
        
        Button(line2, text=" 撤销 ", width=0, command=self.undo).pack(side=LEFT, padx=5)

        self.img_frame = Frame(self.root, bg='white', relief=SUNKEN, bd=2)
        self.img_frame.pack(fill=BOTH, expand=True, padx=10, pady=5)
        self.img_frame.pack_propagate(False)
        
        self.img_label = Label(self.img_frame, bg='white', anchor=CENTER)
        self.img_label.pack(fill=BOTH, expand=True)
        self.img_label.bind("<Double-Button-1>", self.open_current_file)

        line4 = Frame(self.root)
        line4.pack(fill=X, padx=10, pady=5)
        self.out_entries = []
        hints = ['这里是输出文件夹A的路径',
                 '这里是输出文件夹B的路径',
                 '这里是输出文件夹C的路径']
        for i, fo in enumerate(self.output_folders):
            frm = Frame(line4)
            frm.pack(side=LEFT, fill=X, expand=True, padx=(0,5) if i<2 else 0)
            Button(frm, text=fo["name"], width=10,
                  command=lambda f=fo: self.browse_output(f)).pack(side=LEFT)
            e = HintEntry(frm, textvariable=fo["path"], hint=hints[i], state='readonly')
            e.pack(side=LEFT, fill=X, expand=True, padx=5)
            self.out_entries.append(e)

        self.status = Label(self.root, text="", bd=1, relief=SUNKEN, anchor=W)
        self.status.pack(side=BOTTOM, fill=X)

        for key, func in (('a', lambda e: self.move_to(0)),
                         ('s', lambda e: self.move_to(1)),
                         ('d', lambda e: self.move_to(2)),
                         ('w', lambda e: self.skip()),
                         ('x', lambda e: self.go_back()),
                         ('<Control-z>', lambda e: self.undo())):
            self.root.bind(key, func)

        self.update_display()

    def on_display_option_change(self, *args):
        if self.all_images:
            self.show_current()

    def load_images(self):
        self.all_images = []
        if not self.input_folder.get(): return
        root_path = self.input_folder.get()
        if not os.path.exists(root_path): return

        if self.inc_subfolders.get():
            for r, _, fs in os.walk(root_path):
                for f in fs:
                    if f.lower().endswith(self.supported_formats):
                        self.all_images.append(os.path.join(r, f))
        else:
            for f in os.listdir(root_path):
                if f.lower().endswith(self.supported_formats):
                    full = os.path.join(root_path, f)
                    if os.path.isfile(full):
                        self.all_images.append(full)

        rev = self.reverse_sort.get()
        if self.sort_method.get() == "time":
            self.all_images.sort(key=lambda x: os.path.getmtime(x), reverse=not rev)
        elif self.sort_method.get() == "size":
            self.all_images.sort(key=lambda x: os.path.getsize(x), reverse=not rev)
        else:
            self.all_images.sort(reverse=rev)

        self.ptr = 0
        self.update_display()

    def update_display(self):
        self.update_status_bar()
        if not self.input_folder.get():
            self.show_welcome(); return
        if not os.path.exists(self.input_folder.get()):
            self.show_error(f"目录：{self.input_folder.get()} 不存在"); return
        if not self.all_images:
            self.show_error(f"目录：{self.input_folder.get()} 没有图片"); return
        valid = sum(1 for fo in self.output_folders if fo["path"].get())
        if valid < 2:
            self.show_error("请选择至少２个输出文件夹。\n请注意检查右上角的分类模式是否正确。\n此时，您仍可以双击打开当前选定的文件，即使程序没有显示该文件。")
            return
        self.show_current()

    def show_welcome(self):
        txt = ("图片分类工具 by Kimi-AI & Rxinns\n\n"
              "——————————————————————\n\n"
              "操作方法：\n\n"
              "1. 在上方选择输入文件夹\n\n"
              "2. 在下方选择 2 到 3 个输出文件夹\n\n"
              "3. 在键盘上按下 A、S、D ，即可分类到对应的文件夹，支持复制或移动\n\n"
              "4. 不知道该怎么分类？按下“W”，可以跳过这张图片\n\n"
              "5. 突然想分类刚才跳过的图？按“X”即可逐张回退，直到栈空\n\n"
              "6. 不小心按错了？按 Ctrl+Z 可以撤销上一次的分类，支持连续撤销\n\n"
              "7. 感觉字体太小？右键编辑代码，搜索：default_font.configure，可以更改字体大小")
        self.img_label.config(text=txt, fg='gray',
                            font=(self.default_font.actual()['family'],
                                  self.default_font.actual()['size']))

    def show_error(self, msg):
        self.img_label.config(text=msg, fg='red', font=(None, 12))

    def show_current(self):
        if not self.all_images: return
        f = self.all_images[self.ptr]
        ext = os.path.splitext(f)[1].lower()

        if ext in self.vid_ext + self.swf_ext:
            self.img_label.config(
                image="",
                text=f"视频／Flash 文件：{os.path.basename(f)}\n\n双击此处用默认程序打开",
                fg='blue', font=(None, 12))
        else:
            try:
                img = Image.open(f)
                frame_w = self.img_frame.winfo_width() - 10
                frame_h = self.img_frame.winfo_height() - 10
                
                if frame_w < 50 or frame_h < 50:
                    return
                
                scale_mode = self.scale_mode.get()
                dont_enlarge = self.dont_enlarge.get()
                
                if scale_mode == "原始":
                    ph = ImageTk.PhotoImage(img)
                elif scale_mode == "填充":
                    # 计算填满窗口所需的缩放比例（取宽高比最大值）
                    scale_w = frame_w / img.width
                    scale_h = frame_h / img.height
                    scale = max(scale_w, scale_h)
                    
                    # 修复Bug：只有在需要*放大*时才检查dont_enlarge开关
                    if dont_enlarge and scale > 1:  # 直接使用布尔值，不要.get()
                        # 需要放大但开关开启 → 保持1:1原始尺寸（允许溢出）
                        ph = ImageTk.PhotoImage(img)
                    else:
                        # 正常缩放（缩小或放大）
                        new_w = int(img.width * scale)
                        new_h = int(img.height * scale)
                        resized = img.resize((new_w, new_h), Image.Resampling.LANCZOS)
                        ph = ImageTk.PhotoImage(resized)
                else:
                    img_ratio = img.width / img.height
                    frame_ratio = frame_w / frame_h
                    
                    if img.width <= frame_w and img.height <= frame_h and dont_enlarge:
                        ph = ImageTk.PhotoImage(img)
                    else:
                        if img_ratio > frame_ratio:
                            new_w = frame_w
                            new_h = int(frame_w / img_ratio)
                        else:
                            new_h = frame_h
                            new_w = int(frame_h * img_ratio)
                        
                        resized = img.resize((new_w, new_h), Image.Resampling.LANCZOS)
                        ph = ImageTk.PhotoImage(resized)
                
                self.img_label.config(image=ph, text="")
                self.img_label.image = ph
            except Exception as e:
                self.img_label.config(text=f"无法加载图片：{e}", fg='red')

    def update_status_bar(self):
        if self.all_images:
            cur = os.path.basename(self.all_images[self.ptr])
            self.status.config(text=f"{self.ptr + 1}/{len(self.all_images)}：{cur}")
        else:
            self.status.config(text="")

    def skip(self):
        if not self.all_images: return
        self.skip_stack.append(self.all_images[self.ptr])
        self.ptr = (self.ptr + 1) % len(self.all_images)
        self.update_display()

    def go_back(self):
        if not self.all_images: return
        self.ptr = (self.ptr - 1) % len(self.all_images)
        self.update_display()

    def move_to(self, idx):
        if not self.all_images or idx >= 3: return
        fo = self.output_folders[idx]["path"].get()
        if not fo:
            messagebox.showwarning("提示", f"请先选择 {self.output_folders[idx]['name']}")
            return
        os.makedirs(fo, exist_ok=True)

        src = self.all_images[self.ptr]
        name = os.path.basename(src)
        dst = os.path.join(fo, name)
        base, ext = os.path.splitext(name)
        c = 1
        while os.path.exists(dst):
            dst = os.path.join(fo, f"{base}_{c}{ext}")
            c += 1

        try:
            if self.copy_mode.get():
                shutil.copy2(src, dst)
            else:
                shutil.move(src, dst)
            self.history.append({
                'src': dst,
                'dst': src,
                'idx': self.ptr,
                'copy': self.copy_mode.get()
            })
            self.all_images.pop(self.ptr)
            if self.all_images:
                self.ptr = self.ptr % len(self.all_images)
            self.update_display()
        except Exception as e:
            messagebox.showerror("错误", f"操作失败：{e}")

    def undo(self):
        if not self.history: return
        act = self.history.pop()
        try:
            if act['copy']:
                os.remove(act['src'])
            else:
                shutil.move(act['src'], act['dst'])
            self.all_images.insert(act['idx'], act['dst'])
            self.ptr = act['idx']
            self.update_display()
        except Exception as e:
            messagebox.showerror("错误", f"撤销失败：{e}")

    def save_config(self):
        cfg = {
            'input_folder': self.input_folder.get(),
            'inc_subfolders': self.inc_subfolders.get(),
            'sort_method': self.sort_method.get(),
            'reverse_sort': self.reverse_sort.get(),
            'copy_mode': self.copy_mode.get(),
            'scale_mode': self.scale_mode.get(),
            'dont_enlarge': self.dont_enlarge.get(),
            'output_folders': [fo["path"].get() for fo in self.output_folders]
        }
        try:
            with open(self.config_file, 'w', encoding='utf-8') as f:
                json.dump(cfg, f, ensure_ascii=False, indent=2)
        except:
            pass

    def load_config(self):
        try:
            if os.path.exists(self.config_file):
                with open(self.config_file, 'r', encoding='utf-8') as f:
                    cfg = json.load(f)
                self.input_folder.set(cfg.get('input_folder', ''))
                self.inc_subfolders.set(cfg.get('inc_subfolders', False))
                self.sort_method.set(cfg.get('sort_method', 'name'))
                self.reverse_sort.set(cfg.get('reverse_sort', False))
                self.copy_mode.set(cfg.get('copy_mode', True))
                self.scale_mode.set(cfg.get('scale_mode', '完整'))
                self.dont_enlarge.set(cfg.get('dont_enlarge', True))
                for i, p in enumerate(cfg.get('output_folders', [])):
                    if i < 3:
                        self.output_folders[i]["path"].set(p)
        except:
            print("配置文件丢失或损坏，已恢复默认设置。")

    def browse_input(self):
        d = filedialog.askdirectory()
        if d:
            self.input_folder.set(d)
            self.input_entry.set(d)
            self.load_images()
            self.save_config()

    def browse_output(self, fo):
        d = filedialog.askdirectory()
        if d:
            fo["path"].set(d)
            idx = next(i for i,x in enumerate(self.output_folders) if x is fo)
            self.out_entries[idx].set(d)
            self.save_config()
            self.update_display()

    def open_current_file(self, _):
        if not self.all_images: return
        f = self.all_images[self.ptr]
        try:
            if sys.platform == 'win32':
                os.startfile(f)
            elif sys.platform == 'darwin':
                subprocess.run(['open', f], check=True)
            else:
                subprocess.run(['xdg-open', f], check=True)
        except Exception as e:
            messagebox.showerror("错误", f"无法打开文件：{e}")

    def on_window_configure(self, event):
        if event.widget != self.root:
            return
        
        if not hasattr(self.root, 'wm_state'):
            return
        
        current_state = self.root.wm_state()
        
        if not hasattr(self, '_prev_window_state'):
            self._prev_window_state = 'zoomed' if sys.platform == 'win32' else 'normal'
        
        state_changed = (current_state != self._prev_window_state)
        
        if (current_state == 'normal' and 
            not self.windowed_geometry_set and 
            self.windowed_height_ratio > 0):
            
            screen_height = self.root.winfo_screenheight()
            target_height = int(screen_height * self.windowed_height_ratio)
            
            current_width = self.root.winfo_width()
            new_geometry = f"{current_width}x{target_height}"
            self.root.geometry(new_geometry)
            
            self.windowed_geometry_set = True
            state_changed = True
        
        if state_changed and self.all_images:
            current_file = self.all_images[self.ptr]
            ext = os.path.splitext(current_file)[1].lower()
            if ext in self.img_ext:
                self.root.after(100, self.show_current)
        
        self._prev_window_state = current_state


if __name__ == "__main__":
    root = Tk()
    app = ImageClassifier(root)
    
    import atexit
    def cleanup():
        try:
            app.save_config()
        except:
            pass
    atexit.register(cleanup)
    
    root.mainloop()