highcharts 6.1.1 → 6.2.0

package/es-modules/modules/boost.src.js

@@ -271,6 +271,7 @@ var win = H.win,
     Series = H.Series,
     seriesTypes = H.seriesTypes,
     each = H.each,
+    objEach = H.objectEach,
     extend = H.extend,
     addEvent = H.addEvent,
     fireEvent = H.fireEvent,
@@ -502,6 +503,12 @@ function shouldForceChartSeriesBoosting(chart) {
 
             series = chart.series[i];
 
+            // Don't count series with boostThreshold set to 0
+            // See #8950
+            if (series.options.boostThreshold === 0) {
+                continue;
+            }
+
             if (boostableMap[series.type]) {
                 ++canBoostCount;
             }
@@ -517,20 +524,37 @@ function shouldForceChartSeriesBoosting(chart) {
         }
     }
 
-    chart.boostForceChartBoost =
+    chart.boostForceChartBoost = allowBoostForce && (
         (
-            allowBoostForce &&
             canBoostCount === chart.series.length &&
             sboostCount > 0
         ) ||
-        sboostCount > 5;
+        sboostCount > 5
+    );
 
     return chart.boostForceChartBoost;
 }
 
+/**
+ * Return true if ths boost.enabled option is true
+ * @param  {Highcharts.Chart} chart The chart
+ * @return {boolean}
+ */
+function boostEnabled(chart) {
+    return pick(
+        (
+            chart &&
+            chart.options &&
+            chart.options.boost &&
+            chart.options.boost.enabled
+        ),
+        true
+    );
+}
+
 /*
  * Returns true if the chart is in series boost mode
- * @param chart {Highchart.Chart} - the chart to check
+ * @param chart {Highcharts.Chart} - the chart to check
  * @returns {Boolean} - true if the chart is in series boost mode
  */
 Chart.prototype.isChartSeriesBoosting = function () {
@@ -801,9 +825,20 @@ function GLShader(gl) {
         // Uniform for invertion
         isInverted,
         plotHeightUniform,
+        // Error stack
+        errors = [],
         // Texture uniform
         uSamplerUniform;
 
+    /*
+     * Handle errors accumulated in errors stack
+     */
+    function handleErrors() {
+        if (errors.length) {
+            H.error('[highcharts boost] shader error - ' + errors.join('\n'));
+        }
+    }
+
     /* String to shader program
      * @param {string} str - the program source
      * @param {string} type - the program type: either `vertex` or `fragment`
@@ -818,7 +853,13 @@ function GLShader(gl) {
         gl.compileShader(shader);
 
         if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
-            // console.error('shader error:', gl.getShaderInfoLog(shader));
+            errors.push(
+                'when compiling ' +
+                type +
+                ' shader:\n' +
+                gl.getShaderInfoLog(shader)
+            );
+
             return false;
         }
         return shader;
@@ -835,7 +876,7 @@ function GLShader(gl) {
 
         if (!v || !f) {
             shaderProgram = false;
-            // console.error('error creating shader program');
+            handleErrors();
             return false;
         }
 
@@ -847,8 +888,16 @@ function GLShader(gl) {
 
         gl.attachShader(shaderProgram, v);
         gl.attachShader(shaderProgram, f);
+
         gl.linkProgram(shaderProgram);
 
+        if (!gl.getProgramParameter(shaderProgram, gl.LINK_STATUS)) {
+            errors.push(gl.getProgramInfoLog(shaderProgram));
+            handleErrors();
+            shaderProgram = false;
+            return false;
+        }
+
         gl.useProgram(shaderProgram);
 
         gl.bindAttribLocation(shaderProgram, 0, 'aVertexPosition');
@@ -864,6 +913,7 @@ function GLShader(gl) {
         isCircleUniform = uloc('isCircle');
         isInverted = uloc('isInverted');
         plotHeightUniform = uloc('plotHeight');
+
         return true;
     }
 
@@ -871,11 +921,9 @@ function GLShader(gl) {
      * Destroy the shader
      */
     function destroy() {
-        if (gl) {
-            if (shaderProgram) {
-                gl.deleteProgram(shaderProgram);
-                shaderProgram = false;
-            }
+        if (gl && shaderProgram) {
+            gl.deleteProgram(shaderProgram);
+            shaderProgram = false;
         }
     }
 
@@ -885,7 +933,9 @@ function GLShader(gl) {
      * or until 0 is bound.
      */
     function bind() {
-        gl.useProgram(shaderProgram);
+        if (gl && shaderProgram) {
+            gl.useProgram(shaderProgram);
+        }
     }
 
     /*
@@ -895,17 +945,24 @@ function GLShader(gl) {
      * @param val {float} - the value to set
      */
     function setUniform(name, val) {
-        var u = uLocations[name] = uLocations[name] ||
-                                    gl.getUniformLocation(shaderProgram, name);
-        gl.uniform1f(u, val);
+        if (gl && shaderProgram) {
+            var u = uLocations[name] = uLocations[name] ||
+                                       gl.getUniformLocation(
+                                          shaderProgram,
+                                          name
+                                       );
+            gl.uniform1f(u, val);
+        }
     }
 
     /*
      * Set the active texture
      * @param texture - the texture
      */
-    function setTexture() {
-        gl.uniform1i(uSamplerUniform, 0);
+    function setTexture(texture) {
+        if (gl && shaderProgram) {
+            gl.uniform1i(uSamplerUniform, texture);
+        }
     }
 
     /*
@@ -913,26 +970,34 @@ function GLShader(gl) {
      * @flag is the state
      */
     function setInverted(flag) {
-        gl.uniform1i(isInverted, flag);
+        if (gl && shaderProgram) {
+            gl.uniform1i(isInverted, flag);
+        }
     }
 
     /*
      * Enable/disable circle drawing
      */
     function setDrawAsCircle(flag) {
-        gl.uniform1i(isCircleUniform, flag ? 1 : 0);
+        if (gl && shaderProgram) {
+            gl.uniform1i(isCircleUniform, flag ? 1 : 0);
+        }
     }
 
     function setPlotHeight(n) {
-        gl.uniform1f(plotHeightUniform, n);
+        if (gl && shaderProgram) {
+            gl.uniform1f(plotHeightUniform, n);
+        }
     }
 
     /*
      * Flush
      */
     function reset() {
-        gl.uniform1i(isBubbleUniform, 0);
-        gl.uniform1i(isCircleUniform, 0);
+        if (gl && shaderProgram) {
+            gl.uniform1i(isBubbleUniform, 0);
+            gl.uniform1i(isCircleUniform, 0);
+        }
     }
 
     /*
@@ -944,7 +1009,7 @@ function GLShader(gl) {
             zMin = Number.MAX_VALUE,
             zMax = -Number.MAX_VALUE;
 
-        if (series.type === 'bubble') {
+        if (gl && shaderProgram && series.type === 'bubble') {
             zMin = pick(seriesOptions.zMin, Math.min(
                 zMin,
                 Math.max(
@@ -980,20 +1045,24 @@ function GLShader(gl) {
      * @param color {Array<float>} - an array with RGBA values
      */
     function setColor(color) {
-        gl.uniform4f(
-            fillColorUniform,
-            color[0] / 255.0,
-            color[1] / 255.0,
-            color[2] / 255.0,
-            color[3]
-        );
+        if (gl && shaderProgram) {
+            gl.uniform4f(
+                fillColorUniform,
+                color[0] / 255.0,
+                color[1] / 255.0,
+                color[2] / 255.0,
+                color[3]
+            );
+        }
     }
 
     /*
      * Set skip translation
      */
     function setSkipTranslation(flag) {
-        gl.uniform1i(skipTranslationUniform, flag === true ? 1 : 0);
+        if (gl && shaderProgram) {
+            gl.uniform1i(skipTranslationUniform, flag === true ? 1 : 0);
+        }
     }
 
     /*
@@ -1001,7 +1070,9 @@ function GLShader(gl) {
      * @param m {Matrix4x4} - the matrix
      */
     function setPMatrix(m) {
-        gl.uniformMatrix4fv(pUniform, false, m);
+        if (gl && shaderProgram) {
+            gl.uniformMatrix4fv(pUniform, false, m);
+        }
     }
 
     /*
@@ -1009,7 +1080,9 @@ function GLShader(gl) {
      * @param p {float} - point size
      */
     function setPointSize(p) {
-        gl.uniform1f(psUniform, p);
+        if (gl && shaderProgram) {
+            gl.uniform1f(psUniform, p);
+        }
     }
 
     /*
@@ -1021,7 +1094,9 @@ function GLShader(gl) {
     }
 
     if (gl) {
-        createShader();
+        if (!createShader()) {
+            return false;
+        }
     }
 
     return {
@@ -1233,20 +1308,16 @@ function GLRenderer(postRenderCallback) {
         data = false,
         // The marker data
         markerData = false,
-        // Is the texture ready?
-        textureIsReady = false,
         // Exports
         exports = {},
         // Is it inited?
         isInited = false,
         // The series stack
         series = [],
-        // Texture for circles
-        circleTexture = doc.createElement('canvas'),
-        // Context for circle texture
-        circleCtx = circleTexture.getContext('2d'),
-        // Handle for the circle texture
-        circleTextureHandle,
+
+        // Texture handles
+        textureHandles = {},
+
         // Things to draw as "rectangles" (i.e lines)
         asBar = {
             'column': true,
@@ -1420,10 +1491,11 @@ function GLRenderer(postRenderCallback) {
             color,
             scolor,
             sdata = isStacked ? series.data : (xData || rawData),
-            closestLeft = { x: -Number.MAX_VALUE, y: 0 },
-            closestRight = { x: Number.MIN_VALUE, y: 0 },
+            closestLeft = { x: Number.MAX_VALUE, y: 0 },
+            closestRight = { x: -Number.MAX_VALUE, y: 0 },
 
             skipped = 0,
+            hadPoints = false,
 
             cullXThreshold = 1,
             cullYThreshold = 1,
@@ -1444,7 +1516,8 @@ function GLRenderer(postRenderCallback) {
             pcolor = false,
             drawAsBar = asBar[series.type],
             isXInside = false,
-            isYInside = true;
+            isYInside = true,
+            threshold = options.threshold;
 
         if (options.boostData && options.boostData.length > 0) {
             return;
@@ -1752,7 +1825,7 @@ function GLRenderer(postRenderCallback) {
                 closestRight.y = y;
             }
 
-            if (x < xMin && closestLeft.x < xMin) {
+            if (x < xMin && closestLeft.x > xMin) {
                 closestLeft.x = x;
                 closestLeft.y = y;
             }
@@ -1762,7 +1835,7 @@ function GLRenderer(postRenderCallback) {
             }
 
             // Cull points outside the extremes
-            if (y === null || !isYInside) {
+            if (y === null || (!isYInside && !nextInside && !prevInside)) {
                 beginSegment();
                 continue;
             }
@@ -1788,6 +1861,13 @@ function GLRenderer(postRenderCallback) {
                 }
 
                 if (x > plotWidth) {
+                    // If this is  rendered as a point, just skip drawing it
+                    // entirely, as we're not dependandt on lineTo'ing to it.
+                    // See #8197
+                    if (inst.drawMode === 'points') {
+                        continue;
+                    }
+
                     x = plotWidth;
                 }
 
@@ -1806,6 +1886,9 @@ function GLRenderer(postRenderCallback) {
                     }
                 }
 
+                if (!isRange && !isStacked) {
+                    minVal = Math.max(threshold, yMin); // #8731
+                }
                 if (!settings.useGPUTranslations) {
                     minVal = yAxis.toPixels(minVal, true);
                 }
@@ -1843,7 +1926,7 @@ function GLRenderer(postRenderCallback) {
 
             if (!settings.useGPUTranslations &&
                 !settings.usePreallocated &&
-                (lastX && x - lastX < cullXThreshold) &&
+                (lastX && Math.abs(x - lastX) < cullXThreshold) &&
                 (lastY && Math.abs(y - lastY) < cullYThreshold)
             ) {
                 if (settings.debug.showSkipSummary) {
@@ -1887,13 +1970,15 @@ function GLRenderer(postRenderCallback) {
 
             lastX = x;
             lastY = y;
+
+            hadPoints = true;
         }
 
         if (settings.debug.showSkipSummary) {
             console.log('skipped points:', skipped); // eslint-disable-line no-console
         }
 
-        function pushSupplementPoint(point) {
+        function pushSupplementPoint(point, atStart) {
             if (!settings.useGPUTranslations) {
                 inst.skipTranslation = true;
                 point.x = xAxis.toPixels(point.x, true);
@@ -1903,6 +1988,11 @@ function GLRenderer(postRenderCallback) {
             // We should only do this for lines, and we should ignore markers
             // since there's no point here that would have a marker.
 
+            if (atStart) {
+                data = [point.x, point.y, 0, 2].concat(data);
+                return;
+            }
+
             vertice(
                 point.x,
                 point.y,
@@ -1911,13 +2001,19 @@ function GLRenderer(postRenderCallback) {
             );
         }
 
-        if (!lastX &&
+        if (
+            !hadPoints &&
             connectNulls !== false &&
-            closestLeft > -Number.MAX_VALUE &&
-            closestRight < Number.MAX_VALUE) {
-            // There are no points within the selected range
-            pushSupplementPoint(closestLeft);
-            pushSupplementPoint(closestRight);
+            series.drawMode === 'line_strip'
+        ) {
+            if (closestLeft.x < Number.MAX_VALUE) {
+                // We actually need to push this *before* the complete buffer.
+                pushSupplementPoint(closestLeft, true);
+            }
+
+            if (closestRight.x > -Number.MAX_VALUE) {
+                pushSupplementPoint(closestRight);
+            }
         }
 
         closeSegment();
@@ -2056,7 +2152,7 @@ function GLRenderer(postRenderCallback) {
             return false;
         }
 
-        if (!gl || !width || !height) {
+        if (!gl || !width || !height || !shader) {
             return false;
         }
 
@@ -2069,7 +2165,6 @@ function GLRenderer(postRenderCallback) {
 
         shader.bind();
 
-
         gl.viewport(0, 0, width, height);
         shader.setPMatrix(orthoMatrix(width, height));
         shader.setPlotHeight(chart.plotHeight);
@@ -2081,17 +2176,12 @@ function GLRenderer(postRenderCallback) {
         vbuffer.build(exports.data, 'aVertexPosition', 4);
         vbuffer.bind();
 
-        if (textureIsReady) {
-            gl.bindTexture(gl.TEXTURE_2D, circleTextureHandle);
-            shader.setTexture(circleTextureHandle);
-        }
-
         shader.setInverted(chart.inverted);
 
-
         // Render the series
         each(series, function (s, si) {
             var options = s.series.options,
+                shapeOptions = options.marker,
                 sindex,
                 lineWidth = typeof options.lineWidth !== 'undefined' ?
                     options.lineWidth :
@@ -2112,8 +2202,23 @@ function GLRenderer(postRenderCallback) {
                             ) || 10)
                 ),
                 fillColor,
+                shapeTexture = textureHandles[
+                    (shapeOptions && shapeOptions.symbol) || s.series.symbol
+                ] || textureHandles.circle,
                 color;
 
+            if (
+                s.segments.length === 0 ||
+                (s.segmentslength && s.segments[0].from === s.segments[0].to)
+            ) {
+                return;
+            }
+
+            if (shapeTexture.isReady) {
+                gl.bindTexture(gl.TEXTURE_2D, shapeTexture.handle);
+                shader.setTexture(shapeTexture.handle);
+            }
+
             
             fillColor =
                 (s.series.pointAttribs && s.series.pointAttribs().fill) ||
@@ -2197,7 +2302,7 @@ function GLRenderer(postRenderCallback) {
             }
 
             shader.setDrawAsCircle(
-                (asCircle[s.series.type] && textureIsReady) || false
+                asCircle[s.series.type] || false
             );
 
             // Do the actual rendering
@@ -2270,8 +2375,8 @@ function GLRenderer(postRenderCallback) {
      * @param h {Integer} - the height of the viewport
      */
     function setSize(w, h) {
-        // Skip if there's no change
-        if (width === w && h === h) {
+        // Skip if there's no change, or if we have no valid shader
+        if ((width === w && h === h) || !shader) {
             return;
         }
 
@@ -2330,71 +2435,127 @@ function GLRenderer(postRenderCallback) {
         gl.depthFunc(gl.LESS);
 
         shader = GLShader(gl); // eslint-disable-line new-cap
+
+        if (!shader) {
+            // We need to abort, there's no shader context
+            return false;
+        }
+
         vbuffer = GLVertexBuffer(gl, shader); // eslint-disable-line new-cap
 
-        textureIsReady = false;
+        function createTexture(name, fn) {
+            var props = {
+                    isReady: false,
+                    texture: doc.createElement('canvas'),
+                    handle: gl.createTexture()
+                },
+                ctx = props.texture.getContext('2d');
 
-        // Set up the circle texture used for bubbles
-        circleTextureHandle = gl.createTexture();
+            textureHandles[name] = props;
 
-        // Draw the circle
-        circleTexture.width = 512;
-        circleTexture.height = 512;
+            props.texture.width = 512;
+            props.texture.height = 512;
 
-        circleCtx.mozImageSmoothingEnabled = false;
-        circleCtx.webkitImageSmoothingEnabled = false;
-        circleCtx.msImageSmoothingEnabled = false;
-        circleCtx.imageSmoothingEnabled = false;
+            ctx.mozImageSmoothingEnabled = false;
+            ctx.webkitImageSmoothingEnabled = false;
+            ctx.msImageSmoothingEnabled = false;
+            ctx.imageSmoothingEnabled = false;
 
-        circleCtx.strokeStyle = 'rgba(255, 255, 255, 0)';
-        circleCtx.fillStyle = '#FFF';
+            ctx.strokeStyle = 'rgba(255, 255, 255, 0)';
+            ctx.fillStyle = '#FFF';
 
-        circleCtx.beginPath();
-        circleCtx.arc(256, 256, 256, 0, 2 * Math.PI);
-        circleCtx.stroke();
-        circleCtx.fill();
+            fn(ctx);
 
-        try {
+            try {
 
-            gl.bindTexture(gl.TEXTURE_2D, circleTextureHandle);
-            // gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
+                gl.activeTexture(gl.TEXTURE0);
+                gl.bindTexture(gl.TEXTURE_2D, props.handle);
+                // gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
 
-            gl.texImage2D(
-                gl.TEXTURE_2D,
-                0,
-                gl.RGBA,
-                gl.RGBA,
-                gl.UNSIGNED_BYTE,
-                circleTexture
-            );
+                gl.texImage2D(
+                    gl.TEXTURE_2D,
+                    0,
+                    gl.RGBA,
+                    gl.RGBA,
+                    gl.UNSIGNED_BYTE,
+                    props.texture
+                );
 
-            gl.texParameteri(
-                gl.TEXTURE_2D,
-                gl.TEXTURE_WRAP_S,
-                gl.CLAMP_TO_EDGE
-            );
-            gl.texParameteri(
-                gl.TEXTURE_2D,
-                gl.TEXTURE_WRAP_T,
-                gl.CLAMP_TO_EDGE
-            );
-            gl.texParameteri(
-                gl.TEXTURE_2D,
-                gl.TEXTURE_MAG_FILTER,
-                gl.LINEAR
-            );
-            gl.texParameteri(
-                gl.TEXTURE_2D,
-                gl.TEXTURE_MIN_FILTER,
-                gl.LINEAR
-            );
+                gl.texParameteri(
+                    gl.TEXTURE_2D,
+                    gl.TEXTURE_WRAP_S,
+                    gl.CLAMP_TO_EDGE
+                );
+
+                gl.texParameteri(
+                    gl.TEXTURE_2D,
+                    gl.TEXTURE_WRAP_T,
+                    gl.CLAMP_TO_EDGE
+                );
+
+                gl.texParameteri(
+                    gl.TEXTURE_2D,
+                    gl.TEXTURE_MAG_FILTER,
+                    gl.LINEAR
+                );
+
+                gl.texParameteri(
+                    gl.TEXTURE_2D,
+                    gl.TEXTURE_MIN_FILTER,
+                    gl.LINEAR
+                );
 
-            // gl.generateMipmap(gl.TEXTURE_2D);
+                // gl.generateMipmap(gl.TEXTURE_2D);
 
-            gl.bindTexture(gl.TEXTURE_2D, null);
+                gl.bindTexture(gl.TEXTURE_2D, null);
 
-            textureIsReady = true;
-        } catch (e) {}
+                props.isReady = true;
+            } catch (e) {}
+        }
+
+        // Circle shape
+        createTexture('circle', function (ctx) {
+            ctx.beginPath();
+            ctx.arc(256, 256, 256, 0, 2 * Math.PI);
+            ctx.stroke();
+            ctx.fill();
+        });
+
+        // Square shape
+        createTexture('square', function (ctx) {
+            ctx.fillRect(0, 0, 512, 512);
+        });
+
+        // Diamond shape
+        createTexture('diamond', function (ctx) {
+            ctx.beginPath();
+            ctx.moveTo(256, 0);
+            ctx.lineTo(512, 256);
+            ctx.lineTo(256, 512);
+            ctx.lineTo(0, 256);
+            ctx.lineTo(256, 0);
+            ctx.fill();
+        });
+
+        // Triangle shape
+        createTexture('triangle', function (ctx) {
+            ctx.beginPath();
+            ctx.moveTo(0, 512);
+            ctx.lineTo(256, 0);
+            ctx.lineTo(512, 512);
+            ctx.lineTo(0, 512);
+            ctx.fill();
+        });
+
+        // Triangle shape (rotated)
+        createTexture('triangle-down', function (ctx) {
+            ctx.beginPath();
+            ctx.moveTo(0, 0);
+            ctx.lineTo(256, 512);
+            ctx.lineTo(512, 0);
+            ctx.lineTo(0, 0);
+            ctx.fill();
+        });
 
         isInited = true;
 
@@ -2426,9 +2587,13 @@ function GLRenderer(postRenderCallback) {
         vbuffer.destroy();
         shader.destroy();
         if (gl) {
-            if (circleTextureHandle) {
-                gl.deleteTexture(circleTextureHandle);
-            }
+
+            objEach(textureHandles, function (key) {
+                if (textureHandles[key].handle) {
+                    gl.deleteTexture(textureHandles[key].handle);
+                }
+            });
+
             gl.canvas.width = 1;
             gl.canvas.height = 1;
         }
@@ -2600,7 +2765,13 @@ function createAndAttachRenderer(chart, series) {
 
         }); // eslint-disable-line new-cap
 
-        target.ogl.init(target.canvas);
+        if (!target.ogl.init(target.canvas)) {
+            // The OGL renderer couldn't be inited.
+            // This likely means a shader error as we wouldn't get to this point
+            // if there was no WebGL support.
+            H.error('[highcharts boost] - unable to init WebGL renderer');
+        }
+
         // target.ogl.clear();
         target.ogl.setOptions(chart.options.boost || {});
 
@@ -2790,24 +2961,16 @@ each([
 ], function (method) {
     function branch(proceed) {
         var letItPass = this.options.stacking &&
-                        (method === 'translate' || method === 'generatePoints'),
-            enabled = pick(
-                (
-                    this.chart &&
-                    this.chart.options &&
-                    this.chart.options.boost &&
-                    this.chart.options.boost.enabled
-                ),
-                true
-            );
+            (method === 'translate' || method === 'generatePoints');
 
         if (
             !this.isSeriesBoosting ||
             letItPass ||
-            !enabled ||
+            !boostEnabled(this.chart) ||
             this.type === 'heatmap' ||
             this.type === 'treemap' ||
-            !boostableMap[this.type]
+            !boostableMap[this.type] ||
+            this.options.boostThreshold === 0
         ) {
 
             proceed.call(this);
@@ -2852,7 +3015,7 @@ wrap(Series.prototype, 'processData', function (proceed) {
         );
     }
 
-    if (boostableMap[this.type]) {
+    if (boostEnabled(this.chart) && boostableMap[this.type]) {
 
         // If there are no extremes given in the options, we also need to
         // process the data to read the data extremes. If this is a heatmap, do
@@ -3096,6 +3259,7 @@ if (!H.hasWebGLSupport()) {
                 minI,
                 maxI,
                 boostOptions,
+                compareX = options.findNearestPointBy === 'x',
 
                 xDataFull = (
                     this.xData ||
@@ -3105,8 +3269,8 @@ if (!H.hasWebGLSupport()) {
                 ),
 
                 addKDPoint = function (clientX, plotY, i) {
-                    // Shaves off about 60ms compared to repeated concatination
-                    index = clientX + ',' + plotY;
+                    // Shaves off about 60ms compared to repeated concatenation
+                    index = compareX ? clientX : clientX + ',' + plotY;
 
                     // The k-d tree requires series points.
                     // Reduce the amount of points, since the time to build the
@@ -3178,7 +3342,6 @@ if (!H.hasWebGLSupport()) {
                 renderer.pushSeries(series);
                 // Perform the actual renderer if we're on series level
                 renderIfNotSeriesBoosting(renderer, this, chart);
-                // console.log(series, chart);
             }
 
             /* This builds the KD-tree */