init

app.py

@@ -8,6 +8,8 @@ from util import process_image_edit, process_local_image_edit, download_and_chec
 from nfsw import NSFWDetector
 
 # Configuration parameters
+
+TIP_TRY_N = 8       # Show like button tip after 12 tries
 FREE_TRY_N = 20        # Free phase: first 15 tries without restrictions
 SLOW_TRY_N = 25       # Slow phase start: 25 tries
 SLOW2_TRY_N = 32        # Slow phase start: 32 tries
@@ -210,6 +212,9 @@ def edit_image_interface(input_image, prompt, request: gr.Request, progress=gr.P
     
     print(f"📊 User phase info - IP: {client_ip}, current phase: {current_phase}, generation count: {current_count}")
     
+    # Check if user reached the like button tip threshold  
+    show_like_tip = (current_count >= TIP_TRY_N)
+    
     # Check if completely blocked
     if current_phase == 'blocked':
         # Generate blocked limit button
@@ -316,7 +321,7 @@ def edit_image_interface(input_image, prompt, request: gr.Request, progress=gr.P
         print(f"✅ Processing started - IP: {client_ip}, phase: {current_phase}, total count: {updated_count}, prompt: {prompt.strip()}", flush=True)
         
         # Call image editing processing function
-        result_url, message, task_uuid = process_image_edit(input_image, prompt.strip(), progress_callback)
+        result_url, message, task_uuid = process_image_edit(input_image, prompt.strip(), None, progress_callback)
         
         if result_url:
             print(f"✅ Processing completed successfully - IP: {client_ip}, result_url: {result_url}, task_uuid: {task_uuid}", flush=True)
@@ -437,6 +442,28 @@ def edit_image_interface(input_image, prompt, request: gr.Request, progress=gr.P
                 </div>
                 """
             
+            # Add popup script if needed (using different approach)
+            if show_like_tip:
+                action_buttons_html += """
+                <div style='display: flex; justify-content: center; margin: 15px 0 5px 0; padding: 0px;'>
+                    <div style='
+                        display: inline-flex; 
+                        align-items: center;
+                        justify-content: center;
+                        padding: 12px 24px; 
+                        background: linear-gradient(135deg, #ff6b6b 0%, #feca57 100%);
+                        color: white; 
+                        border-radius: 10px; 
+                        font-weight: 600;
+                        font-size: 14px;
+                        text-align: center;
+                        max-width: 400px;
+                        box-shadow: 0 3px 12px rgba(255, 107, 107, 0.3);
+                        border: none;
+                    '>👉 Click the ❤️ Like button to unlock more free trial attempts!</div>
+                </div>
+                """
+            
             return final_result, final_message, gr.update(value=action_buttons_html, visible=True)
         else:
             print(f"❌ Processing failed - IP: {client_ip}, error: {message}", flush=True)
@@ -446,7 +473,7 @@ def edit_image_interface(input_image, prompt, request: gr.Request, progress=gr.P
         print(f"❌ Processing exception - IP: {client_ip}, error: {str(e)}")
         return None, f"❌ Error occurred during processing: {str(e)}", gr.update(visible=False)
 
-def local_edit_interface(image_dict, prompt, request: gr.Request, progress=gr.Progress()):
+def local_edit_interface(image_dict, prompt, reference_image, request: gr.Request, progress=gr.Progress()):
     """
     Handle local editing requests (with phase-based limitations)
     """
@@ -463,14 +490,55 @@ def local_edit_interface(image_dict, prompt, request: gr.Request, progress=gr.Pr
         if image_dict is None:
             return None, "Please upload an image and draw the area to edit", gr.update(visible=False)
         
-        # Check if background and layers exist
-        if "background" not in image_dict or "layers" not in image_dict:
-            return None, "Please draw the area to edit on the image", gr.update(visible=False)
+        # Handle different input formats for ImageEditor
+        if isinstance(image_dict, dict):
+            # ImageEditor dict format
+            if "background" not in image_dict or "layers" not in image_dict:
+                return None, "Please draw the area to edit on the image", gr.update(visible=False)
+            
+            base_image = image_dict["background"]
+            layers = image_dict["layers"]
+            
+            # Special handling: if background is None but composite exists, use composite
+            if base_image is None and "composite" in image_dict and image_dict["composite"] is not None:
+                print("🔧 Background is None, using composite instead")
+                base_image = image_dict["composite"]
+        else:
+            # Simple case: Direct PIL Image (from example)
+            base_image = image_dict
+            layers = []
+        
+        # Check for special example case - bypass mask requirement
+        is_example_case = prompt and prompt.startswith("EXAMPLE_PANDA_CAT_")
         
-        base_image = image_dict["background"]
-        layers = image_dict["layers"]
+        # Debug: check current state
+        if is_example_case:
+            print(f"🔍 Example case detected - base_image is None: {base_image is None}")
         
-        if not layers:
+        # Special handling for example case: load image directly from file
+        if is_example_case and base_image is None:
+            try:
+                from PIL import Image
+                import os
+                
+                main_path = "datas/panda01.jpeg"
+                print(f"🔍 Trying to load: {main_path}, exists: {os.path.exists(main_path)}")
+                
+                if os.path.exists(main_path):
+                    base_image = Image.open(main_path)
+                    print(f"✅ Successfully loaded example image: {base_image.size}")
+                else:
+                    return None, f"❌ Example image not found: {main_path}", gr.update(visible=False)
+            except Exception as e:
+                return None, f"❌ Failed to load example image: {str(e)}", gr.update(visible=False)
+        
+        # Additional check for base_image
+        if base_image is None:
+            if is_example_case:
+                print(f"❌ Example case but base_image still None!")
+            return None, "❌ No image found. Please upload an image first.", gr.update(visible=False)
+        
+        if not layers and not is_example_case:
             return None, "Please draw the area to edit on the image", gr.update(visible=False)
             
         if not prompt or prompt.strip() == "":
@@ -489,6 +557,9 @@ def local_edit_interface(image_dict, prompt, request: gr.Request, progress=gr.Pr
     
     print(f"📊 Local edit user phase info - IP: {client_ip}, current phase: {current_phase}, generation count: {current_count}")
     
+    # Check if user reached the like button tip threshold  
+    show_like_tip = (current_count >= TIP_TRY_N)
+    
     # Check if completely blocked
     if current_phase == 'blocked':
         # Generate blocked limit button
@@ -594,8 +665,18 @@ def local_edit_interface(image_dict, prompt, request: gr.Request, progress=gr.Pr
         
         print(f"✅ Local editing started - IP: {client_ip}, phase: {current_phase}, total count: {updated_count}, prompt: {prompt.strip()}", flush=True)
         
+        # Clean prompt for API call
+        clean_prompt = prompt.strip()
+        if clean_prompt.startswith("EXAMPLE_PANDA_CAT_"):
+            clean_prompt = clean_prompt[18:]  # Remove the prefix
+        
         # Call local image editing processing function
-        result_url, message, task_uuid = process_local_image_edit(base_image, layers, prompt.strip(), progress_callback)
+        if is_example_case:
+            # For example case, pass special flag to use local mask file
+            result_url, message, task_uuid = process_local_image_edit(base_image, layers, clean_prompt, reference_image, progress_callback, use_example_mask="datas/panda01m.jpeg")
+        else:
+            # Normal case
+            result_url, message, task_uuid = process_local_image_edit(base_image, layers, clean_prompt, reference_image, progress_callback)
         
         if result_url:
             print(f"✅ Local editing completed successfully - IP: {client_ip}, result_url: {result_url}, task_uuid: {task_uuid}", flush=True)
@@ -716,6 +797,28 @@ def local_edit_interface(image_dict, prompt, request: gr.Request, progress=gr.Pr
                 </div>
                 """
             
+            # Add popup script if needed (using different approach)
+            if show_like_tip:
+                action_buttons_html += """
+                <div style='display: flex; justify-content: center; margin: 15px 0 5px 0; padding: 0px;'>
+                    <div style='
+                        display: inline-flex; 
+                        align-items: center;
+                        justify-content: center;
+                        padding: 12px 24px; 
+                        background: linear-gradient(135deg, #ff6b6b 0%, #feca57 100%);
+                        color: white; 
+                        border-radius: 10px; 
+                        font-weight: 600;
+                        font-size: 14px;
+                        text-align: center;
+                        max-width: 400px;
+                        box-shadow: 0 3px 12px rgba(255, 107, 107, 0.3);
+                        border: none;
+                    '>👉 Please consider clicking the ❤️ Like button to support this space!</div>
+                </div>
+                """
+            
             return final_result, final_message, gr.update(value=action_buttons_html, visible=True)
         else:
             print(f"❌ Local editing processing failed - IP: {client_ip}, error: {message}", flush=True)
@@ -807,100 +910,250 @@ def create_app():
         </div>
         """, padding=False)
         
-        # Direct interface - no tabs needed
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("### 📸 Upload Image")
-                input_image = gr.Image(
-                    label="Select image to edit",
-                    type="pil",
-                    height=512,
-                    elem_classes=["upload-area"]
-                )
+        with gr.Tabs():
+            with gr.Tab("🌍 Global Editor"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📸 Upload Image")
+                        input_image = gr.Image(
+                            label="Select image to edit",
+                            type="pil",
+                            height=512,
+                            elem_classes=["upload-area"]
+                        )
+
+                        gr.Markdown("### ✍️ Editing Instructions")
+                        prompt_input = gr.Textbox(
+                            label="Enter editing prompt",
+                            placeholder="For example: change background to beach, add rainbow, remove background, etc...",
+                            lines=3,
+                            max_lines=5
+                        )
+                        
+                        edit_button = gr.Button(
+                            "🚀 Start Editing",
+                            variant="primary",
+                            size="lg"
+                        )
+                    
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 🎯 Editing Result")
+                        output_image = gr.Image(
+                            label="Edited image",
+                            height=320,
+                            elem_classes=["result-area"]
+                        )
+                        
+                        use_as_input_btn = gr.Button(
+                            "🔄 Use as Input",
+                            variant="secondary",
+                            size="sm",
+                            elem_classes=["use-as-input-btn"]
+                        )
+                        
+                        status_output = gr.Textbox(
+                            label="Processing status",
+                            lines=2,
+                            max_lines=3,
+                            interactive=False
+                        )
+                        
+                        action_buttons = gr.HTML(visible=False)
                 
-                gr.Markdown("### ✍️ Editing Instructions")
-                prompt_input = gr.Textbox(
-                    label="Enter editing prompt",
-                    placeholder="For example: change background to beach, add rainbow, remove background, etc...",
-                    lines=3,
-                    max_lines=5
+                gr.Markdown("### 💡 Prompt Examples")
+                with gr.Row():
+                    example_prompts = [
+                        "Set the background to a grand opera stage with red curtains",
+                        "Change the outfit into a traditional Chinese hanfu with flowing sleeves",
+                        "Give the character blue dragon-like eyes with glowing pupils",
+                        "Change lighting to soft dreamy pastel glow",
+                        "Change pose to sitting cross-legged on the ground"
+                    ]
+                    
+                    for prompt in example_prompts:
+                        gr.Button(
+                            prompt,
+                            size="sm"
+                        ).click(
+                            lambda p=prompt: p,
+                            outputs=prompt_input
+                        )
+                
+                edit_button.click(
+                    fn=edit_image_interface,
+                    inputs=[input_image, prompt_input],
+                    outputs=[output_image, status_output, action_buttons],
+                    show_progress=True,
+                    concurrency_limit=10,
+                    api_name="global_edit"
                 )
                 
-                edit_button = gr.Button(
-                    "🚀 Start Editing",
-                    variant="primary",
-                    size="lg"
+                def simple_use_as_input(output_img):
+                    if output_img is not None:
+                        return output_img
+                    return None
+                
+                use_as_input_btn.click(
+                    fn=simple_use_as_input,
+                    inputs=[output_image],
+                    outputs=[input_image]
                 )
-            
-            with gr.Column(scale=1):
-                gr.Markdown("### 🎯 Editing Result")
-                output_image = gr.Image(
-                    label="Edited image",
-                    height=320,
-                    elem_classes=["result-area"]
+
+            with gr.Tab("🖌️ Local Inpaint"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📸 Upload Image and Draw Mask")
+                        local_input_image = gr.ImageEditor(
+                            label="Upload image and draw mask",
+                            type="pil",
+                            height=512,
+                            brush=gr.Brush(colors=["#ff0000"], default_size=180),
+                            elem_classes=["upload-area"]
+                        )
+
+                        gr.Markdown("### 🖼️ Reference Image(Optional)")
+                        local_reference_image = gr.Image(
+                            label="Upload reference image (optional)",
+                            type="pil",
+                            height=256
+                        )
+                        
+                        gr.Markdown("### ✍️ Editing Instructions")
+                        local_prompt_input = gr.Textbox(
+                            label="Enter local editing prompt",
+                            placeholder="For example: change selected area hair to golden, add patterns to selected object, change selected area color, etc...",
+                            lines=3,
+                            max_lines=5
+                        )
+                        
+                        local_edit_button = gr.Button(
+                            "🎯 Start Local Editing",
+                            variant="primary",
+                            size="lg"
+                        )
+                    
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 🎯 Editing Result")
+                        local_output_image = gr.Image(
+                            label="Local edited image",
+                            height=320,
+                            elem_classes=["result-area"]
+                        )
+                        
+                        local_use_as_input_btn = gr.Button(
+                            "🔄 Use as Input",
+                            variant="secondary",
+                            size="sm",
+                            elem_classes=["use-as-input-btn"]
+                        )
+                        
+                        local_status_output = gr.Textbox(
+                            label="Processing status",
+                            lines=2,
+                            max_lines=3,
+                            interactive=False
+                        )
+                        
+                        local_action_buttons = gr.HTML(visible=False)
+             
+                local_edit_button.click(
+                    fn=local_edit_interface,
+                    inputs=[local_input_image, local_prompt_input, local_reference_image],
+                    outputs=[local_output_image, local_status_output, local_action_buttons],
+                    show_progress=True,
+                    concurrency_limit=8,
+                    api_name="local_edit"
                 )
                 
-                # Add "Use as Input" button
-                use_as_input_btn = gr.Button(
-                    "🔄 Use as Input",
-                    variant="secondary",
-                    size="sm",
-                    elem_classes=["use-as-input-btn"]
-                )
+                def simple_local_use_as_input(output_img):
+                    if output_img is not None:
+                        return {
+                            "background": output_img,
+                            "layers": [],
+                            "composite": output_img
+                        }
+                    return None
                 
-                status_output = gr.Textbox(
-                    label="Processing status",
-                    lines=2,
-                    max_lines=3,
-                    interactive=False
+                local_use_as_input_btn.click(
+                    fn=simple_local_use_as_input,
+                    inputs=[local_output_image],
+                    outputs=[local_input_image]
                 )
                 
-                # Action buttons that will show after task completion
-                action_buttons = gr.HTML(visible=False)
-        
-        # Example area
-        gr.Markdown("### 💡 Prompt Examples")
-        with gr.Row():
-            example_prompts = [
-                "Set the background to a grand opera stage with red curtains",
-                "Change the outfit into a traditional Chinese hanfu with flowing sleeves",
-                "Give the character blue dragon-like eyes with glowing pupils",
-                "Change lighting to soft dreamy pastel glow",
-                "Change pose to sitting cross-legged on the ground"
-            ]
-            
-            for prompt in example_prompts:
+                # Local inpaint example
+                gr.Markdown("### 💡 Local Inpaint Example")
+                
+                def load_local_example():
+                    """Load panda to cat transformation example - simplified, mask handled in backend"""
+                    try:
+                        from PIL import Image
+                        import os
+                        
+                        # Check file paths
+                        main_path = "datas/panda01.jpeg"
+                        ref_path = "datas/cat01.webp"
+                        
+                        # Load main image
+                        if not os.path.exists(main_path):
+                            return None, None, "EXAMPLE_PANDA_CAT_let the cat ride on the panda"
+                        
+                        main_img = Image.open(main_path)
+                        
+                        # Load reference image  
+                        if not os.path.exists(ref_path):
+                            ref_img = None
+                        else:
+                            ref_img = Image.open(ref_path)
+                        
+                        # ImageEditor format
+                        editor_data = {
+                            "background": main_img,
+                            "layers": [],
+                            "composite": main_img
+                        }
+                        
+                        # Special prompt to indicate this is the example case
+                        prompt = "EXAMPLE_PANDA_CAT_let the cat ride on the panda"
+                        
+                        # Return just the PIL image instead of dict format to avoid UI state issues
+                        return main_img, ref_img, prompt
+                        
+                    except Exception as e:
+                        return None, None, "EXAMPLE_PANDA_CAT_Transform the panda head into a cute cat head, keeping the body"
+                    
+                    # Example display
+                gr.Markdown("#### 🐼➡️🐱 Example: Panda to Cat Transformation")
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        # Preview images for local example
+                        with gr.Row():
+                            try:
+                                gr.Image("datas/panda01.jpeg", label="Main Image", height=120, width=120, show_label=True, interactive=False)
+                                gr.Image("datas/panda01m.jpeg", label="Mask", height=120, width=120, show_label=True, interactive=False)
+                                gr.Image("datas/cat01.webp", label="Reference", height=120, width=120, show_label=True, interactive=False)
+                            except:
+                                gr.Markdown("*Preview images not available*")
+                        gr.Markdown("**Prompt**: let the cat ride on the panda  \n**Note**: Mask will be automatically applied when you submit this example")
+                    with gr.Column(scale=1):
+                        gr.Button(
+                            "🎨 Load Panda Example",
+                            size="lg",
+                            variant="secondary"
+                        ).click(
+                            fn=load_local_example,
+                            outputs=[local_input_image, local_reference_image, local_prompt_input]
+                        )
+                
+                # Add a refresh button to fix UI state issues
                 gr.Button(
-                    prompt,
-                    size="sm"
+                    "🔄 Refresh Image Editor", 
+                    size="sm",
+                    variant="secondary"
                 ).click(
-                    lambda p=prompt: p,
-                    outputs=prompt_input
+                    fn=lambda: gr.update(),
+                    outputs=[local_input_image]
                 )
         
-        # Bind button click events - simplified, remove state management
-        edit_button.click(
-            fn=edit_image_interface,
-            inputs=[input_image, prompt_input],
-            outputs=[output_image, status_output, action_buttons],
-            show_progress=True,
-            # Increase concurrency settings
-            concurrency_limit=10,  # Limit concurrent requests
-            api_name="global_edit"
-        )
-        
-        # Simplify "Use as Input" button, directly copy image
-        def simple_use_as_input(output_img):
-            if output_img is not None:
-                return output_img
-            return None
-        
-        use_as_input_btn.click(
-            fn=simple_use_as_input,
-            inputs=[output_image],
-            outputs=[input_image]
-        )
-        
         # SEO Content Section
         gr.HTML("""
     <div style="width: 100%; margin: 50px 0; padding: 0 20px;">

util.py

@@ -134,44 +134,7 @@ class R2Api:
                 continue
         print("upload_from_memory time is ====>", time.time() - t1)
         return f"{self.domain}{cloud_path}"
-    
-    def upload_file(self, local_path, cloud_path):
-        t1 = time.time()
-        head_dict = {
-            'jpg': 'image/jpeg',
-            'jpeg': 'image/jpeg',
-            'png': 'image/png',
-            'gif': 'image/gif',
-            'bmp': 'image/bmp',
-            'webp': 'image/webp',
-            'ico': 'image/x-icon'
-        }
-        ftype = os.path.basename(local_path).split(".")[-1].lower()
-        ctype = head_dict.get(ftype, 'application/octet-stream')
-        headers = {"Content-Type": ctype}
-
-        
-        cloud_path = f"ImageEdit/Uploads/{str(datetime.date.today())}/{os.path.basename(local_path)}"
-        url = self.client.generate_presigned_url(
-            "put_object",
-            Params={"Bucket": self.R2_BUCKET, "Key": cloud_path, "ContentType": ctype},
-            ExpiresIn=604800
-        )
 
-        retry_count = 0
-        while retry_count < 3:
-            try:
-                with open(local_path, 'rb') as f:
-                    self.session.put(url, data=f.read(), headers=headers, timeout=8)
-                break
-            except (requests.exceptions.Timeout, requests.exceptions.RequestException):
-                retry_count += 1
-                if retry_count == 3:
-                    raise Exception('Failed to upload file to R2 after 3 retries!')
-                continue
-        print("upload_file time is ====>", time.time() - t1)
-        return f"{self.domain}{cloud_path}"
-    
 def upload_user_img_r2(clientIp, timeId, pil_image):
     """
     Upload PIL Image directly to R2 without saving to local file
@@ -293,7 +256,7 @@ def upload_mask_image_r2(client_ip, time_id, mask_image):
 
 
 
-def submit_image_edit_task(user_image_url, prompt, task_type="80", mask_image_url=""):
+def submit_image_edit_task(user_image_url, prompt, task_type="80", mask_image_url="", reference_image_url=""):
     """
     Submit image editing task with improved error handling using API v2
     """
@@ -311,6 +274,9 @@ def submit_image_edit_task(user_image_url, prompt, task_type="80", mask_image_ur
         "priority": 0,
         "secret_key": "219ngu"
     }
+
+    if reference_image_url:
+        data["user_image2"] = reference_image_url
     
     retry_count = 0
     max_retries = 3
@@ -423,7 +389,7 @@ def check_task_status(task_id):
     return 'error', None, f"Failed after {max_retries} retries"
 
 
-def process_image_edit(img_input, prompt, progress_callback=None):
+def process_image_edit(img_input, prompt, reference_image=None, progress_callback=None):
     """
     Complete process for image editing
     
@@ -461,8 +427,28 @@ def process_image_edit(img_input, prompt, progress_callback=None):
         if progress_callback:
             progress_callback("submitting edit task...")
         
+        reference_url = ""
+        if reference_image is not None:
+            try:
+                if progress_callback:
+                    progress_callback("uploading reference image...")
+
+                if hasattr(reference_image, 'save'):
+                    reference_pil = reference_image
+                else:
+                    reference_pil = Image.open(reference_image)
+
+                reference_url = upload_user_img_r2(client_ip, time_id, reference_pil)
+                if not reference_url:
+                    return None, "reference image upload failed", None
+
+                if "?" in reference_url:
+                    reference_url = reference_url.split("?")[0]
+            except Exception as e:
+                return None, f"reference image processing failed: {str(e)}", None
+
         # Submit image editing task
-        task_id, error = submit_image_edit_task(uploaded_url, prompt)
+        task_id, error = submit_image_edit_task(uploaded_url, prompt, reference_image_url=reference_url)
         if error:
             return None, error, None
         
@@ -518,7 +504,7 @@ def process_image_edit(img_input, prompt, progress_callback=None):
         return None, f"error occurred during processing: {str(e)}", None
 
 
-def process_local_image_edit(base_image, layers, prompt, progress_callback=None):
+def process_local_image_edit(base_image, layers, prompt, reference_image=None, progress_callback=None, use_example_mask=None):
     """
     处理局部图片编辑的完整流程
     
@@ -536,15 +522,50 @@ def process_local_image_edit(base_image, layers, prompt, progress_callback=None)
         if progress_callback:
             progress_callback("creating mask image...")
         
-        # 从layers创建mask图片
-        mask_image = create_mask_from_layers(base_image, layers)
-        
-        # 检查mask是否有内容
-        mask_array = np.array(mask_image)
-        if np.max(mask_array) == 0:
-            return None, "please draw mask", None
-        
-        print(f"📝 创建mask图片成功，绘制区域像素数: {np.sum(mask_array > 0)}")
+        # Check if we should use example mask (backdoor for example case)
+        if use_example_mask:
+            # Load local mask file for example
+            try:
+                from PIL import Image
+                import os
+                
+                # Check if base_image is valid
+                if base_image is None:
+                    return None, "Base image is None, cannot process example mask", None
+                
+                if os.path.exists(use_example_mask):
+                    mask_image = Image.open(use_example_mask)
+                    
+                    # Ensure mask has same size as base image
+                    if hasattr(base_image, 'size') and mask_image.size != base_image.size:
+                        mask_image = mask_image.resize(base_image.size)
+                    
+                    # Ensure mask is in L mode (grayscale)
+                    if mask_image.mode != 'L':
+                        mask_image = mask_image.convert('L')
+                    
+                    print(f"🎭 Using example mask from: {use_example_mask}, size: {mask_image.size}")
+                else:
+                    return None, f"Example mask file not found: {use_example_mask}", None
+            except Exception as e:
+                import traceback
+                traceback.print_exc()
+                return None, f"Failed to load example mask: {str(e)}", None
+        else:
+            # Normal case: create mask from layers
+            mask_image = create_mask_from_layers(base_image, layers)
+            
+            # 检查mask是否有内容
+            mask_array = np.array(mask_image)
+            if np.max(mask_array) == 0:
+                return None, "please draw mask", None
+        
+        # Print mask statistics
+        if not use_example_mask:
+            print(f"📝 创建mask图片成功，绘制区域像素数: {np.sum(mask_array > 0)}")
+        else:
+            mask_array = np.array(mask_image)
+            print(f"🎭 Example mask loaded successfully, mask pixels: {np.sum(mask_array > 0)}")
         
         if progress_callback:
             progress_callback("uploading original image...")
@@ -570,15 +591,43 @@ def process_local_image_edit(base_image, layers, prompt, progress_callback=None)
         if "?" in mask_url:
             mask_url = mask_url.split("?")[0]
         
+        reference_url = ""
+        if reference_image is not None:
+            try:
+                if progress_callback:
+                    progress_callback("uploading reference image...")
+
+                if hasattr(reference_image, 'save'):
+                    reference_pil = reference_image
+                else:
+                    reference_pil = Image.open(reference_image)
+
+                reference_url = upload_user_img_r2(client_ip, time_id, reference_pil)
+                if not reference_url:
+                    return None, "reference image upload failed", None
+
+                if "?" in reference_url:
+                    reference_url = reference_url.split("?")[0]
+            except Exception as e:
+                return None, f"reference image processing failed: {str(e)}", None
+
         print(f"📤 图片上传成功:")
         print(f"   原始图片: {uploaded_url}")
         print(f"   Mask图片: {mask_url}")
+        if reference_url:
+            print(f"   参考图片: {reference_url}")
         
         if progress_callback:
             progress_callback("submitting local edit task...")
         
         # 提交局部图片编辑任务 (task_type=81)
-        task_id, error = submit_image_edit_task(uploaded_url, prompt, task_type="81", mask_image_url=mask_url)
+        task_id, error = submit_image_edit_task(
+            uploaded_url,
+            prompt,
+            task_type="81",
+            mask_image_url=mask_url,
+            reference_image_url=reference_url
+        )
         if error:
             return None, error, None