Update app.py

app.py

@@ -816,6 +816,257 @@
 
 
 
+# import gradio as gr
+# import torch
+# import numpy as np
+# import cv2
+# from PIL import Image
+# from transformers import TrOCRProcessor, VisionEncoderDecoderModel
+# from paddleocr import PaddleOCR
+# import pandas as pd
+
+# # --- 1. SETUP TR-OCR ---
+# device = "cuda" if torch.cuda.is_available() else "cpu"
+# print(f"Loading TrOCR on {device}...")
+# processor = TrOCRProcessor.from_pretrained('microsoft/trocr-base-handwritten')
+# model = VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-base-handwritten').to(device).eval()
+
+# # --- 2. SETUP PADDLEOCR ---
+# print("Loading PaddleOCR...")
+# # High resolution settings to detect faint text
+# detector = PaddleOCR(use_angle_cls=True, lang='en', show_log=False, 
+#                      det_limit_side_len=2500, det_db_thresh=0.1, det_db_box_thresh=0.3)
+
+
+# # ==========================================
+# # 🧠 LOGIC: INTERSECTION OVER UNION (IOU)
+# # ==========================================
+# def calculate_iou_containment(box1, box2):
+#     """
+#     Calculates how much of box1 is inside box2.
+#     Returns: ratio (0.0 to 1.0)
+#     """
+#     x1 = max(box1[0], box2[0])
+#     y1 = max(box1[1], box2[1])
+#     x2 = min(box1[2], box2[2])
+#     y2 = min(box1[3], box2[3])
+    
+#     if x2 < x1 or y2 < y1:
+#         return 0.0
+    
+#     intersection = (x2 - x1) * (y2 - y1)
+#     area1 = (box1[2] - box1[0]) * (box1[3] - box1[1])
+    
+#     return intersection / area1
+
+# def filter_nested_boxes(boxes, containment_thresh=0.85):
+#     """
+#     Removes boxes that are mostly contained within other larger boxes.
+#     """
+#     if not boxes: return []
+    
+#     # [x1, y1, x2, y2, area]
+#     active = []
+#     for b in boxes:
+#         area = (b[2] - b[0]) * (b[3] - b[1])
+#         active.append(list(b) + [area])
+    
+#     # Sort by Area descending (Biggest first)
+#     active.sort(key=lambda x: x[4], reverse=True)
+    
+#     final_boxes = []
+    
+#     for current in active:
+#         is_nested = False
+#         curr_box = current[:4]
+        
+#         # Check if this box is inside any bigger box we already kept
+#         for kept in final_boxes:
+#             overlap_ratio = calculate_iou_containment(curr_box, kept)
+            
+#             if overlap_ratio > containment_thresh:
+#                 is_nested = True
+#                 break
+        
+#         if not is_nested:
+#             final_boxes.append(curr_box)
+            
+#     return final_boxes
+
+
+# # ==========================================
+# # 🧠 LOGIC: STRICT LINE MERGING
+# # ==========================================
+# def merge_boxes_into_lines(raw_boxes, log_data):
+#     """
+#     Merges boxes horizontally but prevents vertical merging.
+#     """
+#     if raw_boxes is None or len(raw_boxes) == 0:
+#         return []
+
+#     # 1. Convert to Rects
+#     rects = []
+#     for box in raw_boxes:
+#         box = np.array(box).astype(np.float32)
+#         x1, y1 = np.min(box[:, 0]), np.min(box[:, 1])
+#         x2, y2 = np.max(box[:, 0]), np.max(box[:, 1])
+#         rects.append([x1, y1, x2, y2])
+
+#     log_data.append(f"Raw Detections: {len(rects)} boxes found.")
+
+#     # 2. Filter Nested
+#     rects = filter_nested_boxes(rects)
+#     log_data.append(f"After Cleaning Nested: {len(rects)} boxes remain.")
+
+#     # 3. Sort by Y-Center (Top to Bottom)
+#     rects.sort(key=lambda r: (r[1] + r[3]) / 2)
+
+#     lines = []
+    
+#     while rects:
+#         # Start a new line with the highest remaining box
+#         current_line = [rects.pop(0)]
+        
+#         # Calculate the dynamic "height" of this line based on the first word
+#         ref_h = current_line[0][3] - current_line[0][1]
+#         ref_y_center = (current_line[0][1] + current_line[0][3]) / 2
+        
+#         # Look for other words on this SAME line
+#         # STRICT RULE: A box is on the same line ONLY if its Y-center 
+#         # is within 50% of the reference box's height.
+#         vertical_tolerance = ref_h * 0.5 
+        
+#         remaining_rects = []
+#         for r in rects:
+#             r_y_center = (r[1] + r[3]) / 2
+            
+#             if abs(r_y_center - ref_y_center) < vertical_tolerance:
+#                 current_line.append(r)
+#             else:
+#                 remaining_rects.append(r)
+        
+#         rects = remaining_rects
+        
+#         # Sort words in this line left-to-right
+#         current_line.sort(key=lambda r: r[0])
+        
+#         # 4. Merge the horizontal group into ONE box
+#         lx1 = min(r[0] for r in current_line)
+#         ly1 = min(r[1] for r in current_line)
+#         lx2 = max(r[2] for r in current_line)
+#         ly2 = max(r[3] for r in current_line)
+        
+#         lines.append([lx1, ly1, lx2, ly2])
+
+#     # Final Sort by Y
+#     lines.sort(key=lambda r: r[1])
+    
+#     log_data.append(f"Final Merged Lines: {len(lines)} lines created.")
+#     return lines
+
+
+# def process_image(image):
+#     logs = [] # Store debug messages here
+    
+#     if image is None: 
+#         return None, [], "Please upload an image.", "No logs."
+    
+#     image_np = np.array(image.convert("RGB"))
+
+#     # DETECT
+#     try:
+#         dt_boxes, _ = detector.text_detector(image_np)
+#     except Exception as e:
+#         return image, [], f"Detection Error: {str(e)}", "\n".join(logs)
+        
+#     if dt_boxes is None or len(dt_boxes) == 0:
+#         return image, [], "No text detected.", "\n".join(logs)
+    
+#     # PROCESS
+#     line_boxes = merge_boxes_into_lines(dt_boxes, logs)
+    
+#     annotated_img = image_np.copy()
+#     results = []
+#     debug_crops = []
+    
+#     # Log the final box coordinates for inspection
+#     logs.append("\n--- Final Box Coordinates ---")
+    
+#     for i, box in enumerate(line_boxes):
+#         x1, y1, x2, y2 = map(int, box)
+        
+#         logs.append(f"Line {i+1}: x={x1}, y={y1}, w={x2-x1}, h={y2-y1}")
+        
+#         # Filter Noise
+#         if (x2 - x1) < 20 or (y2 - y1) < 15:
+#             logs.append(f"-> Skipped Line {i+1} (Too Small/Noise)")
+#             continue
+            
+#         # Draw (Green)
+#         cv2.rectangle(annotated_img, (x1, y1), (x2, y2), (0, 255, 0), 2)
+        
+#         # PADDING
+#         PAD = 10
+#         h, w, _ = image_np.shape
+#         x1 = max(0, x1 - PAD)
+#         y1 = max(0, y1 - PAD)
+#         x2 = min(w, x2 + PAD)
+#         y2 = min(h, y2 + PAD)
+        
+#         crop = image_np[y1:y2, x1:x2]
+#         pil_crop = Image.fromarray(crop)
+#         debug_crops.append(pil_crop)
+        
+#         # RECOGNIZE
+#         with torch.no_grad():
+#             pixel_values = processor(images=pil_crop, return_tensors="pt").pixel_values.to(device)
+#             generated_ids = model.generate(pixel_values)
+#             text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
+#             if text.strip():
+#                 results.append(text)
+
+#     full_text = "\n".join(results)
+#     return Image.fromarray(annotated_img), debug_crops, full_text, "\n".join(logs)
+
+# # --- UI ---
+# with gr.Blocks(theme=gr.themes.Soft()) as demo:
+#     gr.Markdown("# ⚡ Smart Line-Level OCR (Debug Mode)")
+    
+#     with gr.Row():
+#         with gr.Column(scale=1):
+#             input_img = gr.Image(type="pil", label="Upload Image")
+#             btn = gr.Button("Transcribe", variant="primary")
+        
+#         with gr.Column(scale=1):
+#             with gr.Tabs():
+#                 with gr.Tab("Visualization"):
+#                     output_img = gr.Image(label="Detected Lines")
+#                 with gr.Tab("Extracted Text"):
+#                     output_txt = gr.Textbox(label="Result", lines=15, show_copy_button=True)
+#                 with gr.Tab("Debug Logs"):
+#                     # CHANGED HERE: Uses Textbox instead of Code to avoid version errors
+#                     log_output = gr.Textbox(label="Processing Logs", lines=20, interactive=False)
+            
+#     with gr.Row():
+#         gallery = gr.Gallery(label="Final Line Crops", columns=4, height=200)
+
+#     btn.click(process_image, input_img, [output_img, gallery, output_txt, log_output])
+
+# if __name__ == "__main__":
+#     demo.launch()
+
+
+
+
+
+
+
+
+
+
+
+
+
 import gradio as gr
 import torch
 import numpy as np
@@ -823,64 +1074,187 @@ import cv2
 from PIL import Image
 from transformers import TrOCRProcessor, VisionEncoderDecoderModel
 from paddleocr import PaddleOCR
-import pandas as pd
+from sklearn.cluster import DBSCAN
+from scipy.spatial.distance import pdist, squareform
+import warnings
+warnings.filterwarnings('ignore')
 
-# --- 1. SETUP TR-OCR ---
+# ==========================================
+# 🚀 SETUP MODELS
+# ==========================================
 device = "cuda" if torch.cuda.is_available() else "cpu"
 print(f"Loading TrOCR on {device}...")
-processor = TrOCRProcessor.from_pretrained('microsoft/trocr-base-handwritten')
-model = VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-base-handwritten').to(device).eval()
 
-# --- 2. SETUP PADDLEOCR ---
+# Upgraded to TrOCR-Large for better accuracy
+processor = TrOCRProcessor.from_pretrained('microsoft/trocr-large-handwritten')
+model = VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-large-handwritten').to(device).eval()
+
 print("Loading PaddleOCR...")
-# High resolution settings to detect faint text
-detector = PaddleOCR(use_angle_cls=True, lang='en', show_log=False, 
-                     det_limit_side_len=2500, det_db_thresh=0.1, det_db_box_thresh=0.3)
+# Optimized settings for handwriting detection
+detector = PaddleOCR(
+    use_angle_cls=True, 
+    lang='en', 
+    show_log=False,
+    det_limit_side_len=2500,      # High resolution
+    det_db_thresh=0.2,            # More sensitive threshold
+    det_db_box_thresh=0.4,        # Better box filtering
+    det_db_unclip_ratio=1.8       # Larger text regions for handwriting
+)
 
 
 # ==========================================
-# 🧠 LOGIC: INTERSECTION OVER UNION (IOU)
+# 🧠 PREPROCESSING FOR HANDWRITING
 # ==========================================
-def calculate_iou_containment(box1, box2):
+def preprocess_for_handwriting(image_np):
     """
-    Calculates how much of box1 is inside box2.
-    Returns: ratio (0.0 to 1.0)
+    Enhanced preprocessing specifically for handwriting.
+    Returns preprocessed image for better detection.
     """
-    x1 = max(box1[0], box2[0])
-    y1 = max(box1[1], box2[1])
-    x2 = min(box1[2], box2[2])
-    y2 = min(box1[3], box2[3])
+    # Convert to grayscale
+    gray = cv2.cvtColor(image_np, cv2.COLOR_RGB2GRAY)
+    
+    # Apply bilateral filter to reduce noise while preserving edges
+    denoised = cv2.bilateralFilter(gray, 9, 75, 75)
+    
+    # Adaptive thresholding (better for varying lighting)
+    binary = cv2.adaptiveThreshold(
+        denoised, 255, 
+        cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
+        cv2.THRESH_BINARY, 
+        15, 10
+    )
+    
+    # Optional: Deskew the image
+    coords = np.column_stack(np.where(binary > 0))
+    if len(coords) > 0:
+        angle = cv2.minAreaRect(coords)[-1]
+        if angle < -45:
+            angle = -(90 + angle)
+        else:
+            angle = -angle
+        
+        # Only deskew if angle is significant (> 0.5 degrees)
+        if abs(angle) > 0.5:
+            (h, w) = binary.shape
+            center = (w // 2, h // 2)
+            M = cv2.getRotationMatrix2D(center, angle, 1.0)
+            binary = cv2.warpAffine(
+                binary, M, (w, h),
+                flags=cv2.INTER_CUBIC,
+                borderMode=cv2.BORDER_REPLICATE
+            )
     
-    if x2 < x1 or y2 < y1:
-        return 0.0
+    # Convert back to RGB for PaddleOCR
+    return cv2.cvtColor(binary, cv2.COLOR_GRAY2RGB)
+
+
+# ==========================================
+# 🧠 IMPROVED LINE DETECTION WITH DBSCAN
+# ==========================================
+def cluster_boxes_into_lines(raw_boxes, log_data):
+    """
+    Uses DBSCAN clustering to intelligently group text boxes into lines.
+    This handles irregular handwriting baselines much better than rule-based methods.
+    """
+    if raw_boxes is None or len(raw_boxes) == 0:
+        return []
+
+    # 1. Convert PaddleOCR boxes to rectangles
+    rects = []
+    for box in raw_boxes:
+        box = np.array(box).astype(np.float32)
+        x1, y1 = np.min(box[:, 0]), np.min(box[:, 1])
+        x2, y2 = np.max(box[:, 0]), np.max(box[:, 1])
+        rects.append([x1, y1, x2, y2])
+
+    log_data.append(f"✓ Raw Detections: {len(rects)} boxes found.")
+
+    # 2. Filter out noise and very small boxes
+    filtered_rects = []
+    for rect in rects:
+        w = rect[2] - rect[0]
+        h = rect[3] - rect[1]
+        if w > 15 and h > 10:  # Minimum size threshold
+            filtered_rects.append(rect)
     
-    intersection = (x2 - x1) * (y2 - y1)
-    area1 = (box1[2] - box1[0]) * (box1[3] - box1[1])
+    rects = filtered_rects
+    log_data.append(f"✓ After noise filtering: {len(rects)} boxes remain.")
     
-    return intersection / area1
+    if len(rects) == 0:
+        return []
+    
+    # 3. Remove nested/overlapping boxes
+    rects = filter_nested_boxes(rects)
+    log_data.append(f"✓ After removing nested boxes: {len(rects)} boxes remain.")
+
+    # 4. DBSCAN clustering by Y-coordinate
+    # Extract y-centers for clustering
+    y_centers = np.array([(r[1] + r[3]) / 2 for r in rects])
+    
+    # Calculate adaptive epsilon based on median box height
+    heights = np.array([r[3] - r[1] for r in rects])
+    median_height = np.median(heights)
+    
+    # Epsilon: 60% of median height works well for handwriting
+    eps = median_height * 0.6
+    
+    log_data.append(f"✓ Clustering parameters: median_height={median_height:.1f}px, eps={eps:.1f}px")
+    
+    # Perform clustering
+    clustering = DBSCAN(eps=eps, min_samples=1, metric='euclidean')
+    labels = clustering.fit_predict(y_centers.reshape(-1, 1))
+    
+    log_data.append(f"✓ DBSCAN found {len(set(labels))} text lines.")
+
+    # 5. Group boxes by cluster labels
+    lines = []
+    for label in set(labels):
+        # Get all boxes in this cluster
+        line_boxes = [rects[i] for i, l in enumerate(labels) if l == label]
+        
+        # Sort boxes left-to-right within the line
+        line_boxes.sort(key=lambda b: b[0])
+        
+        # Merge into a single bounding box for the entire line
+        x1 = min(b[0] for b in line_boxes)
+        y1 = min(b[1] for b in line_boxes)
+        x2 = max(b[2] for b in line_boxes)
+        y2 = max(b[3] for b in line_boxes)
+        
+        lines.append([x1, y1, x2, y2])
+    
+    # Sort lines top-to-bottom
+    lines.sort(key=lambda r: r[1])
+    
+    log_data.append(f"✓ Final merged lines: {len(lines)} lines created.\n")
+    
+    return lines
+
 
 def filter_nested_boxes(boxes, containment_thresh=0.85):
     """
     Removes boxes that are mostly contained within other larger boxes.
+    This prevents duplicate detections.
     """
-    if not boxes: return []
+    if not boxes: 
+        return []
     
-    # [x1, y1, x2, y2, area]
-    active = []
+    # Add area to each box
+    boxes_with_area = []
     for b in boxes:
         area = (b[2] - b[0]) * (b[3] - b[1])
-        active.append(list(b) + [area])
+        boxes_with_area.append(list(b) + [area])
     
-    # Sort by Area descending (Biggest first)
-    active.sort(key=lambda x: x[4], reverse=True)
+    # Sort by area (largest first)
+    boxes_with_area.sort(key=lambda x: x[4], reverse=True)
     
     final_boxes = []
     
-    for current in active:
+    for current in boxes_with_area:
         is_nested = False
         curr_box = current[:4]
         
-        # Check if this box is inside any bigger box we already kept
+        # Check if this box is contained within any already-kept box
         for kept in final_boxes:
             overlap_ratio = calculate_iou_containment(curr_box, kept)
             
@@ -894,173 +1268,249 @@ def filter_nested_boxes(boxes, containment_thresh=0.85):
     return final_boxes
 
 
-# ==========================================
-# 🧠 LOGIC: STRICT LINE MERGING
-# ==========================================
-def merge_boxes_into_lines(raw_boxes, log_data):
+def calculate_iou_containment(box1, box2):
     """
-    Merges boxes horizontally but prevents vertical merging.
+    Calculates how much of box1 is inside box2.
+    Returns: ratio (0.0 to 1.0)
     """
-    if raw_boxes is None or len(raw_boxes) == 0:
-        return []
-
-    # 1. Convert to Rects
-    rects = []
-    for box in raw_boxes:
-        box = np.array(box).astype(np.float32)
-        x1, y1 = np.min(box[:, 0]), np.min(box[:, 1])
-        x2, y2 = np.max(box[:, 0]), np.max(box[:, 1])
-        rects.append([x1, y1, x2, y2])
-
-    log_data.append(f"Raw Detections: {len(rects)} boxes found.")
-
-    # 2. Filter Nested
-    rects = filter_nested_boxes(rects)
-    log_data.append(f"After Cleaning Nested: {len(rects)} boxes remain.")
+    x1 = max(box1[0], box2[0])
+    y1 = max(box1[1], box2[1])
+    x2 = min(box1[2], box2[2])
+    y2 = min(box1[3], box2[3])
+    
+    if x2 < x1 or y2 < y1:
+        return 0.0
+    
+    intersection = (x2 - x1) * (y2 - y1)
+    area1 = (box1[2] - box1[0]) * (box1[3] - box1[1])
+    
+    if area1 == 0:
+        return 0.0
+    
+    return intersection / area1
 
-    # 3. Sort by Y-Center (Top to Bottom)
-    rects.sort(key=lambda r: (r[1] + r[3]) / 2)
 
-    lines = []
+# ==========================================
+# 🧠 ENHANCED TEXT RECOGNITION
+# ==========================================
+def recognize_text_batch(crops, batch_size=4):
+    """
+    Process multiple crops in batches for better efficiency.
+    """
+    results = []
     
-    while rects:
-        # Start a new line with the highest remaining box
-        current_line = [rects.pop(0)]
-        
-        # Calculate the dynamic "height" of this line based on the first word
-        ref_h = current_line[0][3] - current_line[0][1]
-        ref_y_center = (current_line[0][1] + current_line[0][3]) / 2
+    for i in range(0, len(crops), batch_size):
+        batch_crops = crops[i:i+batch_size]
         
-        # Look for other words on this SAME line
-        # STRICT RULE: A box is on the same line ONLY if its Y-center 
-        # is within 50% of the reference box's height.
-        vertical_tolerance = ref_h * 0.5 
-        
-        remaining_rects = []
-        for r in rects:
-            r_y_center = (r[1] + r[3]) / 2
+        with torch.no_grad():
+            pixel_values = processor(
+                images=batch_crops, 
+                return_tensors="pt"
+            ).pixel_values.to(device)
             
-            if abs(r_y_center - ref_y_center) < vertical_tolerance:
-                current_line.append(r)
-            else:
-                remaining_rects.append(r)
-        
-        rects = remaining_rects
-        
-        # Sort words in this line left-to-right
-        current_line.sort(key=lambda r: r[0])
-        
-        # 4. Merge the horizontal group into ONE box
-        lx1 = min(r[0] for r in current_line)
-        ly1 = min(r[1] for r in current_line)
-        lx2 = max(r[2] for r in current_line)
-        ly2 = max(r[3] for r in current_line)
-        
-        lines.append([lx1, ly1, lx2, ly2])
-
-    # Final Sort by Y
-    lines.sort(key=lambda r: r[1])
+            generated_ids = model.generate(
+                pixel_values,
+                max_length=64,
+                num_beams=4,           # Beam search for better quality
+                early_stopping=True
+            )
+            
+            texts = processor.batch_decode(generated_ids, skip_special_tokens=True)
+            results.extend(texts)
     
-    log_data.append(f"Final Merged Lines: {len(lines)} lines created.")
-    return lines
+    return results
 
 
-def process_image(image):
-    logs = [] # Store debug messages here
+# ==========================================
+# 🎯 MAIN PROCESSING FUNCTION
+# ==========================================
+def process_image(image, use_preprocessing=True):
+    """
+    Main OCR pipeline with optional preprocessing.
+    """
+    logs = []
     
     if image is None: 
-        return None, [], "Please upload an image.", "No logs."
+        return None, [], "⚠️ Please upload an image.", "No logs."
+    
+    logs.append("=" * 50)
+    logs.append("🚀 STARTING OCR PIPELINE")
+    logs.append("=" * 50 + "\n")
     
+    # Convert to numpy array
     image_np = np.array(image.convert("RGB"))
-
-    # DETECT
+    original_image = image_np.copy()
+    
+    # Step 1: Preprocessing
+    if use_preprocessing:
+        logs.append("📝 Step 1: Preprocessing image for handwriting...")
+        preprocessed = preprocess_for_handwriting(image_np)
+        logs.append("✓ Preprocessing complete.\n")
+    else:
+        preprocessed = image_np
+        logs.append("📝 Step 1: Skipping preprocessing (disabled).\n")
+
+    # Step 2: Text Detection
+    logs.append("📝 Step 2: Detecting text regions...")
     try:
-        dt_boxes, _ = detector.text_detector(image_np)
+        dt_boxes, _ = detector.text_detector(preprocessed)
     except Exception as e:
-        return image, [], f"Detection Error: {str(e)}", "\n".join(logs)
+        error_msg = f"❌ Detection Error: {str(e)}"
+        logs.append(error_msg)
+        return image, [], error_msg, "\n".join(logs)
         
     if dt_boxes is None or len(dt_boxes) == 0:
-        return image, [], "No text detected.", "\n".join(logs)
+        error_msg = "⚠️ No text detected in the image."
+        logs.append(error_msg)
+        return image, [], error_msg, "\n".join(logs)
     
-    # PROCESS
-    line_boxes = merge_boxes_into_lines(dt_boxes, logs)
+    # Step 3: Line Clustering
+    logs.append("\n📝 Step 3: Clustering text boxes into lines...")
+    line_boxes = cluster_boxes_into_lines(dt_boxes, logs)
     
-    annotated_img = image_np.copy()
-    results = []
-    debug_crops = []
+    if len(line_boxes) == 0:
+        error_msg = "⚠️ No valid text lines found after filtering."
+        logs.append(error_msg)
+        return image, [], error_msg, "\n".join(logs)
     
-    # Log the final box coordinates for inspection
-    logs.append("\n--- Final Box Coordinates ---")
+    # Step 4: Extract and Recognize
+    logs.append("📝 Step 4: Extracting and recognizing text...\n")
+    logs.append("-" * 50)
+    
+    annotated_img = original_image.copy()
+    debug_crops = []
+    crop_images = []
     
     for i, box in enumerate(line_boxes):
         x1, y1, x2, y2 = map(int, box)
         
-        logs.append(f"Line {i+1}: x={x1}, y={y1}, w={x2-x1}, h={y2-y1}")
+        logs.append(f"Line {i+1}: [{x1}, {y1}, {x2}, {y2}] (w={x2-x1}, h={y2-y1})")
         
-        # Filter Noise
-        if (x2 - x1) < 20 or (y2 - y1) < 15:
-            logs.append(f"-> Skipped Line {i+1} (Too Small/Noise)")
-            continue
-            
-        # Draw (Green)
-        cv2.rectangle(annotated_img, (x1, y1), (x2, y2), (0, 255, 0), 2)
+        # Draw bounding box on visualization
+        color = (0, 255, 0)  # Green
+        cv2.rectangle(annotated_img, (x1, y1), (x2, y2), color, 2)
+        cv2.putText(annotated_img, f"L{i+1}", (x1, y1-5), 
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
         
-        # PADDING
+        # Add padding for better recognition
         PAD = 10
-        h, w, _ = image_np.shape
-        x1 = max(0, x1 - PAD)
-        y1 = max(0, y1 - PAD)
-        x2 = min(w, x2 + PAD)
-        y2 = min(h, y2 + PAD)
+        h, w, _ = original_image.shape
+        x1_pad = max(0, x1 - PAD)
+        y1_pad = max(0, y1 - PAD)
+        x2_pad = min(w, x2 + PAD)
+        y2_pad = min(h, y2 + PAD)
         
-        crop = image_np[y1:y2, x1:x2]
+        # Crop the line
+        crop = original_image[y1_pad:y2_pad, x1_pad:x2_pad]
         pil_crop = Image.fromarray(crop)
+        crop_images.append(pil_crop)
         debug_crops.append(pil_crop)
-        
-        # RECOGNIZE
-        with torch.no_grad():
-            pixel_values = processor(images=pil_crop, return_tensors="pt").pixel_values.to(device)
-            generated_ids = model.generate(pixel_values)
-            text = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
-            if text.strip():
-                results.append(text)
-
+    
+    logs.append("-" * 50)
+    logs.append(f"\n📝 Step 5: Running OCR on {len(crop_images)} line crops...")
+    
+    # Batch recognition
+    recognized_texts = recognize_text_batch(crop_images, batch_size=4)
+    
+    # Filter and log results
+    results = []
+    logs.append("\n" + "=" * 50)
+    logs.append("📄 RECOGNITION RESULTS")
+    logs.append("=" * 50 + "\n")
+    
+    for i, text in enumerate(recognized_texts):
+        text = text.strip()
+        if text:
+            results.append(text)
+            logs.append(f"Line {i+1}: {text}")
+        else:
+            logs.append(f"Line {i+1}: [empty]")
+    
+    # Final output
     full_text = "\n".join(results)
+    
+    logs.append("\n" + "=" * 50)
+    logs.append(f"✅ COMPLETE: {len(results)} lines transcribed.")
+    logs.append("=" * 50)
+    
     return Image.fromarray(annotated_img), debug_crops, full_text, "\n".join(logs)
 
-# --- UI ---
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# ⚡ Smart Line-Level OCR (Debug Mode)")
+
+# ==========================================
+# 🎨 GRADIO UI
+# ==========================================
+with gr.Blocks(theme=gr.themes.Soft(), title="Advanced OCR with DBSCAN") as demo:
+    gr.Markdown("""
+    # 🔬 Advanced Handwriting OCR with DBSCAN Clustering
+    
+    **Improvements:**
+    - 🎯 DBSCAN clustering for intelligent line detection
+    - 🔍 TrOCR-Large model for better accuracy  
+    - 🖼️ Preprocessing pipeline for handwriting
+    - ⚡ Batch processing for efficiency
+    - 📊 Detailed debug logs
+    """)
     
     with gr.Row():
         with gr.Column(scale=1):
-            input_img = gr.Image(type="pil", label="Upload Image")
-            btn = gr.Button("Transcribe", variant="primary")
+            input_img = gr.Image(type="pil", label="📤 Upload Handwritten Image")
+            
+            with gr.Accordion("⚙️ Options", open=False):
+                use_preprocess = gr.Checkbox(
+                    label="Enable preprocessing (denoising, deskewing)", 
+                    value=True,
+                    info="Recommended for photos and low-quality scans"
+                )
+            
+            btn = gr.Button("🚀 Transcribe", variant="primary", size="lg")
         
         with gr.Column(scale=1):
             with gr.Tabs():
-                with gr.Tab("Visualization"):
+                with gr.Tab("🖼️ Visualization"):
                     output_img = gr.Image(label="Detected Lines")
-                with gr.Tab("Extracted Text"):
-                    output_txt = gr.Textbox(label="Result", lines=15, show_copy_button=True)
-                with gr.Tab("Debug Logs"):
-                    # CHANGED HERE: Uses Textbox instead of Code to avoid version errors
-                    log_output = gr.Textbox(label="Processing Logs", lines=20, interactive=False)
-            
+                    gr.Markdown("*Green boxes show detected text lines with line numbers*")
+                
+                with gr.Tab("📝 Extracted Text"):
+                    output_txt = gr.Textbox(
+                        label="Recognized Text", 
+                        lines=15, 
+                        show_copy_button=True,
+                        placeholder="Transcribed text will appear here..."
+                    )
+                
+                with gr.Tab("🔍 Debug Logs"):
+                    log_output = gr.Textbox(
+                        label="Processing Logs", 
+                        lines=20, 
+                        interactive=False
+                    )
+    
     with gr.Row():
-        gallery = gr.Gallery(label="Final Line Crops", columns=4, height=200)
-
-    btn.click(process_image, input_img, [output_img, gallery, output_txt, log_output])
+        gallery = gr.Gallery(
+            label="📸 Line Crops (For Debugging)", 
+            columns=4, 
+            height=200,
+            object_fit="contain"
+        )
+    
+    gr.Markdown("""
+    ---
+    ### 💡 Tips for Best Results:
+    - Upload clear, high-contrast images
+    - Ensure text is not too small (minimum 15px height)
+    - Try enabling/disabling preprocessing based on your image quality
+    - Check debug logs if results are unexpected
+    """)
+
+    # Connect button to processing function
+    btn.click(
+        fn=process_image, 
+        inputs=[input_img, use_preprocess], 
+        outputs=[output_img, gallery, output_txt, log_output]
+    )
 
 if __name__ == "__main__":
     demo.launch()
 
 
 
-
-
-
-
-
-
-