Upload 12 files

captions.json

@@ -0,0 +1,13 @@
+{
+  "prompt": "Write a concise, accurate, blunt, and detailed description. Focus on important points instead of writing too long. INCLUDE genre and style of the artwork if not photorealistic, State the ethnicity or race of any person. State what the photo was taken or drawn with. AVOID euphemisms, vague wording. Keep the caption length under 150 words!",
+  "max_new_tokens": 250,
+  "temperature": 1.0,
+  "top_k": 50,
+  "top_p": null,
+  "precision": 1,
+  "thread_count": 4,
+  "batch_size": 1,
+  "prepend_text": "",
+  "append_text": "",
+  "caption_handling": "overwrite"
+}

config.json

@@ -0,0 +1,6 @@
+{
+  "model": "swinv2",
+  "general_threshold": 0.6,
+  "character_threshold": 0.35,
+  "model_dir": "D:/test/models/wd-swinv2-tagger-v3"
+}

image_converter.py

@@ -0,0 +1,426 @@
+import tkinter as tk
+from tkinter import filedialog, ttk, messagebox
+from PIL import Image as PILImage, ImageTk
+from wand.image import Image
+import os
+import queue
+import hashlib
+import threading
+import subprocess
+
+# Biến toàn cục để điều khiển việc dừng và lưu lỗi
+stop_conversion = False
+error_messages = []
+selected_files = []
+converted_hashes = set()
+save_directory = ""
+
+def open_image_converter():
+    global stop_conversion, error_messages, selected_files, save_dir_var, format_var, status_var, num_files_var, errors_var, thread_count_var, filename_var, filter_var, progress, q, root
+
+    # Tạo cửa sổ Tkinter
+    root = tk.Tk()
+    root.title("Image Converter")
+
+    # Khởi tạo các biến Tkinter
+    save_dir_var = tk.StringVar()
+    format_var = tk.StringVar(value='png')
+    status_var = tk.StringVar()
+    num_files_var = tk.StringVar(value="0 files selected.")
+    errors_var = tk.StringVar(value="Errors: 0")
+    thread_count_var = tk.StringVar(value="4")
+    filename_var = tk.StringVar()
+    filter_var = tk.BooleanVar(value=False)
+    progress = tk.IntVar(value=0)
+    q = queue.Queue()
+
+    # Định nghĩa các định dạng được hỗ trợ
+    SUPPORTED_TO_PS = ['pdf', 'jpeg', 'jpg', 'tiff', 'pnm']
+    SUPPORTED_TO_EPS = ['pdf', 'jpeg', 'jpg', 'tiff', 'pnm']
+    NEEDS_INTERMEDIATE_CONVERSION = {
+        'psd': 'pdf', 'svg': 'pdf', 'png': 'pdf',
+        'bmp': 'pdf', 'gif': 'pdf', 'ico': 'png'
+    }
+
+    # Các hàm trợ giúp
+    def center_window(window):
+        window.update_idletasks()
+        width = window.winfo_width()
+        height = window.winfo_height()
+        x = (window.winfo_screenwidth() // 2) - (width // 2)
+        y = (window.winfo_screenheight() // 2) - (height // 2)
+        window.geometry(f'{width}x{height}+{x}+{y}')
+
+    def select_files():
+        filepaths = filedialog.askopenfilenames(
+            title="Select Files",
+            filetypes=[("All Image files", "*.jpg;*.jpeg;*.png;*.gif;*.bmp;*.tiff;*.tif;*.svg;*.webp;*.pdf;*.psd;*.ico"),
+                       ("JPEG files", "*.jpg;*.jpeg"),
+                       ("PNG files", "*.png"),
+                       ("GIF files", "*.gif"),
+                       ("BMP files", "*.bmp"),
+                       ("TIFF files", "*.tiff;*.tif"),
+                       ("SVG files", "*.svg"),
+                       ("WEBP files", "*.webp"),
+                       ("PDF files", "*.pdf"),
+                       ("PSD files", "*.psd"),
+                       ("ICO files", "*.ico")]
+        )
+        if filepaths:
+            selected_files.clear()
+            selected_files.extend(filepaths)
+            num_files_var.set(f"{len(selected_files)} files selected.")
+            update_image_preview()
+
+    def choose_save_directory():
+        global save_directory
+        directory = filedialog.askdirectory()
+        if directory:
+            save_directory = directory
+            save_dir_var.set(directory)
+            save_dir_entry.config(state='normal')
+            save_dir_entry.delete(0, tk.END)
+            save_dir_entry.insert(0, directory)
+            save_dir_entry.config(state='readonly')
+
+    def hash_image(file_path):
+        """Tạo hàm băm SHA-256 từ nội dung ảnh."""
+        hash_sha256 = hashlib.sha256()
+        try:
+            file_path = os.path.normpath(file_path)
+            with open(file_path, "rb") as f:
+                for chunk in iter(lambda: f.read(4096), b""):
+                    hash_sha256.update(chunk)
+        except Exception as e:
+            print(f"Error hashing file {file_path}: {e}")
+            return None
+        return hash_sha256.hexdigest()
+
+    def filter_duplicate_images(filepaths):
+        unique_images = {}
+        filtered_files = []
+        for filepath in filepaths:
+            image_hash = hash_image(filepath)
+            if image_hash and image_hash not in unique_images:
+                if image_hash not in converted_hashes:
+                    unique_images[image_hash] = filepath
+                    filtered_files.append(filepath)
+        return filtered_files
+
+    def can_convert_directly(input_format, output_format):
+        """Kiểm tra xem có thể chuyển đổi trực tiếp từ định dạng nguồn sang định dạng đích không."""
+        if output_format == 'ps':
+            return input_format in SUPPORTED_TO_PS
+        elif output_format == 'eps':
+            return input_format in SUPPORTED_TO_EPS
+        elif output_format == 'ico':
+            return input_format not in ['ps', 'eps', 'pdf']
+        elif input_format == 'ico':
+            return output_format not in ['ps', 'eps']
+        return True
+
+    def notify_conversion_path(input_format, output_format):
+        """Hiển thị thông báo nhắc nhở người dùng về bước chuyển đổi trung gian cần thiết."""
+        intermediate_format = NEEDS_INTERMEDIATE_CONVERSION.get(input_format, None)
+        if intermediate_format:
+            if output_format in ['ps', 'eps']:
+                message = (f"Cannot convert directly from {input_format.upper()} to {output_format.upper()}. "
+                           f"Please convert to PDF first, then convert to {output_format.upper()}.")
+            else:
+                message = (f"Cannot convert directly from {input_format.upper()} to {output_format.upper()}. "
+                           f"Please convert to {intermediate_format.upper()} first, then convert to {output_format.upper()}.")
+        else:
+            message = (f"Conversion from {input_format.upper()} to {output_format.upper()} is not supported. "
+                       "Please use a different format for conversion.")
+        messagebox.showwarning("Conversion Notice", message)
+
+    def convert_image_with_wand(input_path, output_format, output_path):
+        """Chuyển đổi ảnh sử dụng ImageMagick thông qua Wand."""
+        try:
+            with Image(filename=input_path) as img:
+                img.format = output_format
+                img.save(filename=output_path)
+        except Exception as e:
+            raise RuntimeError(f"Error converting {input_path} to {output_format}: {e}")
+
+    def convert_image_with_ghostscript(input_path, output_format, output_path):
+        """Chuyển đổi ảnh sử dụng Ghostscript."""
+        try:
+            gs_command = [
+                "gswin64c",
+                "-dBATCH",
+                "-dNOPAUSE",
+                "-sDEVICE=" + ("ps2write" if output_format == "ps" else "eps2write"),
+                f"-sOutputFile={output_path}",
+                input_path
+            ]
+            subprocess.run(gs_command, check=True, creationflags=subprocess.CREATE_NO_WINDOW)
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"Ghostscript error: {e}")
+
+    def convert_image(input_path, save_directory, output_format, output_filename, q):
+        if stop_conversion:
+            return
+
+        filename = os.path.basename(input_path)
+        name, ext = os.path.splitext(filename)
+        ext = ext[1:].lower()
+        original_name = name
+
+        try:
+            if output_filename:
+                name = output_filename
+
+            output_path = os.path.join(save_directory, f"{name}.{output_format}")
+
+            counter = 1
+            while os.path.exists(output_path):
+                new_name = f"{name} ({counter})"
+                output_path = os.path.join(save_directory, f"{new_name}.{output_format}")
+                counter += 1
+
+            if ext in NEEDS_INTERMEDIATE_CONVERSION and output_format in ["ps", "eps"]:
+                intermediate_format = NEEDS_INTERMEDIATE_CONVERSION[ext]
+                intermediate_path = os.path.join(save_directory, f"{name}.{intermediate_format}")
+
+                # Chuyển đổi sang định dạng trung gian
+                convert_image_with_wand(input_path, intermediate_format, intermediate_path)
+
+                # Chuyển đổi từ định dạng trung gian sang định dạng cuối
+                if output_format in ["ps", "eps"]:
+                    convert_image_with_ghostscript(intermediate_path, output_format, output_path)
+                else:
+                    convert_image_with_wand(intermediate_path, output_format, output_path)
+
+                os.remove(intermediate_path)
+            else:
+                if output_format in ["ps", "eps"]:
+                    convert_image_with_ghostscript(input_path, output_format, output_path)
+                else:
+                    convert_image_with_wand(input_path, output_format, output_path)
+                
+            q.put(input_path)
+            converted_hashes.add(hash_image(output_path))
+        except Exception as e:
+            error_message = f"Error converting {filename}: {str(e)}"
+            q.put(error_message)
+            error_messages.append(error_message)
+
+    def worker(save_directory, output_format, num_threads, output_filename, q, filter_duplicates):
+        try:
+            total_files = selected_files
+            if filter_duplicates:
+                total_files = filter_duplicate_images(selected_files)
+            progress.set(0)
+            for i, input_path in enumerate(total_files, 1):
+                if stop_conversion:
+                    break
+                input_format = os.path.splitext(input_path)[1][1:].lower()
+                if not can_convert_directly(input_format, output_format):
+                    notify_conversion_path(input_format, output_format)
+                    q.put(None)
+                    return
+
+                thread = threading.Thread(target=convert_image, args=(input_path, save_directory, output_format, output_filename, q))
+                thread.start()
+                thread.join()
+
+            q.put(None)
+        except Exception as e:
+            if not stop_conversion:
+                q.put(e)
+
+    def update_progress():
+        try:
+            completed = 0
+            while True:
+                item = q.get()
+                if item is None:
+                    break
+                if isinstance(item, str):
+                    if "Error" in item:
+                        root.after(0, errors_var.set, f"Errors: {len(error_messages)}")
+                        continue
+                completed += 1
+                progress.set(int((completed / len(selected_files)) * 100))
+                if not stop_conversion:
+                    root.after(0, status_var.set, f"Converted {completed} files")
+                    root.after(0, root.update_idletasks)
+            if not stop_conversion:
+                root.after(0, progress.set, 100)
+                show_completion_message(completed)
+        except Exception as e:
+            if not stop_conversion:
+                root.after(0, status_var.set, f"Error: {e}")
+
+    def show_completion_message(completed):
+        message = f"Conversion complete. {completed} files converted."
+        if error_messages:
+            message += f" {len(error_messages)} errors occurred."
+        messagebox.showinfo("Conversion Complete", message)
+
+    def convert_files():
+        global stop_conversion, error_messages
+        stop_conversion = False
+        error_messages.clear()
+        errors_var.set("Errors: 0")
+        save_directory = save_dir_var.get()
+        output_format = format_var.get()
+        try:
+            num_threads = int(thread_count_var.get() or 4)
+        except ValueError:
+            messagebox.showerror("Input Error", "Threads must be a number.")
+            return
+        output_filename = filename_var.get()
+        filter_duplicates = filter_var.get()
+        if not selected_files or not save_directory or not output_format:
+            status_var.set("Please select images, output format, and save location.")
+            return
+
+        threading.Thread(target=worker, args=(save_directory, output_format, num_threads, output_filename, q, filter_duplicates)).start()
+        threading.Thread(target=update_progress).start()
+
+    def stop_conversion_func():
+        global stop_conversion
+        stop_conversion = True
+        status_var.set("Conversion stopped.")
+
+    def return_to_menu():
+        stop_conversion_func()
+        root.destroy()
+        import main
+        main.open_main_menu()
+
+    def on_closing():
+        return_to_menu()
+
+    def show_errors():
+        global error_window
+        if error_window is not None:
+            return
+
+        error_window = tk.Toplevel(root)
+        error_window.title("Error Details")
+        error_window.geometry("500x400")
+
+        error_text = tk.Text(error_window, wrap='word')
+        error_text.pack(expand=True, fill='both')
+
+        if error_messages:
+            for error in error_messages:
+                error_text.insert('end', error + '\n')
+        else:
+            error_text.insert('end', "No errors recorded.")
+
+        error_text.config(state='disabled')
+
+        def on_close_error_window():
+            global error_window
+            error_window.destroy()
+            error_window = None
+
+        error_window.protocol("WM_DELETE_WINDOW", on_close_error_window)
+
+    def update_image_preview():
+        for widget in image_preview_frame.winfo_children():
+            widget.destroy()
+
+        for i, file_path in enumerate(selected_files):
+            thumbnail_size = (100, 100)
+            try:
+                image = PILImage.open(file_path)
+                image.thumbnail(thumbnail_size)
+                thumbnail = ImageTk.PhotoImage(image)
+
+                tk.Label(image_preview_frame, image=thumbnail).grid(row=i, column=0, padx=5, pady=5)
+                tk.Label(image_preview_frame, text=os.path.basename(file_path)).grid(row=i, column=1, padx=5, pady=5)
+                tk.Label(image_preview_frame, text="Caption placeholder", wraplength=300).grid(row=i, column=2, padx=5, pady=5)
+            except Exception as e:
+                tk.Label(image_preview_frame, text="Error loading image").grid(row=i, column=0, columnspan=3, padx=5, pady=5)
+
+    def validate_number(P):
+        if P.isdigit() or P == "":
+            return True
+        else:
+            messagebox.showerror("Input Error", "Please enter only numbers.")
+            return False
+
+    validate_command = root.register(validate_number)
+
+    # Tạo các thành phần giao diện
+    main_frame = tk.Frame(root)
+    main_frame.pack(fill=tk.BOTH, expand=True)
+
+    control_frame = tk.Frame(main_frame)
+    control_frame.pack(fill=tk.X, padx=10, pady=10)
+
+    back_button = tk.Button(control_frame, text="<-", font=('Helvetica', 14), command=return_to_menu)
+    back_button.pack(side=tk.TOP, anchor='w', padx=5, pady=5)
+
+    title_label = tk.Label(control_frame, text="Image Converter", font=('Helvetica', 16))
+    title_label.pack(side=tk.TOP, padx=5, pady=5)
+
+    select_button = tk.Button(control_frame, text="Select Files", command=select_files)
+    select_button.pack(side=tk.TOP, padx=5, pady=5)
+
+    num_files_label = tk.Label(control_frame, textvariable=num_files_var)
+    num_files_label.pack(side=tk.TOP, padx=5, pady=5)
+
+    save_dir_button = tk.Button(control_frame, text="Choose Save Directory", command=choose_save_directory)
+    save_dir_button.pack(side=tk.TOP, padx=5, pady=5)
+
+    save_dir_entry = tk.Entry(control_frame, textvariable=save_dir_var, state='readonly', justify='center')
+    save_dir_entry.pack(side=tk.TOP, padx=5, pady=5, fill=tk.X)
+
+    format_frame = tk.Frame(main_frame)
+    format_frame.pack(fill=tk.X, padx=10, pady=5)
+
+    format_label = tk.Label(format_frame, text="Output Format:")
+    format_label.pack(side=tk.LEFT, padx=5)
+
+    format_dropdown = ttk.Combobox(format_frame, textvariable=format_var, values=['png', 'jpg', 'gif', 'bmp', 'tiff', 'svg', 'webp', 'pdf', 'psd', 'ps', 'eps', 'ico'])
+    format_dropdown.pack(side=tk.LEFT, padx=5)
+
+    thread_count_label = tk.Label(format_frame, text="Threads:")
+    thread_count_label.pack(side=tk.LEFT, padx=5)
+
+    thread_count_entry = tk.Entry(format_frame, textvariable=thread_count_var, width=5, validate="key", validatecommand=(validate_command, '%P'), justify='center')
+    thread_count_entry.pack(side=tk.LEFT, padx=5)
+
+    filename_label = tk.Label(main_frame, text="Output Filename (optional):")
+    filename_label.pack(fill=tk.X, padx=10, pady=5)
+
+    filename_entry = tk.Entry(main_frame, textvariable=filename_var, justify='center')
+    filename_entry.pack(fill=tk.X, padx=10, pady=5)
+
+    filter_frame = tk.Frame(main_frame)
+    filter_frame.pack(fill=tk.X, padx=10, pady=5)
+
+    filter_checkbox = tk.Checkbutton(filter_frame, text="Filter duplicate images", variable=filter_var)
+    filter_checkbox.pack(side=tk.LEFT)
+
+    convert_button = tk.Button(main_frame, text="Convert", command=convert_files)
+    convert_button.pack(pady=10)
+
+    stop_button = tk.Button(main_frame, text="Stop", command=stop_conversion_func)
+    stop_button.pack(pady=5)
+
+    errors_button = tk.Button(main_frame, textvariable=errors_var, command=show_errors)
+    errors_button.pack(pady=5)
+
+    progress_bar = ttk.Progressbar(main_frame, variable=progress, maximum=100)
+    progress_bar.pack(pady=5, fill=tk.X)
+
+    status_label = tk.Label(main_frame, textvariable=status_var, fg="green")
+    status_label.pack(pady=5)
+
+    # Khung hiển thị ảnh và caption
+    image_preview_frame = tk.Frame(root)
+    image_preview_frame.pack(side=tk.BOTTOM, fill=tk.BOTH, expand=True)
+
+    center_window(root)
+    root.protocol("WM_DELETE_WINDOW", on_closing)
+    root.mainloop()
+
+if __name__ == "__main__":
+    open_image_converter()

image_error_fix.py

@@ -0,0 +1,348 @@
+import tkinter as tk
+from tkinter import filedialog, ttk, messagebox
+import os
+import threading, queue
+from PIL import Image, UnidentifiedImageError
+
+# Global variables for managing state and errors
+stop_processing = False
+error_messages = []
+selected_files = []
+error_list = []
+
+def open_image_error_fix():
+    global stop_processing, error_messages, selected_files, status_var, num_files_var, errors_var, progress, q, error_list, error_window, thread_count_var
+
+    # Initialize the main Tkinter window
+    root = tk.Tk()
+    root.title("Image Error Fix")
+
+    # Initialize Tkinter variables
+    status_var = tk.StringVar()
+    num_files_var = tk.StringVar()
+    errors_var = tk.StringVar(value="Errors: 0")
+    progress = tk.IntVar()
+    thread_count_var = tk.StringVar(value="4")  # Default thread count
+    q = queue.Queue()
+
+    def center_window(window):
+        window.update_idletasks()
+        width = window.winfo_width() + 120
+        height = window.winfo_height()
+        x = (window.winfo_screenwidth() // 2) - (width // 2)
+        y = (window.winfo_screenheight() // 2) - (height // 2)
+        window.geometry(f'{width}x{height}+{x}+{y}')
+
+    def validate_number(P):
+        return P.isdigit() or P == ""
+
+    def validate_thread_count(var):
+        value = var.get()
+        if value != "":
+            try:
+                int_value = int(value)
+                if int_value <= 0:
+                    raise ValueError
+            except ValueError:
+                messagebox.showerror("Invalid Input", "Please enter a valid number of threads.")
+                var.set("")
+
+    def select_files():
+        global selected_files
+        filetypes = [
+            ("All Image files", "*.jpg;*.jpeg;*.png;*.gif;*.bmp;*.tiff;*.tif;*.svg;*.webp"),
+            ("JPEG files", "*.jpg;*.jpeg"),
+            ("PNG files", "*.png"),
+            ("GIF files", "*.gif"),
+            ("BMP files", "*.bmp"),
+            ("TIFF files", "*.tiff;*.tif"),
+            ("SVG files", "*.svg"),
+            ("WEBP files", "*.webp")
+        ]
+        filepaths = filedialog.askopenfilenames(title="Select Image Files", filetypes=filetypes)
+        if filepaths:
+            selected_files.clear()
+            selected_files.extend(filepaths)
+            num_files_var.set(f"{len(selected_files)} files selected.")
+
+    def detect_errors(file_path):
+        """Detect potential errors in an image file."""
+        errors = []
+        if not os.access(file_path, os.R_OK):
+            errors.append("Permission Denied")
+        # Additional error checks
+        try:
+            with Image.open(file_path) as img:
+                img.verify()  # Verify the image integrity
+                img = Image.open(file_path)
+                img.load()  # Load the image data to ensure it's not truncated
+        except UnidentifiedImageError:
+            errors.append("Unidentified image format or corrupted file")
+        except IOError as e:
+            errors.append(f"IOError: {str(e)}")
+        except Exception as e:
+            errors.append(f"Unknown error: {str(e)}")
+        return errors
+
+    def fix_error(file_path, error_type):
+        """Fix errors in an image file, if possible."""
+        if error_type == "Permission Denied":
+            # Attempt to change permissions
+            try:
+                os.chmod(file_path, 0o644)
+                return "Permissions fixed. File permissions were successfully updated."
+            except Exception as e:
+                return f"Failed to fix permissions. Ensure you have the necessary permissions to modify this file. Error: {str(e)}"
+        elif error_type == "Unidentified image format or corrupted file":
+            return "The file format is unrecognized or the file is corrupted. Please try to re-download or restore from a backup."
+        elif error_type == "Invalid Format":
+            return ("Cannot automatically fix invalid formats. Ensure the file extension matches the file content.\n"
+                    "To fix this issue, please follow these steps:\n"
+                    "1. Identify the correct file format by using a file type checker tool (e.g., CheckFileType.com).\n"
+                    "2. Rename the file with the correct extension:\n"
+                    "   - Right-click on the file and select 'Rename'.\n"
+                    "   - Change the file extension to the correct format (e.g., .jpg, .png).\n"
+                    "   - Press Enter to save the changes.\n"
+                    "3. Try opening the file again. If the problem persists, the file may be corrupted or contain unsupported data.")
+        elif error_type == "File Not Found":
+            return ("The file could not be found at the specified path. Please ensure that the file has not been moved or deleted.\n"
+                    "1. Verify the file path is correct.\n"
+                    "2. If the file has been moved, update the path in the application or locate the file manually.\n"
+                    "3. If the file was deleted, check your Recycle Bin or use a data recovery tool to attempt to restore it.")
+        elif error_type == "File Path Too Long":
+            return ("The file path exceeds the system limit. Windows has a maximum path length of 260 characters.\n"
+                    "To fix this issue:\n"
+                    "1. Move the file to a location with a shorter path, closer to the root directory (e.g., C:\\).\n"
+                    "2. Rename folders in the path to shorter names.\n"
+                    "3. Enable long path support in Windows if using Windows 10 (version 1607 hoặc cao hơn):\n"
+                    "   - Open the Group Policy Editor (gpedit.msc).\n"
+                    "   - Navigate to 'Local Computer Policy > Computer Configuration > Administrative Templates > System > Filesystem'.\n"
+                    "   - Enable the 'Enable Win32 long paths' option.")
+        elif error_type == "Transmission Errors":
+            return ("The file may be incomplete or corrupted due to transmission errors. This can happen if the file was downloaded or transferred incorrectly.\n"
+                    "To fix this issue:\n"
+                    "1. Re-download hoặc re-transfer the file.\n"
+                    "2. Use a reliable network connection to ensure the file is not corrupted during transfer.\n"
+                    "3. Verify the integrity of the file by comparing checksums (if available).")
+        elif error_type == "Unsupported Format":
+            return ("The file format is not supported by this application. Supported formats include JPEG, PNG, GIF, BMP, TIFF, SVG, và WEBP.\n"
+                    "To fix this issue:\n"
+                    "1. Convert the file to a supported format using an image converter tool.\n"
+                    "2. Ensure that the file is not corrupted and can be opened with other image viewers or editors.")
+        else:
+            return "No action taken. This error type is not recognized or cannot be fixed automatically."
+
+    def delete_file(file_path):
+        """Delete the specified file."""
+        try:
+            os.remove(file_path)
+            # Remove from selected files
+            selected_files.remove(file_path)
+            num_files_var.set(f"{len(selected_files)} files selected.")
+            return f"File {file_path} deleted successfully."
+        except Exception as e:
+            return f"Failed to delete file {file_path}. Error: {str(e)}"
+
+    def process_image(file_path, q):
+        if stop_processing:
+            return
+
+        errors = detect_errors(file_path)
+        if errors:
+            q.put((file_path, errors))
+
+    def worker():
+        try:
+            progress.set(0)
+            total_files = len(selected_files)
+            thread_count = int(thread_count_var.get())  # Get the number of threads
+            for i, input_path in enumerate(selected_files, 1):
+                if stop_processing:
+                    break
+
+                thread = threading.Thread(target=process_image, args=(input_path, q))
+                thread.start()
+                thread.join()
+
+                # Update progress bar
+                progress.set(int(i / total_files * 100))
+            
+            q.put(None)
+        except Exception as e:
+            if not stop_processing:
+                q.put(e)
+
+    def update_progress():
+        try:
+            global error_list
+            error_list = []
+            while True:
+                item = q.get()
+                if item is None:
+                    break
+                if isinstance(item, tuple):
+                    error_list.append(item)
+
+            if not error_list:
+                messagebox.showinfo("No Errors Found", "No errors were detected in the selected images.")
+            else:
+                errors_var.set(f"Errors: {len(error_list)}")
+                display_errors(error_list)
+        except Exception as e:
+            if not stop_processing:
+                root.after(0, status_var.set, f"Error: {e}")
+
+    def update_error_display():
+        """Update the display of errors in the error window."""
+        global error_list, frame
+        # Clear all existing widgets in the frame
+        for widget in frame.winfo_children():
+            widget.destroy()
+
+        # Repopulate the frame with updated error list
+        for file_path, errors in error_list:
+            for error in errors:
+                frame_row = tk.Frame(frame)
+                frame_row.pack(fill="x", pady=2)
+
+                # Hiển thị đường dẫn đầy đủ và tự động xuống dòng
+                file_label = tk.Label(frame_row, text=f"{file_path}: {error}", anchor="w", wraplength=500, justify='left')
+                file_label.pack(side=tk.LEFT, fill="x", expand=True)
+
+                delete_button = tk.Button(frame_row, text="Delete", command=lambda fp=file_path: delete_file_action(fp))
+                delete_button.pack(side=tk.RIGHT)
+
+                fix_button = tk.Button(frame_row, text="Fix", command=lambda fp=file_path, et=error: fix_error_action(fp, et))
+                fix_button.pack(side=tk.RIGHT)
+
+                # Thêm dấu phân cách giữa các lỗi
+                separator = ttk.Separator(frame, orient='horizontal')
+                separator.pack(fill='x', pady=5)
+
+        frame.update_idletasks()
+        canvas.configure(scrollregion=canvas.bbox("all"))
+
+    def display_errors(error_list):
+        global error_window, canvas, frame
+        # Create or raise the error window
+        if 'error_window' in globals() and error_window.winfo_exists():
+            error_window.lift()
+        else:
+            error_window = tk.Toplevel(root)
+            error_window.title("Error Details")
+            error_window.geometry("600x400")
+
+            canvas = tk.Canvas(error_window)
+            canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+
+            scrollbar = tk.Scrollbar(error_window, command=canvas.yview)
+            scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
+
+            canvas.configure(yscrollcommand=scrollbar.set)
+
+            frame = tk.Frame(canvas)
+            canvas.create_window((0, 0), window=frame, anchor="nw")
+
+            update_error_display()
+
+    def fix_error_action(file_path, error_type):
+        fix_message = fix_error(file_path, error_type)
+        messagebox.showinfo("Fix Error", fix_message)
+
+    def delete_file_action(file_path):
+        global error_list
+        delete_message = delete_file(file_path)
+        messagebox.showinfo("Delete File", delete_message)
+        # Remove the error from the error_list and refresh the display
+        error_list = [(fp, errs) for fp, errs in error_list if fp != file_path]
+        errors_var.set(f"Errors: {len(error_list)}")
+        update_error_display()
+
+    def delete_all_errors():
+        global error_list
+        for file_path, _ in error_list:
+            delete_file(file_path)
+        error_list.clear()
+        errors_var.set("Errors: 0")
+        messagebox.showinfo("Delete All Files", "All files with errors have been deleted.")
+        update_error_display()  # Update the error display after deleting all errors
+
+    def scan_and_fix():
+        global stop_processing, error_messages
+        stop_processing = False
+        error_messages.clear()
+        errors_var.set("Errors: 0")
+        if not selected_files:
+            status_var.set("Please select images to scan.")
+            return
+
+        threading.Thread(target=worker).start()
+        threading.Thread(target=update_progress).start()
+
+    def stop_processing_func():
+        global stop_processing
+        stop_processing = True
+        status_var.set("Processing stopped.")
+
+    def return_to_menu():
+        stop_processing_func()
+        root.destroy()
+        import main
+        main.open_main_menu()
+
+    def on_closing():
+        return_to_menu()
+
+    # Create GUI elements
+    validate_command = root.register(validate_number)
+
+    back_button = tk.Button(root, text="<-", font=('Helvetica', 14), command=return_to_menu)
+    back_button.pack(anchor='nw', padx=10, pady=10)
+
+    title_label = tk.Label(root, text="Image Error Fix", font=('Helvetica', 16))
+    title_label.pack(pady=10)
+
+    select_files_button = tk.Button(root, text="Select Files", command=select_files)
+    select_files_button.pack(pady=5)
+
+    num_files_label = tk.Label(root, textvariable=num_files_var)
+    num_files_label.pack(pady=5)
+
+    thread_count_label = tk.Label(root, text="Number of Threads:")
+    thread_count_label.pack(pady=5)
+
+    thread_count_var = tk.StringVar(value="4")
+    thread_count_entry = tk.Entry(root, textvariable=thread_count_var, width=3, justify='center', validate="key", validatecommand=(validate_command, '%P'))
+    thread_count_entry.pack(pady=5)
+
+    # Separator for aesthetics
+    separator = ttk.Separator(root, orient='horizontal')
+    separator.pack(fill='x', pady=10)
+
+    scan_fix_button = tk.Button(root, text="Scan and Fix", command=scan_and_fix)
+    scan_fix_button.pack(pady=10)
+
+    stop_button = tk.Button(root, text="Stop", command=stop_processing_func)
+    stop_button.pack(pady=5)
+
+    progress_bar = ttk.Progressbar(root, variable=progress, maximum=100)
+    progress_bar.pack(pady=5, fill=tk.X)
+
+    delete_all_label = tk.Label(root, text="Click 'Delete All' to remove all files with errors.")
+    delete_all_label.pack(pady=5)
+
+    delete_all_button = tk.Button(root, text="Delete All", command=delete_all_errors)
+    delete_all_button.pack(pady=5)
+
+    errors_label = tk.Label(root, textvariable=errors_var, fg="red")
+    errors_label.pack(pady=5)
+
+    status_label = tk.Label(root, textvariable=status_var, fg="green")
+    status_label.pack(pady=5)
+
+    center_window(root)
+    root.protocol("WM_DELETE_WINDOW", on_closing)
+    root.mainloop()
+
+if __name__ == "__main__":
+    open_image_error_fix()

image_filter.py

@@ -0,0 +1,515 @@
+import tkinter as tk
+from tkinter import filedialog, messagebox, ttk
+import os
+import threading
+import queue
+import hashlib
+import shutil
+from PIL import Image
+
+# Global variables for controlling filtering and error handling
+stop_event = threading.Event()
+error_messages = []
+error_window = None
+filtered_hashes = set()
+selected_files = []
+worker_thread = None
+
+def open_image_filter():
+    global error_messages, error_window, filtered_hashes, selected_files
+    global save_dir_var, status_var, num_files_var, errors_var, thread_count_var, progress
+    global q, format_filter_var, filter_duplicate_var, min_size_var, max_size_var
+    global min_total_resolution_var, max_total_resolution_var, format_mode_var, format_filter_label
+    global delete_originals_var, worker_thread, root, stop_button, saved_files
+
+    # Create the Tkinter window
+    root = tk.Tk()
+    root.title("Image Filter")
+
+    # Initialize Tkinter variables
+    save_dir_var = tk.StringVar()
+    status_var = tk.StringVar()
+    num_files_var = tk.StringVar()
+    errors_var = tk.StringVar(value="Errors: 0")
+    thread_count_var = tk.StringVar(value="4")
+    progress = tk.IntVar()
+    q = queue.Queue()
+    format_filter_var = tk.StringVar()
+    filter_duplicate_var = tk.BooleanVar()
+    min_size_var = tk.IntVar()
+    max_size_var = tk.IntVar()
+    min_total_resolution_var = tk.IntVar()
+    max_total_resolution_var = tk.IntVar()
+    format_mode_var = tk.StringVar(value="exclude")  # 'include' or 'exclude'
+
+    # Initialize variable for deleting original images
+    delete_originals_var = tk.BooleanVar()
+
+    def center_window(window):
+        window.update_idletasks()
+        width = window.winfo_width() + 120  # Add 120 pixels to width
+        height = window.winfo_height()
+        x = (window.winfo_screenwidth() // 2) - (width // 2)
+        y = (window.winfo_screenheight() // 2) - (height // 2)
+        window.geometry(f'{width}x{height}+{x}+{y}')
+
+    def select_directory():
+        filepaths = filedialog.askopenfilenames(
+            title="Select Images",
+            filetypes=[("All Image files", "*.jpg;*.jpeg;*.png;*.gif;*.bmp;*.tiff")]
+        )
+        if filepaths:
+            selected_files.clear()
+            selected_files.extend(filepaths)
+            update_selected_files_label()
+
+    def choose_directory():
+        directory = filedialog.askdirectory()
+        if directory:
+            save_dir_var.set(directory)
+            save_dir_entry.config(state='normal')
+            save_dir_entry.delete(0, tk.END)
+            save_dir_entry.insert(0, directory)
+            save_dir_entry.config(state='readonly')
+
+    def hash_image(file_path):
+        """Create SHA-256 hash of image content."""
+        hash_sha256 = hashlib.sha256()
+        try:
+            with open(file_path, "rb") as f:
+                for chunk in iter(lambda: f.read(4096), b""):
+                    hash_sha256.update(chunk)
+        except Exception as e:
+            error_messages.append(f"Error hashing file {file_path}: {e}")
+            update_error_count()
+            return None
+        return hash_sha256.hexdigest()
+
+    def filter_duplicate_images(filepaths):
+        unique_images = {}
+        filtered_files = []
+        for filepath in filepaths:
+            image_hash = hash_image(filepath)
+            if image_hash and image_hash not in filtered_hashes:
+                unique_images[image_hash] = filepath
+                filtered_hashes.add(image_hash)
+            else:
+                filtered_files.append(filepath)  # Duplicate images will be added to the list
+        return filtered_files
+
+    def parse_formats(format_string):
+        return [fmt.strip().lower() for fmt in format_string.split(',') if fmt.strip()]
+
+    def filter_image_formats(filepaths, include_formats):
+        filtered_files = []
+        formats = parse_formats(format_filter_var.get())
+        if not formats:
+            return filepaths  # No filtering if the format list is empty
+
+        for filepath in filepaths:
+            ext = os.path.splitext(filepath)[1][1:].lower()  # Get the file extension
+            if (ext in formats) == include_formats:
+                filtered_files.append(filepath)
+        return filtered_files
+
+    def filter_image_size(filepaths, min_size, max_size):
+        filtered_files = []
+        for filepath in filepaths:
+            size = os.path.getsize(filepath)
+            if (min_size <= 0 or size >= min_size) and (max_size <= 0 or size <= max_size):
+                filtered_files.append(filepath)
+        return filtered_files
+
+    def filter_image_resolution(filepaths, min_total_resolution, max_total_resolution):
+        filtered_files = []
+        for filepath in filepaths:
+            try:
+                image = Image.open(filepath)
+                width, height = image.size
+                total_resolution = width + height
+                if (min_total_resolution <= 0 or total_resolution >= min_total_resolution) and \
+                   (max_total_resolution <= 0 or total_resolution <= max_total_resolution):
+                    filtered_files.append(filepath)
+            except Exception as e:
+                error_messages.append(f"Error reading image {filepath}: {e}")
+                update_error_count()
+                continue
+        return filtered_files
+
+    def save_file_with_unique_name(filepath, save_directory, saved_files):
+        """Save file with a unique name to avoid overwriting."""
+        if filepath in saved_files:
+            return  # File already saved, do not save again
+    
+        base_name, ext = os.path.splitext(os.path.basename(filepath))
+        save_path = os.path.join(save_directory, f"{base_name}{ext}")
+        counter = 1
+        while os.path.exists(save_path):
+            save_path = os.path.join(save_directory, f"{base_name} ({counter}){ext}")
+            counter += 1
+        try:
+            shutil.copy(filepath, save_path)
+            saved_files.add(filepath)  # Mark this file as saved
+        except Exception as e:
+            error_messages.append(f"Error saving file {filepath}: {e}")
+            update_error_count()
+
+    def delete_original_images():
+        """Delete the original images if delete_originals_var is set."""
+        if delete_originals_var.get():
+            # Iterate through a copy of selected_files to avoid modifying the list during iteration
+            for filepath in selected_files[:]:
+                try:
+                    os.remove(filepath)
+                    selected_files.remove(filepath)  # Remove from selected_files if deleted
+                except FileNotFoundError:
+                    error_messages.append(f"File not found for deletion: {filepath}")
+                    update_error_count()
+                except Exception as e:
+                    error_messages.append(f"Error deleting file {filepath}: {e}")
+                    update_error_count()
+            update_selected_files_label()
+
+    def update_selected_files_label():
+        """Update the label showing the number of selected files."""
+        num_files_var.set(f"{len(selected_files)} files selected.")
+
+    def update_error_count():
+        """Update the error count displayed in the Errors button."""
+        errors_var.set(f"Errors: {len(error_messages)}")
+
+    def check_all_files_filtered(filtered_files, filter_type):
+        """Check if all files have been filtered out and display a specific error message."""
+        if not filtered_files:
+            error_message = f"All images would be filtered out by the selected {filter_type} filter. Please adjust the filter settings."
+            messagebox.showerror("Filtering Error", error_message)
+            return True
+        return False
+
+    def filter_images_preview(filepaths):
+        """
+        Preview the number of images left after applying the filters.
+        Return the count of images left after filtering.
+        """
+        filtered_files = filepaths[:]
+
+        # Preview filtering by image format
+        include_formats = format_mode_var.get() == "include"
+        filtered_files = filter_image_formats(filtered_files, include_formats)
+
+        # Preview filtering by image size
+        filtered_files = filter_image_size(filtered_files, min_size_var.get(), max_size_var.get())
+
+        # Preview filtering by total resolution
+        filtered_files = filter_image_resolution(filtered_files, min_total_resolution_var.get(), max_total_resolution_var.get())
+
+        # Preview filtering duplicates if selected
+        if filter_duplicate_var.get():
+            filtered_files = filter_duplicate_images(filtered_files)
+
+        return len(filtered_files)
+
+    def filter_images(save_directory):
+        global saved_files
+        saved_files = set()  # Initialize saved_files set
+        num_initial_files = 0  # Initialize before try-except block
+        try:
+            num_initial_files = len(selected_files)
+            filtered_files = selected_files[:]
+
+            # Filter by image format
+            include_formats = format_mode_var.get() == "include"
+            filtered_files = filter_image_formats(filtered_files, include_formats)
+            if check_all_files_filtered(filtered_files, "format"):
+                return [], num_initial_files, 0, 0
+
+            # Filter by image size
+            filtered_files = filter_image_size(filtered_files, min_size_var.get(), max_size_var.get())
+            if check_all_files_filtered(filtered_files, "size"):
+                return [], num_initial_files, 0, 0
+
+            # Filter by total resolution
+            filtered_files = filter_image_resolution(filtered_files, min_total_resolution_var.get(), max_total_resolution_var.get())
+            if check_all_files_filtered(filtered_files, "resolution"):
+                return [], num_initial_files, 0, 0
+
+            # Filter duplicates if selected
+            if filter_duplicate_var.get():
+                filtered_files = filter_duplicate_images(filtered_files)
+                if check_all_files_filtered(filtered_files, "duplicate"):
+                    return [], num_initial_files, 0, 0
+
+            # Calculate the number of filtered out images
+            num_filtered_files = len(filtered_files)
+            num_filtered_out_files = num_initial_files - num_filtered_files
+
+            if not os.path.exists(save_directory):
+                os.makedirs(save_directory)
+            for file in filtered_files:
+                save_file_with_unique_name(file, save_directory, saved_files)
+
+            return filtered_files, num_initial_files, num_filtered_files, num_filtered_out_files
+
+        except Exception as e:
+            error_messages.append(str(e))
+            update_error_count()
+            return [], num_initial_files, 0, 0
+
+    def worker(save_directory, num_threads, q):
+        try:
+            filtered_files, num_initial_files, num_filtered_files, num_filtered_out_files = filter_images(save_directory)
+            if not filtered_files:  # Check again if any files left after filtering
+                return  # Stop if no files left
+            for i, file in enumerate(filtered_files):
+                if stop_event.is_set():
+                    break
+                save_file_with_unique_name(file, save_directory, saved_files)
+                progress.set(int((i + 1) / num_initial_files * 100))
+                q.put((filtered_files, num_initial_files, num_filtered_files, num_filtered_out_files))
+            q.put(None)
+        except Exception as e:
+            if not stop_event.is_set():
+                error_messages.append(str(e))
+                update_error_count()
+                q.put(str(e))
+        finally:
+            stop_event.clear()  # Clear the stop event for the next run
+
+    def update_progress():
+        try:
+            completed = 0
+            while True:
+                item = q.get()
+                if item is None:
+                    break
+                if isinstance(item, tuple):
+                    filtered_files, num_initial_files, num_filtered_files, num_filtered_out_files = item
+                    completed += 1
+                    progress.set(int((completed / num_initial_files) * 100))
+                    root.after(0, root.update_idletasks)
+                elif isinstance(item, str):
+                    if "Error" in item:
+                        error_messages.append(item)
+                        root.after(0, update_error_count)
+                        continue
+            if not stop_event.is_set():
+                root.after(0, progress.set(100))
+                show_completion_message(num_initial_files, num_filtered_files, num_filtered_out_files)
+                delete_original_images()  # Delete original images after completion
+            # Re-enable all buttons after completion
+            root.after(0, lambda: filter_button.config(state='normal'))
+            root.after(0, lambda: select_directory_button.config(state='normal'))
+            root.after(0, lambda: choose_dir_button.config(state='normal'))
+            root.after(0, lambda: delete_originals_checkbox.config(state='normal'))
+        except Exception as e:
+            if not stop_event.is_set():
+                error_messages.append(str(e))
+                root.after(0, update_error_count)
+                root.after(0, status_var.set, f"Error: {e}")
+
+    def show_completion_message(num_initial_files, num_filtered_files, num_filtered_out_files):
+        message = (
+            f"Filtering complete.\n"
+            f"Total files selected: {num_initial_files}\n"
+            f"Files processed and saved: {num_filtered_files}\n"
+            f"Files filtered out: {num_filtered_out_files}\n"
+            f"{len(error_messages)} errors occurred."
+        )
+        messagebox.showinfo("Filtering Complete", message)
+
+    def filter_files():
+        global error_messages, error_window, worker_thread
+        stop_event.clear()  # Clear the stop event before starting a new task
+        error_messages.clear()
+        update_error_count()
+        save_directory = save_dir_var.get()
+        try:
+            num_threads = int(thread_count_var.get() or 4)
+            if num_threads <= 0:
+                raise ValueError("Number of threads must be greater than 0.")
+        except ValueError as e:
+            messagebox.showerror("Input Error", f"Invalid number of threads: {e}")
+            return
+
+        if not selected_files or not save_directory:
+            status_var.set("Please select images and save location.")
+            return
+
+        # Preview filtered results
+        remaining_images = filter_images_preview(selected_files)
+        if remaining_images == 0:
+            messagebox.showerror("Filtering Error", "No images will remain after applying the filters. Please adjust the filter settings.")
+            return
+
+        # Disable all buttons except Stop button
+        filter_button.config(state='disabled')
+        select_directory_button.config(state='disabled')
+        choose_dir_button.config(state='disabled')
+        delete_originals_checkbox.config(state='disabled')
+
+        worker_thread = threading.Thread(target=worker, args=(save_directory, num_threads, q))
+        worker_thread.start()
+        threading.Thread(target=update_progress).start()
+
+    def stop_filtering_func():
+        stop_event.set()  # Signal the worker thread to stop
+        status_var.set("Filtering stopped.")
+        # Do not disable the Stop button to keep it always enabled
+        # Re-enable all buttons
+        filter_button.config(state='normal')
+        select_directory_button.config(state='normal')
+        choose_dir_button.config(state='normal')
+        delete_originals_checkbox.config(state='normal')
+        if worker_thread is not None:
+            worker_thread.join()  # Wait for worker thread to finish
+
+    def return_to_menu():
+        stop_filtering_func()
+        root.destroy()
+        # Import main menu and open it
+        from main import open_main_menu
+        open_main_menu()
+
+    def on_closing():
+        stop_filtering_func()
+        return_to_menu()
+
+    def show_errors():
+        global error_window
+        if error_window is not None:
+            return
+
+        error_window = tk.Toplevel(root)
+        error_window.title("Error Details")
+        error_window.geometry("500x400")
+
+        error_text = tk.Text(error_window, wrap='word')
+        error_text.pack(expand=True, fill='both')
+
+        if error_messages:
+            for error in error_messages:
+                error_text.insert('end', error + '\n')
+        else:
+            error_text.insert('end', "No errors recorded.")
+
+        error_text.config(state='disabled')
+
+        def on_close_error_window():
+            global error_window
+            error_window.destroy()
+            error_window = None
+
+        error_window.protocol("WM_DELETE_WINDOW", on_close_error_window)
+
+    def toggle_format_mode():
+        if format_mode_var.get() == "include":
+            format_filter_label.config(text="Include Image Formats (comma-separated, e.g., png,jpg):")
+        else:
+            format_filter_label.config(text="Exclude Image Formats (comma-separated, e.g., png,jpg):")
+
+    def validate_number(P):
+        if P.isdigit() or P == "":
+            return True
+        else:
+            messagebox.showerror("Input Error", "Please enter only numbers.")
+            return False
+
+    validate_command = root.register(validate_number)
+
+    # Create UI elements
+    back_button = tk.Button(root, text="<-", font=('Helvetica', 14), command=return_to_menu)
+    back_button.pack(anchor='nw', padx=10, pady=10)
+
+    title_label = tk.Label(root, text="Image Filter", font=('Helvetica', 16))
+    title_label.pack(pady=10)
+
+    select_directory_button = tk.Button(root, text="Select Images", command=select_directory)
+    select_directory_button.pack(pady=5)
+
+    num_files_label = tk.Label(root, textvariable=num_files_var)
+    num_files_label.pack(pady=5)
+
+    choose_dir_button = tk.Button(root, text="Choose Save Directory", command=choose_directory)
+    choose_dir_button.pack(pady=5)
+
+    save_dir_entry = tk.Entry(root, textvariable=save_dir_var, state='readonly', justify='center')
+    save_dir_entry.pack(pady=5, fill=tk.X)
+
+    # Checkbox to delete original images
+    delete_originals_checkbox = tk.Checkbutton(root, text="Delete Original Images After Filtering", variable=delete_originals_var)
+    delete_originals_checkbox.pack(pady=5)
+
+    # Toggle image format filter mode
+    format_mode_frame = tk.Frame(root)
+    format_mode_frame.pack(pady=5)
+    format_mode_label = tk.Label(format_mode_frame, text="Toggle Format Mode (Include/Exclude):")
+    format_mode_label.pack(side="left")
+
+    # Radio buttons
+    include_radio = tk.Radiobutton(format_mode_frame, text="Include Formats", variable=format_mode_var, value="include", command=toggle_format_mode)
+    include_radio.pack(side="left", padx=5)
+    exclude_radio = tk.Radiobutton(format_mode_frame, text="Exclude Formats", variable=format_mode_var, value="exclude", command=toggle_format_mode)
+    exclude_radio.pack(side="left")
+
+    # Description for image format filter mode
+    format_filter_label = tk.Label(root, text="Exclude Image Formats (comma-separated, e.g., png,jpg):")
+    format_filter_label.pack(pady=5)
+
+    format_filter_entry = tk.Entry(root, textvariable=format_filter_var, justify='center')
+    format_filter_entry.pack(pady=5, fill=tk.X)
+
+    min_size_label = tk.Label(root, text="Min Size (bytes):")
+    min_size_label.pack(pady=5)
+
+    min_size_entry = tk.Entry(root, textvariable=min_size_var, validate="key", validatecommand=(validate_command, '%P'), justify='center', width=8)
+    min_size_entry.pack(pady=5)
+
+    max_size_label = tk.Label(root, text="Max Size (bytes):")
+    max_size_label.pack(pady=5)
+
+    max_size_entry = tk.Entry(root, textvariable=max_size_var, validate="key", validatecommand=(validate_command, '%P'), justify='center', width=8)
+    max_size_entry.pack(pady=5)
+
+    min_resolution_label = tk.Label(root, text="Min Total Resolution (sum of width and height):")
+    min_resolution_label.pack(pady=5)
+
+    min_resolution_entry = tk.Entry(root, textvariable=min_total_resolution_var, validate="key", validatecommand=(validate_command, '%P'), justify='center', width=8)
+    min_resolution_entry.pack(pady=5)
+
+    max_resolution_label = tk.Label(root, text="Max Total Resolution (sum of width and height):")
+    max_resolution_label.pack(pady=5)
+
+    max_resolution_entry = tk.Entry(root, textvariable=max_total_resolution_var, validate="key", validatecommand=(validate_command, '%P'), justify='center', width=8)
+    max_resolution_entry.pack(pady=5)
+
+    # Add label and entry for thread count
+    thread_count_label = tk.Label(root, text="Number of Threads:")
+    thread_count_label.pack(pady=5)
+
+    thread_count_entry = tk.Entry(root, textvariable=thread_count_var, validate="key", validatecommand=(validate_command, '%P'), justify='center', width=4)
+    thread_count_entry.pack(pady=5)
+
+    filter_duplicate_checkbox = tk.Checkbutton(root, text="Filter Duplicate Images", variable=filter_duplicate_var)
+    filter_duplicate_checkbox.pack(pady=5)
+
+    filter_button = tk.Button(root, text="Filter", command=filter_files)
+    filter_button.pack(pady=10)
+
+    stop_button = tk.Button(root, text="Stop", command=stop_filtering_func)  # Ensure stop button is a global variable
+    stop_button.pack(pady=5)
+
+    errors_button = tk.Button(root, textvariable=errors_var, command=show_errors)
+    errors_button.pack(pady=5)
+
+    progress_bar = ttk.Progressbar(root, variable=progress, maximum=100)
+    progress_bar.pack(pady=5, fill=tk.X)
+
+    status_label = tk.Label(root, textvariable=status_var, fg="green")
+    status_label.pack(pady=5)
+
+    center_window(root)
+    root.protocol("WM_DELETE_WINDOW", on_closing)
+    root.mainloop()
+
+if __name__ == "__main__":
+    open_image_filter()

image_to_caption.py

@@ -0,0 +1,844 @@
+import tkinter as tk
+from tkinter import filedialog, messagebox, ttk
+from PIL import Image as PILImage, ImageTk
+import os
+import queue
+import threading
+import torch
+from transformers import AutoModelForCausalLM, LlamaTokenizer
+import json
+import traceback
+import math
+
+torch.set_grad_enabled(False)
+
+stop_processing = False
+error_messages = []
+selected_files = []
+save_directory = ""
+caption_window = None
+caption_frame = None
+thumbnails = []
+caption_text_widgets = []
+error_window = None
+status_var = None
+num_files_var = None
+errors_var = None
+progress = None
+prompt_var = None
+max_new_tokens_var = None
+do_sample_var = None
+temperature_var = None
+top_k_var = None
+top_p_var = None
+thread_count_var = None
+precision_var = None
+batch_size_var = None
+prepend_text_var = None
+append_text_var = None
+caption_handling_var = None  # Variable to handle radio buttons for caption handling
+start_button = None
+stop_button = None
+model = None
+prompt_entry = None
+select_files_button = None
+show_captions_button = None
+thread_count_entry = None
+precision_entry = None
+batch_size_entry = None
+prepend_text_entry = None
+append_text_entry = None
+root = None
+q = queue.Queue()
+
+current_page = 0
+images_per_page = 20
+total_pages = 1
+content_canvas = None
+search_var = None
+original_selected_files = []
+action_var = None
+action_entry = None
+
+def load_model():
+    global model, tokenizer
+    if model is None:
+        tokenizer = LlamaTokenizer.from_pretrained('lmsys/vicuna-7b-v1.5')
+        dtype = torch.float16 if precision_var.get() <= 1 else torch.float32
+        model = AutoModelForCausalLM.from_pretrained(
+            'THUDM/cogvlm-chat-hf',
+            torch_dtype=dtype,
+            low_cpu_mem_usage=True,
+            trust_remote_code=True,
+        ).to('cuda').eval()
+
+def update_and_save_config():
+    top_p_value = top_p_var.get() if do_sample_var.get() else None
+    config_entry = {
+        'prompt': prompt_var.get(),
+        'max_new_tokens': max_new_tokens_var.get(),
+        'temperature': temperature_var.get(),
+        'top_k': top_k_var.get(),
+        'top_p': float(top_p_value) if top_p_value is not None else None,
+        'precision': precision_var.get(),
+        'thread_count': thread_count_var.get(),
+        'batch_size': batch_size_var.get(),
+        'prepend_text': prepend_text_var.get(),
+        'append_text': append_text_var.get(),
+        'caption_handling': caption_handling_var.get()  # Save the selected caption handling option
+    }
+
+    try:
+        with open('captions.json', 'w') as f:
+            json.dump(config_entry, f, indent=2)
+    except Exception as e:
+        print(f"Error saving config to captions.json: {e}")
+
+def load_config_from_json():
+    global prompt_entry
+    try:
+        if os.path.exists('captions.json'):
+            with open('captions.json', 'r') as f:
+                config_entry = json.load(f)
+                prompt_var.set(config_entry.get('prompt', ''))
+                max_new_tokens_var.set(config_entry.get('max_new_tokens', 200))
+                temperature_var.set(config_entry.get('temperature', 1.0))
+                top_k_var.set(config_entry.get('top_k', 50))
+                top_p_value = config_entry.get('top_p', 0.95)
+                top_p_var.set(top_p_value if top_p_value is not None else 0.95)
+                precision_var.set(config_entry.get('precision', 1))
+                thread_count_var.set(config_entry.get('thread_count', 4))
+                batch_size_var.set(config_entry.get('batch_size', 1))
+                prepend_text_var.set(config_entry.get('prepend_text', ''))
+                append_text_var.set(config_entry.get('append_text', ''))
+                caption_handling_var.set(config_entry.get('caption_handling', 'skip'))  # Load the saved caption handling option
+
+                prompt_entry.delete("1.0", tk.END)
+                prompt_entry.insert(tk.END, config_entry.get('prompt', ''))
+    except Exception as e:
+        print(f"Error loading config from captions.json: {e}")
+
+def on_config_change(*args):
+    root.after(100, update_config)
+
+def update_config():
+    try:
+        precision_value = precision_var.get()
+        if precision_value == "":
+            return  # Không làm gì nếu giá trị là chuỗi rỗng
+
+        update_and_save_config()
+    except Exception as e:
+        print(f"Lỗi khi xử lý giá trị: {e}")
+
+def on_prompt_change(event=None):
+    prompt_var.set(prompt_entry.get("1.0", tk.END).strip())
+    update_and_save_config()
+
+def show_errors():
+    global error_window
+    if error_window is not None:
+        return
+
+    error_window = tk.Toplevel(root)
+    error_window.title("Error Details")
+    error_window.geometry("500x400")
+
+    error_text = tk.Text(error_window, wrap='word')
+    error_text.pack(expand=True, fill='both')
+
+    if error_messages:
+        for error in error_messages:
+            error_text.insert('end', error + '\n')
+    else:
+        error_text.insert('end', "No errors recorded.")
+
+    error_text.config(state='disabled')
+
+    def on_close_error_window():
+        global error_window
+        error_window.destroy()
+        error_window = None
+
+    error_window.protocol("WM_DELETE_WINDOW", on_close_error_window)
+
+def validate_numeric_input(value):
+    if value == "" or value == "-":
+        return True
+    try:
+        float(value)
+        return True
+    except ValueError:
+        return False
+
+def center_window(window):
+    window.update_idletasks()
+    width = window.winfo_width()
+    height = window.winfo_height()
+    x = (window.winfo_screenwidth() // 2) - (width // 2)
+    y = (window.winfo_screenheight() // 2) - (height // 2)
+    window.geometry(f'{width}x{height}+{x}+{y}')
+
+def toggle_sampling_options():
+    if do_sample_var.get():
+        temperature_label.pack(pady=5, after=do_sample_check)
+        temperature_entry.pack(pady=5, after=temperature_label)
+        top_k_label.pack(pady=5, after=temperature_entry)
+        top_k_entry.pack(pady=5, after=top_k_label)
+        top_p_label.pack(pady=5, after=top_k_entry)
+        top_p_entry.pack(pady=5, after=top_p_label)
+        root.geometry(f"{root.winfo_width()}x{root.winfo_height() + 150}")
+    else:
+        temperature_label.pack_forget()
+        temperature_entry.pack_forget()
+        top_k_label.pack_forget()
+        top_k_entry.pack_forget()
+        top_p_label.pack_forget()
+        top_p_entry.pack_forget()
+        root.geometry(f"{root.winfo_width()}x{root.winfo_height() - 150}")
+    center_window(root)
+
+def open_image_to_caption():
+    global stop_processing, error_messages, selected_files, save_directory, status_var, num_files_var, errors_var, progress
+    global prompt_var, max_new_tokens_var, do_sample_var, temperature_var, top_k_var, top_p_var, thread_count_var, precision_var, batch_size_var
+    global prepend_text_var, append_text_var, search_var, action_var, caption_handling_var  # Updated caption handling variable
+    global start_button, stop_button
+    global temperature_label, temperature_entry, top_k_label, top_k_entry, top_p_label, top_p_entry
+    global do_sample_check, prompt_entry, select_files_button, show_captions_button, thread_count_entry, precision_entry, batch_size_entry
+    global prepend_text_entry, append_text_entry
+    global root
+    global q
+
+    root = tk.Tk()
+    root.title("Image to Caption")
+    root.geometry("1050x950")
+
+    # Khởi tạo các biến Tkinter sau khi root đã được tạo
+    status_var = tk.StringVar()
+    num_files_var = tk.StringVar()
+    errors_var = tk.StringVar(value="Errors: 0")
+    progress = tk.IntVar()
+    prompt_var = tk.StringVar(value="Describe this image")
+    max_new_tokens_var = tk.IntVar(value=200)
+    do_sample_var = tk.BooleanVar(value=False)
+    temperature_var = tk.DoubleVar(value=1.0)
+    top_k_var = tk.IntVar(value=50)
+    top_p_var = tk.DoubleVar(value=0.95)
+    thread_count_var = tk.IntVar(value=4)
+    precision_var = tk.IntVar(value=1)
+    batch_size_var = tk.IntVar(value=1)
+    prepend_text_var = tk.StringVar()
+    append_text_var = tk.StringVar()
+    caption_handling_var = tk.StringVar(value='skip')  # Default value is 'skip'
+    search_var = tk.StringVar()  # Biến search_var khởi tạo ở đây
+    action_var = tk.StringVar()  # Biến action_var khởi tạo ở đây
+
+    q = queue.Queue()
+
+    validate_cmd = root.register(validate_numeric_input)
+
+    back_button = tk.Button(root, text="<-", font=('Helvetica', 14), command=return_to_menu)
+    back_button.pack(anchor='nw', padx=10, pady=10)
+
+    title_label = tk.Label(root, text="Image Caption Generator", font=('Helvetica', 16))
+    title_label.pack(pady=10)
+
+    warning_label = tk.Label(root, text="NOTE: To run CogVLM with the minimum configuration, you need at least 40GB RAM to load the model in FP16 with batch size 1 and a GPU with at least 24GB of VRAM. It is recommended to install ImageDucHaiten on an NVMe SSD to optimize speed.",
+                             font=('Helvetica', 10), fg="red", wraplength=750, justify="left")
+    warning_label.pack(pady=10)
+
+    select_files_button = tk.Button(root, text="Select Files", command=select_files)
+    select_files_button.pack(pady=10)
+
+    show_captions_button = tk.Button(root, text="Show Captions", command=open_caption_window)
+    show_captions_button.pack(pady=10)
+
+    num_files_label = tk.Label(root, textvariable=num_files_var)
+    num_files_label.pack(pady=5)
+
+    prompt_label = tk.Label(root, text="Prompt (text to describe the image):")
+    prompt_label.pack(pady=5)
+    prompt_entry = tk.Text(root, height=3, wrap='word', width=60)
+    prompt_entry.pack(pady=5, padx=10, fill='both', expand=True)
+    prompt_entry.bind('<KeyRelease>', on_prompt_change)
+
+    prepend_text_label = tk.Label(root, text="Prepend Text:")
+    prepend_text_label.pack(pady=5)
+    prepend_text_entry = tk.Entry(root, textvariable=prepend_text_var, justify='center', width=60)
+    prepend_text_entry.pack(pady=5)
+
+    append_text_label = tk.Label(root, text="Append Text:")
+    append_text_label.pack(pady=5)
+    append_text_entry = tk.Entry(root, textvariable=append_text_var, justify='center', width=60)
+    append_text_entry.pack(pady=5)
+
+    # Thêm các radio button để xử lý caption khi ảnh đã có caption
+    caption_handling_label = tk.Label(root, text="If a caption already exists for an image:", font=('Helvetica', 12))
+    caption_handling_label.pack(pady=5)
+
+    # Frame chứa các radio button
+    options_frame = tk.Frame(root)
+    options_frame.pack(pady=5)
+
+    # Radio buttons
+    overwrite_radio = tk.Radiobutton(options_frame, text="Overwrite existing caption", variable=caption_handling_var, value='overwrite')
+    overwrite_radio.pack(side="left", padx=10)
+
+    append_radio = tk.Radiobutton(options_frame, text="Append to existing caption", variable=caption_handling_var, value='append')
+    append_radio.pack(side="left", padx=10)
+
+    skip_radio = tk.Radiobutton(options_frame, text="Skip images with existing caption", variable=caption_handling_var, value='skip')
+    skip_radio.pack(side="left", padx=10)
+
+    load_config_from_json()
+
+    prompt_var.trace('w', on_config_change)
+    max_new_tokens_var.trace('w', on_config_change)
+    temperature_var.trace('w', on_config_change)
+    top_k_var.trace('w', on_config_change)
+    top_p_var.trace('w', on_config_change)
+    precision_var.trace('w', on_config_change)
+    thread_count_var.trace('w', on_config_change)
+    batch_size_var.trace('w', on_config_change)
+    prepend_text_var.trace('w', on_config_change)
+    append_text_var.trace('w', on_config_change)
+    caption_handling_var.trace('w', on_config_change)  # Trace for the caption handling radio buttons
+
+    max_new_tokens_label = tk.Label(root, text="Max New Tokens (max number of tokens to generate):")
+    max_new_tokens_label.pack(pady=5)
+    max_new_tokens_entry = tk.Entry(root, textvariable=max_new_tokens_var, justify='center', width=5, validate='key', validatecommand=(validate_cmd, '%P'))
+    max_new_tokens_entry.pack(pady=5)
+
+    do_sample_check = tk.Checkbutton(root, text="Do Sample (random sampling):", variable=do_sample_var, command=toggle_sampling_options)
+    do_sample_check.pack(pady=5)
+
+    temperature_label = tk.Label(root, text="Temperature (control randomness of sampling):")
+    top_k_label = tk.Label(root, text="Top-k (consider top k tokens):")
+    top_p_label = tk.Label(root, text="Top-p (consider tokens with cumulative probability p):")
+
+    temperature_entry = tk.Entry(root, textvariable=temperature_var, justify='center', width=5, validate='key', validatecommand=(validate_cmd, '%P'))
+    top_k_entry = tk.Entry(root, textvariable=top_k_var, justify='center', width=5, validate='key', validatecommand=(validate_cmd, '%P'))
+    top_p_entry = tk.Entry(root, textvariable=top_p_var, justify='center', width=5, validate='key', validatecommand=(validate_cmd, '%P'))
+
+    # Frame to hold all three horizontally aligned elements
+    horizontal_frame = tk.Frame(root)
+    horizontal_frame.pack(pady=5, padx=5)
+
+    thread_count_label = tk.Label(horizontal_frame, text="Thread Count (number of threads to use):")
+    thread_count_label.pack(side=tk.LEFT, padx=5)
+    thread_count_entry = tk.Entry(horizontal_frame, textvariable=thread_count_var, justify='center', width=5, validate='key', validatecommand=(validate_cmd, '%P'))
+    thread_count_entry.pack(side=tk.LEFT, padx=5)
+
+    batch_size_label = tk.Label(horizontal_frame, text="Batch Size (number of images to process at once):")
+    batch_size_label.pack(side=tk.LEFT, padx=5)
+    batch_size_entry = tk.Entry(horizontal_frame, textvariable=batch_size_var, justify='center', width=5, validate='key', validatecommand=(validate_cmd, '%P'))
+    batch_size_entry.pack(side=tk.LEFT, padx=5)
+
+    errors_button = tk.Button(root, textvariable=errors_var, command=show_errors)
+    errors_button.pack(pady=10)
+
+    start_button = tk.Button(root, text="Generate Captions", command=lambda: [process_files(), update_and_save_config()])
+    start_button.pack(pady=10)
+
+    stop_button = tk.Button(root, text="Stop", command=stop_processing_func)
+    stop_button.pack(pady=10)
+
+    progress_bar = ttk.Progressbar(root, variable=progress, maximum=100)
+    progress_bar.pack(pady=10, fill=tk.X)
+
+    status_label = tk.Label(root, textvariable=status_var, fg="green")
+    status_label.pack(pady=5)
+
+    center_window(root)
+    root.protocol("WM_DELETE_WINDOW", on_closing)
+    root.mainloop()
+
+def select_files():
+    global selected_files, save_directory, total_pages, original_selected_files
+    filetypes = [("All Image files", "*.jpg;*.jpeg;*.png;*.gif;*.bmp;*.tiff;*.tif;*.svg;*.webp")]
+    filepaths = filedialog.askopenfilenames(title="Select Image Files", filetypes=filetypes)
+    if filepaths:
+        selected_files.clear()
+        selected_files.extend(filepaths)
+        original_selected_files = selected_files.copy()
+        validate_selected_files()
+
+        num_files_var.set(f"{len(selected_files)} files selected.")
+        save_directory = os.path.dirname(selected_files[0])
+        total_pages = (len(selected_files) + images_per_page - 1) // images_per_page
+        if caption_window is not None:
+            update_image_preview(content_canvas)
+
+def validate_selected_files():
+    global selected_files, num_files_var
+    selected_files = [file for file in selected_files if os.path.exists(file)]
+    num_files_var.set(f"{len(selected_files)} files selected.")
+
+def toggle_buttons(state):
+    state = tk.NORMAL if state else tk.DISABLED
+    select_files_button.config(state=state)
+    show_captions_button.config(state=state)
+    prompt_entry.config(state=state)
+    prepend_text_entry.config(state=state)
+    append_text_entry.config(state=state)
+    do_sample_check.config(state=state)
+    temperature_entry.config(state=state)
+    top_k_entry.config(state=state)
+    top_p_entry.config(state=state)
+    thread_count_entry.config(state=state)
+    batch_size_entry.config(state=state)
+    start_button.config(state=state)
+    stop_button.config(state=tk.NORMAL)
+
+def generate_caption(image_path, save_directory, q):
+    if stop_processing:
+        return
+
+    try:
+        load_model()
+
+        filename = os.path.basename(image_path)
+        caption_file_path = os.path.join(save_directory, f"{filename}_caption.txt")
+
+        # Kiểm tra các lựa chọn của người dùng
+        if os.path.exists(caption_file_path):
+            if caption_handling_var.get() == 'skip':
+                q.put(image_path)
+                return
+            elif caption_handling_var.get() == 'append':
+                with open(caption_file_path, 'r', encoding='utf-8') as f:
+                    existing_caption = f.read()
+            else:
+                existing_caption = ""
+        else:
+            existing_caption = ""
+
+        image = PILImage.open(image_path).convert('RGB')
+        if not isinstance(image, PILImage.Image):
+            raise ValueError(f"Expected image to be of type PIL.Image.Image, but got {type(image)}")
+
+        inputs = model.build_conversation_input_ids(
+            tokenizer,
+            query=prompt_var.get(),
+            history=[],
+            images=[image]
+        )
+        inputs = {
+            'input_ids': inputs['input_ids'].unsqueeze(0).to('cuda'),
+            'token_type_ids': inputs['token_type_ids'].unsqueeze(0).to('cuda'),
+            'attention_mask': inputs['attention_mask'].unsqueeze(0).to('cuda'),
+            'images': [[inputs['images'][0].to('cuda').to(torch.float16)]],
+        }
+        gen_kwargs = {
+            "max_new_tokens": max_new_tokens_var.get(),
+            "do_sample": do_sample_var.get(),
+            "temperature": temperature_var.get(),
+            "top_k": top_k_var.get(),
+            "top_p": top_p_var.get() if do_sample_var.get() else None,
+            "num_beams": precision_var.get()
+        }
+
+        with torch.no_grad():
+            outputs = model.generate(**inputs, **gen_kwargs)
+            outputs = outputs[:, inputs['input_ids'].shape[1]:]
+            new_caption = tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+        final_caption = f"{prepend_text_var.get()} {existing_caption} {new_caption} {append_text_var.get()}".strip()
+
+        with open(caption_file_path, 'w', encoding='utf-8') as file:
+            file.write(final_caption)
+
+        q.put(image_path)
+        torch.cuda.empty_cache()
+    except torch.cuda.OutOfMemoryError as e:
+        torch.cuda.empty_cache()
+        error_message = f"CUDA OutOfMemoryError: {traceback.format_exc()}"
+        print(error_message)
+        q.put(error_message)
+        error_messages.append(error_message)
+    except Exception as e:
+        error_message = f"Error processing image {image_path}: {traceback.format_exc()}"
+        print(error_message)
+        q.put(error_message)
+        error_messages.append(error_message)
+
+def worker(save_directory, num_threads, batch_size):
+    try:
+        progress.set(0)
+        threads = []
+
+        num_batches = math.ceil(len(selected_files) / batch_size)
+        batch_size_per_thread = max(1, batch_size // num_threads)  # Số ảnh mỗi luồng xử lý trong một batch
+
+        for batch_index in range(num_batches):
+            if stop_processing:
+                break
+
+            start_index = batch_index * batch_size
+            end_index = min(start_index + batch_size, len(selected_files))
+            batch = selected_files[start_index:end_index]
+
+            # Chia ảnh trong batch cho các luồng
+            for i in range(0, len(batch), batch_size_per_thread):
+                thread_batch = batch[i:i + batch_size_per_thread]
+                thread = threading.Thread(target=generate_captions_for_batch, args=(thread_batch, save_directory, q))
+                threads.append(thread)
+                thread.start()
+
+            # Đợi các luồng trong batch hiện tại hoàn thành
+            for thread in threads:
+                thread.join()
+            threads.clear()
+
+        q.put(None)
+    except Exception as e:
+        if not stop_processing:
+            q.put(e)
+
+def generate_captions_for_batch(batch, save_directory, q):
+    for image_path in batch:
+        generate_caption(image_path, save_directory, q)
+
+def update_progress():
+    try:
+        completed = 0
+        while True:
+            item = q.get()
+            if item is None:
+                break
+            if isinstance(item, str):
+                if "Error" in item:
+                    root.after(0, errors_var.set, f"Errors: {len(error_messages)}")
+                    continue
+            completed += 1
+            progress.set(int((completed / len(selected_files)) * 100))
+            if not stop_processing:
+                root.after(0, status_var.set, f"Processed {completed} files")
+                root.after(0, root.update_idletasks)
+        if not stop_processing:
+            root.after(0, progress.set(100))
+            show_completion_message(completed)
+    except Exception as e:
+        if not stop_processing:
+            root.after(0, status_var.set(f"Error: {e}"))
+    finally:
+        toggle_buttons(True)
+
+def show_completion_message(completed):
+    message = f"Processing complete. {completed} files processed."
+    if error_messages:
+        message += f" {len(error_messages)} errors occurred."
+    messagebox.showinfo("Process Complete", message)
+
+def process_files():
+    global stop_processing, error_messages
+    stop_processing = False
+    error_messages.clear()
+    errors_var.set("Errors: 0")
+
+    validate_selected_files()
+
+    if not selected_files or not save_directory:
+        status_var.set("Please select images.")
+        return
+
+    toggle_buttons(False)
+
+    threading.Thread(target=worker, args=(save_directory, thread_count_var.get(), batch_size_var.get())).start()
+    threading.Thread(target=update_progress).start()
+
+def stop_processing_func():
+    global stop_processing
+    stop_processing = True
+    torch.cuda.empty_cache()
+    status_var.set("Processing stopped.")
+
+def open_caption_window():
+    global caption_window, caption_frame, caption_text_widgets, current_page, total_pages, content_canvas
+    if caption_window is not None:
+        return
+    
+    validate_selected_files()
+
+    caption_window = tk.Toplevel(root)
+    caption_window.title("Image Thumbnails and Captions")
+    caption_window.geometry("800x900")
+
+    main_frame = tk.Frame(caption_window)
+    main_frame.pack(fill=tk.BOTH, expand=True)
+
+    search_frame = tk.Frame(main_frame)
+    search_frame.pack(side=tk.TOP, fill=tk.X)
+
+    search_entry = tk.Entry(search_frame, textvariable=search_var)
+    search_entry.pack(side=tk.LEFT, padx=10, pady=5, fill=tk.X, expand=True)
+
+    search_button = tk.Button(search_frame, text="Search", command=search_captions)
+    search_button.pack(side=tk.LEFT, padx=10)
+
+    reset_button = tk.Button(search_frame, text="Reset Order", command=reset_order)
+    reset_button.pack(side=tk.LEFT, padx=10)
+
+    action_frame = tk.Frame(main_frame)
+    action_frame.pack(side=tk.TOP, fill=tk.X)
+
+    action_entry = tk.Entry(action_frame, textvariable=action_var)
+    action_entry.pack(side=tk.LEFT, padx=10, pady=5, fill=tk.X, expand=True)
+
+    prepend_button = tk.Button(action_frame, text="Add to Beginning", command=lambda: add_to_captions("prepend"))
+    prepend_button.pack(side=tk.LEFT, padx=5)
+
+    append_button = tk.Button(action_frame, text="Add to End", command=lambda: add_to_captions("append"))
+    append_button.pack(side=tk.LEFT, padx=5)
+
+    insert_middle_button = tk.Button(action_frame, text="Add to Middle", command=lambda: add_to_captions("insert_middle"))
+    insert_middle_button.pack(side=tk.LEFT, padx=5)
+
+    delete_keyword_button = tk.Button(action_frame, text="Delete Keyword", command=delete_keyword_from_captions)
+    delete_keyword_button.pack(side=tk.LEFT, padx=5)
+
+    delete_images_button = tk.Button(action_frame, text="Delete Images with Keyword", command=delete_images_with_keyword)
+    delete_images_button.pack(side=tk.LEFT, padx=5)
+
+    content_canvas = tk.Canvas(main_frame)
+    content_canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+
+    caption_frame = tk.Frame(content_canvas)
+    content_canvas.create_window((0, 0), window=caption_frame, anchor='nw')
+
+    caption_scrollbar = tk.Scrollbar(main_frame, orient="vertical", command=content_canvas.yview)
+    caption_scrollbar.pack(side=tk.LEFT, fill=tk.Y)
+    content_canvas.configure(yscrollcommand=caption_scrollbar.set)
+
+    caption_frame.bind("<Configure>", lambda e: content_canvas.configure(scrollregion=content_canvas.bbox("all")))
+    content_canvas.bind_all("<MouseWheel>", lambda event: content_canvas.yview_scroll(int(-1*(event.delta/120)), "units"))
+
+    def on_caption_window_close():
+        global caption_window
+        caption_window.destroy()
+        caption_window = None
+
+    caption_window.protocol("WM_DELETE_WINDOW", on_caption_window_close)
+
+    update_image_preview(content_canvas)
+
+def update_image_preview(content_canvas):
+    global thumbnails, caption_text_widgets, current_page, images_per_page, total_pages
+    if caption_frame is None:
+        return
+
+    for widget in caption_frame.winfo_children():
+        if isinstance(widget, tk.Label) or isinstance(widget, tk.Text) or isinstance(widget, tk.Frame):
+            widget.destroy()
+
+    thumbnails.clear()
+    caption_text_widgets.clear()
+
+    if not selected_files:
+        return
+
+    start_index = current_page * images_per_page
+    end_index = start_index + images_per_page
+    files_to_display = selected_files[start_index:end_index]
+
+    for i, file_path in enumerate(files_to_display):
+        thumbnail_size = (200, 200)
+        try:
+            image = PILImage.open(file_path)
+            image.thumbnail(thumbnail_size)
+            thumbnail = ImageTk.PhotoImage(image)
+            thumbnails.append(thumbnail)
+
+            img_label = tk.Label(caption_frame, image=thumbnail)
+            img_label.grid(row=i*2, column=0, padx=5, pady=5, sticky="nsew")
+
+            file_label = tk.Label(caption_frame, text=os.path.basename(file_path), font=('Helvetica', 12))
+            file_label.grid(row=i*2, column=1, padx=5, pady=5, sticky="nsew")
+
+            caption_file = os.path.join(save_directory, f"{os.path.basename(file_path)}_caption.txt")
+            if os.path.exists(caption_file):
+                with open(caption_file, 'r', encoding='utf-8') as file:
+                    caption_text = file.read()
+            else:
+                caption_text = ""
+
+            caption_var = tk.StringVar(value=caption_text)    
+
+            caption_text_widget = tk.Text(caption_frame, width=50, height=3, wrap=tk.WORD, font=('Helvetica', 12))
+            caption_text_widget.insert(tk.END, caption_text)
+            caption_text_widget.grid(row=i*2, column=2, padx=5, pady=5, sticky="nsew")
+
+            caption_var.trace_add("write", lambda *args, fp=file_path, cv=caption_var: save_caption(fp, cv.get()))
+
+            caption_text_widget.bind("<KeyRelease>", lambda e, cv=caption_var, w=caption_text_widget: cv.set(w.get("1.0", "end-1c")))
+            caption_text_widgets.append(caption_text_widget)
+
+        except Exception as e:
+            tk.Label(caption_frame, text="Error loading image").grid(row=i*2, column=0, columnspan=4, padx=5, pady=5)
+
+    nav_frame = tk.Frame(caption_frame)
+    nav_frame.grid(row=images_per_page*2, column=0, columnspan=3, pady=10)
+
+    if current_page > 0:
+        prev_button = tk.Button(nav_frame, text="Previous", command=lambda: navigate(-1, content_canvas))
+        prev_button.pack(side=tk.LEFT)
+
+    page_label = tk.Label(nav_frame, text=f"Page {current_page + 1} of {total_pages}")
+    page_label.pack(side=tk.LEFT, padx=5)
+
+    page_entry = tk.Entry(nav_frame, width=5)
+    page_entry.pack(side=tk.LEFT)
+
+    go_button = tk.Button(nav_frame, text="Go", command=lambda: go_to_page(page_entry.get(), content_canvas))
+    go_button.pack(side=tk.LEFT, padx=5)
+
+    if current_page < total_pages - 1:
+        next_button = tk.Button(nav_frame, text="Next", command=lambda: navigate(1, content_canvas))
+        next_button.pack(side=tk.RIGHT)
+
+def navigate(direction, content_canvas):
+    global current_page
+    current_page += direction
+    update_image_preview(content_canvas)
+
+def go_to_page(page_number, content_canvas):
+    global current_page, total_pages
+    try:
+        page_number = int(page_number)
+        if 1 <= page_number <= total_pages:
+            current_page = page_number - 1
+            update_image_preview(content_canvas)
+        else:
+            messagebox.showerror("Invalid Page", f"Please enter a valid page number between 1 and {total_pages}.")
+    except ValueError:
+        messagebox.showerror("Invalid Input", "Please enter a valid integer for the page number.")
+
+def save_caption(file_path, caption_text):
+    output_path = os.path.join(save_directory, f"{os.path.basename(file_path)}_caption.txt")
+    try:
+        with open(output_path, 'w', encoding='utf-8') as file:
+            file.write(caption_text.strip())
+    except Exception as e:
+        print(f"Error saving captions: {e}")    
+
+def search_captions():
+    global selected_files
+    search_term = search_var.get().lower().strip()
+    if not search_term:
+        return
+    
+    try:
+        selected_files.sort(key=lambda x: search_score(x, search_term), reverse=True)
+    except Exception as e:
+        error_message = f"Error during sorting: {e}"
+        print(error_message)
+        error_messages.append(error_message)
+
+    update_image_preview(content_canvas)
+
+def search_score(file_path, search_term):
+    caption_file = os.path.join(save_directory, f"{os.path.basename(file_path)}_caption.txt")
+    try:
+        if os.path.exists(caption_file):
+           with open(caption_file, 'r', encoding='utf-8') as file:
+               caption_text = file.read().lower()
+               if search_term in caption_text:
+                   return caption_text.count(search_term)
+               
+    except Exception as e:
+        error_message = f"Error reading file {caption_file}: {e}"
+        print(error_message)
+        error_messages.append(error_message)           
+    return 0
+
+def reset_order():
+    global selected_files
+    selected_files = original_selected_files.copy()
+    update_image_preview(content_canvas)
+
+def add_to_captions(position):
+    global selected_files
+    keyword = action_var.get()
+    if not keyword:
+        return
+
+    for file_path in selected_files:
+        caption_file = os.path.join(save_directory, f"{os.path.basename(file_path)}_caption.txt")
+        if os.path.exists(caption_file):
+            with open(caption_file, 'r+', encoding='utf-8') as file:
+                caption_text = file.read()
+                if position == "prepend":
+                    caption_text = f"{keyword} {caption_text}"
+                elif position == "append":
+                    caption_text = f"{caption_text} {keyword}"
+                elif position == "insert_middle":
+                    middle_index = len(caption_text) // 2
+                    caption_text = f"{caption_text[:middle_index]} {keyword} {caption_text[middle_index:]}"
+                file.seek(0)
+                file.write(caption_text)
+                file.truncate()
+
+    update_image_preview(content_canvas)
+
+def delete_keyword_from_captions():
+    keyword = action_var.get().lower().strip()
+    if not keyword:
+        return
+
+    for file_path in selected_files:
+        caption_file = os.path.join(save_directory, f"{os.path.basename(file_path)}_caption.txt")
+        if os.path.exists(caption_file):
+            with open(caption_file, 'r+', encoding='utf-8') as file:
+                caption_text = file.read().lower().replace(keyword, "")
+
+                updated_caption = caption_text.replace(keyword, "").strip()
+
+                file.seek(0)
+                file.write(updated_caption)
+                file.truncate()
+
+    update_image_preview(content_canvas)
+
+def delete_images_with_keyword():
+    global selected_files
+    keyword = action_var.get().lower()
+    if not keyword:
+        return
+    
+    files_to_delete = []
+    for file_path in selected_files:
+        caption_file = os.path.join(save_directory, f"{os.path.basename(file_path)}_caption.txt")
+        if os.path.exists(caption_file):
+            with open(caption_file, 'r', encoding='utf-8') as file:
+                caption_text = file.read().lower()
+                if keyword in caption_text:
+                    files_to_delete.append(file_path)
+
+    for file_path in files_to_delete:
+        try:
+            os.remove(file_path)
+            caption_file = os.path.join(save_directory, f"{os.path.basename(file_path)}_caption.txt")
+            if os.path.exists(caption_file):
+               os.remove(caption_file)
+        except Exception as e:
+            error_message = f"Error deleting file {file_path} or its caption: {e}"
+            print(error_message)
+            error_messages.append(error_message)
+
+    selected_files = [file_path for file_path in selected_files if file_path not in files_to_delete]
+
+    validate_selected_files()
+
+    update_image_preview(content_canvas)
+
+def return_to_menu():
+    stop_processing_func()
+    root.destroy()
+    import main
+    main.open_main_menu()
+
+def on_closing():
+    return_to_menu()
+
+if __name__ == "__main__":
+    open_image_to_caption()

image_to_tag.py

@@ -0,0 +1,784 @@
+import tkinter as tk
+from tkinter import filedialog, messagebox, ttk
+from PIL import Image as PILImage, ImageTk
+import os
+import queue
+import threading
+import subprocess
+import sys
+import json
+
+# Global variables to control the process and track errors
+stop_processing = False
+error_messages = []
+selected_files = []
+save_directory = ""  # Sử dụng thư mục của ảnh đầu tiên được chọn
+caption_window = None
+caption_frame = None
+thumbnails = []  # To hold references to thumbnail objects
+caption_text_widgets = []  # To hold Text widgets containing captions
+tag_dict = {}  # Store tags and their counts
+selected_tag = None  # Store the selected tag widget
+edit_buttons = {}  # To hold the edit and delete buttons for each tag
+error_window = None  # To ensure only one error window is open at a time
+tag_text_frame = None  # Define globally to manage tag frame
+
+# Global Tkinter variable placeholders
+status_var = None
+num_files_var = None
+errors_var = None
+progress = None
+character_threshold_var = None
+general_threshold_var = None
+thread_count_var = None
+batch_size_var = None
+start_button = None
+stop_button = None
+prepend_text_var = None
+append_text_var = None
+current_page = 0
+images_per_page = 20
+total_pages = 1  # Initialize total pages
+
+def update_and_save_config():
+    """Update and save the configuration to JSON."""
+    save_config_to_json(
+        model="swinv2",  # Default model
+        general_threshold=general_threshold_var.get(),
+        character_threshold=character_threshold_var.get(),
+        model_dir="D:/test/models/wd-swinv2-tagger-v3"  # Default model directory
+    )
+
+def show_errors(root):
+    """Display error details in a new window."""
+    global error_window
+    if error_window is not None:
+        return  # Only one error window can be open at a time
+
+    error_window = tk.Toplevel(root)
+    error_window.title("Error Details")
+    error_window.geometry("500x400")
+
+    error_text = tk.Text(error_window, wrap='word')
+    error_text.pack(expand=True, fill='both')
+
+    if error_messages:
+        for error in error_messages:
+            error_text.insert('end', error + '\n')
+    else:
+        error_text.insert('end', "No errors recorded.")
+
+    error_text.config(state='disabled')
+
+    def on_close_error_window():
+        global error_window
+        error_window.destroy()
+        error_window = None
+
+    error_window.protocol("WM_DELETE_WINDOW", on_close_error_window)
+
+def save_config_to_json(model, general_threshold, character_threshold, model_dir, filepath='config.json'):
+    """Save the model and threshold values to a JSON file."""
+    config = {
+        'model': model,
+        'general_threshold': general_threshold,
+        'character_threshold': character_threshold,
+        'model_dir': model_dir
+    }
+    try:
+        with open(filepath, 'w') as f:
+            json.dump(config, f, indent=2)
+    except Exception as e:
+        print(f"Error saving config to JSON: {e}")
+
+def open_image_to_tag():
+    global stop_processing, error_messages, selected_files, save_directory, caption_window, caption_frame, thumbnails, caption_text_widgets, tag_dict, selected_tag, edit_buttons, tag_text_frame, current_page, total_pages, content_canvas
+    global status_var, num_files_var, errors_var, progress, character_threshold_var, general_threshold_var, thread_count_var, batch_size_var
+    global start_button, stop_button, prepend_text_var, append_text_var
+
+    # Create Tkinter window
+    root = tk.Tk()
+    root.title("Image Caption Generator")
+
+    # Initialize Tkinter variables
+    status_var = tk.StringVar()
+    num_files_var = tk.StringVar()
+    errors_var = tk.StringVar(value="Errors: 0")
+    progress = tk.IntVar()
+    character_threshold_var = tk.DoubleVar(value=0.35)
+    general_threshold_var = tk.DoubleVar(value=0.35)
+    thread_count_var = tk.IntVar(value=4)
+    batch_size_var = tk.IntVar(value=4)
+    prepend_text_var = tk.StringVar()
+    append_text_var = tk.StringVar()
+    q = queue.Queue()
+
+    def center_window(window, width_extra=0, height_extra=0):
+        window.update_idletasks()
+        width = 100 + width_extra
+        height = 820 + height_extra
+        x = (window.winfo_screenwidth() // 2) - (width // 2)
+        y = (window.winfo_screenheight() // 2) - (height // 2)
+        window.geometry(f'{width}x{height}+{x}+{y}')
+
+    def select_files():
+        global selected_files, save_directory, total_pages
+        filetypes = [
+            ("All Image files", "*.jpg;*.jpeg;*.png;*.gif;*.bmp;*.tiff;*.tif;*.svg;*.webp"),
+            ("JPEG files", "*.jpg;*.jpeg"),
+            ("PNG files", "*.png"),
+            ("GIF files", "*.gif"),
+            ("BMP files", "*.bmp"),
+            ("TIFF files", "*.tiff;*.tif"),
+            ("SVG files", "*.svg"),
+            ("WEBP files", "*.webp")
+        ]
+        filepaths = filedialog.askopenfilenames(title="Select Image Files", filetypes=filetypes)
+        if filepaths:
+            selected_files.clear()
+            selected_files.extend(filepaths)
+            num_files_var.set(f"{len(selected_files)} files selected.")
+            save_directory = os.path.dirname(selected_files[0])  # Lấy thư mục của ảnh đầu tiên
+            total_pages = (len(selected_files) + images_per_page - 1) // images_per_page  # Cập nhật tổng số trang
+            if caption_window is not None:
+                update_image_preview(content_canvas)
+
+    def toggle_buttons(state):
+        """Enable or disable buttons based on the state."""
+        state = tk.NORMAL if state else tk.DISABLED
+        select_files_button.config(state=state)
+        show_captions_button.config(state=state)
+        general_threshold_entry.config(state=state)
+        character_threshold_entry.config(state=state)
+        thread_count_entry.config(state=state)
+        batch_size_entry.config(state=state)
+        prepend_text_entry.config(state=state)
+        append_text_entry.config(state=state)
+        start_button.config(state=state)
+        # Stop button should always be enabled
+        stop_button.config(state=tk.NORMAL)
+
+    def generate_caption(image_path, save_directory, q):
+        """Generate captions for a single image using the wd-swinv2-tagger-v3 model."""
+        if stop_processing:
+            return
+
+        try:
+            filename = os.path.basename(image_path)
+            output_path = os.path.join(save_directory, f"{filename}_tags.txt")
+
+            command = [
+                sys.executable, 'D:/test/wdv3-timm-main/wdv3_timm.py',
+                '--model', "swinv2",
+                '--image_path', image_path,
+                '--model_dir', "D:/test/models/wd-swinv2-tagger-v3",
+                '--general_threshold', str(general_threshold_var.get()),
+                '--character_threshold', str(character_threshold_var.get())
+            ]
+
+            result = subprocess.run(command, capture_output=True, text=True, check=True)
+            output = result.stdout
+            print(output)  # Debug: In ra toàn bộ đầu ra từ lệnh subprocess
+            error_output = result.stderr
+            print(output)  # In ra đầu ra từ lệnh subprocess
+            print(error_output)  # In ra đầu ra lỗi từ lệnh subprocess
+
+            # Filter out information to contain only Caption or General tags
+            filtered_output = []
+            recording = False
+            for line in output.split('\n'):
+                if "General tags" in line:
+                    recording = True
+                    continue
+                if recording:
+                    if line.startswith('  '):
+                        tag = line.strip().split(':')[0].replace('_', ' ')
+                        filtered_output.append(tag)
+                    else:
+                        recording = False
+                        break
+
+            # Convert list of tags to comma-separated string
+            final_tags = ','.join(filtered_output) if filtered_output else "No tags found"
+            print("Filtered output:", final_tags)  # Debug: In ra các nhãn cuối cùng sau khi lọc
+
+            # Add prepend and append text
+            final_tags = f"{prepend_text_var.get()},{final_tags},{append_text_var.get()}".strip(',')
+
+            # Save result to text file
+            with open(output_path, 'w', encoding='utf-8') as file:
+                file.write(final_tags)
+
+            q.put(image_path)
+        except Exception as e:
+            error_message = f"Error processing image {image_path}: {str(e)}"
+            print(error_message)  # Debug: In ra thông báo lỗi
+            q.put(error_message)
+            error_messages.append(error_message)
+
+    def worker(save_directory, num_threads, batch_size):
+        try:
+            progress.set(0)
+            batch = []
+            threads = []
+            for i, input_path in enumerate(selected_files, 1):
+                if stop_processing:
+                    break
+
+                batch.append(input_path)
+                if len(batch) == batch_size or i == len(selected_files):
+                    for image_path in batch:
+                        thread = threading.Thread(target=generate_caption, args=(image_path, save_directory, q))
+                        threads.append(thread)
+                        thread.start()
+
+                    for thread in threads:
+                        thread.join()
+
+                    batch.clear()
+                    threads.clear()
+
+            q.put(None)
+        except Exception as e:
+            if not stop_processing:
+                q.put(e)
+
+    def update_progress():
+        try:
+            completed = 0
+            while True:
+                item = q.get()
+                if item is None:
+                    break
+                if isinstance(item, str):
+                    if "Error" in item:
+                        root.after(0, errors_var.set, f"Errors: {len(error_messages)}")
+                        continue
+                completed += 1
+                progress.set(int((completed / len(selected_files)) * 100))
+                if not stop_processing:
+                    root.after(0, status_var.set, f"Processed {completed} files")
+                    root.after(0, root.update_idletasks)
+                    if caption_window is not None:
+                        root.after(0, update_image_preview, content_canvas)
+            if not stop_processing:
+                root.after(0, progress.set(100))
+                show_completion_message(completed)
+        except Exception as e:
+            if not stop_processing:
+                root.after(0, status_var.set, f"Error: {e}")
+        finally:
+            # Re-enable buttons after processing completes
+            toggle_buttons(True)
+
+    def show_completion_message(completed):
+        message = f"Processing complete. {completed} files processed."
+        if error_messages:
+            message += f" {len(error_messages)} errors occurred."
+        messagebox.showinfo("Process Complete", message)
+
+    def process_files():
+        global stop_processing, error_messages
+        stop_processing = False
+        error_messages.clear()
+        errors_var.set("Errors: 0")
+        if not selected_files or not save_directory:
+            status_var.set("Please select images.")
+            return
+
+        # Disable buttons during processing
+        toggle_buttons(False)
+
+        threading.Thread(target=worker, args=(save_directory, thread_count_var.get(), batch_size_var.get())).start()
+        threading.Thread(target=update_progress).start()
+
+    def stop_processing_func():
+        global stop_processing
+        stop_processing = True
+        status_var.set("Processing stopped.")
+
+    def return_to_menu():
+        stop_processing_func()
+        root.destroy()
+        import main
+        main.open_main_menu()
+
+    def on_closing():
+        # Save all captions before closing
+        save_all_captions()
+        return_to_menu()
+
+    def validate_threshold(P):
+        """Validate that the threshold value is between 0 and 1."""
+        if P == "" or (P.replace('.', '', 1).isdigit() and 0 <= float(P) <= 1):
+            return True
+        return False
+
+    def validate_thread_count(P):
+        """Validate that the thread count is a positive integer."""
+        if P == "" or P.isdigit() and int(P) > 0:
+            return True
+        return False
+
+    def validate_batch_size(P):
+        """Validate that the batch size is a positive integer."""
+        if P == "" or P.isdigit() and int(P) > 0:
+            return True
+        return False
+
+    def open_caption_window():
+        global caption_window, caption_frame, caption_text_widgets, tag_text_frame, current_page, total_pages, content_canvas
+        if caption_window is not None:
+            return  # A caption window is already open, do not create a new one
+
+        caption_window = tk.Toplevel(root)
+        caption_window.title("Image Thumbnails and Captions")
+        caption_window.geometry("1400x900")  # Điều chỉnh kích thước cửa sổ
+
+        # Create main frame to hold canvas and other elements
+        main_frame = tk.Frame(caption_window)
+        main_frame.pack(fill=tk.BOTH, expand=True)
+
+        # Create canvas for content
+        content_canvas = tk.Canvas(main_frame)
+        content_canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+
+        # Create frame for content
+        caption_frame = tk.Frame(content_canvas)
+        content_canvas.create_window((0, 0), window=caption_frame, anchor='nw')
+
+        # Add scrollbar for caption_frame
+        caption_scrollbar = tk.Scrollbar(main_frame, orient="vertical", command=content_canvas.yview)
+        caption_scrollbar.pack(side=tk.LEFT, fill=tk.Y)
+        content_canvas.configure(yscrollcommand=caption_scrollbar.set)
+
+        caption_frame.bind("<Configure>", lambda e: content_canvas.configure(scrollregion=content_canvas.bbox("all")))
+
+        # Ensure caption_window is reset to None when the window is closed
+        def on_caption_window_close():
+            global caption_window, tag_text_frame
+            caption_window.destroy()
+            caption_window = None
+            tag_text_frame = None  # Reset tag_text_frame when window is closed
+
+        caption_window.protocol("WM_DELETE_WINDOW", on_caption_window_close)
+
+        # Display content and set dividers
+        update_image_preview(content_canvas)
+
+        # Create frame for tags (on the right side)
+        tag_frame = tk.Frame(main_frame, padx=0)
+        tag_frame.pack(side=tk.RIGHT, fill=tk.Y)
+
+        # Create sorting buttons
+        sort_label = tk.Label(tag_frame, text="Sort by:", font=('Helvetica', 12))
+        sort_label.pack(anchor='nw', pady=5)
+
+        sort_alpha_button = tk.Button(tag_frame, text="Alphabetical", command=sort_tags_alpha)
+        sort_alpha_button.pack(anchor='nw', pady=2)
+
+        sort_count_button = tk.Button(tag_frame, text="Count", command=sort_tags_count)
+        sort_count_button.pack(anchor='nw', pady=2)
+
+        # Create display area for tags
+        tag_canvas = tk.Canvas(tag_frame)
+        tag_text_frame = tk.Frame(tag_canvas)
+        tag_canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        tag_canvas.create_window((0, 0), window=tag_text_frame, anchor='nw')
+
+        # Add scrollbar for tag_frame
+        tag_scrollbar = tk.Scrollbar(main_frame, orient="vertical", command=tag_canvas.yview)
+        tag_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
+        tag_canvas.configure(yscrollcommand=tag_scrollbar.set)
+
+        tag_text_frame.bind("<Configure>", lambda e: tag_canvas.configure(scrollregion=tag_canvas.bbox("all")))
+
+        # Update initial tag display
+        update_tag_display()
+
+    def update_image_preview(content_canvas):
+        global thumbnails, caption_text_widgets, current_page, images_per_page, total_pages
+        if caption_frame is None:
+            return
+
+        for widget in caption_frame.winfo_children():
+            if isinstance(widget, tk.Label) or isinstance(widget, tk.Text) or isinstance(widget, tk.Frame):
+                widget.destroy()
+
+        thumbnails.clear()  # Clear old thumbnails
+        caption_text_widgets.clear()  # Clear old caption_entries
+
+        if not selected_files:
+            return
+
+        start_index = current_page * images_per_page
+        end_index = start_index + images_per_page
+        files_to_display = selected_files[start_index:end_index]
+
+        for i, file_path in enumerate(files_to_display):
+            thumbnail_size = (200, 200)
+            try:
+                image = PILImage.open(file_path)
+                image.thumbnail(thumbnail_size)
+                thumbnail = ImageTk.PhotoImage(image)
+                thumbnails.append(thumbnail)  # Keep reference to thumbnail object
+
+                # Display thumbnail
+                img_label = tk.Label(caption_frame, image=thumbnail)
+                img_label.grid(row=i*2, column=0, padx=5, pady=5, sticky="nsew")
+
+                # Display file name
+                file_label = tk.Label(caption_frame, text=os.path.basename(file_path), font=('Helvetica', 12))
+                file_label.grid(row=i*2, column=1, padx=5, pady=5, sticky="nsew")
+
+                # Check and display caption if available
+                caption_file = os.path.join(save_directory, f"{os.path.basename(file_path)}_tags.txt")
+                if os.path.exists(caption_file):
+                    with open(caption_file, 'r', encoding='utf-8') as file:
+                        caption_text = file.read()
+                else:
+                    caption_text = ""  # Set empty string if no caption available
+
+                caption_text_widget = tk.Text(caption_frame, width=50, height=3, wrap=tk.WORD, font=('Helvetica', 12))
+                caption_text_widget.insert(tk.END, caption_text)
+                caption_text_widget.grid(row=i*2, column=2, padx=5, pady=5, sticky="nsew")
+                caption_text_widget.bind("<FocusOut>", lambda e, fp=file_path: save_caption(fp, caption_text_widget.get("1.0", "end-1c")))
+                caption_text_widgets.append(caption_text_widget)
+
+                # Update tags in tag_dict
+                update_tag_dict(caption_text)
+
+            except Exception as e:
+                tk.Label(caption_frame, text="Error loading image").grid(row=i*2, column=0, columnspan=4, padx=5, pady=5)
+
+        # Add navigation buttons
+        nav_frame = tk.Frame(caption_frame)
+        nav_frame.grid(row=images_per_page*2, column=0, columnspan=3, pady=10)
+
+        if current_page > 0:
+            prev_button = tk.Button(nav_frame, text="Previous", command=lambda: navigate(-1, content_canvas))
+            prev_button.pack(side=tk.LEFT)
+
+        page_label = tk.Label(nav_frame, text=f"Page {current_page + 1} of {total_pages}")
+        page_label.pack(side=tk.LEFT, padx=5)
+
+        page_entry = tk.Entry(nav_frame, width=5)
+        page_entry.pack(side=tk.LEFT)
+
+        go_button = tk.Button(nav_frame, text="Go", command=lambda: go_to_page(page_entry.get(), content_canvas))
+        go_button.pack(side=tk.LEFT, padx=5)
+
+        if current_page < total_pages - 1:
+            next_button = tk.Button(nav_frame, text="Next", command=lambda: navigate(1, content_canvas))
+            next_button.pack(side=tk.RIGHT)
+
+        # Update tag display after loading images
+        update_tag_display()
+
+    def navigate(direction, content_canvas):
+        global current_page
+        current_page += direction
+        update_image_preview(content_canvas)
+
+    def go_to_page(page_number, content_canvas):
+        global current_page, total_pages
+        try:
+            page_number = int(page_number)
+            if 1 <= page_number <= total_pages:
+                current_page = page_number - 1
+                update_image_preview(content_canvas)
+            else:
+                messagebox.showerror("Invalid Page", f"Please enter a valid page number between 1 and {total_pages}.")
+        except ValueError:
+            messagebox.showerror("Invalid Input", "Please enter a valid integer for the page number.")
+
+    def save_caption(file_path, caption_text):
+        """Save caption when user changes it."""
+        output_path = os.path.join(save_directory, f"{os.path.basename(file_path)}_tags.txt")
+        with open(output_path, 'w', encoding='utf-8') as file:
+            file.write(caption_text)
+
+        # Update tags after editing caption
+        update_tag_dict(caption_text)
+        update_tag_display()
+
+    def save_all_captions():
+        """Save all captions when closing the window."""
+        for i, caption_text_widget in enumerate(caption_text_widgets):
+            if caption_text_widget.winfo_exists():
+                file_path = selected_files[current_page * images_per_page + i]
+                caption_text = caption_text_widget.get("1.0", "end-1c")
+                save_caption(file_path, caption_text)
+
+    def update_tag_dict(caption_text=None):
+        """Update tag dictionary based on caption_text."""
+        global tag_dict
+        new_tag_dict = {}
+        for caption_widget in caption_text_widgets:
+            if caption_widget.winfo_exists():
+                caption_text = caption_widget.get("1.0", "end-1c")
+                tags = caption_text.split(',')
+                for tag in tags:
+                    tag = tag.strip()
+                    if tag:
+                        if tag in new_tag_dict:
+                            new_tag_dict[tag] += 1
+                        else:
+                            new_tag_dict[tag] = 1
+        tag_dict = new_tag_dict
+
+    def update_tag_display():
+        """Update tag display on Text widget."""
+        global tag_dict, selected_tag, edit_buttons, tag_text_frame
+        if tag_text_frame is None:
+            return  # If the tag_text_frame is not created yet, return
+        for widget in tag_text_frame.winfo_children():
+            widget.destroy()
+
+        row = 0
+        for tag, count in tag_dict.items():
+            tag_label = tk.Label(tag_text_frame, text=tag, bg="white", padx=5, pady=2, anchor="w", relief="solid", borderwidth=1)
+            tag_label.grid(row=row, column=0, sticky="w", padx=2, pady=1)
+            count_label = tk.Label(tag_text_frame, text=f"({count})", anchor='w', width=5)
+            count_label.grid(row=row, column=1, padx=5, pady=2, sticky='w')
+
+            # Add tag manipulation buttons
+            add_tag_button = tk.Button(tag_text_frame, text="Add", command=lambda r=row: add_tag(r))
+            add_tag_button.grid(row=row, column=2, padx=2)
+            edit_button = tk.Button(tag_text_frame, text="Edit", command=lambda t=tag_label: edit_tag(t))
+            edit_button.grid(row=row, column=3, padx=2)
+            delete_button = tk.Button(tag_text_frame, text="Delete", command=lambda t=tag_label: delete_tag(t))
+            delete_button.grid(row=row, column=4, padx=2)
+            delete_all_button = tk.Button(tag_text_frame, text="Delete All", command=lambda t=tag_label: delete_all_files_with_tag(t))
+            delete_all_button.grid(row=row, column=5, padx=2)
+
+            edit_buttons[tag_label] = [add_tag_button, edit_button, delete_button, delete_all_button]
+
+            row += 1
+
+        # Điều chỉnh trọng số cột để không mở rộng quá mức
+        tag_text_frame.grid_columnconfigure(0, weight=1)  # Cột cho tag
+        tag_text_frame.grid_columnconfigure(1, weight=0)  # Cột cho số lượng
+        tag_text_frame.grid_columnconfigure(2, weight=0)  # Cột cho nút Add
+        tag_text_frame.grid_columnconfigure(3, weight=0)  # Cột cho nút Edit
+        tag_text_frame.grid_columnconfigure(4, weight=0)  # Cột cho nút Delete
+        tag_text_frame.grid_columnconfigure(5, weight=0)  # Cột cho nút Delete All
+
+        tag_text_frame.update_idletasks()  # Làm mới giao diện sau khi cập nhật danh sách tag
+        tag_text_frame.update()  # Làm mới giao diện ngay lập tức
+
+    def add_tag(row):
+        """Add a new tag above the selected row."""
+        def save_new_tag(event=None):
+            new_tag = entry.get().strip()
+            if new_tag:
+                # Add the new tag to the tag_dict
+                if new_tag in tag_dict:
+                    tag_dict[new_tag] += 1
+                else:
+                    tag_dict[new_tag] = 1
+
+                # Update the captions in the respective files
+                for file_path in selected_files:
+                    caption_file = os.path.join(save_directory, f"{os.path.basename(file_path)}_tags.txt")
+                    if os.path.exists(caption_file):
+                        with open(caption_file, 'r', encoding='utf-8') as file:
+                            caption_text = file.read()
+                        new_caption_text = caption_text + ',' + new_tag if caption_text else new_tag
+                        with open(caption_file, 'w', encoding='utf-8') as file:
+                            file.write(new_caption_text)
+
+                update_image_preview(content_canvas)  # Update image preview
+                update_tag_display()  # Update the display of tags
+
+        # Create entry above the row
+        for widget in tag_text_frame.grid_slaves():
+            if int(widget.grid_info()["row"]) >= row:
+                widget.grid_configure(row=int(widget.grid_info()["row"]) + 1)
+
+        entry = tk.Entry(tag_text_frame)
+        entry.grid(row=row, column=0, sticky="w", padx=2, pady=1)
+        entry.bind("<Return>", save_new_tag)
+        entry.bind("<FocusOut>", save_new_tag)
+        entry.bind("<Escape>", lambda e: entry.destroy())
+        entry.focus_set()
+
+    def edit_tag(tag_label):
+        """Edit the selected tag."""
+        def save_edit(event=None):
+            new_tag = entry.get().strip()
+            old_tag = tag_label.cget("text").strip()
+            if new_tag and new_tag != old_tag:
+                # Update the tag_dict with new tag
+                tag_dict[new_tag] = tag_dict.pop(old_tag)
+
+                # Update the captions in the respective files
+                for i, file_path in enumerate(selected_files):
+                    caption_file = os.path.join(save_directory, f"{os.path.basename(file_path)}_tags.txt")
+                    if os.path.exists(caption_file):
+                        with open(caption_file, 'r', encoding='utf-8') as file:
+                            caption_text = file.read()
+                        new_caption_text = caption_text.replace(old_tag, new_tag)
+                        with open(caption_file, 'w', encoding='utf-8') as file:
+                            file.write(new_caption_text)
+
+                update_image_preview(content_canvas)  # Update image preview
+                update_tag_display()  # Update the display of tags
+
+        old_tag = tag_label.cget("text").strip()
+        entry = tk.Entry(tag_text_frame)
+        entry.insert(0, old_tag)
+        entry.grid(row=tag_label.grid_info()["row"], column=0, sticky="w", padx=2, pady=1)
+        entry.bind("<Return>", save_edit)
+        entry.bind("<FocusOut>", save_edit)
+        entry.bind("<Escape>", lambda e: entry.destroy())
+        entry.focus_set()
+
+    def delete_tag(tag_label):
+        """Delete the selected tag."""
+        global selected_tag
+        if tag_label:
+            tag_to_delete = tag_label.cget("text").strip()
+            if tag_to_delete in tag_dict:
+                del tag_dict[tag_to_delete]
+
+                # Update the captions in the respective files
+                for i, file_path in enumerate(selected_files):
+                    caption_file = os.path.join(save_directory, f"{os.path.basename(file_path)}_tags.txt")
+                    if os.path.exists(caption_file):
+                        with open(caption_file, 'r', encoding='utf-8') as file:
+                            caption_text = file.read()
+                        new_caption_text = caption_text.replace(tag_to_delete, "")
+                        with open(caption_file, 'w', encoding='utf-8') as file:
+                            file.write(new_caption_text)
+
+                update_image_preview(content_canvas)  # Update image preview
+                update_tag_display()  # Update the display of tags
+
+    def delete_all_files_with_tag(tag_label):
+        """Delete all images and their corresponding text files containing the tag."""
+        tag_to_delete = tag_label.cget("text").strip()
+        if tag_to_delete in tag_dict:
+            del tag_dict[tag_to_delete]
+
+            # Delete the files containing the tag
+            files_to_delete = []
+            for i, file_path in enumerate(selected_files):
+                caption_file = os.path.join(save_directory, f"{os.path.basename(file_path)}_tags.txt")
+                if os.path.exists(caption_file):
+                    with open(caption_file, 'r', encoding='utf-8') as file:
+                        caption_text = file.read()
+                    if tag_to_delete in caption_text:
+                        files_to_delete.append((file_path, caption_file))
+            for image_file, caption_file in files_to_delete:
+                # Remove image file
+                try:
+                    os.remove(image_file)
+                except Exception as e:
+                    error_messages.append(f"Error deleting image {image_file}: {str(e)}")
+                # Remove caption file
+                try:
+                    os.remove(caption_file)
+                except Exception as e:
+                    error_messages.append(f"Error deleting caption {caption_file}: {str(e)}")
+
+            # Remove deleted files from selected_files list
+            selected_files[:] = [file for file in selected_files if file not in [img for img, cap in files_to_delete]]
+
+            # Clear tag_dict and update tag display
+            update_tag_dict()  # Update tag dictionary
+            update_tag_display()  # Update the display of tags
+            update_image_preview(content_canvas)  # Update image preview
+
+    def sort_tags_alpha():
+        """Sort tags alphabetically."""
+        global tag_dict
+        sorted_tags = sorted(tag_dict.items())
+        tag_dict = dict(sorted_tags)
+        update_tag_display()
+
+    def sort_tags_count():
+        """Sort tags by count."""
+        global tag_dict
+        sorted_tags = sorted(tag_dict.items(), key=lambda item: item[1], reverse=True)
+        tag_dict = dict(sorted_tags)
+        update_tag_display()
+
+    # Create GUI components
+    back_button = tk.Button(root, text="<-", font=('Helvetica', 14), command=return_to_menu)
+    back_button.pack(anchor='nw', padx=10, pady=10)
+
+    title_label = tk.Label(root, text="Image Tag Generator", font=('Helvetica', 16))
+    title_label.pack(pady=10)
+
+    select_files_button = tk.Button(root, text="Select Files", command=select_files)
+    select_files_button.pack(pady=10)
+
+    num_files_label = tk.Label(root, textvariable=num_files_var)
+    num_files_label.pack(pady=5)
+
+    show_captions_button = tk.Button(root, text="Show Captions", command=open_caption_window)
+    show_captions_button.pack(pady=10)
+
+    general_threshold_label = tk.Label(root, text="General Threshold:")
+    general_threshold_label.pack(pady=5)
+    general_threshold_entry = tk.Entry(root, textvariable=general_threshold_var, justify='center', width=5, validate='key')
+    general_threshold_entry.pack(pady=5)
+
+    character_threshold_label = tk.Label(root, text="Character Threshold:")
+    character_threshold_label.pack(pady=5)
+    character_threshold_entry = tk.Entry(root, textvariable=character_threshold_var, justify='center', width=5, validate='key')
+    character_threshold_entry.pack(pady=5)
+
+    prepend_text_label = tk.Label(root, text="Prepend Text:")
+    prepend_text_label.pack(pady=5)
+    prepend_text_entry = tk.Entry(root, textvariable=prepend_text_var, justify='center', width=20)
+    prepend_text_entry.pack(pady=5)
+
+    append_text_label = tk.Label(root, text="Append Text:")
+    append_text_label.pack(pady=5)
+    append_text_entry = tk.Entry(root, textvariable=append_text_var, justify='center', width=20)
+    append_text_entry.pack(pady=5)
+
+    thread_count_label = tk.Label(root, text="Thread Count:")
+    thread_count_label.pack(pady=5)
+    thread_count_entry = tk.Entry(root, textvariable=thread_count_var, justify='center', width=5, validate='key')
+    thread_count_entry.pack(pady=5)
+
+    batch_size_label = tk.Label(root, text="Batch Size:")
+    batch_size_label.pack(pady=5)
+    batch_size_entry = tk.Entry(root, textvariable=batch_size_var, justify='center', width=5, validate='key')
+    batch_size_entry.pack(pady=5)
+
+    errors_button = tk.Button(root, textvariable=errors_var, command=lambda: show_errors(root))
+    errors_button.pack(pady=10)
+
+    start_button = tk.Button(root, text="Generate Captions", command=lambda: [process_files(), update_and_save_config()])
+    start_button.pack(pady=10)
+
+    stop_button = tk.Button(root, text="Stop", command=stop_processing_func)
+    stop_button.pack(pady=10)
+
+    progress_bar = ttk.Progressbar(root, variable=progress, maximum=100)
+    progress_bar.pack(pady=10, fill=tk.X)
+
+    status_label = tk.Label(root, textvariable=status_var, fg="green")
+    status_label.pack(pady=5)
+
+    # Add input validation
+    general_threshold_entry.config(validatecommand=(root.register(validate_threshold), '%P'))
+    character_threshold_entry.config(validatecommand=(root.register(validate_threshold), '%P'))
+    thread_count_entry.config(validatecommand=(root.register(validate_thread_count), '%P'))
+    batch_size_entry.config(validatecommand=(root.register(validate_batch_size), '%P'))
+
+    # Update config when the thresholds or thread count change
+    general_threshold_var.trace_add('write', lambda *args: update_and_save_config())
+    character_threshold_var.trace_add('write', lambda *args: update_and_save_config())
+    thread_count_var.trace_add('write', lambda *args: update_and_save_config())
+
+    center_window(root, width_extra=200)
+    root.protocol("WM_DELETE_WINDOW", on_closing)
+    root.mainloop()
+
+if __name__ == "__main__":
+    open_image_to_tag()

main.py

@@ -0,0 +1,123 @@
+import tkinter as tk
+from tkinter import messagebox
+import webbrowser
+from image_converter import open_image_converter
+from image_filter import open_image_filter
+from rotate_flip import open_image_rotate_flip
+from image_error_fix import open_image_error_fix
+from image_to_tag import open_image_to_tag
+from image_to_caption import open_image_to_caption  # Import the function from image_to_caption.py
+from photo_fantasy import open_photo_fantasy
+from shuffle_image import open_image_shuffle  # Import the function from shuffle_image.py
+
+def open_main_menu():
+    root = tk.Tk()
+    root.title("IMageDucHaiten")
+
+    def center_window(window):
+        window.update_idletasks()
+        width = window.winfo_width()
+        height = window.winfo_height()
+        x = (window.winfo_screenwidth() // 2) - (width // 2)
+        y = (window.winfo_screenheight() // 2) - (height // 2)
+        window.geometry(f'{width}x{height}+{x}+{y}')
+
+    def open_converter_app():
+        root.destroy()
+        open_image_converter()
+
+    def open_image_filter_app():
+        root.destroy()
+        open_image_filter()
+
+    def open_rotate_flip_app():
+        root.destroy()
+        open_image_rotate_flip()
+
+    def open_image_error_fix_app():
+        root.destroy()
+        open_image_error_fix()
+
+    def open_image_to_tag_app():
+        root.destroy()
+        open_image_to_tag()
+
+    def open_image_to_caption_app():
+        root.destroy()
+        open_image_to_caption()
+
+    def open_photo_fantasy_app():
+        root.destroy()
+        open_photo_fantasy()
+
+    def open_shuffle_image_app():
+        root.destroy()
+        open_image_shuffle()
+
+    def open_future_app():
+        messagebox.showinfo("Information", "Other applications are still under development.")
+
+    def exit_app():
+        root.destroy()
+
+    def open_discord():
+        webbrowser.open("https://discord.gg/vKEW6jqa49")
+
+    def open_patreon():
+        webbrowser.open("https://www.patreon.com/duchaitenreal")
+
+    def open_paypal():
+        webbrowser.open("https://www.paypal.com/paypalme/duchaiten")
+
+    # Setup the interface
+    top_frame = tk.Frame(root)
+    top_frame.pack(fill='x', padx=10, pady=10)
+
+    discord_button = tk.Button(top_frame, text="Discord", font=('Helvetica', 12), command=open_discord)
+    discord_button.pack(side='left')
+
+    patreon_button = tk.Button(top_frame, text="Patreon", font=('Helvetica', 12), command=open_patreon)
+    patreon_button.pack(side='right')
+
+    paypal_button = tk.Button(top_frame, text="PayPal", font=('Helvetica', 12), command=open_paypal)
+    paypal_button.pack(side='right')
+
+    title_label = tk.Label(root, text="IMageDucHaiten", font=('Helvetica', 24))
+    title_label.pack(pady=20)
+
+    converter_button = tk.Button(root, text="Image Converter", font=('Helvetica', 16), command=open_converter_app)
+    converter_button.pack(pady=20)
+
+    image_filter_button = tk.Button(root, text="Image Filter", font=('Helvetica', 16), command=open_image_filter_app)
+    image_filter_button.pack(pady=20)
+
+    rotate_flip_button = tk.Button(root, text="Rotate & Flip", font=('Helvetica', 16), command=open_rotate_flip_app)
+    rotate_flip_button.pack(pady=20)
+
+    error_fix_button = tk.Button(root, text="Image Error Fix", font=('Helvetica', 16), command=open_image_error_fix_app)
+    error_fix_button.pack(pady=20)
+
+    caption_button = tk.Button(root, text="Image To Tag", font=('Helvetica', 16), command=open_image_to_tag_app)
+    caption_button.pack(pady=20)
+
+    image_to_caption_button = tk.Button(root, text="Image To Caption", font=('Helvetica', 16), command=open_image_to_caption_app)
+    image_to_caption_button.pack(pady=20)
+
+    photo_fantasy_button = tk.Button(root, text="Photo Fantasy", font=('Helvetica', 16), command=open_photo_fantasy_app)
+    photo_fantasy_button.pack(pady=20)
+
+    shuffle_image_button = tk.Button(root, text="Shuffle Image", font=('Helvetica', 16), command=open_shuffle_image_app)
+    shuffle_image_button.pack(pady=20)
+
+    future_app_button = tk.Button(root, text="Future App Template", font=('Helvetica', 16), command=open_future_app)
+    future_app_button.pack(pady=20)
+
+    exit_button = tk.Button(root, text="Exit", font=('Helvetica', 16), command=exit_app)
+    exit_button.pack(pady=20)
+
+    center_window(root)
+    root.geometry("550x950")  # Set the window size larger
+    root.mainloop()
+
+if __name__ == "__main__":
+    open_main_menu()

photo_fantasy.py

@@ -0,0 +1,393 @@
+import tkinter as tk
+from tkinter import filedialog, messagebox, ttk
+import os
+import threading
+import queue
+import shutil
+import subprocess
+
+# Global variables for controlling filtering and error handling
+stop_event = threading.Event()
+error_messages = []
+error_window = None
+selected_files = []
+worker_thread = None
+
+def open_photo_fantasy():
+    global error_messages, error_window, selected_files
+    global save_dir_var, status_var, num_files_var, errors_var, thread_count_var, progress
+    global q, worker_thread, root, stop_button, saved_files
+
+    # Create the Tkinter window
+    root = tk.Tk()
+    root.title("Photo Fantasy")
+
+    # Initialize Tkinter variables
+    save_dir_var = tk.StringVar()
+    status_var = tk.StringVar()
+    num_files_var = tk.StringVar()
+    errors_var = tk.StringVar(value="Errors: 0")
+    thread_count_var = tk.StringVar(value="4")
+    progress = tk.IntVar()
+    q = queue.Queue()
+
+    def center_window(window):
+        window.update_idletasks()
+        width = window.winfo_width() + 120  # Add 120 pixels to width
+        height = window.winfo_height()
+        x = (window.winfo_screenwidth() // 2) - (width // 2)
+        y = (window.winfo_screenheight() // 2) - (height // 2)
+        window.geometry(f'{width}x{height}+{x}+{y}')
+
+    def select_directory():
+        filepaths = filedialog.askopenfilenames(
+            title="Select Images",
+            filetypes=[("All Image files", "*.jpg;*.jpeg;*.png;*.gif;*.bmp;*.tiff")]
+        )
+        if filepaths:
+            selected_files.clear()
+            selected_files.extend(filepaths)
+            update_selected_files_label()
+
+    def choose_directory():
+        directory = filedialog.askdirectory()
+        if directory:
+            save_dir_var.set(directory)
+            save_dir_entry.config(state='normal')
+            save_dir_entry.delete(0, tk.END)
+            save_dir_entry.insert(0, directory)
+            save_dir_entry.config(state='readonly')
+
+    def save_file_with_unique_name(filepath, save_directory, saved_files):
+        """Save file with a unique name to avoid overwriting."""
+        if filepath in saved_files:
+            return  # File already saved, do not save again
+    
+        base_name, ext = os.path.splitext(os.path.basename(filepath))
+        save_path = os.path.join(save_directory, f"{base_name}{ext}")
+        counter = 1
+        while os.path.exists(save_path):
+            save_path = os.path.join(save_directory, f"{base_name} ({counter}){ext}")
+            counter += 1
+        try:
+            shutil.copy(filepath, save_path)
+            saved_files.add(filepath)  # Mark this file as saved
+        except Exception as e:
+            error_messages.append(f"Error saving file {filepath}: {e}")
+            update_error_count()
+
+    def update_selected_files_label():
+        """Update the label showing the number of selected files."""
+        num_files_var.set(f"{len(selected_files)} files selected.")
+
+    def update_error_count():
+        """Update the error count displayed in the Errors button."""
+        errors_var.set(f"Errors: {len(error_messages)}")
+
+    def run_task(task_func):
+        """Run the given task function in a separate thread."""
+        global worker_thread
+        stop_event.clear()
+        disable_buttons()
+        worker_thread = threading.Thread(target=task_func)
+        worker_thread.start()
+        root.after(100, check_thread)
+
+    def check_thread():
+        """Check if the worker thread is still running."""
+        if worker_thread.is_alive():
+            root.after(100, check_thread)
+        else:
+            enable_buttons()
+            if stop_event.is_set():
+                status_var.set("Task stopped.")
+            else:
+                status_var.set("Task completed.")
+
+    def disable_buttons():
+        """Disable all buttons except the stop button."""
+        select_directory_button.config(state='disabled')
+        choose_dir_button.config(state='disabled')
+        auto_adjust_button.config(state='disabled')
+        enhance_vivid_button.config(state='disabled')
+        horror_theme_button.config(state='disabled')
+        cinematic_theme_button.config(state='disabled')
+        cyberpunk_theme_button.config(state='disabled')
+        fairytale_theme_button.config(state='disabled')
+        classic_vintage_button.config(state='disabled')
+        dark_fantasy_button.config(state='disabled')
+        stop_button.config(state='normal')
+
+    def enable_buttons():
+        """Enable all buttons."""
+        select_directory_button.config(state='normal')
+        choose_dir_button.config(state='normal')
+        auto_adjust_button.config(state='normal')
+        enhance_vivid_button.config(state='normal')
+        horror_theme_button.config(state='normal')
+        cinematic_theme_button.config(state='normal')
+        cyberpunk_theme_button.config(state='normal')
+        fairytale_theme_button.config(state='normal')
+        classic_vintage_button.config(state='normal')
+        dark_fantasy_button.config(state='normal')
+        stop_button.config(state='normal')
+
+    def process_images(process_func):
+        global saved_files
+        saved_files = set()  # Initialize saved_files set
+
+        if not selected_files or not save_dir_var.get():
+            messagebox.showerror("Input Error", "Please select images and a save directory.")
+            enable_buttons()
+            return
+
+        save_directory = save_dir_var.get()
+        if not os.path.exists(save_directory):
+            os.makedirs(save_directory)
+
+        for file in selected_files:
+            if stop_event.is_set():
+                break
+
+            base_name, ext = os.path.splitext(os.path.basename(file))
+            save_path = os.path.join(save_directory, f"{base_name}{ext}")
+            counter = 1
+            while os.path.exists(save_path):
+                save_path = os.path.join(save_directory, f"{base_name} ({counter}){ext}")
+                counter += 1
+
+            try:
+                process_func(file, save_path)
+                saved_files.add(file)  # Mark this file as saved
+            except subprocess.CalledProcessError as e:
+                error_messages.append(f"Error processing file {file}: {e}")
+                update_error_count()
+
+        messagebox.showinfo("Processing Complete", f"Processed {len(saved_files)} files.")
+
+    def auto_adjust_images():
+        process_images(lambda file, save_path: subprocess.run(['magick', 'convert', file, 
+                                                               '-enhance', 
+                                                               '-contrast-stretch', '0.1x0.1%', 
+                                                               '-sharpen', '0x1', 
+                                                               save_path], check=True))
+
+    def enhance_vivid_images():
+        process_images(lambda file, save_path: subprocess.run(['magick', 'convert', file, 
+                                                               '-enhance', 
+                                                               '-contrast-stretch', '0.1x0.1%', 
+                                                               '-sharpen', '0x1', 
+                                                               '-modulate', '105,120,100', 
+                                                               save_path], check=True))
+
+    def horror_theme_images():
+        process_images(lambda file, save_path: subprocess.run(['magick', 'convert', file, 
+                                                               '-modulate', '100,90,100',
+                                                               '-level', '-5%,95%', 
+                                                               '-brightness-contrast', '1x1',
+                                                               '-sigmoidal-contrast', '3x50%', 
+                                                               '-noise', '3',
+                                                               '-sharpen', '0x1.5', 
+                                                               '(', '+clone', '-fill', 'black', '-colorize', '5%', ')', 
+                                                               '-compose', 'multiply', '-flatten', 
+                                                               save_path], check=True))
+
+    def cinematic_theme_images():
+        process_images(lambda file, save_path: subprocess.run(['magick', 'convert', file,
+                                                               '-level', '-5%,95%', 
+                                                               '-modulate', '100,150,100',
+                                                               '-colorize', '0,5,0',   
+                                                               '-brightness-contrast', '5x-0',
+                                                               '-sigmoidal-contrast', '3x50%', 
+                                                               '-sharpen', '0x1.5', 
+                                                               '-noise', '0.1', 
+                                                               '(', '+clone', '-blur', '0x1', ')', 
+                                                               '-compose', 'blend', '-define', 'compose:args=10', '-composite', 
+                                                               '(', '+clone', '-fill', 'black', '-colorize', '10%', ')', 
+                                                               '-compose', 'multiply', '-flatten', 
+                                                               save_path], check=True))
+
+    def cyberpunk_theme_images():
+        process_images(lambda file, save_path: subprocess.run(['magick', 'convert', file,
+                                                               '-modulate', '100,130,100',
+                                                               '-level', '-5%,95%', 
+                                                               '-colorize', '10,0,20', 
+                                                               '-brightness-contrast', '1x1',
+                                                               '-sigmoidal-contrast', '3x50%', 
+                                                               '-sharpen', '0x0.5', 
+                                                               '-noise', '0.5', 
+                                                               '(', '+clone', '-blur', '0x2', ')', 
+                                                               '-compose', 'blend', '-define', 'compose:args=20', '-composite',
+                                                               '(', '+clone', '-fill', 'black', '-colorize', '10%', ')', 
+                                                               '-compose', 'multiply', '-flatten',
+                                                               save_path], check=True))
+
+    def fairytale_theme_images():
+        process_images(lambda file, save_path: subprocess.run(['magick', 'convert', file,
+                                                               '-modulate', '100,120,100', 
+                                                               '-blur', '0x1.2', 
+                                                               '-brightness-contrast', '2x-1', 
+                                                               '(', '+clone', '-alpha', 'extract', '-virtual-pixel', 'black',
+                                                               '-blur', '0x15', '-shade', '120x45', ')', 
+                                                               '-compose', 'softlight', '-composite',
+                                                               save_path], check=True))
+
+    def classic_vintage_images():
+        process_images(lambda file, save_path: subprocess.run(['magick', 'convert', file,
+                                                               '-modulate', '110,80,100', 
+                                                               '-fill', '#704214', '-colorize', '10%', 
+                                                               '-attenuate', '0.3', '+noise', 'Multiplicative', 
+                                                               '-blur', '0x1.2',
+                                                               '-level', '5%,90%', 
+                                                               '-unsharp', '0x5',
+                                                               '-colorspace', 'sRGB',
+                                                               '-brightness-contrast', '-5x15',
+                                                               save_path], check=True))
+
+    def dark_fantasy_images():
+        process_images(lambda file, save_path: subprocess.run(['magick', 'convert', file,
+                                                               '-modulate', '110,130,100', 
+                                                               '-blur', '0x1', 
+                                                               '-brightness-contrast', '5x-10', 
+                                                               '-attenuate', '0.1', '+noise', 'Multiplicative', 
+                                                               '-unsharp', '0x5',
+                                                               '-level', '5%,95%', 
+                                                               '-modulate', '105,125,100', 
+                                                               '-brightness-contrast', '0x1', 
+                                                               '(', '+clone', '-fill', 'black', '-colorize', '10%', ')', 
+                                                               '-compose', 'multiply', '-flatten',
+                                                               '-colorspace', 'sRGB',
+                                                               save_path], check=True))
+
+    def stop_filtering_func():
+        stop_event.set()  # Signal the worker thread to stop
+        status_var.set("Filtering stopped.")
+        # Do not disable the Stop button to keep it always enabled
+        # Re-enable all buttons
+        enable_buttons()
+        if worker_thread is not None:
+            worker_thread.join()  # Wait for worker thread to finish
+
+    def return_to_menu():
+        stop_filtering_func()
+        root.destroy()
+        # Import main menu and open it
+        from main import open_main_menu
+        open_main_menu()
+
+    def on_closing():
+        stop_filtering_func()
+        return_to_menu()
+
+    def show_errors():
+        global error_window
+        if error_window is not None:
+            return
+
+        error_window = tk.Toplevel(root)
+        error_window.title("Error Details")
+        error_window.geometry("500x400")
+
+        error_text = tk.Text(error_window, wrap='word')
+        error_text.pack(expand=True, fill='both')
+
+        if error_messages:
+            for error in error_messages:
+                error_text.insert('end', error + '\n')
+        else:
+            error_text.insert('end', "No errors recorded.")
+
+        error_text.config(state='disabled')
+
+        def on_close_error_window():
+            global error_window
+            error_window.destroy()
+            error_window = None
+
+        error_window.protocol("WM_DELETE_WINDOW", on_close_error_window)
+
+    def validate_number(P):
+        if P.isdigit() or P == "":
+            return True
+        else:
+            messagebox.showerror("Input Error", "Please enter only numbers.")
+            return False
+
+    validate_command = root.register(validate_number)
+
+    # Create UI elements
+    back_button = tk.Button(root, text="<-", font=('Helvetica', 14), command=return_to_menu)
+    back_button.pack(anchor='nw', padx=10, pady=10)
+
+    title_label = tk.Label(root, text="Photo Fantasy", font=('Helvetica', 16))
+    title_label.pack(pady=10)
+
+    select_directory_button = tk.Button(root, text="Select Images", command=select_directory)
+    select_directory_button.pack(pady=5)
+
+    num_files_label = tk.Label(root, textvariable=num_files_var)
+    num_files_label.pack(pady=5)
+
+    choose_dir_button = tk.Button(root, text="Choose Save Directory", command=choose_directory)
+    choose_dir_button.pack(pady=5)
+
+    save_dir_entry = tk.Entry(root, textvariable=save_dir_var, state='readonly', justify='center')
+    save_dir_entry.pack(pady=5, fill=tk.X)
+
+    # Add Auto Adjust button
+    auto_adjust_button = tk.Button(root, text="Auto Adjust Images", command=lambda: run_task(auto_adjust_images))
+    auto_adjust_button.pack(pady=10)
+
+    # Add Enhance Vivid button
+    enhance_vivid_button = tk.Button(root, text="Enhance Vivid Images", command=lambda: run_task(enhance_vivid_images))
+    enhance_vivid_button.pack(pady=10)
+
+    # Add Horror Theme button
+    horror_theme_button = tk.Button(root, text="Horror Theme Images", command=lambda: run_task(horror_theme_images))
+    horror_theme_button.pack(pady=10)
+
+    # Add Cinematic Theme button
+    cinematic_theme_button = tk.Button(root, text="Cinematic Theme Images", command=lambda: run_task(cinematic_theme_images))
+    cinematic_theme_button.pack(pady=10)
+
+    # Add Cyberpunk Theme button
+    cyberpunk_theme_button = tk.Button(root, text="Cyberpunk Theme Images", command=lambda: run_task(cyberpunk_theme_images))
+    cyberpunk_theme_button.pack(pady=10)
+
+    # Add Fairytale Theme button
+    fairytale_theme_button = tk.Button(root, text="Fairytale Theme Images", command=lambda: run_task(fairytale_theme_images))
+    fairytale_theme_button.pack(pady=10)
+
+    # Add Classic Vintage button
+    classic_vintage_button = tk.Button(root, text="Classic Vintage Images", command=lambda: run_task(classic_vintage_images))
+    classic_vintage_button.pack(pady=10)
+
+    # Add Dark Fantasy button
+    dark_fantasy_button = tk.Button(root, text="Dark Fantasy Images", command=lambda: run_task(dark_fantasy_images))
+    dark_fantasy_button.pack(pady=10)
+
+    # Add label and entry for thread count
+    thread_count_label = tk.Label(root, text="Number of Threads:")
+    thread_count_label.pack(pady=5)
+
+    thread_count_entry = tk.Entry(root, textvariable=thread_count_var, validate="key", validatecommand=(validate_command, '%P'), justify='center', width=4)
+    thread_count_entry.pack(pady=5)
+
+    stop_button = tk.Button(root, text="Stop", command=stop_filtering_func)  # Ensure stop button is a global variable
+    stop_button.pack(pady=5)
+
+    errors_button = tk.Button(root, textvariable=errors_var, command=show_errors)
+    errors_button.pack(pady=5)
+
+    progress_bar = ttk.Progressbar(root, variable=progress, maximum=100)
+    progress_bar.pack(pady=5, fill=tk.X)
+
+    status_label = tk.Label(root, textvariable=status_var, fg="green")
+    status_label.pack(pady=5)
+
+    center_window(root)
+    root.protocol("WM_DELETE_WINDOW", on_closing)
+    root.mainloop()
+
+if __name__ == "__main__":
+    open_photo_fantasy()

rotate_flip.py

@@ -0,0 +1,316 @@
+import tkinter as tk
+from tkinter import filedialog, ttk, messagebox
+from wand.image import Image as WandImage
+import os
+import threading
+import queue
+
+# Biến toàn cục để điều khiển việc dừng và lưu lỗi
+stop_processing = False
+error_messages = []
+error_window = None
+selected_files = []
+save_directory = ""
+
+def open_image_rotate_flip():
+    global stop_processing, error_messages, error_window, selected_files, save_dir_var, status_var, num_files_var, errors_var, thread_count_var, progress, q, rotate_left_angle_var, rotate_right_angle_var
+
+    # Tạo cửa sổ Tkinter
+    root = tk.Tk()
+    root.title("Image Rotate & Flip")
+
+    # Khởi tạo các biến Tkinter
+    save_dir_var = tk.StringVar()
+    status_var = tk.StringVar()
+    num_files_var = tk.StringVar()
+    errors_var = tk.StringVar(value="Errors: 0")
+    thread_count_var = tk.StringVar(value="4")
+    rotate_left_angle_var = tk.StringVar(value="90")
+    rotate_right_angle_var = tk.StringVar(value="90")
+    progress = tk.IntVar()
+    q = queue.Queue()
+
+    def center_window(window):
+        window.update_idletasks()
+        width = window.winfo_width() + 120
+        height = window.winfo_height()
+        x = (window.winfo_screenwidth() // 2) - (width // 2)
+        y = (window.winfo_screenheight() // 2) - (height // 2)
+        window.geometry(f'{width}x{height}+{x}+{y}')
+
+    def select_files():
+        global selected_files
+        filetypes = [
+            ("All Image files", "*.jpg;*.jpeg;*.png;*.gif;*.bmp;*.tiff;*.tif;*.svg;*.webp"),
+            ("JPEG files", "*.jpg;*.jpeg"),
+            ("PNG files", "*.png"),
+            ("GIF files", "*.gif"),
+            ("BMP files", "*.bmp"),
+            ("TIFF files", "*.tiff;*.tif"),
+            ("SVG files", "*.svg"),
+            ("WEBP files", "*.webp")
+        ]
+        filepaths = filedialog.askopenfilenames(title="Select Image Files", filetypes=filetypes)
+        if filepaths:
+            selected_files.clear()
+            selected_files.extend(filepaths)
+            num_files_var.set(f"{len(selected_files)} files selected.")
+
+    def choose_directory():
+        global save_directory
+        directory = filedialog.askdirectory()
+        if directory:
+            save_directory = directory
+            save_dir_var.set(directory)
+
+    def rotate_image(input_path, angle, output_path):
+        """Xoay ảnh sử dụng ImageMagick thông qua Wand."""
+        try:
+            with WandImage(filename=input_path) as img:
+                img.rotate(angle)
+                img.save(filename=output_path)
+        except Exception as e:
+            raise RuntimeError(f"Error rotating image: {e}")
+
+    def flip_image(input_path, direction, output_path):
+        """Lật ảnh sử dụng ImageMagick thông qua Wand."""
+        try:
+            with WandImage(filename=input_path) as img:
+                if direction == "horizontal":
+                    img.flip()
+                elif direction == "vertical":
+                    img.flop()
+                img.save(filename=output_path)
+        except Exception as e:
+            raise RuntimeError(f"Error flipping image: {e}")
+
+    def process_image(input_path, save_directory, operation, angle, q):
+        if stop_processing:
+            return
+
+        filename = os.path.basename(input_path)
+        try:
+            output_path = os.path.join(save_directory, filename)
+            if operation == "rotate_left":
+                rotate_image(input_path, -angle, output_path)
+            elif operation == "rotate_right":
+                rotate_image(input_path, angle, output_path)
+            elif operation == "flip_horizontal":
+                flip_image(input_path, "horizontal", output_path)
+            elif operation == "flip_vertical":
+                flip_image(input_path, "vertical", output_path)
+
+            q.put(input_path)
+        except Exception as e:
+            error_message = f"Error processing {filename}: {str(e)}"
+            q.put(error_message)
+            error_messages.append(error_message)
+
+    def worker(save_directory, operation, num_threads, angle):
+        try:
+            progress.set(0)
+            for i, input_path in enumerate(selected_files, 1):
+                if stop_processing:
+                    break
+
+                thread = threading.Thread(target=process_image, args=(input_path, save_directory, operation, angle, q))
+                thread.start()
+                thread.join()
+
+            q.put(None)
+        except Exception as e:
+            if not stop_processing:
+                q.put(e)
+
+    def update_progress():
+        try:
+            completed = 0
+            while True:
+                item = q.get()
+                if item is None:
+                    break
+                if isinstance(item, str):
+                    if "Error" in item:
+                        root.after(0, errors_var.set, f"Errors: {len(error_messages)}")
+                        continue
+                completed += 1
+                progress.set(int((completed / len(selected_files)) * 100))
+                if not stop_processing:
+                    root.after(0, status_var.set, f"Processed {completed} files")
+                    root.after(0, root.update_idletasks)
+            if not stop_processing:
+                root.after(0, progress.set(100))
+                show_completion_message(completed)
+        except Exception as e:
+            if not stop_processing:
+                root.after(0, status_var.set, f"Error: {e}")
+
+    def show_completion_message(completed):
+        message = f"Processing complete. {completed} files processed."
+        if error_messages:
+            message += f" {len(error_messages)} errors occurred."
+        messagebox.showinfo("Process Complete", message)
+
+    def process_files(operation):
+        global stop_processing, error_messages
+        stop_processing = False
+        error_messages.clear()
+        errors_var.set("Errors: 0")
+        if not selected_files or not save_directory:
+            status_var.set("Please select images and save location.")
+            return
+
+        num_threads = int(thread_count_var.get() or 4)
+        if operation in ["rotate_left", "rotate_right"]:
+            angle = int(rotate_left_angle_var.get() or 0 if operation == "rotate_left" else rotate_right_angle_var.get() or 0)
+            if angle < 0 or angle > 360:
+                messagebox.showerror("Invalid Input", "Please enter a valid angle between 0 and 360.")
+                return
+        else:
+            angle = 0
+
+        threading.Thread(target=worker, args=(save_directory, operation, num_threads, angle)).start()
+        threading.Thread(target=update_progress).start()
+
+    def validate_number(P):
+        return P.isdigit() or P == ""
+
+    def validate_angle_input(var):
+        value = var.get()
+        if value != "":
+            try:
+                int_value = int(value)
+                if int_value < 0 or int_value > 360:
+                    raise ValueError
+            except ValueError:
+                messagebox.showerror("Invalid Input", "Please enter a valid angle between 0 and 360.")
+                var.set("")
+
+    def validate_thread_count(var):
+        value = var.get()
+        if value != "":
+            try:
+                int_value = int(value)
+                if int_value <= 0:
+                    raise ValueError
+            except ValueError:
+                messagebox.showerror("Invalid Input", "Please enter a valid number of threads.")
+                var.set("")
+
+    def stop_processing_func():
+        global stop_processing
+        stop_processing = True
+        status_var.set("Processing stopped.")
+
+    def return_to_menu():
+        stop_processing_func()
+        root.destroy()
+        import main
+        main.open_main_menu()
+
+    def on_closing():
+        return_to_menu()
+
+    def show_errors():
+        global error_window
+        if error_window is not None:
+            return
+
+        error_window = tk.Toplevel(root)
+        error_window.title("Error Details")
+        error_window.geometry("500x400")
+
+        error_text = tk.Text(error_window, wrap='word')
+        error_text.pack(expand=True, fill='both')
+
+        if error_messages:
+            for error in error_messages:
+                error_text.insert('end', error + '\n')
+        else:
+            error_text.insert('end', "No errors recorded.")
+
+        error_text.config(state='disabled')
+
+        def on_close_error_window():
+            global error_window
+            error_window.destroy()
+            error_window = None
+
+        error_window.protocol("WM_DELETE_WINDOW", on_close_error_window)
+
+    # Tạo các thành phần giao diện
+    validate_command = root.register(validate_number)
+
+    back_button = tk.Button(root, text="<-", font=('Helvetica', 14), command=return_to_menu)
+    back_button.pack(anchor='nw', padx=10, pady=10)
+
+    title_label = tk.Label(root, text="Image Rotate & Flip", font=('Helvetica', 16))
+    title_label.pack(pady=10)
+
+    select_files_button = tk.Button(root, text="Select Files", command=select_files)
+    select_files_button.pack(pady=5)
+
+    num_files_label = tk.Label(root, textvariable=num_files_var)
+    num_files_label.pack(pady=5)
+
+    choose_dir_button = tk.Button(root, text="Choose Save Directory", command=choose_directory)
+    choose_dir_button.pack(pady=10)
+
+    save_dir_entry = tk.Entry(root, textvariable=save_dir_var, state='readonly', justify='center')
+    save_dir_entry.pack(pady=5, fill=tk.X)
+
+    rotate_left_label = tk.Label(root, text="Enter the rotation angle (°):")
+    rotate_left_label.pack(pady=5)
+    rotate_left_entry = tk.Entry(root, textvariable=rotate_left_angle_var, justify='center', width=5, validate="key", validatecommand=(validate_command, '%P'))
+    rotate_left_entry.pack(pady=5)
+
+    rotate_left_button = tk.Button(root, text="Rotate Left", command=lambda: process_files("rotate_left"))
+    rotate_left_button.pack(pady=5)
+
+    rotate_right_label = tk.Label(root, text="Enter the rotation angle (°):")
+    rotate_right_label.pack(pady=5)
+    rotate_right_entry = tk.Entry(root, textvariable=rotate_right_angle_var, justify='center', width=5, validate="key", validatecommand=(validate_command, '%P'))
+    rotate_right_entry.pack(pady=5)
+
+    rotate_right_button = tk.Button(root, text="Rotate Right", command=lambda: process_files("rotate_right"))
+    rotate_right_button.pack(pady=5)
+
+    # Đường kẻ phân cách
+    separator = ttk.Separator(root, orient='horizontal')
+    separator.pack(fill='x', pady=10)
+
+    flip_horizontal_button = tk.Button(root, text="Flip Horizontal", command=lambda: process_files("flip_horizontal"))
+    flip_horizontal_button.pack(pady=5)
+
+    flip_vertical_button = tk.Button(root, text="Flip Vertical", command=lambda: process_files("flip_vertical"))
+    flip_vertical_button.pack(pady=5)
+
+    thread_count_label = tk.Label(root, text="Number of Threads:")
+    thread_count_label.pack(pady=5)
+
+    thread_count_entry = tk.Entry(root, textvariable=thread_count_var, width=5, justify='center', validate="key", validatecommand=(validate_command, '%P'))
+    thread_count_entry.pack(pady=5)
+
+    stop_button = tk.Button(root, text="Stop", command=stop_processing_func)
+    stop_button.pack(pady=5)
+
+    errors_button = tk.Button(root, textvariable=errors_var, command=show_errors)
+    errors_button.pack(pady=5)
+
+    progress_bar = ttk.Progressbar(root, variable=progress, maximum=100)
+    progress_bar.pack(pady=5, fill=tk.X)
+
+    status_label = tk.Label(root, textvariable=status_var, fg="green")
+    status_label.pack(pady=5)
+
+    # Ràng buộc xác thực đầu vào cho các ô nhập
+    rotate_left_angle_var.trace_add('write', lambda *args: validate_angle_input(rotate_left_angle_var))
+    rotate_right_angle_var.trace_add('write', lambda *args: validate_angle_input(rotate_right_angle_var))
+    thread_count_var.trace_add('write', lambda *args: validate_thread_count(thread_count_var))
+
+    center_window(root)
+    root.protocol("WM_DELETE_WINDOW", on_closing)
+    root.mainloop()
+
+if __name__ == "__main__":
+    open_image_rotate_flip()

shuffle_image.py

@@ -0,0 +1,285 @@
+import tkinter as tk
+from tkinter import filedialog, ttk, messagebox
+import os
+import threading
+import queue
+import random
+import shutil
+
+# Biến toàn cục để điều khiển việc dừng và lưu lỗi
+stop_processing = False
+error_messages = []
+error_window = None
+selected_files = []
+save_directory = ""
+random_selected_files = []
+shuffle_enabled = True  # Biến để lưu trạng thái xáo trộn
+
+def open_image_shuffle():
+    global stop_processing, error_messages, error_window, selected_files, save_dir_var, status_var, num_files_var, errors_var, thread_count_var, progress, q, random_selected_files, random_file_count_var, shuffle_enabled
+
+    # Tạo cửa sổ Tkinter
+    root = tk.Tk()
+    root.title("Image Shuffle")
+
+    # Khởi tạo các biến Tkinter
+    save_dir_var = tk.StringVar()
+    status_var = tk.StringVar()
+    num_files_var = tk.StringVar()
+    errors_var = tk.StringVar(value="Errors: 0")
+    thread_count_var = tk.StringVar(value="4")
+    random_file_count_var = tk.StringVar(value="0")
+    progress = tk.IntVar()
+    q = queue.Queue()
+
+    def center_window(window):
+        window.update_idletasks()
+        width = window.winfo_width() + 120
+        height = window.winfo_height()
+        x = (window.winfo_screenwidth() // 2) - (width // 2)
+        y = (window.winfo_screenheight() // 2) - (height // 2)
+        window.geometry(f'{width}x{height}+{x}+{y}')
+
+    def select_files():
+        global selected_files
+        filetypes = [
+            ("All Image files", "*.jpg;*.jpeg;*.png;*.gif;*.bmp;*.tiff;*.tif;*.svg;*.webp"),
+            ("JPEG files", "*.jpg;*.jpeg"),
+            ("PNG files", "*.png"),
+            ("GIF files", "*.gif"),
+            ("BMP files", "*.bmp"),
+            ("TIFF files", "*.tiff;*.tif"),
+            ("SVG files", "*.svg"),
+            ("WEBP files", "*.webp")
+        ]
+        filepaths = filedialog.askopenfilenames(title="Select Image Files", filetypes=filetypes)
+        if filepaths:
+            selected_files.clear()
+            selected_files.extend(filepaths)
+            num_files_var.set(f"{len(selected_files)} files selected.")
+
+    def choose_directory():
+        global save_directory
+        directory = filedialog.askdirectory()
+        if directory:
+            save_directory = directory
+            save_dir_var.set(directory)
+
+    def shuffle_and_save_images(num_random):
+        """Chọn ngẫu nhiên và lưu ảnh."""
+        try:
+            if num_random > len(selected_files):
+                messagebox.showerror("Error", "Not enough images to select.")
+                return
+            
+            random_selected_files = random.sample(selected_files, num_random)
+            if shuffle_enabled:
+                random.shuffle(random_selected_files)  # Xáo trộn danh sách file nếu được bật
+
+            for i, original_path in enumerate(random_selected_files):
+                filename = os.path.basename(original_path)
+                new_filename = f"shuffled_{i+1:03d}_{filename}"  # Tạo tên file mới với tiền tố shuffled và số thứ tự
+                new_path = os.path.join(save_directory, new_filename)
+                shutil.copy(original_path, new_path)
+                q.put(i + 1)  # Gửi tiến trình hoàn thành cho hàng đợi
+
+            q.put(None)  # Thông báo hoàn thành
+        except Exception as e:
+            q.put(e)  # Gửi lỗi vào hàng đợi
+
+    def select_and_save_sequentially(num_random):
+        """Chọn và lưu ảnh theo thứ tự."""
+        try:
+            if num_random > len(selected_files):
+                messagebox.showerror("Error", "Not enough images to select.")
+                return
+
+            step = len(selected_files) // num_random
+            sequential_selected_files = selected_files[::step]
+
+            for i, original_path in enumerate(sequential_selected_files[:num_random]):
+                filename = os.path.basename(original_path)
+                new_filename = f"sequential_{i+1:03d}_{filename}"  # Tạo tên file mới với tiền tố sequential và số thứ tự
+                new_path = os.path.join(save_directory, new_filename)
+                shutil.copy(original_path, new_path)
+                q.put(i + 1)  # Gửi tiến trình hoàn thành cho hàng đợi
+
+            q.put(None)  # Thông báo hoàn thành
+        except Exception as e:
+            q.put(e)  # Gửi lỗi vào hàng đợi
+
+    def worker(num_random):
+        try:
+            progress.set(0)
+            if shuffle_enabled:
+                shuffle_and_save_images(num_random)
+            else:
+                select_and_save_sequentially(num_random)
+        except Exception as e:
+            q.put(e)  # Gửi lỗi vào hàng đợi
+
+    def update_progress():
+        try:
+            completed = 0
+            total_files = int(random_file_count_var.get())
+            while True:
+                item = q.get()
+                if item is None:
+                    break
+                if isinstance(item, Exception):
+                    raise item
+                completed = item
+                progress.set(int((completed / total_files) * 100))
+                if not stop_processing:
+                    root.after(0, status_var.set, f"Processed {completed} of {total_files} files")
+                    root.after(0, root.update_idletasks)
+            if not stop_processing:
+                root.after(0, progress.set(100))
+                show_completion_message(completed)
+        except Exception as e:
+            root.after(0, status_var.set, f"Error: {e}")
+
+    def show_completion_message(completed):
+        message = f"Processing complete. {completed} files processed."
+        if error_messages:
+            message += f" {len(error_messages)} errors occurred."
+        messagebox.showinfo("Process Complete", message)
+
+    def validate_and_process():
+        global stop_processing, error_messages
+        stop_processing = False
+        error_messages.clear()
+        errors_var.set("Errors: 0")
+        if not selected_files or not save_directory:
+            status_var.set("Please select images and save location.")
+            return
+
+        num_random = int(random_file_count_var.get())
+
+        threading.Thread(target=worker, args=(num_random,)).start()
+        threading.Thread(target=update_progress).start()
+
+    def validate_number(P):
+        return P.isdigit() or P == ""
+
+    def toggle_shuffle():
+        global shuffle_enabled
+        shuffle_enabled = shuffle_var.get() == 1
+        if shuffle_enabled:
+            shuffle_and_save_button.config(text="Shuffle")
+            random_file_count_label.config(text="Number of Random Files:")
+        else:
+            shuffle_and_save_button.config(text="Sequentially")
+            random_file_count_label.config(text="Number of Files to Select:")
+
+    def stop_processing_func():
+        global stop_processing
+        stop_processing = True
+        status_var.set("Processing stopped.")
+
+    def return_to_menu():
+        stop_processing_func()
+        root.destroy()
+        import main
+        main.open_main_menu()
+
+    def on_closing():
+        return_to_menu()
+
+    def show_errors():
+        global error_window
+        if error_window is not None:
+            return
+
+        error_window = tk.Toplevel(root)
+        error_window.title("Error Details")
+        error_window.geometry("500x400")
+
+        error_text = tk.Text(error_window, wrap='word')
+        error_text.pack(expand=True, fill='both')
+
+        if error_messages:
+            for error in error_messages:
+                error_text.insert('end', error + '\n')
+        else:
+            error_text.insert('end', "No errors recorded.")
+
+        error_text.config(state='disabled')
+
+        def on_close_error_window():
+            global error_window
+            error_window.destroy()
+            error_window = None
+
+        error_window.protocol("WM_DELETE_WINDOW", on_close_error_window)
+
+    # Tạo các thành phần giao diện
+    validate_command = root.register(validate_number)
+
+    back_button = tk.Button(root, text="<-", font=('Helvetica', 14), command=return_to_menu)
+    back_button.pack(anchor='nw', padx=10, pady=10)
+
+    title_label = tk.Label(root, text="Image Shuffle", font=('Helvetica', 16))
+    title_label.pack(pady=10)
+
+    select_files_button = tk.Button(root, text="Select Files", command=select_files)
+    select_files_button.pack(pady=5)
+
+    num_files_label = tk.Label(root, textvariable=num_files_var)
+    num_files_label.pack(pady=5)
+
+    choose_dir_button = tk.Button(root, text="Choose Save Directory", command=choose_directory)
+    choose_dir_button.pack(pady=10)
+
+    save_dir_entry = tk.Entry(root, textvariable=save_dir_var, state='readonly', justify='center')
+    save_dir_entry.pack(pady=5, fill=tk.X)
+
+    # Mô tả về các lựa chọn Shuffle và Sequential
+    description_label = tk.Label(root, text="Choose to shuffle or select sequentially the images before saving them:", font=('Helvetica', 10))
+    description_label.pack(pady=5)
+
+    # Khung cho hai lựa chọn Shuffle và Sequential
+    option_frame = tk.Frame(root)
+    option_frame.pack(pady=5)
+
+    shuffle_var = tk.IntVar(value=1)  # Biến để lưu trạng thái xáo trộn
+
+    shuffle_radio_button = tk.Radiobutton(option_frame, text="Shuffle", variable=shuffle_var, value=1, command=toggle_shuffle)
+    shuffle_radio_button.pack(side='left', padx=5)
+
+    sequential_radio_button = tk.Radiobutton(option_frame, text="Sequential", variable=shuffle_var, value=0, command=toggle_shuffle)
+    sequential_radio_button.pack(side='left', padx=5)
+
+    random_file_count_label = tk.Label(root, text="Number of Random Files:")
+    random_file_count_label.pack(pady=5)
+
+    random_file_count_entry = tk.Entry(root, textvariable=random_file_count_var, width=10, justify='center', validate="key", validatecommand=(validate_command, '%P'))
+    random_file_count_entry.pack(pady=5)
+
+    shuffle_and_save_button = tk.Button(root, text="Shuffle", command=validate_and_process)
+    shuffle_and_save_button.pack(pady=10)
+
+    thread_count_label = tk.Label(root, text="Number of Threads:")
+    thread_count_label.pack(pady=5)
+
+    thread_count_entry = tk.Entry(root, textvariable=thread_count_var, width=5, justify='center', validate="key", validatecommand=(validate_command, '%P'))
+    thread_count_entry.pack(pady=5)
+
+    stop_button = tk.Button(root, text="Stop", command=stop_processing_func)
+    stop_button.pack(pady=5)
+
+    errors_button = tk.Button(root, textvariable=errors_var, command=show_errors)
+    errors_button.pack(pady=5)
+
+    progress_bar = ttk.Progressbar(root, variable=progress, maximum=100)
+    progress_bar.pack(pady=5, fill=tk.X)
+
+    status_label = tk.Label(root, textvariable=status_var, fg="green")
+    status_label.pack(pady=5)
+
+    center_window(root)
+    root.protocol("WM_DELETE_WINDOW", on_closing)
+    root.mainloop()
+
+if __name__ == "__main__":
+    open_image_shuffle()