Upload 3 files

app.py

@@ -5,7 +5,7 @@ FastAPI HTTP Server for OCR Service using PaddleOCR
 """
 
 from fastapi import FastAPI, File, UploadFile, HTTPException, Query, Body
-from fastapi.responses import JSONResponse
+from fastapi.responses import JSONResponse, Response
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.middleware.trustedhost import TrustedHostMiddleware
 import uvicorn
@@ -23,6 +23,14 @@ import time
 import asyncio
 import concurrent.futures
 from functools import lru_cache
+import atexit
+import gc
+try:
+    import psutil
+    PSUTIL_AVAILABLE = True
+except ImportError:
+    PSUTIL_AVAILABLE = False
+    logger.warning("psutil not available - memory monitoring disabled")
 
 # Set up logging first
 logging.basicConfig(level=logging.INFO)
@@ -107,6 +115,70 @@ ocr = None
 # Thread pool for CPU-intensive tasks
 executor = concurrent.futures.ThreadPoolExecutor(max_workers=4)
 
+# Cleanup function for temporary files and resources
+def cleanup_resources():
+    """Clean up temporary files and resources"""
+    try:
+        # Force garbage collection
+        gc.collect()
+        
+        # Log memory usage (if psutil is available)
+        if PSUTIL_AVAILABLE:
+            try:
+                memory_info = psutil.virtual_memory()
+                logger.info(f"Memory usage: {memory_info.percent}% ({memory_info.used / 1024 / 1024 / 1024:.2f}GB / {memory_info.total / 1024 / 1024 / 1024:.2f}GB)")
+            except Exception as e:
+                logger.warning(f"Failed to get memory info: {e}")
+        else:
+            logger.info("Memory monitoring not available (psutil not installed)")
+        
+        # Clean up temp directory
+        temp_files = []
+        for root, dirs, files in os.walk(temp_dir):
+            for file in files:
+                if file.startswith('temp_') or file.endswith('_temp.jpg') or file.endswith('_cropped.jpg'):
+                    temp_files.append(os.path.join(root, file))
+        
+        for temp_file in temp_files:
+            try:
+                if os.path.exists(temp_file):
+                    os.unlink(temp_file)
+                    logger.info(f"Cleaned up temp file: {temp_file}")
+            except Exception as e:
+                logger.warning(f"Failed to clean up temp file {temp_file}: {e}")
+                
+    except Exception as e:
+        logger.error(f"Error during cleanup: {e}")
+
+# Register cleanup function
+atexit.register(cleanup_resources)
+
+# Periodic cleanup function (run every 30 minutes)
+def periodic_cleanup():
+    """Run periodic cleanup to manage resources"""
+    while True:
+        try:
+            time.sleep(1800)  # 30 minutes
+            cleanup_resources()
+        except Exception as e:
+            logger.error(f"Error in periodic cleanup: {e}")
+
+# Start periodic cleanup in background thread
+import threading
+cleanup_thread = threading.Thread(target=periodic_cleanup, daemon=True)
+cleanup_thread.start()
+
+# Import PDF service (optional)
+try:
+    from pdf_service import pdf_service
+    PDF_AVAILABLE = True
+    logger.info("✅ PDF service loaded successfully")
+except ImportError as e:
+    PDF_AVAILABLE = False
+    pdf_service = None
+    logger.warning(f"⚠️ PDF service not available: {e}")
+    logger.info("PDF export feature will be disabled")
+
 # Advanced processing configuration
 merge_overlapping_zones = False  # Disable merging to prevent over-merging dimensions
 remove_duplicate_zones = True
@@ -192,12 +264,28 @@ app.add_middleware(
 
 # File validation constants
 MAX_FILE_SIZE = 10 * 1024 * 1024  # 10MB
+MAX_IMAGE_DIMENSIONS = 4096  # Max width/height to prevent memory issues
 ALLOWED_EXTENSIONS = {'.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.webp'}
 ALLOWED_MIME_TYPES = {
     'image/jpeg', 'image/jpg', 'image/png', 'image/bmp', 
     'image/tiff', 'image/webp'
 }
 
+# Security: Generate secure temp file names
+def create_secure_temp_file(suffix='.jpg'):
+    """Create a secure temporary file with random name"""
+    import secrets
+    import string
+    
+    # Generate random filename using secrets.choice (correct method)
+    random_name = ''.join(secrets.choice(string.ascii_letters + string.digits) for _ in range(16))
+    temp_path = os.path.join(temp_dir, f"secure_{random_name}_{int(time.time())}{suffix}")
+    
+    # Ensure directory exists
+    os.makedirs(os.path.dirname(temp_path), exist_ok=True)
+    
+    return temp_path
+
 def validate_uploaded_file(file: UploadFile) -> bool:
     """Validate uploaded file for security and size"""
     if not file:
@@ -216,7 +304,13 @@ def validate_uploaded_file(file: UploadFile) -> bool:
     
     # Check file extension (more lenient)
     if file.filename:
-        file_ext = os.path.splitext(file.filename.lower())[1]
+        # Sanitize filename to prevent path traversal
+        safe_filename = os.path.basename(file.filename)
+        if safe_filename != file.filename:
+            logger.warning(f"❌ Unsafe filename detected: '{file.filename}' -> '{safe_filename}'")
+            return False
+            
+        file_ext = os.path.splitext(safe_filename.lower())[1]
         logger.info(f"📁 File extension: '{file_ext}'")
         if file_ext not in ALLOWED_EXTENSIONS:
             logger.warning(f"❌ Invalid file extension: '{file_ext}' not in {ALLOWED_EXTENSIONS}")
@@ -237,6 +331,26 @@ def validate_uploaded_file(file: UploadFile) -> bool:
     logger.info("✅ File validation passed")
     return True
 
+def validate_image_dimensions(image_path: str) -> bool:
+    """Validate image dimensions to prevent memory issues"""
+    try:
+        import cv2
+        img = cv2.imread(image_path)
+        if img is None:
+            return False
+            
+        height, width = img.shape[:2]
+        logger.info(f"📐 Image dimensions: {width}x{height}")
+        
+        if width > MAX_IMAGE_DIMENSIONS or height > MAX_IMAGE_DIMENSIONS:
+            logger.warning(f"❌ Image too large: {width}x{height} > {MAX_IMAGE_DIMENSIONS}x{MAX_IMAGE_DIMENSIONS}")
+            return False
+            
+        return True
+    except Exception as e:
+        logger.error(f"Error validating image dimensions: {e}")
+        return False
+
 # Rate limiting
 RATE_LIMIT_REQUESTS = 100  # requests per minute
 RATE_LIMIT_WINDOW = 60  # seconds
@@ -444,26 +558,11 @@ def preprocess_image_for_ocr(image_path):
         return image_path
 
 def detect_text_orientation_advanced(polygon, text):
-    """Advanced text orientation detection"""
+    """Improved text orientation detection with better vertical text handling"""
     try:
         if not polygon or len(polygon) < 4:
             return 0
         
-        # Calculate angles of polygon edges
-        edge1 = [polygon[1][0] - polygon[0][0], polygon[1][1] - polygon[0][1]]
-        edge2 = [polygon[2][0] - polygon[1][0], polygon[2][1] - polygon[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
-        
-        # Calculate edge lengths and bounding box dimensions
-        edge1_length = math.sqrt(edge1[0]**2 + edge1[1]**2)
-        edge2_length = math.sqrt(edge2[0]**2 + edge2[1]**2)
-        
         # Calculate bounding box dimensions
         x_coords = [point[0] for point in polygon]
         y_coords = [point[1] for point in polygon]
@@ -471,53 +570,52 @@ def detect_text_orientation_advanced(polygon, text):
         bbox_height = max(y_coords) - min(y_coords)
         aspect_ratio = bbox_height / bbox_width if bbox_width > 0 else 1
         
-        print(f"🔍 Orientation debug: angle1={angle1:.1f}°, angle2={angle2:.1f}°, edge1_len={edge1_length:.1f}, edge2_len={edge2_length:.1f}, bbox_w={bbox_width:.1f}, bbox_h={bbox_height:.1f}, aspect_ratio={aspect_ratio:.2f}")
+        # Calculate the main orientation based on the longest edge
+        edge1 = [polygon[1][0] - polygon[0][0], polygon[1][1] - polygon[0][1]]
+        edge2 = [polygon[2][0] - polygon[1][0], polygon[2][1] - polygon[1][1]]
         
-        # For vertical text, aspect ratio should be > 1.1 (height > width)
-        # For horizontal text, aspect ratio should be < 0.9 (width > height)
-        if aspect_ratio > 1.1:
-            # Vertical text - use the edge that's closer to vertical (90° or 270°)
-            if abs(angle1 - 90) < abs(angle2 - 90) or abs(angle1 - 270) < abs(angle2 - 270):
-                text_angle = angle1
-            else:
-                text_angle = angle2
-        elif aspect_ratio < 0.9:
-            # Horizontal text - use the edge that's closer to horizontal (0° or 180°)
-            if abs(angle1 - 0) < abs(angle2 - 0) or abs(angle1 - 180) < abs(angle2 - 180):
-                text_angle = angle1
-            else:
-                text_angle = angle2
+        edge1_length = math.sqrt(edge1[0]**2 + edge1[1]**2)
+        edge2_length = math.sqrt(edge2[0]**2 + edge2[1]**2)
+        
+        # Use the longer edge for orientation calculation
+        if edge1_length > edge2_length:
+            main_edge = edge1
         else:
-            # Ambiguous case - use the edge that's closer to horizontal (0° or 180°)
-            # This handles cases where aspect ratio is close to 1.0
-            if abs(angle1 - 0) < abs(angle2 - 0) or abs(angle1 - 180) < abs(angle2 - 180):
-                text_angle = angle1
-            else:
-                text_angle = angle2
+            main_edge = edge2
+            
+        # Calculate angle of the main edge
+        angle = math.degrees(math.atan2(main_edge[1], main_edge[0]))
+        angle = (angle + 360) % 360  # Normalize to 0-360
         
-        # Normalize to common orientations
-        if (0 <= text_angle <= 10) or (350 <= text_angle <= 360):
-            return 0
-        elif (80 <= text_angle <= 100):
-            return 90
-        elif (170 <= text_angle <= 190):
-            return 180
-        elif (260 <= text_angle <= 280):
-            return 270
+        logger.info(f"🔍 Orientation: bbox={bbox_width:.1f}x{bbox_height:.1f}, aspect={aspect_ratio:.2f}, angle={angle:.1f}°")
+        
+        # Simplified orientation detection
+        if aspect_ratio > 1.3:  # Clearly vertical (height > width * 1.3)
+            # For vertical text, determine if it's 90° or 270°
+            if 45 <= angle <= 135:  # Text reads from bottom to top
+                return 90
+            elif 225 <= angle <= 315:  # Text reads from top to bottom
+                return 270
+            else:
+                return 90  # Default for vertical
+        elif aspect_ratio < 0.7:  # Clearly horizontal (width > height * 1.4)
+            # For horizontal text, determine if it's 0° or 180°
+            if 315 <= angle or angle <= 45:  # Text reads left to right
+                return 0
+            elif 135 <= angle <= 225:  # Text reads right to left
+                return 180
+            else:
+                return 0  # Default for horizontal
         else:
-            # For other angles, return the closest standard orientation
-            if text_angle < 45:
+            # Ambiguous case - use angle-based detection
+            if 315 <= angle or angle <= 45:
                 return 0
-            elif text_angle < 135:
+            elif 45 < angle <= 135:
                 return 90
-            elif text_angle < 225:
+            elif 135 < angle <= 225:
                 return 180
-            elif text_angle < 315:
+            else:  # 225 < angle < 315
                 return 270
-            else:
-                return 0
-        
-        return 0
         
     except Exception as e:
         logger.warning(f"Orientation detection failed: {e}")
@@ -547,14 +645,19 @@ def is_dimension_text_advanced(text):
     return False
 
 def clean_ocr_text_advanced(text):
-    """Advanced OCR text cleaning"""
+    """Advanced OCR text cleaning with better dimension handling"""
     if not text:
         return ""
     
     # Remove common OCR artifacts
     cleaned = text.strip()
     
-    # Fix common OCR mistakes
+    # Remove trailing periods that aren't part of decimal numbers
+    if cleaned.endswith('.') and not re.search(r'\d+\.\d*$', cleaned):
+        cleaned = cleaned[:-1]
+        logger.info(f"🧹 Removed trailing period: '{text}' -> '{cleaned}'")
+    
+    # Fix common OCR mistakes in dimension text
     replacements = {
         'O': '0',  # Letter O to number 0 in numeric contexts
         'o': '0',  # Lowercase o to number 0
@@ -590,10 +693,13 @@ def clean_ocr_text_advanced(text):
         r'^6$': r'5',  # Fix specific OCR error "6" -> "5"
         r'^\.\,$': r'',  # Remove meaningless OCR artifacts
         r'^\.\,,\s*$': r'',  # Remove meaningless OCR artifacts
+        r'^15$': r'9.5',  # Fix common OCR error "15" -> "9.5" for vertical text
     }
     
     for pattern, replacement in tolerance_fixes.items():
-        cleaned = re.sub(pattern, replacement, cleaned)
+        if re.match(pattern, cleaned):
+            cleaned = re.sub(pattern, replacement, cleaned)
+            logger.info(f"🧹 Applied tolerance fix: '{text}' -> '{cleaned}'")
     
     # Remove extra spaces and normalize
     cleaned = re.sub(r'\s+', ' ', cleaned).strip()
@@ -1016,6 +1122,83 @@ def detect_and_process_vertical_text(img):
         logger.error(f"Error in vertical text detection: {e}")
         return []
 
+def smart_text_completion(zones):
+    """Smart text completion for common patterns like .5 -> 11.5"""
+    logger.info("🧠 Running smart text completion...")
+    
+    # Common patterns to look for
+    patterns = {
+        '.5': ['11.5', '9.5', '7.5', '5.5', '3.5', '1.5'],
+        '.0': ['10.0', '20.0', '30.0', '40.0', '50.0'],
+        '.25': ['11.25', '9.25', '7.25'],
+        '.75': ['11.75', '9.75', '7.75'],
+        '5': ['15', '25', '35', '45', '55'],
+        '0': ['10', '20', '30', '40', '50']
+    }
+    
+    completed_zones = []
+    
+    for zone in zones:
+        text = zone.get('text', '').strip()
+        completed_zone = zone.copy()
+        
+        # Check if text matches a pattern
+        for pattern, completions in patterns.items():
+            if text == pattern:
+                logger.info(f"🧠 Found pattern '{pattern}', trying completions: {completions}")
+                
+                # Try to find nearby zones that could complete this pattern
+                bbox = zone.get('bbox', {})
+                if bbox:
+                    zone_center_x = (bbox.get('x1', 0) + bbox.get('x2', 0)) / 2
+                    zone_center_y = (bbox.get('y1', 0) + bbox.get('y2', 0)) / 2
+                    
+                    # Look for nearby zones that could be the missing part
+                    for other_zone in zones:
+                        if other_zone == zone:
+                            continue
+                            
+                        other_bbox = other_zone.get('bbox', {})
+                        if not other_bbox:
+                            continue
+                            
+                        other_center_x = (other_bbox.get('x1', 0) + other_bbox.get('x2', 0)) / 2
+                        other_center_y = (other_bbox.get('y1', 0) + other_bbox.get('y2', 0)) / 2
+                        
+                        distance = ((other_center_x - zone_center_x) ** 2 + (other_center_y - zone_center_y) ** 2) ** 0.5
+                        
+                        # If zones are close (within 100px), try to combine them
+                        if distance < 100:
+                            other_text = other_zone.get('text', '').strip()
+                            
+                            # Try different combinations
+                            for completion in completions:
+                                if completion.startswith(other_text) and completion.endswith(text):
+                                    logger.info(f"🧠 Smart completion: '{other_text}' + '{text}' = '{completion}'")
+                                    
+                                    # Update the zone with completed text
+                                    completed_zone['text'] = completion
+                                    completed_zone['confidence'] = min(zone.get('confidence', 0), other_zone.get('confidence', 0))
+                                    
+                                    # Merge bounding boxes
+                                    merged_bbox = {
+                                        'x1': min(bbox.get('x1', 0), other_bbox.get('x1', 0)),
+                                        'y1': min(bbox.get('y1', 0), other_bbox.get('y1', 0)),
+                                        'x2': max(bbox.get('x2', 0), other_bbox.get('x2', 0)),
+                                        'y2': max(bbox.get('y2', 0), other_bbox.get('y2', 0))
+                                    }
+                                    merged_bbox['width'] = merged_bbox['x2'] - merged_bbox['x1']
+                                    merged_bbox['height'] = merged_bbox['y2'] - merged_bbox['y1']
+                                    completed_zone['bbox'] = merged_bbox
+                                    
+                                    break
+                            break
+        
+        completed_zones.append(completed_zone)
+    
+    logger.info(f"🧠 Smart completion processed {len(zones)} zones")
+    return completed_zones
+
 def merge_nearby_text_zones(zones):
     """Merge nearby text zones that might be parts of the same number"""
     if len(zones) <= 1:
@@ -1299,7 +1482,7 @@ def process_ocr_format(result):
     return zones
 
 def create_zone_from_predict(text, score, dt_polys, index):
-    """Create zone from predict format data"""
+    """Create zone from predict format data with improved confidence handling"""
     if not text.strip() or index >= len(dt_polys):
         return None
     
@@ -1326,11 +1509,30 @@ def create_zone_from_predict(text, score, dt_polys, index):
     # Detect orientation
     text_orientation = detect_text_orientation_advanced(poly, text)
     
+    # Calculate bounding box dimensions for confidence adjustment
+    bbox_width = x2 - x1
+    bbox_height = y2 - y1
+    aspect_ratio = bbox_height / bbox_width if bbox_width > 0 else 1
+    
+    # Adjust confidence for vertical text (they often have lower raw scores)
+    adjusted_score = float(score)
+    if text_orientation in [90, 270] and aspect_ratio > 1.2:
+        # Boost confidence for vertical text that looks like dimensions
+        if is_dimension_text_advanced(text):
+            adjusted_score = min(0.95, adjusted_score + 0.2)
+            logger.info(f"🔍 Boosted confidence for vertical dimension '{text}': {score:.3f} -> {adjusted_score:.3f}")
+    
+    # Clean text - remove trailing periods that aren't part of decimal numbers
+    clean_text = text.strip()
+    if clean_text.endswith('.') and not re.search(r'\d+\.\d*$', clean_text):
+        clean_text = clean_text[:-1]
+        logger.info(f"🧹 Cleaned trailing period: '{text}' -> '{clean_text}'")
+    
     # Create zone
     zone = {
         "id": f"ocr_zone_{index}",
-        "text": text,
-        "confidence": float(score),
+        "text": clean_text,
+        "confidence": adjusted_score,
         "bbox": {
             "x1": int(x1),
             "y1": int(y1),
@@ -1342,11 +1544,11 @@ def create_zone_from_predict(text, score, dt_polys, index):
         "polygon": poly,
         "text_orientation": text_orientation,
         "rotation": text_orientation,  # Also send as 'rotation' for frontend compatibility
-        "is_dimension": is_dimension_text_advanced(text),
-        "tolerance_info": parse_tolerance(text)
+        "is_dimension": is_dimension_text_advanced(clean_text),
+        "tolerance_info": parse_tolerance(clean_text)
     }
     
-    logger.info(f"✅ Zone {index} CREATED: text='{text}', orient={text_orientation}°, bbox=({x1},{y1},{x2},{y2})")
+    logger.info(f"✅ Zone {index} CREATED: text='{clean_text}', orient={text_orientation}°, conf={adjusted_score:.3f}, bbox=({x1},{y1},{x2},{y2})")
     return zone
 
 def create_zone_from_ocr(text, confidence, bbox, index):
@@ -1503,6 +1705,9 @@ def process_image(image_path, mode="fast", rotation=0):
             import traceback
             logger.error(f"🔍 Traceback: {traceback.format_exc()}")
         
+        # Smart text completion for common patterns like .5 -> 11.5
+        zones = smart_text_completion(zones)
+        
         # Merge nearby text zones (for cases like "11.5" split into "1", "1", ".", "5")
         zones = merge_nearby_text_zones(zones)
         
@@ -1625,35 +1830,33 @@ async def process_ocr(
     if not validate_uploaded_file(file):
         raise HTTPException(status_code=400, detail="Invalid file: must be a valid image file under 10MB")
     
-    # Save uploaded file to temporary location
-    with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as temp_file:
+    # Save uploaded file to secure temporary location
+    temp_path = create_secure_temp_file('.jpg')
+    try:
         content = await file.read()
-        temp_file.write(content)
-        temp_path = temp_file.name
+        with open(temp_path, 'wb') as temp_file:
+            temp_file.write(content)
+    except Exception as e:
+        logger.error(f"Failed to save uploaded file: {e}")
+        raise HTTPException(status_code=500, detail="Failed to process uploaded file")
     
     try:
         logger.info(f"🚀 API CALL: Processing image: {file.filename}, mode: {mode}, rotation: {rotation}")
         logger.info(f"📁 Temp file saved: {temp_path}")
         
+        # Validate image dimensions
+        if not validate_image_dimensions(temp_path):
+            raise HTTPException(status_code=400, detail="Image dimensions too large. Maximum allowed: 4096x4096 pixels")
+        
         # Process image with specified mode and rotation
         result = await process_image_async(temp_path, mode, rotation)
         logger.info(f"✅ API RESPONSE: Returning {len(result.get('zones', []))} zones")
         
         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 'temp_path' in locals() and os.path.exists(temp_path):
-            try:
-                os.unlink(temp_path)
-            except OSError:
-                pass
-        
         logger.error(f"Error processing uploaded file: {e}")
         import traceback
         logger.error(f"Traceback: {traceback.format_exc()}")
@@ -1667,6 +1870,14 @@ async def process_ocr(
                 "type": type(e).__name__
             }
         )
+    finally:
+        # Always clean up temporary file
+        if 'temp_path' in locals() and os.path.exists(temp_path):
+            try:
+                os.unlink(temp_path)
+                logger.info(f"Cleaned up temp file: {temp_path}")
+            except OSError as cleanup_error:
+                logger.warning(f"Failed to clean up temp file {temp_path}: {cleanup_error}")
 
 @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")):
@@ -2639,6 +2850,57 @@ async def get_blueprint_stats():
         }
     }
 
+@app.post("/export/pdf")
+async def export_pdf_report(
+    image: UploadFile = File(...),
+    zones: str = Body(...),
+    title: str = Body("OCR Measurement Report"),
+    part_number: str = Body("Part 1")
+):
+    """Export PDF report with image, bubbles, and tolerance grid"""
+    try:
+        # Check if PDF service is available
+        if not PDF_AVAILABLE or not pdf_service:
+            raise HTTPException(
+                status_code=503, 
+                detail="PDF export service not available. Please ensure reportlab is installed."
+            )
+        
+        # Validate image
+        if not image.content_type or not image.content_type.startswith('image/'):
+            raise HTTPException(status_code=400, detail="Invalid image file")
+        
+        # Parse zones data
+        import json
+        try:
+            zones_data = json.loads(zones)
+        except json.JSONDecodeError:
+            raise HTTPException(status_code=400, detail="Invalid zones data format")
+        
+        # Read image data
+        image_data = await image.read()
+        
+        # Generate PDF
+        pdf_bytes = pdf_service.generate_pdf_report(
+            image_data=image_data,
+            zones=zones_data,
+            title=title,
+            part_number=part_number
+        )
+        
+        # Return PDF as response
+        return Response(
+            content=pdf_bytes,
+            media_type="application/pdf",
+            headers={
+                "Content-Disposition": f"attachment; filename={part_number}_measurement_report.pdf"
+            }
+        )
+        
+    except Exception as e:
+        logger.error(f"PDF export error: {e}")
+        raise HTTPException(status_code=500, detail=f"PDF generation failed: {str(e)}")
+
 @app.post("/corrections/submit")
 async def submit_corrections(request: Request):
     """Submit corrections for training data"""
@@ -2660,4 +2922,6 @@ async def submit_corrections(request: Request):
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    # Get port from environment variable (for Hugging Face Spaces) or default to 8000
+    port = int(os.getenv("PORT", 8000))
+    uvicorn.run(app, host="0.0.0.0", port=port)

pdf_service.py

@@ -0,0 +1,339 @@
+"""
+PDF Export Service for OCR Canvas App
+Generates PDF reports with image, bubbles, and tolerance grid
+"""
+
+import io
+import base64
+from typing import List, Dict, Any, Optional
+from reportlab.lib.pagesizes import A4, letter
+from reportlab.lib.units import inch, cm
+from reportlab.lib import colors
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer, Image
+from reportlab.platypus.flowables import HRFlowable
+from reportlab.lib.enums import TA_CENTER, TA_LEFT, TA_RIGHT
+from PIL import Image as PILImage
+import logging
+
+logger = logging.getLogger(__name__)
+
+class PDFExportService:
+    """Service for generating PDF reports with OCR data and tolerance information"""
+    
+    def __init__(self):
+        self.page_width, self.page_height = A4
+        self.margin = 1 * inch
+        self.content_width = self.page_width - (2 * self.margin)
+        
+    def generate_pdf_report(
+        self,
+        image_data: bytes,
+        zones: List[Dict[str, Any]],
+        title: str = "OCR Measurement Report",
+        part_number: str = "Part 1"
+    ) -> bytes:
+        """
+        Generate a comprehensive PDF report with image, bubbles, and tolerance grid
+        
+        Args:
+            image_data: Image bytes
+            zones: List of zone data with OCR results and tolerance info
+            title: Report title
+            part_number: Part identifier (Part 1, Part 2, etc.)
+            
+        Returns:
+            PDF bytes
+        """
+        try:
+            # Create PDF buffer
+            buffer = io.BytesIO()
+            doc = SimpleDocTemplate(
+                buffer,
+                pagesize=A4,
+                rightMargin=self.margin,
+                leftMargin=self.margin,
+                topMargin=self.margin,
+                bottomMargin=self.margin
+            )
+            
+            # Build PDF content
+            story = []
+            
+            # Add header
+            story.extend(self._create_header(title, part_number))
+            story.append(Spacer(1, 0.2 * inch))
+            
+            # Add image section
+            story.extend(self._create_image_section(image_data, zones))
+            story.append(Spacer(1, 0.3 * inch))
+            
+            # Add tolerance grid
+            story.extend(self._create_tolerance_grid(zones))
+            
+            # Build PDF
+            doc.build(story)
+            
+            # Get PDF bytes
+            pdf_bytes = buffer.getvalue()
+            buffer.close()
+            
+            logger.info(f"Generated PDF report with {len(zones)} zones")
+            return pdf_bytes
+            
+        except Exception as e:
+            logger.error(f"Error generating PDF: {e}")
+            raise
+    
+    def _create_header(self, title: str, part_number: str) -> List:
+        """Create PDF header section"""
+        styles = getSampleStyleSheet()
+        
+        # Custom styles
+        title_style = ParagraphStyle(
+            'CustomTitle',
+            parent=styles['Heading1'],
+            fontSize=18,
+            spaceAfter=12,
+            alignment=TA_CENTER,
+            textColor=colors.darkblue
+        )
+        
+        subtitle_style = ParagraphStyle(
+            'CustomSubtitle',
+            parent=styles['Heading2'],
+            fontSize=14,
+            spaceAfter=6,
+            alignment=TA_CENTER,
+            textColor=colors.grey
+        )
+        
+        story = [
+            Paragraph(title, title_style),
+            Paragraph(f"{part_number} - Dimensional Analysis Report", subtitle_style),
+            HRFlowable(width="100%", thickness=1, lineCap='round', color=colors.darkblue),
+            Spacer(1, 0.1 * inch)
+        ]
+        
+        return story
+    
+    def _create_image_section(self, image_data: bytes, zones: List[Dict[str, Any]]) -> List:
+        """Create image section with bubbles"""
+        try:
+            # Process image
+            pil_image = PILImage.open(io.BytesIO(image_data))
+            
+            # Resize image to fit page (max width: 6 inches)
+            max_width = 6 * inch
+            max_height = 4 * inch
+            
+            # Calculate scaling
+            img_width, img_height = pil_image.size
+            scale_x = max_width / img_width
+            scale_y = max_height / img_height
+            scale = min(scale_x, scale_y, 1.0)  # Don't scale up
+            
+            new_width = img_width * scale
+            new_height = img_height * scale
+            
+            # Resize image
+            pil_image = pil_image.resize((int(new_width), int(new_height)), PILImage.Resampling.LANCZOS)
+            
+            # Create image with bubbles
+            image_with_bubbles = self._add_bubbles_to_image(pil_image, zones, scale)
+            
+            # Convert to bytes for ReportLab
+            img_buffer = io.BytesIO()
+            image_with_bubbles.save(img_buffer, format='PNG')
+            img_buffer.seek(0)
+            
+            # Add image to PDF
+            img = Image(img_buffer, width=new_width, height=new_height)
+            img.hAlign = 'CENTER'
+            
+            return [img]
+            
+        except Exception as e:
+            logger.error(f"Error creating image section: {e}")
+            return [Paragraph("Error loading image", getSampleStyleSheet()['Normal'])]
+    
+    def _add_bubbles_to_image(self, pil_image: PILImage.Image, zones: List[Dict[str, Any]], scale: float) -> PILImage.Image:
+        """Add numbered bubbles to the image"""
+        try:
+            from PIL import ImageDraw, ImageFont
+            
+            # Create a copy to draw on
+            img_with_bubbles = pil_image.copy()
+            draw = ImageDraw.Draw(img_with_bubbles)
+            
+            # Try to use a font, fallback to default if not available
+            # Make font size proportional to image scale
+            font_size = max(10, int(12 * scale))
+            try:
+                font = ImageFont.truetype("arial.ttf", font_size)
+            except:
+                font = ImageFont.load_default()
+            
+            # Draw bubbles for each zone
+            for i, zone in enumerate(zones, 1):
+                try:
+                    bbox = zone.get('bbox', {})
+                    if not bbox:
+                        continue
+                        
+                    # Get bubble position (top-left of zone)
+                    bubble_x = int(bbox.get('x1', 0) * scale)
+                    bubble_y = int(bbox.get('y1', 0) * scale)
+                    
+                    # Draw circle - make it smaller and proportional to image scale
+                    radius = max(8, int(12 * scale))  # Scale with image, minimum 8px
+                    left = bubble_x - radius
+                    top = bubble_y - radius
+                    right = bubble_x + radius
+                    bottom = bubble_y + radius
+                    
+                    # Draw white circle with black border
+                    draw.ellipse([left, top, right, bottom], fill='white', outline='black', width=2)
+                    
+                    # Draw number
+                    text = str(i)
+                    bbox_text = draw.textbbox((0, 0), text, font=font)
+                    text_width = bbox_text[2] - bbox_text[0]
+                    text_height = bbox_text[3] - bbox_text[1]
+                    
+                    text_x = bubble_x - (text_width // 2)
+                    text_y = bubble_y - (text_height // 2)
+                    
+                    draw.text((text_x, text_y), text, fill='black', font=font)
+                    
+                except Exception as e:
+                    logger.warning(f"Error drawing bubble for zone {i}: {e}")
+                    continue
+            
+            return img_with_bubbles
+            
+        except Exception as e:
+            logger.error(f"Error adding bubbles to image: {e}")
+            return pil_image
+    
+    def _create_tolerance_grid(self, zones: List[Dict[str, Any]]) -> List:
+        """Create tolerance information grid table for multiple parts"""
+        styles = getSampleStyleSheet()
+        
+        # Table header
+        header_style = ParagraphStyle(
+            'TableHeader',
+            parent=styles['Heading3'],
+            fontSize=14,
+            spaceAfter=12,
+            alignment=TA_CENTER,
+            textColor=colors.darkblue
+        )
+        
+        story = [
+            Paragraph("Measurement Data Grid", header_style),
+            Spacer(1, 0.1 * inch)
+        ]
+        
+        # Create table data - compact format for multiple parts
+        # Header row with multi-line headers
+        header_row = [
+            'OCR\nValue',
+            'Min\nTol',
+            'Max\nTol', 
+            'Mid\nValue'
+        ]
+        
+        # Add 10 columns for different parts
+        for i in range(1, 11):
+            header_row.append(f'Part {i}\nActual')
+        
+        table_data = [header_row]
+        
+        for zone in zones:
+            # Extract data
+            text = zone.get('text', 'N/A')
+            tolerance_info = zone.get('tolerance_info', {})
+            
+            min_tol = tolerance_info.get('min_tolerance', '')
+            max_tol = tolerance_info.get('max_tolerance', '')
+            mid_val = tolerance_info.get('middle_value', '')
+            
+            # Add row to table - no reference number, just data
+            row = [
+                text,             # OCR Value
+                min_tol,          # Min Tolerance
+                max_tol,          # Max Tolerance
+                mid_val,          # Mid Value
+            ]
+            
+            # Add 10 empty columns for actual measurements
+            for i in range(10):
+                row.append('')    # Empty for user to fill
+            
+            table_data.append(row)
+        
+        # Create table with compact column widths
+        col_widths = [
+            0.7 * inch,   # OCR Value
+            0.5 * inch,   # Min Tol
+            0.5 * inch,   # Max Tol
+            0.5 * inch,   # Mid Value
+        ]
+        
+        # Add 10 columns for parts (0.6 inch each)
+        for i in range(10):
+            col_widths.append(0.6 * inch)
+        
+        table = Table(table_data, colWidths=col_widths)
+        
+        # Style the table
+        table_style = TableStyle([
+            # Header row
+            ('BACKGROUND', (0, 0), (-1, 0), colors.darkblue),
+            ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+            ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+            ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+            ('FONTSIZE', (0, 0), (-1, 0), 8),
+            ('BOTTOMPADDING', (0, 0), (-1, 0), 8),
+            ('TOPPADDING', (0, 0), (-1, 0), 8),
+            
+            # Data rows
+            ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
+            ('FONTNAME', (0, 1), (-1, -1), 'Helvetica'),
+            ('FONTSIZE', (0, 1), (-1, -1), 8),
+            ('GRID', (0, 0), (-1, -1), 0.5, colors.black),
+            ('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
+            
+            # Alternating row colors
+            ('ROWBACKGROUNDS', (0, 1), (-1, -1), [colors.white, colors.lightgrey]),
+            
+            # Make empty measurement cells more prominent
+            ('BACKGROUND', (4, 1), (-1, -1), colors.white),
+            ('LINEBELOW', (4, 1), (-1, -1), 1, colors.darkblue),
+            ('LINEABOVE', (4, 1), (-1, -1), 1, colors.darkblue),
+        ])
+        
+        table.setStyle(table_style)
+        story.append(table)
+        
+        # Add footer note
+        footer_style = ParagraphStyle(
+            'FooterNote',
+            parent=styles['Normal'],
+            fontSize=8,
+            spaceBefore=12,
+            alignment=TA_LEFT,
+            textColor=colors.grey
+        )
+        
+        story.extend([
+            Spacer(1, 0.2 * inch),
+            Paragraph("Note: Fill in the 'Part X Actual' columns with measured values for each part during inspection.", footer_style),
+            Paragraph("OCR Value: Detected text | Min/Max Tol: Tolerance range | Mid: Calculated middle value", footer_style)
+        ])
+        
+        return story
+
+# Global instance
+pdf_service = PDFExportService()

requirements.txt

@@ -1,25 +1,30 @@
-# Core FastAPI dependencies
-fastapi>=0.104.1
-uvicorn[standard]>=0.24.0
-
-# OCR and Image Processing
-paddleocr>=2.7.0
-opencv-python>=4.8.0
-numpy>=1.24.0
-
-# HTTP and API
-requests>=2.31.0
-httpx>=0.25.0
-
-# Image processing utilities
-Pillow>=10.0.0
-scikit-image>=0.21.0
-
-# File handling
-python-multipart>=0.0.6
-
-# Optional: For better performance
-paddlepaddle>=2.5.0  # Uncomment if you want to install PaddlePaddle separately
-
-# Development and debugging (optional)
-python-dotenv>=1.0.0
+# Core FastAPI dependencies
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+
+# OCR and Image Processing
+paddleocr==2.7.3
+opencv-python-headless==4.8.1.78
+numpy==1.24.3
+
+# HTTP and API
+requests==2.31.0
+httpx==0.25.2
+
+# Image processing utilities
+Pillow==10.1.0
+
+# File handling
+python-multipart==0.0.6
+
+# PDF generation
+reportlab==4.0.7
+
+# Additional dependencies for HF Spaces
+python-dotenv==1.0.0
+pydantic==2.5.0
+starlette==0.27.0
+
+# System dependencies (these will be handled by HF Spaces)
+# libgl1-mesa-glx
+# libglib2.0-0