M8.9 (scopes):
- New L3 crate filmcraft-scopes (wasm-clean): Waveform RGB/Luma/YC/YC no Chroma,
Parade RGB/YUV/RGB-White, Histogram, Vectorscope YUV (75/100 % targets, skin-tone
line) and HLS; Rec. 601/709/2100 matrices, Clamp Signal, 8-bit/float/HDR (PQ cd/m2)
scales; numeric summaries; density painting. < 1 ms per scope at 1080p.
- Lumetri Scopes panel rewritten: multi-scope grid, wrench / right-click menu (presets,
scopes, parade/waveform type, targets, colour space, brightness, scale), footer
(colour space, Clamp Signal, 8 Bit/Float/HDR). Settings in UiState::panels.
- scopes.read engine query returns levels, histogram bins, waveform/parade columns and
vectorscope peaks.
M12.6 (panels):
- Metadata panel with editable Name/Label/log fields (metadata.get / metadata.set,
one undo step, stored in ProjectItem::metadata; no schema change, stays v11).
- Timecode panel (rows: current/media/duration/in-out/remaining, any time display).
- Events panel on a new engine event log (failed/disabled commands, toasts, auto-save
errors, jobs started/finished/failed/cancelled; events.list / events.clear).
- Progress panel (jobs with progress and Cancel).
- Reference Monitor (parked or ganged to Program; picture or scopes).
- All open from Window > menu, have automation ids; ui.set {"panels": ...} merges state.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
724 lines
25 KiB
Rust
724 lines
25 KiB
Rust
//! Video scopes maths (layer L3, no UI): the waveform, parade, histogram and the YUV and HLS
|
||
//! vectorscopes of a frame, as count grids ("how many samples land on this cell"), plus numeric
|
||
//! summaries for agents ([`summary`]) and the density-to-pixels mapping the UI draws ([`paint`]).
|
||
//!
|
||
//! The input is a [`Signal`]: the frame's R'G'B' code values (display-encoded, 0..1 nominal;
|
||
//! values outside it are super-whites / sub-blacks of float or HDR frames), decimated to at most
|
||
//! [`MAX_W`] × [`MAX_H`] samples by nearest-sample picking (no averaging, so flat colours and
|
||
//! test patterns land on exact cells). Y'CbCr comes from the scope's colour space matrix
|
||
//! (BT.601, BT.709 or BT.2020 NCL; `filmcraft_color::rgb_to_ycbcr`).
|
||
//!
|
||
//! | Scope | Grid | Columns × rows |
|
||
//! |---|---|---|
|
||
//! | Waveform RGB / Luma / YC / YC no Chroma | per trace: R, G, B / Y / Y and C (Y ± \|CbCr\|) / Y | signal width × `rows` |
|
||
//! | Parade RGB / YUV / RGB-White | per trace: R, G, B / Y, Cb + ½, Cr + ½ / R, G, B, Y | signal width × `rows` (drawn side by side) |
|
||
//! | Histogram | 256 bins per channel R, G, B, Y | — |
|
||
//! | Vectorscope YUV | Cb horizontal, Cr up, ±[`VECTOR_EXTENT`] | `vector_size`² |
|
||
//! | Vectorscope HLS | hue as the angle (red at the YUV red angle), HLS saturation as the radius (1 = 0.5) | `vector_size`² |
|
||
//!
|
||
//! Waveform rows cover `[lo, hi]` = `[0, 1]` with Clamp Signal on (values clamped first) and
|
||
//! `[-0.1, 1.1]` without (values outside are dropped). With 256 rows over `[0, 1]`, an 8-bit code
|
||
//! value `c` lands exactly on row `c`.
|
||
|
||
pub mod paint;
|
||
pub mod summary;
|
||
#[cfg(test)]
|
||
mod tests;
|
||
|
||
pub use filmcraft_color::Matrix;
|
||
use filmcraft_color::rgb_to_ycbcr;
|
||
use serde::{Deserialize, Serialize};
|
||
|
||
/// Largest decimated signal (a 1080p frame is sampled every 4th pixel both ways).
|
||
pub const MAX_W: usize = 480;
|
||
pub const MAX_H: usize = 270;
|
||
|
||
/// Half-width of the vectorscope plane in Cb/Cr units (the 100 % targets of every matrix fit).
|
||
pub const VECTOR_EXTENT: f32 = 0.6;
|
||
|
||
/// The skin-tone line (the "I" axis of NTSC): 123° counter-clockwise from +Cb.
|
||
pub const SKIN_TONE_DEG: f32 = 123.0;
|
||
|
||
// ------------------------------------------------------------------------------------ settings
|
||
|
||
/// A scope of the Lumetri Scopes panel.
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub enum ScopeKind {
|
||
VectorscopeYuv,
|
||
VectorscopeHls,
|
||
Histogram,
|
||
Parade,
|
||
#[default]
|
||
Waveform,
|
||
}
|
||
|
||
impl ScopeKind {
|
||
pub const ALL: [ScopeKind; 5] = [ScopeKind::VectorscopeYuv, ScopeKind::VectorscopeHls, ScopeKind::Histogram, ScopeKind::Parade, ScopeKind::Waveform];
|
||
/// Stable id (`"vectorscopeYuv"`…), as in JSON.
|
||
pub fn name(self) -> &'static str {
|
||
match self {
|
||
ScopeKind::VectorscopeYuv => "vectorscopeYuv",
|
||
ScopeKind::VectorscopeHls => "vectorscopeHls",
|
||
ScopeKind::Histogram => "histogram",
|
||
ScopeKind::Parade => "parade",
|
||
ScopeKind::Waveform => "waveform",
|
||
}
|
||
}
|
||
pub fn label(self) -> &'static str {
|
||
match self {
|
||
ScopeKind::VectorscopeYuv => "Vectorscope YUV",
|
||
ScopeKind::VectorscopeHls => "Vectorscope HLS",
|
||
ScopeKind::Histogram => "Histogram",
|
||
ScopeKind::Parade => "Parade",
|
||
ScopeKind::Waveform => "Waveform",
|
||
}
|
||
}
|
||
/// By id or label, ignoring case, spaces and dashes (`"vectorscope"` = the YUV one).
|
||
pub fn from_name(s: &str) -> Option<ScopeKind> {
|
||
let n = norm(s);
|
||
if n == "vectorscope" || n == "yuv" {
|
||
return Some(ScopeKind::VectorscopeYuv);
|
||
}
|
||
if n == "hls" {
|
||
return Some(ScopeKind::VectorscopeHls);
|
||
}
|
||
Self::ALL.into_iter().find(|k| norm(k.name()) == n || norm(k.label()) == n)
|
||
}
|
||
}
|
||
|
||
fn norm(s: &str) -> String {
|
||
s.chars().filter(|c| c.is_alphanumeric()).collect::<String>().to_ascii_lowercase()
|
||
}
|
||
|
||
/// Waveform Type.
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub enum WaveformType {
|
||
#[default]
|
||
Rgb,
|
||
Luma,
|
||
Yc,
|
||
YcNoChroma,
|
||
}
|
||
|
||
impl WaveformType {
|
||
pub const ALL: [WaveformType; 4] = [WaveformType::Rgb, WaveformType::Luma, WaveformType::Yc, WaveformType::YcNoChroma];
|
||
pub fn label(self) -> &'static str {
|
||
match self {
|
||
WaveformType::Rgb => "RGB",
|
||
WaveformType::Luma => "Luma",
|
||
WaveformType::Yc => "YC",
|
||
WaveformType::YcNoChroma => "YC no Chroma",
|
||
}
|
||
}
|
||
pub fn from_name(s: &str) -> Option<Self> {
|
||
let n = norm(s);
|
||
Self::ALL.into_iter().find(|k| norm(k.label()) == n || norm(&format!("{k:?}")) == n)
|
||
}
|
||
}
|
||
|
||
/// Parade Type.
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub enum ParadeType {
|
||
#[default]
|
||
Rgb,
|
||
Yuv,
|
||
RgbWhite,
|
||
}
|
||
|
||
impl ParadeType {
|
||
pub const ALL: [ParadeType; 3] = [ParadeType::Rgb, ParadeType::Yuv, ParadeType::RgbWhite];
|
||
pub fn label(self) -> &'static str {
|
||
match self {
|
||
ParadeType::Rgb => "RGB",
|
||
ParadeType::Yuv => "YUV",
|
||
ParadeType::RgbWhite => "RGB-White",
|
||
}
|
||
}
|
||
pub fn from_name(s: &str) -> Option<Self> {
|
||
let n = norm(s);
|
||
Self::ALL.into_iter().find(|k| norm(k.label()) == n || norm(&format!("{k:?}")) == n)
|
||
}
|
||
}
|
||
|
||
/// The scopes' colour space (the Y'CbCr matrix; Rec. 2100 also means an HDR signal).
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub enum ColorSpace {
|
||
/// Follow the sequence: Rec. 2100 for an HDR working space, else Rec. 709.
|
||
#[default]
|
||
Auto,
|
||
Rec601,
|
||
Rec709,
|
||
Rec2100,
|
||
}
|
||
|
||
impl ColorSpace {
|
||
pub const ALL: [ColorSpace; 4] = [ColorSpace::Auto, ColorSpace::Rec601, ColorSpace::Rec709, ColorSpace::Rec2100];
|
||
pub fn label(self) -> &'static str {
|
||
match self {
|
||
ColorSpace::Auto => "Automatic",
|
||
ColorSpace::Rec601 => "Rec. 601",
|
||
ColorSpace::Rec709 => "Rec. 709",
|
||
ColorSpace::Rec2100 => "Rec. 2100",
|
||
}
|
||
}
|
||
/// `Auto` resolved for a sequence (`hdr`: its working space is PQ/HLG).
|
||
pub fn resolve(self, hdr: bool) -> ColorSpace {
|
||
match self {
|
||
ColorSpace::Auto if hdr => ColorSpace::Rec2100,
|
||
ColorSpace::Auto => ColorSpace::Rec709,
|
||
c => c,
|
||
}
|
||
}
|
||
pub fn matrix(self) -> Matrix {
|
||
match self {
|
||
ColorSpace::Rec601 => Matrix::Bt601,
|
||
ColorSpace::Rec2100 => Matrix::Bt2020Ncl,
|
||
_ => Matrix::Bt709,
|
||
}
|
||
}
|
||
pub fn from_name(s: &str) -> Option<Self> {
|
||
let n = norm(s);
|
||
Self::ALL.into_iter().find(|k| norm(k.label()) == n || norm(&format!("{k:?}")) == n || norm(k.label()).trim_start_matches("rec") == n)
|
||
}
|
||
}
|
||
|
||
/// Signal scale (the bit-depth dropdown): the labels of the levels axis.
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub enum Scale {
|
||
/// 0–255 code values.
|
||
#[default]
|
||
Bits8,
|
||
/// 0.0–1.0.
|
||
Float,
|
||
/// cd/m² on a PQ axis (0–10 000).
|
||
Hdr,
|
||
}
|
||
|
||
impl Scale {
|
||
pub const ALL: [Scale; 3] = [Scale::Bits8, Scale::Float, Scale::Hdr];
|
||
pub fn label(self) -> &'static str {
|
||
match self {
|
||
Scale::Bits8 => "8 Bit",
|
||
Scale::Float => "Float",
|
||
Scale::Hdr => "HDR",
|
||
}
|
||
}
|
||
pub fn from_name(s: &str) -> Option<Self> {
|
||
let n = norm(s);
|
||
Self::ALL.into_iter().find(|k| norm(k.label()) == n || norm(&format!("{k:?}")) == n)
|
||
}
|
||
}
|
||
|
||
/// Trace brightness.
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
|
||
#[serde(rename_all = "camelCase")]
|
||
pub enum Brightness {
|
||
Dimmed,
|
||
#[default]
|
||
Normal,
|
||
Bright,
|
||
}
|
||
|
||
impl Brightness {
|
||
pub const ALL: [Brightness; 3] = [Brightness::Dimmed, Brightness::Normal, Brightness::Bright];
|
||
pub fn label(self) -> &'static str {
|
||
match self {
|
||
Brightness::Dimmed => "Dimmed",
|
||
Brightness::Normal => "Normal",
|
||
Brightness::Bright => "Bright",
|
||
}
|
||
}
|
||
/// Multiplier of the trace intensity.
|
||
pub fn gain(self) -> f32 {
|
||
match self {
|
||
Brightness::Dimmed => 0.55,
|
||
Brightness::Normal => 1.0,
|
||
Brightness::Bright => 1.6,
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Which colour-bar targets the YUV vectorscope draws.
|
||
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
|
||
pub enum Targets {
|
||
#[default]
|
||
#[serde(rename = "75")]
|
||
Percent75,
|
||
#[serde(rename = "100")]
|
||
Percent100,
|
||
}
|
||
|
||
impl Targets {
|
||
pub fn amplitude(self) -> f32 {
|
||
match self {
|
||
Targets::Percent75 => 0.75,
|
||
Targets::Percent100 => 1.0,
|
||
}
|
||
}
|
||
pub fn label(self) -> &'static str {
|
||
match self {
|
||
Targets::Percent75 => "75%",
|
||
Targets::Percent100 => "100%",
|
||
}
|
||
}
|
||
}
|
||
|
||
/// How scopes are computed.
|
||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||
pub struct Params {
|
||
pub matrix: Matrix,
|
||
/// Clamp Signal: values are clamped to 0..1 before they are plotted.
|
||
pub clamp: bool,
|
||
/// Waveform / parade levels.
|
||
pub rows: usize,
|
||
/// Vectorscope grid size (square; odd, so the centre is a cell).
|
||
pub vector_size: usize,
|
||
}
|
||
|
||
impl Default for Params {
|
||
fn default() -> Self {
|
||
Params { matrix: Matrix::Bt709, clamp: true, rows: 256, vector_size: 255 }
|
||
}
|
||
}
|
||
|
||
impl Params {
|
||
/// The plotted value range of waveform rows.
|
||
pub fn range(&self) -> (f32, f32) {
|
||
if self.clamp { (0.0, 1.0) } else { (-0.1, 1.1) }
|
||
}
|
||
}
|
||
|
||
// ------------------------------------------------------------------------------------ signal
|
||
|
||
/// A frame's R'G'B' samples (decimated), row-major.
|
||
#[derive(Clone, Debug, Default, PartialEq)]
|
||
pub struct Signal {
|
||
pub w: usize,
|
||
pub h: usize,
|
||
pub rgb: Vec<[f32; 3]>,
|
||
}
|
||
|
||
fn steps(w: usize, h: usize, max_w: usize, max_h: usize) -> (usize, usize) {
|
||
(w.div_ceil(max_w.max(1)).max(1), h.div_ceil(max_h.max(1)).max(1))
|
||
}
|
||
|
||
impl Signal {
|
||
/// From straight RGBA8 (code / 255), decimated to [`MAX_W`] × [`MAX_H`].
|
||
pub fn from_rgba8(w: usize, h: usize, px: &[u8]) -> Signal {
|
||
Self::from_rgba8_max(w, h, px, MAX_W, MAX_H)
|
||
}
|
||
|
||
pub fn from_rgba8_max(w: usize, h: usize, px: &[u8], max_w: usize, max_h: usize) -> Signal {
|
||
if w == 0 || h == 0 || px.len() < w * h * 4 {
|
||
return Signal::default();
|
||
}
|
||
let lut: [f32; 256] = std::array::from_fn(|i| i as f32 / 255.0);
|
||
let (sx, sy) = steps(w, h, max_w, max_h);
|
||
let (ow, oh) = (w.div_ceil(sx), h.div_ceil(sy));
|
||
let mut rgb = Vec::with_capacity(ow * oh);
|
||
for y in (0..h).step_by(sy) {
|
||
let row = &px[y * w * 4..(y + 1) * w * 4];
|
||
for x in (0..w).step_by(sx) {
|
||
let p = &row[x * 4..x * 4 + 3];
|
||
rgb.push([lut[p[0] as usize], lut[p[1] as usize], lut[p[2] as usize]]);
|
||
}
|
||
}
|
||
Signal { w: ow, h: oh, rgb }
|
||
}
|
||
|
||
/// From RGBA f32 pixels through `map` (e.g. linear light → PQ code values), decimated.
|
||
pub fn from_rgba_f32_with(w: usize, h: usize, px: &[f32], max_w: usize, max_h: usize, map: impl Fn([f32; 4]) -> [f32; 3]) -> Signal {
|
||
if w == 0 || h == 0 || px.len() < w * h * 4 {
|
||
return Signal::default();
|
||
}
|
||
let (sx, sy) = steps(w, h, max_w, max_h);
|
||
let (ow, oh) = (w.div_ceil(sx), h.div_ceil(sy));
|
||
let mut rgb = Vec::with_capacity(ow * oh);
|
||
for y in (0..h).step_by(sy) {
|
||
for x in (0..w).step_by(sx) {
|
||
let i = (y * w + x) * 4;
|
||
rgb.push(map([px[i], px[i + 1], px[i + 2], px[i + 3]]));
|
||
}
|
||
}
|
||
Signal { w: ow, h: oh, rgb }
|
||
}
|
||
|
||
/// A synthetic signal (tests, generated patterns).
|
||
pub fn from_fn(w: usize, h: usize, f: impl Fn(usize, usize) -> [f32; 3]) -> Signal {
|
||
let mut rgb = Vec::with_capacity(w * h);
|
||
for y in 0..h {
|
||
for x in 0..w {
|
||
rgb.push(f(x, y));
|
||
}
|
||
}
|
||
Signal { w, h, rgb }
|
||
}
|
||
|
||
/// Every sample through `f` (e.g. SDR code values → PQ for the HDR scale).
|
||
pub fn map(&self, f: impl Fn([f32; 3]) -> [f32; 3]) -> Signal {
|
||
Signal { w: self.w, h: self.h, rgb: self.rgb.iter().map(|c| f(*c)).collect() }
|
||
}
|
||
|
||
pub fn len(&self) -> usize {
|
||
self.rgb.len()
|
||
}
|
||
pub fn is_empty(&self) -> bool {
|
||
self.rgb.is_empty()
|
||
}
|
||
}
|
||
|
||
/// Linear light (1.0 = reference white = 203 cd/m², premultiplied RGBA) → PQ code values, for
|
||
/// HDR scopes: 0..1 on the axis is 0..10 000 cd/m².
|
||
pub fn linear_to_pq([r, g, b, a]: [f32; 4]) -> [f32; 3] {
|
||
let a = if a > 1e-6 { a } else { 1.0 };
|
||
let f = |v: f32| filmcraft_color::pq_inverse_eotf(((v / a).max(0.0) * filmcraft_color::REFERENCE_WHITE_NITS as f32 / 10_000.0).clamp(0.0, 1.0));
|
||
[f(r), f(g), f(b)]
|
||
}
|
||
|
||
/// An SDR code value (BT.1886, 100 cd/m² white) on the PQ axis (the HDR scale of an SDR frame).
|
||
pub fn sdr_to_pq(v: f32) -> f32 {
|
||
filmcraft_color::pq_inverse_eotf((v.clamp(0.0, 1.0).powf(2.4) * 100.0 / 10_000.0).clamp(0.0, 1.0))
|
||
}
|
||
|
||
/// cd/m² → height on the PQ axis (0..1).
|
||
pub fn nits_to_pq(nits: f32) -> f32 {
|
||
filmcraft_color::pq_inverse_eotf((nits / 10_000.0).clamp(0.0, 1.0))
|
||
}
|
||
|
||
// ------------------------------------------------------------------------------------ grids
|
||
|
||
/// A count grid: `data[row * cols + col]`, row 0 = the lowest level.
|
||
#[derive(Clone, Debug, PartialEq, Serialize)]
|
||
pub struct Grid {
|
||
pub name: &'static str,
|
||
pub cols: usize,
|
||
pub rows: usize,
|
||
pub data: Vec<u32>,
|
||
}
|
||
|
||
impl Grid {
|
||
pub fn new(name: &'static str, cols: usize, rows: usize) -> Grid {
|
||
Grid { name, cols, rows, data: vec![0; cols * rows] }
|
||
}
|
||
pub fn at(&self, col: usize, row: usize) -> u32 {
|
||
self.data[row * self.cols + col]
|
||
}
|
||
pub fn total(&self) -> u64 {
|
||
self.data.iter().map(|&c| c as u64).sum()
|
||
}
|
||
pub fn max(&self) -> u32 {
|
||
self.data.iter().copied().max().unwrap_or(0)
|
||
}
|
||
/// The rows hit in a column, lowest first.
|
||
pub fn rows_in(&self, col: usize) -> Vec<usize> {
|
||
(0..self.rows).filter(|&r| self.at(col, r) > 0).collect()
|
||
}
|
||
}
|
||
|
||
/// Waveform or parade: one grid per trace, columns = the signal's width.
|
||
#[derive(Clone, Debug, PartialEq, Serialize)]
|
||
pub struct Waveform {
|
||
pub lo: f32,
|
||
pub hi: f32,
|
||
/// Samples per column (the signal's height).
|
||
pub per_column: usize,
|
||
pub traces: Vec<Grid>,
|
||
}
|
||
|
||
impl Waveform {
|
||
pub fn trace(&self, name: &str) -> Option<&Grid> {
|
||
self.traces.iter().find(|t| t.name == name)
|
||
}
|
||
/// The value at the centre of a row.
|
||
pub fn level(&self, row: usize, rows: usize) -> f32 {
|
||
self.lo + (self.hi - self.lo) * row as f32 / (rows.max(2) - 1) as f32
|
||
}
|
||
}
|
||
|
||
/// Row of value `v` in `[lo, hi]` over `rows` levels (None outside, or NaN).
|
||
#[inline]
|
||
pub fn row_of(v: f32, lo: f32, hi: f32, rows: usize) -> Option<usize> {
|
||
let t = (v - lo) / (hi - lo);
|
||
if !(0.0..=1.0).contains(&t) {
|
||
return None;
|
||
}
|
||
Some(((t * (rows - 1) as f32).round() as usize).min(rows - 1))
|
||
}
|
||
|
||
/// Up to 4 (trace, value) pairs per sample.
|
||
type Hits = ([(u8, f32); 4], usize);
|
||
|
||
fn build(s: &Signal, p: &Params, names: &[&'static str], sample: impl Fn([f32; 3]) -> Hits) -> Waveform {
|
||
let (lo, hi) = p.range();
|
||
let rows = p.rows.max(2);
|
||
let mut traces: Vec<Grid> = names.iter().map(|n| Grid::new(n, s.w, rows)).collect();
|
||
for y in 0..s.h {
|
||
for x in 0..s.w {
|
||
let mut c = s.rgb[y * s.w + x];
|
||
if p.clamp {
|
||
c = c.map(|v| v.clamp(0.0, 1.0));
|
||
}
|
||
let (hits, n) = sample(c);
|
||
for &(t, v) in &hits[..n] {
|
||
let v = if p.clamp { v.clamp(0.0, 1.0) } else { v };
|
||
if let Some(r) = row_of(v, lo, hi, rows) {
|
||
let g = &mut traces[t as usize];
|
||
g.data[r * g.cols + x] += 1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
Waveform { lo, hi, per_column: s.h, traces }
|
||
}
|
||
|
||
/// The waveform of a signal.
|
||
pub fn waveform(s: &Signal, kind: WaveformType, p: &Params) -> Waveform {
|
||
let m = p.matrix;
|
||
let z = (0u8, 0.0f32);
|
||
match kind {
|
||
WaveformType::Rgb => build(s, p, &["R", "G", "B"], |[r, g, b]| ([(0, r), (1, g), (2, b), z], 3)),
|
||
WaveformType::Luma => build(s, p, &["Y"], |[r, g, b]| ([(0, rgb_to_ycbcr(r, g, b, m)[0]), z, z, z], 1)),
|
||
WaveformType::YcNoChroma => build(s, p, &["Y"], |[r, g, b]| ([(0, rgb_to_ycbcr(r, g, b, m)[0]), z, z, z], 1)),
|
||
WaveformType::Yc => build(s, p, &["Y", "C"], |[r, g, b]| {
|
||
let [y, cb, cr] = rgb_to_ycbcr(r, g, b, m);
|
||
let c = (cb * cb + cr * cr).sqrt();
|
||
([(0, y), (1, y + c), (1, y - c), z], if c > 1e-6 { 3 } else { 2 })
|
||
}),
|
||
}
|
||
}
|
||
|
||
/// The parade of a signal (the traces are drawn side by side).
|
||
pub fn parade(s: &Signal, kind: ParadeType, p: &Params) -> Waveform {
|
||
let m = p.matrix;
|
||
let z = (0u8, 0.0f32);
|
||
match kind {
|
||
ParadeType::Rgb => build(s, p, &["R", "G", "B"], |[r, g, b]| ([(0, r), (1, g), (2, b), z], 3)),
|
||
ParadeType::RgbWhite => build(s, p, &["R", "G", "B", "Y"], |[r, g, b]| ([(0, r), (1, g), (2, b), (3, rgb_to_ycbcr(r, g, b, m)[0])], 4)),
|
||
ParadeType::Yuv => build(s, p, &["Y", "Cb", "Cr"], |[r, g, b]| {
|
||
let [y, cb, cr] = rgb_to_ycbcr(r, g, b, m);
|
||
([(0, y), (1, cb + 0.5), (2, cr + 0.5), z], 3)
|
||
}),
|
||
}
|
||
}
|
||
|
||
// ------------------------------------------------------------------------------------ histogram
|
||
|
||
/// 256-bin histograms of R', G', B' and Y'.
|
||
#[derive(Clone, Debug, PartialEq, Serialize)]
|
||
pub struct Histogram {
|
||
pub r: Vec<u32>,
|
||
pub g: Vec<u32>,
|
||
pub b: Vec<u32>,
|
||
pub y: Vec<u32>,
|
||
pub samples: u32,
|
||
/// Samples below 0 / above 1 per channel (R, G, B, Y); with Clamp Signal they are also
|
||
/// counted in the first / last bin.
|
||
pub below: [u32; 4],
|
||
pub above: [u32; 4],
|
||
}
|
||
|
||
pub const BINS: usize = 256;
|
||
|
||
/// Bin of a value (None when outside 0..1).
|
||
#[inline]
|
||
pub fn bin_of(v: f32) -> Option<usize> {
|
||
if (0.0..=1.0 + 1e-6).contains(&v) { Some(((v * 255.0).round() as usize).min(BINS - 1)) } else { None }
|
||
}
|
||
|
||
pub fn histogram(s: &Signal, p: &Params) -> Histogram {
|
||
let mut h = Histogram { r: vec![0; BINS], g: vec![0; BINS], b: vec![0; BINS], y: vec![0; BINS], samples: s.len() as u32, below: [0; 4], above: [0; 4] };
|
||
for &[r, g, b] in &s.rgb {
|
||
let y = rgb_to_ycbcr(r, g, b, p.matrix)[0];
|
||
for (i, v) in [r, g, b, y].into_iter().enumerate() {
|
||
let bins = match i {
|
||
0 => &mut h.r,
|
||
1 => &mut h.g,
|
||
2 => &mut h.b,
|
||
_ => &mut h.y,
|
||
};
|
||
match bin_of(v) {
|
||
Some(k) => bins[k] += 1,
|
||
None if v.is_nan() => {}
|
||
None => {
|
||
let low = v < 0.0;
|
||
if low {
|
||
h.below[i] += 1;
|
||
} else {
|
||
h.above[i] += 1;
|
||
}
|
||
if p.clamp {
|
||
bins[if low { 0 } else { BINS - 1 }] += 1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
h
|
||
}
|
||
|
||
// ------------------------------------------------------------------------------------ vectorscopes
|
||
|
||
/// A vectorscope: `data[y * size + x]`, x = Cb (right = +), y = Cr (row 0 = top = +Cr).
|
||
#[derive(Clone, Debug, PartialEq, Serialize)]
|
||
pub struct Vectorscope {
|
||
pub size: usize,
|
||
pub extent: f32,
|
||
pub data: Vec<u32>,
|
||
pub samples: u32,
|
||
/// Mean (Cb, Cr) of the plotted points.
|
||
pub mean: [f32; 2],
|
||
}
|
||
|
||
/// Cell of a (Cb, Cr) point on a `size`² plane spanning ±`extent`.
|
||
#[inline]
|
||
pub fn cell_of(cb: f32, cr: f32, size: usize, extent: f32) -> Option<(usize, usize)> {
|
||
let n = (size - 1) as f32;
|
||
let fx = (cb / extent * 0.5 + 0.5) * n;
|
||
let fy = (0.5 - cr / extent * 0.5) * n;
|
||
if !(0.0..=n).contains(&fx) || !(0.0..=n).contains(&fy) {
|
||
return None;
|
||
}
|
||
Some((fx.round() as usize, fy.round() as usize))
|
||
}
|
||
|
||
impl Vectorscope {
|
||
fn new(size: usize) -> Self {
|
||
Vectorscope { size, extent: VECTOR_EXTENT, data: vec![0; size * size], samples: 0, mean: [0.0; 2] }
|
||
}
|
||
pub fn at(&self, x: usize, y: usize) -> u32 {
|
||
self.data[y * self.size + x]
|
||
}
|
||
pub fn cell(&self, cb: f32, cr: f32) -> Option<(usize, usize)> {
|
||
cell_of(cb, cr, self.size, self.extent)
|
||
}
|
||
/// (Cb, Cr) at the centre of a cell.
|
||
pub fn point(&self, x: usize, y: usize) -> [f32; 2] {
|
||
let n = (self.size - 1) as f32;
|
||
[(x as f32 / n - 0.5) * 2.0 * self.extent, (0.5 - y as f32 / n) * 2.0 * self.extent]
|
||
}
|
||
fn plot(&mut self, cb: f32, cr: f32, sum: &mut [f64; 2]) {
|
||
if let Some((x, y)) = self.cell(cb, cr) {
|
||
self.data[y * self.size + x] += 1;
|
||
self.samples += 1;
|
||
sum[0] += cb as f64;
|
||
sum[1] += cr as f64;
|
||
}
|
||
}
|
||
fn finish(mut self, sum: [f64; 2]) -> Self {
|
||
if self.samples > 0 {
|
||
self.mean = [(sum[0] / self.samples as f64) as f32, (sum[1] / self.samples as f64) as f32];
|
||
}
|
||
self
|
||
}
|
||
}
|
||
|
||
/// The YUV vectorscope (Cb, Cr of each sample).
|
||
pub fn vectorscope_yuv(s: &Signal, p: &Params) -> Vectorscope {
|
||
let mut v = Vectorscope::new(p.vector_size.max(2));
|
||
let mut sum = [0f64; 2];
|
||
for &c in &s.rgb {
|
||
let [r, g, b] = if p.clamp { c.map(|x| x.clamp(0.0, 1.0)) } else { c };
|
||
let [_, cb, cr] = rgb_to_ycbcr(r, g, b, p.matrix);
|
||
v.plot(cb, cr, &mut sum);
|
||
}
|
||
v.finish(sum)
|
||
}
|
||
|
||
/// Angle (degrees, counter-clockwise from +Cb, 0..360) of a chroma point.
|
||
pub fn angle_deg(cb: f32, cr: f32) -> f32 {
|
||
cr.atan2(cb).to_degrees().rem_euclid(360.0)
|
||
}
|
||
|
||
/// The angle of pure red on a matrix's vectorscope (BT.709 ≈ 103°): the HLS scope puts hue 0 there.
|
||
pub fn red_angle(m: Matrix) -> f32 {
|
||
let [_, cb, cr] = rgb_to_ycbcr(1.0, 0.0, 0.0, m);
|
||
angle_deg(cb, cr)
|
||
}
|
||
|
||
/// A sample's point on the HLS vectorscope: hue as the angle from red (counter-clockwise, red →
|
||
/// yellow → green → cyan → blue → magenta), HLS saturation as the radius (1 = 0.5).
|
||
pub fn hls_point(rgb: [f32; 3], m: Matrix) -> [f32; 2] {
|
||
hls_at(rgb, red_angle(m))
|
||
}
|
||
|
||
#[inline]
|
||
fn hls_at([r, g, b]: [f32; 3], red: f32) -> [f32; 2] {
|
||
let [h, s, _] = filmcraft_color::rgb_to_hsl(r, g, b);
|
||
let a = (red + h * 360.0).to_radians();
|
||
let rad = s.clamp(0.0, 1.0) * 0.5;
|
||
[rad * a.cos(), rad * a.sin()]
|
||
}
|
||
|
||
/// The HLS vectorscope.
|
||
pub fn vectorscope_hls(s: &Signal, p: &Params) -> Vectorscope {
|
||
let mut v = Vectorscope::new(p.vector_size.max(2));
|
||
let mut sum = [0f64; 2];
|
||
// hue → unit direction, tabulated at 0.1° (trigonometry per sample is the slow part)
|
||
let red = red_angle(p.matrix);
|
||
let dirs: Vec<[f32; 2]> = (0..=3600).map(|i| (red + i as f32 / 10.0).to_radians()).map(|a| [a.cos(), a.sin()]).collect();
|
||
for &c in &s.rgb {
|
||
let [r, g, b] = c.map(|x| x.clamp(0.0, 1.0));
|
||
let [h, sat, _] = filmcraft_color::rgb_to_hsl(r, g, b);
|
||
let [dx, dy] = dirs[((h * 3600.0).round() as usize).min(3600)];
|
||
let rad = sat.clamp(0.0, 1.0) * 0.5;
|
||
v.plot(rad * dx, rad * dy, &mut sum);
|
||
}
|
||
v.finish(sum)
|
||
}
|
||
|
||
/// A colour-bar target of the YUV vectorscope.
|
||
#[derive(Clone, Copy, Debug, PartialEq, Serialize)]
|
||
pub struct Target {
|
||
pub name: &'static str,
|
||
pub rgb: [f32; 3],
|
||
pub cb: f32,
|
||
pub cr: f32,
|
||
}
|
||
|
||
/// The six colour-bar targets (R, Mg, B, Cy, G, Yl) at `amplitude` (0.75 or 1.0).
|
||
pub fn targets(m: Matrix, amplitude: f32) -> [Target; 6] {
|
||
let a = amplitude;
|
||
let t = |name, rgb: [f32; 3]| {
|
||
let [_, cb, cr] = rgb_to_ycbcr(rgb[0], rgb[1], rgb[2], m);
|
||
Target { name, rgb, cb, cr }
|
||
};
|
||
[t("R", [a, 0.0, 0.0]), t("Mg", [a, 0.0, a]), t("B", [0.0, 0.0, a]), t("Cy", [0.0, a, a]), t("G", [0.0, a, 0.0]), t("Yl", [a, a, 0.0])]
|
||
}
|
||
|
||
/// Hue labels of the HLS vectorscope at radius 0.5: (name, Cb, Cr).
|
||
pub fn hls_targets(m: Matrix) -> [(&'static str, f32, f32); 6] {
|
||
let red = red_angle(m);
|
||
let at = |name, h: f32| {
|
||
let a = (red + h).to_radians();
|
||
(name, 0.5 * a.cos(), 0.5 * a.sin())
|
||
};
|
||
[at("R", 0.0), at("Yl", 60.0), at("G", 120.0), at("Cy", 180.0), at("B", 240.0), at("Mg", 300.0)]
|
||
}
|
||
|
||
// ------------------------------------------------------------------------------------ all scopes
|
||
|
||
/// Every scope the panel can show, computed for a set of settings.
|
||
#[derive(Clone, Debug, PartialEq)]
|
||
pub enum Computed {
|
||
Waveform(Waveform),
|
||
Parade(Waveform),
|
||
Histogram(Histogram),
|
||
Vectorscope(Vectorscope),
|
||
}
|
||
|
||
/// Compute one scope.
|
||
pub fn compute(kind: ScopeKind, s: &Signal, p: &Params, waveform_type: WaveformType, parade_type: ParadeType) -> Computed {
|
||
match kind {
|
||
ScopeKind::Waveform => Computed::Waveform(waveform(s, waveform_type, p)),
|
||
ScopeKind::Parade => Computed::Parade(parade(s, parade_type, p)),
|
||
ScopeKind::Histogram => Computed::Histogram(histogram(s, p)),
|
||
ScopeKind::VectorscopeYuv => Computed::Vectorscope(vectorscope_yuv(s, p)),
|
||
ScopeKind::VectorscopeHls => Computed::Vectorscope(vectorscope_hls(s, p)),
|
||
}
|
||
}
|