REVERT

app.py

@@ -86,73 +86,18 @@ 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 (MINIMAL CHANGE: alpha-aware tiling)
-    # ==========================================================
-    # pattern_np = np.array(pattern_image.convert("RGB"))  # <-- ORIGINAL (kills alpha)
-    # 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)]
-
+    # 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)]
 
-    # 1) Keep RGBA + light feather on alpha
-    _rgba = np.array(pattern_image.convert("RGBA"))
-    _rgb  = _rgba[..., :3].astype(np.float32) / 255.0
-    _a    = (_rgba[..., 3].astype(np.float32) / 255.0)
-    _a    = cv2.GaussianBlur(_a, (5, 5), sigmaX=2, sigmaY=2)  # small feather
-    _a    = np.clip(_a, 0.0, 1.0)
-
-    # 2) Crop to non-transparent bbox to avoid tiling empty margins
-    _ys, _xs = np.where(_a > 0.01)
-    if _ys.size > 0:
-        y0, y1 = _ys.min(), _ys.max() + 1
-        x0, x1 = _xs.min(), _xs.max() + 1
-        _rgb = _rgb[y0:y1, x0:x1, :]
-        _a   = _a[y0:y1, x0:x1]
-
-    ph, pw = _a.shape[:2]
-
-    # 3) Premultiplied source
-    _rgb_pm = _rgb * _a[..., None]
-
-    # 4) Composite tiles in premultiplied space
-    _canvas_rgb_pm = np.zeros((target_h, target_w, 3), dtype=np.float32)
-    _canvas_a      = np.zeros((target_h, target_w, 1), dtype=np.float32)
-
-    for y in range(0, target_h, ph):
-        for x in range(0, target_w, pw):
-            end_y = min(y + ph, target_h)
-            end_x = min(x + pw, target_w)
-            h = end_y - y
-            w = end_x - x
-
-            src_rgb_pm = _rgb_pm[:h, :w, :]
-            src_a      = _a[:h, :w][..., None]
-
-            dst_rgb_pm = _canvas_rgb_pm[y:end_y, x:end_x, :]
-            dst_a      = _canvas_a[y:end_y, x:end_x, :]
-
-            # Porter-Duff "over" (premultiplied)
-            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[y:end_y, x:end_x, :] = out_rgb_pm
-            _canvas_a[y:end_y, x:end_x, :] = out_a
-
-    # 5) Un-premultiply to hand back an RGB tile
-    _alpha_safe = np.clip(_canvas_a, 1e-6, 1.0)
-    _pattern_rgb = np.clip(_canvas_rgb_pm / _alpha_safe, 0.0, 1.0)
-    pattern_tiled = (_pattern_rgb * 255).astype(np.uint8)
-
-    # ==========================================================
     # Blend pattern
-    # ==========================================================
     normal_map_loaded = normal_map.astype(np.float32)
     shading_map_loaded = np.stack([shading_map] * 3, axis=-1)
 
@@ -165,22 +110,29 @@ def _process_saree_core(base_image: Image.Image, pattern_image: Image.Image):
     pattern_folded = np.clip(pattern_folded, 0, 1)
 
     # ==========================================================
-    # Background removal with post-processing
+    # Background removal with post-processing (no duplicate blur)
     # ==========================================================
     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
 
-    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)
+    # 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)
     mask_blurred = cv2.GaussianBlur(mask_eroded, (15, 15), sigmaX=3, sigmaY=3)
+
+    # 3. Normalize
     mask_blurred = mask_blurred.astype(np.float32) / 255.0
 
     # Final RGBA