visualdynamics 0.1.0a42__tar.gz → 0.1.0a43__tar.gz

{visualdynamics-0.1.0a42/src/visualdynamics.egg-info → visualdynamics-0.1.0a43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: visualdynamics
-Version: 0.1.0a42
+Version: 0.1.0a43
 Summary: Structural Dynamics Visualization: a units-aware structural dynamics analysis toolset
 Author-email: Brandon Zwink <bzwink@gmail.com>
 License-Expression: MIT

{visualdynamics-0.1.0a42 → visualdynamics-0.1.0a43}/src/visualdynamics/__init__.py

@@ -90,7 +90,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.0a42'
+__version__ = '0.1.0a43'
 
 
 def launch_gui(*paths: str, in_process: bool | None = None) -> Any:

{visualdynamics-0.1.0a42 → visualdynamics-0.1.0a43}/src/visualdynamics/core/data.py

@@ -3032,6 +3032,9 @@ class Psd(_Bands, DataArray):
         """
         spec = _recast(self, Specification)
         spec.limits = {}
+        # a requirement is not scaled to be compared: the test level
+        # belongs to the measurement
+        spec.__dict__.pop('scale_db', None)
         spec.interpolation = ('bin' if self.bandwidth is not None
                               else Specification.reading_of(self.abscissa))
         return spec

{visualdynamics-0.1.0a42 → visualdynamics-0.1.0a43}/src/visualdynamics/core/shapes.py

@@ -893,6 +893,7 @@ class ShapeSet:
                      other: ShapeSet, other_mode: int,
                      other_geometry: Geometry | None = None, *,
                      on_basis: bool = False,
+                     projected: ShapeSet | None = None,
                      names: tuple[str, str] = ('first', 'second'),
                      **kwargs: Any) -> Any:
         """This mode and another set's overlaid, swinging together, as
@@ -920,6 +921,10 @@ class ShapeSet:
             The other set's geometry; this one's when omitted.
         on_basis : bool, default False
             Draw the other set's projection on this geometry instead.
+        projected : ShapeSet, optional
+            The other set already carried onto this one's DOFs
+            (`correlate.project_shapes`), for a script animating many
+            pairs of the same two sets: made here when omitted.
         names : tuple of str
             What the caption calls the two sets.
         **kwargs
@@ -934,8 +939,7 @@ class ShapeSet:
         from ..viz.animate import animate_pair, pair_deflections
 
         other_geometry = other_geometry or geometry
-        projected = None
-        if other_geometry is not geometry:
+        if other_geometry is not geometry and projected is None:
             from .correlate import project_shapes
             projected, _report = project_shapes(other, other_geometry,
                                                 self, geometry)

{visualdynamics-0.1.0a42 → visualdynamics-0.1.0a43}/src/visualdynamics/gui/main_window.py

@@ -151,9 +151,14 @@ from ..rotate import (
     snapped,
     wrapped,
 )
-from ..theme import OVERLAY_ALPHA
+from ..theme import PAIR_COLORS
 from ..theme import theme as resolve_theme
 from ..units import DEFAULT_SYSTEM, SYSTEMS, UnitSystem
+
+# the playback clock is the viz layer's, so a saved movie and a script's
+# `movie=` play at the window's own rate by construction
+from ..viz.animate import MOVIE_FPS as FRAMES_PER_SECOND
+from ..viz.animate import SECONDS_PER_CYCLE, SECONDS_PER_RECORD
 from ..viz.geometry import (
     AXIS_COLORS,
     ENTITY_LABEL_LIMIT,
@@ -222,10 +227,7 @@ COMBO_CELL_PADDING = 44
 #: a dragged turn snaps to whole degrees of this; a typed angle does not
 ANGLE_STEP = 1.0
 
-FRAMES_PER_SECOND = 30
 PHASE_STEPS = 120            # frames in one mode-shape cycle
-SECONDS_PER_CYCLE = 2.0      # every mode animates at this rate, whatever its Hz
-SECONDS_PER_RECORD = 10.0    # a time record plays in about this long
 
 # What Faster and Slower step through. Doublings, because that is how a
 # speed reads — half as fast, twice as fast — and a ladder rather than a
@@ -1138,7 +1140,6 @@ class MainWindow(QMainWindow):
         self._fit_parabola = None
         self._fit_damping_label = None
         self._fit_coherence_name = None
-        self._fit_records = None
         #: what the plot's top and bottom edges mean as damping, kept
         #: across fits — an article's plausible range rarely changes
         #: between two of its own FRF sets
@@ -3182,8 +3183,12 @@ class MainWindow(QMainWindow):
         rewrites per line is in every frame; then playback is put back
         where it was. `path` skips the dialog (scripts, tests).
         """
-        from ..viz.animate import cycle_parameters, sweep_parameters
-        from .movie import MOVIE_FPS, write_movie
+        from ..viz.animate import (
+            cycle_parameters,
+            movie_frames,
+            sweep_parameters,
+        )
+        from .movie import write_movie
 
         if self.animator is None or self.scene.plotter is None:
             return None
@@ -3201,28 +3206,24 @@ class MainWindow(QMainWindow):
         phase = self.phase_slider.value()
         held = self._cursor.value() if self._cursor is not None else None
         if self._shape_mode:
-            parameters = cycle_parameters(SECONDS_PER_CYCLE / self.speed,
-                                          MOVIE_FPS)
+            parameters = cycle_parameters(SECONDS_PER_CYCLE / self.speed)
+            step = self.animator.set_parameter
         else:
             parameters = sweep_parameters(len(self._cursor_abscissa),
-                                          SECONDS_PER_RECORD / self.speed,
-                                          MOVIE_FPS)
+                                          SECONDS_PER_RECORD / self.speed)
 
-        def frames():
-            for parameter in parameters:
-                if self._shape_mode:
-                    self._draw_frame(parameter)
-                else:
-                    self._cursor.setValue(
-                        float(self._cursor_abscissa[parameter]))
-                yield self.scene.plotter.screenshot(return_img=True)
+            def step(index):
+                # the cursor, not the animator: it is where an envelope
+                # rewrites its caption, so every frame carries its line
+                self._cursor.setValue(float(self._cursor_abscissa[index]))
 
         # seconds on a large model or a Retina screen, with input held
         # off: say so, rather than look hung
         self._show_status(f'Saving {os.path.basename(path)}…')
         QApplication.setOverrideCursor(Qt.CursorShape.WaitCursor)
         try:
-            count = write_movie(path, frames(), fps=MOVIE_FPS)
+            count = write_movie(path, movie_frames(self.scene.plotter, step,
+                                                   parameters))
         except RuntimeError as error:      # MovieUnavailable among them
             self._show_status(str(error))
             return None
@@ -3234,7 +3235,7 @@ class MainWindow(QMainWindow):
                 self._draw_frame(phase / PHASE_STEPS * 2 * np.pi)
             self.set_playing(playing)
         self._show_status(
-            f'Saved {os.path.basename(path)} — {count / MOVIE_FPS:.3g} s, '
+            f'Saved {os.path.basename(path)} — {count / FRAMES_PER_SECOND:.3g} s, '
             f'{os.path.getsize(path) / 1e6:.2g} MB')
         return path
 
@@ -3774,7 +3775,7 @@ class MainWindow(QMainWindow):
 
     # the Basis keeps the comparison overlay's baseline blue; other
     # groups cycle the curve palette
-    LINK_ROLE_COLORS: ClassVar[dict] = {'Basis': '#4c92d9'}
+    LINK_ROLE_COLORS: ClassVar[dict] = {'Basis': PAIR_COLORS[0]}
 
     def _role_holder(self, role):
         """The real object group holding the type's `role`.
@@ -5375,14 +5376,8 @@ class MainWindow(QMainWindow):
             said['origin'] = tuple(float(v) for v in matrix[3])
         cs_id = int(geometry.cs_id[row])
         geometry.place_coordinate_system(cs_id, **said)
-        journal = self.project.journal
-        before = len(journal)
         self.project.record_call(geometry, 'place_coordinate_system', cs_id,
-                                 **said)
-        if len(journal) > before > 0:
-            stem = journal[-1].split('=', 1)[0]
-            if journal[-2].split('=', 1)[0] == stem:
-                journal[-2:] = journal[-1:]
+                                 settle=True, **said)
 
     def _cursor_on_ring(self, matrix, axis, position):
         """Where the cursor's ray meets the plane the ring lies in."""
@@ -8336,7 +8331,7 @@ class MainWindow(QMainWindow):
         color_a = self._link_color(a_name)
         color_b = self._link_color(b_name)
         if color_b is None or color_b == color_a:
-            color_b = next(c for c in ('#ff8c2b', '#3fb950')
+            color_b = next(c for c in (PAIR_COLORS[1], '#3fb950')
                            if c != color_a)
         self._compare['colors'] = (color_a, color_b)
         alphas = overlay_alphas(self.link_role(a_name),
@@ -8358,9 +8353,7 @@ class MainWindow(QMainWindow):
         return None
 
     def _build_comparison_animator(self, first_pair, second_pair,
-                                   caption, showing,
-                                   colors=(None, '#ff8c2b'),
-                                   alphas=(1.0, OVERLAY_ALPHA)):
+                                   caption, showing, colors, alphas):
         """Like _build_animator, twice: two moving copies in one
         scene (`viz.animate.build_pair`), each (geometry, deflection)
         pair on its own mesh, in its own color and at its own opacity."""
@@ -9809,20 +9802,21 @@ class MainWindow(QMainWindow):
         plot another (Brandon, 2026-08-30).
         """
         from ..plot import octave_preview
+        from ..viz.marks import octave_steps
 
         self._clear_octave()
         panel = self.data_pane.octave_panel
         try:
-            self.octave_previews = octave_preview(
-                self.data_pane.graphics.ci.items, psd, panel.per_octave(),
-                self.unit_system, resolve_theme(self.theme_name), records)
-            banded = psd.to_octave(panel.per_octave())
+            steps = octave_steps(psd, panel.per_octave(), self.unit_system)
         except ValueError as refusal:
             panel.show_bands(None)
             panel.show()
             self._show_status(f'No octave preview: {refusal}')
             return
-        panel.show_bands(len(banded.abscissa))
+        self.octave_previews = octave_preview(
+            self.data_pane.graphics.ci.items, steps,
+            resolve_theme(self.theme_name), records)
+        panel.show_bands(len(steps[0].abscissa))
         panel.show()
         self._journal_octave_view(psd, panel.per_octave())
 
@@ -10320,7 +10314,7 @@ class MainWindow(QMainWindow):
                 return self._render_banded(
                     spec_name, spec, spec_records, m_data, m_name,
                     m_records,
-                    scale_db=self._family_scale_db(spec, m_name))
+                    scale_db=self.project.comparison_scale(spec, m_name))
         # a specification bounds autospectra; drawn beside a full CPSD its 30
         # cross terms have no limit near them and bury the six that do —
         # and the window resolves each measured entry's comparison scale
@@ -11813,7 +11807,8 @@ class MainWindow(QMainWindow):
     def read_as_specification_act(self) -> None:
         """The bar's Read as Specification: the selected PSD becomes the
         requirement it is, in place (`Project.read_as_specification`)."""
-        self._read_as(Psd, 'Select a PSD to read as a specification',
+        self._read_as('read_as_specification',
+                      'Select a PSD to read as a specification',
                       self.project.read_as_specification,
                       'read as a specification — compare a measurement '
                       'against it by selecting both')
@@ -11821,23 +11816,26 @@ class MainWindow(QMainWindow):
     def read_as_psd_act(self) -> None:
         """The bar's Read as PSD: the selected specification is plain
         data again, in place (`Project.read_as_psd`)."""
-        self._read_as(Specification, 'Select a specification to read as a PSD',
+        self._read_as('read_as_psd',
+                      'Select a specification without limits to read as a PSD',
                       self.project.read_as_psd, 'read as a PSD')
 
-    def _read_as(self, kind, refusal, verb, said) -> None:
+    def _read_as(self, verb_name, refusal, verb, said) -> None:
         """Swap the selected object for its other reading, under the
         same name: the tree row, its grid and the view follow, the way a
-        recompute's in-place swap does."""
-        acted = self._act_on(kind, refusal, verb)
+        recompute's in-place swap does. Whether it applies is the
+        project's own answer (`Project.verbs`), the one the bar asked."""
+        def applies(obj):
+            return obj is not None and verb_name in dict(
+                self.project.verbs(self.project.name_of(obj)))
+
+        acted = self._act_on(applies, refusal, verb)
         if acted is None:
             return
         name = acted[0]
-        obj = self.objects[name]
         item = self._item_for_object(name)
         if item is not None:
-            self._refresh_item(item, obj)
-            item.setToolTip(0, self._object_tooltip(name, obj))
-            self._build_children(item, obj, name)
+            self._refresh_item(item, self.objects[name])
         self._report_content_changed()
         self.render_current()
         self._show_status(f'{name} {said}')
@@ -12330,8 +12328,6 @@ class MainWindow(QMainWindow):
         # every mode's residues. Chosen by the project's rule, and
         # journaled with the records, so the fit_modes line replays
         # this fit and not another (it did not, until 2026-10-09)
-        self._fit_records = None if records is None else [
-            int(i) for i in records]
         coherence = self.project.fit_coherence(name, records)
         self.fit = ModalFitSession(
             obj, records,
@@ -13253,8 +13249,10 @@ class MainWindow(QMainWindow):
                 f'at={picks!r}'
                 + (f', refine={self.fit.refined}' if self.fit.refined
                    else '')
-                + (f', records={self._fit_records!r}'
-                   if self._fit_records is not None else '')
+                # the session's own rows: every record is the default
+                + (f', records={self.fit.rows!r}'
+                   if self.fit.rows != list(range(self.fit.frf.num_records))
+                   else '')
                 + (f', coherence={self._fit_coherence_name!r}'
                    if self._fit_coherence_name else '')
                 + f', name={self.fit_object_name!r})')
@@ -13291,17 +13289,12 @@ class MainWindow(QMainWindow):
                  if isinstance(data, Specification)]
         if len(specs) != 1:
             return None
-        return {name: self._family_scale_db(specs[0], name)
+        return {name: self.project.comparison_scale(specs[0], name)
                 for name, data, _r in series
                 if isinstance(data, Psd)
                 and not isinstance(data, Specification)
                 and name in self.objects}
 
-    def _family_scale_db(self, spec, name):
-        """The comparison scale for `name`, by the project's rule
-        (`Project.comparison_scale`), which the report reads too."""
-        return self.project.comparison_scale(spec, name)
-
     def _show_comparison_scaling(self, series):
         """Put the comparison's scaling on the bar, or take it away.
 
@@ -13325,7 +13318,7 @@ class MainWindow(QMainWindow):
             self.data_pane.show_scaling(None)
             return
         self._scaling_pair = (specs[0][0], measured[0][0])
-        db = self._family_scale_db(specs[0][1], measured[0][0])
+        db = self.project.comparison_scale(specs[0][1], measured[0][0])
         self.data_pane.show_scaling(f'{db:+d} dB' if db else '0 dB')
 
     def _comparison_scale_edited(self, text):
@@ -13370,7 +13363,7 @@ class MainWindow(QMainWindow):
                 else f'{measured_name} and {len(family) - 1} linked '
                      f'PSD{"s" * (len(family) > 2)}')
         if value is None:
-            detected = self._family_scale_db(spec, measured_name)
+            detected = self.project.comparison_scale(spec, measured_name)
             self._show_status('Scaling returned to automatic — detected '
                               f'{detected:+d} dB from the data')
         else:
@@ -13399,7 +13392,7 @@ class MainWindow(QMainWindow):
             return None
         name, data, records = measured[0]
         rows = compare_all(specs[0][0], data, specs[0][1], records,
-                           scale_db=self._family_scale_db(specs[0][0], name))
+                           scale_db=self.project.comparison_scale(specs[0][0], name))
         if not rows:
             return None
         # a pair that is not compared says why, on the status line the

{visualdynamics-0.1.0a42 → visualdynamics-0.1.0a43}/src/visualdynamics/gui/movie.py

@@ -24,11 +24,12 @@ import struct
 from collections.abc import Iterable
 from functools import cache
 from pathlib import Path
+from typing import Any
 
 import numpy as np
 
-#: frames a second in a saved animation — the window's own rate
-MOVIE_FPS = 30
+from ..plot import _application
+from ..viz.animate import MOVIE_FPS
 
 #: frames sent ahead of what the file holds. The encoder answers after
 #: two or three (measured, VideoToolbox, Qt 6.12), so four never waits
@@ -44,19 +45,6 @@ class MovieUnavailable(RuntimeError):
     """This machine cannot encode H.264, so no movie is written."""
 
 
-def _application():
-    """A Qt application, made if a script has none — the recorder
-    needs one, and a headless script has no window to have made it.
-
-    A widgets application, not a QGuiApplication: Qt keeps the first
-    one made for the life of the process, and a script that later
-    opens a window would abort on its first widget.
-    """
-    from PySide6.QtWidgets import QApplication
-
-    return QApplication.instance() or QApplication([])
-
-
 @cache
 def _mp4_codecs() -> list:
     """The video codecs this machine can encode into an MP4 — asked
@@ -99,12 +87,21 @@ def unavailable_reason() -> str | None:
             'so an animation cannot be saved as a video here')
 
 
-def _rgba(frame: np.ndarray) -> np.ndarray:
-    """A screenshot as the RGBA the frame input is declared to take."""
-    frame = np.asarray(frame, dtype=np.uint8)
-    if frame.shape[2] == 3:
-        frame = np.dstack([frame, np.full(frame.shape[:2], 255, np.uint8)])
-    return np.ascontiguousarray(frame)
+def _image(frame: np.ndarray) -> Any:
+    """A screenshot as an RGBA QImage that owns its pixels — the encoder
+    reads a frame on its own thread, after the array may be gone. An
+    RGB screenshot is converted by Qt rather than padded in numpy: 0.07
+    against 3.5 ms a frame at 1024 × 768 (measured 2026-10-10)."""
+    from PySide6.QtGui import QImage
+
+    frame = np.ascontiguousarray(frame, dtype=np.uint8)
+    height, width, depth = frame.shape
+    if depth == 3:
+        return QImage(frame.data, width, height, 3 * width,
+                      QImage.Format.Format_RGB888).convertToFormat(
+                          QImage.Format.Format_RGBA8888)
+    return QImage(frame.data, width, height, 4 * width,
+                  QImage.Format.Format_RGBA8888).copy()
 
 
 def write_movie(path: str | Path, frames: Iterable[np.ndarray],
@@ -133,7 +130,6 @@ def write_movie(path: str | Path, frames: Iterable[np.ndarray],
     if reason is not None:
         raise MovieUnavailable(reason)
     from PySide6.QtCore import QEventLoop, QSize, QTimer, QUrl
-    from PySide6.QtGui import QImage
     from PySide6.QtMultimedia import (
         QMediaCaptureSession,
         QMediaFormat,
@@ -147,8 +143,8 @@ def write_movie(path: str | Path, frames: Iterable[np.ndarray],
     first = next(source_frames, None)
     if first is None:
         raise ValueError('an animation needs at least one frame')
-    first = _rgba(first)
-    height, width = first.shape[:2]
+    first = _image(first)
+    width, height = first.width(), first.height()
 
     path = Path(path).resolve()
 
@@ -191,8 +187,8 @@ def write_movie(path: str | Path, frames: Iterable[np.ndarray],
                 # still starting and keeps ten (2026-10-09). The next
                 # durationChanged sends on.
                 return
-            frame = state['pending']
-            if frame is None:
+            image = state['pending']
+            if image is None:
                 frame = next(state['frames'], None)
                 if frame is None:
                     # the end marker queues like a frame: refused when
@@ -200,22 +196,18 @@ def write_movie(path: str | Path, frames: Iterable[np.ndarray],
                     # stops — sent again on the next ready signal
                     state['ended'] = source.sendVideoFrame(QVideoFrame())
                     return
-                frame = _rgba(frame)
-                if frame.shape[:2] != (height, width):
+                image = _image(frame)
+                if (image.width(), image.height()) != (width, height):
                     # raised here it would vanish into Qt's slot call
                     state['error'] = 'the frames changed size mid-movie'
                     state['frames'] = iter(())
                     continue
-            # copied: the encoder reads the frame on its own thread,
-            # after this array may be gone
-            image = QImage(frame.data, width, height, 4 * width,
-                           QImage.Format.Format_RGBA8888).copy()
             video = QVideoFrame(image)
             video.setStartTime(state['sent'] * 1_000_000 // fps)
             video.setEndTime((state['sent'] + 1) * 1_000_000 // fps)
             if not source.sendVideoFrame(video):
                 # the encoder is full: keep this one for when it asks
-                state['pending'] = frame
+                state['pending'] = image
                 return
             state['pending'] = None
             state['sent'] += 1
@@ -240,18 +232,33 @@ def write_movie(path: str | Path, frames: Iterable[np.ndarray],
         state['frames'], state['pending'] = iter(()), None
         recorder.stop()
 
-    watchdog.timeout.connect(stalled)
-    source.readyToSendVideoFrame.connect(send)
-    recorder.durationChanged.connect(lambda _duration: send())
-    recorder.recorderStateChanged.connect(changed)
-    recorder.errorOccurred.connect(failed)
+    connected = ((watchdog.timeout, stalled),
+                 (source.readyToSendVideoFrame, send),
+                 (recorder.durationChanged, lambda _duration: send()),
+                 (recorder.recorderStateChanged, changed),
+                 (recorder.errorOccurred, failed))
+    for signal, slot in connected:
+        signal.connect(slot)
     recorder.record()
     if not state['finished']:
         loop.exec(QEventLoop.ProcessEventsFlag.ExcludeUserInputEvents)
     watchdog.stop()
+    # the slots hold the recorder, the input and the timer they are
+    # connected to — a cycle Python cannot see through Qt — so a save
+    # kept all of it alive for the life of the process until let go
+    for signal, slot in connected:
+        signal.disconnect(slot)
     if state['error']:
         raise RuntimeError(f'The movie could not be written: '
                            f'{state["error"]}')
+    # read back, not trusted: the pacing above leans on how one Qt
+    # buffers frames, and a Qt that buffers otherwise would write a
+    # short movie without a word (Principle 12 takes each Qt as it comes)
+    codec, kept = mp4_reading(path)
+    if codec != b'avc1' or kept != state['sent']:
+        raise RuntimeError(
+            f'The movie came out wrong: {kept} of {state["sent"]} frames '
+            f'as {(codec or b"nothing").decode(errors="replace")}')
     return state['sent']
 
 

{visualdynamics-0.1.0a42 → visualdynamics-0.1.0a43}/src/visualdynamics/gui/object_tables.py

@@ -9,6 +9,7 @@ beside them is not.
 from __future__ import annotations
 
 from collections.abc import Callable, Mapping, Sequence
+from functools import partial
 from typing import TYPE_CHECKING, Any
 
 import numpy as np
@@ -78,11 +79,10 @@ def matched_modes_model(matched: MatchedModes, objects: Mapping[str, Any],
     from ..core.tables import MATCHED_DECIMALS, cell_text, matched_rows
 
     headers, rows = matched_rows(matched, objects)
-    columns = [
-        Column(title, lambda s, r, i=i: s[r][i],
-               **({} if decimals is None else
-                  {'format': lambda v, d=decimals: cell_text(v, d)}))
-        for i, (title, decimals) in enumerate(zip(headers, MATCHED_DECIMALS))]
+    columns = [Column(title, lambda s, r, i=i: s[r][i],
+                      format=partial(cell_text, decimals=decimals))
+               for i, (title, decimals)
+               in enumerate(zip(headers, MATCHED_DECIMALS))]
     return TableModel(rows, columns, len, parent)
 
 

{visualdynamics-0.1.0a42 → visualdynamics-0.1.0a43}/src/visualdynamics/plot/__init__.py

@@ -1977,17 +1977,19 @@ def _beyond(values, up):
 
 
 def _application():
+    """A Qt application, made if a script has none — a plot rendered to a
+    file, and a movie being encoded, both need one.
+
+    A widgets application, not a QGuiApplication: Qt keeps the first
+    one made for the life of the process, and a script that later opens
+    a window would abort on its first widget.
+    """
     from PySide6.QtWidgets import QApplication
 
     return QApplication.instance() or QApplication([])
 
 
-#: the readings `plot_data(marks=...)` puts over a trace
-FLAT_READINGS = ('averaging', 'shocks', 'truncation', 'filter', 'octave')
-
-
-def octave_preview(items: Iterable[Any], psd: Any,
-                   per_octave: int | None, unit_system: Any,
+def octave_preview(items: Iterable[Any], steps: tuple[Any, Any, Any],
                    colors: Mapping[str, str],
                    records: Sequence[int] | None = None
                    ) -> list[tuple[Any, Any]]:
@@ -1998,16 +2000,12 @@ def octave_preview(items: Iterable[Any], psd: Any,
     window's octave view and `plot_data(marks='octave')`; returns the
     (plot, curve) pairs drawn.
 
-    Raises
-    ------
-    ValueError
-        When the spectrum cannot be banded.
+    `steps` is `viz.marks.octave_steps`' answer, banded once by the
+    caller, which reads the band count off the same banding.
     """
     import pyqtgraph as pg
 
-    from ..viz.marks import octave_steps
-
-    banded, x, rows = octave_steps(psd, per_octave, unit_system)
+    banded, x, rows = steps
     wanted = (range(rows.shape[0]) if records is None
               else [int(i) for i in records])
     pen = pg.mkPen(colors['filter_preview'], width=2)
@@ -2032,7 +2030,8 @@ def octave_preview(items: Iterable[Any], psd: Any,
 def _mark(layout, data, marks, theme=None, per_octave=None,
           unit_system=None):
     """A reading over every plot in `layout` — the frames, the shocks,
-    the cut, the filter's preview or the octave steps.
+    the cut, the filter's preview or the octave steps — as the window's
+    toggles draw it (`viz.marks.held_reading`).
 
     Locked, because a mark you can drag is a mark that reports the drag
     to somebody, and in a standalone plot there is nobody. Returns the
@@ -2040,51 +2039,37 @@ def _mark(layout, data, marks, theme=None, per_octave=None,
     """
     import pyqtgraph as pg
 
-    from ..core.averaging import Averaging
-    from ..core.data import Psd, TimeHistory
+    from ..viz.marks import held_reading, octave_steps
 
     if marks is None:
         return []
-    if marks not in FLAT_READINGS:
-        raise ValueError(f'{marks!r} is not a reading of a plot: '
-                         + ', '.join(repr(r) for r in FLAT_READINGS))
+    held = held_reading(data, marks)
     colors = resolve_theme(theme)
     plots = [item for item in layout.ci.items if isinstance(item, pg.PlotItem)]
     if marks == 'octave':
-        if not isinstance(data, Psd):
-            raise TypeError('octave bands read a PSD, not '
-                            f'{type(data).__name__}')
-        return octave_preview(plots, data, per_octave, unit_system, colors)
-    if not isinstance(data, TimeHistory):
-        raise TypeError(f'{marks} marks belong on a time history, not on '
-                        f'{type(data).__name__}')
+        return octave_preview(
+            plots, octave_steps(data, per_octave, unit_system), colors)
     if marks == 'shocks':
-        from ..core.shocks import suggest
         from .shocks import ShockOverlay
 
-        found = tuple(data.shocks or suggest(data))
-        return [ShockOverlay(plot, found, colors, locked=True)
+        return [ShockOverlay(plot, held, colors, locked=True)
                 for plot in plots]
     if marks == 'filter':
         from .filtering import FilterOverlay
 
-        filtering = data.filtering or data.suggest_filtering()
-        return [FilterOverlay(plot, filtering, data.sample_rate, colors)
+        return [FilterOverlay(plot, held, data.sample_rate, colors)
                 for plot in plots]
     if marks == 'truncation':
         from .truncation import TruncationOverlay
 
         abscissa = np.asarray(data.abscissa, dtype=float)
-        truncation = data.truncation or data.suggest_truncation()
-        return [TruncationOverlay(plot, truncation, float(abscissa[0]),
+        return [TruncationOverlay(plot, held, float(abscissa[0]),
                                   float(abscissa[-1]), colors)
                 for plot in plots]
     from .averaging import AveragingOverlay
 
-    samples = len(data.abscissa)
-    averaging = data.averaging or Averaging.for_records(samples)
-    return [AveragingOverlay(plot, averaging, data.sample_rate, samples,
-                             colors, locked=True)
+    return [AveragingOverlay(plot, held, data.sample_rate,
+                             len(data.abscissa), colors, locked=True)
             for plot in plots]