fix(ui): stop chart jitter on play with anchored bucket downsampling

LTTB partitions a slice into N equal buckets *by index* and picks the
"best" point per bucket. During cursor-tracked playback the slice
itself shifts a few samples each frame, so each bucket gets a slightly
different sample set and the chosen peak flickers — visibly so when
zoomed far out, where peaks are flattened to single buckets.

Replace LTTB in compute_viewport_points with min/max-per-bucket, where
bucket boundaries are anchored to absolute time (k × bucket_size from
t = 0) instead of the viewport. As the cursor advances, samples slide
through a fixed grid and each bucket's contents are invariant to the
viewport offset, so peaks stay put. Two points per bucket (min, max)
preserve the envelope; the bucket count is halved so total output
stays under MAX_CHART_POINTS.

Author: irudoy

src/app.rs

@@ -51,8 +51,6 @@ pub struct UltraLogApp {
     load_receiver: Option<Receiver<LoadResult>>,
     /// Current loading state
     pub(crate) loading_state: LoadingState,
-    /// Cache for downsampled chart data
-    pub(crate) downsample_cache: HashMap<CacheKey, Vec<[f64; 2]>>,
     /// Cache for channel min/max values (avoids O(n) scans)
     pub(crate) minmax_cache: HashMap<CacheKey, (f64, f64)>,
     /// Last X-axis bounds shown by each plot area. Used to slice raw data to
@@ -178,7 +176,6 @@ impl Default for UltraLogApp {
             last_drop_time: None,
             load_receiver: None,
             loading_state: LoadingState::Idle,
-            downsample_cache: HashMap::new(),
             minmax_cache: HashMap::new(),
             chart_last_x_bounds: HashMap::new(),
             cursor_time: None,
@@ -812,6 +809,26 @@ impl UltraLogApp {
         }
     }
 
+    /// Borrow channel data without copying. Returns an empty slice for invalid
+    /// indices or computed channels that haven't been evaluated yet. Used in
+    /// per-frame chart paths where cloning the full channel would be wasteful.
+    pub fn get_channel_data_ref(&self, file_index: usize, channel_index: usize) -> &[f64] {
+        let Some(file) = self.files.get(file_index) else {
+            return &[];
+        };
+        let regular_count = file.log.channels.len();
+        if channel_index < regular_count {
+            file.get_channel_column(channel_index).unwrap_or(&[])
+        } else {
+            let computed_idx = channel_index - regular_count;
+            self.file_computed_channels
+                .get(&file_index)
+                .and_then(|c| c.get(computed_idx))
+                .and_then(|c| c.cached_data.as_deref())
+                .unwrap_or(&[])
+        }
+    }
+
     /// Get the display name of a channel by index (handles both regular and computed channels)
     pub fn get_channel_name(&self, file_index: usize, channel_index: usize) -> String {
         if file_index >= self.files.len() {
@@ -853,20 +870,19 @@ impl UltraLogApp {
             return Some(cached);
         }
 
-        // Compute min/max (handles both regular and computed channels)
-        let data = self.get_channel_data(file_index, channel_index);
-
-        if data.is_empty() {
-            return None;
-        }
-
-        let (min_val, max_val) = data
-            .iter()
-            .fold((f64::INFINITY, f64::NEG_INFINITY), |(min, max), &v| {
-                (min.min(v), max.max(v))
-            });
+        // Compute min/max (handles both regular and computed channels).
+        // Scoped to release the borrow before mutating the cache below.
+        let (min_val, max_val) = {
+            let data = self.get_channel_data_ref(file_index, channel_index);
+            if data.is_empty() {
+                return None;
+            }
+            data.iter()
+                .fold((f64::INFINITY, f64::NEG_INFINITY), |(min, max), &v| {
+                    (min.min(v), max.max(v))
+                })
+        };
 
-        // Cache the result
         self.minmax_cache.insert(cache_key, (min_val, max_val));
         Some((min_val, max_val))
     }
@@ -883,28 +899,6 @@ impl UltraLogApp {
                 self.close_tab(tab_idx);
             }
 
-            // Clear downsample cache entries for this file and update indices
-            let mut new_cache = HashMap::new();
-            for (key, value) in self.downsample_cache.drain() {
-                if key.file_index == index {
-                    // Skip entries for removed file
-                    continue;
-                } else if key.file_index > index {
-                    // Update indices for files after the removed one
-                    new_cache.insert(
-                        CacheKey {
-                            file_index: key.file_index - 1,
-                            channel_index: key.channel_index,
-                            plot_area_id: key.plot_area_id,
-                        },
-                        value,
-                    );
-                } else {
-                    new_cache.insert(key, value);
-                }
-            }
-            self.downsample_cache = new_cache;
-
             // Clear minmax cache entries for this file and update indices
             let mut new_minmax_cache = HashMap::new();
             for (key, value) in self.minmax_cache.drain() {

src/state.rs

@@ -4,6 +4,7 @@
 //! the application, including loaded files, selected channels, and color palettes.
 
 use std::path::PathBuf;
+use std::sync::OnceLock;
 
 use crate::parsers::{Channel, EcuType, Log};
 
@@ -84,6 +85,11 @@ pub struct LoadedFile {
     /// Cached flag for each channel: true if channel has non-zero data
     /// Computed once on load for UI performance
     pub channels_with_data: Vec<bool>,
+    /// Lazy column-major view of `log.data` as `Vec<Vec<f64>>`. Built on first
+    /// access so the chart hot path can borrow `&[f64]` for a channel instead
+    /// of re-collecting an owned `Vec<f64>` from the row-major store on every
+    /// frame.
+    channel_columns: OnceLock<Vec<Vec<f64>>>,
 }
 
 impl LoadedFile {
@@ -103,6 +109,7 @@ impl LoadedFile {
             ecu_type,
             log,
             channels_with_data,
+            channel_columns: OnceLock::new(),
         }
     }
 
@@ -114,6 +121,17 @@ impl LoadedFile {
             .copied()
             .unwrap_or(false)
     }
+
+    /// Borrow a regular channel's f64 data without copying. Lazily transposes
+    /// `log.data` into column-major form on first call.
+    pub fn get_channel_column(&self, channel_index: usize) -> Option<&[f64]> {
+        let cols = self.channel_columns.get_or_init(|| {
+            (0..self.log.channels.len())
+                .map(|i| self.log.get_channel_data(i))
+                .collect()
+        });
+        cols.get(channel_index).map(Vec::as_slice)
+    }
 }
 
 /// A channel selected for visualization on the chart

src/ui/chart.rs

@@ -851,35 +851,75 @@ impl UltraLogApp {
         channel_index: usize,
         viewport: Option<(f64, f64)>,
     ) -> Option<Vec<[f64; 2]>> {
+        // Resolve min/max first so the mutable borrow on the cache ends before
+        // we take immutable borrows on the channel data below.
+        let (min_y, max_y) = self
+            .get_channel_min_max(file_index, channel_index)
+            .unwrap_or((0.0, 1.0));
+
         let file = self.files.get(file_index)?;
         let times = file.log.get_times_as_f64();
-        let data = self.get_channel_data(file_index, channel_index);
+        let data = self.get_channel_data_ref(file_index, channel_index);
         if times.is_empty() || times.len() != data.len() {
             return None;
         }
 
-        let (lo, hi) = match viewport {
+        let full_lttb = || Self::downsample_lttb(times, data, MAX_CHART_POINTS);
+        let downsampled = match viewport {
             Some((vmin, vmax)) if vmax > vmin => {
+                // Anchored min/max-per-bucket downsampling. Bucket
+                // boundaries are at multiples of `bucket_size` from t=0,
+                // so during cursor-tracked playback samples slide through
+                // a fixed grid instead of being re-bucketed every frame.
+                // Without this anchoring, LTTB-by-index re-selects a
+                // different "best peak" per frame and the curve jitters
+                // at far zoom-out.
                 let pad = (vmax - vmin) * 0.1;
-                let lo_t = vmin - pad;
-                let hi_t = vmax + pad;
-                let lo_i = times.partition_point(|&t| t < lo_t).saturating_sub(1);
-                let hi_i = times
-                    .partition_point(|&t| t <= hi_t)
-                    .saturating_add(1)
-                    .min(times.len());
-                (lo_i, hi_i.max(lo_i + 1))
+                let padded_span = (vmax - vmin) + 2.0 * pad;
+                let n_buckets = (MAX_CHART_POINTS / 2).max(1);
+                let bucket_size = padded_span / n_buckets as f64;
+                if bucket_size <= 0.0 {
+                    full_lttb()
+                } else {
+                    let raw_lo = vmin - pad;
+                    let k_lo = (raw_lo / bucket_size).floor() as i64;
+                    let mut points: Vec<[f64; 2]> = Vec::with_capacity(MAX_CHART_POINTS);
+                    let mut idx = times.partition_point(|&t| t < k_lo as f64 * bucket_size);
+                    for k in 0..n_buckets as i64 {
+                        let bucket_end = (k_lo + k + 1) as f64 * bucket_size;
+                        let mut end_idx = idx;
+                        while end_idx < times.len() && times[end_idx] < bucket_end {
+                            end_idx += 1;
+                        }
+                        if end_idx > idx {
+                            let mut min_i = idx;
+                            let mut max_i = idx;
+                            for i in idx..end_idx {
+                                if data[i] < data[min_i] {
+                                    min_i = i;
+                                }
+                                if data[i] > data[max_i] {
+                                    max_i = i;
+                                }
+                            }
+                            if min_i == max_i {
+                                points.push([times[min_i], data[min_i]]);
+                            } else if min_i < max_i {
+                                points.push([times[min_i], data[min_i]]);
+                                points.push([times[max_i], data[max_i]]);
+                            } else {
+                                points.push([times[max_i], data[max_i]]);
+                                points.push([times[min_i], data[min_i]]);
+                            }
+                        }
+                        idx = end_idx;
+                    }
+                    points
+                }
             }
-            _ => (0, times.len()),
+            _ => full_lttb(),
         };
 
-        let times_slice = &times[lo..hi];
-        let data_slice = &data[lo..hi];
-        let downsampled = Self::downsample_lttb(times_slice, data_slice, MAX_CHART_POINTS);
-
-        let (min_y, max_y) = self
-            .get_channel_min_max(file_index, channel_index)
-            .unwrap_or((0.0, 1.0));
         let range = (max_y - min_y).abs();
         // Constant channels (range ≈ 0) get parked at the middle of the
         // overlay strip so they remain visible instead of pinning to the