WIP

app.py

@@ -12,6 +12,9 @@ from huggingface_hub import login
 from diffusers import FluxControlNetPipeline, FluxControlNetModel
 from diffusers.models import FluxMultiControlNetModel
 
+import warnings
+from typing import Tuple
+
 """
 FLUX‑1 ControlNet demo
 ----------------------
@@ -64,39 +67,191 @@ pipe.set_progress_bar_config(disable=True)
 # --------------------------------------------------
 MODE_MAPPING = {
     "canny": 0,
-    "depth": 1,
-    "openpose": 2,
-    "gray": 3,
-    "blur": 4,
-    "tile": 5,
+    "tile": 1,
+    "depth": 2,
+    "blur": 3,
+    "pose": 4,
+    "gray": 5,
     "low quality": 6,
 }
 
 MAX_SEED = 100
 
-# --------------------------------------------------
-# Helper: quick‑n‑dirty Canny preview (only for UI display)
-# --------------------------------------------------
+# -----------------------------------------------------------------------------
+# Preview helpers – one small, self‑contained function per mode
+# -----------------------------------------------------------------------------
 
 
 def _preview_canny(
     pil_img: Image.Image, canny_threshold_1: int, canny_threshold_2: int
 ) -> Image.Image:
+    """Fast Canny‑edge preview (already implemented)."""
+
     arr = np.array(pil_img.convert("RGB"))
     edges = cv2.Canny(arr, threshold1=canny_threshold_1, threshold2=canny_threshold_2)
     edges_rgb = cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB)
     return Image.fromarray(edges_rgb)
 
 
+# ――― tile ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――― #
+
+
+def _preview_tile(pil_img: Image.Image, grid: Tuple[int, int] = (2, 2)) -> Image.Image:
+    """Replicates *pil_img* into an *n×m* tiled grid (default 2×2).
+
+    This offers a quick visual hint of what a *tiling* control mode will do
+    (repeatable textures, etc.)."""
+
+    cols, rows = grid
+    img_rgb = pil_img.convert("RGB")
+    w, h = img_rgb.size
+    tiled = Image.new("RGB", (w * cols, h * rows))
+    for c in range(cols):
+        for r in range(rows):
+            tiled.paste(img_rgb, (c * w, r * h))
+    return tiled
+
+
+# ――― depth ――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――― #
+
+
+def _preview_depth(pil_img: Image.Image) -> Image.Image:
+    """Very rough *depth* proxy using the Laplacian and a colormap.
+
+    ▸ Convert to gray
+    ▸ Run Laplacian to highlight depth‑like gradients
+    ▸ Apply a TURBO colormap to mimic depth heat‑map appearance"""
+
+    gray = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2GRAY)
+    lap = cv2.Laplacian(gray, cv2.CV_16S, ksize=3)
+    depth = cv2.convertScaleAbs(lap)
+    depth_color = cv2.applyColorMap(depth, cv2.COLORMAP_TURBO)
+    return Image.fromarray(depth_color)
+
+
+# ――― blur ――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――― #
+
+
+def _preview_blur(pil_img: Image.Image, ksize: int = 15) -> Image.Image:
+    """Gaussian blur preview.
+    A single, relatively large kernel is enough for UI illustration."""
+
+    if ksize % 2 == 0:
+        ksize += 1  # kernel must be odd
+    blurred = cv2.GaussianBlur(np.array(pil_img), (ksize, ksize), sigmaX=0)
+    return Image.fromarray(blurred)
+
+
+# ――― pose ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――― #
+
+
+def _preview_pose(pil_img: Image.Image) -> Image.Image:
+    """Attempt a lightweight 2‑D pose overlay using *mediapipe* if available.
+
+    If *mediapipe* is not installed (or CPU inference fails), we gracefully
+    fallback to an edge‑map preview so the UI never crashes."""
+
+    try:
+        import mediapipe as mp  # type: ignore
+
+        mp_pose = mp.solutions.pose
+        mp_drawing = mp.solutions.drawing_utils
+
+        img_bgr = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2BGR)
+        with mp_pose.Pose(static_image_mode=True) as pose_estimator:
+            results = pose_estimator.process(
+                img_bgr[..., ::-1]
+            )  # Mediapipe expects RGB
+
+        annotated = img_bgr.copy()
+        if results.pose_landmarks:
+            mp_drawing.draw_landmarks(
+                annotated, results.pose_landmarks, mp_pose.POSE_CONNECTIONS
+            )
+        annotated_rgb = cv2.cvtColor(annotated, cv2.COLOR_BGR2RGB)
+        return Image.fromarray(annotated_rgb)
+
+    except Exception as exc:  # pragma: no cover – any import / runtime error
+        warnings.warn(
+            f"Pose preview failed ({exc!s}); falling back to Canny.", RuntimeWarning
+        )
+        # Return an edge map as a sensible fallback rather than exploding the UI
+        return _preview_canny(pil_img, 100, 200)
+
+
+# ――― gray ――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――― #
+
+
+def _preview_gray(pil_img: Image.Image) -> Image.Image:
+    """Simple grayscale conversion, but keep a 3‑channel RGB image so the UI
+    widget pipeline stays consistent."""
+
+    gray = cv2.cvtColor(np.array(pil_img.convert("RGB")), cv2.COLOR_RGB2GRAY)
+    gray_rgb = cv2.cvtColor(gray, cv2.COLOR_GRAY2RGB)
+    return Image.fromarray(gray_rgb)
+
+
+# ――― low quality ――――――――――――――――――――――――――――――――――――――――――――――――――――――――― #
+
+
+def _preview_low_quality(pil_img: Image.Image, factor: int = 8) -> Image.Image:
+    """Mimic a low‑quality thumbnail: aggressively downsample then upscale.
+
+    The default *factor* (8×) is chosen to make artefacts obvious."""
+
+    img_rgb = pil_img.convert("RGB")
+    w, h = img_rgb.size
+    small = img_rgb.resize((max(1, w // factor), max(1, h // factor)), Image.BILINEAR)
+    low_q = small.resize(
+        (w, h), Image.NEAREST
+    )  # upsample w/ Nearest to exaggerate blocks
+    return low_q
+
+
+# -----------------------------------------------------------------------------
+# Master dispatch
+# -----------------------------------------------------------------------------
+
+
 def _make_preview(
     control_image: Image.Image,
     mode: str,
-    canny_threshold_1: int,
-    canny_threshold_2: int,
+    canny_threshold_1: int = 100,
+    canny_threshold_2: int = 200,
 ) -> Image.Image:
+    """Return a *quick‑n‑dirty* preview image for the requested *mode*.
+
+    Parameters
+    ----------
+    control_image : PIL.Image
+        The input image selected by the user.
+    mode : str
+        One of the keys of :data:`MODE_MAPPING`.
+    canny_threshold_1 / 2 : int, optional
+        Only used if *mode* is "canny" (passed straight to OpenCV Canny).
+    """
+
+    mode = mode.lower()
+    if mode not in MODE_MAPPING:
+        warnings.warn(f"Unknown preview mode '{mode}'. Returning untouched image.")
+        return control_image
+
     if mode == "canny":
         return _preview_canny(control_image, canny_threshold_1, canny_threshold_2)
-    # For other modes you can plug in your own visualiser later
+    if mode == "tile":
+        return _preview_tile(control_image)
+    if mode == "depth":
+        return _preview_depth(control_image)
+    if mode == "blur":
+        return _preview_blur(control_image)
+    if mode == "pose":
+        return _preview_pose(control_image)
+    if mode == "gray":
+        return _preview_gray(control_image)
+    if mode == "low quality":
+        return _preview_low_quality(control_image)
+
+    # Fallback – should never happen due to early mode check
     return control_image