draftwright 0.2.9__tar.gz → 0.2.11__tar.gz

{draftwright-0.2.9 → draftwright-0.2.11}/CHANGELOG.md

@@ -1,5 +1,76 @@
 # Changelog
 
+## v0.2.11 — 2026-07-08
+
+**Automatic layout now has one authority.** Page/scale selection, section placement,
+furniture footprints, and table/balloon escalation now negotiate through the same layout
+fitness model instead of using separate fixed offsets or first-fit policies after the main
+solve.
+
+### Fixed
+
+- **Solver placement paths are more consistent.** STEP PMI dimensions now queue into
+  the shared ADR 0009 corridor solve instead of carving after the drain; front-view
+  hole callouts use the strip solver instead of fixed row stepping; pitch-dimension
+  fallback searches bounded, obstacle-aware positions; repair no longer hides
+  `annotation_overlap` with a fixed-step nudge; and step-count sizing now handles
+  non-convergence conservatively. (#524)
+- **Page/scale fitness is shared across initial selection and repack.** Later layout
+  passes now compare candidates with the same model as the page chooser, preventing a
+  nominally "better" repack from invalidating the original layout decision. (#519)
+- **Section A-A participates in layout selection.** Section placement is measured as
+  part of page/scale fitness, so a section view is no longer a fixed-offset afterthought
+  that can disappear on dense sheets. (#515)
+- **Furniture placement reserves full rendered footprints.** Section arrows, detail
+  views, balloons, hole/data tables, and other furniture now reserve/check their true
+  rendered footprint instead of just their labels. (#518)
+- **Hole/data tables and balloon rings escalate through the layout model.** Dense table
+  and balloon outputs can move or negotiate for available room rather than dropping from
+  greedy first-fit placement when a small adjustment would fit. (#516, #517)
+
+## v0.2.10 — 2026-07-07
+
+**Declarative-surface fidelity and layout-engine unification.** Editing and re-running a
+declarative `Sheet` script now reproduces more of the drawing (title block, layout, PMI on the
+declared path), a new lint catches stale declarations, and an intentional scale is respected.
+Internally the annotation placer moves further onto the single collect-then-solve (ADR 0009),
+and `kiwisolver` is dropped as a dependency.
+
+### Added
+
+- **Declaration-vs-geometry reconciliation lint** — `lint()` now flags a declared cylindrical
+  feature (hole/boss/step) with **no matching geometry** in the part (`declared_feature_absent`):
+  a callout drawn over empty space because the part was edited but the declaration went stale.
+  Closes the last gap in the "did my edit break the drawing?" loop (over-declaration; coverage
+  lint already caught under-declaration). Matches on axis + ⌀ + in-plane position + bore/boss
+  polarity. Gated on a caller-supplied `model=` (detection can't over-declare). (#487)
+- **Title-block + layout aspects on the `Sheet` DSL** — `Sheet(drawn_by=…, tolerance=…, scale=…,
+  page=…)`; the generated `--script` reproduces them, and the CLI forwards
+  `--drawn-by`/`--tolerance`/`--scale`/`--page` on the sheet path (no more inert-flag warning). (#474)
+- **PMI reproduced on the declared-model path** — `build_drawing(path, model=…, pmi="annotate")`
+  synthesises the STEP AP242 PMI into the declared model, so a declared build draws the same PMI
+  dimensions as the detection path. (#472)
+
+### Changed
+
+- **An intentional explicit `scale=` below the legibility floor is honoured with a warning**
+  rather than rejected. A part deliberately drawn at 1:1 (or `Sheet(scale="1:10")`) whose smallest
+  feature falls under the 10 mm legibility floor now renders (annotations may crowd) instead of
+  raising `ValueError`; only a genuinely degenerate scale (< 0.1 mm projected, where OCCT arcs
+  collapse) is rejected. The floor now binds only the *automatic* scale. (#489)
+- **`kiwisolver` is no longer a dependency.** The 1-D strip solve delegates to the built-in
+  deterministic minimum-total-leader-length PAVA algorithm, which supersedes the Cassowary
+  solver — same placement contract, one fewer third-party dependency. (#507)
+
+### Fixed
+
+- **Dimension placement is more robust under contention.** Candidate **priority** is plumbed
+  through the shared corridor solve, so an authored GD&T frame is kept over a lower-value
+  automatic dimension when a strip is over capacity (#357). Rotational concentric-bore leaders
+  are now bounded to the front-view height with ranked drops, and pitch dimensions are placed
+  onto the obstacle-aware per-side zone-strip solve — retiring the last fixed-offset,
+  count-based stacking placers (the shape behind earlier dense-sheet overruns). (#374)
+
 ## v0.2.9 — 2026-07-06
 
 **Declarative GD&T, datums, and surface finish (ADR 0011 Phase 2b/2c).** The `Sheet` DSL can

{draftwright-0.2.9 → draftwright-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.2.9
+Version: 0.2.11
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright
@@ -685,7 +685,6 @@ Requires-Python: <3.15,>=3.10
 Requires-Dist: build123d-drafting-helpers>=0.13.0
 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: kiwisolver<2,>=1.4
 Requires-Dist: numpy>=1.24
 Requires-Dist: reportlab>=4.0
 Requires-Dist: svglib>=1.5
@@ -786,7 +785,7 @@ bore = Pos(0, 0, 0) * Cylinder(4, 20)
 sheet = Sheet(plate - bore, title="Plate", number="DWG-002")
 sheet.envelope()
 sheet.datum("A", plate.faces().sort_by()[-1])             # datum A on the top face
-hole = sheet.hole(bore).finish("1.6")                     # ⌀8 bore, Ra 1.6
+hole = sheet.hole(bore).finish("1.6").note("M3x0.5 TAP")  # ⌀8 bore, Ra 1.6, tapped
 sheet.control(hole).position(0.1, to="A", diameter=True)  # ⌀0.1 position wrt A
 sheet.export("plate")                                     # writes plate.svg + plate.dxf
 ```
@@ -794,7 +793,8 @@ sheet.export("plate")                                     # writes plate.svg + p
 Every aspect the geometry can't carry is a declared verb: `.tolerance(±)` / `.fit("H7")`
 (ISO 286), `.finish("Ra")` (ISO 1302), `sheet.datum(letter, ref)` (ISO 5459), and
 `sheet.control(ref)` with all 14 ISO 1101 characteristics
-(`.position`/`.flatness`/`.perpendicularity`/`.circular_runout`/…). A feature verb returns
+(`.position`/`.flatness`/`.perpendicularity`/`.circular_runout`/…), plus `sheet.note(text, ref)`
+/ `.note(text)` for free-text shop callouts (thread specs, `DEBURR`, knurl). A feature verb returns
 a chainable handle (`sheet.hole(bore)`) that the aspect and `control(...)` verbs decorate;
 targets are placed automatically — the view and strip are derived from the referenced
 feature or face, with `view=`/`side=` overrides.

{draftwright-0.2.9 → draftwright-0.2.11}/README.md

@@ -92,7 +92,7 @@ bore = Pos(0, 0, 0) * Cylinder(4, 20)
 sheet = Sheet(plate - bore, title="Plate", number="DWG-002")
 sheet.envelope()
 sheet.datum("A", plate.faces().sort_by()[-1])             # datum A on the top face
-hole = sheet.hole(bore).finish("1.6")                     # ⌀8 bore, Ra 1.6
+hole = sheet.hole(bore).finish("1.6").note("M3x0.5 TAP")  # ⌀8 bore, Ra 1.6, tapped
 sheet.control(hole).position(0.1, to="A", diameter=True)  # ⌀0.1 position wrt A
 sheet.export("plate")                                     # writes plate.svg + plate.dxf
 ```
@@ -100,7 +100,8 @@ sheet.export("plate")                                     # writes plate.svg + p
 Every aspect the geometry can't carry is a declared verb: `.tolerance(±)` / `.fit("H7")`
 (ISO 286), `.finish("Ra")` (ISO 1302), `sheet.datum(letter, ref)` (ISO 5459), and
 `sheet.control(ref)` with all 14 ISO 1101 characteristics
-(`.position`/`.flatness`/`.perpendicularity`/`.circular_runout`/…). A feature verb returns
+(`.position`/`.flatness`/`.perpendicularity`/`.circular_runout`/…), plus `sheet.note(text, ref)`
+/ `.note(text)` for free-text shop callouts (thread specs, `DEBURR`, knurl). A feature verb returns
 a chainable handle (`sheet.hole(bore)`) that the aspect and `control(...)` verbs decorate;
 targets are placed automatically — the view and strip are derived from the referenced
 feature or face, with `view=`/`side=` overrides.

{draftwright-0.2.9 → draftwright-0.2.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.2.9"
+version = "0.2.11"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -18,7 +18,6 @@ dependencies = [
     "build123d>=0.9.0,<0.11 ; python_full_version < '3.13'",
     "build123d>=0.11,<0.12 ; python_full_version >= '3.13'",
     "build123d-drafting-helpers>=0.13.0",
-    "kiwisolver>=1.4,<2",
     "numpy>=1.24",
     "reportlab>=4.0",
     "svglib>=1.5",

{draftwright-0.2.9 → draftwright-0.2.11}/src/draftwright/_core.py

@@ -21,6 +21,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from draftwright.recognition import TurnedProfile
+    from draftwright.sheet import StripDepths
 
 from build123d import Align, BoundBox, Location, Mode, Shape, Text
 from build123d_drafting.helpers import (
@@ -255,10 +256,21 @@ _SLOT_DIM_HEIGHT = 2 * _FONT_SIZE + 2 * _PAD  # fv_zones.right: overall height d
 
 
 _MIN_VIEW_MM = (
-    10.0  # min projected view dimension; below it annotation geometry degenerates (#129)
+    10.0  # legibility floor: the projected size below which an *explicit* scale earns a warning.
+    # It is NOT a bound on the auto scale (choose_scale is a pure geometric page fit) and does NOT
+    # gate which annotations exist (step/location legibility use _MIN_STEP_*/_MIN_LOC_SEP_MM). Its
+    # only use is the explicit-scale advisory in analysis.py: below it a user scale is honoured
+    # with a warning, not rejected (#489).
 )
 
 
+# Hard geometry floor: below this projected size OCCT's annotation arcs collapse
+# (Geom_TrimmedCurve U1==U2), which happens near 1e-4 mm empirically — 0.1 mm is a conservative
+# floor far above that and far below any real drawing. An explicit scale under it is rejected with
+# a clean message rather than a cryptic OCP error (#489).
+_MIN_RENDER_MM = 0.1
+
+
 _SLOT_DIM_STEP = 4 * _FONT_SIZE + _PAD  # fv_zones.right: step-height dimension
 
 
@@ -327,7 +339,7 @@ def _legible_locations(positions, scale):
     return kept, n_too_close
 
 
-def _largest_empty_rect(drawable, obstacles):
+def _largest_empty_rect(drawable, obstacles, *, warn: bool = True):
     """Largest axis-aligned empty rectangle in *drawable* avoiding *obstacles*.
 
     *drawable* and each obstacle are ``(x0, y0, x1, y1)`` page-mm boxes.  Returns
@@ -365,10 +377,11 @@ def _largest_empty_rect(drawable, obstacles):
         # is unreachable in practice — choose_scale always leaves a gap — but
         # if it ever happens the iso would render over the other views, so flag
         # it rather than fail silently.
-        _log.warning(
-            "No empty rectangle found for the iso view; obstacles fill the "
-            "drawable area — iso may overlap other views"
-        )
+        if warn:
+            _log.warning(
+                "No empty rectangle found for the iso view; obstacles fill the "
+                "drawable area — iso may overlap other views"
+            )
         return drawable
     return best
 
@@ -503,6 +516,10 @@ class Analysis:
     is_rotational: bool
     od_axis: str  # rotation/turning axis of a rotational part ("z" default; "x"/"y" #222)
     step_zs: list[float]
+    layout_strips: StripDepths
+    layout_n_steps: int
+    layout_section: bool
+    layout_table_sizes: tuple[tuple[float, float], ...]
     sv_right: float
     iso_right_limit: float
     SCALE: float

{draftwright-0.2.9 → draftwright-0.2.11}/src/draftwright/analysis.py

@@ -12,6 +12,8 @@ from __future__ import annotations
 
 import logging
 import math
+import warnings
+from collections.abc import Callable
 
 from build123d import Compound, Shape
 from build123d_drafting.helpers import draft_preset
@@ -19,9 +21,11 @@ from OCP.IFSelect import IFSelect_ReturnStatus
 from OCP.STEPControl import STEPControl_Reader
 
 from draftwright._core import (
+    _CONCENTRIC_TOL_MM,
     _DIM_PAD,
     _FONT_SIZE,
     _MARGIN,
+    _MIN_RENDER_MM,
     _MIN_VIEW_MM,
     Analysis,
     _legible_steps,
@@ -38,9 +42,12 @@ from draftwright.recognition import (
     full_cylinders,
 )
 from draftwright.sheet import (
+    StripDepths,
     _build_zones,
+    _est_hole_table_sizes,
     _layout_geometry,
     _measure_strips,
+    _will_section,
     choose_scale,
 )
 
@@ -52,6 +59,41 @@ _log = logging.getLogger(__name__)
 _SQUARENESS_TOL = 0.05
 _OD_FILL_MIN = 0.8
 _OD_AXIS_TOL = 0.05
+_ScalePick = tuple[float, float, float, float]
+
+
+def _declared_will_section(model, *, is_rotational=False, cx=0.0, cy=0.0) -> bool:
+    """True when a caller-supplied IR model contains a section-driving Z hole.
+
+    Detection-based layout uses recogniser holes; declared-model builds may
+    intentionally supply features detection missed. Inspect the public IR shape
+    duck-typed here so declared sections get the same page/scale reservation.
+    """
+
+    if model is None:
+        return False
+    features = getattr(model, "features", model)
+
+    def feature_member(pt) -> bool:
+        return not (is_rotational and math.hypot(pt[0] - cx, pt[1] - cy) <= _CONCENTRIC_TOL_MM)
+
+    for feat in features:
+        if getattr(feat, "kind", None) not in ("hole", "pattern"):
+            continue
+        frame = getattr(feat, "frame", None)
+        if frame is None or frame.axis != "z":
+            continue
+        members = getattr(feat, "members", ()) or (frame.origin,)
+        if not any(feature_member(m) for m in members):
+            continue
+        bore = getattr(feat, "member", feat)
+        if (
+            getattr(bore, "cbore", None) is not None
+            or getattr(bore, "spotface", None) is not None
+            or not getattr(bore, "through", True)
+        ):
+            return True
+    return False
 
 
 def _import_step(path) -> Compound:
@@ -104,6 +146,53 @@ def _is_rotational(x_size, y_size, od_diam, od_axis_offset) -> bool:
     )
 
 
+def _converge_step_sizing(
+    initial_steps: int,
+    measure_strips: Callable[[int], StripDepths],
+    pick_scale: Callable[[int, StripDepths], _ScalePick],
+    count_legible: Callable[[float], int],
+) -> tuple[_ScalePick, StripDepths, int]:
+    """Choose scale/page with a step-corridor count that matches legibility.
+
+    The right-side step ladder is reserved before the scale is known, but the
+    actual step list is filtered by the chosen scale. Iterate that dependency
+    until it reaches a fixed point; if it cycles, reserve the largest count seen
+    so the sheet is sized conservatively instead of silently accepting whichever
+    value happened to appear on a fixed iteration budget (#520).
+    """
+    n_for_sizing = initial_steps
+    seen: set[int] = set()
+    attempted: list[int] = []
+    max_iter = max(4, initial_steps + 2)
+
+    for _ in range(max_iter):
+        if n_for_sizing in seen:
+            break
+        seen.add(n_for_sizing)
+        attempted.append(n_for_sizing)
+
+        strips = measure_strips(n_for_sizing)
+        scale_pick = pick_scale(n_for_sizing, strips)
+        n_next = count_legible(scale_pick[0])
+        if n_next == n_for_sizing:
+            return scale_pick, strips, n_for_sizing
+        if n_next in seen:
+            n_for_sizing = n_next
+            break
+        n_for_sizing = n_next
+
+    conservative_n = max(attempted + [n_for_sizing], default=initial_steps)
+    strips = measure_strips(conservative_n)
+    scale_pick = pick_scale(conservative_n, strips)
+    _log.warning(
+        "Step-corridor sizing did not converge from %d steps (tried %s); reserving %d steps",
+        initial_steps,
+        attempted,
+        conservative_n,
+    )
+    return scale_pick, strips, conservative_n
+
+
 # A hole is "concentric" with a turned part's rotation axis when its drilling
 # axis is the Z (OD) axis and its opening sits on the part centreline.  Such
 # bores are already dimensioned by the ldr_z bore leaders, so they must not
@@ -200,7 +289,16 @@ def _solids_body(part, src: str = "part"):
 
 
 def _analyse(
-    step_file, title, number, tolerance, drawn_by, out, scale=None, page=None, pmi="off"
+    step_file,
+    title,
+    number,
+    tolerance,
+    drawn_by,
+    out,
+    scale=None,
+    page=None,
+    pmi="off",
+    model=None,
 ) -> Analysis:
     """Load STEP or use a build123d Shape, analyse geometry, compute layout.
 
@@ -315,6 +413,20 @@ def _analyse(
     patterns = find_hole_patterns(holes)
     bosses = find_bosses(part, cyls=(z_cyls, cross_cyls))  # detect once — the one inventory (#264)
     slots = find_slots(part)
+    layout_section = _will_section(
+        holes,
+        patterns,
+        is_rotational=is_rotational,
+        cx=cx,
+        cy=cy,
+    ) or _declared_will_section(model, is_rotational=is_rotational, cx=cx, cy=cy)
+    layout_table_sizes = _est_hole_table_sizes(
+        holes,
+        patterns,
+        bb,
+        font_size=_FONT_SIZE,
+        pad_around_text=_pad_around_text,
+    )
 
     # Choose scale/page, iterating so the reserved step corridor matches the
     # number of steps the legibility gate will actually place (#1) — not the raw
@@ -322,40 +434,79 @@ def _analyse(
     # with 15 tiny treads) reserves a phantom step ladder that blocks a larger
     # scale. Seed conservatively (all faces), then re-gate at the chosen scale;
     # converges in a couple of rounds.
-    n_for_sizing = len(step_zs)
-    strips_i = None
-    for _ in range(3):
-        strips_i = _measure_strips(
+    def _measure_for_step_count(n_steps_i: int) -> StripDepths:
+        return _measure_strips(
             holes,
             patterns,
-            n_for_sizing,
+            n_steps_i,
             bb,
             arrow_length=_arrow_length,
             pad_around_text=_pad_around_text,
         )
-        SCALE, PAGE_W, PAGE_H, TB_W = choose_scale(
-            x_size, y_size, z_size, n_steps=n_for_sizing, scale=scale, page=page, strips=strips_i
+
+    def _pick_for_step_count(n_steps_i: int, strips_i: StripDepths) -> _ScalePick:
+        return choose_scale(
+            x_size,
+            y_size,
+            z_size,
+            n_steps=n_steps_i,
+            scale=scale,
+            page=page,
+            strips=strips_i,
+            section=layout_section,
+            table_sizes=layout_table_sizes,
         )
-        n_next = len(_legible_steps(step_zs, bb.min.Z, SCALE)[0])
-        if n_next == n_for_sizing:
-            break
-        n_for_sizing = n_next
+
+    (SCALE, PAGE_W, PAGE_H, TB_W), strips_i, n_for_sizing = _converge_step_sizing(
+        len(step_zs),
+        _measure_for_step_count,
+        _pick_for_step_count,
+        lambda scale_i: len(_legible_steps(step_zs, bb.min.Z, scale_i)[0]),
+    )
     if scale is not None:
+        # An explicit scale is the user's call — honour it (#489). Two floors apply:
+        #  - _MIN_RENDER_MM: a hard geometry limit; below it OCCT's annotation arcs degenerate
+        #    (Geom_TrimmedCurve U1==U2, ~1e-4 mm empirically — 0.1 mm is a conservative floor).
+        #    Reject with a clean message; there is no meaningful drawing this small anyway.
+        #  - _MIN_VIEW_MM: a legibility floor; below it annotations crowd but the drawing is
+        #    valid, so honour the scale with a warning. This floor does NOT bound the auto scale
+        #    (choose_scale is a pure geometric page fit), so a warning is only useful when a
+        #    legible page-fitting scale actually exists — i.e. the auto scale is itself legible.
+        min_dim = min(x_size, y_size, z_size)
+        min_view = min_dim * SCALE
+        if min_view < _MIN_RENDER_MM:
+            safe = _MIN_RENDER_MM / min_dim
+            raise ValueError(
+                f"scale {SCALE!r} projects the smallest part dimension "
+                f"({min_dim:.0f} mm) to {min_view:.3g} mm — the drawing geometry degenerates "
+                f"below {_MIN_RENDER_MM:g} mm (OCCT arc construction fails). "
+                f"Use scale ≥ {safe:.3g} or omit the scale for automatic selection."
+            )
         auto_scale, _, _, _ = choose_scale(
-            x_size, y_size, z_size, n_steps=n_for_sizing, scale=None, page=page, strips=strips_i
+            x_size,
+            y_size,
+            z_size,
+            n_steps=n_for_sizing,
+            scale=None,
+            page=page,
+            strips=strips_i,
+            section=layout_section,
+            table_sizes=layout_table_sizes,
         )
-        if SCALE < auto_scale:
-            min_dim = min(x_size, y_size, z_size)
-            min_view = min_dim * SCALE
-            if min_view < _MIN_VIEW_MM:
-                safe = _MIN_VIEW_MM / min_dim
-                raise ValueError(
-                    f"scale {SCALE!r} projects the smallest part dimension "
-                    f"({min_dim:.0f} mm) to {min_view:.1f} mm — "
-                    f"annotation geometry degenerates below {_MIN_VIEW_MM:.0f} mm "
-                    f"(OCCT Standard_DomainError / SIGABRT). "
-                    f"Use scale ≥ {safe:.3g} or omit --scale for automatic selection."
-                )
+        # 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
+        # page-fitting scale can't be helped by a bigger one, so nagging there would be false.
+        if min_view < _MIN_VIEW_MM <= auto_scale * min_dim:
+            safe = _MIN_VIEW_MM / min_dim
+            # No stacklevel that reaches user code: this fires deep in _analyse, and the public
+            # entry points (make_drawing, Sheet.export, build_drawing) sit at different depths.
+            # The message is self-contained (names the scale, the projection, and the fix).
+            warnings.warn(
+                f"scale {SCALE!r} projects the smallest part dimension ({min_dim:.0f} mm) to "
+                f"{min_view:.1f} mm, below the {_MIN_VIEW_MM:.0f} mm legibility floor — "
+                f"annotations may crowd or overlap. Honouring the requested scale; use "
+                f"scale ≥ {safe:.3g} or omit the scale for an automatic legible fit."
+            )
     DIM_PAD = _DIM_PAD
     margin = _MARGIN
     # Refine: apply the same legibility gate _auto_annotate uses for dim_step.
@@ -371,7 +522,19 @@ def _analyse(
     # View positions + iso empty-rectangle, shared with scale selection (_fits)
     # via _layout_geometry so placement and fit never diverge (#11).  _fit_iso_view
     # later scales the iso to fill its rectangle.
-    _g = _layout_geometry(x_size, y_size, z_size, SCALE, PAGE_W, PAGE_H, TB_W, strips, n_steps)
+    _g = _layout_geometry(
+        x_size,
+        y_size,
+        z_size,
+        SCALE,
+        PAGE_W,
+        PAGE_H,
+        TB_W,
+        strips,
+        n_steps,
+        section=layout_section,
+        table_sizes=layout_table_sizes,
+    )
     fv_hw = _g.fv_hw
     fv_hh = _g.fv_hh
     pv_hh = _g.pv_hh
@@ -439,6 +602,10 @@ def _analyse(
         is_rotational=is_rotational,
         od_axis=od_axis,
         step_zs=step_zs,
+        layout_strips=strips,
+        layout_n_steps=n_steps,
+        layout_section=layout_section,
+        layout_table_sizes=layout_table_sizes,
         sv_right=sv_right,
         iso_right_limit=iso_right_limit,
         SCALE=SCALE,