python-cad-tools 0.1.0rc1__py3-none-any.whl

python_cad_tools/exporters/drawings/pdf.py

@@ -0,0 +1,119 @@
+"""Python CAD Tools vector PDF sheet-set writer."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from reportlab.lib.pagesizes import landscape, letter
+from reportlab.pdfgen.canvas import Canvas
+
+from .primitives import DrawingScene
+
+
+def write_pdf(scenes: list[DrawingScene], path: Path) -> Path:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    page_size = landscape(letter)
+    canvas = Canvas(str(path), pagesize=page_size, pageCompression=0, invariant=1)
+    for scene in scenes:
+        _draw_scene(canvas, scene, page_size)
+        canvas.showPage()
+    canvas.save()
+    return path
+
+
+def _draw_scene(canvas: Canvas, scene: DrawingScene, page_size: tuple[float, float]) -> None:
+    page_width, page_height = page_size
+    margin = 42
+    canvas.setFillColorRGB(1, 1, 1)
+    canvas.rect(0, 0, page_width, page_height, stroke=0, fill=1)
+    canvas.setFillColorRGB(0, 0, 0)
+    canvas.setStrokeColorRGB(0.2, 0.2, 0.2)
+    canvas.setLineWidth(0.6)
+    canvas.rect(24, 24, page_width - 48, page_height - 48, stroke=1, fill=0)
+    x0, y0, x1, y1 = scene.viewport.bounds
+    scale = min((page_width - 2 * margin) / (x1 - x0), (page_height - 3 * margin) / (y1 - y0))
+
+    def point(value: tuple[float, float]) -> tuple[float, float]:
+        return margin + (value[0] - x0) * scale, margin * 1.5 + (value[1] - y0) * scale
+
+    canvas.setStrokeColorRGB(0.05, 0.05, 0.05)
+    canvas.setLineWidth(1.0)
+    for polyline in scene.polylines:
+        path = canvas.beginPath()
+        start = point(polyline.points[0])
+        path.moveTo(*start)
+        for source in polyline.points[1:]:
+            path.lineTo(*point(source))
+        if polyline.closed:
+            path.close()
+        canvas.drawPath(path)
+    canvas.saveState()
+    canvas.setStrokeColorRGB(0.1, 0.35, 0.55)
+    canvas.setDash(7, 3)
+    canvas.setLineWidth(0.8)
+    for line in scene.lines:
+        canvas.line(*point(line.start), *point(line.end))
+    canvas.restoreState()
+    canvas.saveState()
+    canvas.setStrokeColorRGB(0.25, 0.25, 0.25)
+    canvas.setFillColorRGB(0.15, 0.15, 0.15)
+    canvas.setLineWidth(0.65)
+    canvas.setFont("Helvetica", 7)
+    for dimension in scene.dimensions:
+        dx = dimension.end[0] - dimension.start[0]
+        dy = dimension.end[1] - dimension.start[1]
+        if abs(dx) >= abs(dy):
+            start = (dimension.start[0], dimension.start[1] + dimension.offset)
+            end = (dimension.end[0], dimension.end[1] + dimension.offset)
+        else:
+            start = (dimension.start[0] + dimension.offset, dimension.start[1])
+            end = (dimension.end[0] + dimension.offset, dimension.end[1])
+        start_page = point(start)
+        end_page = point(end)
+        canvas.line(*start_page, *end_page)
+        canvas.line(start_page[0] - 3, start_page[1] - 3, start_page[0] + 3, start_page[1] + 3)
+        canvas.line(end_page[0] - 3, end_page[1] - 3, end_page[0] + 3, end_page[1] + 3)
+        canvas.drawCentredString(
+            (start_page[0] + end_page[0]) / 2,
+            (start_page[1] + end_page[1]) / 2 + 4,
+            dimension.label,
+        )
+    canvas.restoreState()
+    canvas.setFont("Helvetica", 7)
+    for text in scene.texts:
+        canvas.drawString(*point(text.position), text.value)
+    for entity in scene.annotation_entities:
+        canvas.saveState()
+        canvas.setStrokeColorRGB(0.48, 0.12, 0.12)
+        canvas.setFillColorRGB(0.48, 0.12, 0.12)
+        canvas.setLineWidth(0.8)
+        if entity.kind == "line":
+            canvas.line(*point(entity.points[0]), *point(entity.points[1]))
+        elif entity.kind == "polyline":
+            annotation_path = canvas.beginPath()
+            annotation_path.moveTo(*point(entity.points[0]))
+            for source in entity.points[1:]:
+                annotation_path.lineTo(*point(source))
+            if entity.closed:
+                annotation_path.close()
+            canvas.drawPath(annotation_path)
+        elif entity.kind == "circle" and entity.center is not None and entity.radius is not None:
+            center = point(entity.center)
+            canvas.circle(center[0], center[1], entity.radius * scale, stroke=1, fill=0)
+        elif entity.kind == "text" and entity.text is not None:
+            x, y = point(entity.points[0])
+            canvas.translate(x, y)
+            canvas.rotate(entity.rotation_degrees)
+            canvas.setFont("Helvetica", max(entity.height_mm * scale, 5.0))
+            canvas.drawString(0, 0, entity.text)
+        canvas.restoreState()
+    canvas.setFont("Helvetica-Bold", 12)
+    canvas.drawString(margin, page_height - margin, scene.title_block.sheet_title)
+    canvas.setFont("Helvetica", 8)
+    canvas.drawString(margin, margin * 0.72, scene.title_block.project_name)
+    canvas.drawRightString(page_width - margin, page_height - margin, f"{scene.title_block.sheet_number}  Rev {scene.title_block.revision}")
+    canvas.line(margin, margin * 1.05, page_width - margin, margin * 1.05)
+    canvas.setFillColorRGB(0.65, 0.0, 0.0)
+    canvas.setFont("Helvetica-Bold", 11)
+    canvas.drawCentredString(page_width / 2, margin * 0.72, scene.title_block.notice)
+    canvas.setFillColorRGB(0, 0, 0)

python_cad_tools/exporters/drawings/primitives.py

@@ -0,0 +1,93 @@
+"""Format-neutral Python CAD Tools drawing primitives."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .annotations import AnnotationEntity
+
+
+@dataclass(frozen=True, slots=True)
+class Line:
+    start: tuple[float, float]
+    end: tuple[float, float]
+    layer: str = "VISIBLE"
+    source_id: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class Polyline:
+    points: tuple[tuple[float, float], ...]
+    closed: bool = False
+    layer: str = "VISIBLE"
+    source_id: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class Arc:
+    center: tuple[float, float]
+    radius: float
+    start_deg: float
+    end_deg: float
+    layer: str = "VISIBLE"
+
+
+@dataclass(frozen=True, slots=True)
+class Text:
+    position: tuple[float, float]
+    value: str
+    height: float = 3.0
+    layer: str = "TEXT"
+
+
+@dataclass(frozen=True, slots=True)
+class Dimension:
+    start: tuple[float, float]
+    end: tuple[float, float]
+    offset: float
+    label: str
+    source_id: str | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class Leader:
+    points: tuple[tuple[float, float], ...]
+    label: str
+
+
+@dataclass(frozen=True, slots=True)
+class Hatch:
+    boundary: tuple[tuple[float, float], ...]
+    pattern: str = "ANSI31"
+
+
+@dataclass(frozen=True, slots=True)
+class Viewport:
+    name: str
+    bounds: tuple[float, float, float, float]
+    scale: float
+
+
+@dataclass(frozen=True, slots=True)
+class TitleBlock:
+    project_name: str
+    sheet_title: str
+    sheet_number: str
+    revision: str
+    notice: str = "Conceptual — not for construction or permitting"
+
+
+@dataclass(slots=True)
+class DrawingScene:
+    title_block: TitleBlock
+    viewport: Viewport
+    lines: list[Line] = field(default_factory=list)
+    polylines: list[Polyline] = field(default_factory=list)
+    arcs: list[Arc] = field(default_factory=list)
+    texts: list[Text] = field(default_factory=list)
+    dimensions: list[Dimension] = field(default_factory=list)
+    leaders: list[Leader] = field(default_factory=list)
+    hatches: list[Hatch] = field(default_factory=list)
+    annotation_entities: tuple[AnnotationEntity, ...] = ()

python_cad_tools/exporters/drawings/projection.py

@@ -0,0 +1,64 @@
+"""Orthographic shared-model projection into Python CAD Tools primitives."""
+
+from __future__ import annotations
+
+from ...drawings import AnnotationPrimitive, DrawingSheet
+from ...drawings._catalog import project_bounds
+from ...geometry import bounds
+from ...units import format_feet_inches
+from ..base import selected_elements
+from .annotations import annotation_bounds, flatten_annotations
+from .primitives import Dimension, DrawingScene, Line, Polyline, Text, TitleBlock, Viewport
+
+
+def project_model(
+    model,
+    sheet: DrawingSheet,
+    annotations: tuple[AnnotationPrimitive, ...] = (),
+    revision: str = "WORKING",
+) -> DrawingScene:
+    physical = selected_elements(model, "drawings", physical_only=True)
+    rectangles = []
+    for element in physical:
+        rectangle = project_bounds(bounds(element.geometry), sheet.origin_mm, sheet.x_axis, sheet.y_axis)
+        rectangles.append((element, rectangle))
+    geometry_bounds = sheet.projected_bounds_mm
+    min_x, min_y, max_x, max_y = geometry_bounds
+    annotation_entities = flatten_annotations(annotations)
+    annotation_rectangle = annotation_bounds(annotation_entities)
+    if annotation_rectangle is not None:
+        min_x = min(min_x, annotation_rectangle[0])
+        min_y = min(min_y, annotation_rectangle[1])
+        max_x = max(max_x, annotation_rectangle[2])
+        max_y = max(max_y, annotation_rectangle[3])
+    padding = max(max_x - min_x, max_y - min_y) * 0.12
+    scene = DrawingScene(
+        title_block=TitleBlock(model.name, f"Overall {sheet.view_id.title()}", sheet.sheet_id, revision),
+        viewport=Viewport(sheet.view_id, (min_x - padding, min_y - padding, max_x + padding, max_y + padding), 1.0),
+        annotation_entities=annotation_entities,
+    )
+    label_all = len(rectangles) <= 20
+    for element, (x0, y0, x1, y1) in rectangles:
+        scene.polylines.append(
+            Polyline(((x0, y0), (x1, y0), (x1, y1), (x0, y1)), True, "VISIBLE", element.id)
+        )
+        if label_all or element.properties.get("drawing_label", False):
+            scene.texts.append(
+                Text((x0, y1 + padding * 0.12), f"{element.name} [{element.id}]", max(padding * 0.035, 3))
+            )
+    for element in selected_elements(model, "drawings"):
+        if element.physical:
+            continue
+        projected = project_bounds(bounds(element.geometry), sheet.origin_mm, sheet.x_axis, sheet.y_axis)
+        start, end = (projected[0], projected[1]), (projected[2], projected[3])
+        if start != end:
+            scene.lines.append(Line(start, end, "REFERENCE", element.id))
+    if rectangles:
+        x0, y0, x1, y1 = geometry_bounds
+        scene.dimensions.extend(
+            [
+                Dimension((x0, y0), (x1, y0), -padding * 0.35, format_feet_inches(x1 - x0), model.id),
+                Dimension((x0, y0), (x0, y1), -padding * 0.35, format_feet_inches(y1 - y0), model.id),
+            ]
+        )
+    return scene

python_cad_tools/exporters/drawings/svg.py

@@ -0,0 +1,135 @@
+"""SVG writer for the shared Python CAD Tools drawing scene."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from xml.etree import ElementTree as ET
+
+from .primitives import DrawingScene
+
+SVG_NS = "http://www.w3.org/2000/svg"
+ET.register_namespace("", SVG_NS)
+
+
+def write_svg(scene: DrawingScene, path: Path) -> Path:
+    x0, y0, x1, y1 = scene.viewport.bounds
+    width = x1 - x0
+    height = y1 - y0
+    root = ET.Element(
+        f"{{{SVG_NS}}}svg",
+        {
+            "viewBox": f"{x0:g} {y0:g} {width:g} {height:g}",
+            "data-sheet": scene.title_block.sheet_number,
+        },
+    )
+    ET.SubElement(root, f"{{{SVG_NS}}}title").text = scene.title_block.sheet_title
+    group = ET.SubElement(root, f"{{{SVG_NS}}}g", {"transform": f"translate(0 {y0 + y1:g}) scale(1 -1)"})
+    for polyline in scene.polylines:
+        points = " ".join(f"{x:g},{y:g}" for x, y in polyline.points)
+        ET.SubElement(
+            group,
+            f"{{{SVG_NS}}}{'polygon' if polyline.closed else 'polyline'}",
+            {
+                "points": points,
+                "fill": "none",
+                "stroke": "#111111",
+                "stroke-width": "2",
+                "vector-effect": "non-scaling-stroke",
+                "data-layer": polyline.layer,
+                "data-source-id": polyline.source_id or "",
+            },
+        )
+    for line in scene.lines:
+        ET.SubElement(
+            group,
+            f"{{{SVG_NS}}}line",
+            {
+                "x1": f"{line.start[0]:g}", "y1": f"{line.start[1]:g}",
+                "x2": f"{line.end[0]:g}", "y2": f"{line.end[1]:g}",
+                "stroke": "#111111", "data-layer": line.layer,
+            },
+        )
+    text_group = ET.SubElement(root, f"{{{SVG_NS}}}g", {"fill": "#111111", "font-family": "sans-serif"})
+    for item in scene.texts:
+        ET.SubElement(
+            text_group,
+            f"{{{SVG_NS}}}text",
+            {"x": f"{item.position[0]:g}", "y": f"{y0 + y1 - item.position[1]:g}", "font-size": f"{item.height:g}"},
+        ).text = item.value
+    for dimension in scene.dimensions:
+        dx = dimension.end[0] - dimension.start[0]
+        dy = dimension.end[1] - dimension.start[1]
+        if abs(dx) >= abs(dy):
+            a = (dimension.start[0], dimension.start[1] + dimension.offset)
+            b = (dimension.end[0], dimension.end[1] + dimension.offset)
+        else:
+            a = (dimension.start[0] + dimension.offset, dimension.start[1])
+            b = (dimension.end[0] + dimension.offset, dimension.end[1])
+        ET.SubElement(group, f"{{{SVG_NS}}}line", {"x1": f"{a[0]:g}", "y1": f"{a[1]:g}", "x2": f"{b[0]:g}", "y2": f"{b[1]:g}", "stroke": "#333333", "data-layer": "DIMENSIONS"})
+        ET.SubElement(text_group, f"{{{SVG_NS}}}text", {"x": f"{(a[0] + b[0]) / 2:g}", "y": f"{y0 + y1 - (a[1] + b[1]) / 2:g}", "font-size": "12", "text-anchor": "middle"}).text = dimension.label
+    annotation_group = ET.SubElement(group, f"{{{SVG_NS}}}g", {"data-layer": "ANNOTATIONS"})
+    annotation_text_group = ET.SubElement(
+        root,
+        f"{{{SVG_NS}}}g",
+        {"data-layer": "ANNOTATIONS", "fill": "#111111", "font-family": "sans-serif"},
+    )
+    for entity in scene.annotation_entities:
+        attributes = {"data-annotation-id": entity.id, "data-style": entity.style}
+        if entity.kind == "line":
+            start, end = entity.points
+            ET.SubElement(
+                annotation_group,
+                f"{{{SVG_NS}}}line",
+                attributes
+                | {
+                    "x1": f"{start[0]:g}",
+                    "y1": f"{start[1]:g}",
+                    "x2": f"{end[0]:g}",
+                    "y2": f"{end[1]:g}",
+                    "fill": "none",
+                    "stroke": "#7a1f1f",
+                    "vector-effect": "non-scaling-stroke",
+                },
+            )
+        elif entity.kind == "polyline":
+            ET.SubElement(
+                annotation_group,
+                f"{{{SVG_NS}}}{'polygon' if entity.closed else 'polyline'}",
+                attributes
+                | {
+                    "points": " ".join(f"{x:g},{y:g}" for x, y in entity.points),
+                    "fill": "none",
+                    "stroke": "#7a1f1f",
+                    "vector-effect": "non-scaling-stroke",
+                },
+            )
+        elif entity.kind == "circle" and entity.center is not None and entity.radius is not None:
+            ET.SubElement(
+                annotation_group,
+                f"{{{SVG_NS}}}circle",
+                attributes
+                | {
+                    "cx": f"{entity.center[0]:g}",
+                    "cy": f"{entity.center[1]:g}",
+                    "r": f"{entity.radius:g}",
+                    "fill": "none",
+                    "stroke": "#7a1f1f",
+                    "vector-effect": "non-scaling-stroke",
+                },
+            )
+        elif entity.kind == "text" and entity.text is not None:
+            x, y = entity.points[0]
+            text_attributes = attributes | {
+                "x": f"{x:g}",
+                "y": f"{y0 + y1 - y:g}",
+                "font-size": f"{entity.height_mm:g}",
+            }
+            if entity.rotation_degrees:
+                text_attributes["transform"] = f"rotate({-entity.rotation_degrees:g} {x:g} {y0 + y1 - y:g})"
+            ET.SubElement(annotation_text_group, f"{{{SVG_NS}}}text", text_attributes).text = entity.text
+    notice = ET.SubElement(root, f"{{{SVG_NS}}}text", {"x": f"{x0 + width * 0.02:g}", "y": f"{y1 - height * 0.02:g}", "font-size": f"{max(height * 0.025, 10):g}", "font-weight": "bold"})
+    notice.text = scene.title_block.notice
+    path.parent.mkdir(parents=True, exist_ok=True)
+    ET.ElementTree(root).write(path, encoding="utf-8", xml_declaration=True)
+    ET.parse(path)
+    return path

python_cad_tools/exporters/glb.py

@@ -0,0 +1,100 @@
+"""OCP tessellation and glTF 2.0 binary scene export."""
+
+from __future__ import annotations
+
+import json
+import struct
+from pathlib import Path
+
+import numpy as np
+import trimesh
+
+from ..determinism import write_json
+from ..exceptions import BuildExportError
+from ..geometry import combined_bounds, tessellate
+from .base import selected_elements
+
+
+class GlbExporter:
+    name = "glb"
+
+    def __init__(self, linear_deflection: float = 0.5, angular_deflection: float = 0.25) -> None:
+        self.linear_deflection = linear_deflection
+        self.angular_deflection = angular_deflection
+
+    def export(self, model, output_dir: Path) -> list[Path]:
+        target = output_dir / "glb"
+        target.mkdir(parents=True, exist_ok=True)
+        scene = trimesh.Scene(base_frame="model")
+        expected_ids: list[str] = []
+        triangle_counts: dict[str, int] = {}
+        for element in selected_elements(model, "glb", physical_only=True):
+            vertices, faces = tessellate(element.geometry, self.linear_deflection, self.angular_deflection)
+            # CAD Z-up (x,y,z) -> glTF Y-up (x,z,-y), a right-handed rotation.
+            converted = np.asarray([[x, z, -y] for x, y, z in vertices], dtype=np.float64)
+            material = trimesh.visual.material.PBRMaterial(
+                name=element.material.name if element.material else element.id,
+                baseColorFactor=[
+                    int(round(channel * 255)) for channel in (element.color_rgb or (0.7, 0.7, 0.7))
+                ]
+                + [255],
+                metallicFactor=0.0,
+                roughnessFactor=0.8,
+            )
+            mesh = trimesh.Trimesh(vertices=converted, faces=np.asarray(faces), process=False, validate=True)
+            mesh.visual = trimesh.visual.TextureVisuals(material=material)
+            extras = {
+                "stable_id": element.id,
+                "category": element.category,
+                "source_module": element.source_module,
+                "geometry_kind": element.geometry_kind,
+                "units": "millimetres",
+            }
+            scene.add_geometry(mesh, geom_name=element.id, node_name=element.id, metadata=extras)
+            expected_ids.append(element.id)
+            triangle_counts[element.id] = len(faces)
+        path = target / f"{model.artifact_stem}.glb"
+        path.write_bytes(trimesh.exchange.gltf.export_glb(scene, include_normals=True))
+        document = glb_json(path)
+        found_ids = sorted(
+            node.get("extras", {}).get("stable_id")
+            for node in document.get("nodes", [])
+            if node.get("extras", {}).get("stable_id")
+        )
+        if found_ids != sorted(expected_ids):
+            raise BuildExportError(f"GLB node extras missing stable IDs: {found_ids}")
+        loaded = trimesh.load(path, force="scene", process=False)
+        if not isinstance(loaded, trimesh.Scene) or len(loaded.geometry) != len(expected_ids):
+            raise BuildExportError("Independent GLB reload did not preserve element geometry count")
+        manifest = write_json(
+            target / "manifest.json",
+            {
+                "schema_id": "urn:python-cad-tools:schema:glb-manifest:1",
+                "schema_version": 1,
+                "coordinate_transform": "CAD (x,y,z) to glTF (x,z,-y), right-handed",
+                "elements": sorted(expected_ids),
+                "triangle_counts": triangle_counts,
+                "bounds_cad_mm": [
+                    round(value, 6)
+                    for value in combined_bounds(
+                        [element.geometry for element in selected_elements(model, "glb", physical_only=True)]
+                    )
+                ],
+                "bounds_y_up_mm": np.asarray(loaded.bounds).round(6).tolist(),
+                "file_size": path.stat().st_size,
+            },
+        )
+        return [path, manifest]
+
+
+def glb_json(path: Path) -> dict:
+    data = path.read_bytes()
+    if data[:4] != b"glTF":
+        raise BuildExportError("Invalid GLB magic")
+    _, version, _ = struct.unpack_from("<4sII", data, 0)
+    if version != 2:
+        raise BuildExportError(f"Expected glTF 2.0, got {version}")
+    chunk_length, chunk_type = struct.unpack_from("<II", data, 12)
+    if chunk_type != 0x4E4F534A:
+        raise BuildExportError("First GLB chunk is not JSON")
+    return json.loads(data[20 : 20 + chunk_length].decode("utf-8").rstrip(" \t\r\n\0"))