TILE PATTERN EDIT

app.py

@@ -135,28 +135,107 @@ def _process_saree_core(base_image: Image.Image, pattern_image: Image.Image):
     l_clahe = clahe.apply(l_channel)
     shading_map = l_clahe / 255.0
 
-    # Tile pattern
-    pattern_np = np.array(pattern_image.convert("RGB"))
+        # ==========================================================
+    # [PATCHED] TILE PATTERN (soft crossfade) + BLEND
+    #    Replace the block from "# Tile pattern" through
+    #    "pattern_folded = np.clip(pattern_folded, 0, 1)"
+    #    and keep everything below (BG removal etc.) unchanged.
+    # ==========================================================
+
+    # ----- ORIGINAL (hard tiling) — kept for reference -----
+    # # Tile pattern
+    # pattern_np = np.array(pattern_image.convert("RGB"))
+    # 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)
+    # 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)
+    # ----- END ORIGINAL -----
+
+    # ---------- NEW: seam‑free overlapped tiling ----------
+    eps = 1e-6
+
+    # 1) Clean the tile (unpremultiply RGBA to remove black fringe; optional 2px crop)
+    _tile_rgba = np.array(pattern_image.convert("RGBA")).astype(np.float32) / 255.0
+    _tile_rgb  = _tile_rgba[..., :3]
+    _tile_a    = _tile_rgba[..., 3:4]
+    _tile_rgb  = np.where(_tile_a > eps, _tile_rgb / np.clip(_tile_a, eps, 1.0), _tile_rgb)
+
+    _crop = 2  # try 2–3 if fringe persists
+    if _tile_rgb.shape[0] > 2*_crop and _tile_rgb.shape[1] > 2*_crop:
+        _tile_rgb = _tile_rgb[_crop:-_crop, _crop:-_crop, :]
+
+    pattern_np = (np.clip(_tile_rgb, 0.0, 1.0) * 255).astype(np.uint8)
+
+    # 2) Overlapped tiling with cosine crossfade
     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)
+    th, tw = pattern_np.shape[:2]
+    ov = 6  # overlap width in px (tune 4–12)
+
+    def _make_weight(h, w, ov_):
+        ovh = min(ov_, h // 2)
+        ovw = min(ov_, w // 2)
+        wy = np.ones((h,), dtype=np.float32)
+        wx = np.ones((w,), dtype=np.float32)
+        if ovh > 0:
+            t = np.linspace(0, np.pi, ovh, endpoint=False)
+            ramp = 0.5 - 0.5 * np.cos(t)
+            wy[:ovh]  = np.minimum(wy[:ovh], ramp)
+            wy[-ovh:] = np.minimum(wy[-ovh:], ramp[::-1])
+        if ovw > 0:
+            t = np.linspace(0, np.pi, ovw, endpoint=False)
+            ramp = 0.5 - 0.5 * np.cos(t)
+            wx[:ovw]  = np.minimum(wx[:ovw], ramp)
+            wx[-ovw:] = np.minimum(wx[-ovw:], ramp[::-1])
+        return np.outer(wy, wx).astype(np.float32)
+
+    acc  = np.zeros((target_h, target_w, 3), dtype=np.float32)
+    wacc = np.zeros((target_h, target_w, 1), dtype=np.float32)
+
+    stride_y = max(1, th - ov)
+    stride_x = max(1, tw - ov)
+
+    for y in range(0, target_h, stride_y):
+        for x in range(0, target_w, stride_x):
+            h_crop = min(th, target_h - y)
+            w_crop = min(tw, target_w - x)
+            tile   = pattern_np[:h_crop, :w_crop, :].astype(np.float32) / 255.0
+            wmask  = _make_weight(h_crop, w_crop, ov)[..., None]  # (h,w,1)
+
+            acc[y:y+h_crop, x:x+w_crop]  += tile * wmask
+            wacc[y:y+h_crop, x:x+w_crop] += wmask
+
+    pattern_tiled = acc / np.clip(wacc, eps, None)
+    pattern_tiled = np.clip(pattern_tiled, 0.0, 1.0)  # float32 in [0,1]
+
+    # 3) Continue with your shading/normal blending (unchanged)
+    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 = 0.7
-    blended_shading = alpha * shading_map_loaded + (1 - alpha)
-
-    pattern_folded = pattern_tiled.astype(np.float32) / 255.0 * blended_shading
-    normal_boost = 0.5 + 0.5 * normal_map_loaded[..., 2:3]
+    pattern_folded = pattern_tiled * 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)
+    pattern_folded  = np.clip(pattern_folded, 0.0, 1.0)
+    
+    # ==========================================================
+    # [END PATCHED]
+    # ==========================================================
+
 
     # ==========================================================
     # Background removal with post-processing (no duplicate blur)