Fiches de poste rapides, badges sans initiales, vue par bénévole sur l'axe des temps

Étape 62 : les fiches de poste intégraient la photo d'origine de chaque
bénévole pour chaque créneau (CPU à 300 %, puis erreur) — photos réduites
à la vignette une fois par PDF ; badges : photo recadrée une fois par
génération et décodée à taille réduite.

Étape 61 : sans photo, le cadre de la photo reste vide sur le badge.

Étape 60 : vue par bénévole en tranches de 30 min, affectations étirées
sur toute leur durée, postes simultanés empilés, ligne de l'heure actuelle.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

backend/app/api/badges.py

@@ -37,7 +37,6 @@ from app.badges.pdf import (
     BadgeTableSection,
     generate_badge_sheets_pdf,
     image_size_mm,
-    initials,
 )
 from app.db import get_session
 from app.i18n import t
@@ -320,8 +319,8 @@ def _field_text(
         # Prénom puis nom, chacun sur sa ligne.
         return f"{volunteer.first_name}\n{volunteer.last_name}"
     if field.field_type == BadgeFieldType.PHOTO:
-        # Imprimées à la place d'une photo absente ou illisible.
-        return initials(volunteer.first_name, volunteer.last_name)
+        # Une image, pas un texte (rien d'imprimé sans photo).
+        return ""
     if field.field_type == BadgeFieldType.FREE_TEXT:
         # Texte commun saisi dans l'éditeur, remplacé pour un bénévole par
         # le « Texte du badge » de sa fiche s'il en a un.

backend/app/badges/pdf.py

@@ -42,8 +42,6 @@ _AUTO_FIT_STEP_PT = 0.5
 _AUTO_FIT_MIN_PT = 4.0
 # Photo absente ou illisible : initiales sur ce fond, à cette taille (part de
 # la largeur du cadre).
-_INITIALS_BG = "#E7E0CE"
-_INITIALS_SIZE_RATIO = 0.28
 
 # Résolution supposée d'une image de fond importée, pour convertir ses pixels
 # en millimètres réels (donc en taille de badge) — 300 dpi est la résolution
@@ -86,9 +84,8 @@ class BadgeFieldSpec:
 
     `is_photo` : le champ est la photo du bénévole (`image`, ses octets
     bruts tels que stockés) plutôt qu'un texte, découpée selon
-    `photo_shape` (`RECT`/`OVAL`). Sans photo (ou photo illisible), les
-    initiales du bénévole (`text`) sont imprimées à la place, sur un fond
-    neutre de la même forme.
+    `photo_shape` (`RECT`/`OVAL`). Sans photo (ou photo illisible), rien
+    n'est imprimé : le cadre reste vide.
 
     `table` : le champ est un tableau (`text` ignoré) — voir `_draw_table`.
 
@@ -193,6 +190,9 @@ def _fit_photo(image: bytes, width_mm: float, height_mm: float) -> bytes | None:
     )
     try:
         with Image.open(io.BytesIO(image)) as img:
+            # JPEG : décodage directement à taille réduite (bien plus rapide
+            # qu'une photo de téléphone décodée en pleine résolution).
+            img.draft("RGB", (target[0] * 2, target[1] * 2))
             fitted = ImageOps.fit(ImageOps.exif_transpose(img).convert("RGB"), target)
     except (UnidentifiedImageError, OSError):
         return None
@@ -224,38 +224,37 @@ def _shape_path(c: canvas.Canvas, shape: str, x: float, y: float, w: float, h: f
     return path
 
 
-def initials(first_name: str, last_name: str) -> str:
-    """Initiales imprimées à la place d'une photo absente : première lettre
-    du prénom et du nom, en majuscules."""
-    return "".join(part.strip()[:1] for part in (first_name, last_name)).upper()
-
-
-def _draw_initials(c: canvas.Canvas, f: BadgeFieldSpec, x: float, y: float, w: float, h: float):
-    c.setFillColor(HexColor(_INITIALS_BG))
-    c.drawPath(_shape_path(c, f.photo_shape, x, y, w, h), stroke=0, fill=1)
-    if not f.text:
-        return
-    size = max(_AUTO_FIT_MIN_PT, w * _INITIALS_SIZE_RATIO)
-    c.setFont("Helvetica-Bold", size)
-    c.setFillColor(HexColor(f.color))
-    # Ligne de base décalée d'environ un tiers de la taille : centre
-    # visuel des majuscules (hauteur de capitale ≈ 0,7 × la taille).
-    c.drawCentredString(x + w / 2, y + h / 2 - size * 0.35, f.text)
+# Photos déjà recadrées pendant une génération, par (photo, largeur,
+# hauteur du cadre) : un bénévole a souvent la même photo au recto, au verso
+# et sur plusieurs exemplaires (`badge_count`) — elle n'est traitée qu'une
+# fois.
+PhotoCache = dict[tuple[bytes, float, float], bytes | None]
 
 
 def _draw_photo(
-    c: canvas.Canvas, f: BadgeFieldSpec, x0_mm: float, y0_mm: float, badge_height_mm: float
+    c: canvas.Canvas,
+    f: BadgeFieldSpec,
+    x0_mm: float,
+    y0_mm: float,
+    badge_height_mm: float,
+    cache: PhotoCache,
 ) -> None:
     x, y, w, h = _frame_rect(f, x0_mm, y0_mm, badge_height_mm)
-    photo = _fit_photo(f.image, f.width_mm, f.height_mm) if f.image else None
-    c.saveState()
+    photo = None
+    if f.image:
+        key = (f.image, f.width_mm, f.height_mm)
+        if key not in cache:
+            cache[key] = _fit_photo(f.image, f.width_mm, f.height_mm)
+        photo = cache[key]
     if photo is None:
-        _draw_initials(c, f, x, y, w, h)
-    else:
-        if f.photo_shape == "OVAL":
-            # Découpe en ellipse inscrite dans le cadre.
-            c.clipPath(_shape_path(c, "OVAL", x, y, w, h), stroke=0, fill=0)
-        c.drawImage(ImageReader(io.BytesIO(photo)), x, y, width=w, height=h)
+        # Pas de photo (ou illisible) : cadre laissé vide, choix de la
+        # coordination — avant, les initiales étaient imprimées à la place.
+        return
+    c.saveState()
+    if f.photo_shape == "OVAL":
+        # Découpe en ellipse inscrite dans le cadre.
+        c.clipPath(_shape_path(c, "OVAL", x, y, w, h), stroke=0, fill=0)
+    c.drawImage(ImageReader(io.BytesIO(photo)), x, y, width=w, height=h)
     c.restoreState()
 
 
@@ -495,10 +494,11 @@ def _draw_fields(
     x0_mm: float,
     y0_mm: float,
     badge_height_mm: float,
+    photos: PhotoCache,
 ) -> None:
     for f in fields:
         if f.is_photo:
-            _draw_photo(c, f, x0_mm, y0_mm, badge_height_mm)
+            _draw_photo(c, f, x0_mm, y0_mm, badge_height_mm, photos)
             continue
         _draw_zone_background(c, f, x0_mm, y0_mm, badge_height_mm)
         if f.table is not None:
@@ -522,17 +522,18 @@ def generate_badge_sheets_pdf(
 
     buffer = io.BytesIO()
     c = canvas.Canvas(buffer, pagesize=A4)
+    photos: PhotoCache = {}
     for page_badges in pages:
         for i, badge in enumerate(page_badges):
             x0, y0 = _cell_origin(i, cols, badge_width_mm, badge_height_mm)
             _draw_background(c, front_image, x0, y0, badge_width_mm, badge_height_mm)
-            _draw_fields(c, badge.fields, x0, y0, badge_height_mm)
+            _draw_fields(c, badge.fields, x0, y0, badge_height_mm, photos)
         c.showPage()
 
         for i, badge in enumerate(page_badges):
             x0, y0 = _cell_origin(i, cols, badge_width_mm, badge_height_mm, mirrored=True)
             _draw_background(c, back_image, x0, y0, badge_width_mm, badge_height_mm)
-            _draw_fields(c, badge.back_fields, x0, y0, badge_height_mm)
+            _draw_fields(c, badge.back_fields, x0, y0, badge_height_mm, photos)
         c.showPage()
     c.save()
     return buffer.getvalue()

backend/app/sheets/pdf.py

@@ -13,11 +13,12 @@ import datetime as dt
 import io
 from dataclasses import dataclass
 
+from PIL import Image as PILImage
+from PIL import ImageOps, UnidentifiedImageError
 from reportlab.lib import colors
 from reportlab.lib.pagesizes import A4
 from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet
 from reportlab.lib.units import mm
-from reportlab.lib.utils import ImageReader
 from reportlab.platypus import (
     Image,
     PageBreak,
@@ -29,6 +30,8 @@ from reportlab.platypus import (
 )
 
 _PHOTO_BOX_MM = 14 * mm
+# Côté de la vignette en pixels : 14 mm à 300 dpi.
+_PHOTO_BOX_PX = round(14 / 25.4 * 300)
 
 _WEEKDAYS_FR = ["Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche"]
 _MONTHS_FR = [
@@ -115,16 +118,45 @@ def _styles() -> dict[str, ParagraphStyle]:
     }
 
 
-def _photo_thumbnail(photo: bytes) -> Image:
-    """Vignette carrée (14 mm de côté max), proportions préservées."""
-    width_px, height_px = ImageReader(io.BytesIO(photo)).getSize()
+def _thumbnail(photo: bytes) -> tuple[bytes, int, int] | None:
+    """Photo réduite à la taille de la vignette (orientation EXIF appliquée),
+    en JPEG : `(octets, largeur, hauteur)`, `None` si illisible. La photo
+    d'origine (souvent plusieurs Mo, prise au téléphone) intégrée telle
+    quelle pour chaque bénévole de chaque créneau faisait tourner la
+    génération plusieurs minutes et produisait un PDF énorme — jusqu'à
+    l'erreur (bug corrigé une fois)."""
+    try:
+        with PILImage.open(io.BytesIO(photo)) as img:
+            # JPEG : décodage directement à taille réduite (bien plus rapide).
+            img.draft("RGB", (_PHOTO_BOX_PX, _PHOTO_BOX_PX))
+            thumb = ImageOps.exif_transpose(img).convert("RGB")
+            thumb.thumbnail((_PHOTO_BOX_PX, _PHOTO_BOX_PX))
+    except (UnidentifiedImageError, OSError, ValueError):
+        return None
+    out = io.BytesIO()
+    thumb.save(out, format="JPEG", quality=85)
+    return out.getvalue(), thumb.width, thumb.height
+
+
+def _photo_cell(photo: bytes | None, cache: dict[bytes, tuple[bytes, int, int] | None]):
+    """Vignette carrée (14 mm de côté max), proportions préservées. Chaque
+    photo n'est réduite qu'une fois par PDF (`cache`), même si le bénévole
+    figure sur plusieurs créneaux."""
+    if not photo:
+        return ""
+    if photo not in cache:
+        cache[photo] = _thumbnail(photo)
+    thumb = cache[photo]
+    if thumb is None:
+        return ""
+    data, width_px, height_px = thumb
     scale = _PHOTO_BOX_MM / max(width_px, height_px)
-    return Image(io.BytesIO(photo), width=width_px * scale, height=height_px * scale)
+    return Image(io.BytesIO(data), width=width_px * scale, height=height_px * scale)
 
 
-def _shift_table(shift: SheetShift) -> Table:
+def _shift_table(shift: SheetShift, cache: dict[bytes, tuple[bytes, int, int] | None]) -> Table:
     rows = [["", "Bénévole", "Téléphone"]] + [
-        [_photo_thumbnail(v.photo) if v.photo else "", v.name, v.phone or "—"]
+        [_photo_cell(v.photo, cache), v.name, v.phone or "—"]
         for v in shift.volunteers
     ]
     table = Table(rows, colWidths=[18 * mm, 92 * mm, 55 * mm])
@@ -153,6 +185,7 @@ def generate_position_sheets_pdf(sheets: list[PositionDaySheet]) -> bytes:
     )
 
     story = []
+    thumbnails: dict[bytes, tuple[bytes, int, int] | None] = {}
     for i, sheet in enumerate(sheets):
         if i > 0:
             story.append(PageBreak())
@@ -190,7 +223,7 @@ def generate_position_sheets_pdf(sheets: list[PositionDaySheet]) -> bytes:
             style = styles["shiftHeaderWarning"] if shift.understaffed else styles["shiftHeader"]
             story.append(Paragraph(header, style))
             if shift.volunteers:
-                story.append(_shift_table(shift))
+                story.append(_shift_table(shift, thumbnails))
             else:
                 story.append(Paragraph("Personne affecté pour l'instant.", styles["normal"]))
         story.append(Spacer(1, 0))