Feature: Advanced BG Remove - 8 improvements (alpha matting, 5 modes, edge refine, shadow, quality check, GrabCut fallback)

filters.py

@@ -1411,29 +1411,234 @@ def process_video_watermark(video_path, output_path, progress_callback=None):
         
     return _apply_video_transform(video_path, output_path, wm_frame, progress_callback)
 
-def apply_bg_remove(image_path, output_path):
-    """Rasmdan fonni olib tashlaydi (shaffof PNG)."""
+def apply_bg_remove(image_path, output_path, mode="transparent"):
+    """Rasmdan fonni professional darajada olib tashlaydi.
+    
+    Rejimlar:
+        transparent — shaffof PNG (soya bilan)
+        white — oq fon
+        black — qora fon
+        blur — asl fonni bokeh bilan xiralashtirib qaytarish
+        gradient — ko'k-binafsha gradient fon
+    
+    Xususiyatlar:
+        - Alpha Matting (soch/detall uchun)
+        - Edge Refinement (Morphology + Feather)
+        - Kichik rasm avtomatik upscale
+        - Sifat nazorati
+        - GrabCut fallback
+    """
     try:
-        from rembg import remove
+        image_path = os.path.abspath(image_path)
+        output_path = os.path.abspath(output_path)
         
-        with open(os.path.abspath(image_path), 'rb') as inp:
-            input_data = inp.read()
+        # ===== 1. Rasmni yuklash va hajmini tekshirish =====
+        original_img = cv2.imread(image_path, cv2.IMREAD_UNCHANGED)
+        if original_img is None:
+            logger.error(f"BG Remove: Rasm o'qilmadi: {image_path}")
+            return None
         
-        output_data = remove(input_data)
+        h, w = original_img.shape[:2]
+        needs_downscale = False
+        orig_size = (w, h)
         
-        # PNG sifatida saqlash (shaffof fon)
-        png_path = os.path.abspath(output_path).rsplit('.', 1)[0] + '.png'
-        with open(png_path, 'wb') as out:
-            out.write(output_data)
+        # Kichik rasmlarni upscale qilish (sifatni saqlash)
+        if min(w, h) < 500:
+            scale = 2
+            original_img = cv2.resize(original_img, (w * scale, h * scale), interpolation=cv2.INTER_LANCZOS4)
+            h, w = original_img.shape[:2]
+            needs_downscale = True
+            logger.info(f"BG Remove: Kichik rasm {orig_size} → ({w},{h}) upscale qilindi")
         
-        return png_path
-    except ImportError:
-        logger.error("rembg kutubxonasi o'rnatilmagan.")
-        return None
+        # ===== 2. rembg bilan fon o'chirish (Alpha Matting) =====
+        result_pil = None
+        alpha_mask = None
+        
+        try:
+            from rembg import remove
+            from PIL import Image as PILImage
+            import io
+            
+            # Rasmni bytes ga o'tkazish
+            _, img_encoded = cv2.imencode('.png', original_img)
+            input_bytes = img_encoded.tobytes()
+            
+            # Alpha Matting + Post-Process bilan o'chirish
+            output_bytes = remove(
+                input_bytes,
+                alpha_matting=True,
+                alpha_matting_foreground_threshold=230,
+                alpha_matting_background_threshold=20,
+                alpha_matting_erode_size=12,
+                post_process_mask=True
+            )
+            
+            result_pil = PILImage.open(io.BytesIO(output_bytes)).convert("RGBA")
+            alpha_mask = np.array(result_pil.split()[-1])  # Alpha kanal
+            
+            logger.info("BG Remove: rembg + Alpha Matting muvaffaqiyatli")
+            
+        except ImportError:
+            logger.warning("rembg kutubxonasi yo'q — GrabCut fallback ishlatiladi")
+            result_pil = None
+        except Exception as e:
+            logger.warning(f"rembg xatosi: {e} — GrabCut fallback ishlatiladi")
+            result_pil = None
+        
+        # ===== 3. GrabCut Fallback =====
+        if result_pil is None:
+            logger.info("BG Remove: GrabCut fallback boshlandi")
+            img_bgr = original_img[:, :, :3] if original_img.shape[2] == 4 else original_img
+            
+            mask = np.zeros(img_bgr.shape[:2], np.uint8)
+            bgd_model = np.zeros((1, 65), np.float64)
+            fgd_model = np.zeros((1, 65), np.float64)
+            
+            # Markaziy to'rtburchak (fon chetlarda deb taxmin)
+            margin_x = int(w * 0.05)
+            margin_y = int(h * 0.05)
+            rect = (margin_x, margin_y, w - 2 * margin_x, h - 2 * margin_y)
+            
+            cv2.grabCut(img_bgr, mask, rect, bgd_model, fgd_model, 5, cv2.GC_INIT_WITH_RECT)
+            
+            # Foreground va probable foreground
+            alpha_mask = np.where((mask == 2) | (mask == 0), 0, 255).astype('uint8')
+            
+            # PIL RGBA rasm yaratish
+            img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
+            result_pil = Image.fromarray(img_rgb).convert("RGBA")
+            r, g, b, _ = result_pil.split()
+            result_pil = Image.merge("RGBA", (r, g, b, Image.fromarray(alpha_mask)))
+            
+            logger.info("BG Remove: GrabCut fallback muvaffaqiyatli")
+        
+        # ===== 4. Sifat Nazorati =====
+        total_pixels = alpha_mask.shape[0] * alpha_mask.shape[1]
+        transparent_pixels = np.sum(alpha_mask < 30)
+        opaque_pixels = np.sum(alpha_mask > 225)
+        removed_ratio = transparent_pixels / total_pixels
+        kept_ratio = opaque_pixels / total_pixels
+        
+        if removed_ratio < 0.03:
+            logger.warning(f"BG Remove: Fon topilmadi (faqat {removed_ratio:.1%} o'chirildi)")
+            # Davom etamiz, lekin natija yaxshi bo'lmasligi mumkin
+        
+        if kept_ratio < 0.03:
+            logger.warning(f"BG Remove: Ob'ekt topilmadi (faqat {kept_ratio:.1%} qoldi)")
+        
+        logger.info(f"BG Remove sifat: {removed_ratio:.0%} fon o'chirildi, {kept_ratio:.0%} ob'ekt qoldi")
+        
+        # ===== 5. Edge Refinement (Chetlarni tozalash) =====
+        refined_alpha = alpha_mask.copy()
+        
+        # Morphology Close — kichik teshiklarni to'ldirish
+        kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+        refined_alpha = cv2.morphologyEx(refined_alpha, cv2.MORPH_CLOSE, kernel, iterations=2)
+        
+        # Morphology Open — kichik shovqinlarni olib tashlash
+        kernel_small = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3))
+        refined_alpha = cv2.morphologyEx(refined_alpha, cv2.MORPH_OPEN, kernel_small, iterations=1)
+        
+        # Gaussian Feathering — yumshoq chet
+        refined_alpha = cv2.GaussianBlur(refined_alpha, (3, 3), 0)
+        
+        # Threshold clean — partial transparency → solid
+        refined_alpha = np.where(refined_alpha > 200, 255, 
+                        np.where(refined_alpha < 30, 0, refined_alpha)).astype(np.uint8)
+        
+        # Alpha kanalni yangilash
+        r, g, b, _ = result_pil.split()
+        result_pil = Image.merge("RGBA", (r, g, b, Image.fromarray(refined_alpha)))
+        
+        # ===== 6. Agar upscale qilingan bo'lsa — qaytarish =====
+        if needs_downscale:
+            result_pil = result_pil.resize(orig_size, Image.LANCZOS)
+            logger.info(f"BG Remove: Asl o'lchamga qaytarildi: {orig_size}")
+        
+        # ===== 7. Rejimga qarab natija yaratish =====
+        final_w, final_h = result_pil.size
+        
+        if mode == "transparent":
+            # Shaffof PNG + tabiiy soya
+            shadow_layer = Image.new("RGBA", (final_w, final_h), (0, 0, 0, 0))
+            
+            # Soya — ob'ektning alpha maskini siljitib yumshatish
+            shadow_alpha = np.array(result_pil.split()[-1])
+            # Soyani pastga va o'ngga siljitish
+            shift_x, shift_y = max(2, final_w // 200), max(3, final_h // 150)
+            shadow_shifted = np.zeros_like(shadow_alpha)
+            shadow_shifted[shift_y:, shift_x:] = shadow_alpha[:-shift_y, :-shift_x]
+            # Yumshatish
+            shadow_blurred = cv2.GaussianBlur(shadow_shifted, (21, 21), 0)
+            shadow_blurred = (shadow_blurred * 0.25).astype(np.uint8)  # 25% shaffoflik
+            
+            shadow_img = Image.new("RGBA", (final_w, final_h), (0, 0, 0, 0))
+            shadow_r = Image.new("L", (final_w, final_h), 0)
+            shadow_img = Image.merge("RGBA", (shadow_r, shadow_r, shadow_r, Image.fromarray(shadow_blurred)))
+            
+            # Soya + Ob'ekt birlashtirish
+            final = Image.alpha_composite(shadow_img, result_pil)
+            
+            png_path = output_path.rsplit('.', 1)[0] + '.png'
+            final.save(png_path, "PNG", optimize=True)
+            return png_path
+            
+        elif mode == "white":
+            bg = Image.new("RGBA", (final_w, final_h), (255, 255, 255, 255))
+            bg = Image.alpha_composite(bg, result_pil).convert("RGB")
+            jpg_path = output_path.rsplit('.', 1)[0] + '.jpg'
+            bg.save(jpg_path, "JPEG", quality=92, optimize=True)
+            return jpg_path
+            
+        elif mode == "black":
+            bg = Image.new("RGBA", (final_w, final_h), (0, 0, 0, 255))
+            bg = Image.alpha_composite(bg, result_pil).convert("RGB")
+            jpg_path = output_path.rsplit('.', 1)[0] + '.jpg'
+            bg.save(jpg_path, "JPEG", quality=92, optimize=True)
+            return jpg_path
+            
+        elif mode == "blur":
+            # Asl rasmni bokeh bilan xiralshtirish
+            orig_bgr = cv2.imread(image_path)
+            if needs_downscale:
+                orig_bgr = cv2.resize(orig_bgr, orig_size, interpolation=cv2.INTER_LANCZOS4)
+            blurred_bg = cv2.GaussianBlur(orig_bgr, (51, 51), 25)
+            blurred_pil = Image.fromarray(cv2.cvtColor(blurred_bg, cv2.COLOR_BGR2RGB)).convert("RGBA")
+            
+            # Xiralashtirilgan fon + ob'ekt
+            final = Image.alpha_composite(blurred_pil, result_pil).convert("RGB")
+            jpg_path = output_path.rsplit('.', 1)[0] + '.jpg'
+            final.save(jpg_path, "JPEG", quality=92, optimize=True)
+            return jpg_path
+            
+        elif mode == "gradient":
+            # Ko'k-binafsha gradient fon
+            gradient = np.zeros((final_h, final_w, 3), dtype=np.uint8)
+            for y in range(final_h):
+                ratio = y / max(1, final_h - 1)
+                # Ko'kdan (70, 130, 230) binafshaga (150, 80, 200)
+                r_val = int(70 + (150 - 70) * ratio)
+                g_val = int(130 + (80 - 130) * ratio)
+                b_val = int(230 + (200 - 230) * ratio)
+                gradient[y, :] = [r_val, g_val, b_val]
+            
+            gradient_pil = Image.fromarray(gradient).convert("RGBA")
+            final = Image.alpha_composite(gradient_pil, result_pil).convert("RGB")
+            jpg_path = output_path.rsplit('.', 1)[0] + '.jpg'
+            final.save(jpg_path, "JPEG", quality=92, optimize=True)
+            return jpg_path
+        
+        else:
+            logger.error(f"BG Remove: Noma'lum rejim: {mode}")
+            return None
+            
     except Exception as e:
         logger.error(f"Background Remove xatosi: {e}")
+        import traceback
+        logger.error(traceback.format_exc())
         return None
 
+
 def process_video_subtitle_translate(video_path, output_path, target_lang="uz", progress_callback=None):
     """Videoga avtomatik subtitle + tarjima qo'shadi."""
     from PIL import ImageFont, ImageDraw

main.py

@@ -258,7 +258,15 @@ async def handle_photo(update: Update, context: ContextTypes.DEFAULT_TYPE):
                 InlineKeyboardButton("🪞 Oyna Effekt", callback_data=f"mr|p|{short_id}")
             ],
             [
-                InlineKeyboardButton("🎨 Fonni O'chirish", callback_data=f"bg|p|{short_id}"),
+                InlineKeyboardButton("🎨 Shaffof Fon", callback_data=f"bg_t|p|{short_id}"),
+                InlineKeyboardButton("⬜ Oq Fon", callback_data=f"bg_w|p|{short_id}")
+            ],
+            [
+                InlineKeyboardButton("⬛ Qora Fon", callback_data=f"bg_k|p|{short_id}"),
+                InlineKeyboardButton("🌫️ Blur Fon", callback_data=f"bg_b|p|{short_id}")
+            ],
+            [
+                InlineKeyboardButton("🌈 Gradient Fon", callback_data=f"bg_c|p|{short_id}"),
                 InlineKeyboardButton("📱 Suv belgisi", callback_data=f"wm|p|{short_id}")
             ],
             [
@@ -533,13 +541,25 @@ async def handle_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
                     try: await query.edit_message_text("💎 AI Ultra HD sifatga oshirilmoqda...\n(Bu jarayon bir oz vaqt olishi mumkin)")
                     except: pass
                     success_path = await loop.run_in_executor(executor, upscale_image, input_path, output_path)
+                elif action.startswith("bg_"):
+                    bg_mode_map = {
+                        "bg_t": "transparent", "bg_w": "white",
+                        "bg_k": "black", "bg_b": "blur", "bg_c": "gradient"
+                    }
+                    bg_mode = bg_mode_map.get(action, "transparent")
+                    mode_names = {"bg_t": "🎨 Shaffof fon", "bg_w": "⬜ Oq fon", "bg_k": "⬛ Qora fon", "bg_b": "🌫️ Blur fon", "bg_c": "🌈 Gradient fon"}
+                    try: await query.edit_message_text(f"✂️ {mode_names.get(action, 'Fon')} tayyorlanmoqda...\n(AI tahlil + Edge Refinement)")
+                    except: pass
+                    success_path = await loop.run_in_executor(
+                        executor, apply_bg_remove, input_path, output_path, bg_mode
+                    )
                 else:
                     func = {
                         "r": apply_retro_filter, "u": upscale_image, 
                         "f": apply_face_restore, "a": apply_auto_enhance,
                         "n": apply_nudenet_filter,
                         "gl": apply_glitch_filter, "mr": apply_mirror_filter,
-                        "wm": apply_watermark, "bg": apply_bg_remove,
+                        "wm": apply_watermark,
                         "qb": apply_quality_boost,
                     }.get(action)
                     
@@ -603,7 +623,9 @@ async def handle_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
                      "st_anime": "AI anime", "st_sketch": "AI sketch",
                      "st_oil": "AI oil paint", "st_cart": "AI cartoon",
                      "stuz": "sub+o'zbek", "stru": "sub+rus", "sten": "sub+english",
-                     "qb": "sifat+ pro", "stb": "stabilizatsiya"
+                     "qb": "sifat+ pro", "stb": "stabilizatsiya",
+                     "bg_t": "shaffof fon", "bg_w": "oq fon",
+                     "bg_k": "qora fon", "bg_b": "blur fon", "bg_c": "gradient fon"
                 }.get(action, f"filter_{action}")
                 db.log_history(query.from_user.id, "photo" if m_type == "p" else "video", f_name, file_id)