Files
qlcplus/simulator/decode.py
T
jimmyandClaude Opus 5.5 fc8abf9c99 Set the movers' zeros and pan directions, swap M1/M2's patch, and model tilt in the simulator.
The front right mover is on DMX 1 and the front left on 45, so M1 and M2
swap addresses in the stage map and test.qxw. Measured on the rig, pan 0
faces forward on the front pair and into the middle on the back pair, back
at 85. M1 and M4 turn anticlockwise, so movers get a pan_reverse flag.

Tilt 127 now points straight down: the simulator draws a spot under the
head, and past 127 the beam flips behind the pan heading.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 22:54:14 +13:00

441 lines
15 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""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 math
import re
from simulator.stage import Fixture, Stage
_PIXEL = re.compile(r"^(red|green|blue|white) (\d+)$", re.IGNORECASE)
PAN_DEGREES = 540.0
# Tilt 127 is straight down. 0 leans along the pan heading, 255 away from it.
TILT_DEGREES = 270.0
# Plan reach of a beam at or above horizontal.
BEAM_MAX_M = 4.7
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)
tilt_deg = (tilt - 32768) / 65536.0 * TILT_DEGREES
# Reach along the pan heading on the plan. Negative points behind it.
lean = max(-90.0, min(90.0, -tilt_deg))
beam_m = BEAM_MAX_M * math.sin(math.radians(lean))
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),
"tilt_deg": round(tilt_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)
if fixture.pan_reverse and "pan_deg" in viewed:
viewed["pan_deg"] = -viewed["pan_deg"]
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}