import tkinter as tk
from tkinter import ttk, messagebox
from reportlab.pdfgen import canvas
class GuillotineCuttingOptimizer:
def __init__(self, stock_width, stock_length, stock_quantity, cut_sizes):
self.stock_width = stock_width
self.stock_length = stock_length
self.stock_quantity = stock_quantity
self.cut_sizes = cut_sizes
self.sheets_needed = 0
self.remaining_stock_area = 0
self.cut_plan = []
def optimize_cutting_plan(self):
self.cut_sizes.sort(key=lambda x: x[0] * x[1], reverse=True)
stock_area = self.stock_width * self.stock_length * self.stock_quantity
remaining_stock_area = stock_area
sheets_needed = 0
cut_plan = []
while self.cut_sizes:
sheet_area = stock_area
current_cut_plan = []
while self.cut_sizes:
cut_width, cut_length, cut_quantity = self.cut_sizes.pop(0)
if cut_width <= self.stock_width and cut_length <= self.stock_length:
current_cut_plan.append((cut_width, cut_length, cut_quantity))
sheet_area -= cut_width * cut_length * cut_quantity
if sheet_area < stock_area:
sheets_needed += 1
remaining_stock_area -= sheet_area
cut_plan.extend(current_cut_plan)
self.sheets_needed = sheets_needed
self.remaining_stock_area = remaining_stock_area
self.cut_plan = cut_plan
class GuillotineApp:
def __init__(self, root):
self.root = root
self.root.title("Guillotine Cutting Planner")
# Variables
self.stock_width_var = tk.DoubleVar()
self.stock_length_var = tk.DoubleVar()
self.stock_quantity_var = tk.IntVar()
self.cut_width_var = tk.DoubleVar()
self.cut_length_var = tk.DoubleVar()
self.cut_quantity_var = tk.IntVar()
self.cut_sizes = []
# Create and place widgets
self.create_widgets()
def create_widgets(self):
# Stock Sheet Entry
stock_frame = ttk.LabelFrame(self.root, text="Stock Sheet")
stock_frame.grid(row=0, column=0, padx=10, pady=10, sticky="ew")
self.create_label_entry(stock_frame, "Width:", self.stock_width_var, 0)
self.create_label_entry(stock_frame, "Length:", self.stock_length_var, 1)
self.create_label_entry(stock_frame, "Quantity:", self.stock_quantity_var, 2)
# Cut Sizes Entry
cuts_frame = ttk.LabelFrame(self.root, text="Cut Sizes")
cuts_frame.grid(row=1, column=0, padx=10, pady=10, sticky="ew")
self.create_label_entry(cuts_frame, "Width:", self.cut_width_var, 0)
self.create_label_entry(cuts_frame, "Length:", self.cut_length_var, 1)
self.create_label_entry(cuts_frame, "Quantity:", self.cut_quantity_var, 2)
ttk.Button(self.root, text="Optimize", command=self.optimize_and_display).grid(row=2, column=0, pady=20)
ttk.Button(self.root, text="Export to PDF", command=self.export_to_pdf).grid(row=3, column=0, pady=10)
# Canvas for Drawing
self.canvas = tk.Canvas(self.root, bg="white", width=800, height=600)
self.canvas.grid(row=0, column=1, rowspan=4, padx=10, pady=10, sticky="nsew")
# Make canvas resizable
self.root.grid_rowconfigure(0, weight=1)
self.root.grid_columnconfigure(1, weight=1)
# Bind canvas resize event
self.canvas.bind("<Configure>", self.on_canvas_resize)
def create_label_entry(self, frame, label_text, variable, row):
ttk.Label(frame, text=label_text).grid(row=row, column=0, padx=5, pady=5, sticky="e")
ttk.Entry(frame, textvariable=variable).grid(row=row, column=1, padx=5, pady=5, sticky="w")
def on_canvas_resize(self, event):
# Redraw the cut sizes when the canvas is resized
self.display_cut_sizes(self.cut_sizes)
def optimize_and_display(self):
try:
stock_width = float(self.stock_width_var.get())
stock_length = float(self.stock_length_var.get())
stock_quantity = int(self.stock_quantity_var.get())
cut_width = float(self.cut_width_var.get())
cut_length = float(self.cut_length_var.get())
cut_quantity = int(self.cut_quantity_var.get())
if cut_width > 0 and cut_length > 0 and cut_quantity > 0:
self.cut_sizes.append((cut_width, cut_length, cut_quantity))
else:
messagebox.showerror("Error", "Please enter valid positive values for Cut Width, Length, and Quantity.")
optimizer = GuillotineCuttingOptimizer(stock_width, stock_length, stock_quantity, self.cut_sizes)
optimizer.optimize_cutting_plan()
self.display_stock_size(stock_width, stock_length, stock_quantity)
self.display_optimization_results(optimizer)
self.display_cut_sizes(optimizer.cut_plan)
messagebox.showinfo("Optimized Calculation",
f"Optimized Cutting Plan:\nTotal sheets needed: {optimizer.sheets_needed}\nRemaining stock area: {optimizer.remaining_stock_area:.2f} mm²")
except ValueError:
messagebox.showerror("Error", "Please enter valid numeric values.")
def display_stock_size(self, stock_width, stock_length, stock_quantity):
# Clear previous drawings on the canvas
self.canvas.delete("stock_size")
# Calculate total dimensions of stock sheet
total_width = stock_width * stock_quantity
total_length = stock_length
# Draw the stock sheet rectangle
self.canvas.create_rectangle(10, 10, total_width + 10, total_length + 10,
outline="black", fill="lightgreen", tags="stock_size")
# Display stock size dimensions
self.canvas.create_text(total_width / 2 + 10, total_length / 2 + 10,
text=f"Stock Size\n{stock_width} mm x {stock_length} mm x {stock_quantity}",
fill="black", anchor="center", tags="stock_size")
def display_cut_sizes(self, cut_plan):
# Clear previous drawings on the canvas
self.canvas.delete("cut_sizes")
# Calculate total dimensions of stock sheet and cut sizes
total_width = max(self.stock_width_var.get(), *map(lambda x: x[0], cut_plan))
total_length = max(self.stock_length_var.get(), *map(lambda x: x[1], cut_plan))
# Calculate scale factor based on canvas size and total dimensions
scale_factor = min(self.canvas.winfo_width() / total_width, self.canvas.winfo_height() / total_length)
current_x = 10
current_y = 10
for cut_width, cut_length, cut_quantity in cut_plan:
# Scale dimensions for better visibility
scaled_width = cut_width * scale_factor
scaled_length = cut_length * scale_factor
# Draw the cut size rectangle
for _ in range(cut_quantity):
self.canvas.create_rectangle(current_x, current_y, current_x + scaled_width, current_y + scaled_length,
outline="black", fill="lightblue", tags="cut_sizes")
# Display cut size dimensions
self.canvas.create_text(current_x + scaled_width / 2, current_y - 5,
text=f"{cut_width} mm", fill="black", anchor="s", tags="cut_sizes")
self.canvas.create_text(current_x - 5, current_y + scaled_length / 2,
text=f"{cut_length} mm", fill="black", anchor="e", tags="cut_sizes")
# Display cut size quantity
self.canvas.create_text(current_x + scaled_width / 2, current_y + scaled_length + 5,
text=f"Qty: {cut_quantity}", fill="black", anchor="n", tags="cut_sizes")
current_y += scaled_length # Remove the gap between cut sizes
# Adjust the canvas scroll region based on the actual drawing dimensions
self.canvas.config(scrollregion=self.canvas.bbox("all"))
def display_optimization_results(self, optimizer):
# Display optimization results on the canvas
result_text = f"Optimization Results:\nTotal sheets needed: {optimizer.sheets_needed}\nRemaining stock area: {optimizer.remaining_stock_area:.2f} mm²"
self.canvas.create_text(400, 500, text=result_text, fill="black", anchor="center", tags="optimization_results")
def export_to_pdf(self):
try:
pdf_filename = "cutting_plan.pdf"
pdf = canvas.Canvas(pdf_filename, pagesize=(800, 600))
self.display_stock_size_to_pdf(pdf, float(self.stock_width_var.get()), float(self.stock_length_var.get()), int(self.stock_quantity_var.get()))
self.display_cut_sizes_to_pdf(pdf, self.cut_sizes)
self.display_optimization_results_to_pdf(pdf) # Pass optimizer object here
pdf.save()
messagebox.showinfo("PDF Export", f"The cutting plan has been exported to {pdf_filename}")
except Exception as e:
messagebox.showerror("Error", f"An error occurred while exporting to PDF: {str(e)}")
def display_stock_size_to_pdf(self, pdf, stock_width, stock_length, stock_quantity):
# Calculate total dimensions of stock sheet
total_width = stock_width * stock_quantity
total_length = stock_length
# Draw the stock sheet rectangle on PDF
pdf.rect(10, 10, total_width + 10, total_length + 10, fill=1)
# Display stock size dimensions on PDF
pdf.drawCentredString(total_width / 2 + 10, total_length / 2 + 10,
f"Stock Size\n{stock_width} mm x {stock_length} mm x {stock_quantity}")
def display_cut_sizes_to_pdf(self, pdf, cut_plan):
current_x = 10
current_y = 10
for cut_width, cut_length, cut_quantity in cut_plan:
# Scale dimensions for better visibility
scale_factor = 10
scaled_width = cut_width * scale_factor
scaled_length = cut_length * scale_factor
# Draw the cut size rectangle on PDF
for _ in range(cut_quantity):
pdf.rect(current_x, current_y, scaled_width, scaled_length, fill=1)
# Display cut size dimensions on PDF
pdf.drawCentredString(current_x + scaled_width / 2, current_y - 5, f"{cut_width} mm")
pdf.drawRightString(current_x - 5, current_y + scaled_length / 2, f"{cut_length} mm")
# Display cut size quantity on PDF
pdf.drawCentredString(current_x + scaled_width / 2, current_y + scaled_length + 5, f"Qty: {cut_quantity}")
current_y += scaled_length + 10
def display_optimization_results_to_pdf(self, pdf):
# Display optimization results on PDF
result_text = f"Optimization Results:\nTotal sheets needed: {self.sheets_needed}\nRemaining stock area: {self.remaining_stock_area:.2f} mm²"
pdf.drawCentredString(400, 500, result_text)
if __name__ == "__main__":
root = tk.Tk()
app = GuillotineApp(root)
root.mainloop()I need help to finding best 2d cutting optimization cutting plan on cutting layout.It is not working to display well calculated and quality results for the same.