Function downsampleTimeWindow

app/src/DSP.h:1152–1227

* @brief Decimate the visible [xLo, xHi] slice of a monotonic time ring to render * columns. Times rebase so the newest sample sits at 0 (axis [-T, 0]); monotonic * time resolves the window as two binary searches and the slice is walked once. * Buckets sit on an absolute newest-anchored column-width lattice (shimmer fix). */

 *        Buckets sit on an absolute newest-anchored column-width lattice (shimmer fix).
 */
inline bool downsampleTimeWindow(const AxisData& timeX,
                                 const AxisData& valueY,
                                 ssfp_t xLo,
                                 ssfp_t xHi,
                                 int w,
                                 int h,
                                 QList<QPointF>& out,
                                 DownsampleWorkspace* ws)
{
  out.clear();
  const std::size_t n = std::min<std::size_t>(timeX.size(), valueY.size());
  if (n == 0 || w <= 0 || h <= 0 || !(xLo < xHi))
    return true;

  std::size_t xn0, xn1, yn0, yn1;
  const ssfp_t *xp0, *xp1, *yp0, *yp1;
  spanFromFixedQueue(timeX, xp0, xn0, xp1, xn1);
  spanFromFixedQueue(valueY, yp0, yn0, yp1, yn1);

  auto xAbs = [&](std::size_t i) -> ssfp_t {
    return (i < xn0) ? xp0[i] : xp1[i - xn0];
  };
  auto yAt = [&](std::size_t i) -> ssfp_t {
    return (i < yn0) ? yp0[i] : yp1[i - yn0];
  };

  const ssfp_t newest = xAbs(n - 1);
  auto tRel           = [&](std::size_t i) -> ssfp_t {
    return xAbs(i) - newest;
  };

  const std::size_t lo = dsLowerBound(n, xAbs, xLo + newest);
  const std::size_t hi = dsUpperBound(n, xAbs, xHi + newest);

  const std::size_t visible = (hi > lo) ? (hi - lo) : 0;
  if (visible == 0)
    return true;

  auto xWin = [&](std::size_t i) -> ssfp_t {
    return tRel(lo + i);
  };
  auto yWin = [&](std::size_t i) -> ssfp_t {
    return yAt(lo + i);
  };

  const std::size_t C = std::size_t(w);
  ws->reset(C);

  const ssfp_t span        = std::max<ssfp_t>(1e-12, xHi - xLo);
  const auto scaleX        = static_cast<ssfp_t>(w - 1) / span;
  const ssfp_t colWidth    = span / static_cast<ssfp_t>(std::max(1, w - 1));
  const ssfp_t anchorShift = newest - std::floor(newest / colWidth) * colWidth;

  auto xBkt = [&](std::size_t i) -> ssfp_t {
    return tRel(lo + i) + anchorShift;
  };

  dsAccumulateBuckets(visible, w, xLo, scaleX, xBkt, yWin, ws);