charts.axis

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_round_float::round_float;  ← from math.round-float ^1.0.0 · built alongside by fune

// d3-axis's default gap between the end of a tick mark and its label.
const LABEL_PADDING: f64 = 3.0;

/// A pixel coordinate rounded to 2 places, the precision every axis output uses.
pub fn axis_pixel(value: f64) -> f64 {
    round_float(value, 2)
}

pub fn axis_line(x1: f64, y1: f64, x2: f64, y2: f64) -> Line {
    Line { x1: axis_pixel(x1), y1: axis_pixel(y1), x2: axis_pixel(x2), y2: axis_pixel(y2) }
}

pub fn check_orient(orient: &str) {
    if !matches!(orient, "bottom" | "top" | "left" | "right") {
        panic!("orient must be bottom, top, left or right, received \"{}\"", orient);
    }
}

/// Axis geometry from tick positions and labels, for any scale (d3-axis layout).
///
/// # Panics
/// Panics on an unknown orient, positions and labels of different lengths, or
/// a range without exactly two values.
pub fn axis_from_ticks(positions: &[f64], labels: &[String], range: &[f64], orient: &str, position: f64, tick_size: f64) -> Axis {
    check_orient(orient);
    if positions.len() != labels.len() {
        panic!(
            "positions and labels must be the same length, received {} and {}",
            positions.len(),
            labels.len()
        );
    }
    if range.len() != 2 {
        panic!("range must have exactly 2 values, [from, to]; got {}", range.len());
    }
    let horizontal = orient == "bottom" || orient == "top";
    let sign = if orient == "bottom" || orient == "right" { 1.0 } else { -1.0 };
    let mark_end = position + sign * tick_size;
    let label_at = position + sign * (tick_size + LABEL_PADDING);
    let ticks = positions
        .iter()
        .zip(labels)
        .map(|(&p, label)| {
            if horizontal {
                AxisTick {
                    position: axis_pixel(p),
                    label: label.clone(),
                    tick: axis_line(p, position, p, mark_end),
                    label_x: axis_pixel(p),
                    label_y: axis_pixel(label_at),
                    anchor: "middle".to_string(),
                    baseline: if orient == "bottom" { "hanging" } else { "alphabetic" }.to_string(),
                }
            } else {
                AxisTick {
                    position: axis_pixel(p),
                    label: label.clone(),
                    tick: axis_line(position, p, mark_end, p),
                    label_x: axis_pixel(label_at),
                    label_y: axis_pixel(p),
                    anchor: if orient == "left" { "end" } else { "start" }.to_string(),
                    baseline: "middle".to_string(),
                }
            }
        })
        .collect();
    let line = if horizontal {
        axis_line(range[0], position, range[1], position)
    } else {
        axis_line(position, range[0], position, range[1])
    };
    Axis { orient: orient.to_string(), position: axis_pixel(position), line, ticks }
}

pub fn line_to_value(l: &Line) -> Value {
    Value::obj(vec![
        ("x1", Value::Float(l.x1)),
        ("y1", Value::Float(l.y1)),
        ("x2", Value::Float(l.x2)),
        ("y2", Value::Float(l.y2)),
    ])
}

pub fn line_from_value(v: &Value) -> Line {
    Line { x1: v.get("x1").as_f64(), y1: v.get("y1").as_f64(), x2: v.get("x2").as_f64(), y2: v.get("y2").as_f64() }
}

pub fn axis_to_value(a: &Axis) -> Value {
    Value::obj(vec![
        ("orient", Value::str(&a.orient)),
        ("position", Value::Float(a.position)),
        ("line", line_to_value(&a.line)),
        (
            "ticks",
            Value::Arr(
                a.ticks
                    .iter()
                    .map(|t| {
                        Value::obj(vec![
                            ("position", Value::Float(t.position)),
                            ("label", Value::str(&t.label)),
                            ("tick", line_to_value(&t.tick)),
                            ("labelX", Value::Float(t.label_x)),
                            ("labelY", Value::Float(t.label_y)),
                            ("anchor", Value::str(&t.anchor)),
                            ("baseline", Value::str(&t.baseline)),
                        ])
                    })
                    .collect(),
            ),
        ),
    ])
}

pub fn axis_from_value(v: &Value) -> Axis {
    Axis {
        orient: v.get("orient").as_str().to_string(),
        position: v.get("position").as_f64(),
        line: line_from_value(v.get("line")),
        ticks: v
            .get("ticks")
            .as_arr()
            .iter()
            .map(|t| AxisTick {
                position: t.get("position").as_f64(),
                label: t.get("label").as_str().to_string(),
                tick: line_from_value(t.get("tick")),
                label_x: t.get("labelX").as_f64(),
                label_y: t.get("labelY").as_f64(),
                anchor: t.get("anchor").as_str().to_string(),
                baseline: t.get("baseline").as_str().to_string(),
            })
            .collect(),
    }
}

/// A JSON list of numbers or strings, for the vector adapters.
pub fn axis_floats(v: &Value) -> Vec<f64> {
    v.as_arr().iter().map(|x| x.as_f64()).collect()
}

pub fn axis_strings(v: &Value) -> Vec<String> {
    v.as_arr().iter().map(|x| x.as_str().to_string()).collect()
}

pub fn fune_vector(args: &[Value]) -> Value {
    axis_to_value(&axis_from_ticks(
        &axis_floats(&args[0]),
        &axis_strings(&args[1]),
        &axis_floats(&args[2]),
        args[3].as_str(),
        args[4].as_f64(),
        args[5].as_f64(),
    ))
}

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::charts_axis_axis_from_ticks::{axis_floats, axis_from_ticks, axis_to_value};  ← axisFromTicks, another function of this group · built into the same file, even by a slim install
use super::charts_format_format_tick::format_tick;
use super::charts_scale_linear_scale::linear_scale;
use super::charts_ticks_nice_ticks::nice_ticks;
use super::charts_ticks_tick_step::tick_step;

/// A linear number axis: nice ticks, placed by linear_scale, labelled for the step.
///
/// # Panics
/// Panics on a domain without two different ends, a count below 1, or an
/// unknown orient.
pub fn number_axis(domain: &[f64], range: &[f64], count: i64, orient: &str, position: f64, tick_size: f64) -> Axis {
    if domain.len() != 2 {
        panic!("domain must have exactly 2 values, [from, to]; got {}", domain.len());
    }
    let lo = domain[0].min(domain[1]);
    let hi = domain[0].max(domain[1]);
    let values = nice_ticks(domain[0], domain[1], count);
    let step = tick_step(lo, hi, count);
    let positions: Vec<f64> = values.iter().map(|v| linear_scale(domain, range, *v, false)).collect();
    let labels: Vec<String> = values.iter().map(|v| format_tick(*v, step)).collect();
    axis_from_ticks(&positions, &labels, range, orient, position, tick_size)
}

pub fn fune_vector(args: &[Value]) -> Value {
    axis_to_value(&number_axis(
        &axis_floats(&args[0]),
        &axis_floats(&args[1]),
        args[2].as_i64(),
        args[3].as_str(),
        args[4].as_f64(),
        args[5].as_f64(),
    ))
}

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::charts_axis_axis_from_ticks::{axis_floats, axis_from_ticks, axis_strings, axis_to_value};  ← axisFromTicks, another function of this group · built into the same file, even by a slim install
use super::charts_format_format_date::format_date;
use super::charts_scale_time_scale::time_scale;
use super::charts_ticks_time_tick_interval::time_tick_interval;
use super::charts_ticks_time_ticks::time_ticks;

/// A date axis: a calendar interval for about `count` ticks, labelled for that interval.
///
/// # Panics
/// Panics on a domain without two different dates, a count below 1, or an
/// unknown orient.
pub fn time_axis(domain: &[String], range: &[f64], count: i64, orient: &str, position: f64, tick_size: f64) -> Axis {
    if domain.len() != 2 {
        panic!("domain must have exactly 2 values, [from, to]; got {}", domain.len());
    }
    let (lo, hi) = if domain[0] < domain[1] { (&domain[0], &domain[1]) } else { (&domain[1], &domain[0]) };
    let chosen = time_tick_interval(lo, hi, count);
    let values = time_ticks(lo, hi, &chosen.interval, chosen.step);
    let positions: Vec<f64> = values.iter().map(|v| time_scale(domain, range, v, false)).collect();
    let labels: Vec<String> = values.iter().map(|v| format_date(v, &chosen.interval)).collect();
    axis_from_ticks(&positions, &labels, range, orient, position, tick_size)
}

pub fn fune_vector(args: &[Value]) -> Value {
    axis_to_value(&time_axis(
        &axis_strings(&args[0]),
        &axis_floats(&args[1]),
        args[2].as_i64(),
        args[3].as_str(),
        args[4].as_f64(),
        args[5].as_f64(),
    ))
}

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::charts_axis_axis_from_ticks::{axis_floats, axis_from_ticks, axis_strings, axis_to_value};  ← axisFromTicks, another function of this group · built into the same file, even by a slim install
use super::charts_scale_band_scale::band_scale;

/// A category axis: one tick at the centre of each band, labelled with the category.
///
/// # Panics
/// Panics on an empty or duplicated domain, padding outside 0..=1, or an
/// unknown orient.
pub fn band_axis(
    domain: &[String],
    range: &[f64],
    padding_inner: f64,
    padding_outer: f64,
    orient: &str,
    position: f64,
    tick_size: f64,
) -> Axis {
    let positions: Vec<f64> = domain
        .iter()
        .map(|v| band_scale(domain, range, v, padding_inner, padding_outer, 0.5).center)
        .collect();
    axis_from_ticks(&positions, domain, range, orient, position, tick_size)
}

pub fn fune_vector(args: &[Value]) -> Value {
    axis_to_value(&band_axis(
        &axis_strings(&args[0]),
        &axis_floats(&args[1]),
        args[2].as_f64(),
        args[3].as_f64(),
        args[4].as_str(),
        args[5].as_f64(),
        args[6].as_f64(),
    ))
}

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::charts_axis_axis_from_ticks::{axis_from_value, axis_line, check_orient, line_to_value};  ← axisFromTicks, another function of this group · built into the same file, even by a slim install

/// One gridline per tick, from the axis line across the plot: up from a bottom
/// axis, down from a top one, right from a left axis and left from a right one.
///
/// # Panics
/// Panics on an unknown orient or a negative or non-finite length.
pub fn grid_lines(axis: &Axis, length: f64) -> Vec<Line> {
    check_orient(&axis.orient);
    if !length.is_finite() || length < 0.0 {
        panic!("length must be a finite number of zero or more, received {}", length);
    }
    let pos = axis.position;
    axis.ticks
        .iter()
        .map(|t| {
            let p = t.position;
            match axis.orient.as_str() {
                "bottom" => axis_line(p, pos, p, pos - length),
                "top" => axis_line(p, pos, p, pos + length),
                "left" => axis_line(pos, p, pos + length, p),
                _ => axis_line(pos, p, pos - length, p),
            }
        })
        .collect()
}

pub fn fune_vector(args: &[Value]) -> Value {
    Value::Arr(grid_lines(&axis_from_value(&args[0]), args[1].as_f64()).iter().map(line_to_value).collect())
}