visualdynamics 0.1.0a42__tar.gz → 0.1.0a44__tar.gz

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

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

{visualdynamics-0.1.0a42 → visualdynamics-0.1.0a44}/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.0a44}/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.0a44}/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
@@ -771,6 +773,7 @@ class MainWindow(QMainWindow):
         self._gizmo_reading = None  # the drag's number, while it lasts
         self._sliding = None       # the arrow gesture in progress (2026-10-02)
         self._rotate_observers = []
+        self._gizmo_hovered = None  # ('ring' or 'arrow', axis) under the cursor
         self._last_axis = 2        # the ring a typed angle turns about
         self._pick_observers = []
         self._cursor = None
@@ -1138,7 +1141,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 +3184,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 +3207,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 +3236,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 +3776,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`.
@@ -5121,6 +5123,7 @@ class MainWindow(QMainWindow):
         self._rotate_observers = []
         self._rotating = None
         self._sliding = None
+        self._gizmo_hovered = None
         if self.scene.plotter is not None:
             for axis in range(3):
                 for kind in ('ring', 'arrow', 'head'):
@@ -5137,7 +5140,7 @@ class MainWindow(QMainWindow):
         span = np.ptp(_points, axis=0).max() if len(_points) > 1 else 1.0
         return 0.12 * (span or 1.0) * 1.15
 
-    def _draw_rings(self):
+    def _draw_rings(self, render=True):
         """Three rings, one about each of the frame's own axes."""
         import pyvista as pv
 
@@ -5152,18 +5155,22 @@ class MainWindow(QMainWindow):
             self.scene.plotter.add_mesh(
                 pv.lines_from_points(loop).tube(radius=radius * 0.03,
                                                 n_sides=12),
-                color=AXIS_COLORS[axis], name=f'rotate-ring-{axis}')
+                color=self._gizmo_color('ring', axis),
+                name=f'rotate-ring-{axis}')
             # and an arrow along each axis, for sliding (2026-10-02)
             shaft = arrow_points(matrix, axis, self._arrow_length(), steps=2)
             self.scene.plotter.add_mesh(
                 pv.lines_from_points(shaft).tube(radius=radius * 0.03,
                                                  n_sides=12),
-                color=AXIS_COLORS[axis], name=f'rotate-arrow-{axis}')
+                color=self._gizmo_color('arrow', axis),
+                name=f'rotate-arrow-{axis}')
             self.scene.plotter.add_mesh(
                 pv.Cone(center=shaft[-1], direction=matrix[axis],
                         height=radius * 0.3, radius=radius * 0.1),
-                color=AXIS_COLORS[axis], name=f'rotate-head-{axis}')
-        self.scene.plotter.render()
+                color=self._gizmo_color('arrow', axis),
+                name=f'rotate-head-{axis}')
+        if render:
+            self.scene.plotter.render()
 
     def _arrow_length(self):
         """An arrow reaches past the rings, so its head is clear of
@@ -5207,11 +5214,64 @@ class MainWindow(QMainWindow):
         radius = self._ring_radius()
         rings = []
         for axis in range(3):
+            points = ring_points(matrix, axis, radius)
+            # closed, as drawn, so the last stretch of ring is a line too
             projector = ScreenProjector(self.scene.plotter.renderer,
-                                        ring_points(matrix, axis, radius))
+                                        np.vstack([points, points[:1]]))
             rings.append((axis, projector.screen()[0]))
         return rings
 
+    def _gizmo_under_cursor(self, position):
+        """('arrow' or 'ring', axis) — what a press at `position` takes,
+        or None. One answer for the press and the hover, so what lights
+        up is what a press would grab. An arrow first: the arrows cross
+        the rings, and a press there is a slide, the gesture that needs
+        the origin."""
+        reach = self._gizmo_reach()
+        axis = ring_under_cursor(self._arrow_screen_points(), position, reach)
+        if axis is not None:
+            return 'arrow', axis
+        axis = ring_under_cursor(self._ring_screen_points(), position, reach)
+        return None if axis is None else ('ring', axis)
+
+    def _gizmo_color(self, kind, axis):
+        """An axis's own color, or the scene's highlight — the color a
+        hovered node takes — while that ring or arrow is under the
+        cursor (2026-10-10)."""
+        if self._gizmo_hovered == (kind, axis):
+            return resolve_theme(self.theme_name)['scene_highlight']
+        return AXIS_COLORS[axis]
+
+    def _hover_gizmo(self):
+        """Light the ring or arrow under the cursor, so a press lands
+        knowing what it will take. Not while a button is down: an orbit
+        sweeps the rings past the cursor, and nothing there is on
+        offer."""
+        position = self._cursor_position()
+        if position is None or self.scene.plotter is None:
+            return
+        part = None
+        if QApplication.mouseButtons() == Qt.MouseButton.NoButton:
+            part = self._gizmo_under_cursor(position)
+        if part == self._gizmo_hovered:
+            return                      # nothing changed, so nothing to redraw
+        self._gizmo_hovered = part
+        actors = self.scene.plotter.renderer.actors
+        for axis in range(3):
+            for kind, name in (('ring', 'ring'), ('arrow', 'arrow'),
+                               ('arrow', 'head')):
+                actor = actors.get(f'rotate-{name}-{axis}')
+                if actor is not None:
+                    actor.prop.color = self._gizmo_color(kind, axis)
+        self.scene.plotter.render()
+
+    def _gizmo_reach(self):
+        """How near a ring or an arrow a press must land: 14 points,
+        counted in the device pixels VTK reports the cursor and projects
+        the rings in. Counted in pixels until 2026-10-10, which on a
+        Retina screen — two pixels to the point — was a 7-point target."""
+        return 14.0 * self.devicePixelRatioF()
+
     def _abort(self, caller, observer):
         """Stop VTK passing this event on to the camera."""
         with contextlib.suppress(Exception):
@@ -5221,10 +5281,11 @@ class MainWindow(QMainWindow):
         position = self._cursor_position()
         if position is None:
             return
-        # an arrow first: the arrows cross the rings at the origin, and
-        # a press there is a slide, the gesture that needs the origin
-        axis = ring_under_cursor(self._arrow_screen_points(), position)
-        if axis is not None:
+        part = self._gizmo_under_cursor(position)
+        if part is None:
+            return                      # not on the gizmo: let the camera have it
+        kind, axis = part
+        if kind == 'arrow':
             row, matrix = self._rotating_frame()
             world = self._cursor_on_axis(matrix, axis, position)
             if world is None:
@@ -5235,9 +5296,6 @@ class MainWindow(QMainWindow):
                 'from': distance_along(self._display_frame(matrix), axis, world)}
             self._abort(caller, self._rotate_observers[0])
             return
-        axis = ring_under_cursor(self._ring_screen_points(), position)
-        if axis is None:
-            return                      # not on a ring: let the camera have it
         row, matrix = self._rotating_frame()
         world = self._cursor_on_ring(matrix, axis, position)
         if world is None:
@@ -5265,6 +5323,7 @@ class MainWindow(QMainWindow):
             self._abort(caller, self._rotate_observers[1])
             return
         if self._rotating is None:
+            self._hover_gizmo()
             return
         position = self._cursor_position()
         if position is None:
@@ -5375,14 +5434,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."""
@@ -5799,7 +5852,7 @@ class MainWindow(QMainWindow):
 
     def hover_at(self, x: float, y: float) -> int | None:
         """Light up whatever is under this pixel; returns the entity."""
-        entity = self._picker.pick(x, y)
+        entity = self._picker.pick(x, y, pixel_ratio=self.devicePixelRatioF())
         if entity == self._hovered:
             return entity        # nothing changed, so nothing to redraw
         self._hovered = entity
@@ -6007,6 +6060,12 @@ class MainWindow(QMainWindow):
         # scene, and a rebuilt scene would otherwise re-frame itself
         self.scene.set_home_view(geometry.opening_view, geometry)
         self.scene.plotter.camera_position = camera
+        if self._rotate_observers:
+            # the clear above took the rings with it, and every committed
+            # drag comes through here (its row refresh is an edit): until
+            # 2026-10-10 they vanished after the first turn while still
+            # answering clicks where they had been
+            self._draw_rings(render=False)
         self.scene.plotter.render()
 
     def _add_hover_mesh(self, geometry, colors):
@@ -8336,7 +8395,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 +8417,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."""
@@ -8495,7 +8552,9 @@ class MainWindow(QMainWindow):
             if start is None:
                 return
             end = iren.interactor.GetEventPosition()
-            if abs(end[0] - start[0]) <= 3 and abs(end[1] - start[1]) <= 3:
+            # 3 points of slop, in the device pixels VTK reports
+            slop = 3 * self.devicePixelRatioF()
+            if abs(end[0] - start[0]) <= slop and abs(end[1] - start[1]) <= slop:
                 self._mac_bars_clicked(end)
 
         iren.add_observer('LeftButtonPressEvent', pressed)
@@ -9809,20 +9868,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 +10380,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 +11873,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 +11882,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 +12394,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 +13315,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 +13355,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 +13384,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 +13429,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 +13458,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