182 lines
6.0 KiB
Python
182 lines
6.0 KiB
Python
"""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"]
|
|
|
|
|
|
# ---- Round 124: which way the three-quarter view looks ----
|
|
|
|
def _differ(a, b):
|
|
return sum(abs(a.pixelColor(x, y).red() - b.pixelColor(x, y).red()) > 60
|
|
for x in range(a.width()) for y in range(a.height()))
|
|
|
|
|
|
def test_facing_left_is_the_mirror_image(qapp):
|
|
for posture in (vl.STAND, vl.SIT):
|
|
right = vl.LintRenderer({vl.FACE_LEFT_KEY: False})
|
|
left = vl.LintRenderer({vl.FACE_LEFT_KEY: True})
|
|
for r in (right, left):
|
|
r.posture = posture
|
|
# Same step, same wobble: one is the other flipped (bar a few
|
|
# antialiased edge pixels), and nothing like it unflipped.
|
|
a, b = _draw(left), _draw(right)
|
|
flipped = _differ(a, b.mirrored(True, False))
|
|
assert flipped < _differ(a, b) / 10
|
|
|
|
|
|
def test_head_on_ignores_facing(qapp):
|
|
a = vl.LintRenderer({vl.HEAD_ON_KEY: True, vl.FACE_LEFT_KEY: False})
|
|
b = vl.LintRenderer({vl.HEAD_ON_KEY: True, vl.FACE_LEFT_KEY: True})
|
|
for r in (a, b):
|
|
r.posture = vl.STAND
|
|
assert _draw(a) == _draw(b)
|
|
|
|
|
|
def test_asleep_facing_left_still_draws(qapp):
|
|
r = vl.LintRenderer({vl.FACE_LEFT_KEY: True})
|
|
r.posture = vl.SLEEP
|
|
img = _draw(r)
|
|
assert any(img.pixelColor(x, y).blue() - img.pixelColor(x, y).red() > 80
|
|
for x in range(240) for y in range(240))
|
|
|
|
|
|
def test_facing_is_a_setting(qapp, tmp_path):
|
|
prefs = Preferences(tmp_path)
|
|
assert vs.settings(prefs)[vl.FACE_LEFT_KEY] is False # right by default
|
|
prefs.set(vl.FACE_LEFT_KEY, True)
|
|
assert vs.make_renderer(vs.STYLE_LINT, vs.settings(prefs)).face_left
|
|
assert vl.FACE_LEFT_KEY in presets.STYLE_KEYS["lint"]
|