Function lttbIndicesForInterleavedXY

src/data/lttbSample.ts:8–86

(data: Float32Array, targetPoints: number)

}

function lttbIndicesForInterleavedXY(data: Float32Array, targetPoints: number): Int32Array {
  const n = data.length >>> 1; // floor(length / 2)
  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 lastX = data[lastIndex * 2 + 0];
  const lastY = data[lastIndex * 2 + 1];

  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++) {
        sumX += data[i * 2 + 0];
        sumY += data[i * 2 + 1];
        avgCount++;
      }
      if (avgCount > 0) {
        avgX = sumX / avgCount;
        avgY = sumY / avgCount;
      }
    }

    const ax = data[a * 2 + 0];