Add a stage simulator that draws the rig from Art-Net.

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
jimmyandCursor committed 2026-10-21 17:39:13 +13:00
1 parent 9b5f6b5bdd
commit 24f9ca300e
10 files changed
+2237

No files matched your search

+1
View File
@@ -0,0 +1 @@
"""Stage visualiser that listens for Art-Net."""
+172
View File
@@ -0,0 +1,172 @@
"""Stage simulator.
Loads a stage map, patches DMX addresses from a QLC+ show, and listens for
Art-Net. Open the printed URL and point QLC+ Art-Net output at this machine.
python -m simulator
python -m simulator --stage stage/map.json --show shows/templeoftechno.qxw
python -m simulator --demo
"""
from __future__ import annotations
import argparse
import math
import threading
import time
from pathlib import Path
from simulator.artnet import ArtNetNode
from simulator.server import Simulator, make_server
from simulator.stage import Fixture, apply_show, load_stage
ROOT = Path(__file__).resolve().parents[1]
def _hsv(hue: float) -> tuple[int, int, int]:
hue = hue % 1.0
i = int(hue * 6)
f = hue * 6 - i
q = int(255 * (1 - f))
t = int(255 * f)
segment = i % 6
if segment == 0:
return 255, t, 0
if segment == 1:
return q, 255, 0
if segment == 2:
return 0, 255, t
if segment == 3:
return 0, q, 255
if segment == 4:
return t, 0, 255
return 255, 0, q
def _slot(fixture: Fixture, name: str) -> int | None:
if fixture.address is None:
return None
for index, channel in enumerate(fixture.channel_names):
if channel.lower() == name.lower():
return fixture.address + index
return None
def _put(frame: bytearray, fixture: Fixture, name: str, value: int) -> None:
slot = _slot(fixture, name)
if slot is not None and 0 <= slot < len(frame):
frame[slot] = max(0, min(255, value))
def _demo_frame(fixtures: list[Fixture], elapsed: float) -> bytearray:
frame = bytearray(512)
cans = [fixture for fixture in fixtures if fixture.kind == "can" and fixture.address is not None]
cans.sort(key=lambda fixture: fixture.label)
# Walk the BCC145 macro: RGBW mix, colour jump, pulse, then gradient.
look = int(elapsed / 5) % 4
macro = (0, 120, 170, 220)[look]
speed = int(40 + (math.sin(elapsed * 0.7) * 0.5 + 0.5) * 180)
for index, fixture in enumerate(cans):
_put(frame, fixture, "Dimmer", 255)
_put(frame, fixture, "Macro", macro)
_put(frame, fixture, "Speed", speed)
if macro == 0:
red, green, blue = _hsv(elapsed * 0.05 + index / max(1, len(cans)))
_put(frame, fixture, "Red", red)
_put(frame, fixture, "Green", green)
_put(frame, fixture, "Blue", blue)
movers = [fixture for fixture in fixtures if fixture.kind == "mover" and fixture.address is not None]
for index, fixture in enumerate(movers):
pan = int(32768 + math.sin(elapsed * 0.6 + index * math.pi) * 9000)
pan = max(0, min(65535, pan))
tilt = 42000
_put(frame, fixture, "Pan", (pan >> 8) & 0xFF)
_put(frame, fixture, "Pan Fine", pan & 0xFF)
_put(frame, fixture, "Tilt", (tilt >> 8) & 0xFF)
_put(frame, fixture, "Tilt Fine", tilt & 0xFF)
_put(frame, fixture, "Zoom", 40)
_put(frame, fixture, "Center Brightness", 255)
color = (255, 40, 0) if index % 2 == 0 else (40, 80, 255)
for pixel in range(1, 8):
_put(frame, fixture, f"Red {pixel}", color[0])
_put(frame, fixture, f"Green {pixel}", color[1])
_put(frame, fixture, f"Blue {pixel}", color[2])
_put(frame, fixture, "Dynamic Effect", 30 if index % 2 == 0 else 160)
_put(frame, fixture, "Lens Rotate", 210 if index % 2 == 0 else 40)
return frame
def _demo_loop(node: ArtNetNode, fixtures: list[Fixture], stop: threading.Event) -> None:
started = time.monotonic()
while not stop.is_set():
frame = _demo_frame(fixtures, time.monotonic() - started)
node.write(0, frame)
stop.wait(0.05)
def _parse_host_port(value: str, default_port: int) -> tuple[str, int]:
if ":" not in value:
return value, default_port
host, port = value.rsplit(":", 1)
return host or "0.0.0.0", int(port)
def main() -> None:
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument("--stage", type=Path, default=ROOT / "stage" / "map.json")
parser.add_argument("--show", type=Path, default=ROOT / "shows" / "templeoftechno.qxw")
parser.add_argument("--no-show", action="store_true", help="Use addresses stored in the stage file only")
parser.add_argument("--http", default="0.0.0.0:8765", help="Web view host:port")
parser.add_argument("--artnet", default="0.0.0.0:6454", help="Art-Net listen host:port")
parser.add_argument("--demo", action="store_true", help="Play a local look when you want to see the rig without QLC+")
args = parser.parse_args()
stage = load_stage(args.stage)
if not args.no_show:
if not args.show.is_file():
raise SystemExit(f"Show not found: {args.show}")
apply_show(stage, args.show)
http_host, http_port = _parse_host_port(args.http, 8765)
artnet_host, artnet_port = _parse_host_port(args.artnet, 6454)
node = ArtNetNode(artnet_host, artnet_port)
node.start()
server = make_server(Simulator(stage, node), http_host, http_port)
print("Stage simulator", flush=True)
print(f" stage: {args.stage}", flush=True)
if stage.show:
print(f" show: {args.show}", flush=True)
print(f" Art-Net {artnet_host}:{artnet_port}", flush=True)
print(f" view: http://127.0.0.1:{server.server_address[1]}", flush=True)
if stage.output_ip:
print(f" QLC+ Art-Net output in this show is {stage.output_ip}.", flush=True)
print(" Point that output at this computer (universe 0), or broadcast.", flush=True)
for fixture in stage.fixtures:
if fixture.dmx is None:
print(f" {fixture.label:<4} no address", flush=True)
else:
print(
f" {fixture.label:<4} {fixture.name:<16} universe {fixture.universe} DMX {fixture.dmx}",
flush=True,
)
for warning in stage.warnings:
print(f" warning: {warning}", flush=True)
stop = threading.Event()
if args.demo:
threading.Thread(target=_demo_loop, args=(node, stage.fixtures, stop), daemon=True).start()
print(" demo look is running", flush=True)
try:
server.serve_forever()
except KeyboardInterrupt:
print("\nStopping.", flush=True)
finally:
stop.set()
server.shutdown()
node.close()
if __name__ == "__main__":
main()
+214
View File
@@ -0,0 +1,214 @@
"""Art-Net receiver. Speaks ArtDMX and answers ArtPoll."""
from __future__ import annotations
import socket
import threading
import time
from collections import deque
ARTNET_PORT = 6454
HEADER = b"Art-Net\x00"
OP_POLL = 0x2000
OP_POLL_REPLY = 0x2100
OP_DMX = 0x5000
def build_artdmx(channels: bytes, universe: int = 0, sequence: int = 1) -> bytes:
"""ArtDMX packet. `channels` is the 0-based DMX frame (up to 512)."""
data = bytearray(channels)
n = len(data)
if n < 2:
data.extend(b"\x00" * (2 - n))
n = 2
if n & 1:
data.append(0)
n += 1
if n > 512:
data = data[:512]
n = 512
pkt = bytearray(18 + n)
pkt[0:8] = HEADER
pkt[8] = OP_DMX & 0xFF
pkt[9] = (OP_DMX >> 8) & 0xFF
pkt[11] = 14
pkt[12] = sequence & 0xFF
pkt[14] = universe & 0xFF
pkt[15] = (universe >> 8) & 0x7F
pkt[16] = (n >> 8) & 0xFF
pkt[17] = n & 0xFF
pkt[18 : 18 + n] = data
return bytes(pkt)
def parse_artdmx(packet: bytes) -> tuple[int, bytes] | None:
"""Return (port-address, dmx) for an ArtDMX packet, else None."""
if len(packet) < 18 or not packet.startswith(HEADER):
return None
opcode = packet[8] | (packet[9] << 8)
if opcode != OP_DMX:
return None
universe = packet[14] | ((packet[15] & 0x7F) << 8)
length = (packet[16] << 8) | packet[17]
if length < 2 or 18 + length > len(packet):
return None
return universe, packet[18 : 18 + length]
def parse_opcode(packet: bytes) -> int | None:
if len(packet) < 10 or not packet.startswith(HEADER):
return None
return packet[8] | (packet[9] << 8)
def poll_reply(ip: str) -> bytes:
"""Short ArtPollReply so QLC+ can list this node."""
pkt = bytearray(239)
pkt[0:8] = HEADER
pkt[8] = OP_POLL_REPLY & 0xFF
pkt[9] = (OP_POLL_REPLY >> 8) & 0xFF
pkt[11] = 14
parts = [int(part) for part in ip.split(".")]
if len(parts) != 4:
parts = [127, 0, 0, 1]
pkt[12:16] = bytes(parts)
pkt[16] = ARTNET_PORT & 0xFF
pkt[17] = (ARTNET_PORT >> 8) & 0xFF
pkt[19] = 1
pkt[25] = 0xD0
short = b"Stage sim"
pkt[28 : 28 + len(short)] = short
long = b"QLC+ stage Art-Net simulator"
pkt[46 : 46 + len(long)] = long
pkt[175] = 1
pkt[176] = 0x80
pkt[184] = 0x80
return bytes(pkt)
def local_ip_toward(peer: str) -> str:
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
sock.connect((peer, ARTNET_PORT))
return sock.getsockname()[0]
except OSError:
return "127.0.0.1"
finally:
sock.close()
class ArtNetNode:
"""Holds the latest DMX frame per Art-Net universe."""
def __init__(self, host: str = "0.0.0.0", port: int = ARTNET_PORT):
self.host = host
self.port = port
self._lock = threading.Lock()
self._universes: dict[int, bytearray] = {}
self.packets = 0
self._times: deque[float] = deque()
self.last_rx = 0.0
self.last_universe: int | None = None
self._sock: socket.socket | None = None
self._running = False
self._thread: threading.Thread | None = None
self._announced = False
def start(self) -> None:
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
if hasattr(socket, "SO_REUSEPORT"):
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
try:
sock.bind((self.host, self.port))
except OSError as exc:
sock.close()
raise OSError(
f"Cannot listen for Art-Net on {self.host}:{self.port} ({exc}). "
"Close the other program using that port, or pass --artnet-port."
) from exc
sock.settimeout(0.5)
self._sock = sock
self._running = True
self._thread = threading.Thread(target=self._loop, name="artnet", daemon=True)
self._thread.start()
def close(self) -> None:
self._running = False
sock = self._sock
if sock is not None:
try:
sock.close()
except OSError:
pass
if self._thread is not None:
self._thread.join(timeout=1.5)
def write(self, universe: int, data: bytes) -> None:
with self._lock:
buf = self._universes.get(universe)
if buf is None:
buf = bytearray(512)
self._universes[universe] = buf
n = min(512, len(data))
buf[:n] = data[:n]
if n < 512:
buf[n:] = b"\x00" * (512 - n)
now = time.monotonic()
self.packets += 1
self.last_rx = now
self.last_universe = universe
self._times.append(now)
def snapshot(self) -> dict[int, bytes]:
with self._lock:
return {universe: bytes(buf) for universe, buf in self._universes.items()}
def stats(self) -> dict:
now = time.monotonic()
with self._lock:
while self._times and now - self._times[0] > 1.0:
self._times.popleft()
age = None if self.last_rx == 0 else now - self.last_rx
return {
"packets": self.packets,
"rate": len(self._times),
"age": None if age is None else round(age, 3),
"universe": self.last_universe,
"listen": f"{self.host}:{self.port}",
}
def _loop(self) -> None:
sock = self._sock
assert sock is not None
while self._running:
try:
packet, addr = sock.recvfrom(2048)
except TimeoutError:
continue
except OSError:
break
self._handle(packet, addr)
def _handle(self, packet: bytes, addr: tuple) -> None:
opcode = parse_opcode(packet)
if opcode == OP_DMX:
parsed = parse_artdmx(packet)
if parsed is None:
return
universe, data = parsed
self.write(universe, data)
if not self._announced:
self._announced = True
print(
f"Art-Net DMX from {addr[0]}:{addr[1]} "
f"universe {universe} ({len(data)} channels)",
flush=True,
)
return
if opcode == OP_POLL and self._sock is not None:
ip = local_ip_toward(addr[0])
try:
self._sock.sendto(poll_reply(ip), (addr[0], ARTNET_PORT))
except OSError:
pass
+430
View File
@@ -0,0 +1,430 @@
"""Turn a DMX frame into colours, beams, and strobe rates.
Channel order comes from the stage map's fixture definitions. Role names
such as Dimmer, Red, Pan, and Zoom select the slots.
"""
from __future__ import annotations
import re
from simulator.stage import Fixture, Stage
_PIXEL = re.compile(r"^(red|green|blue|white) (\d+)$", re.IGNORECASE)
PAN_DEGREES = 540.0
ZOOM_MIN = 5.0
ZOOM_MAX = 45.0
# BCC145 8ch: strobe 0–7 is open. Small Eye centre strobe 0–3 is open.
CAN_STROBE_OPEN = 7
MOVER_STROBE_OPEN = 3
# beamZ BCC145 8ch macro, matching fixtures/beamZ-BCC145.qxf.
# 0–50 RGBW mix, 51–100 fixed colour, 101–150 jump, 151–200 pulse,
# 201–250 gradient, 251–255 sound. Speed is slow to fast.
_PAR_PALETTE = (
(255, 0, 0),
(255, 96, 0),
(255, 200, 0),
(255, 255, 0),
(0, 255, 0),
(0, 255, 160),
(0, 64, 255),
(140, 0, 255),
(255, 0, 160),
(255, 255, 255),
)
# Small Eye 43ch colour macros, static masks, and dynamic chases.
# Ranges match fixtures/Small-Eye-7-Mover.qxf: 0–9 is no function.
_MOVER_MACROS = (
(255, 0, 0),
(255, 80, 0),
(255, 255, 0),
(0, 255, 0),
(0, 255, 255),
(0, 40, 255),
(160, 0, 255),
(255, 0, 180),
(255, 255, 255),
(255, 180, 80),
)
_STATIC_MASKS = (
("all", (1, 1, 1, 1, 1, 1, 1)),
("odds", (1, 0, 1, 0, 1, 0, 1)),
("evens", (0, 1, 0, 1, 0, 1, 0)),
("center", (0, 0, 0, 1, 0, 0, 0)),
("ends", (1, 0, 0, 0, 0, 0, 1)),
("left", (1, 1, 1, 1, 0, 0, 0)),
("right", (0, 0, 0, 1, 1, 1, 1)),
("one", None),
)
_DYNAMIC = ("chase", "reverse", "rainbow", "bounce", "pulse", "pairs")
_DYNAMIC_LABELS = {
"chase": "chase",
"reverse": "reverse chase",
"rainbow": "rainbow",
"bounce": "bounce",
"pulse": "pixel pulse",
"pairs": "pairs",
}
MOVER_43 = [
"Pan", "Pan Fine", "Tilt", "Tilt Fine", "Pan/Tilt Speed", "Lens Rotate", "Zoom", "Focus",
"Center Brightness", "Center Strobe",
"Red 1", "Green 1", "Blue 1", "White 1",
"Red 2", "Green 2", "Blue 2", "White 2",
"Red 3", "Green 3", "Blue 3", "White 3",
"Red 4", "Green 4", "Blue 4", "White 4",
"Red 5", "Green 5", "Blue 5", "White 5",
"Red 6", "Green 6", "Blue 6", "White 6",
"Red 7", "Green 7", "Blue 7", "White 7",
"Colour Temperature", "Colour Macro", "Static Effect", "Dynamic Effect", "Reset",
]
def _find(names: list[str], wanted: str) -> int | None:
wanted = wanted.lower()
for index, name in enumerate(names):
if name.lower() == wanted:
return index
return None
def _value(channels: list[int], names: list[str], wanted: str, default: int = 0) -> int:
index = _find(names, wanted)
if index is None or index >= len(channels):
return default
return channels[index]
def _pixels(channels: list[int], names: list[str], dimmer: int) -> list[list[int]]:
groups: dict[int, dict[str, int]] = {}
for index, name in enumerate(names):
match = _PIXEL.match(name.strip())
if match is None:
continue
groups.setdefault(int(match.group(2)), {})[match.group(1).lower()] = index
def at(group: dict[str, int], color: str) -> int:
index = group.get(color)
if index is None or index >= len(channels):
return 0
return channels[index]
return [
list(mix_rgbw(at(groups[number], "red"), at(groups[number], "green"), at(groups[number], "blue"), at(groups[number], "white"), dimmer))
for number in sorted(groups)
]
def slots_at(frame: bytes, address: int, count: int) -> list[int]:
out: list[int] = []
for offset in range(count):
index = address + offset
out.append(frame[index] if 0 <= index < len(frame) else 0)
return out
def mix_rgbw(red: int, green: int, blue: int, white: int, dimmer: int) -> tuple[int, int, int]:
"""White is a fourth emitter. Dimmer scales the whole mix."""
level = max(0, min(255, dimmer)) / 255.0
return (
int(round(min(255, red + white) * level)),
int(round(min(255, green + white) * level)),
int(round(min(255, blue + white) * level)),
)
def strobe_hz(value: int, open_max: int) -> float:
if value <= open_max:
return 0.0
span = max(1, 255 - open_max)
return round(1.0 + (value - open_max) / span * 18.0, 2)
def lens_angle(value: int) -> float:
"""Indexed lens position, 0–60°. Spin ranges are not an index."""
if value <= 127:
return round(value / 127.0 * 60.0, 1)
return 0.0
def lens_spin(value: int) -> float:
"""Degrees per second. Negative is counter-clockwise.
0–127 index, 128–188 CCW fast to slow, 189–193 stop, 194–255 CW slow to fast.
"""
if 128 <= value <= 188:
rate = (188 - value) / 60.0
return round(-(40.0 + rate * 320.0), 1)
if 194 <= value <= 255:
rate = (value - 194) / 61.0
return round(40.0 + rate * 320.0, 1)
return 0.0
def _beam_color(pixels: list[list[int]]) -> tuple[int, int, int]:
"""Brightness-weighted mix, so one lit pixel stays its own colour."""
red = green = blue = weight = 0.0
for pr, pg, pb in pixels:
w = pr + pg + pb
red += pr * w
green += pg * w
blue += pb * w
weight += w
if weight <= 0:
return 0, 0, 0
return int(round(red / weight)), int(round(green / weight)), int(round(blue / weight))
def _scale(colour: tuple[int, int, int], dimmer: int) -> tuple[int, int, int]:
level = max(0, min(255, dimmer)) / 255.0
return tuple(int(round(channel * level)) for channel in colour)
def _speed_hz(speed: int, *, slow: float = 0.35, fast: float = 8.0) -> float:
return round(slow + max(0, min(255, speed)) / 255.0 * (fast - slow), 2)
def _can_mode(macro: int) -> str:
if macro <= 50:
return "mix"
if macro <= 100:
return "fixed"
if macro <= 150:
return "jump"
if macro <= 200:
return "pulse"
if macro <= 250:
return "gradient"
return "sound"
def _range_pick(value: int, start: int, count: int) -> tuple[int, float] | None:
"""Map value onto `count` bands from `start` through 255. Returns index and 0–1 position."""
if value < start or count <= 0:
return None
span = 256 - start
index = min(count - 1, (value - start) * count // span)
band = span / count
frac = ((value - start) - index * band) / band
return index, max(0.0, min(0.999, frac))
def apply_cto(red: int, green: int, blue: int, amount: int) -> tuple[int, int, int]:
"""0 leaves the colour alone. Higher values warm it, the way a CTO does."""
if amount <= 0:
return red, green, blue
warm = max(0, min(255, amount)) / 255.0
return (
red,
int(round(green * (1 - 0.35 * warm))),
int(round(blue * (1 - 0.75 * warm))),
)
def _can_view(
dimmer: int,
strobe: int,
red: int,
green: int,
blue: int,
white: int,
macro: int,
speed: int,
channels: list[int],
) -> dict:
mode = _can_mode(macro)
mixed = mix_rgbw(red, green, blue, white, dimmer)
peak = mix_rgbw(red, green, blue, white, 255)
if peak == (0, 0, 0):
peak = (255, 255, 255)
shown = mixed
palette = None
sound = 0
hz = 0.0
if mode == "fixed":
span = 50
index = min(len(_PAR_PALETTE) - 1, max(0, macro - 51) * len(_PAR_PALETTE) // span)
shown = _scale(_PAR_PALETTE[index], dimmer)
elif mode == "pulse":
shown = _scale(peak, dimmer)
hz = _speed_hz(speed, slow=0.4, fast=6.0)
elif mode in ("jump", "gradient", "sound"):
palette = [list(colour) for colour in _PAR_PALETTE]
hz = _speed_hz(speed)
shown = _scale(_PAR_PALETTE[0], dimmer)
if mode == "sound":
sound = 2 if macro >= 254 else 1
labels = {
"mix": "RGBW",
"fixed": "fixed colour",
"jump": "colour jump",
"pulse": "colour pulse",
"gradient": "colour gradient",
"sound": "sound 2" if sound == 2 else "sound 1",
}
viewed = {
"r": shown[0],
"g": shown[1],
"b": shown[2],
"dimmer": dimmer,
"strobe_hz": strobe_hz(strobe, CAN_STROBE_OPEN),
"strobe_mode": "strobe" if strobe > CAN_STROBE_OPEN else "open",
"effect": mode != "mix",
"function": mode,
"function_label": labels[mode],
"speed_hz": hz,
"sound": sound,
"channels": channels,
}
if palette is not None:
viewed["palette"] = palette
return viewed
def decode_can(channels: list[int]) -> dict:
def at(index: int) -> int:
return channels[index] if index < len(channels) else 0
return _can_view(at(0), at(1), at(2), at(3), at(4), at(5), at(6), at(7), channels)
def decode_named(channels: list[int], names: list[str], *, kind: str) -> dict:
"""Read a fixture using the channel names from the stage map."""
if kind == "mover" or (_find(names, "Pan") is not None and _find(names, "Tilt") is not None):
return _decode_mover_named(channels, names)
return _decode_can_named(channels, names)
def _decode_can_named(channels: list[int], names: list[str]) -> dict:
dimmer = 255 if _find(names, "Dimmer") is None else _value(channels, names, "Dimmer")
return _can_view(
dimmer,
_value(channels, names, "Strobe"),
_value(channels, names, "Red"),
_value(channels, names, "Green"),
_value(channels, names, "Blue"),
_value(channels, names, "White"),
_value(channels, names, "Macro"),
_value(channels, names, "Speed"),
channels,
)
def _mover_strobe(value: int) -> tuple[float, str]:
"""Centre strobe: open, linear strobe, then three random-strobe bands."""
if value <= MOVER_STROBE_OPEN:
return 0.0, "open"
if value <= 200:
return strobe_hz(value, MOVER_STROBE_OPEN), "strobe"
if value <= 215:
return 6.0, "random"
if value <= 234:
return 12.0, "random"
return 18.0, "random"
def _decode_mover_named(channels: list[int], names: list[str]) -> dict:
pan = (_value(channels, names, "Pan") << 8) | _value(channels, names, "Pan Fine")
tilt = (_value(channels, names, "Tilt") << 8) | _value(channels, names, "Tilt Fine")
zoom = _value(channels, names, "Zoom")
rotate = _value(channels, names, "Lens Rotate")
dimmer = 255 if _find(names, "Center Brightness") is None else _value(channels, names, "Center Brightness")
strobe = _value(channels, names, "Center Strobe")
pixels = _pixels(channels, names, dimmer)
macro_value = _value(channels, names, "Colour Macro")
static_value = _value(channels, names, "Static Effect")
dynamic_value = _value(channels, names, "Dynamic Effect")
cto = _value(channels, names, "Colour Temperature")
macro = _range_pick(macro_value, 10, len(_MOVER_MACROS))
static = _range_pick(static_value, 10, len(_STATIC_MASKS))
dynamic = _range_pick(dynamic_value, 10, len(_DYNAMIC))
source = [list(pixel) for pixel in pixels]
function = "pixels"
label = "pixels"
dynamic_name = None
speed = 0.0
if macro is not None:
colour = list(_scale(_MOVER_MACROS[macro[0]], dimmer))
source = [colour[:] for _ in range(7)]
function = "macro"
label = "colour macro"
if static is not None or dynamic is not None:
if not any(sum(pixel) > 0 for pixel in source):
white = list(_scale((255, 255, 255), dimmer))
source = [white[:] for _ in range(7)]
if static is not None and dynamic is None:
name, mask = _STATIC_MASKS[static[0]]
if name == "one":
pixel = min(6, int(static[1] * 7))
mask = tuple(1 if index == pixel else 0 for index in range(7))
source = [pixel if mask[index] else [0, 0, 0] for index, pixel in enumerate(source)]
function = "static"
label = "one pixel" if name == "one" else f"static {name}"
if dynamic is not None:
dynamic_name = _DYNAMIC[dynamic[0]]
speed = round(0.4 + dynamic[1] * 6.0, 2)
function = "dynamic"
label = _DYNAMIC_LABELS[dynamic_name]
tinted = [list(apply_cto(pixel[0], pixel[1], pixel[2], cto)) for pixel in source]
red, green, blue = _beam_color(tinted)
rate, strobe_mode = _mover_strobe(strobe)
reset = _value(channels, names, "Reset")
pan_speed = _value(channels, names, "Pan/Tilt Speed")
pan_deg = (pan - 32768) / 65536.0 * PAN_DEGREES
zoom_deg = ZOOM_MIN + (zoom / 255.0) * (ZOOM_MAX - ZOOM_MIN)
# Long enough to read on the plan at tilt zero. Tilt stretches the throw.
beam_m = 2.2 + (tilt / 65535.0) * 2.5
return {
"r": red,
"g": green,
"b": blue,
"dimmer": dimmer,
"strobe_hz": rate,
"strobe_mode": strobe_mode,
"effect": function != "pixels",
"function": function,
"function_label": label,
"speed_hz": speed,
"dynamic": dynamic_name,
"pan_deg": round(pan_deg, 2),
"zoom_deg": round(zoom_deg, 2),
"beam_m": round(beam_m, 3),
"pixels": tinted,
"spin_dps": lens_spin(rotate),
"lens_deg": lens_angle(rotate),
"focus": round(_value(channels, names, "Focus") / 255.0, 3),
"move": round(1 - pan_speed / 255.0, 3),
"cto": cto,
"reset": 200 <= reset <= 205,
"channels": channels,
}
def decode_mover(channels: list[int]) -> dict:
return _decode_mover_named(channels, MOVER_43)
def view_fixture(fixture: Fixture, universes: dict[int, bytes]) -> dict:
if fixture.address is None or fixture.universe is None:
return {"patched": False, "r": 0, "g": 0, "b": 0, "dimmer": 0, "strobe_hz": 0, "channels": []}
count = len(fixture.channel_names) or fixture.channels or (43 if fixture.kind == "mover" else 8)
frame = universes.get(fixture.universe, bytes(512))
channels = slots_at(frame, fixture.address, count)
if fixture.channel_names:
viewed = decode_named(channels, fixture.channel_names, kind=fixture.kind)
elif fixture.kind == "mover":
viewed = decode_mover(channels)
else:
viewed = decode_can(channels)
viewed["patched"] = True
return viewed
def view_stage(stage: Stage, universes: dict[int, bytes]) -> dict[str, dict]:
return {fixture.id: view_fixture(fixture, universes) for fixture in stage.fixtures}
+106
View File
@@ -0,0 +1,106 @@
"""HTTP view of the stage. The page polls /api/state."""
from __future__ import annotations
import json
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from urllib.parse import urlparse
from simulator.artnet import ArtNetNode
from simulator.decode import view_stage
from simulator.stage import Stage, set_heading
STATIC = Path(__file__).resolve().parent / "static"
CONTENT_TYPES = {
".html": "text/html; charset=utf-8",
".js": "text/javascript; charset=utf-8",
".css": "text/css; charset=utf-8",
}
class Simulator:
def __init__(self, stage: Stage, node: ArtNetNode):
self.stage = stage
self.node = node
def state(self) -> dict:
stats = self.node.stats()
stats["fixtures"] = view_stage(self.stage, self.node.snapshot())
return stats
def make_handler(sim: Simulator):
class Handler(BaseHTTPRequestHandler):
simulator = sim
def log_message(self, fmt: str, *args) -> None:
return
def do_POST(self) -> None:
path = urlparse(self.path).path
if path != "/api/heading":
self.send_error(404)
return
length = int(self.headers.get("Content-Length") or 0)
if length <= 0 or length > 4096:
self._json({"error": "bad heading"}, 400)
return
try:
payload = json.loads(self.rfile.read(length))
fixture = set_heading(
self.simulator.stage,
str(payload["id"]),
direction=payload.get("direction"),
zero=payload.get("zero"),
)
except (KeyError, TypeError, ValueError, json.JSONDecodeError):
self._json({"error": "bad heading"}, 400)
return
self._json({"id": fixture.id, "direction": fixture.direction, "zero": fixture.zero})
def do_GET(self) -> None:
path = urlparse(self.path).path
if path == "/api/state":
self._json(self.simulator.state())
return
if path == "/api/stage":
self._json(self.simulator.stage.to_json())
return
if path in ("/", "/index.html"):
self._file(STATIC / "index.html")
return
if path.startswith("/static/"):
target = (STATIC / path.removeprefix("/static/")).resolve()
if STATIC.resolve() in target.parents or target == STATIC.resolve():
self._file(target)
return
self.send_error(404)
def _json(self, payload: dict, status: int = 200) -> None:
body = json.dumps(payload).encode()
self.send_response(status)
self.send_header("Content-Type", "application/json")
self.send_header("Cache-Control", "no-store")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def _file(self, path: Path) -> None:
if not path.is_file():
self.send_error(404)
return
body = path.read_bytes()
self.send_response(200)
self.send_header("Content-Type", CONTENT_TYPES.get(path.suffix, "application/octet-stream"))
self.send_header("Cache-Control", "no-store")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
return Handler
def make_server(sim: Simulator, host: str, port: int) -> ThreadingHTTPServer:
return ThreadingHTTPServer((host, port), make_handler(sim))
+283
View File
@@ -0,0 +1,283 @@
"""Load a stage map and patch it from a QLC+ workspace."""
from __future__ import annotations
import json
import re
import xml.etree.ElementTree as ET
from dataclasses import dataclass, field
from pathlib import Path
_NUMBER = re.compile(r"#\s*0*(\d+)")
@dataclass
class FixtureDef:
name: str
manufacturer: str
model: str
mode: str
channels: list[str]
@dataclass
class Fixture:
id: str
label: str
kind: str
x: float
y: float
universe: int | None = None
address: int | None = None # 0-based, same as the QLC+ workspace file
channels: int = 0
mode: str = ""
name: str = ""
definition: str = ""
channel_names: list[str] = field(default_factory=list)
direction: float = 0.0 # cans: beam heading, degrees clockwise from +Y
zero: float = 0.0 # movers: heading at pan centre, same degrees
@property
def dmx(self) -> int | None:
"""1-based DMX start address."""
if self.address is None:
return None
return self.address + 1
def to_json(self) -> dict:
return {
"id": self.id,
"label": self.label,
"kind": self.kind,
"x": self.x,
"y": self.y,
"universe": self.universe,
"address": self.address,
"dmx": self.dmx,
"channels": self.channels,
"mode": self.mode,
"name": self.name or self.label,
"def": self.definition,
"channel_names": self.channel_names,
"direction": self.direction,
"zero": self.zero,
}
@dataclass
class Stage:
building_width: float
origin: str
fixtures: list[Fixture]
name: str = "xchc"
show: str | None = None
output_ip: str | None = None
path: Path | None = None
warnings: list[str] = field(default_factory=list)
def to_json(self) -> dict:
return {
"name": self.name,
"building_width": self.building_width,
"origin": self.origin,
"show": self.show,
"output_ip": self.output_ip,
"fixtures": [fixture.to_json() for fixture in self.fixtures],
"warnings": self.warnings,
}
def _local(tag: str) -> str:
return tag.rsplit("}", 1)[-1]
def _text(element: ET.Element, name: str, default: str = "") -> str:
for child in element:
if _local(child.tag) == name and child.text:
return child.text.strip()
return default
def _definitions(data: dict) -> dict[str, FixtureDef]:
found: dict[str, FixtureDef] = {}
for name, raw in data.get("definitions", {}).items():
found[str(name)] = FixtureDef(
name=str(name),
manufacturer=str(raw.get("manufacturer") or ""),
model=str(raw.get("model") or ""),
mode=str(raw.get("mode") or ""),
channels=[str(channel) for channel in raw.get("channels") or []],
)
return found
def load_stage(path: Path) -> Stage:
data = json.loads(path.read_text())
definitions = _definitions(data)
fixtures: list[Fixture] = []
for key, raw in data.get("fixtures", {}).items():
kind = raw.get("kind", "can")
if raw.get("address") is not None:
address = int(raw["address"])
elif raw.get("dmx") is not None:
address = int(raw["dmx"]) - 1
else:
address = None
definition = definitions.get(str(raw.get("def") or ""))
channel_names = list(definition.channels) if definition else []
channels = int(raw.get("channels") or 0) or len(channel_names)
if address is not None and channels == 0:
channels = 43 if kind == "mover" else 8
fixtures.append(
Fixture(
id=str(key),
label=str(raw.get("label", key)),
kind=kind,
x=float(raw["x"]),
y=float(raw["y"]),
universe=None if raw.get("universe") is None else int(raw["universe"]),
address=None if address is None else int(address),
channels=channels,
mode=str(raw.get("mode") or (definition.mode if definition else "")),
name=str(raw.get("name") or raw.get("label", key)),
definition=definition.name if definition else str(raw.get("def") or ""),
channel_names=channel_names,
direction=float(raw.get("direction") or 0),
zero=float(raw.get("zero") or 0),
)
)
return Stage(
building_width=float(data.get("building_width", 7.0)),
origin=str(data.get("origin", "")),
fixtures=fixtures,
name=str(data.get("name") or "xchc"),
path=Path(path),
)
def wrap_degrees(degrees: float) -> int:
"""Nearest degree in -179..180. 0 points toward +Y."""
return (round(float(degrees)) + 180) % 360 - 180
def set_heading(stage: Stage, fixture_id: str, *, direction: float | None = None, zero: float | None = None) -> Fixture:
"""Point a can's direction, or a mover's zero, and store it in the stage file."""
fixture = next((item for item in stage.fixtures if item.id == fixture_id), None)
if fixture is None:
raise KeyError(fixture_id)
if fixture.kind == "can":
if direction is None:
raise ValueError("direction required")
fixture.direction = wrap_degrees(direction)
_write_number(stage, fixture_id, "direction", fixture.direction)
else:
if zero is None:
raise ValueError("zero required")
fixture.zero = wrap_degrees(zero)
_write_number(stage, fixture_id, "zero", fixture.zero)
return fixture
def _write_number(stage: Stage, fixture_id: str, field_name: str, value: int) -> None:
if stage.path is None or not stage.path.is_file():
return
text = stage.path.read_text()
marker = f'"{fixture_id}": {{'
start = text.find(marker)
if start < 0:
return
end = text.find("\n }", start)
if end < 0:
return
block = text[start:end]
updated, count = re.subn(
rf'("{re.escape(field_name)}":\s*)-?\d+(?:\.\d+)?',
rf"\g<1>{value}",
block,
count=1,
)
if count == 0:
updated = block.rstrip() + f',\n "{field_name}": {value}'
stage.path.write_text(text[:start] + updated + text[end:])
def _qxw_fixtures(path: Path) -> tuple[list[dict], str | None]:
root = ET.parse(path).getroot()
output_ip = None
fixtures: list[dict] = []
for element in root.iter():
name = _local(element.tag)
if name == "PluginParameters" and output_ip is None:
output_ip = element.attrib.get("outputIP") or None
if name != "Engine":
continue
for child in element:
if _local(child.tag) != "Fixture":
continue
fixtures.append(
{
"name": _text(child, "Name"),
"mode": _text(child, "Mode"),
"model": _text(child, "Model"),
"manufacturer": _text(child, "Manufacturer"),
"universe": int(_text(child, "Universe", "0")),
"address": int(_text(child, "Address", "0")),
"channels": int(_text(child, "Channels", "0")),
}
)
return fixtures, output_ip
def _stage_id_for(patched: dict, stage_ids: set[str]) -> str | None:
name = patched["name"]
if name in stage_ids:
return name
match = _NUMBER.search(name)
number = int(match.group(1)) if match else None
blob = f"{patched['manufacturer']} {patched['model']} {name}".lower()
mover = "mover" in blob or "small eye" in blob
can = "bcc145" in blob or blob.strip().endswith("can")
if number is None:
lowered = name.lower()
if "front left" in lowered and "M1" in stage_ids:
return "M1"
if "front right" in lowered and "M2" in stage_ids:
return "M2"
if "back left" in lowered and "M3" in stage_ids:
return "M3"
if "back right" in lowered and "M4" in stage_ids:
return "M4"
return None
if mover:
key = f"M{number}"
if key in stage_ids:
return key
if can:
key = f"#{number}"
if key in stage_ids:
return key
return None
def apply_show(stage: Stage, show_path: Path) -> None:
"""Fill missing DMX addresses from a QLC+ workspace."""
patched, output_ip = _qxw_fixtures(show_path)
stage.show = show_path.name
stage.output_ip = output_ip
by_id = {fixture.id: fixture for fixture in stage.fixtures}
used: set[str] = set()
for item in patched:
key = _stage_id_for(item, set(by_id))
if key is None or key in used:
continue
fixture = by_id[key]
if fixture.address is None:
fixture.universe = item["universe"]
fixture.address = item["address"]
fixture.channels = item["channels"] or fixture.channels
fixture.mode = item["mode"]
fixture.name = item["name"]
used.add(key)
for fixture in stage.fixtures:
if fixture.address is None:
stage.warnings.append(f"{fixture.label} has no DMX address")
+612
View File
@@ -0,0 +1,612 @@
const canvas = document.getElementById("stage");
const ctx = canvas.getContext("2d");
const statusEl = document.getElementById("status");
const originEl = document.getElementById("origin");
const nameEl = document.getElementById("stage-name");
const patchEl = document.getElementById("patch");
const listEl = document.getElementById("fixtures");
const detailEl = document.getElementById("detail");
const detailTitle = document.getElementById("detail-title");
const detailMeta = document.getElementById("detail-meta");
const channelsEl = document.getElementById("channels");
let stage = null;
let state = { fixtures: {}, age: null, rate: 0, universe: null, packets: 0 };
let selected = null;
let drag = null;
const rows = new Map();
function luma(r, g, b) {
return 0.2126 * r + 0.7152 * g + 0.0722 * b;
}
function hsv(hue, value) {
const h = ((hue % 1) + 1) % 1;
const i = Math.floor(h * 6);
const f = h * 6 - i;
const q = value * (1 - f);
const t = value * f;
const map = [
[value, t, 0],
[q, value, 0],
[0, value, t],
[0, q, value],
[t, 0, value],
[value, 0, q],
];
const [r, g, b] = map[i % 6];
return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255)];
}
const PAR_PALETTE = [
[255, 0, 0],
[255, 96, 0],
[255, 200, 0],
[255, 255, 0],
[0, 255, 0],
[0, 255, 160],
[0, 64, 255],
[140, 0, 255],
[255, 0, 160],
[255, 255, 255],
];
const aims = new Map();
function scaleColour(colour, dimmer) {
const level = (dimmer || 0) / 255;
return colour.map((channel) => Math.round(channel * level));
}
function paletteColour(live, gradient) {
const palette = live.palette && live.palette.length ? live.palette : PAR_PALETTE;
const speed = live.speed_hz || 0.35;
const phase = performance.now() / 1000 * speed;
const index = Math.floor(phase) % palette.length;
if (!gradient) return palette[index];
const next = palette[(index + 1) % palette.length];
const blend = phase - Math.floor(phase);
return palette[index].map((channel, slot) => Math.round(channel + (next[slot] - channel) * blend));
}
function canColour(live) {
const mode = live.function || "mix";
const dimmer = live.dimmer || 0;
if (mode === "jump" || mode === "gradient") return scaleColour(paletteColour(live, mode === "gradient"), dimmer);
if (mode === "pulse") {
const speed = live.speed_hz || 0.4;
const wave = 0.5 - 0.5 * Math.cos((performance.now() / 1000) * speed * Math.PI * 2);
const depth = 0.05 + 0.95 * wave;
return [live.r || 0, live.g || 0, live.b || 0].map((channel) => Math.round(channel * depth));
}
if (mode === "sound") {
const speed = live.speed_hz || 1;
const variant = live.sound === 2 ? 2 : 1;
const bpm = (variant === 2 ? 156 : 104) * (0.55 + Math.min(speed, 8) / 10);
const beat = ((performance.now() / 1000) * bpm / 60) % 1;
let hit = beat < 0.08 ? 1 : 0.04;
if (variant === 2 && beat > 0.5 && beat < 0.58) hit = 1;
const colour = (live.palette && live.palette[variant === 2 ? 4 : 0]) || PAR_PALETTE[variant === 2 ? 4 : 0];
return scaleColour(colour, dimmer).map((channel) => Math.round(channel * hit));
}
return [live.r || 0, live.g || 0, live.b || 0];
}
function effectPixels(live) {
const source = (live.pixels || []).map((pixel) => pixel.slice());
if (!live.dynamic || !source.length) return source;
const count = source.length;
const lit = source.find((pixel) => pixel[0] + pixel[1] + pixel[2] > 0);
const fallback = lit || scaleColour([255, 255, 255], live.dimmer || 0);
const speed = live.speed_hz || 1;
const t = (performance.now() / 1000) * speed;
return source.map((pixel, index) => {
const colour = pixel[0] + pixel[1] + pixel[2] > 0 ? pixel : fallback;
if (live.dynamic === "rainbow") {
return hsv((t * 0.2 + index / count) % 1, (live.dimmer || 0) / 255);
}
let level = 1;
if (live.dynamic === "chase") level = Math.floor(t) % count === index ? 1 : 0.08;
else if (live.dynamic === "reverse") level = Math.floor(t) % count === (count - 1 - index) ? 1 : 0.08;
else if (live.dynamic === "bounce") {
const span = Math.max(1, count - 1);
const tri = Math.abs((t % (2 * span)) - span);
level = Math.round(tri) === index ? 1 : 0.08;
} else if (live.dynamic === "pulse") level = 0.15 + 0.85 * (0.5 + 0.5 * Math.sin(t * Math.PI * 2));
else if (live.dynamic === "pairs") level = Math.floor(t) % 2 === index % 2 ? 1 : 0.08;
return colour.map((channel) => Math.round(channel * level));
});
}
function mixPixels(pixels) {
let red = 0;
let green = 0;
let blue = 0;
let weight = 0;
for (const pixel of pixels) {
const w = pixel[0] + pixel[1] + pixel[2];
red += pixel[0] * w;
green += pixel[1] * w;
blue += pixel[2] * w;
weight += w;
}
if (weight <= 0) return [0, 0, 0];
return [Math.round(red / weight), Math.round(green / weight), Math.round(blue / weight)];
}
function shutter(live) {
if (!live.strobe_hz) return 1;
const t = performance.now() / 1000;
if (live.strobe_mode === "random") {
const bucket = Math.floor(t * live.strobe_hz);
const noise = Math.abs(Math.sin(bucket * 12.9898) * 43758.5453) % 1;
return noise > 0.55 ? 1 : 0;
}
const period = 1 / live.strobe_hz;
return t % period < period * 0.42 ? 1 : 0;
}
function aimed(id, live, zero) {
const targetPan = (zero || 0) + (live.pan_deg || 0);
const targetBeam = live.beam_m || 0;
const now = performance.now() / 1000;
let state = aims.get(id);
if (!state) {
state = { pan: targetPan, beam: targetBeam, t: now };
aims.set(id, state);
return state;
}
const dt = Math.min(0.05, Math.max(0, now - state.t));
state.t = now;
const fast = live.move == null ? 1 : live.move;
if (fast > 0.97) {
state.pan = targetPan;
state.beam = targetBeam;
return state;
}
const tau = 0.05 + (1 - fast) * 1.8;
const k = 1 - Math.exp(-dt / tau);
state.pan += (targetPan - state.pan) * k;
state.beam += (targetBeam - state.beam) * k;
return state;
}
function appearance(fixture, live) {
const pixels = fixture.kind === "mover" ? effectPixels(live) : null;
let [r, g, b] = fixture.kind === "can" ? canColour(live) : pixels && live.dynamic ? mixPixels(pixels) : [live.r || 0, live.g || 0, live.b || 0];
const gate = shutter(live);
return {
r: Math.round(r * gate),
g: Math.round(g * gate),
b: Math.round(b * gate),
dimmer: live.dimmer || 0,
pixels: pixels && pixels.map((pixel) => pixel.map((channel) => Math.round(channel * gate))),
};
}
function layout(width, height) {
const ys = stage.fixtures.map((fixture) => fixture.y);
const backY = Math.min(0, ...ys);
const depth = Math.max(2.4, ...ys);
const padX = 0.85;
const padY = 0.7;
const x0 = -stage.building_width / 2 - padX;
const x1 = stage.building_width / 2 + padX;
const y0 = backY - padY;
const y1 = depth + padY;
const worldW = x1 - x0;
const worldH = y1 - y0;
const scale = Math.min(width / worldW, height / worldH);
const ox = (width - worldW * scale) / 2;
const oy = (height - worldH * scale) / 2;
return {
depth,
backY,
sx: (x) => ox + (x - x0) * scale,
sy: (y) => oy + (y1 - y) * scale,
mx: (px) => x0 + (px - ox) / scale,
my: (py) => y1 - (py - oy) / scale,
};
}
function draw() {
if (!stage) return;
const dpr = window.devicePixelRatio || 1;
const width = canvas.width;
const height = canvas.height;
ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
const cssW = width / dpr;
const cssH = height / dpr;
const view = layout(cssW, cssH);
const { sx, sy, depth, backY } = view;
ctx.clearRect(0, 0, cssW, cssH);
ctx.fillStyle = "#121216";
ctx.fillRect(0, 0, cssW, cssH);
const left = sx(-stage.building_width / 2);
const right = sx(stage.building_width / 2);
const front = sy(depth);
const back = sy(backY);
ctx.strokeStyle = "#5c5c66";
ctx.lineWidth = 2;
ctx.strokeRect(left, front, right - left, back - front);
ctx.strokeStyle = "#3a3a44";
ctx.lineWidth = 1;
ctx.setLineDash([4, 6]);
ctx.beginPath();
ctx.moveTo(sx(0), sy(backY - 0.2));
ctx.lineTo(sx(0), sy(depth + 0.25));
ctx.stroke();
ctx.setLineDash([]);
ctx.fillStyle = "#9a9aa4";
ctx.font = "600 13px system-ui, sans-serif";
ctx.textAlign = "center";
ctx.fillText("AUDIENCE", sx(0), sy(depth + 0.38));
ctx.font = "12px system-ui, sans-serif";
ctx.fillStyle = "#8d8d96";
ctx.fillText("row of 4", sx(0), sy(-0.28));
ctx.font = "11px system-ui, sans-serif";
ctx.fillText(`${stage.building_width.toFixed(1)} m`, sx(0), front - 8);
ctx.globalCompositeOperation = "lighter";
for (const fixture of stage.fixtures) {
const live = state.fixtures[fixture.id] || {};
const color = appearance(fixture, live);
const dragging = drag && drag.moved && drag.id === fixture.id;
const beamColor = dragging && color.r + color.g + color.b < 8 ? { ...color, r: 190, g: 190, b: 200 } : color;
if (fixture.kind === "mover") {
const fixed = dragging
? { pan: (fixture.zero || 0) + (live.pan_deg || 0), beam: Math.max(live.beam_m || 0, 1.6), zoom: live.zoom_deg || 18, focus: 1 - (live.focus || 0) }
: null;
drawBeam(sx, sy, fixture, live, beamColor, fixed);
} else {
drawBeam(sx, sy, fixture, live, beamColor, { pan: fixture.direction || 0, beam: 2.2, zoom: 25, focus: 0.35 });
}
drawGlow(sx, sy, fixture, color);
}
ctx.globalCompositeOperation = "source-over";
for (const fixture of stage.fixtures) {
const live = state.fixtures[fixture.id] || {};
drawBody(sx, sy, fixture, live, appearance(fixture, live));
}
}
function drawGlow(sx, sy, fixture, color) {
const level = (color.r + color.g + color.b) / (255 * 3);
if (level <= 0.01) return;
const x = sx(fixture.x);
const y = sy(fixture.y);
const radius = (fixture.kind === "mover" ? 70 : 54) * (0.45 + level);
const gradient = ctx.createRadialGradient(x, y, 2, x, y, radius);
gradient.addColorStop(0, `rgba(${color.r},${color.g},${color.b},${0.55 * level + 0.15})`);
gradient.addColorStop(1, `rgba(${color.r},${color.g},${color.b},0)`);
ctx.fillStyle = gradient;
ctx.beginPath();
ctx.arc(x, y, radius, 0, Math.PI * 2);
ctx.fill();
}
function drawBeam(sx, sy, fixture, live, color, fixed) {
const level = (color.r + color.g + color.b) / 255;
const length = fixed ? fixed.beam : Math.max(live.beam_m || 0, fixture.kind === "mover" ? 2.2 : 0);
if (live.patched === false || level <= 0.02 || !length) return;
const aim = fixed || aimed(fixture.id, live, fixture.zero);
// DMX focus 0 is a wide wash. Focus 255 holds the zoom angle.
// Fixed beams pass spread directly, 0 tight and 1 wide.
const spread = fixed ? fixed.focus : 1 - (live.focus || 0);
const zoom = fixed ? fixed.zoom : live.zoom_deg || 8;
const tight = zoom / 2;
const wide = Math.max(tight, 40);
const rad = aim.pan * Math.PI / 180;
const half = (tight + (wide - tight) * spread) * Math.PI / 180;
const tip = [fixture.x + Math.sin(rad) * length, fixture.y + Math.cos(rad) * length];
const left = [fixture.x + Math.sin(rad - half) * length, fixture.y + Math.cos(rad - half) * length];
const right = [fixture.x + Math.sin(rad + half) * length, fixture.y + Math.cos(rad + half) * length];
ctx.beginPath();
ctx.moveTo(sx(fixture.x), sy(fixture.y));
ctx.lineTo(sx(left[0]), sy(left[1]));
ctx.lineTo(sx(right[0]), sy(right[1]));
ctx.closePath();
const gradient = ctx.createLinearGradient(sx(fixture.x), sy(fixture.y), sx(tip[0]), sy(tip[1]));
const alpha = 0.85 * (1 - spread * 0.35);
gradient.addColorStop(0, `rgba(${color.r},${color.g},${color.b},${alpha})`);
gradient.addColorStop(1, `rgba(${color.r},${color.g},${color.b},0)`);
ctx.fillStyle = gradient;
ctx.fill();
}
function lensRotation(live) {
if (live.spin_dps) return ((performance.now() / 1000) * live.spin_dps * Math.PI) / 180;
return ((live.lens_deg || 0) * Math.PI) / 180;
}
function drawBody(sx, sy, fixture, live, color) {
const x = sx(fixture.x);
const y = sy(fixture.y);
const pixels = color.pixels || [];
const head = fixture.kind === "mover" && pixels.length ? pixels[0] : [color.r, color.g, color.b];
const lit = head[0] + head[1] + head[2] > 8;
const size = fixture.kind === "mover" ? 15 : 13;
ctx.beginPath();
if (fixture.kind === "mover") {
ctx.rect(x - size, y - size, size * 2, size * 2);
} else {
ctx.arc(x, y, size, 0, Math.PI * 2);
}
ctx.fillStyle = lit ? `rgb(${head[0]},${head[1]},${head[2]})` : "#2a2a30";
ctx.fill();
ctx.lineWidth = fixture.id === selected ? 2.5 : 1.5;
ctx.strokeStyle = fixture.id === selected ? "#fff" : "#c8c8d0";
ctx.stroke();
if (fixture.kind === "mover" && pixels.length > 1) {
const ring = pixels.slice(1);
const spin = lensRotation(live);
ring.forEach((pixel, index) => {
const angle = spin + (index / ring.length) * Math.PI * 2 - Math.PI / 2;
const px = x + Math.cos(angle) * (size + 7);
const py = y + Math.sin(angle) * (size + 7);
ctx.beginPath();
ctx.arc(px, py, 3.5, 0, Math.PI * 2);
const on = pixel[0] + pixel[1] + pixel[2] > 0;
ctx.fillStyle = on ? `rgb(${pixel[0]},${pixel[1]},${pixel[2]})` : "#333";
ctx.fill();
});
}
ctx.fillStyle = lit && luma(head[0], head[1], head[2]) > 140 ? "#16161a" : "#f2f2f4";
ctx.font = "600 11px system-ui, sans-serif";
ctx.textAlign = "center";
ctx.textBaseline = "middle";
ctx.fillText(fixture.label, x, y);
ctx.textBaseline = "alphabetic";
}
function resize() {
const rect = canvas.getBoundingClientRect();
const dpr = window.devicePixelRatio || 1;
canvas.width = Math.max(1, Math.floor(rect.width * dpr));
canvas.height = Math.max(1, Math.floor(rect.height * dpr));
draw();
}
function swatchColor(fixture, live) {
const color = appearance(fixture, live || {});
const head = fixture.kind === "mover" && color.pixels && color.pixels[0] ? color.pixels[0] : [color.r, color.g, color.b];
if (head[0] + head[1] + head[2] < 8) return "#2a2a30";
return `rgb(${head[0]},${head[1]},${head[2]})`;
}
function buildList() {
listEl.replaceChildren();
rows.clear();
for (const fixture of stage.fixtures) {
const li = document.createElement("li");
li.id = `fx-${fixture.id}`;
li.className = fixture.kind;
li.dataset.id = fixture.id;
const swatch = document.createElement("span");
swatch.className = "swatch";
const name = document.createElement("span");
name.className = "name";
name.textContent = fixture.label;
const addr = document.createElement("span");
addr.className = "addr";
addr.textContent = fixture.dmx == null ? "no address" : `DMX ${fixture.dmx}`;
li.append(swatch, name, addr);
li.addEventListener("click", () => {
selected = fixture.id;
updateDetail();
draw();
});
listEl.append(li);
rows.set(fixture.id, { li, swatch, addr });
}
}
function updateList() {
for (const fixture of stage.fixtures) {
const row = rows.get(fixture.id);
const live = state.fixtures[fixture.id] || {};
row.swatch.style.background = swatchColor(fixture, live);
row.li.classList.toggle("selected", fixture.id === selected);
if (!live.patched) row.addr.textContent = "no address";
else if (live.function && live.function !== "mix" && live.function !== "pixels") {
row.addr.textContent = `DMX ${fixture.dmx} · ${live.function_label || live.function}`;
} else row.addr.textContent = `DMX ${fixture.dmx}`;
}
}
function updateDetail() {
const fixture = stage.fixtures.find((item) => item.id === selected);
if (!fixture) {
detailEl.hidden = true;
return;
}
const live = state.fixtures[fixture.id] || {};
detailEl.hidden = false;
detailTitle.textContent = fixture.name || fixture.label;
const bits = [];
if (fixture.dmx != null) bits.push(`DMX ${fixture.dmx}`);
if (fixture.def) bits.push(fixture.def);
else if (fixture.mode) bits.push(fixture.mode);
if (fixture.kind === "can") bits.push(`direction ${fixture.direction || 0}°`);
if (fixture.kind === "mover") bits.push(`zero ${fixture.zero || 0}°`);
if (live.function_label && live.function !== "mix" && live.function !== "pixels") bits.push(live.function_label);
if (live.speed_hz) bits.push(`${live.speed_hz.toFixed(1)} Hz`);
if (live.reset) bits.push("reset");
if (fixture.kind === "mover" && live.pan_deg != null) {
bits.push(`pan ${live.pan_deg.toFixed(0)}°`);
bits.push(`zoom ${(live.zoom_deg || 0).toFixed(0)}°`);
if (live.spin_dps) bits.push(`lens ${live.spin_dps > 0 ? "CW" : "CCW"}`);
else if (live.lens_deg) bits.push(`lens ${live.lens_deg.toFixed(0)}°`);
}
detailMeta.textContent = bits.join(" · ");
const channels = live.channels || [];
channelsEl.replaceChildren();
channels.forEach((value, index) => {
const row = document.createElement("div");
row.className = "channel";
const label = document.createElement("span");
label.textContent = String(index + 1);
const title = document.createElement("span");
title.className = "ch-name";
title.textContent = (fixture.channel_names && fixture.channel_names[index]) || "";
const bar = document.createElement("div");
bar.className = "bar";
const fill = document.createElement("span");
fill.style.width = `${(value / 255) * 100}%`;
bar.append(fill);
const num = document.createElement("span");
num.textContent = String(value);
row.append(label, title, bar, num);
channelsEl.append(row);
});
}
function updateStatus() {
const age = state.age;
const live = age != null && age < 1.5;
statusEl.classList.toggle("live", live);
if (!live) {
statusEl.textContent = state.packets ? "Art-Net idle" : "waiting for Art-Net";
return;
}
const universe = state.universe == null ? "" : ` · universe ${state.universe}`;
statusEl.textContent = `Art-Net ${state.rate} fps${universe}`;
}
async function poll() {
try {
state = await fetch("/api/state").then((response) => response.json());
updateStatus();
updateList();
if (selected) updateDetail();
} catch {
statusEl.classList.remove("live");
statusEl.textContent = "view disconnected";
}
}
function frame() {
draw();
if (stage) updateList();
requestAnimationFrame(frame);
}
function pointerMetres(event) {
const rect = canvas.getBoundingClientRect();
const view = layout(rect.width, rect.height);
return {
x: view.mx(event.clientX - rect.left),
y: view.my(event.clientY - rect.top),
};
}
function fixtureAt(x, y) {
let best = null;
let bestDist = 0.55;
for (const fixture of stage.fixtures) {
const dist = Math.hypot(fixture.x - x, fixture.y - y);
if (dist < bestDist) {
best = fixture;
bestDist = dist;
}
}
return best;
}
function wrapDegrees(degrees) {
return ((Math.round(degrees) + 180) % 360 + 360) % 360 - 180;
}
function aimDegrees(fixture, x, y) {
return wrapDegrees(Math.atan2(x - fixture.x, y - fixture.y) * 180 / Math.PI);
}
function saveHeading(fixture) {
const body = fixture.kind === "can"
? { id: fixture.id, direction: fixture.direction }
: { id: fixture.id, zero: fixture.zero };
fetch("/api/heading", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(body),
}).catch(() => {});
}
canvas.addEventListener("pointerdown", (event) => {
if (!stage || event.button !== 0) return;
const { x, y } = pointerMetres(event);
const fixture = fixtureAt(x, y);
selected = fixture ? fixture.id : null;
drag = fixture ? { id: fixture.id, moved: false } : null;
if (drag) canvas.setPointerCapture(event.pointerId);
canvas.style.cursor = fixture ? "grabbing" : "default";
updateList();
updateDetail();
});
canvas.addEventListener("pointermove", (event) => {
if (!stage) return;
const { x, y } = pointerMetres(event);
if (!drag) {
canvas.style.cursor = fixtureAt(x, y) ? "grab" : "default";
return;
}
const fixture = stage.fixtures.find((item) => item.id === drag.id);
if (!fixture) return;
if (!drag.moved && Math.hypot(x - fixture.x, y - fixture.y) < 0.2) return;
drag.moved = true;
const heading = aimDegrees(fixture, x, y);
if (fixture.kind === "can") fixture.direction = heading;
else {
const live = state.fixtures[fixture.id] || {};
fixture.zero = wrapDegrees(heading - (live.pan_deg || 0));
}
updateDetail();
});
canvas.addEventListener("pointerup", () => {
if (!drag) return;
const fixture = stage.fixtures.find((item) => item.id === drag.id);
const moved = drag.moved;
drag = null;
canvas.style.cursor = "grab";
if (fixture && moved) {
aims.delete(fixture.id);
saveHeading(fixture);
}
updateDetail();
});
canvas.addEventListener("pointercancel", () => {
drag = null;
canvas.style.cursor = "default";
});
window.addEventListener("resize", resize);
fetch("/api/stage")
.then((response) => response.json())
.then((loaded) => {
stage = loaded;
nameEl.textContent = stage.name || "xchc";
document.title = stage.name || "xchc";
originEl.textContent = stage.origin || "";
const show = stage.show ? stage.show : "stage file";
const target = stage.output_ip ? ` · QLC+ output ${stage.output_ip}` : "";
patchEl.textContent = `${show}${target}`;
buildList();
resize();
poll();
setInterval(poll, 50);
requestAnimationFrame(frame);
})
.catch(() => {
statusEl.textContent = "could not load the stage";
});
+31
View File
@@ -0,0 +1,31 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>xchc</title>
<link rel="stylesheet" href="/static/style.css">
</head>
<body>
<header>
<div class="titles">
<h1 id="stage-name">xchc</h1>
<p id="origin"></p>
</div>
<p id="status" class="pill">waiting for Art-Net</p>
</header>
<main>
<canvas id="stage" aria-label="Stage plan"></canvas>
<aside>
<p id="patch" class="meta"></p>
<ul id="fixtures"></ul>
<section id="detail" hidden>
<h2 id="detail-title"></h2>
<p id="detail-meta" class="meta"></p>
<div id="channels"></div>
</section>
</aside>
</main>
<script src="/static/app.js"></script>
</body>
</html>
+158
View File
@@ -0,0 +1,158 @@
:root {
color-scheme: dark;
--bg: #0e0e10;
--panel: #141418;
--line: #2c2c34;
--text: #eee;
--muted: #8d8d96;
--live: #3dd68c;
--idle: #d7a13a;
}
* { box-sizing: border-box; }
html, body {
margin: 0;
height: 100%;
background: var(--bg);
color: var(--text);
font-family: system-ui, sans-serif;
}
body {
display: grid;
grid-template-rows: auto 1fr;
min-height: 100%;
}
header {
display: flex;
align-items: center;
justify-content: space-between;
gap: 16px;
padding: 12px 16px;
border-bottom: 1px solid var(--line);
}
h1, h2 {
margin: 0;
font-size: 16px;
font-weight: 600;
}
h2 { font-size: 14px; }
.titles p, .meta {
margin: 2px 0 0;
color: var(--muted);
font-size: 12px;
}
.pill {
margin: 0;
padding: 4px 10px;
border-radius: 999px;
background: #2a2418;
color: var(--idle);
font-size: 12px;
font-variant-numeric: tabular-nums;
}
.pill.live {
background: #14281e;
color: var(--live);
}
main {
display: grid;
grid-template-columns: 1fr 300px;
min-height: 0;
}
canvas {
width: 100%;
height: 100%;
display: block;
background: #121216;
touch-action: none;
}
aside {
border-left: 1px solid var(--line);
background: var(--panel);
overflow: auto;
padding: 12px 14px 24px;
}
ul {
list-style: none;
margin: 10px 0 0;
padding: 0;
}
li {
display: grid;
grid-template-columns: 18px 1fr auto;
gap: 8px;
align-items: center;
padding: 7px 6px;
border-radius: 6px;
cursor: pointer;
}
li:hover, li.selected { background: #22222a; }
.swatch {
width: 18px;
height: 18px;
border-radius: 50%;
border: 1px solid #555;
background: #222;
}
li.mover .swatch { border-radius: 3px; }
.name { font-size: 13px; font-weight: 600; }
.addr { color: var(--muted); font-size: 11px; }
#detail { margin-top: 16px; }
#channels {
display: grid;
gap: 3px;
margin-top: 8px;
}
.channel {
display: grid;
grid-template-columns: 22px minmax(72px, 1.2fr) 1fr 28px;
gap: 6px;
align-items: center;
font-size: 11px;
color: var(--muted);
font-variant-numeric: tabular-nums;
}
.ch-name {
overflow: hidden;
text-overflow: ellipsis;
white-space: nowrap;
}
.bar {
height: 6px;
background: #2a2a32;
border-radius: 99px;
overflow: hidden;
}
.bar span {
display: block;
height: 100%;
background: #d0d0d8;
}
@media (max-width: 800px) {
main { grid-template-columns: 1fr; grid-template-rows: minmax(280px, 1fr) auto; }
aside { border-left: 0; border-top: 1px solid var(--line); max-height: 42vh; }
}
+230
View File
@@ -0,0 +1,230 @@
"""Stage simulator: Art-Net decode and the XCHC patch."""
from __future__ import annotations
import json
import threading
from pathlib import Path
from urllib.request import urlopen
from simulator.artnet import ArtNetNode, build_artdmx, parse_artdmx, parse_opcode
from simulator.decode import apply_cto, decode_can, decode_mover, lens_angle, lens_spin, mix_rgbw, view_stage
from simulator.server import Simulator, make_server
from simulator.stage import apply_show, load_stage, set_heading, wrap_degrees
ROOT = Path(__file__).resolve().parents[1]
def test_artdmx_roundtrip():
frame = bytearray(512)
frame[87] = 255
frame[89] = 200
packet = build_artdmx(frame, universe=0, sequence=3)
parsed = parse_artdmx(packet)
assert parsed is not None
universe, data = parsed
assert universe == 0
assert data[87] == 255
assert data[89] == 200
assert parse_opcode(packet) == 0x5000
def test_poll_is_not_dmx():
packet = b"Art-Net\x00" + bytes([0x00, 0x20]) + bytes(10)
assert parse_opcode(packet) == 0x2000
assert parse_artdmx(packet) is None
def test_xchc_patch_matches_the_stage_map():
stage = load_stage(ROOT / "stage" / "map.json")
apply_show(stage, ROOT / "shows" / "xchc.qxw")
by_id = {fixture.id: fixture for fixture in stage.fixtures}
assert by_id["#1"].address == 87
assert by_id["#1"].dmx == 88
assert by_id["#8"].address == 143
assert by_id["M1"].address == 0
assert by_id["M1"].dmx == 1
assert by_id["M2"].address == 44
assert by_id["M1"].channels == 43
assert by_id["#3"].kind == "can"
assert stage.output_ip == "192.168.1.228"
assert stage.name == "xchc"
assert by_id["#9"].x == -3.5 and by_id["#9"].y == -0.8
assert by_id["#11"].y == -6.8 and by_id["#12"].x == 3.5
assert by_id["#13"].x == -3.5 and by_id["#15"].x == 3.5
assert by_id["#14"].x == 0.0 and by_id["#14"].y == -7.65
assert by_id["#1"].address == 87 and by_id["#9"].address == 151
assert by_id["#15"].address == 199 and by_id["M1"].address == 0
assert by_id["M2"].address == 44 and by_id["#15"].channels == 8
assert by_id["M3"].address == 257 and by_id["M3"].channels == 43
assert by_id["M3"].x == -1.75 and by_id["M3"].y == -7.65
assert by_id["M4"].address == 300 and by_id["M4"].x == 1.75
assert by_id["#1"].direction == 90 and by_id["#8"].direction == -90
assert by_id["#3"].direction == 0 and by_id["#14"].direction == 0
assert by_id["M1"].zero == 0 and by_id["M4"].zero == 0
assert stage.warnings == []
def test_can_red_and_white():
assert mix_rgbw(0, 0, 0, 255, 255) == (255, 255, 255)
viewed = decode_can([255, 0, 255, 0, 0, 0, 0, 0])
assert (viewed["r"], viewed["g"], viewed["b"]) == (255, 0, 0)
assert viewed["function"] == "mix"
assert viewed["strobe_hz"] == 0
assert decode_can([255, 255, 255, 0, 0, 0, 0, 0])["strobe_hz"] > 0
assert decode_can([128, 0, 0, 0, 0, 0, 120, 0])["effect"] is True
def test_can_macro_functions():
assert decode_can([255, 0, 0, 0, 0, 0, 51, 0])["function"] == "fixed"
assert decode_can([255, 0, 0, 0, 0, 0, 51, 0])["r"] == 255
assert decode_can([0, 0, 0, 0, 0, 0, 80, 0])["r"] == 0
jump = decode_can([255, 0, 0, 0, 0, 0, 120, 200])
assert jump["function"] == "jump"
assert jump["speed_hz"] > 1
assert jump["palette"][0] == [255, 0, 0]
pulse = decode_can([255, 0, 255, 80, 0, 0, 170, 0])
assert pulse["function"] == "pulse"
assert pulse["r"] == 255 and pulse["g"] == 80
assert decode_can([255, 0, 0, 0, 0, 0, 220, 0])["function"] == "gradient"
sound = decode_can([255, 0, 0, 0, 0, 0, 255, 0])
assert sound["function"] == "sound" and sound["sound"] == 2
def test_mover_home_points_at_the_audience():
channels = [0] * 43
channels[0] = 128 # pan coarse, fine 0 → 32768, the centre of 540°
channels[2] = 160
channels[8] = 255
channels[10] = 255 # red on the first pixel
viewed = decode_mover(channels)
assert viewed["pan_deg"] == 0
assert viewed["r"] == 255
assert viewed["beam_m"] > 2
parked = [0] * 43
parked[8] = 255
assert decode_mover(parked)["beam_m"] >= 2.2
assert lens_spin(0) == 0
assert lens_spin(160) < 0
assert lens_spin(230) > 0
assert lens_angle(0) == 0
assert 25 < lens_angle(64) < 35
def test_mover_functions():
channels = [0] * 43
channels[5] = 230
channels[6] = 255
channels[8] = 255
channels[39] = 20
macro = decode_mover(channels)
assert macro["function"] == "macro"
assert macro["r"] == 255 and macro["b"] == 0
assert macro["zoom_deg"] == 45
assert macro["spin_dps"] > 0
channels[40] = 103
static = decode_mover(channels)
assert static["function"] == "static"
assert static["pixels"][3][0] == 255
assert static["pixels"][0] == [0, 0, 0]
channels[41] = 30
dynamic = decode_mover(channels)
assert dynamic["function"] == "dynamic"
assert dynamic["dynamic"] == "chase"
assert dynamic["pixels"][0][0] == 255
assert dynamic["speed_hz"] > 0
warm = [0] * 43
warm[8] = 255
warm[10] = warm[11] = warm[12] = 255
warm[38] = 255
tinted = decode_mover(warm)
assert tinted["r"] == 255
assert tinted["b"] < apply_cto(255, 255, 255, 0)[2]
assert tinted["b"] < 100
strobe = [0] * 43
strobe[9] = 240
assert decode_mover(strobe)["strobe_mode"] == "random"
assert decode_mover([0] * 43)["strobe_mode"] == "open"
def test_map_definition_selects_the_channels():
stage = load_stage(ROOT / "stage" / "map.json")
mover = next(fixture for fixture in stage.fixtures if fixture.id == "M1")
can = next(fixture for fixture in stage.fixtures if fixture.id == "#1")
assert can.channel_names[:3] == ["Dimmer", "Strobe", "Red"]
assert mover.channel_names[5] == "Lens Rotate"
assert mover.channel_names[6] == "Zoom"
assert mover.mode == "43 Channel"
frame = bytearray(512)
frame[mover.address + mover.channel_names.index("Pan")] = 128
frame[mover.address + mover.channel_names.index("Zoom")] = 255
frame[mover.address + mover.channel_names.index("Center Brightness")] = 255
frame[mover.address + mover.channel_names.index("Red 1")] = 255
frame[mover.address + mover.channel_names.index("Lens Rotate")] = 230
live = view_stage(stage, {0: bytes(frame)})["M1"]
assert live["zoom_deg"] == 45
assert live["spin_dps"] > 0
assert live["r"] == 255
assert live["pan_deg"] == 0
def test_view_reads_universe_bytes():
stage = load_stage(ROOT / "stage" / "map.json")
apply_show(stage, ROOT / "shows" / "xchc.qxw")
frame = bytearray(512)
frame[87] = 255
frame[89] = 0
frame[90] = 255
live = view_stage(stage, {0: bytes(frame)})
assert (live["#1"]["r"], live["#1"]["g"], live["#1"]["b"]) == (0, 255, 0)
assert live["#2"]["dimmer"] == 0
def test_http_state_follows_artnet():
stage = load_stage(ROOT / "stage" / "map.json")
apply_show(stage, ROOT / "shows" / "xchc.qxw")
node = ArtNetNode("127.0.0.1", 0)
node.start()
server = make_server(Simulator(stage, node), "127.0.0.1", 0)
thread = threading.Thread(target=server.serve_forever, daemon=True)
thread.start()
try:
frame = bytearray(512)
frame[0] = 128
frame[8] = 255
frame[10] = 255
node.write(0, frame)
port = server.server_address[1]
with urlopen(f"http://127.0.0.1:{port}/api/state") as response:
payload = json.load(response)
assert payload["packets"] == 1
assert payload["fixtures"]["M1"]["r"] == 255
with urlopen(f"http://127.0.0.1:{port}/api/stage") as response:
described = json.load(response)
assert described["fixtures"][0]["x"] == -3.5
finally:
server.shutdown()
node.close()
def test_heading_is_stored_in_the_map(tmp_path):
target = tmp_path / "map.json"
target.write_text((ROOT / "stage" / "map.json").read_text())
stage = load_stage(target)
assert wrap_degrees(270) == -90
set_heading(stage, "#1", direction=45)
set_heading(stage, "M1", zero=-30)
saved = json.loads(target.read_text())
assert saved["fixtures"]["#1"]["direction"] == 45
assert saved["fixtures"]["#2"]["direction"] == 90
assert saved["fixtures"]["M1"]["zero"] == -30
assert saved["fixtures"]["M2"]["zero"] == 0
again = load_stage(target)
by_id = {fixture.id: fixture for fixture in again.fixtures}
assert by_id["#1"].direction == 45
assert by_id["M1"].zero == -30