Function lttbIndicesForDataPoints

src/data/lttbSample.ts:88–172

(data: ReadonlyArray<DataPoint>, targetPoints: number)

}

function lttbIndicesForDataPoints(data: ReadonlyArray<DataPoint>, targetPoints: number): Int32Array {
  const n = data.length;
  const lastIndex = n - 1;

  if (targetPoints <= 0 || n === 0) return new Int32Array(0);
  if (targetPoints === 1) return new Int32Array([0]);
  if (targetPoints === 2) return n >= 2 ? new Int32Array([0, lastIndex]) : new Int32Array([0]);
  if (n <= targetPoints) {
    const indices = new Int32Array(n);
    for (let i = 0; i < n; i++) indices[i] = i;
    return indices;
  }

  const indices = new Int32Array(targetPoints);
  indices[0] = 0;
  indices[targetPoints - 1] = lastIndex;

  const bucketSize = (n - 2) / (targetPoints - 2);

  let a = 0;
  let out = 1;

  const pLast = data[lastIndex]!;
  const lastX = isTupleDataPoint(pLast) ? pLast[0] : pLast.x;
  const lastY = isTupleDataPoint(pLast) ? pLast[1] : pLast.y;

  for (let bucket = 0; bucket < targetPoints - 2; bucket++) {
    // Current bucket: candidate points are [rangeStart, rangeEndExclusive) and never include lastIndex.
    let rangeStart = Math.floor(bucketSize * bucket) + 1;
    let rangeEndExclusive = Math.min(Math.floor(bucketSize * (bucket + 1)) + 1, lastIndex);
    if (rangeStart >= rangeEndExclusive) {
      // Defensive: ensure at least one candidate point.
      rangeStart = Math.min(rangeStart, lastIndex - 1);
      rangeEndExclusive = Math.min(rangeStart + 1, lastIndex);
    }

    // Next bucket for average: [nextRangeStart, nextRangeEndExclusive)
    const nextRangeStart = Math.floor(bucketSize * (bucket + 1)) + 1;
    const nextRangeEndExclusive = Math.min(Math.floor(bucketSize * (bucket + 2)) + 1, lastIndex);

    // If there are no points in the next bucket, use the last point as the average.
    let avgX = lastX;
    let avgY = lastY;
    if (nextRangeStart < nextRangeEndExclusive) {
      let sumX = 0;
      let sumY = 0;
      let avgCount = 0;
      for (let i = nextRangeStart; i < nextRangeEndExclusive; i++) {
        const p = data[i]!;
        const x = isTupleDataPoint(p) ? p[0] : p.x;
        const y = isTupleDataPoint(p) ? p[1] : p.y;
        sumX += x;
        sumY += y;
        avgCount++;
      }
      if (avgCount > 0) {
        avgX = sumX / avgCount;
        avgY = sumY / avgCount;