photobooth/backend/collage.py

import logging
from pathlib import Path

from PIL import Image, ImageDraw

from backend.config import DOSSIER_EXPORTS, charger_config

log = logging.getLogger("photobooth.collage")

# Format 10x15cm a 300dpi
LARGEUR_10x15 = 1200
HAUTEUR_10x15 = 1800
# Format 10x15cm paysage
LARGEUR_10x15_L = 1800
HAUTEUR_10x15_L = 1200


def _crop_center(img: Image.Image, ratio_cible: float) -> Image.Image:
    """Recadre une image au centre pour correspondre au ratio cible."""
    ratio_img = img.width / img.height
    if ratio_img > ratio_cible:
        nouvelle_largeur = int(img.height * ratio_cible)
        offset = (img.width - nouvelle_largeur) // 2
        return img.crop((offset, 0, offset + nouvelle_largeur, img.height))
    else:
        nouvelle_hauteur = int(img.width / ratio_cible)
        offset = (img.height - nouvelle_hauteur) // 2
        return img.crop((0, offset, img.width, offset + nouvelle_hauteur))


def creer_strip(photos: list[Path], marge: int = 20, couleur_fond: str = "#ffffff") -> Path:
    """Cree une bande portrait style pellicule (4 photos de gauche a droite).

    La bande fait la moitie d'un 10x15 paysage (1800 x 570px environ).
    Style pellicule : bords avec perforations.
    """
    nb = len(photos)
    images = [Image.open(p) for p in photos]

    # Dimensions de la bande : largeur d'un 10x15 paysage, hauteur = moitie
    bande_largeur = LARGEUR_10x15_L
    bande_hauteur = (HAUTEUR_10x15_L - marge * 3) // 2  # 2 bandes par page

    # Zone perforations pellicule (haut et bas)
    perf_hauteur = 30
    zone_photos_hauteur = bande_hauteur - perf_hauteur * 2

    # Taille de chaque photo dans la bande
    espace_photos = bande_largeur - marge * (nb + 1)
    largeur_cellule = espace_photos // nb
    hauteur_cellule = zone_photos_hauteur
    ratio_cellule = largeur_cellule / hauteur_cellule

    # Recadrer et redimensionner
    images_redim = []
    for img in images:
        img_crop = _crop_center(img, ratio_cellule)
        img_redim = img_crop.resize((largeur_cellule, hauteur_cellule), Image.LANCZOS)
        images_redim.append(img_redim)

    # Creer la bande
    strip = Image.new("RGB", (bande_largeur, bande_hauteur), couleur_fond)
    draw = ImageDraw.Draw(strip)

    # Perforations pellicule (haut)
    for px in range(marge, bande_largeur - marge, 40):
        draw.rounded_rectangle(
            [px, 6, px + 20, perf_hauteur - 6],
            radius=4, fill=(30, 30, 30)
        )
    # Perforations pellicule (bas)
    for px in range(marge, bande_largeur - marge, 40):
        draw.rounded_rectangle(
            [px, bande_hauteur - perf_hauteur + 6, px + 20, bande_hauteur - 6],
            radius=4, fill=(30, 30, 30)
        )

    # Bords pellicule
    draw.rectangle([0, 0, bande_largeur - 1, perf_hauteur], fill=(40, 40, 40))
    draw.rectangle([0, bande_hauteur - perf_hauteur, bande_largeur - 1, bande_hauteur - 1],
                    fill=(40, 40, 40))

    # Re-dessiner les perforations par-dessus les bords
    for px in range(marge, bande_largeur - marge, 40):
        draw.rounded_rectangle([px, 6, px + 20, perf_hauteur - 6], radius=4, fill=couleur_fond)
        draw.rounded_rectangle(
            [px, bande_hauteur - perf_hauteur + 6, px + 20, bande_hauteur - 6],
            radius=4, fill=couleur_fond
        )

    # Coller les photos
    x = marge
    for img in images_redim:
        strip.paste(img, (x, perf_hauteur))
        x += largeur_cellule + marge

    nom = f"strip_{photos[0].stem}.jpg"
    chemin = DOSSIER_EXPORTS / nom
    strip.save(chemin, "JPEG", quality=95, dpi=(300, 300))
    log.info(f"Strip pellicule cree : {chemin} ({nb} photos)")
    return chemin


def creer_impression_strip(chemin_strip: Path, marge: int = 20,
                           couleur_fond: str = "#ffffff") -> Path:
    """Cree un 10x15 paysage avec 2 bandes identiques superposees pour impression."""
    strip = Image.open(chemin_strip)

    # Canvas 10x15 paysage
    page = Image.new("RGB", (LARGEUR_10x15_L, HAUTEUR_10x15_L), couleur_fond)

    # Redimensionner la bande pour qu'elle tienne dans la moitie
    bande_largeur = LARGEUR_10x15_L - marge * 2
    bande_hauteur = (HAUTEUR_10x15_L - marge * 3) // 2
    strip_redim = strip.resize((bande_largeur, bande_hauteur), Image.LANCZOS)

    # Coller 2 fois
    page.paste(strip_redim, (marge, marge))
    page.paste(strip_redim, (marge, marge + bande_hauteur + marge))

    nom = f"print_{chemin_strip.stem}.jpg"
    chemin = DOSSIER_EXPORTS / nom
    page.save(chemin, "JPEG", quality=95, dpi=(300, 300))
    log.info(f"Page impression 10x15 creee : {chemin}")
    return chemin


def creer_collage(photos: list[Path], colonnes: int = 2, marge: int = 25,
                  couleur_fond: str = "#ffffff") -> Path:
    """Cree un collage en grille au format 10x15cm."""
    nb = len(photos)
    images = [Image.open(p) for p in photos]

    lignes = (nb + colonnes - 1) // colonnes

    largeur_cellule = (LARGEUR_10x15 - marge * (colonnes + 1)) // colonnes
    hauteur_cellule = (HAUTEUR_10x15 - marge * (lignes + 1)) // lignes
    ratio_cellule = largeur_cellule / hauteur_cellule

    images_redim = []
    for img in images:
        img_crop = _crop_center(img, ratio_cellule)
        img_redim = img_crop.resize((largeur_cellule, hauteur_cellule), Image.LANCZOS)
        images_redim.append(img_redim)

    collage = Image.new("RGB", (LARGEUR_10x15, HAUTEUR_10x15), couleur_fond)

    for i, img in enumerate(images_redim):
        col = i % colonnes
        lig = i // colonnes
        x = marge + col * (largeur_cellule + marge)
        y = marge + lig * (hauteur_cellule + marge)
        collage.paste(img, (x, y))

    nom = f"collage_{photos[0].stem}.jpg"
    chemin = DOSSIER_EXPORTS / nom
    collage.save(chemin, "JPEG", quality=95, dpi=(300, 300))
    log.info(f"Collage 10x15 cree : {chemin} ({nb} photos, {colonnes}x{lignes})")
    return chemin