927 lines
34 KiB
Python
927 lines
34 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
WImageEditTk.py
|
|
|
|
Tkinter-based GUI for WImageEdit, using wimage_core for:
|
|
- ImageMagick command building (including rotation and parametric settings).
|
|
- "Actions" (Color Pos/Neg, BW Pos/Neg).
|
|
- Granite background with adjustable scale.
|
|
- Simple per-file save/load of settings (imgedit_proc.json).
|
|
- Directory defaults.
|
|
|
|
This version:
|
|
- Shows TWO views:
|
|
Left = original (with rotation applied, no processing except resize)
|
|
Right = preview with current options applied (Pillow approximation).
|
|
- Includes parametric controls for:
|
|
- Sigmoidal contrast (contrast, midpoint)
|
|
- Sharpen (radius, amount, threshold)
|
|
- Includes rotation controls:
|
|
- None / 90 / 180 / 270 / Custom
|
|
"""
|
|
|
|
import subprocess
|
|
from pathlib import Path
|
|
from dataclasses import dataclass, field
|
|
from typing import Optional, Tuple, List
|
|
|
|
import tkinter as tk
|
|
from tkinter import ttk, filedialog, messagebox
|
|
|
|
from PIL import (
|
|
Image,
|
|
ImageTk,
|
|
ExifTags,
|
|
ImageOps,
|
|
ImageFilter,
|
|
ImageDraw,
|
|
ImageFont,
|
|
)
|
|
|
|
from wimage_core import (
|
|
EditOptions,
|
|
build_imagemagick_cmd,
|
|
build_granite_background_cmd,
|
|
apply_action_preset,
|
|
load_options_for_file,
|
|
save_options_for_file,
|
|
load_directory_defaults,
|
|
save_directory_defaults,
|
|
)
|
|
|
|
|
|
# ---------------------- helpers / file listing / EXIF ----------------------
|
|
|
|
|
|
def get_exif_datetime_original(path: Path) -> Optional[str]:
|
|
try:
|
|
img = Image.open(path)
|
|
exif = img._getexif()
|
|
if not exif:
|
|
return None
|
|
rev = {v: k for k, v in ExifTags.TAGS.items()}
|
|
dto_tag = rev.get("DateTimeOriginal")
|
|
if not dto_tag:
|
|
return None
|
|
return exif.get(dto_tag)
|
|
except Exception:
|
|
return None
|
|
|
|
|
|
def list_image_files(directory: Path) -> List[Path]:
|
|
"""
|
|
List files that are likely to be images.
|
|
|
|
Includes common RAW extensions so directories with only RAWs won't appear empty.
|
|
"""
|
|
exts = {
|
|
".jpg", ".jpeg", ".png", ".gif", ".tif", ".tiff", ".bmp",
|
|
".nef", ".cr2", ".cr3", ".arw", ".rw2", ".orf", ".dng", ".pef", ".srw",
|
|
}
|
|
return [p for p in sorted(directory.iterdir()) if p.suffix.lower() in exts]
|
|
|
|
|
|
# ----------------------------- app state ------------------------------------
|
|
|
|
|
|
@dataclass
|
|
class AppState:
|
|
directory: Optional[Path] = None
|
|
files: List[Path] = field(default_factory=list)
|
|
current_index: int = 0
|
|
base_image: Optional[Image.Image] = None # unrotated full-res PIL image
|
|
current_image: Optional[Image.Image] = None # rotated version used for crop/preview
|
|
current_photo_orig: Optional[ImageTk.PhotoImage] = None
|
|
current_photo_prev: Optional[ImageTk.PhotoImage] = None
|
|
crop_start: Optional[Tuple[int, int]] = None
|
|
crop_rect_id: Optional[int] = None
|
|
crop_box_canvas: Optional[Tuple[int, int, int, int]] = None
|
|
image_size: Optional[Tuple[int, int]] = None
|
|
canvas_size_orig: Optional[Tuple[int, int]] = None
|
|
canvas_size_prev: Optional[Tuple[int, int]] = None
|
|
|
|
|
|
# ----------------------------- main GUI -------------------------------------
|
|
|
|
|
|
class WImageEditTk(tk.Tk):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.title("WImageEditTk (Tkinter)")
|
|
|
|
self.state = AppState()
|
|
|
|
# UI variables
|
|
self.dir_var = tk.StringVar()
|
|
|
|
self.color_var = tk.BooleanVar(value=True)
|
|
self.sigmoidal_var = tk.BooleanVar(value=True)
|
|
self.sig_contrast_var = tk.DoubleVar(value=6.0)
|
|
self.sig_midpoint_var = tk.DoubleVar(value=0.5)
|
|
|
|
self.sharpen_var = tk.BooleanVar(value=True)
|
|
self.sharp_radius_var = tk.DoubleVar(value=0.0)
|
|
self.sharp_amount_var = tk.DoubleVar(value=0.5)
|
|
self.sharp_thresh_var = tk.DoubleVar(value=0.02)
|
|
|
|
self.gray_var = tk.BooleanVar(value=False)
|
|
self.invert_var = tk.BooleanVar(value=False)
|
|
|
|
self.background_var = tk.BooleanVar(value=False)
|
|
self.background_scale_var = tk.DoubleVar(value=1.1)
|
|
|
|
# Rotation
|
|
self.rotation_mode_var = tk.StringVar(value="None") # None/90/180/270/Custom
|
|
self.rotation_custom_var = tk.DoubleVar(value=0.0)
|
|
|
|
# Annotation
|
|
self.annot_size_var = tk.IntVar(value=32)
|
|
self.annot_pos_var = tk.StringVar(value="Bottom")
|
|
|
|
self.info_var = tk.StringVar(value="Select a directory to begin.")
|
|
|
|
self._build_ui()
|
|
|
|
# --------------------------- UI building ---------------------------------
|
|
|
|
def _build_ui(self):
|
|
top = ttk.Frame(self, padding=5)
|
|
top.pack(side=tk.TOP, fill=tk.X)
|
|
|
|
# Left: file list + nav
|
|
left = ttk.Frame(self, padding=5)
|
|
ttk.Label(left, text="Dir:").pack(side=tk.LEFT)
|
|
ttk.Entry(left, textvariable=self.dir_var, width=30).pack(side=tk.LEFT, padx=4)
|
|
ttk.Button(left, text="Browse...", command=self.select_directory).pack(side=tk.LEFT)
|
|
|
|
left.pack(side=tk.LEFT, fill=tk.Y)
|
|
|
|
ttk.Label(left, text="Files:").pack(anchor=tk.W)
|
|
self.file_listbox = tk.Listbox(left, width=40, height=25)
|
|
self.file_listbox.pack(fill=tk.BOTH, expand=True)
|
|
self.file_listbox.bind("<<ListboxSelect>>", self.on_file_select)
|
|
|
|
nav_frame = ttk.Frame(left)
|
|
nav_frame.pack(fill=tk.X, pady=4)
|
|
ttk.Button(nav_frame, text="Prev", command=self.prev_image).pack(side=tk.LEFT, expand=True, fill=tk.X)
|
|
ttk.Button(nav_frame, text="Next", command=self.next_image).pack(side=tk.LEFT, expand=True, fill=tk.X)
|
|
|
|
# Center: two canvases (Original + Preview)
|
|
center = ttk.Frame(self, padding=5)
|
|
center.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
|
|
|
|
canvas_labels = ttk.Frame(center)
|
|
canvas_labels.pack(fill=tk.X)
|
|
#ttk.Label(canvas_labels, text="Original").pack(side=tk.LEFT, expand=True)
|
|
ttk.Label(canvas_labels, text="Original").pack(side=tk.TOP, expand=True)
|
|
#ttk.Label(canvas_labels, text="Preview").pack(side=tk.RIGHT, expand=True)
|
|
ttk.Label(canvas_labels, text="Preview").pack(side=tk.BOTTOM, expand=True)
|
|
|
|
canvases = ttk.Frame(center)
|
|
canvases.pack(fill=tk.BOTH, expand=True)
|
|
|
|
self.canvas_orig = tk.Canvas(canvases, bg="gray", width=600, height=400)
|
|
#self.canvas_orig.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=(0, 2))
|
|
self.canvas_orig.pack(side=tk.TOP, fill=tk.BOTH, expand=True, padx=(0, 2))
|
|
|
|
self.canvas_prev = tk.Canvas(canvases, bg="gray", width=600, height=400)
|
|
#self.canvas_prev.pack(side=tk.LEFT, fill=tk.BOTH, expand=True, padx=(2, 0))
|
|
self.canvas_prev.pack(side=tk.BOTTOM, fill=tk.BOTH, expand=True, padx=(2, 0))
|
|
|
|
# Crop is defined by dragging on the ORIGINAL canvas
|
|
self.canvas_orig.bind("<ButtonPress-1>", self.on_canvas_press)
|
|
self.canvas_orig.bind("<B1-Motion>", self.on_canvas_drag)
|
|
self.canvas_orig.bind("<ButtonRelease-1>", self.on_canvas_release)
|
|
|
|
# Right: controls
|
|
right = ttk.Frame(self, padding=5)
|
|
right.pack(side=tk.RIGHT, fill=tk.Y)
|
|
|
|
# Actions frame
|
|
actions_frame = ttk.LabelFrame(right, text="Actions", padding=5)
|
|
actions_frame.pack(fill=tk.X)
|
|
|
|
ttk.Button(actions_frame, text="Color Pos",
|
|
command=lambda: self.apply_action("Color Pos")).pack(fill=tk.X, pady=1)
|
|
ttk.Button(actions_frame, text="Color Neg",
|
|
command=lambda: self.apply_action("Color Neg")).pack(fill=tk.X, pady=1)
|
|
ttk.Button(actions_frame, text="BW Pos",
|
|
command=lambda: self.apply_action("BW Pos")).pack(fill=tk.X, pady=1)
|
|
ttk.Button(actions_frame, text="BW Neg",
|
|
command=lambda: self.apply_action("BW Neg")).pack(fill=tk.X, pady=1)
|
|
|
|
# Processing options
|
|
opts_frame = ttk.LabelFrame(right, text="Processing", padding=5)
|
|
opts_frame.pack(fill=tk.X, pady=(5, 0))
|
|
|
|
ttk.Checkbutton(
|
|
opts_frame, text="Color correction",
|
|
variable=self.color_var, command=self.options_changed
|
|
).pack(anchor=tk.W)
|
|
|
|
# Sigmoidal contrast + params
|
|
ttk.Checkbutton(
|
|
opts_frame, text="Sigmoidal contrast",
|
|
variable=self.sigmoidal_var, command=self.options_changed
|
|
).pack(anchor=tk.W)
|
|
|
|
sig_frame = ttk.Frame(opts_frame)
|
|
sig_frame.pack(fill=tk.X, pady=(2, 0))
|
|
ttk.Label(sig_frame, text="C:").pack(side=tk.LEFT)
|
|
ttk.Spinbox(
|
|
sig_frame, from_=0.0, to=20.0, increment=0.5,
|
|
textvariable=self.sig_contrast_var, width=5,
|
|
command=self.options_changed
|
|
).pack(side=tk.LEFT)
|
|
ttk.Label(sig_frame, text="M:").pack(side=tk.LEFT, padx=(4, 0))
|
|
ttk.Spinbox(
|
|
sig_frame, from_=0.0, to=1.0, increment=0.05,
|
|
textvariable=self.sig_midpoint_var, width=5,
|
|
command=self.options_changed
|
|
).pack(side=tk.LEFT)
|
|
|
|
# Sharpen + params
|
|
ttk.Checkbutton(
|
|
opts_frame, text="Sharpen",
|
|
variable=self.sharpen_var, command=self.options_changed
|
|
).pack(anchor=tk.W)
|
|
|
|
sharp_frame = ttk.Frame(opts_frame)
|
|
sharp_frame.pack(fill=tk.X, pady=(2, 0))
|
|
ttk.Label(sharp_frame, text="R:").pack(side=tk.LEFT)
|
|
ttk.Spinbox(
|
|
sharp_frame, from_=0.0, to=5.0, increment=0.1,
|
|
textvariable=self.sharp_radius_var, width=5,
|
|
command=self.options_changed
|
|
).pack(side=tk.LEFT)
|
|
ttk.Label(sharp_frame, text="Amt:").pack(side=tk.LEFT, padx=(4, 0))
|
|
ttk.Spinbox(
|
|
sharp_frame, from_=0.0, to=5.0, increment=0.1,
|
|
textvariable=self.sharp_amount_var, width=5,
|
|
command=self.options_changed
|
|
).pack(side=tk.LEFT)
|
|
ttk.Label(sharp_frame, text="Thr:").pack(side=tk.LEFT, padx=(4, 0))
|
|
ttk.Spinbox(
|
|
sharp_frame, from_=0.0, to=1.0, increment=0.01,
|
|
textvariable=self.sharp_thresh_var, width=5,
|
|
command=self.options_changed
|
|
).pack(side=tk.LEFT)
|
|
|
|
ttk.Checkbutton(
|
|
opts_frame, text="Grayscale",
|
|
variable=self.gray_var, command=self.options_changed
|
|
).pack(anchor=tk.W)
|
|
ttk.Checkbutton(
|
|
opts_frame, text="Invert (neg)",
|
|
variable=self.invert_var, command=self.options_changed
|
|
).pack(anchor=tk.W)
|
|
|
|
ttk.Checkbutton(
|
|
opts_frame, text="Granite background",
|
|
variable=self.background_var, command=self.options_changed
|
|
).pack(anchor=tk.W)
|
|
scale_row = ttk.Frame(opts_frame)
|
|
scale_row.pack(fill=tk.X, pady=(4, 0))
|
|
ttk.Label(scale_row, text="Background scale:").pack(side=tk.LEFT)
|
|
ttk.Spinbox(
|
|
scale_row,
|
|
from_=1.0,
|
|
to=2.0,
|
|
increment=0.05,
|
|
textvariable=self.background_scale_var,
|
|
width=6,
|
|
format="%.2f",
|
|
command=self.options_changed,
|
|
).pack(side=tk.LEFT, padx=4)
|
|
ttk.Label(scale_row, text="(1.1 ≈ 10% border)").pack(side=tk.LEFT)
|
|
|
|
# Rotation controls
|
|
rot_frame = ttk.LabelFrame(right, text="Rotation", padding=5)
|
|
rot_frame.pack(fill=tk.X, pady=5)
|
|
|
|
def rot_rb(text, value):
|
|
return ttk.Radiobutton(
|
|
rot_frame, text=text, value=value,
|
|
variable=self.rotation_mode_var, command=self.rotation_changed
|
|
)
|
|
|
|
rot_rb("None", "None").pack(anchor=tk.W)
|
|
rot_rb("90°", "90").pack(anchor=tk.W)
|
|
rot_rb("180°", "180").pack(anchor=tk.W)
|
|
rot_rb("270°", "270").pack(anchor=tk.W)
|
|
|
|
custom_row = ttk.Frame(rot_frame)
|
|
custom_row.pack(fill=tk.X, pady=(2, 0))
|
|
ttk.Radiobutton(
|
|
custom_row, text="Custom:", value="Custom",
|
|
variable=self.rotation_mode_var, command=self.rotation_changed
|
|
).pack(side=tk.LEFT)
|
|
ttk.Spinbox(
|
|
custom_row, from_=-360.0, to=360.0, increment=1.0,
|
|
textvariable=self.rotation_custom_var, width=6,
|
|
command=self.rotation_changed,
|
|
).pack(side=tk.LEFT, padx=4)
|
|
|
|
# Annotation
|
|
annot_frame = ttk.LabelFrame(right, text="Text annotation", padding=5)
|
|
annot_frame.pack(fill=tk.X, pady=5)
|
|
|
|
ttk.Label(annot_frame, text="Text:").pack(anchor=tk.W)
|
|
self.annot_text = tk.Text(annot_frame, width=30, height=4)
|
|
self.annot_text.pack(fill=tk.X)
|
|
self.annot_text.bind("<<Modified>>", self.on_annot_modified)
|
|
|
|
ttk.Label(annot_frame, text="Font size:").pack(anchor=tk.W)
|
|
ttk.Spinbox(
|
|
annot_frame,
|
|
from_=8,
|
|
to=120,
|
|
textvariable=self.annot_size_var,
|
|
width=5,
|
|
command=self.options_changed,
|
|
).pack(anchor=tk.W)
|
|
|
|
ttk.Label(annot_frame, text="Position:").pack(anchor=tk.W)
|
|
ttk.Radiobutton(
|
|
annot_frame, text="Top", value="Top",
|
|
variable=self.annot_pos_var, command=self.options_changed
|
|
).pack(anchor=tk.W)
|
|
ttk.Radiobutton(
|
|
annot_frame, text="Center", value="Center",
|
|
variable=self.annot_pos_var, command=self.options_changed
|
|
).pack(anchor=tk.W)
|
|
ttk.Radiobutton(
|
|
annot_frame, text="Bottom", value="Bottom",
|
|
variable=self.annot_pos_var, command=self.options_changed
|
|
).pack(anchor=tk.W)
|
|
|
|
# Directory defaults
|
|
defaults_frame = ttk.LabelFrame(right, text="Directory defaults", padding=5)
|
|
defaults_frame.pack(fill=tk.X, pady=5)
|
|
ttk.Button(
|
|
defaults_frame, text="Set from current image",
|
|
command=self.set_directory_defaults_from_current
|
|
).pack(fill=tk.X)
|
|
|
|
# Actions buttons
|
|
action_frame = ttk.Frame(right)
|
|
action_frame.pack(fill=tk.X, pady=10)
|
|
ttk.Button(action_frame, text="Process", command=self.process_current).pack(fill=tk.X)
|
|
ttk.Button(action_frame, text="Quit", command=self.destroy).pack(fill=tk.X, pady=(5, 0))
|
|
|
|
ttk.Label(
|
|
right, textvariable=self.info_var,
|
|
wraplength=220, justify=tk.LEFT
|
|
).pack(fill=tk.X, pady=5)
|
|
|
|
# ------------------------------ directory & files ------------------------
|
|
|
|
def select_directory(self):
|
|
dirname = filedialog.askdirectory(title="Select image directory")
|
|
if not dirname:
|
|
return
|
|
self.dir_var.set(dirname)
|
|
self.state.directory = Path(dirname)
|
|
self.load_files()
|
|
|
|
def load_files(self):
|
|
if not self.state.directory:
|
|
return
|
|
self.state.files = list_image_files(self.state.directory)
|
|
self.file_listbox.delete(0, tk.END)
|
|
for p in self.state.files:
|
|
self.file_listbox.insert(tk.END, p.name)
|
|
if self.state.files:
|
|
self.state.current_index = 0
|
|
self.file_listbox.selection_set(0)
|
|
self.load_image(0)
|
|
else:
|
|
self.state.current_index = 0
|
|
self.canvas_orig.delete("all")
|
|
self.canvas_prev.delete("all")
|
|
self.info_var.set("No image files found in directory.")
|
|
|
|
def on_file_select(self, event=None):
|
|
sel = self.file_listbox.curselection()
|
|
if not sel:
|
|
return
|
|
self.load_image(sel[0])
|
|
|
|
def load_image(self, index: int):
|
|
if index < 0 or index >= len(self.state.files):
|
|
return
|
|
self.state.current_index = index
|
|
path = self.state.files[index]
|
|
try:
|
|
img = Image.open(path)
|
|
self.state.base_image = img
|
|
self.state.image_size = img.size
|
|
|
|
# Reset crop
|
|
self.state.crop_rect_id = None
|
|
self.state.crop_box_canvas = None
|
|
|
|
dto = get_exif_datetime_original(path)
|
|
info = f"{path.name}\n{img.size[0]}x{img.size[1]}"
|
|
if dto:
|
|
info += f"\nEXIF DateTimeOriginal: {dto}"
|
|
|
|
# Attempt to restore saved options or directory defaults
|
|
self.restore_options_for_file(path)
|
|
|
|
# Build rotated original + preview
|
|
self.rebuild_original_and_preview(reset_crop=True)
|
|
|
|
self.info_var.set(info)
|
|
|
|
except Exception as e:
|
|
messagebox.showerror("Error", f"Failed to load image:\n{e}")
|
|
|
|
def display_on_canvas(self, canvas: tk.Canvas, img: Image.Image, is_original: bool):
|
|
"""Scale and display img on the given canvas, center it."""
|
|
canvas_w = canvas.winfo_width() or 400
|
|
canvas_h = canvas.winfo_height() or 600
|
|
scale = min(canvas_w / img.size[0], canvas_h / img.size[1])
|
|
new_size = (max(1, int(img.size[0] * scale)), max(1, int(img.size[1] * scale)))
|
|
disp_img = img.resize(new_size, Image.LANCZOS)
|
|
|
|
x0 = (canvas_w - new_size[0]) // 2
|
|
y0 = (canvas_h - new_size[1]) // 2
|
|
|
|
photo = ImageTk.PhotoImage(disp_img)
|
|
canvas.delete("all")
|
|
canvas.create_image(x0, y0, anchor=tk.NW, image=photo)
|
|
canvas.image = photo # prevent GC
|
|
|
|
if is_original:
|
|
self.state.canvas_size_orig = new_size
|
|
self.state.current_photo_orig = photo
|
|
else:
|
|
self.state.canvas_size_prev = new_size
|
|
self.state.current_photo_prev = photo
|
|
|
|
def prev_image(self):
|
|
if not self.state.files:
|
|
return
|
|
idx = (self.state.current_index - 1) % len(self.state.files)
|
|
self.file_listbox.selection_clear(0, tk.END)
|
|
self.file_listbox.selection_set(idx)
|
|
self.load_image(idx)
|
|
|
|
def next_image(self):
|
|
if not self.state.files:
|
|
return
|
|
idx = (self.state.current_index + 1) % len(self.state.files)
|
|
self.file_listbox.selection_clear(0, tk.END)
|
|
self.file_listbox.selection_set(idx)
|
|
self.load_image(idx)
|
|
|
|
# ----------------------------- canvas / cropping -------------------------
|
|
|
|
def on_canvas_press(self, event):
|
|
self.state.crop_start = (event.x, event.y)
|
|
if self.state.crop_rect_id is not None:
|
|
self.canvas_orig.delete(self.state.crop_rect_id)
|
|
self.state.crop_rect_id = None
|
|
|
|
def on_canvas_drag(self, event):
|
|
if not self.state.crop_start:
|
|
return
|
|
x0, y0 = self.state.crop_start
|
|
x1, y1 = event.x, event.y
|
|
if self.state.crop_rect_id is None:
|
|
self.state.crop_rect_id = self.canvas_orig.create_rectangle(
|
|
x0, y0, x1, y1, outline="yellow", width=2
|
|
)
|
|
else:
|
|
self.canvas_orig.coords(self.state.crop_rect_id, x0, y0, x1, y1)
|
|
self.state.crop_box_canvas = (x0, y0, x1, y1)
|
|
self.update_preview()
|
|
|
|
def on_canvas_release(self, event):
|
|
pass
|
|
|
|
def canvas_to_image_coords(self, x, y) -> Tuple[int, int]:
|
|
if not self.state.current_image or not self.state.canvas_size_orig:
|
|
return 0, 0
|
|
img_w, img_h = self.state.current_image.size
|
|
disp_w, disp_h = self.state.canvas_size_orig
|
|
canvas_w = self.canvas_orig.winfo_width() or disp_w
|
|
canvas_h = self.canvas_orig.winfo_height() or disp_h
|
|
|
|
x0 = (canvas_w - disp_w) // 2
|
|
y0 = (canvas_h - disp_h) // 2
|
|
|
|
x_clamped = min(max(x, x0), x0 + disp_w)
|
|
y_clamped = min(max(y, y0), y0 + disp_h)
|
|
|
|
rel_x = x_clamped - x0
|
|
rel_y = y_clamped - y0
|
|
scale_x = img_w / disp_w
|
|
scale_y = img_h / disp_h
|
|
img_x = int(rel_x * scale_x)
|
|
img_y = int(rel_y * scale_y)
|
|
return img_x, img_y
|
|
|
|
def get_crop_box_image_coords(self) -> Optional[Tuple[int, int, int, int]]:
|
|
if not self.state.crop_box_canvas:
|
|
return None
|
|
x0c, y0c, x1c, y1c = self.state.crop_box_canvas
|
|
x0i, y0i = self.canvas_to_image_coords(x0c, y0c)
|
|
x1i, y1i = self.canvas_to_image_coords(x1c, y1c)
|
|
x1i, x2i = sorted((x0i, x1i))
|
|
y1i, y2i = sorted((y0i, y1i))
|
|
if x2i <= x1i or y2i <= y1i:
|
|
return None
|
|
return (x1i, y1i, x2i, y2i)
|
|
|
|
# -------------------------- rotation helpers -----------------------------
|
|
|
|
def get_rotation_degrees(self) -> float:
|
|
mode = self.rotation_mode_var.get()
|
|
if mode == "None":
|
|
return 0.0
|
|
if mode == "90":
|
|
return 90.0
|
|
if mode == "180":
|
|
return 180.0
|
|
if mode == "270":
|
|
return 270.0
|
|
# Custom
|
|
try:
|
|
return float(self.rotation_custom_var.get())
|
|
except Exception:
|
|
return 0.0
|
|
|
|
def set_rotation_ui_from_degrees(self, deg: float):
|
|
# Normalize to [0,360)
|
|
d = deg % 360
|
|
if abs(d) < 0.01 or abs(d - 360) < 0.01:
|
|
self.rotation_mode_var.set("None")
|
|
self.rotation_custom_var.set(0.0)
|
|
elif abs(d - 90) < 0.01:
|
|
self.rotation_mode_var.set("90")
|
|
elif abs(d - 180) < 0.01:
|
|
self.rotation_mode_var.set("180")
|
|
elif abs(d - 270) < 0.01:
|
|
self.rotation_mode_var.set("270")
|
|
else:
|
|
self.rotation_mode_var.set("Custom")
|
|
self.rotation_custom_var.set(deg)
|
|
|
|
def rotation_changed(self):
|
|
"""
|
|
When rotation changes, we need to rebuild the original and preview,
|
|
and reset the crop (since the coordinates are no longer valid).
|
|
"""
|
|
self.state.crop_start = None
|
|
if self.state.crop_rect_id is not None:
|
|
self.canvas_orig.delete(self.state.crop_rect_id)
|
|
self.state.crop_rect_id = None
|
|
self.state.crop_box_canvas = None
|
|
self.rebuild_original_and_preview(reset_crop=True)
|
|
|
|
# -------------------------- actions & options ----------------------------
|
|
|
|
def apply_action(self, action_name: str):
|
|
"""
|
|
Apply an action preset by updating the checkboxes/params to match.
|
|
"""
|
|
opts = self.gather_options_from_ui(include_crop=False)
|
|
apply_action_preset(opts, action_name)
|
|
|
|
# Sync UI from modified options (except crop)
|
|
self.color_var.set(opts.color_correction)
|
|
|
|
self.sigmoidal_var.set(opts.sigmoidal)
|
|
self.sig_contrast_var.set(opts.sigmoidal_contrast)
|
|
self.sig_midpoint_var.set(opts.sigmoidal_midpoint)
|
|
|
|
self.sharpen_var.set(opts.sharpen)
|
|
self.sharp_radius_var.set(opts.sharpen_radius)
|
|
self.sharp_amount_var.set(opts.sharpen_amount)
|
|
self.sharp_thresh_var.set(opts.sharpen_threshold)
|
|
|
|
self.gray_var.set(opts.grayscale)
|
|
self.invert_var.set(opts.invert)
|
|
self.background_var.set(opts.use_background)
|
|
self.background_scale_var.set(opts.background_scale)
|
|
|
|
self.rebuild_original_and_preview(reset_crop=False)
|
|
|
|
def gather_options_from_ui(self, include_crop: bool = True) -> EditOptions:
|
|
"""
|
|
Construct an EditOptions instance from current UI state.
|
|
"""
|
|
crop_box = self.get_crop_box_image_coords() if include_crop else None
|
|
|
|
opts = EditOptions(
|
|
crop_box=crop_box,
|
|
rotation_degrees=self.get_rotation_degrees(),
|
|
color_correction=self.color_var.get(),
|
|
sigmoidal=self.sigmoidal_var.get(),
|
|
sigmoidal_contrast=self.sig_contrast_var.get(),
|
|
sigmoidal_midpoint=self.sig_midpoint_var.get(),
|
|
sharpen=self.sharpen_var.get(),
|
|
sharpen_radius=self.sharp_radius_var.get(),
|
|
sharpen_amount=self.sharp_amount_var.get(),
|
|
sharpen_threshold=self.sharp_thresh_var.get(),
|
|
grayscale=self.gray_var.get(),
|
|
invert=self.invert_var.get(),
|
|
use_background=self.background_var.get(),
|
|
background_scale=self.background_scale_var.get(),
|
|
annotation_text=self.annot_text.get("1.0", tk.END).strip(),
|
|
annotation_pos=self.annot_pos_var.get(),
|
|
annotation_size=self.annot_size_var.get(),
|
|
)
|
|
return opts
|
|
|
|
def restore_options_for_file(self, path: Path) -> None:
|
|
"""
|
|
Try to load saved options for the given file, else fall back to
|
|
directory defaults, and update the UI.
|
|
"""
|
|
if not self.state.directory:
|
|
return
|
|
|
|
saved = load_options_for_file(self.state.directory, path)
|
|
if not saved:
|
|
saved = load_directory_defaults(self.state.directory)
|
|
if not saved:
|
|
# No prior settings; leave UI as-is.
|
|
return
|
|
|
|
self.color_var.set(saved.color_correction)
|
|
|
|
self.sigmoidal_var.set(saved.sigmoidal)
|
|
self.sig_contrast_var.set(saved.sigmoidal_contrast)
|
|
self.sig_midpoint_var.set(saved.sigmoidal_midpoint)
|
|
|
|
self.sharpen_var.set(saved.sharpen)
|
|
self.sharp_radius_var.set(saved.sharpen_radius)
|
|
self.sharp_amount_var.set(saved.sharpen_amount)
|
|
self.sharp_thresh_var.set(saved.sharpen_threshold)
|
|
|
|
self.gray_var.set(saved.grayscale)
|
|
self.invert_var.set(saved.invert)
|
|
self.background_var.set(saved.use_background)
|
|
self.background_scale_var.set(saved.background_scale)
|
|
|
|
self.set_rotation_ui_from_degrees(saved.rotation_degrees)
|
|
|
|
self.annot_pos_var.set(saved.annotation_pos)
|
|
self.annot_size_var.set(saved.annotation_size)
|
|
self.annot_text.delete("1.0", tk.END)
|
|
if saved.annotation_text:
|
|
self.annot_text.insert("1.0", saved.annotation_text)
|
|
|
|
def set_directory_defaults_from_current(self):
|
|
"""
|
|
Save the current UI options as directory defaults.
|
|
"""
|
|
if not self.state.directory:
|
|
messagebox.showerror("Error", "No directory selected.")
|
|
return
|
|
opts = self.gather_options_from_ui(include_crop=False)
|
|
save_directory_defaults(self.state.directory, opts)
|
|
messagebox.showinfo("Directory defaults", "Defaults saved for this directory.")
|
|
|
|
# ---------------------- preview rendering (Pillow) -----------------------
|
|
|
|
def rebuild_original_and_preview(self, reset_crop: bool = False):
|
|
"""
|
|
Rebuild the rotated original and the preview from base_image + options.
|
|
"""
|
|
if self.state.base_image is None:
|
|
return
|
|
opts = self.gather_options_from_ui(include_crop=False)
|
|
# Rotate base image according to opts
|
|
rotated = self.state.base_image.rotate(opts.rotation_degrees, expand=True)
|
|
self.state.current_image = rotated
|
|
|
|
# Original view: rotated, no processing except resize
|
|
self.display_on_canvas(self.canvas_orig, rotated, is_original=True)
|
|
|
|
# Reset crop if asked
|
|
if reset_crop:
|
|
self.state.crop_box_canvas = None
|
|
self.state.crop_start = None
|
|
if self.state.crop_rect_id is not None:
|
|
self.canvas_orig.delete(self.state.crop_rect_id)
|
|
self.state.crop_rect_id = None
|
|
|
|
# Preview: rotated + processing (including crop if present)
|
|
self.update_preview()
|
|
|
|
def apply_preview_effects(self, base_img: Image.Image, opts: EditOptions) -> Image.Image:
|
|
"""
|
|
Apply a subset of the edit options in-memory to generate a preview image.
|
|
This approximates the IM pipeline but doesn't have to be pixel-identical.
|
|
|
|
NOTE: Rotation is already baked into base_img; we do NOT apply it again here.
|
|
"""
|
|
img = base_img
|
|
|
|
# Crop
|
|
if opts.crop_box is not None:
|
|
x1, y1, x2, y2 = opts.crop_box
|
|
img = img.crop((x1, y1, x2, y2))
|
|
|
|
# Grayscale
|
|
if opts.grayscale:
|
|
img = img.convert("L").convert("RGB")
|
|
|
|
# Invert
|
|
if opts.invert:
|
|
img = ImageOps.invert(img)
|
|
|
|
# Sharpen (approximate IM unsharp)
|
|
if opts.sharpen:
|
|
radius = max(0.0, float(opts.sharpen_radius))
|
|
amount = max(0.0, float(opts.sharpen_amount))
|
|
thresh = max(0.0, float(opts.sharpen_threshold))
|
|
percent = int(amount * 100.0)
|
|
threshold = int(thresh * 255.0)
|
|
img = img.filter(ImageFilter.UnsharpMask(radius=radius or 1.0,
|
|
percent=percent or 150,
|
|
threshold=threshold))
|
|
|
|
# Simple annotation
|
|
if opts.annotation_text.strip():
|
|
draw = ImageDraw.Draw(img)
|
|
text = opts.annotation_text
|
|
try:
|
|
font = ImageFont.truetype("DejaVuSans.ttf", opts.annotation_size)
|
|
except Exception:
|
|
font = ImageFont.load_default()
|
|
|
|
# Measure text size compatible with older Pillow
|
|
try:
|
|
bbox = draw.textbbox((0, 0), text, font=font)
|
|
text_w = bbox[2] - bbox[0]
|
|
text_h = bbox[3] - bbox[1]
|
|
except AttributeError:
|
|
text_w, text_h = font.getsize(text)
|
|
|
|
w, h = img.size
|
|
|
|
pos_name = opts.annotation_pos
|
|
if pos_name == "Top":
|
|
x = (w - text_w) // 2
|
|
y = int(0.02 * h)
|
|
elif pos_name == "Center":
|
|
x = (w - text_w) // 2
|
|
y = (h - text_h) // 2
|
|
else: # Bottom
|
|
x = (w - text_w) // 2
|
|
y = int(h - text_h - 0.02 * h)
|
|
|
|
# simple text with outline
|
|
outline = 2
|
|
for dx in (-outline, outline):
|
|
for dy in (-outline, outline):
|
|
draw.text((x + dx, y + dy), text, font=font, fill="black")
|
|
draw.text((x, y), text, font=font, fill="white")
|
|
|
|
# Simple granite-like background preview
|
|
if opts.use_background:
|
|
subject = img
|
|
scale = max(1.0, float(opts.background_scale))
|
|
bg_w = max(1, int(subject.width * scale))
|
|
bg_h = max(1, int(subject.height * scale))
|
|
try:
|
|
noise = Image.effect_noise((bg_w, bg_h), 64)
|
|
bg = noise.filter(ImageFilter.GaussianBlur(radius=1))
|
|
except Exception:
|
|
bg = Image.new("L", (bg_w, bg_h), 128)
|
|
if opts.grayscale:
|
|
bg = bg.convert("L")
|
|
bg = bg.convert("RGB")
|
|
x = (bg_w - subject.width) // 2
|
|
y = (bg_h - subject.height) // 2
|
|
bg.paste(subject, (x, y))
|
|
img = bg
|
|
|
|
return img
|
|
|
|
def update_preview(self):
|
|
"""
|
|
Recompute and display the preview image (processed) on the right canvas.
|
|
"""
|
|
if not self.state.current_image:
|
|
return
|
|
opts = self.gather_options_from_ui(include_crop=True)
|
|
preview_img = self.apply_preview_effects(self.state.current_image.copy(), opts)
|
|
self.display_on_canvas(self.canvas_prev, preview_img, is_original=False)
|
|
|
|
def options_changed(self):
|
|
"""Callback used by various controls to trigger preview update."""
|
|
self.update_preview()
|
|
|
|
def on_annot_modified(self, event):
|
|
"""Handle <<Modified>> event from the annotation Text widget."""
|
|
self.annot_text.edit_modified(False)
|
|
self.update_preview()
|
|
|
|
# -------------------------- processing (IM) ------------------------------
|
|
|
|
def process_current(self):
|
|
if not self.state.files:
|
|
return
|
|
path = self.state.files[self.state.current_index]
|
|
if not self.state.directory:
|
|
messagebox.showerror("Error", "Internal error: no directory set.")
|
|
return
|
|
|
|
opts = self.gather_options_from_ui(include_crop=True)
|
|
dest = path.with_name(path.stem + "_edit.jpg")
|
|
|
|
use_bg = opts.use_background
|
|
if not use_bg:
|
|
cmd = build_imagemagick_cmd(path, dest, opts)
|
|
if not self.confirm_and_run(cmd):
|
|
return
|
|
else:
|
|
tmp_subject = path.with_name(path.stem + "_tmp_subject.jpg")
|
|
|
|
# First pass: main edits, no background
|
|
opts_main = EditOptions(
|
|
crop_box=opts.crop_box,
|
|
rotation_degrees=opts.rotation_degrees,
|
|
color_correction=opts.color_correction,
|
|
sigmoidal=opts.sigmoidal,
|
|
sigmoidal_contrast=opts.sigmoidal_contrast,
|
|
sigmoidal_midpoint=opts.sigmoidal_midpoint,
|
|
sharpen=opts.sharpen,
|
|
sharpen_radius=opts.sharpen_radius,
|
|
sharpen_amount=opts.sharpen_amount,
|
|
sharpen_threshold=opts.sharpen_threshold,
|
|
grayscale=opts.grayscale,
|
|
invert=opts.invert,
|
|
use_background=False,
|
|
background_scale=opts.background_scale,
|
|
annotation_text=opts.annotation_text,
|
|
annotation_pos=opts.annotation_pos,
|
|
annotation_size=opts.annotation_size,
|
|
extra_args=opts.extra_args,
|
|
)
|
|
|
|
cmd1 = build_imagemagick_cmd(path, tmp_subject, opts_main)
|
|
print(cmd1)
|
|
if not self.confirm_and_run(cmd1):
|
|
return
|
|
|
|
# Determine subject size for background scaling
|
|
try:
|
|
with Image.open(tmp_subject) as s_img:
|
|
subject_size = s_img.size
|
|
except Exception as e:
|
|
messagebox.showerror("Error", f"Failed to open temp subject:\n{e}")
|
|
return
|
|
|
|
cmd2 = build_granite_background_cmd(tmp_subject, dest, opts, subject_size)
|
|
print(cmd2)
|
|
if not self.confirm_and_run(cmd2):
|
|
return
|
|
|
|
# Optionally clean up tmp_subject
|
|
try:
|
|
tmp_subject.unlink()
|
|
except Exception:
|
|
pass
|
|
|
|
# On success, save the options for this file
|
|
save_options_for_file(self.state.directory, path, opts)
|
|
messagebox.showinfo("Done", f"Created {dest.name}")
|
|
|
|
def confirm_and_run(self, cmd: List[str]) -> bool:
|
|
"""
|
|
Ask for confirmation, then run the given command.
|
|
Returns True on success, False on failure or cancel.
|
|
"""
|
|
if not messagebox.askyesno(
|
|
"Run ImageMagick",
|
|
"About to run:\n\n" + " ".join(cmd) + "\n\nProceed?",
|
|
):
|
|
return False
|
|
try:
|
|
subprocess.run(cmd, check=True)
|
|
return True
|
|
except subprocess.CalledProcessError as e:
|
|
messagebox.showerror("Error", f"Processing failed:\n{e}")
|
|
return False
|
|
|
|
|
|
# ------------------------------- main ---------------------------------------
|
|
|
|
|
|
def main():
|
|
print("start ...")
|
|
app = WImageEditTk()
|
|
app.mainloop()
|
|
print("done.")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|