UPDATE

app.py

@@ -56,7 +56,9 @@ def _process_saree_core(base_image: Image.Image, pattern_image: Image.Image):
     img_pil = base_image.convert("RGB")
     img_np = np.array(img_pil)
 
-    # Prepare tensor
+    # ===============================
+    # Prepare tensor (depth surrogate)
+    # ===============================
     img_resized = img_pil.resize((384, 384))
     img_tensor = torch.from_numpy(np.array(img_resized)).permute(2, 0, 1).unsqueeze(0).float() / 255.0
     mean = torch.as_tensor([0.5, 0.5, 0.5], device=img_tensor.device).view(1, 3, 1, 1)
@@ -74,73 +76,163 @@ def _process_saree_core(base_image: Image.Image, pattern_image: Image.Image):
         depth_map = depth_map.squeeze().cpu().numpy()
 
     # Normalize depth
-    depth_vis = (depth_map - depth_map.min()) / (depth_map.max() - depth_map.min())
+    depth_vis = (depth_map - depth_map.min()) / (depth_map.max() - depth_map.min() + 1e-8)
 
     # Normal map
     normal_map = depth_to_normal(depth_vis)
 
+    # ===============================
     # Shading map (CLAHE)
+    # ===============================
     img_lab = cv2.cvtColor(img_np, cv2.COLOR_RGB2LAB)
     l_channel, _, _ = cv2.split(img_lab)
     clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
     l_clahe = clahe.apply(l_channel)
     shading_map = l_clahe / 255.0
-
-    # Tile pattern
-    pattern_np = np.array(pattern_image.convert("RGB"))
+    shading_map_loaded = np.stack([shading_map] * 3, axis=-1)  # (H,W,3)
+
+    # ===============================
+    # OVERLAY prep: preserve + feather alpha (NEW)
+    # ===============================
+    # pattern_np = np.array(pattern_image.convert("RGB"))  # <-- ORIGINAL (kills alpha)  [COMMENTED]
+    pattern_rgba_full = np.array(pattern_image.convert("RGBA"))
+    alpha = pattern_rgba_full[:, :, 3].astype(np.float32) / 255.0
+    # Feather alpha to soften edges a bit
+    alpha_feathered = cv2.GaussianBlur(alpha, (5, 5), sigmaX=2, sigmaY=2)
+    alpha_feathered = np.clip(alpha_feathered, 0.0, 1.0)
+    # Premultiply RGB by feathered alpha
+    rgb = pattern_rgba_full[:, :, :3].astype(np.float32) / 255.0
+    rgb_pm = rgb * alpha_feathered[..., None]
+
+    # Optional: crop to non‑transparent bbox to avoid tiling empty margins
+    alpha_thresh = 0.01
+    ys, xs = np.where(alpha_feathered > alpha_thresh)
+    if ys.size > 0:
+        y0, y1 = ys.min(), ys.max() + 1
+        x0, x1 = xs.min(), xs.max() + 1
+        rgb_pm = rgb_pm[y0:y1, x0:x1, :]
+        alpha_crop = alpha_feathered[y0:y1, x0:x1]
+    else:
+        alpha_crop = alpha_feathered
+
+    ph, pw = alpha_crop.shape[:2]
     target_h, target_w = img_np.shape[:2]
-    pattern_h, pattern_w = pattern_np.shape[:2]
-    pattern_tiled = np.zeros((target_h, target_w, 3), dtype=np.uint8)
-    for y in range(0, target_h, pattern_h):
-        for x in range(0, target_w, pattern_w):
-            end_y = min(y + pattern_h, target_h)
-            end_x = min(x + pattern_w, target_w)
-            pattern_tiled[y:end_y, x:end_x] = pattern_np[0:(end_y - y), 0:(end_x - x)]
-
-    # Blend pattern
-    normal_map_loaded = normal_map.astype(np.float32)
-    shading_map_loaded = np.stack([shading_map] * 3, axis=-1)
 
-    alpha = 0.7
-    blended_shading = alpha * shading_map_loaded + (1 - alpha)
+    # ===============================
+    # Alpha-aware tiling WITH OVERLAP + crossfade (NEW)
+    # ===============================
+    # --- ORIGINAL hard RGB tiling (seams) [COMMENTED] ---
+    # pattern_h, pattern_w = pattern_np.shape[:2]
+    # pattern_tiled = np.zeros((target_h, target_w, 3), dtype=np.uint8)
+    # for y in range(0, target_h, pattern_h):
+    #     for x in range(0, target_w, pattern_w):
+    #         end_y = min(y + pattern_h, target_h)
+    #         end_x = min(x + pattern_w, target_w)
+    #         pattern_tiled[y:end_y, x:end_x] = pattern_np[0:(end_y - y), 0:(end_x - x)]
+
+    # Build weighted tile to cross‑fade edges
+    tile_rgb_pm = rgb_pm.astype(np.float32)               # (ph,pw,3)
+    tile_a      = alpha_crop.astype(np.float32)[..., None]  # (ph,pw,1)
+
+    # Overlap size (tune 8–24 px depending on texture)
+    overlap = 16
+    overlap_y = min(overlap, max(1, ph // 4))
+    overlap_x = min(overlap, max(1, pw // 4))
+
+    # Horizontal & vertical ramps (0..1)
+    wx = np.ones((1, pw, 1), np.float32)
+    if overlap_x > 0:
+        rampx = np.linspace(0, 1, overlap_x, dtype=np.float32)[None, :, None]
+        wx[:, :overlap_x, :] = rampx
+        wx[:, -overlap_x:, :] = rampx[:, ::-1, :]
+
+    wy = np.ones((ph, 1, 1), np.float32)
+    if overlap_y > 0:
+        rampy = np.linspace(0, 1, overlap_y, dtype=np.float32)[:, None, None]
+        wy[:overlap_y, :, :] = rampy
+        wy[-overlap_y:, :, :] = rampy[::-1, :, :]
+
+    w_ramp = wx * wy  # (ph,pw,1)
+
+    tile_rgb_pm_w = tile_rgb_pm * w_ramp
+    tile_a_w      = tile_a * w_ramp
+
+    # Canvas in premultiplied form
+    canvas_rgb_pm = np.zeros((target_h, target_w, 3), np.float32)
+    canvas_a      = np.zeros((target_h, target_w, 1), np.float32)
+
+    # Step so tiles overlap
+    step_y = ph - overlap_y
+    step_x = pw - overlap_x
+    if step_y <= 0: step_y = ph
+    if step_x <= 0: step_x = pw
+
+    for y0 in range(0, target_h, step_y):
+        for x0 in range(0, target_w, step_x):
+            y1 = min(y0 + ph, target_h)
+            x1 = min(x0 + pw, target_w)
+            h  = y1 - y0
+            w_ = x1 - x0
+
+            src_rgb_pm = tile_rgb_pm_w[:h, :w_, :]
+            src_a      = tile_a_w[:h, :w_, :]
+
+            dst_rgb_pm = canvas_rgb_pm[y0:y1, x0:x1, :]
+            dst_a      = canvas_a[y0:y1, x0:x1, :]
+
+            # Porter‑Duff "over" in premultiplied space
+            out_rgb_pm = src_rgb_pm + dst_rgb_pm * (1.0 - src_a)
+            out_a      = src_a      + dst_a      * (1.0 - src_a)
+
+            canvas_rgb_pm[y0:y1, x0:x1, :] = out_rgb_pm
+            canvas_a[y0:y1, x0:x1, :] = out_a
+
+    # Keep premultiplied; no un‑premultiply yet
+    pattern_rgb_pm_tiled = canvas_rgb_pm
+    pattern_alpha_tiled  = np.clip(canvas_a[..., 0], 0.0, 1.0)  # (H,W)
+
+    # ===============================
+    # Shading & normal boost (premultiplied)
+    # ===============================
+    normal_map_loaded = normal_map.astype(np.float32)
+    alpha_s = 0.7
+    blended_shading = alpha_s * shading_map_loaded + (1 - alpha_s)
 
-    pattern_folded = pattern_tiled.astype(np.float32) / 255.0 * blended_shading
-    normal_boost = 0.5 + 0.5 * normal_map_loaded[..., 2:3]
-    pattern_folded *= normal_boost
-    pattern_folded = np.clip(pattern_folded, 0, 1)
+    # Multiply premultiplied RGB by shading & normal (alpha unchanged)
+    pattern_rgb_pm_shaded = pattern_rgb_pm_tiled * blended_shading
+    pattern_rgb_pm_shaded *= (0.5 + 0.5 * normal_map_loaded[..., 2:3])
+    pattern_rgb_pm_shaded = np.clip(pattern_rgb_pm_shaded, 0.0, 1.0)
 
-    # ==========================================================
-    # Background removal with post-processing (no duplicate blur)
-    # ==========================================================
+    # ===============================
+    # Background removal for BASE + edge clean
+    # ===============================
     buf = BytesIO()
     base_image.save(buf, format="PNG")
     base_bytes = buf.getvalue()
 
-    # Get RGBA from bgrem
     result_no_bg = bgrem_remove(base_bytes)
     mask_img = Image.open(BytesIO(result_no_bg)).convert("RGBA")
-
-    # Extract alpha and clean edges
     mask_alpha = np.array(mask_img)[:, :, 3].astype(np.float32) / 255.0
 
-    # 1. Slightly stronger shrink (balanced)
-    kernel = np.ones((5, 5), np.uint8)   # slightly larger kernel
-    mask_binary = (mask_alpha > 0.05).astype(np.uint8) * 255  # slightly stricter threshold
-    mask_eroded = cv2.erode(mask_binary, kernel, iterations=3)  # balanced erosion
-
-
-    # 2. Feather edges (blur)
+    kernel = np.ones((5, 5), np.uint8)
+    mask_binary = (mask_alpha > 0.05).astype(np.uint8) * 255
+    mask_eroded = cv2.erode(mask_binary, kernel, iterations=3)
     mask_blurred = cv2.GaussianBlur(mask_eroded, (15, 15), sigmaX=3, sigmaY=3)
+    mask_blurred = mask_blurred.astype(np.float32) / 255.0  # [0,1]
+
+    # ===============================
+    # Final alpha & straight RGB out
+    # ===============================
+    # Combine base mask with tiled overlay alpha to avoid re‑introducing seams
+    alpha_final = np.clip(mask_blurred * pattern_alpha_tiled, 0.0, 1.0)
 
-    # 3. Normalize
-    mask_blurred = mask_blurred.astype(np.float32) / 255.0
+    # Convert premultiplied → straight once, at the end
+    alpha_safe = np.clip(alpha_final, 1e-6, 1.0)
+    pattern_rgb_straight = np.clip(pattern_rgb_pm_shaded / alpha_safe[..., None], 0.0, 1.0)
 
-    # Final RGBA
-    mask_stack = np.stack([mask_blurred] * 3, axis=-1)
-    pattern_final = pattern_folded * mask_stack
-    pattern_rgb = (pattern_final * 255).astype(np.uint8)
-    alpha_channel = (mask_blurred * 255).astype(np.uint8)
-    pattern_rgba = np.dstack((pattern_rgb, alpha_channel))
+    pattern_rgb_u8 = (pattern_rgb_straight * 255).astype(np.uint8)
+    alpha_u8 = (alpha_final * 255).astype(np.uint8)
+    pattern_rgba = np.dstack((pattern_rgb_u8, alpha_u8))
 
     return Image.fromarray(pattern_rgba, mode="RGBA")