Upload app.py

app.py

@@ -16,13 +16,7 @@ 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",
@@ -85,75 +79,41 @@ class CustomBlueTheme(Soft):
 
 app_theme = CustomBlueTheme()
 
-# ============ GLOBAL SETUP ============
 device = "cuda" if torch.cuda.is_available() else "cpu"
 print(f"🖥️ Using compute device: {device}")
 
-# 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 = 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 ============
+    IMG_MODEL = None
+    IMG_PROCESSOR = None
+    TRK_MODEL = None
+    TRK_PROCESSOR = None
+    VID_MODEL = None
+    VID_PROCESSOR = None
+
+
+# --- UTILS ---
 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):
@@ -167,6 +127,7 @@ 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]
     
@@ -207,297 +168,154 @@ def draw_points_on_image(image, points):
     
     for pt in points:
         x, y = pt
-        r = 8
+        r = 8 # Radius of point
         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 process_image_job(job):
-    """Process image segmentation job"""
-    source_img = job['image']
-    text_query = job['prompt']
-    conf_thresh = job.get('conf_thresh', 0.5)
-    
-    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)
+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.")
     
-    return {
-        'image': (pil_image, annotation_list),
-        'output_path': output_path
-    }
+    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}")
 
 @spaces.GPU
-def process_video_job(job):
-    """Process video segmentation job"""
-    source_vid = job['video']
-    text_query = job['prompt']
-    frame_limit = job.get('frame_limit', 60)
-    
-    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()
+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.")
     
-    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)
+    if input_image is None: return input_image, [], []
+    if points_state is None: points_state = []; labels_state = []
     
-    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])
+    # 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)
         
-        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
+        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)
             
-        video_writer.write(cv2.cvtColor(np.array(final_frame), cv2.COLOR_RGB2BGR))
+        # Post process
+        masks = TRK_PROCESSOR.post_process_masks(outputs.pred_masks.cpu(), inputs["original_sizes"], binarize=True)[0]
         
-        # Update progress
-        progress = int((frame_idx + 1) / total_frames * 100)
-        processing_results[job['id']]['progress'] = progress
+        # Overlay mask
+        # masks shape is [1, 1, H, W] for single object tracking
+        final_img = apply_mask_overlay(input_image, masks[0])
         
-    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)
+        # Draw the visual points on top
+        final_img = draw_points_on_image(final_img, points_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
+        return final_img, 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')}"
+    except Exception as e:
+        print(f"Tracker Error: {e}")
+        return input_image, points_state, labels_state
 
 def image_click_handler(image, evt: gr.SelectData, points_state, labels_state):
-    """Handle click events for interactive segmentation"""
+    # Wrapper to handle the Gradio select event
     x, y = evt.index
-    
-    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
-    }
-    
+    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.")
+        
     try:
-        result = process_click_job(job)
-        return result['image'], 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))
+        
+        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.✅"
+        
     except Exception as e:
-        print(f"Click error: {e}")
-        return image, points_state, labels_state
+        return None, f"Error during video processing: {str(e)}"
 
-# ============ GRADIO INTERFACE ============
 custom_css="""
-#col-container { margin: 0 auto; max-width: 1200px; }
+#col-container { margin: 0 auto; max-width: 1100px; }
 #main-title h1 { font-size: 2.1em !important; }
-.history-box { max-height: 600px; overflow-y: auto; }
 """
 
-with gr.Blocks(css=custom_css, theme=app_theme) as demo:
+with gr.Blocks() as demo:
     with gr.Column(elem_id="col-container"):
-        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!")
+        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.")
 
         with gr.Tabs():
-            # ===== IMAGE SEGMENTATION TAB =====
-            with gr.Tab("📷 Image Segmentation"):
+            with gr.Tab("Image Segmentation"):
                 with gr.Row():
                     with gr.Column(scale=1):
                         image_input = gr.Image(label="Upload Image", type="pil", height=350)
@@ -505,28 +323,29 @@ with gr.Blocks(css=custom_css, theme=app_theme) 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_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)
+                        btn_process_img = gr.Button("Segment Image", variant="primary")
 
                     with gr.Column(scale=1.5):
                         image_result = gr.AnnotatedImage(label="Segmented Result", height=410)
-                        status_img = gr.Textbox(label="Status", interactive=False)
                 
-                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]
-                )
+                        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]
+                        )
             
-            # ===== VIDEO SEGMENTATION TAB =====
-            with gr.Tab("🎥 Video Segmentation"):
+            with gr.Tab("Video Segmentation"):
                 with gr.Row():
                     with gr.Column():
                         video_input = gr.Video(label="Upload Video", format="mp4", height=320)
@@ -536,35 +355,36 @@ with gr.Blocks(css=custom_css, theme=app_theme) 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_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)
+                        btn_process_vid = gr.Button("Segment Video", variant="primary")
                         
                     with gr.Column():
                         video_result = gr.Video(label="Processed Video")
-                        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]
-                )
+                        process_status = gr.Textbox(label="System Status", interactive=False)
                 
-                btn_check_vid.click(
-                    fn=check_video_status,
-                    inputs=[job_id_vid],
-                    outputs=[video_result, status_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]
                 )
                 
-            # ===== CLICK SEGMENTATION TAB =====
-            with gr.Tab("👆 Click Segmentation"):
+            with gr.Tab("Image 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([])
@@ -582,43 +402,6 @@ with gr.Blocks(css=custom_css, theme=app_theme) 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)