draftwright 0.4.23__tar.gz → 0.4.25__tar.gz

{draftwright-0.4.23 → draftwright-0.4.25}/CHANGELOG.md

@@ -478,6 +478,10 @@
 
 ### Fixed
 
+- Overall height and envelope width remain dimensioned when approved turned-step lengths
+  cover only part of the respective extent. Redundancy suppression now requires adjoining
+  measurements on one profile to reach both overall endpoints; STC618 retains its missing
+  62 mm height (#1509).
 - Non-1:1 orthographic and isometric projection now scales extracted solids about the world
   origin, matching the view-coordinate mapper and solver zones. Solids carrying a non-zero
   build123d `Location` no longer shift their silhouette away from dimensions and callouts.

{draftwright-0.4.23 → draftwright-0.4.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: draftwright
-Version: 0.4.23
+Version: 0.4.25
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright
@@ -684,7 +684,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: <3.15,>=3.10
 Requires-Dist: antlr4-python3-runtime<4.10
-Requires-Dist: build123d-drafting-helpers>=0.14.2
+Requires-Dist: build123d-drafting-helpers>=0.15.1
 Requires-Dist: build123d<0.11,>=0.9.0; python_full_version < '3.13'
 Requires-Dist: build123d<0.12,>=0.11; python_full_version >= '3.13'
 Requires-Dist: cadquery-ocp-novtk!=7.9.3.1.1; python_full_version >= '3.13'

{draftwright-0.4.23 → draftwright-0.4.25}/docs/reference/sheet.md

@@ -4,6 +4,76 @@
 are documented here because they are part of normal use even though their Python names begin
 with an underscore.
 
+## Projection convention
+
+Use `Sheet(part, projection="first")` or `build_drawing(part, projection="first")`
+for first-angle layout and its matching projection symbol. The CLI equivalent is
+`--projection first`. Explicit `"third"` selects third-angle layout and its symbol;
+omitting `projection` keeps third-angle layout without a symbol.
+
+View names retain their physical viewing directions in the working part frame. Changing
+convention changes sheet relationships, not which side of the part a name shows:
+
+| View | Viewed from | Page directions | Third-angle position | First-angle position |
+|---|---|---|---|---|
+| `front` | Negative Y | X right, Z up | Reference | Reference |
+| `plan` | Positive Z | X right, Y up | Above front | Below front |
+| `side` | Positive X | Y right, Z up | Right of front | Left of front |
+
+The resolved convention is available as `drawing.view_plan.convention`. Generated scripts
+retain the requested convention. Annotation footprints, scale/page selection and measured
+repacking use the same convention. An authored relation contradicting the principal layout
+fails before projection; a whole-view pin must preserve the convention's relationships.
+
+## Dimension text style
+
+Position and reading direction are independent drawing-wide settings:
+
+```python
+sheet = Sheet(part, text_position="above", text_orientation="horizontal")
+# Declare features and dimensions as usual, then build.
+drawing = sheet.build()
+```
+
+`text_position="inline"` (the default) leaves a gap for the value in the dimension
+line; `"above"` keeps the line continuous and offsets the full value and tolerance.
+For angular dimensions, above means outside the arc. `text_orientation="aligned"`
+(the default) follows the dimension line or arc tangent; `"horizontal"` keeps text
+horizontal on the sheet. An aligned vertical value reads from the right. Short
+spans use outside arrows while retaining their complete text.
+
+The same options are accepted by `build_drawing()`, `make_drawing()`,
+`emit_sheet_script()` and `generate_sheet_script()`. The CLI flags are
+`--text-position` and `--text-orientation`. Generated scripts retain these settings;
+SVG, PDF and DXF export the same resolved ink. Unsupported values raise `ValueError`.
+The choices affect rendering and its placement footprint, not feature measurements
+or tolerances. These are explicit rendering choices, not a claim of standards conformity.
+
+## Through-hole wording
+
+The optional argument to a hole handle's `through()` controls its printed indicator:
+
+```python
+hole.through()                # default THRU
+hole.through("THRU")          # explicit wording
+hole.through("")              # omit the printed indicator
+hole.through("THROUGH ALL")   # alternative wording
+```
+
+Each declares a through hole and clears any blind depth. Diameter, tolerances, fits and
+measurement identities remain unchanged. The empty string is an explicit display omission;
+it remains visible in the suppression ledger and does not count as a printed through
+qualifier. `.depth(4)` makes the hole blind and clears the override; a later `.through()`
+returns to the default.
+
+The override is also accepted as `through_indicator=` by `Sheet.hole()` and the IR `hole()`
+constructor, including pattern members. Generated scripts preserve the difference between
+no override, explicit default wording and an empty string. Callouts and hole tables measure
+the selected wording before placement. Compatible holes can share a callout when their
+resolved wording, machining specifications and placement constraints agree; original feature
+owners and measurement identities remain separate. Removing one owner of a shared callout
+rebuilds the survivors through the placement solver.
+
 ## Grooves on coaxial bodies
 
 When different turned bodies share an axis line, give their steps distinct `profile_group`
@@ -245,6 +315,30 @@ detail = s.detail_view("B", around=hole).scale(2)
 dwg = s.build()
 ```
 
+Rear views are explicitly requested. `s.view("rear")` includes rear in an authored
+view set; `s.auto_views().add_view("rear")` adds it to the automatic baseline.
+Rear looks toward the part from +Y with Z upward, so increasing world X runs left
+on the page. This physical direction is the same under both projection conventions.
+When side is also present, rear sits beyond side in the unfolding direction: left
+for first-angle, right for third-angle.
+
+Y-axis hole and hole-pattern callouts, locations and pitch dimensions can use rear,
+as can overall width and height. For example:
+
+```python
+s = Sheet(part, projection="first").authored_dimensions()
+hole = s.hole(diameter=6, at=(10, 20, 5), axis="y").through("THRU")
+s.dimension(hole, "bore.diameter")
+s.dimension(hole, "location")
+s.view("rear")
+drawing = s.build()
+```
+
+Dimensions still use the shared placement solve. An unsupported measurement/view
+combination is refused; a required depth extent, for example, needs side. Rear is
+never added automatically to improve visibility, coverage or hidden lines. Generated
+scripts preserve an explicit rear request.
+
 `view(...)`, `section_view(...)` and `detail_view(...)` define complete authored sets;
 omission suppresses a view. `add_view(...)`, `add_section_view(...)` and
 `add_detail_view(...)` augment an explicitly selected `auto_views()` source. `row(...)` and
@@ -403,7 +497,7 @@ geometry cannot prove a complete chain or the provider aggregate's Fillet preced
 referential `DimensionIntent`. The handle never carries a replacement nominal and never chooses
 page coordinates. Use `format(decimals=n)` to preserve between 0 and 15 decimal places in the
 printed nominal while reconciliation, tolerance, suppression and provenance continue to read the
-numeric parameter from the feature. Optional `view="front|plan|side"` and
+numeric parameter from the feature. Optional `view="front|plan|side|rear"` and
 `side="above|below|left|right"` arguments select a supported semantic corridor when authored
 routing must override the derived default; the normal placement solve still chooses coordinates
 and reports capacity/crossing failures. Trailing zeroes are intentional manufacturing display text:

{draftwright-0.4.23 → draftwright-0.4.25}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.4.23"
+version = "0.4.25"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -22,7 +22,7 @@ dependencies = [
     # This novtk release lacks OCP.GccEnt on macOS. The exclusion must reach
     # published wheels, not only uv's development resolver constraints.
     "cadquery-ocp-novtk!=7.9.3.1.1 ; python_full_version >= '3.13'",
-    "build123d-drafting-helpers>=0.14.2",
+    "build123d-drafting-helpers>=0.15.1",
     "quiddity==0.2.6",
     "numpy>=1.24",
     # PNG raster export (SVG→PDF→PNG). Both permissively licensed (Pillow HPND; pypdfium2

{draftwright-0.4.23 → draftwright-0.4.25}/src/draftwright/_core.py

@@ -20,6 +20,7 @@ import re
 from bisect import bisect_left, bisect_right
 from collections.abc import Callable
 from dataclasses import dataclass
+from decimal import Decimal
 from pathlib import Path
 from types import SimpleNamespace
 from typing import TYPE_CHECKING, Literal
@@ -33,6 +34,7 @@ if TYPE_CHECKING:
 
 from build123d import (
     Align,
+    ArrowHead,
     BoundBox,
     Compound,
     Edge,
@@ -174,6 +176,24 @@ _TB_CLEAR = _MARGIN + 1.0  # title-block inset: one extra mm over _MARGIN for cl
 _FONT_SIZE = 3.0  # annotation text height (page-mm); the draft preset is built with this
 
 
+def _dimension_draft(text_position="inline", text_orientation="aligned"):
+    """One fixed typography preset, with helper-owned validation of text style."""
+    return draft_preset(
+        font_size=_FONT_SIZE,
+        decimal_precision=1,
+        font_path=PLEX_MONO,
+        text_position=text_position,
+        text_orientation=text_orientation,
+    )
+
+
+@functools.lru_cache(maxsize=128)
+def _dimension_head_bounds(arrow_length, head_type):
+    """Measure each fixed-size arrow style once, before candidate evaluation."""
+    box = ArrowHead(arrow_length, head_type=head_type, mode=Mode.PRIVATE).bounding_box()
+    return box.min.X, box.min.Y, box.max.X, box.max.Y
+
+
 _TB_H = 35.0
 
 
@@ -321,9 +341,9 @@ def _build_table(rows, draft, block_cols=None):
 
 def _tol_suffix(tolerance, draft) -> str:
     """The ``±`` / limit tolerance suffix to append to a **callout** label (a ø leader
-    or a hole callout), matching byte-for-byte what ``Dimension(tolerance=…)`` renders
-    on a linear dim (helpers ``_format_label``): a symmetric ``float`` → ``" ±t"``; an
-    ``(lower, upper)`` pair → ``" +upper -lower"`` — all rounded to the draft precision.
+    or a hole callout): a symmetric ``float`` → ``" ±t"``; an ``(lower, upper)`` pair
+    → ``" +upper -lower"``. Draft precision is a minimum; supplied tolerance
+    magnitudes must never be rounded into different engineering requirements.
 
     draftwright owns this suffix ONLY because the pinned helpers' ``Leader`` /
     ``HoleCallout`` take no ``tolerance=`` yet, so we bake it into the label string
@@ -336,11 +356,16 @@ def _tol_suffix(tolerance, draft) -> str:
         return ""
     if isinstance(tolerance, FitClass):
         return tolerance.suffix()
-    prec = draft.decimal_precision
+
+    def magnitude(value):
+        decimal = Decimal(str(value))
+        precision = max(draft.decimal_precision, -int(decimal.as_tuple().exponent))
+        return f"{decimal:.{precision}f}"
+
     if isinstance(tolerance, (int, float)):
-        return f" ±{round(tolerance, prec):.{prec}f}"
+        return f" ±{magnitude(tolerance)}"
     lo, hi = tolerance
-    return f" +{round(hi, prec):.{prec}f} -{round(lo, prec):.{prec}f}"
+    return f" +{magnitude(hi)} -{magnitude(lo)}"
 
 
 def _tag_sequence(n):
@@ -963,14 +988,14 @@ class DetailRequest:
 class _Projector:
     """Model → page coordinate projection for the orthographic views.
 
-    Each in-plane view axis projects as ``origin + (value - centroid) * scale``.
+    Each in-plane view axis projects from its centroid and page origin. Rear
+    reverses model X while keeping Z up, matching its camera from positive Y.
     Built once in :func:`_analyse` and hung off the analysis namespace as
     ``a.proj`` so the annotation passes share one projector instead of each
     re-deriving the ``FX``/``FZ``/``SX``/``SZ``/``PX``/``PY`` closures.
 
-    This deliberately mirrors those analysis-phase closures byte-for-byte (an
-    unsigned ``+1`` projection), so the consolidation is provably
-    behaviour-preserving. The helpers library's ``ViewCoordinates.px``/``.py``
+    The original three views retain their analysis-phase ``+1`` closures.
+    The helpers library's ``ViewCoordinates.px``/``.py``
     (already built per view as ``dwg._coords``) computes a *signed* projection
     from ``view_axes()``; routing through it would couple the annotation passes
     to render-order ``_coords`` population and could change output where a view
@@ -992,6 +1017,8 @@ class _Projector:
     cy: float
     cz: float
     scale: float
+    rv_x: float = 0.0
+    rv_y: float = 0.0
 
     def front_x(self, x: float) -> float:
         return self.fv_x + (x - self.cx) * self.scale
@@ -1011,6 +1038,12 @@ class _Projector:
     def plan_y(self, y: float) -> float:
         return self.pv_y + (y - self.cy) * self.scale
 
+    def rear_x(self, x: float) -> float:
+        return self.rv_x - (x - self.cx) * self.scale
+
+    def rear_z(self, z: float) -> float:
+        return self.rv_y + (z - self.cz) * self.scale
+
 
 @dataclass(frozen=True)
 class LayoutFrame:
@@ -1042,6 +1075,8 @@ class LayoutFrame:
     fv_zones: ViewZones
     pv_zones: ViewZones
     sv_zones: ViewZones
+    rear: tuple[float, float, float, float] | None = None
+    rv_zones: ViewZones | None = None
 
     def project(self, view: str, point) -> tuple[float, float]:
         """A part-space *point* in *view*'s page coordinates."""
@@ -1052,6 +1087,8 @@ class LayoutFrame:
             return self.proj.side_x(y), self.proj.side_z(z)
         if view == "plan":
             return self.proj.plan_x(x), self.proj.plan_y(y)
+        if view == "rear" and self.rear is not None:
+            return self.proj.rear_x(x), self.proj.rear_z(z)
         raise ValueError(f"unknown view {view!r}")
 
     def edges(self, view: str) -> tuple[float, float, float, float]:
@@ -1060,11 +1097,24 @@ class LayoutFrame:
         The stored endpoints come from projected world minima/maxima, whose handedness
         need not match page left/right. Normalise here so callers can rely on the names
         this API exposes rather than knowing projector orientation."""
-        x0, x1, y0, y1 = {"front": self.front, "plan": self.plan, "side": self.side}[view]
+        bounds = {"front": self.front, "plan": self.plan, "side": self.side, "rear": self.rear}[
+            view
+        ]
+        if bounds is None:
+            raise ValueError(f"view {view!r} has no planned layout frame")
+        x0, x1, y0, y1 = bounds
         return min(x0, x1), max(x0, x1), min(y0, y1), max(y0, y1)
 
     def zones(self, view: str) -> ViewZones:
-        return {"front": self.fv_zones, "plan": self.pv_zones, "side": self.sv_zones}[view]
+        zones = {
+            "front": self.fv_zones,
+            "plan": self.pv_zones,
+            "side": self.sv_zones,
+            "rear": self.rv_zones,
+        }[view]
+        if zones is None:
+            raise ValueError(f"view {view!r} has no planned annotation zones")
+        return zones
 
 
 def layout_frame(a: Analysis) -> LayoutFrame:
@@ -1099,6 +1149,15 @@ def layout_frame(a: Analysis) -> LayoutFrame:
         fv_zones=a.fv_zones,
         pv_zones=a.pv_zones,
         sv_zones=a.sv_zones,
+        rear=(
+            a.proj.rear_x(a.bb.min.X),
+            a.proj.rear_x(a.bb.max.X),
+            a.proj.rear_z(a.bb.min.Z),
+            a.proj.rear_z(a.bb.max.Z),
+        )
+        if a.rv_zones is not None
+        else None,
+        rv_zones=a.rv_zones,
     )
 
 
@@ -1210,6 +1269,9 @@ class Analysis:
     frame: bool = False
     # Projection-method symbol (#769): "third" / "first" (ISO 5456-2) or None (omit).
     projection: str | None = None
+    projection_convention: str = "third"
+    text_position: str = "inline"
+    text_orientation: str = "aligned"
     # Draw the ISO 5457 zone-grid border ruler (#768). Implies a frame (the ticks sit on it).
     zones: bool = False
     # The PartModel built by _analyse's pre-scale sizing pass (#584 WP1 A) — stored so
@@ -1260,6 +1322,9 @@ class Analysis:
     #: Coordinate-coherent PMI projection used by the compiler. ``None`` means the source
     #: report's records are already in working coordinates (raw and declared builds).
     pmi_working_records: tuple[object, ...] | None = None
+    RV_X: float = 0.0
+    RV_Y: float = 0.0
+    rv_zones: ViewZones | None = None
 
     @property
     def pmi(self) -> list:

{draftwright-0.4.23 → draftwright-0.4.25}/src/draftwright/_geometry.py

@@ -23,6 +23,9 @@ from quiddity import full_cylinders
 
 _log = logging.getLogger(__name__)
 
+# Ignore floating-point noise at rectangle boundaries, never visible overflow.
+BOUNDS_ROUNDOFF = 1e-9
+
 # Axis letter -> the orthographic view a feature on that axis reads end-on in: a z-hole is
 # a circle in plan, an x-channel is a cross-section in side.
 #

{draftwright-0.4.23 → draftwright-0.4.25}/src/draftwright/analysis.py

@@ -18,7 +18,6 @@ from dataclasses import dataclass, replace
 from typing import cast
 
 from build123d import Compound, Shape
-from build123d_drafting.helpers import draft_preset
 from OCP.IFSelect import IFSelect_ReturnStatus
 from OCP.STEPControl import STEPControl_Reader
 from quiddity import (
@@ -41,6 +40,7 @@ from draftwright._core import (
     _MIN_VIEW_MM,
     Analysis,
     _content_margin,
+    _dimension_draft,
     _legible_steps,
     _Projector,
 )
@@ -53,6 +53,7 @@ from draftwright._geometry import (
 )
 from draftwright.compose import (
     StripDepths,
+    _build_rear_zones,
     _build_zones,
     _est_hole_table_sizes,
     _est_planned_bore_callout_width,
@@ -71,7 +72,12 @@ from draftwright.recognition_frame import (
     require_unambiguous_groove_owner,
 )
 from draftwright.recognition_ownership import RecognitionOwnershipBuilder
-from draftwright.view_plan import ViewConstraints, arrangement_of
+from draftwright.view_plan import (
+    ViewConstraints,
+    arrangement_of,
+    principal_placements,
+    third_angle_view_names,
+)
 
 _log = logging.getLogger(__name__)
 
@@ -132,15 +138,18 @@ def _apply_principal_view_pins(
         "plan": (geometry.PV_X, geometry.PV_Y),
         "side": (geometry.SV_X, geometry.SV_Y),
     }
+    if "rear" in planned:
+        centres["rear"] = (geometry.RV_X, geometry.RV_Y)
     cx, cy, cz = centre
     projected_centre = {
         "front": (cx * scale, cz * scale),
         "plan": (cx * scale, cy * scale),
         "side": (cy * scale, cz * scale),
+        "rear": (-cx * scale, cz * scale),
     }
     translations = []
     for pin in constraints.pins:
-        if pin.view not in centres:
+        if pin.view not in projected_centre:
             where = f" at {pin.source}" if pin.source is not None else ""
             raise ValueError(
                 f"whole-view pin{where} targets {pin.view!r}; this slice can anchor principal "
@@ -159,7 +168,7 @@ def _apply_principal_view_pins(
         if max(abs(other_dx - dx), abs(other_dy - dy)) > 0.05:
             raise ValueError(
                 f"whole-view pins at {first.source} and {pin.source} contradict the fixed "
-                "third-angle relationships; they imply different group translations"
+                f"{geometry.convention}-angle relationships; they imply different group translations"
             )
 
     geometry.FV_X += dx
@@ -168,9 +177,13 @@ def _apply_principal_view_pins(
     geometry.PV_Y += dy
     geometry.SV_X += dx
     geometry.SV_Y += dy
+    if "rear" in planned:
+        geometry.RV_X += dx
+        geometry.RV_Y += dy
     geometry.sv_geometry_right += dx
     geometry.sv_right += dx
     geometry.sv_right_wall += dx
+    geometry.front_plan_wall += dy
     # Geometry bounds are the minimum pre-projection feasibility gate. Annotation bands use
     # the shifted anchors below and remain subject to the ordinary completeness/lint gates.
     extents = {
@@ -178,6 +191,8 @@ def _apply_principal_view_pins(
         "plan": (geometry.PV_X, geometry.PV_Y, geometry.fv_hw, geometry.pv_hh),
         "side": (geometry.SV_X, geometry.SV_Y, geometry.sv_hw, geometry.fv_hh),
     }
+    if "rear" in planned:
+        extents["rear"] = (geometry.RV_X, geometry.RV_Y, geometry.fv_hw, geometry.fv_hh)
     page_w, page_h = page
     for name in planned:
         x, y, hw, hh = extents[name]
@@ -680,6 +695,7 @@ def _validate_explicit_scale(
     views: tuple[str, ...] | None = None,
     include_iso: bool = True,
     iso_scale_factor: float | None = None,
+    convention: str = "third",
 ) -> None:
     """Enforce the two scale floors when the caller pinned an explicit *scale* (#489, #590 split
     of :func:`_analyse`). An explicit scale is the user's call — honour it, subject to:
@@ -719,6 +735,7 @@ def _validate_explicit_scale(
         views=views,
         include_iso=include_iso,
         iso_scale_factor=iso_scale_factor,
+        convention=convention,
     )
     # Warn only when omitting the scale would truly give a legible fit (auto scale itself is
     # legible) but the requested scale is below the floor. A part illegible at every
@@ -753,12 +770,15 @@ def _analyse(
     model=None,
     decorations=None,
     authored=None,
+    requested=None,
     material="",
     date="",
     revision="A",
     company="",
     frame: bool = False,
     projection: str | None = None,
+    text_position: str = "inline",
+    text_orientation: str = "aligned",
     zones: bool = False,
     _reuse: Analysis | None = None,
     _required_tables=(),
@@ -772,6 +792,7 @@ def _analyse(
 
     Returns an :class:`Analysis`.
     """
+    convention = projection or "third"
     # The zone-grid ruler (#768) draws its ticks on the frame, so it implies one.
     frame = frame or zones
     # The content margin — raised by the sheet-frame band (#767) so scale/page selection and
@@ -986,7 +1007,7 @@ def _analyse(
     # Construct the same draft preset used later in build_drawing() to read
     # arrow_length and pad_around_text from their authoritative source rather
     # than re-stating them as magic literals in the estimators.
-    _draft_est = draft_preset(font_size=_FONT_SIZE, decimal_precision=1)
+    _draft_est = _dimension_draft(text_position, text_orientation)
     _arrow_length = _draft_est.arrow_length
     _pad_around_text = _draft_est.pad_around_text
     # Empty on the declared path — NOT "this part has no holes", but "nothing was detected".
@@ -1078,21 +1099,23 @@ def _analyse(
         if ownership_builder is not None
         else None
     )
-    # Authored omission affects annotation FOOTPRINT sizing, but the analysis model retains
-    # its historical automatic requirement inventory for view-feasibility preflight.  The
-    # builder applies the same authored tuple to the render model later.  Keeping this as a
-    # strip-only copy avoids letting a sparse authored dimension set erase semantic view
-    # requirements (for example the parent view needed by an authored detail), while ensuring
-    # suppressed pad bands cannot reduce the selected scale (#1392).
-    strip_sizing_model = (
-        replace(sizing_model, authored_dimensions=tuple(authored))
+    # Dimension feasibility and annotation footprints consume the authored set.
+    # Derived-view dependencies still use sizing_model below; omitting an unrelated
+    # envelope extent must not force its view back onto an authored sheet.
+    strip_sizing_model = replace(
+        sizing_model,
+        authored_dimensions=tuple(authored)
         if authored is not None
-        else sizing_model
+        else sizing_model.authored_dimensions,
+        requested_dimensions=tuple(requested) if requested else sizing_model.requested_dimensions,
     )
     # ADR 2 (was 0018) Phase 5.5: prove the chosen principal set can carry every approved
     # dimension before scale selection or projection.  A reduced view set is therefore a
     # re-plan, not the fixed three-view plan rendered into fewer views.
-    sizing_groups = plan_dimensions(sizing_model, planned_views=_views)
+    sizing_groups = plan_dimensions(
+        strip_sizing_model,
+        planned_views=third_angle_view_names() if _views is None else _views,
+    )
     bore_callout_width = _est_planned_bore_callout_width(
         sizing_groups, _draft_est, font_size=_FONT_SIZE, pad_around_text=_pad_around_text
     )
@@ -1126,6 +1149,8 @@ def _analyse(
             arrow_length=_arrow_length,
             pad_around_text=_pad_around_text,
             bore_callout_width=bore_callout_width,
+            text_position=text_position,
+            text_orientation=text_orientation,
         )
 
     layout_advisories: list[tuple[str, str]] = []
@@ -1149,6 +1174,7 @@ def _analyse(
             views=_views,
             include_iso=_include_iso,
             iso_scale_factor=planned_iso_scale,
+            convention=convention,
         )
 
     scale_pick, strips_i, n_for_sizing = _converge_step_sizing(
@@ -1181,6 +1207,7 @@ def _analyse(
         views=_views,
         include_iso=_include_iso,
         iso_scale_factor=planned_iso_scale,
+        convention=convention,
     )
     DIM_PAD = _DIM_PAD
     # margin was computed up front (_content_margin(frame)) so scale selection already saw it.
@@ -1215,6 +1242,7 @@ def _analyse(
         views=_views,
         include_iso=_include_iso,
         iso_scale_factor=planned_iso_scale,
+        convention=convention,
     )
     _apply_principal_view_pins(
         _g,
@@ -1225,6 +1253,13 @@ def _analyse(
         margin=margin,
         views=_views,
     )
+    if isinstance(_view_constraints, ViewConstraints):
+        places = principal_placements(_g)
+        for relation in _view_constraints.relations:
+            if relation.subject in _g.planned_views and relation.reference in _g.planned_views:
+                relation.validate(
+                    places[relation.subject].bounds, places[relation.reference].bounds
+                )
     fv_hw = _g.fv_hw
     fv_hh = _g.fv_hh
     pv_hh = _g.pv_hh
@@ -1275,6 +1310,9 @@ def _analyse(
         arrangement=ARRANGEMENT,
         planned_views=_views,
         planned_iso=_include_iso,
+        RV_X=_g.RV_X,
+        RV_Y=_g.RV_Y,
+        rv_zones=_build_rear_zones(_g, margin, PAGE_H),
         planned_iso_scale=planned_iso_scale,
         view_constraints=_view_constraints,
         part=part,
@@ -1336,6 +1374,8 @@ def _analyse(
             sv_y=SV_Y,
             pv_x=PV_X,
             pv_y=PV_Y,
+            rv_x=_g.RV_X,
+            rv_y=_g.RV_Y,
             cx=cx,
             cy=cy,
             cz=cz,
@@ -1366,6 +1406,9 @@ def _analyse(
         company=company,
         frame=frame,
         projection=projection,
+        text_position=text_position,
+        text_orientation=text_orientation,
+        projection_convention=convention,
         zones=zones,
         out=out,
         pmi_report=pmi_report,