draftwright 0.5.0rc4__tar.gz → 0.5.0rc6__tar.gz

{draftwright-0.5.0rc4 → draftwright-0.5.0rc6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: draftwright
-Version: 0.5.0rc4
+Version: 0.5.0rc6
 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.5.0rc4 → draftwright-0.5.0rc6}/docs/reference/sheet.md

@@ -867,6 +867,10 @@ A location intent's precision applies to all its selected directional values, in
 side-drilled holes and slots. The policy survives generated-script replay. When several
 location intents share one coincident mark, give them matching display precision; incompatible
 printed values raise an actionable error instead of silently choosing one intent's label.
+For a diameter that references an imported knurl maximum, the numeric value sets a
+minimum number of decimal places: `format(decimals=1)` cannot print `ø10.05` as
+`ø10.1`. The numeric PMI fields are floats; this policy does not preserve trailing
+zeroes from the retained source prose.
 
 
 ::: draftwright.sheet.DimensionIntent

{draftwright-0.5.0rc4 → draftwright-0.5.0rc6}/pyproject.toml

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

{draftwright-0.5.0rc4 → draftwright-0.5.0rc6}/src/draftwright/_geometry.py

@@ -261,6 +261,18 @@ def _radial_axis_in_view(axis: str, view: str) -> str:
         raise ValueError(f"no radial axis for shaft axis {axis!r} in view {view!r}") from e
 
 
+def _cylindrical_finish_site(reference):
+    """Preferred visible site for one external orthographic cylinder finish."""
+    axis = reference.principal_axis.lower()
+    if reference.sense != "external" or axis not in _EDGE_ON:
+        return None
+    view = _EDGE_ON[axis]
+    radial = _radial_axis_in_view(axis, view)
+    site = list(reference.midpoint)
+    site["xyz".index(radial)] += reference.radius
+    return (tuple(site), view, "above" if radial == "z" else "right")
+
+
 def _canonical_profile_site(site, centre, axis: str, view: str) -> tuple[float, float, float]:
     """Rotate a turned surface *site* about its shaft onto the selected profile plane.
 
@@ -641,6 +653,11 @@ def _boxes_overlap(a, b) -> bool:
     return bool(a[0] < b[2] and a[2] > b[0] and a[1] < b[3] and a[3] > b[1])
 
 
+def detail_caption_text_gap(font_size: float) -> float:
+    """Minimum page-space gap between a detail caption and another label."""
+    return font_size / 3.0
+
+
 def _segment_crosses_box(p1, p2, box) -> bool:
     """True when line segment *p1*-*p2* intersects axis-aligned *box*
     ``(x0, y0, x1, y1)`` — the precise counterpart of ``_box_hits`` for a
@@ -1027,6 +1044,62 @@ def material_span(p, q, field: MaterialField) -> float:
     )
 
 
+def label_on_narrow_material(box, field: MaterialField) -> bool:
+    """Whether text covers material too close to its projected boundary.
+
+    A projected edge can miss a text box by a fraction of a millimetre while
+    the glyphs still fill a thin shaft. A broad face keeps room around the box.
+    Probe both centre lines and half the shorter label extent beyond each edge; the
+    material field is the same one used for leader routing. An edge of a broad
+    face alone is not a narrow shaft: the local material band across the label's
+    short axis must also be less than three short-axis extents.
+    """
+    if not field or field.box is None:
+        return False
+    x0, y0, x1, y1 = box
+    width, height = x1 - x0, y1 - y0
+    if width <= 0.0 or height <= 0.0:
+        return False
+    x = (x0 + x1) / 2.0
+    y = (y0 + y1) / 2.0
+    if (
+        material_span((x0, y), (x1, y), field) < width - MATERIAL_VISIBLE_FLOOR
+        or material_span((x, y0), (x, y1), field) < height - MATERIAL_VISIBLE_FLOOR
+    ):
+        return False
+    short = min(width, height)
+    if width <= height:
+        p, q, centre = (field.box[0], y), (field.box[2], y), x
+        axis = 0
+    else:
+        p, q, centre = (x, field.box[1]), (x, field.box[3]), y
+        axis = 1
+    span = q[axis] - p[axis]
+    if span <= 0.0:
+        return False
+    centre_tick = round((centre - p[axis]) / span * _MATERIAL_SPAN_TICKS)
+    local_band = next(
+        (
+            span * (hi - lo) / _MATERIAL_SPAN_TICKS
+            for lo, hi in material_intervals(p, q, field)
+            if lo <= centre_tick <= hi
+        ),
+        None,
+    )
+    if local_band is None or local_band >= 3.0 * short:
+        return False
+    margin = short / 2.0
+    return any(
+        material_span(p, q, field) < margin - MATERIAL_VISIBLE_FLOOR
+        for p, q in (
+            ((x0 - margin, y), (x0, y)),
+            ((x1, y), (x1 + margin, y)),
+            ((x, y0 - margin), (x, y0)),
+            ((x, y1), (x, y1 + margin)),
+        )
+    )
+
+
 def material_intervals(
     p, q, field: MaterialField, *, bridge: float = 0.0
 ) -> tuple[tuple[int, int], ...]:

draftwright-0.5.0rc6/src/draftwright/_pmi_datum_geometry.py

@@ -0,0 +1,174 @@
+"""Exact imported datum attachment geometry in source or recognition frame."""
+
+from __future__ import annotations
+
+import math
+from typing import cast
+
+from quiddity import PartFrame
+
+
+def _bbox_centroid(bbox: tuple) -> tuple[float, float, float]:
+    xmin, ymin, zmin, xmax, ymax, zmax = bbox
+    return ((xmin + xmax) / 2, (ymin + ymax) / 2, (zmin + zmax) / 2)
+
+
+def _frame_point(
+    point: tuple[float, float, float], frame: PartFrame | None
+) -> tuple[float, float, float]:
+    """Express one source-space point in *frame*, preserving default extraction exactly."""
+    if frame is None:
+        return point
+    return frame.to_local(point)
+
+
+def _frame_vector(
+    vector: tuple[float, float, float], frame: PartFrame | None
+) -> tuple[float, float, float]:
+    """Express one free vector in *frame* without applying the frame origin."""
+    if frame is None:
+        return vector
+    return cast(
+        tuple[float, float, float],
+        tuple(
+            sum(component * basis[index] for index, component in enumerate(vector))
+            for basis in (frame.x, frame.y, frame.z)
+        ),
+    )
+
+
+def _cylindrical_datum_site(face, bbox, axis_index, frame):
+    """Find a normal axis-aligned projection site on the exact trimmed face."""
+    from OCP.BRepAdaptor import BRepAdaptor_Surface
+    from OCP.BRepBuilderAPI import BRepBuilderAPI_MakeVertex
+    from OCP.BRepExtrema import BRepExtrema_DistShapeShape
+    from OCP.gp import gp_Pnt
+
+    cylinder = BRepAdaptor_Surface(face).Cylinder()
+    centre = _bbox_centroid(bbox)
+    location = cylinder.Axis().Location()
+    axis_site = _frame_point((location.X(), location.Y(), location.Z()), frame)
+    radial_index = 2 if axis_index < 2 else 0
+    preferred_signs = (-1, 1) if axis_index < 2 else (1, -1)
+    # The upper station avoids CTC-01's lower source label, but a trimmed
+    # sidewall may lose that station to a cross-hole. Try the midpoint too.
+    stations: tuple[float, ...] = (centre[axis_index],)
+    if axis_index == 2:
+        stations = (centre[axis_index] + min((bbox[5] - bbox[2]) / 4, 10.0), *stations)
+    for station in stations:
+        for sign in preferred_signs:
+            silhouette = list(axis_site)
+            silhouette[axis_index] = station
+            silhouette[radial_index] += sign * cylinder.Radius()
+            local_site = tuple(silhouette)
+            if not all(
+                bbox[index] - 1e-6 <= local_site[index] <= bbox[index + 3] + 1e-6
+                for index in range(3)
+            ):
+                continue
+            world_site = local_site if frame is None else frame.to_world(local_site)
+            vertex = BRepBuilderAPI_MakeVertex(gp_Pnt(*world_site)).Vertex()
+            distance = BRepExtrema_DistShapeShape(vertex, face)
+            distance.Perform()
+            if distance.IsDone() and distance.Value() <= 1e-6:
+                return local_site
+    return None
+
+
+def _datum_face_site(shape, bbox, kind, axis_index, frame):
+    """Choose a proven face site, on the projected silhouette for cylinders."""
+    from OCP.BRep import BRep_Tool
+    from OCP.BRepAdaptor import BRepAdaptor_Surface
+    from OCP.BRepClass import BRepClass_FaceClassifier
+    from OCP.BRepMesh import BRepMesh_IncrementalMesh
+    from OCP.BRepTools import BRepTools
+    from OCP.gp import gp_Pnt, gp_Pnt2d
+    from OCP.TopAbs import TopAbs_IN
+    from OCP.TopLoc import TopLoc_Location
+    from OCP.TopoDS import TopoDS
+
+    face = TopoDS.Face_s(shape)
+    if kind == "cylinder":
+        return _cylindrical_datum_site(face, bbox, axis_index, frame)
+    u0, u1, v0, v1 = BRepTools.UVBounds_s(face)
+    surface = BRepAdaptor_Surface(face)
+    classifier = BRepClass_FaceClassifier()
+    centre = _bbox_centroid(bbox)
+    candidates = []
+    if all(math.isfinite(value) for value in (u0, u1, v0, v1)):
+        for ui in range(13):
+            u = u0 + (ui + 0.5) * (u1 - u0) / 13
+            for vi in range(13):
+                v = v0 + (vi + 0.5) * (v1 - v0) / 13
+                classifier.Perform(face, gp_Pnt2d(u, v), 1e-7)
+                if classifier.State() == TopAbs_IN:
+                    point = surface.Value(u, v)
+                    candidates.append((point.X(), point.Y(), point.Z()))
+    if not candidates:
+        # A narrow ring can lie entirely between grid samples. Mesh triangles
+        # cover the trimmed face, and their centroids supply interior sites.
+        for deflection in (0.1, 0.01, 0.001, 0.0001):
+            BRepMesh_IncrementalMesh(face, deflection, False, 0.5, False).Perform()
+            location = TopLoc_Location()
+            mesh = BRep_Tool.Triangulation_s(face, location)
+            if mesh is None:
+                continue
+            transform = location.Transformation()
+            for index in range(1, mesh.NbTriangles() + 1):
+                vertices = mesh.Triangle(index).Get()
+                nodes = [mesh.Node(vertex).Transformed(transform) for vertex in vertices]
+                point = tuple(sum(node.Coord()[axis] for node in nodes) / 3 for axis in range(3))
+                classifier.Perform(face, gp_Pnt(*point), 1e-7)
+                if classifier.State() == TopAbs_IN:
+                    candidates.append(point)
+            if candidates:
+                break
+    sites = []
+    for point in candidates:
+        site = _frame_point(point, frame)
+        hidden = 0 if axis_index == 1 else 1
+        key = (
+            abs(site[hidden] - centre[hidden]),
+            sum((site[i] - centre[i]) ** 2 for i in range(3)),
+        )
+        sites.append((key, site))
+    return min(sites)[1] if sites else None
+
+
+def _datum_reference_normal(shapes, points, frame) -> tuple[tuple[float, ...], str]:
+    """Measure a planar datum's oriented outward normal."""
+    from OCP.BRepAdaptor import BRepAdaptor_Surface
+    from OCP.GeomAbs import GeomAbs_Cylinder, GeomAbs_Plane
+    from OCP.TopAbs import TopAbs_FORWARD, TopAbs_REVERSED
+    from OCP.TopoDS import TopoDS
+
+    normals = []
+    for shape, _site in zip(shapes, points, strict=True):
+        face = TopoDS.Face_s(shape)
+        surface = BRepAdaptor_Surface(face)
+        kind = surface.GetType()
+        if kind == GeomAbs_Cylinder:
+            continue
+        if kind != GeomAbs_Plane:
+            return (), "datum reference surface has no supported oriented normal"
+        direction = surface.Plane().Axis().Direction()
+        vector: tuple[float, ...] = _frame_vector(
+            (direction.X(), direction.Y(), direction.Z()), frame
+        )
+        orientation = face.Orientation()
+        if orientation == TopAbs_REVERSED:
+            vector = tuple(-component for component in vector)
+        elif orientation != TopAbs_FORWARD:
+            return (), "datum reference surface has no outward orientation"
+        magnitude = math.sqrt(sum(component * component for component in vector))
+        if magnitude < 1e-9:
+            return (), "datum reference surface has no usable normal"
+        normals.append(tuple(component / magnitude for component in vector))
+    if not normals:
+        return (), ""
+    if any(
+        sum(a * b for a, b in zip(normals[0], normal, strict=True)) < 0.999
+        for normal in normals[1:]
+    ):
+        return (), "datum reference faces disagree about outward normal"
+    return normals[0], ""

{draftwright-0.5.0rc4 → draftwright-0.5.0rc6}/src/draftwright/annotations/_diameters.py

@@ -898,7 +898,9 @@ def _reroute_crossing_diameters(dwg, *, ctx, material_penalty) -> int:
         # 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
+        toward_lo = tip[ax] - lo_b <= hi_b - tip[ax]
+        near_a = lo_b - gap if toward_lo else hi_b + gap
+        edge_a = lo_b - draft.pad_around_text if toward_lo else hi_b + draft.pad_around_text
 
         def _pt(a_val, r_val, _ax=ax):
             p = [0.0, 0.0]
@@ -907,6 +909,7 @@ def _reroute_crossing_diameters(dwg, *, ctx, material_penalty) -> int:
 
         candidates = (
             _pt(near_a, tip[rad]),
+            _pt(edge_a, tip[rad]),
             _pt(tip[ax], fb[rad] - gap),
             _pt(tip[ax], fb[rad + 2] + gap),
         )