Update app.py

app.py

@@ -15,36 +15,94 @@ if os.path.exists('.env'):
 else:
     print("Warning: .env file not found. Using default environment variables.")
 
+# Get environment variables with fallback
 api_key_token = os.getenv('api_key_token', '')
 groq_api_key = os.getenv('groq_api_key', '')
 
 if not api_key_token or not groq_api_key:
     raise ValueError("Please configure your API keys in .env file")
 
-print(f"===== Application Startup at {time.strftime('%Y-%m-%d %H:%M:%S')} =====")
+# Ghi log khởi động
 print("Version 2.19 - Fixed RGBA to RGB conversion for JPEG")
 print("Running grok_app.py with workflow processing and .env configuration")
 
+# URL và thông tin cá nhân từ API
 url_pre = "https://ap-east-1.tensorart.cloud/v1"
 SAVE_DIR = "generated_images"
 Path(SAVE_DIR).mkdir(exist_ok=True)
 
+# Danh sách mã sản phẩm
 PRODUCT_GROUPS = {
-    "Standard": {"C1012 Glacier White": "817687427545199895", "C1026 Polar": "819910519797326073", "C3269 Ash Grey": "821839484099264081", "C3168 Silver Wave": "821849044696643212", "C1005 Milky White": "821948258441171133"},
-    "Deluxe": {"C2103 Onyx Carrara": "827090618489513527", "C2104 Massa": "822075428127644644", "C3105 Casla Cloudy": "828912225788997963", "C3146 Casla Nova": "828013009961087650", "C2240 Marquin": "828085015087780649", "C2262 Concrete (Honed)": "822211862058871636", "C3311 Calacatta Sky": "829984593223502930", "C3346 Massimo": "827938741386607132"},
-    "Luxury": {"C4143 Mario": "829984593223502930", "C4145 Marina": "828132560375742058", "C4202 Calacatta Gold": "828167757632695310", "C1205 Casla Everest": "828296778450463190", "C4211 Calacatta Supreme": "828436321937882328", "C4204 Calacatta Classic": "828422973179466146", "C5240 Spring": "is coming", "C1102 Super White": "828545723344775887", "C4246 Casla Mystery": "828544778451950698", "C4345 Oro": "828891068780182635", "C4346 Luxe": "829436426547535131", "C4342 Casla Eternal": "829190256201829181", "C4221 Athena": "829644354504131520", "C4222 Lagoon": "is coming", "C5225 Amber": "is coming"},
-    "Super Luxury": {"C4255 Calacatta Extra": "829659013227537217"},
+    "Standard": {
+        "C1012 Glacier White": "817687427545199895",
+        "C1026 Polar": "819910519797326073",
+        "C3269 Ash Grey": "821839484099264081",
+        "C3168 Silver Wave": "821849044696643212",
+        "C1005 Milky White": "821948258441171133",
+    },
+    "Deluxe": {
+        "C2103 Onyx Carrara": "827090618489513527",
+        "C2104 Massa": "822075428127644644",
+        "C3105 Casla Cloudy": "828912225788997963",
+        "C3146 Casla Nova": "828013009961087650",
+        "C2240 Marquin": "828085015087780649",
+        "C2262 Concrete (Honed)": "822211862058871636",
+        "C3311 Calacatta Sky": "829984593223502930",
+        "C3346 Massimo": "827938741386607132",
+    },
+    "Luxury": {
+        "C4143 Mario": "829984593223502930",
+        "C4145 Marina": "828132560375742058",
+        "C4202 Calacatta Gold": "828167757632695310",
+        "C1205 Casla Everest": "828296778450463190",
+        "C4211 Calacatta Supreme": "828436321937882328",
+        "C4204 Calacatta Classic": "828422973179466146",
+        "C5240 Spring": "is coming",
+        "C1102 Super White": "828545723344775887",
+        "C4246 Casla Mystery": "828544778451950698",
+        "C4345 Oro": "828891068780182635",
+        "C4346 Luxe": "829436426547535131",
+        "C4342 Casla Eternal": "829190256201829181",
+        "C4221 Athena": "829644354504131520",
+        "C4222 Lagoon": "is coming",
+        "C5225 Amber": "is coming",
+    },
+    "Super Luxury": {
+        "C4255 Calacatta Extra": "829659013227537217",
+    },
 }
 
+# Danh sách ảnh sản phẩm tương ứng với mã sản phẩm
 PRODUCT_IMAGE_MAP = {
-    "C1012 Glacier White": "product_images/C1012.jpg", "C1026 Polar": "product_images/C1026.jpg", "C3269 Ash Grey": "product_images/C3269.jpg", "C3168 Silver Wave": "product_images/C3168.jpg", "C1005 Milky White": "product_images/C1005.jpg",
-    "C2103 Onyx Carrara": "product_images/C2103.jpg", "C2104 Massa": "product_images/C2104.jpg", "C3105 Casla Cloudy": "product_images/C3105.jpg", "C3146 Casla Nova": "product_images/C3146.jpg", "C2240 Marquin": "product_images/C2240.jpg",
-    "C2262 Concrete (Honed)": "product_images/C2262.jpg", "C3311 Calacatta Sky": "product_images/C3311.jpg", "C3346 Massimo": "product_images/C3346.jpg", "C4143 Mario": "product_images/C4143.jpg", "C4145 Marina": "product_images/C4145.jpg",
-    "C4202 Calacatta Gold": "product_images/C4202.jpg", "C1205 Casla Everest": "product_images/C1205.jpg", "C4211 Calacatta Supreme": "product_images/C4211.jpg", "C4204 Calacatta Classic": "product_images/C4204.jpg", "C1102 Super White": "product_images/C1102.jpg",
-    "C4246 Casla Mystery": "product_images/C4246.jpg", "C4345 Oro": "product_images/C4345.jpg", "C4346 Luxe": "product_images/C4346.jpg", "C4342 Casla Eternal": "product_images/C4342.jpg", "C4221 Athena": "product_images/C4221.jpg",
+    "C1012 Glacier White": "product_images/C1012.jpg",
+    "C1026 Polar": "product_images/C1026.jpg",
+    "C3269 Ash Grey": "product_images/C3269.jpg",
+    "C3168 Silver Wave": "product_images/C3168.jpg",
+    "C1005 Milky White": "product_images/C1005.jpg",
+    "C2103 Onyx Carrara": "product_images/C2103.jpg",
+    "C2104 Massa": "product_images/C2104.jpg",
+    "C3105 Casla Cloudy": "product_images/C3105.jpg",
+    "C3146 Casla Nova": "product_images/C3146.jpg",
+    "C2240 Marquin": "product_images/C2240.jpg",
+    "C2262 Concrete (Honed)": "product_images/C2262.jpg",
+    "C3311 Calacatta Sky": "product_images/C3311.jpg",
+    "C3346 Massimo": "product_images/C3346.jpg",
+    "C4143 Mario": "product_images/C4143.jpg",
+    "C4145 Marina": "product_images/C4145.jpg",
+    "C4202 Calacatta Gold": "product_images/C4202.jpg",
+    "C1205 Casla Everest": "product_images/C1205.jpg",
+    "C4211 Calacatta Supreme": "product_images/C4211.jpg",
+    "C4204 Calacatta Classic": "product_images/C4204.jpg",
+    "C1102 Super White": "product_images/C1102.jpg",
+    "C4246 Casla Mystery": "product_images/C4246.jpg",
+    "C4345 Oro": "product_images/C4345.jpg",
+    "C4346 Luxe": "product_images/C4346.jpg",
+    "C4342 Casla Eternal": "product_images/C4342.jpg",
+    "C4221 Athena": "product_images/C4221.jpg",
     "C4255 Calacatta Extra": "product_images/C4255.jpg",
 }
 
+# Định nghĩa màu sắc cho từng nhóm sản phẩm
 GROUP_COLORS = {
     "Standard": "#FFCCCC",
     "Deluxe": "#CCFFCC",
@@ -52,39 +110,24 @@ GROUP_COLORS = {
     "Super Luxury": "#CCFCFF",
 }
 
+# Khởi tạo client Groq
 client = Groq(api_key=groq_api_key)
 
 def rewrite_prompt_with_groq(vietnamese_prompt, product_codes):
-    print(f"Rewriting prompt: {vietnamese_prompt} with product codes: {product_codes}")
-    system_prompt = (
-        "You are an expert in interior design descriptions. Rewrite the user's prompt "
-        "to include the provided product codes in a natural and appealing way, ensuring "
-        "the description remains coherent and attractive. Return only the rewritten prompt without anything else."
-    )
-    user_message = f"Prompt: {vietnamese_prompt}"
-
-    print("Sending request to Groq API for prompt rewriting...")
-    response = client.chat.completions.create(
-        model="mixtral-8x7b-32768",
-        messages=[
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": user_message}
-        ],
-        max_tokens=200,
-        temperature=0.7
-    )
-    
-    rewritten_prompt = response.choices[0].message.content.strip()
-    print(f"Rewritten prompt from Groq: {rewritten_prompt}")
-    return rewritten_prompt
+    prompt = f"{vietnamese_prompt}, featuring {' and '.join(product_codes)} quartz marble"
+    return prompt
 
+# Hàm upload ảnh lên TensorArt
 def upload_image_to_tensorart(image_path):
-    print(f"Starting image upload process for: {image_path}")
     try:
         url = f"{url_pre}/resource/image"
         payload = json.dumps({"expireSec": "7200"})
-        headers = {'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': f'Bearer {api_key_token}'}
-        print(f"Sending POST request to: {url}")
+        headers = {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+            'Authorization': f'Bearer {api_key_token}'
+        }
+        print(f"Starting upload for: {image_path}")
         if not os.path.exists(image_path):
             print(f"File does not exist: {image_path}")
             return None
@@ -103,77 +146,81 @@ def upload_image_to_tensorart(image_path):
         with open(image_path, 'rb') as img_file:
             upload_response = requests.put(put_url, data=img_file, headers=headers_put)
             print(f"PUT response: {upload_response.status_code} - {upload_response.text}")
-            if upload_response.status_code == 200:
-                print("Upload completed successfully.")
-            elif upload_response.status_code == 203:
-                print("Warning: Upload completed with 'CallbackFailed'. Proceeding with resourceId, but callback to TensorArt failed.")
-            else:
+            if upload_response.status_code not in [200, 203]:
                 raise Exception(f"PUT failed with status {upload_response.status_code}: {upload_response.text}")
+            if upload_response.status_code == 203:
+                print("Warning: PUT returned 203 - CallbackFailed, but proceeding with resourceId")
         
         resource_id = resource_response.get('resourceId')
         if not resource_id:
             print(f"Upload failed - No 'resourceId' in response: {resource_response}")
             return None
         print(f"Upload successful - resourceId: {resource_id}")
-        time.sleep(10)
+        time.sleep(10)  # Đợi đồng bộ tài nguyên
+        print(f"Waited 10s for resource sync: {resource_id}")
         return resource_id
     except Exception as e:
         print(f"Upload error for {image_path}: {str(e)}")
         return None
 
+# Hàm kiểm tra params
 def check_workflow_params(params):
-    print("Checking workflow parameters...")
     url = f"{url_pre}/jobs/workflow/params/check"
-    headers = {'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': f'Bearer {api_key_token}'}
+    headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'Authorization': f'Bearer {api_key_token}'
+    }
     payload = json.dumps({"params": params})
-    print(f"Sending params check request to: {url}")
+    print(f"Checking workflow params: {json.dumps(payload, indent=2)}")
     response = requests.post(url, headers=headers, data=payload, timeout=30)
     print(f"Params check response: {response.status_code} - {response.text}")
     if response.status_code != 200:
         raise Exception(f"Params check failed: {response.text}")
     return response.json()
 
+# Hàm chạy workflow và chờ kết quả
 def run_workflow(payload, step_name):
-    print(f"Running workflow for step: {step_name}")
-    print(f"Payload: {json.dumps(payload, indent=2)}")
     try:
-        check_result = check_workflow_params(payload["params"])
-        print(f"Params check result: {check_result}")
+        check_workflow_params(payload["params"])
     except Exception as e:
         print(f"Workflow params check failed for {step_name}: {str(e)}")
         raise
-    headers = {'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': f'Bearer {api_key_token}'}
-    print(f"Submitting workflow to: {url_pre}/jobs/workflow")
+    
+    headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'Authorization': f'Bearer {api_key_token}'
+    }
+    print(f"Sending {step_name} workflow request to {url_pre}/jobs/workflow with data: {json.dumps(payload, indent=2)}")
     response = requests.post(f"{url_pre}/jobs/workflow", json=payload, headers=headers, timeout=300)
-    print(f"Workflow submission response: {response.status_code} - {response.text}")
+    print(f"{step_name} workflow response: {response.status_code} - {response.text}")
     if response.status_code != 200:
         raise Exception(f"Error {response.status_code}: {response.text}")
+    
     response_data = response.json()
     job_id = response_data['job'].get('id')
     if not job_id:
         raise Exception("Không tìm thấy job_id trong response")
-    print(f"Job submitted successfully, job_id: {job_id}")
     
+    print(f"Starting {step_name} job status check for job_id: {job_id}")
     max_attempts = 36
     for attempt in range(max_attempts):
-        print(f"Checking job status, attempt {attempt + 1}/{max_attempts}")
         response = requests.get(f"{url_pre}/jobs/{job_id}", headers=headers, timeout=30)
-        print(f"Job status response: {response.status_code} - {response.text}")
         response.raise_for_status()
         result = response.json()
+        print(f"{step_name} job status (attempt {attempt + 1}/{max_attempts}): {json.dumps(result, indent=2)}")
         status = result['job'].get('status')
-        print(f"Current job status: {status}")
         if status == 'SUCCESS':
             success_info = result['job'].get('successInfo', {})
             if not success_info.get('images'):
                 raise Exception(f"Không tìm thấy hình ảnh trong successInfo cho {step_name}")
             image_url = success_info['images'][0]['url']
-            print(f"Downloading image from: {image_url}")
             image_response = requests.get(image_url)
             image = Image.open(BytesIO(image_response.content))
+            # Chuyển từ RGBA sang RGB nếu cần
             if image.mode == 'RGBA':
                 image = image.convert('RGB')
-                print("Converted image from RGBA to RGB")
             output_path = Path(SAVE_DIR) / f"{step_name}_{int(time.time())}.jpg"
             image.save(output_path)
             print(f"{step_name} image saved to: {output_path}")
@@ -181,394 +228,314 @@ def run_workflow(payload, step_name):
         elif status in ['FAILED', 'ERROR']:
             failed_info = result['job'].get('failedInfo', {})
             error_reason = failed_info.get('reason', 'Không có chi tiết')
-            raise Exception(f"{step_name} job thất bại: {error_reason}")
+            error_code = failed_info.get('code', 'Không xác định')
+            raise Exception(f"{step_name} job thất bại: {error_reason} (code: {error_code})")
         time.sleep(5)
     raise Exception(f"Hết thời gian chờ {step_name} job sau 3 phút")
 
-def generate_text2img_workflow(prompt, width, height, selected_product_code):
-    print(f"Starting Text2Img workflow with prompt: {prompt}, width: {width}, height: {height}, product_code: {selected_product_code}")
-    texture_filepath = PRODUCT_IMAGE_MAP.get(selected_product_code)
-    if not texture_filepath or not os.path.exists(texture_filepath):
-        print(f"Error: Texture file not found for product code {selected_product_code}")
-        raise Exception(f"Không tìm thấy ảnh sản phẩm cho mã {selected_product_code}")
-    texture_resource_id = upload_image_to_tensorart(texture_filepath)
-    if not texture_resource_id:
-        print(f"Error: Failed to upload texture for product code {selected_product_code}")
-        raise Exception(f"Không thể upload ảnh sản phẩm {selected_product_code}")
-    print(f"Texture uploaded successfully, resource_id: {texture_resource_id}")
-
-    workflow_params = {
-        "27": {
-            "classType": "EmptySD3LatentImage",
-            "inputs": {"width": width, "height": height, "batch_size": 1},
-            "properties": {"Node name for S&R": "EmptySD3LatentImage"}
-        },
-        "45": {
-            "classType": "TensorArt_PromptText",
-            "inputs": {"Text": prompt},
-            "properties": {"Node name for S&R": "TensorArt_PromptText"}
-        },
-        "42": {
-            "classType": "CLIPTextEncode",
-            "inputs": {"clip": ["44", 1], "text": ["45", 0]},
-            "properties": {"Node name for S&R": "CLIPTextEncode"}
-        },
-        "41": {
-            "classType": "CLIPTextEncode",
-            "inputs": {"clip": ["44", 1], "text": ""},
-            "properties": {"Node name for S&R": "CLIPTextEncode"}
-        },
-        "35": {
-            "classType": "FluxGuidance",
-            "inputs": {"conditioning": ["42", 0], "guidance": 3.5},
-            "properties": {"Node name for S&R": "FluxGuidance"}
-        },
-        "47": {
-            "classType": "TensorArt_Seed",
-            "inputs": {"seed": int(time.time()), "mode": "randomize"},
-            "properties": {"Node name for S&R": "TensorArt_Seed"}
-        },
-        "31": {
-            "classType": "KSampler",
-            "inputs": {
-                "model": ["44", 0],
-                "positive": ["35", 0],
-                "negative": ["41", 0],
-                "latent_image": ["27", 0],
-                "seed": ["47", 0],
-                "steps": 20,
-                "cfg": 1,
-                "sampler_name": "euler",
-                "scheduler": "normal",
-                "denoise": 1
+# Hàm tạo mask và áp texture
+def generate_mask(image_resource_id, position, selected_product_code):
+    try:
+        if not image_resource_id:
+            raise Exception("Không có image_resource_id hợp lệ - ảnh gốc chưa được upload")
+        print(f"Using image_resource_id: {image_resource_id}")
+        time.sleep(10)  # Đợi đồng bộ tài nguyên
+        
+        short_code = selected_product_code.split()[0]
+        texture_filepath = PRODUCT_IMAGE_MAP.get(selected_product_code)
+        print(f"Texture file: {texture_filepath}, exists: {os.path.exists(texture_filepath)}")
+        if not texture_filepath or not os.path.exists(texture_filepath):
+            raise Exception(f"Không tìm thấy ảnh sản phẩm cho mã {short_code}")
+        
+        texture_resource_id = upload_image_to_tensorart(texture_filepath)
+        print(f"Texture resource_id: {texture_resource_id}")
+        if not texture_resource_id:
+            raise Exception(f"Không thể upload ảnh sản phẩm {short_code}")
+        time.sleep(10)  # Đợi đồng bộ tài nguyên
+
+        if isinstance(position, (set, list)):
+            position = position[0] if position else "default"
+        print(f"Position: {position}, type: {type(position)}")
+
+        # Dùng params đúng như mẫu TensorArt
+        workflow_params = {
+            "1": {
+                "classType": "LayerMask: SegmentAnythingUltra V3",
+                "inputs": {
+                    "black_point": 0.3,
+                    "detail_dilate": 6,
+                    "detail_erode": 65,
+                    "detail_method": "GuidedFilter",
+                    "device": "cuda",
+                    "image": ["2", 0],
+                    "max_megapixels": 2,
+                    "process_detail": True,
+                    "prompt": ["4", 0],
+                    "sam_models": ["3", 0],
+                    "threshold": 0.3,
+                    "white_point": 0.99
+                },
+                "properties": {"Node name for S&R": "LayerMask: SegmentAnythingUltra V3"}
             },
-            "properties": {"Node name for S&R": "KSampler"}
-        },
-        "8": {
-            "classType": "VAEDecode",
-            "inputs": {"samples": ["31", 0], "vae": ["43", 2]},
-            "properties": {"Node name for S&R": "VAEDecode"}
-        },
-        "43": {
-            "classType": "TensorArt_CheckpointLoader",
-            "inputs": {"ckpt_name": "779398605850080514"},
-            "properties": {"Node name for S&R": "TensorArt_CheckpointLoader"}
-        },
-        "56": {
-            "classType": "Lora Loader",
-            "inputs": {
-                "model": ["43", 0],
-                "clip": ["43", 1],
-                "lora_name": "792964023831298420",
-                "strength_model": 1,
-                "strength_clip": 1
+            "10": {
+                "classType": "Image Seamless Texture",
+                "inputs": {
+                    "blending": 0.37,
+                    "images": ["17", 0],
+                    "tiled": "true",
+                    "tiles": 2
+                },
+                "properties": {"Node name for S&R": "Image Seamless Texture"}
             },
-            "properties": {"Node name for S&R": "Lora Loader"}
-        },
-        "44": {
-            "classType": "TensorArt_LoraLoader",
-            "inputs": {
-                "model": ["56", 0],
-                "clip": ["56", 1],
-                "lora_name": "821795980375725476",
-                "strength_model": 0.64,
-                "strength_clip": 1
+            "13": {
+                "classType": "Paste By Mask",
+                "inputs": {
+                    "image_base": ["2", 0],
+                    "image_to_paste": ["10", 0],
+                    "mask": ["8", 0],
+                    "resize_behavior": "resize"
+                },
+                "properties": {"Node name for S&R": "Paste By Mask"}
             },
-            "properties": {"Node name for S&R": "TensorArt_LoraLoader"}
-        },
-        "49": {
-            "classType": "TensorArt_LLM_Prompt(Free)",
-            "inputs": {
-                "prompt": ["45", 0],
-                "system_prompt": "You are the best assistant and you help choosing exactly the objects from user's input.\nExample:\nUser's input: \"Serene corner with quartz marble countertop centered amidst soft lighting and calming surroundings, capturing warmth and tranquility\".\nYour answer: \"countertop\"\n\n*Remember that you will only response the objects name without anything else.",
-                "model": "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B",
-                "seed": 941451825154147,
-                "mode": "randomize",
-                "max_images": 1,
-                "max_tokens": 4093,
-                "censor": "disable"
+            "17": {
+                "classType": "TensorArt_LoadImage",
+                "inputs": {
+                    "_height": 768,
+                    "_width": 512,
+                    "image": texture_resource_id,
+                    "upload": "image"
+                },
+                "properties": {"Node name for S&R": "TensorArt_LoadImage"}
             },
-            "properties": {"Node name for S&R": "TensorArt_LLM_Prompt(Free)"}
-        },
-        "54": {
-            "classType": "TensorArt_LoadImage",
-            "inputs": {"image": texture_resource_id, "upload": "image"},
-            "properties": {"Node name for S&R": "TensorArt_LoadImage"}
-        },
-        "53": {
-            "classType": "Image Seamless Texture",
-            "inputs": {"images": ["54", 0], "blending": 0.4, "tiled": "true", "tiles": 2},
-            "properties": {"Node name for S&R": "Image Seamless Texture"}
-        },
-        "50": {
-            "classType": "LayerMask: SegmentAnythingUltra V3",
-            "inputs": {
-                "image": ["8", 0],
-                "sam_models": ["51", 0],
-                "prompt": ["49", 0],
-                "threshold": 0.3,
-                "detail_method": "PyMatting",
-                "detail_erode": 16,
-                "detail_dilate": 16,
-                "black_point": 0.15,
-                "white_point": 0.99,
-                "process_detail": True,
-                "device": "cuda",
-                "max_megapixels": 2
+            "2": {
+                "classType": "TensorArt_LoadImage",
+                "inputs": {
+                    "_height": 1024,
+                    "_width": 768,
+                    "image": image_resource_id,
+                    "upload": "image"
+                },
+                "properties": {"Node name for S&R": "TensorArt_LoadImage"}
             },
-            "properties": {"Node name for S&R": "LayerMask: SegmentAnythingUltra V3"}
-        },
-        "51": {
-            "classType": "LayerMask: LoadSegmentAnythingModels",
-            "inputs": {"sam_model": "sam_vit_h (2.56GB)", "grounding_dino_model": "GroundingDINO_SwinT_OGC (694MB)"},
-            "properties": {"Node name for S&R": "LayerMask: LoadSegmentAnythingModels"}
-        },
-        "52": {
-            "classType": "MaskToImage",
-            "inputs": {"mask": ["50", 1]},
-            "properties": {"Node name for S&R": "MaskToImage"}
-        },
-        "55": {
-            "classType": "Paste By Mask",
-            "inputs": {"image_base": ["8", 0], "image_to_paste": ["53", 0], "mask": ["52", 0], "mask_mapping_optional": None, "resize_behavior": "resize"},
-            "properties": {"Node name for S&R": "Paste By Mask"}
-        },
-        "9": {
-            "classType": "SaveImage",
-            "inputs": {
-                "filename_prefix": "TensorArt",
-                "images": ["55", 0]
+            "3": {
+                "classType": "LayerMask: LoadSegmentAnythingModels",
+                "inputs": {
+                    "grounding_dino_model": "GroundingDINO_SwinB (938MB)",
+                    "sam_model": "sam_vit_h (2.56GB)"
+                },
+                "properties": {"Node name for S&R": "LayerMask: LoadSegmentAnythingModels"}
             },
-            "properties": {"Node name for S&R": "SaveImage"}
+            "4": {
+                "classType": "TensorArt_PromptText",
+                "inputs": {"Text": position.lower()},
+                "properties": {"Node name for S&R": "TensorArt_PromptText"}
+            },
+            "7": {
+                "classType": "PreviewImage",
+                "inputs": {"images": ["13", 0]},
+                "properties": {"Node name for S&R": "PreviewImage"}
+            },
+            "8": {
+                "classType": "MaskToImage",
+                "inputs": {"mask": ["1", 1]},
+                "properties": {"Node name for S&R": "MaskToImage"}
+            }
         }
-    }
-
-    payload = {
-        "requestId": f"workflow_{int(time.time())}",
-        "model_id": "779398605850080514",
-        "params": workflow_params,
-        "runningNotifyUrl": ""
-    }
-    
-    print("Preparing to run Text2Img workflow")
-    output_path = run_workflow(payload, "text2img")
-    print(f"Text2Img workflow completed, output_path: {output_path}")
-    return output_path
 
-def generate_text2img_with_loading(prompt, size_choice, custom_size, *product_choices):
-    print("Starting Text2Img generation with loading")
-    yield None, gr.update(visible=True), gr.update(visible=True, value='<div class="progress-container"><div class="progress-bar" style="width: 0%"></div></div>'), None
-    try:
-        print(f"Processing size choice: {size_choice}, custom_size: {custom_size}")
-        if size_choice == "Custom size":
-            if not custom_size.strip():
-                print("Error: Custom size input is empty")
-                yield "Vui lòng nhập kích thước tùy chỉnh.", gr.update(visible=False), gr.update(visible=False), None
-                return
-            width, height = map(int, custom_size.split("x"))
-            print(f"Parsed custom size: width={width}, height={height}")
-        else:
-            width, height = map(int, size_choice.split("x"))
-            print(f"Selected predefined size: width={width}, height={height}")
-
-        selected_products = []
-        for group, choices in zip(PRODUCT_GROUPS.keys(), product_choices):
-            selected_products.extend(choices)
-        if not selected_products:
-            print("Error: No product selected")
-            yield "Vui lòng chọn ít nhất một mã sản phẩm.", gr.update(visible=False), gr.update(visible=False), None
-            return
-        selected_product_code = selected_products[0]
-        print(f"Selected product code: {selected_product_code}")
-
-        rewritten_prompt = rewrite_prompt_with_groq(prompt, [selected_product_code.split()[0]])
-        output_path = generate_text2img_workflow(rewritten_prompt, width, height, selected_product_code)
-        if not output_path:
-            print("Error: Workflow returned no output")
-            yield "Lỗi: Không thể tạo ảnh", gr.update(visible=False), gr.update(visible=False), None
-            return
+        payload = {
+            "requestId": f"workflow_{int(time.time())}",
+            "params": workflow_params,
+            "runningNotifyUrl": ""
+        }
+        
+        output_path = run_workflow(payload, "full_workflow")
+        return output_path
 
-        print("Text2Img generation completed successfully")
-        yield "Hoàn tất!", gr.update(visible=False), gr.update(visible=True, value='<div class="progress-container"><div class="progress-bar" style="width: 100%"></div></div>'), Image.open(output_path)
     except Exception as e:
-        print(f"Text2Img generation failed: {str(e)}")
-        yield f"Lỗi khi xử lý: {e}", gr.update(visible=False), gr.update(visible=False), None
-
-def generate_img2img_workflow(image_resource_id, position, selected_product_code):
-    print(f"Starting Img2Img workflow with image_resource_id: {image_resource_id}, position: {position}, product_code: {selected_product_code}")
-    texture_filepath = PRODUCT_IMAGE_MAP.get(selected_product_code)
-    if not texture_filepath or not os.path.exists(texture_filepath):
-        print(f"Error: Texture file not found for product code {selected_product_code}")
-        raise Exception(f"Không tìm thấy ảnh sản phẩm cho mã {selected_product_code}")
-    texture_resource_id = upload_image_to_tensorart(texture_filepath)
-    if not texture_resource_id:
-        print(f"Error: Failed to upload texture for product code {selected_product_code}")
-        raise Exception(f"Không thể upload ảnh sản phẩm {selected_product_code}")
-    print(f"Texture uploaded successfully, resource_id: {texture_resource_id}")
-
-    workflow_params = {
-        "1": {
-            "classType": "LayerMask: SegmentAnythingUltra V3",
-            "inputs": {
-                "black_point": 0.15,
-                "detail_dilate": 38,
-                "detail_erode": 15,
-                "detail_method": "PyMatting",
-                "device": "cuda",
-                "image": ["2", 0],
-                "max_megapixels": 2,
-                "process_detail": True,
-                "prompt": ["4", 0],
-                "sam_models": ["3", 0],
-                "threshold": 0.3,
-                "white_point": 0.99
-            },
-            "properties": {"Node name for S&R": "LayerMask: SegmentAnythingUltra V3"}
-        },
-        "10": {
-            "classType": "Image Seamless Texture",
-            "inputs": {
-                "blending": 0.37,
-                "images": ["17", 0],
-                "tiled": "true",
-                "tiles": 2
-            },
-            "properties": {"Node name for S&R": "Image Seamless Texture"}
-        },
-        "13": {
-            "classType": "Paste By Mask",
-            "inputs": {
-                "image_base": ["2", 0],
-                "image_to_paste": ["10", 0],
-                "mask": ["8", 0],
-                "resize_behavior": "resize"
-            },
-            "properties": {"Node name for S&R": "Paste By Mask"}
-        },
-        "17": {
-            "classType": "TensorArt_LoadImage",
-            "inputs": {
-                "_height": 768,
-                "_width": 512,
-                "image": texture_resource_id,
-                "upload": "image"
-            },
-            "properties": {"Node name for S&R": "TensorArt_LoadImage"}
-        },
-        "2": {
-            "classType": "TensorArt_LoadImage",
-            "inputs": {
-                "_height": 1024,
-                "_width": 768,
-                "image": image_resource_id,
-                "upload": "image"
-            },
-            "properties": {"Node name for S&R": "TensorArt_LoadImage"}
-        },
-        "3": {
-            "classType": "LayerMask: LoadSegmentAnythingModels",
-            "inputs": {
-                "grounding_dino_model": "GroundingDINO_SwinB (938MB)",
-                "sam_model": "sam_vit_h (2.56GB)"
-            },
-            "properties": {"Node name for S&R": "LayerMask: LoadSegmentAnythingModels"}
-        },
-        "4": {
-            "classType": "TensorArt_PromptText",
-            "inputs": {"Text": position.lower()},
-            "properties": {"Node name for S&R": "TensorArt_PromptText"}
-        },
-        "7": {
-            "classType": "PreviewImage",
-            "inputs": {"images": ["13", 0]},
-            "properties": {"Node name for S&R": "PreviewImage"}
-        },
-        "8": {
-            "classType": "MaskToImage",
-            "inputs": {"mask": ["1", 1]},
-            "properties": {"Node name for S&R": "MaskToImage"}
-        }
-    }
+        print(f"Mask generation error: {str(e)}")
+        return None
 
-    payload = {
-        "requestId": f"workflow_{int(time.time())}",
-        "params": workflow_params,
-        "runningNotifyUrl": ""
-    }
+# Hàm xử lý img2img với spinner và progress bar
+def generate_img2img(image, position, size_choice, custom_size, *product_choices):
+    yield None, gr.update(visible=True), gr.update(visible=True, value='<div class="progress-container"><div class="progress-bar" style="width: 0%"></div></div>'), None
+    
+    if size_choice == "Custom size":
+        if not custom_size.strip():
+            yield "Vui lòng nhập kích thước tùy chỉnh.", gr.update(visible=False), gr.update(visible=False), None
+            return
+        width, height = map(int, custom_size.split("x"))
+    else:
+        width, height = map(int, size_choice.split("x"))
+
+    yield "Đang upload ảnh gốc...", gr.update(visible=True), gr.update(visible=True, value='<div class="progress-container"><div class="progress-bar" style="width: 20%"></div></div>'), None
+    image_path = Path(SAVE_DIR) / f"input_{int(time.time())}.jpg"
+    image.save(image_path)
+    image_resource_id = upload_image_to_tensorart(str(image_path))
+    print(f"Generated image_resource_id: {image_resource_id}")
+    if not image_resource_id:
+        yield "Lỗi: Không thể upload ảnh gốc", gr.update(visible=False), gr.update(visible=False), None
+        return
+
+    yield "Đang chuẩn bị ảnh sản phẩm...", gr.update(visible=True), gr.update(visible=True, value='<div class="progress-container"><div class="progress-bar" style="width: 40%"></div></div>'), None
+    selected_products = []
+    for group, choices in zip(PRODUCT_GROUPS.keys(), product_choices):
+        selected_products.extend(choices)
+    if not selected_products:
+        yield "Vui lòng chọn ít nhất một mã sản phẩm.", gr.update(visible=False), gr.update(visible=False), None
+        return
+    selected_product_code = selected_products[0]
+
+    yield "Đang tạo mask và áp texture...", gr.update(visible=True), gr.update(visible=True, value='<div class="progress-container"><div class="progress-bar" style="width: 60%"></div></div>'), None
+    output_path = generate_mask(image_resource_id, position, selected_product_code)
+    if not output_path:
+        yield "Lỗi: Không thể tạo ảnh", gr.update(visible=False), gr.update(visible=False), None
+        return
     
-    print("Preparing to run Img2Img workflow")
-    output_path = run_workflow(payload, "img2img")
-    print(f"Img2Img workflow completed, output_path: {output_path}")
-    return output_path
+    yield "Hoàn tất!", gr.update(visible=False), gr.update(visible=True, value='<div class="progress-container"><div class="progress-bar" style="width: 100%"></div></div>'), Image.open(output_path)
 
-def generate_img2img_with_loading(image, position, size_choice, custom_size, *product_choices):
-    print("Starting Img2Img generation with loading")
+# Hàm generate_with_loading (text2img)
+def generate_with_loading(prompt, size_choice, custom_size, *product_choices):
     yield None, gr.update(visible=True), gr.update(visible=True, value='<div class="progress-container"><div class="progress-bar" style="width: 0%"></div></div>'), None
     try:
-        print(f"Processing size choice: {size_choice}, custom_size: {custom_size}")
         if size_choice == "Custom size":
             if not custom_size.strip():
-                print("Error: Custom size input is empty")
                 yield "Vui lòng nhập kích thước tùy chỉnh.", gr.update(visible=False), gr.update(visible=False), None
                 return
             width, height = map(int, custom_size.split("x"))
-            print(f"Parsed custom size: width={width}, height={height}")
         else:
             width, height = map(int, size_choice.split("x"))
-            print(f"Selected predefined size: width={width}, height={height}")
-
-        image_path = Path(SAVE_DIR) / f"input_{int(time.time())}.jpg"
-        print(f"Saving input image to: {image_path}")
-        image.save(image_path)
-        image_resource_id = upload_image_to_tensorart(str(image_path))
-        if not image_resource_id:
-            print("Error: Failed to upload input image")
-            yield "Lỗi: Không thể upload ảnh gốc", gr.update(visible=False), gr.update(visible=False), None
-            return
-        print(f"Input image uploaded successfully, resource_id: {image_resource_id}")
 
         selected_products = []
         for group, choices in zip(PRODUCT_GROUPS.keys(), product_choices):
             selected_products.extend(choices)
         if not selected_products:
-            print("Error: No product selected")
             yield "Vui lòng chọn ít nhất một mã sản phẩm.", gr.update(visible=False), gr.update(visible=False), None
             return
-        selected_product_code = selected_products[0]
-        print(f"Selected product code: {selected_product_code}")
 
-        output_path = generate_img2img_workflow(image_resource_id, position, selected_product_code)
-        if not output_path:
-            print("Error: Workflow returned no output")
-            yield "Lỗi: Không thể tạo ảnh", gr.update(visible=False), gr.update(visible=False), None
-            return
-        
-        print("Img2Img generation completed successfully")
-        yield "Hoàn tất!", gr.update(visible=False), gr.update(visible=True, value='<div class="progress-container"><div class="progress-bar" style="width: 100%"></div></div>'), Image.open(output_path)
+        short_codes = [code.split()[0] for code in selected_products]
+        rewritten_prompt = rewrite_prompt_with_groq(prompt, short_codes)
+        print(f"Rewritten Prompt: {rewritten_prompt}")
+
+        progress = 0
+        while progress < 100:
+            time.sleep(0.5)
+            progress += 10
+            yield None, gr.update(visible=True), gr.update(value=f'<div class="progress-container"><div class="progress-bar" style="width: {progress}%"></div></div>'), None
+
+        result = txt2img(rewritten_prompt, width, height, short_codes)
+        if isinstance(result, str):
+            yield result, gr.update(visible=False), gr.update(visible=False), None
+        else:
+            yield None, gr.update(visible=False), gr.update(visible=False), result
     except Exception as e:
-        print(f"Img2Img generation failed: {str(e)}")
         yield f"Lỗi khi xử lý: {e}", gr.update(visible=False), gr.update(visible=False), None
 
+# Hàm text2img
+def txt2img(prompt, width, height, product_codes):
+    model_id = "779398605850080514"
+    vae_id = "ae.sft"
+
+    txt2img_data = {
+        "request_id": hashlib.md5(str(int(time.time())).encode()).hexdigest(),
+        "stages": [
+            {"type": "INPUT_INITIALIZE", "inputInitialize": {"seed": -1, "count": 1}},
+            {
+                "type": "DIFFUSION",
+                "diffusion": {
+                    "width": width,
+                    "height": height,
+                    "prompts": [{"text": prompt}],
+                    "negativePrompts": [{"text": " "}],
+                    "sdModel": model_id,
+                    "sdVae": vae_id,
+                    "sampler": "Euler a",
+                    "steps": 30,
+                    "cfgScale": 8,
+                    "clipSkip": 1,
+                    "etaNoiseSeedDelta": 31337,
+                }
+            }
+        ]
+    }
+    headers = {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+        'Authorization': f'Bearer {api_key_token}'
+    }
+    response = requests.post(f"{url_pre}/jobs", json=txt2img_data, headers=headers)
+    if response.status_code != 200:
+        return f"Error: {response.status_code} - {response.text}"
+    response_data = response.json()
+    job_id = response_data['job']['id']
+    print(f"Job created. ID: {job_id}")
+    start_time = time.time()
+    timeout = 300
+    while True:
+        time.sleep(10)
+        elapsed_time = time.time() - start_time
+        if elapsed_time > timeout:
+            return f"Error: Job timed out after {timeout} seconds."
+        response = requests.get(f"{url_pre}/jobs/{job_id}", headers=headers)
+        if response.status_code != 200:
+            return f"Error: {response.status_code} - {response.text}"
+        get_job_response_data = response.json()
+        job_status = get_job_response_data['job']['status']
+        if job_status == 'SUCCESS':
+            image_url = get_job_response_data['job']['successInfo']['images'][0]['url']
+            response_image = requests.get(image_url)
+            img = Image.open(BytesIO(response_image.content))
+            save_path = Path(SAVE_DIR) / f"{hashlib.md5(prompt.encode()).hexdigest()}.png"
+            img.save(save_path)
+            print(f"Image saved to: {save_path}")
+            return img
+        elif job_status == 'FAILED':
+            return "Error: Job failed."
+
+# CSS
 css = """
 .loading-spinner { border: 4px solid #f3f3f3; border-top: 4px solid #3498db; border-radius: 50%; width: 40px; height: 40px; animation: spin 1s linear infinite; margin: auto; }
 @keyframes spin { 0% { transform: rotate(0deg); } 100% { transform: rotate(360deg); } }
 .progress-container { width: 100%; max-width: 400px; margin: 20px auto; background-color: #f3f3f3; border-radius: 20px; overflow: hidden; box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1); }
 .progress-bar { width: 0%; height: 10px; background: linear-gradient(90deg, #3498db, #e74c3c); border-radius: 20px; transition: width 0.3s ease-in-out; }
-.image-row { display: flex; gap: 20px; margin-bottom: 20px; }
-.image-container { flex: 1; border: 1px solid #ddd; padding: 10px; border-radius: 5px; }
+/* Thêm vào phần CSS hiện có */
+.image-row {
+    display: flex;
+    gap: 20px;
+    margin-bottom: 20px;
+}
+
+.image-container {
+    flex: 1;
+    border: 1px solid #ddd;
+    padding: 10px;
+    border-radius: 5px;
+}
+
+.settings-column {
+    max-width: 400px;
+    margin-left: 20px;
+}
+
+.position-selector {
+    margin-top: 20px;
+    padding: 15px;
+    background: #f5f5f5;
+    border-radius: 5px;
+}
 """
 
+# Giao diện Gradio
 with gr.Blocks(css=css) as demo:
-    gr.Markdown("## CaslaQuartz AI")
+    gr.Markdown("## Ứng dụng Tạo Ảnh CaslaQuartz với Ảnh Sản Phẩm")
     with gr.Tabs():
-        with gr.Tab("Tạo hình ảnh ứng dụng sản phẩm đá CaslaQuartz"):
+        with gr.Tab("Text2Img"):
             with gr.Row():
                 with gr.Column():
-                    text2img_prompt_input = gr.Textbox(label="Mô tả ảnh cần tạo", placeholder="Một nhà bếp hiện đại với mặt bàn bằng đá thạch anh.")
-                    text2img_size_radio = gr.Radio(choices=["1152x768", "1024x1024", "768x1152", "Custom size"], label="Chọn kích thước ảnh", value="1024x1024")
-                    text2img_custom_size_input = gr.Textbox(label="Nhập kích thước tùy chỉnh (VD: 1280x720)", placeholder="Chiều rộng x Chiều cao", visible=False)
-                    text2img_size_radio.change(fn=lambda x: gr.update(visible=x == "Custom size"), inputs=text2img_size_radio, outputs=text2img_custom_size_input)
-                    text2img_product_checkbox_group = []
+                    prompt_input = gr.Textbox(label="Mô tả ảnh cần tạo", placeholder="Một nhà bếp hiện đại với mặt bàn bằng đá thạch anh.")
+                    size_radio = gr.Radio(choices=["1152x768", "1024x1024", "768x1152", "Custom size"], label="Chọn kích thước ảnh", value="1024x1024")
+                    custom_size_input = gr.Textbox(label="Nhập kích thước tùy chỉnh (VD: 1280x720)", placeholder="Chiều rộng x Chiều cao", visible=False)
+                    size_radio.change(fn=lambda x: gr.update(visible=x == "Custom size"), inputs=size_radio, outputs=custom_size_input)
+                    product_checkbox_group = []
                     for group, color in GROUP_COLORS.items():
                         with gr.Accordion(f"Sản phẩm - {group}", open=False):
                             checkboxes = gr.CheckboxGroup(
@@ -576,42 +543,88 @@ with gr.Blocks(css=css) as demo:
                                 label=f"Chọn sản phẩm ({group})",
                                 value=[]
                             )
-                            text2img_product_checkbox_group.append((group, checkboxes))
-                    text2img_generate_button = gr.Button("Generate")
+                            product_checkbox_group.append((group, checkboxes))
+                    generate_button = gr.Button("Generate")
                 with gr.Column():
-                    text2img_output_image = gr.Image(label="Ảnh đã tạo")
-                    text2img_error_message = gr.Textbox(label="Thông báo", visible=False)
-                    text2img_loading_spinner = gr.HTML('<div class="loading-spinner"></div>', visible=False)
-                    text2img_progress_bar = gr.HTML('', visible=False)
-            text2img_inputs = [text2img_prompt_input, text2img_size_radio, text2img_custom_size_input] + [checkboxes for _, checkboxes in text2img_product_checkbox_group]
-            text2img_generate_button.click(fn=generate_text2img_with_loading, inputs=text2img_inputs, outputs=[text2img_error_message, text2img_loading_spinner, text2img_progress_bar, text2img_output_image])
-
-        with gr.Tab("Ứng dụng sản phẩm CaslaQuartz trong không gian bất kỳ"):
-            with gr.Row():
-                img2img_image_upload = gr.Image(label="Ảnh không gian muốn ứng dụng", type="pil", height=400)
-                img2img_output_image = gr.Image(label="Ảnh kết quả", height=400)
-            with gr.Row():
-                img2img_position_input = gr.Dropdown(label="Vị trí áp dụng", choices=["Wall", "Countertop", "Floor", "Counter", "Table", "Coffee Table top", "Backsplash"], value="Countertop")
+                    output_image = gr.Image(label="Ảnh đã tạo")
+                    error_message = gr.Textbox(label="Thông báo", visible=False)
+                    loading_spinner = gr.HTML('<div class="loading-spinner"></div>', visible=False)
+                    progress_bar = gr.HTML('', visible=False)
+            inputs = [prompt_input, size_radio, custom_size_input] + [checkboxes for _, checkboxes in product_checkbox_group]
+            generate_button.click(fn=generate_with_loading, inputs=inputs, outputs=[error_message, loading_spinner, progress_bar, output_image])
+
+        with gr.Tab("Img2Img"):
             with gr.Row():
+                # Cột ảnh input và output
+                with gr.Column():
+                    gr.Markdown("### Ảnh đầu vào và kết quả")
+                    with gr.Row():
+                        image_upload = gr.Image(label="Ảnh đầu vào", type="pil", height=400)
+                        output_image_img2img = gr.Image(label="Ảnh kết quả", height=400)
+                    
+                    # Phần chọn vật ngay dưới ảnh input
+                    with gr.Row():
+                        with gr.Column():
+                            position_input = gr.Dropdown(
+                                label="Vị trí áp dụng",
+                                choices=["Wall", "Countertop", "Floor", "Counter", "Table", "Coffee Table top", "Backsplash"],
+                                value="Wall"
+                            )
+
+                # Cột cài đặt và chọn sản phẩm
                 with gr.Column():
-                    img2img_size_radio = gr.Radio(choices=["1152x768", "1024x1024", "768x1152", "Custom size"], label="Chọn kích thước ảnh", value="1024x1024")
-                    img2img_custom_size_input = gr.Textbox(label="Nhập kích thước tùy chỉnh (VD: 1280x720)", placeholder="Chiều rộng x Chiều cao", visible=False)
-                    img2img_size_radio.change(fn=lambda x: gr.update(visible=x == "Custom size"), inputs=img2img_size_radio, outputs=img2img_custom_size_input)
-                    img2img_product_checkbox_group = []
+                    gr.Markdown("### Cài đặt")
+                    with gr.Accordion("Cài đặt kích thước", open=False):
+                        size_radio_img2img = gr.Radio(
+                            label="Kích thước ảnh",
+                            choices=["1152x768", "1024x1024", "768x1152", "Custom size"],
+                            value="1024x1024"
+                        )
+                        custom_size_input_img2img = gr.Textbox(
+                            label="Kích thước tùy chỉnh",
+                            placeholder="Chiều rộng x Chiều cao (VD: 1280x720)",
+                            visible=False
+                        )
+                        size_radio_img2img.change(
+                            fn=lambda x: gr.update(visible=x == "Custom size"),
+                            inputs=size_radio_img2img,
+                            outputs=custom_size_input_img2img
+                        )
+                    
+                    gr.Markdown("### Chọn sản phẩm")
+                    product_checkbox_group_img2img = []
                     for group, color in GROUP_COLORS.items():
                         with gr.Accordion(f"Sản phẩm - {group}", open=False):
                             checkboxes = gr.CheckboxGroup(
-                                choices=[(code, code) for code in PRODUCT_GROUPS[group] if PRODUCT_GROUPS[group][code] not in ["is coming", "is loading"]],
+                                choices=[(code, code) for code in PRODUCT_GROUPS[group] 
+                                if PRODUCT_GROUPS[group][code] not in ["is coming", "is loading"]],
                                 label=f"Chọn sản phẩm ({group})",
-                                value=[]
+                                value=[],
+                                elem_classes=["product-select"]
                             )
-                            img2img_product_checkbox_group.append((group, checkboxes))
-                    img2img_generate_button = gr.Button("Generate")
-                with gr.Column():
-                    img2img_error_message = gr.Textbox(label="Thông báo", visible=False)
-                    img2img_loading_spinner = gr.HTML('<div class="loading-spinner"></div>', visible=False)
-                    img2img_progress_bar = gr.HTML('', visible=False)
-            img2img_inputs = [img2img_image_upload, img2img_position_input, img2img_size_radio, img2img_custom_size_input] + [checkboxes for _, checkboxes in img2img_product_checkbox_group]
-            img2img_generate_button.click(fn=generate_img2img_with_loading, inputs=img2img_inputs, outputs=[img2img_error_message, img2img_loading_spinner, img2img_progress_bar, img2img_output_image])
+                            product_checkbox_group_img2img.append((group, checkboxes))
+
+            # Phần thông báo và nút bấm
+            with gr.Row():
+                error_message_img2img = gr.Textbox(label="Thông báo", visible=False)
+                loading_spinner_img2img = gr.HTML(
+                    '<div class="loading-spinner"></div>', 
+                    visible=False
+                )
+                progress_bar_img2img = gr.HTML(
+                    '<div class="progress-container"><div class="progress-bar"></div></div>',
+                    visible=False
+                )
+                inpaint_button = gr.Button("Tạo Ảnh", variant="primary")
+
+            # Inputs and button click handler
+            inputs_img2img = [image_upload, position_input, size_radio_img2img, custom_size_input_img2img] + \
+                            [checkboxes for _, checkboxes in product_checkbox_group_img2img]
+                            
+            inpaint_button.click(
+                fn=generate_img2img,
+                inputs=inputs_img2img,
+                outputs=[error_message_img2img, loading_spinner_img2img, progress_bar_img2img, output_image_img2img]
+            )
 
 demo.launch(share=True)