chartml_core/shapes/
pie.rs

1/// Computes start/end angles for pie slices from data values.
2/// Equivalent to D3's `d3.pie()`.
3use std::f64::consts::PI;
4
5/// A computed pie slice with angular position.
6#[derive(Debug, Clone)]
7pub struct PieSlice {
8    /// Index of the original data value.
9    pub index: usize,
10    /// The original data value.
11    pub value: f64,
12    /// Start angle in radians.
13    pub start_angle: f64,
14    /// End angle in radians.
15    pub end_angle: f64,
16}
17
18/// Computes pie layout angles from data values.
19pub struct PieLayout {
20    start_angle: f64,
21    end_angle: f64,
22    sort: bool,
23}
24
25impl PieLayout {
26    /// Create a new PieLayout with default settings (full circle, unsorted).
27    pub fn new() -> Self {
28        Self {
29            start_angle: 0.0,
30            end_angle: 2.0 * PI,
31            sort: false,
32        }
33    }
34
35    /// Set the start angle in radians.
36    pub fn start_angle(mut self, angle: f64) -> Self {
37        self.start_angle = angle;
38        self
39    }
40
41    /// Set the end angle in radians.
42    pub fn end_angle(mut self, angle: f64) -> Self {
43        self.end_angle = angle;
44        self
45    }
46
47    /// Set whether to sort slices by value (descending).
48    pub fn sort(mut self, sort: bool) -> Self {
49        self.sort = sort;
50        self
51    }
52
53    /// Compute pie slices from data values.
54    /// Each value gets a proportional angle within [start_angle, end_angle].
55    pub fn layout(&self, values: &[f64]) -> Vec<PieSlice> {
56        if values.is_empty() {
57            return Vec::new();
58        }
59
60        let total: f64 = values.iter().sum();
61        let angle_span = self.end_angle - self.start_angle;
62
63        // Build indexed values
64        let mut indexed: Vec<(usize, f64)> = values.iter().enumerate().map(|(i, &v)| (i, v)).collect();
65
66        if self.sort {
67            indexed.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
68        }
69
70        let mut slices = Vec::with_capacity(indexed.len());
71        let mut current_angle = self.start_angle;
72
73        for &(index, value) in &indexed {
74            let slice_angle = if total > 0.0 {
75                value / total * angle_span
76            } else {
77                0.0
78            };
79            let start = current_angle;
80            let end = current_angle + slice_angle;
81            slices.push(PieSlice {
82                index,
83                value,
84                start_angle: start,
85                end_angle: end,
86            });
87            current_angle = end;
88        }
89
90        slices
91    }
92}
93
94impl Default for PieLayout {
95    fn default() -> Self {
96        Self::new()
97    }
98}
99
100#[cfg(test)]
101mod tests {
102    use super::*;
103
104    #[test]
105    fn pie_basic() {
106        let layout = PieLayout::new();
107        let slices = layout.layout(&[1.0, 2.0, 3.0]);
108        assert_eq!(slices.len(), 3);
109        // Angles should sum to 2*PI
110        let total_angle: f64 = slices.iter().map(|s| s.end_angle - s.start_angle).sum();
111        assert!((total_angle - 2.0 * PI).abs() < 1e-10, "Total angle should be 2*PI, got: {}", total_angle);
112        // First slice should be 1/6 of the circle
113        let first_angle = slices[0].end_angle - slices[0].start_angle;
114        assert!((first_angle - 2.0 * PI / 6.0).abs() < 1e-10);
115    }
116
117    #[test]
118    fn pie_single_value() {
119        let layout = PieLayout::new();
120        let slices = layout.layout(&[1.0]);
121        assert_eq!(slices.len(), 1);
122        assert!((slices[0].start_angle - 0.0).abs() < 1e-10);
123        assert!((slices[0].end_angle - 2.0 * PI).abs() < 1e-10);
124    }
125
126    #[test]
127    fn pie_equal_values() {
128        let layout = PieLayout::new();
129        let slices = layout.layout(&[1.0, 1.0, 1.0]);
130        assert_eq!(slices.len(), 3);
131        let expected_angle = 2.0 * PI / 3.0;
132        for slice in &slices {
133            let angle = slice.end_angle - slice.start_angle;
134            assert!((angle - expected_angle).abs() < 1e-10, "Each slice should be 2*PI/3, got: {}", angle);
135        }
136    }
137
138    #[test]
139    fn pie_sorted_descending() {
140        let layout = PieLayout::new().sort(true);
141        let slices = layout.layout(&[1.0, 3.0, 2.0]);
142        assert_eq!(slices.len(), 3);
143        // Sorted descending: first slice should be value 3.0 (index 1)
144        assert_eq!(slices[0].index, 1);
145        assert!((slices[0].value - 3.0).abs() < 1e-10);
146        // Second should be value 2.0 (index 2)
147        assert_eq!(slices[1].index, 2);
148        assert!((slices[1].value - 2.0).abs() < 1e-10);
149        // Third should be value 1.0 (index 0)
150        assert_eq!(slices[2].index, 0);
151    }
152
153    #[test]
154    fn pie_custom_angle_range() {
155        // Half circle (semicircle)
156        let layout = PieLayout::new().start_angle(0.0).end_angle(PI);
157        let slices = layout.layout(&[1.0, 1.0]);
158        assert_eq!(slices.len(), 2);
159        let total_angle: f64 = slices.iter().map(|s| s.end_angle - s.start_angle).sum();
160        assert!((total_angle - PI).abs() < 1e-10, "Total angle should be PI, got: {}", total_angle);
161        // Each slice should be PI/2
162        let each = PI / 2.0;
163        assert!((slices[0].end_angle - slices[0].start_angle - each).abs() < 1e-10);
164    }
165
166    #[test]
167    fn pie_with_zero() {
168        let layout = PieLayout::new();
169        let slices = layout.layout(&[0.0, 1.0, 2.0]);
170        assert_eq!(slices.len(), 3);
171        // Zero-value slice should have start == end angle
172        assert!((slices[0].end_angle - slices[0].start_angle).abs() < 1e-10,
173            "Zero-value slice should have zero angle span");
174    }
175}
chartml_core/shapes/pie.rs

chartml_core/shapes/
pie.rs
