Update app.py

app.py

@@ -8,8 +8,7 @@ import os
 from math import atan2, degrees
 import asyncio
 from pyppeteer import launch
-import nest_asyncio
-nest_asyncio.apply()
+import multiprocessing
 
 # Configure logging
 logging.basicConfig(
@@ -25,67 +24,66 @@ logging.basicConfig(
 ROBOFLOW_API_KEY = "KUP9w62eUcD5PrrRMJsV"  # Replace with your API key
 PROJECT_NAME = "model_verification_project"
 VERSION_NUMBER = 2
-# FONT_PATH is no longer used since we generate handwriting via Calligraphr
-# FONT_PATH = "./STEVEHANDWRITING-REGULAR.TTF"
 
 # ----------------------------
-# Pyppeteer: Generate handwriting image via Calligraphr
+# New: Run Pyppeteer code in a separate process
 # ----------------------------
-async def generate_handwriting_text_image(text_prompt, screenshot_path):
-    browser = await launch(headless=True, args=['--no-sandbox', '--disable-setuid-sandbox'])
-    page = await browser.newPage()
-    
-    # Navigate to Calligraphr (adjust URL if needed)
-    await page.goto('https://www.calligraphr.com/en/font/', {'waitUntil': 'networkidle2'})
-    
-    # Wait for the text input to be available and type the text
-    await page.waitForSelector('#text-input')
-    await page.type('#text-input', text_prompt)
-    
-    # Wait for the page to render the handwriting preview
-    await asyncio.sleep(2)
-    
-    # Take a screenshot of the area containing the rendered handwriting text.
-    # (Adjust the clip values if needed to capture the correct area.)
-    await page.screenshot({
-        'path': screenshot_path,
-        'clip': {'x': 100, 'y': 200, 'width': 600, 'height': 150}
-    })
-    
-    await browser.close()
-    logging.debug(f"Calligraphr screenshot saved at {screenshot_path}")
-    return screenshot_path
+def generate_handwriting_image_process(text_prompt, screenshot_path, return_dict):
+    """
+    This function runs in a separate process so that the Pyppeteer code
+    runs in the main thread of that process.
+    """
+    import asyncio
+    from pyppeteer import launch
+
+    async def _generate():
+        browser = await launch(headless=True, args=['--no-sandbox', '--disable-setuid-sandbox'])
+        page = await browser.newPage()
+        await page.goto('https://www.calligraphr.com/en/font/', {'waitUntil': 'networkidle2'})
+        await page.waitForSelector('#text-input')
+        await page.type('#text-input', text_prompt)
+        await asyncio.sleep(2)  # Wait for the handwriting preview to render
+
+        # Adjust these clip dimensions as needed for the correct area
+        await page.screenshot({
+            'path': screenshot_path,
+            'clip': {'x': 100, 'y': 200, 'width': 600, 'height': 150}
+        })
+        await browser.close()
+        return screenshot_path
+
+    # Create a new event loop for this process
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    result = loop.run_until_complete(_generate())
+    return_dict['result'] = result
+
+def get_handwriting_image(text_prompt, screenshot_path="/tmp/handwriting.png"):
+    manager = multiprocessing.Manager()
+    return_dict = manager.dict()
+    process = multiprocessing.Process(target=generate_handwriting_image_process, args=(text_prompt, screenshot_path, return_dict))
+    process.start()
+    process.join()
+    return return_dict.get('result', None)
 
 # ----------------------------
 # Helper: Detect paper angle within bounding box
 # ----------------------------
 def detect_paper_angle(image, bounding_box):
     x1, y1, x2, y2 = bounding_box
-
-    # Crop the region of interest (ROI) based on the bounding box
     roi = np.array(image)[y1:y2, x1:x2]
-
-    # Convert ROI to grayscale
     gray = cv2.cvtColor(roi, cv2.COLOR_RGBA2GRAY)
-
-    # Apply edge detection
     edges = cv2.Canny(gray, 50, 150)
-
-    # Detect lines using Hough Line Transformation
     lines = cv2.HoughLinesP(edges, 1, np.pi / 180, threshold=100, minLineLength=50, maxLineGap=10)
-
     if lines is not None:
-        # Find the longest line (most prominent edge)
         longest_line = max(lines, key=lambda line: np.linalg.norm((line[0][2] - line[0][0], line[0][3] - line[0][1])))
         x1_line, y1_line, x2_line, y2_line = longest_line[0]
-
-        # Calculate the angle of the line relative to the horizontal axis
         dx = x2_line - x1_line
         dy = y2_line - y1_line
         angle = degrees(atan2(dy, dx))
-        return angle  # Angle of the paper
+        return angle
     else:
-        return 0  # Default to no rotation if no lines are found
+        return 0
 
 # ----------------------------
 # Main processing function
@@ -110,62 +108,44 @@ def process_image(image, text):
         prediction = model.predict(input_image_path, confidence=70, overlap=50).json()
         logging.debug(f"Inference result: {prediction}")
 
-        # Open the image for processing
         pil_image = image.convert("RGBA")
         logging.debug("Converted image to RGBA mode.")
 
-        # Iterate over detected objects (assumed white papers)
+        # Process each detected object (assumed to be white paper)
         for obj in prediction['predictions']:
-            # Use white paper dimensions from the prediction
             white_paper_width = obj['width']
             white_paper_height = obj['height']
-
-            # Set padding (adjust percentages as needed)
             padding_x = int(white_paper_width * 0.1)
             padding_y = int(white_paper_height * 0.1)
-
             box_width = white_paper_width - 2 * padding_x
             box_height = white_paper_height - 2 * padding_y
             logging.debug(f"Padded white paper dimensions: width={box_width}, height={box_height}.")
 
-            # Calculate padded coordinates
             x1_padded = int(obj['x'] - white_paper_width / 2 + padding_x)
             y1_padded = int(obj['y'] - white_paper_height / 2 + padding_y)
             x2_padded = int(obj['x'] + white_paper_width / 2 - padding_x)
             y2_padded = int(obj['y'] + white_paper_height / 2 - padding_y)
 
-            # Detect paper angle
             angle = detect_paper_angle(np.array(image), (x1_padded, y1_padded, x2_padded, y2_padded))
             logging.debug(f"Detected paper angle: {angle} degrees.")
 
-            # For debugging: draw the bounding box (optional)
+            # For debugging: draw bounding box (optional)
             debug_layer = pil_image.copy()
             debug_draw = ImageDraw.Draw(debug_layer)
             debug_draw.rectangle([(x1_padded, y1_padded), (x2_padded, y2_padded)], outline="red", width=3)
             debug_layer.save("/tmp/debug_bounding_box.png")
             logging.debug("Saved bounding box debug image to /tmp/debug_bounding_box.png.")
 
-            # --------------------------------------------
-            # New: Generate handwriting image via Calligraphr
-            # --------------------------------------------
-            handwriting_path = "/tmp/handwriting.png"
-            try:
-                # Run the async Pyppeteer function to generate handwriting
-                handwriting_path = asyncio.run(generate_handwriting_text_image(text, handwriting_path))
-            except Exception as e:
-                logging.error(f"Error generating handwriting image: {e}")
-                continue  # Optionally, you could fall back to another method here
-
-            # Open the generated handwriting image
+            # Generate handwriting image using the separate process
+            handwriting_path = get_handwriting_image(text, "/tmp/handwriting.png")
+            if not handwriting_path:
+                logging.error("Handwriting image generation failed.")
+                continue
+
             handwriting_img = Image.open(handwriting_path).convert("RGBA")
-            # Resize handwriting image to fit the white paper box
             handwriting_img = handwriting_img.resize((box_width, box_height), Image.ANTIALIAS)
-
-            # Rotate the handwriting image to align with the detected paper angle
             rotated_handwriting = handwriting_img.rotate(-angle, resample=Image.BICUBIC, expand=True)
 
-            # Composite the rotated handwriting image onto a transparent layer,
-            # then overlay it on the original image
             text_layer = Image.new("RGBA", pil_image.size, (255, 255, 255, 0))
             paste_x = int(obj['x'] - rotated_handwriting.size[0] / 2)
             paste_y = int(obj['y'] - rotated_handwriting.size[1] / 2)
@@ -173,7 +153,6 @@ def process_image(image, text):
             pil_image = Image.alpha_composite(pil_image, text_layer)
             logging.debug("Handwriting layer composited onto the original image.")
 
-        # Save and return output image path
         output_image_path = "/tmp/output_image.png"
         pil_image.convert("RGB").save(output_image_path)
         logging.debug(f"Output image saved to {output_image_path}.")
@@ -205,16 +184,15 @@ interface = gr.Interface(
         gr.Textbox(label="Enter Text to Overlay")
     ],
     outputs=[
-        gr.Image(label="Processed Image Preview"),  # Preview processed image
-        gr.File(label="Download Processed Image"),    # Download the image
-        gr.Textbox(label="Status")                     # Status message
+        gr.Image(label="Processed Image Preview"),
+        gr.File(label="Download Processed Image"),
+        gr.Textbox(label="Status")
     ],
     title="Roboflow Detection with Handwriting Overlay",
-    description="Upload an image, enter text to overlay. The Roboflow model detects the white paper area, and a handwriting image is generated via Calligraphr using Pyppeteer. The output image is composited accordingly.",
+    description="Upload an image and enter text to overlay. The Roboflow model detects the white paper area, and a handwriting image is generated via Calligraphr using Pyppeteer. The output image is composited accordingly.",
     allow_flagging="never"
 )
 
-# Launch the Gradio app
 if __name__ == "__main__":
     logging.debug("Launching Gradio interface.")
     interface.launch(share=True)