Update app.py

app.py

@@ -3,7 +3,7 @@ import numpy as np
 import json
 import gradio as gr
 import os
-from lxml import etree
+import xml.etree.ElementTree as ET
 
 # ---------------- Helper functions ----------------
 def get_rotated_rect_corners(x, y, w, h, rotation_deg):
@@ -36,48 +36,33 @@ def detect_and_match(img1_gray, img2_gray, method="SIFT", ratio_thresh=0.78):
     good = [m for m,n in raw_matches if m.distance < ratio_thresh*n.distance]
     return kp1, kp2, good
 
-# ---------------- XML overlay helper using lxml ----------------
-def extract_points_lxml(xml_path):
-    tree = etree.parse(xml_path)
+def parse_xml_points(xml_file):
+    tree = ET.parse(xml_file)
     root = tree.getroot()
-    transform = root.find('.//transform')
-    points = {}
-    for pt in transform.findall('.//point'):
-        pt_type = pt.attrib['type']
-        x = float(pt.attrib['x'])
-        y = float(pt.attrib['y'])
-        points[pt_type] = (x,y)
-    return points
-
-def draw_polygon_on_image(img, points_dict):
-    ordered_points = ['TopLeft','TopRight','BottomRight','BottomLeft']
-    polygon = [points_dict[pt] for pt in ordered_points]
-    pts = np.array(polygon, np.int32).reshape((-1,1,2))
-    img_copy = img.copy()
-    cv2.polylines(img_copy, [pts], isClosed=True, color=(0,0,255), thickness=3)
-    for px, py in polygon:
-        cv2.circle(img_copy, (int(px),int(py)), 5, (255,0,0), -1)
-    return img_copy
+    points=[]
+    for pt_type in ["TopLeft","TopRight","BottomLeft","BottomRight"]:
+        elem=root.find(f".//point[@type='{pt_type}']")
+        points.append([float(elem.get("x")), float(elem.get("y"))])
+    return np.array(points,dtype=np.float32).reshape(-1,2)
 
 # ---------------- Padding Helper ----------------
 def pad_to_size(img, target_h, target_w):
     h, w = img.shape[:2]
+    top_pad = 0
+    left_pad = 0
+    bottom_pad = target_h - h
+    right_pad = target_w - w
     canvas = np.ones((target_h, target_w,3), dtype=np.uint8)*255
-    canvas[:h,:w] = img
+    canvas[top_pad:top_pad+h, left_pad:left_pad+w] = img
     return canvas
 
-def match_img_to_reference(match_img, ref_h, ref_w):
-    h, w = match_img.shape[:2]
-    scale = ref_w / w
-    new_w = ref_w
-    new_h = int(h * scale)
-    resized = cv2.resize(match_img, (new_w,new_h))
-    if new_h < ref_h:
-        canvas = np.ones((ref_h, ref_w,3), dtype=np.uint8)*255
-        canvas[:new_h,:new_w] = resized
-        return canvas
-    else:
-        return resized
+# ---------------- Draw XML Ground-Truth ----------------
+def draw_xml_gt(img, xml_points):
+    for px,py in xml_points:
+        cv2.circle(img,(int(px),int(py)),5,(0,0,255),-1)
+    # Draw polygon
+    cv2.polylines(img,[xml_points.astype(np.int32)],True,(255,0,0),2)
+    return img
 
 # ---------------- Main Function ----------------
 def homography_all_detectors(flat_file, persp_file, json_file, xml_file):
@@ -91,7 +76,7 @@ def homography_all_detectors(flat_file, persp_file, json_file, xml_file):
 
     flat_gray = preprocess_gray_clahe(flat_img)
     persp_gray = preprocess_gray_clahe(persp_img)
-    xml_points_dict = extract_points_lxml(xml_file.name)
+    xml_points = parse_xml_points(xml_file.name)
 
     methods = ["SIFT","ORB","BRISK","KAZE","AKAZE"]
     gallery_paths = []
@@ -103,42 +88,44 @@ def homography_all_detectors(flat_file, persp_file, json_file, xml_file):
 
         match_img = cv2.drawMatches(flat_img,kp1,persp_img,kp2,good_matches,None,flags=2)
 
-        # ROI on perspective image
-        roi_corners_flat = get_rotated_rect_corners(roi_x,roi_y,roi_w,roi_h,roi_rot_deg)
         src_pts = np.float32([kp1[m.queryIdx].pt for m in good_matches]).reshape(-1,1,2)
         dst_pts = np.float32([kp2[m.trainIdx].pt for m in good_matches]).reshape(-1,1,2)
         H,_ = cv2.findHomography(src_pts,dst_pts,cv2.RANSAC,5.0)
+        if H is None: continue
+
+        # ROI homography projection
+        roi_corners_flat = get_rotated_rect_corners(roi_x,roi_y,roi_w,roi_h,roi_rot_deg)
+        roi_corners_persp = cv2.perspectiveTransform(roi_corners_flat.reshape(-1,1,2),H).reshape(-1,2)
         persp_roi = persp_img.copy()
-        if H is not None:
-            roi_corners_persp = cv2.perspectiveTransform(roi_corners_flat.reshape(-1,1,2),H).reshape(-1,2)
-            cv2.polylines(persp_roi,[roi_corners_persp.astype(int)],True,(0,255,0),2)
-            for px,py in roi_corners_persp: cv2.circle(persp_roi,(int(px),int(py)),5,(255,0,0),-1)
+        cv2.polylines(persp_roi,[roi_corners_persp.astype(int)],True,(0,255,0),2)
+        for px,py in roi_corners_persp: cv2.circle(persp_roi,(int(px),int(py)),5,(255,0,0),-1)
 
-        # XML GT overlay on perspective
-        xml_gt_img = draw_polygon_on_image(persp_img, xml_points_dict)
+        # XML GT overlay
+        xml_gt_img = persp_img.copy()
+        xml_gt_img = draw_xml_gt(xml_gt_img, xml_points)
 
         # Convert to RGB
         flat_rgb = cv2.cvtColor(flat_img,cv2.COLOR_BGR2RGB)
-        match_rgb = match_img_to_reference(cv2.cvtColor(match_img,cv2.COLOR_BGR2RGB),
-                                           flat_rgb.shape[0], flat_rgb.shape[1])
+        match_rgb = cv2.cvtColor(match_img,cv2.COLOR_BGR2RGB)
         roi_rgb = cv2.cvtColor(persp_roi,cv2.COLOR_BGR2RGB)
         xml_rgb = cv2.cvtColor(xml_gt_img,cv2.COLOR_BGR2RGB)
 
-        # Determine max height and width
+        # Determine max height and width for padding
         max_h = max(flat_rgb.shape[0], match_rgb.shape[0], roi_rgb.shape[0], xml_rgb.shape[0])
         max_w = max(flat_rgb.shape[1], match_rgb.shape[1], roi_rgb.shape[1], xml_rgb.shape[1])
 
-        # Pad images
+        # Pad all images to same size
         flat_pad = pad_to_size(flat_rgb, max_h, max_w)
         match_pad = pad_to_size(match_rgb, max_h, max_w)
         roi_pad = pad_to_size(roi_rgb, max_h, max_w)
         xml_pad = pad_to_size(xml_rgb, max_h, max_w)
 
-        # 2x2 grid
+        # Merge 2x2 grid
         top = np.hstack([flat_pad, match_pad])
         bottom = np.hstack([roi_pad, xml_pad])
         combined_grid = np.vstack([top, bottom])
 
+        # Save combined grid
         base_name = os.path.splitext(os.path.basename(persp_file))[0]
         file_name = f"{base_name}_{method.lower()}.png"
         cv2.imwrite(file_name, cv2.cvtColor(combined_grid,cv2.COLOR_RGB2BGR))
@@ -166,7 +153,7 @@ iface = gr.Interface(
         gr.File(label="Download AKAZE Result")
     ],
     title="Homography ROI Projection with Feature Matching & XML GT",
-    description="Flat + Perspective images with mockup.json & XML. Grid aligned. Perspective GT overlay now uses XML lxml parsing."
+    description="Flat + Perspective images with mockup.json & XML. Original resolution maintained. Grid aligned with white padding. XML GT overlaid."
 )
 
 iface.launch()