232 lines
8.6 KiB
Python
232 lines
8.6 KiB
Python
"""Image loading, processing, and statistics logic."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import colorsys
|
|
from pathlib import Path
|
|
from typing import Iterable, Tuple
|
|
|
|
from tkinter import filedialog, messagebox
|
|
|
|
from PIL import Image, ImageDraw, ImageTk
|
|
|
|
from .constants import IMAGES_DIR, PREVIEW_MAX_SIZE
|
|
|
|
|
|
class ImageProcessingMixin:
|
|
"""Handles all image related operations."""
|
|
|
|
image_path: Path | None
|
|
orig_img: Image.Image | None
|
|
preview_img: Image.Image | None
|
|
preview_tk: ImageTk.PhotoImage | None
|
|
overlay_tk: ImageTk.PhotoImage | None
|
|
|
|
def load_image(self) -> None:
|
|
default_dir = IMAGES_DIR if IMAGES_DIR.exists() else Path.cwd()
|
|
path = filedialog.askopenfilename(
|
|
title="Bild wählen",
|
|
filetypes=[("Images", "*.webp *.png *.jpg *.jpeg *.bmp")],
|
|
initialdir=str(default_dir),
|
|
)
|
|
if not path:
|
|
return
|
|
self.image_path = Path(path)
|
|
try:
|
|
image = Image.open(path).convert("RGBA")
|
|
except Exception as exc:
|
|
messagebox.showerror("Fehler", f"Bild konnte nicht geladen werden: {exc}")
|
|
return
|
|
self.orig_img = image
|
|
self.prepare_preview()
|
|
self.update_preview()
|
|
self.status.config(
|
|
text=f"Geladen: {self.image_path.name} — {self.orig_img.width}x{self.orig_img.height}"
|
|
)
|
|
|
|
def save_overlay(self) -> None:
|
|
if self.orig_img is None:
|
|
messagebox.showinfo("Info", "Kein Bild geladen.")
|
|
return
|
|
if self.preview_img is None:
|
|
messagebox.showerror("Fehler", "Keine Preview vorhanden.")
|
|
return
|
|
|
|
overlay = self._build_overlay_image(
|
|
self.orig_img,
|
|
self.exclude_rects,
|
|
alpha=int(self.alpha.get()),
|
|
scale_from_preview=self.preview_img.size,
|
|
is_purple_fn=self.is_purple_pixel,
|
|
)
|
|
merged = Image.alpha_composite(self.orig_img.convert("RGBA"), overlay)
|
|
|
|
out_path = filedialog.asksaveasfilename(
|
|
defaultextension=".png", filetypes=[("PNG", "*.png")], title="Overlay speichern als"
|
|
)
|
|
if not out_path:
|
|
return
|
|
merged.save(out_path)
|
|
messagebox.showinfo("Gespeichert", f"Overlay gespeichert: {out_path}")
|
|
|
|
def prepare_preview(self) -> None:
|
|
if self.orig_img is None:
|
|
return
|
|
width, height = self.orig_img.size
|
|
max_w, max_h = PREVIEW_MAX_SIZE
|
|
scale = min(max_w / width, max_h / height, 1.0)
|
|
size = (max(1, int(width * scale)), max(1, int(height * scale)))
|
|
self.preview_img = self.orig_img.resize(size, Image.LANCZOS)
|
|
self.preview_tk = ImageTk.PhotoImage(self.preview_img)
|
|
self.canvas_orig.delete("all")
|
|
self.canvas_orig.config(width=size[0], height=size[1])
|
|
self.canvas_overlay.config(width=size[0], height=size[1])
|
|
self.canvas_orig.create_image(0, 0, anchor="nw", image=self.preview_tk)
|
|
|
|
def update_preview(self) -> None:
|
|
if self.preview_img is None:
|
|
return
|
|
merged = self.create_overlay_preview()
|
|
if merged is None:
|
|
return
|
|
self.overlay_tk = ImageTk.PhotoImage(merged)
|
|
self.canvas_overlay.delete("all")
|
|
self.canvas_overlay.create_image(0, 0, anchor="nw", image=self.overlay_tk)
|
|
|
|
self.canvas_orig.delete("all")
|
|
self.canvas_orig.create_image(0, 0, anchor="nw", image=self.preview_tk)
|
|
for (x0, y0, x1, y1) in self.exclude_rects:
|
|
self.canvas_orig.create_rectangle(x0, y0, x1, y1, outline="yellow", width=3)
|
|
|
|
stats = self.compute_stats_preview()
|
|
if stats:
|
|
p_all, t_all = stats["all"]
|
|
p_keep, t_keep = stats["keep"]
|
|
p_ex, t_ex = stats["excl"]
|
|
r_with = (p_keep / t_keep * 100) if t_keep else 0.0
|
|
r_no = (p_all / t_all * 100) if t_all else 0.0
|
|
excl_share = (t_ex / t_all * 100) if t_all else 0.0
|
|
excl_purp = (p_ex / t_ex * 100) if t_ex else 0.0
|
|
self.ratio_label.config(
|
|
text=(
|
|
f"Purple (mit Excludes): {r_with:.2f}% | "
|
|
f"Purple (ohne Excludes): {r_no:.2f}% | "
|
|
f"Excluded: {excl_share:.2f}% vom Bild, davon {excl_purp:.2f}% purple"
|
|
)
|
|
)
|
|
|
|
bg = "#0f0f10" if self.theme == "dark" else "#1e1e1e"
|
|
self.canvas_orig.configure(bg=bg)
|
|
self.canvas_overlay.configure(bg=bg)
|
|
|
|
def create_overlay_preview(self) -> Image.Image | None:
|
|
if self.preview_img is None:
|
|
return None
|
|
base = self.preview_img.convert("RGBA")
|
|
overlay = Image.new("RGBA", base.size, (0, 0, 0, 0))
|
|
draw = ImageDraw.Draw(overlay)
|
|
pixels = base.load()
|
|
width, height = base.size
|
|
alpha = int(self.alpha.get())
|
|
for y in range(height):
|
|
for x in range(width):
|
|
if self._is_excluded(x, y):
|
|
continue
|
|
r, g, b, a = pixels[x, y]
|
|
if a == 0:
|
|
continue
|
|
if self.is_purple_pixel(r, g, b):
|
|
draw.point((x, y), fill=(255, 0, 0, alpha))
|
|
merged = Image.alpha_composite(base, overlay)
|
|
for (x0, y0, x1, y1) in self.exclude_rects:
|
|
ImageDraw.Draw(merged).rectangle([x0, y0, x1, y1], outline=(255, 215, 0, 200), width=3)
|
|
return merged
|
|
|
|
def compute_stats_preview(self):
|
|
if self.preview_img is None:
|
|
return None
|
|
px = self.preview_img.convert("RGBA").load()
|
|
width, height = self.preview_img.size
|
|
purple_all = total_all = 0
|
|
purple_keep = total_keep = 0
|
|
purple_excl = total_excl = 0
|
|
for y in range(height):
|
|
for x in range(width):
|
|
r, g, b, a = px[x, y]
|
|
if a == 0:
|
|
continue
|
|
is_excluded = self._is_excluded(x, y)
|
|
total_all += 1
|
|
if self.is_purple_pixel(r, g, b):
|
|
purple_all += 1
|
|
if not is_excluded:
|
|
total_keep += 1
|
|
if self.is_purple_pixel(r, g, b):
|
|
purple_keep += 1
|
|
else:
|
|
total_excl += 1
|
|
if self.is_purple_pixel(r, g, b):
|
|
purple_excl += 1
|
|
return {"all": (purple_all, total_all), "keep": (purple_keep, total_keep), "excl": (purple_excl, total_excl)}
|
|
|
|
def is_purple_pixel(self, r, g, b) -> bool:
|
|
h, s, v = colorsys.rgb_to_hsv(r / 255.0, g / 255.0, b / 255.0)
|
|
hue = h * 360.0
|
|
hmin = float(self.hue_min.get())
|
|
hmax = float(self.hue_max.get())
|
|
smin = float(self.sat_min.get()) / 100.0
|
|
vmin = float(self.val_min.get()) / 100.0
|
|
vmax = float(self.val_max.get()) / 100.0
|
|
if hmin <= hmax:
|
|
hue_ok = hmin <= hue <= hmax
|
|
else:
|
|
hue_ok = (hue >= hmin) or (hue <= hmax)
|
|
return hue_ok and (s >= smin) and (v >= vmin) and (v <= vmax)
|
|
|
|
def _is_excluded(self, x: int, y: int) -> bool:
|
|
return any(x0 <= x <= x1 and y0 <= y <= y1 for (x0, y0, x1, y1) in self.exclude_rects)
|
|
|
|
@staticmethod
|
|
def _map_preview_excludes(
|
|
excludes: Iterable[Tuple[int, int, int, int]],
|
|
orig_size: Tuple[int, int],
|
|
preview_size: Tuple[int, int],
|
|
) -> list[Tuple[int, int, int, int]]:
|
|
scale_x = orig_size[0] / preview_size[0]
|
|
scale_y = orig_size[1] / preview_size[1]
|
|
mapped = []
|
|
for x0, y0, x1, y1 in excludes:
|
|
mapped.append(
|
|
(int(x0 * scale_x), int(y0 * scale_y), int(x1 * scale_x), int(y1 * scale_y))
|
|
)
|
|
return mapped
|
|
|
|
@classmethod
|
|
def _build_overlay_image(
|
|
cls,
|
|
image: Image.Image,
|
|
excludes_preview: Iterable[Tuple[int, int, int, int]],
|
|
*,
|
|
alpha: int,
|
|
scale_from_preview: Tuple[int, int],
|
|
is_purple_fn,
|
|
) -> Image.Image:
|
|
overlay = Image.new("RGBA", image.size, (0, 0, 0, 0))
|
|
draw = ImageDraw.Draw(overlay)
|
|
pixels = image.load()
|
|
width, height = image.size
|
|
excludes = cls._map_preview_excludes(excludes_preview, image.size, scale_from_preview)
|
|
for y in range(height):
|
|
for x in range(width):
|
|
if any(x0 <= x <= x1 and y0 <= y <= y1 for (x0, y0, x1, y1) in excludes):
|
|
continue
|
|
r, g, b, a = pixels[x, y]
|
|
if a == 0:
|
|
continue
|
|
if is_purple_fn(r, g, b):
|
|
draw.point((x, y), fill=(255, 0, 0, alpha))
|
|
return overlay
|
|
|
|
|
|
__all__ = ["ImageProcessingMixin"]
|