CAD_Agent / backend /export_pdf.py
system's picture
system HF Staff
Deploy ai-solidworks be54a42
8654c8a verified
Raw History Blame Contribute Delete
23.6 kB
"""Illustrative 3D and orthographic PDF export for supported plate plans."""
from __future__ import annotations
import math
from collections.abc import Iterable
from reportlab.lib.colors import Color, HexColor
from reportlab.lib.pagesizes import A4, landscape
from reportlab.pdfgen import canvas
INK = HexColor("#233648")
MUTED = HexColor("#647789")
TOP_FACE = HexColor("#E7EFF6")
FRONT_FACE = HexColor("#B8C9D7")
RIGHT_FACE = HexColor("#8FA6B8")
RULE = HexColor("#CBD5DE")
HIDDEN = HexColor("#75899A")
def _polygon(pdf: canvas.Canvas, points: Iterable[tuple[float, float]], fill: Color) -> None:
points = list(points)
path = pdf.beginPath()
path.moveTo(*points[0])
for point in points[1:]:
path.lineTo(*point)
path.close()
pdf.setFillColor(fill)
pdf.setStrokeColor(INK)
pdf.drawPath(path, stroke=1, fill=1)
def _draw_page_header(pdf: canvas.Canvas, page_w: float, page_h: float, title: str, part_name: str) -> None:
pdf.setFillColor(INK)
pdf.setFont("Helvetica-Bold", 16)
pdf.drawString(38, page_h - 40, title)
pdf.setFillColor(MUTED)
pdf.setFont("Helvetica", 9)
pdf.drawString(38, page_h - 57, f"Part: {part_name} Units: mm Generated from validated CAD plan")
pdf.setStrokeColor(RULE)
pdf.setLineWidth(0.8)
pdf.line(38, page_h - 70, page_w - 38, page_h - 70)
def _draw_footer(pdf: canvas.Canvas, page_w: float, page_number: int) -> None:
pdf.setStrokeColor(RULE)
pdf.line(38, 43, page_w - 38, 43)
pdf.setFillColor(MUTED)
pdf.setFont("Helvetica-Oblique", 8)
pdf.drawString(
38,
29,
"Illustrative drawing only. Not a certified manufacturing drawing; "
"verify dimensions and fit before manufacture.",
)
pdf.drawRightString(page_w - 38, 29, f"Page {page_number} of 2")
def _dimension_horizontal(
pdf: canvas.Canvas,
x1: float,
x2: float,
object_y: float,
dimension_y: float,
label: str,
) -> None:
pdf.saveState()
pdf.setStrokeColor(INK)
pdf.setFillColor(INK)
pdf.setLineWidth(0.65)
pdf.line(x1, object_y, x1, dimension_y - 4)
pdf.line(x2, object_y, x2, dimension_y - 4)
pdf.line(x1, dimension_y, x2, dimension_y)
_arrow(pdf, x1, dimension_y, 1)
_arrow(pdf, x2, dimension_y, -1)
pdf.setFont("Helvetica", 8.5)
pdf.drawCentredString((x1 + x2) / 2, dimension_y - 13, label)
pdf.restoreState()
def _dimension_vertical(
pdf: canvas.Canvas,
x: float,
y1: float,
y2: float,
dimension_x: float,
label: str,
) -> None:
pdf.saveState()
pdf.setStrokeColor(INK)
pdf.setFillColor(INK)
pdf.setLineWidth(0.65)
pdf.line(x, y1, dimension_x + 4, y1)
pdf.line(x, y2, dimension_x + 4, y2)
pdf.line(dimension_x, y1, dimension_x, y2)
_arrow_vertical(pdf, dimension_x, y1, 1)
_arrow_vertical(pdf, dimension_x, y2, -1)
pdf.translate(dimension_x + 11, (y1 + y2) / 2)
pdf.rotate(90)
pdf.setFont("Helvetica", 8.5)
pdf.drawCentredString(0, 0, label)
pdf.restoreState()
def _arrow(pdf: canvas.Canvas, x: float, y: float, direction: int) -> None:
pdf.line(x, y, x + direction * 4, y + 2)
pdf.line(x, y, x + direction * 4, y - 2)
def _arrow_vertical(pdf: canvas.Canvas, x: float, y: float, direction: int) -> None:
pdf.line(x, y, x - 2, y + direction * 4)
pdf.line(x, y, x + 2, y + direction * 4)
def _draw_top_view(
pdf: canvas.Canvas,
x0: float,
y0: float,
length: float,
width: float,
scale: float,
holes: dict | None,
slots: dict | None = None,
pockets: dict | None = None,
*,
mirror_x: bool = False,
) -> None:
draw_w, draw_h = length * scale, width * scale
pdf.saveState()
pdf.setStrokeColor(INK)
pdf.setFillColor(HexColor("#FFFFFF"))
pdf.setLineWidth(1.2)
pdf.rect(x0, y0, draw_w, draw_h, stroke=1, fill=1)
if holes:
diameter = float(holes["diameter"])
radius = diameter * scale / 2
pdf.setLineWidth(0.9)
for hole in holes["positions"]:
cx_mm = length - float(hole["x"]) if mirror_x else float(hole["x"])
cx = x0 + cx_mm * scale
cy = y0 + float(hole["y"]) * scale
pdf.circle(cx, cy, radius, stroke=1, fill=0)
pdf.line(cx - 3, cy, cx + 3, cy)
pdf.line(cx, cy - 3, cx, cy + 3)
if slots:
for slot_position in slots["positions"]:
center_x = float(slot_position["x"])
center_y = float(slot_position["y"])
if mirror_x:
center_x = length - center_x
_draw_capsule(
pdf,
slots,
lambda x, y: (x0 + (center_x + x) * scale, y0 + (center_y + y) * scale),
fill=True,
)
if pockets:
pocket_length = float(pockets["pocket_length"])
pocket_width = float(pockets["pocket_width"])
for position in pockets["positions"]:
center_x = float(position["x"])
center_y = float(position["y"])
if mirror_x:
center_x = length - center_x
pdf.rect(
x0 + (center_x - pocket_length / 2) * scale,
y0 + (center_y - pocket_width / 2) * scale,
pocket_length * scale,
pocket_width * scale,
stroke=1,
fill=0,
)
pdf.restoreState()
def _draw_capsule(pdf: canvas.Canvas, slot: dict, project, *, fill: bool) -> None:
"""Draw a rounded-end slot from its centerline length and width."""
radius = float(slot["slot_width"]) / 2
half_centerline = (float(slot["slot_length"]) - float(slot["slot_width"])) / 2
def point(along: float, across: float) -> tuple[float, float]:
if slot["orientation"] == "y":
along, across = across, along
return project(along, across)
k = 0.5522847498
path = pdf.beginPath()
path.moveTo(*point(-half_centerline, -radius))
path.lineTo(*point(half_centerline, -radius))
path.curveTo(
*point(half_centerline + k * radius, -radius),
*point(half_centerline + radius, -k * radius),
*point(half_centerline + radius, 0),
)
path.curveTo(
*point(half_centerline + radius, k * radius),
*point(half_centerline + k * radius, radius),
*point(half_centerline, radius),
)
path.lineTo(*point(-half_centerline, radius))
path.curveTo(
*point(-half_centerline - k * radius, radius),
*point(-half_centerline - radius, k * radius),
*point(-half_centerline - radius, 0),
)
path.curveTo(
*point(-half_centerline - radius, -k * radius),
*point(-half_centerline - k * radius, -radius),
*point(-half_centerline, -radius),
)
path.close()
pdf.drawPath(path, stroke=1, fill=int(fill))
def _iso_point(
x: float,
y: float,
z: float,
scale: float,
origin_x: float,
origin_y: float,
) -> tuple[float, float]:
cosine = math.cos(math.radians(30))
return (
origin_x + (x - y) * cosine * scale,
origin_y + (x + y) * 0.5 * scale + z * scale,
)
def _ellipse_path(
pdf: canvas.Canvas,
center: tuple[float, float],
axis_x: tuple[float, float],
axis_y: tuple[float, float],
*,
fill: bool,
) -> None:
"""Draw a projected circle using two 2D basis vectors."""
k = 0.5522847498
cx, cy = center
ux, uy = axis_x
vx, vy = axis_y
path = pdf.beginPath()
path.moveTo(cx + ux, cy + uy)
path.curveTo(
cx + ux + k * vx, cy + uy + k * vy,
cx + vx + k * ux, cy + vy + k * uy,
cx + vx, cy + vy,
)
path.curveTo(
cx + vx - k * ux, cy + vy - k * uy,
cx - ux + k * vx, cy - uy + k * vy,
cx - ux, cy - uy,
)
path.curveTo(
cx - ux - k * vx, cy - uy - k * vy,
cx - vx - k * ux, cy - vy - k * uy,
cx - vx, cy - vy,
)
path.curveTo(
cx - vx + k * ux, cy - vy + k * uy,
cx + ux - k * vx, cy + uy - k * vy,
cx + ux, cy + uy,
)
path.close()
pdf.drawPath(path, stroke=1, fill=int(fill))
def _draw_isometric(
pdf: canvas.Canvas,
length: float,
width: float,
thickness: float,
holes: dict | None,
slots: dict | None,
pockets: dict | None,
area: tuple[float, float, float, float],
) -> None:
area_x, area_y, area_w, area_h = area
cosine = math.cos(math.radians(30))
projected_w = cosine * (length + width)
projected_h = 0.5 * (length + width) + thickness
scale = min(area_w / projected_w, area_h / projected_h)
projected_center_x = area_x + area_w / 2
projected_center_y = area_y + area_h / 2
min_x, max_x = -cosine * width, cosine * length
min_y, max_y = 0.0, 0.5 * (length + width) + thickness
origin_x = projected_center_x - (min_x + max_x) * scale / 2
origin_y = projected_center_y - (min_y + max_y) * scale / 2
def p(x: float, y: float, z: float) -> tuple[float, float]:
return _iso_point(x, y, z, scale, origin_x, origin_y)
# Show the two visible side faces and then the top face.
_polygon(
pdf,
[p(0, 0, 0), p(length, 0, 0), p(length, 0, thickness), p(0, 0, thickness)],
FRONT_FACE,
)
_polygon(
pdf,
[p(length, 0, 0), p(length, width, 0), p(length, width, thickness), p(length, 0, thickness)],
RIGHT_FACE,
)
_polygon(
pdf,
[p(0, 0, thickness), p(length, 0, thickness), p(length, width, thickness), p(0, width, thickness)],
TOP_FACE,
)
if holes:
radius = float(holes["diameter"]) / 2
cosine = math.cos(math.radians(30))
for hole in holes["positions"]:
hx, hy = float(hole["x"]), float(hole["y"])
center_top = p(hx, hy, thickness)
center_bottom = p(hx, hy, 0)
axis_x = (radius * cosine * scale, radius * 0.5 * scale)
axis_y = (-radius * cosine * scale, radius * 0.5 * scale)
pdf.saveState()
pdf.setStrokeColor(INK)
pdf.setLineWidth(0.75)
pdf.setFillColor(HexColor("#FFFFFF"))
_ellipse_path(pdf, center_bottom, axis_x, axis_y, fill=True)
_ellipse_path(pdf, center_top, axis_x, axis_y, fill=True)
for sign in (-1, 1):
x_offset, y_offset = sign * axis_x[0], sign * axis_x[1]
pdf.line(
center_top[0] + x_offset,
center_top[1] + y_offset,
center_bottom[0] + x_offset,
center_bottom[1] + y_offset,
)
pdf.restoreState()
if slots:
for slot_position in slots["positions"]:
center_x, center_y = float(slot_position["x"]), float(slot_position["y"])
project_top = lambda x, y: p(center_x + x, center_y + y, thickness)
project_bottom = lambda x, y: p(center_x + x, center_y + y, 0)
pdf.saveState()
pdf.setStrokeColor(INK)
pdf.setLineWidth(0.8)
pdf.setFillColor(HexColor("#FFFFFF"))
_draw_capsule(pdf, slots, project_top, fill=True)
pdf.setStrokeColor(HIDDEN)
pdf.setDash(2, 2)
_draw_capsule(pdf, slots, project_bottom, fill=False)
pdf.restoreState()
if pockets:
pocket_length = float(pockets["pocket_length"])
pocket_width = float(pockets["pocket_width"])
pocket_depth = float(pockets["pocket_depth"])
floor_z = thickness - pocket_depth
for position in pockets["positions"]:
x0 = float(position["x"]) - pocket_length / 2
x1 = float(position["x"]) + pocket_length / 2
y0 = float(position["y"]) - pocket_width / 2
y1 = float(position["y"]) + pocket_width / 2
corners = ((x0, y0), (x1, y0), (x1, y1), (x0, y1))
_polygon(pdf, [p(x, y, floor_z) for x, y in corners], HexColor("#D8E1E8"))
_polygon(pdf, [p(x0, y0, thickness), p(x1, y0, thickness),
p(x1, y0, floor_z), p(x0, y0, floor_z)], FRONT_FACE)
_polygon(pdf, [p(x1, y0, thickness), p(x1, y1, thickness),
p(x1, y1, floor_z), p(x1, y0, floor_z)], RIGHT_FACE)
pdf.saveState()
pdf.setStrokeColor(INK)
pdf.setLineWidth(0.8)
opening = [p(x, y, thickness) for x, y in corners]
for start, end in zip(opening, opening[1:] + opening[:1]):
pdf.line(*start, *end)
pdf.restoreState()
# Reassert the visible top and side edges over the hole graphics.
pdf.saveState()
pdf.setStrokeColor(INK)
pdf.setLineWidth(1.15)
top = [p(0, 0, thickness), p(length, 0, thickness), p(length, width, thickness), p(0, width, thickness)]
for start, end in zip(top, top[1:] + top[:1]):
pdf.line(*start, *end)
side_edges = (
(p(0, 0, 0), p(length, 0, 0)),
(p(length, 0, 0), p(length, width, 0)),
(p(0, 0, 0), p(0, 0, thickness)),
(p(length, 0, 0), p(length, 0, thickness)),
(p(length, width, 0), p(length, width, thickness)),
)
for start, end in side_edges:
pdf.line(*start, *end)
pdf.restoreState()
def _unique(values: Iterable[float]) -> list[float]:
return sorted(set(round(value, 6) for value in values))
def _draw_elevation(
pdf: canvas.Canvas,
center_x: float,
center_y: float,
horizontal_length: float,
thickness: float,
scale: float,
hidden_positions: Iterable[float],
*,
mirror: bool = False,
hidden_ranges: Iterable[tuple[float, float]] = (),
hidden_rectangles: Iterable[tuple[float, float, float, float]] = (),
) -> None:
width_pt, height_pt = horizontal_length * scale, thickness * scale
x0, y0 = center_x - width_pt / 2, center_y - height_pt / 2
pdf.saveState()
pdf.setStrokeColor(INK)
pdf.setLineWidth(1.1)
pdf.rect(x0, y0, width_pt, height_pt, stroke=1, fill=0)
pdf.setStrokeColor(HIDDEN)
pdf.setLineWidth(0.7)
pdf.setDash(3, 2)
for value in hidden_positions:
projected = horizontal_length - value if mirror else value
pdf.line(x0 + projected * scale, y0, x0 + projected * scale, y0 + height_pt)
for start, end in hidden_ranges:
if mirror:
start, end = horizontal_length - end, horizontal_length - start
left, right = x0 + start * scale, x0 + end * scale
pdf.rect(left, y0, right - left, height_pt, stroke=1, fill=0)
for start, end, bottom_z, top_z in hidden_rectangles:
if mirror:
start, end = horizontal_length - end, horizontal_length - start
left, right = x0 + start * scale, x0 + end * scale
bottom, top = y0 + bottom_z * scale, y0 + top_z * scale
pdf.rect(left, bottom, right - left, top - bottom, stroke=1, fill=0)
pdf.setDash()
pdf.restoreState()
def _view_label(pdf: canvas.Canvas, center_x: float, y: float, title: str, subtitle: str | None = None) -> None:
pdf.saveState()
pdf.setFillColor(INK)
pdf.setFont("Helvetica-Bold", 9)
pdf.drawCentredString(center_x, y, title)
if subtitle:
pdf.setFillColor(MUTED)
pdf.setFont("Helvetica", 7)
pdf.drawCentredString(center_x, y - 10, subtitle)
pdf.restoreState()
def export_dimension_pdf(plan: dict, destination: str) -> None:
"""Export a two-page illustrative drawing with an isometric and six face views."""
base = plan["features"][0]
length = float(base["length"])
width = float(base["width"])
thickness = float(base["thickness"])
holes = next((item for item in plan["features"][1:] if item["type"] == "through_holes"), None)
slots = next((item for item in plan["features"][1:] if item["type"] == "through_slots"), None)
pockets = next((item for item in plan["features"][1:] if item["type"] == "rectangular_pockets"), None)
page_w, page_h = landscape(A4)
pdf = canvas.Canvas(destination, pagesize=(page_w, page_h), pageCompression=0)
pdf.setTitle(f'{plan["part_name"]} - 3D and orthographic views')
pdf.setAuthor("AI CAD Agent")
_draw_page_header(pdf, page_w, page_h, "3D MODEL AND DIMENSIONED TOP VIEW", plan["part_name"])
_view_label(pdf, 235, page_h - 94, "ISOMETRIC VIEW")
_draw_isometric(pdf, length, width, thickness, holes, slots, pockets, (55, 125, 365, 325))
_view_label(
pdf,
630,
page_h - 94,
"TOP VIEW",
"Hole positions from bottom-left datum",
)
top_scale = min(292 / length, 170 / width)
top_x = 478
top_y = 308
_draw_top_view(pdf, top_x, top_y, length, width, top_scale, holes, slots, pockets)
_dimension_horizontal(pdf, top_x, top_x + length * top_scale, top_y, top_y - 22, f"L = {length:g} mm")
_dimension_vertical(
pdf,
top_x + length * top_scale,
top_y,
top_y + width * top_scale,
top_x + length * top_scale + 25,
f"W = {width:g} mm",
)
specs_x, specs_y = 478, 252
pdf.setFillColor(INK)
pdf.setFont("Helvetica-Bold", 9)
pdf.drawString(specs_x, specs_y, "MODEL DATA")
pdf.setFillColor(MUTED)
pdf.setFont("Helvetica", 8)
lines = [f"Length: {length:g} mm", f"Width: {width:g} mm", f"Thickness: {thickness:g} mm"]
if holes:
lines.append(f"Through holes: {len(holes['positions'])} x dia. {float(holes['diameter']):g} mm")
for index, hole in enumerate(holes["positions"][:6], start=1):
lines.append(f" H{index}: X {float(hole['x']):g}, Y {float(hole['y']):g} mm")
if len(holes["positions"]) > 6:
lines.append(f" Remaining {len(holes['positions']) - 6} centers are shown in the top view.")
else:
lines.append("No holes")
if slots:
lines.append(
f"Through slots: {len(slots['positions'])} x {float(slots['slot_length']):g} x "
f"{float(slots['slot_width']):g} mm; axis {slots['orientation'].upper()}"
)
for index, position in enumerate(slots["positions"][:6], start=1):
lines.append(f" S{index} center: X {float(position['x']):g}, Y {float(position['y']):g} mm")
else:
lines.append("No through slots")
if pockets:
lines.append(
f"Blind rectangular pockets: {len(pockets['positions'])} x "
f"{float(pockets['pocket_length']):g} x {float(pockets['pocket_width']):g} mm; "
f"depth {float(pockets['pocket_depth']):g} mm"
)
for index, position in enumerate(pockets["positions"][:6], start=1):
lines.append(f" P{index} center: X {float(position['x']):g}, Y {float(position['y']):g} mm")
else:
lines.append("No blind rectangular pockets")
for index, line in enumerate(lines, start=1):
pdf.drawString(specs_x, specs_y - index * 12, line)
pdf.setFont("Helvetica-Oblique", 7.5)
pdf.drawString(specs_x, 75, "All dimensions are in mm. Do not scale from this sheet.")
_draw_footer(pdf, page_w, 1)
pdf.showPage()
_draw_page_header(pdf, page_w, page_h, "ORTHOGRAPHIC PROJECTIONS - SIX PRINCIPAL VIEWS", plan["part_name"])
pdf.setFillColor(MUTED)
pdf.setFont("Helvetica", 8)
pdf.drawString(
38,
page_h - 86,
"One consistent view scale. Dashed edges indicate cut boundaries hidden in edge views.",
)
holes_list = holes["positions"] if holes else []
radius = float(holes["diameter"]) / 2 if holes else 0
x_positions = _unique(float(hole["x"]) for hole in holes_list)
y_positions = _unique(float(hole["y"]) for hole in holes_list)
x_edges = [value for position in x_positions for value in (position - radius, position + radius)]
y_edges = [value for position in y_positions for value in (position - radius, position + radius)]
x_slot_ranges = []
y_slot_ranges = []
if slots:
half_slot = float(slots["slot_length"]) / 2
if slots["orientation"] == "x":
x_slot_ranges = [
(float(position["x"]) - half_slot, float(position["x"]) + half_slot)
for position in slots["positions"]
]
else:
y_slot_ranges = [
(float(position["y"]) - half_slot, float(position["y"]) + half_slot)
for position in slots["positions"]
]
pocket_x_rectangles = []
pocket_y_rectangles = []
if pockets:
pocket_floor = thickness - float(pockets["pocket_depth"])
pocket_half_length = float(pockets["pocket_length"]) / 2
pocket_half_width = float(pockets["pocket_width"]) / 2
pocket_x_rectangles = [
(float(position["x"]) - pocket_half_length,
float(position["x"]) + pocket_half_length, pocket_floor, thickness)
for position in pockets["positions"]
]
pocket_y_rectangles = [
(float(position["y"]) - pocket_half_width,
float(position["y"]) + pocket_half_width, pocket_floor, thickness)
for position in pockets["positions"]
]
scale = min(2.1, (page_w - 76 - 3 * 22) / (2 * (length + width)))
gap = 22
# Third-angle style row: left, front, right, and rear; top and bottom align with front.
widths = [width, length, width, length]
total_width = sum(widths) * scale + 3 * gap
left_edge = (page_w - total_width) / 2
centers: list[float] = []
cursor = left_edge
for view_width in widths:
centers.append(cursor + view_width * scale / 2)
cursor += view_width * scale + gap
left_center, front_center, right_center, rear_center = centers
front_y = 282
top_y_center = front_y + (thickness / 2 + 20 + width / 2) * scale
bottom_y_center = front_y - (thickness / 2 + 20 + width / 2) * scale
_view_label(pdf, left_center, 300, "LEFT VIEW", "looking toward +X")
_draw_elevation(pdf, left_center, front_y, width, thickness, scale, y_edges, mirror=True,
hidden_ranges=y_slot_ranges, hidden_rectangles=pocket_y_rectangles)
_view_label(pdf, front_center, top_y_center + width * scale / 2 + 17, "TOP VIEW")
_draw_top_view(pdf, front_center - length * scale / 2, top_y_center - width * scale / 2,
length, width, scale, holes, slots, pockets)
_view_label(pdf, right_center, 300, "RIGHT VIEW", "looking toward -X")
_draw_elevation(pdf, right_center, front_y, width, thickness, scale, y_edges,
hidden_ranges=y_slot_ranges, hidden_rectangles=pocket_y_rectangles)
_view_label(pdf, rear_center, 300, "REAR VIEW", "looking toward -Y")
_draw_elevation(pdf, rear_center, front_y, length, thickness, scale, x_edges, mirror=True,
hidden_ranges=x_slot_ranges, hidden_rectangles=pocket_x_rectangles)
_view_label(pdf, front_center, 300, "FRONT VIEW", "looking toward +Y")
_draw_elevation(pdf, front_center, front_y, length, thickness, scale, x_edges,
hidden_ranges=x_slot_ranges, hidden_rectangles=pocket_x_rectangles)
_view_label(pdf, front_center, bottom_y_center - width * scale / 2 - 20, "BOTTOM VIEW", "looking toward +Z")
_draw_top_view(pdf, front_center - length * scale / 2, bottom_y_center - width * scale / 2,
length, width, scale, holes, slots, mirror_x=True)
pdf.setFillColor(MUTED)
pdf.setFont("Helvetica", 7)
pdf.drawRightString(page_w - 38, 55, f"Projection views at consistent scale; plate thickness = {thickness:g} mm")
_draw_footer(pdf, page_w, 2)
pdf.save()