visualdynamics 0.1.0a67__tar.gz → 0.1.0a68__tar.gz

{visualdynamics-0.1.0a67/src/visualdynamics.egg-info → visualdynamics-0.1.0a68}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: visualdynamics
-Version: 0.1.0a67
+Version: 0.1.0a68
 Summary: Structural Dynamics Visualization: a units-aware structural dynamics analysis toolset
 Author-email: Brandon Zwink <bzwink@gmail.com>
 License-Expression: MIT
@@ -32,6 +32,7 @@ Requires-Dist: pyvista
 Requires-Dist: pyvistaqt
 Requires-Dist: vtk
 Requires-Dist: PySide6
+Requires-Dist: shiboken6
 Requires-Dist: pyqtgraph
 Requires-Dist: openpyxl
 Requires-Dist: pandas

{visualdynamics-0.1.0a67 → visualdynamics-0.1.0a68}/pyproject.toml

@@ -79,6 +79,10 @@ dependencies = [
     # pyvista's own cap is what decides which VTK is installed.
     "vtk",
     "PySide6",
+    # PySide6's own binding layer (LGPL-3.0, the same terms), installed
+    # with it: imported by name for the exit's window release
+    # (gui.release_widgets), so declared rather than relied on arriving
+    "shiboken6",
     "pyqtgraph",
     "openpyxl",
     # A channel table is a spreadsheet, and a DataFrame is what carries a

{visualdynamics-0.1.0a67 → visualdynamics-0.1.0a68}/src/visualdynamics/__init__.py

@@ -97,7 +97,7 @@ from .units import (
 #: alpha, said in the version itself so the dialog, the About text, the
 #: installers and latest.json all say the same thing, and the first
 #: non-alpha release is offered as an upgrade (Brandon, 2026-09-11)
-__version__ = '0.1.0a67'
+__version__ = '0.1.0a68'
 
 
 def launch_gui(*paths: str, in_process: bool | None = None) -> Any:

{visualdynamics-0.1.0a67 → visualdynamics-0.1.0a68}/src/visualdynamics/core/instrumentation.py

@@ -23,7 +23,10 @@ surface allows. A node where surfaces meet at an edge or a corner is a
 candidate on each of them, so that a sensor sits flat on one; within a
 surface the faces' normals at the node are averaged. A plate's normal
 points away from the middle of the model. Beams contribute every node,
-measured in the global system.
+measured in the global system. A place nearer than `edge_distance` to
+its surface's edge is not a candidate, since a sensor's base needs flat
+ground around the spot it is glued to; an edge here is wherever the
+surface ends, at a sharp edge, a free edge, a hole or where parts touch.
 
 `local_shapes` turns a shape set's translations into each candidate's
 own directions, and `effective_independence` chooses the sensors:
@@ -52,7 +55,16 @@ import numpy as np
 #: neighboring faces whose outward normals differ by more than this, in
 #: degrees, are on separate surfaces: a block's edge is 90, a
 #: cylinder's facets a few degrees each
-EDGE_ANGLE = 40.0
+# Brandon, 2026-10-22: 20 degrees, from 40
+EDGE_ANGLE = 20.0
+
+#: how far a sensor stays from its surface's edge, in meters: a quarter
+#: of an inch (Brandon, 2026-10-22)
+EDGE_DISTANCE = 0.25 * 0.0254
+
+#: a surface of less than this share of the whole outside's area is
+#: left out unless picked (`default_surfaces`)
+SMALL_SURFACE = 0.01
 
 #: removal in batches stops once this many times the wanted count
 #: remain, and the rest is removed one at a time
@@ -231,8 +243,35 @@ def skin(geometry: Any, *, edge_angle: float = EDGE_ANGLE) -> list[Surface]:
     return found
 
 
+def default_surfaces(found: list[Surface]) -> list[int]:
+    """The surfaces sensors go on unless told otherwise: every one of at
+    least `SMALL_SURFACE` of the whole outside's area. Sensors go on
+    the significant surfaces of a test article; a small one is most
+    often a sliver along an edge, a fillet or a hole's bore. When no
+    surface is that large, all of them.
+
+    Parameters
+    ----------
+    found : list of Surface
+        From `skin`.
+
+    Returns
+    -------
+    list of int
+        Their ids, in order.
+    """
+    # Brandon, 2026-10-22: at 20 degrees the cone split into 193
+    # surfaces, most of them a single element; "any surfaces less than
+    # 1% of the total surface area should be de-selected by default ...
+    # we just mount to significant surfaces usually"
+    total = sum(s.area for s in found)
+    kept = [s.id for s in found if s.area >= SMALL_SURFACE * total]
+    return kept or [s.id for s in found]
+
+
 def candidates(geometry: Any, groups: Any = None, surfaces: Any = None, *,
-               edge_angle: float = EDGE_ANGLE, found: Any = None) -> Candidates:
+               edge_angle: float = EDGE_ANGLE, found: Any = None,
+               edge_distance: float = 0.0) -> Candidates:
     """Every place on `geometry` a sensor can be mounted, as an
     experimental geometry with a coordinate system per place.
 
@@ -244,13 +283,19 @@ def candidates(geometry: Any, groups: Any = None, surfaces: Any = None, *,
         The element groups sensors may go on. All of them when omitted.
         A face shared with a group that is not picked is still inside.
     surfaces : sequence of int, optional
-        The surfaces sensors may go on, by `Surface.id`. All of those in
-        `groups` when omitted.
+        The surfaces sensors may go on, by `Surface.id`. Those of
+        `groups` that `default_surfaces` keeps when omitted: every one
+        of at least `SMALL_SURFACE` of the outside's area.
     edge_angle : float, default EDGE_ANGLE
         Degrees between two neighboring faces' normals beyond which they
         are on separate surfaces.
     found : list of Surface, optional
         `skin(geometry, edge_angle=edge_angle)`, when already found.
+    edge_distance : float, default 0
+        How near a place may be to its surface's edge, in the
+        geometry's coordinates (meters once its units are defined),
+        measured in a straight line. Nothing is left out at 0. A
+        surface with no edge, such as a whole sphere, keeps every place.
 
     Returns
     -------
@@ -260,11 +305,12 @@ def candidates(geometry: Any, groups: Any = None, surfaces: Any = None, *,
 
     picked = ({int(g) for g in geometry.group_id} if groups is None
               else {int(g) for g in groups})
-    wanted = None if surfaces is None else {int(s) for s in surfaces}
     xyz = geometry.node_xyz
     row_of = {int(n): k for k, n in enumerate(geometry.node_id)}
+    by_id = np.argsort(geometry.node_id)
     if found is None:
         found = skin(geometry, edge_angle=edge_angle)
+    wanted = set(default_surfaces(found) if surfaces is None else (int(s) for s in surfaces))
 
     # a place per node per surface, the surface's faces at the node
     # averaged by area; the largest first, so a node's own id goes to it
@@ -278,6 +324,11 @@ def candidates(geometry: Any, groups: Any = None, surfaces: Any = None, *,
         at, where = np.unique(corner_nodes, return_inverse=True)
         summed = np.zeros((len(at), 3))
         np.add.at(summed, where, np.repeat(weight, per_face, axis=0))
+        if edge_distance > 0:
+            rows = by_id[np.searchsorted(geometry.node_id, at, sorter=by_id)]
+            away = _away_from_edge(surface.faces, at, xyz[rows], xyz, by_id,
+                                   geometry.node_id, edge_distance)
+            at, summed = at[away], summed[away]
         nodes.append(at)
         sums.append(summed)
         kinds.extend([surface.kind] * len(at))
@@ -623,7 +674,8 @@ class Plan:
 
 def plan(shapes: Any, geometry: Any, triaxial: int, uniaxial: int = 0, *,
          modes: Any = None, groups: Any = None, surfaces: Any = None,
-         edge_angle: float | None = None, axes: Any = (2,)) -> Plan:
+         edge_angle: float | None = None, axes: Any = (2,),
+         edge_distance: float | None = None) -> Plan:
     """Plan a test's accelerometers from a finite element model.
 
     Parameters
@@ -642,14 +694,20 @@ def plan(shapes: Any, geometry: Any, triaxial: int, uniaxial: int = 0, *,
     groups : sequence of int, optional
         The element groups sensors may go on. All when omitted.
     surfaces : sequence of int, optional
-        The surfaces sensors may go on, by `Surface.id`. All of those in
-        `groups` when omitted.
+        The surfaces sensors may go on, by `Surface.id`. Those of
+        `groups` that `default_surfaces` keeps when omitted.
     edge_angle : float, optional
         Degrees between neighboring faces' normals beyond which they are
         on separate surfaces; `EDGE_ANGLE` when omitted.
     axes : sequence of int, default (2,)
         The directions a uni-axial accelerometer may measure: 0, 1, 2
         for a place's X, Y, Z. Z, the surface normal, by default.
+    edge_distance : float, optional
+        How near a sensor may be to its surface's edge, in the
+        geometry's coordinates. `EDGE_DISTANCE`, a quarter of an inch,
+        when omitted and the geometry's units are defined; 0 when they
+        are not, since a distance means nothing against coordinates
+        with no unit.
 
     Returns
     -------
@@ -665,8 +723,11 @@ def plan(shapes: Any, geometry: Any, triaxial: int, uniaxial: int = 0, *,
     modes = [int(m) for m in modes]
     if not modes:
         raise ValueError('no modes to measure: every mode is a rigid-body mode at 0 Hz')
+    if edge_distance is None:
+        edge_distance = EDGE_DISTANCE if geometry.units_defined else 0.0
     places = candidates(geometry, groups, surfaces,
-                        edge_angle=EDGE_ANGLE if edge_angle is None else float(edge_angle))
+                        edge_angle=EDGE_ANGLE if edge_angle is None else float(edge_angle),
+                        edge_distance=float(edge_distance))
     blocks, measured = local_shapes(shapes, modes, places, geometry)
     placement = effective_independence(blocks, triaxial, uniaxial, axes=axes,
                                        allowed=measured, sources=places.source,
@@ -770,6 +831,39 @@ def assemble(shapes: Any, modes: Any, places: Candidates, blocks: Any,
     return Plan(kept_geometry, table, test_shapes, placement)
 
 
+def _away_from_edge(faces: list, at: np.ndarray, points: np.ndarray, xyz: np.ndarray,
+                    by_id: np.ndarray, node_id: np.ndarray, distance: float) -> np.ndarray:
+    """Which of the nodes `at`, at `points`, are at least `distance`
+    from the edge of the surface made of `faces`: the sides only one of
+    its faces has."""
+    from scipy.spatial import cKDTree
+
+    sides = np.array([sorted((f[k], f[(k + 1) % len(f)])) for f in faces
+                      for k in range(len(f))], dtype=np.int64).reshape(-1, 2)
+    unique, count = np.unique(sides, axis=0, return_counts=True)
+    edge = unique[count == 1]
+    if not len(edge):
+        return np.ones(len(at), dtype=bool)
+    ends = xyz[by_id[np.searchsorted(node_id, edge.ravel(), sorter=by_id)]].reshape(-1, 2, 3)
+    start, along = ends[:, 0], ends[:, 1] - ends[:, 0]
+    middle = start + along / 2
+    half = float(np.linalg.norm(along, axis=1).max()) / 2
+    # every side whose middle is near enough that the side could be
+    # nearer than `distance`, then its exact distance
+    near = cKDTree(middle).query_ball_point(points, distance + half, return_sorted=False)
+    which = np.repeat(np.arange(len(at)), [len(n) for n in near])
+    side = np.fromiter((k for n in near for k in n), dtype=np.int64, count=len(which))
+    if not len(side):
+        return np.ones(len(at), dtype=bool)
+    span = np.einsum('ij,ij->i', along[side], along[side])
+    t = np.einsum('ij,ij->i', points[which] - start[side], along[side])
+    t = np.clip(np.divide(t, span, out=np.zeros_like(t), where=span > 0), 0.0, 1.0)
+    gap = np.linalg.norm(points[which] - start[side] - t[:, None] * along[side], axis=1)
+    away = np.ones(len(at), dtype=bool)
+    away[which[gap < distance]] = False
+    return away
+
+
 def _remove(kept: np.ndarray, loss: np.ndarray, target: int) -> np.ndarray:
     """`kept` less its weakest: a tenth of it while far more remain than
     are wanted, otherwise the single weakest."""

{visualdynamics-0.1.0a67 → visualdynamics-0.1.0a68}/src/visualdynamics/gui/__init__.py

@@ -244,4 +244,41 @@ def main(argv: Sequence[str] | None = None) -> int:
     # while both still stand.
     app.clipboard().clear()
     app.processEvents()
+    release_widgets(app)
     return code
+
+
+def release_widgets(app: Any) -> int:
+    """Delete the windows Python still owns, one by one, while the
+    application stands, and return how many there were.
+
+    Left to the interpreter's exit, PySide deletes every widget it still
+    owns in one sweep over its own table, in no particular order. A
+    window deleted there takes its children with it, and the sweep then
+    reaches a child it still lists and deletes it again: the process
+    segfaults on its way out. Deleting each window here, through its
+    wrapper, leaves the sweep nothing to do.
+    """
+    # a gate worker segfaulted at exit three times on 2026-10-22, in
+    # PySide's moduleShutdown sweep, on a QListWidget, a QComboBox and a
+    # QRadioButton of dialogs the tests had left open; PLAN.md, "Nothing
+    # of Python's left for PySide's sweep"
+    import gc
+
+    import shiboken6
+    from PySide6.QtCore import QCoreApplication, QEvent
+
+    # the cycles first: a window held by nothing but its own connections
+    # goes the way Python owns it, not the sweep's
+    gc.collect()
+    released = 0
+    for widget in app.topLevelWidgets():
+        # through shiboken, not deleteLater: a window Qt deletes leaves
+        # its children's wrappers standing, and the sweep still crashed
+        if (shiboken6.isValid(widget) and shiboken6.ownedByPython(widget)
+                and widget.parent() is None):
+            shiboken6.delete(widget)
+            released += 1
+    QCoreApplication.sendPostedEvents(None, QEvent.Type.DeferredDelete)
+    app.processEvents()
+    return released

{visualdynamics-0.1.0a67 → visualdynamics-0.1.0a68}/src/visualdynamics/gui/icons.py

@@ -1867,40 +1867,50 @@ def _draw_coordinate_systems(painter, color):
     painter.drawEllipse(origin, 5, 5)
 
 
+def _depth(painter, color, *edges):
+    """The edges a solid's face is extruded along, thinner than the face
+    so they read as going back.
+
+    `_element_shape` leaves the pen off to fill its node dots, so these
+    take a pen of their own.
+    """
+    # drawn with the dots' empty pen they were invisible: the tet wore
+    # the triangle's icon and the brick the quad's (Brandon, 2026-10-22)
+    painter.setPen(_pen(color, 5))
+    for start, end in edges:
+        painter.drawLine(QPointF(*start), QPointF(*end))
+
+
 def _draw_tet(painter, color):
-    """A tetrahedron: a triangle with its apex drawn to the far corner."""
+    """A tetrahedron: a triangle with its far corner inside, joined to
+    the three."""
     _element_shape(painter, color, [(32, 10), (54, 50), (10, 50)])
-    painter.drawLine(QPointF(32, 10), QPointF(34, 36))
-    painter.drawLine(QPointF(54, 50), QPointF(34, 36))
-    painter.drawLine(QPointF(10, 50), QPointF(34, 36))
+    _depth(painter, color, ((32, 10), (34, 36)), ((54, 50), (34, 36)),
+           ((10, 50), (34, 36)))
 
 
 def _draw_wedge(painter, color):
-    """A wedge: a triangle extruded sideways."""
-    _element_shape(painter, color, [(12, 20), (28, 48), (12, 48)])
-    painter.drawLine(QPointF(12, 20), QPointF(40, 14))
-    painter.drawLine(QPointF(28, 48), QPointF(54, 42))
-    painter.drawLine(QPointF(12, 48), QPointF(40, 42))
-    painter.drawLine(QPointF(40, 14), QPointF(54, 42))
-    painter.drawLine(QPointF(40, 14), QPointF(40, 42))
-    painter.drawLine(QPointF(40, 42), QPointF(54, 42))
+    """A wedge: an upright triangle extruded back and to the right, a
+    triangular prism, the hidden edges left out as the brick leaves
+    them."""
+    # Brandon, 2026-10-22: the old sideways ramp did not read as a wedge
+    _element_shape(painter, color, [(24, 24), (40, 54), (8, 54)])
+    _depth(painter, color, ((24, 24), (38, 10)), ((40, 54), (54, 40)),
+           ((38, 10), (54, 40)))
 
 
 def _draw_hex(painter, color):
     """A brick: a square with its back face offset."""
     _element_shape(painter, color, [(10, 22), (42, 22), (42, 54), (10, 54)])
-    painter.drawLine(QPointF(10, 22), QPointF(22, 10))
-    painter.drawLine(QPointF(42, 22), QPointF(54, 10))
-    painter.drawLine(QPointF(42, 54), QPointF(54, 42))
-    painter.drawLine(QPointF(22, 10), QPointF(54, 10))
-    painter.drawLine(QPointF(54, 10), QPointF(54, 42))
+    _depth(painter, color, ((10, 22), (22, 10)), ((42, 22), (54, 10)),
+           ((42, 54), (54, 42)), ((22, 10), (54, 10)), ((54, 10), (54, 42)))
 
 
 def _draw_pyramid(painter, color):
     """A pyramid: a quad base with an apex."""
     _element_shape(painter, color, [(10, 50), (42, 50), (54, 40), (22, 40)])
-    for corner in ((10, 50), (42, 50), (54, 40), (22, 40)):
-        painter.drawLine(QPointF(*corner), QPointF(32, 10))
+    _depth(painter, color, *(((corner), (32, 10))
+                             for corner in ((10, 50), (42, 50), (54, 40), (22, 40))))
 
 
 def _draw_elements(painter, color):

{visualdynamics-0.1.0a67 → visualdynamics-0.1.0a68}/src/visualdynamics/gui/instrumentation_panel.py

@@ -7,7 +7,8 @@ the selection does while the pane is open; the pane names them. The
 element groups sensors may go on are checked here, and the surfaces
 of the model are drawn in the view, where a click on one leaves it out
 or puts it back. The numbers of tri-axial and uni-axial accelerometers
-are typed, and the sensors Effective Independence chooses are drawn on
+are typed, and so is how far a sensor stays from a surface's edge, in
+the display unit system; the sensors Effective Independence chooses are drawn on
 the model as they change, each tri-axial one as a triad and each
 uni-axial one as an arrow, with how well they tell the modes apart: the
 worst off-diagonal term of the auto-MAC at the chosen channels and the
@@ -33,7 +34,7 @@ from PySide6.QtWidgets import (
 )
 
 from ..core.instrumentation import EDGE_ANGLE
-from .editors import DoubleSpinBox, SpinBox, commit_on_enter, number_box
+from .editors import LENGTH_DECIMALS, DoubleSpinBox, SpinBox, commit_on_enter, number_box
 from .settings_panel import panel_grid
 
 # Brandon, 2026-10-21: plan the accelerometers of a modal or vibration
@@ -52,8 +53,9 @@ class InstrumentationPanel(QWidget):
     #: the counts or the uni-axial directions changed: the window chooses
     #: the sensors again
     changed = Signal()
-    #: the element groups or the edge angle changed: the window finds the
-    #: places and reads the modes again, then chooses
+    #: the element groups, the edge angle or the distance from the edges
+    #: changed: the window finds the places and reads the modes again,
+    #: then chooses
     places_changed = Signal()
     #: every surface put back, or every one left out
     all_asked = Signal()
@@ -97,6 +99,12 @@ class InstrumentationPanel(QWidget):
             tip='Two neighboring faces are on one surface while their normals are within '
                 'this angle: a curved surface is one surface however far it turns. Raise it '
                 'for a coarse curved mesh that splits into strips.')
+        # Brandon, 2026-10-22: stay a quarter of an inch from the edges by
+        # default, shown in the display unit system
+        self.edge_distance: DoubleSpinBox = number_box(
+            0.0, 1e9, value=0.0, decimals=LENGTH_DECIMALS,
+            tip='How near a sensor may be to the edge of its surface: a sharp edge, a free '
+                'edge, a hole or where parts touch. 0 allows a sensor on the edge.')
         self.triaxial: SpinBox = SpinBox()
         self.triaxial.setRange(0, 100000)
         self.triaxial.setToolTip('How many tri-axial accelerometers: placed first')
@@ -110,21 +118,22 @@ class InstrumentationPanel(QWidget):
         self.axes.setToolTip('Which way a uni-axial accelerometer may point, in its '
                              "place's own system: Z is out of the surface")
         for row, (label, widget) in enumerate(
-                (('Surface edge', self.edge_angle), ('Tri-axial', self.triaxial),
-                 ('Uni-axial', self.uniaxial), ('Uni-axial along', self.axes)), start=7):
+                (('Surface edge', self.edge_angle), ('Away from edges', self.edge_distance),
+                 ('Tri-axial', self.triaxial), ('Uni-axial', self.uniaxial),
+                 ('Uni-axial along', self.axes)), start=7):
             grid.addWidget(QLabel(label), row, 0)
             grid.addWidget(widget, row, 1)
         self.name_label: QLabel = QLabel('Name')
         self.name: QLineEdit = QLineEdit()
         self.name.setToolTip("The start of the three names Keep adds: '... Geometry', "
                              "'... Channels' and '... Shapes'")
-        grid.addWidget(self.name_label, 11, 0)
-        grid.addWidget(self.name, 11, 1)
+        grid.addWidget(self.name_label, 12, 0)
+        grid.addWidget(self.name, 12, 1)
         self.reading_label: QLabel = QLabel()
         self.reading_label.setWordWrap(True)
         self.reading_label.setTextInteractionFlags(
             Qt.TextInteractionFlag.TextSelectableByMouse)
-        grid.addWidget(self.reading_label, 12, 0, 1, 2)
+        grid.addWidget(self.reading_label, 13, 0, 1, 2)
         buttons = QHBoxLayout()
         self.keep_button: QPushButton = QPushButton('Keep')
         self.keep_button.setToolTip('Add the experimental geometry, the channel table '
@@ -134,13 +143,14 @@ class InstrumentationPanel(QWidget):
         self.close_button.setToolTip('Put the pane away; nothing is added')
         buttons.addWidget(self.keep_button)
         buttons.addWidget(self.close_button)
-        grid.addLayout(buttons, 13, 0, 1, 2)
-        grid.setRowStretch(14, 1)
-        commit_on_enter(self.triaxial, self.uniaxial, self.edge_angle)
+        grid.addLayout(buttons, 14, 0, 1, 2)
+        grid.setRowStretch(15, 1)
+        commit_on_enter(self.triaxial, self.uniaxial, self.edge_angle, self.edge_distance)
         self.triaxial.valueChanged.connect(lambda _value: self.changed.emit())
         self.uniaxial.valueChanged.connect(lambda _value: self.changed.emit())
         self.axes.currentIndexChanged.connect(lambda _index: self.changed.emit())
         self.edge_angle.valueChanged.connect(lambda _value: self.places_changed.emit())
+        self.edge_distance.valueChanged.connect(lambda _value: self.places_changed.emit())
         self.all_button.clicked.connect(self.all_asked.emit)
         self.none_button.clicked.connect(self.none_asked.emit)
         self.groups.itemChanged.connect(lambda _item: self.places_changed.emit())
@@ -190,6 +200,14 @@ class InstrumentationPanel(QWidget):
         or 0, 1 and 2."""
         return tuple(self.axes.currentData())
 
+    def show_edge_distance(self, value: float, unit: str) -> None:
+        """Show the distance from the edges, `value` in `unit` ('' for a
+        geometry whose units are not defined), without reporting it."""
+        self.edge_distance.blockSignals(True)
+        self.edge_distance.setSuffix(f' {unit}' if unit else '')
+        self.edge_distance.setValue(value)
+        self.edge_distance.blockSignals(False)
+
     def show_modes(self, text: str) -> None:
         """Name the modes measured."""
         self.modes_label.setText(text)

{visualdynamics-0.1.0a67 → visualdynamics-0.1.0a68}/src/visualdynamics/gui/main_window.py

@@ -9114,7 +9114,11 @@ class MainWindow(QMainWindow):
         return True
 
     def _units_changed(self, name):
+        planning = self.__dict__.get('_planning')
+        distance = self._planning_distance() if planning is not None else None
         self.unit_system = SYSTEMS[name]
+        if planning is not None:
+            self._show_plan_distance(distance)  # the same distance, in the new unit
         if self._merging is not None:
             self._open_merge_panel()        # its tolerance, in the new unit
         self.render_current()
@@ -14295,6 +14299,7 @@ class MainWindow(QMainWindow):
         triaxial = -(-len(modes) // 3) + 1
         panel = self.scene.instrumentation_panel
         panel.open_for(f'{name}, on {geometry_name}', groups, triaxial, 0, f'{name} Plan')
+        self._show_plan_distance(self._plan_default_distance())
         panel.show()
         self._begin_plan_clicks()
         self._plan_now()
@@ -14319,7 +14324,7 @@ class MainWindow(QMainWindow):
 
     def _planning_skin(self):
         """The model's surfaces at the pane's edge angle, found once."""
-        from ..core.instrumentation import skin
+        from ..core.instrumentation import default_surfaces, skin
 
         planning = self._planning
         angle = float(self.scene.instrumentation_panel.edge_angle.value())
@@ -14330,12 +14335,41 @@ class MainWindow(QMainWindow):
             finally:
                 QApplication.restoreOverrideCursor()
             # a surface's number is its place in this angle's split: the
-            # ones left out at another angle mean nothing here
-            if planning['skins']:
-                planning['off'] = set()
+            # ones left out at another angle mean nothing here, and each
+            # split starts from the default, the small surfaces out
+            planning['off'] = {s.id for s in found} - set(default_surfaces(found))
             planning['skins'] = {angle: found}
         return angle, planning['skins'][angle]
 
+    def _plan_default_distance(self) -> float:
+        """The distance sensors keep from the edges unless told: a
+        quarter of an inch, or none on a geometry whose units are not
+        defined (`core.instrumentation.plan`)."""
+        from ..core.instrumentation import EDGE_DISTANCE
+
+        geometry = self.objects[self._planning['geometry']]
+        return EDGE_DISTANCE if geometry.units_defined else 0.0
+
+    def _planning_distance(self) -> float:
+        """The distance sensors keep from the surfaces' edges, in the
+        geometry's coordinates: the pane's box, typed in the display unit
+        system once the geometry's units are defined."""
+        geometry = self.objects[self._planning['geometry']]
+        typed = float(self.scene.instrumentation_panel.edge_distance.value())
+        return (float(self.unit_system.to_si(typed, 'length')) if geometry.units_defined
+                else typed)
+
+    def _show_plan_distance(self, distance: float) -> None:
+        """Put `distance`, in the geometry's coordinates, in the pane's
+        box in the display unit system."""
+        geometry = self.objects[self._planning['geometry']]
+        panel = self.scene.instrumentation_panel
+        if geometry.units_defined:
+            panel.show_edge_distance(float(self.unit_system.from_si(distance, 'length')),
+                                     self.unit_system.label_text('length'))
+        else:
+            panel.show_edge_distance(distance, '')
+
     def _planning_kept(self, found, groups) -> list[int]:
         """The surfaces sensors may go on: in a checked group and not
         clicked out."""
@@ -14353,10 +14387,11 @@ class MainWindow(QMainWindow):
         planning = self._planning
         angle, found = self._planning_skin()
         kept = self._planning_kept(found, groups)
-        key = (angle, tuple(groups), tuple(kept))
+        distance = self._planning_distance()
+        key = (angle, tuple(groups), tuple(kept), distance)
         if planning['places'] is None or planning['places'][0] != key:
             places = candidates(self.objects[planning['geometry']], groups, kept,
-                                edge_angle=angle, found=found)
+                                edge_angle=angle, found=found, edge_distance=distance)
             planning['places'] = (key, places)
             planning['blocks'] = None
         places = planning['places'][1]
@@ -14558,16 +14593,29 @@ class MainWindow(QMainWindow):
     def _begin_plan_clicks(self) -> None:
         """Watch the view's clicks: a press and release in one place on a
         surface leaves it out or puts it back. The press goes on to the
-        camera, so a drag turns the view and toggles nothing."""
+        camera, so a drag turns the view and toggles nothing.
+
+        The release is heard from the camera's style, as the end of its
+        interaction, not from the interactor: the style takes the mouse
+        to itself from the press (VTK's GrabFocus), so the interactor's
+        observers hear neither the drag nor the release. Listening there,
+        no click ever toggled a surface, and the press left behind ended
+        the hover's light for good (Brandon, 2026-10-22)."""
         interactor = getattr(self.scene.plotter, 'iren', None)
         if interactor is None or self.__dict__.get('_plan_observers'):
             return
         raw = interactor.interactor
         self._plan_observers = [
-            raw.AddObserver('LeftButtonPressEvent', self._on_plan_press, 10.0),
-            raw.AddObserver('LeftButtonReleaseEvent', self._on_plan_release, 10.0),
-            raw.AddObserver('MouseMoveEvent', self._on_plan_move, 10.0),
+            (raw, raw.AddObserver('LeftButtonPressEvent', self._on_plan_press, 10.0)),
+            (raw, raw.AddObserver('MouseMoveEvent', self._on_plan_move, 10.0)),
         ]
+        style = raw.GetInteractorStyle()
+        if style is not None:
+            self._plan_observers.append(
+                (style, style.AddObserver('EndInteractionEvent', self._on_plan_release, 10.0)))
+        else:
+            self._plan_observers.append(
+                (raw, raw.AddObserver('LeftButtonReleaseEvent', self._on_plan_release, 10.0)))
 
     def _on_plan_press(self, _caller, _event) -> None:
         planning = self.__dict__.get('_planning')
@@ -14601,7 +14649,12 @@ class MainWindow(QMainWindow):
         """Keep: the plan added to the project as the pane says it
         (`Project.plan_instrumentation`), its three objects in the tree,
         and the pane put away."""
-        from ..core.instrumentation import EDGE_ANGLE, FewerDirectionsWarning, elastic
+        from ..core.instrumentation import (
+            EDGE_ANGLE,
+            FewerDirectionsWarning,
+            default_surfaces,
+            elastic,
+        )
 
         planning = self.__dict__.get('_planning')
         if planning is None:
@@ -14621,10 +14674,17 @@ class MainWindow(QMainWindow):
             options['modes'] = modes
         if not panel.all_groups:
             options['groups'] = groups
-        if len(kept) < len([s for s in found if s.group in set(groups)]):
+        # journaled only when the person changed them from the default
+        offered = {s.id for s in found if s.group in set(groups)}
+        if set(kept) != set(default_surfaces(found)) & offered:
             options['surfaces'] = kept
         if angle != EDGE_ANGLE:
             options['edge_angle'] = angle
+        distance = self._planning_distance()
+        if not np.isclose(distance, self._plan_default_distance(), rtol=1e-4, atol=0.0):
+            # in the geometry's own coordinates, which are meters once
+            # its units are defined: the default unit
+            options['edge_distance'] = distance
         if panel.uniaxial_axes != (2,):
             options['axes'] = list(panel.uniaxial_axes)
         typed = panel.name.text().strip()
@@ -14656,11 +14716,9 @@ class MainWindow(QMainWindow):
         """Put Plan Instrumentation away; nothing is added."""
         self.scene.instrumentation_panel.hide()
         self._plan_timer.stop()
-        interactor = getattr(self.scene.plotter, 'iren', None)
-        for observer in self.__dict__.get('_plan_observers') or []:
-            if interactor is not None:
-                with contextlib.suppress(Exception):
-                    interactor.interactor.RemoveObserver(observer)
+        for watched, observer in self.__dict__.get('_plan_observers') or []:
+            with contextlib.suppress(Exception):
+                watched.RemoveObserver(observer)
         self._plan_observers = []
         if self.__dict__.get('_planning') is None:
             return