use std::{
f32::consts::{PI, TAU},
hash::Hash,
sync::Arc,
};
use super::{
chart::{
ChartArea, ChartFrame, ChartLabel, ChartLook, ChartMotion, ChartPart, ChartPlot, ChartPoint, ChartProps,
ChartRenderer, ChartSeries, ChartSize, ChartTip, LinearScale, bits, chart_recipe, signature_of,
},
names,
part_style::Opacity,
recipe::Recipe,
theme::{Themed, current_theme},
};
use crate::{
app::{
ctx::Ctx,
theme::{PaletteColor, Theme},
},
canvas::{ArcDirection, CanvasItem, Context2D, LineJoin},
layout::layout_kind::Justify,
node::Element,
};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum RadarChartPart {
Ring,
Area,
ActiveArea,
}
names!(RadarChartPart {
Ring => "ring",
Area => "area",
ActiveArea => "active_area",
});
const NAME_GAP: f32 = 6.0;
const ROOM: f32 = 15.0;
const EDGE: f32 = 1.5;
const DOT: f32 = 3.5;
#[derive(Clone)]
pub struct RadarChart {
axes: Arc<[Arc<str>]>,
series: Vec<ChartSeries>,
props: ChartProps,
}
impl RadarChart {
pub fn new<S: AsRef<str>>(axes: impl IntoIterator<Item = S>, series: impl IntoIterator<Item = ChartSeries>) -> Self {
Self {
axes: axes.into_iter().map(|name| Arc::from(name.as_ref())).collect(),
series: series.into_iter().collect(),
props: ChartProps::default(),
}
}
crate::chart_props!();
fn frame(&self, theme: &Theme) -> ChartFrame {
let mut plot = RadarPlot {
axes: self.axes.clone(),
values: self.series.iter().map(|series| Arc::from(series.values())).collect(),
shown: self.series.iter().map(|series| !self.props.is_hidden(series)).collect(),
names: self.series.iter().map(|series| Arc::from(series.name())).collect(),
rings: false,
};
let case = self.props.case(ChartSize::Sm, plot.is_empty());
let recipe = theme
.resolve::<RadarChart>(&case, Some(&self.props.rules))
.owned_by(self.props.id.as_ref());
plot.rings = self.props.value_axis.unwrap_or(false);
let side = self.props.plot_height(&recipe);
self
.props
.frame(
recipe,
Arc::new(plot),
self.series.clone(),
theme.renderer::<RadarChart>(),
)
.plot_width(side)
.plot_justify(Justify::Center)
}
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<RadarChart> for Element {
fn from(chart: RadarChart) -> Self {
chart.build(¤t_theme())
}
}
#[derive(Clone)]
struct RadarPlot {
axes: Arc<[Arc<str>]>,
values: Vec<Arc<[f64]>>,
shown: Vec<bool>,
names: Vec<Arc<str>>,
rings: bool,
}
impl RadarPlot {
fn value(&self, series: usize, axis: usize) -> Option<f64> {
self
.values
.get(series)
.and_then(|values| values.get(axis))
.copied()
.filter(|value| value.is_finite())
}
fn shown(&self) -> Vec<usize> {
(0..self.values.len()).filter(|series| self.shown[*series]).collect()
}
fn geometry(&self, area: ChartArea) -> (f32, f32, f32) {
let side = area.width.min(area.height);
(area.width / 2.0, area.height / 2.0, (side / 2.0 - ROOM).max(0.0))
}
fn scale(&self, radius: f32) -> LinearScale {
let values = self
.shown()
.into_iter()
.flat_map(|series| (0..self.axes.len()).filter_map(move |axis| self.value(series, axis)))
.collect::<Vec<_>>();
LinearScale::nice(values, (0.0, radius), 3)
}
fn angle(&self, axis: usize) -> f32 {
-PI / 2.0 + axis as f32 / self.axes.len().max(1) as f32 * TAU
}
fn at(&self, area: ChartArea, axis: usize, value: f64) -> (f32, f32) {
let (cx, cy, radius) = self.geometry(area);
let distance = self.scale(radius).map(value).clamp(0.0, radius);
let angle = self.angle(axis);
(cx + distance * angle.cos(), cy + distance * angle.sin())
}
fn vertex(&self, area: ChartArea, series: usize, axis: usize) -> (f32, f32) {
let scale = self.scale(self.geometry(area).2);
let least = scale.invert(0.0);
self.at(area, axis, self.value(series, axis).unwrap_or(least))
}
fn ring(&self, canvas: &Context2D, (cx, cy): (f32, f32), radius: f32) {
canvas.begin_path();
let count = self.axes.len();
if count < 3 {
let _ = canvas.arc(cx, cy, radius, 0.0, TAU, ArcDirection::Clockwise);
} else {
for axis in 0..count {
let angle = self.angle(axis);
let (x, y) = (cx + radius * angle.cos(), cy + radius * angle.sin());
if axis == 0 {
canvas.move_to(x, y);
} else {
canvas.line_to(x, y);
}
}
}
canvas.close_path();
}
fn polygon(canvas: &Context2D, corners: &[(f32, f32)]) {
canvas.begin_path();
for (index, (x, y)) in corners.iter().enumerate() {
if index == 0 {
canvas.move_to(*x, *y);
} else {
canvas.line_to(*x, *y);
}
}
canvas.close_path();
}
fn corners(&self, area: ChartArea, series: usize) -> Vec<(f32, f32)> {
(0..self.axes.len())
.map(|axis| self.vertex(area, series, axis))
.collect()
}
fn paint_polygons(
&self,
canvas: &Context2D,
area: ChartArea,
look: &ChartLook,
active: Option<ChartPoint>,
polygons: &[(usize, Vec<(f32, f32)>)],
) {
let (cx, cy, radius) = self.geometry(area);
if radius <= 0.0 {
return;
}
let scale = self.scale(radius);
canvas.set_line_width(1.0);
canvas.set_line_join(LineJoin::Miter);
canvas.set_stroke_style(look.color(RadarChartPart::Ring));
for tick in scale.ticks() {
let at = scale.map(tick);
if at > 0.5 {
self.ring(canvas, (cx, cy), at);
canvas.stroke();
}
}
for axis in 0..self.axes.len() {
let angle = self.angle(axis);
let on = active.is_some_and(|point| point.index == axis);
canvas.set_stroke_style(if on {
look.color(ChartPart::Cursor)
} else {
look.color(RadarChartPart::Ring)
});
canvas.begin_path();
canvas.move_to(cx, cy);
canvas.line_to(cx + radius * angle.cos(), cy + radius * angle.sin());
canvas.stroke();
}
let (rest, lit) = (
opacity(look, RadarChartPart::Area, 0.2),
opacity(look, RadarChartPart::ActiveArea, 0.35),
);
canvas.set_line_width(EDGE);
canvas.set_line_join(LineJoin::Round);
for (series, corners) in polygons {
let color = look.series(*series);
let on = active.is_some_and(|point| point.series == *series);
let alpha = color.a() as f32 / 255.0;
Self::polygon(canvas, corners);
canvas.set_fill_style(color.with_opacity(alpha * if on { lit } else { rest }));
canvas.fill();
canvas.set_stroke_style(if on { color } else { color.with_opacity(alpha * rest) });
canvas.stroke();
}
if let Some(point) = active
&& let Some((_, corners)) = polygons.iter().find(|(series, _)| *series == point.series)
&& let Some((x, y)) = corners.get(point.index)
{
canvas.begin_path();
let _ = canvas.arc(*x, *y, DOT, 0.0, TAU, ArcDirection::Clockwise);
canvas.set_fill_style(look.series(point.series));
canvas.fill();
canvas.set_line_width(2.0);
canvas.set_stroke_style(look.theme().palette_color(PaletteColor::Card));
canvas.stroke();
}
}
fn order(&self, active: Option<ChartPoint>) -> Vec<usize> {
let mut order = self.shown();
if let Some(point) = active
&& let Some(place) = order.iter().position(|series| *series == point.series)
{
let series = order.remove(place);
order.push(series);
}
order
}
}
fn opacity(look: &ChartLook, part: RadarChartPart, or: f32) -> f32 {
match look.part(part).rest().opacity {
Some(Opacity::Value(value)) => value,
_ => or,
}
}
impl ChartPlot for RadarPlot {
fn paint(&self, canvas: &Context2D, area: ChartArea, look: &ChartLook, active: Option<ChartPoint>) {
let polygons: Vec<(usize, Vec<(f32, f32)>)> = self
.order(active)
.into_iter()
.map(|series| (series, self.corners(area, series)))
.collect();
self.paint_polygons(canvas, area, look, active, &polygons);
}
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 (cx, cy, _) = self.geometry(area);
let between = |from: (f32, f32), to: (f32, f32)| (motion.lerp(from.0, to.0), motion.lerp(from.1, to.1));
let from = motion.from_as::<RadarPlot>();
let was = |series: usize, axis: usize| {
from
.filter(|from| from.shown.get(series).copied().unwrap_or(false) && axis < from.axes.len())
.map_or((cx, cy), |from| from.vertex(area, series, axis))
};
let mut polygons: Vec<(usize, Vec<(f32, f32)>)> = Vec::new();
if let Some(from) = from {
for series in from.shown() {
if self.shown.get(series).copied().unwrap_or(false) {
continue;
}
let corners = (0..from.axes.len())
.map(|axis| between(from.vertex(area, series, axis), (cx, cy)))
.collect();
polygons.push((series, corners));
}
}
for series in self.order(active) {
let corners = (0..self.axes.len())
.map(|axis| between(was(series, axis), self.vertex(area, series, axis)))
.collect();
polygons.push((series, corners));
}
self.paint_polygons(canvas, area, look, active, &polygons);
}
fn point_at(&self, area: ChartArea, x: f32, y: f32) -> Option<ChartPoint> {
let (cx, cy, radius) = self.geometry(area);
let (dx, dy) = (x - cx, y - cy);
if self.axes.is_empty() || (dx * dx + dy * dy).sqrt() > radius + ROOM {
return None;
}
let mut turn = (dy.atan2(dx) + PI / 2.0).rem_euclid(TAU);
let step = TAU / self.axes.len() as f32;
turn += step / 2.0;
let axis = ((turn / step) as usize) % self.axes.len();
self
.shown()
.into_iter()
.map(|series| {
let (px, py) = self.vertex(area, series, axis);
(series, (px - x).powi(2) + (py - y).powi(2))
})
.min_by(|a, b| a.1.total_cmp(&b.1))
.map(|(series, _)| ChartPoint::new(series, axis))
}
fn anchor(&self, area: ChartArea, point: ChartPoint) -> Option<(f32, f32)> {
(point.index < self.axes.len()).then(|| self.vertex(area, point.series, point.index))
}
fn counts(&self) -> Vec<usize> {
(0..self.values.len())
.map(|series| if self.shown[series] { self.axes.len() } else { 0 })
.collect()
}
fn tip(&self, point: ChartPoint) -> ChartTip {
ChartTip {
title: self
.axes
.get(point.index)
.map(|name| name.to_string())
.unwrap_or_default(),
rows: self
.shown()
.into_iter()
.filter_map(|series| Some((series, self.value(series, point.index)?)))
.collect(),
}
}
fn items(&self, area: ChartArea, look: &ChartLook) -> Vec<CanvasItem> {
let mut items = Vec::new();
for series in self.shown() {
for axis in 0..self.axes.len() {
let Some(value) = self.value(series, axis) else {
continue;
};
let (x, y) = self.vertex(area, series, axis);
items.push(
CanvasItem::point(format!("point-{series}-{axis}"), "point", x, y, 6.0)
.label(format!("{}, {}", self.axes[axis], self.names[series]))
.value((look.value_text)(value)),
);
}
}
items
}
fn labels(&self, area: ChartArea, look: &ChartLook) -> Vec<ChartLabel> {
let (cx, cy, radius) = self.geometry(area);
let mut labels: Vec<ChartLabel> = (0..self.axes.len())
.map(|axis| {
let angle = self.angle(axis);
let (dx, dy) = (angle.cos(), angle.sin());
let (x, y) = (cx + (radius + NAME_GAP) * dx, cy + (radius + NAME_GAP) * dy);
let across = if dx > 0.3 {
0.0
} else if dx < -0.3 {
-1.0
} else {
-0.5
};
let up = if dy < -0.3 {
-1.0
} else if dy > 0.3 {
0.0
} else {
-0.5
};
ChartLabel::new(x, y, self.axes[axis].to_string(), (across, up))
})
.collect();
if self.rings {
let scale = self.scale(radius);
for tick in scale.ticks() {
let at = scale.map(tick);
if at > 0.5 {
labels.push(
ChartLabel::new(cx + 3.0, cy - at + 1.0, (look.value_text)(tick), (0.0, 0.0)).part(ChartPart::ValueLabel),
);
}
}
}
labels
}
fn signature(&self) -> u64 {
signature_of((
self.axes.iter().map(|name| name.to_string()).collect::<Vec<_>>(),
self
.values
.iter()
.map(|values| values.iter().map(|value| bits(*value)).collect::<Vec<_>>())
.collect::<Vec<_>>(),
&self.shown,
))
}
fn is_empty(&self) -> bool {
self.axes.is_empty() || self.shown().iter().all(|series| self.values[*series].is_empty())
}
}
impl crate::ui::Styled for RadarChart {
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 RadarChart {
const NAME: &'static str = "radar_chart";
type Renderer = ChartRenderer;
fn parts() -> crate::ui::Declared {
RadarChartPart::declared()
}
fn recipe() -> Recipe {
chart_recipe()
.base(ChartPart::Plot, |s| s.height(180.0))
.size(ChartSize::Sm, ChartPart::Plot, |s| s.height(150.0))
.base(RadarChartPart::Ring, |s| s.background(PaletteColor::Border))
.base(RadarChartPart::Area, |s| s.opacity(0.2))
.base(RadarChartPart::ActiveArea, |s| s.opacity(0.35))
}
}