use std::{hash::Hash, sync::Arc};
use super::{
chart::{
ChartArea, ChartFrame, ChartLabel, ChartLook, ChartMotion, ChartPart, ChartPlot, ChartPoint, ChartProps,
ChartRenderer, ChartSeries, ChartSize, ChartTip, bits, chart_recipe, resolve, signature_of,
},
names,
part_style::{FontFamily, Length},
recipe::{Recipe, ResolvedRecipe},
theme::{Themed, current_theme},
};
use crate::{
app::{
ctx::Ctx,
theme::{PaletteColor, Theme},
},
canvas::{CanvasItem, Context2D},
components::Row,
layout::{Alignment, layout_kind::Justify},
node::{Element, color::Color},
};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum HeatmapPart {
Cell,
Fill,
Missing,
Ring,
Scale,
Step,
ScaleLabel,
}
names!(HeatmapPart {
Cell => "cell",
Fill => "fill",
Missing => "missing",
Ring => "ring",
Scale => "scale",
Step => "step",
ScaleLabel => "scale_label",
});
const GAP: f32 = 4.0;
const RADIUS: f32 = 3.0;
const CELL: f32 = 14.0;
const COLUMN_ROOM: f32 = 18.0;
const NAME_ADVANCE: f32 = 6.0;
const NAME_GAP: f32 = 8.0;
#[derive(Clone)]
pub struct Heatmap {
columns: Arc<[Arc<str>]>,
rows: Vec<ChartSeries>,
steps: usize,
range: Option<(f64, f64)>,
cell_size: f32,
column_axis: bool,
less_text: Arc<str>,
more_text: Arc<str>,
missing_text: Arc<str>,
props: ChartProps,
}
impl Heatmap {
pub fn new<S: AsRef<str>>(columns: impl IntoIterator<Item = S>, rows: impl IntoIterator<Item = ChartSeries>) -> Self {
Self {
columns: columns.into_iter().map(|name| Arc::from(name.as_ref())).collect(),
rows: rows.into_iter().collect(),
steps: 5,
range: None,
cell_size: CELL,
column_axis: false,
less_text: super::current_locale().data.less.clone(),
more_text: super::current_locale().data.more.clone(),
missing_text: super::current_locale().data.no_value.clone(),
props: ChartProps::default(),
}
}
pub fn steps(mut self, steps: usize) -> Self {
self.steps = steps.max(2);
self
}
pub fn range(mut self, least: f64, most: f64) -> Self {
self.range = Some((least, most));
self
}
pub fn cell_size(mut self, size: f32) -> Self {
self.cell_size = size.max(1.0);
self
}
pub fn column_axis(mut self, column_axis: bool) -> Self {
self.column_axis = column_axis;
self
}
pub fn less_text(mut self, text: &str) -> Self {
self.less_text = Arc::from(text);
self
}
pub fn more_text(mut self, text: &str) -> Self {
self.more_text = Arc::from(text);
self
}
pub fn missing_text(mut self, text: &str) -> Self {
self.missing_text = Arc::from(text);
self
}
crate::chart_props!();
fn plot(&self, cell: f32) -> HeatPlot {
let values: Vec<Arc<[f64]>> = self
.rows
.iter()
.map(|row| {
(0..self.columns.len())
.map(|column| row.values().get(column).copied().unwrap_or(f64::NAN))
.collect()
})
.collect();
let finite = || {
values
.iter()
.flat_map(|row| row.iter().copied())
.filter(|value| value.is_finite())
};
let (least, most) = self.range.unwrap_or_else(|| {
(
finite().fold(0.0_f64, f64::min),
finite().fold(f64::NEG_INFINITY, f64::max),
)
});
let widest = self
.rows
.iter()
.map(|row| row.name().chars().count())
.max()
.unwrap_or(0);
HeatPlot {
columns: self.columns.clone(),
rows: self.rows.iter().map(|row| Arc::from(row.name())).collect(),
values,
steps: self.steps,
least,
most,
cell,
room: if widest > 0 {
(widest as f32 * NAME_ADVANCE).ceil() + NAME_GAP
} else {
0.0
},
column_axis: self.column_axis,
missing: self.missing_text.clone(),
fixed: self.props.height.is_some(),
}
}
fn frame(&self, theme: &Theme) -> ChartFrame {
let rows = self.rows.len() as f32;
let under = if self.column_axis { COLUMN_ROOM } else { 0.0 };
let empty = self.columns.is_empty() || self.rows.is_empty();
let case = self.props.case(ChartSize::Sm, empty);
let recipe = theme
.resolve::<Heatmap>(&case, Some(&self.props.rules))
.owned_by(self.props.id.as_ref());
let cell = match self.props.height {
Some(_) if rows > 0.0 => ((self.props.plot_height(&recipe) - under - GAP * (rows - 1.0)) / rows).max(1.0),
_ => self.cell_size,
};
let plot = self.plot(cell);
let mut props = self.props.clone();
props.height = Some(Length::from((rows * (cell + GAP) - GAP).max(cell) + under));
let scale = self.scale(&recipe, &plot);
props
.frame(recipe, Arc::new(plot), self.rows.clone(), theme.renderer::<Heatmap>())
.own_legend(scale)
}
fn scale(&self, recipe: &ResolvedRecipe, plot: &HeatPlot) -> Element {
let part = recipe.part(HeatmapPart::Scale);
let label = recipe.part(HeatmapPart::ScaleLabel);
let step = recipe.part(HeatmapPart::Step);
let colors = Colors::of(recipe);
let mut row = Row::new()
.width(crate::node::dimension::Dimension::Pct(100.0))
.justify(Justify::End)
.align_items(Alignment::Center)
.part(&part)
.describe("a11y_role", "img")
.describe(
"a11y_name",
crate::core::fill(
&super::current_locale().data.scale,
&[("less", &self.less_text), ("more", &self.more_text)],
),
)
.child({
let label = label.clone().keyed("less");
label.text(&self.less_text).part(&label).nowrap()
});
for at in 0..plot.steps {
let mut swatch = Row::new().part(&step).background(colors.step(at, plot.steps));
if let Some(id) = &self.props.id {
swatch = swatch.id(format!("{id}-scale-{at}"));
}
row = row.child(swatch);
}
if let Some(id) = &self.props.id {
row = row.id(format!("{id}-scale"));
}
let label = label.keyed("more");
row.child(label.text(&self.more_text).part(&label).nowrap()).into()
}
pub fn build(self, theme: &Theme) -> Element {
self.frame(theme).build()
}
pub fn mount(self, ctx: &mut Ctx) -> Element {
let key = self.props.key.clone();
ChartFrame::mount(ctx, key, move |theme| self.frame(theme))
}
}
impl From<Heatmap> for Element {
fn from(chart: Heatmap) -> Self {
chart.build(¤t_theme())
}
}
struct Colors {
cell: Color,
fill: Color,
}
impl Colors {
fn from_look(look: &ChartLook) -> Self {
Self {
cell: look.color(HeatmapPart::Cell),
fill: look.color(HeatmapPart::Fill),
}
}
fn of(recipe: &ResolvedRecipe) -> Self {
let color = |part: HeatmapPart, or: PaletteColor| {
recipe
.part(part)
.rest()
.background
.map(|background| resolve(recipe.theme(), background))
.unwrap_or_else(|| recipe.theme().palette_color(or))
};
Self {
cell: color(HeatmapPart::Cell, PaletteColor::Muted),
fill: color(HeatmapPart::Fill, PaletteColor::Chart1),
}
}
fn step(&self, at: usize, steps: usize) -> Color {
if at == 0 {
return self.cell;
}
let share = at as f32 / (steps - 1).max(1) as f32;
self.fill.with_opacity(self.fill.a() as f32 / 255.0 * share)
}
}
#[derive(Clone)]
struct HeatPlot {
columns: Arc<[Arc<str>]>,
rows: Vec<Arc<str>>,
values: Vec<Arc<[f64]>>,
steps: usize,
least: f64,
most: f64,
cell: f32,
room: f32,
column_axis: bool,
missing: Arc<str>,
fixed: bool,
}
impl HeatPlot {
fn value(&self, row: usize, column: usize) -> Option<f64> {
self
.values
.get(row)
.and_then(|values| values.get(column))
.copied()
.filter(|value| value.is_finite())
}
fn step(&self, value: f64) -> usize {
let top = self.steps - 1;
if value <= self.least || !(self.most > self.least) {
return if value > self.least { top } else { 0 };
}
let share = ((value - self.least) / (self.most - self.least)).clamp(0.0, 1.0);
((share * top as f64).ceil() as usize).clamp(1, top)
}
fn side(&self, area: ChartArea) -> f32 {
let columns = self.columns.len() as f32;
if area.width <= 0.0 || columns == 0.0 {
return self.cell;
}
let pitch = 1.0 + GAP / self.cell;
let fits = (area.width - self.room) / (columns * pitch - GAP / self.cell);
self.cell.min(fits).max(0.5)
}
fn gap(&self, side: f32) -> f32 {
GAP * (side / self.cell).min(1.0)
}
fn cell(&self, area: ChartArea, row: usize, column: usize) -> (f32, f32, f32) {
let side = self.side(area);
let pitch = side + self.gap(side);
(self.room + column as f32 * pitch, row as f32 * pitch, side)
}
fn color(&self, colors: &Colors, row: usize, column: usize) -> Option<Color> {
self
.value(row, column)
.map(|value| colors.step(self.step(value), self.steps))
}
fn paint_cells(
&self,
canvas: &Context2D,
area: ChartArea,
look: &ChartLook,
active: Option<ChartPoint>,
color: impl Fn(usize, usize) -> Option<Color>,
) {
for row in 0..self.rows.len() {
for column in 0..self.columns.len() {
let (x, y, side) = self.cell(area, row, column);
let r = RADIUS.min(side / 2.0);
if self.value(row, column).is_none() {
canvas.set_stroke_style(look.color(HeatmapPart::Missing));
canvas.set_line_width(1.0);
canvas.begin_path();
let _ = canvas.round_rect(x + 0.5, y + 0.5, side - 1.0, side - 1.0, (r - 0.5).max(0.0));
canvas.stroke();
}
if let Some(fill) = color(row, column) {
canvas.set_fill_style(fill);
canvas.begin_path();
let _ = canvas.round_rect(x, y, side, side, r);
canvas.fill();
}
}
}
if let Some(point) = active
&& point.series < self.rows.len()
&& point.index < self.columns.len()
{
let (x, y, side) = self.cell(area, point.series, point.index);
canvas.set_stroke_style(look.color(HeatmapPart::Ring));
canvas.set_line_width(1.5);
canvas.begin_path();
let _ = canvas.round_rect(x - 1.25, y - 1.25, side + 2.5, side + 2.5, RADIUS + 1.25);
canvas.stroke();
}
}
fn name(&self, row: usize, column: usize) -> String {
format!("{}, {}", self.rows[row], self.columns[column])
}
}
impl ChartPlot for HeatPlot {
fn paint(&self, canvas: &Context2D, area: ChartArea, look: &ChartLook, active: Option<ChartPoint>) {
let colors = Colors::from_look(look);
self.paint_cells(canvas, area, look, active, |row, column| {
self.color(&colors, row, column)
});
}
fn paint_moving(
&self,
canvas: &Context2D,
area: ChartArea,
look: &ChartLook,
active: Option<ChartPoint>,
motion: ChartMotion<'_>,
) {
if motion.at_rest() {
return self.paint(canvas, area, look, active);
}
let colors = Colors::from_look(look);
let from = motion.from_as::<HeatPlot>();
self.paint_cells(canvas, area, look, active, |row, column| {
let to = self.color(&colors, row, column);
let was = from.and_then(|from| {
(row < from.rows.len() && column < from.columns.len())
.then(|| from.color(&colors, row, column))
.flatten()
});
match (was, to) {
(Some(was), Some(to)) => Some(mix(was, to, motion.progress)),
(None, Some(to)) => Some(mix(to.with_alpha(0), to, motion.progress)),
(Some(was), None) => Some(mix(was, was.with_alpha(0), motion.progress)),
(None, None) => None,
}
});
}
fn height_for(&self, width: f32) -> Option<f32> {
if self.fixed || self.is_empty() {
return None;
}
let side = self.side(ChartArea { width, height: 0.0 });
let rows = self.rows.len() as f32;
let under = if self.column_axis { COLUMN_ROOM } else { 0.0 };
let gap = self.gap(side);
Some((rows * (side + gap) - gap).max(side) + under)
}
fn point_at(&self, area: ChartArea, x: f32, y: f32) -> Option<ChartPoint> {
let side = self.side(area);
let gap = self.gap(side);
let pitch = side + gap;
if x < self.room || y < 0.0 {
return None;
}
let column = ((x - self.room + gap / 2.0) / pitch) as usize;
let row = ((y + gap / 2.0) / pitch) as usize;
(row < self.rows.len() && column < self.columns.len()).then(|| ChartPoint::new(row, column))
}
fn anchor(&self, area: ChartArea, point: ChartPoint) -> Option<(f32, f32)> {
(point.series < self.rows.len() && point.index < self.columns.len()).then(|| {
let (x, y, side) = self.cell(area, point.series, point.index);
(x + side / 2.0, y)
})
}
fn counts(&self) -> Vec<usize> {
vec![self.columns.len(); self.rows.len()]
}
fn tip(&self, point: ChartPoint) -> ChartTip {
let column = self
.columns
.get(point.index)
.map(|name| name.to_string())
.unwrap_or_default();
match self.value(point.series, point.index) {
Some(value) => ChartTip {
title: column,
rows: vec![(point.series, value)],
},
None => ChartTip {
title: format!(
"{column}, {}: {}",
self.rows.get(point.series).map_or("", |row| row),
self.missing
),
rows: Vec::new(),
},
}
}
fn tip_color(&self, point: ChartPoint, _series: usize, look: &ChartLook) -> Option<Color> {
let value = self.value(point.series, point.index)?;
let colors = Colors::from_look(look);
let color = colors.step(self.step(value), self.steps);
Some(over(color, look.theme().palette_color(PaletteColor::Popover)))
}
fn items(&self, area: ChartArea, look: &ChartLook) -> Vec<CanvasItem> {
let mut items = Vec::new();
for row in 0..self.rows.len() {
for column in 0..self.columns.len() {
let (x, y, side) = self.cell(area, row, column);
let value = match self.value(row, column) {
Some(value) => (look.value_text)(value),
None => self.missing.to_string(),
};
items.push(
CanvasItem::rect(format!("cell-{row}-{column}"), "cell", x, y, side, side)
.label(self.name(row, column))
.value(value),
);
}
}
items
}
fn labels(&self, area: ChartArea, _look: &ChartLook) -> Vec<ChartLabel> {
let side = self.side(area);
let pitch = side + self.gap(side);
let apart = ((14.0 / pitch).ceil() as usize).max(1);
let every = if pitch < 24.0 && self.rows.len() > 4 {
apart.max(2)
} else {
apart
};
let mut labels: Vec<ChartLabel> = (0..self.rows.len())
.step_by(every)
.map(|row| {
ChartLabel::new(
0.0,
row as f32 * pitch + side / 2.0,
self.rows[row].to_string(),
(0.0, -0.5),
)
})
.collect();
if self.column_axis && !self.columns.is_empty() {
let widest = self.columns.iter().map(|name| name.chars().count()).max().unwrap_or(0) as f32;
let skip = (((widest * NAME_ADVANCE + NAME_GAP) / pitch).ceil() as usize).max(1);
let under = self.rows.len() as f32 * pitch;
labels.extend((0..self.columns.len()).step_by(skip).map(|column| {
ChartLabel::new(
self.room + column as f32 * pitch,
under,
self.columns[column].to_string(),
(0.0, 0.0),
)
}));
}
labels
}
fn signature(&self) -> u64 {
signature_of((
self.columns.iter().map(|name| name.to_string()).collect::<Vec<_>>(),
self.rows.iter().map(|name| name.to_string()).collect::<Vec<_>>(),
self
.values
.iter()
.map(|values| values.iter().map(|value| bits(*value)).collect::<Vec<_>>())
.collect::<Vec<_>>(),
self.steps,
bits(self.least),
bits(self.most),
self.cell.to_bits(),
self.room.to_bits(),
))
}
fn is_empty(&self) -> bool {
self.columns.is_empty() || self.rows.is_empty()
}
}
fn mix(from: Color, to: Color, progress: f32) -> Color {
let channel = |a: u8, b: u8| (a as f32 + (b as f32 - a as f32) * progress.clamp(0.0, 1.0)).round() as u8;
Color::new(
channel(from.r(), to.r()),
channel(from.g(), to.g()),
channel(from.b(), to.b()),
channel(from.a(), to.a()),
)
}
fn over(color: Color, ground: Color) -> Color {
let alpha = color.a() as f32 / 255.0;
let mix = |top: u8, under: u8| (top as f32 * alpha + under as f32 * (1.0 - alpha)).round() as u8;
Color::new(
mix(color.r(), ground.r()),
mix(color.g(), ground.g()),
mix(color.b(), ground.b()),
255,
)
}
impl crate::ui::Styled for Heatmap {
type Component = Self;
fn rules(self, rules: &crate::ui::Recipe) -> Self {
Self::rules(self, rules)
}
fn state(self, state: impl Into<crate::ui::Name>, on: bool) -> Self {
Self::state(self, state, on)
}
}
impl Themed for Heatmap {
const NAME: &'static str = "heatmap";
type Renderer = ChartRenderer;
fn parts() -> crate::ui::Declared {
HeatmapPart::declared()
}
fn recipe() -> Recipe {
chart_recipe()
.base(ChartPart::AxisLabel, |s| s.font_size(10.0))
.base(HeatmapPart::Cell, |s| s.background(PaletteColor::Muted))
.base(HeatmapPart::Fill, |s| s.background(PaletteColor::Chart1))
.base(HeatmapPart::Missing, |s| s.background(PaletteColor::Border))
.base(HeatmapPart::Ring, |s| s.background(PaletteColor::Foreground))
.base(HeatmapPart::Scale, |s| s.gap(6.0))
.base(HeatmapPart::Step, |s| s.square(12.0).radius(RADIUS))
.base(HeatmapPart::ScaleLabel, |s| {
s.font_family(FontFamily::Mono)
.font_size(11.0)
.foreground(PaletteColor::MutedForeground)
})
}
}