Update app.py

app.py

@@ -1,1534 +1,401 @@
 #!/usr/bin/env python3
 """
-Hugging Face Spaces deployment for SPaCial AI OCR Service
-FastAPI HTTP Server for OCR Service using PaddleOCR
+Client application for SPaCial AI OCR Service
+Enhanced version with full feature support
 """
 
-from fastapi import FastAPI, File, UploadFile, HTTPException, Query, Body
-from fastapi.responses import JSONResponse
-from fastapi.middleware.cors import CORSMiddleware
-import uvicorn
-import cv2
-import numpy as np
-import os
-import tempfile
-import math
-from pathlib import Path
-import logging
-
-# Set up logging first
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Set environment variables BEFORE importing PaddleOCR
-os.environ['PADDLE_PDX_MODEL_SOURCE'] = 'BOS'
-
-# Determine base directory (works for both local and HF Spaces)
-base_dir = os.getenv('HOME', os.getcwd())
-if not os.path.exists(base_dir) or not os.access(base_dir, os.W_OK):
-    # Fallback to current directory if HOME is not writable
-    base_dir = os.getcwd()
-
-# Set paths relative to base directory
-paddle_home = os.path.join(base_dir, '.paddlex')
-paddleocr_home = os.path.join(base_dir, '.paddleocr')
-temp_dir = os.path.join(base_dir, 'temp')
-
-os.environ['PADDLE_HOME'] = paddle_home
-os.environ['PADDLEX_HOME'] = paddle_home
-os.environ['PADDLEOCR_HOME'] = paddleocr_home
-os.environ['TEMP'] = temp_dir
-os.environ['TMP'] = temp_dir
-os.environ['TMPDIR'] = temp_dir
-
-logger.info(f"Using base directory: {base_dir}")
-logger.info(f"PaddleOCR home: {paddleocr_home}")
-
-# Let PaddleOCR auto-detect GPU/CPU (newer versions handle this automatically)
-
-# Create directories with proper permissions for all PaddleOCR models
-try:
-    os.makedirs(paddle_home, mode=0o777, exist_ok=True)
-    os.makedirs(paddleocr_home, mode=0o777, exist_ok=True)
-    os.makedirs(os.path.join(paddleocr_home, 'whl'), mode=0o777, exist_ok=True)
-    
-    # Detection model
-    os.makedirs(os.path.join(paddleocr_home, 'whl', 'det', 'en', 'en_PP-OCRv3_det_infer'), mode=0o777, exist_ok=True)
-    
-    # Recognition model
-    os.makedirs(os.path.join(paddleocr_home, 'whl', 'rec', 'en', 'en_PP-OCRv3_rec_infer'), mode=0o777, exist_ok=True)
-    
-    # Classification model
-    os.makedirs(os.path.join(paddleocr_home, 'whl', 'cls', 'en_ppocr_mobile_v2.0_cls_infer'), mode=0o777, exist_ok=True)
-    
-    os.makedirs(temp_dir, mode=0o777, exist_ok=True)
-    logger.info("Successfully created all PaddleOCR model directories with write permissions")
-except Exception as e:
-    logger.error(f"Failed to create directories: {e}")
-    logger.warning("Continuing with default PaddleOCR paths...")
-
-# Now import PaddleOCR
-from paddleocr import PaddleOCR
-
-
-# Initialize FastAPI app
-app = FastAPI(
-    title="SPaCial AI OCR Service",
-    description="OCR service for dimension detection using PaddleOCR",
-    version="1.0.0"
-)
-
-# Add CORS middleware for HF Spaces
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # Allow all origins for HF Spaces
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Global OCR instance (initialize once at startup)
-ocr = None
-
-def is_dimension_text(text):
-    """Check if text looks like a dimension"""
-    import re
-    # Look for numbers, possibly with units or decimal points
-    if re.search(r'\d+\.?\d*\s*(mm|cm|m|in|inch)?', text.strip(), re.IGNORECASE):
-        return True
-    # Look for pure numbers
-    if re.match(r'^\d+\.?\d*$', text.strip()):
-        return True
-    return False
-
-def parse_tolerance(text):
-    """Parse tolerance information from text with improved patterns"""
-    import re
-    
-    if not text:
-        return None
-    
-    # Clean the text and handle common OCR errors
-    clean_text = text.strip()
-    
-    # Fix common OCR errors
-    clean_text = clean_text.replace('0', 'Ø')  # Fix Ø being read as 0
-    clean_text = clean_text.replace('ØØ', 'Ø')  # Fix double Ø
-    clean_text = clean_text.replace('O', 'Ø')  # Fix O being read as Ø
-    clean_text = clean_text.replace('°', '')   # Remove degree symbols that might interfere
-    clean_text = re.sub(r'\s+', ' ', clean_text)  # Normalize spaces
-    
-    # Pattern 1: ± tolerance (e.g., "28±0.03", "104±0.04", "Ø48±0.03", "28 ± 0.03")
-    plus_minus_match = re.search(r'(?:Ø|DIA|DIAMETER)?\s*(\d+\.?\d*)\s*±\s*(\d+\.?\d*)', clean_text, re.IGNORECASE)
-    if plus_minus_match:
-        value = float(plus_minus_match.group(1))
-        tolerance = float(plus_minus_match.group(2))
-        is_diameter = bool(re.search(r'[ØDIA]', clean_text, re.IGNORECASE))
-        return {
-            "value": value,
-            "tolerance_plus": tolerance,
-            "tolerance_minus": tolerance,
-            "tolerance_type": "±",
-            "is_diameter": is_diameter,
-            "original_text": text
-        }
-    
-    # Pattern 2: +tolerance/-tolerance (e.g., "25.5+0.1/-0.05", "Ø48+0.1/-0.05", "25.5 +0.1 / -0.05")
-    asymmetric_match = re.search(r'(?:Ø|DIA|DIAMETER)?\s*(\d+\.?\d*)\s*\+\s*(\d+\.?\d*)\s*/\s*-\s*(\d+\.?\d*)', clean_text, re.IGNORECASE)
-    if asymmetric_match:
-        value = float(asymmetric_match.group(1))
-        plus_tolerance = float(asymmetric_match.group(2))
-        minus_tolerance = float(asymmetric_match.group(3))
-        is_diameter = bool(re.search(r'[ØDIA]', clean_text, re.IGNORECASE))
-        return {
-            "value": value,
-            "tolerance_plus": plus_tolerance,
-            "tolerance_minus": minus_tolerance,
-            "tolerance_type": "+/-",
-            "is_diameter": is_diameter,
-            "original_text": text
-        }
-    
-    # Pattern 3: Value with negative tolerance only (e.g., "Ø48-0.03", "48 -0.03")
-    negative_only_match = re.search(r'(?:Ø|DIA|DIAMETER)?\s*(\d+\.?\d*)\s*-\s*(\d+\.?\d*)', clean_text, re.IGNORECASE)
-    if negative_only_match:
-        value = float(negative_only_match.group(1))
-        minus_tolerance = float(negative_only_match.group(2))
-        is_diameter = bool(re.search(r'[ØDIA]', clean_text, re.IGNORECASE))
-        return {
-            "value": value,
-            "tolerance_plus": 0.0,
-            "tolerance_minus": minus_tolerance,
-            "tolerance_type": "-only",
-            "is_diameter": is_diameter,
-            "original_text": text
-        }
-    
-    # Pattern 4: Value with positive tolerance only (e.g., "Ø48+0.03", "48 +0.03")
-    positive_only_match = re.search(r'(?:Ø|DIA|DIAMETER)?\s*(\d+\.?\d*)\s*\+\s*(\d+\.?\d*)', clean_text, re.IGNORECASE)
-    if positive_only_match:
-        value = float(positive_only_match.group(1))
-        plus_tolerance = float(positive_only_match.group(2))
-        is_diameter = bool(re.search(r'[ØDIA]', clean_text, re.IGNORECASE))
-        return {
-            "value": value,
-            "tolerance_plus": plus_tolerance,
-            "tolerance_minus": 0.0,
-            "tolerance_type": "+only",
-            "is_diameter": is_diameter,
-            "original_text": text
-        }
-    
-    # Pattern 5: ISO tolerance classes (e.g., "48H7", "25.5f6", "Ø48H7")
-    iso_tolerance_match = re.search(r'(?:Ø|DIA|DIAMETER)?\s*(\d+\.?\d*)\s*([A-Za-z]\d+)', clean_text, re.IGNORECASE)
-    if iso_tolerance_match:
-        value = float(iso_tolerance_match.group(1))
-        tolerance_class = iso_tolerance_match.group(2).upper()
-        is_diameter = bool(re.search(r'[ØDIA]', clean_text, re.IGNORECASE))
-        
-        # Basic ISO tolerance lookup (simplified)
-        iso_tolerances = {
-            'H7': {'plus': 0.025, 'minus': 0.0},
-            'H8': {'plus': 0.039, 'minus': 0.0},
-            'H9': {'plus': 0.062, 'minus': 0.0},
-            'F6': {'plus': 0.0, 'minus': 0.013},
-            'F7': {'plus': 0.0, 'minus': 0.025},
-            'G6': {'plus': 0.0, 'minus': 0.009},
-            'G7': {'plus': 0.0, 'minus': 0.020}
-        }
-        
-        tolerance_info = iso_tolerances.get(tolerance_class, {'plus': 0.0, 'minus': 0.0})
-        
-        return {
-            "value": value,
-            "tolerance_plus": tolerance_info['plus'],
-            "tolerance_minus": tolerance_info['minus'],
-            "tolerance_type": f"ISO {tolerance_class}",
-            "is_diameter": is_diameter,
-            "original_text": text
-        }
-    
-    # Pattern 6: Single value with no tolerance (e.g., "48", "Ø48", "DIA 48")
-    single_value_match = re.search(r'(?:Ø|DIA|DIAMETER)?\s*(\d+\.?\d*)', clean_text, re.IGNORECASE)
-    if single_value_match:
-        value = float(single_value_match.group(1))
-        is_diameter = bool(re.search(r'[ØDIA]', clean_text, re.IGNORECASE))
-        return {
-            "value": value,
-            "tolerance_plus": 0.0,
-            "tolerance_minus": 0.0,
-            "tolerance_type": "none",
-            "is_diameter": is_diameter,
-            "original_text": text
-        }
-    
-    return None
-
-def merge_vertical_text(zones):
-    """Merge nearby vertical text that might have been split by OCR"""
-    if len(zones) < 2:
-        return zones
-    
-    merged_zones = []
-    used_indices = set()
-    
-    for i, zone1 in enumerate(zones):
-        if i in used_indices:
-            continue
-            
-        bbox1 = zone1.get('bbox', [])
-        if len(bbox1) < 4:
-            merged_zones.append(zone1)
-            continue
-            
-        x1_1, y1_1, x2_1, y2_1 = bbox1[0], bbox1[1], bbox1[2], bbox1[3]
-        text1 = zone1.get('text', '')
-        
-        # Look for nearby zones to merge
-        merged_text = text1
-        merged_bbox = [x1_1, y1_1, x2_1, y2_1]
-        
-        for j, zone2 in enumerate(zones[i+1:], i+1):
-            if j in used_indices:
-                continue
-                
-            bbox2 = zone2.get('bbox', [])
-            if len(bbox2) < 4:
-                continue
-                
-            x1_2, y1_2, x2_2, y2_2 = bbox2[0], bbox2[1], bbox2[2], bbox2[3]
-            text2 = zone2.get('text', '')
-            
-            # Check if zones are vertically close and horizontally aligned
-            vertical_distance = abs((y1_1 + y2_1) / 2 - (y1_2 + y2_2) / 2)
-            horizontal_overlap = not (x2_1 < x1_2 or x2_2 < x1_1)
-            
-            # If zones are close vertically and overlap horizontally, merge them
-            if vertical_distance < 30 and horizontal_overlap:
-                # Merge text
-                if y1_2 < y1_1:  # zone2 is above zone1
-                    merged_text = text2 + text1
-                    merged_bbox = [min(x1_1, x1_2), min(y1_1, y1_2), 
-                                 max(x2_1, x2_2), max(y2_1, y2_2)]
-                else:  # zone1 is above zone2
-                    merged_text = text1 + text2
-                    merged_bbox = [min(x1_1, x1_2), min(y1_1, y1_2), 
-                                 max(x2_1, x2_2), max(y2_1, y2_2)]
-                
-                used_indices.add(j)
-                logger.info(f"Merged vertical text: '{text1}' + '{text2}' = '{merged_text}'")
-        
-        # Create merged zone
-        merged_zone = {
-            "id": f"ocr_zone_{len(merged_zones)}",
-            "text": merged_text,
-            "confidence": zone1.get('confidence', 0.9),
-            "bbox": merged_bbox,
-            "x": float(merged_bbox[0]),
-            "y": float(merged_bbox[1]),
-            "width": float(merged_bbox[2] - merged_bbox[0]),
-            "height": float(merged_bbox[3] - merged_bbox[1]),
-            "orientation": zone1.get('orientation', 0),
-            "rotation": 0
-        }
-        
-        merged_zones.append(merged_zone)
-        used_indices.add(i)
-    
-    # Add any remaining zones that weren't merged
-    for i, zone in enumerate(zones):
-        if i not in used_indices:
-            merged_zones.append(zone)
-    
-    logger.info(f"Merged {len(zones)} zones into {len(merged_zones)} zones")
-    return merged_zones
-
-def create_overlay_image(image_path, zones, lines=None, dimension_lines=None):
-    """Create overlay image with bounding boxes and lines (using direct coordinates, no rotation)"""
-    try:
-        # Load original image
-        img = cv2.imread(str(image_path))
-        if img is None:
-            return None
-        
-        # Create overlay with better visualization
-        overlay = img.copy()
-        
-        # Create a separate overlay for semi-transparent rectangles
-        overlay_color = np.zeros_like(img)
-        
-        # Draw lines first (so they appear behind text boxes)
-        if lines:
-            for line in lines:
-                x1, y1, x2, y2 = int(line['x1']), int(line['y1']), int(line['x2']), int(line['y2'])
-                cv2.line(overlay, (x1, y1), (x2, y2), (128, 128, 128), 1)  # Gray lines
-        
-        # Draw dimension lines in different color
-        if dimension_lines:
-            for dim_line in dimension_lines:
-                line = dim_line['closest_line']
-                x1, y1, x2, y2 = int(line['x1']), int(line['y1']), int(line['x2']), int(line['y2'])
-                cv2.line(overlay, (x1, y1), (x2, y2), (0, 255, 255), 2)  # Yellow for dimension lines
-        
-        # Draw clean bounding boxes for each zone
-        for i, zone in enumerate(zones):
-            bbox = zone.get("bbox", {})
-            if not bbox:
-                continue
-            
-            # Extract coordinates with NaN and type safety
-            x1 = bbox.get("x1", 0)
-            y1 = bbox.get("y1", 0)
-            x2 = bbox.get("x2", 0)
-            y2 = bbox.get("y2", 0)
-            
-            # Validate coordinates
-            if not all(isinstance(coord, (int, float)) and not math.isnan(coord) for coord in [x1, y1, x2, y2]):
-                logger.warning(f"Invalid coordinates in zone {i}: x1={x1}, y1={y1}, x2={x2}, y2={y2}")
-                continue
-            
-            # Ensure coordinates are within image bounds
-            x1 = max(0, min(int(x1), img.shape[1] - 1))
-            y1 = max(0, min(int(y1), img.shape[0] - 1))
-            x2 = max(0, min(int(x2), img.shape[1]))
-            y2 = max(0, min(int(y2), img.shape[0]))
-            
-            # Skip if box is too small
-            if x2 - x1 < 1 or y2 - y1 < 1:
-                continue
-            
-            # Color for this zone (cycling through colors)
-            colors = [(0, 255, 0), (255, 0, 0), (0, 0, 255), (255, 255, 0), (255, 0, 255), (0, 255, 255)]
-            color = colors[i % len(colors)]
-            
-            # Draw semi-transparent rectangle
-            cv2.rectangle(overlay_color, 
-                         (x1, y1), 
-                         (x2, y2), 
-                         color, -1)  # Filled rectangle
-            
-            # Draw clean border
-            cv2.rectangle(overlay, 
-                         (x1, y1), 
-                         (x2, y2), 
-                         color, 2)  # Border only
-            
-            # Draw clean text label with background
-            label_text = f"{i+1}. {zone.get('text', '')} ({int(zone.get('confidence', 0)*100)}%)"
-            font_scale = 0.5
-            thickness = 1
-            (text_width, text_height), _ = cv2.getTextSize(label_text, cv2.FONT_HERSHEY_SIMPLEX, font_scale, thickness)
-            
-            # Position label above the box
-            label_x = x1
-            label_y = max(y1 - 10, text_height + 5)
-            
-            # Ensure label is within image bounds
-            if label_y > 0 and label_x >= 0:
-                # Draw text background
-                cv2.rectangle(overlay, 
-                             (label_x - 2, label_y - text_height - 2), 
-                             (label_x + text_width + 2, label_y + 2), 
-                             (255, 255, 255), -1)  # White background
-                
-                # Draw text border for better readability
-                cv2.putText(overlay, label_text, 
-                           (label_x, label_y), 
-                           cv2.FONT_HERSHEY_SIMPLEX, font_scale, (255, 255, 255), thickness + 1)  # White border
-                cv2.putText(overlay, label_text, 
-                           (label_x, label_y), 
-                           cv2.FONT_HERSHEY_SIMPLEX, font_scale, (0, 0, 0), thickness)  # Black text
-        
-        # Blend the colored overlay with the original image
-        alpha = 0.3
-        overlay = cv2.addWeighted(overlay, 1, overlay_color, alpha, 0)
-                    
-        # Save overlay image
-        overlay_path = str(image_path).replace('.', '_overlay.')
-        cv2.imwrite(overlay_path, overlay)
-        
-        return overlay_path
-        
-    except Exception as e:
-        logger.error(f"Error creating overlay: {e}")
-        import traceback
-        logger.error(f"Traceback: {traceback.format_exc()}")
-        return None
-
-def process_image(image_path, mode="fast", rotation=0):
-    """Process a single image and return OCR results with specified mode"""
-    try:
-        # Get image dimensions for coordinate transformation
-        img = cv2.imread(str(image_path))
-        if img is None:
-            logger.error(f"Failed to load image: {image_path}")
-            return {"zones": [], "metadata": {"error": "Failed to load image"}}
-        
-        height, width = img.shape[:2]
-        
-        # Apply rotation if specified
-        if rotation != 0:
-            center = (width // 2, height // 2)
-            rotation_matrix = cv2.getRotationMatrix2D(center, rotation, 1.0)
-            img = cv2.warpAffine(img, rotation_matrix, (width, height))
-            
-            # Save rotated image temporarily
-            rotated_path = str(image_path).replace('.jpg', '_rotated.jpg')
-            cv2.imwrite(rotated_path, img)
-            image_path = rotated_path
-        
-        # Use single OCR model
-        logger.info(f"Processing image with OCR mode: {mode}, rotation: {rotation}")
-        
-        # HARDCORE OCR MODE - aggressive parameters for maximum detection
-        if mode == "accurate" or mode == "hardcore":
-            logger.info("Using HARDCORE OCR parameters for maximum detection")
-            try:
-                result = ocr.ocr(str(image_path), 
-                               det_db_thresh=0.3,      # Lower threshold for detection
-                               det_db_box_thresh=0.5,  # Lower box threshold
-                               det_db_unclip_ratio=1.8, # Higher unclip ratio
-                               rec_batch_num=6,        # More batch processing
-                               use_angle_cls=True,     # Enable angle classification
-                               use_textline_orientation=True,  # Enable text line orientation
-                               lang='en')
-            except Exception as e:
-                logger.warning(f"Hardcore mode failed, falling back to predict: {e}")
-                result = ocr.predict(str(image_path))
+import gradio as gr
+import requests
+from PIL import Image, ImageDraw, ImageFont
+import io
+import json
+from typing import Tuple, Dict, Any, Optional
+
+# API URL for the SPaCial OCR server
+API_URL = "https://cooldan-spacial-server-api.hf.space"
+
+def format_tolerance_info(tolerance_info: Optional[Dict]) -> str:
+    """Format tolerance information for display"""
+    if not tolerance_info:
+        return ""
+    
+    value = tolerance_info.get("value", "")
+    tol_type = tolerance_info.get("tolerance_type", "")
+    is_diameter = tolerance_info.get("is_diameter", False)
+    
+    if tol_type == "none":
+        prefix = "Ø" if is_diameter else ""
+        return f" → {prefix}{value}"
+    elif tol_type == "±":
+        tol = tolerance_info.get("tolerance_plus", 0)
+        prefix = "Ø" if is_diameter else ""
+        return f" → {prefix}{value}±{tol}"
+    elif tol_type == "+/-":
+        plus = tolerance_info.get("tolerance_plus", 0)
+        minus = tolerance_info.get("tolerance_minus", 0)
+        prefix = "Ø" if is_diameter else ""
+        return f" → {prefix}{value}+{plus}/-{minus}"
+    else:
+        return f" → {tol_type}"
+
+def get_orientation_symbol(orientation: int) -> str:
+    """Get symbol for text orientation"""
+    if orientation == 0:
+        return "→"  # Horizontal
+    elif orientation == 90:
+        return "↓"  # Vertical down
+    elif orientation == 180:
+        return "←"  # Horizontal reversed
+    elif orientation == 270:
+        return "↑"  # Vertical up
+    elif orientation == 45:
+        return "↘"  # Diagonal
+    elif orientation == 135:
+        return "↙"  # Diagonal
+    elif orientation == 225:
+        return "↖"  # Diagonal
+    elif orientation == 315:
+        return "↗"  # Diagonal
+    else:
+        return "⊙"  # Other
+
+def get_bbox_color(zone: Dict) -> Tuple[int, int, int]:
+    """Determine bbox color based on zone properties"""
+    is_dimension = zone.get("is_dimension", False)
+    orientation = zone.get("text_orientation", 0)
+    
+    if is_dimension:
+        # Dimensions in blue shades
+        if orientation in [45, 135, 225, 315]:
+            return (0, 100, 255)  # Bright blue for diagonal dimensions
         else:
-            # Use ocr.predict() method (PaddleOCR 2.8+ API)
-            result = ocr.predict(str(image_path))
-        
-        zones = []
-        
-        # Handle both result formats (predict vs ocr)
-        if result and len(result) > 0:
-            # Check if it's predict format (with .json attribute)
-            if hasattr(result[0], 'json'):
-                # Process predict() format
-                for res in result:
-                    if hasattr(res, 'json') and 'res' in res.json:
-                        res_data = res.json['res']
-                        if 'rec_texts' in res_data and 'rec_scores' in res_data:
-                            texts = res_data['rec_texts']
-                            scores = res_data['rec_scores']
-                            dt_polys = res_data.get('dt_polys', [])
-                            text_orientations = res_data.get('textline_orientation_angles', [])
-                            
-                            for i, (text, score) in enumerate(zip(texts, scores)):
-                                if text.strip() and i < len(dt_polys):
-                                    poly = dt_polys[i]
-                                    
-                                    # Convert polygon to bounding box
-                                    x_coords = [p[0] for p in poly]
-                                    y_coords = [p[1] for p in poly]
-                                    x1, x2 = min(x_coords), max(x_coords)
-                                    y1, y2 = min(y_coords), max(y_coords)
-                                    
-                                    # Validate coordinates with NaN checks
-                                    if (math.isnan(x1) or math.isnan(x2) or math.isnan(y1) or math.isnan(y2) or
-                                        x1 >= x2 or y1 >= y2 or x2 - x1 < 1 or y2 - y1 < 1):
-                                        logger.warning(f"Invalid coordinates for text '{text}'")
-                                        continue
-                                    
-                                    # Get text orientation
-                                    text_orientation = 0
-                                    if i < len(text_orientations):
-                                        orientation_angle = text_orientations[i]
-                                        if orientation_angle == 1:
-                                            text_orientation = 90
-                                        elif orientation_angle == 2:
-                                            text_orientation = 180
-                                        elif orientation_angle == 3:
-                                            text_orientation = 270
-                                    
-                                    # Enhanced 45° orientation detection
-                                    if text_orientation == 0 and len(poly) >= 4:
-                                        # Calculate angles of polygon edges
-                                        edge1 = [poly[1][0] - poly[0][0], poly[1][1] - poly[0][1]]
-                                        edge2 = [poly[2][0] - poly[1][0], poly[2][1] - poly[1][1]]
-                                        
-                                        angle1 = math.degrees(math.atan2(edge1[1], edge1[0]))
-                                        angle2 = math.degrees(math.atan2(edge2[1], edge2[0]))
-                                        
-                                        # Normalize to 0-360
-                                        angle1 = (angle1 + 360) % 360
-                                        angle2 = (angle2 + 360) % 360
-                                        
-                                        # Check for 45° patterns (±10° tolerance)
-                                        for angle in [angle1, angle2]:
-                                            if (35 <= angle <= 55):
-                                                text_orientation = 45
-                                                break
-                                            elif (125 <= angle <= 145):
-                                                text_orientation = 135
-                                                break
-                                            elif (215 <= angle <= 235):
-                                                text_orientation = 225
-                                                break
-                                            elif (305 <= angle <= 325):
-                                                text_orientation = 315
-                                                break
-                                    
-                                    # Create zone with consistent bbox structure
-                                    zone = {
-                                        "id": f"ocr_zone_{i}",
-                                        "text": text,
-                                        "confidence": float(score),
-                                        "bbox": {
-                                            "x1": int(x1),
-                                            "y1": int(y1),
-                                            "x2": int(x2),
-                                            "y2": int(y2),
-                                            "width": int(x2 - x1),
-                                            "height": int(y2 - y1)
-                                        },
-                                        "polygon": poly,
-                                        "text_orientation": text_orientation,
-                                        "is_dimension": is_dimension_text(text),
-                                        "tolerance_info": parse_tolerance(text)
-                                    }
-                                    zones.append(zone)
-            else:
-                # Process ocr() format: [[[bbox, (text, confidence)], ...]]
-                for line in result:
-                    if line:
-                        for item in line:
-                            if len(item) >= 2:
-                                bbox = item[0]
-                                text_info = item[1]
-                                
-                                # Handle text that might be tuple or string
-                                if isinstance(text_info, (tuple, list)) and len(text_info) >= 2:
-                                    text = text_info[0]
-                                    confidence = text_info[1]
-                                elif isinstance(text_info, str):
-                                    text = text_info
-                                    confidence = 0.9
-                                else:
-                                    continue
-                                
-                                if isinstance(text, str) and text.strip():
-                                    # Extract coordinates from bbox
-                                    x_coords = [point[0] for point in bbox]
-                                    y_coords = [point[1] for point in bbox]
-                                    x1, x2 = min(x_coords), max(x_coords)
-                                    y1, y2 = min(y_coords), max(y_coords)
-                                    
-                                    # Validate with NaN checks
-                                    if (math.isnan(x1) or math.isnan(x2) or math.isnan(y1) or math.isnan(y2) or
-                                        x1 >= x2 or y1 >= y2 or x2 - x1 < 1 or y2 - y1 < 1):
-                                        continue
-                                    
-                                    # Basic orientation detection
-                                    text_orientation = 0
-                                    width_bbox = x2 - x1
-                                    height_bbox = y2 - y1
-                                    if height_bbox > width_bbox * 1.5:
-                                        text_orientation = 90
-                                    
-                                    # Create zone
-                                    zone = {
-                                        "id": f"ocr_zone_{len(zones)}",
-                                        "text": text,
-                                        "confidence": float(confidence),
-                                        "bbox": {
-                                            "x1": int(x1),
-                                            "y1": int(y1),
-                                            "x2": int(x2),
-                                            "y2": int(y2),
-                                            "width": int(x2 - x1),
-                                            "height": int(y2 - y1)
-                                        },
-                                        "polygon": bbox,
-                                        "text_orientation": text_orientation,
-                                        "is_dimension": is_dimension_text(text),
-                                        "tolerance_info": parse_tolerance(text)
-                                    }
-                                    zones.append(zone)
-        
-        # Create overlay image with bounding boxes
-        overlay_path = create_overlay_image(image_path, zones)
-        
-        # Clean up rotated image if created
-        if rotation != 0 and os.path.exists(str(image_path)) and '_rotated' in str(image_path):
-            try:
-                os.unlink(str(image_path))
-            except:
-                pass
-        
-        return {
-            "zones": zones,
-            "metadata": {
-                "total_zones": len(zones),
-                "overlay_path": overlay_path,
-                "detected_angle": 0
-            }
-        }
-        
-    except Exception as e:
-        logger.error(f"Error processing image: {e}")
-        import traceback
-        logger.error(f"Traceback: {traceback.format_exc()}")
-        return {
-            "zones": [],
-            "metadata": {"error": str(e)}
-        }
+            return (0, 0, 255)  # Standard blue for dimensions
+    else:
+        # Regular text in green shades
+        if orientation in [90, 270]:
+            return (0, 200, 0)  # Bright green for vertical text
+        elif orientation in [45, 135, 225, 315]:
+            return (100, 255, 100)  # Light green for diagonal text
+        else:
+            return (0, 255, 0)  # Standard green for horizontal text
 
-@app.on_event("startup")
-async def startup_event():
-    """Initialize PaddleOCR models on startup"""
-    global ocr
-    logger.info("Initializing PaddleOCR model...")
+def client_process_ocr(pil_img: Image.Image, mode: str = "fast", rotation: int = 0) -> Tuple[Image.Image, str, str]:
+    """
+    Function that sends the image to the FastAPI server for OCR processing.
     
-    # Single OCR instance (auto GPU detection for newer PaddleOCR)
-    try:
-        logger.info("Initializing PaddleOCR with auto GPU detection...")
-        ocr = PaddleOCR(
-            use_doc_orientation_classify=False,  # Disable for better performance
-            use_doc_unwarping=False,
-            use_textline_orientation=True,  # Enable text line orientation
-            lang='en'
-        )
-        logger.info("PaddleOCR initialized successfully with auto GPU detection!")
-    except Exception as error:
-        logger.error(f"PaddleOCR initialization failed: {error}")
-        raise
+    Args:
+        pil_img: PIL Image object
+        mode: OCR mode ('fast', 'accurate', or 'hardcore')
+        rotation: Rotation angle in degrees (0, 90, 180, 270)
     
-    logger.info("PaddleOCR initialized successfully!")
-
-@app.get("/")
-async def root():
-    """Health check endpoint"""
-    return {
-        "message": "SPaCial AI OCR Service",
-        "status": "running",
-        "ocr_initialized": ocr is not None,
-        "service": "SPaCial AI OCR Service",
-        "version": "1.0.0"
-    }
-
-@app.post("/ocr/process")
-async def process_ocr(
-    file: UploadFile = File(...), 
-    mode: str = Query("fast", description="OCR mode: 'fast' for position detection, 'accurate' or 'hardcore' for maximum text detection"),
-    rotation: int = Query(0, description="Rotation angle in degrees (0, 90, 180, 270)")
-):
+    Returns:
+        Tuple of (processed_image, extracted_text, statistics)
     """
-    Process uploaded image with OCR
-    Returns detected zones with bounding boxes and text
     
-    Parameters:
-    - file: Image file to process
-    - mode: 'fast' (default) or 'accurate'/'hardcore' for maximum detection
-    - rotation: Rotation angle in degrees (0, 90, 180, 270)
-    """
-    if ocr is None:
-        raise HTTPException(status_code=503, detail="OCR service not initialized")
+    if pil_img is None:
+        return None, "Please upload an image first.", ""
     
-    # Validate file type
-    if not file.content_type or not file.content_type.startswith('image/'):
-        raise HTTPException(status_code=400, detail="File must be an image")
+    # 1. Prepare the Image for POST Request
+    img_byte_arr = io.BytesIO()
+    # Save the image in JPEG format in memory
+    pil_img.save(img_byte_arr, format='JPEG')
+    img_byte_arr.seek(0)
     
-    # Save uploaded file to temporary location
-    with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as temp_file:
-        content = await file.read()
-        temp_file.write(content)
-        temp_path = temp_file.name
+    # Prepare data for submission (multipart/form-data)
+    files = {'file': ('image.jpg', img_byte_arr, 'image/jpeg')}
     
-    try:
-        logger.info(f"Processing image: {temp_path}, mode: {mode}, rotation: {rotation}")
-        
-        # Process image with specified mode and rotation
-        result = process_image(temp_path, mode, rotation)
-        
-        logger.info(f"OCR result: {len(result.get('zones', []))} zones found")
-        
-        # Clean up temporary file
-        os.unlink(temp_path)
-        
-        return JSONResponse(content=result)
-        
-    except Exception as e:
-        # Clean up temporary file on error
-        if os.path.exists(temp_path):
-            os.unlink(temp_path)
-        
-        logger.error(f"Error processing uploaded file: {e}")
-        import traceback
-        logger.error(f"Traceback: {traceback.format_exc()}")
-        raise HTTPException(status_code=500, detail=f"Error processing image: {str(e)}")
-
-@app.post("/ocr/process-path")
-async def process_ocr_path(image_path: str = Query(...), mode: str = Query("fast", description="OCR mode: 'fast' for position detection, 'accurate' for hard text search")):
-    """
-    Process image from file path
-    Returns detected zones with bounding boxes and text
-    """
-    if ocr is None:
-        raise HTTPException(status_code=503, detail="OCR service not initialized")
+    # The processing endpoint is "/ocr/process"
+    endpoint_url = f"{API_URL}/ocr/process"
     
-    if not os.path.exists(image_path):
-        raise HTTPException(status_code=404, detail="Image file not found")
+    # Add query parameters
+    params = {
+        'mode': mode,
+        'rotation': rotation
+    }
     
     try:
-        result = process_image(image_path, mode)
-        return JSONResponse(content=result)
-        
-    except Exception as e:
-        logger.error(f"Error processing image path: {e}")
-        raise HTTPException(status_code=500, detail=f"Error processing image: {str(e)}")
-
-@app.post("/ocr/process-center")
-async def process_center_point(request: dict = Body(...)):
-    """Process center point to find dimension and fit box to text"""
-    try:
-        # Extract data from request
-        image_data = request.get('image', '')
-        center_point = request.get('center_point', {})
-        center_x = center_point.get('x', 0)
-        center_y = center_point.get('y', 0)
-        
-        if not image_data:
-            raise HTTPException(status_code=400, detail="No image data provided")
-        
-        # Decode base64 image
-        import base64
-        if image_data.startswith('data:image'):
-            image_data = image_data.split(',')[1]
-        
-        image_bytes = base64.b64decode(image_data)
-        
-        # Save temporary image
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as tmp_file:
-            tmp_file.write(image_bytes)
-            tmp_path = tmp_file.name
-        
-        try:
-            # Process image with OCR
-            result = process_image(tmp_path, mode="fast")
-            
-            if not result or not result.get('zones'):
-                return {"zones": [], "message": "No text detected"}
-            
-            # Find the closest zone to the center point
-            zones = result['zones']
-            closest_zone = None
-            min_distance = float('inf')
-            
-            for zone in zones:
-                bbox = zone.get('bbox', {})
-                if not bbox:
-                    continue
-                
-                # Calculate zone center
-                zone_center_x = (bbox.get('x1', 0) + bbox.get('x2', 0)) / 2
-                zone_center_y = (bbox.get('y1', 0) + bbox.get('y2', 0)) / 2
-                
-                # Calculate distance to clicked point
-                distance = ((center_x - zone_center_x) ** 2 + (center_y - zone_center_y) ** 2) ** 0.5
-                
-                if distance < min_distance:
-                    min_distance = distance
-                    closest_zone = zone
-            
-            # If we found a close zone, return it
-            if closest_zone and min_distance < 100:  # Within 100 pixels
-                # Ensure we return the zone with proper bbox coordinates
-                zone_bbox = closest_zone.get('bbox', {})
-                if isinstance(zone_bbox, dict):
-                    # Return zone with image coordinates
-                    return {
-                        "zone": {
-                            "text": closest_zone.get('text', ''),
-                            "confidence": closest_zone.get('confidence', 0),
-                            "bbox": zone_bbox,
-                            "x": zone_bbox.get('x1', 0),
-                            "y": zone_bbox.get('y1', 0),
-                            "width": zone_bbox.get('width', 0),
-                            "height": zone_bbox.get('height', 0),
-                            "tolerance_info": closest_zone.get('tolerance_info', {})
-                        },
-                        "message": f"Found dimension at center point (distance: {min_distance:.1f}px)",
-                        "center_point": {"x": center_x, "y": center_y},
-                        "found_zone": closest_zone.get('text', ''),
-                        "fitted": True
-                    }
-                else:
-                    return {
-                        "zone": closest_zone,
-                        "message": f"Found dimension at center point (distance: {min_distance:.1f}px)",
-                        "center_point": {"x": center_x, "y": center_y},
-                        "found_zone": closest_zone.get('text', ''),
-                        "fitted": True
-                    }
-            else:
-                return {
-                    "zones": [],
-                    "message": f"No dimension found near center point (closest: {min_distance:.1f}px)",
-                    "center_point": {"x": center_x, "y": center_y}
-                }
-                
-        finally:
-            # Clean up temporary file
-            if os.path.exists(tmp_path):
-                os.unlink(tmp_path)
-                
-    except Exception as e:
-        logger.error(f"Error processing center point: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/ocr/process-with-lines")
-async def process_with_lines(request: dict = Body(...)):
-    """Process image with OCR and detect dimension lines"""
-    try:
-        # Extract data from request
-        image_data = request.get('image', '')
-        
-        if not image_data:
-            raise HTTPException(status_code=400, detail="No image data provided")
-        
-        # Decode base64 image
-        import base64
-        if image_data.startswith('data:image'):
-            image_data = image_data.split(',')[1]
-        
-        image_bytes = base64.b64decode(image_data)
+        gr.Info(f"Sending image to OCR server (mode: {mode}, rotation: {rotation}°)...")
         
-        # Save temporary image
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as tmp_file:
-            tmp_file.write(image_bytes)
-            tmp_path = tmp_file.name
+        # 2. Send HTTP POST Request
+        response = requests.post(endpoint_url, files=files, params=params, timeout=60)
         
-        try:
-            # Process image with OCR
-            result = process_image(tmp_path, mode="fast")
-            
-            if not result or not result.get('zones'):
-                return {"zones": [], "lines": [], "dimension_lines": [], "message": "No text detected"}
-            
-            # Detect lines in the image
-            detected_lines = detect_dimension_lines(tmp_path)
-            
-            # Find lines near dimensions
-            dimension_lines = find_lines_near_dimensions(result['zones'], detected_lines)
-            
-            # Create overlay image with lines
-            overlay_image = create_overlay_image(tmp_path, result['zones'], detected_lines, dimension_lines)
-            
-            # Convert overlay to base64
-            overlay_base64 = None
-            if overlay_image is not None:
-                import base64
-                _, buffer = cv2.imencode('.jpg', overlay_image)
-                overlay_base64 = base64.b64encode(buffer).decode('utf-8')
-            
-            return {
-                "zones": result['zones'],
-                "lines": detected_lines,
-                "dimension_lines": dimension_lines,
-                "overlay_image": overlay_base64,
-                "message": f"Found {len(result['zones'])} text zones, {len(detected_lines)} lines, {len(dimension_lines)} dimension-line pairs"
-            }
-                
-        finally:
-            # Clean up temporary file
-            if os.path.exists(tmp_path):
-                os.unlink(tmp_path)
-                
-    except Exception as e:
-        logger.error(f"Error processing image with lines: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+        # Check status code
+        if response.status_code != 200:
+            return pil_img, f"Server Error ({response.status_code}): {response.text}", ""
 
-@app.post("/ocr/get-text-properties")
-async def get_text_properties(request: dict = Body(...)):
-    """Get original text properties for precise box fitting"""
-    try:
-        # Extract data from request
-        image_data = request.get('image', '')
-        bbox = request.get('bbox', {})
-        
-        if not image_data or not bbox:
-            raise HTTPException(status_code=400, detail="Image data and bbox required")
-        
-        # Decode base64 image
-        import base64
-        if image_data.startswith('data:image'):
-            image_data = image_data.split(',')[1]
-        
-        image_bytes = base64.b64decode(image_data)
+        # 3. Process JSON Response
+        result_data = response.json()
         
-        # Save temporary image
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as tmp_file:
-            tmp_file.write(image_bytes)
-            tmp_path = tmp_file.name
+        # Extract zones and metadata
+        zones = result_data.get("zones", [])
+        metadata = result_data.get("metadata", {})
         
-        try:
-            # Process image with OCR
-            result = process_image(tmp_path, mode="fast")
-            
-            if not result or not result.get('zones'):
-                return {"error": "No text detected"}
-            
-            # Find the zone that matches the bbox
-            target_zone = None
-            for zone in result['zones']:
-                zone_bbox = zone.get('bbox', {})
-                if (isinstance(zone_bbox, dict) and 
-                    abs(zone_bbox.get('x1', 0) - bbox.get('x1', 0)) < 10 and
-                    abs(zone_bbox.get('y1', 0) - bbox.get('y1', 0)) < 10):
-                    target_zone = zone
-                    break
-            
-            if not target_zone:
-                return {"error": "Matching zone not found"}
-            
-            # Extract text properties
-            text_properties = {
-                "text": target_zone.get('text', ''),
-                "confidence": target_zone.get('confidence', 0),
-                "bbox": target_zone.get('bbox', {}),
-                "orientation": target_zone.get('orientation', 0),
-                "rotation": target_zone.get('rotation', 0),
-                "width": target_zone.get('width', 0),
-                "height": target_zone.get('height', 0)
-            }
-            
-            return text_properties
-                
-        finally:
-            # Clean up temporary file
-            if os.path.exists(tmp_path):
-                os.unlink(tmp_path)
-                
-    except Exception as e:
-        logger.error(f"Error getting text properties: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@app.post("/ocr/process-baseline")
-async def process_baseline(request: dict = Body(...)):
-    """Process baseline to find text and fit precise box"""
-    try:
-        # Extract data from request
-        image_data = request.get('image', '')
-        baseline = request.get('baseline', {})
-        x1 = baseline.get('x1', 0)
-        y1 = baseline.get('y1', 0)
-        x2 = baseline.get('x2', 0)
-        y2 = baseline.get('y2', 0)
-        
-        if not image_data:
-            raise HTTPException(status_code=400, detail="No image data provided")
+        if not zones:
+            return pil_img, "No text detected in image.", f"Total zones: 0"
         
-        # Decode base64 image
-        import base64
-        if image_data.startswith('data:image'):
-            image_data = image_data.split(',')[1]
+        # 4. Draw Bounding Boxes on Image
+        draw_img = pil_img.copy()
+        draw = ImageDraw.Draw(draw_img, 'RGBA')
         
-        image_bytes = base64.b64decode(image_data)
+        # Statistics counters
+        stats = {
+            'total': len(zones),
+            'dimensions': 0,
+            'with_tolerance': 0,
+            'horizontal': 0,
+            'vertical': 0,
+            'diagonal': 0
+        }
         
-        # Save temporary image
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as tmp_file:
-            tmp_file.write(image_bytes)
-            tmp_path = tmp_file.name
+        full_text_output = []
         
-        try:
-            # Process full image with OCR
-            result = process_image(tmp_path, mode="fast")
-            
-            if not result or not result.get('zones'):
-                return {"zones": [], "message": "No text detected"}
-            
-            # Find text zones that intersect with the baseline
-            zones = result['zones']
-            intersecting_zones = []
-            
-            for zone in zones:
-                bbox = zone.get('bbox', {})
-                if not bbox:
-                    continue
-                
-                # Check if zone intersects with baseline
-                if intersects_with_line(bbox, x1, y1, x2, y2):
-                    # Calculate distance from zone center to baseline
-                    zone_center_x = (bbox.get('x1', 0) + bbox.get('x2', 0)) / 2
-                    zone_center_y = (bbox.get('y1', 0) + bbox.get('y2', 0)) / 2
-                    distance = distance_point_to_line(zone_center_x, zone_center_y, x1, y1, x2, y2)
-                    
-                    intersecting_zones.append({
-                        'zone': zone,
-                        'distance': distance
-                    })
-            
-            # Sort by distance to baseline (closest first)
-            intersecting_zones.sort(key=lambda x: x['distance'])
-            
-            if intersecting_zones:
-                # Return the closest zone
-                closest = intersecting_zones[0]
-                zone = closest['zone']
-                zone_bbox = zone.get('bbox', {})
+        for i, zone in enumerate(zones):
+            text = zone.get("text", "")
+            confidence = zone.get("confidence", 0.0)
+            bbox = zone.get("bbox", {})
+            is_dimension = zone.get("is_dimension", False)
+            tolerance_info = zone.get("tolerance_info")
+            orientation = zone.get("text_orientation", 0)
+            
+            # Update statistics
+            if is_dimension:
+                stats['dimensions'] += 1
+            if tolerance_info and tolerance_info.get("tolerance_type") != "none":
+                stats['with_tolerance'] += 1
+            if orientation in [0, 180]:
+                stats['horizontal'] += 1
+            elif orientation in [90, 270]:
+                stats['vertical'] += 1
+            elif orientation in [45, 135, 225, 315]:
+                stats['diagonal'] += 1
+            
+            # Text formatting for output
+            prefix = "📐" if is_dimension else "📝"
+            orientation_symbol = get_orientation_symbol(orientation)
+            tolerance_str = format_tolerance_info(tolerance_info)
+            
+            full_text_output.append(
+                f"{i+1}. {prefix} {orientation_symbol} [{confidence:.2f}] {text}{tolerance_str}"
+            )
+            
+            # Draw BBox with color coding
+            if bbox:
+                # Fixed: bbox is always dict format from updated server
+                x1 = bbox.get("x1", 0)
+                y1 = bbox.get("y1", 0)
+                x2 = bbox.get("x2", 0)  # ✅ FIXED: was x2 before
+                y2 = bbox.get("y2", 0)  # ✅ FIXED: was x2 (BUG!)
                 
-                # Ensure we return the zone with proper bbox coordinates
-                if isinstance(zone_bbox, dict):
-                    return {
-                        "zone": {
-                            "text": zone.get('text', ''),
-                            "confidence": zone.get('confidence', 0),
-                            "bbox": zone_bbox,
-                            "x": zone_bbox.get('x1', 0),
-                            "y": zone_bbox.get('y1', 0),
-                            "width": zone_bbox.get('width', 0),
-                            "height": zone_bbox.get('height', 0),
-                            "tolerance_info": zone.get('tolerance_info', {})
-                        },
-                        "message": f"Found text along baseline (distance: {closest['distance']:.1f}px)",
-                        "baseline": {"x1": x1, "y1": y1, "x2": x2, "y2": y2},
-                        "found_zone": zone.get('text', ''),
-                        "fitted": True
-                    }
-                else:
-                    return {
-                        "zone": zone,
-                        "message": f"Found text along baseline (distance: {closest['distance']:.1f}px)",
-                        "baseline": {"x1": x1, "y1": y1, "x2": x2, "y2": y2},
-                        "found_zone": zone.get('text', ''),
-                        "fitted": True
-                    }
-            else:
-                return {
-                    "zones": [],
-                    "message": "No text found along baseline",
-                    "baseline": {"x1": x1, "y1": y1, "x2": x2, "y2": y2}
-                }
+                # Get color based on zone type
+                color = get_bbox_color(zone)
                 
-        finally:
-            # Clean up temporary file
-            if os.path.exists(tmp_path):
-                os.unlink(tmp_path)
+                # Draw semi-transparent filled rectangle
+                draw.rectangle([(x1, y1), (x2, y2)], outline=color, width=3)
                 
-    except Exception as e:
-        logger.error(f"Error processing baseline: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-def intersects_with_line(bbox, x1, y1, x2, y2):
-    """Check if bounding box intersects with line"""
-    bx1, by1 = bbox.get('x1', 0), bbox.get('y1', 0)
-    bx2, by2 = bbox.get('x2', 0), bbox.get('y2', 0)
-    
-    # Check if any corner of the box is close to the line
-    corners = [(bx1, by1), (bx2, by1), (bx2, by2), (bx1, by2)]
-    
-    for cx, cy in corners:
-        distance = distance_point_to_line(cx, cy, x1, y1, x2, y2)
-        if distance < 20:  # Within 20 pixels
-            return True
-    
-    return False
-
-def distance_point_to_line(px, py, x1, y1, x2, y2):
-    """Calculate distance from point to line"""
-    # Line vector
-    line_dx = x2 - x1
-    line_dy = y2 - y1
-    
-    # Point vector
-    point_dx = px - x1
-    point_dy = py - y1
-    
-    # Calculate distance using cross product
-    if line_dx == 0 and line_dy == 0:
-        # Line is a point
-        return ((px - x1) ** 2 + (py - y1) ** 2) ** 0.5
-    
-    # Distance = |cross_product| / |line_vector|
-    cross_product = abs(point_dx * line_dy - point_dy * line_dx)
-    line_length = (line_dx ** 2 + line_dy ** 2) ** 0.5
-    
-    return cross_product / line_length
-
-def detect_dimension_lines(image_path):
-    """Detect lines in the image that could be dimension lines"""
-    import cv2
-    import numpy as np
-    
-    # Read image
-    img = cv2.imread(image_path)
-    if img is None:
-        return []
-    
-    # Convert to grayscale
-    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-    
-    # Apply edge detection
-    edges = cv2.Canny(gray, 50, 150, apertureSize=3)
-    
-    # Detect lines using HoughLinesP
-    lines = cv2.HoughLinesP(edges, 1, np.pi/180, threshold=50, minLineLength=30, maxLineGap=10)
-    
-    detected_lines = []
-    if lines is not None:
-        for line in lines:
-            x1, y1, x2, y2 = line[0]
-            length = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5
-            
-            # Filter out very short lines
-            if length > 20:
-                # Calculate angle
-                angle = math.atan2(y2 - y1, x2 - x1) * 180 / math.pi
-                if angle < 0:
-                    angle += 180
+                # Draw zone number
+                try:
+                    # Try to use a font, fallback to default
+                    font = ImageFont.truetype("arial.ttf", 14)
+                except:
+                    font = ImageFont.load_default()
                 
-                detected_lines.append({
-                    'x1': float(x1),
-                    'y1': float(y1),
-                    'x2': float(x2),
-                    'y2': float(y2),
-                    'length': float(length),
-                    'angle': float(angle)
-                })
-    
-    return detected_lines
-
-def find_lines_near_dimensions(zones, lines, max_distance=50):
-    """Find lines that are close to dimension text"""
-    dimension_lines = []
-    
-    for zone in zones:
-        bbox = zone.get('bbox', {})
-        if not bbox:
-            continue
-        
-        # Get zone center
-        zone_center_x = (bbox.get('x1', 0) + bbox.get('x2', 0)) / 2
-        zone_center_y = (bbox.get('y1', 0) + bbox.get('y2', 0)) / 2
-        
-        # Find closest lines
-        nearby_lines = []
-        for line in lines:
-            distance = distance_point_to_line(zone_center_x, zone_center_y, 
-                                            line['x1'], line['y1'], line['x2'], line['y2'])
-            
-            if distance < max_distance:
-                nearby_lines.append({
-                    'line': line,
-                    'distance': distance
-                })
-        
-        # Sort by distance
-        nearby_lines.sort(key=lambda x: x['distance'])
+                # Draw label background
+                label = f"{i+1}"
+                bbox_label = draw.textbbox((x1, y1 - 20), label, font=font)
+                draw.rectangle(bbox_label, fill=(255, 255, 255, 200))
+                draw.text((x1, y1 - 20), label, fill=color, font=font)
+        
+        gr.Info(f"Processing completed. Found {len(zones)} text zones.")
+        
+        # Create statistics string
+        stats_str = f"""📊 **Statistics:**
+- Total zones: {stats['total']}
+- Dimensions: {stats['dimensions']} 📐
+- With tolerances: {stats['with_tolerance']} ±
+- Horizontal: {stats['horizontal']} →
+- Vertical: {stats['vertical']} ↓
+- Diagonal: {stats['diagonal']} ↘
+
+🎯 **Metadata:**
+- Detected angle: {metadata.get('detected_angle', 0)}°
+"""
         
-        if nearby_lines:
-            dimension_lines.append({
-                'zone': zone,
-                'closest_line': nearby_lines[0]['line'],
-                'distance': nearby_lines[0]['distance'],
-                'all_nearby_lines': [nl['line'] for nl in nearby_lines[:3]]  # Top 3 closest
-            })
-    
-    return dimension_lines
-
-# Telegram Bot Integration
-import requests
-import json
-from fastapi import Request
-from fastapi.responses import FileResponse
-from fastapi.staticfiles import StaticFiles
-
-# Mount static files
-app.mount("/static", StaticFiles(directory="static"), name="static")
+        # Return the drawn image, text, and stats
+        return draw_img, "\n".join(full_text_output), stats_str
 
-def send_telegram_message(message, chat_id=None):
-    """Send message to Telegram"""
-    bot_token = os.getenv('TELEGRAM_BOT_TOKEN')
-    if not bot_token:
-        return False
-    
-    target_chat_id = chat_id or os.getenv('TELEGRAM_CHAT_ID')
-    if not target_chat_id:
-        return False
-    
-    # Try multiple Telegram API endpoints for better connectivity
-    api_urls = [
-        "https://api.telegram.org",
-        "https://api.telegram.org:443"
-    ]
+    except requests.exceptions.Timeout:
+        return pil_img, f"Timeout Error: Server took too long to respond (>60s).", ""
     
-    for api_url in api_urls:
-        try:
-            url = f"{api_url}/bot{bot_token}/sendMessage"
-            data = {
-                'chat_id': target_chat_id,
-                'text': message,
-                'parse_mode': 'Markdown'
-            }
-            
-            # Add timeout and retry logic
-            session = requests.Session()
-            session.timeout = 10
-            
-            response = session.post(url, data=data, timeout=10)
-            if response.status_code == 200:
-                logger.info(f"Successfully sent Telegram message via {api_url}")
-                return True
-                
-        except Exception as e:
-            logger.warning(f"Failed to send via {api_url}: {e}")
-            continue
-    
-    logger.error("Failed to send Telegram message via all endpoints")
-    return False
-
-def send_telegram_photo(image_path, caption="", chat_id=None):
-    """Send photo to Telegram"""
-    bot_token = os.getenv('TELEGRAM_BOT_TOKEN')
-    if not bot_token:
-        return False
-    
-    target_chat_id = chat_id or os.getenv('TELEGRAM_CHAT_ID')
-    if not target_chat_id:
-        return False
-    
-    url = f"https://api.telegram.org/bot{bot_token}/sendPhoto"
-    
-    try:
-        with open(image_path, 'rb') as photo:
-            files = {'photo': photo}
-            data = {
-                'chat_id': target_chat_id,
-                'caption': caption
-            }
-            response = requests.post(url, files=files, data=data)
-            return response.status_code == 200
-    except Exception as e:
-        logger.error(f"Failed to send Telegram photo: {e}")
-        return False
-
-def send_telegram_document(file_path, caption="", chat_id=None):
-    """Send document to Telegram"""
-    bot_token = os.getenv('TELEGRAM_BOT_TOKEN')
-    if not bot_token:
-        return False
-    
-    target_chat_id = chat_id or os.getenv('TELEGRAM_CHAT_ID')
-    if not target_chat_id:
-        return False
-    
-    url = f"https://api.telegram.org/bot{bot_token}/sendDocument"
-    
-    try:
-        with open(file_path, 'rb') as document:
-            files = {'document': document}
-            data = {
-                'chat_id': target_chat_id,
-                'caption': caption
-            }
-            response = requests.post(url, files=files, data=data)
-            return response.status_code == 200
-    except Exception as e:
-        logger.error(f"Failed to send Telegram document: {e}")
-        return False
-
-def send_correction_to_telegram(correction_data):
-    """Send correction data to Telegram channel"""
-    try:
-        # Create message
-        message = f"""📊 New Training Data Received
+    except requests.exceptions.ConnectionError:
+        return pil_img, f"Connection Error: Cannot reach server at {API_URL}\nMake sure the server is running.", ""
 
-🆔 Image ID: {correction_data.get('image_id', 'unknown')}
-👤 User: {correction_data.get('user_id', 'unknown')}
-⏰ Time: {correction_data.get('timestamp', 'unknown')}
+    except requests.exceptions.RequestException as e:
+        return pil_img, f"API Connection Error: {str(e)}", ""
 
-📈 Statistics:
-• Original zones: {len(correction_data.get('original_zones', []))}
-• Corrected zones: {len(correction_data.get('corrected_zones', []))}
-• Text fixed: {sum(1 for zone in correction_data.get('corrected_zones', []) if zone.get('correction_type') == 'text_fixed')}
-• Boxes moved: {sum(1 for zone in correction_data.get('corrected_zones', []) if zone.get('correction_type') == 'box_moved')}
-• New zones added: {sum(1 for zone in correction_data.get('corrected_zones', []) if zone.get('correction_type') == 'new_zone')}
-• Zones deleted: {sum(1 for zone in correction_data.get('corrected_zones', []) if zone.get('correction_type') == 'deleted')}
-• Validated (OK): {sum(1 for zone in correction_data.get('corrected_zones', []) if zone.get('correction_type') == 'validated')}
+    except json.JSONDecodeError:
+        return pil_img, f"Error: Invalid response (non-JSON) from server.\nResponse: {response.text[:200]}", ""
 
-✅ Data saved for model training"""
-
-        # Send message
-        send_telegram_message(message)
-        
-        # Create JSON file with training data
-        import tempfile
-        with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
-            json.dump(correction_data, f, indent=2)
-            json_path = f.name
-        
-        # Send JSON file
-        send_telegram_document(json_path, "Training data JSON")
-        
-        # Clean up
-        os.unlink(json_path)
-        
-        return True
-    except Exception as e:
-        logger.error(f"Failed to send correction to Telegram: {e}")
-        return False
-
-@app.get("/telegram/status")
-async def telegram_status():
-    """Check Telegram bot configuration"""
-    bot_token = os.getenv('TELEGRAM_BOT_TOKEN')
-    chat_id = os.getenv('TELEGRAM_CHAT_ID')
-    
-    return {
-        "configured": bool(bot_token and chat_id),
-        "bot_token_set": bool(bot_token),
-        "chat_id_set": bool(chat_id),
-        "connection": "ok" if (bot_token and chat_id) else "missing_config",
-        "bot_username": "unknown"  # Would need to fetch from Telegram API
-    }
-
-@app.post("/telegram/set-webhook")
-async def set_telegram_webhook(webhook_url: str = Query(...)):
-    """Set Telegram webhook URL"""
-    bot_token = os.getenv('TELEGRAM_BOT_TOKEN')
-    if not bot_token:
-        return {"success": False, "message": "Bot token not configured"}
-    
-    url = f"https://api.telegram.org/bot{bot_token}/setWebhook"
-    data = {"url": webhook_url}
-    
-    try:
-        response = requests.post(url, data=data)
-        result = response.json()
-        return {
-            "success": result.get("ok", False),
-            "message": result.get("description", "Unknown error"),
-            "webhook_url": webhook_url,
-            "telegram_response": result
-        }
-    except Exception as e:
-        return {"success": False, "message": f"Error setting webhook: {str(e)}"}
-
-@app.post("/telegram/webhook")
-async def telegram_webhook(request: Request):
-    """Handle incoming Telegram messages"""
-    try:
-        data = await request.json()
-        logger.info(f"Received Telegram webhook: {data}")
-        
-        # Extract message info
-        message = data.get('message', {})
-        chat_id = message.get('chat', {}).get('id')
-        user_id = message.get('from', {}).get('id')
-        text = message.get('text', '')
-        photo = message.get('photo', [])
-        
-        # Handle text commands
-        if text:
-            if text.startswith('/start'):
-                # Log the command but don't send response due to DNS issues
-                logger.info(f"User {user_id} sent /start command")
-                # Just return success - user can access mini app directly
-                pass
-            
-            elif text.startswith('/help'):
-                logger.info(f"User {user_id} requested help")
-                # Just return success
-                pass
-            
-            elif text.startswith('/status'):
-                logger.info(f"User {user_id} checked status")
-                # Just return success
-                pass
-        
-        # Handle photo uploads
-        elif photo:
-            # Get the largest photo
-            largest_photo = max(photo, key=lambda x: x.get('file_size', 0))
-            file_id = largest_photo.get('file_id')
-            
-            # Download photo
-            photo_path = await download_telegram_photo(file_id)
-            if photo_path:
-                try:
-                    # Process with OCR
-                    result = process_image(photo_path, mode="fast")
-                    
-                    if result and result.get('zones'):
-                        zones = result['zones']
-                        logger.info(f"Processed photo for user {user_id}: Found {len(zones)} zones")
-                        
-                        # Log the results instead of sending message
-                        for i, zone in enumerate(zones[:5]):
-                            logger.info(f"Zone {i+1}: {zone.get('text', '')} ({int(zone.get('confidence', 0)*100)}%)")
-                        
-                        if len(zones) > 5:
-                            logger.info(f"... and {len(zones)-5} more zones")
-                    else:
-                        logger.info(f"No text detected in photo from user {user_id}")
-                    
-                except Exception as ocr_error:
-                    logger.error(f"OCR processing error for user {user_id}: {ocr_error}")
-                finally:
-                    # Clean up
-                    if os.path.exists(photo_path):
-                        os.unlink(photo_path)
-        
-        return {"status": "ok"}
-        
     except Exception as e:
-        logger.error(f"Error handling Telegram webhook: {e}")
-        return {"status": "error", "message": str(e)}
-
-def send_telegram_message_with_keyboard(message, chat_id, keyboard):
-    """Send message with inline keyboard"""
-    bot_token = os.getenv('TELEGRAM_BOT_TOKEN')
-    if not bot_token:
-        return False
-    
-    # Try multiple Telegram API endpoints for better connectivity
-    api_urls = [
-        "https://api.telegram.org",
-        "https://api.telegram.org:443"
-    ]
-    
-    for api_url in api_urls:
-        try:
-            url = f"{api_url}/bot{bot_token}/sendMessage"
-            data = {
-                'chat_id': chat_id,
-                'text': message,
-                'parse_mode': 'Markdown',
-                'reply_markup': json.dumps(keyboard)
-            }
-            
-            # Add timeout and retry logic
-            session = requests.Session()
-            session.timeout = 10
-            
-            response = session.post(url, data=data, timeout=10)
-            if response.status_code == 200:
-                logger.info(f"Successfully sent Telegram message with keyboard via {api_url}")
-                return True
-                
-        except Exception as e:
-            logger.warning(f"Failed to send keyboard message via {api_url}: {e}")
-            continue
-    
-    logger.error("Failed to send Telegram message with keyboard via all endpoints")
-    return False
+        import traceback
+        return pil_img, f"Unexpected error: {str(e)}\n\nTraceback:\n{traceback.format_exc()}", ""
 
-async def download_telegram_photo(file_id):
-    """Download photo from Telegram"""
-    bot_token = os.getenv('TELEGRAM_BOT_TOKEN')
-    if not bot_token:
-        return None
-    
+def check_api_status() -> str:
+    """Check if the API server is running and accessible."""
     try:
-        # Get file info
-        url = f"https://api.telegram.org/bot{bot_token}/getFile"
-        response = requests.get(url, params={'file_id': file_id})
-        file_info = response.json()
-        
-        if not file_info.get('ok'):
-            return None
-        
-        file_path = file_info['result']['file_path']
-        
-        # Download file
-        download_url = f"https://api.telegram.org/file/bot{bot_token}/{file_path}"
-        response = requests.get(download_url)
-        
-        # Save to temporary file
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as tmp_file:
-            tmp_file.write(response.content)
-            return tmp_file.name
-            
+        response = requests.get(f"{API_URL}/health", timeout=10)
+        if response.status_code == 200:
+            data = response.json()
+            return f"""✅ **API Status: Running**
+
+🔧 Service: {data.get('service', 'Unknown')}
+📦 Version: {data.get('version', 'Unknown')}
+🤖 OCR Initialized: {data.get('ocr_initialized', False)}
+🌐 URL: {API_URL}
+"""
+        else:
+            return f"❌ API Error: {response.status_code}\n{response.text}"
+    except requests.exceptions.Timeout:
+        return f"⏱️ Timeout: Server is not responding"
+    except requests.exceptions.ConnectionError:
+        return f"❌ Connection Error: Cannot reach {API_URL}\n\nMake sure the server is deployed and running."
     except Exception as e:
-        logger.error(f"Failed to download Telegram photo: {e}")
-        return None
-
-@app.get("/camera")
-async def camera_mini_app():
-    """Serve the camera mini app"""
-    return FileResponse("static/camera.html")
+        return f"❌ Error: {str(e)}"
+
+# --- Gradio Interface ---
+
+custom_css = """
+.gradio-container {
+    font-family: 'Arial', sans-serif;
+}
+.gr-button-primary {
+    background: linear-gradient(90deg, #4CAF50, #45a049) !important;
+    border: none !important;
+}
+.gr-button-secondary {
+    background: linear-gradient(90deg, #2196F3, #1976D2) !important;
+    border: none !important;
+}
+"""
 
-@app.post("/corrections/submit")
-async def submit_corrections(request: Request):
-    """Submit corrections for training data"""
-    try:
-        data = await request.json()
-        
-        # Send to Telegram channel
-        success = send_correction_to_telegram(data)
-        
-        return {
-            "status": "success" if success else "error",
-            "message": "Corrections submitted successfully" if success else "Failed to submit corrections",
-            "total_zones": len(data.get('corrected_zones', []))
-        }
-        
-    except Exception as e:
-        logger.error(f"Error submitting corrections: {e}")
-        return {"status": "error", "message": str(e)}
+with gr.Blocks(title="SPaCial OCR Client", css=custom_css) as demo:
+    gr.Markdown(
+        """
+        # 🖼️ SPaCial AI OCR Client (Enhanced)
+        
+        This interface connects to the **SPaCial AI OCR API** server for advanced dimension detection.
+        
+        ## 🎨 **Color Legend:**
+        - 🟢 **Green**: Regular text (horizontal/vertical)
+        - 💚 **Light Green**: Diagonal text (45°)
+        - 🔵 **Blue**: Dimensions (horizontal/vertical)
+        - 💙 **Bright Blue**: Diagonal dimensions (45°)
+        
+        ## 📐 **Orientation Symbols:**
+        - → Horizontal | ↓ Vertical | ↘ Diagonal (45°) | ↙ Diagonal (135°)
+        
+        ## ⚙️ **OCR Modes:**
+        - **Fast**: Quick detection for well-visible text
+        - **Accurate**: Better for small or unclear text
+        - **Hardcore**: Maximum detection (aggressive parameters)
+        """
+    )
+    
+    # API Status Check
+    with gr.Row():
+        with gr.Column(scale=2):
+            status_btn = gr.Button("🔍 Check API Status", variant="secondary", size="sm")
+        with gr.Column(scale=8):
+            status_output = gr.Markdown(value="Click 'Check API Status' to verify server connection")
+    
+    gr.Markdown("---")
+    
+    with gr.Row():
+        with gr.Column():
+            image_input = gr.Image(
+                type="pil", 
+                label="📤 1. Upload Technical Drawing", 
+                sources=["upload", "clipboard"], 
+                interactive=True
+            )
+            
+            # OCR Options
+            gr.Markdown("### ⚙️ OCR Settings")
+            with gr.Row():
+                mode_dropdown = gr.Dropdown(
+                    choices=["fast", "accurate", "hardcore"],
+                    value="fast",
+                    label="OCR Mode",
+                    info="Hardcore mode uses aggressive detection parameters"
+                )
+                rotation_slider = gr.Slider(
+                    minimum=0,
+                    maximum=270,
+                    value=0,
+                    step=90,
+                    label="Rotation (degrees)",
+                    info="Pre-rotate image before OCR (0, 90, 180, 270)"
+                )
+            
+            process_btn = gr.Button("🚀 Process Image with OCR", variant="primary", size="lg")
+        
+        with gr.Column():
+            # Output columns
+            image_output = gr.Image(
+                type="pil", 
+                label="📊 Result with Bounding Boxes", 
+                interactive=False
+            )
+            
+            stats_output = gr.Markdown(
+                label="Statistics",
+                value="Process an image to see statistics"
+            )
+    
+    # Text output below (full width)
+    gr.Markdown("### 📝 Extracted Text Details")
+    text_output = gr.Textbox(
+        label="Detected Text with Confidence, Orientation & Tolerances", 
+        lines=15,
+        interactive=False,
+        show_copy_button=True
+    )
+    
+    # Examples
+    gr.Markdown("### 📋 Quick Start Tips")
+    gr.Markdown("""
+    1. **Upload** a technical drawing or document image
+    2. **Select** OCR mode (try 'hardcore' for difficult images)
+    3. **Adjust** rotation if image is sideways
+    4. **Click** 'Process Image with OCR'
+    5. **View** results with color-coded bounding boxes
+    
+    **Note:** Dimensions (with Ø, ±, tolerances) are automatically highlighted in blue!
+    """)
+    
+    # Event handlers
+    status_btn.click(
+        fn=check_api_status,
+        outputs=status_output
+    )
+    
+    process_btn.click(
+        fn=client_process_ocr,
+        inputs=[image_input, mode_dropdown, rotation_slider],
+        outputs=[image_output, text_output, stats_output]
+    )
+
+# Auto-check status on launch
+demo.load(
+    fn=check_api_status,
+    outputs=status_output
+)
 
 if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    # Launch the Gradio interface
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )
+