Update app.py

app.py

@@ -27,7 +27,7 @@ import gradio as gr
 from gradio import mount_gradio_app
 from PIL import Image
 import io
-
+from scipy import ndimage
 # DigitalOcean Spaces
 import boto3
 from botocore.client import Config
@@ -109,6 +109,415 @@ def ensure_codeformer():
 
 ensure_codeformer()
 
+class NaturalFaceSwapper:
+    """Enhanced face swapping with natural blending techniques"""
+    
+    def __init__(self, swapper, face_app):
+        self.swapper = swapper
+        self.face_app = face_app
+    
+    def match_color_histogram(self, source, target, mask=None):
+        """Match color histogram of source to target for better blending"""
+        if mask is None:
+            mask = np.ones(source.shape[:2], dtype=np.uint8) * 255
+        
+        result = source.copy()
+        for i in range(3):  # Process each channel
+            source_channel = source[:, :, i]
+            target_channel = target[:, :, i]
+            
+            # Only use masked regions
+            source_masked = source_channel[mask > 0]
+            target_masked = target_channel[mask > 0]
+            
+            if len(source_masked) > 0 and len(target_masked) > 0:
+                # Match histograms
+                matched = self._match_histogram_channel(
+                    source_channel, source_masked, target_masked
+                )
+                result[:, :, i] = matched
+        
+        return result
+    def subtle_skin_smooth(img, strength=0.3, preserve_details=True):
+        """
+        Subtle bilateral filter for natural skin smoothing
+        
+        Args:
+            img: Input image (BGR format)
+            strength: Smoothing strength (0.1-0.5 recommended, default 0.3)
+            preserve_details: If True, uses edge-preserving filter
+        
+        Returns:
+            Smoothed image
+        """
+        if preserve_details:
+            # Bilateral filter preserves edges while smoothing
+            smoothed = cv2.bilateralFilter(img, d=9, sigmaColor=75, sigmaSpace=75)
+        else:
+            # Gaussian blur (faster but less detail preservation)
+            smoothed = cv2.GaussianBlur(img, (9, 9), 0)
+        
+        # Blend with original
+        result = cv2.addWeighted(img, 1-strength, smoothed, strength, 0)
+        return result
+
+
+    def advanced_skin_smooth(img, strength=0.3):
+        """
+        Advanced skin smoothing with frequency separation
+        Smooths skin while preserving pores and texture
+        
+        Args:
+            img: Input image (BGR format)
+            strength: Smoothing strength (0.2-0.5 recommended)
+        
+        Returns:
+            Smoothed image with preserved texture
+        """
+        # Convert to float for better precision
+        img_float = img.astype(np.float32) / 255.0
+        
+        # Low frequency (color and tone)
+        low_freq = cv2.GaussianBlur(img_float, (0, 0), sigmaX=3, sigmaY=3)
+        
+        # High frequency (details and texture)
+        high_freq = img_float - low_freq
+        
+        # Smooth only the low frequency
+        low_freq_smoothed = cv2.bilateralFilter(
+            (low_freq * 255).astype(np.uint8), 
+            d=9, 
+            sigmaColor=75, 
+            sigmaSpace=75
+        ).astype(np.float32) / 255.0
+        
+        # Blend smoothed low frequency with original
+        low_freq_final = cv2.addWeighted(low_freq, 1-strength, low_freq_smoothed, strength, 0)
+        
+        # Recombine with high frequency to preserve texture
+        result = low_freq_final + high_freq
+        result = np.clip(result * 255, 0, 255).astype(np.uint8)
+        
+        return result
+
+
+    def skin_tone_aware_smooth(img, face_analysis_app, strength=0.3):
+        """
+        Smooth only skin regions (more advanced)
+        Detects face and creates skin mask
+        
+        Args:
+            img: Input image (BGR format)
+            face_analysis_app: InsightFace app for face detection
+            strength: Smoothing strength
+        
+        Returns:
+            Image with skin-only smoothing
+        """
+        # Detect faces to create skin mask
+        faces = face_analysis_app.get(img)
+        
+        if not faces:
+            # No face detected, smooth entire image
+            return subtle_skin_smooth(img, strength)
+        
+        # Create skin mask based on face regions
+        mask = np.zeros(img.shape[:2], dtype=np.uint8)
+        
+        for face in faces:
+            x1, y1, x2, y2 = [int(v) for v in face.bbox]
+            
+            # Expand bbox to include more skin area
+            padding_x = int((x2 - x1) * 0.2)
+            padding_y = int((y2 - y1) * 0.3)
+            
+            x1 = max(0, x1 - padding_x)
+            y1 = max(0, y1 - padding_y)
+            x2 = min(img.shape[1], x2 + padding_x)
+            y2 = min(img.shape[0], y2 + padding_y)
+            
+            # Create elliptical mask for natural look
+            center = ((x1 + x2) // 2, (y1 + y2) // 2)
+            axes = ((x2 - x1) // 2, (y2 - y1) // 2)
+            cv2.ellipse(mask, center, axes, 0, 0, 360, 255, -1)
+        
+        # Blur mask for smooth transition
+        mask = cv2.GaussianBlur(mask, (31, 31), 0)
+        mask_float = mask.astype(float) / 255.0
+        mask_3ch = np.stack([mask_float] * 3, axis=2)
+        
+        # Apply smoothing
+        smoothed = cv2.bilateralFilter(img, 9, 75, 75)
+        
+        # Blend only where mask is present
+        result = (smoothed * mask_3ch * strength + 
+                  img * (1 - mask_3ch * strength)).astype(np.uint8)
+        
+        return result
+    
+    def _match_histogram_channel(self, channel, source_vals, target_vals):
+        """Match histogram for single channel"""
+        # Compute CDFs
+        source_hist, _ = np.histogram(source_vals, 256, [0, 256])
+        target_hist, _ = np.histogram(target_vals, 256, [0, 256])
+        
+        source_cdf = source_hist.cumsum()
+        target_cdf = target_hist.cumsum()
+        
+        # Normalize
+        source_cdf = source_cdf / source_cdf[-1]
+        target_cdf = target_cdf / target_cdf[-1]
+        
+        # Create mapping
+        mapping = np.zeros(256, dtype=np.uint8)
+        for i in range(256):
+            # Find closest value in target CDF
+            idx = np.argmin(np.abs(target_cdf - source_cdf[i]))
+            mapping[i] = idx
+        
+        return mapping[channel]
+    
+    def seamless_clone_blend(self, source, target, mask, center):
+        """Use Poisson blending for seamless integration"""
+        try:
+            # OpenCV's seamlessClone for natural blending
+            result = cv2.seamlessClone(
+                source, target, mask, center, 
+                cv2.NORMAL_CLONE  # Try MIXED_CLONE for different effect
+            )
+            return result
+        except:
+            # Fallback to alpha blending if seamlessClone fails
+            return self.alpha_blend_with_feather(source, target, mask)
+    
+    def alpha_blend_with_feather(self, source, target, mask, feather_amount=15):
+        """Alpha blend with feathered edges for smooth transition"""
+        # Create feathered mask
+        mask_float = mask.astype(float) / 255.0
+        
+        # Apply Gaussian blur for feathering
+        feathered_mask = cv2.GaussianBlur(mask_float, (feather_amount*2+1, feather_amount*2+1), 0)
+        feathered_mask = np.clip(feathered_mask, 0, 1)
+        
+        # Expand mask to 3 channels
+        feathered_mask_3ch = np.stack([feathered_mask] * 3, axis=2)
+        
+        # Blend
+        blended = (source * feathered_mask_3ch + 
+                   target * (1 - feathered_mask_3ch)).astype(np.uint8)
+        
+        return blended
+    
+    def laplacian_pyramid_blend(self, source, target, mask, levels=6):
+        """Multi-resolution blending using Laplacian pyramids"""
+        # Generate Gaussian pyramid for mask
+        mask_float = mask.astype(float) / 255.0
+        gaussian_mask = [mask_float]
+        
+        for i in range(levels):
+            mask_float = cv2.pyrDown(mask_float)
+            gaussian_mask.append(mask_float)
+        
+        # Generate Laplacian pyramids
+        def build_laplacian_pyramid(img, levels):
+            gaussian = [img.astype(float)]
+            for i in range(levels):
+                img = cv2.pyrDown(img)
+                gaussian.append(img)
+            
+            laplacian = []
+            for i in range(levels):
+                size = (gaussian[i].shape[1], gaussian[i].shape[0])
+                upsampled = cv2.pyrUp(gaussian[i + 1], dstsize=size)
+                laplacian.append(gaussian[i] - upsampled)
+            laplacian.append(gaussian[levels])
+            
+            return laplacian
+        
+        lp_source = build_laplacian_pyramid(source, levels)
+        lp_target = build_laplacian_pyramid(target, levels)
+        
+        # Blend each level
+        blended_pyramid = []
+        for ls, lt, gm in zip(lp_source, lp_target, gaussian_mask):
+            # Resize mask if needed
+            if gm.shape[:2] != ls.shape[:2]:
+                gm = cv2.resize(gm, (ls.shape[1], ls.shape[0]))
+            gm_3ch = np.stack([gm] * 3, axis=2)
+            blended = ls * gm_3ch + lt * (1 - gm_3ch)
+            blended_pyramid.append(blended)
+        
+        # Reconstruct
+        result = blended_pyramid[-1]
+        for i in range(levels - 1, -1, -1):
+            size = (blended_pyramid[i].shape[1], blended_pyramid[i].shape[0])
+            result = cv2.pyrUp(result, dstsize=size)
+            result += blended_pyramid[i]
+        
+        return np.clip(result, 0, 255).astype(np.uint8)
+    
+    def match_lighting(self, swapped_face, target_img, face_bbox):
+        """Match lighting conditions between swapped face and target"""
+        x1, y1, x2, y2 = [int(v) for v in face_bbox]
+        
+        # Extract face region from target
+        target_face = target_img[y1:y2, x1:x2]
+        
+        if target_face.size == 0 or swapped_face.size == 0:
+            return swapped_face
+        
+        # Resize if needed
+        if swapped_face.shape[:2] != target_face.shape[:2]:
+            target_face = cv2.resize(target_face, 
+                                    (swapped_face.shape[1], swapped_face.shape[0]))
+        
+        # Convert to LAB color space
+        swapped_lab = cv2.cvtColor(swapped_face, cv2.COLOR_BGR2LAB).astype(float)
+        target_lab = cv2.cvtColor(target_face, cv2.COLOR_BGR2LAB).astype(float)
+        
+        # Match mean and std of L channel (luminance)
+        swapped_l = swapped_lab[:, :, 0]
+        target_l = target_lab[:, :, 0]
+        
+        swapped_l_mean, swapped_l_std = swapped_l.mean(), swapped_l.std()
+        target_l_mean, target_l_std = target_l.mean(), target_l.std()
+        
+        if swapped_l_std > 0:
+            swapped_lab[:, :, 0] = ((swapped_l - swapped_l_mean) / swapped_l_std * 
+                                     target_l_std + target_l_mean)
+        
+        # Convert back
+        result = cv2.cvtColor(swapped_lab.astype(np.uint8), cv2.COLOR_LAB2BGR)
+        return result
+    
+    def adjust_face_mask(self, mask, erosion=3, dilation=5):
+        """Adjust mask to avoid harsh edges"""
+        # Slightly erode to avoid edge artifacts
+        kernel_erode = np.ones((erosion, erosion), np.uint8)
+        mask = cv2.erode(mask, kernel_erode, iterations=1)
+        
+        # Then dilate to smooth
+        kernel_dilate = np.ones((dilation, dilation), np.uint8)
+        mask = cv2.dilate(mask, kernel_dilate, iterations=1)
+        
+        # Gaussian blur for soft edges
+        mask = cv2.GaussianBlur(mask, (15, 15), 0)
+        
+        return mask
+    
+    def natural_face_swap(self, src_img, tgt_img, use_laplacian=True):
+        """
+        Complete natural face swap pipeline
+        
+        Args:
+            src_img: Source image (RGB)
+            tgt_img: Target image (RGB)
+            use_laplacian: Use Laplacian pyramid blending (slower but better)
+        
+        Returns:
+            Naturally blended face-swapped image
+        """
+        src_bgr = cv2.cvtColor(src_img, cv2.COLOR_RGB2BGR)
+        tgt_bgr = cv2.cvtColor(tgt_img, cv2.COLOR_RGB2BGR)
+        
+        # Detect faces
+        src_faces = self.face_app.get(src_bgr)
+        tgt_faces = self.face_app.get(tgt_bgr)
+        
+        if not src_faces or not tgt_faces:
+            raise ValueError("No faces detected")
+        
+        # Get largest faces
+        src_face = max(src_faces, key=lambda f: (f.bbox[2]-f.bbox[0])*(f.bbox[3]-f.bbox[1]))
+        tgt_face = max(tgt_faces, key=lambda f: (f.bbox[2]-f.bbox[0])*(f.bbox[3]-f.bbox[1]))
+        
+        # Perform basic swap
+        swapped_bgr = self.swapper.get(tgt_bgr, tgt_face, src_face, paste_back=True)
+        
+        # Create face mask
+        x1, y1, x2, y2 = [int(v) for v in tgt_face.bbox]
+        mask = np.zeros(tgt_bgr.shape[:2], dtype=np.uint8)
+        
+        # Use landmarks for better mask if available
+        if hasattr(tgt_face, 'kps') and tgt_face.kps is not None:
+            kps = tgt_face.kps.astype(np.int32)
+            hull = cv2.convexHull(kps)
+            cv2.fillConvexPoly(mask, hull, 255)
+        else:
+            # Fallback to bbox with some padding
+            padding = int((x2 - x1) * 0.1)
+            cv2.ellipse(mask, 
+                       ((x1 + x2) // 2, (y1 + y2) // 2),
+                       ((x2 - x1) // 2 + padding, (y2 - y1) // 2 + padding),
+                       0, 0, 360, 255, -1)
+        
+        # Adjust mask for softer edges
+        mask = self.adjust_face_mask(mask)
+        
+        # Color histogram matching
+        swapped_bgr = self.match_color_histogram(swapped_bgr, tgt_bgr, mask)
+        
+        # Lighting adjustment
+        swapped_face_region = swapped_bgr[y1:y2, x1:x2]
+        adjusted_face = self.match_lighting(swapped_face_region, tgt_bgr, tgt_face.bbox)
+        swapped_bgr[y1:y2, x1:x2] = adjusted_face
+        
+        # Final blending
+        if use_laplacian:
+            # Best quality but slower
+            result = self.laplacian_pyramid_blend(swapped_bgr, tgt_bgr, mask)
+        else:
+            # Faster alternative: Seamless cloning
+            center = ((x1 + x2) // 2, (y1 + y2) // 2)
+            result = self.seamless_clone_blend(swapped_bgr, tgt_bgr, mask, center)
+        
+        return cv2.cvtColor(result, cv2.COLOR_BGR2RGB)
+
+
+# ============================================
+# Integration into your existing code
+# ============================================
+
+def enhanced_face_swap_and_enhance(src_img, tgt_img, swapper, face_app, temp_dir=None):
+    """
+    Enhanced version of your face_swap_and_enhance function
+    """
+    try:
+        # Initialize natural swapper
+        natural_swapper = NaturalFaceSwapper(swapper, face_app)
+        
+        # Perform natural swap
+        swapped_rgb = natural_swapper.natural_face_swap(
+            src_img, tgt_img, 
+            use_laplacian=True  # Set False for faster processing
+        )
+        
+        # Apply CodeFormer enhancement
+        enhanced_rgb = enhance_image_with_codeformer(swapped_rgb, temp_dir)
+        
+        # Post-enhancement sharpening (subtle)
+        kernel_sharpen = np.array([[-0.5, -0.5, -0.5],
+                                   [-0.5,  5.0, -0.5],
+                                   [-0.5, -0.5, -0.5]]) * 0.3
+        enhanced_bgr = cv2.cvtColor(enhanced_rgb, cv2.COLOR_RGB2BGR)
+        sharpened = cv2.filter2D(enhanced_bgr, -1, kernel_sharpen)
+        
+        # Blend sharpened with original (60% sharp, 40% original)
+        final_bgr = cv2.addWeighted(sharpened, 0.6, enhanced_bgr, 0.4, 0)
+        final_rgb = cv2.cvtColor(final_bgr, cv2.COLOR_BGR2RGB)
+        
+        # Save result
+        if temp_dir is None:
+            temp_dir = os.path.join(tempfile.gettempdir(), f"faceswap_{uuid.uuid4().hex[:8]}")
+        os.makedirs(temp_dir, exist_ok=True)
+        
+        final_path = os.path.join(temp_dir, "enhanced.png")
+        cv2.imwrite(final_path, final_bgr)
+        
+        return final_rgb, final_path, ""
+        
+    except Exception as e:
+        return None, None, f"❌ Error: {str(e)}"
 
 # --------------------- FastAPI ---------------------
 fastapi_app = FastAPI()
@@ -719,7 +1128,12 @@ async def face_swap_api(
         # ------------------------------------------------------------------
         # FACE SWAP EXECUTION
         # ------------------------------------------------------------------
-        final_img, final_path, err = face_swap_and_enhance(src_rgb, tgt_rgb)
+        # final_img, final_path, err = face_swap_and_enhance(src_rgb, tgt_rgb)
+        
+        #--------------------Version 2.0 ----------------------------------------#
+        final_img, final_path, err = enhanced_face_swap_and_enhance(src_rgb, tgt_rgb)
+        #--------------------Version 2.0 ----------------------------------------#
+        
         if err:
             raise HTTPException(500, err)
 
@@ -851,214 +1265,6 @@ async def multi_face_swap_api(
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
-# @fastapi_app.post("/face-swap-couple", dependencies=[Depends(verify_token)])
-# async def face_swap_api(
-#     image1: UploadFile = File(...),
-#     image2: Optional[UploadFile] = File(None),
-#     target_category_id: str = Form(None),
-#     new_category_id: str = Form(None),
-#     user_id: Optional[str] = Form(None),
-#     credentials: HTTPAuthorizationCredentials = Security(security)
-# ):
-#     """
-#     Production-ready face swap endpoint supporting:
-#     - Multiple source images (image1 + optional image2)
-#     - Gender-based pairing
-#     - Merged faces from multiple sources
-#     - Mandatory CodeFormer enhancement
-#     """
-#     start_time = datetime.utcnow()
-    
-#     try:
-#         # -----------------------------
-#         # Validate input
-#         # -----------------------------
-#         if target_category_id == "":
-#             target_category_id = None
-#         if new_category_id == "":
-#             new_category_id = None
-#         if user_id == "":
-#             user_id = None
-
-#         if target_category_id and new_category_id:
-#             raise HTTPException(400, "Provide only one of new_category_id or target_category_id.")
-#         if not target_category_id and not new_category_id:
-#             raise HTTPException(400, "Either new_category_id or target_category_id is required.")
-
-#         logger.info(f"[FaceSwap] Incoming request → target_category_id={target_category_id}, new_category_id={new_category_id}, user_id={user_id}")
-
-#         # -----------------------------
-#         # Read source images
-#         # -----------------------------
-#         src_images = []
-#         img1_bytes = await image1.read()
-#         src1 = cv2.imdecode(np.frombuffer(img1_bytes, np.uint8), cv2.IMREAD_COLOR)
-#         if src1 is None:
-#             raise HTTPException(400, "Invalid image1 data")
-#         src_images.append(cv2.cvtColor(src1, cv2.COLOR_BGR2RGB))
-
-#         if image2:
-#             img2_bytes = await image2.read()
-#             src2 = cv2.imdecode(np.frombuffer(img2_bytes, np.uint8), cv2.IMREAD_COLOR)
-#             if src2 is not None:
-#                 src_images.append(cv2.cvtColor(src2, cv2.COLOR_BGR2RGB))
-
-#         # -----------------------------
-#         # Determine target image
-#         # -----------------------------
-#         target_bytes = None
-
-#         if new_category_id:
-#             doc = await subcategories_col.find_one({"asset_images._id": ObjectId(new_category_id)})
-#             if not doc:
-#                 raise HTTPException(404, "Asset image not found")
-#             asset = next((img for img in doc["asset_images"] if str(img["_id"]) == new_category_id), None)
-#             if not asset:
-#                 raise HTTPException(404, "Asset image URL not found")
-#             target_url = asset["url"]
-
-#         elif target_category_id:
-#             client = get_spaces_client()
-#             base_prefix = "faceswap/target/"
-#             resp = client.list_objects_v2(Bucket=DO_SPACES_BUCKET, Prefix=base_prefix, Delimiter="/")
-#             categories = [p["Prefix"].split("/")[2] for p in resp.get("CommonPrefixes", [])]
-#             target_url = None
-#             for category in categories:
-#                 original_prefix = f"faceswap/target/{category}/original/"
-#                 objects = client.list_objects_v2(Bucket=DO_SPACES_BUCKET, Prefix=original_prefix).get("Contents", [])
-#                 original_filenames = sorted([obj["Key"].split("/")[-1] for obj in objects if obj["Key"].endswith(".png")])
-#                 for idx, filename in enumerate(original_filenames, start=1):
-#                     cid = f"{category.lower()}image_{idx}"
-#                     if cid == target_category_id:
-#                         target_url = f"{DO_SPACES_ENDPOINT}/{DO_SPACES_BUCKET}/{original_prefix}{filename}"
-#                         break
-#                 if target_url:
-#                     break
-#             if not target_url:
-#                 raise HTTPException(404, "Target categoryId not found")
-
-#         # -----------------------------
-#         # Download target image
-#         # -----------------------------
-#         async with httpx.AsyncClient(timeout=30.0) as client:
-#             resp = await client.get(target_url)
-#             resp.raise_for_status()
-#             target_bytes = resp.content
-
-#         tgt_bgr = cv2.imdecode(np.frombuffer(target_bytes, np.uint8), cv2.IMREAD_COLOR)
-#         if tgt_bgr is None:
-#             raise HTTPException(400, "Invalid target image data")
-#         target_rgb = cv2.cvtColor(tgt_bgr, cv2.COLOR_BGR2RGB)
-
-#         # -----------------------------
-#         # Merge all source faces
-#         # -----------------------------
-#         all_src_faces = []
-#         for img in src_images:
-#             faces = face_analysis_app.get(cv2.cvtColor(img, cv2.COLOR_RGB2BGR))
-#             all_src_faces.extend(faces)
-
-#         if not all_src_faces:
-#             raise HTTPException(400, "No faces detected in source images")
-
-#         tgt_faces = face_analysis_app.get(tgt_bgr)
-#         if not tgt_faces:
-#             raise HTTPException(400, "No faces detected in target image")
-
-#         # -----------------------------
-#         # Gender-based pairing
-#         # -----------------------------
-#         def face_sort_key(face):
-#             x1, y1, x2, y2 = face.bbox
-#             area = (x2 - x1) * (y2 - y1)
-#             cx = (x1 + x2) / 2
-#             return (-area, cx)
-
-#         # Separate by gender
-#         src_male = sorted([f for f in all_src_faces if f.gender == 1], key=face_sort_key)
-#         src_female = sorted([f for f in all_src_faces if f.gender == 0], key=face_sort_key)
-#         tgt_male = sorted([f for f in tgt_faces if f.gender == 1], key=face_sort_key)
-#         tgt_female = sorted([f for f in tgt_faces if f.gender == 0], key=face_sort_key)
-
-#         pairs = []
-#         for s, t in zip(src_male, tgt_male):
-#             pairs.append((s, t))
-#         for s, t in zip(src_female, tgt_female):
-#             pairs.append((s, t))
-
-#         # fallback if gender mismatch
-#         if not pairs:
-#             src_all = sorted(all_src_faces, key=face_sort_key)
-#             tgt_all = sorted(tgt_faces, key=face_sort_key)
-#             pairs = list(zip(src_all, tgt_all))
-
-#         # -----------------------------
-#         # Perform face swap
-#         # -----------------------------
-#         with swap_lock:
-#             result_img = tgt_bgr.copy()
-#             for src_face, _ in pairs:
-#                 current_faces = sorted(face_analysis_app.get(result_img), key=face_sort_key)
-#                 candidates = [f for f in current_faces if f.gender == src_face.gender] or current_faces
-#                 target_face = candidates[0]
-#                 result_img = swapper.get(result_img, target_face, src_face, paste_back=True)
-
-#         result_rgb = cv2.cvtColor(result_img, cv2.COLOR_BGR2RGB)
-
-#         # -----------------------------
-#         # Mandatory enhancement
-#         # -----------------------------
-#         enhanced_rgb = mandatory_enhancement(result_rgb)
-#         enhanced_bgr = cv2.cvtColor(enhanced_rgb, cv2.COLOR_RGB2BGR)
-
-#         # -----------------------------
-#         # Save, upload, compress
-#         # -----------------------------
-#         temp_dir = tempfile.mkdtemp(prefix="faceswap_")
-#         final_path = os.path.join(temp_dir, "result.png")
-#         cv2.imwrite(final_path, enhanced_bgr)
-
-#         with open(final_path, "rb") as f:
-#             result_bytes = f.read()
-
-#         result_key = f"faceswap/result/{uuid.uuid4().hex}_enhanced.png"
-#         result_url = upload_to_spaces(result_bytes, result_key)
-
-#         compressed_bytes = compress_image(result_bytes, max_size=(1280, 1280), quality=72)
-#         compressed_key = f"faceswap/result/{uuid.uuid4().hex}_enhanced_compressed.jpg"
-#         compressed_url = upload_to_spaces(compressed_bytes, compressed_key, content_type="image/jpeg")
-
-#         # -----------------------------
-#         # Log API usage
-#         # -----------------------------
-#         end_time = datetime.utcnow()
-#         response_time_ms = (end_time - start_time).total_seconds() * 1000
-#         if database is not None:
-#             await database.api_logs.insert_one({
-#                 "endpoint": "/face-swap",
-#                 "status": "success",
-#                 "response_time_ms": response_time_ms,
-#                 "timestamp": end_time
-#             })
-
-#         return {
-#             "result_key": result_key,
-#             "result_url": result_url,
-#             "compressed_url": compressed_url
-#         }
-
-#     except Exception as e:
-#         end_time = datetime.utcnow()
-#         response_time_ms = (end_time - start_time).total_seconds() * 1000
-#         if database is not None:
-#             await database.api_logs.insert_one({
-#                 "endpoint": "/face-swap",
-#                 "status": "fail",
-#                 "response_time_ms": response_time_ms,
-#                 "timestamp": end_time,
-#                 "error": str(e)
-#             })
-#         raise HTTPException(500, f"Face swap failed: {str(e)}")
 
 @fastapi_app.post("/face-swap-couple", dependencies=[Depends(verify_token)])
 async def face_swap_api(