Function downsampleMonotonic

app/src/DSP.h:1081–1135

* @brief Downsample a 2D series (X,Y) into screen-space pixels, preserving extremes. * X must be monotonic non-decreasing: the X bounds come from the finite * endpoints and the Y bounds from the filled columns, so the samples are * walked once (bucket accumulation) instead of twice. */

 *        walked once (bucket accumulation) instead of twice.
 */
inline bool downsampleMonotonic(
  const AxisData& X, const AxisData& Y, int w, int h, QList<QPointF>& out, DownsampleWorkspace* ws)
{
  out.clear();
  const std::size_t n = std::min<std::size_t>(X.size(), Y.size());
  if (n == 0 || w <= 0 || h <= 0)
    return true;

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

  auto xAt = [&](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];
  };

  std::size_t firstFinite = 0;
  std::size_t lastFinite  = 0;
  if (!dsFiniteEnds(n, xAt, yAt, firstFinite, lastFinite))
    return false;

  const ssfp_t xmin = xAt(firstFinite);
  const ssfp_t xmax = xAt(lastFinite);
  if (!(xmin < xmax)) {
    dsEmitSteppedFallback(n, w, firstFinite, lastFinite, xAt, yAt, out);
    return true;
  }

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

  const auto scaleX = static_cast<ssfp_t>(w - 1) / std::max(1e-12, xmax - xmin);
  dsAccumulateBuckets(n, w, xmin, scaleX, xAt, yAt, ws);

  ssfp_t ymin = 0;
  ssfp_t ymax = 0;
  if (!dsColumnYBounds(ws, C, ymin, ymax))
    return false;

  const auto scaleY = static_cast<ssfp_t>(h) / std::max(1e-12, ymax - ymin);

  out.reserve(w * 3 / 2 + 8);
  for (std::size_t c = 0; c < C; ++c) {
    if (ws->cnt[c] == 0)
      continue;

    dsEmitColumnPoints(c, scaleY, ws, xAt, yAt, out);
  }

  return true;
}

/**
 * @brief Downsample a LineSeries (paired X and Y AxisData) for rendering.