Update app.py

app.py

@@ -31,9 +31,7 @@ os.environ['TMPDIR'] = '/app/temp'
 os.environ['HOME'] = '/app'
 os.environ['USER'] = 'app'
 
-# Force CPU mode for HF Spaces (no GPU available)
-os.environ['CUDA_VISIBLE_DEVICES'] = ''  # Hide all GPUs
-os.environ['PADDLE_INFERENCE_BACKEND'] = 'cpu'  # Force CPU backend
+# Let PaddleOCR auto-detect GPU/CPU (newer versions handle this automatically)
 
 # Create directories with proper permissions for all PaddleOCR models
 try:
@@ -386,7 +384,7 @@ def process_image(image_path, mode="fast"):
         # Use single OCR model (mode parameter kept for future use)
         logger.info(f"Processing image with OCR mode: {mode}")
         
-        # Use ocr.predict() with single model (like ocr_api_server.py)
+        # Use ocr.predict() method (PaddleOCR 2.8+ API)
         result = ocr.predict(str(image_path))
         
         zones = []
@@ -428,53 +426,37 @@ def process_image(image_path, mode="fast"):
                                     else:
                                         text_orientation = 0
                                 
-                                # Enhanced orientation detection for 45° angles
-                                if text_orientation == 0:  # Only analyze if PaddleOCR didn't detect rotation
-                                    # Analyze polygon shape to detect 45° rotation
-                                    if len(poly) >= 4:
-                                        # Calculate the angle of the first edge
-                                        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]]
-                                        
-                                        # Calculate angle of first edge
-                                        angle1 = math.degrees(math.atan2(edge1[1], edge1[0]))
-                                        angle2 = math.degrees(math.atan2(edge2[1], edge2[0]))
-                                        
-                                        # Normalize angles to 0-360
-                                        angle1 = (angle1 + 360) % 360
-                                        angle2 = (angle2 + 360) % 360
-                                        
-                                        # Check for 45° patterns
-                                        for angle in [angle1, angle2]:
-                                            # Check for 45°, 135°, 225°, 315° (±10° tolerance)
-                                            if (35 <= angle <= 55) or (125 <= angle <= 145) or (215 <= angle <= 235) or (305 <= angle <= 325):
-                                                if 35 <= angle <= 55:
-                                                    text_orientation = 45
-                                                elif 125 <= angle <= 145:
-                                                    text_orientation = 135
-                                                elif 215 <= angle <= 235:
-                                                    text_orientation = 225
-                                                elif 305 <= angle <= 325:
-                                                    text_orientation = 315
-                                                print(f"Enhanced orientation detection: {text} -> {text_orientation}° (angle: {angle:.1f}°)")
-                                                break
-                            
-                            zone = {
-                                    "id": f"ocr_zone_{i}",
-                                "text": text,
-                                    "confidence": float(score),
+                                # Calculate text dimensions
+                                text_width = x2 - x1
+                                text_height = y2 - y1
+                                
+                                # Parse tolerance information
+                                tolerance_info = parse_tolerance(text)
+                                
+                                # Check if this looks like a dimension
+                                is_dimension = is_dimension_text(text)
+                                
+                                # Create zone with proper bbox format
+                                zone = {
+                                    "text": text,
+                                    "confidence": score,
                                     "bbox": {
-                                        "x1": int(x1), "y1": int(y1),
-                                        "x2": int(x2), "y2": int(y2),
-                                        "width": int(x2 - x1),
-                                        "height": int(y2 - y1)
+                                        "x1": int(x1),
+                                        "y1": int(y1),
+                                        "x2": int(x2),
+                                        "y2": int(y2),
+                                        "width": int(text_width),
+                                        "height": int(text_height)
                                     },
-                                    "polygon": poly,
-                                    "text_orientation": text_orientation,
-                                    "is_dimension": is_dimension_text(text),
-                                    "tolerance_info": parse_tolerance(text)
-                            }
-                            zones.append(zone)
+                                    "orientation": text_orientation,
+                                    "rotation": text_orientation,  # Keep for compatibility
+                                    "width": int(text_width),
+                                    "height": int(text_height),
+                                    "is_dimension": is_dimension,
+                                    "tolerance_info": tolerance_info
+                                }
+                                
+                                zones.append(zone)
         
         # Create overlay image with bounding boxes
         overlay_path = create_overlay_image(image_path, zones)
@@ -501,17 +483,16 @@ async def startup_event():
     global ocr
     logger.info("Initializing PaddleOCR model...")
     
-    # Single OCR instance (force CPU mode for HF Spaces)
+    # Single OCR instance (auto GPU detection for newer PaddleOCR)
     try:
-        logger.info("Initializing PaddleOCR in CPU mode for HF Spaces...")
+        logger.info("Initializing PaddleOCR with auto GPU detection...")
         ocr = PaddleOCR(
-            use_gpu=False,  # Force CPU mode for HF Spaces
             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 in CPU mode!")
+        logger.info("PaddleOCR initialized successfully with auto GPU detection!")
     except Exception as error:
         logger.error(f"PaddleOCR initialization failed: {error}")
         raise
@@ -1042,5 +1023,4 @@ def find_lines_near_dimensions(zones, lines, max_distance=50):
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
-    
+    uvicorn.run(app, host="0.0.0.0", port=8000)