charts.color

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one

fn nibble(ch: u8, hex: &str) -> i64 {
    match ch {
        b'0'..=b'9' => i64::from(ch - b'0'),
        b'a'..=b'f' => i64::from(ch - b'a') + 10,
        b'A'..=b'F' => i64::from(ch - b'A') + 10,
        _ => panic!("\"{}\" is not a hex colour (#rgb or #rrggbb)", hex),
    }
}

/// "#rrggbb" or the short "#rgb" (digits doubled, as CSS does), either case.
///
/// # Panics
/// Panics on anything else.
pub fn parse_hex(hex: &str) -> Rgb {
    let bytes = hex.as_bytes();
    if bytes.first() != Some(&b'#') || (bytes.len() != 4 && bytes.len() != 7) {
        panic!("\"{}\" is not a hex colour (#rgb or #rrggbb)", hex);
    }
    if bytes.len() == 4 {
        return Rgb {
            r: nibble(bytes[1], hex) * 17,
            g: nibble(bytes[2], hex) * 17,
            b: nibble(bytes[3], hex) * 17,
        };
    }
    Rgb {
        r: nibble(bytes[1], hex) * 16 + nibble(bytes[2], hex),
        g: nibble(bytes[3], hex) * 16 + nibble(bytes[4], hex),
        b: nibble(bytes[5], hex) * 16 + nibble(bytes[6], hex),
    }
}

pub fn rgb_to_value(rgb: &Rgb) -> Value {
    Value::obj(vec![("r", Value::Int(rgb.r)), ("g", Value::Int(rgb.g)), ("b", Value::Int(rgb.b))])
}

pub fn fune_vector(args: &[Value]) -> Value {
    rgb_to_value(&parse_hex(args[0].as_str()))
}

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one

const HEX: &[u8; 16] = b"0123456789abcdef";

fn pair(value: i64) -> String {
    if !(0..=255).contains(&value) {
        panic!("rgb channels must be whole numbers from 0 to 255, received {}", value);
    }
    let mut s = String::new();
    s.push(HEX[(value / 16) as usize] as char);
    s.push(HEX[(value % 16) as usize] as char);
    s
}

/// Lowercase "#rrggbb", the form every renderer accepts.
///
/// # Panics
/// Panics if a channel is outside 0..=255.
pub fn to_hex(rgb: &Rgb) -> String {
    format!("#{}{}{}", pair(rgb.r), pair(rgb.g), pair(rgb.b))
}

pub fn rgb_from_value(v: &Value) -> Rgb {
    Rgb { r: v.get("r").as_i64(), g: v.get("g").as_i64(), b: v.get("b").as_i64() }
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::str(&to_hex(&rgb_from_value(&args[0])))
}

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one
use super::math_pow::pow;  ← from math.pow ^1.0.0 · built alongside by fune
use super::math_round_float::round_float;  ← from math.round-float ^1.0.0 · built alongside by fune

/// The sRGB transfer function (IEC 61966-2-1) undone: an 8-bit channel as
/// linear light from 0 to 1, rounded to 12 places.
///
/// # Panics
/// Panics if the channel is outside 0..=255.
pub fn srgb_to_linear(channel: i64) -> f64 {
    if !(0..=255).contains(&channel) {
        panic!("channel must be a whole number from 0 to 255, received {}", channel);
    }
    let c = channel as f64 / 255.0;
    let linear = if c <= 0.04045 { c / 12.92 } else { pow((c + 0.055) / 1.055, 2.4) };
    round_float(linear, 12)
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::Float(srgb_to_linear(args[0].as_i64()))
}

Imports name this capability’s declared dependencies, which fune builds next to it in your project; each one links to its page.

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one
use super::math_pow::pow;  ← from math.pow ^1.0.0 · built alongside by fune
use super::math_round_float::round_float;  ← from math.round-float ^1.0.0 · built alongside by fune

/// Linear light back to an 8-bit sRGB channel, clipping to 0..1 first.
///
/// # Panics
/// Panics if `value` is not finite.
pub fn linear_to_srgb(value: f64) -> i64 {
    if !value.is_finite() {
        panic!("value must be a finite number, received {}", value);
    }
    let v = if value < 0.0 { 0.0 } else if value > 1.0 { 1.0 } else { value };
    let encoded = if v <= 0.0031308 { 12.92 * v } else { 1.055 * pow(v, 1.0 / 2.4) - 0.055 };
    round_float(encoded * 255.0, 0) as i64
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::Int(linear_to_srgb(args[0].as_f64()))
}