draftwright 0.1.4__tar.gz → 0.1.6__tar.gz

{draftwright-0.1.4 → draftwright-0.1.6}/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## Unreleased
 
+## v0.1.5 — 2026-06-15
+
+### Fixed
+
+- CTC-02 spurious full-page line: build123d's `ExportSVG` projected
+  circle-edge-on edges (hole/fillet rims seen edge-on) as elliptical arcs with
+  a near-zero minor radius, which renderers blow up into full-page lines.
+  `sanitize_svg_arcs()` rewrites any arc with a sub-1e-3 mm radius into the
+  straight line it actually is, leaving real arcs untouched (#19). Not a PMI
+  issue — the file is AP203 geometry-only.
+
+### Tests
+
+- Added the full NIST CTC set (01–05) as fixtures, both AP203 geometry-only and
+  AP242 (with-PMI) variants.
+- Heavy end-to-end CTC fixture builds are marked `slow` and deselected from the
+  default `pytest` run (fast normal run, ~4.5 min); CI runs the fast tier across
+  the OS/Python matrix and the slow tier once.
+- Known: AP242 CTC-02 and both CTC-04 variants crash OCCT on import (#20); their
+  fixtures are excluded from build tests.
+
 ## v0.1.4 — 2026-06-15
 
 ### Changed

{draftwright-0.1.4 → draftwright-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.1.4
+Version: 0.1.6
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright

{draftwright-0.1.4 → draftwright-0.1.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.1.4"
+version = "0.1.6"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -57,7 +57,11 @@ include = [
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 timeout = 300
-addopts = "--tb=short --cov=src/draftwright --cov-report=term-missing --cov-report=xml"
+# `slow` covers the heavy end-to-end builds over the large NIST CTC fixtures
+# (minutes each). They are deselected by default for a fast normal run; run the
+# full suite with `-m ""` or just the slow tier with `-m slow` (CI runs both).
+markers = ["slow: heavy end-to-end CTC fixture builds (deselected by default)"]
+addopts = "--tb=short --cov=src/draftwright --cov-report=term-missing --cov-report=xml -m 'not slow'"
 
 [tool.coverage.run]
 source = ["src/draftwright"]

{draftwright-0.1.4 → draftwright-0.1.6}/src/draftwright/make_drawing.py

@@ -71,7 +71,9 @@ from build123d_drafting.helpers import (
     view_axes,
 )
 from OCP.BRepAdaptor import BRepAdaptor_Surface
+from OCP.BRepAlgoAPI import BRepAlgoAPI_Cut
 from OCP.GeomAbs import GeomAbs_Plane
+from OCP.TopTools import TopTools_ListOfShape
 
 _log = logging.getLogger(__name__)
 
@@ -118,6 +120,53 @@ def fix_svg_page_size(svg_path: str, page_w: float, page_h: float) -> None:
     Path(svg_path).write_text(data, encoding="utf-8")
 
 
+# Below this, an elliptical-arc radius (page-mm) is treated as degenerate.
+# Real feature arcs are orders of magnitude larger; the bad ones are ~1e-7.
+_MIN_ARC_RADIUS = 1e-3
+
+_SVG_NUM = r"(-?\d+\.?\d*(?:[eE][-+]?\d+)?)"
+_SVG_ARC_RE = re.compile(
+    r"A\s*"
+    + _SVG_NUM
+    + r"[ ,]+"
+    + _SVG_NUM
+    + r"[ ,]+"
+    + _SVG_NUM
+    + r"[ ,]+([01])[ ,]*([01])[ ,]+"
+    + _SVG_NUM
+    + r"[ ,]+"
+    + _SVG_NUM
+)
+
+
+def sanitize_svg_arcs(svg_path: str) -> int:
+    """Rewrite near-degenerate elliptical arcs as straight line segments.
+
+    build123d's ``ExportSVG`` projects a circular edge seen edge-on (a hole or
+    fillet rim whose plane is parallel to the view direction) as an elliptical
+    arc with a vanishing minor radius (``ry`` ≈ 1e-7).  The SVG spec says a
+    zero-radius arc is a straight line, but because the radius is not *exactly*
+    zero, renderers (librsvg, cairosvg) treat it as a hugely eccentric ellipse
+    and draw a spurious full-page line.  Each such arc (``A rx ry rot lf sf x
+    y``) with ``rx`` or ``ry`` below :data:`_MIN_ARC_RADIUS` is replaced by
+    ``L x y`` — its true geometry.  Returns the number of arcs rewritten.
+    """
+    data = Path(svg_path).read_text(encoding="utf-8")
+    n = 0
+
+    def _repl(m):
+        nonlocal n
+        if abs(float(m.group(1))) < _MIN_ARC_RADIUS or abs(float(m.group(2))) < _MIN_ARC_RADIUS:
+            n += 1
+            return f"L {m.group(6)} {m.group(7)}"
+        return m.group(0)
+
+    fixed = _SVG_ARC_RE.sub(_repl, data)
+    if n:
+        Path(svg_path).write_text(fixed, encoding="utf-8")
+    return n
+
+
 # ---------------------------------------------------------------------------
 # Geometry analysis
 # ---------------------------------------------------------------------------
@@ -1305,6 +1354,9 @@ class Drawing:
         svg_path = out + ".svg"
         svg.write(svg_path)
         fix_svg_page_size(svg_path, self.page_w, self.page_h)
+        n_arcs = sanitize_svg_arcs(svg_path)
+        if n_arcs:
+            _log.info("Rewrote %d degenerate (near-zero-radius) arc(s) as line segments", n_arcs)
         _log.info("SVG → %s", svg_path)
 
         dxf = ExportDXF()
@@ -2261,6 +2313,39 @@ def _section_hatch_edges(face, SX, SZ, spacing):
     return result
 
 
+def _fuzzy_cut(body, cutter, fuzzy: float = 1e-3):
+    """Boolean-subtract *cutter* from *body* with a fuzzy tolerance.
+
+    Returns a build123d ``Solid`` (or ``Compound`` of solids), or ``None`` if the
+    boolean fails or yields no solid.
+
+    build123d's plain ``body - cutter`` runs an exact (zero-fuzzy) boolean which
+    raises an *uncatchable* ``Standard_DomainError`` on some cast geometry — the
+    C++ exception escapes to ``libc++abi: terminating`` (SIGABRT) and a
+    surrounding ``try/except`` never sees it, killing the whole drawing (NIST
+    CTC-04 section cut, #20). A small fuzzy value makes ``BRepAlgoAPI_Cut`` robust
+    on the same input. We drive the OCCT op directly (build123d's
+    ``Shape._bool_op`` result-processing aborts on the resulting compound) and
+    keep only the solids, so non-solid boolean artefacts can't crash the
+    downstream hidden-line projection.
+    """
+    args = TopTools_ListOfShape()
+    args.Append(body.wrapped)
+    tools = TopTools_ListOfShape()
+    tools.Append(cutter.wrapped)
+    op = BRepAlgoAPI_Cut()
+    op.SetArguments(args)
+    op.SetTools(tools)
+    op.SetFuzzyValue(fuzzy)
+    op.Build()
+    if not op.IsDone():
+        return None
+    solids = Compound(op.Shape()).solids()
+    if not solids:
+        return None
+    return solids[0] if len(solids) == 1 else Compound(children=list(solids))
+
+
 def _add_section_view(dwg, a, axis_letter, holes=None):
     """Full section A–A when blind or stepped holes hide their structure (#94).
 
@@ -2330,10 +2415,15 @@ def _add_section_view(dwg, a, axis_letter, holes=None):
         return
     body = solids[0] if len(solids) == 1 else Compound(children=list(solids))
     try:
-        keep_behind = body - Pos(a.cx, y_star - big / 2, a.cz) * Box(big, big, big)
+        # Fuzzy boolean: the exact `body - Box(...)` aborts uncatchably
+        # (Standard_DomainError) on some cast geometry — see _fuzzy_cut / #20.
+        keep_behind = _fuzzy_cut(body, Pos(a.cx, y_star - big / 2, a.cz) * Box(big, big, big))
     except Exception as exc:  # noqa: BLE001 — OCC booleans raise broadly
         _log.warning("Section A–A skipped (cut failed: %s)", exc)
         return
+    if keep_behind is None:
+        _log.warning("Section A–A skipped (boolean cut produced no solid)")
+        return
     camera = (dwg.look_at[0], dwg.look_at[1] - dwg.dist, dwg.look_at[2])
     dwg.add_view("section_aa", keep_behind, camera, (0, 0, 1), (pos_x, a.FV_Y))
     dwg.add(