Update app.py

app.py

@@ -7,13 +7,12 @@ import numpy as np
 import os
 from math import atan2, degrees
 import asyncio
-from pyppeteer import launch
 import multiprocessing
 
 # Configure logging
 logging.basicConfig(
     level=logging.DEBUG,
-    format='%(asctime)s - %(levelname)s - %(message)s',
+    format="%(asctime)s - %(levelname)s - %(message)s",
     handlers=[
         logging.FileHandler("debug.log"),
         logging.StreamHandler()
@@ -21,30 +20,40 @@ logging.basicConfig(
 )
 
 # Roboflow and model configuration
-ROBOFLOW_API_KEY = "KUP9w62eUcD5PrrRMJsV"  # Replace with your API key
+ROBOFLOW_API_KEY = "KUP9w62eUcD5PrrRMJsV"  # Replace with your API key if needed
 PROJECT_NAME = "model_verification_project"
 VERSION_NUMBER = 2
 
 # ----------------------------
-# New: Run Pyppeteer code in a separate process
+# Function to generate handwriting image using Pyppeteer in a separate process
 # ----------------------------
 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.
+    This function runs in a separate process so that Pyppeteer's signal handling
+    works correctly in its main thread.
     """
     import asyncio
     from pyppeteer import launch
 
     async def _generate():
-        browser = await launch(headless=True, args=['--no-sandbox', '--disable-setuid-sandbox'])
+        # Launch Chromium with additional flags for containerized environments
+        browser = await launch(
+            headless=True,
+            args=[
+                '--no-sandbox',
+                '--disable-setuid-sandbox',
+                '--disable-dev-shm-usage',
+                '--disable-gpu',
+                '--single-process'
+            ]
+        )
         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
+        # Adjust the clip values as needed to capture the proper area of the page
         await page.screenshot({
             'path': screenshot_path,
             'clip': {'x': 100, 'y': 200, 'width': 600, 'height': 150}
@@ -55,13 +64,25 @@ def generate_handwriting_image_process(text_prompt, screenshot_path, return_dict
     # 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
+    try:
+        result = loop.run_until_complete(_generate())
+        return_dict['result'] = result
+    except Exception as e:
+        logging.error("Error in handwriting generation process: " + str(e))
+        return_dict['result'] = None
+    finally:
+        loop.close()
 
 def get_handwriting_image(text_prompt, screenshot_path="/tmp/handwriting.png"):
+    """
+    Starts a separate process to generate a handwriting image and returns the image path.
+    """
     manager = multiprocessing.Manager()
     return_dict = manager.dict()
-    process = multiprocessing.Process(target=generate_handwriting_image_process, args=(text_prompt, screenshot_path, return_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)
@@ -76,7 +97,9 @@ def detect_paper_angle(image, bounding_box):
     edges = cv2.Canny(gray, 50, 150)
     lines = cv2.HoughLinesP(edges, 1, np.pi / 180, threshold=100, minLineLength=50, maxLineGap=10)
     if lines is not None:
-        longest_line = max(lines, key=lambda line: np.linalg.norm((line[0][2] - line[0][0], line[0][3] - line[0][1])))
+        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]
         dx = x2_line - x1_line
         dy = y2_line - y1_line
@@ -108,6 +131,7 @@ def process_image(image, text):
         prediction = model.predict(input_image_path, confidence=70, overlap=50).json()
         logging.debug(f"Inference result: {prediction}")
 
+        # Convert image for processing
         pil_image = image.convert("RGBA")
         logging.debug("Converted image to RGBA mode.")
 
@@ -126,10 +150,11 @@ def process_image(image, text):
             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 bounding box (optional)
+            # (Optional) Save a debug image with the bounding box drawn
             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)
@@ -146,6 +171,7 @@ def process_image(image, text):
             handwriting_img = handwriting_img.resize((box_width, box_height), Image.ANTIALIAS)
             rotated_handwriting = handwriting_img.rotate(-angle, resample=Image.BICUBIC, expand=True)
 
+            # Composite the handwriting onto 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)
@@ -153,6 +179,7 @@ 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 the output image
         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}.")