Update app.py

app.py

@@ -1,401 +1,1534 @@
 #!/usr/bin/env python3
 """
-Client application for SPaCial AI OCR Service
-Enhanced version with full feature support
+Hugging Face Spaces deployment for SPaCial AI OCR Service
+FastAPI HTTP Server for OCR Service using PaddleOCR
 """
 
-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:
-            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
+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))
         else:
-            return (0, 255, 0)  # Standard green for horizontal text
+            # 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)}
+        }
 
-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.
+@app.on_event("startup")
+async def startup_event():
+    """Initialize PaddleOCR models on startup"""
+    global ocr
+    logger.info("Initializing PaddleOCR model...")
     
-    Args:
-        pil_img: PIL Image object
-        mode: OCR mode ('fast', 'accurate', or 'hardcore')
-        rotation: Rotation angle in degrees (0, 90, 180, 270)
+    # 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
     
-    Returns:
-        Tuple of (processed_image, extracted_text, statistics)
+    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)")
+):
     """
+    Process uploaded image with OCR
+    Returns detected zones with bounding boxes and text
     
-    if pil_img is None:
-        return None, "Please upload an image first.", ""
+    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")
     
-    # 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)
+    # 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")
     
-    # Prepare data for submission (multipart/form-data)
-    files = {'file': ('image.jpg', img_byte_arr, 'image/jpeg')}
+    # 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
     
-    # The processing endpoint is "/ocr/process"
-    endpoint_url = f"{API_URL}/ocr/process"
+    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")
     
-    # Add query parameters
-    params = {
-        'mode': mode,
-        'rotation': rotation
-    }
+    if not os.path.exists(image_path):
+        raise HTTPException(status_code=404, detail="Image file not found")
     
     try:
-        gr.Info(f"Sending image to OCR server (mode: {mode}, rotation: {rotation}°)...")
+        result = process_image(image_path, mode)
+        return JSONResponse(content=result)
         
-        # 2. Send HTTP POST Request
-        response = requests.post(endpoint_url, files=files, params=params, timeout=60)
+    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
         
-        # Check status code
-        if response.status_code != 200:
-            return pil_img, f"Server Error ({response.status_code}): {response.text}", ""
+        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))
 
-        # 3. Process JSON Response
-        result_data = response.json()
+@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', '')
         
-        # Extract zones and metadata
-        zones = result_data.get("zones", [])
-        metadata = result_data.get("metadata", {})
+        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 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))
+
+@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', {})
         
-        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!)
+        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)
+        
+        # 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 {"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
                 
-                # 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 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")
+        
+        # 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 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
                 
-                # Draw zone number
-                try:
-                    # Try to use a font, fallback to default
-                    font = ImageFont.truetype("arial.ttf", 14)
-                except:
-                    font = ImageFont.load_default()
+                # 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', {})
                 
-                # 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)}°
-"""
+                # 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}
+                }
+                
+        finally:
+            # Clean up temporary file
+            if os.path.exists(tmp_path):
+                os.unlink(tmp_path)
+                
+    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
+                
+                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
+                })
         
-        # Return the drawn image, text, and stats
-        return draw_img, "\n".join(full_text_output), stats_str
+        # Sort by distance
+        nearby_lines.sort(key=lambda x: x['distance'])
+        
+        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")
 
-    except requests.exceptions.Timeout:
-        return pil_img, f"Timeout Error: Server took too long to respond (>60s).", ""
+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.ConnectionError:
-        return pil_img, f"Connection Error: Cannot reach server at {API_URL}\nMake sure the server is running.", ""
+    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.RequestException as e:
-        return pil_img, f"API Connection Error: {str(e)}", ""
+🆔 Image ID: {correction_data.get('image_id', 'unknown')}
+👤 User: {correction_data.get('user_id', 'unknown')}
+⏰ Time: {correction_data.get('timestamp', 'unknown')}
 
-    except json.JSONDecodeError:
-        return pil_img, f"Error: Invalid response (non-JSON) from server.\nResponse: {response.text[:200]}", ""
+📈 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')}
 
+✅ 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:
-        import traceback
-        return pil_img, f"Unexpected error: {str(e)}\n\nTraceback:\n{traceback.format_exc()}", ""
+        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
+    }
 
-def check_api_status() -> str:
-    """Check if the API server is running and accessible."""
+@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.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."
+        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 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;
-}
-"""
+        return {"success": False, "message": f"Error setting webhook: {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
-)
+@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)}
 
-if __name__ == "__main__":
-    # Launch the Gradio interface
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True
-    )
+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
 
+async def download_telegram_photo(file_id):
+    """Download photo from Telegram"""
+    bot_token = os.getenv('TELEGRAM_BOT_TOKEN')
+    if not bot_token:
+        return None
+    
+    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
+            
+    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")
+
+@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)}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)