plotpx 0.1.7

Pixel-focused plotting engine that renders magnitude grids, heatmaps, and spectra to RGBA buffers
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360

use crate::color_scheme::{default_color_scheme_data, get_color_count, Rgba};

#[derive(Clone, Copy, Debug, PartialEq)]
pub enum BarStyle {
    Solid,     // Solid color bars
    Gradient,  // Gradient color bars
    Segmented, // Segmented bars (like LED VU meters)
}

pub struct Spectrum {
    pub num_bins: u32,
    pub width: u32,
    pub height: u32,
    pub max_magnitude: f32,
    pub min_magnitude: f32,
    pub buffer: Vec<f32>,
    pub peak_values: Vec<f32>,
    pub style: BarStyle,
    pub peak_decay: f32,
    pub show_peaks: bool,
    pub bar_width_factor: f32,
    pub background_color: Rgba,
}

impl Spectrum {
    pub fn new(bins: u32, width: u32, height: u32) -> Self {
        Self {
            num_bins: bins,
            width,
            height,
            max_magnitude: f32::NEG_INFINITY,
            min_magnitude: f32::INFINITY,
            buffer: vec![0.0; bins as usize],
            peak_values: vec![0.0; bins as usize],
            style: BarStyle::Solid,
            peak_decay: 0.0,
            show_peaks: false,
            bar_width_factor: 0.8,
            background_color: [0, 0, 0, 0], // Transparent by default
        }
    }

    pub fn set_background_color(&mut self, r: u8, g: u8, b: u8, a: u8) {
        self.background_color = [r, g, b, a];
    }

    pub fn update(&mut self, magnitudes: &[f32]) {
        let len = magnitudes.len().min(self.buffer.len());

        for i in 0..len {
            self.buffer[i] = magnitudes[i];

            // Update peak values
            if self.show_peaks {
                if magnitudes[i] > self.peak_values[i] {
                    self.peak_values[i] = magnitudes[i];
                } else if self.peak_decay > 0.0 {
                    self.peak_values[i] *= 1.0 - self.peak_decay;
                }
            }

            // Update min/max
            if magnitudes[i] > self.max_magnitude {
                self.max_magnitude = magnitudes[i];
            }
            if magnitudes[i] < self.min_magnitude {
                self.min_magnitude = magnitudes[i];
            }
        }
    }

    pub fn update_bin(&mut self, bin: u32, magnitude_value: f32) {
        if bin >= self.num_bins {
            return;
        }

        let idx = bin as usize;
        self.buffer[idx] = magnitude_value;

        // Update peak
        if self.show_peaks {
            if magnitude_value > self.peak_values[idx] {
                self.peak_values[idx] = magnitude_value;
            } else if self.peak_decay > 0.0 {
                self.peak_values[idx] *= 1.0 - self.peak_decay;
            }
        }

        // Update min/max
        if magnitude_value > self.max_magnitude {
            self.max_magnitude = magnitude_value;
        }
        if magnitude_value < self.min_magnitude {
            self.min_magnitude = magnitude_value;
        }
    }

    pub fn shift_buffer_to_non_negative(&mut self) {
        if self.min_magnitude < 0.0 {
            let shift = -self.min_magnitude;
            for val in &mut self.buffer {
                *val += shift;
            }
            for val in &mut self.peak_values {
                *val += shift;
            }
            self.max_magnitude += shift;
            self.min_magnitude = 0.0;
        }
    }

    pub fn render(&mut self) -> Vec<u8> {
        let colors = default_color_scheme_data();
        self.render_with_colors(&colors)
    }

    pub fn render_with_colors(&mut self, colors: &[u8]) -> Vec<u8> {
        self.shift_buffer_to_non_negative();
        let saturation = if self.max_magnitude > 0.0 {
            self.max_magnitude
        } else {
            1.0
        };
        self.render_saturated(colors, saturation)
    }

    pub fn render_saturated(&self, colors: &[u8], saturation: f32) -> Vec<u8> {
        assert!(saturation > 0.0);

        let total_pixels = (self.width * self.height) as usize;
        let mut colorbuf = vec![0u8; total_pixels * 4];

        // Fill with background color
        for i in 0..total_pixels {
            let idx = i * 4;
            colorbuf[idx] = self.background_color[0];
            colorbuf[idx + 1] = self.background_color[1];
            colorbuf[idx + 2] = self.background_color[2];
            colorbuf[idx + 3] = self.background_color[3];
        }

        let ncolors = get_color_count(colors);
        if ncolors == 0 {
            return colorbuf;
        }

        // Determine rendering method based on bins vs pixels
        if self.num_bins <= self.width {
            // Fewer bins than pixels - expand bins to pixels
            self.render_bins_to_pixels(colors, saturation, &mut colorbuf, ncolors);
        } else {
            // More bins than pixels - aggregate bins to pixels
            self.render_pixels_from_bins(colors, saturation, &mut colorbuf, ncolors);
        }

        colorbuf
    }

    fn render_bins_to_pixels(
        &self,
        colors: &[u8],
        saturation: f32,
        colorbuf: &mut [u8],
        ncolors: usize,
    ) {
        let pixels_per_bin = self.width as f32 / self.num_bins as f32;
        let bar_width = (pixels_per_bin * self.bar_width_factor) as u32;
        let bar_spacing = ((pixels_per_bin - bar_width as f32) / 2.0) as u32;

        for bin in 0..self.num_bins {
            let val = self.buffer[bin as usize];
            let normalized = (val / saturation).clamp(0.0, 1.0);

            let bar_height = (normalized * self.height as f32) as u32;
            let bar_start_x = (bin as f32 * pixels_per_bin) as u32 + bar_spacing;
            let bar_end_x = (bar_start_x + bar_width).min(self.width);

            // Draw the bar
            match self.style {
                BarStyle::Solid => {
                    let color_idx = ((ncolors - 1) as f32 * normalized + 0.5) as usize;
                    let color_idx = color_idx.min(ncolors - 1);
                    let color = &colors[color_idx * 4..color_idx * 4 + 4];

                    for y in (self.height - bar_height)..self.height {
                        for x in bar_start_x..bar_end_x {
                            let pixel_idx = ((y * self.width + x) * 4) as usize;
                            colorbuf[pixel_idx..pixel_idx + 4].copy_from_slice(color);
                        }
                    }
                }
                BarStyle::Gradient => {
                    for y in (self.height - bar_height)..self.height {
                        let y_normalized = (self.height - y) as f32 / self.height as f32;
                        let gradient_val = y_normalized * normalized;
                        let color_idx = ((ncolors - 1) as f32 * gradient_val + 0.5) as usize;
                        let color_idx = color_idx.min(ncolors - 1);
                        let color = &colors[color_idx * 4..color_idx * 4 + 4];

                        for x in bar_start_x..bar_end_x {
                            let pixel_idx = ((y * self.width + x) * 4) as usize;
                            colorbuf[pixel_idx..pixel_idx + 4].copy_from_slice(color);
                        }
                    }
                }
                BarStyle::Segmented => {
                    let segment_height = 4; // Height of each segment
                    let segment_gap = 2; // Gap between segments
                    let segment_total = segment_height + segment_gap;

                    let mut y = self.height;
                    while y > self.height - bar_height {
                        let seg_bottom = y;
                        let seg_top =
                            (y.saturating_sub(segment_height)).max(self.height - bar_height);

                        let y_normalized = (self.height - seg_bottom) as f32 / self.height as f32;
                        let color_idx = ((ncolors - 1) as f32 * y_normalized + 0.5) as usize;
                        let color_idx = color_idx.min(ncolors - 1);
                        let color = &colors[color_idx * 4..color_idx * 4 + 4];

                        for seg_y in seg_top..seg_bottom {
                            for x in bar_start_x..bar_end_x {
                                let pixel_idx = ((seg_y * self.width + x) * 4) as usize;
                                colorbuf[pixel_idx..pixel_idx + 4].copy_from_slice(color);
                            }
                        }

                        if y <= segment_total {
                            break;
                        }
                        y -= segment_total;
                    }
                }
            }

            // Draw peak indicator if enabled
            if self.show_peaks {
                let peak_val = self.peak_values[bin as usize];
                let peak_normalized = (peak_val / saturation).clamp(0.0, 1.0);
                let peak_y = self.height - (peak_normalized * self.height as f32) as u32;

                if peak_y < self.height {
                    // Draw a white line for the peak
                    for x in bar_start_x..bar_end_x {
                        let pixel_idx = ((peak_y * self.width + x) * 4) as usize;
                        colorbuf[pixel_idx] = 255; // R
                        colorbuf[pixel_idx + 1] = 255; // G
                        colorbuf[pixel_idx + 2] = 255; // B
                        colorbuf[pixel_idx + 3] = 255; // A
                    }
                }
            }
        }
    }

    fn render_pixels_from_bins(
        &self,
        colors: &[u8],
        saturation: f32,
        colorbuf: &mut [u8],
        ncolors: usize,
    ) {
        let bins_per_pixel = self.num_bins as f32 / self.width as f32;

        for x in 0..self.width {
            let bin_start = (x as f32 * bins_per_pixel) as u32;
            let bin_end = ((x + 1) as f32 * bins_per_pixel) as u32;
            let bin_end = bin_end.min(self.num_bins);

            // Aggregate bins for this pixel column (take maximum)
            let mut max_val = 0.0f32;
            let mut max_peak = 0.0f32;
            for bin in bin_start..bin_end {
                max_val = max_val.max(self.buffer[bin as usize]);
                if self.show_peaks {
                    max_peak = max_peak.max(self.peak_values[bin as usize]);
                }
            }

            let normalized = (max_val / saturation).clamp(0.0, 1.0);
            let bar_height = (normalized * self.height as f32) as u32;

            // Draw the column
            match self.style {
                BarStyle::Solid => {
                    let color_idx = ((ncolors - 1) as f32 * normalized + 0.5) as usize;
                    let color_idx = color_idx.min(ncolors - 1);
                    let color = &colors[color_idx * 4..color_idx * 4 + 4];

                    for y in (self.height - bar_height)..self.height {
                        let pixel_idx = ((y * self.width + x) * 4) as usize;
                        colorbuf[pixel_idx..pixel_idx + 4].copy_from_slice(color);
                    }
                }
                BarStyle::Gradient => {
                    for y in (self.height - bar_height)..self.height {
                        let y_normalized = (self.height - y) as f32 / self.height as f32;
                        let gradient_val = y_normalized * normalized;
                        let color_idx = ((ncolors - 1) as f32 * gradient_val + 0.5) as usize;
                        let color_idx = color_idx.min(ncolors - 1);
                        let color = &colors[color_idx * 4..color_idx * 4 + 4];

                        let pixel_idx = ((y * self.width + x) * 4) as usize;
                        colorbuf[pixel_idx..pixel_idx + 4].copy_from_slice(color);
                    }
                }
                BarStyle::Segmented => {
                    // Similar to bins_to_pixels but for single column
                    let segment_height = 2;
                    let segment_gap = 1;
                    let segment_total = segment_height + segment_gap;

                    let mut y = self.height;
                    while y > self.height - bar_height {
                        let seg_bottom = y;
                        let seg_top =
                            (y.saturating_sub(segment_height)).max(self.height - bar_height);

                        let y_normalized = (self.height - seg_bottom) as f32 / self.height as f32;
                        let color_idx = ((ncolors - 1) as f32 * y_normalized + 0.5) as usize;
                        let color_idx = color_idx.min(ncolors - 1);
                        let color = &colors[color_idx * 4..color_idx * 4 + 4];

                        for seg_y in seg_top..seg_bottom {
                            let pixel_idx = ((seg_y * self.width + x) * 4) as usize;
                            colorbuf[pixel_idx..pixel_idx + 4].copy_from_slice(color);
                        }

                        if y <= segment_total {
                            break;
                        }
                        y -= segment_total;
                    }
                }
            }

            // Draw peak indicator
            if self.show_peaks && max_peak > 0.0 {
                let peak_normalized = (max_peak / saturation).clamp(0.0, 1.0);
                let peak_y = self.height - (peak_normalized * self.height as f32) as u32;

                if peak_y < self.height {
                    let pixel_idx = ((peak_y * self.width + x) * 4) as usize;
                    colorbuf[pixel_idx] = 255; // R
                    colorbuf[pixel_idx + 1] = 255; // G
                    colorbuf[pixel_idx + 2] = 255; // B
                    colorbuf[pixel_idx + 3] = 255; // A
                }
            }
        }
    }

    pub fn reset(&mut self) {
        self.buffer.fill(0.0);
        self.peak_values.fill(0.0);
        self.max_magnitude = f32::NEG_INFINITY;
        self.min_magnitude = f32::INFINITY;
    }
}