visualdynamics 0.1.0a40__tar.gz → 0.1.0a42__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: visualdynamics
-Version: 0.1.0a40
+Version: 0.1.0a42
 Summary: Structural Dynamics Visualization: a units-aware structural dynamics analysis toolset
 Author-email: Brandon Zwink <bzwink@gmail.com>
 License-Expression: MIT
@@ -73,11 +73,12 @@ file.
 
 **This is an alpha.** Every launch opens with a disclaimer to
 acknowledge: the software is offered as is, and its numbers are the
-user's to check against a tool they already trust. The project file,
-`.vdyn`, is provisional: the next alpha will save projects in the
-Engineering Sciences Common Data Format (`.h5`), a public standard,
-and will still open `.vdyn` files; the first release that is not an
-alpha will not. Open each `.vdyn` once in that alpha and save it again.
+user's to check against a tool they already trust. Projects are
+saved as `.vdyn` files, and Engineering Sciences Common Data Format
+(`.h5`) files are imported and exported for exchanging data with
+other tools. While Visual Dynamics is an alpha the `.vdyn` format may
+still change; the promise that a later version opens every earlier
+file starts with the first release that is not an alpha.
 
 **[Core principles](PRINCIPLES.md)** — thirteen principles
 that shape every part of it: data you can see and handle, a workflow

{visualdynamics-0.1.0a40 → visualdynamics-0.1.0a42}/README.md

@@ -16,11 +16,12 @@ file.
 
 **This is an alpha.** Every launch opens with a disclaimer to
 acknowledge: the software is offered as is, and its numbers are the
-user's to check against a tool they already trust. The project file,
-`.vdyn`, is provisional: the next alpha will save projects in the
-Engineering Sciences Common Data Format (`.h5`), a public standard,
-and will still open `.vdyn` files; the first release that is not an
-alpha will not. Open each `.vdyn` once in that alpha and save it again.
+user's to check against a tool they already trust. Projects are
+saved as `.vdyn` files, and Engineering Sciences Common Data Format
+(`.h5`) files are imported and exported for exchanging data with
+other tools. While Visual Dynamics is an alpha the `.vdyn` format may
+still change; the promise that a later version opens every earlier
+file starts with the first release that is not an alpha.
 
 **[Core principles](PRINCIPLES.md)** — thirteen principles
 that shape every part of it: data you can see and handle, a workflow

{visualdynamics-0.1.0a40 → visualdynamics-0.1.0a42}/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.0a40'
+__version__ = '0.1.0a42'
 
 
 def launch_gui(*paths: str, in_process: bool | None = None) -> Any:

{visualdynamics-0.1.0a40 → visualdynamics-0.1.0a42}/src/visualdynamics/core/channel_table.py

@@ -161,7 +161,7 @@ def _parse_date(text: str) -> str:
     value = value.split(' ')[0]        # a spreadsheet's midnight timestamp
     for form in _DATE_FORMATS:
         try:
-            return _datetime.datetime.strptime(  # noqa: DTZ007
+            return _datetime.datetime.strptime(
                 value, form).date().isoformat()
         except ValueError:
             continue

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

@@ -229,6 +229,18 @@ class _LogAbscissa:
         return cls._log_abscissa_default
 
 
+def _recast(obj: Any, cls: type) -> Any:
+    """`obj` as an instance of `cls`, every field copied — what reading
+    a PSD as a specification, or back, changes is the kind and nothing
+    else, so nothing is rebuilt through a constructor that might not
+    know a field (a declared-later unit, a dimension hint, a band)."""
+    import copy
+
+    out = cls.__new__(cls)
+    out.__dict__.update(copy.deepcopy(obj.__dict__))
+    return out
+
+
 class DataArray:
     """Base class; use a concrete subclass (TimeHistory, Spectrum, Frf, Psd).
 
@@ -1037,6 +1049,30 @@ class TimeHistory(DataArray):
     abscissa_dim = 'time'
     complex_ordinate = False
 
+    def animate(self, geometry: Any, records: Any = None,
+                **kwargs: Any) -> Any:
+        """The records moving on a geometry, sample by sample, as the
+        GUI plays a time history selected with one.
+
+        Parameters
+        ----------
+        geometry : Geometry
+            The geometry to move.
+        records : sequence of int, optional
+            Which records. One per DOF either way (`animation_records`).
+        **kwargs
+            Passed through to the scene: `screenshot=` for the still at
+            the furthest the model gets, `movie=` for the record once
+            through as an MP4, `seconds=` for how long that takes.
+
+        Returns
+        -------
+        object
+            The plotter, or the file written.
+        """
+        from ..viz.animate import animate_time
+        return animate_time(geometry, self, records, **kwargs)
+
     def compute_spectra(self) -> Spectrum:
         """The averaged spectrum of every channel — sdynpy's convention.
 
@@ -2976,6 +3012,30 @@ class Psd(_Bands, DataArray):
             self.ordinate: np.ndarray = np.ascontiguousarray(self.ordinate.real)
         self._take_bandwidth(bandwidth)
 
+    def as_specification(self) -> Specification:
+        """This PSD read as a specification: the same numbers, records,
+        units and bands, held as the requirement a measurement is judged
+        against, with no limits.
+
+        Nothing in a file says a PSD is a requirement when the format
+        has no word for one — ESCDF's data types do not, and a target
+        written by another program arrives as a PSD with only its name
+        to tell — so the person who knows says so (Brandon,
+        2026-10-09). A banded PSD steps, as a banded specification does;
+        otherwise its frequencies decide whether it reads as a
+        controller's lines or as breakpoints (`Specification.reading_of`).
+
+        Returns
+        -------
+        Specification
+            A copy; this PSD is unchanged.
+        """
+        spec = _recast(self, Specification)
+        spec.limits = {}
+        spec.interpolation = ('bin' if self.bandwidth is not None
+                              else Specification.reading_of(self.abscissa))
+        return spec
+
     def to_octave(self, per_octave: int | None = None,
                   low: float | None = None,
                   high: float | None = None) -> Psd:
@@ -3409,6 +3469,31 @@ class Specification(Bounded, Psd):
         with np.errstate(invalid='ignore'):
             return (np.isfinite(magnitude) & (magnitude > 0.0)).any(axis=0)
 
+    def as_psd(self) -> Psd:
+        """This specification read as a plain PSD — `Psd.as_specification`
+        undone, for a PSD read as a requirement by mistake. Its reading
+        of its own points is kept.
+
+        Returns
+        -------
+        Psd
+            A copy; this specification is unchanged.
+
+        Raises
+        ------
+        ValueError
+            When it has limits: a PSD has nowhere to keep them, and
+            dropping them unasked would lose what the file said.
+            `limit(name)` hands one out as a PSD of its own.
+        """
+        if self.limits:
+            raise ValueError(
+                'it carries warning or abort limits, which a PSD cannot '
+                'hold; take one out with limit(name) instead')
+        plain = _recast(self, Psd)
+        plain.__dict__.pop('limits', None)
+        return plain
+
     def to_octave(self, per_octave: int | None = None,
                   low: float | None = None,
                   high: float | None = None) -> Specification:

{visualdynamics-0.1.0a40 → visualdynamics-0.1.0a42}/src/visualdynamics/core/filters.py

@@ -54,6 +54,7 @@ double integration invents are set out.
 from __future__ import annotations
 
 from dataclasses import dataclass, replace
+from functools import cache
 from typing import TYPE_CHECKING, Any
 
 import numpy as np
@@ -94,11 +95,27 @@ def threaded_sosfiltfilt(sos: Any, rows: Any, axis: int = -1) -> np.ndarray:
     if rows.ndim < 2 or axis not in (-1, rows.ndim - 1) or rows.shape[0] < 2 \
             or rows.size < 1_000_000:
         return sosfiltfilt(sos, rows, axis=axis)
+    return np.stack(list(_filter_pool().map(
+        lambda row: sosfiltfilt(sos, row), rows)))
+
+
+@cache
+def _filter_pool() -> Any:
+    """The threads `threaded_sosfiltfilt` shares, made once and kept.
+
+    A pool per call started up to eight threads every time the filter
+    preview redrew. One gate run stalled for an hour inside exactly
+    that: the main thread in `Thread.start`, waiting on a new worker
+    that never said it had begun, from a render of the filter view
+    (2026-10-09; CPython 3.13.2, not reproduced in 1 200 calls). A kept
+    pool starts its threads once a session, so no redraw waits on a
+    thread being born — and skips the start-up besides.
+    """
     import os
     from concurrent.futures import ThreadPoolExecutor
 
-    with ThreadPoolExecutor(min(8, os.cpu_count() or 1)) as pool:
-        return np.stack(list(pool.map(lambda row: sosfiltfilt(sos, row), rows)))
+    return ThreadPoolExecutor(min(8, os.cpu_count() or 1),
+                              thread_name_prefix='visualdynamics-filter')
 
 
 @dataclass(frozen=True, kw_only=True)

{visualdynamics-0.1.0a40 → visualdynamics-0.1.0a42}/src/visualdynamics/core/geometry.py

@@ -950,6 +950,49 @@ class Geometry:
         self.cs_matrix = np.concatenate([self.cs_matrix, matrix[np.newaxis]])
         return cs_id
 
+    def place_coordinate_system(self, cs_id: int, *,
+                                origin: ArrayLike | None = None,
+                                angles: ArrayLike | None = None,
+                                rotation: ArrayLike | None = None) -> None:
+        """Turn a coordinate system, move it, or both — what the 3-D
+        view's rings and arrows do to one, as a call.
+
+        Parameters
+        ----------
+        cs_id : int
+            Which coordinate system.
+        origin : array_like, optional
+            Where it sits, in the geometry's stored length unit (meters
+            once its units are declared). Kept when omitted.
+        angles : array_like, optional
+            Its turn as degrees about the geometry's fixed X, then Y,
+            then Z axes (`rotate.frame_from_angles`) — the angles the
+            view's angle box and the box panel speak. (0, 0, 0) undoes
+            any turn. Kept when omitted.
+        rotation : array_like, optional
+            Its turn as a 3x3 matrix whose rows are its axes, instead
+            of `angles`.
+
+        Returns
+        -------
+        None
+        """
+        from ..rotate import frame_from_angles
+
+        rows = np.flatnonzero(self.cs_id == int(cs_id))
+        if not len(rows):
+            raise KeyError(f'no coordinate system {int(cs_id)}')
+        if angles is not None and rotation is not None:
+            raise ValueError('give the turn as angles or as a rotation, '
+                             'not both')
+        row = int(rows[0])
+        if angles is not None:
+            self.cs_matrix[row, :3] = frame_from_angles(angles)[:3]
+        elif rotation is not None:
+            self.cs_matrix[row, :3] = np.asarray(rotation, dtype=np.float64)
+        if origin is not None:
+            self.cs_matrix[row, 3] = np.asarray(origin, dtype=np.float64)
+
     def add_beams(self, node_ids: Ids, group: int | None = None,
                   color: int = 1, elem_type: int = 21) -> int:
         """A chain of two-node line elements through the given nodes, in

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

@@ -110,6 +110,76 @@ def aligned_mode(a: ShapeSet, i: int, b: ShapeSet, j: int) -> np.ndarray:
     return apply_alignment(b.shape_matrix[j], alignment_factor(a, i, b, j))
 
 
+def paired_mode(a: ShapeSet, i: int, b: ShapeSet, j: int,
+                projected: ShapeSet | None = None) -> np.ndarray:
+    """b's mode j, phase-aligned to swing with a's mode i when the two
+    are overlaid — over b's own coordinates.
+
+    Sets on one geometry share DOFs and align directly. Sets on two
+    geometries share none, so the alignment is measured against
+    `projected` — b carried onto a's DOFs (`correlate.project_shapes`)
+    — and applied to b's dense original. The one rule the window's
+    overlay, the report's and `ShapeSet.animate_pair` all draw by.
+    """
+    if projected is None:
+        return aligned_mode(a, i, b, j)
+    return apply_alignment(b.shape_matrix[j],
+                           alignment_factor(a, i, projected, j))
+
+
+def pair_scale_note(a_name: str, a: ShapeSet, b_name: str, b: ShapeSet,
+                    i: int, j: int) -> str | None:
+    """One line: how big this pair's second shape is against its first.
+
+    Overlaying scales each shape to its own peak, which is what makes a
+    sparse test set and a dense model comparable — and also what hides
+    one set being thirty times the other. So the number the overlay
+    cannot show is written above it.
+
+    **For the pair on screen, not for the sets.** A constant factor
+    across every mode is a unit or a normalization convention; a factor
+    that is 1.00 everywhere and 3.4 on one mode is that mode fitted
+    badly, and a figure averaged over the set hides exactly that.
+    `ScaleComparison.message` is the other reading — over a whole set,
+    at length — and the report still uses it.
+
+    Named by the objects rather than by their roles: a reader looking
+    at two animations wants to know which of the two things in front
+    of them is the bigger.
+    """
+    try:
+        ratios = compare_scaling(a, b, [(i, j)]).ratios
+    except (ValueError, IndexError):
+        return None
+    if not ratios.size or not np.isfinite(ratios[0]):
+        return None
+    # an unscaled fit has no drive point pinning its size, so the ratio
+    # is arithmetic rather than physics — said in a word, because the
+    # number is about to be read as if it meant one
+    unscaled = [name for name, shapes in ((a_name, a), (b_name, b))
+                if getattr(shapes, 'unscaled', False)]
+    note = f'{b_name}/{a_name} = {float(ratios[0]):.2f}'
+    return note + (f'  ({", ".join(unscaled)} unscaled)'
+                   if unscaled else '')
+
+
+def pair_caption(a_name: str, a: ShapeSet, b_name: str, b: ShapeSet,
+                 i: int, j: int) -> str:
+    """What the corner of an overlay says: each mode on a line of its
+    own — set, number, description, frequency, damping — and the scale
+    note under them (`pair_scale_note`)."""
+    def described(name: str, shape_set: ShapeSet, mode: int) -> str:
+        description = str(shape_set.description[mode]).strip()
+        return (f'{name}  mode {mode + 1}'
+                + (f'  {description}' if description else '')
+                + f'  {float(shape_set.frequency[mode]):.4f} Hz'
+                f'  {float(shape_set.damping[mode]) * 100:.3f} %')
+
+    caption = described(a_name, a, i) + '\n' + described(b_name, b, j)
+    scaling = pair_scale_note(a_name, a, b_name, b, i, j)
+    return caption + ('\n' + scaling if scaling else '')
+
+
 #: how far the two sets' levels may differ before it is worth saying so,
 #: as a fraction. Two properly mass-normalized sets of one structure in
 #: one unit system land far closer than this; a tenth is loose enough
@@ -819,6 +889,66 @@ class ShapeSet:
         from ..viz.animate import animate_shape
         return animate_shape(geometry, self, mode, **kwargs)
 
+    def animate_pair(self, geometry: Geometry, mode: int,
+                     other: ShapeSet, other_mode: int,
+                     other_geometry: Geometry | None = None, *,
+                     on_basis: bool = False,
+                     names: tuple[str, str] = ('first', 'second'),
+                     **kwargs: Any) -> Any:
+        """This mode and another set's overlaid, swinging together, as
+        the window animates a picked cell of the two sets' cross-MAC.
+
+        The other mode is phase-aligned to this one (`paired_mode`) and
+        each is scaled to its own peak, so the picture compares shape;
+        the caption names both modes and says how their sizes compare
+        (`pair_caption`). On two geometries the other set is projected
+        onto this one's DOFs to measure the alignment
+        (`correlate.project_shapes`), and drawn on its own geometry —
+        or, `on_basis`, the projection on this one's.
+
+        Parameters
+        ----------
+        geometry : Geometry
+            This set's geometry.
+        mode : int
+            This set's mode, by index.
+        other : ShapeSet
+            The set compared against.
+        other_mode : int
+            Its mode, by index.
+        other_geometry : Geometry, optional
+            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.
+        names : tuple of str
+            What the caption calls the two sets.
+        **kwargs
+            Passed through to `viz.animate.animate_pair`: `colors`,
+            `alphas`, `scale`, `screenshot=`, `movie=`.
+
+        Returns
+        -------
+        object
+            The plotter, the still, or the movie's path.
+        """
+        from ..viz.animate import animate_pair, pair_deflections
+
+        other_geometry = other_geometry or geometry
+        projected = None
+        if other_geometry is not geometry:
+            from .correlate import project_shapes
+            projected, _report = project_shapes(other, other_geometry,
+                                                self, geometry)
+        first, second = pair_deflections(self, mode, other, other_mode,
+                                         geometry, other_geometry,
+                                         projected, on_basis)
+        if not len(first[1].rows) or not len(second[1].rows):
+            raise ValueError('a set of the pair has no DOFs on its '
+                             'geometry')
+        kwargs.setdefault('caption', pair_caption(
+            names[0], self, names[1], other, mode, other_mode))
+        return animate_pair(first, second, **kwargs)
+
     def plot(self, geometry: Geometry | None = None, mode: int = 0,
              **kwargs: Any) -> Any:
         """The set's own reading: its auto-MAC, or one mode animated

visualdynamics-0.1.0a42/src/visualdynamics/core/tables.py

@@ -0,0 +1,117 @@
+"""What an object reads as, as a table: headers and rows of text.
+
+The app has table *models* — editable, colored, unit-aware, and Qt to
+the core. This is the other kind: the read-only rendering that goes in a
+report, and that a script wants when it asks what is in a channel table
+without opening a window.
+
+One implementation, because the report and a script asking the same
+question must not answer it differently.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+#: decimals each matched-modes column is read to, None for as-is
+MATCHED_DECIMALS = (None, 4, 3, None, 4, 3, None, 3, 2)
+
+
+def matched_rows(matched: Any, objects: Mapping[str, Any]
+                 ) -> tuple[list[str], list[tuple[Any, ...]]]:
+    """A MatchedModes object's table as values: headers, and a row per
+    pair — each set's mode number, frequency [Hz] and damping [%], the
+    frequency error against the first set (text, signed), the pair's
+    MAC, and the second set's size against the first's.
+
+    The sets are read live by name, so their parameters restate
+    themselves as the sets change, while the MAC is the object's own
+    stored value (it came from the comparison as displayed, possibly
+    projected). A set gone from `objects`, or a mode past its end,
+    reads None rather than a guess. The last column is the scale each
+    pair was normalized by, which an overlay — both shapes drawn to
+    their own peak — cannot show: 1.00 down it is the evidence that a
+    comparison is of shape alone.
+
+    The window's table and the report's draw these rows; `table_of`
+    is them as text.
+    """
+    from .shapes import scale_ratios
+
+    a_name, b_name = matched.first, matched.second
+    a, b = objects.get(a_name), objects.get(b_name)
+
+    def parameters(shape_set: Any,
+                   mode: int) -> tuple[float | None, float | None]:
+        if shape_set is None or not 0 <= mode < shape_set.num_shapes:
+            return None, None
+        return (float(shape_set.frequency[mode]),
+                float(shape_set.damping[mode]) * 100.0)
+
+    ratios = (scale_ratios(a, b, matched.pairs)
+              if a is not None and b is not None
+              else [None] * len(matched.pairs))
+    rows = []
+    for index, ((row, column), mac) in enumerate(
+            zip(matched.pairs, matched.macs)):
+        fa, da = parameters(a, row)
+        fb, db = parameters(b, column)
+        delta = (f'{(fb - fa) / fa * 100.0:+.2f}'
+                 if fa and fb is not None else '—')
+        rows.append((row + 1, fa, da, column + 1, fb, db, delta,
+                     float(mac), ratios[index]))
+    headers = [f'{a_name} Mode', 'Frequency [Hz]', 'Damping [%]',
+               f'{b_name} Mode', 'Frequency [Hz]', 'Damping [%]',
+               'Δf [%]', 'MAC', f'{b_name}/{a_name}']
+    return headers, rows
+
+
+def cell_text(value: Any, decimals: int | None) -> str:
+    """One matched-modes value as it is read: a dash for nothing."""
+    if value is None:
+        return '—'
+    return str(value) if decimals is None else f'{value:.{decimals}f}'
+
+
+def table_of(obj: Any, geometry: Any = None,
+             objects: Mapping[str, Any] | None = None
+             ) -> tuple[list[str], list[list[str]]] | None:
+    """(headers, rows) for an object that reads as a table, else None.
+
+    A shape set is its identified modal parameters; a channel table is
+    its instrumentation — with the direction columns a geometry
+    derives beside it, when one is given; matched modes are the pairs
+    beside both sets' parameters (`matched_rows`), read from the sets
+    in `objects`. Everything is text, formatted the way it is read
+    rather than the way it is stored — a damping of 0.0213 is '2.130'
+    percent, because that is the number an engineer quotes.
+    """
+    from .channel_table import ChannelTable
+    from .matches import MatchedModes
+    from .shapes import ShapeSet
+
+    if isinstance(obj, MatchedModes):
+        headers, rows = matched_rows(obj, objects or {})
+        return headers, [[cell_text(value, decimals) for value, decimals
+                          in zip(row, MATCHED_DECIMALS)] for row in rows]
+
+    if isinstance(obj, ShapeSet):
+        return (['Mode', 'Frequency [Hz]', 'Damping [%]', 'Description'],
+                [[str(m + 1), f'{float(obj.frequency[m]):.4f}',
+                  f'{float(obj.damping[m]) * 100:.3f}', obj.description[m]]
+                 for m in range(obj.num_shapes)])
+    if isinstance(obj, ChannelTable):
+        # every column, because the schema is already the curated set:
+        # a Rattlesnake save's coupling and feedback wiring stop at the
+        # importer now, so there is no acquisition plumbing left here to
+        # cut and no second list to keep in step with the first
+        from .channel_table import DERIVED_COLUMNS, title_of
+
+        names = obj.column_names
+        derived = list(DERIVED_COLUMNS) if geometry is not None else []
+        return ([title_of(name) for name in names + derived],
+                [[str(obj[name][r]) for name in names]
+                 + (obj.derived_cells(r, geometry) if derived else [])
+                 for r in range(obj.num_channels)])
+    return None

{visualdynamics-0.1.0a40 → visualdynamics-0.1.0a42}/src/visualdynamics/core/wavelet.py

@@ -113,6 +113,8 @@ influence are Torrence and Compo's.
 
 from __future__ import annotations
 
+from typing import Any
+
 import numpy as np
 from numpy.typing import ArrayLike
 
@@ -504,3 +506,42 @@ def default_range(sample_rate: float, duration: float) -> tuple[float, float]:
     low = (8.0 / float(duration)) if duration else high / 100.0
     low = min(max(low, nyquist / 1000.0), high / 2.0)
     return low, high
+
+
+def reading(history: Any, channel: int = 0, *, low: float | None = None,
+            high: float | None = None, per_octave: int | None = None,
+            omega0: float | None = None
+            ) -> tuple[np.ndarray, np.ndarray, np.ndarray, float]:
+    """One channel's scalogram as the app draws it, flat or in 3-D:
+    (clock, magnitude, frequencies, omega0).
+
+    Settings left out take the defaults the panel opens on
+    (`default_range`, `PER_OCTAVE`, `OMEGA0`); lines at or over Nyquist
+    are dropped, since the record cannot carry them. Time is held to
+    `COLUMNS` columns by peak-hold (`scalogram_peaks`), so a long
+    record reads in bounded memory and a transient's ridge is not
+    strided past. The clock is the record's own.
+
+    One implementation for the window, `plot.plot_scalogram` and
+    `viz.scalogram.plot_scalogram_stage`.
+
+    Raises
+    ------
+    ValueError
+        When fewer than two lines of the range lie under Nyquist.
+    """
+    rate = float(history.sample_rate)
+    values = np.real(np.asarray(history.ordinate)[channel])
+    duration = len(history.abscissa) / rate
+    default_low, default_high = default_range(rate, duration)
+    frequencies = log_frequencies(
+        default_low if low is None else low,
+        default_high if high is None else high,
+        PER_OCTAVE if per_octave is None else per_octave)
+    frequencies = frequencies[frequencies < rate / 2.0]
+    if frequencies.size < 2:
+        raise ValueError('no frequencies this record can carry in that '
+                         f'range; it reaches {rate / 2.0:g} Hz')
+    width = OMEGA0 if omega0 is None else float(omega0)
+    clock, magnitude = scalogram_peaks(values, rate, frequencies, width)
+    return clock + float(history.abscissa[0]), magnitude, frequencies, width

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

@@ -161,6 +161,15 @@ def main(argv: Sequence[str] | None = None) -> int:
     QApplication.setApplicationName('Visual Dynamics')
     QApplication.setApplicationDisplayName('Visual Dynamics')
     app = QApplication.instance() or QApplication(sys.argv[:1])
+    if '--check-movie' in argv:
+        # the packaged build's self-check, no window: can this install
+        # save an animation? (gui.movie.check — 0 yes, 2 no H.264 here)
+        from .movie import check
+
+        where = argv[argv.index('--check-movie') + 1:][:1] or ['check.mp4']
+        code, message = check(where[0])
+        print(message, flush=True)
+        return code
     from .icons import app_icon
 
     app.setWindowIcon(app_icon())

{visualdynamics-0.1.0a40 → visualdynamics-0.1.0a42}/src/visualdynamics/gui/disclaimer.py

@@ -35,12 +35,10 @@ TEXT = (
     'set of tests. Numbers it produces — modal parameters, spectra, '
     'levels, comparisons against a specification — are to be verified by '
     'independent means before anything depends on them.</p>'
-    '<p>The project file, <code>.vdyn</code>, is provisional. The next '
-    'alpha will save projects in the Engineering Sciences Common Data '
-    'Format (<code>.h5</code>), a public standard, and will still '
-    'open <code>.vdyn</code> files; the first release that is not an '
-    'alpha will not. Open each <code>.vdyn</code> once in that alpha and '
-    'save it again.</p>'
+    '<p>Projects are saved as <code>.vdyn</code> files. While this is '
+    'an alpha the <code>.vdyn</code> format may still change; the '
+    'promise that a later version opens every earlier file starts with '
+    'the first release that is not an alpha.</p>'
     '<p>Anything that looks wrong is worth reporting: '
     '<a href="mailto:contact@visualdynamics.org">contact@visualdynamics.org</a>.</p>'
 )