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

python_cad_tools/exporters/drawings/annotations.py

@@ -0,0 +1,444 @@
+"""Deterministic expansion of neutral annotations into renderer entities."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from math import cos, radians, sin
+from typing import Any, Literal
+
+from ...drawings import (
+    AnnotationPrimitive,
+    DrawingAnnotationSet,
+    ElevationMarker,
+    Line,
+    Polyline,
+    SectionCallout,
+    Table,
+    Text,
+)
+
+type EntityKind = Literal["line", "polyline", "circle", "text"]
+
+
+@dataclass(frozen=True, slots=True)
+class AnnotationEntity:
+    id: str
+    parent_id: str | None
+    sheet_id: str
+    primitive_type: str
+    role: str
+    kind: EntityKind
+    style: str
+    points: tuple[tuple[float, float], ...] = ()
+    closed: bool = False
+    center: tuple[float, float] | None = None
+    radius: float | None = None
+    text: str | None = None
+    height_mm: float = 4.0
+    rotation_degrees: float = 0.0
+
+
+def annotations_for_sheet(
+    annotations: DrawingAnnotationSet | None,
+    sheet_id: str,
+) -> tuple[AnnotationPrimitive, ...]:
+    if annotations is None:
+        return ()
+    record = next((record for record in annotations.sheets if record.sheet_id == sheet_id), None)
+    return () if record is None else record.annotations
+
+
+def flatten_annotations(annotations: tuple[AnnotationPrimitive, ...]) -> tuple[AnnotationEntity, ...]:
+    entities: list[AnnotationEntity] = []
+    for annotation in annotations:
+        if isinstance(annotation, Line):
+            entities.append(
+                AnnotationEntity(
+                    annotation.id,
+                    None,
+                    annotation.sheet_id,
+                    "line",
+                    "line",
+                    "line",
+                    annotation.style,
+                    (annotation.start, annotation.end),
+                )
+            )
+        elif isinstance(annotation, Polyline):
+            entities.append(
+                AnnotationEntity(
+                    annotation.id,
+                    None,
+                    annotation.sheet_id,
+                    "polyline",
+                    "polyline",
+                    "polyline",
+                    annotation.style,
+                    annotation.points,
+                    annotation.closed,
+                )
+            )
+        elif isinstance(annotation, Text):
+            entities.append(
+                AnnotationEntity(
+                    annotation.id,
+                    None,
+                    annotation.sheet_id,
+                    "text",
+                    "text",
+                    "text",
+                    annotation.style,
+                    points=(annotation.position,),
+                    text=annotation.value,
+                    height_mm=annotation.height_mm,
+                    rotation_degrees=annotation.rotation_degrees,
+                )
+            )
+        elif isinstance(annotation, SectionCallout):
+            entities.extend(_section_entities(annotation))
+        elif isinstance(annotation, ElevationMarker):
+            entities.extend(_elevation_entities(annotation))
+        elif isinstance(annotation, Table):
+            entities.extend(_table_entities(annotation))
+    return tuple(entities)
+
+
+def annotation_bounds(entities: tuple[AnnotationEntity, ...]) -> tuple[float, float, float, float] | None:
+    bounds: list[tuple[float, float, float, float]] = []
+    for entity in entities:
+        if entity.kind in {"line", "polyline"}:
+            bounds.append(
+                (
+                    min(point[0] for point in entity.points),
+                    min(point[1] for point in entity.points),
+                    max(point[0] for point in entity.points),
+                    max(point[1] for point in entity.points),
+                )
+            )
+        elif entity.kind == "circle" and entity.center is not None and entity.radius is not None:
+            bounds.append(
+                (
+                    entity.center[0] - entity.radius,
+                    entity.center[1] - entity.radius,
+                    entity.center[0] + entity.radius,
+                    entity.center[1] + entity.radius,
+                )
+            )
+        elif entity.kind == "text" and entity.points and entity.text is not None:
+            x, y = entity.points[0]
+            width = max(entity.height_mm * 0.65 * len(entity.text), entity.height_mm)
+            angle = radians(entity.rotation_degrees)
+            dx = abs(width * cos(angle)) + abs(entity.height_mm * sin(angle))
+            dy = abs(width * sin(angle)) + abs(entity.height_mm * cos(angle))
+            bounds.append((x, y - entity.height_mm * 0.25, x + dx, y + dy))
+    if not bounds:
+        return None
+    return (
+        min(item[0] for item in bounds),
+        min(item[1] for item in bounds),
+        max(item[2] for item in bounds),
+        max(item[3] for item in bounds),
+    )
+
+
+def manifest_records(
+    annotations: DrawingAnnotationSet | None,
+    entities_by_sheet: dict[str, tuple[AnnotationEntity, ...]],
+) -> list[dict[str, Any]]:
+    if annotations is None:
+        return []
+    result: list[dict[str, Any]] = []
+    entities = {entity.id: entity for values in entities_by_sheet.values() for entity in values}
+    for sheet in annotations.sheets:
+        for annotation in sheet.annotations:
+            child_ids = [entity.id for entity in entities_by_sheet[sheet.sheet_id] if entity.parent_id == annotation.id]
+            direct = annotation.id in entities
+            result.append(
+                {
+                    "id": annotation.id,
+                    "parent_id": None,
+                    "sheet_id": sheet.sheet_id,
+                    "primitive_type": _primitive_type(annotation),
+                    "role": "annotation",
+                    "content": _annotation_content(annotation),
+                    "child_ids": child_ids,
+                    "rendered_entity": direct,
+                    "renderer_presence": {"svg": True, "dxf": True, "pdf": True},
+                }
+            )
+            for child_id in child_ids:
+                entity = entities[child_id]
+                result.append(
+                    {
+                        "id": entity.id,
+                        "parent_id": annotation.id,
+                        "sheet_id": sheet.sheet_id,
+                        "primitive_type": entity.primitive_type,
+                        "role": entity.role,
+                        "content": {"text": normalize_text(entity.text)} if entity.text is not None else {},
+                        "child_ids": [],
+                        "rendered_entity": True,
+                        "renderer_presence": {"svg": True, "dxf": True, "pdf": True},
+                    }
+                )
+    return sorted(result, key=lambda item: item["id"])
+
+
+def pdf_texts(entities: tuple[AnnotationEntity, ...]) -> list[str]:
+    return [normalize_text(entity.text) for entity in entities if entity.kind == "text" and entity.text is not None]
+
+
+def normalize_text(value: str | None) -> str:
+    return "" if value is None else " ".join(value.split())
+
+
+def _section_entities(annotation: SectionCallout) -> tuple[AnnotationEntity, ...]:
+    direction = _direction_vector(annotation.view_direction)
+    arrow_size = 8.0
+    normal = (-direction[1], direction[0])
+    arrows = []
+    for role, point in (("arrow.start", annotation.start), ("arrow.end", annotation.end)):
+        tip = (point[0] + direction[0] * arrow_size, point[1] + direction[1] * arrow_size)
+        base = (point[0] - direction[0] * arrow_size * 0.35, point[1] - direction[1] * arrow_size * 0.35)
+        arrows.append(
+            AnnotationEntity(
+                f"{annotation.id}.{role}",
+                annotation.id,
+                annotation.sheet_id,
+                "section_callout",
+                role,
+                "polyline",
+                "annotation-section",
+                (
+                    (base[0] + normal[0] * arrow_size * 0.45, base[1] + normal[1] * arrow_size * 0.45),
+                    tip,
+                    (base[0] - normal[0] * arrow_size * 0.45, base[1] - normal[1] * arrow_size * 0.45),
+                ),
+            )
+        )
+    label_text = f"{normalize_text(annotation.label)} / {annotation.reference_sheet_id}"
+    return (
+        AnnotationEntity(
+            f"{annotation.id}.line",
+            annotation.id,
+            annotation.sheet_id,
+            "section_callout",
+            "line",
+            "line",
+            "annotation-section",
+            (annotation.start, annotation.end),
+        ),
+        *arrows,
+        AnnotationEntity(
+            f"{annotation.id}.label.start",
+            annotation.id,
+            annotation.sheet_id,
+            "section_callout",
+            "label.start",
+            "text",
+            "annotation-section",
+            points=((annotation.start[0] + direction[0] * 12, annotation.start[1] + direction[1] * 12),),
+            text=label_text,
+        ),
+        AnnotationEntity(
+            f"{annotation.id}.label.end",
+            annotation.id,
+            annotation.sheet_id,
+            "section_callout",
+            "label.end",
+            "text",
+            "annotation-section",
+            points=((annotation.end[0] + direction[0] * 12, annotation.end[1] + direction[1] * 12),),
+            text=label_text,
+        ),
+    )
+
+
+def _elevation_entities(annotation: ElevationMarker) -> tuple[AnnotationEntity, ...]:
+    direction = _direction_vector(annotation.direction)
+    normal = (-direction[1], direction[0])
+    radius = 9.0
+    tip = (annotation.position[0] + direction[0] * radius, annotation.position[1] + direction[1] * radius)
+    back = (
+        annotation.position[0] - direction[0] * radius * 0.45,
+        annotation.position[1] - direction[1] * radius * 0.45,
+    )
+    label = f"{normalize_text(annotation.label)} / {annotation.reference_sheet_id}"
+    return (
+        AnnotationEntity(
+            f"{annotation.id}.outline",
+            annotation.id,
+            annotation.sheet_id,
+            "elevation_marker",
+            "outline",
+            "circle",
+            "annotation-elevation",
+            center=annotation.position,
+            radius=radius,
+        ),
+        AnnotationEntity(
+            f"{annotation.id}.pointer",
+            annotation.id,
+            annotation.sheet_id,
+            "elevation_marker",
+            "pointer",
+            "polyline",
+            "annotation-elevation",
+            (
+                tip,
+                (back[0] + normal[0] * radius * 0.5, back[1] + normal[1] * radius * 0.5),
+                (back[0] - normal[0] * radius * 0.5, back[1] - normal[1] * radius * 0.5),
+            ),
+            True,
+        ),
+        AnnotationEntity(
+            f"{annotation.id}.label",
+            annotation.id,
+            annotation.sheet_id,
+            "elevation_marker",
+            "label",
+            "text",
+            "annotation-elevation",
+            points=((annotation.position[0] + radius * 1.4, annotation.position[1]),),
+            text=label,
+        ),
+    )
+
+
+def _table_entities(annotation: Table) -> tuple[AnnotationEntity, ...]:
+    height = 4.0
+    row_height = 7.0
+    widths = []
+    for index, column in enumerate(annotation.columns):
+        values = [column, *(row.cells[index] for row in annotation.rows)]
+        widths.append(max(28.0, max(len(normalize_text(value)) for value in values) * height * 0.65 + 8.0))
+    total_width = sum(widths)
+    total_height = row_height * (len(annotation.rows) + 2)
+    x0, y0 = annotation.position
+    x1, y1 = x0 + total_width, y0 + total_height
+    entities = [
+        AnnotationEntity(
+            f"{annotation.id}.title",
+            annotation.id,
+            annotation.sheet_id,
+            "table",
+            "title",
+            "text",
+            "annotation-table",
+            points=((x0 + 2.0, y1 - row_height + 1.5),),
+            text=annotation.title,
+            height_mm=height,
+        ),
+        AnnotationEntity(
+            f"{annotation.id}.border",
+            annotation.id,
+            annotation.sheet_id,
+            "table",
+            "border",
+            "polyline",
+            "annotation-table",
+            ((x0, y0), (x1, y0), (x1, y1), (x0, y1)),
+            True,
+        ),
+    ]
+    cursor = x0
+    header_y = y1 - row_height * 2 + 1.5
+    for index, (column, width) in enumerate(zip(annotation.columns, widths, strict=True)):
+        entities.append(
+            AnnotationEntity(
+                f"{annotation.id}.header.{index}",
+                annotation.id,
+                annotation.sheet_id,
+                "table",
+                f"header.{index}",
+                "text",
+                "annotation-table",
+                points=((cursor + 2.0, header_y),),
+                text=column,
+                height_mm=height,
+            )
+        )
+        cursor += width
+    for row_index, row in enumerate(annotation.rows):
+        cursor = x0
+        baseline = y1 - row_height * (row_index + 3) + 1.5
+        for column_index, (cell, width) in enumerate(zip(row.cells, widths, strict=True)):
+            entities.append(
+                AnnotationEntity(
+                    f"{annotation.id}.row.{row.id}.cell.{column_index}",
+                    annotation.id,
+                    annotation.sheet_id,
+                    "table",
+                    f"row.{row.id}.cell.{column_index}",
+                    "text",
+                    "annotation-table",
+                    points=((cursor + 2.0, baseline),),
+                    text=cell,
+                    height_mm=height,
+                )
+            )
+            cursor += width
+        separator_y = y1 - row_height * (row_index + 3)
+        entities.append(
+            AnnotationEntity(
+                f"{annotation.id}.row.{row.id}.separator",
+                annotation.id,
+                annotation.sheet_id,
+                "table",
+                f"row.{row.id}.separator",
+                "line",
+                "annotation-table",
+                ((x0, separator_y), (x1, separator_y)),
+            )
+        )
+    return tuple(entities)
+
+
+def _direction_vector(direction: str) -> tuple[float, float]:
+    return {
+        "right": (1.0, 0.0),
+        "left": (-1.0, 0.0),
+        "up": (0.0, 1.0),
+        "down": (0.0, -1.0),
+    }[direction]
+
+
+def _primitive_type(annotation: AnnotationPrimitive) -> str:
+    names = {
+        Line: "line",
+        Polyline: "polyline",
+        Text: "text",
+        SectionCallout: "section_callout",
+        ElevationMarker: "elevation_marker",
+        Table: "table",
+    }
+    return names[type(annotation)]
+
+
+def _annotation_content(annotation: AnnotationPrimitive) -> dict[str, Any]:
+    if isinstance(annotation, Text):
+        return {"text": normalize_text(annotation.value)}
+    if isinstance(annotation, SectionCallout):
+        return {
+            "label": normalize_text(annotation.label),
+            "reference_sheet_id": annotation.reference_sheet_id,
+            "view_direction": annotation.view_direction,
+        }
+    if isinstance(annotation, ElevationMarker):
+        return {
+            "label": normalize_text(annotation.label),
+            "reference_sheet_id": annotation.reference_sheet_id,
+            "direction": annotation.direction,
+        }
+    if isinstance(annotation, Table):
+        return {
+            "title": normalize_text(annotation.title),
+            "columns": [normalize_text(value) for value in annotation.columns],
+            "rows": [
+                {"id": row.id, "cells": [normalize_text(value) for value in row.cells]} for row in annotation.rows
+            ],
+        }
+    return {}
+
+
+__all__: list[str] = []

python_cad_tools/exporters/drawings/dxf.py

@@ -0,0 +1,110 @@
+"""Python CAD Tools DXF writer with explicit conceptual layers."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+import ezdxf
+
+from ...determinism import normalized_build_epoch
+from .primitives import DrawingScene
+
+LAYERS: dict[str, dict[str, Any]] = {
+    "VISIBLE": {"color": 7, "lineweight": 35},
+    "HIDDEN": {"color": 8, "lineweight": 18, "linetype": "DASHED"},
+    "TEXT": {"color": 2, "lineweight": 18},
+    "DIMENSIONS": {"color": 3, "lineweight": 18},
+    "REFERENCE": {"color": 4, "lineweight": 18, "linetype": "CENTER"},
+    "NOTICE": {"color": 1, "lineweight": 35},
+    "ANNOTATION_LINE": {"color": 1, "lineweight": 25},
+    "ANNOTATION_TEXT": {"color": 1, "lineweight": 18},
+    "ANNOTATION_SECTION": {"color": 1, "lineweight": 35},
+    "ANNOTATION_ELEVATION": {"color": 1, "lineweight": 35},
+    "ANNOTATION_TABLE": {"color": 1, "lineweight": 25},
+}
+
+APP_ID = "PYTHON_CAD_TOOLS"
+
+
+def write_dxf(scene: DrawingScene, path: Path) -> Path:
+    document = ezdxf.new("R2018", setup=True)
+    document.units = ezdxf.units.MM
+    epoch = normalized_build_epoch()
+    # AutoCAD stores these values as Julian dates. Fixed GUIDs and a generous
+    # hand seed remove the last writer-created per-run fields.
+    julian = epoch.timestamp() / 86400.0 + 2440587.5
+    document.header["$TDCREATE"] = julian
+    document.header["$TDUPDATE"] = julian
+    document.header["$TDUCREATE"] = 0.0
+    document.header["$TDUUPDATE"] = 0.0
+    document.header["$FINGERPRINTGUID"] = "{00000000-0000-5000-8000-000000000001}"
+    document.header["$VERSIONGUID"] = "{00000000-0000-5000-8000-000000000002}"
+    document.header["$HANDSEED"] = "FFFF"
+    for name, attributes in LAYERS.items():
+        if name not in document.layers:
+            document.layers.add(name, **attributes)
+    if APP_ID not in document.appids:
+        document.appids.add(APP_ID)
+    modelspace = document.modelspace()
+    for polyline in scene.polylines:
+        modelspace.add_lwpolyline(polyline.points, close=polyline.closed, dxfattribs={"layer": polyline.layer})
+    for line in scene.lines:
+        modelspace.add_line(line.start, line.end, dxfattribs={"layer": line.layer})
+    for text in scene.texts:
+        modelspace.add_text(text.value, height=text.height, dxfattribs={"layer": text.layer}).set_placement(text.position)
+    for dimension in scene.dimensions:
+        modelspace.add_aligned_dim(
+            dimension.start,
+            dimension.end,
+            distance=dimension.offset,
+            text=dimension.label,
+            override={"dimtxt": 12},
+            dxfattribs={"layer": "DIMENSIONS"},
+        ).render()
+    for entity in scene.annotation_entities:
+        layer = entity.style.replace("-", "_").upper()
+        created: Any = None
+        if entity.kind == "line":
+            created = modelspace.add_line(entity.points[0], entity.points[1], dxfattribs={"layer": layer})
+        elif entity.kind == "polyline":
+            created = modelspace.add_lwpolyline(entity.points, close=entity.closed, dxfattribs={"layer": layer})
+        elif entity.kind == "circle" and entity.center is not None and entity.radius is not None:
+            created = modelspace.add_circle(entity.center, entity.radius, dxfattribs={"layer": layer})
+        elif entity.kind == "text" and entity.text is not None:
+            created = modelspace.add_text(
+                entity.text,
+                height=entity.height_mm,
+                dxfattribs={"layer": layer, "rotation": entity.rotation_degrees},
+            ).set_placement(entity.points[0])
+        if created is not None:
+            created.set_xdata(APP_ID, [(1000, entity.id)])
+    x0, y0, x1, y1 = scene.viewport.bounds
+    modelspace.add_text(scene.title_block.notice, height=max((y1 - y0) * 0.025, 10), dxfattribs={"layer": "NOTICE"}).set_placement((x0, y0))
+    path.parent.mkdir(parents=True, exist_ok=True)
+    document.classes.add_required_classes(document.dxfversion)
+    ordered_classes = sorted(document.classes.classes.items())
+    document.classes.classes.clear()
+    document.classes.classes.update(ordered_classes)
+    document.saveas(path)
+    _normalize_saved_dxf(path, julian, epoch.strftime("%Y-%m-%dT%H:%M:%S+00:00"))
+    reloaded = ezdxf.readfile(path)
+    auditor = reloaded.audit()
+    if auditor.has_errors:
+        raise RuntimeError(f"DXF audit failed with {len(auditor.errors)} error(s)")
+    return path
+
+
+def _normalize_saved_dxf(path: Path, julian: float, timestamp: str) -> None:
+    text = path.read_text(encoding="utf-8")
+    replacements = (
+        (r"(\$TDUPDATE\n 40\n)[^\n]+", rf"\g<1>{julian}"),
+        (r"(\$VERSIONGUID\n  2\n)[^\n]+", r"\g<1>{00000000-0000-5000-8000-000000000002}"),
+        (r"(\d+\.\d+\.\d+ @ )\d{4}-\d{2}-\d{2}T[^\n]+", rf"\g<1>{timestamp}"),
+    )
+    for pattern, replacement in replacements:
+        text, count = re.subn(pattern, replacement, text)
+        if count == 0:
+            raise RuntimeError(f"DXF normalization pattern was not present: {pattern}")
+    path.write_text(text, encoding="utf-8", newline="\n")

python_cad_tools/exporters/drawings/model.py

@@ -0,0 +1,70 @@
+"""Conceptual sheet-set exporter coordinating Python CAD Tools writers."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from pypdf import PdfReader
+
+from ...determinism import write_json
+from ...drawings import DrawingAnnotationSet, DrawingSheet
+from ...drawings._catalog import standard_sheet_catalog
+from .annotations import annotations_for_sheet, manifest_records, pdf_texts
+from .dxf import write_dxf
+from .pdf import write_pdf
+from .projection import project_model
+from .svg import write_svg
+
+
+class DrawingExporter:
+    name = "drawings"
+
+    def export(
+        self,
+        model,
+        output_dir: Path,
+        sheets: tuple[DrawingSheet, ...] = (),
+        annotations: DrawingAnnotationSet | None = None,
+    ) -> list[Path]:
+        drawing_dir = output_dir / "drawings"
+        catalog = sheets or standard_sheet_catalog(model)
+        scenes = [
+            project_model(model, sheet, annotations_for_sheet(annotations, sheet.sheet_id))
+            for sheet in catalog
+        ]
+        paths: list[Path] = []
+        for scene in scenes:
+            slug = scene.viewport.name.replace(" ", "_")
+            paths.append(write_svg(scene, drawing_dir / "svg" / f"{model.artifact_stem}_{slug}.svg"))
+            paths.append(write_dxf(scene, drawing_dir / "dxf" / f"{model.artifact_stem}_{slug}.dxf"))
+        pdf = write_pdf(scenes, drawing_dir / "pdf" / f"{model.artifact_stem}_Conceptual_Drawings.pdf")
+        if len(PdfReader(pdf).pages) != len(scenes):
+            raise RuntimeError("PDF validation failed: unexpected page count")
+        paths.append(pdf)
+        entities_by_sheet = {
+            scene.title_block.sheet_number: scene.annotation_entities
+            for scene in scenes
+        }
+        paths.append(
+            write_json(
+                drawing_dir / "annotation-manifest.json",
+                {
+                    "schema_id": "urn:python-cad-tools:schema:drawing-annotations:1",
+                    "schema_version": 1,
+                    "provider_id": None if annotations is None else annotations.provider_id,
+                    "annotations": manifest_records(annotations, entities_by_sheet),
+                    "sheets": [
+                        {
+                            "sheet_id": scene.title_block.sheet_number,
+                            "view_id": scene.viewport.name,
+                            "page_number": index,
+                            "viewport_bounds_mm": list(scene.viewport.bounds),
+                            "annotation_ids": sorted(entity.id for entity in scene.annotation_entities),
+                            "pdf_text": pdf_texts(scene.annotation_entities),
+                        }
+                        for index, scene in enumerate(scenes, start=1)
+                    ],
+                },
+            )
+        )
+        return paths