203 lines
7.5 KiB
Python
203 lines
7.5 KiB
Python
"""The flashy bit: an ANSI-colour spectrum analyser / oscilloscope."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from collections.abc import Sequence
|
|
from typing import TYPE_CHECKING, cast
|
|
|
|
from rich.console import Group, RenderableType
|
|
from rich.text import Text
|
|
from textual.widget import Widget
|
|
|
|
from ..spectrum import Frame, SpectrumEngine
|
|
from .common import LEVELS, SPECTRUM_STOPS, gradient
|
|
|
|
if TYPE_CHECKING:
|
|
from ..app import SomaFMApp
|
|
|
|
|
|
class SpectrumPanel(Widget):
|
|
can_focus = False
|
|
|
|
def __init__(self, engine: SpectrumEngine) -> None:
|
|
super().__init__()
|
|
self.engine = engine
|
|
self.border_title = "SPECTRUM"
|
|
self._palettes: dict[tuple[int, int, bool], list[str]] = {}
|
|
|
|
# Called from the app ticker so the border title tracks the analyser mode.
|
|
def sync(self, mode: str, status: str) -> None:
|
|
label = {"both": "MIRROR", "bars": "BARS", "wave": "WAVE"}.get(
|
|
mode, mode.upper()
|
|
)
|
|
title = f"SPECTRUM · {label} · {status}"
|
|
if self.border_title != title:
|
|
self.border_title = title
|
|
self.refresh()
|
|
|
|
def render(self) -> RenderableType:
|
|
app = cast("SomaFMApp", self.app)
|
|
frame = self.engine.snapshot()
|
|
width = max(8, self.size.width)
|
|
height = max(2, self.size.height)
|
|
mode = getattr(app, "visualizer", "both")
|
|
phase = int(getattr(app, "tick_count", 0) // 2)
|
|
dim = frame.status == "idle"
|
|
|
|
lines: list[Text]
|
|
if mode == "wave":
|
|
lines = self._wave(frame, width, height, phase, dim)
|
|
elif mode == "bars" or height < 8:
|
|
lines = self._bars(frame, width, height, phase, dim)
|
|
else:
|
|
# Default mode: a full-height mirrored spectrum. The top half
|
|
# grows up from the centre line, the bottom half grows down from
|
|
# it (same values, flipped rows, dimmed like a reflection).
|
|
top_height = height // 2
|
|
bottom_height = height - top_height
|
|
lines = self._bars(frame, width, top_height, phase, dim)
|
|
mirrored = self._bars(
|
|
frame, width, bottom_height, phase + 5, True, peaks=False
|
|
)
|
|
mirrored.reverse()
|
|
lines.extend(mirrored)
|
|
return Group(*lines)
|
|
|
|
# ------------------------------------------------------------------ #
|
|
# drawing
|
|
# ------------------------------------------------------------------ #
|
|
|
|
def _row_palette(self, height: int, phase: int, dim: bool) -> list[str]:
|
|
key = (height, phase % 12, dim)
|
|
cached = self._palettes.get(key)
|
|
if cached is not None:
|
|
return cached
|
|
palette: list[str] = []
|
|
for row in range(height):
|
|
position = (height - 1 - row) / max(1, height - 1)
|
|
colour = gradient(SPECTRUM_STOPS, position)
|
|
style = f"bold {colour}" if (row + phase) % 7 == 0 else colour
|
|
if dim:
|
|
style = f"dim {style}"
|
|
palette.append(style)
|
|
if len(self._palettes) > 96:
|
|
self._palettes.clear()
|
|
self._palettes[key] = palette
|
|
return palette
|
|
|
|
@staticmethod
|
|
def _resample(values: Sequence[float], width: int) -> list[float]:
|
|
count = len(values)
|
|
if count == 0:
|
|
return [0.0] * width
|
|
if width <= 1 or count == 1:
|
|
return [float(values[0])] * width
|
|
last = count - 1
|
|
output: list[float] = []
|
|
for column in range(width):
|
|
position = column * last / (width - 1)
|
|
low = int(position)
|
|
high = min(low + 1, last)
|
|
fraction = position - low
|
|
output.append(values[low] * (1.0 - fraction) + values[high] * fraction)
|
|
return output
|
|
|
|
@staticmethod
|
|
def _resample_mean(values: Sequence[float], width: int) -> list[float]:
|
|
count = len(values)
|
|
if count == 0:
|
|
return [0.0] * width
|
|
output: list[float] = []
|
|
for column in range(width):
|
|
low = int(column * count / width)
|
|
high = max(low + 1, int((column + 1) * count / width))
|
|
high = min(high, count)
|
|
chunk = values[low:high]
|
|
output.append(sum(chunk) / len(chunk) if chunk else 0.0)
|
|
return output
|
|
|
|
def _bars(
|
|
self,
|
|
frame: Frame,
|
|
width: int,
|
|
height: int,
|
|
phase: int,
|
|
dim: bool,
|
|
peaks: bool = True,
|
|
) -> list[Text]:
|
|
values = self._resample(frame.bands, width)
|
|
peaks = self._resample(frame.peaks, width)
|
|
palette = self._row_palette(height, phase, dim)
|
|
scale = height * 8.0
|
|
|
|
lines: list[Text] = []
|
|
for row in range(height):
|
|
line = Text(no_wrap=True)
|
|
row_top = (height - row - 1) * 8.0
|
|
style = palette[row]
|
|
for column in range(width):
|
|
units = min(values[column], 1.0) * scale - row_top
|
|
peak_units = min(peaks[column], 1.0) * scale - row_top
|
|
if units >= 8.0:
|
|
line.append("█", style=style)
|
|
elif units > 0.0:
|
|
level = max(1, min(7, int(units)))
|
|
line.append(LEVELS[level], style=style)
|
|
elif (
|
|
peaks
|
|
and 0.0 <= peak_units < 8.0
|
|
and peak_units > units + 1.0
|
|
):
|
|
line.append("▁", style="dim" if dim else "bold")
|
|
else:
|
|
line.append(" ", style="")
|
|
lines.append(line)
|
|
return lines
|
|
|
|
def _wave(
|
|
self, frame: Frame, width: int, height: int, phase: int, dim: bool
|
|
) -> list[Text]:
|
|
wave = self._resample_mean(frame.wave, width)
|
|
# The engine normalises each chunk, but smoothing and averaging make
|
|
# the trace sit around the middle. A gentle display gain lets the
|
|
# oscilloscope use the full height without amplifying silence into
|
|
# noise.
|
|
peak = max((abs(value) for value in wave), default=0.0)
|
|
if peak > 0.02:
|
|
gain = min(2.5, 0.9 / peak)
|
|
wave = [value * gain for value in wave]
|
|
palette = self._row_palette(height, phase, dim)
|
|
centre = (height - 1) / 2.0
|
|
amplitude = max(0.75, (height - 1) / 2.0)
|
|
|
|
grid = [[" " for _ in range(width)] for _ in range(height)]
|
|
previous_row: int | None = None
|
|
for column, value in enumerate(wave):
|
|
clamped = max(-1.0, min(1.0, float(value)))
|
|
position = centre - clamped * amplitude
|
|
row = max(0, min(height - 1, round(position)))
|
|
grid[row][column] = "█"
|
|
delta = position - row
|
|
if delta > 0.35 and row + 1 < height:
|
|
grid[row + 1][column] = "▄"
|
|
elif delta < -0.35 and row - 1 >= 0:
|
|
grid[row - 1][column] = "▀"
|
|
if previous_row is not None and previous_row != row:
|
|
low, high = sorted((previous_row, row))
|
|
for between in range(low + 1, high):
|
|
if grid[between][column] == " ":
|
|
grid[between][column] = "│"
|
|
previous_row = row
|
|
|
|
lines: list[Text] = []
|
|
for row in range(height):
|
|
line = Text(no_wrap=True)
|
|
style = palette[row]
|
|
for char in grid[row]:
|
|
if char == " ":
|
|
line.append(" ", style="")
|
|
else:
|
|
line.append(char, style=style)
|
|
lines.append(line)
|
|
return lines
|