init

app.py

@@ -4,12 +4,12 @@ import os
 import shutil
 import tempfile
 import time
-from util import process_image_edit, get_country_info_safe, get_location_info_safe, contains_chinese
+from util import process_image_edit, process_local_image_edit, get_country_info_safe
 from nfsw import NSFWDetector
 
 # 配置参数
 NSFW_TIME_WINDOW = 5  # 时间窗口：5分钟
-NSFW_LIMIT = 6        # 限制次数：6次
+NSFW_LIMIT = 10        # 限制次数：6次
 
 IP_Dict = {}
 NSFW_Dict = {}  # 记录每个IP的NSFW违规次数
@@ -151,32 +151,6 @@ def edit_image_interface(input_image, prompt, request: gr.Request, progress=gr.P
 
     # 获取IP属地信息
     country_info = get_country_info_safe(client_ip)
-    location_info = get_location_info_safe(client_ip)
-    
-    # # 检查IP是否因NSFW违规过多而被屏蔽 3 
-    # if client_ip in NSFW_Dict and NSFW_Dict[client_ip] >= 5:
-    #     print(f"❌ IP blocked due to excessive NSFW violations - IP: {client_ip}({country_info}), violations: {NSFW_Dict[client_ip]}")
-        
-    #     # 检查是否需要特殊处理（中文prompt或中国IP）
-    #     has_chinese = contains_chinese(prompt.strip()) if prompt else False
-    #     is_china_ip = location_info.get("country", "").lower() == "中国"
-        
-    #     if has_chinese or is_china_ip:
-    #         # 构建特殊警告信息
-    #         prov = location_info.get("prov", "未知省份")
-    #         city = location_info.get("city", "未知城市")
-    #         isp = location_info.get("isp", "Unknown")
-            
-    #         # 处理城市名称
-    #         city_name = city.replace("市", "") if city != "未知城市" else "当地"
-            
-    #         # 处理ISP名称，去掉"中国"前缀
-    #         isp_name = isp.replace("中国", "") if isp != "Unknown" else "未知"
-            
-    #         warning_msg = f"您的ip地址为{client_ip}，地点为{prov}-{city}，您的网络服务商为{isp_name}，检测到您目前正在浏览，制作淫秽内容，已经上报给 {city_name}市公安局，已加急处理，请耐心等待警察上门调查"
-    #         return None, f"❌ {warning_msg}"
-    #     else:
-    #         return None, f"❌ Your ip {client_ip}, your region has been blocked for too much nsfw content"
     
     if input_image is None:
         return None, "Please upload an image first"
@@ -195,7 +169,6 @@ def edit_image_interface(input_image, prompt, request: gr.Request, progress=gr.P
             # 直接使用PIL Image对象进行检测，避免文件路径问题
             nsfw_result = nsfw_detector.predict_pil_label_only(input_image)
             
-            
             if nsfw_result.lower() == "nsfw":
                 print(f"🔍 NSFW检测结果: ❌❌❌ {nsfw_result} - IP: {client_ip}({country_info})")
                 # 检查NSFW频率限制
@@ -213,10 +186,6 @@ def edit_image_interface(input_image, prompt, request: gr.Request, progress=gr.P
                     # 未超过频率限制，记录此次检测但允许继续处理
                     record_nsfw_detection(client_ip)
                     window_info = get_current_window_info(client_ip)
-                    # print(f"🔍 NSFW检测记录 - IP: {client_ip}({country_info})")
-                    # print(f"   时间窗口: {window_info['window_start']} - {window_info['window_end']}")
-                    # print(f"   当前计数: {window_info['current_count']}/{NSFW_LIMIT}, 允许继续处理")
-                    # 不return，允许继续处理图片编辑
             else:
                 print(f"🔍 NSFW检测结果: ✅✅✅ {nsfw_result} - IP: {client_ip}({country_info})")
                 
@@ -227,13 +196,6 @@ def edit_image_interface(input_image, prompt, request: gr.Request, progress=gr.P
     if IP_Dict[client_ip]>10 and country_info.lower() in ["印度", "巴基斯坦"]:
         print(f"❌ Content not allowed - IP: {client_ip}({country_info}), count: {IP_Dict[client_ip]}, prompt: {prompt.strip()}")
         return None, "❌ Content not allowed. Please modify your prompt"
-    # if IP_Dict[client_ip]>18 and country_info.lower() in ["中国"]:
-    #     print(f"❌ Content not allowed - IP: {client_ip}({country_info}), count: {IP_Dict[client_ip]}, prompt: {prompt.strip()}")
-    #     return None, "❌ Content not allowed. Please modify your prompt"
-    # if client_ip.lower() in ["221.194.171.230", "101.126.56.37", "101.126.56.44"]:
-    #     print(f"❌ Content not allowed - IP: {client_ip}({country_info}), count: {IP_Dict[client_ip]}, prompt: {prompt.strip()}")
-    #     return None, "❌ Content not allowed. Please modify your prompt"
-    
 
     result_url = None
     status_message = ""
@@ -261,6 +223,139 @@ def edit_image_interface(input_image, prompt, request: gr.Request, progress=gr.P
     except Exception as e:
         return None, f"❌ Error occurred during processing: {str(e)}"
 
+# 局部编辑处理函数
+# 状态更新函数
+def update_global_input_state(image):
+    """更新全局编辑输入图片状态"""
+    return image
+
+def update_global_output_state(image):
+    """更新全局编辑输出图片状态"""
+    return image
+
+def update_local_input_state(image):
+    """更新局部编辑输入图片状态"""
+    return image
+
+def update_local_output_state(image):
+    """更新局部编辑输出图片状态"""
+    return image
+
+def use_global_output_as_input(output_image):
+    """将全局编辑的输出图片设为输入图片"""
+    if output_image is not None:
+        return output_image, output_image
+    return None, None
+
+def use_local_output_as_input(output_image):
+    """将局部编辑的输出图片设为输入图片"""
+    if output_image is not None:
+        # 对于局部编辑，我们需要创建一个新的ImageEditor格式
+        # 将输出图片作为背景，不包含任何编辑层
+        return {"background": output_image, "layers": []}, output_image
+    return None, None
+
+def load_global_input_from_state(state_image):
+    """从状态加载全局编辑输入图片"""
+    return state_image
+
+def load_local_input_from_state(state_image):
+    """从状态加载局部编辑输入图片"""
+    return state_image
+
+def local_edit_interface(image_dict, prompt, request: gr.Request, progress=gr.Progress()):
+    """
+    处理局部编辑请求
+    """
+    # 提取用户IP
+    client_ip = request.client.host
+    x_forwarded_for = dict(request.headers).get('x-forwarded-for')
+    if x_forwarded_for:
+        client_ip = x_forwarded_for   
+    if client_ip not in IP_Dict:
+        IP_Dict[client_ip] = 0
+    IP_Dict[client_ip] += 1
+
+    # 获取IP属地信息
+    country_info = get_country_info_safe(client_ip)
+    
+    if image_dict is None:
+        return None, "Please upload an image and draw the area to edit"
+    
+    # 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"
+    
+    base_image = image_dict["background"]
+    layers = image_dict["layers"]
+    
+    if not layers:
+        return None, "Please draw the area to edit on the image"
+        
+    if not prompt or prompt.strip() == "":
+        return None, "Please enter editing prompt"
+    
+    # Check prompt length
+    if len(prompt.strip()) <= 3:
+        return None, "❌ Editing prompt must be more than 3 characters"
+    
+    # 检查图片是否包含NSFW内容
+    nsfw_result = None
+    if nsfw_detector is not None and base_image is not None:
+        try:
+            nsfw_result = nsfw_detector.predict_pil_label_only(base_image)
+            
+            if nsfw_result.lower() == "nsfw":
+                print(f"🔍 NSFW检测结果: ❌❌❌ {nsfw_result} - IP: {client_ip}({country_info})")
+                # 检查NSFW频率限制
+                is_rate_limited, wait_time = check_nsfw_rate_limit(client_ip)
+                
+                if is_rate_limited:
+                    wait_minutes = int(wait_time / 60) + 1
+                    window_info = get_current_window_info(client_ip)
+                    print(f"⚠️ NSFW频率限制 - IP: {client_ip}({country_info})")
+                    print(f"   时间窗口: {window_info['window_start']} - {window_info['window_end']}")
+                    print(f"   当前计数: {window_info['current_count']}/{NSFW_LIMIT}, 需要等待 {wait_minutes} 分钟")
+                    return None, f"❌ Please wait {wait_minutes} minutes before generating again"
+                else:
+                    record_nsfw_detection(client_ip)
+                    window_info = get_current_window_info(client_ip)
+            else:
+                print(f"🔍 NSFW检测结果: ✅✅✅ {nsfw_result} - IP: {client_ip}({country_info})")
+                
+        except Exception as e:
+            print(f"⚠️ NSFW检测失败: {e}")
+    
+    # IP访问限制检查
+    if IP_Dict[client_ip]>10 and country_info.lower() in ["印度", "巴基斯坦"]:
+        print(f"❌ Content not allowed - IP: {client_ip}({country_info}), count: {IP_Dict[client_ip]}, prompt: {prompt.strip()}")
+        return None, "❌ Content not allowed. Please modify your prompt"
+
+    result_url = None
+    status_message = ""
+    
+    def progress_callback(message):
+        nonlocal status_message
+        status_message = message
+        progress(0.5, desc=message)
+    
+    try:
+        print(f"✅ Local editing started - IP: {client_ip}({country_info}), count: {IP_Dict[client_ip]}, prompt: {prompt.strip()}", flush=True)
+        
+        # 调用局部图像编辑处理函数
+        result_url, message = process_local_image_edit(base_image, layers, prompt.strip(), progress_callback)
+        
+        if result_url:
+            print(f"✅ Local editing completed successfully - IP: {client_ip}({country_info}), result_url: {result_url}", flush=True)
+            progress(1.0, desc="Processing completed")
+            return result_url, "✅ " + message
+        else:
+            print(f"❌ Local editing processing failed - IP: {client_ip}({country_info}), error: {message}", flush=True)
+            return None, "❌ " + message
+            
+    except Exception as e:
+        return None, f"❌ Error occurred during processing: {str(e)}"
+
 # Create Gradio interface
 def create_app():
     with gr.Blocks(
@@ -283,9 +378,19 @@ def create_app():
             border-radius: 10px;
             background-color: #f8f9fa;
         }
+        .use-as-input-btn {
+            margin-top: 10px;
+            width: 100%;
+        }
         """
     ) as app:
         
+        # 使用State组件保持图片状态，防止切换tab时丢失
+        global_input_state = gr.State()
+        global_output_state = gr.State()
+        local_input_state = gr.State()
+        local_output_state = gr.State()
+        
         gr.Markdown(
             """
             # 🎨 AI Image Editor
@@ -293,72 +398,197 @@ def create_app():
             elem_classes=["main-container"]
         )
         
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("### 📸 Upload Image")
-                input_image = gr.Image(
-                    label="Select image to edit",
-                    type="pil",
-                    height=400,
-                    elem_classes=["upload-area"]
+        with gr.Tabs():
+            # Global editing tab
+            with gr.Tab("🌍 Global Editing"):
+                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" 按钮
+                        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
+                        )
+                
+                # Example area
+                gr.Markdown("### 💡 Prompt Examples")
+                with gr.Row():
+                    example_prompts = [
+                        "Change the character's background to a sunny seaside with blue waves",
+                        "Change the character's background to New York at night with neon lights",
+                        "Change the character's background to a fairytale castle with bright colors",
+                        "Change background to forest",
+                        "Change background to snow mountain"
+                    ]
+                    
+                    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],
+                    show_progress=True
+                ).then(
+                    fn=update_global_output_state,
+                    inputs=[output_image],
+                    outputs=[global_output_state]
                 )
                 
-                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
+                # 绑定 "Use as Input" 按钮
+                use_as_input_btn.click(
+                    fn=use_global_output_as_input,
+                    inputs=[output_image],
+                    outputs=[input_image, global_input_state]
                 )
                 
-                edit_button = gr.Button(
-                    "🚀 Start Editing",
-                    variant="primary",
-                    size="lg"
+                # 绑定输入图片变化事件以更新状态
+                input_image.change(
+                    fn=update_global_input_state,
+                    inputs=[input_image],
+                    outputs=[global_input_state]
                 )
             
-            with gr.Column(scale=1):
-                gr.Markdown("### 🎯 Editing Result")
-                output_image = gr.Image(
-                    label="Edited image",
-                    height=400,
-                    elem_classes=["result-area"]
+            # Local editing tab  
+            with gr.Tab("🖌️ Local Editing"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📸 Upload Image and Draw Edit Area")
+                        local_input_image = gr.ImageEditor(
+                            label="Upload image and draw mask",
+                            type="pil",
+                            height=512,
+                            brush=gr.Brush(colors=["#ff0000"], default_size=60),
+                            elem_classes=["upload-area"]
+                        )
+                        
+                        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"]
+                        )
+                        
+                        # 添加 "Use as Input" 按钮
+                        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 editing examples
+                gr.Markdown("### 💡 Local Editing Prompt Examples")
+                with gr.Row():
+                    local_example_prompts = [
+                        "Change selected area hair to golden",
+                        "Add pattern designs to selected clothing",
+                        "Change selected area to different material",
+                        "Add decorations to selected object",
+                        "Change selected area color and style"
+                    ]
+                    
+                    for prompt in local_example_prompts:
+                        gr.Button(
+                            prompt,
+                            size="sm"
+                        ).click(
+                            lambda p=prompt: p,
+                            outputs=local_prompt_input
+                        )
+                
+                # 绑定局部编辑按钮点击事件
+                local_edit_button.click(
+                    fn=local_edit_interface,
+                    inputs=[local_input_image, local_prompt_input],
+                    outputs=[local_output_image, local_status_output],
+                    show_progress=True
+                ).then(
+                    fn=update_local_output_state,
+                    inputs=[local_output_image],
+                    outputs=[local_output_state]
                 )
                 
-                status_output = gr.Textbox(
-                    label="Processing status",
-                    lines=2,
-                    max_lines=3,
-                    interactive=False
+                # 绑定局部编辑 "Use as Input" 按钮
+                local_use_as_input_btn.click(
+                    fn=use_local_output_as_input,
+                    inputs=[local_output_image],
+                    outputs=[local_input_image, local_input_state]
                 )
-        
-        # Example area
-        gr.Markdown("### 💡 Prompt Examples")
-        with gr.Row():
-            example_prompts = [
-                "Change the character's background to a sunny seaside with blue waves.",
-                "Change the character's background to New York at night with neon lights.",
-                "Change the character's background to a fairytale castle with bright colors.",
-                "Change background to forest",
-                "Change background to snow mountain"
-            ]
-            
-            for prompt in example_prompts:
-                gr.Button(
-                    prompt,
-                    size="sm"
-                ).click(
-                    lambda p=prompt: p,
-                    outputs=prompt_input
+                
+                # 绑定局部编辑输入图片变化事件以更新状态
+                local_input_image.change(
+                    fn=update_local_input_state,
+                    inputs=[local_input_image],
+                    outputs=[local_input_state]
                 )
-        
-        # Bind button click event
-        edit_button.click(
-            fn=edit_image_interface,
-            inputs=[input_image, prompt_input],
-            outputs=[output_image, status_output],
-            show_progress=True
-        )
     
     return app
 

requirements.txt

@@ -1,4 +1,4 @@
-gradio>=4.0.0
+gradio==5.42.0
 opencv-python>=4.8.0
 requests>=2.28.0
 func-timeout>=4.3.5

util.py

@@ -142,103 +142,138 @@ def upload_user_img_r2(clientIp, timeId, img):
 
 @func_timeout.func_set_timeout(10)
 def get_country_info(ip):
-    """获取IP对应的国家信息"""
+    """Get country information for IP address"""
     try:
-        # 使用您指定的新接口 URL
+        # Use the new API URL
         url = f"https://qifu-api.baidubce.com/ip/geo/v1/district?ip={ip}"
         ret = requests.get(url)
-        ret.raise_for_status()  # 如果请求失败 (例如 404, 500), 会抛出异常
+        ret.raise_for_status()  # Raises exception if request fails (e.g. 404, 500)
         
         json_data = ret.json()
         
-        # 根据新的JSON结构，国家信息在 'data' -> 'country' 路径下
+        # Based on new JSON structure, country info is under 'data' -> 'country' path
         if json_data.get("code") == "Success":
             country = json_data.get("data", {}).get("country")
             return country if country else "Unknown"
         else:
-            # 处理API返回错误码的情况
-            print(f"API请求失败: {json_data.get('msg', '未知错误')}")
+            # Handle API error codes
+            print(f"API request failed: {json_data.get('msg', 'Unknown error')}")
             return "Unknown"
             
     except requests.exceptions.RequestException as e:
-        print(f"网络请求失败: {e}")
+        print(f"Network request failed: {e}")
         return "Unknown"
     except Exception as e:
-        print(f"获取IP属地失败: {e}")
+        print(f"Failed to get IP location: {e}")
         return "Unknown"
 
-@func_timeout.func_set_timeout(10)
-def get_location_info(ip):
-    """获取IP对应的详细位置信息"""
-    try:
-        # 使用您指定的新接口 URL
-        url = f"https://qifu-api.baidubce.com/ip/geo/v1/district?ip={ip}"
-        ret = requests.get(url)
-        ret.raise_for_status()
-        
-        json_data = ret.json()
-        
-        if json_data.get("code") == "Success":
-            data = json_data.get("data", {})
-            return {
-                "country": data.get("country", "Unknown"),
-                "prov": data.get("prov", "Unknown"),
-                "city": data.get("city", "Unknown"),
-                "isp": data.get("isp", "Unknown"),
-                "owner": data.get("owner", "Unknown"),
-                "full_data": data
-            }
-        else:
-            print(f"API请求失败: {json_data.get('msg', '未知错误')}")
-            return {
-                "country": "Unknown",
-                "prov": "Unknown", 
-                "city": "Unknown",
-                "isp": "Unknown",
-                "owner": "Unknown",
-                "full_data": {}
-            }
-            
-    except requests.exceptions.RequestException as e:
-        print(f"网络请求失败: {e}")
-        return {"country": "Unknown", "prov": "Unknown", "city": "Unknown", "isp": "Unknown", "owner": "Unknown", "full_data": {}}
-    except Exception as e:
-        print(f"获取IP属地失败: {e}")
-        return {"country": "Unknown", "prov": "Unknown", "city": "Unknown", "isp": "Unknown", "owner": "Unknown", "full_data": {}}
-
 def get_country_info_safe(ip):
-    """安全获取IP属地信息，出错时返回Unknown"""
+    """Safely get IP location info, returns Unknown on error"""
     try:
         return get_country_info(ip)
     except func_timeout.FunctionTimedOut:
-        print(f"获取IP属地超时: {ip}")
+        print(f"IP location request timeout: {ip}")
         return "Unknown"
     except Exception as e:
-        print(f"获取IP属地失败: {e}")
+        print(f"Failed to get IP location: {e}")
         return "Unknown"
 
-def get_location_info_safe(ip):
-    """安全获取IP详细位置信息，出错时返回默认值"""
-    try:
-        return get_location_info(ip)
-    except func_timeout.FunctionTimedOut:
-        print(f"获取IP位置超时: {ip}")
-        return {"country": "Unknown", "prov": "Unknown", "city": "Unknown", "isp": "Unknown", "owner": "Unknown", "full_data": {}}
-    except Exception as e:
-        print(f"获取IP位置失败: {e}")
-        return {"country": "Unknown", "prov": "Unknown", "city": "Unknown", "isp": "Unknown", "owner": "Unknown", "full_data": {}}
+def create_mask_from_layers(base_image, layers):
+    """
+    Create mask image from ImageEditor layers
+    
+    Args:
+        base_image (PIL.Image): Original image
+        layers (list): ImageEditor layer data
+        
+    Returns:
+        PIL.Image: Black and white mask image
+    """
+    from PIL import Image, ImageDraw
+    import numpy as np
+    
+    # Create blank mask with same size as original image
+    mask = Image.new('L', base_image.size, 0)  # 'L' mode is grayscale, 0 is black
+    
+    if not layers:
+        return mask
+    
+    # Iterate through all layers, set drawn areas to white
+    for layer in layers:
+        if layer is not None:
+            # Convert layer to numpy array
+            layer_array = np.array(layer)
+            
+            # Check layer format
+            if len(layer_array.shape) == 3:  # RGB/RGBA format
+                # If RGBA, check alpha channel
+                if layer_array.shape[2] == 4:
+                    # Use alpha channel as mask
+                    alpha_channel = layer_array[:, :, 3]
+                    # Set non-transparent areas (alpha > 0) to white
+                    mask_array = np.where(alpha_channel > 0, 255, 0).astype(np.uint8)
+                else:
+                    # RGB format, check if not pure black (0,0,0)
+                    # Assume drawn areas are non-black
+                    non_black = np.any(layer_array > 0, axis=2)
+                    mask_array = np.where(non_black, 255, 0).astype(np.uint8)
+            elif len(layer_array.shape) == 2:  # Grayscale
+                # Use grayscale values directly, set non-zero areas to white
+                mask_array = np.where(layer_array > 0, 255, 0).astype(np.uint8)
+            else:
+                continue
+            
+            # Convert mask_array to PIL image and merge into total mask
+            layer_mask = Image.fromarray(mask_array, mode='L')
+            # Resize to match original image
+            if layer_mask.size != base_image.size:
+                layer_mask = layer_mask.resize(base_image.size, Image.LANCZOS)
+            
+            # Merge masks (use maximum value to ensure all drawn areas are included)
+            mask_array_current = np.array(mask)
+            layer_mask_array = np.array(layer_mask)
+            combined_mask_array = np.maximum(mask_array_current, layer_mask_array)
+            mask = Image.fromarray(combined_mask_array, mode='L')
+    
+    return mask
 
-def contains_chinese(text):
-    """检测文本是否包含中文字符"""
-    import re
-    return bool(re.search(r'[\u4e00-\u9fff]', text))
 
+def upload_mask_image_r2(client_ip, time_id, mask_image):
+    """
+    Upload mask image to R2
+    
+    Args:
+        client_ip (str): Client IP
+        time_id (int): Timestamp
+        mask_image (PIL.Image): Mask image
+        
+    Returns:
+        str: Uploaded URL
+    """
+    file_name = f"{client_ip.replace('.', '')}{time_id}_mask.png"
+    local_path = os.path.join(tmpFolder, file_name)
+    
+    try:
+        # Save mask image as PNG format (supports transparency)
+        mask_image.save(local_path, 'PNG')
+        
+        # Upload to R2
+        res = R2Api().upload_file(local_path, file_name)
+        
+        return res
+    except Exception as e:
+        print(f"Failed to upload mask image: {e}")
+        return None
+    finally:
+        # Clean up local files
+        if os.path.exists(local_path):
+            os.remove(local_path)
 
 
 
-def submit_image_edit_task(user_image_url, prompt):
+def submit_image_edit_task(user_image_url, prompt, task_type="80", mask_image_url=""):
     """
-    提交图片编辑任务
+    Submit image editing task
     """
     headers = {
         'Content-Type': 'application/json',
@@ -247,7 +282,8 @@ def submit_image_edit_task(user_image_url, prompt):
     
     data = {
         "user_image": user_image_url,
-        "task_type": "80",
+        "mask_image": mask_image_url,
+        "task_type": task_type,
         "prompt": prompt,
         "secret_key": "219ngu",
         "is_private": "0"
@@ -274,7 +310,7 @@ def submit_image_edit_task(user_image_url, prompt):
 
 def check_task_status(task_id):
     """
-    查询任务状态
+    Query task status
     """
     headers = {
         'Content-Type': 'application/json',
@@ -307,52 +343,52 @@ def check_task_status(task_id):
 
 def process_image_edit(img_input, prompt, progress_callback=None):
     """
-    处理图片编辑的完整流程
+    Complete process for image editing
     
     Args:
-        img_input: 可以是文件路径(str)或PIL Image对象
-        prompt: 编辑指令
-        progress_callback: 进度回调函数
+        img_input: Can be file path (str) or PIL Image object
+        prompt: Editing instructions
+        progress_callback: Progress callback function
     """
     temp_img_path = None
     try:
-        # 生成客户端 IP 和时间戳
-        client_ip = "127.0.0.1"  # 默认IP
+        # Generate client IP and timestamp
+        client_ip = "127.0.0.1"  # Default IP
         time_id = int(time.time())
         
-        # 处理输入图像 - 支持PIL Image和文件路径
-        if hasattr(img_input, 'save'):  # PIL Image对象
-            # 创建临时文件
+        # Process input image - supports PIL Image and file path
+        if hasattr(img_input, 'save'):  # PIL Image object
+            # Create temporary file
             temp_dir = tempfile.mkdtemp()
             temp_img_path = os.path.join(temp_dir, f"temp_img_{time_id}.jpg")
             
-            # 保存PIL Image为临时文件
+            # Save PIL Image as temporary file
             if img_input.mode != 'RGB':
                 img_input = img_input.convert('RGB')
             img_input.save(temp_img_path, 'JPEG', quality=95)
             
             img_path = temp_img_path
-            print(f"💾 PIL Image已保存为临时文件: {temp_img_path}")
+            print(f"💾 PIL Image saved as temporary file: {temp_img_path}")
         else:
-            # 假设是文件路径
+            # Assume it's a file path
             img_path = img_input
         
         if progress_callback:
             progress_callback("uploading image...")
         
-        # 上传用户图片
+        # Upload user image
         uploaded_url = upload_user_img_r2(client_ip, time_id, img_path)
         if not uploaded_url:
             return None, "image upload failed"
         
-        # 从上传 URL 中提取实际的图片 URL
+        # Extract actual image URL from upload URL
         if "?" in uploaded_url:
             uploaded_url = uploaded_url.split("?")[0]
         
         if progress_callback:
             progress_callback("submitting edit task...")
         
-        # 提交图片编辑任务
+        # Submit image editing task
         task_id, error = submit_image_edit_task(uploaded_url, prompt)
         if error:
             return None, error
@@ -360,8 +396,8 @@ def process_image_edit(img_input, prompt, progress_callback=None):
         if progress_callback:
             progress_callback(f"task submitted, ID: {task_id}, processing...")
         
-        # 等待任务完成
-        max_attempts = 60  # 最多等待10分钟
+        # Wait for task completion
+        max_attempts = 60  # Wait up to 10 minutes
         for attempt in range(max_attempts):
             status, output_url, task_data = check_task_status(task_id)
             
@@ -395,9 +431,131 @@ def process_image_edit(img_input, prompt, progress_callback=None):
                 temp_dir = os.path.dirname(temp_img_path)
                 if os.path.exists(temp_dir):
                     os.rmdir(temp_dir)
-                print(f"🗑️ 已清理临时文件: {temp_img_path}")
+                print(f"🗑️ Cleaned up temporary file: {temp_img_path}")
+            except Exception as cleanup_error:
+                print(f"⚠️ Failed to clean up temporary file: {cleanup_error}")
+
+
+def process_local_image_edit(base_image, layers, prompt, progress_callback=None):
+    """
+    处理局部图片编辑的完整流程
+    
+    Args:
+        base_image (PIL.Image): 原始图片
+        layers (list): ImageEditor的层数据
+        prompt (str): 编辑指令
+        progress_callback: 进度回调函数
+    """
+    temp_img_path = None
+    temp_mask_path = None
+    
+    try:
+        # Generate client IP and timestamp
+        client_ip = "127.0.0.1"  # Default IP
+        time_id = int(time.time())
+        
+        if progress_callback:
+            progress_callback("正在创建mask图片...")
+        
+        # 从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, "请在图片上绘制需要编辑的区域"
+        
+        print(f"📝 创建mask图片成功，绘制区域像素数: {np.sum(mask_array > 0)}")
+        
+        if progress_callback:
+            progress_callback("正在上传原始图片...")
+        
+        # 处理并上传原始图片
+        temp_dir = tempfile.mkdtemp()
+        temp_img_path = os.path.join(temp_dir, f"temp_img_{time_id}.jpg")
+        
+        # 保存原始图片
+        if base_image.mode != 'RGB':
+            base_image = base_image.convert('RGB')
+        base_image.save(temp_img_path, 'JPEG', quality=95)
+        
+        # 上传原始图片
+        uploaded_url = upload_user_img_r2(client_ip, time_id, temp_img_path)
+        if not uploaded_url:
+            return None, "原始图片上传失败"
+        
+        # 从上传 URL 中提取实际的图片 URL
+        if "?" in uploaded_url:
+            uploaded_url = uploaded_url.split("?")[0]
+        
+        if progress_callback:
+            progress_callback("正在上传mask图片...")
+        
+        # 上传mask图片
+        mask_url = upload_mask_image_r2(client_ip, time_id, mask_image)
+        if not mask_url:
+            return None, "mask图片上传失败"
+        
+        # 从上传 URL 中提取实际的图片 URL
+        if "?" in mask_url:
+            mask_url = mask_url.split("?")[0]
+        
+        print(f"📤 图片上传成功:")
+        print(f"   原始图片: {uploaded_url}")
+        print(f"   Mask图片: {mask_url}")
+        
+        if progress_callback:
+            progress_callback("正在提交局部编辑任务...")
+        
+        # 提交局部图片编辑任务 (task_type=81)
+        task_id, error = submit_image_edit_task(uploaded_url, prompt, task_type="81", mask_image_url=mask_url)
+        if error:
+            return None, error
+        
+        if progress_callback:
+            progress_callback(f"任务已提交，ID: {task_id}，正在处理...")
+        
+        print(f"🚀 局部编辑任务已提交，任务ID: {task_id}")
+        
+        # Wait for task completion
+        max_attempts = 60  # Wait up to 10 minutes
+        for attempt in range(max_attempts):
+            status, output_url, task_data = check_task_status(task_id)
+            
+            if status == 'completed':
+                if output_url:
+                    print(f"✅ 局部编辑任务完成，结果: {output_url}")
+                    return output_url, "局部图片编辑完成"
+                else:
+                    return None, "任务完成但未返回结果图片"
+            elif status == 'error' or status == 'failed':
+                return None, f"任务处理失败: {task_data}"
+            elif status in ['queued', 'processing', 'running', 'created', 'working']:
+                if progress_callback:
+                    progress_callback(f"正在处理中... (状态: {status})")
+                time.sleep(1)  # Wait 1 second before retry
+            else:
+                if progress_callback:
+                    progress_callback(f"未知状态: {status}")
+                time.sleep(1)
+        
+        return None, "任务处理超时"
+        
+    except Exception as e:
+        print(f"❌ 局部编辑处理异常: {str(e)}")
+        return None, f"处理过程中发生错误: {str(e)}"
+    
+    finally:
+        # 清理临时文件
+        if temp_img_path and os.path.exists(temp_img_path):
+            try:
+                os.remove(temp_img_path)
+                temp_dir = os.path.dirname(temp_img_path)
+                if os.path.exists(temp_dir):
+                    os.rmdir(temp_dir)
+                print(f"🗑️ Cleaned up temporary file: {temp_img_path}")
             except Exception as cleanup_error:
-                print(f"⚠️ 清理临时文件失败: {cleanup_error}")
+                print(f"⚠️ Failed to clean up temporary file: {cleanup_error}")
 
 
 if __name__ == "__main__":