121 lines
3.5 KiB
Python
121 lines
3.5 KiB
Python
import cv2
|
|
import numpy as np
|
|
from PIL import Image
|
|
import imagehash
|
|
import os
|
|
from typing import List, Optional
|
|
|
|
|
|
def is_blurry(path: str, threshold: float = 100.0) -> bool:
|
|
"""Gibt True zurueck, wenn das Bild unscharf ist (Laplacian Variance < threshold)."""
|
|
img = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
|
|
if img is None:
|
|
return False
|
|
variance = cv2.Laplacian(img, cv2.CV_64F).var()
|
|
return bool(variance < threshold)
|
|
|
|
|
|
def _mean_brightness(path: str) -> float:
|
|
"""Durchschnittliche Helligkeit eines Bildes (0-255)."""
|
|
img = Image.open(path).convert("L")
|
|
arr = np.array(img, dtype=np.float32)
|
|
return float(arr.mean())
|
|
|
|
|
|
def is_overexposed(path: str, threshold: float = 240.0) -> bool:
|
|
"""Gibt True zurueck, wenn das Bild ueberbelichtet ist."""
|
|
return _mean_brightness(path) > threshold
|
|
|
|
|
|
def is_underexposed(path: str, threshold: float = 30.0) -> bool:
|
|
"""Gibt True zurueck, wenn das Bild unterbelichtet ist."""
|
|
return _mean_brightness(path) < threshold
|
|
|
|
|
|
def find_duplicates(paths: List[str], threshold: int = 8) -> List[List[str]]:
|
|
"""
|
|
Findet Gruppen aehnlicher Bilder via perceptual hashing.
|
|
Das erste Element jeder Gruppe gilt als Original, der Rest als Duplikate.
|
|
"""
|
|
hashes = {}
|
|
for path in paths:
|
|
try:
|
|
h = imagehash.phash(Image.open(path))
|
|
hashes[path] = h
|
|
except Exception:
|
|
continue
|
|
|
|
groups = []
|
|
used = set()
|
|
path_list = list(hashes.keys())
|
|
|
|
for i, p1 in enumerate(path_list):
|
|
if p1 in used:
|
|
continue
|
|
group = [p1]
|
|
for p2 in path_list[i + 1:]:
|
|
if p2 in used:
|
|
continue
|
|
if abs(hashes[p1] - hashes[p2]) <= threshold:
|
|
group.append(p2)
|
|
used.add(p2)
|
|
if len(group) > 1:
|
|
used.add(p1)
|
|
groups.append(group)
|
|
|
|
return groups
|
|
|
|
|
|
SUPPORTED_EXTENSIONS = {".jpg", ".jpeg", ".png"}
|
|
|
|
|
|
def analyze_folder(
|
|
folder: str,
|
|
blur_threshold: float = 100.0,
|
|
over_threshold: float = 240.0,
|
|
under_threshold: float = 30.0,
|
|
dup_threshold: int = 8,
|
|
use_ai: bool = False,
|
|
api_key: Optional[str] = None,
|
|
) -> List[dict]:
|
|
"""
|
|
Analysiert alle Bilder im Ordner.
|
|
Gibt Liste zurueck: [{"path": "/foo/bar.jpg", "reasons": ["unscharf"]}, ...]
|
|
Nur Bilder mit mindestens einem Grund werden zurueckgegeben.
|
|
"""
|
|
paths = [
|
|
os.path.join(folder, f)
|
|
for f in os.listdir(folder)
|
|
if os.path.splitext(f)[1].lower() in SUPPORTED_EXTENSIONS
|
|
]
|
|
|
|
results: dict = {path: [] for path in paths}
|
|
|
|
for path in paths:
|
|
try:
|
|
if is_blurry(path, blur_threshold):
|
|
results[path].append("unscharf")
|
|
if is_overexposed(path, over_threshold):
|
|
results[path].append("ueberbelichtet")
|
|
if is_underexposed(path, under_threshold):
|
|
results[path].append("unterbelichtet")
|
|
except Exception:
|
|
continue
|
|
|
|
dup_groups = find_duplicates(paths, dup_threshold)
|
|
for group in dup_groups:
|
|
original = os.path.basename(group[0])
|
|
for dup_path in group[1:]:
|
|
results[dup_path].append(f"Duplikat von {original}")
|
|
|
|
if use_ai and api_key:
|
|
ai_results = _analyze_with_ai(paths, api_key)
|
|
for path, ai_reasons in ai_results.items():
|
|
results[path].extend(ai_reasons)
|
|
|
|
return [
|
|
{"path": path, "reasons": reasons}
|
|
for path, reasons in results.items()
|
|
if reasons
|
|
]
|