// Render a single arc-length-normalized time series to `ret` function renderSingleSeries( x0, ys, options, xScale, yScale, { tmpBuf: tmp, tmpSums: sums, tmpMinY: minY, tmpMaxY: maxY }, ret ) { let { xBins, yBins, arcLengthNormalize } = options; if (ys.length < 2) return ret; let { max, min } = Math; let prevX = xScale(x0); let prevY = yScale(ys[0]); // prepare our temporary buffers tmp.fill(0); sums.fill(0); minY.fill(yBins - 1); maxY.fill(0); // render all interpolated lines (between adjacent points) to the temp canvas // note: the current bresenham implementation assumes integer coordinates. let curInBounds = 0 <= prevX && prevX < xBins && 0 <= prevY && prevY < yBins; let prevInBounds; for (let i = 1; i < ys.length; i++) { let curX = xScale(x0 + i); let curY = yScale(ys[i]); // perf todo: this could apply a constant increment? // this bounds check prevents rendering NaN values as well as datapoints out of bounds prevInBounds = curInBounds; curInBounds = 0 <= curX && curX < xBins && 0 <= curY && curY < yBins; let inBounds = prevInBounds || curInBounds; if (inBounds || nonnegative(prevY) != nonnegative(curY)) { plotLine(prevX, prevY, curX, curY, (x, y) => { // plot only in-bounds pixels if (0 <= x && x < xBins && 0 <= y && y < yBins) { sums[x] += tmp[yBins * x + y] == 0; tmp[yBins * x + y] = 1; minY[x] = min(minY[x], y); maxY[x] = max(maxY[x], y); } }); } prevX = curX; prevY = curY; } // normalize the temp canvas by column sums and add to ret canvas for (let x = 0; x < xBins; x++) { let sum = sums[x]; if (sum > 0) { let scale = arcLengthNormalize ? 1 / sum : 1; let lo = yBins * x + minY[x]; let hi = yBins * x + maxY[x] + 1; for (let i = lo; i < hi; i++) ret[i] += tmp[i] * scale; } } return ret; }