Update app.py

app.py

@@ -1,3 +1,14 @@
+# Install system dependencies first
+!apt-get update
+!apt-get install -y \
+    chromium-browser \
+    chromium-chromedriver \
+    libnss3 \
+    libxss1 \
+    libatk-bridge2.0-0 \
+    libgtk-3-0 \
+    libgbm-dev
+
 import nest_asyncio
 nest_asyncio.apply()
 
@@ -23,16 +34,19 @@ logging.basicConfig(
 )
 
 # Roboflow and model configuration
-ROBOFLOW_API_KEY = "KUP9w62eUcD5PrrRMJsV"
+ROBOFLOW_API_KEY = "KUP9w62eUcD5PrrRMJsV"  # Replace with your API key if needed
 PROJECT_NAME = "model_verification_project"
 VERSION_NUMBER = 2
 
+# ----------------------------
+# Asynchronous function to generate handwriting image via Pyppeteer
+# ----------------------------
 async def _generate_handwriting_image(text_prompt, screenshot_path):
     try:
+        # Launch Chromium with the correct path
         browser = await launch(
             headless=True,
-            # If you installed chromium via apt, you can specify the path:
-            executablePath="/usr/bin/chromium-browser",
+            executablePath="/usr/bin/chromium-browser",  # Explicit path to Chromium
             args=[
                 '--no-sandbox',
                 '--disable-setuid-sandbox',
@@ -44,26 +58,42 @@ async def _generate_handwriting_image(text_prompt, screenshot_path):
             ]
         )
         page = await browser.newPage()
+        
+        # Navigate to Calligraphr
         await page.goto('https://www.calligraphr.com/en/font/', {
             'waitUntil': 'networkidle2',
-            'timeout': 60000
+            'timeout': 60000  # 60 seconds timeout
         })
+        
+        # Wait for the text input field
         await page.waitForSelector('#text-input', {'timeout': 30000})
+        
+        # Type the text prompt
         await page.type('#text-input', text_prompt)
+        
+        # Wait for rendering
         await asyncio.sleep(5)
+        
+        # Take a screenshot
         await page.screenshot({
             'path': screenshot_path,
             'clip': {'x': 100, 'y': 200, 'width': 600, 'height': 150}
         })
         return screenshot_path
+
     except Exception as e:
         logging.error(f"Pyppeteer error: {str(e)}")
         return None
+
     finally:
+        # Close the browser
         if 'browser' in locals():
             await browser.close()
 
 def generate_handwriting_image(text_prompt, screenshot_path="/tmp/handwriting.png"):
+    """
+    Synchronous wrapper around the async Pyppeteer call.
+    """
     try:
         loop = asyncio.get_event_loop()
         result = loop.run_until_complete(_generate_handwriting_image(text_prompt, screenshot_path))
@@ -72,24 +102,9 @@ def generate_handwriting_image(text_prompt, screenshot_path="/tmp/handwriting.pn
         logging.error(f"Error generating handwriting image: {e}")
         return None
 
-def detect_paper_angle(image, bounding_box):
-    x1, y1, x2, y2 = bounding_box
-    roi = np.array(image)[y1:y2, x1:x2]
-    gray = cv2.cvtColor(roi, cv2.COLOR_RGBA2GRAY)
-    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]))
-        )
-        x1_line, y1_line, x2_line, y2_line = longest_line[0]
-        dx = x2_line - x1_line
-        dy = y2_line - y1_line
-        angle = degrees(atan2(dy, dx))
-        return angle
-    else:
-        return 0
-
+# ----------------------------
+# Main processing function
+# ----------------------------
 def process_image(image, text):
     try:
         # Initialize Roboflow
@@ -113,23 +128,30 @@ def process_image(image, text):
         pil_image = image.convert("RGBA")
         logging.debug("Converted image to RGBA mode.")
 
+        # Iterate over detected objects (assumed white paper)
         for obj in prediction['predictions']:
+            # Paper dimensions
             white_paper_width = obj['width']
             white_paper_height = obj['height']
+
+            # Padding
             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.")
 
+            # (Optional) debug bounding box
             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 +168,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
             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 +176,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 output
         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}.")
@@ -162,15 +186,9 @@ def process_image(image, text):
         logging.error(f"Error during image processing: {e}")
         return None
 
-def gradio_inference(image, text):
-    logging.debug("Starting Gradio inference.")
-    result_path = process_image(image, text)
-    if result_path:
-        logging.debug("Gradio inference successful.")
-        return result_path, result_path, "Processing complete! Download the image below."
-    logging.error("Gradio inference failed.")
-    return None, None, "An error occurred while processing the image. Please check the logs."
-
+# ----------------------------
+# Gradio interface
+# ----------------------------
 interface = gr.Interface(
     fn=gradio_inference,
     inputs=[
@@ -192,4 +210,4 @@ if __name__ == "__main__":
         server_name="0.0.0.0",
         server_port=int(os.environ.get("PORT", 7860)),
         enable_queue=True
-    )
+    )