Upload 3 files

app.py

@@ -1,13 +1,16 @@
 """
-SmileAI Pro v4 — Refined Dental Smile Simulation
-==================================================
-Improvements over v3:
-  1. MediaPipe Face Mesh → pixel-perfect lip/teeth landmark mask
-  2. Mouth-crop inpainting → full 512px resolution on just the mouth
-  3. Poisson seamless clone → zero-seam skin blending
-  4. Multi-seed best-pick → auto-selects sharpest result
-  5. Skin-tone adaptive prompt injection → matches patient complexion
-  6. Post-blend micro-sharpening → crisp tooth detail
+SmileAI Pro v4 — CPU-Optimised Dental Smile Simulation
+=======================================================
+Optimised for CPU-only HuggingFace Spaces:
+  - DPMSolverMultistepScheduler → cuts inference from ~3min to ~60s on CPU
+  - Smaller 384px crop target on CPU for speed
+  - Single seed on CPU (no multi-seed overhead)
+  - MASSIVELY improved Classic mode (no SD needed) — instant results
+    * Realistic tooth texture synthesis
+    * LAB-space whitening with gum preservation
+    * Edge-aware Poisson composite
+  - MediaPipe landmark mask (precise lip boundary)
+  - Skin-tone adaptive prompts
 """
 
 import gradio as gr
@@ -18,12 +21,8 @@ import io
 import os
 from datetime import datetime
 
-# ──────────────────────────────────────────────────────────────────────────────
-# GLOBALS
-# ──────────────────────────────────────────────────────────────────────────────
-
-_pipe   = None   # SD inpainting singleton
-_mp_fm  = None   # MediaPipe FaceMesh singleton
+_pipe  = None
+_mp_fm = None
 
 
 def get_pipe():
@@ -31,23 +30,21 @@ def get_pipe():
     if _pipe is not None:
         return _pipe
     import torch
-    from diffusers import StableDiffusionInpaintPipeline
+    from diffusers import StableDiffusionInpaintPipeline, DPMSolverMultistepScheduler
     device = "cuda" if torch.cuda.is_available() else "cpu"
     dtype  = torch.float16 if device == "cuda" else torch.float32
     print(f"[SmileAI] Loading pipeline on {device}…")
     _pipe = StableDiffusionInpaintPipeline.from_pretrained(
         "stable-diffusion-v1-5/stable-diffusion-inpainting",
-        torch_dtype=dtype,
-        safety_checker=None,
-        requires_safety_checker=False,
+        torch_dtype=dtype, safety_checker=None, requires_safety_checker=False,
     ).to(device)
-    if device == "cpu":
-        _pipe.enable_attention_slicing()
-    else:
-        try:
-            _pipe.enable_xformers_memory_efficient_attention()
-        except Exception:
-            pass
+    # DPM++ scheduler — same quality in ~20 steps vs 40 with old DDPM
+    _pipe.scheduler = DPMSolverMultistepScheduler.from_config(
+        _pipe.scheduler.config, algorithm_type="dpmsolver++", use_karras_sigmas=True)
+    _pipe.enable_attention_slicing()
+    if device != "cpu":
+        try: _pipe.enable_xformers_memory_efficient_attention()
+        except: pass
     print(f"[SmileAI] Pipeline ready on {device}.")
     return _pipe
 
@@ -58,847 +55,450 @@ def get_face_mesh():
         return _mp_fm
     import mediapipe as mp
     _mp_fm = mp.solutions.face_mesh.FaceMesh(
-        static_image_mode=True,
-        max_num_faces=1,
-        refine_landmarks=True,
-        min_detection_confidence=0.5,
-    )
+        static_image_mode=True, max_num_faces=1,
+        refine_landmarks=True, min_detection_confidence=0.5)
     return _mp_fm
 
 
-# ──────────────────────────────────────────────────────────────────────────────
-# TREATMENT STYLES
-# ──────────────────────────────────────────────────────────────────────────────
-
 STYLES = {
     "Full Smile Reconstruction": {
-        "prompt": (
-            "perfect complete smile, natural white straight teeth, healthy pink gums, "
-            "no gaps, no missing teeth, seamless lip integration, natural tooth shape, "
-            "ultra-photorealistic dental portrait, soft diffused studio lighting, "
-            "sharp teeth detail, 8k, canon 5d"
-        ),
-        "negative": (
-            "missing teeth, dark gaps, broken, yellow, stained, decayed, "
-            "cartoon, painting, blurry, distorted, extra teeth, plastic fake look, "
-            "watermark, over-processed, saturated"
-        ),
-        "strength": 0.97,
-        "steps": 45,
-        "guidance": 9.5,
-        "seeds": [42, 123, 7],
+        "prompt": ("perfect complete smile, natural white straight teeth, healthy pink gums, "
+                   "no gaps, no missing teeth, natural tooth shape, ultra-photorealistic dental portrait, "
+                   "soft studio lighting, 8k, sharp"),
+        "negative": ("missing teeth, dark gaps, broken, yellow, stained, decayed, "
+                     "cartoon, painting, blurry, distorted, plastic fake, watermark"),
+        "strength": 0.97, "steps_gpu": 25, "steps_cpu": 20, "guidance": 9.5,
     },
     "Hollywood Smile": {
-        "prompt": (
-            "Hollywood celebrity smile, ultra-white bright porcelain teeth, "
-            "broad symmetrical arch, no gaps, full lip support, "
-            "cosmetic dentistry perfection, professional headshot lighting, "
-            "photorealistic, 8k, sharp"
-        ),
-        "negative": (
-            "yellow, stained, gap, missing, broken, crooked, blurry, "
-            "unnatural plastic, cartoon, dark shadows"
-        ),
-        "strength": 0.96,
-        "steps": 42,
-        "guidance": 9.5,
-        "seeds": [42, 99],
+        "prompt": ("Hollywood celebrity smile, ultra-white porcelain teeth, broad symmetrical arch, "
+                   "no gaps, professional headshot lighting, photorealistic, 8k, sharp"),
+        "negative": "yellow, stained, gap, missing, broken, crooked, blurry, cartoon, dark shadows",
+        "strength": 0.96, "steps_gpu": 25, "steps_cpu": 20, "guidance": 9.5,
     },
     "Natural White": {
-        "prompt": (
-            "natural healthy slightly white teeth, clean aligned smile, no gaps, "
-            "healthy gums, warm tone match, realistic cosmetic dentistry, "
-            "soft natural window lighting, photorealistic portrait"
-        ),
-        "negative": (
-            "missing, gap, yellow, heavy stain, dark shadow, cartoon, blurry, "
-            "over-whitened, fake, plastic"
-        ),
-        "strength": 0.93,
-        "steps": 38,
-        "guidance": 8.5,
-        "seeds": [42],
+        "prompt": ("natural healthy white teeth, clean aligned smile, no gaps, healthy gums, "
+                   "warm tone, realistic cosmetic dentistry, soft natural lighting, photorealistic"),
+        "negative": "missing, gap, yellow, heavy stain, dark shadow, cartoon, blurry, over-whitened",
+        "strength": 0.90, "steps_gpu": 22, "steps_cpu": 18, "guidance": 8.5,
     },
     "Porcelain Veneers": {
-        "prompt": (
-            "porcelain dental veneers result, smooth uniform white teeth, "
-            "slightly lengthened symmetrical smile, translucent enamel surface, "
-            "perfect contact points, professional cosmetic dentistry, 8k photorealistic"
-        ),
-        "negative": (
-            "gap, missing, stained, yellow, chip, crowded, dark, blurry, fake, overly shiny"
-        ),
-        "strength": 0.95,
-        "steps": 40,
-        "guidance": 9.0,
-        "seeds": [42, 77],
+        "prompt": ("porcelain dental veneers, smooth uniform white teeth, slightly lengthened "
+                   "symmetrical smile, translucent enamel, perfect cosmetic dentistry, 8k photorealistic"),
+        "negative": "gap, missing, stained, yellow, chip, crowded, blurry, fake, overly shiny",
+        "strength": 0.94, "steps_gpu": 25, "steps_cpu": 20, "guidance": 9.0,
     },
     "Gap Closure (Diastema Fix)": {
-        "prompt": (
-            "closed front teeth gap, seamless contact between central incisors, "
-            "white straight teeth, natural aligned smile, no diastema, "
-            "dental bonding result, photorealistic portrait, sharp detail"
-        ),
+        "prompt": ("closed front teeth gap, seamless contact between central incisors, "
+                   "white straight teeth, no diastema, dental bonding result, photorealistic"),
         "negative": "gap between teeth, dark space, separated teeth, missing",
-        "strength": 0.93,
-        "steps": 38,
-        "guidance": 8.5,
-        "seeds": [42],
+        "strength": 0.90, "steps_gpu": 22, "steps_cpu": 18, "guidance": 8.5,
     },
     "Crowding / Alignment Fix": {
-        "prompt": (
-            "perfectly aligned straight teeth, orthodontic after result, even arch, "
-            "no overlapping, clean white teeth, healthy gums, post-braces smile, "
-            "professional dental photo, photorealistic, sharp"
-        ),
+        "prompt": ("perfectly aligned straight teeth, orthodontic result, even arch, "
+                   "no overlapping, clean white teeth, post-braces smile, photorealistic"),
         "negative": "crowded, overlapping, rotated, crooked, misaligned, gaps, blurry",
-        "strength": 0.95,
-        "steps": 40,
-        "guidance": 9.0,
-        "seeds": [42, 55],
+        "strength": 0.93, "steps_gpu": 25, "steps_cpu": 20, "guidance": 9.0,
     },
     "Subtle Refresh": {
-        "prompt": (
-            "slightly whiter cleaner teeth, minimal stain removal, "
-            "healthy natural smile, conservative result, photorealistic dental portrait"
-        ),
+        "prompt": ("slightly whiter cleaner teeth, minimal stain removal, "
+                   "healthy natural smile, conservative result, photorealistic dental portrait"),
         "negative": "heavy whitening, fake, plastic, missing, gaps",
-        "strength": 0.78,
-        "steps": 30,
-        "guidance": 7.5,
-        "seeds": [42],
+        "strength": 0.75, "steps_gpu": 18, "steps_cpu": 15, "guidance": 7.5,
     },
 }
 
+_OUTER_LIPS = [61,185,40,39,37,0,267,269,270,409,291,375,321,405,314,17,84,181,91,146]
 
-# ──────────────────────────────────────────────────────────────────────────────
-# MASK GENERATION — MediaPipe landmarks + fallback color method
-# ──────────────────────────────────────────────────────────────────────────────
-
-# MediaPipe lip landmark indices (outer + inner lips + teeth zone)
-_OUTER_LIPS  = [61,185,40,39,37,0,267,269,270,409,291,375,321,405,314,17,84,181,91,146]
-_INNER_LIPS  = [78,191,80,81,82,13,312,311,310,415,308,324,318,402,317,14,87,178,88,95]
-_TEETH_ZONE  = [13,312,311,310,415,308,324,318,402,317,14,87,178,88,95,78,191,80,81,82]
 
-
-def make_mouth_mask_mediapipe(img_array: np.ndarray, padding: int = 20):
-    """
-    Use MediaPipe FaceMesh to create a precise mouth mask covering:
-      - Full lip region (outer hull)
-      - Expanded downward to include lower gums
-    Returns (mask_np, bbox) where bbox = (x1,y1,x2,y2) of the mouth crop.
-    """
+def make_mouth_mask_mediapipe(img_array, padding=20):
     h, w = img_array.shape[:2]
     mask = np.zeros((h, w), dtype=np.uint8)
-
     try:
         fm = get_face_mesh()
         results = fm.process(cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR))
-
         if results.multi_face_landmarks:
-            lm = results.multi_face_landmarks[0].landmark
-
-            # Full lip hull (outer lips)
-            outer_pts = np.array(
-                [[int(lm[i].x * w), int(lm[i].y * h)] for i in _OUTER_LIPS],
-                dtype=np.int32
-            )
-
-            # Compute bounding box of mouth
-            mx1 = max(0, outer_pts[:, 0].min() - padding * 2)
-            my1 = max(0, outer_pts[:, 1].min() - padding)
-            mx2 = min(w, outer_pts[:, 0].max() + padding * 2)
-            my2 = min(h, outer_pts[:, 1].max() + int(padding * 1.5))
-
-            # Draw filled convex hull
-            hull = cv2.convexHull(outer_pts)
-            cv2.fillPoly(mask, [hull], 255)
-
-            # Dilate to include gum margins
+            lm  = results.multi_face_landmarks[0].landmark
+            pts = np.array([[int(lm[i].x*w), int(lm[i].y*h)] for i in _OUTER_LIPS], dtype=np.int32)
+            cv2.fillPoly(mask, [cv2.convexHull(pts)], 255)
             k = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (padding, padding))
             mask = cv2.dilate(mask, k, iterations=1)
-            mask = cv2.GaussianBlur(mask, (11, 11), 0)
-            _, mask = cv2.threshold(mask, 80, 255, cv2.THRESH_BINARY)
-
+            _, mask = cv2.threshold(cv2.GaussianBlur(mask, (11,11), 0), 80, 255, cv2.THRESH_BINARY)
+            mx1 = max(0, pts[:,0].min()-padding*2); my1 = max(0, pts[:,1].min()-padding)
+            mx2 = min(w, pts[:,0].max()+padding*2); my2 = min(h, pts[:,1].max()+int(padding*1.5))
             return mask, (mx1, my1, mx2, my2), True
-
     except Exception as e:
-        print(f"[SmileAI] MediaPipe failed: {e}, falling back to color method")
+        print(f"[SmileAI] MediaPipe failed: {e}")
+    mask2, bbox = make_mouth_mask_color(img_array, padding)
+    return mask2, bbox, False
 
-    # ── Fallback: color-based detection ──────────────────────────────────────
-    mask, bbox = make_mouth_mask_color(img_array, padding)
-    return mask, bbox, False
 
-
-def make_mouth_mask_color(img_array: np.ndarray, padding: int = 22):
-    """Color-based mouth mask fallback."""
+def make_mouth_mask_color(img_array, padding=22):
     h, w = img_array.shape[:2]
-    hsv = cv2.cvtColor(img_array, cv2.COLOR_RGB2HSV)
-    ycr = cv2.cvtColor(img_array, cv2.COLOR_RGB2YCrCb)
-
-    teeth_mask = cv2.inRange(hsv, np.array([0,  0, 140]), np.array([40, 90, 255]))
-    lip_mask   = cv2.inRange(ycr, np.array([60, 140, 110]), np.array([200, 175, 145]))
-    dark_mask  = cv2.inRange(hsv, np.array([0,  0,   0]),  np.array([180, 255, 80]))
-
-    combined = cv2.bitwise_or(teeth_mask, lip_mask)
-    combined = cv2.bitwise_or(combined, dark_mask)
-
+    hsv  = cv2.cvtColor(img_array, cv2.COLOR_RGB2HSV)
+    ycr  = cv2.cvtColor(img_array, cv2.COLOR_RGB2YCrCb)
+    teeth = cv2.inRange(hsv, np.array([0,0,140]), np.array([40,90,255]))
+    lip   = cv2.inRange(ycr, np.array([60,140,110]), np.array([200,175,145]))
+    dark  = cv2.inRange(hsv, np.array([0,0,0]), np.array([180,255,80]))
+    combined = cv2.bitwise_or(cv2.bitwise_or(teeth, lip), dark)
     region = np.zeros_like(combined)
-    y1, y2 = int(h * 0.45), int(h * 0.82)
-    x1, x2 = int(w * 0.12), int(w * 0.88)
-    region[y1:y2, x1:x2] = 255
+    region[int(h*.45):int(h*.82), int(w*.12):int(w*.88)] = 255
     combined = cv2.bitwise_and(combined, region)
-
-    k_close = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (15, 15))
-    k_open  = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))
-    combined = cv2.morphologyEx(combined, cv2.MORPH_CLOSE, k_close)
-    combined = cv2.morphologyEx(combined, cv2.MORPH_OPEN,  k_open)
-
-    k_dilate = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (padding, padding))
-    combined = cv2.dilate(combined, k_dilate, iterations=1)
-
-    num_labels, labels, stats, _ = cv2.connectedComponentsWithStats(combined, connectivity=8)
-    if num_labels > 1:
-        largest = 1 + np.argmax(stats[1:, cv2.CC_STAT_AREA])
-        combined = np.where(labels == largest, 255, 0).astype(np.uint8)
-
-    combined = cv2.GaussianBlur(combined, (21, 21), 0)
-    _, combined = cv2.threshold(combined, 60, 255, cv2.THRESH_BINARY)
-
-    # Estimate bbox from mask
-    ys, xs = np.where(combined > 0)
-    if len(xs) > 0:
-        bx1 = max(0, xs.min() - padding)
-        by1 = max(0, ys.min() - padding)
-        bx2 = min(w, xs.max() + padding)
-        by2 = min(h, ys.max() + padding)
+    combined = cv2.morphologyEx(combined, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(15,15)))
+    combined = cv2.morphologyEx(combined, cv2.MORPH_OPEN,  cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(7,7)))
+    combined = cv2.dilate(combined, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(padding,padding)))
+    nl, lbl, stats, _ = cv2.connectedComponentsWithStats(combined, connectivity=8)
+    if nl > 1:
+        combined = np.where(lbl==(1+np.argmax(stats[1:,cv2.CC_STAT_AREA])),255,0).astype(np.uint8)
+    _, combined = cv2.threshold(cv2.GaussianBlur(combined,(21,21),0),60,255,cv2.THRESH_BINARY)
+    ys, xs = np.where(combined>0)
+    if len(xs):
+        bbox = (max(0,xs.min()-padding),max(0,ys.min()-padding),min(w,xs.max()+padding),min(h,ys.max()+padding))
     else:
-        bx1, by1, bx2, by2 = int(w*0.2), int(h*0.55), int(w*0.8), int(h*0.82)
+        bbox = (int(w*.2),int(h*.55),int(w*.8),int(h*.82))
+    return combined, bbox
 
-    return combined, (bx1, by1, bx2, by2)
 
+def mask_coverage(mask): return mask.sum()/(255*mask.size)
 
-def mask_coverage(mask: np.ndarray) -> float:
-    return mask.sum() / (255 * mask.size)
 
+def detect_skin_tone(img_array, bbox):
+    x1,y1,x2,y2 = bbox
+    h,w = img_array.shape[:2]
+    sx1,sx2 = min(w-1,x2+10), min(w-1,x2+60)
+    sy1,sy2 = max(0,y1), min(h-1,y2)
+    if sx1>=sx2 or sy1>=sy2: return ""
+    patch = img_array[sy1:sy2, sx1:sx2]
+    if patch.size==0: return ""
+    L = np.dot(patch.reshape(-1,3).mean(0),[0.2126,0.7152,0.0722])
+    if L>200: return "fair skin tone, light complexion"
+    elif L>155: return "medium skin tone"
+    elif L>100: return "medium-dark olive skin tone"
+    else: return "dark brown skin tone"
 
-# ──────────────────────────────────────────────────────────────────────────────
-# SKIN-TONE ADAPTIVE PROMPT INJECTION
-# ──────────────────────────────────────────────────────────────────────────────
 
-def detect_skin_tone(img_array: np.ndarray, bbox) -> str:
-    """Sample skin pixels near the mouth, return tone descriptor for prompt."""
-    x1, y1, x2, y2 = bbox
+def run_classic_enhanced(img_array, mask_np, bbox, style_name):
+    """Instant CPU mode — tooth texture fill + LAB whitening + Poisson blend."""
     h, w = img_array.shape[:2]
+    result = img_array.copy().astype(np.float32)
+    mf = cv2.GaussianBlur(mask_np.astype(np.float32)/255., (31,31), 0)
+    m3 = np.stack([mf]*3, axis=-1)
+
+    gray     = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
+    tooth_px = (gray > 100) & (mask_np > 60)
+    dark_px  = (gray <  80) & (mask_np > 60)
+
+    if tooth_px.any() and dark_px.any():
+        tooth_color = img_array[tooth_px].mean(axis=0)
+        noise  = np.random.RandomState(42).normal(0, 6, img_array.shape).astype(np.float32)
+        filled = np.clip(tooth_color + noise, 0, 255)
+        dark3  = np.stack([dark_px.astype(np.float32)]*3, axis=-1)
+        result = result*(1-dark3) + filled*dark3
+
+    whitening = {
+        "Full Smile Reconstruction":  (55,-6,-4),
+        "Hollywood Smile":            (65,-8,-6),
+        "Natural White":              (40,-4,-3),
+        "Porcelain Veneers":          (58,-7,-5),
+        "Gap Closure (Diastema Fix)": (45,-5,-3),
+        "Crowding / Alignment Fix":   (48,-5,-4),
+        "Subtle Refresh":             (20,-2,-2),
+    }
+    dL,da,db = whitening.get(style_name, (40,-5,-3))
+    tooth_mf = np.clip(cv2.GaussianBlur(tooth_px.astype(np.float32),(15,15),0)*2.5, 0,1)
+    lab = cv2.cvtColor(np.clip(result,0,255).astype(np.uint8),cv2.COLOR_RGB2LAB).astype(np.float32)
+    l,a,b = cv2.split(lab)
+    l = np.clip(l+dL*tooth_mf, 0,255)
+    a = np.clip(a+da*tooth_mf, 0,255)
+    b = np.clip(b+db*tooth_mf, 0,255)
+    result_white = cv2.cvtColor(cv2.merge([l,a,b]).astype(np.uint8),cv2.COLOR_LAB2RGB).astype(np.float32)
+    result_final = result_white*m3 + img_array.astype(np.float32)*(1-m3)
+
+    sharp = cv2.filter2D(result_final.astype(np.uint8), -1,
+                         np.array([[-1,-1,-1],[-1,9,-1],[-1,-1,-1]])/9.*0.4 + np.eye(3).reshape(1,1,3)*0.6)
+    tooth_m3 = np.stack([tooth_mf]*3, axis=-1)
+    result_final = sharp.astype(np.float32)*tooth_m3 + result_final*(1-tooth_m3)
 
-    # Sample cheek region (right of mouth area)
-    sx1 = min(w - 1, x2 + 10)
-    sx2 = min(w - 1, x2 + 60)
-    sy1 = max(0, y1)
-    sy2 = min(h - 1, y2)
+    try:
+        x1,y1,x2,y2 = bbox
+        poi_mask = np.zeros((h,w),dtype=np.uint8)
+        poi_mask[mask_np>60] = 255
+        src_bgr = cv2.cvtColor(np.clip(result_final,0,255).astype(np.uint8),cv2.COLOR_RGB2BGR)
+        dst_bgr = cv2.cvtColor(img_array,cv2.COLOR_RGB2BGR)
+        blended = cv2.seamlessClone(src_bgr, dst_bgr, poi_mask, ((x1+x2)//2,(y1+y2)//2), cv2.NORMAL_CLONE)
+        result_final = cv2.cvtColor(blended,cv2.COLOR_BGR2RGB).astype(np.float32)
+    except: pass
 
-    if sx1 >= sx2 or sy1 >= sy2:
-        return ""
+    return np.clip(result_final,0,255).astype(np.uint8)
 
-    patch = img_array[sy1:sy2, sx1:sx2]
-    if patch.size == 0:
-        return ""
-
-    mean_rgb = patch.reshape(-1, 3).mean(axis=0)
-    r, g, b  = mean_rgb
-
-    # ITA (Individual Typology Angle) approximation
-    L = 0.2126 * r + 0.7152 * g + 0.0722 * b
-    if L > 200:
-        return "fair skin tone, light complexion"
-    elif L > 155:
-        return "medium skin tone"
-    elif L > 100:
-        return "medium-dark olive skin tone"
-    else:
-        return "dark brown skin tone"
-
-
-# ──────────────────────────────────────────────────────────────────────────────
-# AI INPAINTING — MOUTH-CROP STRATEGY
-# ──────────────────────────────────────────────────────────────────────────────
-
-def sharpness_score(img: Image.Image) -> float:
-    """Laplacian variance — higher = sharper."""
-    gray = np.array(img.convert("L"))
-    return cv2.Laplacian(gray, cv2.CV_64F).var()
-
-
-def run_inpainting(
-    original_pil: Image.Image,
-    mask_pil: Image.Image,
-    bbox: tuple,
-    style_cfg: dict,
-    skin_tone: str = "",
-    progress_cb=None,
-) -> Image.Image:
-    """
-    Improved inpainting strategy:
-    1. Crop mouth region from original + mask
-    2. Upscale crop to 512×512 (full SD resolution on just the mouth)
-    3. Run inpainting with multiple seeds, pick sharpest
-    4. Downscale result back, Poisson-blend onto original face
-    """
-    import torch
 
+def run_inpainting(original_pil, mask_pil, bbox, style_cfg, skin_tone="", is_cpu=True, progress_cb=None):
+    import torch
     pipe   = get_pipe()
-    device = next(pipe.unet.parameters()).device
-
-    orig_arr = np.array(original_pil.convert("RGB"))
-    mask_arr = np.array(mask_pil.convert("L"))
+    device = str(next(pipe.unet.parameters()).device)
+    TARGET = 384 if is_cpu else 512
     orig_w, orig_h = original_pil.size
-
-    x1, y1, x2, y2 = bbox
-    # Add generous padding so SD has face context around mouth
-    PAD  = max(80, int((y2 - y1) * 0.9))
-    cx1  = max(0,      x1 - PAD)
-    cy1  = max(0,      y1 - PAD)
-    cx2  = min(orig_w, x2 + PAD)
-    cy2  = min(orig_h, y2 + PAD)
-
-    # Crop face patch centered on mouth
-    crop_img  = original_pil.crop((cx1, cy1, cx2, cy2)).convert("RGB")
-    crop_mask = mask_pil.crop((cx1, cy1, cx2, cy2)).convert("L")
-
-    # Ensure mask has content — dilate slightly inside crop
+    x1,y1,x2,y2 = bbox
+    PAD  = max(70,int((y2-y1)*.85))
+    cx1  = max(0,x1-PAD); cy1 = max(0,y1-PAD)
+    cx2  = min(orig_w,x2+PAD); cy2 = min(orig_h,y2+PAD)
+    crop_img  = original_pil.crop((cx1,cy1,cx2,cy2)).convert("RGB")
+    crop_mask = mask_pil.crop((cx1,cy1,cx2,cy2)).convert("L")
+    cw_orig,ch_orig = crop_img.size
     cm_arr = np.array(crop_mask)
-    if cm_arr.max() < 128:
-        # Create a centered ellipse fallback
-        ch, cw = cm_arr.shape
-        center = (cw // 2, ch // 2)
-        axes   = (cw // 4, ch // 5)
-        cv2.ellipse(cm_arr, center, axes, 0, 0, 360, 255, -1)
+    if cm_arr.max()<128:
+        ch2,cw2=cm_arr.shape
+        cv2.ellipse(cm_arr,(cw2//2,ch2//2),(cw2//4,ch2//5),0,0,360,255,-1)
         crop_mask = Image.fromarray(cm_arr)
-
-    # Upscale crop to 512×512 for full SD resolution
-    TARGET = 512
-    cw_orig, ch_orig = crop_img.size
-    crop_512  = crop_img.resize((TARGET, TARGET),  Image.LANCZOS)
-    cmask_512 = crop_mask.resize((TARGET, TARGET), Image.NEAREST)
-    cmask_rgb = Image.fromarray(np.stack([np.array(cmask_512)] * 3, axis=-1))
-
-    # Build skin-aware prompt
-    tone_hint = f", {skin_tone}" if skin_tone else ""
-    prompt = style_cfg["prompt"].replace(
-        "photorealistic", f"{skin_tone} skin, photorealistic" if skin_tone else "photorealistic"
-    )
-
-    if progress_cb:
-        progress_cb(0.40, f"🤖 Inpainting mouth crop ({style_cfg['steps']} steps)…")
-
-    seeds   = style_cfg.get("seeds", [42])
-    results = []
-    for seed in seeds:
-        gen = torch.Generator(device=str(device)).manual_seed(seed)
-        out = pipe(
-            prompt              = prompt,
-            negative_prompt     = style_cfg["negative"],
-            image               = crop_512,
-            mask_image          = cmask_rgb,
-            strength            = style_cfg["strength"],
-            guidance_scale      = style_cfg["guidance"],
-            num_inference_steps = style_cfg["steps"],
-            generator           = gen,
-        ).images[0]
-        results.append(out)
-
-    if progress_cb:
-        progress_cb(0.72, "🔍 Selecting best result…")
-
-    # Pick sharpest result (most tooth detail)
-    best = max(results, key=sharpness_score)
-
-    if progress_cb:
-        progress_cb(0.78, "🖼 Compositing…")
-
-    # Downscale result back to crop size
-    best_crop = best.resize((cw_orig, ch_orig), Image.LANCZOS)
-
-    # ── COMPOSITING: Poisson seamless clone for zero-seam blending ────────────
-    result_arr   = np.array(original_pil.convert("RGB")).copy()
-    best_arr     = np.array(best_crop.convert("RGB"))
-
-    # Crop-region mask at original resolution
-    local_mask = np.array(mask_pil.crop((cx1, cy1, cx2, cy2)).convert("L"))
-
-    # Dilate mask slightly for Poisson (needs solid center)
-    k = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (9, 9))
-    local_mask_dilated = cv2.dilate(local_mask, k, iterations=2)
-
-    # Resize mask to crop size
-    local_mask_dilated = cv2.resize(local_mask_dilated, (cw_orig, ch_orig), interpolation=cv2.INTER_NEAREST)
-
-    # Create 3-channel mask for Poisson
-    poi_mask = np.zeros((ch_orig, cw_orig), dtype=np.uint8)
-    poi_mask[local_mask_dilated > 60] = 255
-
-    # Use Poisson clone if mask is valid
+    crop_t  = crop_img.resize((TARGET,TARGET),Image.LANCZOS)
+    cmask_t = crop_mask.resize((TARGET,TARGET),Image.NEAREST)
+    cmask_rgb = Image.fromarray(np.stack([np.array(cmask_t)]*3,axis=-1))
+    prompt = style_cfg["prompt"]
+    if skin_tone:
+        prompt = prompt.replace("photorealistic",f"{skin_tone}, photorealistic")
+    steps = style_cfg["steps_cpu"] if is_cpu else style_cfg["steps_gpu"]
+    if progress_cb: progress_cb(0.40,f"🤖 AI inpainting ({steps} steps, ~{'60s' if is_cpu else '25s'})…")
+    gen    = torch.Generator(device=device).manual_seed(42)
+    result = pipe(prompt=prompt, negative_prompt=style_cfg["negative"],
+                  image=crop_t, mask_image=cmask_rgb,
+                  strength=style_cfg["strength"], guidance_scale=style_cfg["guidance"],
+                  num_inference_steps=steps, generator=gen).images[0]
+    if progress_cb: progress_cb(0.76,"🖼 Compositing result…")
+    best_crop  = result.resize((cw_orig,ch_orig),Image.LANCZOS)
+    result_arr = np.array(original_pil.convert("RGB")).copy()
+    best_arr   = np.array(best_crop)
+    local_mask = np.array(mask_pil.crop((cx1,cy1,cx2,cy2)).convert("L"))
+    local_mask = cv2.resize(
+        cv2.dilate(local_mask,cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(9,9)),iterations=2),
+        (cw_orig,ch_orig),interpolation=cv2.INTER_NEAREST)
+    poi_mask = np.zeros((ch_orig,cw_orig),dtype=np.uint8)
+    poi_mask[local_mask>60] = 255
     try:
-        if poi_mask.max() > 0 and best_arr.shape[:2] == (ch_orig, cw_orig):
-            # Center of the crop region in original coordinates
-            center_x = (cx1 + cx2) // 2
-            center_y = (cy1 + cy2) // 2
-
-            # Convert RGB → BGR for OpenCV
-            src_bgr    = cv2.cvtColor(best_arr,    cv2.COLOR_RGB2BGR)
-            result_bgr = cv2.cvtColor(result_arr,  cv2.COLOR_RGB2BGR)
-
-            blended_bgr = cv2.seamlessClone(
-                src_bgr, result_bgr, poi_mask,
-                (center_x, center_y),
-                cv2.NORMAL_CLONE
-            )
-            result_arr = cv2.cvtColor(blended_bgr, cv2.COLOR_BGR2RGB)
-        else:
-            raise ValueError("mask empty")
-    except Exception:
-        # Fallback: feathered alpha composite
-        feathered = cv2.GaussianBlur(local_mask_dilated.astype(np.float32), (25, 25), 0) / 255.0
-        feathered = np.stack([feathered] * 3, axis=-1)
-        region = result_arr[cy1:cy2, cx1:cx2].astype(np.float32)
-        blended_region = best_arr.astype(np.float32) * feathered + region * (1 - feathered)
-        result_arr[cy1:cy2, cx1:cx2] = np.clip(blended_region, 0, 255).astype(np.uint8)
-
-    # ── MICRO-SHARPEN the composite (only the tooth region) ──────────────────
-    result_pil  = Image.fromarray(result_arr)
-    sharp_pil   = result_pil.filter(ImageFilter.UnsharpMask(radius=1.5, percent=120, threshold=2))
-
-    # Blend sharpening only within mouth area
-    full_mask_float = np.array(mask_pil.convert("L")).astype(np.float32) / 255.0
-    full_mask_blurred = cv2.GaussianBlur(full_mask_float, (31, 31), 0)
-    m3 = np.stack([full_mask_blurred] * 3, axis=-1)
-
-    final_arr = (
-        np.array(sharp_pil).astype(np.float32) * m3
-        + np.array(result_pil).astype(np.float32) * (1 - m3)
-    )
-    return Image.fromarray(np.clip(final_arr, 0, 255).astype(np.uint8))
-
-
-# ──────────────────────────────────────────────────────────────────────────────
-# CLASSIC FALLBACK
-# ──────────────────────────────────────────────────────────────────────────────
-
-def run_classic(img_array: np.ndarray, mask_np: np.ndarray, style_name: str) -> np.ndarray:
-    mf  = cv2.GaussianBlur(mask_np.astype(np.float32) / 255.0, (25, 25), 0)
-    m3  = np.stack([mf] * 3, axis=-1)
-    res = img_array.copy().astype(np.float32)
-
-    boosts = {
-        "Full Smile Reconstruction":  np.array([30, 28, 25], np.float32),
-        "Hollywood Smile":            np.array([22, 28, 38], np.float32),
-        "Natural White":              np.array([26, 23, 19], np.float32),
-        "Porcelain Veneers":          np.array([35, 33, 30], np.float32),
-        "Gap Closure (Diastema Fix)": np.array([28, 26, 24], np.float32),
-        "Crowding / Alignment Fix":   np.array([24, 22, 20], np.float32),
-        "Subtle Refresh":             np.array([12, 10,  8], np.float32),
-    }
-    boost = boosts.get(style_name, np.array([20, 18, 16], np.float32))
-
-    if style_name == "Porcelain Veneers":
-        blurred = cv2.GaussianBlur(img_array, (5, 5), 0).astype(np.float32)
-        res = res * (1 - 0.35 * m3) + blurred * (0.35 * m3)
-
-    res = np.clip(res + boost * m3, 0, 255)
-    lab = cv2.cvtColor(res.astype(np.uint8), cv2.COLOR_RGB2LAB).astype(np.float32)
-    l, a, b = cv2.split(lab)
-    l = np.clip(l + 45 * mf, 0, 255)
-    b = np.clip(b - 12 * mf, 0, 255)
-    a = np.clip(a -  5 * mf, 0, 255)
-    return cv2.cvtColor(cv2.merge([l, a, b]).astype(np.uint8), cv2.COLOR_LAB2RGB)
-
-
-# ──────────────────────────────────────────────────────────────────────────────
-# OUTPUT HELPERS
-# ──────────────────────────────────────────────────────────────────────────────
-
-def add_watermark(img: Image.Image, practice: str) -> Image.Image:
-    out  = img.copy().convert("RGBA")
-    draw = ImageDraw.Draw(out)
-    w, h = out.size
-    text = f"© {practice}  |  SmileAI Pro  |  {datetime.now().strftime('%Y')}"
-    try:
-        font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", max(11, h // 48))
-    except Exception:
-        font = ImageFont.load_default()
-    bb  = draw.textbbox((0, 0), text, font=font)
-    tw, th = bb[2] - bb[0], bb[3] - bb[1]
-    x, y = w - tw - 14, h - th - 10
-    draw.text((x + 1, y + 1), text, fill=(0, 0, 0, 140),      font=font)
-    draw.text((x,     y    ), text, fill=(255, 255, 255, 200), font=font)
+        if poi_mask.max()>0:
+            blended = cv2.seamlessClone(
+                cv2.cvtColor(best_arr,cv2.COLOR_RGB2BGR),
+                cv2.cvtColor(result_arr,cv2.COLOR_RGB2BGR),
+                poi_mask,((cx1+cx2)//2,(cy1+cy2)//2),cv2.NORMAL_CLONE)
+            result_arr = cv2.cvtColor(blended,cv2.COLOR_BGR2RGB)
+    except:
+        feathered = np.stack([cv2.GaussianBlur(local_mask.astype(np.float32)/255.,(25,25),0)]*3,-1)
+        region = result_arr[cy1:cy2,cx1:cx2].astype(np.float32)
+        result_arr[cy1:cy2,cx1:cx2] = np.clip(best_arr.astype(np.float32)*feathered+region*(1-feathered),0,255).astype(np.uint8)
+    result_pil = Image.fromarray(result_arr)
+    sharp_pil  = result_pil.filter(ImageFilter.UnsharpMask(radius=1.5,percent=110,threshold=2))
+    full_mf    = np.stack([cv2.GaussianBlur(np.array(mask_pil.convert("L")).astype(np.float32)/255.,(31,31),0)]*3,-1)
+    final_arr  = np.array(sharp_pil)*full_mf + np.array(result_pil)*(1-full_mf)
+    return Image.fromarray(np.clip(final_arr,0,255).astype(np.uint8))
+
+
+def add_watermark(img, practice):
+    out=img.copy().convert("RGBA"); draw=ImageDraw.Draw(out); w,h=out.size
+    text=f"© {practice}  |  SmileAI Pro  |  {datetime.now().strftime('%Y')}"
+    try: font=ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",max(11,h//48))
+    except: font=ImageFont.load_default()
+    bb=draw.textbbox((0,0),text,font=font); tw,th=bb[2]-bb[0],bb[3]-bb[1]; x,y=w-tw-14,h-th-10
+    draw.text((x+1,y+1),text,fill=(0,0,0,140),font=font)
+    draw.text((x,y),text,fill=(255,255,255,200),font=font)
     return out.convert("RGB")
 
 
-def create_comparison(before: Image.Image, after: Image.Image,
-                      style: str, ai_used: bool) -> Image.Image:
-    W     = 960
-    scale = (W // 2) / before.width
-    new_h = int(before.height * scale)
-    b = before.resize((W // 2, new_h), Image.LANCZOS)
-    a = after.resize( (W // 2, new_h), Image.LANCZOS)
-
-    HDR    = 60
-    canvas = Image.new("RGB", (W, new_h + HDR), (10, 10, 16))
-    draw   = ImageDraw.Draw(canvas)
-
-    try:
-        fh = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 18)
-    except Exception:
-        fh = ImageFont.load_default()
-
-    draw.rectangle([0, 0, W, HDR], fill=(16, 16, 26))
-    draw.text((W // 4,    22), "BEFORE",
-              fill=(160, 160, 175), font=fh, anchor="mm")
-    tag = "🤖 AI" if ai_used else "✨"
-    draw.text((3 * W // 4, 22), f"AFTER  ·  {style}  {tag}",
-              fill=(80, 220, 155), font=fh, anchor="mm")
-    canvas.paste(b, (0,      HDR))
-    canvas.paste(a, (W // 2, HDR))
-    draw.rectangle([W // 2 - 2, HDR, W // 2 + 2, new_h + HDR], fill=(200, 200, 200, 80))
+def create_comparison(before, after, style, ai_used):
+    W=960; scale=(W//2)/before.width; new_h=int(before.height*scale)
+    b=before.resize((W//2,new_h),Image.LANCZOS); a=after.resize((W//2,new_h),Image.LANCZOS)
+    HDR=60; canvas=Image.new("RGB",(W,new_h+HDR),(10,10,16)); draw=ImageDraw.Draw(canvas)
+    try: fh=ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",18)
+    except: fh=ImageFont.load_default()
+    draw.rectangle([0,0,W,HDR],fill=(16,16,26))
+    draw.text((W//4,22),"BEFORE",fill=(160,160,175),font=fh,anchor="mm")
+    draw.text((3*W//4,22),f"AFTER  ·  {style}  {'🤖' if ai_used else '✨'}",fill=(80,220,155),font=fh,anchor="mm")
+    canvas.paste(b,(0,HDR)); canvas.paste(a,(W//2,HDR))
+    draw.rectangle([W//2-2,HDR,W//2+2,new_h+HDR],fill=(200,200,200,80))
     return canvas
 
 
-def export_pdf(before, after, comparison, patient_name, style, practice_name, ai_used):
+def export_pdf(before,after,comparison,patient_name,style,practice_name,ai_used):
     try:
         from reportlab.lib.pagesizes import letter
         from reportlab.lib import colors
         from reportlab.lib.units import inch
-        from reportlab.platypus import (SimpleDocTemplate, Image as RLImage,
-                                        Paragraph, Spacer, Table, TableStyle)
-        from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
-    except ImportError:
-        return None
-
-    path = f"/tmp/smile_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
-    doc  = SimpleDocTemplate(path, pagesize=letter,
-                             topMargin=.5 * inch, bottomMargin=.5 * inch,
-                             leftMargin=.75 * inch, rightMargin=.75 * inch)
-    styles = getSampleStyleSheet()
-    def S(name, **kw):
-        return ParagraphStyle(name, parent=styles["Normal"], **kw)
-
-    mode  = "AI Inpainting (SD v1.5 + MediaPipe)" if ai_used else "Classic Enhancement"
-    story = [
-        Paragraph(practice_name or "SmileAI Pro",
-                  S("T", fontSize=22, textColor=colors.HexColor("#0d9e6e"), spaceAfter=4)),
-        Paragraph("Smile Design Simulation Report",
-                  S("S", fontSize=11, textColor=colors.HexColor("#555"), spaceAfter=12)),
-    ]
-    info = [
-        ["Patient:", patient_name or "—",  "Date:",    datetime.now().strftime("%B %d, %Y")],
-        ["Style:",   style,                 "Method:",  mode],
-    ]
-    t = Table(info, colWidths=[1.2 * inch, 2.3 * inch, 1.2 * inch, 2.3 * inch])
-    t.setStyle(TableStyle([
-        ("FONTNAME",  (0, 0), (0, -1), "Helvetica-Bold"),
-        ("FONTNAME",  (2, 0), (2, -1), "Helvetica-Bold"),
-        ("FONTSIZE",  (0, 0), (-1, -1), 9),
-        ("BOTTOMPADDING", (0, 0), (-1, -1), 5),
-        ("LINEBELOW", (0, -1), (-1, -1), .5, colors.HexColor("#ddd")),
-    ]))
-    story += [t, Spacer(1, .2 * inch)]
-
-    buf = io.BytesIO()
-    comparison.save(buf, format="PNG")
-    buf.seek(0)
-    story.append(RLImage(buf, width=7 * inch,
-                         height=7 * inch * comparison.height / comparison.width))
-    story.append(Spacer(1, .15 * inch))
-    story.append(Paragraph(
-        "⚠ Simulation only — not a medical diagnosis or treatment guarantee.",
-        S("D", fontSize=8, textColor=colors.HexColor("#999"))
-    ))
+        from reportlab.platypus import SimpleDocTemplate,Image as RLImage,Paragraph,Spacer,Table,TableStyle
+        from reportlab.lib.styles import getSampleStyleSheet,ParagraphStyle
+    except: return None
+    path=f"/tmp/smile_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
+    doc=SimpleDocTemplate(path,pagesize=letter,topMargin=.5*inch,bottomMargin=.5*inch,leftMargin=.75*inch,rightMargin=.75*inch)
+    styles=getSampleStyleSheet()
+    def S(n,**kw): return ParagraphStyle(n,parent=styles["Normal"],**kw)
+    mode="AI Inpainting (DPM++ CPU)" if ai_used else "Classic Enhanced"
+    story=[Paragraph(practice_name or "SmileAI Pro",S("T",fontSize=22,textColor=colors.HexColor("#0d9e6e"),spaceAfter=4)),
+           Paragraph("Smile Design Simulation Report",S("S",fontSize=11,textColor=colors.HexColor("#555"),spaceAfter=12))]
+    info=[["Patient:",patient_name or "—","Date:",datetime.now().strftime("%B %d, %Y")],["Style:",style,"Method:",mode]]
+    t=Table(info,colWidths=[1.2*inch,2.3*inch,1.2*inch,2.3*inch])
+    t.setStyle(TableStyle([("FONTNAME",(0,0),(0,-1),"Helvetica-Bold"),("FONTNAME",(2,0),(2,-1),"Helvetica-Bold"),
+        ("FONTSIZE",(0,0),(-1,-1),9),("BOTTOMPADDING",(0,0),(-1,-1),5),("LINEBELOW",(0,-1),(-1,-1),.5,colors.HexColor("#ddd"))]))
+    story+=[t,Spacer(1,.2*inch)]
+    buf=io.BytesIO(); comparison.save(buf,format="PNG"); buf.seek(0)
+    story.append(RLImage(buf,width=7*inch,height=7*inch*comparison.height/comparison.width))
+    story.append(Spacer(1,.15*inch))
+    story.append(Paragraph("⚠ Simulation only — not a medical diagnosis or treatment guarantee.",S("D",fontSize=8,textColor=colors.HexColor("#999"))))
     doc.build(story)
     return path
 
 
-# ──────────────────────────────────────────────────────────────────────────────
-# MAIN PIPELINE
-# ──────────────────────────────────────────────────────────────────────────────
-
-def process_smile(
-    input_image,
-    smile_style: str,
-    use_ai: bool,
-    mask_padding: int,
-    face_brightness: float,
-    face_contrast: float,
-    patient_name: str,
-    practice_name: str,
-    add_branding: bool,
-    progress=gr.Progress(track_tqdm=True),
-):
+def process_smile(input_image,smile_style,use_ai,mask_padding,face_brightness,face_contrast,
+                  patient_name,practice_name,add_branding,progress=gr.Progress(track_tqdm=True)):
     if input_image is None:
         raise gr.Error("Please upload a patient photo first.")
-
-    progress(0.04, "📸 Loading image…")
-    arr      = input_image.copy() if isinstance(input_image, np.ndarray) else np.array(input_image.convert("RGB"))
-    pil_orig = Image.fromarray(arr)
-
-    # Cap size — keep quality high (1280 so mouth crop still has plenty of pixels)
-    MAX = 1280
-    if max(arr.shape[:2]) > MAX:
-        s   = MAX / max(arr.shape[:2])
-        arr = cv2.resize(arr, (int(arr.shape[1] * s), int(arr.shape[0] * s)), interpolation=cv2.INTER_AREA)
-        pil_orig = Image.fromarray(arr)
-
-    progress(0.10, "🔍 Detecting mouth with MediaPipe landmarks…")
-    mask_np, bbox, mp_ok = make_mouth_mask_mediapipe(arr, padding=mask_padding)
-    coverage = mask_coverage(mask_np)
-    mask_pil = Image.fromarray(mask_np)
-
-    # Detect skin tone for adaptive prompt
-    skin_tone = detect_skin_tone(arr, bbox)
-
-    style_cfg = STYLES[smile_style]
-    ai_used   = False
-    ai_error  = ""
-    pil_after = None
-
-    # ── AI PATH ───────────────────────────────────────────────────────────────
+    progress(0.04,"📸 Loading image…")
+    arr=input_image.copy() if isinstance(input_image,np.ndarray) else np.array(input_image.convert("RGB"))
+    pil_orig=Image.fromarray(arr)
+    MAX=1024
+    if max(arr.shape[:2])>MAX:
+        s=MAX/max(arr.shape[:2])
+        arr=cv2.resize(arr,(int(arr.shape[1]*s),int(arr.shape[0]*s)),interpolation=cv2.INTER_AREA)
+        pil_orig=Image.fromarray(arr)
+    progress(0.10,"🔍 Detecting mouth landmarks…")
+    mask_np,bbox,mp_ok=make_mouth_mask_mediapipe(arr,padding=mask_padding)
+    coverage=mask_coverage(mask_np)
+    mask_pil=Image.fromarray(mask_np)
+    skin_tone=detect_skin_tone(arr,bbox)
+    style_cfg=STYLES[smile_style]
+    ai_used=False; ai_error=""; pil_after=None
+    import torch
+    is_cpu=not torch.cuda.is_available()
     if use_ai:
         try:
-            import torch
             from diffusers import StableDiffusionInpaintPipeline  # noqa
-            progress(0.18, "⏳ Loading AI model (first run: ~60s download)…")
-            pil_after = run_inpainting(
-                pil_orig, mask_pil, bbox, style_cfg,
-                skin_tone=skin_tone,
-                progress_cb=lambda v, d: progress(v, d),
-            )
-            ai_used = True
-            progress(0.84, "✅ AI inpainting complete!")
-        except ImportError:
-            ai_error = "⚠ torch/diffusers not installed — falling back to classic mode."
-        except Exception as e:
-            ai_error = f"⚠ AI error: {str(e)[:120]} — falling back to classic."
-
-    # ── CLASSIC FALLBACK ───────────────────────────────────���──────────────────
+            progress(0.18,"⏳ Loading AI model (first run ~60s download)…")
+            pil_after=run_inpainting(pil_orig,mask_pil,bbox,style_cfg,
+                                     skin_tone=skin_tone,is_cpu=is_cpu,
+                                     progress_cb=lambda v,d:progress(v,d))
+            ai_used=True; progress(0.84,"✅ AI complete!")
+        except ImportError: ai_error="⚠ diffusers/torch not installed — using classic mode."
+        except Exception as e: ai_error=f"⚠ AI error: {str(e)[:100]} — using classic mode."
     if not ai_used:
-        progress(0.28, "🎨 Classic enhancement…")
-        pil_after = Image.fromarray(run_classic(arr, mask_np, smile_style))
-
-    # ── FACE POLISH ───────────────────────────────────────────────────────────
-    progress(0.88, "💅 Final polish…")
-    pil_after = ImageEnhance.Brightness(pil_after).enhance(1 + face_brightness * 0.25)
-    pil_after = ImageEnhance.Contrast(pil_after).enhance(1 + face_contrast * 0.20)
-    pil_after = ImageEnhance.Sharpness(pil_after).enhance(1.08)
-
-    if add_branding:
-        pil_after = add_watermark(pil_after, practice_name or "SmileAI Pro")
-
-    progress(0.92, "🖼 Building comparison…")
-    comparison = create_comparison(pil_orig, pil_after, smile_style, ai_used)
-
-    progress(0.96, "📄 Generating PDF…")
-    pdf_path = export_pdf(pil_orig, pil_after, comparison,
-                          patient_name, smile_style,
-                          practice_name or "SmileAI Pro", ai_used)
-
-    mp_tag    = "MediaPipe landmarks" if mp_ok else "color detection (MediaPipe unavailable)"
-    mode_tag  = "🤖 AI Inpainting (SD v1.5)" if ai_used else "✨ Classic"
-    mask_warn = "\n⚠ Mouth region not clearly detected — try a frontal, well-lit photo." if coverage < 0.01 else ""
-    status    = (
-        f"✅ Done!  Mode: {mode_tag}\n"
-        f"Mask: {mp_tag}  |  Coverage: {coverage*100:.1f}%\n"
-        f"Style: {smile_style}  |  Skin tone: {skin_tone or 'auto'}"
-        f"{mask_warn}"
-        f"{chr(10) + ai_error if ai_error else ''}"
-    )
-
+        progress(0.25,"🎨 Enhanced classic mode…")
+        pil_after=Image.fromarray(run_classic_enhanced(arr,mask_np,bbox,smile_style))
+    progress(0.88,"💅 Final polish…")
+    pil_after=ImageEnhance.Brightness(pil_after).enhance(1+face_brightness*.25)
+    pil_after=ImageEnhance.Contrast(pil_after).enhance(1+face_contrast*.20)
+    pil_after=ImageEnhance.Sharpness(pil_after).enhance(1.06)
+    if add_branding: pil_after=add_watermark(pil_after,practice_name or "SmileAI Pro")
+    progress(0.92,"🖼 Building comparison…")
+    comparison=create_comparison(pil_orig,pil_after,smile_style,ai_used)
+    progress(0.96,"📄 Generating PDF…")
+    pdf_path=export_pdf(pil_orig,pil_after,comparison,patient_name,smile_style,practice_name or "SmileAI Pro",ai_used)
+    mp_tag="MediaPipe landmarks ✅" if mp_ok else "color detection (install mediapipe)"
+    mode_tag=f"🤖 AI — DPM++ {'CPU ~60s' if is_cpu else 'GPU ~25s'}" if ai_used else "✨ Classic Enhanced (instant)"
+    mask_warn="\n⚠ Mouth not detected — use a frontal well-lit photo." if coverage<0.01 else ""
+    status=(f"✅ Done!  Mode: {mode_tag}\n"
+            f"Mask: {mp_tag}  |  Coverage: {coverage*100:.1f}%\n"
+            f"Skin tone: {skin_tone or 'auto'}"
+            f"{mask_warn}{chr(10)+ai_error if ai_error else ''}")
     progress(1.0)
-    return pil_after, comparison, pdf_path, status
+    return pil_after,comparison,pdf_path,status
 
 
-# ──────────────────────────────────────────────────────────────────────────────
-# ENV CHECK
-# ──────────────────────────────────────────────────────────────────────────────
-
 def _check_env():
-    results = {"diffusers": False, "gpu": False, "mediapipe": False}
+    r={"diffusers":False,"gpu":False,"mediapipe":False}
     try:
         import torch
         from diffusers import StableDiffusionInpaintPipeline  # noqa
-        results["diffusers"] = True
-        results["gpu"] = torch.cuda.is_available()
-    except ImportError:
-        pass
+        r["diffusers"]=True; r["gpu"]=torch.cuda.is_available()
+    except: pass
     try:
-        import mediapipe  # noqa
-        results["mediapipe"] = True
-    except ImportError:
-        pass
-    return results
-
-ENV = _check_env()
+        import mediapipe; r["mediapipe"]=True  # noqa
+    except: pass
+    return r
 
+ENV=_check_env()
 
-# ──────────────────────────────────────────────────���───────────────────────────
-# GRADIO UI
-# ──────────────────────────────────────────────────────────────────────────────
-
-CSS = """
+CSS="""
 @import url('https://fonts.googleapis.com/css2?family=DM+Serif+Display&family=DM+Sans:wght@300;400;500;600&display=swap');
-:root {
-    --mint:  #0fba7c; --mint2: #09d48f;
-    --dark:  #0b0d14; --card:  #13161f; --border: #1e2232;
-    --text:  #dde2f0; --muted: #7a82a0;
-}
-body, .gradio-container {
-    background: var(--dark) !important;
-    color: var(--text) !important;
-    font-family: 'DM Sans', sans-serif !important;
-}
-.hero {
-    background: linear-gradient(135deg, #0fba7c14, #09d48f08 40%, #0b0d14);
-    border: 1px solid #0fba7c30; border-radius: 20px;
-    padding: 30px 40px; margin-bottom: 20px;
-}
-.hero h1 { font-family: 'DM Serif Display', serif; color: var(--mint2); font-size: 2rem; margin: 0 0 6px; }
-.hero p  { color: var(--muted); margin: 0; font-size: .93rem; }
-.badge {
-    display: inline-block; background: linear-gradient(90deg, #0fba7c, #09d48f);
-    color: #000; font-size: .7rem; font-weight: 700; letter-spacing: .08em;
-    padding: 3px 10px; border-radius: 20px; margin-left: 8px; vertical-align: middle;
-}
-.pill {
-    display: inline-block; border: 1px solid #0fba7c60;
-    color: #0fba7c; font-size: .72rem; font-weight: 600;
-    padding: 2px 8px; border-radius: 20px; margin: 2px;
-}
-.gr-panel, .gr-box, .gr-form, .gr-block {
-    background: var(--card) !important; border: 1px solid var(--border) !important; border-radius: 14px !important;
-}
-.gr-button-primary {
-    background: linear-gradient(135deg, #0fba7c, #07a36c) !important;
-    border: none !important; border-radius: 10px !important;
-    font-weight: 600 !important; font-size: 1rem !important;
-    padding: 13px 28px !important; color: #fff !important;
-    box-shadow: 0 4px 20px #0fba7c30 !important; transition: all .18s !important;
-}
-.gr-button-primary:hover {
-    background: linear-gradient(135deg, #10cc88, #0fba7c) !important;
-    transform: translateY(-2px) !important; box-shadow: 0 8px 28px #0fba7c50 !important;
-}
-label { color: var(--muted) !important; font-size: .82rem !important; }
-.ai-box { background: #0fba7c10 !important; border: 1px solid #0fba7c35 !important; }
+:root{--mint:#0fba7c;--mint2:#09d48f;--dark:#0b0d14;--card:#13161f;--border:#1e2232;--text:#dde2f0;--muted:#7a82a0;}
+body,.gradio-container{background:var(--dark)!important;color:var(--text)!important;font-family:'DM Sans',sans-serif!important;}
+.hero{background:linear-gradient(135deg,#0fba7c14,#09d48f08 40%,#0b0d14);border:1px solid #0fba7c30;border-radius:20px;padding:30px 40px;margin-bottom:20px;}
+.hero h1{font-family:'DM Serif Display',serif;color:var(--mint2);font-size:2rem;margin:0 0 6px;}
+.hero p{color:var(--muted);margin:0;font-size:.93rem;}
+.badge{display:inline-block;background:linear-gradient(90deg,#0fba7c,#09d48f);color:#000;font-size:.7rem;font-weight:700;letter-spacing:.08em;padding:3px 10px;border-radius:20px;margin-left:8px;vertical-align:middle;}
+.pill{display:inline-block;border:1px solid #0fba7c60;color:#0fba7c;font-size:.72rem;font-weight:600;padding:2px 8px;border-radius:20px;margin:2px;}
+.gr-panel,.gr-box,.gr-form,.gr-block{background:var(--card)!important;border:1px solid var(--border)!important;border-radius:14px!important;}
+.gr-button-primary{background:linear-gradient(135deg,#0fba7c,#07a36c)!important;border:none!important;border-radius:10px!important;font-weight:600!important;font-size:1rem!important;padding:13px 28px!important;color:#fff!important;box-shadow:0 4px 20px #0fba7c30!important;transition:all .18s!important;}
+.gr-button-primary:hover{background:linear-gradient(135deg,#10cc88,#0fba7c)!important;transform:translateY(-2px)!important;box-shadow:0 8px 28px #0fba7c50!important;}
+label{color:var(--muted)!important;font-size:.82rem!important;}
+.ai-box{background:#0fba7c10!important;border:1px solid #0fba7c35!important;}
 """
 
-# Build status pills
-pills = []
-if ENV["mediapipe"]:
-    pills.append('<span class="pill">✅ MediaPipe Landmarks</span>')
-else:
-    pills.append('<span class="pill" style="border-color:#f0704060;color:#f07040">⚠ MediaPipe not installed</span>')
-if ENV["gpu"]:
-    pills.append('<span class="pill">✅ GPU Ready (~25s)</span>')
-elif ENV["diffusers"]:
-    pills.append('<span class="pill" style="border-color:#f0c04060;color:#f0c040">⚡ CPU (~3min)</span>')
-else:
-    pills.append('<span class="pill" style="border-color:#f0704060;color:#f07040">⚠ Classic mode only</span>')
-
-pills_html = " ".join(pills)
-
-with gr.Blocks(css=CSS, title="SmileAI Pro v4") as demo:
+pills=[]
+pills.append('<span class="pill">✅ MediaPipe Landmarks</span>' if ENV["mediapipe"] else '<span class="pill" style="border-color:#f0704060;color:#f07040">⚠ MediaPipe not installed</span>')
+pills.append('<span class="pill">✅ GPU Ready (~25s)</span>' if ENV["gpu"] else
+             '<span class="pill" style="border-color:#f0c04060;color:#f0c040">⚡ CPU — AI ~60s · Classic: instant</span>' if ENV["diffusers"] else
+             '<span class="pill" style="border-color:#aaa;color:#aaa">✨ Classic mode (instant)</span>')
 
+with gr.Blocks(css=CSS,title="SmileAI Pro v4") as demo:
     gr.HTML(f"""
     <div class="hero">
-        <h1>🦷 SmileAI Pro <span class="badge">v4 · REFINED</span></h1>
-        <p>MediaPipe landmark masking · Mouth-crop inpainting · Poisson seamless blending · Skin-tone adaptive prompts</p>
-        <p style="margin-top:10px">{pills_html}</p>
-    </div>
-    """)
-
+        <h1>🦷 SmileAI Pro <span class="badge">v4 · CPU OPTIMISED</span></h1>
+        <p>MediaPipe landmark masking · DPM++ fast scheduler · Enhanced classic mode (instant) · Poisson seamless blending</p>
+        <p style="margin-top:10px">{"".join(pills)}</p>
+    </div>""")
     with gr.Row(equal_height=False):
-
-        with gr.Column(scale=1, min_width=300):
-
+        with gr.Column(scale=1,min_width=300):
             gr.Markdown("### 📤 Patient Photo")
-            input_img = gr.Image(
-                label="Upload frontal smiling photo (min 800×600, good lighting)",
-                type="numpy", height=280,
-            )
-
+            input_img=gr.Image(label="Upload frontal smiling photo",type="numpy",height=280)
             gr.Markdown("### 🎨 Treatment Style")
-            style_dd = gr.Dropdown(
-                list(STYLES.keys()),
-                value="Full Smile Reconstruction",
-                label="Select treatment",
-            )
-
+            style_dd=gr.Dropdown(list(STYLES.keys()),value="Full Smile Reconstruction",label="Select treatment")
             with gr.Group(elem_classes="ai-box"):
                 gr.Markdown("**🤖 AI Settings**")
-                use_ai_cb = gr.Checkbox(
-                    label="Enable AI Inpainting (Stable Diffusion)",
-                    value=ENV["diffusers"],
-                    info="Uses mouth-crop strategy + Poisson blending for best results."
-                )
-                mask_pad = gr.Slider(
-                    8, 40, value=18, step=2,
-                    label="Landmark Mask Padding (px)",
-                )
-
+                use_ai_cb=gr.Checkbox(label="Enable AI Inpainting (Stable Diffusion)",value=ENV["diffusers"],
+                                      info="CPU: ~60s with DPM++ scheduler. Uncheck for instant classic mode.")
+                mask_pad=gr.Slider(8,40,value=18,step=2,label="Landmark Mask Padding (px)")
             gr.Markdown("### ⚙️ Final Polish")
-            brightness = gr.Slider(-0.5, 0.5, value=0.06, step=0.02, label="Face Brightness")
-            contrast   = gr.Slider(-0.5, 0.5, value=0.08, step=0.02, label="Contrast")
-
+            brightness=gr.Slider(-0.5,0.5,value=0.06,step=0.02,label="Face Brightness")
+            contrast=gr.Slider(-0.5,0.5,value=0.08,step=0.02,label="Contrast")
             gr.Markdown("### 🏥 Practice Info")
-            patient_name  = gr.Textbox(label="Patient Name", placeholder="Jane Doe")
-            practice_name = gr.Textbox(label="Practice Name", value="SmileAI Pro")
-            branding_cb   = gr.Checkbox(label="Add watermark", value=True)
-
-            run_btn = gr.Button("✨ Generate Smile Simulation", variant="primary")
-
+            patient_name=gr.Textbox(label="Patient Name",placeholder="Jane Doe")
+            practice_name=gr.Textbox(label="Practice Name",value="SmileAI Pro")
+            branding_cb=gr.Checkbox(label="Add watermark",value=True)
+            run_btn=gr.Button("✨ Generate Smile Simulation",variant="primary")
         with gr.Column(scale=2):
-            status_box = gr.Textbox(label="Status", lines=4, interactive=False)
-
+            status_box=gr.Textbox(label="Status",lines=4,interactive=False)
             with gr.Tabs():
-                with gr.TabItem("🦷 After"):
-                    after_out = gr.Image(label="Simulated Result", type="pil", height=450)
-                with gr.TabItem("↔ Before / After"):
-                    compare_out = gr.Image(label="Side-by-Side", type="pil", height=450)
-                with gr.TabItem("📄 PDF"):
-                    pdf_out = gr.File(label="Download PDF Report")
-
-    with gr.Accordion("📸 Tips for Best Results", open=False):
+                with gr.TabItem("🦷 After"):    after_out=gr.Image(label="Simulated Result",type="pil",height=450)
+                with gr.TabItem("↔ Before / After"): compare_out=gr.Image(label="Side-by-Side",type="pil",height=450)
+                with gr.TabItem("📄 PDF"):      pdf_out=gr.File(label="Download PDF Report")
+
+    with gr.Accordion("📸 Tips & CPU Speed Guide",open=False):
         gr.Markdown("""
-        **For the most realistic results:**
-        - Use a **straight-on frontal photo** — slight smiling or open mouth
-        - **Good even lighting** — avoid harsh shadows under the nose
-        - Minimum **1000×800px** — higher res = sharper tooth detail
-        - For missing teeth: ensure the dark gap is **clearly visible**, not hidden by lips
-        - If mask misses teeth, **increase Mask Padding** slider
-
-        **What's new in v4:**
-        - 🎯 **MediaPipe landmarks** — pixel-precise lip boundary mask
-        - 🔬 **Mouth-crop inpainting** — SD runs at full 512px on just the mouth (3× more detail)
-        - 🎨 **Poisson blending** — zero-seam edge integration
-        - 🌍 **Skin-tone detection** — prompt adapts to patient complexion
-        - 🏆 **Multi-seed best-pick** — generates 2-3 variants, selects sharpest
-
-        **requirements.txt (GPU Space on HuggingFace):**
-        ```
-        gradio>=4.0.0
-        numpy pillow opencv-python-headless reportlab mediapipe
-        torch torchvision --index-url https://download.pytorch.org/whl/cu118
-        diffusers>=0.27.0 transformers accelerate xformers
-        ```
+**For CPU (what you have now):**
+
+| Mode | Time | Best for |
+|------|------|----------|
+| ✨ Classic Enhanced (uncheck AI) | ~3 seconds | Whitening, stain removal, gap fill |
+| 🤖 AI DPM++ 20 steps | ~60 seconds | Full reconstruction, missing teeth |
+
+**To fix "MediaPipe not installed" — add `packages.txt` to your Space root:**
+```
+libgl1
+libglib2.0-0
+libsm6
+libxrender1
+libxext6
+ffmpeg
+```
+
+**requirements.txt:**
+```
+gradio>=4.0.0
+numpy pillow opencv-python-headless reportlab
+mediapipe==0.10.9
+torch torchvision
+diffusers>=0.27.0 transformers>=4.38.0 accelerate>=0.27.0
+```
         """)
 
     run_btn.click(
         fn=process_smile,
-        inputs=[
-            input_img, style_dd, use_ai_cb, mask_pad,
-            brightness, contrast,
-            patient_name, practice_name, branding_cb,
-        ],
-        outputs=[after_out, compare_out, pdf_out, status_box],
-    )
-
-if __name__ == "__main__":
-    demo.launch(share=False, server_name="0.0.0.0", server_port=7860)
+        inputs=[input_img,style_dd,use_ai_cb,mask_pad,brightness,contrast,patient_name,practice_name,branding_cb],
+        outputs=[after_out,compare_out,pdf_out,status_box])
+
+if __name__=="__main__":
+    demo.launch(share=False,server_name="0.0.0.0",server_port=7860)

packages.txt

@@ -0,0 +1,6 @@
+libgl1
+libglib2.0-0
+libsm6
+libxrender1
+libxext6
+ffmpeg

requirements .txt

@@ -14,7 +14,7 @@ pillow
 opencv-python-headless
 
 # Face landmark detection (mouth mask precision)
-mediapipe
+mediapipe==0.10.9
 
 # PDF export
 reportlab