draftwright 0.3.6__tar.gz → 0.3.7__tar.gz

{draftwright-0.3.6 → draftwright-0.3.7}/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## v0.3.7 — 2026-07-21
+
+### Fixed
+
+- **Turned ⌀ leaders point at the feature, not a corner or across the body**
+  (#794/#798): the diameter callouts on a turned part now centre on the step's
+  mid-length (a boss keeps its frame origin; a ⌀ shared by disjoint steps centres
+  on the longest run), so the arrow lands on the middle of the feature's edge
+  rather than a step corner. A leader that would otherwise cut diagonally through
+  the body — a nested or end feature such as a ⌀6 boss stub — is re-routed out to
+  the nearest clear margin (axis-aware: X-turned → left/right, Z-turned → top/
+  bottom), pointing straight at the feature instead of clipping the silhouette. A
+  re-route that can't be placed clear-and-safe is restored and flagged, and a
+  pinned leader is never moved.
+
+### Added
+
+- **`leader_crosses_silhouette` lint notice** (#796): an info-level structural
+  notice when a leader shaft passes *through* the projected part body (as opposed
+  to a hole callout legitimately exiting an internal hole), so the gap is
+  observable even where routing cannot clear it.
+
 ## v0.3.6 — 2026-07-21
 
 ### Fixed

{draftwright-0.3.6 → draftwright-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.3.6
+Version: 0.3.7
 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.3.6 → draftwright-0.3.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.3.6"
+version = "0.3.7"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }

{draftwright-0.3.6 → draftwright-0.3.7}/src/draftwright/annotations/from_model.py

@@ -52,6 +52,7 @@ from draftwright._core import (
     _legible_locations,
     _legible_steps,
     _log,
+    _shape_box2d,
     _solve_strip_ys,
     _text_size,
     _title_block_box,
@@ -776,8 +777,8 @@ def _diameter_row_below(dwg, items, start: int = 0, trace=None) -> int:
                 for _, d, _, _ in items
             )
         return 0
-    specs = []  # (tip_page, dia, label, feature), tip on the step's bottom silhouette
-    for anchor, dia, feat, dtol in items:
+    specs = []  # (tip_page, dia, label, feature), tip on the step's bottom silhouette,
+    for anchor, dia, feat, dtol in items:  # centred along the feature's length (not a corner)
         ax, ay, az = anchor
         tip = dwg.at("front", ax, ay, az - dia / 2)
         specs.append((tip, dia, f"ø{_fmt(dia)}{_tol_suffix(dtol, draft)}", feat))
@@ -890,8 +891,8 @@ def _diameter_column_left(dwg, items, start: int = 0, trace=None) -> int:
                 for _, d, _, _ in items
             )
         return 0
-    specs = []  # (tip_page, dia, label, feature), tip on the step's left silhouette
-    for anchor, dia, feat, dtol in items:
+    specs = []  # (tip_page, dia, label, feature), tip on the step's left silhouette,
+    for anchor, dia, feat, dtol in items:  # centred along the feature's length (not a corner)
         ax, ay, az = anchor
         tip = dwg.at("front", ax - dia / 2, ay, az)
         specs.append((tip, dia, f"ø{_fmt(dia)}{_tol_suffix(dtol, draft)}", feat))
@@ -935,6 +936,45 @@ def _diameter_column_left(dwg, items, start: int = 0, trace=None) -> int:
     return placed
 
 
+def _diameter_step_anchor(anchor, features):
+    """Anchor point for a turned ⌀ leader tip.
+
+    Centre the leader at the MID-LENGTH of the STEP carrying this diameter, rather
+    than the frame origin passed in (which for a boss or a shared ⌀'s first-bucketed
+    step can be an end corner). Only STEP spans are used: a step round-trips its
+    length + centre through the emitted Sheet script (declared ``length=``/``at=``),
+    so direct and scripted builds agree (#707 parity); a boss is re-synthesised
+    without a declared span and keeps its frame origin in both paths (``anchor``).
+
+    When a ⌀ is shared by several steps, select ONE — the longest run, leftmost on
+    ties — and use THAT step's OWN origin (radial + axial). Never the convex-hull
+    midpoint (which for disjoint ⌀A–⌀B–⌀A steps falls in the ⌀B gap, off any
+    silhouette) and never the bucket ``anchor``'s radial (which for non-coaxial
+    same-⌀ steps belongs to a different feature). The selection quantises both the
+    length and the lower end to the emitter's 3-dp values, so direct and scripted
+    pick the same run. In the #426 finalize/``only=`` path this centres over the
+    recorded subset, as the pre-#794 first-recorded-origin anchor also did.
+    """
+    steps = [
+        f for f in features if getattr(f, "kind", None) == "step" and getattr(f, "span", None)
+    ]
+    if not steps:
+        return anchor
+    idx = {"x": 0, "y": 1, "z": 2}[steps[0].frame.axis]
+
+    def _key(f):
+        ends = sorted(end[idx] for end in f.span)
+        length = round(ends[1] - ends[0], 3)  # emitter rounds step length and centre (`at`) to
+        at = round((ends[0] + ends[1]) / 2, 3)  # 3dp — quantise both so the selection round-trips
+        return (length, -(at - length / 2))
+
+    step = max(steps, key=_key)
+    ends = sorted(end[idx] for end in step.span)
+    centred = list(step.frame.origin)  # the SELECTED step's own origin (radial + axial)
+    centred[idx] = (ends[0] + ends[1]) / 2
+    return tuple(centred)
+
+
 def render_diameters(dwg, groups, tol: float = 0.15, *, ctx, only=None) -> int:
     """ø leaders for a turned part's external step/boss diameters, from the IR —
     one distinct callout per diameter, in a tidy row below the front view
@@ -978,7 +1018,8 @@ def render_diameters(dwg, groups, tol: float = 0.15, *, ctx, only=None) -> int:
 
     def _items(buckets):
         return [
-            (a, d, next(iter(fs)) if len(fs) == 1 else None, t) for a, d, fs, t in buckets.values()
+            (_diameter_step_anchor(a, fs), d, next(iter(fs)) if len(fs) == 1 else None, t)
+            for a, d, fs, t in buckets.values()
         ]
 
     # The placers name leaders m_dia_{x,z}{start+i} CONTIGUOUSLY from one start. The auto-pass
@@ -998,9 +1039,128 @@ def render_diameters(dwg, groups, tol: float = 0.15, *, ctx, only=None) -> int:
     start_x = _next_start("m_dia_x") if only is not None else 0
     start_z = _next_start("m_dia_z") if only is not None else 0
     trace = getattr(ctx, "trace", None)  # the immediate placers report to the trace too (#736)
-    return _diameter_row_below(
+    placed = _diameter_row_below(
         dwg, _items(row_buckets), start=start_x, trace=trace
     ) + _diameter_column_left(dwg, _items(col_buckets), start=start_z, trace=trace)
+    # #798: a ⌀ leader the row/column solve sent DIAGONALLY into the body — cutting
+    # the silhouette, or an end feature whose diagonal merely grazes it — is re-routed
+    # to the clear side (the margin the feature sits at). Auto-pass only: the finalize
+    # (only=) path replays recorded verbs and must not disturb pinned user dims.
+    if only is None:
+        _reroute_crossing_diameters(dwg)
+    return placed
+
+
+_REROUTE_EDGE_TOL = 2.0  # page mm: a tip this close to an axial end sits AT that end
+_REROUTE_SLACK = 1.0  # page mm: an elbow displaced this far toward the interior is "into the body"
+
+
+def _reroute_crossing_diameters(dwg) -> int:
+    """Route a turned ⌀ leader that heads INTO the part body (#798) out to the
+    nearest CLEAR margin, rather than diagonally into the body.
+
+    Two triggers, both re-routed to the clear side:
+
+    * The shaft CUTS THROUGH the body (the Phase-1 ``_leader_shaft_hits_edges``
+      discriminator) — a nested feature clipping a neighbour.
+    * An END feature (tip at the part's axial extreme, e.g. a ⌀6 boss stub) whose
+      row/column-solved elbow diagonals back INTO the body — a near-miss that reads
+      as clipping the outline even where it does not strictly cross.
+
+    Axis-aware: an ``m_dia_x`` (X-turned) leader's axial run is page-X and its clear
+    margins are left/right; an ``m_dia_z`` (Z-turned) leader's axial run is page-Y
+    and its margins are bottom/top. Candidates (near margin → straight out either way
+    along the radial axis) are kept only when the new shaft clears the outline AND the
+    rebuilt leader's LABEL stays inside the page and off every other view/annotation
+    box — so a re-route never trades an info crossing for an out-of-bounds or overlap
+    error (the shaft itself, like the row/column placers, is gated only on the
+    silhouette). If nothing is both clear and safe the leader is restored unchanged
+    (Phase-1 then flags it). A PINNED leader (ADR 0012) is never moved. Returns the
+    number re-routed."""
+    from draftwright.linting.structural import _leader_shaft_hits_edges
+
+    vs = dwg.views.get("front")
+    if not vs or vs[0] is None:
+        return 0
+    try:
+        edges = [(e, _shape_box2d(e)) for e in vs[0].edges()]
+    except Exception:  # noqa: BLE001 — an unanalysable projected shape just skips re-routing
+        return 0
+    fb = dwg.view_bounds("front")
+    if not fb:
+        return 0
+    draft = dwg.draft
+    gap = draft.font_size + 2 * draft.pad_around_text
+    page = (_MARGIN, _MARGIN, dwg.page_w - _MARGIN, dwg.page_h - _MARGIN)
+
+    def _within_page(box):
+        return box[0] >= page[0] and box[1] >= page[1] and box[2] <= page[2] and box[3] <= page[3]
+
+    rerouted = 0
+    for name in [n for n in dwg.annotations() if n.startswith(("m_dia_x", "m_dia_z"))]:
+        ldr = dwg.get_annotation(name)
+        if ldr is None or getattr(ldr, "elbow", None) is None:
+            continue
+        if dwg.registry.is_pinned(name):  # a pin is the user's "stays put" (ADR 0012)
+            continue
+        tip, elbow = ldr.tip, ldr.elbow
+        crosses = _leader_shaft_hits_edges(tip, elbow, edges)
+        ax = 0 if name.startswith("m_dia_x") else 1  # axial page axis (X row / Y column)
+        rad = 1 - ax
+        lo_b, hi_b = fb[ax], fb[ax + 2]
+        at_lo = tip[ax] - lo_b <= _REROUTE_EDGE_TOL
+        at_hi = hi_b - tip[ax] <= _REROUTE_EDGE_TOL
+        into_body = (at_lo and elbow[ax] > tip[ax] + _REROUTE_SLACK) or (
+            at_hi and elbow[ax] < tip[ax] - _REROUTE_SLACK
+        )
+        if not (crosses or into_body):
+            continue
+        # Clear-side elbows toward the CLEAR end only: the near axial margin (the end
+        # the feature sits at) first, then straight out either way along the radial
+        # axis. The far axial margin is deliberately NOT a candidate — a leader run
+        # the whole length of the part to the opposite end reads worse than the
+        # near-miss it replaces; restore-and-flag is the honest fallback instead.
+        near_a = lo_b - gap if tip[ax] - lo_b <= hi_b - tip[ax] else hi_b + gap
+
+        def _pt(a_val, r_val, _ax=ax):
+            p = [0.0, 0.0]
+            p[_ax], p[1 - _ax] = a_val, r_val
+            return (p[0], p[1])
+
+        candidates = (
+            _pt(near_a, tip[rad]),
+            _pt(tip[ax], fb[rad] - gap),
+            _pt(tip[ax], fb[rad + 2] + gap),
+        )
+        feat = dwg.registry.feature_of(name)
+        old = dwg.remove(name)  # remove first so obstacles exclude the leader being replaced
+        placed_it = False
+        try:
+            obstacles = strip_obstacles(dwg, crossable=CROSSABLE_TYPES)
+            for vis, hid in dwg.views.values():
+                for shp in (vis, hid):
+                    if shp is None:
+                        continue
+                    b = shp.bounding_box()
+                    obstacles.append((b.min.X, b.min.Y, b.max.X, b.max.Y))
+            for ex, ey in candidates:
+                if _leader_shaft_hits_edges(tip, (ex, ey), edges):
+                    continue
+                cand = Leader(
+                    tip=(tip[0], tip[1], 0), elbow=(ex, ey, 0), label=ldr.label, draft=draft
+                )
+                box = _anno_box(cand)
+                if box is None or not _within_page(box) or _box_hits(box, obstacles):
+                    continue
+                dwg.add(cand, name, view="front", feature=feat)
+                rerouted += 1
+                placed_it = True
+                break
+        except Exception:  # noqa: BLE001 — a re-route error must never lose the leader
+            placed_it = False
+        if not placed_it and dwg.get_annotation(name) is None:
+            dwg.add(old, name, view="front", feature=feat)  # restore (Phase-1 flags it)
+    return rerouted
 
 
 def _env_pd(group, role):

{draftwright-0.3.6 → draftwright-0.3.7}/src/draftwright/linting/structural.py

@@ -454,6 +454,89 @@ def _edges_intersect_rect(edge_entries, rect) -> bool:
     return False
 
 
+def _seg_seg_point(a, b, c, d):
+    """Intersection point of segments *a*-*b* and *c*-*d*, or ``None`` (parallel,
+    collinear, or no overlap). Collinear returns ``None`` on purpose — a shaft
+    running ALONG an edge does not cut across it."""
+    rx, ry = b[0] - a[0], b[1] - a[1]
+    sx, sy = d[0] - c[0], d[1] - c[1]
+    denom = rx * sy - ry * sx
+    if abs(denom) < 1e-12:
+        return None
+    qpx, qpy = c[0] - a[0], c[1] - a[1]
+    t = (qpx * sy - qpy * sx) / denom
+    u = (qpx * ry - qpy * rx) / denom
+    if 0.0 <= t <= 1.0 and 0.0 <= u <= 1.0:
+        return (a[0] + t * rx, a[1] + t * ry)
+    return None
+
+
+def _leader_shaft_hits_edges(tip, elbow, edge_entries, skip_mm=0.5) -> bool:
+    """True if the leader shaft *tip*→*elbow* cuts THROUGH the projected view
+    silhouette *edge_entries* (``(edge, bbox2d)`` pairs, #796).
+
+    The discriminator is the count of DISTINCT crossing points, past a *skip_mm*
+    step off the tip:
+
+    * A leader that legitimately EXITS the outline — a hole/feature callout whose
+      tip is at an internal point, or a ⌀ callout whose tip is on the surface and
+      whose shaft runs outward — crosses the outline **once** (or not at all).
+    * A shaft that cuts THROUGH a body — a ⌀ leader clipping a neighbouring step,
+      a groove leader crossing a flange — **enters and exits**, crossing **twice**.
+
+    Genuine crossing POINTS are computed (not edge-bbox hits) and deduped within
+    0.5 mm, so a shaft merely grazing a shared vertex, or a doubled/coincident
+    projected edge, counts once — not two (review of #799). Straight edges use an
+    exact segment intersection; a curved edge is sampled ~1 mm; an edge whose
+    geometry THROWS during analysis counts as one crossing (conservative). A cut
+    is **two or more** distinct crossings beyond the tip's on-outline touch, which
+    the skip removes (the tip's own edge crosses at t<0 of the skipped shaft).
+
+    The 0.5 mm dedup radius is a page-space resolution floor: a shaft cutting a
+    feature narrower than ~0.5 mm ON THE PAGE merges to one crossing and is not
+    flagged — acceptable for a Phase-1 observability notice (#798 owns the robust
+    filled-region test)."""
+    tx, ty = tip[0], tip[1]
+    ex, ey = elbow[0], elbow[1]
+    length = ((ex - tx) ** 2 + (ey - ty) ** 2) ** 0.5
+    if length < 1e-9:
+        return False
+    t = min(0.5, skip_mm / length)  # step off the tip; never past the shaft midpoint
+    a = (tx + t * (ex - tx), ty + t * (ey - ty))
+    b = (ex, ey)
+    points: list[tuple[float, float]] = []
+    opaque = 0
+    for e, eb in edge_entries:
+        if eb is None:
+            continue
+        if not _segment_clips_box(a, b, eb):  # cheap bbox prefilter
+            continue
+        try:
+            if e.geom_type == GeomType.LINE:
+                s, d = e.start_point(), e.end_point()
+                p = _seg_seg_point(a, b, (s.X, s.Y), (d.X, d.Y))
+                if p is not None:
+                    points.append(p)
+            else:
+                n = min(200, max(8, int(e.length) + 1))
+                prev = e.position_at(0)
+                for i in range(1, n + 1):
+                    cur = e.position_at(i / n)
+                    p = _seg_seg_point(a, b, (prev.X, prev.Y), (cur.X, cur.Y))
+                    if p is not None:
+                        points.append(p)
+                    prev = cur
+        except Exception:
+            opaque += 1
+    distinct = 0
+    seen: list[tuple[float, float]] = []
+    for p in points:
+        if not any(abs(p[0] - q[0]) < 0.5 and abs(p[1] - q[1]) < 0.5 for q in seen):
+            seen.append(p)
+            distinct += 1
+    return (distinct + opaque) >= 2
+
+
 def _view_edge_entries(vs, cache):
     """Per-edge ``(edge, bbox2d)`` list for view shape *vs*, memoised in *cache*.
 
@@ -548,6 +631,51 @@ def _lint_view_shapes(
                     )
                 )
 
+    # #796 — leader shaft crosses the view silhouette. A leader that routes its
+    # shaft THROUGH the part body to reach its label reads as clipping the
+    # outline; the tip-on-silhouette touch is excluded (see _leader_shaft_hits_edges).
+    # Only tested where the shaft's own bbox overlaps the view (a leader far from a
+    # view can't cross it), reusing the shared edge cache.
+    for vname, vbb, vs in named_views:
+        for ann in ann_items:
+            if id(ann) in view_shape_ids:
+                continue
+            if getattr(ann, "elbow", None) is None:
+                continue
+            if getattr(ann, "is_centerline", False) or getattr(ann, "is_section_hatch", False):
+                continue
+            if getattr(ann, "covers_diameters", None):
+                continue  # a hole/bore callout legitimately exits the part from an internal hole
+            try:
+                tip, elbow = ann.tip, ann.elbow
+                shaft_bb = (
+                    min(tip[0], elbow[0]),
+                    min(tip[1], elbow[1]),
+                    max(tip[0], elbow[0]),
+                    max(tip[1], elbow[1]),
+                )
+            except Exception:
+                continue
+            if not _boxes_overlap(vbb, shaft_bb):
+                continue
+            edges = _view_edge_entries(vs, cache)
+            if edges is None:
+                continue
+            if _leader_shaft_hits_edges(tip, elbow, edges):
+                albl = getattr(ann, "label", None) or getattr(ann, "name", None) or "leader"
+                issues.append(
+                    LintIssue(
+                        severity="info",
+                        message=(
+                            f"leader '{albl}' shaft crosses view '{vname}' silhouette "
+                            f"— route it clear of the outline, or dimension the feature "
+                            f"in a detail view"
+                        ),
+                        location=(elbow[0], elbow[1]),
+                        code="leader_crosses_silhouette",
+                    )
+                )
+
     # #160 — view shape vs view shape bounding box overlaps
     for i, (aname, abb, _) in enumerate(named_views):
         ax0, ay0, ax1, ay1 = abb

{draftwright-0.3.6 → draftwright-0.3.7}/tests/test_lint_structural.py

@@ -481,3 +481,82 @@ class TestLintSelfSilencing:
         b = SimpleNamespace(label_bbox=(0.0, 0.0, 4.0, 4.0), label="B")
         with pytest.raises(IndexError):
             lint_drawing([a, b])
+
+
+class TestLeaderCrossesSilhouette:
+    """#796: leader_crosses_silhouette — a leader shaft that cuts THROUGH the part
+    body. Discriminator unit-tested here on controlled real edges (no projection);
+    the real projected-view behaviour is integration-tested in test_make_drawing."""
+
+    @staticmethod
+    def _edges(*segs):
+        from build123d import Edge
+
+        from draftwright.linting.structural import _shape_box2d
+
+        out = []
+        for (x0, y0), (x1, y1) in segs:
+            e = Edge.make_line((x0, y0, 0), (x1, y1, 0))
+            out.append((e, _shape_box2d(e)))
+        return out
+
+    def test_two_crossings_is_a_cut(self):
+        from draftwright.linting.structural import _leader_shaft_hits_edges
+
+        # shaft x=5, y 0→20; two horizontal edges at y=8 and y=12 → enters+exits.
+        edges = self._edges(((0, 8), (10, 8)), ((0, 12), (10, 12)))
+        assert _leader_shaft_hits_edges((5.0, 0.0), (5.0, 20.0), edges)
+
+    def test_single_crossing_is_a_legitimate_exit(self):
+        from draftwright.linting.structural import _leader_shaft_hits_edges
+
+        # only one edge on the way out (a hole callout exiting the outline once).
+        edges = self._edges(((0, 12), (10, 12)))
+        assert not _leader_shaft_hits_edges((5.0, 0.0), (5.0, 20.0), edges)
+
+    def test_tip_edge_is_skipped(self):
+        from draftwright.linting.structural import _leader_shaft_hits_edges
+
+        # the tip sits ON an edge (y=0) and the shaft runs away: the tip's own edge
+        # crosses at t<0 of the skipped shaft, so a lone outward ⌀ leader is not a cut.
+        edges = self._edges(((0, 0), (10, 0)))
+        assert not _leader_shaft_hits_edges((5.0, 0.0), (5.0, 20.0), edges)
+
+    def test_shared_vertex_counts_once(self):
+        from draftwright.linting.structural import _leader_shaft_hits_edges
+
+        # Two edges meet at (5, 5) forming a V; a shaft grazing that vertex crosses
+        # BOTH edges at the same point — deduped to one, so it is not a cut (the
+        # bbox-count version over-counted this to two — #799 review).
+        edges = self._edges(((0, 0), (5, 5)), ((5, 5), (10, 0)))
+        assert not _leader_shaft_hits_edges((5.0, -5.0), (5.0, 10.0), edges)
+
+    def test_doubled_edge_counts_once(self):
+        from draftwright.linting.structural import _leader_shaft_hits_edges
+
+        # A coincident/doubled projected edge (front+back face project alike) is one
+        # crossing, not two.
+        edges = self._edges(((0, 10), (10, 10)), ((0, 10), (10, 10)))
+        assert not _leader_shaft_hits_edges((5.0, 0.0), (5.0, 20.0), edges)
+
+    def test_tip_skip_prevents_near_edge_false_positive(self):
+        from draftwright.linting.structural import _leader_shaft_hits_edges
+
+        # Tip ON a near edge (y=0), with a far edge (y=12); the shaft exits through
+        # the far edge only. The tip's own edge must be stepped over — WITHOUT the
+        # skip this counts 2 (near tip-touch + far exit) and false-fires. This is the
+        # case that actually pins the load-bearing tip-skip (#799 review).
+        edges = self._edges(((0, 0), (10, 0)), ((0, 12), (10, 12)))
+        assert not _leader_shaft_hits_edges((5.0, 0.0), (5.0, 20.0), edges)
+
+    def test_shaft_through_a_curved_edge_twice_is_a_cut(self):
+        from build123d import Edge
+
+        from draftwright.linting.structural import _leader_shaft_hits_edges, _shape_box2d
+
+        # A single CURVED edge crossed twice (enter+exit) is a cut — exercises the
+        # curve-sampling + cross-subsegment dedup path. Circle r5 at origin; the
+        # shaft along y=0 passes through it at x=-5 and x=+5.
+        arc = Edge.make_circle(5)
+        edges = [(arc, _shape_box2d(arc))]
+        assert _leader_shaft_hits_edges((-10.0, 0.0), (10.0, 0.0), edges)