app.py

import cadquery as cq
import numpy as np
import matplotlib.pyplot as plt
import pyvista as pv
from reportlab.lib.pagesizes import letter
from reportlab.pdfgen import canvas
import gradio as gr

# Function for Progressive Die Design
def generate_die(length, width, thickness):
    try:
        plate = cq.Workplane("XY").box(length, width, thickness)
        punch = cq.Workplane("XY").rect(10, 10).extrude(5).translate((length / 4, width / 4, thickness / 2))
        die = plate.cut(punch)
        filename = "progressive_die.step"
        cq.exporters.export(die, filename)
        return filename
    except Exception as e:
        return f"Error generating die: {str(e)}"

# Function to visualize die in 3D
def visualize_die(length, width, thickness):
    try:
        plate = cq.Workplane("XY").box(length, width, thickness)
        punch = cq.Workplane("XY").rect(10, 10).extrude(5).translate((length / 4, width / 4, thickness / 2))
        die = plate.cut(punch)

        # Export to STL for visualization
        cq.exporters.exportShape(die.val(), "STL", "progressive_die.stl")

        # Visualize with PyVista
        mesh = pv.read("progressive_die.stl")
        plotter = pv.Plotter(off_screen=True)
        plotter.add_mesh(mesh, color="blue")
        screenshot = "progressive_die_visualization.png"
        plotter.screenshot(screenshot)
        return screenshot
    except Exception as e:
        return f"Error visualizing die: {str(e)}"

# Function for Stress Analysis
def stress_analysis(force, die_width, die_height, material_strength):
    try:
        stress = force / (die_width * die_height)
        safety_factor = material_strength / stress

        fig, ax = plt.subplots()
        ax.bar(["Stress", "Material Strength"], [stress, material_strength])
        ax.set_ylabel("Stress (MPa)")
        ax.set_title("Stress Analysis")
        plt.close(fig)

        return f"Safety Factor: {round(safety_factor, 2)}", fig
    except Exception as e:
        return f"Error in stress analysis: {str(e)}", None

# Function to generate PDF report
def generate_pdf_report(data, filename="report.pdf"):
    try:
        c = canvas.Canvas(filename, pagesize=letter)
        c.drawString(100, 750, "Simulation Report")
        c.drawString(100, 730, f"Max Stress: {data.get('stress', 'N/A')} MPa")
        c.drawString(100, 710, f"Safety Factor: {data.get('safety_factor', 'N/A')}")
        c.save()
        return filename
    except Exception as e:
        return f"Error generating report: {str(e)}"

# Function for Tool Optimization
def optimize_tool(speed, feed_rate, depth_of_cut, material):
    try:
        tool_life = 1000 / (speed * feed_rate * depth_of_cut)
        recommended_speed = 0.8 * speed
        recommended_feed_rate = 0.9 * feed_rate

        return {
            "Estimated Tool Life (hrs)": round(tool_life, 2),
            "Recommended Speed (m/min)": round(recommended_speed, 2),
            "Recommended Feed Rate (mm/rev)": round(recommended_feed_rate, 2)
        }
    except Exception as e:
        return {"Error": str(e)}

# Gradio interface functions
def progressive_die_interface(length, width, thickness):
    filename = generate_die(length, width, thickness)
    visualization = visualize_die(length, width, thickness)
    return filename, visualization

def stress_analysis_interface(force, width, height, material_strength):
    safety_factor, fig = stress_analysis(force, width, height, material_strength)
    data = {"stress": force / (width * height), "safety_factor": safety_factor}
    pdf_filename = generate_pdf_report(data)
    return safety_factor, fig, pdf_filename

def tool_optimization_interface(speed, feed_rate, depth_of_cut, material):
    return optimize_tool(speed, feed_rate, depth_of_cut, material)

# Create the Gradio Interface
with gr.Blocks() as app:
    gr.Markdown("## Press Tool AI Suite")
    gr.Markdown("Select a tool below to get started:")

    with gr.Tabs():
        with gr.Tab("Progressive Die Design"):
            gr.Markdown("### Enter Dimensions for Progressive Die")
            length = gr.Number(label="Length (mm)", value=100)
            width = gr.Number(label="Width (mm)", value=50)
            thickness = gr.Number(label="Thickness (mm)", value=10)
            die_output = gr.Textbox(label="Die Output File")
            visualization_output = gr.Image(label="3D Visualization")
            die_button = gr.Button("Generate Die")
            die_button.click(progressive_die_interface, inputs=[length, width, thickness], outputs=[die_output, visualization_output])

        with gr.Tab("Stress Analysis"):
            gr.Markdown("### Enter Parameters for Stress Analysis")
            force = gr.Number(label="Force (N)", value=10000)
            die_width = gr.Number(label="Width (m)", value=0.05)
            die_height = gr.Number(label="Height (m)", value=0.01)
            material_strength = gr.Number(label="Material Strength (MPa)", value=250)
            safety_factor_output = gr.Textbox(label="Safety Factor")
            stress_chart = gr.Plot()
            pdf_file = gr.File(label="Download Report")
            stress_button = gr.Button("Analyze Stress")
            stress_button.click(stress_analysis_interface, inputs=[force, die_width, die_height, material_strength], outputs=[safety_factor_output, stress_chart, pdf_file])

        with gr.Tab("Tool Optimization"):
            gr.Markdown("### Enter Machining Parameters for Tool Optimization")
            speed = gr.Number(label="Cutting Speed (m/min)", value=100)
            feed_rate = gr.Number(label="Feed Rate (mm/rev)", value=0.2)
            depth_of_cut = gr.Number(label="Depth of Cut (mm)", value=1.0)
            material = gr.Dropdown(choices=["Steel", "Aluminum", "Titanium"], label="Material", value="Steel")
            optimization_results = gr.JSON(label="Optimization Results")
            optimize_button = gr.Button("Optimize Tool")
            optimize_button.click(tool_optimization_interface, inputs=[speed, feed_rate, depth_of_cut, material], outputs=optimization_results)

# Launch the app
app.launch()