Update app.py

app.py

@@ -12,14 +12,11 @@ def get_alto_namespace(xml_file_path):
     try:
         tree = ET.parse(xml_file_path)
         root = tree.getroot()
-        # The namespace is usually defined in the root <alto> tag
-        # e.g., xmlns="http://www.loc.gov/standards/alto/v3/alto.xsd"
-        # ET.ElementTree prepends this as {namespace_uri}tag
         if '}' in root.tag:
-            return root.tag.split('}')[0] + '}' # e.g., {http://www.loc.gov/standards/alto/v3/alto.xsd}
+            return root.tag.split('}')[0] + '}'
     except ET.ParseError:
         print(f"Error parsing XML to find namespace: {xml_file_path}")
-    return '' # Default to no namespace if not found or error
+    return ''
 
 def parse_alto_xml(xml_file_path):
     """
@@ -36,18 +33,15 @@ def parse_alto_xml(xml_file_path):
         return "Error: XML file not provided or does not exist.", []
 
     try:
-        # Dynamically determine the namespace
         ns_prefix = get_alto_namespace(xml_file_path)
-        
         tree = ET.parse(xml_file_path)
         root = tree.getroot()
 
-        # Find all TextLine elements
         for text_line in root.findall(f'.//{ns_prefix}TextLine'):
             line_text_parts = []
             for string_element in text_line.findall(f'{ns_prefix}String'):
                 text = string_element.get('CONTENT')
-                if text: # Ensure text is not None
+                if text:
                     line_text_parts.append(text)
                     try:
                         hpos = int(float(string_element.get('HPOS')))
@@ -63,9 +57,8 @@ def parse_alto_xml(xml_file_path):
                         })
                     except (ValueError, TypeError) as e:
                         print(f"Warning: Could not parse coordinates for '{text}': {e}")
-                        # Add with default/placeholder values if needed, or skip
                         ocr_data.append({
-                            'text': text, 'x': 0, 'y': 0, 'w': 10, 'h': 10 # Placeholder
+                            'text': text, 'x': 0, 'y': 0, 'w': 10, 'h': 10
                         })
             if line_text_parts:
                 full_text_lines.append(" ".join(line_text_parts))
@@ -81,77 +74,61 @@ def parse_alto_xml(xml_file_path):
 def draw_ocr_on_image(image_pil, ocr_data):
     """
     Draws bounding boxes and text from ocr_data onto the image.
-    Args:
-        image_pil (PIL.Image): The image to draw on.
-        ocr_data (list): List of OCR data dictionaries.
-    Returns:
-        PIL.Image: Image with overlays.
     """
     if not image_pil or not ocr_data:
-        return image_pil # Return original image if no data or image
+        return image_pil
 
     draw = ImageDraw.Draw(image_pil)
     
-    # Try to load a font, fallback to default if not found
     try:
-        # Adjust font size based on average box height or fixed small size
-        avg_height = sum(d['h'] for d in ocr_data if d['h'] > 0) / len(ocr_data) if ocr_data else 10
-        font_size = max(8, int(avg_height * 0.6)) # Heuristic for font size
+        avg_height = sum(d['h'] for d in ocr_data if d['h'] > 0) / len(ocr_data) if ocr_data and any(d['h'] > 0 for d in ocr_data) else 10
+        font_size = max(8, int(avg_height * 0.6)) 
         font = ImageFont.truetype("arial.ttf", font_size)
-    except IOError:
+    except (IOError, ZeroDivisionError): # Added ZeroDivisionError for safety
         font = ImageFont.load_default()
-        font_size = 10 # Default font is usually small
-        print("Arial font not found, using default font.")
+        font_size = 10 
+        print("Arial font not found or issue with height calculation, using default font.")
 
     for item in ocr_data:
         x, y, w, h = item['x'], item['y'], item['w'], item['h']
         text = item['text']
-
-        # Draw bounding box
         draw.rectangle([(x, y), (x + w, y + h)], outline="red", width=2)
-        
-        # Draw text (slightly offset for better visibility, handle multi-line if necessary)
-        # Simple text drawing; for complex layouts, more sophisticated placement is needed
-        text_position = (x + 2, y - font_size - 2 if y - font_size - 2 > 0 else y + 2) # Above or below
-        
-        # Optional: Draw a small background for text for better readability
-        # text_bbox = draw.textbbox(text_position, text, font=font)
-        # draw.rectangle(text_bbox, fill="rgba(255,255,255,0.7)")
-        
+        text_position = (x + 2, y - font_size - 2 if y - font_size - 2 > 0 else y + 2)
         draw.text(text_position, text, fill="green", font=font)
         
     return image_pil
 
 # --- Gradio Interface Function ---
 
-def process_image_and_xml(image_file, xml_file, show_overlay):
+def process_image_and_xml(image_path, xml_path, show_overlay):
     """
     Main function for the Gradio interface.
+    image_path and xml_path are now file paths (strings).
     """
-    if image_file is None:
+    if image_path is None:
         return None, "Please upload an image.", None
-    if xml_file is None:
-        return Image.open(image_file.name), "Please upload an OCR XML file.", None
+    if xml_path is None:
+        # If image_path is not None, we can still show the image
+        try:
+            img_pil_orig = Image.open(image_path).convert("RGB")
+        except Exception as e:
+            return None, f"Error loading image: {e}. Also, please upload an OCR XML file.", None
+        return img_pil_orig, "Please upload an OCR XML file.", None
 
     try:
-        # Load the image
-        img_pil = Image.open(image_file.name).convert("RGB") # Ensure RGB for drawing
+        img_pil = Image.open(image_path).convert("RGB")
     except Exception as e:
         return None, f"Error loading image: {e}", None
 
-    # Parse XML
-    extracted_text, ocr_box_data = parse_alto_xml(xml_file.name)
+    extracted_text, ocr_box_data = parse_alto_xml(xml_path)
 
     overlay_image_pil = None
     if show_overlay and ocr_box_data:
-        # Create a copy for drawing to keep the original clean for the first output
         img_for_overlay = img_pil.copy()
         overlay_image_pil = draw_ocr_on_image(img_for_overlay, ocr_box_data)
-    elif show_overlay and not ocr_box_data and not extracted_text.startswith("Error"):
-        # If overlay is checked but no bounding boxes (e.g. empty XML or parsing issue not caught as error string)
+    elif show_overlay and not ocr_box_data and not (isinstance(extracted_text, str) and extracted_text.startswith("Error")):
         extracted_text += "\n(No bounding box data found or parsed for overlay)"
 
-
     return img_pil, extracted_text, overlay_image_pil
 
 
@@ -167,8 +144,9 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
 
     with gr.Row():
         with gr.Column(scale=1):
-            image_input = gr.File(label="Upload Image (PNG, JPG, etc.)", type="file") # Using type="file" for path
-            xml_input = gr.File(label="Upload ALTO XML File (.xml)", type="file")
+            # Corrected: type="filepath"
+            image_input = gr.File(label="Upload Image (PNG, JPG, etc.)", type="filepath")
+            xml_input = gr.File(label="Upload ALTO XML File (.xml)", type="filepath")
             show_overlay_checkbox = gr.Checkbox(label="Show OCR Overlay on Image", value=False)
             submit_button = gr.Button("Process Files", variant="primary")
 
@@ -178,25 +156,22 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         with gr.Column(scale=1):
             output_text = gr.Textbox(label="Extracted Plain Text", lines=15, interactive=False)
     
-    output_image_overlay = gr.Image(label="Image with OCR Overlay", type="pil", interactive=False, visible=True) # Always visible, content changes
-
-    def update_interface(image_f, xml_f, show_overlay_val):
-        if image_f is None or xml_f is None:
-            # Handle cases where one or both files are not yet uploaded
-            img_to_show = Image.open(image_f.name).convert("RGB") if image_f else None
-            text_to_show = "Please upload both an image and an XML file."
-            overlay_to_show = None
-            if image_f is None:
-                text_to_show = "Please upload an image file."
-            elif xml_f is None:
-                text_to_show = "Please upload an XML file."
-            
-            return img_to_show, text_to_show, overlay_to_show
+    output_image_overlay = gr.Image(label="Image with OCR Overlay", type="pil", interactive=False, visible=True)
 
-        img, text, overlay_img = process_image_and_xml(image_f, xml_f, show_overlay_val)
+    def update_interface(image_filepath, xml_filepath, show_overlay_val):
+        # image_filepath and xml_filepath are now strings (paths) or None
+        
+        # Initial check for None inputs to provide guidance
+        if image_filepath is None and xml_filepath is None:
+            return None, "Please upload an image and an XML file.", None
+        if image_filepath is None:
+            # xml_filepath might be present, but we need the image first
+            return None, "Please upload an image file.", None
+        # xml_filepath can be None here, process_image_and_xml handles it
+
+        # Call the main processing function
+        img, text, overlay_img = process_image_and_xml(image_filepath, xml_filepath, show_overlay_val)
         
-        # If "show overlay" is not checked, overlay_img will be None from process_image_and_xml
-        # The gr.Image component will handle None by showing nothing or a placeholder.
         return img, text, overlay_img
 
     submit_button.click(
@@ -205,7 +180,6 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
         outputs=[output_image_orig, output_text, output_image_overlay]
     )
     
-    # Also update if the checkbox changes, provided files are already there
     show_overlay_checkbox.change(
         fn=update_interface,
         inputs=[image_input, xml_input, show_overlay_checkbox],
@@ -243,22 +217,21 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
 
 
 if __name__ == "__main__":
-    # To test, create a dummy image and use the XML from your example.
-    # Save the XML content you provided as "189819724.34.xml" in the same directory.
-    # Create a dummy image, e.g., "dummy_image.png"
     try:
-        from PIL import Image as PImage
-        img = PImage.new('RGB', (2394, 3612), color = 'lightgray') # Dimensions from example XML
-        # Optionally add some text to image if you want to see if boxes align (roughly)
-        # d = ImageDraw.Draw(img)
-        # d.text((500,200), "Test Image", fill=(0,0,0))
+        # from PIL import Image as PImage # Already imported as Image
+        img = Image.new('RGB', (2394, 3612), color = 'lightgray')
         img.save("dummy_image.png")
         print("Created dummy_image.png for testing.")
         
-        # Ensure the example XML file (189819724.34.xml) exists in the same directory
-        # or provide the correct path if it's elsewhere.
-        if not os.path.exists("189819724.34.xml"):
-            print("WARNING: Example XML '189819724.34.xml' not found. Please create it or upload your own.")
+        # Make sure your example XML is named 189819724.34.xml and is in the same directory
+        # Or, create it if it doesn't exist with the content you provided
+        example_xml_filename = "189819724.34.xml"
+        if not os.path.exists(example_xml_filename):
+            print(f"WARNING: Example XML '{example_xml_filename}' not found. Please create it or upload your own.")
+            # You could also write the example XML content here if needed for testing
+            # with open(example_xml_filename, "w") as f:
+            #     f.write("""<?xml version="1.0" encoding="UTF-8"?> ...your full XML... </alto>""")
+
 
     except ImportError:
         print("Pillow not installed, can't create dummy image.")