Update app.py

app.py

@@ -1364,6 +1364,142 @@ def supa_login(email, password):
     except Exception as e:
         return f"❌ Login error: {e}", True
 
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+import numpy as np
+from PIL import Image
+import os
+
+def draw_shapes_with_zorder(
+    polygons_data=None,
+    ellipses_data=None,
+    filename="multiple_shapes.png",
+    fig_size=(10, 8),
+    transparent_bg=False
+):
+    fig, ax = plt.subplots(figsize=fig_size)
+    ax.set_aspect('equal', adjustable='box')
+    ax.set_axis_off()
+    ax.set_facecolor('#f0f0f0')
+
+    min_x, max_x = float('inf'), float('-inf')
+    min_y, max_y = float('inf'), float('-inf')
+
+    all_coords = []
+    if polygons_data:
+        for poly_info in polygons_data:
+            points = poly_info.get('points')
+            if points:
+                all_coords.extend(points)
+                polygon = patches.Polygon(
+                    points,
+                    closed=True,
+                    facecolor=poly_info.get('facecolor', '#ADD8E6'),
+                    edgecolor=poly_info.get('edgecolor', 'blue'),
+                    linewidth=poly_info.get('linewidth', 2),
+                    zorder=poly_info.get('zorder', 1)
+                )
+                ax.add_patch(polygon)
+
+    if ellipses_data:
+        for ellipse_info in ellipses_data:
+            e_cx = ellipse_info.get('center_x')
+            e_cy = ellipse_info.get('center_y')
+            e_w = ellipse_info.get('width')
+            e_h = ellipse_info.get('height')
+            e_angle = ellipse_info.get('angle', 0)
+
+            if e_cx is None or e_cy is None or e_w is None or e_h is None:
+                continue
+
+            all_coords.append((e_cx - e_w / 2, e_cy - e_h / 2))
+            all_coords.append((e_cx + e_w / 2, e_cy + e_h / 2))
+            all_coords.append((e_cx - e_w / 2, e_cy + e_h / 2))
+            all_coords.append((e_cx + e_w / 2, e_cy - e_h / 2))
+
+            ellipse = patches.Ellipse(
+                (e_cx, e_cy),
+                e_w,
+                e_h,
+                angle=e_angle,
+                facecolor=ellipse_info.get('facecolor', '#FFD700'),
+                edgecolor=ellipse_info.get('edgecolor', 'orange'),
+                linewidth=ellipse_info.get('linewidth', 2),
+                zorder=ellipse_info.get('zorder', 1)
+            )
+            ax.add_patch(ellipse)
+
+    if all_coords:
+        coords_array = np.array(all_coords)
+        min_x, min_y = np.min(coords_array, axis=0)
+        max_x, max_y = np.max(coords_array, axis=0)
+
+        padding_x = (max_x - min_x) * 0.2 if (max_x - min_x) > 0 else 1.0
+        padding_y = (max_y - min_y) * 0.2 if (max_y - min_y) > 0 else 1.0
+
+        ax.set_xlim(min_x - padding_x, max_x + padding_x)
+        ax.set_ylim(min_y - padding_y, max_y + padding_y)
+    else:
+        ax.set_xlim(0, 10)
+        ax.set_ylim(0, 8)
+
+    plt.savefig(filename, dpi=300, bbox_inches='tight', pad_inches=0, transparent=transparent_bg)
+    plt.close(fig)  # Close to avoid memory leak
+
+    return Image.open(filename)  # Return as PIL.Image object for Gradio
+
+# --- Example Usage ---
+
+# Define data for multiple polygons
+my_polygons = [
+    {
+        'points': [(0.56, 14.72), (0.56, 19.05), (19.5, 19.05), (19.5, 14.53)],
+        'facecolor': "#E6ADAD",
+        'edgecolor': 'brown',
+        'linewidth': 0,
+        'zorder': 2
+    },
+    {
+        'points': [(3, 14.72), (3, 9.45), (17, 9.45), (17, 14.6)],
+        'facecolor': '#E6ADAD',
+        'edgecolor': 'darkgreen',
+        'linewidth': 0,
+        'zorder': 1
+    },
+    {
+        'points': [(4.24, 18.74), (9.68, 18.74), (9.68, 17.34), (4.24, 17.34)],
+        'facecolor': '#f0f0f0',
+        'edgecolor': 'brown',
+        'linewidth': 0,
+        'zorder': 4
+    },
+    {
+        'points': [(12.25, 18.74), (15.88, 18.74), (15.88, 17.34), (12.25, 17.34)],
+        'facecolor': '#f0f0f0',
+        'edgecolor': 'darkgreen',
+        'linewidth': 0,
+        'zorder': 4
+    }
+]
+
+# Define data for multiple ellipses
+my_ellipses = [
+    {
+        'center_x': 10.0, 'center_y': 9.45, 'width': 9.0, 'height': 12.0, 'angle': 0,
+        'facecolor': '#f0f0f0',
+        'edgecolor': 'blue',
+        'linewidth': 0,
+        'zorder': 4
+    },
+    {
+        'center_x': 10.0, 'center_y': 9.45, 'width': 14.0, 'height': 17.0, 'angle': 0,
+        'facecolor': '#E6ADAD',
+        'edgecolor': 'purple',
+        'linewidth': 0,
+        'zorder': 3
+    }
+]
+
 # Final app logic (your current full app can go here)
 def launch_main_app():
     import gradio as gr
@@ -1462,6 +1598,8 @@ def launch_main_app():
         models_coinref_p2 = gr.State(None)
         device_p2 = gr.State(None)
         gallery_segmentation_p4 = gr.State()
+        polygons, ellipses = gr.State(), gr.State()
+        polygons1, ellipses1 = gr.State(), gr.State()
         
         full_app_interface.load(
             fn=lambda: [GLOBAL_HOLES, GLOBAL_RIM, GLOBAL_COIN, device_p2],
@@ -1708,6 +1846,20 @@ def launch_main_app():
             download_all_file = gr.File(visible=False)
             download_all_error = gr.File(visible=False)
             
+            res_stat1 = gr.State()
+            step1 = gr.State()
+                
+            with gr.Column():
+                with gr.Row():
+                    result_status1 = gr.Textbox(label="", visible=False, interactive=False, elem_id='pretty-box')
+                with gr.Row():
+                    with gr.Column():
+                        result_image11 = gr.Image(label="Chassy Image", visible=False, interactive=False)
+                    with gr.Column():
+                        result_image21 = gr.Image(label="Toilet Image", visible=False, interactive=False)
+                    with gr.Column():
+                        result_image31 = gr.Image(label="Overlapped Image", visible=False, interactive=False)
+            
             with gr.Column(visible=False) as col:
                 gr.Markdown("## 🎯 Prediction Accuracy Analysis", elem_id="centered-title")
 
@@ -1771,6 +1923,20 @@ def launch_main_app():
                             error_plot = gr.Image(label="📉 Error Plot", height=400, width=600, interactive=False, visible=False)
                     with gr.Row():
                         avg_error_text = gr.Textbox(label="🎯 Average Error %", interactive=False, elem_id='centered-title')
+                
+                res_stat = gr.State()
+                step = gr.State()
+                
+                with gr.Column():
+                    with gr.Row():
+                        result_status = gr.Textbox(label="", visible=False, interactive=False, elem_id='pretty-box')
+                    with gr.Row():
+                        with gr.Column():
+                            result_image1 = gr.Image(label="Chassy Image", visible=False, interactive=False)
+                        with gr.Column():
+                            result_image2 = gr.Image(label="Toilet Image", visible=False, interactive=False)
+                        with gr.Column():
+                            result_image3 = gr.Image(label="Overlapped Image", visible=False, interactive=False)
         
         run_pipeline_btn.click(fn=lambda: gr.update(visible=True), outputs=group_to_show)
         run_pipeline_btn.click(fn=lambda: gr.update(value="🔄 Processing... (Please Wait)"), outputs=process)
@@ -1927,6 +2093,437 @@ def launch_main_app():
 
             return zip_path, gr.update(value="")
         
+        import matplotlib.pyplot as plt
+        import matplotlib.patches as patches
+        import numpy as np
+        from PIL import Image
+        import os
+
+        def draw_shapes_with_zorder(
+            polygons_data=None,
+            ellipses_data=None,
+            res_stat=True,
+            filename="chasis_image.png",
+            fig_size=(20, 15),
+            transparent_bg=False
+        ):
+            if not res_stat:
+                return None
+            
+            fig, ax = plt.subplots(figsize=fig_size)
+            ax.set_aspect('equal', adjustable='box')
+            ax.set_axis_off()
+            ax.set_facecolor('#f0f0f0')
+
+            min_x, max_x = float('inf'), float('-inf')
+            min_y, max_y = float('inf'), float('-inf')
+
+            all_coords = []
+            if polygons_data:
+                for poly_info in polygons_data:
+                    points = poly_info.get('points')
+                    if points:
+                        all_coords.extend(points)
+                        polygon = patches.Polygon(
+                            points,
+                            closed=True,
+                            facecolor=poly_info.get('facecolor', '#ADD8E6'),
+                            edgecolor=poly_info.get('edgecolor', 'blue'),
+                            linewidth=poly_info.get('linewidth', 2),
+                            zorder=poly_info.get('zorder', 1)
+                        )
+                        ax.add_patch(polygon)
+
+            if ellipses_data:
+                for ellipse_info in ellipses_data:
+                    e_cx = ellipse_info.get('center_x')
+                    e_cy = ellipse_info.get('center_y')
+                    e_w = ellipse_info.get('width')
+                    e_h = ellipse_info.get('height')
+                    e_angle = ellipse_info.get('angle', 0)
+
+                    if e_cx is None or e_cy is None or e_w is None or e_h is None:
+                        continue
+
+                    all_coords.append((e_cx - e_w / 2, e_cy - e_h / 2))
+                    all_coords.append((e_cx + e_w / 2, e_cy + e_h / 2))
+                    all_coords.append((e_cx - e_w / 2, e_cy + e_h / 2))
+                    all_coords.append((e_cx + e_w / 2, e_cy - e_h / 2))
+
+                    ellipse = patches.Ellipse(
+                        (e_cx, e_cy),
+                        e_w,
+                        e_h,
+                        angle=e_angle,
+                        facecolor=ellipse_info.get('facecolor', '#FFD700'),
+                        edgecolor=ellipse_info.get('edgecolor', 'orange'),
+                        linewidth=ellipse_info.get('linewidth', 2),
+                        zorder=ellipse_info.get('zorder', 1)
+                    )
+                    ax.add_patch(ellipse)
+
+            if all_coords:
+                coords_array = np.array(all_coords)
+                min_x, min_y = np.min(coords_array, axis=0)
+                max_x, max_y = np.max(coords_array, axis=0)
+
+                padding_x = (max_x - min_x) * 0.2 if (max_x - min_x) > 0 else 1.0
+                padding_y = (max_y - min_y) * 0.2 if (max_y - min_y) > 0 else 1.0
+
+                ax.set_xlim(min_x - padding_x, max_x + padding_x)
+                ax.set_ylim(min_y - padding_y, max_y + padding_y)
+            else:
+                ax.set_xlim(0, 10)
+                ax.set_ylim(0, 8)
+
+            plt.savefig(filename, dpi=300, bbox_inches='tight', pad_inches=0, transparent=transparent_bg)
+            plt.close(fig)  # Close to avoid memory leak
+
+            res = Image.open(filename)  # Return as PIL.Image object for Gradio
+            return gr.update(visible=True, value=res)
+
+        # --- Example Usage ---
+
+        # Define data for multiple polygons
+        my_polygons = gr.State([
+            {
+                'points': [(0.56, 14.72), (0.56, 19.05), (19.5, 19.05), (19.5, 14.53)],
+                'facecolor': "#E6ADAD",
+                'edgecolor': 'brown',
+                'linewidth': 0,
+                'zorder': 2
+            },
+            {
+                'points': [(3, 14.72), (3, 9.45), (17, 9.45), (17, 14.6)],
+                'facecolor': '#E6ADAD',
+                'edgecolor': 'darkgreen',
+                'linewidth': 0,
+                'zorder': 1
+            },
+            {
+                'points': [(4.24, 18.74), (9.68, 18.74), (9.68, 17.34), (4.24, 17.34)],
+                'facecolor': '#f0f0f0',
+                'edgecolor': 'brown',
+                'linewidth': 0,
+                'zorder': 4
+            },
+            {
+                'points': [(12.25, 18.74), (15.88, 18.74), (15.88, 17.34), (12.25, 17.34)],
+                'facecolor': '#f0f0f0',
+                'edgecolor': 'darkgreen',
+                'linewidth': 0,
+                'zorder': 4
+            }
+        ])
+
+        # Define data for multiple ellipses
+        my_ellipses = gr.State([
+            {
+                'center_x': 10.0, 'center_y': 9.45, 'width': 9.0, 'height': 12.0, 'angle': 0,
+                'facecolor': '#f0f0f0',
+                'edgecolor': 'blue',
+                'linewidth': 0,
+                'zorder': 4
+            },
+            {
+                'center_x': 10.0, 'center_y': 9.45, 'width': 14.0, 'height': 17.0, 'angle': 0,
+                'facecolor': '#E6ADAD',
+                'edgecolor': 'purple',
+                'linewidth': 0,
+                'zorder': 3
+            }
+        ])
+        
+        import matplotlib.pyplot as plt
+        import matplotlib.patches as patches
+        import numpy as np
+        from PIL import Image
+        import os
+
+        def draw_shapes_with_zorder2(
+            polygons_data=None,
+            ellipses_data=None,
+            res_stat=True,
+            step=0, out_ref_ratios_p5=None,
+            filename="toilet_image.png",
+            title="Custom Shapes Drawing",
+        ):
+            if not res_stat:
+                return None
+
+            fig, ax = plt.subplots(figsize=(20, 15))
+            ax.set_axis_off()
+            ax.set_aspect('equal', adjustable='box')
+            ax.set_facecolor('#f0f0f0')
+
+            ratio = out_ref_ratios_p5.get("closed", 1.0) if out_ref_ratios_p5 else 1.0
+            vertical_shift = int(step * ratio)
+
+            min_x, max_x = float('inf'), float('-inf')
+            min_y, max_y = float('inf'), float('-inf')
+
+            if polygons_data:
+                for poly_info in polygons_data:
+                    points = poly_info.get('points')
+                    if not points:
+                        continue
+
+                    # Apply vertical shift to y-coordinates
+                    shifted_points = [(x, y - vertical_shift) for (x, y) in points]
+
+                    for x, y in shifted_points:
+                        min_x = min(min_x, x)
+                        max_x = max(max_x, x)
+                        min_y = min(min_y, y)
+                        max_y = max(max_y, y)
+
+                    polygon = patches.Polygon(
+                        shifted_points,
+                        closed=True,
+                        facecolor=poly_info.get('facecolor', '#ADD8E6'),
+                        edgecolor=poly_info.get('edgecolor', 'blue'),
+                        linewidth=poly_info.get('linewidth', 2),
+                        label=poly_info.get('label', 'Polygon'),
+                        zorder=poly_info.get('zorder', 1)
+                    )
+                    ax.add_patch(polygon)
+
+            if ellipses_data:
+                for ellipse_info in ellipses_data:
+                    e_cx = ellipse_info.get('center_x')
+                    e_cy = ellipse_info.get('center_y')
+                    e_w = ellipse_info.get('width')
+                    e_h = ellipse_info.get('height')
+                    e_angle = ellipse_info.get('angle', 0)
+
+                    if e_cx is None or e_cy is None or e_w is None or e_h is None:
+                        continue
+
+                    e_cy_shifted = e_cy - vertical_shift
+
+                    min_x = min(min_x, e_cx - e_w / 2)
+                    max_x = max(max_x, e_cx + e_w / 2)
+                    min_y = min(min_y, e_cy_shifted - e_h / 2)
+                    max_y = max(max_y, e_cy_shifted + e_h / 2)
+
+                    ellipse = patches.Ellipse(
+                        (e_cx, e_cy_shifted),
+                        e_w,
+                        e_h,
+                        angle=e_angle,
+                        facecolor=ellipse_info.get('facecolor', '#f0f0f0'),
+                        edgecolor=ellipse_info.get('edgecolor', '#f0f0f0'),
+                        linewidth=ellipse_info.get('linewidth', 2),
+                        label=ellipse_info.get('label', 'Ellipse'),
+                        zorder=ellipse_info.get('zorder', 1)
+                    )
+                    ax.add_patch(ellipse)
+
+            if min_x != float('inf') and max_x != float('-inf'):
+                padding_x = (max_x - min_x) * 0.2 if (max_x - min_x) > 0 else 1.0
+                padding_y = (max_y - min_y) * 0.2 if (max_y - min_y) > 0 else 1.0
+                ax.set_xlim(min_x - padding_x, max_x + padding_x)
+                ax.set_ylim(min_y - padding_y, max_y + padding_y)
+            else:
+                ax.set_xlim(0, 10)
+                ax.set_ylim(0, 8)
+
+            plt.savefig(filename, dpi=300, bbox_inches='tight')
+            plt.close(fig)
+
+            res = Image.open(filename)
+            return gr.update(visible=True, value=res)
+        
+        import sympy
+        from sympy import symbols, Eq, solve, N
+
+        def find_tangent_points_from_external(px, py, cx, cy, a, b):
+            x, y = symbols('x y')
+
+            # Ellipse equation
+            ellipse_eq_sym = Eq((x - cx)**2 / a**2 + (y - cy)**2 / b**2, 1)
+
+            # Polar equation for (px, py)
+            polar_eq_sym = Eq(
+                (x - cx) * (px - cx) / a**2 +
+                (y - cy) * (py - cy) / b**2, 1
+            )
+
+            # Solve the system to find tangent points
+            solutions = solve([ellipse_eq_sym, polar_eq_sym], (x, y))
+
+            tangent_points = []
+            for sol in solutions:
+                # Check the type of solution to handle both dict and tuple cases
+                if isinstance(sol, dict):
+                    # If solution is a dictionary {x: val_x, y: val_y}
+                    if all(s.is_real for s in sol.values()):
+                        tangent_points.append((float(N(sol[x])), float(N(sol[y]))))
+                elif isinstance(sol, tuple) and len(sol) == 2:
+                    # If solution is a tuple (val_x, val_y)
+                    # Make sure sol[0] and sol[1] are SymPy expressions before calling .is_real
+                    if sol[0].is_real and sol[1].is_real:
+                        tangent_points.append((float(N(sol[0])), float(N(sol[1]))))
+            
+            return tangent_points
+
+        def get_specific_tangent_points(
+            center_x, center_y, width, height,
+            point1_x, point1_y, point2_x, point2_y
+        ):
+            a = width / 2
+            b = height / 2
+
+            # Find tangent points for P1
+            tangent_points_p1 = find_tangent_points_from_external(point1_x, point1_y, center_x, center_y, a, b)
+
+            # Find tangent points for P2
+            tangent_points_p2 = find_tangent_points_from_external(point2_x, point2_y, center_x, center_y, a, b)
+
+            # --- Select the "left" tangent point for P1 ---
+            # Sort by x-coordinate to easily pick left/right
+            tangent_points_p1.sort(key=lambda p: p[0])
+            selected_tangent_point_p1 = tangent_points_p1[0] # The one with smaller x-coordinate is "left"
+
+            # --- Select the "right" tangent point for P2 ---
+            tangent_points_p2.sort(key=lambda p: p[0])
+            selected_tangent_point_p2 = tangent_points_p2[1] # The one with larger x-coordinate is "right"
+
+            return selected_tangent_point_p2, selected_tangent_point_p1
+
+        # --- Example Usage ---
+        def guide(a2, b2, c2, d2, e2, f2, g2, h2, res_stat):
+            if not res_stat:
+                return None, None
+            
+            a2, b2, c2, d2, e2, f2, g2, h2 = float(a2), float(b2), float(c2), float(d2), float(e2), float(f2), float(g2), float(h2)
+            
+            # Ellipse parameters
+            ellipse_center_x = 10
+            ellipse_center_y = 10
+            ellipse_width = f2  # a = 5
+            ellipse_height = g2   # b = 3
+
+            # External points (always above the ellipse, not exactly on top of center)
+            point_1_x, point_1_y = 10 - (h2/2), 10 + (e2/2) + a2 + b2
+
+            point_2_x, point_2_y = 10 + (h2/2), 10 + (e2/2) + a2 + b2
+
+            tangent_points = get_specific_tangent_points(
+                ellipse_center_x, ellipse_center_y,
+                ellipse_width, ellipse_height,
+                point_1_x, point_1_y, point_2_x, point_2_y
+            )
+
+            polygons = [
+                {
+                    'points': [(10 - (h2/2), 10 + (e2/2) + a2 + b2), (10 + (h2/2), 10 + (e2/2) + a2 + b2), (tangent_points[0][0], tangent_points[0][1]), (tangent_points[1][0], tangent_points[1][1])],
+                    'facecolor': '#ADD8E6', # Peach
+                    'edgecolor': 'brown',
+                    'linewidth': 0,
+                    'label': 'Irregular Quad',
+                    'zorder': 2 # This will be on top of the green triangle
+                }
+            ]
+
+            # Define data for multiple ellipses
+            ellipses = [
+                {
+                    'center_x': 10.0, 'center_y': 10, 'width': d2, 'height': e2, 'angle': 0,
+                    'facecolor': '#f0f0f0', # Light blue
+                    'edgecolor': 'blue',
+                    'linewidth': 0,
+                    'label': 'Rotated Ellipse',
+                    'zorder': 4 # This will be on top of both polygons
+                },
+                {
+                    'center_x': 10.0, 'center_y': 10, 'width': f2, 'height': g2, 'angle': 0,
+                    'facecolor': '#ADD8E6', # Pink
+                    'edgecolor': 'purple',
+                    'linewidth': 0,
+                    'label': 'Small Circle',
+                    'zorder': 3 # This will be on top of everything else
+                },
+                {
+                    'center_x': 10 - (c2/2) + 0.75, 'center_y': 10 + (e2/2) + b2, 'width': 0.75, 'height': 0.75, 'angle': 0,
+                    'facecolor': '#f0f0f0', # Light blue
+                    'edgecolor': 'blue',
+                    'linewidth': 0,
+                    'label': 'Rotated Ellipse',
+                    'zorder': 4 # This will be on top of both polygons
+                },
+                {
+                    'center_x': 10 + (c2/2) - 0.75, 'center_y': 10 + (e2/2) + b2, 'width': 0.75, 'height': 0.75, 'angle': 0,
+                    'facecolor': '#f0f0f0', # Pink
+                    'edgecolor': 'purple',
+                    'linewidth': 0,
+                    'label': 'Small Circle',
+                    'zorder': 4 # This will be on top of everything else
+                }
+            ]
+            return polygons, ellipses
+        
+        from PIL import Image
+
+        def overlay_images_centered(background_path, foreground_path, res_stat, step, out_ref_ratios_p5):
+            if not res_stat:
+                return None
+
+            # Load images from NumPy arrays
+            bg = Image.fromarray(background_path).convert("RGBA")
+            fg = Image.fromarray(foreground_path).convert("RGBA")
+
+            # Make #f0f0f0 pixels transparent
+            new_data = [
+                (255, 255, 255, 0) if pixel[:3] == (240, 240, 240) else pixel
+                for pixel in fg.getdata()
+            ]
+            fg.putdata(new_data)
+
+            # Get sizes
+            bg_w, bg_h = bg.size
+            fg_w, fg_h = fg.size
+            ratio = out_ref_ratios_p5.get("closed", 1.0)
+            vertical_shift = int(step * ratio)
+
+            # Create a blank transparent image (same size as background)
+            shifted_fg = Image.new("RGBA", bg.size, (255, 255, 255, 0))
+
+            # Center the foreground, shifted UP by vertical_shift pixels
+            pos_x = (bg_w - fg_w) // 2
+            pos_y = (bg_h - fg_h) // 2 - vertical_shift
+            shifted_fg.paste(fg, (pos_x, pos_y), fg)
+
+            # Reduce opacity to 50%
+            alpha = shifted_fg.split()[3].point(lambda a: int(a * 0.5))
+            shifted_fg.putalpha(alpha)
+
+            # Composite foreground onto background
+            result = Image.alpha_composite(bg, shifted_fg).convert("RGB")
+
+            return gr.update(visible=True, value=result)
+        
+        def checkstatus(b2, c2, g2):
+            hole_rad = 0.375
+            max_range = 18.1
+            top_val = max_range - 0.31 - hole_rad
+            bottom_val = top_val - 1.4 + (hole_rad * 2)
+            min_width = 4.5 + hole_rad
+            max_width = 11.52 - hole_rad
+
+            max_step = 0.5
+            step_size = 0.05
+            steps = int(max_step / step_size) + 1  # Includes 0.0 step
+
+            for i in range(steps):
+                step = i * step_size
+                if float(bottom_val) < float(g2) + float(b2) + float(step) < float(top_val) and float(min_width) < float(c2) < float(max_width):
+                    msg = "✅ Our Product can fit in your Washroom."
+                    return gr.update(value=msg, visible=True), True, step
+
+            msg = "❌ Unfortunately we cannot fit our product in your washroom."
+            return gr.update(value=msg, visible=True), False, None
+        
         submit_btn.click(
             fn=lambda *args: (
                 compare_measurements(*args)[0],
@@ -1939,7 +2536,12 @@ def launch_main_app():
         then(fn=download_all_results,
             inputs=[a1, b1, c1, d1, e1, f1, g1, h1, a2, b2, c2, d2, e2, f2, g2, h2, avg_error_text, error_plot],
             outputs=[download_all_error, progress]).\
-            then(upload_zip_error, inputs=[email, download_all_error], outputs=[])
+        then(upload_zip_error, inputs=[email, download_all_error], outputs=[]).\
+        then(checkstatus, inputs=[b2, c2, g2], outputs=[result_status, res_stat, step]).\
+        then(fn=draw_shapes_with_zorder, inputs=[my_polygons, my_ellipses, res_stat], outputs=[result_image1]).\
+        then(fn=guide, inputs=[a2, b2, c2, d2, e2, f2, g2, h2, res_stat], outputs=[polygons, ellipses]).\
+        then(fn=draw_shapes_with_zorder2, inputs=[polygons, ellipses, res_stat, step, out_ref_ratios_p5], outputs=[result_image2]).\
+        then(fn=overlay_images_centered, inputs=[result_image1, result_image2, res_stat, step, out_ref_ratios_p5], outputs=[result_image3])
 
         submit_btn.click(fn=lambda: gr.update(visible=True), inputs=[], outputs=[error])
         
@@ -2220,29 +2822,12 @@ def launch_main_app():
                 remaining_lid_img_p12, remaining_str, out_image, top_width_str, a1, b1, c1, d1, e1, f1, g1, h1
             ],
             outputs=[download_all_file, progress]).\
-            then(upload_zip, inputs=[email, download_all_file], outputs=[col])
-        
-        with gr.Row():
-            gr.Markdown("")
-        with gr.Row():
-            gr.Markdown("")
-        with gr.Row():
-            gr.Markdown("")
-        with gr.Row():
-            gr.Markdown("\nFor any queries, Feel free to contact 📧 core.atsc@gmail.com", elem_id='centered-title')
-        
-        with gr.Row():
-            gr.Markdown(
-                """
-                ---
-                #### 👨‍💻 Created by Heet Savaliya  
-                📧 Email: savaliyaheet19@gmail.com  
-                🔗  [LinkedIn](https://www.linkedin.com/in/heet-savaliya-03b863252/)
-                🔗  [GitHub](https://github.com/heetsavaliya)  
-                © 2025 Heet Savaliya
-                """,
-                elem_id="footer-text",
-            )
+            then(upload_zip, inputs=[email, download_all_file], outputs=[col]).\
+            then(checkstatus, inputs=[b1, c1, g1], outputs=[result_status1, res_stat1, step1]).\
+            then(fn=draw_shapes_with_zorder, inputs=[my_polygons, my_ellipses, res_stat1], outputs=[result_image11]).\
+            then(fn=guide, inputs=[a1, b1, c1, d1, e1, f1, g1, h1, res_stat1], outputs=[polygons1, ellipses1]).\
+            then(fn=draw_shapes_with_zorder2, inputs=[polygons1, ellipses1, res_stat1, step1, out_ref_ratios_p5], outputs=[result_image21]).\
+            then(fn=overlay_images_centered, inputs=[result_image11, result_image21, res_stat1, step1, out_ref_ratios_p5], outputs=[result_image31])
 
 with gr.Blocks(title="🧪 Toilet Segmentation & Measurement App") as full_app_interface:
     auth_state = gr.State(False)  # Used to track login state
@@ -2295,6 +2880,25 @@ with gr.Blocks(title="🧪 Toilet Segmentation & Measurement App") as full_app_i
 
     auth_state.change(toggle_app, inputs=auth_state, outputs=protected_content)
     
+    with gr.Row():
+        gr.Markdown("")
+    with gr.Row():
+        gr.Markdown("")
+    with gr.Row():
+        gr.Markdown("")
+    with gr.Row():
+        gr.Markdown("\nFor any queries, Feel free to contact 📧 core.atsc@gmail.com", elem_id='centered-title')
+        
+    with gr.Row():
+        gr.Markdown(
+            """
+            ---
+            #### [👨‍💻](mailto:savaliyaheet19@gmail.com) [*Created by*](https://github.com/heetsavaliya) [**Heet Savaliya**](https://www.linkedin.com/in/heet-savaliya-03b863252/), [**PDEU**](https://www.linkedin.com/in/heet-savaliya-03b863252/)
+            © 2025 HapiHygi Innovations Private Limited. All rights reserved.
+            """,
+            elem_id="footer-text",
+        )
+    
 # 🚀 Launch App
 if __name__ == "__main__":
-    full_app_interface.launch()
+    full_app_interface.launch()