draftwright 0.5.0rc8__tar.gz → 0.5.0rc9__tar.gz

{draftwright-0.5.0rc8 → draftwright-0.5.0rc9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: draftwright
-Version: 0.5.0rc8
+Version: 0.5.0rc9
 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.0rc8 → draftwright-0.5.0rc9}/pyproject.toml

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

{draftwright-0.5.0rc8 → draftwright-0.5.0rc9}/src/draftwright/_pmi_linear_geometry.py

@@ -4,6 +4,11 @@ from __future__ import annotations
 
 import math
 
+from draftwright._pmi_topology import (
+    _is_mixed_planar_bore,
+    _parallel_planar_reference_witness,
+    _planar_bore_axis_witness,
+)
 from draftwright.model.ir import _linear_projection_view
 
 _LINEAR_AXIS_ABS_TOL = 0.005
@@ -13,6 +18,47 @@ _LINEAR_VALUE_REL_TOL = 5e-4
 _LINEAR_OBLIQUE_VALUE_ABS_TOL = 0.05
 
 
+def _proved_planar_linear(groups, stations, nominal, kind, frame, shape_bbox):
+    """Resolve the normal span and a face-supported projected witness together."""
+    axis, view, witness = _parallel_planar_reference_witness(groups, frame, shape_bbox)
+    if witness is None:
+        return (
+            tuple(point for point in stations if point is not None),
+            "?",
+            None,
+            ("parallel planar source faces have no proven shared witness",),
+        )
+    if axis is None and kind == "linear" and _is_mixed_planar_bore(groups):
+        bore_support = _planar_bore_axis_witness(groups, frame, shape_bbox)
+        if bore_support is None:
+            points, dominant, reasons = _dimension_reference_stations(
+                tuple(stations), nominal, kind
+            )
+            return (
+                points,
+                dominant,
+                None,
+                (
+                    *reasons,
+                    "plane-to-bore location has no proven face-supported axis witness",
+                ),
+            )
+        stations, axis, view = bore_support
+    if witness:
+        stations = tuple(
+            tuple(
+                next((value for index, value in witness if index == i), point[i]) for i in range(3)
+            )
+            if point is not None
+            else None
+            for point in stations
+        )
+    points, dominant, reasons = _dimension_reference_stations(
+        tuple(stations), nominal, kind, plane_axis=axis
+    )
+    return points, dominant, view, reasons
+
+
 def _linear_reference_stations(
     stations: tuple[tuple[float, float, float] | None, ...],
     nominal: float,

{draftwright-0.5.0rc8 → draftwright-0.5.0rc9}/src/draftwright/_pmi_topology.py

@@ -6,7 +6,7 @@ B-rep; geometric likeness alone cannot establish source ownership.
 
 from __future__ import annotations
 
-from draftwright._pmi_datum_geometry import _frame_vector
+from draftwright._pmi_datum_geometry import _frame_point, _frame_vector
 from draftwright._pmi_support_blockers import _failure_reason
 
 try:
@@ -20,14 +20,21 @@ except ImportError:
 
 def _parallel_planar_reference_support(groups, frame, shape_bbox) -> tuple[str | None, str | None]:
     """Find the common principal normal and any required witness view."""
+    axis, view, _witness = _parallel_planar_reference_witness(groups, frame, shape_bbox)
+    return axis, view
+
+
+def _parallel_planar_reference_witness(groups, frame, shape_bbox):
+    """Prove a view and, when its default midpoint misses, a shared face witness."""
     from OCP.BRepAdaptor import BRepAdaptor_Surface
     from OCP.GeomAbs import GeomAbs_Plane
     from OCP.TopoDS import TopoDS
 
     if len(groups) != 2 or not all(groups):
-        return None, None
+        return None, None, ()
     axes: list[int] = []
     group_boxes = []
+    group_faces = []
     for shapes in groups:
         group_axis = None
         group_station = None
@@ -35,35 +42,209 @@ def _parallel_planar_reference_support(groups, frame, shape_bbox) -> tuple[str |
         for shape in shapes:
             try:
                 if shape.ShapeType() != TopAbs_FACE:
-                    return None, None
+                    return None, None, ()
                 surface = BRepAdaptor_Surface(TopoDS.Face_s(shape))
                 if surface.GetType() != GeomAbs_Plane:
-                    return None, None
+                    return None, None, ()
                 direction = surface.Plane().Axis().Direction()
                 local = _frame_vector((direction.X(), direction.Y(), direction.Z()), frame)
                 axis_index = max(range(3), key=lambda index: abs(local[index]))
                 if abs(abs(local[axis_index]) - 1.0) > 1e-6:
-                    return None, None
+                    return None, None, ()
                 if any(abs(local[index]) > 1e-6 for index in range(3) if index != axis_index):
-                    return None, None
+                    return None, None, ()
                 box = shape_bbox(shape) if frame is None else shape_bbox(shape, frame)
                 boxes.append(box)
                 station = (box[axis_index] + box[axis_index + 3]) / 2
                 if box[axis_index + 3] - box[axis_index] > 1e-5:
-                    return None, None
+                    return None, None, ()
             except Exception:
-                return None, None
+                return None, None, ()
             if group_axis is not None and group_axis != axis_index:
-                return None, None
+                return None, None, ()
             if group_station is not None and abs(group_station - station) > 1e-5:
-                return None, None
+                return None, None, ()
             group_axis, group_station = axis_index, station
         assert group_axis is not None  # Each validated source group contains a face.
         axes.append(group_axis)
         group_boxes.append(boxes)
+        group_faces.append(shapes)
     if axes[0] != axes[1]:
-        return None, None
-    return _supported_planar_view("XYZ"[axes[0]], group_boxes)
+        return None, None, ()
+    axis = "XYZ"[axes[0]]
+    if axis == "X":
+        return _principal_x_planar_witness(group_boxes, group_faces, frame)
+    view_axis, view = _supported_planar_view(axis, group_boxes)
+    return view_axis, view, ()
+
+
+def _principal_x_planar_witness(group_boxes, group_faces, frame):
+    # A front projection only needs both planes represented at the same Z;
+    # parallel face patches may be offset in Y (#2184). The plan fallback,
+    # however, claims one shared Y/Z point and must prove it on both trims.
+    if _midpoint_witness_supported(group_boxes, 2):
+        return "X", None, ()
+    common = _common_x_face_witness(group_boxes, group_faces, frame)
+    if common is not None:
+        y, z = common
+        return "X", "plan", ((1, y), (2, z))
+    return None, None, None
+
+
+def _common_x_face_witness(group_boxes, group_faces, frame):
+    """Find a point in the interiors of both exact, trimmed X faces."""
+    candidates = [
+        (
+            (min(a[4], b[4]) - max(a[1], b[1])) * (min(a[5], b[5]) - max(a[2], b[2])),
+            max(a[1], b[1]),
+            max(a[2], b[2]),
+            min(a[4], b[4]),
+            min(a[5], b[5]),
+            a,
+            b,
+            group_faces[0][i],
+            group_faces[1][j],
+        )
+        for i, a in enumerate(group_boxes[0])
+        for j, b in enumerate(group_boxes[1])
+        if min(a[4], b[4]) >= max(a[1], b[1]) and min(a[5], b[5]) >= max(a[2], b[2])
+    ]
+    for _area, y0, z0, y1, z1, a, b, first, second in sorted(
+        candidates, key=lambda item: (-item[0], item[1], item[2])
+    ):
+        # Start at the overlap centre, then sample its interior deterministically.
+        # A bounding box may contain a face hole or a concavity; only OCC's
+        # trimmed-face classifier can establish a real common witness.
+        for y_fraction, z_fraction in ((0.5, 0.5),) + tuple(
+            (i / 10, j / 10) for i in range(1, 10) for j in range(1, 10)
+        ):
+            y = y0 + (y1 - y0) * y_fraction
+            z = z0 + (z1 - z0) * z_fraction
+            if all(
+                _point_inside_x_face(face, (box[0] + box[3]) / 2, y, z, frame)
+                for face, box in ((first, a), (second, b))
+            ):
+                return y, z
+    return None
+
+
+def _point_inside_x_face(face, x, y, z, frame):
+    from OCP.BRepClass import BRepClass_FaceClassifier
+    from OCP.gp import gp_Pnt
+    from OCP.TopAbs import TopAbs_IN
+    from OCP.TopoDS import TopoDS
+
+    local = (x, y, z)
+    world = local if frame is None else frame.to_world(local)
+    classifier = BRepClass_FaceClassifier()
+    try:
+        classifier.Perform(TopoDS.Face_s(face), gp_Pnt(*world), 1e-7)
+        return classifier.State() == TopAbs_IN
+    except Exception:
+        return False
+
+
+def _planar_bore_axis_witness(groups, frame, shape_bbox):
+    """Prove a location from one principal plane to one finite Z-bore axis.
+
+    A cylindrical face's bbox centre is its axial *height*, not the location
+    station. The plane must actually contain the axis-aligned witness point;
+    a bounding-box overlap alone would invent a witness through a trimmed face.
+    """
+    from OCP.BRepAdaptor import BRepAdaptor_Surface
+    from OCP.BRepClass import BRepClass_FaceClassifier
+    from OCP.GeomAbs import GeomAbs_Cylinder, GeomAbs_Plane
+    from OCP.gp import gp_Pnt
+    from OCP.TopAbs import TopAbs_IN, TopAbs_ON
+    from OCP.TopoDS import TopoDS
+
+    if len(groups) != 2 or any(len(group) != 1 for group in groups):
+        return None
+    try:
+        faces = tuple(TopoDS.Face_s(group[0]) for group in groups)
+        surfaces = tuple(BRepAdaptor_Surface(face) for face in faces)
+        kinds = tuple(surface.GetType() for surface in surfaces)
+        if kinds not in ((GeomAbs_Plane, GeomAbs_Cylinder), (GeomAbs_Cylinder, GeomAbs_Plane)):
+            return None
+        plane_i = kinds.index(GeomAbs_Plane)
+        bore_i = 1 - plane_i
+        normal = surfaces[plane_i].Plane().Axis().Direction()
+        normal = _frame_vector((normal.X(), normal.Y(), normal.Z()), frame)
+        axis = max(range(3), key=lambda index: abs(normal[index]))
+        if axis not in (0, 1) or abs(abs(normal[axis]) - 1) > 1e-6:
+            return None
+        bore = surfaces[bore_i].Cylinder().Axis()
+        direction = bore.Direction()
+        direction = _frame_vector((direction.X(), direction.Y(), direction.Z()), frame)
+        if abs(abs(direction[2]) - 1) > 1e-6 or max(abs(value) for value in direction[:2]) > 1e-6:
+            return None
+        point = bore.Location()
+        centre = _frame_point((point.X(), point.Y(), point.Z()), frame)
+        boxes = tuple(
+            shape_bbox(group[0]) if frame is None else shape_bbox(group[0], frame)
+            for group in groups
+        )
+        plane_box, bore_box = boxes[plane_i], boxes[bore_i]
+        z0 = max(plane_box[2], bore_box[2])
+        z1 = min(plane_box[5], bore_box[5])
+        if z1 - z0 <= 1e-6:
+            return None
+        station = (plane_box[axis] + plane_box[axis + 3]) / 2
+        if plane_box[axis + 3] - plane_box[axis] > 1e-5:
+            return None
+        witness = list(centre)
+        witness[axis] = station
+        witness[2] = (z0 + z1) / 2
+        world = witness if frame is None else frame.to_world(tuple(witness))
+        classifier = BRepClass_FaceClassifier()
+        classifier.Perform(faces[plane_i], gp_Pnt(*world), 1e-7)
+        if classifier.State() not in (TopAbs_IN, TopAbs_ON):
+            return None
+        points = [tuple(witness), tuple(witness)]
+        bore_point = list(witness)
+        bore_point[axis] = centre[axis]
+        points[bore_i] = tuple(bore_point)
+        return tuple(points), "XYZ"[axis], "plan"
+    except Exception:
+        return None
+
+
+def _is_mixed_planar_bore(groups):
+    """Recognise the mixed support even when its location proof fails."""
+    from OCP.BRepAdaptor import BRepAdaptor_Surface
+    from OCP.GeomAbs import GeomAbs_Cylinder, GeomAbs_Plane
+    from OCP.TopoDS import TopoDS
+
+    if len(groups) != 2 or any(len(group) != 1 for group in groups):
+        return False
+    try:
+        kinds = tuple(BRepAdaptor_Surface(TopoDS.Face_s(group[0])).GetType() for group in groups)
+        return kinds in ((GeomAbs_Plane, GeomAbs_Cylinder), (GeomAbs_Cylinder, GeomAbs_Plane))
+    except Exception:
+        return False
+
+
+def _common_principal_cylinder_axis(references):
+    """Return a shared principal axis only when every exact cylinder proves it."""
+    axes = []
+    for reference in references:
+        vector = reference.axis_direction
+        axis = max(range(3), key=lambda index: abs(vector[index]))
+        if abs(abs(vector[axis]) - 1.0) > 1e-6 or any(
+            abs(vector[index]) > 1e-6 for index in range(3) if index != axis
+        ):
+            return ""
+        axes.append("XYZ"[axis])
+    return axes[0] if axes and len(set(axes)) == 1 else ""
+
+
+def _optional_cylinder_support(probe):
+    """Keep an optional axis probe from erasing otherwise valid source PMI."""
+    try:
+        references, reasons = probe()
+        return references if not reasons else ()
+    except Exception:
+        return ()
 
 
 def _supported_planar_view(axis: str, group_boxes) -> tuple[str | None, str | None]:

{draftwright-0.5.0rc8 → draftwright-0.5.0rc9}/src/draftwright/annotations/_common.py

@@ -51,6 +51,10 @@ from draftwright.annotations._placement_geometry import (
 from draftwright.annotations._placement_geometry import (
     _box_hits as _box_hits,
 )
+from draftwright.annotations._placement_geometry import (
+    _box_outside_explicit_drawable_bounds,
+    _first_box_conflict,
+)
 from draftwright.annotations._placement_geometry import (
     _geom_box as _geom_box,
 )
@@ -78,6 +82,7 @@ from draftwright.annotations._placement_geometry import (
 from draftwright.annotations._placement_occupancy import (  # noqa: F401 — stable _common imports
     _PAGE_SPANNING_RIDERS,
     CROSSABLE_TYPES,
+    DeferredCompactCandidate,
     annotation_ink_clear,
     annotation_ink_obstacles,
     annotation_obstacle_boxes,
@@ -85,6 +90,7 @@ from draftwright.annotations._placement_occupancy import (  # noqa: F401 — sta
     balloon_annotation_label_boxes,
     balloon_geometry_hits_annotation_labels,
     box_within_page_and_clear,
+    compact_probe_clear,
     corridor_blockers,
     full_strip_message,
     is_page_spanning_rider,
@@ -1889,26 +1895,11 @@ def _prepare_strip_candidate_run(run) -> None:
             if r is not None and r[perp] < band_hi and r[perp + 2] > band_lo
         ]
     blockers = () if force else corridor_blockers(dwg, view, exact_leaders=bool(exact_ink))
-    # The title block is drawn near the end of `_PASS_SEQUENCE`, so it is
-    # never in `occupied` above. `pending_title_block_box` knows its fixed box
-    # from the sheet geometry, so a strip placer can honour it regardless.
-    #
-    # A hard 2-D box checked against each candidate's REAL footprint in
-    # `_real_box_conflict` below, the way `forbid` guards this same block for GD&T frames
-    # — not an entry in the carve. The carve inflates by `pad`, the separation two
-    # dimension LINES need from each other, and projects onto the stacking axis, claiming
-    # every position at that coordinate; against a block this large both over-claim
-    # badly, refusing dims that clear it by a millimetre. A 2-D test against the
-    # candidate's own footprint refuses exactly the dims that land on it.
-    #
-    # `forbid` also pre-checks the PREDICTED box inside the segment solve, so a rejection
-    # frees its slot for a refill in the same pass. Not mirrored here: on this corpus
-    # either check alone catches every case (measured by deleting each in turn), and an
-    # untested second branch is worth less than the packing it might win. The real-box
-    # check is the one kept because it cannot be defeated by a prediction miss.
-    #
-    # Honoured under `force` too, for the reason `forbid` is: a dim kept on its natural
-    # view as a last resort must still not print over the block.
+    # The title block is drawn after this pass, so it is absent from occupancy.
+    # Check its fixed 2-D box against REAL candidate ink, not the inflated strip
+    # carve: projection would reject dimensions that clear it. A predicted-box
+    # precheck would permit refill, but the real-box check alone is sufficient and
+    # cannot miss underpredicted ink. Even forced candidates must respect the block.
     _tb = pending_title_block_box(dwg)
     keep_out = (_tb,) if _tb is not None else ()
     segs = _reserved_strip_segments(lo, hi, occupied, idx, pad)
@@ -1926,18 +1917,20 @@ def _prepare_strip_candidate_run(run) -> None:
     todo = list(cands)
 
     def _real_box_conflict(name, real, annotation=None):
-        """Return the hard-obstacle reason for a built survivor, if any."""
         if real is None:
             return None
+        # A bounded strip does not bound oblique witness ink; check even under force.
+        if _box_outside_explicit_drawable_bounds(dwg, real):
+            return "real_box_page_bounds"
         if not force and _box_hits(real, blockers):
             return "real_box_corridor_blocked"
         fb = (forbid or {}).get(name)
         if fb is not None and _box_hits(real, (fb,)):
             return "real_box_forbid"
-        if _box_hits(real, out_of_band):
-            return "real_box_out_of_band"
-        if _box_hits(real, keep_out):
-            return "real_box_title_block"
+        if reason := _first_box_conflict(
+            real, (("real_box_out_of_band", out_of_band), ("real_box_title_block", keep_out))
+        ):
+            return reason
         if (
             annotation is not None
             and not force
@@ -2262,7 +2255,15 @@ def _compact_strip_candidate_ink(run) -> None:
         index = next((i for i, (key, _dim) in enumerate(solved) if key == name), None)
         original = solved[index][1] if index is not None else None
         others = [item for key, item in solved if key != name]
-        for candidate in alternatives(original):
+        for proposal in alternatives(original):
+            if isinstance(proposal, DeferredCompactCandidate):
+                if not compact_probe_clear(
+                    dwg, proposal, others, (forbid or {}).get(name), label_clear
+                ):
+                    continue
+                candidate = proposal.materialize()
+            else:
+                candidate = proposal
             if (
                 original is not None
                 and hasattr(candidate, "arc_radius")