Update app.py

app.py

@@ -1,22 +1,24 @@
 import gradio as gr
 import logging
 from roboflow import Roboflow
-from PIL import Image, ImageDraw, ImageFont, ImageFilter
+from PIL import Image, ImageDraw
 import cv2
 import numpy as np
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver import ActionChains
+from selenium.webdriver.support.ui import Select
+import time
 import os
 from math import atan2, degrees
-from diffusers import AutoPipelineForText2Image
-import torch
 
 # Configure logging
 logging.basicConfig(
     level=logging.DEBUG,
-    format='%(asctime)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler("debug.log"),
-        logging.StreamHandler()
-    ]
+    format="%(asctime)s - %(levelname)s - %(message)s",
+    handlers=[logging.FileHandler("debug.log"), logging.StreamHandler()],
 )
 
 # Roboflow and model configuration
@@ -24,13 +26,41 @@ ROBOFLOW_API_KEY = "KUP9w62eUcD5PrrRMJsV"  # Replace with your API key
 PROJECT_NAME = "model_verification_project"
 VERSION_NUMBER = 2
 
-# Initialize the FLUX handwriting model
-device = "cuda" if torch.cuda.is_available() else "cpu"
-pipeline = AutoPipelineForText2Image.from_pretrained(
-    'black-forest-labs/FLUX.1-dev',
-    torch_dtype=torch.float16
-).to(device)
-pipeline.load_lora_weights('fofr/flux-handwriting', weight_name='lora.safetensors')
+# Selenium configuration for Calligrapher
+def get_calligrapher():
+    calli_url = "https://www.calligrapher.ai"
+    driver = webdriver.Chrome()
+    driver.maximize_window()
+    driver.get(calli_url)
+
+    # Adjust sliders for customization
+    speed_slider = WebDriverWait(driver, 20).until(EC.element_to_be_clickable((By.ID, 'speed-slider')))
+    ActionChains(driver).drag_and_drop_by_offset(speed_slider, 40, 0).perform()
+
+    bias_slider = WebDriverWait(driver, 20).until(EC.element_to_be_clickable((By.ID, 'bias-slider')))
+    ActionChains(driver).drag_and_drop_by_offset(bias_slider, 20, 0).perform()
+
+    width_slider = WebDriverWait(driver, 20).until(EC.element_to_be_clickable((By.ID, 'width-slider')))
+    ActionChains(driver).drag_and_drop_by_offset(width_slider, 20, 0).perform()
+
+    # Select handwriting style
+    select = Select(driver.find_element(By.ID, 'select-style'))
+    select.select_by_visible_text('9')  # Adjust to the desired style
+    return driver
+
+def get_calligrapher_text(driver, text, save_path):
+    text_input = WebDriverWait(driver, 20).until(EC.element_to_be_clickable((By.ID, 'text-input')))
+    text_input.clear()
+    text_input.send_keys(text)
+
+    draw_button = WebDriverWait(driver, 20).until(EC.element_to_be_clickable((By.ID, 'draw-button')))
+    draw_button.click()
+    time.sleep(3)
+
+    # Save the generated handwriting as an image
+    canvas = WebDriverWait(driver, 20).until(EC.presence_of_element_located((By.ID, 'draw-area')))
+    canvas.screenshot(save_path)
+    print(f"Handwriting saved to: {save_path}")
 
 # Function to detect paper angle within bounding box
 def detect_paper_angle(image, bounding_box):
@@ -49,9 +79,18 @@ def detect_paper_angle(image, bounding_box):
     else:
         return 0
 
-# Function to process image and overlay text
+# Function to process image and overlay handwriting
 def process_image(image, text):
     try:
+        # Initialize Selenium and generate handwriting
+        save_path = "/tmp/handwriting.png"
+        driver = get_calligrapher()
+        get_calligrapher_text(driver, text, save_path)
+        driver.quit()
+
+        # Open generated handwriting image
+        handwriting_image = Image.open(save_path).convert("RGBA")
+
         # Initialize Roboflow
         rf = Roboflow(api_key=ROBOFLOW_API_KEY)
         logging.debug("Initialized Roboflow API.")
@@ -78,39 +117,21 @@ def process_image(image, text):
         for obj in prediction['predictions']:
             white_paper_width = obj['width']
             white_paper_height = obj['height']
-            padding_x = int(white_paper_width * 0.1)
-            padding_y = int(white_paper_height * 0.1)
+
+            padding_x = int(white_paper_width * 0.1)  # 10% padding horizontally
+            padding_y = int(white_paper_height * 0.1)  # 10% padding vertically
+
             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}.")
 
             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.")
-
-            # Generate handwriting image with transparent background
-            prompt = f'HWRIT handwriting saying "{text}", neat style, black ink on transparent background'
-            generated_image = pipeline(prompt).images[0].convert("RGBA")
-            logging.debug("Generated handwriting image.")
 
-            # Resize generated handwriting to fit the detected area
-            generated_image = generated_image.resize((box_width, box_height), Image.ANTIALIAS)
+            # Resize handwriting image to fit the detected area
+            resized_handwriting = handwriting_image.resize((box_width, box_height), Image.ANTIALIAS)
 
-            # Create a mask for the generated handwriting
-            mask = generated_image.split()[3]
-
-            # Rotate the generated handwriting to match the detected paper angle
-            rotated_handwriting = generated_image.rotate(-angle, resample=Image.BICUBIC, center=(box_width // 2, box_height // 2))
-            mask = mask.rotate(-angle, resample=Image.BICUBIC, center=(box_width // 2, box_height // 2))
-
-            # Paste the rotated handwriting onto the original image
-            pil_image.paste(rotated_handwriting, (x1_padded, y1_padded), mask)
-            logging.debug("Pasted generated handwriting onto the original image.")
+            # Paste handwriting onto detected area
+            pil_image.paste(resized_handwriting, (x1_padded, y1_padded), resized_handwriting)
 
         # Save and return output image path
         output_image_path = "/tmp/output_image.png"
@@ -132,29 +153,29 @@ def gradio_inference(image, text):
     logging.error("Gradio inference failed.")
     return None, None, "An error occurred while processing the image. Please check the logs."
 
-# Gradio interface
 # Gradio interface
 interface = gr.Interface(
     fn=gradio_inference,
     inputs=[
-        gr.Image(type="pil", label="Upload an Image"),  # Upload an image
-        gr.Textbox(label="Enter Text to Overlay"),  # Enter text to overlay
+        gr.Image(type="pil", label="Upload an Image"),
+        gr.Textbox(label="Enter Text to Overlay"),
     ],
     outputs=[
-        gr.Image(label="Processed Image Preview"),  # Preview the processed image
+        gr.Image(label="Processed Image Preview"),  # Preview processed image
         gr.File(label="Download Processed Image"),  # Download the image
         gr.Textbox(label="Status"),  # Status message
     ],
-    title="Handwriting Overlay on White Paper",
+    title="Roboflow Detection with Calligrapher Text Overlay",
     description=(
-        "Upload an image with white paper detected, and enter the text to overlay. "
-        "This app will generate handwriting using the FLUX handwriting model and overlay it on the detected white paper. "
+        "Upload an image, enter text to overlay, and let the Roboflow model process the image. "
+        "Handwritten text is generated using Calligrapher.ai and overlaid on the detected white paper areas. "
         "Preview or download the output image below."
     ),
-    allow_flagging="never",  # Disables flagging
+    allow_flagging="never",
 )
 
 # Launch the Gradio app
 if __name__ == "__main__":
     logging.debug("Launching Gradio interface.")
     interface.launch(share=True)
+