Update app.py

app.py

@@ -16,7 +16,13 @@ from transformers import (
     Sam3VideoModel, Sam3VideoProcessor,
     Sam3TrackerModel, Sam3TrackerProcessor
 )
+import json
+from datetime import datetime
+import threading
+import queue
+import uuid
 
+# ============ THEME SETUP ============
 colors.steel_blue = colors.Color(
     name="steel_blue",
     c50="#EBF3F8",
@@ -79,41 +85,75 @@ class CustomBlueTheme(Soft):
 
 app_theme = CustomBlueTheme()
 
+# ============ GLOBAL SETUP ============
 device = "cuda" if torch.cuda.is_available() else "cpu"
 print(f"🖥️ Using compute device: {device}")
 
-print("⏳ Loading SAM3 Models permanently into memory...")
+# History storage
+HISTORY_DIR = "processing_history"
+os.makedirs(HISTORY_DIR, exist_ok=True)
+HISTORY_FILE = os.path.join(HISTORY_DIR, "history.json")
+
+# Background processing queue
+processing_queue = queue.Queue()
+processing_results = {}
 
+# Load models
+print("⏳ Loading SAM3 Models permanently into memory...")
 try:
-    # 1. Load Image Segmentation Model (Text)
     print("   ... Loading Image Text Model")
     IMG_MODEL = Sam3Model.from_pretrained("DiffusionWave/sam3").to(device)
     IMG_PROCESSOR = Sam3Processor.from_pretrained("DiffusionWave/sam3")
 
-    # 2. Load Image Tracker Model (Click)
     print("   ... Loading Image Tracker Model")
     TRK_MODEL = Sam3TrackerModel.from_pretrained("DiffusionWave/sam3").to(device)
     TRK_PROCESSOR = Sam3TrackerProcessor.from_pretrained("DiffusionWave/sam3")
 
-    # 3. Load Video Segmentation Model
     print("   ... Loading Video Model")
-    # Using bfloat16 for video to optimize VRAM
     VID_MODEL = Sam3VideoModel.from_pretrained("DiffusionWave/sam3").to(device, dtype=torch.bfloat16)
     VID_PROCESSOR = Sam3VideoProcessor.from_pretrained("DiffusionWave/sam3")
     
     print("✅ All Models loaded successfully!")
-
 except Exception as e:
     print(f"❌ CRITICAL ERROR LOADING MODELS: {e}")
-    IMG_MODEL = None
-    IMG_PROCESSOR = None
-    TRK_MODEL = None
-    TRK_PROCESSOR = None
-    VID_MODEL = None
-    VID_PROCESSOR = None
-
-
-# --- UTILS ---
+    IMG_MODEL = IMG_PROCESSOR = TRK_MODEL = TRK_PROCESSOR = VID_MODEL = VID_PROCESSOR = None
+
+# ============ HISTORY MANAGEMENT ============
+def load_history():
+    """Load processing history from JSON file"""
+    if os.path.exists(HISTORY_FILE):
+        try:
+            with open(HISTORY_FILE, 'r') as f:
+                return json.load(f)
+        except:
+            return []
+    return []
+
+def save_history(history_item):
+    """Save a new history item"""
+    history = load_history()
+    history.insert(0, history_item)  # Add to beginning
+    history = history[:100]  # Keep last 100 items
+    with open(HISTORY_FILE, 'w') as f:
+        json.dump(history, f, indent=2)
+
+def get_history_display():
+    """Format history for display"""
+    history = load_history()
+    if not history:
+        return "Chưa có lịch sử xử lý nào"
+    
+    display_text = ""
+    for i, item in enumerate(history[:50], 1):
+        status_emoji = "✅" if item['status'] == 'completed' else "❌"
+        display_text += f"{status_emoji} **{item['type'].upper()}** - {item['timestamp']}\n"
+        display_text += f"   Prompt: {item['prompt']}\n"
+        if item.get('output_path'):
+            display_text += f"   File: `{os.path.basename(item['output_path'])}`\n"
+        display_text += "\n"
+    return display_text
+
+# ============ UTILITY FUNCTIONS ============
 def apply_mask_overlay(base_image, mask_data, opacity=0.5):
     """Draws segmentation masks on top of an image."""
     if isinstance(base_image, np.ndarray):
@@ -127,7 +167,6 @@ def apply_mask_overlay(base_image, mask_data, opacity=0.5):
         mask_data = mask_data.cpu().numpy()
     mask_data = mask_data.astype(np.uint8)
     
-    # Handle dimensions
     if mask_data.ndim == 4: mask_data = mask_data[0] 
     if mask_data.ndim == 3 and mask_data.shape[0] == 1: mask_data = mask_data[0]
     
@@ -168,154 +207,297 @@ def draw_points_on_image(image, points):
     
     for pt in points:
         x, y = pt
-        r = 8 # Radius of point
+        r = 8
         draw.ellipse((x-r, y-r, x+r, y+r), fill="red", outline="white", width=4)
     
     return draw_img
 
+# ============ BACKGROUND PROCESSING WORKER ============
+def background_worker():
+    """Background thread that processes jobs from queue"""
+    while True:
+        try:
+            job = processing_queue.get()
+            if job is None:
+                break
+            
+            job_id = job['id']
+            job_type = job['type']
+            
+            processing_results[job_id] = {'status': 'processing', 'progress': 0}
+            
+            try:
+                if job_type == 'image':
+                    result = process_image_job(job)
+                elif job_type == 'video':
+                    result = process_video_job(job)
+                elif job_type == 'click':
+                    result = process_click_job(job)
+                
+                processing_results[job_id] = {
+                    'status': 'completed',
+                    'result': result,
+                    'progress': 100
+                }
+                
+                # Save to history
+                save_history({
+                    'id': job_id,
+                    'type': job_type,
+                    'prompt': job.get('prompt', 'N/A'),
+                    'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                    'status': 'completed',
+                    'output_path': result.get('output_path')
+                })
+                
+            except Exception as e:
+                processing_results[job_id] = {
+                    'status': 'error',
+                    'error': str(e),
+                    'progress': 0
+                }
+                save_history({
+                    'id': job_id,
+                    'type': job_type,
+                    'prompt': job.get('prompt', 'N/A'),
+                    'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                    'status': 'error',
+                    'error': str(e)
+                })
+        except Exception as e:
+            print(f"Worker error: {e}")
+
+# Start background worker
+worker_thread = threading.Thread(target=background_worker, daemon=True)
+worker_thread.start()
+
+# ============ JOB PROCESSORS ============
 @spaces.GPU
-def run_image_segmentation(source_img, text_query, conf_thresh=0.5):
-    if IMG_MODEL is None or IMG_PROCESSOR is None:
-        raise gr.Error("Models failed to load on startup.")
-        
-    if source_img is None or not text_query:
-        raise gr.Error("Please provide an image and a text prompt.")
+def process_image_job(job):
+    """Process image segmentation job"""
+    source_img = job['image']
+    text_query = job['prompt']
+    conf_thresh = job.get('conf_thresh', 0.5)
     
-    try:
-        pil_image = source_img.convert("RGB")
-        model_inputs = IMG_PROCESSOR(images=pil_image, text=text_query, return_tensors="pt").to(device)
-
-        with torch.no_grad():
-            inference_output = IMG_MODEL(**model_inputs)
-
-        processed_results = IMG_PROCESSOR.post_process_instance_segmentation(
-            inference_output,
-            threshold=conf_thresh,
-            mask_threshold=0.5,
-            target_sizes=model_inputs.get("original_sizes").tolist()
-        )[0]
-
-        annotation_list = []
-        raw_masks = processed_results['masks'].cpu().numpy()
-        raw_scores = processed_results['scores'].cpu().numpy()
-        
-        for idx, mask_array in enumerate(raw_masks):
-            label_str = f"{text_query} ({raw_scores[idx]:.2f})"
-            annotation_list.append((mask_array, label_str))
-            
-        return (pil_image, annotation_list)
-
-    except Exception as e:
-        raise gr.Error(f"Error during image processing: {e}")
+    if isinstance(source_img, str):
+        source_img = Image.open(source_img)
+    
+    pil_image = source_img.convert("RGB")
+    model_inputs = IMG_PROCESSOR(images=pil_image, text=text_query, return_tensors="pt").to(device)
+
+    with torch.no_grad():
+        inference_output = IMG_MODEL(**model_inputs)
+
+    processed_results = IMG_PROCESSOR.post_process_instance_segmentation(
+        inference_output,
+        threshold=conf_thresh,
+        mask_threshold=0.5,
+        target_sizes=model_inputs.get("original_sizes").tolist()
+    )[0]
+
+    annotation_list = []
+    raw_masks = processed_results['masks'].cpu().numpy()
+    raw_scores = processed_results['scores'].cpu().numpy()
+    
+    for idx, mask_array in enumerate(raw_masks):
+        label_str = f"{text_query} ({raw_scores[idx]:.2f})"
+        annotation_list.append((mask_array, label_str))
+    
+    # Save output
+    output_path = os.path.join(HISTORY_DIR, f"{job['id']}_result.jpg")
+    result_img = apply_mask_overlay(pil_image, raw_masks)
+    result_img.save(output_path)
+    
+    return {
+        'image': (pil_image, annotation_list),
+        'output_path': output_path
+    }
 
 @spaces.GPU
-def run_image_click_gpu(input_image, x, y, points_state, labels_state):
-    if TRK_MODEL is None or TRK_PROCESSOR is None:
-        raise gr.Error("Tracker Model failed to load.")
+def process_video_job(job):
+    """Process video segmentation job"""
+    source_vid = job['video']
+    text_query = job['prompt']
+    frame_limit = job.get('frame_limit', 60)
     
-    if input_image is None: return input_image, [], []
-    if points_state is None: points_state = []; labels_state = []
+    video_cap = cv2.VideoCapture(source_vid)
+    vid_fps = video_cap.get(cv2.CAP_PROP_FPS)
+    vid_w = int(video_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    vid_h = int(video_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
     
-    # Append new point
-    points_state.append([x, y])
-    labels_state.append(1) # 1 indicates a positive click (foreground)
-
-    try:
-        # Prepare inputs format: [Batch, Point_Group, Point_Idx, Coord]
-        input_points = [[points_state]] 
-        input_labels = [[labels_state]]
-        
-        inputs = TRK_PROCESSOR(images=input_image, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(device)
+    video_frames = []
+    counter = 0
+    while video_cap.isOpened():
+        ret, frame = video_cap.read()
+        if not ret or (frame_limit > 0 and counter >= frame_limit): break
+        video_frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+        counter += 1
+    video_cap.release()
+    
+    session = VID_PROCESSOR.init_video_session(video=video_frames, inference_device=device, dtype=torch.bfloat16)
+    session = VID_PROCESSOR.add_text_prompt(inference_session=session, text=text_query)
+    
+    output_path = os.path.join(HISTORY_DIR, f"{job['id']}_result.mp4")
+    video_writer = cv2.VideoWriter(output_path, cv2.VideoWriter_fourcc(*'mp4v'), vid_fps, (vid_w, vid_h))
+    
+    total_frames = len(video_frames)
+    for frame_idx, model_out in enumerate(VID_MODEL.propagate_in_video_iterator(inference_session=session, max_frame_num_to_track=total_frames)):
+        post_processed = VID_PROCESSOR.postprocess_outputs(session, model_out)
+        f_idx = model_out.frame_idx
+        original_pil = Image.fromarray(video_frames[f_idx])
         
-        with torch.no_grad():
-            # multimask_output=True usually helps with ambiguity, but let's default to best mask for simplicity here
-            outputs = TRK_MODEL(**inputs, multimask_output=False)
+        if 'masks' in post_processed:
+            detected_masks = post_processed['masks']
+            if detected_masks.ndim == 4: detected_masks = detected_masks.squeeze(1)
+            final_frame = apply_mask_overlay(original_pil, detected_masks)
+        else: 
+            final_frame = original_pil
             
-        # Post process
-        masks = TRK_PROCESSOR.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"], binarize=True)[0]
+        video_writer.write(cv2.cvtColor(np.array(final_frame), cv2.COLOR_RGB2BGR))
         
-        # Overlay mask
-        # masks shape is [1, 1, H, W] for single object tracking
-        final_img = apply_mask_overlay(input_image, masks[0])
+        # Update progress
+        progress = int((frame_idx + 1) / total_frames * 100)
+        processing_results[job['id']]['progress'] = progress
         
-        # Draw the visual points on top
-        final_img = draw_points_on_image(final_img, points_state)
+    video_writer.release()
+    return {'output_path': output_path}
+
+@spaces.GPU
+def process_click_job(job):
+    """Process click segmentation job"""
+    input_image = job['image']
+    points_state = job['points']
+    labels_state = job['labels']
+    
+    if isinstance(input_image, str):
+        input_image = Image.open(input_image)
+    
+    input_points = [[points_state]] 
+    input_labels = [[labels_state]]
+    
+    inputs = TRK_PROCESSOR(images=input_image, input_points=input_points, input_labels=input_labels, return_tensors="pt").to(device)
+    
+    with torch.no_grad():
+        outputs = TRK_MODEL(**inputs, multimask_output=False)
         
-        return final_img, points_state, labels_state
+    masks = TRK_PROCESSOR.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"], binarize=True)[0]
+    final_img = apply_mask_overlay(input_image, masks[0])
+    final_img = draw_points_on_image(final_img, points_state)
+    
+    output_path = os.path.join(HISTORY_DIR, f"{job['id']}_result.jpg")
+    final_img.save(output_path)
+    
+    return {
+        'image': final_img,
+        'output_path': output_path
+    }
+
+# ============ UI HANDLERS ============
+def submit_image_job(source_img, text_query, conf_thresh):
+    """Submit image segmentation job to background queue"""
+    if source_img is None or not text_query:
+        return None, "❌ Vui lòng cung cấp ảnh và prompt", ""
+    
+    job_id = str(uuid.uuid4())
+    job = {
+        'id': job_id,
+        'type': 'image',
+        'image': source_img,
+        'prompt': text_query,
+        'conf_thresh': conf_thresh
+    }
+    
+    processing_queue.put(job)
+    return None, f"✅ Đã thêm vào hàng chờ (ID: {job_id[:8]}). Đang xử lý...", job_id
 
-    except Exception as e:
-        print(f"Tracker Error: {e}")
-        return input_image, points_state, labels_state
+def check_image_status(job_id):
+    """Check status of image processing job"""
+    if not job_id or job_id not in processing_results:
+        return None, "Không tìm thấy công việc"
+    
+    result = processing_results[job_id]
+    
+    if result['status'] == 'processing':
+        return None, f"⏳ Đang xử lý... {result['progress']}%"
+    elif result['status'] == 'completed':
+        return result['result']['image'], "✅ Hoàn thành!"
+    else:
+        return None, f"❌ Lỗi: {result.get('error', 'Unknown')}"
+
+def submit_video_job(source_vid, text_query, frame_limit, time_limit):
+    """Submit video segmentation job to background queue"""
+    if not source_vid or not text_query:
+        return None, "❌ Vui lòng cung cấp video và prompt", ""
+    
+    job_id = str(uuid.uuid4())
+    job = {
+        'id': job_id,
+        'type': 'video',
+        'video': source_vid,
+        'prompt': text_query,
+        'frame_limit': frame_limit,
+        'time_limit': time_limit
+    }
+    
+    processing_queue.put(job)
+    return None, f"✅ Đã thêm vào hàng chờ (ID: {job_id[:8]}). Đang xử lý...", job_id
+
+def check_video_status(job_id):
+    """Check status of video processing job"""
+    if not job_id or job_id not in processing_results:
+        return None, "Không tìm thấy công việc"
+    
+    result = processing_results[job_id]
+    
+    if result['status'] == 'processing':
+        return None, f"⏳ Đang xử lý... {result['progress']}%"
+    elif result['status'] == 'completed':
+        return result['result']['output_path'], "✅ Hoàn thành!"
+    else:
+        return None, f"❌ Lỗi: {result.get('error', 'Unknown')}"
 
 def image_click_handler(image, evt: gr.SelectData, points_state, labels_state):
-    # Wrapper to handle the Gradio select event
+    """Handle click events for interactive segmentation"""
     x, y = evt.index
-    return run_image_click_gpu(image, x, y, points_state, labels_state)
-
-def calc_timeout_duration(vid_file, *args):
-    return args[-1] if args else 60
-
-@spaces.GPU(duration=calc_timeout_duration)
-def run_video_segmentation(source_vid, text_query, frame_limit, time_limit):
-    if VID_MODEL is None or VID_PROCESSOR is None:
-        raise gr.Error("Video Models failed to load on startup.")
-
-    if not source_vid or not text_query:
-        raise gr.Error("Missing video or prompt.")
-        
+    
+    if points_state is None: points_state = []
+    if labels_state is None: labels_state = []
+    
+    points_state.append([x, y])
+    labels_state.append(1)
+    
+    # Process immediately (can be changed to background if needed)
+    job_id = str(uuid.uuid4())
+    job = {
+        'id': job_id,
+        'type': 'click',
+        'image': image,
+        'points': points_state,
+        'labels': labels_state
+    }
+    
     try:
-        video_cap = cv2.VideoCapture(source_vid)
-        vid_fps = video_cap.get(cv2.CAP_PROP_FPS)
-        vid_w = int(video_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-        vid_h = int(video_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        
-        video_frames = []
-        counter = 0
-        while video_cap.isOpened():
-            ret, frame = video_cap.read()
-            if not ret or (frame_limit > 0 and counter >= frame_limit): break
-            video_frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
-            counter += 1
-        video_cap.release()
-        
-        session = VID_PROCESSOR.init_video_session(video=video_frames, inference_device=device, dtype=torch.bfloat16)
-        session = VID_PROCESSOR.add_text_prompt(inference_session=session, text=text_query)
-        
-        temp_out_path = tempfile.mktemp(suffix=".mp4")
-        video_writer = cv2.VideoWriter(temp_out_path, cv2.VideoWriter_fourcc(*'mp4v'), vid_fps, (vid_w, vid_h))
-        
-        for model_out in VID_MODEL.propagate_in_video_iterator(inference_session=session, max_frame_num_to_track=len(video_frames)):
-            post_processed = VID_PROCESSOR.postprocess_outputs(session, model_out)
-            f_idx = model_out.frame_idx
-            original_pil = Image.fromarray(video_frames[f_idx])
-            
-            if 'masks' in post_processed:
-                detected_masks = post_processed['masks']
-                if detected_masks.ndim == 4: detected_masks = detected_masks.squeeze(1)
-                final_frame = apply_mask_overlay(original_pil, detected_masks)
-            else: 
-                final_frame = original_pil
-                
-            video_writer.write(cv2.cvtColor(np.array(final_frame), cv2.COLOR_RGB2BGR))
-            
-        video_writer.release()
-        return temp_out_path, "Video processing completed successfully.✅"
-        
+        result = process_click_job(job)
+        return result['image'], points_state, labels_state
     except Exception as e:
-        return None, f"Error during video processing: {str(e)}"
+        print(f"Click error: {e}")
+        return image, points_state, labels_state
 
+# ============ GRADIO INTERFACE ============
 custom_css="""
-#col-container { margin: 0 auto; max-width: 1100px; }
+#col-container { margin: 0 auto; max-width: 1200px; }
 #main-title h1 { font-size: 2.1em !important; }
+.history-box { max-height: 600px; overflow-y: auto; }
 """
 
-with gr.Blocks() as demo:
+with gr.Blocks(css=custom_css, theme=app_theme) as demo:
     with gr.Column(elem_id="col-container"):
-        gr.Markdown("# **SAM3: Segment Anything Model 3**", elem_id="main-title")
-        gr.Markdown("Segment objects in image or video using **SAM3** with Text Prompts or Interactive Clicks.")
+        gr.Markdown("# **SAM3: Segment Anything Model 3** 🚀", elem_id="main-title")
+        gr.Markdown("Xử lý ảnh/video với **background processing** - không cần chờ đợi!")
 
         with gr.Tabs():
-            with gr.Tab("Image Segmentation"):
+            # ===== IMAGE SEGMENTATION TAB =====
+            with gr.Tab("📷 Image Segmentation"):
                 with gr.Row():
                     with gr.Column(scale=1):
                         image_input = gr.Image(label="Upload Image", type="pil", height=350)
@@ -323,29 +505,28 @@ with gr.Blocks() as demo:
                         with gr.Accordion("Advanced Settings", open=False):
                             conf_slider = gr.Slider(0.0, 1.0, value=0.45, step=0.05, label="Confidence Threshold")
                         
-                        btn_process_img = gr.Button("Segment Image", variant="primary")
+                        btn_submit_img = gr.Button("🚀 Submit Job (Background)", variant="primary")
+                        btn_check_img = gr.Button("🔍 Check Status", variant="secondary")
+                        job_id_img = gr.Textbox(label="Job ID", visible=False)
 
                     with gr.Column(scale=1.5):
                         image_result = gr.AnnotatedImage(label="Segmented Result", height=410)
+                        status_img = gr.Textbox(label="Status", interactive=False)
                 
-                        gr.Examples(
-                            examples=[
-                                ["examples/player.jpg", "player in white", 0.5],
-                            ],
-                            inputs=[image_input, txt_prompt_img, conf_slider],
-                            outputs=[image_result],
-                            fn=run_image_segmentation,
-                            cache_examples=False,
-                            label="Image Examples"
-                        )
-        
-                        btn_process_img.click(
-                            fn=run_image_segmentation, 
-                            inputs=[image_input, txt_prompt_img, conf_slider], 
-                            outputs=[image_result]
-                        )
+                btn_submit_img.click(
+                    fn=submit_image_job,
+                    inputs=[image_input, txt_prompt_img, conf_slider],
+                    outputs=[image_result, status_img, job_id_img]
+                )
+                
+                btn_check_img.click(
+                    fn=check_image_status,
+                    inputs=[job_id_img],
+                    outputs=[image_result, status_img]
+                )
             
-            with gr.Tab("Video Segmentation"):
+            # ===== VIDEO SEGMENTATION TAB =====
+            with gr.Tab("🎥 Video Segmentation"):
                 with gr.Row():
                     with gr.Column():
                         video_input = gr.Video(label="Upload Video", format="mp4", height=320)
@@ -355,36 +536,35 @@ with gr.Blocks() as demo:
                             frame_limiter = gr.Slider(10, 500, value=60, step=10, label="Max Frames")
                             time_limiter = gr.Radio([60, 120, 180], value=60, label="Timeout (seconds)")
                         
-                        btn_process_vid = gr.Button("Segment Video", variant="primary")
+                        btn_submit_vid = gr.Button("🚀 Submit Job (Background)", variant="primary")
+                        btn_check_vid = gr.Button("🔍 Check Status", variant="secondary")
+                        job_id_vid = gr.Textbox(label="Job ID", visible=False)
                         
                     with gr.Column():
                         video_result = gr.Video(label="Processed Video")
-                        process_status = gr.Textbox(label="System Status", interactive=False)
+                        status_vid = gr.Textbox(label="Status", interactive=False)
+
+                btn_submit_vid.click(
+                    fn=submit_video_job,
+                    inputs=[video_input, txt_prompt_vid, frame_limiter, time_limiter],
+                    outputs=[video_result, status_vid, job_id_vid]
+                )
                 
-                        gr.Examples(
-                            examples=[
-                                ["examples/sample_video.mp4", "players", 120, 120],
-                            ],
-                            inputs=[video_input, txt_prompt_vid, frame_limiter, time_limiter],
-                            outputs=[video_result, process_status],
-                            fn=run_video_segmentation,
-                            cache_examples=False,
-                            label="Video Examples"
-                        )
-
-                btn_process_vid.click(
-                    run_video_segmentation, 
-                    inputs=[video_input, txt_prompt_vid, frame_limiter, time_limiter], 
-                    outputs=[video_result, process_status]
+                btn_check_vid.click(
+                    fn=check_video_status,
+                    inputs=[job_id_vid],
+                    outputs=[video_result, status_vid]
                 )
                 
-            with gr.Tab("Image Click Segmentation"):
+            # ===== CLICK SEGMENTATION TAB =====
+            with gr.Tab("👆 Click Segmentation"):
                 with gr.Row():
                     with gr.Column(scale=1):
                         img_click_input = gr.Image(type="pil", label="Upload Image", interactive=True, height=450)
+                        gr.Markdown("**Hướng dẫn:** Click vào đối tượng bạn muốn phân đoạn")
                         
                         with gr.Row():
-                            img_click_clear = gr.Button("Clear Points & Reset", variant="primary")
+                            img_click_clear = gr.Button("🔄 Clear Points & Reset", variant="primary")
                         
                         st_click_points = gr.State([])
                         st_click_labels = gr.State([])
@@ -402,6 +582,43 @@ with gr.Blocks() as demo:
                     lambda: (None, [], []),
                     outputs=[img_click_output, st_click_points, st_click_labels]
                 )
+            
+            # ===== HISTORY TAB =====
+            with gr.Tab("📜 Lịch Sử Xử Lý"):
+                with gr.Row():
+                    with gr.Column():
+                        btn_refresh_history = gr.Button("🔄 Refresh History", variant="primary")
+                        history_display = gr.Markdown(value=get_history_display(), elem_classes="history-box")
+                        
+                        with gr.Accordion("Hướng dẫn", open=False):
+                            gr.Markdown("""
+                            ### Lịch sử lưu:
+                            - ✅ **Hoàn thành**: File đã được xử lý thành công
+                            - ❌ **Lỗi**: Xử lý thất bại
+                            - Tất cả file output được lưu trong thư mục `processing_history/`
+                            - Hệ thống giữ lại 100 lịch sử gần nhất
+                            """)
+                
+                btn_refresh_history.click(
+                    fn=get_history_display,
+                    outputs=[history_display]
+                )
+            
+            # ===== BATCH PROCESSING TAB =====
+            with gr.Tab("⚙️ Batch Processing"):
+                gr.Markdown("### Xử lý hàng loạt (Coming Soon)")
+                gr.Markdown("""
+                Tính năng này sẽ cho phép bạn:
+                - Upload nhiều ảnh/video cùng lúc
+                - Tự động xử lý tuần tự
+                - Download tất cả kết quả dưới dạng ZIP
+                """)
 
 if __name__ == "__main__":
-    demo.launch(css=custom_css, theme=app_theme, ssr_mode=False, mcp_server=True, show_error=True)
+    demo.launch(
+        css=custom_css,
+        theme=app_theme,
+        ssr_mode=False,
+        mcp_server=True,
+        show_error=True
+    )