Upload 38 files

.gitattributes

@@ -33,3 +33,18 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+merged_models_and_api/temp_image.png filter=lfs diff=lfs merge=lfs -text
+merged_models_and_api/uploads/1ad196f4-9c68-4e25-a11f-f78d0067591b.jpg filter=lfs diff=lfs merge=lfs -text
+merged_models_and_api/uploads/1c837ff1-19ea-47a7-ad48-7a2b78feddac.jpg filter=lfs diff=lfs merge=lfs -text
+merged_models_and_api/uploads/34d20ae0-092f-4fc1-a957-38296d6d4f07.png filter=lfs diff=lfs merge=lfs -text
+merged_models_and_api/uploads/3e585a79-d927-4ba0-bfe8-294e2a6228d8.jpg filter=lfs diff=lfs merge=lfs -text
+merged_models_and_api/uploads/4a23733a-104d-4804-90b8-694a3186edcf.jpg filter=lfs diff=lfs merge=lfs -text
+merged_models_and_api/uploads/73b35923-3a5a-4a0b-9ba7-6ad3b544362f.jpg filter=lfs diff=lfs merge=lfs -text
+merged_models_and_api/uploads/8b2085b4-c44f-4925-a1f4-182eac070bbf.jpg filter=lfs diff=lfs merge=lfs -text
+merged_models_and_api/uploads/a3d25bdd-ca68-4167-9c74-a50e3a43e448.jpg filter=lfs diff=lfs merge=lfs -text
+merged_models_and_api/uploads/a770eb04-2469-4102-af71-53afc5ea08ef.jpg filter=lfs diff=lfs merge=lfs -text
+merged_models_and_api/uploads/bfcedb9d-acab-420d-95ba-aa239c121810.png filter=lfs diff=lfs merge=lfs -text
+merged_models_and_api/uploads/cce44ef5-15af-4532-8197-db4cb51ec4d9.jpg filter=lfs diff=lfs merge=lfs -text
+merged_models_and_api/uploads/e177e7dc-50da-4ef8-8746-d428193f98e5.jpg filter=lfs diff=lfs merge=lfs -text
+merged_models_and_api/uploads/f05a4dae-d69e-48a0-a6e5-28508c2d1147.png filter=lfs diff=lfs merge=lfs -text
+merged_models_and_api/uploads/f2046fa5-79e5-4c20-91f6-f0f70fab2232.jpg filter=lfs diff=lfs merge=lfs -text

merged_models_and_api/.env

@@ -0,0 +1,2 @@
+SECRET_API_KEY="AIzaSyBQ1l8bsM59ux19c7eOl91wir8A5VDH5uQ"
+SEARCH_API_KEY="AIzaSyD4UYlJlpktwEyCtM_ONEpQWMrbyKyzmFg"

merged_models_and_api/.gitignore

@@ -0,0 +1,4 @@
+.env
+.env.local
+.env.development
+.env.test

merged_models_and_api/background_generator.py

@@ -0,0 +1,102 @@
+import base64
+import mimetypes
+import os
+import time
+import uuid
+from google import genai
+from google.genai import types
+from dotenv import load_dotenv
+
+
+load_dotenv()
+
+class BackgroundGenerator:
+    def save_binary_file(self, file_name, data):
+        f = open(file_name, "wb")
+        f.write(data)
+        f.close()
+        print(f"File saved to to: {file_name}")
+
+
+    def generate(self, prompt):
+        client = genai.Client(
+            api_key=os.getenv("SECRET_API_KEY"),
+        )
+
+        model = "gemini-2.0-flash-preview-image-generation"
+        contents = [
+            types.Content(
+                role="user",
+                parts=[
+                    types.Part.from_text(text=prompt),
+                ],
+            ),
+        ]
+        generate_content_config = types.GenerateContentConfig(
+            response_modalities=[
+                "IMAGE",
+                "TEXT",
+            ],
+            safety_settings=[
+                types.SafetySetting(
+                    category="HARM_CATEGORY_HARASSMENT",
+                    threshold="BLOCK_NONE",  
+                ),
+                types.SafetySetting(
+                    category="HARM_CATEGORY_HATE_SPEECH",
+                    threshold="BLOCK_NONE", 
+                ),
+                types.SafetySetting(
+                    category="HARM_CATEGORY_SEXUALLY_EXPLICIT",
+                    threshold="BLOCK_NONE", 
+                ),
+                types.SafetySetting(
+                    category="HARM_CATEGORY_DANGEROUS_CONTENT",
+                    threshold="BLOCK_NONE",  
+                ),
+            ],
+        )
+
+        timestamp = int(time.time())
+        unique_id = str(uuid.uuid4())
+
+        file_index = 0
+        for chunk in client.models.generate_content_stream(
+            model=model,
+            contents=contents,
+            config=generate_content_config,
+        ):
+            if (
+                chunk.candidates is None
+                or chunk.candidates[0].content is None
+                or chunk.candidates[0].content.parts is None
+            ):
+                continue
+            if chunk.candidates[0].content.parts[0].inline_data and chunk.candidates[0].content.parts[0].inline_data.data:
+                inline_data = chunk.candidates[0].content.parts[0].inline_data
+                data_buffer = inline_data.data
+                file_extension = mimetypes.guess_extension(inline_data.mime_type)
+
+                script_dir = os.path.dirname(os.path.abspath(__file__))
+                project_root = os.path.dirname(os.path.dirname(script_dir))  # Go up 2 levels from merged_models_and_api
+                
+                # Path to frontend public folder
+                frontend_public = os.path.join(project_root, "frontend", "public")
+                
+                # Create the directory if it doesn't exist
+                os.makedirs(frontend_public, exist_ok=True)
+                
+                unique_filename = f"background_{timestamp}_{unique_id[:8]}{file_extension}"
+                output_path = os.path.join(frontend_public, unique_filename)
+
+                self.save_binary_file(output_path, data_buffer)
+                
+                # Return both the full path and the public URL path
+                public_url = f"/backgrounds/{unique_filename}"
+                return {
+                    'file_path': output_path,
+                    'public_url': public_url,
+                    'file_name': unique_filename
+                }
+            else:
+                print(chunk.text)

merged_models_and_api/image_enhancement_option3_helper.py

@@ -0,0 +1,214 @@
+import os
+import uuid
+from PIL import Image, ImageEnhance, ImageFilter
+from langchain_google_genai import ChatGoogleGenerativeAI
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class image_enhancement_option3_helper:
+    def __init__(self, model):
+        self.model = model
+    
+    def analyze_image(self, img) -> dict:
+        """Analyzes an image and returns its properties."""
+        try:
+            width, height = img.size
+            mode = img.mode
+            
+            # Simple brightness analysis
+            grayscale = img.convert('L')
+            pixels = list(grayscale.getdata())
+            avg_brightness = sum(pixels) / len(pixels)
+            
+            analysis = {
+                'width': width,
+                'height': height,
+                'mode': mode,
+                'avg_brightness': avg_brightness,
+                'is_dark': avg_brightness < 100,
+                'is_small': width < 500 or height < 500,
+                'aspect_ratio': width / height,
+                'recommendations': []
+            }
+            
+            # Generate recommendations
+            if analysis['is_dark']:
+                analysis['recommendations'].append(f"Increase brightness (current: {avg_brightness:.1f})")
+            
+            analysis['recommendations'].append("Enhance contrast for better dynamic range")
+            
+            if analysis['is_small']:
+                analysis['recommendations'].append("Apply sharpening (small image)")
+            
+            analysis['recommendations'].append("Light noise reduction for smoothing")
+            return analysis
+                
+        except Exception as e:
+            print(f"Error analyzing image: {e}")
+            return {}
+
+    def ai_enhanced_image_processing(self, image: Image) -> str:
+        """
+        Uses AI to analyze the image and decide on enhancements, then applies them.
+        This is a hybrid approach that uses AI for decision making but direct Python for processing.
+        """
+        # Step 1: Analyze the image
+        analysis = self.analyze_image(image)
+        if not analysis:
+            return None
+        
+        
+        # Step 2: Using Google Generative AI to decide on enhancements
+        llm = ChatGoogleGenerativeAI(
+            model="gemini-2.5-flash",
+            google_api_key=os.getenv("SECRET_API_KEY"),
+            temperature=0.1,
+        )
+        
+        ai_prompt = f"""
+        You are an expert image enhancement specialist. Based on this image analysis, decide on the optimal enhancement strategy:
+
+        Image Analysis:
+        - Dimensions: {analysis['width']}x{analysis['height']} pixels
+        - Color mode: {analysis['mode']}
+        - Average brightness: {analysis['avg_brightness']:.1f} (0-255 scale)
+        - Is dark: {analysis['is_dark']}
+        - Is small: {analysis['is_small']}
+        - Aspect ratio: {analysis['aspect_ratio']:.2f}
+
+        Recommendations from analysis:
+        {chr(10).join(f"- {rec}" for rec in analysis['recommendations'])}
+
+        Please provide a specific enhancement plan in this exact format:
+        BRIGHTNESS_FACTOR: [number between 0.8-1.5, or SKIP]
+        CONTRAST_FACTOR: [number between 0.8-1.5, or SKIP]
+        SHARPNESS_FACTOR: [number between 0.8-2.0, or SKIP]
+        NOISE_REDUCTION_RADIUS: [number between 0.3-2.0, or SKIP]
+
+        Consider:
+        - If brightness < 90, suggest 1.2-1.4 brightness factor
+        - If brightness > 90, suggest 1.0-1.2 or SKIP
+        - Always enhance contrast slightly (1.1-1.3)
+        - For small images, use higher sharpness (1.3-1.8)
+        - Use light noise reduction (0.5-0.8) for final smoothing
+        """
+        
+        try:
+            ai_response = llm.invoke(ai_prompt)
+            print(f"AI Enhancement Plan:\n{ai_response.content}")
+            
+            enhancement_plan = self.parse_ai_response(ai_response.content)
+                    
+            if enhancement_plan.get('brightness') != 'SKIP':
+                print(f"Applying brightness enhancement (factor: {enhancement_plan['brightness']})")
+                current_image = self.increase_brightness(image, enhancement_plan['brightness'])
+
+            if enhancement_plan.get('contrast') != 'SKIP':
+                print(f"Applying contrast enhancement (factor: {enhancement_plan['contrast']})")
+                current_image = self.increase_contrast(current_image, enhancement_plan['contrast'])
+
+            if enhancement_plan.get('sharpness') != 'SKIP':
+                print(f"Applying sharpness enhancement (factor: {enhancement_plan['sharpness']})")
+                current_image = self.increase_sharpness(current_image, enhancement_plan['sharpness'])
+
+            if enhancement_plan.get('noise_reduction') != 'SKIP':
+                print(f"Applying noise reduction (radius: {enhancement_plan['noise_reduction']})")
+                current_image = self.noise_reduction(current_image, enhancement_plan['noise_reduction'])
+            return current_image 
+            
+        except Exception as e:
+            return self.rule_based_enhancement(image, analysis)
+
+    def parse_ai_response(self,response: str) -> dict:
+        """Parse the AI response to extract enhancement parameters."""
+        plan = {}
+        lines = response.split('\n')
+        
+        for line in lines:
+            if 'BRIGHTNESS_FACTOR:' in line:
+                value = line.split(':')[1].strip()
+                plan['brightness'] = float(value) if value != 'SKIP' else 'SKIP'
+            elif 'CONTRAST_FACTOR:' in line:
+                value = line.split(':')[1].strip()
+                plan['contrast'] = float(value) if value != 'SKIP' else 'SKIP'
+            elif 'SHARPNESS_FACTOR:' in line:
+                value = line.split(':')[1].strip()
+                plan['sharpness'] = float(value) if value != 'SKIP' else 'SKIP'
+            elif 'NOISE_REDUCTION_RADIUS:' in line:
+                value = line.split(':')[1].strip()
+                plan['noise_reduction'] = float(value) if value != 'SKIP' else 'SKIP'
+        
+        # Set defaults if not provided
+        plan.setdefault('brightness', 1.1)
+        plan.setdefault('contrast', 1.2)
+        plan.setdefault('sharpness', 1.3)
+        plan.setdefault('noise_reduction', 0.6)
+        
+        return plan
+
+    def rule_based_enhancement(self, image, analysis: dict):
+        """Fallback rule-based enhancement if AI fails."""
+        print("🔧 Applying rule-based enhancement...")
+
+        current_image = image
+
+        if analysis['is_dark']:
+            current_image = self.increase_brightness(current_image, 1.3)
+
+        current_image = self.increase_contrast(current_image, 1.2)
+
+        if analysis['is_small']:
+            current_image = self.increase_sharpness(current_image, 1.4)
+        else:
+            current_image = self.increase_sharpness(current_image, 1.2)
+
+        current_image = self.noise_reduction(current_image, 0.3)
+
+        return current_image
+
+    def increase_brightness(self, img, factor: float) -> str:
+        """Increases the brightness of the image."""
+        try:
+            enhancer = ImageEnhance.Brightness(img)
+            enhanced_img = enhancer.enhance(factor)
+            return enhanced_img
+        except Exception as e:
+            print(f"Error: {e}")
+            return img
+
+    def increase_contrast(self, img, factor: float) -> str:
+        """Increases the contrast of the image."""
+        try:
+            enhancer = ImageEnhance.Contrast(img)
+            enhanced_img = enhancer.enhance(factor)
+            return enhanced_img
+        except Exception as e:
+            print(f"Error: {e}")
+            return img
+        except Exception as e:
+            print(f"Error: {e}")
+            return img
+
+    def increase_sharpness(self, img, factor: float) -> str:
+        """Increases the sharpness of the image."""
+        try:
+            enhancer = ImageEnhance.Sharpness(img)
+            enhanced_img = enhancer.enhance(factor)
+            return enhanced_img
+        except Exception as e:
+            print(f"Error: {e}")
+            return img
+
+    def noise_reduction(self, img, radius: float) -> str:
+        """Reduces noise in the image using Gaussian blur."""
+        try:
+            filtered_img = img.filter(ImageFilter.GaussianBlur(radius=radius))
+            return filtered_img
+        except Exception as e:
+            print(f"Error: {e}")
+            return img
+        except Exception as e:
+            print(f"Error: {e}")
+            return img
+

merged_models_and_api/process_image.py

@@ -0,0 +1,357 @@
+from matplotlib import image
+from transformers import OwlViTProcessor, OwlViTForObjectDetection
+from PIL import Image
+import torch
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+from rembg import remove
+import os
+import cv2
+import numpy as np
+from PIL import Image, ImageEnhance, ImageFilter
+from gradio_client import Client, handle_file
+import requests
+import shutil
+import json
+import google.generativeai as genai
+import base64
+from langchain_google_genai import ChatGoogleGenerativeAI
+import image_enhancement_option3_helper
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class process_image:
+    def __init__(self):
+        self.image_path = None
+        self.raw_image = None
+        self.detected_objects = []
+        self.cropped_image = None
+        self.no_background_image = None
+        self.enhanced_image_1 = None
+        self.enhanced_image_2 = None
+        self.enhanced_image_3 = None
+        self.chosen_image = None
+        self.description = ""
+
+    def detect_object(self):
+        processor = OwlViTProcessor.from_pretrained("google/owlvit-base-patch32")
+        model = OwlViTForObjectDetection.from_pretrained("google/owlvit-base-patch32")
+        texts = [[
+            # Giyim
+            "clothing",
+            "topwear",
+            "bottomwear",
+            "outerwear",
+            "apparel",
+            "sportswear",
+            "uniform",
+            "underwear",
+            "dress",
+            "outfit",
+
+            # Ayakkabı
+            "footwear",
+            "shoes",
+            "boots",
+            "sneakers",
+
+            # Aksesuarlar
+            "accessory",
+            "bag",
+            "backpack",
+            "handbag",
+            "wallet",
+            "belt",
+            "hat",
+            "cap",
+            "scarf",
+            "glasses",
+            "watch",
+            "jewelry",
+
+            # Elektronik
+            "electronics",
+            "device",
+            "gadget",
+            "smartphone",
+            "laptop",
+            "tablet",
+            "headphones",
+            "smartwatch",
+
+            # Kozmetik / Kişisel Bakım
+            "cosmetics",
+            "beauty product",
+            "skincare",
+            "makeup",
+            "perfume",
+            "hair product",
+
+            # Bebek ve çocuk
+            "baby product",
+            "baby clothes",
+            "toy",
+            "stroller",
+            "pacifier",
+
+            # Ev ve yaşam
+            "home item",
+            "furniture",
+            "appliance",
+            "decor",
+            "kitchenware",
+            "bedding",
+            "cleaning tool",
+
+            # Spor ve outdoor
+            "sports gear",
+            "fitness equipment",
+            "gym accessory",
+            "camping gear",
+            "bicycle equipment"
+            ]
+        ]
+
+        inputs = processor(text=texts, images=self.raw_image, return_tensors="pt")
+
+        with torch.no_grad():
+            outputs = model(**inputs)
+
+        target_sizes = torch.tensor([self.raw_image.size[::-1]])
+        results = processor.post_process_grounded_object_detection(
+            outputs=outputs,
+            target_sizes=target_sizes,
+            threshold=0.2
+        )[0]
+        self.detected_objects = results["labels"].tolist()
+        
+        # Collect all valid bounding boxes
+        valid_boxes = []
+        detected_labels = []
+        for score, label_id, box in zip(results["scores"], results["labels"], results["boxes"]):
+            if score < 0.05:
+                continue 
+            valid_boxes.append(box.tolist())
+            detected_labels.append(texts[0][label_id])
+        
+        if len(valid_boxes) == 0:
+            self.cropped_image = self.raw_image
+        elif len(valid_boxes) == 1:
+            # Single object detected
+            xmin, ymin, xmax, ymax = map(int, valid_boxes[0])
+            self.cropped_image = self.raw_image.crop((xmin, ymin, xmax, ymax))
+            print(f"Single object detected: {detected_labels[0]}")
+        else:
+            # Multiple objects detected and they are pairs      
+            similar_items = ['shoes', 'boots', 'sneakers', 'footwear', 'glasses', 'earrings', 
+                           'gloves', 'socks', 'jewelry', 'watch', 'bracelet']
+            clothing_items = ['clothing', 'topwear', 'bottomwear', 'dress', 'outfit', 'apparel']
+            
+            has_similar_items = any(any(item in label.lower() for item in similar_items) 
+                                  for label in detected_labels)
+            has_clothing_items = any(any(item in label.lower() for item in clothing_items) 
+                                   for label in detected_labels)
+            
+            if has_similar_items or has_clothing_items or len(valid_boxes) <= 3:
+                # Combining them
+                all_xmin = min(box[0] for box in valid_boxes)
+                all_ymin = min(box[1] for box in valid_boxes)
+                all_xmax = max(box[2] for box in valid_boxes)
+                all_ymax = max(box[3] for box in valid_boxes)
+            
+                self.cropped_image = self.raw_image.crop((all_xmin, all_ymin, all_xmax, all_ymax))
+            else: # If there are too many different objects
+                self.cropped_image = self.raw_image
+        
+    def remove_background(self):
+        if self.cropped_image is None:
+            print("No cropped image available. Using entire image.")
+            self.cropped_image = self.raw_image
+
+        self.no_background_image = remove(self.cropped_image)
+
+    def enhance_image_option1(self):
+        sharpened = self.no_background_image.filter(ImageFilter.UnsharpMask(
+            radius=1,
+            percent=120,
+            threshold=1
+        ))
+
+        enhancer = ImageEnhance.Contrast(sharpened)
+        contrast_enhanced = enhancer.enhance(1.1)  # 10% more contrast
+        
+        enhancer = ImageEnhance.Brightness(contrast_enhanced)
+        brightness_enhanced = enhancer.enhance(1.02)  # 2% brighter
+        
+        enhancer = ImageEnhance.Color(brightness_enhanced)
+        color_enhanced = enhancer.enhance(1.05)  # 5% more vibrant
+ 
+        img_array = np.array(color_enhanced)
+        
+        img_bgr = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
+        denoised = cv2.bilateralFilter(img_bgr, 3, 10, 10)
+        img_rgb = cv2.cvtColor(denoised, cv2.COLOR_BGR2RGB)
+        
+        self.enhanced_image_1 = Image.fromarray(img_rgb)
+        scale = 1.5
+        original_size = self.enhanced_image_1.size
+        new_size = (int(original_size[0] * scale), int(original_size[1] * scale))
+
+        self.enhanced_image_1 = self.enhanced_image_1.resize(new_size, Image.Resampling.LANCZOS)
+        return self.enhanced_image_1
+
+    def enhance_image_option2(self):
+
+        client = Client("finegrain/finegrain-image-enhancer")
+
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        output_path = os.path.join(script_dir, "temp_image.png")
+
+        self.no_background_image.save(output_path)
+
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        temp_image_path = os.path.join(script_dir, "temp_image.png")
+        result = client.predict(
+                input_image=handle_file(temp_image_path),
+                prompt="",
+                negative_prompt="",
+                seed=0,
+                upscale_factor=2.6,
+                controlnet_scale=0.5,
+                controlnet_decay=0.6,
+                condition_scale=5,
+                tile_width=200,
+                tile_height=200,
+                denoise_strength=0,
+                num_inference_steps=23,
+                solver="DPMSolver",
+                api_name="/process"
+        )
+        # Get the image from result[1] - local file path, not a URL
+        image_path = result[1]
+
+        self.enhanced_image_2 = Image.open(image_path)
+        return self.enhanced_image_2
+    
+    def enhance_image_option3(self):
+        enhancer = image_enhancement_option3_helper.image_enhancement_option3_helper(model=None)
+        self.enhanced_image_3 = enhancer.ai_enhanced_image_processing(self.no_background_image)
+
+    def generate_description_from_image(self, image_b64: str,
+                                        tone: str = "professional",
+                                        lang: str = "en") -> str:
+        
+        API_KEY = os.getenv("SECRET_API_KEY")
+
+        genai.configure(api_key=API_KEY) # ← ONLY this line
+
+        model = genai.GenerativeModel("gemini-2.0-flash-exp")  # Updated model name
+
+        prompt = (
+            f"Analyze this product image and generate an SEO-optimized e-commerce product listing in {lang}. "
+            f"Tone: {tone}. Respond ONLY with valid JSON (no markdown formatting) containing these exact keys: "
+            f"'title', 'description', 'features', 'tags'. "
+            f"The 'features' and 'tags' must be arrays of strings. "
+            f"Do not include any other text or formatting."
+        )
+
+        try:
+            response = model.generate_content(
+                [
+                    {"inline_data": {"mime_type": "image/jpeg", "data": image_b64}},
+                    prompt
+                ]
+            )
+            text = response.text.strip()
+            
+            # Remove markdown code blocks
+            if text.startswith("```json"):
+                text = text[7:]  # Remove ```json
+            if text.startswith("```"):
+                text = text[3:]   # Remove ```
+            if text.endswith("```"):
+                text = text[:-3]  # Remove trailing ```
+            
+            text = text.strip()
+            
+            # Parsing the JSON response
+            try:
+                parsed_json = json.loads(text)
+                print("Successfully parsed JSON response")
+                return text
+            except json.JSONDecodeError:
+                return "Invalid JSON response: " + text
+        except Exception as err:
+            return "Error generating description: " + str(err)
+    
+
+    def choose_image(self, number: int):
+        if number == 1:
+            self.chosen_image = self.enhanced_image_1
+        elif number == 2:
+            self.chosen_image = self.enhanced_image_2
+        elif number == 3:
+            self.chosen_image = self.enhanced_image_3
+        else:
+            raise ValueError("Invalid image number. Choose 1, 2, or 3.")
+        
+
+    def generate_description(self):
+        print("Starting description generation...")
+        
+        if self.chosen_image is None:
+            print("Error: No image chosen for description generation")
+            self.description = "Error: No image selected for description generation"
+            return self.description
+        
+        try:
+            print("Converting image to base64...")
+            from io import BytesIO
+            buffer = BytesIO()  
+            
+            # It handles RGBA images by converting to RGB
+            image_to_save = self.chosen_image
+            if image_to_save.mode == 'RGBA':
+                background = Image.new('RGB', image_to_save.size, (255, 255, 255))
+                background.paste(image_to_save, mask=image_to_save.split()[-1])  # Use alpha channel as mask
+                image_to_save = background
+            elif image_to_save.mode != 'RGB':
+                image_to_save = image_to_save.convert('RGB')
+            
+            image_to_save.save(buffer, format='JPEG', quality=95)
+            img_b64 = base64.b64encode(buffer.getvalue()).decode()
+            print(f"Image converted to base64, size: {len(img_b64)} characters")
+            
+            tone = "professional"
+            lang = "en"
+            self.description = self.generate_description_from_image(img_b64, tone, lang)
+
+
+            if len(self.description) > 15000:
+                self.description = self.description[:15000] + "..."
+
+            return self.description
+        except Exception as e:
+            print(f"Error in generate_description: {str(e)}")
+            import traceback
+            traceback.print_exc()
+            self.description = f"Error generating description: {str(e)}"
+            return self.description
+
+    def process(self, image_path):
+        if os.path.isabs(image_path):
+            # If absolute path, use it directly
+            self.image_path = image_path
+        else:
+            # If relative path, join with script directory
+            script_dir = os.path.dirname(os.path.abspath(__file__))
+            self.image_path = os.path.join(script_dir, image_path)
+        
+        self.raw_image = Image.open(self.image_path).convert("RGB")
+
+    def get_enhanced_images(self):
+        return self.enhanced_image_1, self.enhanced_image_2, self.enhanced_image_3
+    
+    def get_description(self):
+        return self.description

merged_models_and_api/rf_ai_api.py

@@ -0,0 +1,294 @@
+from process_image import process_image
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Optional
+import shutil
+import os
+import base64
+from io import BytesIO
+from PIL import Image
+import uuid
+from search_product import search_product
+
+app = FastAPI()
+
+# Add CORS middleware to allow frontend to call the API
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000", "http://localhost:3001", "http://localhost:5173", "http://127.0.0.1:3000", "http://127.0.0.1:5173"],  # React dev servers
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Store active processors
+processors = {}
+
+class ImageEnhancementRequest(BaseModel):
+    image_path: str
+    background: str
+
+class ImageSelectionRequest(BaseModel):
+    image_path: str
+    option_number: int
+
+def pil_image_to_base64(pil_image):
+    """Convert PIL Image to base64 string for JSON serialization"""
+    if pil_image is None:
+        return None
+    if pil_image.mode != 'RGB':
+        pil_image = pil_image.convert('RGB')
+    
+    buffer = BytesIO()
+    pil_image.save(buffer, format='JPEG', quality=95)
+    img_str = base64.b64encode(buffer.getvalue()).decode()
+    return f"data:image/jpeg;base64,{img_str}"
+
+def apply_background(image: Image.Image, background: str) -> Image.Image:
+    """Apply a given base64 background image to an RGBA image"""
+    if image.mode != 'RGBA':
+        image = image.convert("RGBA")
+
+    try:
+        # Decode the base64 background image
+        background_data = base64.b64decode(background.split(",")[1])  # Remove the "data:image/...;base64," prefix
+        background_image = Image.open(BytesIO(background_data))
+
+        # Ensure the background image matches the size of the input image
+        background_image = background_image.resize(image.size)
+
+        # Paste the input image (with transparency) on top of the background
+        combined_image = Image.new("RGB", image.size)
+        combined_image.paste(background_image, (0, 0))
+        combined_image.paste(image, (0, 0), mask=image.split()[3])  # Use alpha channel as mask
+
+        return combined_image
+    except Exception as e:
+        raise ValueError(f"Error applying background: {str(e)}")
+
+@app.post("/upload")
+async def upload_image(image: UploadFile = File(...)):
+    """Upload an image file and return the file path"""
+    try:
+        # Validate file type
+        if not image.content_type.startswith('image/'):
+            raise HTTPException(status_code=400, detail="File must be an image")
+        
+        # Create uploads directory if it doesn't exist
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        upload_dir = os.path.join(script_dir, "uploads")
+
+        os.makedirs(upload_dir, exist_ok=True)
+        
+        # Generate unique filename
+        file_extension = os.path.splitext(image.filename)[1]
+        unique_filename = f"{uuid.uuid4()}{file_extension}"
+        file_path = os.path.join(upload_dir, unique_filename)
+        
+        # Save the uploaded file
+        with open(file_path, "wb") as buffer:
+            shutil.copyfileobj(image.file, buffer)
+        
+        return {"file_path": file_path, "filename": unique_filename}
+    
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error uploading file: {str(e)}")
+
+@app.post("/enhance_and_return_all_options")
+async def enhance_image(request: ImageEnhancementRequest):
+    """Process image through all enhancement options"""
+    try:
+        print(f"Starting enhancement for image: {request.image_path}")
+        background_color = request.background
+        print(f"Using background color: {background_color}")
+        # Create a new processor instance
+        processor_id = str(uuid.uuid4())
+        img_processor = process_image()
+        
+        # Check if the image path is absolute or relative
+        if os.path.isabs(request.image_path):
+            # If absolute path, convert to relative from the script directory
+            script_dir = os.path.dirname(os.path.abspath(__file__))
+            relative_path = os.path.relpath(request.image_path, script_dir)
+            image_path_to_use = relative_path
+        else:
+            # If relative path, use as is
+            image_path_to_use = request.image_path
+        
+        print(f"Using image path: {image_path_to_use}")
+        
+        # Check if file exists before processing
+        full_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), image_path_to_use)
+        if not os.path.exists(full_path):
+            raise HTTPException(status_code=404, detail=f"Image file not found: {full_path}")
+        
+        # Process the image step by step with error handling
+        print("Step 1: Processing image...")
+        img_processor.process(image_path_to_use)
+        
+        img_processor.raw_image.save("processed_image.png")  # Save processed image for debugging
+        
+        print("Step 2: Detecting objects...")
+        img_processor.detect_object()
+        
+        img_processor.cropped_image.save("detected_objects_image.png")  # Save detected objects image for debugging
+        print(img_processor.detected_objects)
+        
+        print("Step 3: Removing background...")
+        img_processor.remove_background()
+        
+        img_processor.no_background_image = apply_background(img_processor.no_background_image, background_color)
+        
+        img_processor.no_background_image.save("no_background_image.png")  # Save no background image for debugging
+        
+        print("Step 4: Enhancement option 1...")
+        try:
+            img_processor.enhance_image_option1()
+            print("Enhancement option 1 completed")
+        except Exception as e:
+            print(f"Enhancement option 1 failed: {str(e)}")
+            # Set a placeholder or skip this enhancement
+            img_processor.enhanced_image_1 = img_processor.no_background_image
+        
+        print("Step 5: Enhancement option 2...")
+        try:
+            img_processor.enhance_image_option2()
+            print("Enhancement option 2 completed")
+        except Exception as e:
+            print(f"Enhancement option 2 failed: {str(e)}")
+            # Set a placeholder or skip this enhancement
+            img_processor.enhanced_image_2 = img_processor.no_background_image
+        
+        print("Step 6: Enhancement option 3...")
+        try:
+            img_processor.enhance_image_option3()
+            print("✓ Enhancement option 3 completed")
+        except Exception as e:
+            print(f"Enhancement option 3 failed: {str(e)}")
+            # Set a placeholder or skip this enhancement
+            img_processor.enhanced_image_3 = img_processor.no_background_image
+        
+        # Store the processor for later use
+        processors[processor_id] = img_processor
+        print(f"Enhancement completed successfully. Processor ID: {processor_id}")
+        
+        # Convert PIL images to base64 for JSON response
+        return {
+            "processor_id": processor_id,
+            "enhanced_image_1": pil_image_to_base64(img_processor.enhanced_image_1),
+            "enhanced_image_2": pil_image_to_base64(img_processor.enhanced_image_2),
+            "enhanced_image_3": pil_image_to_base64(img_processor.enhanced_image_3),
+            "original_image": pil_image_to_base64(img_processor.raw_image),
+            "no_background_image": pil_image_to_base64(img_processor.no_background_image)
+        }
+    
+    except HTTPException:
+        # Re-raise HTTP exceptions
+        raise
+    except Exception as e:
+        print(f"Error during enhancement: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Error enhancing image: {str(e)}")
+
+@app.post("/choose_image_and_generate_description")
+async def choose_image_and_generate_description(
+    processor_id: str,
+    option_number: int
+):
+    """Choose an enhanced image option and generate description"""
+    try:
+        # Get the processor instance
+        if processor_id not in processors:
+            raise HTTPException(status_code=404, detail="Processor not found. Please enhance image first.")
+        
+        img_processor = processors[processor_id]
+        
+        # Choose the image
+        img_processor.choose_image(option_number)
+        
+        # Generate description
+        description = img_processor.generate_description()
+        
+        return {
+            "chosen_image": pil_image_to_base64(img_processor.chosen_image),
+            "description": description,
+            "option_number": option_number
+        }
+    
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error generating description: {str(e)}") 
+
+@app.delete("/cleanup/{processor_id}")
+async def cleanup_processor(processor_id: str):
+    """Clean up processor instance to free memory"""
+    if processor_id in processors:
+        del processors[processor_id]
+        return {"message": "Processor cleaned up successfully"}
+    else:
+        raise HTTPException(status_code=404, detail="Processor not found")
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {"status": "healthy", "active_processors": len(processors)}
+
+@app.post("/get_search_results")
+async def get_search_results(query:str):
+    """Get search results for a query"""
+    try:
+        print(f"Searching for: {query}")
+        searcher = search_product()
+        results = searcher.search_products_google_cse(query, 5)
+        
+        print(f"Found {len(results)} results")
+        for i, result in enumerate(results):
+            print(f"Result {i+1}: {result.get('title', 'No title')}")
+            print(f"URL: {result.get('link', 'No URL')}")
+        
+        return {
+            "results": results, 
+        }
+    except Exception as e:
+        print(f"Error in search: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Error searching: {str(e)}")
+    
+@app.post("/generate_background")
+async def generate_background(promptFromUser: str):
+    """Generate a background image using Google GenAI"""
+    try:
+        from background_generator import BackgroundGenerator
+        background_gen = BackgroundGenerator()
+        print("Generating background image...")
+        result = background_gen.generate(prompt=promptFromUser)
+        image_path = result.get("file_path")
+        public_url = result.get("public_url")
+        file_name = result.get("file_name")
+        print("Background image generated successfully.")
+        
+        if not os.path.exists(image_path):
+            raise HTTPException(status_code=404, detail="Generated background image not found")
+        
+        with Image.open(image_path) as img:
+            if img.mode != 'RGB':
+                img = img.convert('RGB')
+
+            encoded_image = pil_image_to_base64(img)
+            if encoded_image is None:
+                raise HTTPException(status_code=500, detail="Error converting image to base64")
+            return {"image": encoded_image
+                    , "public_url": public_url, "file_name": file_name
+                    , "file_path": image_path}
+            
+    except Exception as e:
+        print(f"Error generating background: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Error generating background: {str(e)}")
+    
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="127.0.0.1", port=8001)

merged_models_and_api/search_product.py

@@ -0,0 +1,105 @@
+import requests
+import json
+from dotenv import load_dotenv
+import os
+import re
+from fastapi import HTTPException
+
+load_dotenv()
+
+class search_product:
+    def __init__(self):
+        self.results = []
+
+        self.product_patterns = [
+                r'/product/',
+                r'/products/',
+                r'/item/',
+                r'/items/',
+                r'/p/',
+                r'/dp/',  # Amazon
+                r'/pd/',  # Some sites use pd
+                r'/shop/',
+                r'/buy/',
+                r'/store/',
+                r'product-',
+                r'item-',
+                r'/goods/',
+                r'/merchandise/',
+                r'/catalog/',
+                r'/detail/',
+                r'/details/',
+                r'/product-detail/',
+                r'productId=',
+                r'itemId=',
+                r'sku=',
+                r'/sku/',
+            ]
+        
+    def is_product_url(self, url):
+        """Check if URL looks like a product page"""
+        url_lower = url.lower()
+        
+        # Check for product patterns in URL
+        for pattern in self.product_patterns:
+            if re.search(pattern, url_lower):
+                return True  
+            
+        return False
+    
+    def search_products_google_cse(self, query, num_results=5):
+        """
+        Search using Google Custom Search Engine API
+        """
+        url = "https://www.googleapis.com/customsearch/v1"
+        
+        params = {
+            'key': os.getenv("SEARCH_API_KEY"),
+            'cx': "068bf089d39b74b14",
+            'q': query,
+            'num': min(num_results, 10),
+            'safe': 'active'
+        }
+        
+        try:
+            response = requests.get(url, params=params)
+            response.raise_for_status()
+            
+            data = response.json()
+            results = []  # Fresh results for this search
+            first_result = None
+            if 'items' in data:
+                for i, item in enumerate(data['items']):
+                    link = item.get('link', '')
+                    if(i == 0):
+                        first_result = {
+                            'title': item.get('title', ''),
+                            'link': link,
+                            'url': link,
+                            'snippet': item.get('snippet', ''),
+                            'displayLink': item.get('displayLink', ''),
+                            'is_product': True
+                        }
+
+                    # Filter for product URLs
+                    if self.is_product_url(link):
+                        result = {
+                            'title': item.get('title', ''),
+                            'link': link,
+                            'url': link,
+                            'snippet': item.get('snippet', ''),
+                            'displayLink': item.get('displayLink', ''),
+                            'is_product': True
+                        }
+                        results.append(result)
+                        break
+            
+            # Update instance results and return current results
+            self.results = results
+            if not self.results:
+                results.append(first_result)
+            return results
+        
+        except requests.exceptions.RequestException as e:
+            print(f"Error making request: {e}")
+            return []