v0.89.0: Lint Oontz in three-quarter view (or head on), nodding to the bass, ten dance moves by intensity
The moves come in three tiers picked by how full the music is now against the last ~12 s, so a build or a drop changes the move; some use the legs. It waits standing for 10 s before sitting and sleeps at 30 s, and skipping songs no longer sits it down.
This commit is contained in:
@@ -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
|
||||
|
||||
@@ -1,3 +1,3 @@
|
||||
"""LinTunes — iTunes-style music library manager and player for Linux."""
|
||||
|
||||
__version__ = "0.88.1"
|
||||
__version__ = "0.89.0"
|
||||
|
||||
@@ -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)
|
||||
|
||||
+343
-151
@@ -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):
|
||||
|
||||
@@ -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",),
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -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")
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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):
|
||||
|
||||
@@ -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"]
|
||||
Reference in New Issue
Block a user