feat: Add photo path handling in poster generation and enhance collage creation

app.py

@@ -389,6 +389,7 @@ def upload_photo(
     SESSION_STORE[session_id]["photos"].append({
         "photo_id": photo_id,
         "photo_name": photo_name,
+        "photo_path": photo_file if isinstance(photo_file, str) else "",
         "caption": caption,
         "task_id": task_id,
     })
@@ -513,7 +514,11 @@ def generate_poster_from_session(session_id: str):
     )
     result = generate_story(packet, session_id=session_id)
 
-    poster_url, status = generate_poster_sync(session_id, result["poster_prompt"])
+    poster_url, status = generate_poster_sync(
+        session_id,
+        result["poster_prompt"],
+        photo_paths=[p.get("photo_path", "") for p in photos if p.get("photo_path")],
+    )
     session["poster_url"] = poster_url
     return poster_url, status
 

app/services/image_gen.py

@@ -1,7 +1,10 @@
-"""Black Forest Labs FLUX poster generation module.
+"""Poster generation module — two strategies:
 
-Generates a recap poster image from a text prompt using FLUX offline
-via ``diffusers`` (same lazy-download pattern as generator.py / minicpm.py).
+1. **Photo collage** (default) — builds an attractive collage from the
+   player's uploaded gameplay photos using Pillow.  Instant, free, and
+   shows *real* game moments.
+2. **FLUX text-to-image** (fallback) — generates an AI poster from a
+   text prompt via ``diffusers``.  Requires GPU and the FLUX model.
 
 Sponsor alignment: Black Forest Labs FLUX produces a visible demo artifact
 (the recap poster) rather than being hidden in backend code.
@@ -155,21 +158,180 @@ def generate_poster(poster_prompt: str) -> Optional[str]:
         return None
 
 
+# ── Photo collage poster (uses uploaded gameplay photos) ─────────────────
+
+def generate_collage_poster(
+    photo_paths: list[str],
+    title: str = "CityQuest",
+    game_title: str = "",
+) -> Optional[str]:
+    """Build an attractive photo collage poster from uploaded gameplay photos.
+
+    Uses Pillow only (no GPU required).  Falls back to FLUX text-to-image
+    if Pillow is unavailable or no photos are provided.
+
+    Args:
+        photo_paths: List of filesystem paths to uploaded player photos.
+        title: Overlay title text (e.g. "CityQuest AI").
+        game_title: The game's title from generation.
+
+    Returns:
+        Filesystem path (as string) to the saved poster, or ``None``.
+    """
+    if not photo_paths:
+        return None
+
+    # Filter to only files that actually exist
+    valid = [p for p in photo_paths if Path(p).exists()]
+    if not valid:
+        return None
+
+    try:
+        from PIL import Image, ImageDraw, ImageFont
+
+        POSTER_DIR.mkdir(parents=True, exist_ok=True)
+
+        # Poster dimensions
+        W, H = 1024, 768
+        poster = Image.new("RGB", (W, H), (20, 20, 30))
+        draw = ImageDraw.Draw(poster)
+
+        # Layout: pick grid based on photo count
+        n = len(valid)
+        if n == 1:
+            cols, rows = 1, 1
+        elif n == 2:
+            cols, rows = 2, 1
+        elif n <= 4:
+            cols, rows = 2, 2
+        elif n <= 6:
+            cols, rows = 3, 2
+        else:
+            cols, rows = 4, 2
+
+        padding = 8
+        header_h = 80  # space for title overlay at top
+        footer_h = 60  # space for bottom overlay
+        grid_w = W - 2 * padding
+        grid_h = H - header_h - footer_h - 2 * padding
+        cell_w = grid_w // cols
+        cell_h = grid_h // rows
+
+        # Paste photos into grid
+        placed = 0
+        for idx, path in enumerate(valid[: cols * rows]):
+            try:
+                img = Image.open(path).convert("RGB")
+                # Resize to fit cell, preserve aspect ratio (cover)
+                ratio = max(cell_w / img.width, cell_h / img.height)
+                new_w = int(img.width * ratio)
+                new_h = int(img.height * ratio)
+                img = img.resize((new_w, new_h), Image.LANCZOS)
+                # Center-crop to cell size
+                left = (new_w - cell_w) // 2
+                top = (new_h - cell_h) // 2
+                img = img.crop((left, top, left + cell_w, top + cell_h))
+                # Place in grid
+                col = placed % cols
+                row = placed // cols
+                x = padding + col * cell_w
+                y = header_h + padding + row * cell_h
+                poster.paste(img, (x, y))
+                placed += 1
+            except Exception as exc:
+                print(f"[image_gen] Skipping photo {path}: {exc}")
+
+        if placed == 0:
+            return None
+
+        # Semi-transparent header overlay
+        overlay = Image.new("RGBA", (W, header_h), (0, 0, 0, 180))
+        poster.paste(
+            Image.alpha_composite(
+                Image.new("RGBA", (W, header_h), (0, 0, 0, 0)),
+                overlay,
+            ).convert("RGB"),
+            (0, 0),
+        )
+
+        # Semi-transparent footer overlay
+        footer_overlay = Image.new("RGBA", (W, footer_h), (0, 0, 0, 180))
+        poster.paste(
+            Image.alpha_composite(
+                Image.new("RGBA", (W, footer_h), (0, 0, 0, 0)),
+                footer_overlay,
+            ).convert("RGB"),
+            (0, H - footer_h),
+        )
+
+        # Draw title text
+        draw = ImageDraw.Draw(poster)
+        display_title = game_title or title
+        try:
+            font_large = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 36)
+            font_small = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", 20)
+        except (OSError, IOError):
+            # Fallback if system fonts unavailable
+            font_large = ImageFont.load_default()
+            font_small = ImageFont.load_default()
+
+        # Title (centered top)
+        bbox = draw.textbbox((0, 0), display_title, font=font_large)
+        tw = bbox[2] - bbox[0]
+        draw.text(((W - tw) // 2, 20), display_title, fill=(255, 255, 255), font=font_large)
+
+        # Footer text
+        footer_text = f"{placed} photo{'s' if placed != 1 else ''} from gameplay"
+        bbox2 = draw.textbbox((0, 0), footer_text, font=font_small)
+        fw = bbox2[2] - bbox2[0]
+        draw.text(((W - fw) // 2, H - 45), footer_text, fill=(200, 200, 200), font=font_small)
+
+        # Save
+        filename = f"poster_{uuid.uuid4().hex[:8]}.png"
+        filepath = POSTER_DIR / filename
+        poster.save(str(filepath), quality=95)
+        print(f"[image_gen] Collage poster saved -> {filepath} ({placed} photos)")
+        return str(filepath)
+
+    except ImportError:
+        print("[image_gen] Pillow not installed — cannot create collage")
+        return None
+    except Exception as e:
+        print(f"[image_gen] Collage generation failed: {type(e).__name__}: {e}")
+        return None
+
+
 def generate_poster_sync(
     session_id: str,
     poster_prompt: str,
+    photo_paths: Optional[list[str]] = None,
 ) -> tuple[Optional[str], str]:
     """Generate a poster and return (image_path, status_message).
 
-    This is a convenience wrapper for use in the pipeline entry point.
+    Strategy:
+      1. If uploaded photos exist → build a photo collage (instant, no GPU).
+      2. Otherwise → fall back to FLUX text-to-image (needs GPU).
 
     Args:
         session_id: Session identifier (for logging).
         poster_prompt: Text prompt for the image.
+        photo_paths: Optional list of uploaded gameplay photo file paths.
 
     Returns:
         Tuple of (image_path_or_None, status_message).
     """
+    # ── Strategy 1: Photo collage from uploaded gameplay photos ─────────
+    if photo_paths:
+        print(f"[image_gen] Attempting collage from {len(photo_paths)} photo(s)")
+        collage = generate_collage_poster(photo_paths)
+        if collage:
+            return collage, (
+                f"**Poster created from your gameplay photos!** 📸\n"
+                f"Saved as `{collage}` — refresh the Recap tab to view."
+            )
+        print("[image_gen] Collage failed, falling back to FLUX text-to-image")
+
+    # ── Strategy 2: FLUX text-to-image (GPU required) ─────────────────
     image_path = generate_poster(poster_prompt)
 
     if image_path:

requirements.txt

@@ -13,6 +13,7 @@ diffusers[torch]>=0.30.0
 transformers>=5.4.0
 accelerate
 safetensors
+Pillow>=9.0
 # Cohere Transcribe ASR (voice journal) — gated model, requires HF_TOKEN
 soundfile
 librosa