visualdynamics 0.1.0a67__tar.gz → 0.1.0a69__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: visualdynamics
-Version: 0.1.0a67
+Version: 0.1.0a69
 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.0a69}/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.0a69}/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.0a69'
 
 
 def launch_gui(*paths: str, in_process: bool | None = None) -> Any:

{visualdynamics-0.1.0a67 → visualdynamics-0.1.0a69}/src/visualdynamics/compatibility.py

@@ -137,6 +137,24 @@ def _listed(dofs: Sequence[str]) -> str:
     return text
 
 
+def _channel_named(table: Any, row: int) -> str:
+    """A channel as the issue lists it: its DOF, or, before it has one,
+    its number and what it still lacks ('channel 3 (no node yet)'). A
+    channel with a node and no direction is listed only when the node is
+    not on the geometry, so its node is named: 'channel 5 at node 9 (no
+    direction yet)'."""
+    # A channel added blank listed as '', so the message ended at its
+    # colon with nothing named (Brandon, 2026-10-22).
+    node, direction = str(table['node'][row]), str(table['direction'][row])
+    number = int(table['channel'][row])
+    if node and direction:
+        return table.dof_strings()[row]
+    if node:
+        return f'channel {number} at node {node} (no direction yet)'
+    lacking = 'node' if direction else 'node or direction'
+    return f'channel {number} (no {lacking} yet)'
+
+
 def modal_object(obj: Any) -> int | None:
     """The highest mode a data object's coordinates name, when every
     one of its DOFs is a modal coordinate, else None."""
@@ -283,12 +301,15 @@ def check_object(name: str, obj: Any, geometry: Geometry | None,
                    if geometry.missing_dofs([dof])]
         if not flagged:
             return None
-        missing = [dofs[i] for i in flagged]
+        named = [_channel_named(obj, i) for i in flagged]
         return Issue(
             name=name, kind='dofs-not-in-geometry',
             message=(f'{len(flagged)} of {len(dofs)} channels are not in '
-                     f'geometry {geometry_name!r}: {_listed(missing)}'),
-            missing_dofs=missing, sub_items=flagged)
+                     f'geometry {geometry_name!r}: {_listed(named)}'),
+            # only what is a DOF: a channel not yet placed names none
+            missing_dofs=[dofs[i] for i in flagged
+                          if str(obj['node'][i]) and str(obj['direction'][i])],
+            sub_items=flagged)
 
     return None
 

{visualdynamics-0.1.0a67 → visualdynamics-0.1.0a69}/src/visualdynamics/core/channel_table.py

@@ -359,7 +359,10 @@ class ChannelTable:
                     dtype='int64')
             else:
                 frame[name] = pd.Series(values, dtype='string').fillna('')
-        frame['channel_type'] = cls._typed_by_unit(frame)
+        # a Series of its own type, as the other text columns: a bare list
+        # with no channels in it read as an empty float column
+        frame['channel_type'] = pd.Series(cls._typed_by_unit(frame),
+                                          dtype='string')
         return frame
 
     @classmethod
@@ -559,6 +562,41 @@ class ChannelTable:
         declared = str(self.frame.loc[row, 'channel_type'])
         return list(ORDINATE_UNITS.get(declared, ALL_ORDINATE_UNITS))
 
+    def add_channels(self, count: int = 1) -> list[int]:
+        """Add blank channels at the end of the table, numbered on from
+        the highest channel in it (from 1 in an empty table).
+
+        Every other cell takes its column's default, so the node,
+        direction and unit are blank until they are typed in.
+
+        Parameters
+        ----------
+        count : int, default 1
+            How many channels to add.
+
+        Returns
+        -------
+        list of int
+            The new channels' numbers.
+
+        Raises
+        ------
+        ValueError
+            If `count` is less than 1.
+        """
+        import pandas as pd
+
+        count = int(count)
+        if count < 1:
+            raise ValueError(f'cannot add {count} channels; add at least one')
+        start = int(self.frame['channel'].max()) + 1 if self.num_channels else 1
+        numbers = list(range(start, start + count))
+        added = self._typed(pd.DataFrame(
+            {name: numbers if name == 'channel' else [spec.default] * count
+             for name, spec in self.COLUMNS.items()}))
+        self.frame = pd.concat([self.frame, added], ignore_index=True)
+        return numbers
+
     def delete_channels(self, indices: Sequence[int]) -> None:
         """Remove the given rows in place. At least one row must remain.
 

{visualdynamics-0.1.0a67 → visualdynamics-0.1.0a69}/src/visualdynamics/core/geometry.py

@@ -2700,3 +2700,37 @@ class Geometry:
         from ..viz.geometry import plot_dofs
         return plot_dofs(self, source, quantity, unit_system=unit_system,
                          **kwargs)
+
+    def plot_channels(self, table: Any, role: str = 'all',
+                      unit_system: UnitSystem | None = None,
+                      **kwargs: Any) -> Any:
+        """Draw this geometry with a labeled arrow at each channel's DOF
+        in a channel table, as the app does when the two are selected
+        together.
+
+        A channel with no node or direction yet, or at a node this
+        geometry does not have, has no arrow.
+
+        Parameters
+        ----------
+        table : ChannelTable
+            The channels to draw.
+        role : str, default 'all'
+            'reference', 'response' or 'monitor' to draw only the
+            channels in that role, 'control' for the channels with
+            Control checked, or 'all' for every channel.
+        unit_system : UnitSystem, optional
+            Units to draw in.
+        **kwargs
+            Passed through to the scene.
+
+        Returns
+        -------
+        object
+            The plotter the scene is in.
+        """
+        # Brandon, 2026-10-22: a channel table and a geometry selected
+        # together draw the table's DOFs, picked by role.
+        from ..viz.geometry import plot_channels
+        return plot_channels(self, table, role, unit_system=unit_system,
+                             **kwargs)

{visualdynamics-0.1.0a67 → visualdynamics-0.1.0a69}/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.0a69}/src/visualdynamics/core/tables.py

@@ -76,6 +76,37 @@ def cell_text(value: Any, decimals: int | None) -> str:
     return str(value) if decimals is None else f'{value:.{decimals}f}'
 
 
+def mode_heading(mode: int) -> str:
+    """The column heading of mode `mode` (from 0) in a table of shape
+    values: 'M1' for the first."""
+    return f'M{mode + 1}'
+
+
+def shape_value_text(value: Any) -> str:
+    """One shape value as text, to six significant figures; a complex
+    one as its real and imaginary parts, '0.5-0.25j'."""
+    import numpy as np
+
+    if np.iscomplexobj(value):
+        return f'{value.real:.6g}{value.imag:+.6g}j'
+    return f'{float(value):.6g}'
+
+
+def shape_values(shapes: Any) -> tuple[list[str], list[list[str]]]:
+    """``(headers, rows)`` of a shape set's values: a row per DOF, the
+    DOF first, then a column per mode ('M1', 'M2', ...).
+
+    Rows are DOFs and columns modes, the way a mode shape matrix is
+    usually written, which is the transpose of `ShapeSet.shape_matrix`.
+    """
+    # Brandon, 2026-10-22, with the table of them beside the mode list.
+    headers = ['DOF'] + [mode_heading(m) for m in range(shapes.num_shapes)]
+    rows = [[str(dof)] + [shape_value_text(value)
+                          for value in shapes.shape_matrix[:, i]]
+            for i, dof in enumerate(shapes.coordinate)]
+    return headers, rows
+
+
 def table_of(obj: Any, geometry: Any = None,
              objects: Mapping[str, Any] | None = None
              ) -> tuple[list[str], list[list[str]]] | None:

{visualdynamics-0.1.0a67 → visualdynamics-0.1.0a69}/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.0a69}/src/visualdynamics/gui/icons.py

@@ -162,12 +162,7 @@ def _draw_geometry(painter, color):
 def _draw_new_geometry(painter, color):
     """The geometry's frame with a plus: an empty geometry to build."""
     _draw_geometry(painter, color)
-    painter.setPen(Qt.PenStyle.NoPen)
-    painter.setBrush(QBrush(QColor('#2ca02c')))
-    painter.drawEllipse(QPointF(50, 50), 13, 13)
-    painter.setBrush(QBrush(QColor('white')))
-    painter.drawRoundedRect(QRectF(48, 42, 4, 16), 1, 1)
-    painter.drawRoundedRect(QRectF(42, 48, 16, 4), 1, 1)
+    _plus(painter, 50, 50)
 
 
 #: A pulse and its ringdown. The shape a time history wears, and the
@@ -284,6 +279,12 @@ def _draw_specification(painter, color):
     _psd_body(painter, color)
 
 
+def _draw_new_specification(painter, color):
+    """The specification's glyph with a plus: a specification to write."""
+    _draw_specification(painter, color)
+    _plus(painter, 50, 50)
+
+
 def _draw_srs(painter, color):
     """The shape every shock response spectrum has.
 
@@ -969,6 +970,65 @@ def _draw_channel_table(painter, color):
     painter.drawLine(QPointF(32, 15), QPointF(32, 49))
 
 
+def _plus(painter, x, y):
+    """The green disc with a white plus that marks a control as making
+    something new, centered at `(x, y)`."""
+    painter.setPen(Qt.PenStyle.NoPen)
+    painter.setBrush(QBrush(QColor('#2ca02c')))
+    painter.drawEllipse(QPointF(x, y), 13, 13)
+    painter.setBrush(QBrush(QColor('white')))
+    painter.drawRoundedRect(QRectF(x - 2, y - 8, 4, 16), 1, 1)
+    painter.drawRoundedRect(QRectF(x - 8, y - 2, 16, 4), 1, 1)
+
+
+def _draw_new_channel_table(painter, color):
+    """The channel table with a plus: an empty one to fill in."""
+    _draw_channel_table(painter, color)
+    _plus(painter, 50, 50)
+
+
+def _draw_add_channel(painter, color):
+    """A header and one row, with a plus on the row: a channel added to
+    the table."""
+    header = QColor(color)
+    header.setAlpha(110)
+    painter.fillRect(QRectF(8, 16, 48, 10), QBrush(header))
+    painter.setPen(_pen(color, 4))
+    painter.setBrush(Qt.BrushStyle.NoBrush)
+    painter.drawRoundedRect(QRectF(8, 16, 48, 22), 3, 3)
+    painter.drawLine(QPointF(8, 26), QPointF(56, 26))
+    painter.drawLine(QPointF(32, 16), QPointF(32, 38))
+    _plus(painter, 32, 50)
+
+
+def _draw_mac(painter, color):
+    """A three by three grid, its diagonal full and the rest faint: a
+    set's MAC against itself."""
+    faint = QColor(color)
+    faint.setAlpha(70)
+    painter.setPen(Qt.PenStyle.NoPen)
+    for row in range(3):
+        for column in range(3):
+            painter.setBrush(QBrush(QColor(color) if row == column else faint))
+            painter.drawRect(QRectF(10 + 15 * column, 10 + 15 * row, 13, 13))
+
+
+def _draw_shape_values(painter, color):
+    """A table headed along its top and down its left side: values with
+    a DOF for each row and a mode for each column."""
+    header = QColor(color)
+    header.setAlpha(110)
+    painter.fillRect(QRectF(11, 15, 42, 10), QBrush(header))
+    painter.fillRect(QRectF(11, 25, 12, 24), QBrush(header))
+    painter.setPen(_pen(color, 4))
+    painter.setBrush(Qt.BrushStyle.NoBrush)
+    painter.drawRoundedRect(QRectF(11, 15, 42, 34), 3, 3)
+    for y in (25, 37):
+        painter.drawLine(QPointF(11, y), QPointF(53, y))
+    for x in (23, 38):
+        painter.drawLine(QPointF(x, 15), QPointF(x, 49))
+
+
 def _draw_shape_set(painter, color):
     """A deformed mode shape with nodes riding on it."""
     points = [(10 + i, 32 - 16 * math.sin(i / 44 * 2 * math.pi))
@@ -1867,40 +1927,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):
@@ -2150,6 +2220,10 @@ def control_icon(name: str) -> QIcon:
      'faster': _draw_faster, 'slower': _draw_slower,
      'up': _draw_up, 'down': _draw_down,
      'add': _draw_add, 'new_geometry': _draw_new_geometry,
+     'new_channel_table': _draw_new_channel_table,
+     'mac': _draw_mac, 'shape_values': _draw_shape_values,
+     'new_specification': _draw_new_specification,
+     'add_channel': _draw_add_channel,
      'beam': _draw_beam, 'tri': _draw_tri, 'quad': _draw_quad,
      'edit': _draw_edit, 'edit_on': _draw_edit_on, 'trash': _draw_trash,
      'colormap': _draw_colormap,