Update app.py

app.py

@@ -76,7 +76,7 @@ logging.basicConfig(
 # -------------------------------------------------------------------------
 # 🤖 Roboflow configuration
 # -------------------------------------------------------------------------
-ROBOFLOW_API_KEY = "JKuvVbqDgv4mBdVM0fUE"  # ✅ your key
+ROBOFLOW_API_KEY = "u5LX112EBlNmzYoofvPL"  # ✅ your key
 PROJECT_NAME = "model_verification_project"
 VERSION_NUMBER = 2
 
@@ -88,6 +88,41 @@ os.environ["ROBOFLOW_API_KEY"] = ROBOFLOW_API_KEY
 # -------------------------------------------------------------------------
 HANDWRITING_MODEL_ENDPOINT = "3morrrrr/Handwriting_Model_Inf"
 
+# Cached client instance (lazy init)
+_handwriting_client = None
+
+def get_handwriting_client(max_retries=5, retry_delay=3):
+    """
+    Lazily initialize and cache the handwriting Client.
+
+    Retries a few times in case the Hugging Face Space is cold-starting,
+    to avoid crashing the whole app on startup.
+    """
+    global _handwriting_client
+    if _handwriting_client is not None:
+        return _handwriting_client
+
+    last_error = None
+    for attempt in range(1, max_retries + 1):
+        try:
+            logging.info(
+                f"Initializing handwriting client "
+                f"(attempt {attempt}/{max_retries}) for {HANDWRITING_MODEL_ENDPOINT}"
+            )
+            _handwriting_client = Client(HANDWRITING_MODEL_ENDPOINT)
+            logging.info("Handwriting client initialized successfully.")
+            return _handwriting_client
+        except Exception as e:
+            last_error = e
+            logging.warning(
+                f"Failed to initialize handwriting client "
+                f"(attempt {attempt}/{max_retries}): {e}"
+            )
+            time.sleep(retry_delay)
+
+    logging.error("Exceeded max retries while initializing handwriting client.")
+    raise last_error
+
 # -------------------------------------------------------------------------
 # ⚙️ General configuration
 # -------------------------------------------------------------------------
@@ -137,12 +172,12 @@ def save_debug_image(image, filename, text=None):
     return path
 
 # -------------------------------------------------------------------------
-# 🧠 Load Roboflow + HuggingFace models
+# 🧠 Load Roboflow models
 # -------------------------------------------------------------------------
 rf = Roboflow(api_key=ROBOFLOW_API_KEY)
 project = rf.workspace().project(PROJECT_NAME)
 model = project.version(VERSION_NUMBER).model
-client = Client(HANDWRITING_MODEL_ENDPOINT)
+
 # Improved function to detect paper angle
 def detect_paper_angle(image, bounding_box):
     """
@@ -242,8 +277,6 @@ def detect_paper_angle(image, bounding_box):
     except Exception as e:
         logging.warning(f"Error in adaptive threshold method: {str(e)}")
     
-
-    
     # Method 3: Fall back to Canny edge detection with improved parameters
     try:
         # Apply Gaussian blur to reduce noise
@@ -278,18 +311,22 @@ def detect_paper_angle(image, bounding_box):
             if DEBUG:
                 lines_debug = roi.copy() if len(roi.shape) == 3 else cv2.cvtColor(roi, cv2.COLOR_GRAY2RGB)
                 for line in lines:
-                    x1, y1, x2, y2 = line[0]
-                    cv2.line(lines_debug, (x1, y1), (x2, y2), (0, 255, 255), 2)
+                    x1_l, y1_l, x2_l, y2_l = line[0]
+                    cv2.line(lines_debug, (x1_l, y1_l), (x2_l, y2_l), (0, 255, 255), 2)
                 cv2.imwrite(os.path.join(DEBUG_DIR, f"hough_lines_{int(time.time())}.png"), lines_debug)
             
             # Find the longest line
-            longest_line = max(lines, key=lambda line: 
-                              np.linalg.norm((line[0][2] - line[0][0], line[0][3] - line[0][1])))
-            x1, y1, x2, y2 = longest_line[0]
+            longest_line = max(
+                lines,
+                key=lambda line: np.linalg.norm(
+                    (line[0][2] - line[0][0], line[0][3] - line[0][1])
+                )
+            )
+            x1_l, y1_l, x2_l, y2_l = longest_line[0]
             
             # Calculate the angle of the line
-            dx = x2 - x1
-            dy = y2 - y1
+            dx = x2_l - x1_l
+            dy = y2_l - y1_l
             angle = degrees(atan2(dy, dx))
             
             # Normalize angle to be between -45 and 45 degrees
@@ -323,16 +360,17 @@ def extract_text_from_handwriting(image_path):
         if DEBUG:
             debug_img = img.copy()
             draw = ImageDraw.Draw(debug_img)
-            draw.text((10, 10), f"Original Handwriting: {img.width}x{img.height}", 
-                      fill=(255, 0, 0, 255))
+            draw.text(
+                (10, 10),
+                f"Original Handwriting: {img.width}x{img.height}",
+                fill=(255, 0, 0, 255)
+            )
             debug_img.save(os.path.join(DEBUG_DIR, "original_handwriting.png"))
         
         # Get the original dimensions
         original_width, original_height = img.width, img.height
         
         # Get the bounding box of non-zero areas (text content)
-        # Convert to grayscale first to better detect handwriting
-        # This is a more aggressive approach to find the text content
         gray_img = img.convert('L')
         # Normalize the image to make text stand out
         thresh = 240  # Higher threshold to catch light text
@@ -380,9 +418,15 @@ def extract_text_from_handwriting(image_path):
                 # Draw original bounding box
                 draw.rectangle(bbox, outline=(255, 0, 0, 255), width=2)
                 # Add text annotation
-                draw.text((bbox[0], bbox[1] - 15), 
-                         f"Original: {original_width}x{original_height}, Text: {text_width}x{text_height} ({text_dimensions['text_percentage']['width']:.1f}%)", 
-                         fill=(255, 0, 0, 255))
+                draw.text(
+                    (bbox[0], bbox[1] - 15),
+                    (
+                        f"Original: {original_width}x{original_height}, "
+                        f"Text: {text_width}x{text_height} "
+                        f"({text_dimensions['text_percentage']['width']:.1f}%)"
+                    ),
+                    fill=(255, 0, 0, 255)
+                )
                 debug_img.save(debug_image_path)
                 # Save for reference
                 debug_img.save(os.path.join(DEBUG_DIR, "text_extraction.png"))
@@ -393,7 +437,7 @@ def extract_text_from_handwriting(image_path):
             # If no content found, just return the original
             shutil.copy(image_path, temp_image_path)
             text_dimensions['error'] = "No text content detected"
-            logging.warning(f"No text content detected in handwriting image")
+            logging.warning("No text content detected in handwriting image")
             return image_path, None, text_dimensions
     except Exception as e:
         logging.error(f"Error extracting text from image: {str(e)}")
@@ -411,16 +455,16 @@ def process_image(image, text, style, bias, color, stroke_width):
         image.save(input_debug_path)
         
         # Detect papers using Roboflow first to get paper dimensions for text formatting
-        rf = Roboflow(api_key=ROBOFLOW_API_KEY)
-        project = rf.workspace().project(PROJECT_NAME)
-        model = project.version(VERSION_NUMBER).model
+        rf_local = Roboflow(api_key=ROBOFLOW_API_KEY)
+        project_local = rf_local.workspace().project(PROJECT_NAME)
+        model_local = project_local.version(VERSION_NUMBER).model
         
         # Save input image temporarily
         input_image_path = "/tmp/input_image.jpg"
         image.save(input_image_path)
         
         # Perform inference to detect papers
-        prediction = model.predict(input_image_path, confidence=70, overlap=50).json()
+        prediction = model_local.predict(input_image_path, confidence=70, overlap=50).json()
         num_papers = len(prediction['predictions'])
         logging.debug(f"Detected {num_papers} papers")
         
@@ -430,8 +474,8 @@ def process_image(image, text, style, bias, color, stroke_width):
             
         # Format text based on the first detected paper dimensions
         if len(prediction['predictions']) > 0:
-            obj = prediction['predictions'][0]
-            paper_width = obj['width']
+            obj0 = prediction['predictions'][0]
+            paper_width = obj0['width']
             
             # Calculate usable width (accounting for padding)
             padding_x = int(paper_width * 0.1)
@@ -446,7 +490,7 @@ def process_image(image, text, style, bias, color, stroke_width):
         
         # 1. Generate handwritten text using the Hugging Face model with formatted text
         logging.debug(f"Calling handwriting model with formatted text: '{formatted_text}'")
-        handwriting_client = Client(HANDWRITING_MODEL_ENDPOINT)
+        handwriting_client = get_handwriting_client()
         result = handwriting_client.predict(
             formatted_text,   # Use formatted text instead of original
             style,            # handwriting style
@@ -499,7 +543,7 @@ def process_image(image, text, style, bias, color, stroke_width):
             # Log paper dimensions
             logging.debug(f"Paper {i+1} dimensions: {paper_width}x{paper_height} at position ({obj['x']}, {obj['y']})")
             
-            # Add padding (10%)
+            # Add padding (20%)
             padding_x = int(paper_width * 0.20)
             padding_y = int(paper_height * 0.20)
             
@@ -507,7 +551,7 @@ def process_image(image, text, style, bias, color, stroke_width):
             box_width = paper_width - 2 * padding_x
             box_height = paper_height - 2 * padding_y
             
-            # Calculate paper coordinates
+            # Calculate text box coordinates
             x1 = int(obj['x'] - paper_width / 2 + padding_x)
             y1 = int(obj['y'] - paper_height / 2 + padding_y)
             x2 = int(obj['x'] + paper_width / 2 - padding_x)
@@ -515,15 +559,22 @@ def process_image(image, text, style, bias, color, stroke_width):
             
             # Draw paper boundary on debug image
             paper_box = [(obj['x'] - paper_width/2, obj['y'] - paper_height/2), 
-                        (obj['x'] + paper_width/2, obj['y'] + paper_height/2)]
+                         (obj['x'] + paper_width/2, obj['y'] + paper_height/2)]
             debug_draw.rectangle(paper_box, outline=(0, 255, 0, 255), width=3)
-            debug_draw.text((paper_box[0][0], paper_box[0][1] - 15), 
-                           f"Paper {i+1}: {paper_width}x{paper_height}", fill=(0, 255, 0, 255))
+            debug_draw.text(
+                (paper_box[0][0], paper_box[0][1] - 15),
+                f"Paper {i+1}: {paper_width}x{paper_height}",
+                fill=(0, 255, 0, 255)
+            )
             
             # Draw usable area on debug image
             usable_box = [(x1, y1), (x2, y2)]
             debug_draw.rectangle(usable_box, outline=(255, 255, 0, 255), width=2)
-            debug_draw.text((x1, y1 - 15), f"Usable: {box_width}x{box_height}", fill=(255, 255, 0, 255))
+            debug_draw.text(
+                (x1, y1 - 15),
+                f"Usable: {box_width}x{box_height}",
+                fill=(255, 255, 0, 255)
+            )
             
             # Paper coordinates for detecting the actual paper orientation
             paper_x1 = int(obj['x'] - paper_width / 2)
@@ -532,35 +583,37 @@ def process_image(image, text, style, bias, color, stroke_width):
             paper_y2 = int(obj['y'] + paper_height / 2)
             
             # Detect the actual paper angle (not just the bounding box)
-            angle = detect_paper_angle(np.array(image), (paper_x1, paper_y1, paper_x2, paper_y2))
+            angle = detect_paper_angle(
+                np.array(image),
+                (paper_x1, paper_y1, paper_x2, paper_y2)
+            )
             logging.debug(f"Paper {i+1} angle: {angle} degrees")
             
             # Add a debug visualization of the detected angle
             debug_draw.line(
-                [(obj['x'], obj['y']), 
-                 (obj['x'] + 50 * np.cos(np.radians(angle)), 
-                  obj['y'] + 50 * np.sin(np.radians(angle)))], 
-                fill=(255, 0, 0, 255), width=3
+                [
+                    (obj['x'], obj['y']),
+                    (
+                        obj['x'] + 50 * np.cos(np.radians(angle)),
+                        obj['y'] + 50 * np.sin(np.radians(angle))
+                    )
+                ],
+                fill=(255, 0, 0, 255),
+                width=3
             )
             debug_draw.text(
-                (obj['x'] + 60, obj['y']), 
-                f"Angle: {angle:.1f}°", 
+                (obj['x'] + 60, obj['y']),
+                f"Angle: {angle:.1f}°",
                 fill=(255, 0, 0, 255)
             )
             
             # Calculate the initial size while maintaining aspect ratio
             handwriting_aspect = handwriting_img.width / handwriting_img.height
             
-            # ENHANCED SCALING APPROACH:
-            # 1. Start with the full paper width for maximum readability
-            # 2. Then apply the scale factor to make it even larger
-            # 3. Ensure minimum width percentage
-            # 4. Only adjust if it doesn't fit the height
-            
             # Start with the full usable width
             target_width = box_width
             
-            # Apply scale factor to make text larger (but don't exceed usable width)
+            # Apply scale factor to make text larger (but don't exceed 2x usable width)
             target_width = min(int(target_width * TEXT_SCALE_FACTOR), box_width * 2)
             
             # Calculate height based on aspect ratio
@@ -582,24 +635,41 @@ def process_image(image, text, style, bias, color, stroke_width):
                     target_width = int(target_height * handwriting_aspect)
             
             # Log sizing calculations
-            logging.debug(f"Paper {i+1} usable area: {box_width}x{box_height}")
-            logging.debug(f"Text resizing: original={handwriting_img.width}x{handwriting_img.height}, " +
-                         f"target={target_width}x{target_height} (scale factor={TEXT_SCALE_FACTOR})")
+            logging.debug(
+                f"Paper {i+1} usable area: {box_width}x{box_height}"
+            )
+            logging.debug(
+                "Text resizing: original="
+                f"{handwriting_img.width}x{handwriting_img.height}, "
+                f"target={target_width}x{target_height} "
+                f"(scale factor={TEXT_SCALE_FACTOR})"
+            )
             
             # Draw text area on debug image
             text_center_x = x1 + box_width // 2
             text_center_y = y1 + box_height // 2
-            text_box = [(text_center_x - target_width // 2, text_center_y - target_height // 2),
-                       (text_center_x + target_width // 2, text_center_y + target_height // 2)]
+            text_box = [
+                (text_center_x - target_width // 2, text_center_y - target_height // 2),
+                (text_center_x + target_width // 2, text_center_y + target_height // 2)
+            ]
             debug_draw.rectangle(text_box, outline=(255, 0, 255, 255), width=2)
-            debug_draw.text((text_box[0][0], text_box[0][1] - 15), 
-                          f"Text: {target_width}x{target_height}", fill=(255, 0, 255, 255))
+            debug_draw.text(
+                (text_box[0][0], text_box[0][1] - 15),
+                f"Text: {target_width}x{target_height}",
+                fill=(255, 0, 255, 255)
+            )
             
             # Resize the handwriting with the calculated dimensions
-            resized_handwriting = handwriting_img.resize((target_width, target_height), Image.LANCZOS)
+            resized_handwriting = handwriting_img.resize(
+                (target_width, target_height),
+                Image.LANCZOS
+            )
             
             # Save resized handwriting for reference
-            resized_hw_debug_path = os.path.join(DEBUG_DIR, f"{timestamp}_resized_handwriting_{i+1}.png")
+            resized_hw_debug_path = os.path.join(
+                DEBUG_DIR,
+                f"{timestamp}_resized_handwriting_{i+1}.png"
+            )
             resized_handwriting.save(resized_hw_debug_path)
             
             # Create a transparent layer for the handwriting
@@ -613,35 +683,48 @@ def process_image(image, text, style, bias, color, stroke_width):
             handwriting_layer.paste(resized_handwriting, (paste_x, paste_y), resized_handwriting)
             
             # Add to debug image
-            debug_paste_box = [(paste_x, paste_y), (paste_x + target_width, paste_y + target_height)]
+            debug_paste_box = [
+                (paste_x, paste_y),
+                (paste_x + target_width, paste_y + target_height)
+            ]
             debug_draw.rectangle(debug_paste_box, outline=(0, 0, 255, 255), width=1)
             
             # Create another debug visualization showing rotation center and angle
-            rotation_debug_path = os.path.join(DEBUG_DIR, f"{timestamp}_rotation_paper_{i+1}.png")
+            rotation_debug_path = os.path.join(
+                DEBUG_DIR,
+                f"{timestamp}_rotation_paper_{i+1}.png"
+            )
             rotation_debug = handwriting_layer.copy()
             rotation_debug_draw = ImageDraw.Draw(rotation_debug)
             rotation_debug_draw.line(
-                [(obj['x'] - 50, obj['y']), (obj['x'] + 50, obj['y'])], 
-                fill=(255, 0, 0, 255), width=1
+                [(obj['x'] - 50, obj['y']), (obj['x'] + 50, obj['y'])],
+                fill=(255, 0, 0, 255),
+                width=1
             )
             rotation_debug_draw.line(
-                [(obj['x'], obj['y'] - 50), (obj['x'], obj['y'] + 50)], 
-                fill=(255, 0, 0, 255), width=1
+                [(obj['x'], obj['y'] - 50), (obj['x'], obj['y'] + 50)],
+                fill=(255, 0, 0, 255),
+                width=1
             )
             rotation_debug_draw.ellipse(
-                [(obj['x'] - 5, obj['y'] - 5), (obj['x'] + 5, obj['y'] + 5)], 
+                [(obj['x'] - 5, obj['y'] - 5), (obj['x'] + 5, obj['y'] + 5)],
                 fill=(255, 0, 0, 255)
             )
             rotation_debug_draw.text(
-                (obj['x'] + 10, obj['y'] + 10), 
-                f"Rotation center: ({obj['x']}, {obj['y']})\nAngle: {angle:.1f}°", 
+                (obj['x'] + 10, obj['y'] + 10),
+                (
+                    f"Rotation center: ({obj['x']}, {obj['y']})\n"
+                    f"Angle: {angle:.1f}°"
+                ),
                 fill=(255, 0, 0, 255)
             )
             rotation_debug.save(rotation_debug_path)
             
             # Rotate to match paper angle
             rotated_layer = handwriting_layer.rotate(
-                -angle, resample=Image.BICUBIC, center=(obj['x'], obj['y'])
+                -angle,
+                resample=Image.BICUBIC,
+                center=(obj['x'], obj['y'])
             )
             
             # Composite onto original image
@@ -681,12 +764,15 @@ def process_image(image, text, style, bias, color, stroke_width):
                     'width': obj['width'],
                     'height': obj['height'],
                     'position': (obj['x'], obj['y']),
-                    'detected_angle': detect_paper_angle(np.array(image), (
-                        int(obj['x'] - obj['width'] / 2),
-                        int(obj['y'] - obj['height'] / 2),
-                        int(obj['x'] + obj['width'] / 2),
-                        int(obj['y'] + obj['height'] / 2)
-                    ))
+                    'detected_angle': detect_paper_angle(
+                        np.array(image),
+                        (
+                            int(obj['x'] - obj['width'] / 2),
+                            int(obj['y'] - obj['height'] / 2),
+                            int(obj['x'] + obj['width'] / 2),
+                            int(obj['y'] + obj['height'] / 2)
+                        )
+                    )
                 } for i, obj in enumerate(prediction['predictions'])
             ],
             'debug_overlay': debug_path,
@@ -779,9 +865,13 @@ interface = gr.Interface(
         gr.Textbox(label="Debug Info", lines=10)
     ],
     title="Handwritten Text on Paper Detection - Debug Version",
-    description="Upload an image with paper, enter text, and the app will detect the paper and overlay handwritten text on it. Debug info will show what's happening behind the scenes."
+    description=(
+        "Upload an image with paper, enter text, and the app will detect the paper "
+        "and overlay handwritten text on it. Debug info will show what's happening "
+        "behind the scenes."
+    )
 )
 
 # Launch app
 if __name__ == "__main__":
-    interface.launch(share=True)
+    interface.launch(share=True)