diff --git a/CLAUDE.md b/CLAUDE.md index 878dec1..5cea484 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -412,21 +412,29 @@ persistence) → GUI (Qt widgets that read the manager and connect to its signal `tests/kaleidostrobe_golden.npz` was recorded from the emulated original and `test_round84` holds the port to it byte for byte. -- **`gui/visualizer_lint.py`** — Lint Oontz, the fifth style (Round 122, - `lint`): one line-drawn lint ball in big headphones on the panel's gray. +- **`gui/visualizer_lint.py`** — Lint Oontz, the fifth style (Rounds + 122–123, `lint`): one line-drawn lint ball in big headphones on the + panel's gray, in **three-quarter view** (default: face turned to our + right, the near cup seen whole, the far one clipped to what shows past + the ball) or **head on** (`visualizer_lint_head_on`, Preferences' View + combo; in `STYLE_KEYS`). The ball is filled with the panel colour so + what's behind it (legs' tops, the far arm in 3/4) is hidden. **Stop motion**: the renderer steps at 8 fps on its own clock and `advance` is True only on a step; every step re-rolls each line's wobble - (seeded by step, so one step always draws the same) and nothing is ever - tweened. A bass onset (energy `ONSET_RATIO` over its own average) dips - the head and bends the knees; the arms dance only when the onset tempo - is ≥ `BUSY_BPM` *and* the spectrum is full (`BUSY_FULLNESS`, calibrated - on pink noise vs. sparse tones), otherwise they hang. Quiet (or paused, - `clear()`) → it **sits** after `SIT_AFTER_S` and **sleeps** after - `SLEEP_AFTER_S`. Two renderer flags the widget reads: `idles` keeps the - 60 Hz timer running with nothing playing (fed silence, never the old - song's tail) so it can fall asleep, and `black_mode` adds `MODE_BLACK` - to the colour wheel (colour → gray → black → off) — for any other style - a saved black reads as colour. No settings yet (no `STYLE_KEYS` entry). + (seeded by step) and nothing is ever tweened. A bass onset **nods** the + head (rotated about the neck in 3/4; head on, the face drops) — the legs + no longer crouch on the bass. Busy (onset tempo ≥ `BUSY_BPM` *and* a full + spectrum) → one of `MOVES`: ten arm+leg moves in three tiers; the tier is + `now` fullness (1.5 s) against `TIER_EDGES`, ±1 when `now` is `LIFT` over + or under `lately` (12 s) — a build or a drop. A tier change that holds 2 + beats switches the move; every 16 beats it may switch within the tier. + Not busy: arms hang, it only nods. Quiet/nothing playing: stands, sits + at `SIT_AFTER_S` (10), sleeps at `SLEEP_AFTER_S` (30); `clear()` does + nothing, so skipping songs never sits it down. Two renderer flags the + widget reads: `idles` keeps the 60 Hz timer running with nothing playing + (fed silence, never the old song's tail), and `black_mode` adds + `MODE_BLACK` to the colour wheel (colour → gray → black → off) — for any + other style a saved black reads as colour. - **`lintunes/dj/`** + **`gui/dj_shelf.py`** — DJ mode (Round 93; View › DJ Mode or the turntable button under BPM). The window parts **under the diff --git a/lintunes/__init__.py b/lintunes/__init__.py index b728512..564e017 100644 --- a/lintunes/__init__.py +++ b/lintunes/__init__.py @@ -1,3 +1,3 @@ """LinTunes — iTunes-style music library manager and player for Linux.""" -__version__ = "0.88.1" +__version__ = "0.89.0" diff --git a/lintunes/gui/preferences_dialog.py b/lintunes/gui/preferences_dialog.py index ef6da86..91d9b6f 100644 --- a/lintunes/gui/preferences_dialog.py +++ b/lintunes/gui/preferences_dialog.py @@ -873,12 +873,23 @@ class PreferencesDialog(QDialog): lint = QWidget() form = self._viz_form(lint) + self._preset_row(form, "lint") self._sync_delay_slider(form, "lint") + view = QComboBox() + view.addItems(["Three-quarter", "Head on"]) + view.setSizeAdjustPolicy(QComboBox.SizeAdjustPolicy.AdjustToContents) + view.setCurrentIndex(int(config["visualizer_lint_head_on"])) # before connect + view.setToolTip("Turned a little to one side, one headphone cup " + "behind its head — or facing you") + view.currentIndexChanged.connect( + lambda i: self._prefs.set("visualizer_lint_head_on", i == 1)) + self._viz_setters["visualizer_lint_head_on"] = ( + lambda value: view.setCurrentIndex(int(bool(value)))) + form.addRow("View:", view) about = QLabel( "A ball of lint in headphones: it bobs to the bass, dances when " "the music is fast and full, sits down when it goes quiet and " - "falls asleep after a while. The colour wheel adds black for it. " - "No settings yet.") + "falls asleep after a while. The colour wheel adds black for it.") about.setWordWrap(True) about.setEnabled(False) form.addRow(about) diff --git a/lintunes/gui/visualizer_lint.py b/lintunes/gui/visualizer_lint.py index d3407f5..fe0186f 100644 --- a/lintunes/gui/visualizer_lint.py +++ b/lintunes/gui/visualizer_lint.py @@ -1,34 +1,47 @@ -"""Lint Oontz: a ball of lint in headphones, dancing (Round 122). +"""Lint Oontz: a ball of lint in headphones, dancing (Rounds 122–123). A very rough line drawing, animated like stop motion: the renderer steps at ``FPS`` (8) on its own clock and each step is a new pose with every line re-wobbled, never an in-between — no tweening. Each step costs one repaint; the widget's 60 Hz timer only feeds it audio (silence while nothing plays: -``idles``, so it keeps its clock and can fall asleep). +``idles``, so it keeps its clock and can sit down and fall asleep). What the music does to it: -- **bass** → the head bob. A bass onset (energy well over its own recent - average) dips the ball and bends the knees; between beats it springs back. -- **busy** → the arms. When the beats come fast (``BUSY_BPM`` or more, - counted from the onsets themselves) *and* the spectrum is full - (``BUSY_FULLNESS``), every beat throws a new arm pose and the feet step. - Otherwise the arms hang and only the head bobs. -- **quiet** (or nothing playing) → it sits down after ``SIT_AFTER_S``, and - after ``SLEEP_AFTER_S`` lies down to sleep (closed eyes, rising z's), - until the music comes back. +- **bass** → the head **nods**: on a bass onset (energy well over its own + recent average) the head tips forward and comes back over two steps. + Three-quarter view rotates it; head on, the face drops (a nod towards + you can't be a rotation). +- **busy** (the onsets come at ``BUSY_BPM`` or faster *and* the spectrum is + full, ``BUSY_FULLNESS``) → it **dances**: one of ``MOVES``, ten arm (and + leg) moves in three intensity tiers. The tier is how full the music is + now, raised a step when it is fuller than it has been lately (a drop, a + build) and lowered when it thinned out. A tier that changes and holds + for two beats switches the move — a shift in the music, a new move — + and every 16 beats it may change move within the tier anyway. Not busy, + the arms hang and it only nods. +- **quiet** (or nothing playing) → it stands waiting, sits after + ``SIT_AFTER_S`` and lies down to sleep after ``SLEEP_AFTER_S``, until + the music comes back. Skipping between songs never sits it down. + +Two views (``visualizer_lint_head_on``): three-quarter (the default: the +face turned to one side, one headphone cup seen whole and the other behind +the ball) or head on. Same moves in both. The lines are the colour the wheel picks — highlight, gray or black (``black_mode``: this style adds black to the wheel) — on the panel's gray. +The ball is filled with the panel's colour, so what is behind it is hidden. """ import math +from dataclasses import dataclass import numpy as np from PyQt6.QtCore import QPointF, QRectF, Qt -from PyQt6.QtGui import QColor, QPainterPath, QPen +from PyQt6.QtGui import QColor, QPainterPath, QPen, QTransform STYLE = "lint" +HEAD_ON_KEY = "visualizer_lint_head_on" FPS = 8 # stop motion: a new drawing this often STEP_S = 1.0 / FPS INSET = 3 @@ -45,39 +58,89 @@ BUSY_FULLNESS = 0.28 # mean band level (0..1) of a "full" spectrum: # mix of a few tones 0.12-0.14 CALM_AFTER_S = 2.0 # busy has to be gone this long to stop dancing QUIET_DB = -48.0 # RMS under this is quiet -SIT_AFTER_S = 1.5 -SLEEP_AFTER_S = 20.0 +SIT_AFTER_S = 10.0 # standing, waiting for the music, until then +SLEEP_AFTER_S = 30.0 WAKE_AFTER_S = 0.3 FULLNESS_BANDS = 16 -# Arm poses as (left, right) shoulder angles in degrees from straight down, -# outward positive, plus each elbow's extra bend. -HANG = ((18, 8), (18, 8)) -LYING = ((4, 0), (4, 0)) # asleep: arms along the body -SITTING = ((48, -20), (48, -20)) # hands down on the floor beside it -BLINK_EVERY = 29 # steps; one closed-eye drawing each time +# Intensity: how full the music is over the last ~1.5 s, against the last +# ~12 s. Pink noise reads 0.31 at -20 dB RMS and 0.43 at -14. +NOW_S, LATELY_S = 1.5, 12.0 +TIER_EDGES = (0.34, 0.42) # below the first: tier 0; past the second: 2 +LIFT = 0.05 # fuller than lately by this much: a tier up +TIER_HOLD_BEATS = 2 # a new tier must last this long to change move +SWITCH_EVERY = 16 # beats; then maybe a new move in the same tier +NOD_DEG = 15 # three-quarter: the head tips this far +NOD_DROP = 0.2 # head on: the face drops this share of r + +BLINK_EVERY = 29 # steps; one closed-eye drawing each time STAND, SIT, SLEEP = "stand", "sit", "sleep" -DANCE = ( - ((150, -30), (30, 20)), # left up - ((140, -20), (140, -20)), # both up - ((30, 20), (150, -30)), # right up - ((90, 40), (90, 40)), # both out, bent + +# An arm is (shoulder, elbow bend) in degrees: the upper arm's angle from +# straight down, outward positive (180 = straight up, past it = across the +# head or body), and the forearm's angle relative to it. +HANG = ((18, 8), (18, 8)) +LYING = ((4, 0), (4, 0)) # asleep: arms along the body +SITTING = ((48, -20), (48, -20)) # hands down on the floor beside it + + +@dataclass(frozen=True) +class Move: + name: str + tier: int # 0 low, 1 mid, 2 high + cadence: int # stop-motion steps per frame; 0 = one per beat + frames: tuple # ((left arm, right arm, legs), ...) + + +def _wave_frames(): + """Arms out, a wave running from the left hand through to the right.""" + frames = [] + for k in range(8): + p = 2 * math.pi * k / 8 + left = (90 + 25 * math.sin(p), 45 * math.sin(p - 1.3)) + right = (90 + 25 * math.sin(p - math.pi), + 45 * math.sin(p - math.pi - 1.3)) + frames.append((left, right, "wide")) + return tuple(frames) + + +def _windmill_frames(): + frames = [] + for k in range(8): + a = k * 45 + frames.append((((a + 180) % 360, 0), (a, 0), + "wide" if k % 2 else "stand")) + return tuple(frames) + + +MOVES = ( + # ---- tier 0: a bit going on ---- + Move("sway", 0, 0, (((-10, 5), (40, 10), "step_r"), + ((40, 10), (-10, 5), "step_l"))), + Move("snap", 0, 0, (((25, 115), (20, 30), "knee_l"), + ((20, 30), (25, 115), "knee_r"))), + Move("shimmy", 0, 2, (((75, 55), (50, 55), "stand"), + ((50, 55), (75, 55), "stand"))), + # ---- tier 1: going ---- + Move("point", 1, 0, (((45, -110), (150, 0), "step_r"), + ((45, -110), (-25, 0), "stand"), + ((150, 0), (45, -110), "step_l"), + ((-25, 0), (45, -110), "stand"))), + Move("wave", 1, 1, _wave_frames()), + Move("pump", 1, 0, (((40, -110), (165, 0), "kick_l"), + ((40, -110), (100, 80), "stand"))), + Move("robot", 1, 0, (((90, 90), (90, -90), "knee_l"), + ((90, -90), (90, 90), "knee_r"))), + # ---- tier 2: the drop ---- + Move("hands up", 2, 0, (((165, 25), (165, 25), "jump"), + ((150, -15), (150, -15), "stand"))), + Move("raise the roof", 2, 0, (((135, 45), (135, 45), "wide"), + ((105, 75), (105, 75), "wide"))), + Move("windmill", 2, 1, _windmill_frames()), ) -class _Figure: - """One lint ball: its fixed fuzz profile and its own pose.""" - - def __init__(self, index: int): - rng = np.random.default_rng(7919 * (index + 1)) - self.index = index - self.radii = 1.0 + rng.uniform(-0.09, 0.09, 26) - self.hairs = rng.uniform(0, 2 * math.pi, 9) - self.hair_len = rng.uniform(0.12, 0.3, 9) - self.pose = 0 - - class LintRenderer: name = STYLE black_mode = True # the wheel offers black for this style @@ -86,7 +149,12 @@ class LintRenderer: panel = QColor(200, 200, 200) # set by the widget: the background def __init__(self, config=None): - self._fig = _Figure(0) + rng = np.random.default_rng(7919) + self._radii = 1.0 + rng.uniform(-0.09, 0.09, 26) + self._hairs = rng.uniform(0, 2 * math.pi, 9) + self._hair_len = rng.uniform(0.12, 0.3, 9) + self._rng = np.random.default_rng(104729) + self.head_on = False self._behind = 0.0 self._clock = 0.0 self.step = 1 # 0 would be a blink @@ -94,34 +162,33 @@ class LintRenderer: self._last_beat = -1.0 self._beats = [] self._beat_pending = False - self.bob = 0.0 + self.nod = 0.0 self.fullness = 0.0 + self.now = 0.0 # fullness over NOW_S + self.lately = 0.0 # … and over LATELY_S self.busy = False self._calm_for = 0.0 self._quiet_for = SIT_AFTER_S # nothing has played yet: sitting self._loud_for = 0.0 self.posture = SIT - self.feet = 0 + self.move = None # a Move while dancing + self._frame = 0 # which of its frames + self._move_beats = 0 # beats since the move began + self._new_tier = None # (tier, beats it has held) + self.configure(config or {}) # ---- the renderer contract ---- def configure(self, config): - pass # no settings yet + self.head_on = bool(config.get(HEAD_ON_KEY, False)) @property def asleep(self) -> bool: return self.posture == SLEEP def clear(self): - """Stopped or paused: it sits down (and sleeps, given time).""" - self._quiet_for = max(self._quiet_for, SIT_AFTER_S) - self._loud_for = 0.0 - if self.posture == STAND: - self.posture = SIT - self.busy = False - self.bob = 0.0 - self._beats.clear() - self.step += 1 + """Paused or stopped. Nothing changes here: the quiet clock (fed + silence) sits it down in its own time, so skipping songs doesn't.""" @property def tempo(self) -> float: @@ -131,6 +198,15 @@ class LintRenderer: return 0.0 return 60.0 * (len(recent) - 1) / max(1e-6, recent[-1] - recent[0]) + @property + def tier(self) -> int: + base = 0 if self.now < TIER_EDGES[0] else 1 if self.now < TIER_EDGES[1] else 2 + if self.now - self.lately > LIFT: + base += 1 + elif self.lately - self.now > LIFT: + base -= 1 + return max(0, min(2, base)) + def advance(self, frame) -> bool: dt = max(0.0, frame.dt) self._clock += dt @@ -166,7 +242,10 @@ class LintRenderer: spectrum, freqs = spectrum_of(frame.samples, FFT, frame.rate) lo, hi = np.searchsorted(freqs, BASS_HZ) bass = float(np.sum(np.square(spectrum[lo:hi]))) - keep = math.exp(-dt / AVERAGE_S) if dt > 0 else 1.0 + + def keep(seconds): + return math.exp(-dt / seconds) if dt > 0 else 1.0 + if (db >= QUIET_DB and bass > ONSET_RATIO * self._bass_avg and bass > 1e-5 and self._clock - self._last_beat >= ONSET_GAP_S): @@ -175,10 +254,18 @@ class LintRenderer: self._beat_pending = True self._beats = [t for t in self._beats if self._clock - t <= TEMPO_WINDOW_S] - self._bass_avg = keep * self._bass_avg + (1 - keep) * bass - levels = band_levels(spectrum, freqs, - band_edges(FULLNESS_BANDS, frame.rate)) - self.fullness = keep * self.fullness + (1 - keep) * float(levels.mean()) + k = keep(AVERAGE_S) + self._bass_avg = k * self._bass_avg + (1 - k) * bass + if db >= QUIET_DB: # silence between songs isn't "thinner music" + full = float(band_levels( + spectrum, freqs, band_edges(FULLNESS_BANDS, frame.rate)).mean()) + if not self.lately: # the first music heard: nothing to lift from + self.now = self.lately = full + self.fullness = k * self.fullness + (1 - k) * full + k = keep(NOW_S) + self.now = k * self.now + (1 - k) * full + k = keep(LATELY_S) + self.lately = k * self.lately + (1 - k) * full wants = self.tempo >= BUSY_BPM and self.fullness >= BUSY_FULLNESS if wants: @@ -191,20 +278,60 @@ class LintRenderer: # ---- posing (every stop-motion step) ---- + def _pick(self, tier: int): + choices = [m for m in MOVES if m.tier == tier and m is not self.move] + self.move = choices[int(self._rng.integers(len(choices)))] + self._frame = 0 + self._move_beats = 0 + self._new_tier = None + def _pose(self): self.step += 1 + beat = self._beat_pending + self._beat_pending = False if self.posture != STAND: - self.bob = 0.0 - self._beat_pending = False + self.nod = 0.0 return - if self._beat_pending: - self._beat_pending = False - self.bob = 1.0 - if self.busy: - self.feet ^= 1 - self._fig.pose = (self._fig.pose + 1) % len(DANCE) - else: - self.bob = 0.35 if self.bob >= 1.0 else 0.0 + self.nod = 1.0 if beat else (0.45 if self.nod >= 1.0 else 0.0) + if not self.busy: + self.move = None + return + tier = self.tier + if self.move is None: + self._pick(tier) + elif beat: + self._move_beats += 1 + if tier != self.move.tier: + held = (self._new_tier[1] + 1 if self._new_tier + and self._new_tier[0] == tier else 1) + self._new_tier = (tier, held) + if held >= TIER_HOLD_BEATS: + self._pick(tier) + return + else: + self._new_tier = None + if self._move_beats >= SWITCH_EVERY: + self._move_beats = 0 + if self._rng.random() < 0.5: + self._pick(tier) + return + if self.move.cadence == 0: + if beat: + self._frame = (self._frame + 1) % len(self.move.frames) + elif self.step % self.move.cadence == 0: + self._frame = (self._frame + 1) % len(self.move.frames) + + def _limbs(self): + """(left arm, right arm, legs) for this step.""" + if self.posture == SLEEP: + return LYING[0], LYING[1], "stand" + if self.posture == SIT: + return SITTING[0], SITTING[1], "sit" + if self.move is not None: + return self.move.frames[self._frame % len(self.move.frames)] + swing = 6 * self.nod # a hanging arm swings with the nod + return ((HANG[0][0] + swing, HANG[0][1]), + (HANG[1][0] + swing, HANG[1][1]), "stand") # ---- drawing ---- @@ -214,16 +341,16 @@ class LintRenderer: return painter.save() painter.setRenderHint(painter.RenderHint.Antialiasing) - self._paint_figure(painter, area, self._fig, QColor(color)) + self._paint_figure(painter, area, QColor(color)) painter.restore() - def _paint_figure(self, painter, cell, fig, ink): - # The ball's radius: room for headphones either side and legs below, - # or (asleep) lying full length. - r = min(cell.width() / 3.9, cell.height() / 4.2) + def _paint_figure(self, painter, cell, ink): + # The ball's radius: room for arms either side, the band above and + # legs below — or, asleep, lying full length. + r = min(cell.width() / 4.4, cell.height() / 4.6) if self.posture == SLEEP: r = min(r, cell.width() / 4.6, cell.height() / 2.8) - rng = np.random.default_rng(self.step * 31 + fig.index) + rng = np.random.default_rng(self.step * 31) wob = max(0.4, r * 0.06) def j(x, y): @@ -244,122 +371,187 @@ class LintRenderer: head = cx - r * 0.75 painter.translate(head, ground - r * 1.4) painter.rotate(-90) - self._body(painter, fig, r, 0.0, j, SLEEP) + self._body(painter, r, j, 0.0) painter.restore() - self._zzz(painter, head + r * 0.5, ground - r * 3.0, r, fig, j) + self._zzz(painter, head + r * 0.5, ground - r * 3.0, r, j) return if self.posture == SIT: painter.translate(cx, ground - r * 1.1) # the ball on the floor - self._body(painter, fig, r, 0.0, j, SIT) - painter.restore() - return - legs = r * 1.25 - dip = self.bob * r * 0.22 - painter.translate(cx, ground - legs - r + dip) - self._body(painter, fig, r, dip, j, STAND) + else: + lift = r * 0.35 if self._limbs()[2] == "jump" else 0.0 + painter.translate(cx, ground - r * 2.25 - lift) + self._body(painter, r, j, self.nod) painter.restore() - def _body(self, painter, fig, r, dip, j, posture): - """The figure drawn around its ball's centre (0, 0), feet at +y.""" - asleep = posture == SLEEP - blink = posture == SIT and self.step % BLINK_EVERY == 0 - # The fuzzy ball: a wobbly ring plus a few loose hairs. - n = len(fig.radii) + def _body(self, painter, r, j, nod): + """The figure around its ball's centre (0, 0), feet at +y.""" + posture = self.posture + three_q = not self.head_on + left_arm, right_arm, legs = self._limbs() + # The head (ball, face, headphones) nods about the neck: tipped in + # three-quarter view, the face dropped head on. + pivot = QPointF(0, r * 0.85) + tilt = QTransform() + if three_q and nod: + tilt.translate(pivot.x(), pivot.y()) + tilt.rotate(NOD_DEG * nod) + tilt.translate(-pivot.x(), -pivot.y()) + drop = 0.0 if three_q else NOD_DROP * r * nod + + if three_q: + shoulders = {-1: (-r * 0.92, r * 0.3), 1: (r * 0.82, r * 0.38)} + hips = {-1: -r * 0.3, 1: r * 0.42} + else: + shoulders = {-1: (-r * 0.92, r * 0.3), 1: (r * 0.92, r * 0.3)} + hips = {-1: -r * 0.35, 1: r * 0.35} + shoulders = {s: tilt.map(QPointF(*p)) for s, p in shoulders.items()} + + # Behind the ball: the legs (their tops hidden), and in + # three-quarter view the far arm and the far headphone cup. + self._legs(painter, r, j, legs, hips) + if three_q: + self._arm(painter, r, j, 1, shoulders[1], right_arm) + painter.save() + painter.setTransform(tilt, True) + if three_q: + outside = QPainterPath() + outside.addRect(QRectF(-3 * r, -3 * r, 6 * r, 6 * r)) + ball = QPainterPath() + ball.addEllipse(QPointF(0, 0), r * 1.02, r * 1.02) + painter.save() + painter.setClipPath(outside.subtracted(ball), + Qt.ClipOperation.IntersectClip) + painter.drawEllipse(j(r * 0.98, -r * 0.05), r * 0.2, r * 0.4) + painter.restore() + + # The fuzzy ball, filled with the panel so what's behind is hidden. + n = len(self._radii) ring = QPainterPath() for i in range(n + 1): a = 2 * math.pi * (i % n) / n - p = j(math.cos(a) * r * fig.radii[i % n], - math.sin(a) * r * fig.radii[i % n]) + p = j(math.cos(a) * r * self._radii[i % n], + math.sin(a) * r * self._radii[i % n]) ring.moveTo(p) if i == 0 else ring.lineTo(p) + painter.setBrush(QColor(self.panel)) painter.drawPath(ring) - for a, length in zip(fig.hairs, fig.hair_len): + painter.setBrush(Qt.BrushStyle.NoBrush) + for a, length in zip(self._hairs, self._hair_len): if abs(math.cos(a)) > 0.8 or math.sin(a) > 0.5: continue # where the headphone cups and the legs are painter.drawLine(j(math.cos(a) * r, math.sin(a) * r), j(math.cos(a) * r * (1 + length), math.sin(a) * r * (1 + length))) - # Face. - eye_y, eye_x = -r * 0.18, r * 0.32 + self._face(painter, r, j, posture, three_q, drop) + self._headphones(painter, r, j, three_q, drop) + painter.restore() + + if three_q: + self._arm(painter, r, j, -1, shoulders[-1], left_arm) + else: + for s, arm in ((-1, left_arm), (1, right_arm)): + self._arm(painter, r, j, s, shoulders[s], arm) + + def _face(self, painter, r, j, posture, three_q, drop): + asleep = posture == SLEEP + blink = posture == SIT and self.step % BLINK_EVERY == 0 + eye_y = -r * 0.18 + drop + mouth_y = r * 0.22 + drop + if three_q: # turned to its left (our right) + eyes = ((r * 0.18, 1.0), (r * 0.6, 0.8)) # (x, size): far is smaller + mouth = (r * 0.12, r * 0.62) + else: + eyes = ((-r * 0.32, 1.0), (r * 0.32, 1.0)) + mouth = (-r * 0.3, r * 0.3) + mid = (mouth[0] + mouth[1]) / 2 if asleep or blink: - for s in (-1, 1): - painter.drawLine(j(s * eye_x - r * 0.13, eye_y), - j(s * eye_x + r * 0.13, eye_y)) - if asleep: - painter.drawLine(j(-r * 0.12, r * 0.32), j(r * 0.12, r * 0.32)) - elif posture == SIT: - if not blink: - dot = max(0.8, r * 0.07) - for s in (-1, 1): - painter.drawEllipse(j(s * eye_x, eye_y), dot, dot) - painter.drawLine(j(-r * 0.18, r * 0.32), j(r * 0.18, r * 0.3)) + for x, size in eyes: + painter.drawLine(j(x - r * 0.13 * size, eye_y), + j(x + r * 0.13 * size, eye_y)) else: dot = max(0.8, r * 0.07) - for s in (-1, 1): - c = j(s * eye_x, eye_y) - painter.drawEllipse(c, dot, dot) - smile = QPainterPath(j(-r * 0.3, r * 0.22)) + for x, size in eyes: + painter.drawEllipse(j(x, eye_y), dot * size, dot) + if asleep: + painter.drawLine(j(mid - r * 0.12, mouth_y + r * 0.1), + j(mid + r * 0.12, mouth_y + r * 0.1)) + elif posture == SIT: + painter.drawLine(j(mid - r * 0.18, mouth_y + r * 0.1), + j(mid + r * 0.18, mouth_y + r * 0.08)) + else: + smile = QPainterPath(j(mouth[0], mouth_y)) depth = r * (0.5 if self.busy else 0.32) - smile.quadTo(j(0, r * 0.22 + depth), j(r * 0.3, r * 0.22)) + smile.quadTo(j(mid, mouth_y + depth), j(mouth[1], mouth_y)) painter.drawPath(smile) - # Big headphones: a band over the top, a cup over each side. - band = QPainterPath(j(-r * 1.12, -r * 0.1)) - band.cubicTo(j(-r * 1.25, -r * 1.75), j(r * 1.25, -r * 1.75), - j(r * 1.12, -r * 0.1)) + def _headphones(self, painter, r, j, three_q, drop): + d = drop * 0.3 + if three_q: + # The near cup seen whole on the side of the head, the band + # over the top to the far cup (drawn behind the ball). + near = j(-r * 0.55, -r * 0.02 + d) + painter.drawEllipse(near, r * 0.3, r * 0.44) + painter.drawEllipse(near, r * 0.14, r * 0.24) + band = QPainterPath(j(-r * 0.6, -r * 0.45 + d)) + band.cubicTo(j(-r * 0.75, -r * 1.65 + d), j(r * 0.95, -r * 1.55 + d), + j(r * 0.98, -r * 0.42 + d)) + painter.drawPath(band) + return + band = QPainterPath(j(-r * 1.12, -r * 0.1 + d)) + band.cubicTo(j(-r * 1.25, -r * 1.75 + d), j(r * 1.25, -r * 1.75 + d), + j(r * 1.12, -r * 0.1 + d)) painter.drawPath(band) for s in (-1, 1): - c = j(s * r * 1.08, 0) - painter.drawEllipse(c, r * 0.24, r * 0.42) + painter.drawEllipse(j(s * r * 1.08, d), r * 0.24, r * 0.42) - # Arms from the shoulders, two sticks each. - if asleep: - pose = LYING - elif posture == SIT: - pose = SITTING - elif self.busy: - pose = DANCE[fig.pose] - else: - pose = HANG - upper, lower = r * 0.75, r * 0.6 - for s, (shoulder, bend) in zip((-1, 1), pose): - if posture == STAND and not self.busy: - shoulder += 6 * self.bob # a hanging arm swings with the bob - start = (s * r * 0.92, r * 0.3) - a = math.radians(shoulder) - elbow = (start[0] + s * math.sin(a) * upper, - start[1] + math.cos(a) * upper) - b = math.radians(shoulder + bend) - hand = (elbow[0] + s * math.sin(b) * lower, - elbow[1] + math.cos(b) * lower) - painter.drawPolyline([j(*start), j(*elbow), j(*hand)]) + def _arm(self, painter, r, j, s, start, arm): + shoulder, bend = arm + upper, lower = r * 0.8, r * 0.65 + a = math.radians(shoulder) + elbow = (start.x() + s * math.sin(a) * upper, + start.y() + math.cos(a) * upper) + b = math.radians(shoulder + bend) + hand = (elbow[0] + s * math.sin(b) * lower, + elbow[1] + math.cos(b) * lower) + painter.drawPolyline([j(start.x(), start.y()), j(*elbow), j(*hand)]) - if posture == SIT: + def _legs(self, painter, r, j, legs, hips): + if legs == "sit": # Splayed out along the floor, feet turned up. for s in (-1, 1): - hip = (s * r * 0.45, r * 0.85) - knee = (s * r * 1.0, r * 1.08) - foot = (s * r * 1.6, r * 1.08) + hip = (hips[s] * 1.2, r * 0.85) + knee = (s * r * 1.0 + hips[s] * 0.2, r * 1.08) + foot = (s * r * 1.6 + hips[s] * 0.2, r * 1.08) painter.drawPolyline([j(*hip), j(*knee), j(*foot), j(foot[0] + s * r * 0.05, r * 0.78)]) return - - # Legs: straight, or bent at the knee by the bob; the feet step - # apart when dancing. - legs = r * 1.25 - knee_out = dip * 0.9 - spread = r * (0.5 if (self.busy and self.feet) else 0.35) + foot_y = r * 2.25 for s in (-1, 1): - hip = (s * r * 0.35, r * 0.93) - foot_y = r + legs - dip - out = spread + (r * 0.15 if self.busy and self.feet == (s > 0) else 0) - foot = (s * out, foot_y) + side = "l" if s < 0 else "r" + hip = (hips[s], r * 0.6) + foot = [hips[s] + s * r * 0.02, foot_y] + knee_out = 0.0 + toe = s * r * 0.25 + if legs == "wide": + foot[0] = hips[s] + s * r * 0.45 + knee_out = r * 0.15 + elif legs == "step_" + side: + foot[0] = hips[s] + s * r * 0.35 + elif legs == "kick_" + side: + foot = [hips[s] + s * r * 1.0, foot_y - r * 0.6] + knee_out = r * 0.15 + elif legs == "knee_" + side: + foot[1] = foot_y - r * 0.35 + knee_out = r * 0.4 + elif legs == "jump": + foot = [hips[s] + s * r * 0.05, foot_y - r * 0.3] + knee_out = r * 0.35 knee = ((hip[0] + foot[0]) / 2 + s * knee_out, - (hip[1] + foot_y) / 2) + (hip[1] + foot[1]) / 2) painter.drawPolyline([j(*hip), j(*knee), j(*foot), - j(foot[0] + s * r * 0.25, foot_y)]) + j(foot[0] + toe, foot[1])]) - def _zzz(self, painter, x, y, r, fig, j): + def _zzz(self, painter, x, y, r, j): """Little z's rising, a new one every few frames.""" phase = self.step % 12 for k in range(3): diff --git a/lintunes/gui/visualizer_presets.py b/lintunes/gui/visualizer_presets.py index 526bd5c..36d784b 100644 --- a/lintunes/gui/visualizer_presets.py +++ b/lintunes/gui/visualizer_presets.py @@ -33,6 +33,7 @@ STYLE_KEYS = { "visualizer_laser_glow", "visualizer_laser_grid", "visualizer_laser_head", "visualizer_laser_dot", "visualizer_laser_grid_dot"), + "lint": ("visualizer_lint_head_on",), } diff --git a/lintunes/gui/visualizer_styles.py b/lintunes/gui/visualizer_styles.py index fb29a9b..47da55e 100644 --- a/lintunes/gui/visualizer_styles.py +++ b/lintunes/gui/visualizer_styles.py @@ -77,7 +77,8 @@ LIMITS = { "visualizer_radial_dot": (0.2, 2.5), # × the automatic size } _FLAGS = ("visualizer_radial_normalize", "visualizer_laser_head", - "visualizer_laser_glow", "visualizer_laser_grid") + "visualizer_laser_glow", "visualizer_laser_grid", + "visualizer_lint_head_on") _INTEGER = ("visualizer_radial_spokes", "visualizer_radial_levels", "visualizer_bars_count", "visualizer_laser_low_hz", "visualizer_laser_high_hz") diff --git a/lintunes/preferences.py b/lintunes/preferences.py index c56f216..a7f2c67 100644 --- a/lintunes/preferences.py +++ b/lintunes/preferences.py @@ -35,6 +35,7 @@ DEFAULTS = { "visualizer_radial_levels": 20, # volume steps along each spoke "visualizer_radial_dot": 1.0, # dot size, × the automatic size "visualizer_radial_normalize": True, # even out bass vs treble + "visualizer_lint_head_on": False, # Lint Oontz: head on, not 3/4 view # Per-area grayscale overrides (0=black .. 255=white). None = inherit the # current/default look for that surface, so nothing changes until the user # drags a slider in Preferences. diff --git a/tests/test_round122.py b/tests/test_round122.py index 7893383..33dcce2 100644 --- a/tests/test_round122.py +++ b/tests/test_round122.py @@ -98,11 +98,11 @@ def test_quiet_sits_then_sleeps_and_music_wakes_it(): assert r.posture == STAND -def test_pausing_sits_it_down(): +def test_pausing_lets_the_quiet_clock_decide(): r = LintRenderer() _play(r, _song(128, 2, True)) r.clear() - assert r.posture == SIT + assert r.posture == STAND # Round 123: it waits before sitting def test_one_ball_in_the_given_colour(qapp): @@ -115,8 +115,8 @@ def test_one_ball_in_the_given_colour(qapp): if any(img.pixelColor(x, y).blue() - img.pixelColor(x, y).red() > 80 for y in range(0, h, 2))] assert cols - # One figure, in the middle: nothing in the outer fifths. - assert min(cols) > w * 0.2 and max(cols) < w * 0.8 + # One figure, in the middle: nothing in the outer sixths. + assert min(cols) > w / 6 and max(cols) < w * 5 / 6 def test_every_frame_wobbles(qapp): diff --git a/tests/test_round123.py b/tests/test_round123.py new file mode 100644 index 0000000..6ff5822 --- /dev/null +++ b/tests/test_round123.py @@ -0,0 +1,137 @@ +"""Round 123: Lint Oontz in three-quarter view (or head on, a setting), +nodding its head, ten dance moves by intensity, and slower to sit/sleep.""" +import numpy as np +from PyQt6.QtCore import QRectF +from PyQt6.QtGui import QColor, QImage, QPainter + +from lintunes.gui import visualizer_lint as vl +from lintunes.gui import visualizer_presets as presets +from lintunes.gui import visualizer_styles as vs +from lintunes.preferences import Preferences + +RATE = 44100 + + +def _pink(n, db, rng): + w = rng.normal(size=n) + f = np.fft.rfft(w) + k = np.arange(len(f)) + k[0] = 1 + x = np.fft.irfft(f / np.sqrt(k), n) + return x / np.sqrt(np.mean(x ** 2)) * 10 ** (db / 20) + + +def _section(seconds, db, rng, bpm=128): + n = int(RATE * seconds) + t = np.arange(n) / RATE + kick = np.sin(2 * np.pi * 55 * t) * np.exp(-(t % (60 / bpm)) * 18) * 0.7 + return (_pink(n, db, rng) + kick).astype(np.float32) + + +def _feed(r, audio, on_step=None): + hist = np.zeros(vs.HISTORY, np.float32) + n = RATE // 60 + for i in range(0, len(audio) - n, n): + chunk = audio[i:i + n] + hist = np.concatenate([hist, chunk])[-vs.HISTORY:] + if r.advance(vs.Frame(hist, RATE, chunk, 1 / 60)) and on_step: + on_step() + + +def _quiet(r, seconds): + for _ in range(int(seconds * 60)): + r.advance(vs.Frame(np.zeros(vs.HISTORY, np.float32), RATE, + np.zeros(0, np.float32), 1 / 60)) + + +def _draw(r, w=240, h=240): + img = QImage(w, h, QImage.Format.Format_ARGB32) + img.fill(QColor(205, 205, 205)) + p = QPainter(img) + r.paint(p, QRectF(0, 0, w, h), QColor(40, 110, 220)) + p.end() + return img + + +def test_ten_moves_in_three_tiers_using_arms_and_legs(): + assert len(vl.MOVES) == 10 + assert len({m.name for m in vl.MOVES}) == 10 + assert {m.tier for m in vl.MOVES} == {0, 1, 2} + legs = {frame[2] for m in vl.MOVES for frame in m.frames} + assert legs - {"stand"} # some moves use the legs + + +def test_waits_standing_then_sits_then_sleeps(): + r = vl.LintRenderer() + _feed(r, _section(3, -16, np.random.default_rng(1))) + assert r.posture == vl.STAND + _quiet(r, 2) # skipping to the next song + assert r.posture == vl.STAND + _quiet(r, vl.SIT_AFTER_S - 2 + 0.5) + assert r.posture == vl.SIT + _quiet(r, vl.SLEEP_AFTER_S - vl.SIT_AFTER_S) + assert r.posture == vl.SLEEP + assert vl.SIT_AFTER_S >= 8 and vl.SLEEP_AFTER_S >= 25 + + +def test_the_moves_follow_the_music_shifting(): + rng = np.random.default_rng(2) + r = vl.LintRenderer() + tiers = {} + for name, seconds, db in (("verse", 20, -21), ("drop", 20, -13), + ("break", 15, -21)): + seen = set() + _feed(r, _section(seconds, db, rng), + lambda: r.move and seen.add(r.move.tier)) + tiers[name] = (r.move.tier, seen) + assert tiers["verse"][0] == 0 + assert tiers["drop"][0] == 2 + assert tiers["break"][0] == 0 + + +def test_a_beat_nods_the_head(): + r = vl.LintRenderer() + r.posture = vl.STAND + r._beat_pending = True + r._pose() + assert r.nod == 1.0 + r._pose() + assert 0 < r.nod < 1 + r._pose() + assert r.nod == 0.0 + for head_on in (False, True): # and it shows, in both views + r.configure({vl.HEAD_ON_KEY: head_on}) + r.nod = 0.0 + still = _draw(r) + r.nod = 1.0 + assert _draw(r) != still + + +def test_both_views_draw_every_move(qapp): + for head_on in (False, True): + r = vl.LintRenderer({vl.HEAD_ON_KEY: head_on}) + r.posture, r.busy = vl.STAND, True + for move in vl.MOVES: + r.move = move + for f in range(len(move.frames)): + r._frame = f + img = _draw(r, 134, 38) + assert any(img.pixelColor(x, y).blue() - img.pixelColor(x, y).red() > 80 + for x in range(134) for y in range(38)) + + +def test_three_quarter_and_head_on_differ(qapp): + a = vl.LintRenderer({vl.HEAD_ON_KEY: False}) + b = vl.LintRenderer({vl.HEAD_ON_KEY: True}) + for r in (a, b): + r.posture = vl.STAND + assert _draw(a) != _draw(b) + + +def test_the_view_is_a_setting(qapp, tmp_path): + prefs = Preferences(tmp_path) + assert vs.settings(prefs)[vl.HEAD_ON_KEY] is False # 3/4 by default + prefs.set(vl.HEAD_ON_KEY, True) + r = vs.make_renderer(vs.STYLE_LINT, vs.settings(prefs)) + assert r.head_on + assert vl.HEAD_ON_KEY in presets.STYLE_KEYS["lint"]