REVERT to K=5

app.py

@@ -53,57 +53,8 @@ def depth_to_normal(depth):
 # CORE PROCESSING FUNCTION
 # ===============================
 def _process_saree_core(base_image: Image.Image, pattern_image: Image.Image):
-    # img_pil = base_image.convert("RGB")  # <-- COMMENTED: this injects black behind transparency
-    # img_np = np.array(img_pil)
-
-    # --- ORIGINAL (white matte) kept for reference ---
-    # base_rgba = base_image.convert("RGBA")
-    # _arr = np.array(base_rgba).astype(np.float32)
-    # _rgb = _arr[..., :3]
-    # _a = (_arr[..., 3:4] / 255.0)
-    # _rgb_over_white = _rgb * _a + (1.0 - _a) * 255.0
-    # _rgb_over_white = _rgb_over_white.astype(np.uint8)
-    # img_pil = Image.fromarray(_rgb_over_white, mode="RGB")
-    # img_np = _rgb_over_white
-    # --- end ORIGINAL ---
-
-    # --- NEW: alpha-aware RGB using median color along interior boundary as matte ---
-    base_rgba = base_image.convert("RGBA")
-    _arr = np.array(base_rgba).astype(np.float32)              # (H,W,4), RGB in 0..255, A in 0..255
-    _rgb = _arr[..., :3]                                       # (H,W,3)
-    _alpha8 = _arr[..., 3].astype(np.uint8)                    # (H,W) uint8 alpha
-    _a = (_alpha8.astype(np.float32) / 255.0)[..., None]       # (H,W,1) float alpha
-
-    # Build a foreground mask from alpha (slightly strict to avoid wispy edges)
-    _fg_mask = (_alpha8 > 128).astype(np.uint8) * 255          # (H,W) 0/255
-
-    # Morphological interior boundary: foreground minus a 1-iteration erosion
-    _k = np.ones((3, 3), np.uint8)
-    _eroded = cv2.erode(_fg_mask, _k, iterations=1)
-    _boundary = cv2.bitwise_and(_fg_mask, cv2.bitwise_not(_eroded))  # thin interior ring
-
-    # If boundary is too thin/few pixels, widen the ring via morphological gradient
-    if int((_boundary > 0).sum()) < 100:
-        _dil = cv2.dilate(_fg_mask, _k, iterations=2)
-        _ero = cv2.erode(_fg_mask, _k, iterations=2)
-        _boundary = cv2.subtract(_dil, _ero)
-
-    _idx = (_boundary > 0)
-    if not np.any(_idx):
-        # Fallback: use entire foreground if boundary not found
-        _idx = (_fg_mask > 0)
-
-    # Compute median color over the selected boundary pixels (in 0..255 space)
-    _median_color = np.median(_rgb[_idx], axis=0) if np.any(_idx) else np.array([255.0, 255.0, 255.0], dtype=np.float32)
-    _median_color = _median_color.reshape(1, 1, 3)             # (1,1,3)
-
-    # Composite RGB over median matte (avoid introducing black/white bias)
-    _rgb_over_matte = _rgb * _a + (1.0 - _a) * _median_color
-    _rgb_over_matte = np.clip(_rgb_over_matte, 0.0, 255.0).astype(np.uint8)
-
-    img_pil = Image.fromarray(_rgb_over_matte, mode="RGB")
-    img_np = _rgb_over_matte
-    # --- end NEW ---
+    img_pil = base_image.convert("RGB")
+    img_np = np.array(img_pil)
 
     # Prepare tensor
     img_resized = img_pil.resize((384, 384))
@@ -135,107 +86,28 @@ def _process_saree_core(base_image: Image.Image, pattern_image: Image.Image):
     l_clahe = clahe.apply(l_channel)
     shading_map = l_clahe / 255.0
 
-    # ==========================================================
-    # [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
+    # Tile pattern
+    pattern_np = np.array(pattern_image.convert("RGB"))
     target_h, target_w = img_np.shape[:2]
-    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)
+    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 * blended_shading
-    normal_boost   = 0.5 + 0.5 * normal_map_loaded[..., 2:3]
-    pattern_folded *= normal_boost
-    pattern_folded  = np.clip(pattern_folded, 0.0, 1.0)
-    
-    # ==========================================================
-    # [END PATCHED]
-    # ==========================================================
+    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)
 
     # ==========================================================
     # Background removal with post-processing (no duplicate blur)
@@ -257,107 +129,22 @@ def _process_saree_core(base_image: Image.Image, pattern_image: Image.Image):
     mask_binary = (mask_alpha > k/100).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
 
-    # ================================
-    # NEW: SEAM-FIX UPSTREAM (3 steps)
-    # ================================
-    # (A) MASK EXPANSION / OVERLAP: expand slightly to ensure overlap across seams
-    overlap_iters = 2                # <-- tune: 1..3 (px-ish with 5x5 kernel)
-    # mask_expanded = cv2.dilate(mask_eroded, kernel, iterations=overlap_iters)   # old idea
-    # --- Better: expand the FLOAT feathered mask to preserve soft edge continuity ---
-    _mask_float = (mask_blurred * 255).astype(np.uint8)
-    _mask_expanded_u8 = cv2.dilate(_mask_float, kernel, iterations=overlap_iters)
-    mask_expanded = _mask_expanded_u8.astype(np.float32) / 255.0  # [0..1]
-
-    # (B) FEATHER AGAIN after expansion (very light) for a smooth transition band
-    mask_expanded = cv2.GaussianBlur((mask_expanded * 255).astype(np.uint8), (7, 7), sigmaX=1.5, sigmaY=1.5)
-    mask_expanded = mask_expanded.astype(np.float32) / 255.0
-
-    # (C) BLEED-COLOR FILLING in premultiplied space for near-edge pixels
-    #     - Create a thin edge band where alpha is small (e.g., up to 8%)
-    edge_upper = 0.08
     # Final RGBA
-    # mask_stack = np.stack([mask_blurred] * 3, axis=-1)
-    # pattern_final = pattern_folded * mask_stack
-    # --- Replace above with expanded mask for overlap ---
-    mask_stack = np.stack([mask_expanded] * 3, axis=-1)
-    pattern_final = pattern_folded * mask_stack  # premultiplied RGB (color * alpha) with overlap
-
-    #     - Dilate premultiplied RGB slightly so edge pixels borrow nearby garment color
-    bleed_iters = 2               # <-- tune: 1..3
-    _kernel_bleed = np.ones((3, 3), np.uint8)
-    _premul_u8 = (pattern_final * 255).astype(np.uint8)
-    _premul_bleed = cv2.dilate(_premul_u8, _kernel_bleed, iterations=bleed_iters).astype(np.float32) / 255.0
-
-    #     - Replace only in the very thin edge band (alpha between 0 and edge_upper)
-    edge_band = (mask_expanded > 0.0) & (mask_expanded <= edge_upper)
-    if np.any(edge_band):
-        pattern_final[edge_band] = _premul_bleed[edge_band]
-    # ================================
-    # END NEW: SEAM-FIX UPSTREAM
-    # ================================
-
-        # ================================
-    # POST-PROCESS: SEAM / BLACK-LINE FILL
-    # (place this right before: "Premultiplied → Straight alpha")
-    # ================================
-
-    # Build a temporary straight-RGB for detection (do NOT export this)
-    _alpha_tmp = np.clip(mask_expanded, eps, 1.0)                   # [H,W]
-    _alpha_tmp3 = _alpha_tmp[..., None]                              # [H,W,1]
-    straight_tmp = np.clip(pattern_final / _alpha_tmp3, 0.0, 1.0)    # [H,W,3], float
-
-    # Convert to 8-bit for OpenCV ops
-    straight_u8 = (straight_tmp * 255).astype(np.uint8)
-    gray8 = cv2.cvtColor(straight_u8, cv2.COLOR_RGB2GRAY)
-
-    # Local median to find narrow dark troughs (seams)
-    med8 = cv2.medianBlur(gray8, 5)
-
-    # Heuristics: dark + locally darker than neighbors + inside garment
-    dark_thr = int(0.22 * 255)       # tune: 0.18..0.28
-    delta_thr = int(0.08 * 255)      # tune: 0.06..0.10
-    dark = gray8 < dark_thr
-    contrast = (med8.astype(np.int16) - gray8.astype(np.int16)) > delta_thr
-    inside = (mask_expanded > 0.06)   # avoid true background
-
-    seam_mask = (dark & contrast & inside).astype(np.uint8) * 255
-
-    # Keep seams thin (remove blobs); nudge toward single‑pixel cores
-    k3 = np.ones((3, 3), np.uint8)
-    seam_mask = cv2.morphologyEx(seam_mask, cv2.MORPH_OPEN, k3, iterations=1)
-    seam_mask = cv2.erode(seam_mask, np.ones((2, 2), np.uint8), iterations=1)
-
-    # Inpaint on straight space (Telea = good for thin scratches)
-    inpaint_radius = 3  # try 2..4
-    inpainted_u8 = cv2.inpaint(straight_u8, seam_mask, inpaint_radius, cv2.INPAINT_TELEA)
-    inpainted = inpainted_u8.astype(np.float32) / 255.0
-
-    # Re-premultiply and replace
-
-
-    # Premultiplied → Straight alpha
-    eps = 1e-6
-    # _alpha = np.clip(mask_blurred, eps, 1.0)
-    # --- Use the expanded mask for export, with a small alpha floor to hide hairlines ---
-    alpha_floor = 0.02  # 2% floor; increase to 0.03 if a faint line persists
-    _alpha = np.clip(mask_expanded, max(alpha_floor, eps), 1.0)
-    _alpha3 = _alpha[..., None]
-    rgb_straight = np.clip(pattern_final / _alpha3, 0.0, 1.0)
-
-    pattern_rgb = (rgb_straight * 255).astype(np.uint8)
-    alpha_channel = (_alpha * 255).astype(np.uint8)
+    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))
 
     return Image.fromarray(pattern_rgba, mode="RGBA")
 
-
-
 # ===============================
 # WRAPPER: ACCEPT BYTES OR BASE64
 # ===============================