Use binary search for interpolations

[kurkle]

Closes: #4246

master
pr

[kurkle]

Master is not that bad now, because #6953 was already merged :)

[benmccann]

I don't understand why this is returning two items. Shouldn't the data be located just at one index? It seems like handler could be called extra times and after the time scale is split we may not need the "lo" and "hi" concept but then still be using it here

[kurkle]

Event at the black dot, those highlighted indices are returned. This is not strictly needed here, but the cost is insignificant.

[kurkle]

With caching of dimensions:

var start = Date.now();
var rect = chart.canvas.getBoundingClientRect();
for (var i = 0; i < 100000; i++) {
	var ix = Math.round(Math.random() * 55549);
	var point = chart._metasets[0].data[ix];
	var event = {
		type: 'mousemove',
		target: chart.canvas,
		clientX: rect.left + point.x,
		clientY: rect.top + point.y,
		cancelable: true,
		bubbles: true,
		view: window
	};
	chart.getElementsAtEventForMode(event, 'nearest', {intersect: false, axis: 'x'});
}
console.log(Date.now() - start);

master: ~750ms
pr: ~370ms

[benmccann]

I just realized this might not technically be correct (eventhough I introduced it). Imagine you have very large points that are all overlapping with the given position. Just returning the items at the nearest index might not be enough because there could be elements at several indices that are all intersecting with the given point

[kurkle]

Thats right, index and (plain) coordinate based determination can both be wrong.
I'll remove the intersect optimization for now.
This case needs the generalized, will do that in another pr.
This case could be optimized using ranged lookup, but would need maximum radius/dimension on the axis direction of the elements to know how large range needs to be handled.

Something like:

let range = determineMaxSizeOfElementsForAxis(axis);
const start = lookup(data, axis, position[axis] - range);
const end  = lookup(data, axis, position[axis] + range);
const startIndex = start.loIndex || start.hiIndex;
const endIndex = end.hiIndex || end.loIndex;
for(let i = startIndex; i <= endIndex; ++i) {
  handler(data[i], index, i);
}

[kurkle]

Ok, ready for review again.

• Removed the caching, because its not that simple. Deserves its own PR.
• If elements share options, use binarySearch for intersect mode too (other conditions still apllying)
  • assuming the size of the elements is consistent with shared options.

Timing: ~950ms (master is still ~750ms)

Change mode to 'linear', and reduce loop count to 1000 (so it completes in master):
pr: 21ms
master: ~6000ms (a lot of variation)

[kurkle]

Reverse mode was not working, so fixed that.
https://plnkr.co/edit/PpmJrvIakA01hzgbnwQq?p=preview