Delete app.py

app.py

@@ -1,516 +0,0 @@
-# app.py
-# Combined Engineering Suite for Hugging Face Deployment
-
-# --- 1. IMPORTS ---
-# Standard library imports
-import re
-import os
-import io
-import warnings
-
-# Third-party imports
-import gradio as gr
-import numpy as np
-import matplotlib
-matplotlib.use('Agg') # Use a non-interactive backend
-import matplotlib.pyplot as plt
-from matplotlib import cm
-from PIL import Image, ImageDraw, ImageFont
-import plotly.graph_objects as go
-from shapely.geometry import box, Point
-from shapely.affinity import scale
-import trimesh
-import pyvista as pv
-
-# Suppress warnings for a cleaner output
-warnings.filterwarnings('ignore')
-
-# --- 2. CORE LOGIC FROM PDFS ---
-
-# === MODULE 1: Text to CAD & G-Code (from g-code.pdf) ===
-
-def parse_simple_description(description):
-    """Parses a textual description to extract geometric parameters for a plate."""
-    width, height = 100, 100
-    holes, slots, ovals = [], [], []
-
-    # Dimensions
-    dim_match = re.search(r'(\d+)\s*mm\s*[xX×]\s*(\d+)\s*mm', description)
-    if dim_match:
-        width, height = int(dim_match.group(1)), int(dim_match.group(2))
-
-    # Holes
-    for hole_match in re.finditer(r'(hole|circle|circular cutout)[^\d]*(\d+)\s*mm', description):
-        holes.append({'x': width / 2, 'y': height / 2, 'diameter': int(hole_match.group(2))})
-
-    # Slots
-    for slot_match in re.finditer(r'(\d+)\s*mm\s+long\s+and\s+(\d+)\s*mm\s+wide\s+slot', description):
-        slots.append({'x': width / 2, 'y': height / 2, 'length': int(slot_match.group(1)), 'width': int(slot_match.group(2))})
-
-    # Ovals
-    for oval_match in re.finditer(r'oval\s+hole\s+(\d+)\s*mm\s+long\s+and\s+(\d+)\s*mm\s+wide', description):
-        ovals.append({'x': width / 2, 'y': height / 2, 'length': int(oval_match.group(1)), 'width': int(oval_match.group(2))})
-
-    return {"width": width, "height": height, "holes": holes, "slots": slots, "ovals": ovals}
-
-def generate_simple_3_view_drawing(description):
-    """Generates a 3-view engineering drawing from a simple description."""
-    parsed = parse_simple_description(description)
-    width, height, depth = parsed["width"], parsed["height"], 5
-    fig, axes = plt.subplots(1, 3, figsize=(15, 5))
-    plt.style.use('grayscale')
-
-    views = ['Top View', 'Front View', 'Side View']
-    for ax, view in zip(axes, views):
-        ax.set_title(view)
-        ax.grid(True, linestyle='--', linewidth=0.5)
-        ax.set_aspect('equal', adjustable='box')
-
-        if view == "Top View":
-            shape = box(0, 0, width, height)
-            x, y = shape.exterior.xy
-            ax.plot(x, y, color='black')
-            for hole in parsed["holes"]:
-                ax.plot(*Point(hole['x'], hole['y']).buffer(hole['diameter'] / 2).exterior.xy, color='black')
-            for slot in parsed["slots"]:
-                ax.plot(*scale(Point(slot['x'], slot['y']).buffer(1), slot['length']/2, slot['width']/2).exterior.xy, color='black')
-            for oval in parsed["ovals"]:
-                ax.plot(*scale(Point(oval['x'], oval['y']).buffer(1), oval['length']/2, oval['width']/2).exterior.xy, color='black')
-            ax.set_xlim(-10, width + 10)
-            ax.set_ylim(-10, height + 10)
-        elif view == "Front View":
-            ax.plot(*box(0, 0, width, depth).exterior.xy, color='black')
-            ax.set_xlim(-10, width + 10)
-            ax.set_ylim(-10, depth + 10)
-        elif view == "Side View":
-            ax.plot(*box(0, 0, height, depth).exterior.xy, color='black')
-            ax.set_xlim(-10, height + 10)
-            ax.set_ylim(-10, depth + 10)
-
-    plt.tight_layout()
-    drawing_path = "simple_3_view_drawing.png"
-    fig.savefig(drawing_path)
-    plt.close(fig)
-    return drawing_path
-
-def generate_gcode(description):
-    """Generates G-code for milling the part based on the description."""
-    parsed = parse_simple_description(description)
-    w, h = parsed['width'], parsed['height']
-    gcode = [
-        "G21 ; Set units to mm", "G90 ; Use absolute positioning", "G17 ; Select XY plane",
-        "M3 S1000 ; Start spindle", "G0 Z5 ; Lift Z to a safe height",
-        "\n; --- Mill Outer Profile ---",
-        "G0 X0 Y0", "G1 Z-1 F100", f"G1 X{w} F300", f"G1 Y{h}", f"G1 X0", "G1 Y0", "G0 Z5"
-    ]
-    for hole in parsed['holes']:
-        x, y, r = hole['x'], hole['y'], hole['diameter'] / 2
-        gcode.extend([f"\n; --- Mill Hole at X{x}, Y{y}, D{hole['diameter']} ---", f"G0 X{x - r} Y{y}", "G1 Z-1 F100", f"G2 I{r} J0 F200", "G0 Z5"])
-    for slot in parsed['slots']:
-        x, y, l, w_slot = slot['x'], slot['y'], slot['length'], slot['width']
-        r = w_slot / 2
-        x_start, x_end = x - (l - w_slot) / 2, x + (l - w_slot) / 2
-        gcode.extend([f"\n; --- Mill Slot at center X{x}, Y{y} ---", f"G0 X{x_start} Y{y - r}", "G1 Z-1 F100", f"G1 X{x_end} F200", f"G2 I0 J{r}", f"G1 X{x_start}", f"G2 I0 J{r}", "G0 Z5"])
-    for oval in parsed['ovals']:
-        gcode.append(f"\n; --- Oval hole at X{oval['x']}, Y{oval['y']} (manual operation needed) ---")
-    gcode.extend(["\nM5 ; Stop spindle", "G0 X0 Y0 ; Return to home", "M30 ; End of program"])
-    return "\n".join(gcode)
-
-def export_svg(description):
-    """Exports a 2D drawing of the part top-view as an SVG file."""
-    parsed = parse_simple_description(description)
-    width, height = parsed["width"], parsed["height"]
-    fig, ax = plt.subplots(figsize=(width/25.4, height/25.4)) # Inches
-    ax.set_aspect('equal')
-    ax.plot(*box(0, 0, width, height).exterior.xy, color='black', linewidth=2)
-    for hole in parsed["holes"]:
-        ax.plot(*Point(hole['x'], hole['y']).buffer(hole['diameter'] / 2).exterior.xy, color='black', linewidth=1.5)
-    ax.set_xlim(-10, width + 10)
-    ax.set_ylim(-10, height + 10)
-    ax.axis('off')
-    svg_path = "drawing.svg"
-    fig.savefig(svg_path, format="svg", bbox_inches='tight', pad_inches=0.1)
-    plt.close(fig)
-    return svg_path
-
-def process_simple_cad(description):
-    """Top-level function for the simple CAD generator."""
-    if not description.strip():
-        return None, "Please enter a description.", None
-    try:
-        drawing_path = generate_simple_3_view_drawing(description)
-        gcode = generate_gcode(description)
-        svg_path = export_svg(description)
-        return drawing_path, gcode, svg_path
-    except Exception as e:
-        return None, f"An error occurred: {e}", None
-
-# === MODULE 2: Advanced Text-to-CAD (from text to cad.pdf) ===
-class TextToCADGenerator:
-    """Text-to-CAD generator using procedural geometry."""
-    def __init__(self):
-        self.shapes_library = {
-            'cube': self._create_cube, 'box': self._create_cube,
-            'sphere': self._create_sphere, 'ball': self._create_sphere,
-            'cylinder': self._create_cylinder, 'tube': self._create_cylinder,
-            'cone': self._create_cone, 'plate': self._create_plate,
-            'washer': self._create_washer, 'bracket': self._create_bracket,
-        }
-
-    def parse_prompt(self, prompt: str) -> dict:
-        prompt = prompt.lower().strip()
-        dimensions = self._extract_dimensions(prompt)
-        shape_type = next((shape for shape in self.shapes_library if shape in prompt), 'cube')
-        color = next((c for c in ['red', 'blue', 'green', 'yellow', 'gray'] if c in prompt), 'lightblue')
-        return {'shape': shape_type, 'dimensions': dimensions, 'color': color, 'prompt': prompt}
-
-    def _extract_dimensions(self, prompt: str) -> dict:
-        dims = {'length': 10, 'width': 10, 'height': 10, 'radius': 5, 'diameter': 10}
-        patterns = {
-            'length': r'length\s*[:=]?\s*(\d+\.?\d*)', 'width': r'width\s*[:=]?\s*(\d+\.?\d*)',
-            'height': r'height\s*[:=]?\s*(\d+\.?\d*)', 'radius': r'radius\s*[:=]?\s*(\d+\.?\d*)',
-            'diameter': r'diameter\s*[:=]?\s*(\d+\.?\d*)', 'thick': r'thick\w*\s*[:=]?\s*(\d+\.?\d*)'
-        }
-        for key, pattern in patterns.items():
-            match = re.search(pattern, prompt, re.IGNORECASE)
-            if match:
-                dims[key] = float(match.group(1))
-        return dims
-
-    def generate_3d_model(self, params: dict) -> trimesh.Trimesh:
-        shape_func = self.shapes_library.get(params['shape'], self._create_cube)
-        return shape_func(params['dimensions'])
-
-    def generate_2d_drawing(self, params: dict) -> Image.Image:
-        fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15, 5))
-        fig.suptitle(f"Technical Drawing: {params['shape'].title()}", fontsize=16)
-        dims = params['dimensions']
-        # Simplified drawing logic
-        self._draw_rectangular_part(ax1, ax2, ax3, dims, params['shape'])
-        plt.tight_layout(rect=[0, 0.03, 1, 0.95])
-        buf = io.BytesIO()
-        plt.savefig(buf, format='png', dpi=150)
-        buf.seek(0)
-        img = Image.open(buf)
-        plt.close(fig)
-        return img
-
-    def _draw_rectangular_part(self, ax1, ax2, ax3, dims, shape):
-        l, w, h = dims['length'], dims['width'], dims['height']
-        views = {"Front View": (w, h), "Top View": (w, l), "Side View": (l, h)}
-        axes = {"Front View": ax1, "Top View": ax2, "Side View": ax3}
-        for title, (dim1, dim2) in views.items():
-            ax = axes[title]
-            ax.set_title(title)
-            ax.add_patch(plt.Rectangle((0, 0), dim1, dim2, fill=False, edgecolor='black', linewidth=2))
-            ax.set_xlim(-dim1*0.1, dim1*1.1)
-            ax.set_ylim(-dim2*0.1, dim2*1.1)
-            ax.set_aspect('equal')
-            ax.grid(True, alpha=0.3)
-            ax.set_xlabel(f"Dim 1: {dim1:.2f}")
-            ax.set_ylabel(f"Dim 2: {dim2:.2f}")
-
-    def generate_3d_visualization(self, mesh: trimesh.Trimesh, color: str = 'lightblue') -> go.Figure:
-        fig = go.Figure(data=[go.Mesh3d(
-            x=mesh.vertices[:, 0], y=mesh.vertices[:, 1], z=mesh.vertices[:, 2],
-            i=mesh.faces[:, 0], j=mesh.faces[:, 1], k=mesh.faces[:, 2],
-            color=color, opacity=0.9
-        )])
-        fig.update_layout(title="3D CAD Model", scene=dict(xaxis_title="X", yaxis_title="Y", zaxis_title="Z"))
-        return fig
-
-    # Shape creation methods
-    def _create_cube(self, dims: dict) -> trimesh.Trimesh:
-        return trimesh.creation.box(extents=[dims['length'], dims['width'], dims['height']])
-    def _create_sphere(self, dims: dict) -> trimesh.Trimesh:
-        return trimesh.creation.icosphere(subdivisions=3, radius=dims.get('radius', dims.get('diameter', 10) / 2))
-    def _create_cylinder(self, dims: dict) -> trimesh.Trimesh:
-        return trimesh.creation.cylinder(radius=dims.get('radius', 5), height=dims.get('height', 10))
-    def _create_cone(self, dims: dict) -> trimesh.Trimesh:
-        return trimesh.creation.cone(radius=dims.get('radius', 5), height=dims.get('height', 10))
-    def _create_plate(self, dims: dict) -> trimesh.Trimesh:
-        return trimesh.creation.box(extents=[dims['length'], dims['width'], dims.get('height', 2)])
-    def _create_washer(self, dims: dict) -> trimesh.Trimesh:
-        outer = trimesh.creation.cylinder(radius=dims.get('radius', 10), height=dims.get('height', 2))
-        inner = trimesh.creation.cylinder(radius=dims.get('radius', 10) * 0.5, height=dims.get('height', 2) * 1.1)
-        return outer.difference(inner)
-    def _create_bracket(self, dims: dict) -> trimesh.Trimesh:
-        l, w, h, t = dims.get('length', 20), dims.get('width', 15), dims.get('height', 20), dims.get('thick', 3)
-        base = trimesh.creation.box(extents=[l, w, t])
-        base.apply_translation([l/2, w/2, t/2])
-        wall = trimesh.creation.box(extents=[t, w, h])
-        wall.apply_translation([t/2, w/2, h/2])
-        return base.union(wall)
-
-cad_generator = TextToCADGenerator()
-
-def process_advanced_text_to_cad(prompt: str):
-    """Main function for the advanced CAD generator."""
-    try:
-        params = cad_generator.parse_prompt(prompt)
-        mesh_3d = cad_generator.generate_3d_model(params)
-        drawing_2d = cad_generator.generate_2d_drawing(params)
-        fig_3d = cad_generator.generate_3d_visualization(mesh_3d, params['color'])
-        summary = f"*Shape:* {params['shape'].title()}\n*Dimensions:* {params['dimensions']}"
-        return drawing_2d, fig_3d, summary
-    except Exception as e:
-        return None, go.Figure().add_annotation(text=f"Error: {e}", showarrow=False), f"Error: {e}"
-
-
-# === MODULE 3: 3D to Orthographic View (from cad to ortho.pdf) ===
-
-def generate_ortho_views(uploaded_file):
-    """Generates orthographic views from an uploaded 3D model file."""
-    if uploaded_file is None:
-        return None, "Please upload a 3D model file."
-    try:
-        # PyVista reads from a file path
-        mesh = pv.read(uploaded_file.name)
-
-        # Generate base views with PyVista
-        views, filenames = ['xy', 'xz', 'yz'], ['front.png', 'top.png', 'side.png']
-        plotter = pv.Plotter(off_screen=True, window_size=[800, 800])
-        plotter.background_color = 'white'
-        plotter.enable_parallel_projection()
-        for i, view in enumerate(views):
-            plotter.clear()
-            plotter.add_mesh(mesh.extract_feature_edges(), color='black', line_width=2)
-            plotter.camera_position = view
-            plotter.reset_camera()
-            plotter.camera.zoom(1.2)
-            plotter.screenshot(filenames[i])
-
-        # Combine and add dimensions with Matplotlib
-        fig, axes = plt.subplots(1, 3, figsize=(18, 6))
-        fig.patch.set_facecolor('white')
-        bounds = mesh.bounds
-        x_dim, y_dim, z_dim = bounds[1]-bounds[0], bounds[3]-bounds[2], bounds[5]-bounds[4]
-        dims = [(x_dim, y_dim), (x_dim, z_dim), (y_dim, z_dim)]
-        view_titles = ["Front View (XY)", "Top View (XZ)", "Side View (YZ)"]
-
-        for i, ax in enumerate(axes):
-            img = plt.imread(filenames[i])
-            ax.imshow(img)
-            ax.set_title(view_titles[i], fontsize=12, pad=10)
-            ax.axis('off')
-            dim1, dim2 = dims[i]
-            # Add annotations
-            ax.text(0.5, 0.05, f"Width: {dim1:.2f}", transform=ax.transAxes, ha='center', va='bottom', fontsize=10)
-            ax.text(0.05, 0.5, f"Height: {dim2:.2f}", transform=ax.transAxes, ha='left', va='center', rotation=90, fontsize=10)
-
-        final_path = 'orthographic_views_with_dimensions.png'
-        plt.tight_layout()
-        plt.savefig(final_path, dpi=150)
-        plt.close(fig)
-        return final_path, f"Successfully generated views for {os.path.basename(uploaded_file.name)}."
-
-    except Exception as e:
-        return None, f"An error occurred: {e}"
-
-
-# === MODULE 4: 2D CFD Simulation (from cfd.pdf) ===
-
-def run_cfd_simulation(Lx, Ly, Nx, Ny, inlet_velocity_u, rho, mu, ox1, oy1, ox2, oy2, max_iter, p_iter):
-    """Runs a 2D CFD simulation and returns the result plot."""
-    try:
-        # Grid and Initialization
-        dx, dy = Lx / (Nx - 1), Ly / (Ny - 1)
-        x, y = np.linspace(0, Lx, Nx), np.linspace(0, Ly, Ny)
-        X, Y = np.meshgrid(x, y)
-        u, v, p = np.zeros((Ny, Nx)), np.zeros((Ny, Nx)), np.zeros((Ny, Nx))
-        
-        # Obstacle
-        obstacle_mask = np.zeros((Ny, Nx), dtype=bool)
-        if ox1 < ox2 and oy1 < oy2:
-            i1, i2 = int(ox1 / dx), int(ox2 / dx)
-            j1, j2 = int(oy1 / dy), int(oy2 / dy)
-            obstacle_mask[j1:j2, i1:i2] = True
-
-        # Main Loop (SIMPLE algorithm simplified)
-        nu = mu / rho
-        udiff, stepcount = 1.0, 0
-        alpha_p, alpha_uv = 0.1, 0.5 # Relaxation factors
-
-        for it in range(max_iter):
-            un, vn = u.copy(), v.copy()
-            
-            # Momentum predictor (simplified)
-            # Pressure correction (simplified Poisson equation)
-            p_prime = np.zeros_like(p)
-            for _ in range(p_iter):
-                pn_prime = p_prime.copy()
-                p_prime[1:-1, 1:-1] = ((pn_prime[1:-1, 2:] + pn_prime[1:-1, :-2]) * dy**2 +
-                                       (pn_prime[2:, 1:-1] + pn_prime[:-2, 1:-1]) * dx**2) / \
-                                      (2 * (dx**2 + dy**2))
-                # BCs for p_prime
-                p_prime[:, -1] = 0 # Outlet
-                p_prime[:, 0] = p_prime[:, 1]
-                p_prime[0, :] = p_prime[1, :]
-                p_prime[-1, :] = p_prime[-2, :]
-                
-            p += alpha_p * p_prime
-            
-            # Velocity corrector
-            u[1:-1, 1:-1] -= alpha_uv * (p_prime[1:-1, 1:-1] - p_prime[1:-1, :-2]) / dx
-            v[1:-1, 1:-1] -= alpha_uv * (p_prime[1:-1, 1:-1] - p_prime[:-2, 1:-1]) / dy
-
-            # Boundary Conditions
-            u[:, 0], v[:, 0] = inlet_velocity_u, 0
-            u[:, -1], v[:, -1] = u[:, -2], v[:, -2]
-            u[0, :], v[0, :] = 0, 0
-            u[-1, :], v[-1, :] = 0, 0
-            u[obstacle_mask], v[obstacle_mask] = 0, 0
-
-            udiff = np.linalg.norm(u - un) / (np.linalg.norm(un) + 1e-6)
-            if udiff < 1e-6: break
-
-        # Visualization
-        fig, ax = plt.subplots(figsize=(10, 5))
-        velocity_magnitude = np.sqrt(u**2 + v**2)
-        velocity_magnitude[obstacle_mask] = np.nan
-        
-        cf = ax.contourf(X, Y, velocity_magnitude, levels=50, cmap=cm.jet)
-        fig.colorbar(cf, label='Velocity Magnitude (m/s)')
-        ax.streamplot(X, Y, u, v, color='black', linewidth=0.7, density=1.5)
-        if np.any(obstacle_mask):
-            ax.contour(X, Y, obstacle_mask, levels=[0.5], colors='grey', linewidths=3)
-            
-        ax.set_title(f'CFD Simulation Results after {it+1} iterations')
-        ax.set_xlabel('X (m)')
-        ax.set_ylabel('Y (m)')
-        ax.set_aspect('equal')
-        plt.tight_layout()
-        
-        return fig
-    except Exception as e:
-        fig, ax = plt.subplots()
-        ax.text(0.5, 0.5, f"Error during CFD simulation:\n{e}", ha='center', va='center')
-        return fig
-
-# --- 3. GRADIO UI ---
-
-def create_gradio_interface():
-    """Create and launch the main Gradio interface."""
-    
-    css = """
-    .gradio-container { max-width: 1280px !important; margin: auto; }
-    .gr-tabs { border: 1px solid #E0E0E0; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.05); }
-    footer { display: none !important; }
-    """
-    
-    with gr.Blocks(theme=gr.themes.Soft(), css=css, title="Engineering Suite") as demo:
-        gr.Markdown("# 🛠️ Engineering Suite")
-        gr.Markdown("A collection of tools for CAD generation, G-Code, and simulation. Created by combining multiple code sources.")
-
-        with gr.Tabs():
-            # --- Tab 1: Simple Text to CAD & G-Code ---
-            with gr.TabItem("Text to CAD & G-Code"):
-                gr.Markdown("### Describe a simple 2D part to generate drawings and G-Code.")
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        simple_cad_input = gr.Textbox(
-                            lines=4,
-                            label="Part Description",
-                            placeholder="e.g., A 100mm x 50mm plate with a 20mm diameter hole and a 30mm long and 10mm wide slot"
-                        )
-                        simple_cad_button = gr.Button("Generate", variant="primary")
-                    with gr.Column(scale=2):
-                        simple_cad_img_output = gr.Image(label="3-View Drawing")
-                with gr.Row():
-                    simple_cad_gcode_output = gr.Code(label="Generated G-Code", language="gcode")
-                    simple_cad_svg_output = gr.File(label="Download SVG Drawing")
-                
-                gr.Examples(
-                    examples=[
-                        ["A 150mm x 100mm plate with a 25mm diameter circular cutout"],
-                        ["A 100mm x 100mm plate with a 50mm long and 10mm wide slot"],
-                    ],
-                    inputs=simple_cad_input
-                )
-
-            # --- Tab 2: Advanced Text-to-CAD ---
-            with gr.TabItem("Advanced Text-to-CAD"):
-                gr.Markdown("### Generate a 3D model and technical drawing from a more detailed description.")
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        adv_cad_input = gr.Textbox(lines=4, label="Design Prompt", placeholder="e.g., Create a blue bracket with length 50, width 30, height 40 and thickness 5")
-                        adv_cad_button = gr.Button("Generate 3D Model", variant="primary")
-                        adv_cad_summary = gr.Markdown(label="Generation Summary")
-                    with gr.Column(scale=2):
-                        adv_cad_img_output = gr.Image(label="2D Technical Drawing")
-                        adv_cad_3d_output = gr.Plot(label="Interactive 3D Model")
-
-                gr.Examples(
-                    examples=[
-                        ["A red cube with length 20, width 30, height 15"],
-                        ["A green cylinder with radius 10 and height 40"],
-                        ["A gray washer with radius 15 and height 3"],
-                    ],
-                    inputs=adv_cad_input
-                )
-
-            # --- Tab 3: 3D to Orthographic View ---
-            with gr.TabItem("3D to Orthographic View"):
-                gr.Markdown("### Upload a 3D model file (.stl, .obj) to generate its dimensioned orthographic views.")
-                with gr.Row():
-                    with gr.Column(scale=1):
-                        ortho_input = gr.File(label="Upload 3D Model (.stl, .obj, .ply)")
-                        ortho_button = gr.Button("Generate Ortho Views", variant="primary")
-                        ortho_status = gr.Textbox(label="Status", interactive=False)
-                    with gr.Column(scale=2):
-                        ortho_output = gr.Image(label="Orthographic Views with Dimensions")
-
-            # --- Tab 4: 2D CFD Simulation ---
-            with gr.TabItem("2D CFD Simulation"):
-                gr.Markdown("### Configure and run a 2D channel flow simulation.")
-                with gr.Row():
-                    with gr.Column():
-                        gr.Markdown("**Domain & Grid**")
-                        cfd_Lx = gr.Slider(1.0, 5.0, value=2.0, label="Channel Length (Lx)")
-                        cfd_Ly = gr.Slider(0.5, 2.0, value=1.0, label="Channel Height (Ly)")
-                        cfd_Nx = gr.Slider(31, 101, value=61, step=10, label="Grid Points X (Nx)")
-                        cfd_Ny = gr.Slider(21, 81, value=41, step=10, label="Grid Points Y (Ny)")
-                        gr.Markdown("**Fluid Properties**")
-                        cfd_vel = gr.Slider(0.001, 0.1, value=0.01, label="Inlet Velocity (m/s)")
-                        cfd_rho = gr.Slider(1.0, 1000.0, value=1.0, label="Density (kg/m^3)")
-                        cfd_mu = gr.Slider(0.001, 0.1, value=0.02, label="Viscosity (Pa.s)")
-                    with gr.Column():
-                        gr.Markdown("**Obstacle (relative to domain)**")
-                        cfd_ox1 = gr.Slider(0.0, 1.0, value=0.4, label="Obstacle X1")
-                        cfd_oy1 = gr.Slider(0.0, 1.0, value=0.4, label="Obstacle Y1")
-                        cfd_ox2 = gr.Slider(0.0, 1.0, value=0.6, label="Obstacle X2")
-                        cfd_oy2 = gr.Slider(0.0, 1.0, value=0.6, label="Obstacle Y2")
-                        gr.Markdown("**Solver Settings**")
-                        cfd_max_iter = gr.Slider(100, 5000, value=500, step=100, label="Max Iterations")
-                        cfd_p_iter = gr.Slider(20, 200, value=50, step=10, label="Pressure Solver Iterations")
-                        cfd_button = gr.Button("Run Simulation", variant="primary")
-                cfd_output = gr.Plot(label="CFD Result")
-
-        # --- Event Handlers ---
-        simple_cad_button.click(
-            fn=process_simple_cad,
-            inputs=[simple_cad_input],
-            outputs=[simple_cad_img_output, simple_cad_gcode_output, simple_cad_svg_output]
-        )
-        adv_cad_button.click(
-            fn=process_advanced_text_to_cad,
-            inputs=[adv_cad_input],
-            outputs=[adv_cad_img_output, adv_cad_3d_output, adv_cad_summary]
-        )
-        ortho_button.click(
-            fn=generate_ortho_views,
-            inputs=[ortho_input],
-            outputs=[ortho_output, ortho_status]
-        )
-        cfd_button.click(
-            fn=run_cfd_simulation,
-            inputs=[cfd_Lx, cfd_Ly, cfd_Nx, cfd_Ny, cfd_vel, cfd_rho, cfd_mu, cfd_ox1, cfd_oy1, cfd_ox2, cfd_oy2, cfd_max_iter, cfd_p_iter],
-            outputs=[cfd_output]
-        )
-
-    return demo
-
-# --- 4. LAUNCH THE APP ---
-if __name__ == "__main__":
-    app = create_gradio_interface()
-    app.launch()