Create app.py

app.py

@@ -0,0 +1,640 @@
+import gradio as gr
+from pint import UnitRegistry, set_application_registry
+import matplotlib.pyplot as plt
+import io
+import base64
+from sympy import symbols, Symbol, Eq, solve, Rational
+from reportlab.lib.pagesizes import letter
+from reportlab.pdfgen import canvas
+from PIL import Image
+import base64
+import io
+from reportlab.lib.utils import ImageReader
+import os
+import subprocess
+
+
+
+# Initialize unit registry
+u = UnitRegistry()
+set_application_registry(u)
+Q_ = u.Quantity
+
+def generate_beam_diagram(n_spans, lengths, loads, moments, R_sx, R_dx,
+                          cantilever_left_length=0 * u.meter, cantilever_left_load=0 * u.newton / u.meter,
+                          cantilever_right_length=0 * u.meter, cantilever_right_load=0 * u.newton / u.meter,
+                          unit_system='SI'):
+    # Define units and their abbreviations based on the unit system
+    if unit_system == 'SI':
+        length_unit = u.meter
+        load_unit = u.newton / u.meter
+        moment_unit = u.newton * u.meter
+        reaction_unit = u.newton
+        length_unit_str = 'm'
+        load_unit_str = 'N/m'
+        moment_unit_str = 'N·m'
+        reaction_unit_str = 'N'
+        length_display_unit = u.meter  # For consistent plotting
+    else:
+        length_unit = u.foot
+        load_unit = u.pound_force / u.foot
+        moment_unit = u.pound_force * u.foot
+        reaction_unit = u.pound_force
+        length_unit_str = 'ft'
+        load_unit_str = 'lb/ft'
+        moment_unit_str = 'lb·ft'
+        reaction_unit_str = 'lb'
+        length_display_unit = u.foot  # For consistent plotting
+
+    # Adjust lengths to include cantilevers
+    lengths_display = []
+    x_positions = [0]
+    # Left cantilever
+    if cantilever_left_length.magnitude > 0:
+        l_cant_left_display = cantilever_left_length.to(length_display_unit)
+        lengths_display.append(l_cant_left_display)
+        x_positions.append(x_positions[-1] + l_cant_left_display.magnitude)
+    # Main spans
+    for l in lengths:
+        l_display = l.to(length_display_unit)
+        lengths_display.append(l_display)
+        x_positions.append(x_positions[-1] + l_display.magnitude)
+    # Right cantilever
+    if cantilever_right_length.magnitude > 0:
+        l_cant_right_display = cantilever_right_length.to(length_display_unit)
+        lengths_display.append(l_cant_right_display)
+        x_positions.append(x_positions[-1] + l_cant_right_display.magnitude)
+
+    total_length = x_positions[-1]
+
+    fig, ax = plt.subplots(figsize=(10, 2))
+
+    # Draw the beam as a line
+    ax.hlines(0, 0, total_length, colors='black', linewidth=2)
+
+    # Draw supports
+    support_width = total_length / 50  # Adjust support width relative to total length
+    n_supports = n_spans + 1
+    support_positions = []
+    idx = 0
+    # Left support
+    if cantilever_left_length.magnitude > 0:
+        # Support at end of cantilever
+        x = x_positions[1]
+        support_positions.append(x)
+        ax.plot([x, x], [0, -0.1], color='black')
+        support = plt.Polygon([[x - support_width, -0.1],
+                               [x + support_width, -0.1],
+                               [x, -0.2]], color='black')
+        ax.add_patch(support)
+        idx = 2
+    else:
+        # Support at start
+        x = x_positions[0]
+        support_positions.append(x)
+        ax.plot([x, x], [0, -0.1], color='black')
+        support = plt.Polygon([[x - support_width, -0.1],
+                               [x + support_width, -0.1],
+                               [x, -0.2]], color='black')
+        ax.add_patch(support)
+        idx = 1
+
+    # Intermediate supports
+    for i in range(1, n_supports - 1):
+        x = x_positions[idx]
+        support_positions.append(x)
+        ax.plot([x, x], [0, -0.1], color='black')
+        support = plt.Polygon([[x - support_width, -0.1],
+                               [x + support_width, -0.1],
+                               [x, -0.2]], color='black')
+        ax.add_patch(support)
+        idx += 1
+
+    # Right support
+    if cantilever_right_length.magnitude > 0:
+        # Support before cantilever
+        x = x_positions[-2]
+        support_positions.append(x)
+        ax.plot([x, x], [0, -0.1], color='black')
+        support = plt.Polygon([[x - support_width, -0.1],
+                               [x + support_width, -0.1],
+                               [x, -0.2]], color='black')
+        ax.add_patch(support)
+    else:
+        # Support at end
+        x = x_positions[-1]
+        support_positions.append(x)
+        ax.plot([x, x], [0, -0.1], color='black')
+        support = plt.Polygon([[x - support_width, -0.1],
+                               [x + support_width, -0.1],
+                               [x, -0.2]], color='black')
+        ax.add_patch(support)
+
+    # Annotate reactions
+    for i, x in enumerate(support_positions):
+        # Left-side reaction
+        R_sx_value = R_sx[i]
+        R_sx_unit = R_sx_value.to(reaction_unit)
+        R_sx_num = round(R_sx_unit.magnitude, 6)
+        # Right-side reaction
+        R_dx_value = R_dx[i]
+        R_dx_unit = R_dx_value.to(reaction_unit)
+        R_dx_num = round(R_dx_unit.magnitude, 6)
+        # Display reactions with proper offsets to avoid overlap
+        ax.text(x, 0.15, f'$R_{{{i+1},\, \\mathrm{{sx}}}} = {R_sx_num}$ {reaction_unit_str}',
+                ha='center', va='bottom', color='green')
+        ax.text(x, 0.25, f'$R_{{{i+1},\, \\mathrm{{dx}}}} = {R_dx_num}$ {reaction_unit_str}',
+                ha='center', va='bottom', color='green')
+
+    # Annotate internal moments
+    for i, x in enumerate(support_positions):
+        M_value = moments[i]
+        M_unit = M_value.to(moment_unit)
+        M_num = round(M_unit.magnitude, 6)
+        ax.text(x, -0.25, f'$M_{{{i+1}}} = {M_num}$ {moment_unit_str}',
+                ha='center', va='top', color='blue')
+
+    # Remove axes
+    ax.axis('off')
+    plt.xlim(-0.05 * total_length, total_length * 1.05)
+    plt.ylim(-0.4, 0.4)
+
+    # Save plot to a buffer
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png', bbox_inches='tight', dpi=150)
+    plt.close(fig)
+    buf.seek(0)
+    img_base64 = base64.b64encode(buf.getvalue()).decode('utf-8')
+    return f'<img src="data:image/png;base64,{img_base64}" alt="Beam Diagram"/>'
+
+def calculate_reactions(n_spans, lengths, distributed_loads, moments,
+                        cantilever_left_length=Q_(0.0, u.meter), cantilever_left_load=Q_(0.0, u.newton / u.meter),
+                        cantilever_right_length=Q_(0.0, u.meter), cantilever_right_load=Q_(0.0, u.newton / u.meter)):
+    """
+    Calculate reactions using Excel formulas and print torques:
+    r1_sx = (sx cantilever * weight)
+    r1_dx = (ln-1 * weight)/2 + (torque1 - torque2)/ln-1
+    r2_sx = (ln-1 * weight) - r(m-1)_dx
+    r2_dx = (ln-1 * weight)/2 + (torque_m - torque_m+1)/ln-1
+    And so on...
+    """
+    n_supports = n_spans + 1
+    
+    # Print all torques (moments)
+    print("\nTorques at each support:")
+    for i, moment in enumerate(moments):
+        print(f"Torque {i+1}: {moment}")
+    print("\n")
+    
+    # Initialize reaction lists
+    R_sx = [Q_(0.0, 'newton') for _ in range(n_supports)]
+    R_dx = [Q_(0.0, 'newton') for _ in range(n_supports)]
+
+    # ---------------------------
+    # First support (m = 0)
+    # ---------------------------
+    print(f"Calculating R1:")
+    # r1_sx = (sx cantilever * weight)
+    if cantilever_left_length.magnitude > 0:
+        R_sx[0] = cantilever_left_load * cantilever_left_length
+        print(f"R1_sx = cantilever_load * cantilever_length = {R_sx[0]}")
+        
+    # r1_dx = (l0 * w0)/2 + (torque1 - torque2)/l0
+    R_dx[0] = (distributed_loads[0] * lengths[0]) / 2 + \
+              (moments[0] - moments[1]) / lengths[0]
+    print(f"R1_dx = ({distributed_loads[0]} * {lengths[0]})/2 + ({moments[0]} - {moments[1]})/{lengths[0]} = {R_dx[0]}")
+              
+    # ---------------------------
+    # Middle supports (1..n-1)
+    # ---------------------------
+    for m in range(1, n_supports - 1):
+        print(f"\nCalculating R{m+1}:")
+        # r(m)_sx = (l(m-1)*w(m-1)) - r(m-1)_dx
+        R_sx[m] = distributed_loads[m-1] * lengths[m-1] - R_dx[m-1]
+        print(f"R{m+1}_sx = {distributed_loads[m-1]} * {lengths[m-1]} - {R_dx[m-1]} = {R_sx[m]}")
+        
+        # r(m)_dx = (l(m)*w(m))/2 + (torque_m - torque_(m+1))/l(m)
+        R_dx[m] = (distributed_loads[m] * lengths[m]) / 2 + \
+                  (moments[m] - moments[m+1]) / lengths[m]
+        print(f"R{m+1}_dx = ({distributed_loads[m]} * {lengths[m]})/2 + ({moments[m]} - {moments[m+1]})/{lengths[m]} = {R_dx[m]}")
+    
+    # ---------------------------
+    # Last support (m = n_supports-1)
+    # ---------------------------
+    m = n_supports - 1
+    print(f"\nCalculating R{m+1}:")
+
+    # Last left reaction
+    R_sx[m] = distributed_loads[m-1] * lengths[m-1] - R_dx[m-1]
+    print(f"R{m+1}_sx = {distributed_loads[m-1]} * {lengths[m-1]} - {R_dx[m-1]} = {R_sx[m]}")
+
+    # --- Key Fix: Force R_dx at the last support to always be 0 ---
+    R_dx[m] = Q_(0.0, 'newton')
+    print(f"R{m+1}_dx is forced to 0: {R_dx[m]}")
+    # --------------------------------------------------------------
+
+    # Print final summary of all reactions
+    print("\nFinal Reactions Summary:")
+    for i in range(n_supports):
+        print(f"R{i+1}_sx = {R_sx[i]}")
+        print(f"R{i+1}_dx = {R_dx[i]}")
+        print(f"R{i+1}_total = {R_sx[i] + R_dx[i]}\n")
+
+    return R_sx, R_dx
+
+
+
+
+def continuous_beam_solver(unit_system, n_spans, lengths_str, loads_str,
+                           cantilever_left_length_str='0', cantilever_left_load_str='0',
+                           cantilever_right_length_str='0', cantilever_right_load_str='0'):
+    # Parse the input strings into lists
+    try:
+        n_spans = int(n_spans)
+        l_values = [float(val.strip()) for val in lengths_str.split(',')]
+        p_values = [float(val.strip()) for val in loads_str.split(',')]
+        cantilever_left_length = float(cantilever_left_length_str.strip())
+        cantilever_left_load = float(cantilever_left_load_str.strip())
+        cantilever_right_length = float(cantilever_right_length_str.strip())
+        cantilever_right_load = float(cantilever_right_load_str.strip())
+    except ValueError:
+        return "Invalid input. Please ensure all inputs are numbers.", "", "", "", "", ""
+
+    if len(l_values) != n_spans or len(p_values) != n_spans:
+        return "The number of lengths and loads must match the number of spans.", "", "", "", "", ""
+
+    n_supports = n_spans + 1  # Total number of supports
+
+    # Define units based on the selected unit system
+    if unit_system == 'SI':
+        length_unit = u.meter
+        load_unit = u.newton / u.meter
+        moment_unit = u.newton * u.meter
+        reaction_unit = u.newton
+    else:
+        length_unit = u.foot
+        load_unit = u.pound_force / u.foot
+        moment_unit = u.pound_force * u.foot
+        reaction_unit = u.pound_force
+
+    # Convert lengths and loads to quantities with units
+    l = [Q_(length, length_unit) for length in l_values]
+    p = [Q_(load, load_unit) for load in p_values]
+
+    # Convert lengths and loads to SI units for calculation
+    l_SI = [length.to(u.meter) for length in l]
+    p_SI = [load.to(u.newton / u.meter) for load in p]
+
+    # Process cantilever inputs
+    cantilever_left_length = Q_(cantilever_left_length, length_unit)
+    cantilever_left_load = Q_(cantilever_left_load, load_unit)
+    cantilever_right_length = Q_(cantilever_right_length, length_unit)
+    cantilever_right_load = Q_(cantilever_right_load, load_unit)
+
+    # Convert to SI units for calculations
+    cantilever_left_length_SI = cantilever_left_length.to(u.meter)
+    cantilever_left_load_SI = cantilever_left_load.to(u.newton / u.meter)
+    cantilever_right_length_SI = cantilever_right_length.to(u.meter)
+    cantilever_right_load_SI = cantilever_right_load.to(u.newton / u.meter)
+
+    # Initialize moments at supports
+    M_values_SI = []
+    M_values_Imperial = []
+
+    # Handle single-span beam separately
+    if n_spans == 1:
+        # Moments at supports A and B for a single span
+        M_cantilever_left = 0.0
+        if cantilever_left_length_SI.magnitude > 0 and cantilever_left_load_SI.magnitude != 0:
+            M_cantilever_left = (cantilever_left_load_SI * cantilever_left_length_SI**2 / 2).to(u.newton * u.meter).magnitude
+
+        M_cantilever_right = 0.0
+        if cantilever_right_length_SI.magnitude > 0 and cantilever_right_load_SI.magnitude != 0:
+            M_cantilever_right = (cantilever_right_load_SI * cantilever_right_length_SI**2 / 2).to(u.newton * u.meter).magnitude
+
+        # Assign moments for supports A and B
+        M_A = M_cantilever_left
+        M_B = M_cantilever_right
+
+        # Store the moments in lists
+        M_values_SI = [Q_(M_A, u.newton * u.meter), Q_(M_B, u.newton * u.meter)]
+        M_values_Imperial = [M.to(u.pound_force * u.foot) for M in M_values_SI]
+
+        # Calculate reactions
+        R_sx_SI, R_dx_SI = calculate_reactions(n_spans, l_SI, p_SI, M_values_SI)
+
+        # Convert reactions to Imperial units
+        R_sx_Imperial = [R.to(u.pound_force) for R in R_sx_SI]
+        R_dx_Imperial = [R.to(u.pound_force) for R in R_dx_SI]
+
+        # Prepare results
+        results_SI = ""
+        results_Imperial = ""
+        for i in range(n_supports):
+            M_value_SI = M_values_SI[i]
+            M_value_Imperial = M_values_Imperial[i]
+            results_SI += f"M_{i+1} = {M_value_SI.magnitude:.6f} N·m\n"
+            results_Imperial += f"M_{i+1} = {M_value_Imperial.magnitude:.6f} lb·ft\n"
+
+        # Generate beam diagrams for SI and Imperial units
+        beam_diagram_SI = generate_beam_diagram(
+            n_spans, l, p, M_values_SI, R_sx_SI, R_dx_SI,
+            cantilever_left_length=cantilever_left_length,
+            cantilever_left_load=cantilever_left_load,
+            cantilever_right_length=cantilever_right_length,
+            cantilever_right_load=cantilever_right_load,
+            unit_system='SI'
+        )
+        beam_diagram_Imperial = generate_beam_diagram(
+            n_spans, l, p, M_values_Imperial, R_sx_Imperial, R_dx_Imperial,
+            cantilever_left_length=cantilever_left_length,
+            cantilever_left_load=cantilever_left_load,
+            cantilever_right_length=cantilever_right_length,
+            cantilever_right_load=cantilever_right_load,
+            unit_system='Imperial'
+        )
+
+        # There are no complex equations for the single-span beam, so leave the equations blank.
+        equations_md = ""
+        return results_SI, results_Imperial, beam_diagram_SI, beam_diagram_Imperial, equations_md, ""
+
+    # For multiple spans
+    else:
+        # Compute fixed-end moments due to cantilever loads
+        M_cantilever_left = 0.0
+        if cantilever_left_length_SI.magnitude > 0 and cantilever_left_load_SI.magnitude != 0:
+            M_cantilever_left = (cantilever_left_load_SI * cantilever_left_length_SI**2 / 2).to(u.newton * u.meter).magnitude
+
+        M_cantilever_right = 0.0
+        if cantilever_right_length_SI.magnitude > 0 and cantilever_right_load_SI.magnitude != 0:
+            M_cantilever_right = (cantilever_right_load_SI * cantilever_right_length_SI**2 / 2).to(u.newton * u.meter).magnitude
+
+        # Initialize moments M_i (M_1 to M_{n_supports})
+        M_symbols = []
+        M_symbols.append(M_cantilever_left)  # M_1
+
+        for i in range(1, n_supports - 1):
+            M_symbols.append(symbols(f'M_{i+1}'))  # M_2 to M_{n_supports-1}
+
+        M_symbols.append(M_cantilever_right)  # M_n
+
+        # Set up the system of equations
+        equations = []
+        equations_latex = []
+        for k in range(1, n_supports - 1):
+            # Indices for spans and supports
+            l_prev = l_SI[k - 1].magnitude     # l_{k} in meters
+            l_curr = l_SI[k].magnitude         # l_{k+1} in meters
+            p_prev = p_SI[k - 1].magnitude     # p_{k} in N/m
+            p_curr = p_SI[k].magnitude         # p_{k+1} in N/m
+            M_prev = M_symbols[k - 1]          # M_{k}
+            M_curr = M_symbols[k]              # M_{k+1}
+            M_next = M_symbols[k + 1]          # M_{k+2}
+
+            # Left-hand side of the equation (N·m²)
+            lhs = (1/24) * (l_prev**3 * p_prev + l_curr**3 * p_curr)
+
+            # Right-hand side of the equation (N·m²)
+            rhs = (1/6) * (l_prev * M_prev + l_curr * M_next) + (1/3) * (l_prev + l_curr) * M_curr
+
+            # Form the equation
+            equation = Eq(lhs, rhs)
+            equations.append(equation)
+
+            # Convert equation to LaTeX for display
+            equation_latex = f"\\frac{{1}}{{24}}(l_{{{k}}}^3 p_{{{k}}} + l_{{{k+1}}}^3 p_{{{k+1}}}) = \\frac{{1}}{{6}}(l_{{{k}}} M_{{{k}}} + l_{{{k+1}}} M_{{{k+2}}}) + \\frac{{1}}{{3}}(l_{{{k}}} + l_{{{k+1}}}) M_{{{k+1}}}"
+            equations_latex.append(equation_latex)
+
+        # Solve the system of equations
+        unknown_M_symbols = [M_symbols[i] for i in range(
+            1, n_supports - 1) if isinstance(M_symbols[i], Symbol)]
+
+        solution = solve(equations, unknown_M_symbols, dict=True)
+
+        # Prepare results and collect moments for diagrams
+        if solution:
+            solution = solution[0]  # Extract the solution dictionary
+            results_SI = ""
+            results_Imperial = ""
+            M_values_SI = []
+            M_values_Imperial = []
+            for i in range(n_supports):
+                M_i_value = M_symbols[i]
+                if isinstance(M_i_value, Symbol):
+                    M_i_value = float(solution.get(M_i_value, 0))
+                else:
+                    M_i_value = float(M_i_value)
+
+                # SI Units
+                M_quantity_SI = Q_(M_i_value, u.newton * u.meter)
+                M_values_SI.append(M_quantity_SI)
+                results_SI += f"M_{i+1} = {M_quantity_SI.magnitude:.6f} N·m\n"
+                # Imperial Units
+                M_quantity_Imperial = M_quantity_SI.to(u.pound_force * u.foot)
+                M_values_Imperial.append(M_quantity_Imperial)
+                results_Imperial += f"M_{i+1} = {M_quantity_Imperial.magnitude:.6f} lb·ft\n"
+        else:
+            return "No solution found.", "", "", "", "", ""
+
+        # Calculate reactions
+        R_sx_SI, R_dx_SI = calculate_reactions(n_spans, l_SI, p_SI, M_values_SI)
+
+        # Convert reactions to Imperial units
+        R_sx_Imperial = [R.to(u.pound_force) for R in R_sx_SI]
+        R_dx_Imperial = [R.to(u.pound_force) for R in R_dx_SI]
+
+        # Generate beam diagrams
+        beam_diagram_SI = generate_beam_diagram(
+            n_spans, l, p, M_values_SI, R_sx_SI, R_dx_SI,
+            cantilever_left_length=cantilever_left_length,
+            cantilever_left_load=cantilever_left_load,
+            cantilever_right_length=cantilever_right_length,
+            cantilever_right_load=cantilever_right_load,
+            unit_system='SI')
+        beam_diagram_Imperial = generate_beam_diagram(
+            n_spans, l, p, M_values_Imperial, R_sx_Imperial, R_dx_Imperial,
+            cantilever_left_length=cantilever_left_length,
+            cantilever_left_load=cantilever_left_load,
+            cantilever_right_length=cantilever_right_length,
+            cantilever_right_load=cantilever_right_load,
+            unit_system='Imperial')
+
+        # Prepare equations in LaTeX
+        equations_md = "\n\n".join(
+            [f"**Equation {i+1}:**\n\n$$ {eq} $$" for i, eq in enumerate(equations_latex)])
+
+        return results_SI, results_Imperial, beam_diagram_SI, beam_diagram_Imperial, equations_md, ""
+
+
+
+# def add_image_to_pdf(canvas, image_data, x, y, max_width, max_height):
+#     """Helper function to add an image to the PDF canvas while preserving aspect ratio."""
+#     # Decode the base64 image data
+#     # image_data is like "data:image/png;base64,iVBOR..." so split off the header
+#     base64_data = image_data.split(",")[1]
+#     img_bytes = base64.b64decode(base64_data)
+#     img = Image.open(io.BytesIO(img_bytes))
+
+#     # Get the original size
+#     orig_width, orig_height = img.size
+
+#     # Compute a scale factor so that the image fits within max_width x max_height
+#     # while preserving aspect ratio
+#     scale = min(max_width / orig_width, max_height / orig_height)
+
+#     # Scaled dimensions
+#     display_width = orig_width * scale
+#     display_height = orig_height * scale
+
+#     # Convert the (scaled) PIL image to something reportlab can draw
+#     buffer = io.BytesIO()
+#     img.save(buffer, format="PNG")
+#     buffer.seek(0)
+#     img_reader = ImageReader(buffer)
+
+#     # Draw the image onto the canvas at (x, y), with the scaled width/height
+#     canvas.drawImage(img_reader, x, y, width=display_width, height=display_height)
+
+
+# def create_pdf_report(filename, results_SI, results_Imperial, beam_diagram_SI, beam_diagram_Imperial, equations_md):
+#     """
+#     Creates a multi-page PDF:
+#       - Page 1: Title, summary, internal moments (SI & Imperial)
+#       - Page 2: SI beam diagram
+#       - Page 3: Imperial beam diagram
+#       - Page 4: Equations in LaTeX syntax (un-rendered, but still readable).
+#     """
+#     c = canvas.Canvas(filename, pagesize=letter)
+#     page_width, page_height = letter
+
+#     # -------------
+#     # PAGE 1: Title & Moments
+#     # -------------
+#     c.setFont("Helvetica-Bold", 16)
+#     c.drawString(30, page_height - 40, "Continuous Beam Analysis Report")
+    
+#     # Description
+#     c.setFont("Helvetica", 12)
+#     c.drawString(30, page_height - 70, "This report contains a detailed analysis of a continuous beam, including:")
+#     c.drawString(50, page_height - 90, "- Internal moments at supports")
+#     c.drawString(50, page_height - 110, "- Beam diagrams (SI and Imperial)")
+#     c.drawString(50, page_height - 130, "- Equations used (in LaTeX)")
+
+#     # Internal Moments (SI)
+#     y_offset = page_height - 170
+#     c.setFont("Helvetica-Bold", 14)
+#     c.drawString(30, y_offset, "Internal Moments at Supports (SI Units):")
+#     y_offset -= 20
+#     c.setFont("Helvetica", 12)
+#     text_obj = c.beginText(30, y_offset)
+#     text_obj.textLines(results_SI)
+#     c.drawText(text_obj)
+
+#     # Internal Moments (Imperial)
+#     y_offset -= 20 + 14 * (results_SI.count("\n") + 1)  # move down after SI text
+#     c.setFont("Helvetica-Bold", 14)
+#     c.drawString(30, y_offset, "Internal Moments at Supports (Imperial Units):")
+#     y_offset -= 20
+#     c.setFont("Helvetica", 12)
+#     text_obj = c.beginText(30, y_offset)
+#     text_obj.textLines(results_Imperial)
+#     c.drawText(text_obj)
+
+#     # Finish Page 1
+#     c.showPage()
+
+#     # -------------
+#     # PAGE 2: SI Diagram
+#     # -------------
+#     c.setFont("Helvetica-Bold", 14)
+#     c.drawString(30, page_height - 40, "Beam Diagram (SI Units)")
+#     c.setFont("Helvetica", 12)
+#     # You could add more descriptive text here if desired.
+
+#     # Place the SI diagram, preserving aspect ratio
+#     if beam_diagram_SI:
+#         max_w = 500
+#         max_h = 400
+#         # 30 points from left, 100 points from bottom
+#         add_image_to_pdf(c, beam_diagram_SI, 30, page_height - 100 - max_h, max_w, max_h)
+
+#     c.showPage()
+
+#     # -------------
+#     # PAGE 3: Imperial Diagram
+#     # -------------
+#     c.setFont("Helvetica-Bold", 14)
+#     c.drawString(30, page_height - 40, "Beam Diagram (Imperial Units)")
+#     c.setFont("Helvetica", 12)
+
+#     # Place the Imperial diagram, preserving aspect ratio
+#     if beam_diagram_Imperial:
+#         max_w = 500
+#         max_h = 400
+#         add_image_to_pdf(c, beam_diagram_Imperial, 30, page_height - 100 - max_h, max_w, max_h)
+
+#     c.showPage()
+
+#     # -------------
+#     # PAGE 4: Equations in LaTeX
+#     # -------------
+#     c.setFont("Helvetica-Bold", 16)
+#     c.drawString(30, page_height - 40, "Equations Used in Analysis (LaTeX):")
+#     c.setFont("Helvetica", 12)
+
+#     y_offset = page_height - 70
+#     text_obj = c.beginText(30, y_offset)
+
+#     # Here, we do NOT strip out the $$ or **, so the raw LaTeX is visible
+#     lines = equations_md.split("\n")
+#     text_obj.textLines(lines)
+#     c.drawText(text_obj)
+
+#     # Finish the PDF
+#     c.save()
+
+def gradio_interface(unit_system, n_spans, lengths_str, loads_str,
+                     cantilever_left_length, cantilever_left_load,
+                     cantilever_right_length, cantilever_right_load):
+    # Call continuous beam solver to get results
+    results_SI, results_Imperial, beam_diagram_SI, beam_diagram_Imperial, equations_md, pdf_filename = continuous_beam_solver(
+        unit_system, n_spans, lengths_str, loads_str,
+        cantilever_left_length, cantilever_left_load,
+        cantilever_right_length, cantilever_right_load)
+
+    # # Create the PDF report
+    # pdf_filename = "continuous_beam_analysis_report.pdf"
+    # create_pdf_report(pdf_filename, results_SI, results_Imperial, beam_diagram_SI, beam_diagram_Imperial, equations_md)
+
+    return results_SI, results_Imperial, beam_diagram_SI, beam_diagram_Imperial, equations_md # ,pdf_filename
+
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=[
+        gr.Radio(['SI', 'Imperial'], label="Unit System", value='SI'),
+        gr.Number(label="Number of Spans (n)", value=3, precision=0),
+        gr.Textbox(label="Lengths l_i (comma-separated)", placeholder="e.g., 5, 5, 5", value='7.91667,7.91667,7.91667'),
+        gr.Textbox(label="Loads p_i (comma-separated)", placeholder="e.g., 10000, 10000, 10000", value='200,200,200'),
+        gr.Textbox(label="Cantilever Left Length", placeholder="e.g., 2.0", value='6.66667'),
+        gr.Textbox(label="Cantilever Left Load", placeholder="e.g., 5000", value='200'),
+        gr.Textbox(label="Cantilever Right Length", placeholder="e.g., 0", value='6.66667'),
+        gr.Textbox(label="Cantilever Right Load", placeholder="e.g., 0", value='200'),
+    ],
+    outputs=[
+        gr.Textbox(label="Internal Moments at Supports (SI Units)"),
+        gr.Textbox(label="Internal Moments at Supports (Imperial Units)"),
+        gr.HTML(label="Beam Diagram (SI Units)"),
+        gr.HTML(label="Beam Diagram (Imperial Units)"),
+        gr.Markdown(label="Equations Used"),
+        # gr.File(label="Download Report")
+    ],c
+    title="Continuous Beam Solver with Cantilevers",
+    description="Solve for internal moments at supports of a continuous beam with multiple spans, including cantilevers.\n"
+                "Select the unit system for input. The results will be displayed in both SI and Imperial units.\n\n"
+                "The beam diagrams and equations used will be displayed below.",
+    allow_flagging="never",
+)
+
+
+if __name__ == "__main__":
+    iface.launch()