@corva/ui 0.65.0-0 → 0.65.0-1-test

package/config/highcharts/highcharts-contour.js

@@ -1 +1,792 @@
-import t from"@babel/runtime/helpers/typeof";function e(e){var i=e.getOptions(),r=e.defined,o=e.each,a=e.find,s=e.pick,n=e.extendClass,l=e.merge,p=e.seriesTypes,h=e.wrap;e.perspective;var u=1e-4,c=0;i.plotOptions.contour=l(i.plotOptions.scatter,{marker:{radius:0,fillColor:"#ffffff",states:{hover:{radius:i.plotOptions.scatter.marker.radius}}},states:{hover:{halo:{size:i.plotOptions.scatter.marker.radius+4,attributes:{fill:"#000000"},opacity:.5}}},turboThreshold:0}),p.contour=n(p.heatmap,{type:"contour",hasPointSpecificOptions:!0,getSymbol:p.scatter.prototype.getSymbol,drawPoints:e.Series.prototype.drawPoints,pointClass:e.Point,pointAttribs:e.Series.prototype.pointAttribs,init:function(t){this.is3d=t.is3d&&t.is3d(),this.gradiend_ids={},this.dataFuncState={},p.scatter.prototype.init.apply(this,arguments)},translate:function(){p.scatter.prototype.translate.call(this,arguments),this.translateColors()},dataFunction:function(i){var r=this.options.dataFunction(i);if("number"==typeof r){var a={};return o(this.parallelArrays,(function(t){a[t]="value"===t?r:s(i[t],r)})),a}return"object"===t(r)?e.merge(i,r):null},updateDataIfNecessary:function(){var t=this,i=s(t.options.axis1,"x"),o=s(t.options.axis2,t.is3d?"z":"y"),a=t[i+"Axis"],n=t[o+"Axis"];if(t.options.dataFunction&&r(a.min)&&r(a.max)&&r(n.min)&&r(n.max)){var l=s(a.min,a.options.min),h=s(n.min,n.options.min),u=s(a.max,a.options.max),c=s(n.max,n.options.max),d=s(t.options.grid_width,t.options.grid_height,21),x=s(t.options.grid_height,t.options.grid_width,21),f={dataFunc:t.options.dataFunction,axis1_type:i,axis2_type:o,axis1_min:l,axis1_max:u,axis2_min:h,axis2_max:c,axis1_steps:d,axis2_steps:x},g=e.cleanRecursively(f,t.dataFuncState);if(0!==Object.keys(g).length){t.dataFuncState=f;for(var v=[],m=0;m<x;m++)for(var y=0;y<d;y++){var _={};_[i]=y/(d-1)*(u-l)+l,_[o]=m/(x-1)*(c-h)+h;var A=this.dataFunction(_);v.push(A)}return p.scatter.prototype.setData.call(this,v,!0,!1,!1)}}},bindAxes:function(){this.is3d?(this.axisTypes=["xAxis","yAxis","zAxis","colorAxis"],this.parallelArrays=["x","y","z","value"]):(this.axisTypes=["xAxis","yAxis","colorAxis"],this.parallelArrays=["x","y","value"]),p.scatter.prototype.bindAxes.apply(this,arguments)},drawTriangle:function(t,i,r,o,a,s){var n,l=this,p=this.chart,h=this.chart.renderer,v=t.A,m=t.B,y=t.C,_=[v,m,y];if(r){var A=[this.colorAxis.normalizedValue(v.value),this.colorAxis.normalizedValue(m.value),this.colorAxis.normalizedValue(y.value)],b=Math.max(A[0],A[1],A[2]),w=Math.min(A[0],A[1],A[2]),Y=Math.abs(d(v,m,y));if(b-w<u||Y<u)n=this.colorAxis.toColor((v.value+m.value+y.value)/3);else{var X=new g([[v.plotX,v.plotY,1,A[0]],[m.plotX,m.plotY,1,A[1]],[y.plotX,y.plotY,1,A[2]]]);X.toReducedRowEchelonForm();var k=X.mtx[0][3],z=X.mtx[1][3],S=X.mtx[2][3],M=(0-S)/(k*k+z*z),F=(1-S)/(k*k+z*z),T=x(M*k),C=x(M*z),O=x(F*k),P=x(F*z);if(h.isSVG){var V=t.gradient;V?V.animate({x1:T,y1:C,x2:O,y2:P}):(V=h.createElement("linearGradient"),t.gradient=V,V.add(h.defs),V.attr({id:"contour-gradient-id-"+c++,x1:T,y1:C,x2:O,y2:P})),V.element.setAttributeNS("http://www.w3.org/1999/xlink","xlink:href",this.base_gradient_id),n="url("+h.url+"#"+V.attr("id")+")"}else n={linearGradient:{x1:T,y1:C,x2:O,y2:P,spreadMethod:"pad",gradientUnits:"userSpaceOnUse"},stops:this.colorAxis.stops}}var E=["M",v.plotX,v.plotY,"L",m.plotX,m.plotY,"L",y.plotX,y.plotY,"Z"];t.shape?(t.shape.animate({d:E}).attr({fill:n}),t.shape.parent!=t.group&&t.shape.add(t.group)):(t.shape=h.path(E).attr({"shape-rendering":"crispEdges",fill:n}),t.shape.on("mousemove",(function(i){if(i=p.pointer.normalize(i),p.inverted)var r=p.plotTop+p.plotHeight-i.chartY,o=p.plotLeft+p.plotWidth-i.chartX;else r=i.chartX-p.plotLeft,o=i.chartY-p.plotTop;if(l.options.interpolateTooltip){var a=new g([[v.plotX,v.plotY,1,v.x,v.y,v.z,v.value],[m.plotX,m.plotY,1,m.x,m.y,m.z,m.value],[y.plotX,y.plotY,1,y.x,y.y,y.z,y.value]]);a.toReducedRowEchelonForm();var s={x:f(l.xAxis,a.mtx[0][3]*r+a.mtx[1][3]*o+a.mtx[2][3]),y:f(l.yAxis,a.mtx[0][4]*r+a.mtx[1][4]*o+a.mtx[2][4]),z:f(l.zAxis,a.mtx[0][5]*r+a.mtx[1][5]*o+a.mtx[2][5]),value:a.mtx[0][6]*r+a.mtx[1][6]*o+a.mtx[2][6]};l.options.dataFunction&&(s=l.dataFunction(s));var n=(new e.Point).init(l);n.applyOptions(s);var h=l.data;l.data=[n],l.translate(),l.data=h,p.tooltip.refresh(n,i)}else{var u=function(t){return(t.plotX-r)*(t.plotX-r)+(t.plotY-o)*(t.plotY-o)},c=t.A;u(t.B)<u(c)&&(c=t.B),u(t.C)<u(c)&&(c=t.C),c.onMouseOver(i)}})),t.shape.add(t.group))}else t.shape&&(t.shape.destroy,delete t.shape);var L=t.group.edge_path,j=t.group.edge_path_old;if(o||a){var G=function(t,e,r,o){i[e+"-"+t]?a&&i[t+"-"+e]--:1==i[t+"-"+e]--&&(L.push("M",r.plotX,r.plotY,"L",o.plotX,o.plotY),j.push("M",r.plotX_prev,r.plotY_prev,"L",o.plotX_prev,o.plotY_prev))};G(t.a,t.b,t.A,t.B),G(t.b,t.c,t.B,t.C),G(t.c,t.a,t.C,t.A)}for(var R=0;R<s.length;R++){var B=s[R].axis,Z=s[R].attr;for(var I in B.tickPositions){for(var D=B.tickPositions[I],U=[],N=0;N<3;N++){T=_[N].plotX;var W=_[N].plotX_prev,H=(C=_[N].plotY,_[N].plotY_prev),q=_[N][Z],J=(O=_[(N+1)%3].plotX,_[(N+1)%3].plotX_prev),K=(P=_[(N+1)%3].plotY,_[(N+1)%3].plotY_prev),Q=_[(N+1)%3][Z];if(q!=Q&&D>=Math.min(q,Q)&&D<Math.max(q,Q)){var $=(D-q)/(Q-q);U.push([$*(O-T)+T,$*(P-C)+C,$*(J-W)+W,$*(K-H)+H])}}2==U.length&&(L.push("M",U[0][0],U[0][1],"L",U[1][0],U[1][1]),j.push("M",U[0][2],U[0][3],"L",U[1][2],U[1][3]))}}},assignGroups:function(){for(var t=this,i=0;i<t.triangles.length;i++)t.triangles[i].group_id=t.is3d?i:0;var r={},o=t.groups;for(i=0;i<t.triangles.length;i++){var a=t.triangles[i],s=a.group_id;o[s]?(r[s]=o[s],r[s].zSum=0,r[s].triangle_count=0,delete o[s]):r[s]||(r[s]=t.chart.renderer.g().add(this.surface_group),r[s].zSum=0,r[s].triangle_count=0),t.triangles[i].group=r[s],r[s].zSum+=a.A.plotZ+a.B.plotZ+a.C.plotZ,r[s].triangle_count++}e.objectEach(r,(function(t,e){t.attr({zIndex:-t.zSum/(3*t.triangle_count)})})),e.objectEach(o,(function(t){t.destroy()})),t.groups=r},drawGraph:function(){this.updateDataIfNecessary();var i=this,r=i.points,o=this.options,a=i.chart.renderer;if(i.surface_group||(i.surface_group=a.g().add(i.group),i.triangles=[],i.groups={}),i.chart.renderer.isSVG){for(var n="",l=0;l<this.colorAxis.stops.length;l++)for(var p=0;p<this.colorAxis.stops[l].length;p++)n+=":"+this.colorAxis.stops[l][p];if(!this.gradiend_ids[n]){var h=i.chart.renderer.rect(0,0,1,1).attr({fill:{linearGradient:{x1:0,y1:0,x2:1,y2:0,spreadMethod:"pad",gradientUnits:"userSpaceOnUse"},stops:this.colorAxis.stops}});this.gradiend_ids[n]=/(#.*)[)]/.exec(h.attr("fill"))[1]}this.base_gradient_id=this.gradiend_ids[n]}i.surface_group;var u=0,c={},x=function(t){return t&&"number"==typeof t.x&&"number"==typeof t.y&&("number"==typeof t.z||!i.is3d)&&"number"==typeof t.value},f=function(t,e){c[t+"-"+e]=(c[t+"-"+e]||0)+1},g=function(t,e,o){if(x(r[t])&&x(r[e])&&x(r[o])){if(i.is3d)if(d(r[t],r[e],r[o])<0){var a=t;t=e,e=a}var s=i.triangles[u];s||(s=i.triangles[u]={}),u++,s.a=t,s.b=e,s.c=o,s.A=r[t],s.B=r[e],s.C=r[o],f(t,e),f(e,o),f(o,t)}},v=[];if(o.triangles)for(l=0;l<o.triangles.length;l++){var m=o.triangles[l];"number"==typeof m?v.push(m):"object"===t(m)&&"number"==typeof m[0]&&"number"==typeof m[1]&&"number"==typeof m[2]&&v.push(m[0],m[1],m[2])}else if(o.grid_width){var y=o.grid_width;for(l=1;l<r.length/y;l++)for(p=1;p<o.grid_width&&l*y+p<r.length;p++){var _=(l-1)*y+(p-1),A=(l-1)*y+p,b=l*y+(p-1),w=l*y+p;this.is3d&&Math.abs(r[_].value-r[w].value)<Math.abs(r[A].value-r[b].value)?(v.push(_,A,w),v.push(_,w,b)):(v.push(_,A,b),v.push(A,w,b))}}else r=r.filter(x),v=Delaunay.triangulate(r.map(this.is3d?function(t){return[t.axisXpos,t.axisZpos]}:function(t){return[t.plotX,t.plotY]}));for(l=0;l<v.length-2;l+=3)g(v[l],v[l+1],v[l+2]);for(l=u;l<i.triangles.length;l++)i.triangles[l].shape&&i.triangles[l].shape.destroy(),i.triangles[l].edge&&i.triangles[l].edge.destroy(),i.triangles[l].gradient&&i.triangles[l].gradient.destroy();i.triangles.splice(u,i.triangles.length-u),this.assignGroups(),e.objectEach(i.groups,(function(t){t.edge_path_old=[],t.edge_path=[]}));var Y=[];for(o.contours?e.each(o.contours,(function(t){switch(t){case"x":Y.push({axis:i.xAxis,attr:"x"});break;case"y":Y.push({axis:i.yAxis,attr:"y"});break;case"z":Y.push({axis:i.zAxis,attr:"z"});break;case"value":Y.push({axis:i.colorAxis,attr:"value"})}})):o.showContours&&Y.push({axis:i.colorAxis,attr:"value"}),l=0;l<u;l++)i.drawTriangle(i.triangles[l],c,s(o.showFaces,!0),s(o.showEdges,!1),s(o.showTriangles,!1),Y);e.objectEach(i.groups,(function(t){t.edge_path.length?t.edges?t.edges.attr({d:t.edge_path_old}).animate({d:t.edge_path}):(t.edges=a.path(t.edge_path).attr({"stroke-linecap":"round",stroke:"black","stroke-width":1,zIndex:1}),t.edges.add(t)):t.edges&&(t.edges.destroy(),delete t.edges)})),e.each(r,(function(t){t.plotX_prev=t.plotX,t.plotY_prev=t.plotY,t.plotZ_prev=t.plotZ}))}});var d=function(t,e,i){return(t.plotX*(e.plotY-i.plotY)+e.plotX*(i.plotY-t.plotY)+i.plotX*(t.plotY-e.plotY))/2},x=function(t){return t>=-1e-6&&t<=1e-6?0:t},f=function(t,i){if(!t)return i;var r=t.toValue(t.toPixels(i)-.5),o=t.toValue(t.toPixels(i)+.5),a=Math.abs(o-r),s=e.normalizeTickInterval(a,[1,2,5,10],e.getMagnitude(a),!0);return e.correctFloat(s*Math.round(i/s))};function g(t){this.mtx=t,this.height=t.length,this.width=t[0].length}g.prototype.toReducedRowEchelonForm=function(){for(var t=0;t<this.width&&t<this.height;t++){for(var e=null,i=0,r=t;r<this.height;r++)Math.abs(this.mtx[r][t])>i&&(e=r,i=Math.abs(this.mtx[r][t]));if(null!=e){var o=this.mtx[t];this.mtx[t]=this.mtx[e],this.mtx[e]=o;for(r=0;r<this.height;r++)if(r!=t)for(var a=this.mtx[r][t]/this.mtx[t][t],s=t;s<this.width;s++)this.mtx[r][s]-=a*this.mtx[t][s];for(a=this.mtx[t][t],s=t;s<this.width;s++)this.mtx[t][s]/=a;for(r=0;r<this.height;r++)this.mtx[r][t]=r==t?1:0}else for(var r=0;r<this.height;r++)this.mtx[r][t]=0}return this},g.prototype.toString=function(){for(var t=[],e=0;e<this.mtx.length;e++)t.push(this.mtx[e].join(","));return t.join("\n")};var v=function(t,e){var i,r,o=t.contourSeries.xAxis,a=t.contourSeries.yAxis;return t.isXAxis?(i=o.toValue(e,!0),r=a.toValue(!t.opposite!=!t.chart.inverted?0:a.len,!0)):(i=o.toValue(!t.opposite!=!t.chart.inverted?o.len:0,!0),r=a.toValue(e,!0)),{x:i,y:r}},m=function(){var t=this,i=t.contourSeries;if(!i){if(!(i=a(t.chart.series,(function(e){return t.options.serie?e.id===t.options.serie||e.options&&e.options.id===t.options.serie:"contour"===e.type}))))return e.error(17,!1),[];t.contourSeries=i,o(i.axisTypes||[],(function(e){h(i[e],"setTickPositions",(function(e){e.apply(this,[].slice.call(arguments,1)),t.forceRedraw=!0,t.setScale()}))}))}var r,s,n=i.colorAxis.tickPositions;if(!n||0===n.length)return[];for(var l=[],p={},u=0;u<=t.len;u++){var c=t.toValue(u,!0),d=i.dataFunction(v(t,u)).value;if(u>0&&s!==d)for(var x in n){var f=n[x];if(f>=Math.min(s,d)&&f<=Math.max(s,d)){var g=(f-s)/(d-s)*(c-r)+r;l.push(g),p[g]=f}}r=c,s=d}return t._contourAxisLabels=p,l};h(e.Axis.prototype,"setOptions",(function(t,e){return e.contourAxis&&(e=l({tickWidth:1,tickColor:"black",title:{text:null}},e,{min:0,max:1,startOnTick:!1,endOnTick:!1,tickPositioner:m})),t.call(this,e)})),h(e.Axis.prototype,"init",(function(t,e,i){if(t.apply(this,[].slice.call(arguments,1)),this.options.tickPositioner===m){var r=this.labelFormatter;this.labelFormatter=function(){return this.value=this.axis._contourAxisLabels[this.value],r.call(this)}}}))}export{e as default};
+import _typeof from '@babel/runtime/helpers/typeof';
+
+/**
+ * Highcharts plugin for contour curves
+ *
+ * Author: Paulo Costa
+ */
+
+function addContour (H) {
+
+  var defaultOptions = H.getOptions(),
+    defined = H.defined,
+    each = H.each,
+    find = H.find,
+    pick = H.pick,
+    extendClass = H.extendClass,
+    merge = H.merge,
+    seriesTypes = H.seriesTypes,
+    wrap = H.wrap;
+    H.perspective;
+    var eps = 0.0001,
+    XLINK_NS = 'http://www.w3.org/1999/xlink',
+    gradient_id = 0;
+
+  /**
+   * Extend the default options with map options
+   */
+
+  defaultOptions.plotOptions.contour = merge(defaultOptions.plotOptions.scatter, {
+    marker: {
+      radius: 0,
+      fillColor: '#ffffff',
+      states: {
+        hover: {
+          radius: defaultOptions.plotOptions.scatter.marker.radius
+        }
+      }
+    },
+    states: {
+      hover: {
+        halo: {
+          size: defaultOptions.plotOptions.scatter.marker.radius + 4,
+          attributes: {
+            fill: '#000000'
+          },
+          opacity: 0.5
+        }
+      }
+    },
+    turboThreshold: 0
+  });
+
+  // The Heatmap series type
+  seriesTypes.contour = extendClass(seriesTypes.heatmap, {
+    type: 'contour',
+    hasPointSpecificOptions: true,
+    getSymbol: seriesTypes.scatter.prototype.getSymbol,
+    drawPoints: H.Series.prototype.drawPoints,
+    pointClass: H.Point,
+    pointAttribs: H.Series.prototype.pointAttribs,
+    init: function init(chart) {
+      this.is3d = chart.is3d && chart.is3d();
+      this.gradiend_ids = {};
+      this.dataFuncState = {};
+      seriesTypes.scatter.prototype.init.apply(this, arguments);
+    },
+    translate: function translate() {
+      seriesTypes.scatter.prototype.translate.call(this, arguments);
+      this.translateColors();
+    },
+    dataFunction: function dataFunction(coord) {
+      var result = this.options.dataFunction(coord);
+      if (typeof result === 'number') {
+        var ret = {};
+        each(this.parallelArrays, function (axis) {
+          ret[axis] = axis === 'value' ? result : pick(coord[axis], result);
+        });
+        return ret;
+      } else if (_typeof(result) === 'object') {
+        return H.merge(coord, result);
+      } else {
+        return null;
+      }
+    },
+    updateDataIfNecessary: function updateDataIfNecessary() {
+      var series = this,
+        axis1_type = pick(series.options.axis1, 'x'),
+        axis2_type = pick(series.options.axis2, series.is3d ? 'z' : 'y'),
+        axis1 = series[axis1_type + 'Axis'],
+        axis2 = series[axis2_type + 'Axis'];
+      if (!series.options.dataFunction || !defined(axis1.min) || !defined(axis1.max) || !defined(axis2.min) || !defined(axis2.max)) {
+        return;
+      }
+      var axis1_min = pick(axis1.min, axis1.options.min),
+        axis2_min = pick(axis2.min, axis2.options.min),
+        axis1_max = pick(axis1.max, axis1.options.max),
+        axis2_max = pick(axis2.max, axis2.options.max),
+        axis1_steps = pick(series.options.grid_width, series.options.grid_height, 21),
+        axis2_steps = pick(series.options.grid_height, series.options.grid_width, 21);
+      var newDataFuncState = {
+        dataFunc: series.options.dataFunction,
+        axis1_type: axis1_type,
+        axis2_type: axis2_type,
+        axis1_min: axis1_min,
+        axis1_max: axis1_max,
+        axis2_min: axis2_min,
+        axis2_max: axis2_max,
+        axis1_steps: axis1_steps,
+        axis2_steps: axis2_steps
+      };
+      var changes = H.cleanRecursively(newDataFuncState, series.dataFuncState);
+      if (Object.keys(changes).length === 0) {
+        return;
+      }
+      series.dataFuncState = newDataFuncState;
+      var data = [];
+      for (var j = 0; j < axis2_steps; j++) {
+        for (var i = 0; i < axis1_steps; i++) {
+          var coord = {};
+          coord[axis1_type] = i / (axis1_steps - 1) * (axis1_max - axis1_min) + axis1_min;
+          coord[axis2_type] = j / (axis2_steps - 1) * (axis2_max - axis2_min) + axis2_min;
+          var point = this.dataFunction(coord);
+          data.push(point);
+        }
+      }
+      return seriesTypes.scatter.prototype.setData.call(this, data, true, false, false);
+    },
+    bindAxes: function bindAxes() {
+      if (this.is3d) {
+        this.axisTypes = ['xAxis', 'yAxis', 'zAxis', 'colorAxis'];
+        this.parallelArrays = ['x', 'y', 'z', 'value'];
+      } else {
+        this.axisTypes = ['xAxis', 'yAxis', 'colorAxis'];
+        this.parallelArrays = ['x', 'y', 'value'];
+      }
+      seriesTypes.scatter.prototype.bindAxes.apply(this, arguments);
+    },
+    drawTriangle: function drawTriangle(triangle_data, edgeCount, show_faces, show_edges, show_triangles, contours) {
+      var fill;
+      var series = this;
+      var chart = this.chart;
+      var renderer = this.chart.renderer;
+      var a = triangle_data.A;
+      var b = triangle_data.B;
+      var c = triangle_data.C;
+      var abc = [a, b, c];
+      if (show_faces) {
+        // Normalized values of the vertexes
+        var values = [this.colorAxis.normalizedValue(a.value), this.colorAxis.normalizedValue(b.value), this.colorAxis.normalizedValue(c.value)],
+          maxValue = Math.max(values[0], values[1], values[2]),
+          minValue = Math.min(values[0], values[1], values[2]),
+          area = Math.abs(triangleArea(a, b, c));
+
+        // All vertexes have the same value/color, or the triangle has a zero-ish area
+        if (maxValue - minValue < eps || area < eps) {
+          fill = this.colorAxis.toColor((a.value + b.value + c.value) / 3);
+          // Use a linear gradient to interpolate values/colors
+        } else {
+          // Find function where "Value = A*X + B*Y + C" at the 3 vertexes
+          var m = new Matrix([[a.plotX, a.plotY, 1, values[0]], [b.plotX, b.plotY, 1, values[1]], [c.plotX, c.plotY, 1, values[2]]]);
+          m.toReducedRowEchelonForm();
+          var A = m.mtx[0][3];
+          var B = m.mtx[1][3];
+          var C = m.mtx[2][3];
+
+          // For convenience, we place our gradient control points at (k*A, k*B)
+          // We can find the value of K as:
+          //   Value = A*X + B*Y + C =
+          //   Value = A*(A*k) + B*(B*k) + C
+          //   Value = A²*k + B²*k + C
+          //   Value = k*(A² + B²) + C
+          // k = (Value - C) / (A² + B²)
+          var k0 = (0 - C) / (A * A + B * B);
+          var k1 = (1 - C) / (A * A + B * B);
+          var x1 = ensureDecimal(k0 * A);
+          var y1 = ensureDecimal(k0 * B);
+          var x2 = ensureDecimal(k1 * A);
+          var y2 = ensureDecimal(k1 * B);
+
+          // Assign a linear gradient that interpolates all 3 vertexes
+          if (renderer.isSVG) {
+            //SVGRenderer implementation of gradient is slow and leaks memory -- Lets do it ourselves
+            var gradient = triangle_data.gradient;
+            if (!gradient) {
+              gradient = renderer.createElement('linearGradient');
+              triangle_data.gradient = gradient;
+              gradient.add(renderer.defs);
+              gradient.attr({
+                id: 'contour-gradient-id-' + gradient_id++,
+                x1: x1,
+                y1: y1,
+                x2: x2,
+                y2: y2
+              });
+            } else {
+              gradient.animate({
+                x1: x1,
+                y1: y1,
+                x2: x2,
+                y2: y2
+              });
+            }
+            gradient.element.setAttributeNS(XLINK_NS, 'xlink:href', this.base_gradient_id);
+            fill = 'url(' + renderer.url + '#' + gradient.attr('id') + ')';
+          } else {
+            fill = {
+              linearGradient: {
+                x1: x1,
+                y1: y1,
+                x2: x2,
+                y2: y2,
+                spreadMethod: 'pad',
+                gradientUnits: 'userSpaceOnUse'
+              },
+              stops: this.colorAxis.stops
+            };
+          }
+        }
+        var path = ['M', a.plotX, a.plotY, 'L', b.plotX, b.plotY, 'L', c.plotX, c.plotY, 'Z'];
+        if (triangle_data.shape) {
+          triangle_data.shape.animate({
+            d: path
+          }).attr({
+            fill: fill
+          });
+          if (triangle_data.shape.parent != triangle_data.group) {
+            triangle_data.shape.add(triangle_data.group);
+          }
+        } else {
+          triangle_data.shape = renderer.path(path).attr({
+            'shape-rendering': 'crispEdges',
+            fill: fill
+          });
+          triangle_data.shape.on('mousemove', function (e) {
+            e = chart.pointer.normalize(e);
+            if (chart.inverted) {
+              var mx = chart.plotTop + chart.plotHeight - e.chartY;
+              var my = chart.plotLeft + chart.plotWidth - e.chartX;
+            } else {
+              var mx = e.chartX - chart.plotLeft;
+              var my = e.chartY - chart.plotTop;
+            }
+            if (series.options.interpolateTooltip) {
+              //Find an interpolated point on [X, Y, Z, Value] right under the mouse
+              var m = new Matrix([[a.plotX, a.plotY, 1, a.x, a.y, a.z, a.value], [b.plotX, b.plotY, 1, b.x, b.y, b.z, b.value], [c.plotX, c.plotY, 1, c.x, c.y, c.z, c.value]]);
+              m.toReducedRowEchelonForm();
+              var interpolated = {
+                x: axisRound(series.xAxis, m.mtx[0][3] * mx + m.mtx[1][3] * my + m.mtx[2][3]),
+                y: axisRound(series.yAxis, m.mtx[0][4] * mx + m.mtx[1][4] * my + m.mtx[2][4]),
+                z: axisRound(series.zAxis, m.mtx[0][5] * mx + m.mtx[1][5] * my + m.mtx[2][5]),
+                value: m.mtx[0][6] * mx + m.mtx[1][6] * my + m.mtx[2][6]
+              };
+
+              //If the series has a dataFunction, use it to calculate
+              //an exact value at the Interpolated point
+              if (series.options.dataFunction) {
+                interpolated = series.dataFunction(interpolated);
+              }
+              var interpolatedPoint = new H.Point().init(series);
+              interpolatedPoint.applyOptions(interpolated);
+
+              //interpolatedPoint.plotX = mx;
+              //interpolatedPoint.plotY = my;
+              var dataBackup = series.data;
+              series.data = [interpolatedPoint];
+              series.translate();
+              series.data = dataBackup;
+              chart.tooltip.refresh(interpolatedPoint, e);
+            } else {
+              var dist = function dist(P) {
+                return (P.plotX - mx) * (P.plotX - mx) + (P.plotY - my) * (P.plotY - my);
+              };
+              var nearest = triangle_data.A;
+              if (dist(triangle_data.B) < dist(nearest)) {
+                nearest = triangle_data.B;
+              }
+              if (dist(triangle_data.C) < dist(nearest)) {
+                nearest = triangle_data.C;
+              }
+              nearest.onMouseOver(e);
+            }
+          });
+          triangle_data.shape.add(triangle_data.group);
+        }
+      } else if (triangle_data.shape) {
+        triangle_data.shape.destroy;
+        delete triangle_data.shape;
+      }
+
+      // Draw edges around the triangle and/or on contour curves
+
+      var edge_path = triangle_data.group.edge_path;
+      var edge_path_old = triangle_data.group.edge_path_old;
+      if (show_edges || show_triangles) {
+        var processEdge = function processEdge(a, b, A, B) {
+          if (!edgeCount[b + '-' + a]) {
+            if (edgeCount[a + '-' + b]-- == 1) {
+              edge_path.push('M', A.plotX, A.plotY, 'L', B.plotX, B.plotY);
+              edge_path_old.push('M', A.plotX_prev, A.plotY_prev, 'L', B.plotX_prev, B.plotY_prev);
+            }
+          } else if (show_triangles) {
+            edgeCount[a + '-' + b]--;
+          }
+        };
+        processEdge(triangle_data.a, triangle_data.b, triangle_data.A, triangle_data.B);
+        processEdge(triangle_data.b, triangle_data.c, triangle_data.B, triangle_data.C);
+        processEdge(triangle_data.c, triangle_data.a, triangle_data.C, triangle_data.A);
+      }
+      for (var contour_index = 0; contour_index < contours.length; contour_index++) {
+        var contourAxis = contours[contour_index].axis;
+        var contourAttr = contours[contour_index].attr;
+        for (var tickIndex in contourAxis.tickPositions) {
+          var tickValue = contourAxis.tickPositions[tickIndex];
+          var contourVertexes = [];
+          for (var i = 0; i < 3; i++) {
+            var x1 = abc[i].plotX,
+              x1_prev = abc[i].plotX_prev,
+              y1 = abc[i].plotY,
+              y1_prev = abc[i].plotY_prev,
+              v1 = abc[i][contourAttr],
+              x2 = abc[(i + 1) % 3].plotX,
+              x2_prev = abc[(i + 1) % 3].plotX_prev,
+              y2 = abc[(i + 1) % 3].plotY,
+              y2_prev = abc[(i + 1) % 3].plotY_prev,
+              v2 = abc[(i + 1) % 3][contourAttr];
+            if (v1 != v2 && tickValue >= Math.min(v1, v2) && tickValue < Math.max(v1, v2)) {
+              var q = (tickValue - v1) / (v2 - v1);
+              contourVertexes.push([q * (x2 - x1) + x1, q * (y2 - y1) + y1, q * (x2_prev - x1_prev) + x1_prev, q * (y2_prev - y1_prev) + y1_prev]);
+            }
+          }
+          if (contourVertexes.length == 2) {
+            edge_path.push('M', contourVertexes[0][0], contourVertexes[0][1], 'L', contourVertexes[1][0], contourVertexes[1][1]);
+            edge_path_old.push('M', contourVertexes[0][2], contourVertexes[0][3], 'L', contourVertexes[1][2], contourVertexes[1][3]);
+          }
+        }
+      }
+    },
+    assignGroups: function assignGroups() {
+      var series = this;
+      for (var i = 0; i < series.triangles.length; i++) {
+        series.triangles[i].group_id = series.is3d ? i : 0;
+
+        //TODO: On 3D, group faces that form a continuous surface
+      }
+
+      //Add group on the SVG
+      var new_groups = {};
+      var old_groups = series.groups;
+      for (var i = 0; i < series.triangles.length; i++) {
+        var triangle = series.triangles[i];
+        var group_id = triangle.group_id;
+        if (old_groups[group_id]) {
+          new_groups[group_id] = old_groups[group_id];
+          new_groups[group_id].zSum = 0;
+          new_groups[group_id].triangle_count = 0;
+          delete old_groups[group_id];
+        } else if (!new_groups[group_id]) {
+          new_groups[group_id] = series.chart.renderer.g().add(this.surface_group);
+          new_groups[group_id].zSum = 0;
+          new_groups[group_id].triangle_count = 0;
+        }
+        series.triangles[i].group = new_groups[group_id];
+        new_groups[group_id].zSum += triangle.A.plotZ + triangle.B.plotZ + triangle.C.plotZ;
+        new_groups[group_id].triangle_count++;
+      }
+
+      //Assign Z-Index of new groups as the mean Z of all triangles
+      H.objectEach(new_groups, function (group, group_id) {
+        group.attr({
+          zIndex: -group.zSum / (3 * group.triangle_count)
+        });
+      });
+
+      //Remove old groups from SVG
+      H.objectEach(old_groups, function (group) {
+        group.destroy();
+      });
+      series.groups = new_groups;
+    },
+    drawGraph: function drawGraph() {
+      this.updateDataIfNecessary();
+      var series = this,
+        i,
+        j,
+        points = series.points,
+        options = this.options,
+        renderer = series.chart.renderer;
+      if (!series.surface_group) {
+        series.surface_group = renderer.g().add(series.group);
+        series.triangles = [];
+        series.groups = {};
+      }
+
+      // When creating a SVG, we create a "base" gradient with the right colors,
+      // And extend it on every triangle to define the orientation.
+      if (series.chart.renderer.isSVG) {
+        var gradiend_id = '';
+        for (var i = 0; i < this.colorAxis.stops.length; i++) {
+          for (var j = 0; j < this.colorAxis.stops[i].length; j++) {
+            gradiend_id += ':' + this.colorAxis.stops[i][j];
+          }
+        }
+        if (!this.gradiend_ids[gradiend_id]) {
+          var fake_rect = series.chart.renderer.rect(0, 0, 1, 1).attr({
+            fill: {
+              linearGradient: {
+                x1: 0,
+                y1: 0,
+                x2: 1,
+                y2: 0,
+                spreadMethod: 'pad',
+                gradientUnits: 'userSpaceOnUse'
+              },
+              stops: this.colorAxis.stops
+            }
+          });
+          this.gradiend_ids[gradiend_id] = /(#.*)[)]/.exec(fake_rect.attr('fill'))[1];
+        }
+        this.base_gradient_id = this.gradiend_ids[gradiend_id];
+      }
+      series.surface_group;
+      var triangle_count = 0;
+      var egde_count = {};
+      var validatePoint = function validatePoint(p) {
+        return p && typeof p.x === 'number' && typeof p.y === 'number' && (typeof p.z === 'number' || !series.is3d) && typeof p.value === 'number';
+      };
+      var appendEdge = function appendEdge(a, b) {
+        egde_count[a + '-' + b] = (egde_count[a + '-' + b] || 0) + 1;
+      };
+      var appendTriangle = function appendTriangle(a, b, c) {
+        if (validatePoint(points[a]) && validatePoint(points[b]) && validatePoint(points[c])) {
+          if (series.is3d) {
+            // Ensure all triangles are counter-clockwise.
+            // This is used to detect "3D wrap-around" edges.
+            var area = triangleArea(points[a], points[b], points[c]);
+            if (area < 0) {
+              var tmp = a;
+              a = b;
+              b = tmp;
+            }
+          }
+          var triangle_data = series.triangles[triangle_count];
+          if (!triangle_data) {
+            triangle_data = series.triangles[triangle_count] = {};
+          }
+          triangle_count++;
+          triangle_data.a = a;
+          triangle_data.b = b;
+          triangle_data.c = c;
+          triangle_data.A = points[a];
+          triangle_data.B = points[b];
+          triangle_data.C = points[c];
+          appendEdge(a, b);
+          appendEdge(b, c);
+          appendEdge(c, a);
+        }
+      };
+      var triangles = [];
+      if (options.triangles) {
+        for (i = 0; i < options.triangles.length; i++) {
+          var v = options.triangles[i];
+          if (typeof v === 'number') {
+            triangles.push(v);
+          } else if (_typeof(v) === 'object' && typeof v[0] === 'number' && typeof v[1] === 'number' && typeof v[2] === 'number') {
+            triangles.push(v[0], v[1], v[2]);
+          }
+        }
+      } else if (options.grid_width) {
+        //points are in a nice regular grid
+        var grid_width = options.grid_width;
+        for (i = 1; i < points.length / grid_width; i++) {
+          for (j = 1; j < options.grid_width && i * grid_width + j < points.length; j++) {
+            var i00 = (i - 1) * grid_width + (j - 1);
+            var i01 = (i - 1) * grid_width + j;
+            var i10 = i * grid_width + (j - 1);
+            var i11 = i * grid_width + j;
+            if (this.is3d && Math.abs(points[i00].value - points[i11].value) < Math.abs(points[i01].value - points[i10].value)) {
+              triangles.push(i00, i01, i11);
+              triangles.push(i00, i11, i10);
+            } else {
+              triangles.push(i00, i01, i10);
+              triangles.push(i01, i11, i10);
+            }
+          }
+        }
+      } else {
+        //If points are not in a regular grid, use Delaunay triangulation.
+        //You will have to include this: https://github.com/ironwallaby/delaunay
+        points = points.filter(validatePoint);
+        triangles = Delaunay.triangulate(points.map(this.is3d ? function (x) {
+          return [x.axisXpos, x.axisZpos];
+        } : function (x) {
+          return [x.plotX, x.plotY];
+        }));
+      }
+      for (i = 0; i < triangles.length - 2; i += 3) {
+        appendTriangle(triangles[i], triangles[i + 1], triangles[i + 2]);
+      }
+
+      // Remove extra unused triangles from previous rendering
+      for (i = triangle_count; i < series.triangles.length; i++) {
+        if (series.triangles[i].shape) {
+          series.triangles[i].shape.destroy();
+        }
+        if (series.triangles[i].edge) {
+          series.triangles[i].edge.destroy();
+        }
+        if (series.triangles[i].gradient) {
+          series.triangles[i].gradient.destroy();
+        }
+      }
+      series.triangles.splice(triangle_count, series.triangles.length - triangle_count);
+
+      //Assign triangles in groups (drawing layers)
+      this.assignGroups();
+      H.objectEach(series.groups, function (group) {
+        group.edge_path_old = [];
+        group.edge_path = [];
+      });
+      var contours = [];
+      if (options.contours) {
+        H.each(options.contours, function (contourName) {
+          switch (contourName) {
+            case 'x':
+              contours.push({
+                axis: series.xAxis,
+                attr: 'x'
+              });
+              break;
+            case 'y':
+              contours.push({
+                axis: series.yAxis,
+                attr: 'y'
+              });
+              break;
+            case 'z':
+              contours.push({
+                axis: series.zAxis,
+                attr: 'z'
+              });
+              break;
+            case 'value':
+              contours.push({
+                axis: series.colorAxis,
+                attr: 'value'
+              });
+              break;
+          }
+        });
+      } else if (options.showContours) {
+        contours.push({
+          axis: series.colorAxis,
+          attr: 'value'
+        });
+      }
+
+      // Render each triangle
+      for (i = 0; i < triangle_count; i++) {
+        series.drawTriangle(series.triangles[i], egde_count, pick(options.showFaces, true), pick(options.showEdges, false), pick(options.showTriangles, false), contours);
+      }
+
+      // Render edges
+      H.objectEach(series.groups, function (group) {
+        if (group.edge_path.length) {
+          if (group.edges) {
+            group.edges.attr({
+              d: group.edge_path_old
+            }).animate({
+              d: group.edge_path
+            });
+          } else {
+            group.edges = renderer.path(group.edge_path).attr({
+              'stroke-linecap': 'round',
+              stroke: 'black',
+              'stroke-width': 1,
+              zIndex: 1
+            });
+            group.edges.add(group);
+          }
+        } else if (group.edges) {
+          group.edges.destroy();
+          delete group.edges;
+        }
+      });
+
+      //Prepare point for next rendering
+      H.each(points, function (point) {
+        point.plotX_prev = point.plotX;
+        point.plotY_prev = point.plotY;
+        point.plotZ_prev = point.plotZ;
+      });
+    }
+  });
+  var triangleArea = function triangleArea(a, b, c) {
+    return (a.plotX * (b.plotY - c.plotY) + b.plotX * (c.plotY - a.plotY) + c.plotX * (a.plotY - b.plotY)) / 2;
+  };
+
+  /**
+   * Round tiny numbers to 0, as scientific notation isn't handled by SVG
+   */
+  var ensureDecimal = function ensureDecimal(num) {
+    if (num >= -1e-6 && num <= 1e-6) {
+      return 0;
+    }
+    return num;
+  };
+
+  /**
+   * Smart-rounding of axis values, where the precision depends on the axis slope.
+   */
+  var axisRound = function axisRound(axis, value) {
+    if (!axis) {
+      return value;
+    }
+    var valueMin = axis.toValue(axis.toPixels(value) - 0.5);
+    var valueMax = axis.toValue(axis.toPixels(value) + 0.5);
+    var valueInterval = Math.abs(valueMax - valueMin);
+    var roundedValueInterval = H.normalizeTickInterval(valueInterval, [1, 2, 5, 10], H.getMagnitude(valueInterval), true);
+    var roundValue = H.correctFloat(roundedValueInterval * Math.round(value / roundedValueInterval));
+    return roundValue;
+  };
+
+  /**
+   * Matrix class
+   * Based on:
+   * - http://rosettacode.org/wiki/Matrix_Transpose#JavaScript
+   * - http://rosettacode.org/wiki/Reduced_row_echelon_form#JavaScript
+   */
+  function Matrix(ary) {
+    this.mtx = ary;
+    this.height = ary.length;
+    this.width = ary[0].length;
+  }
+  Matrix.prototype.toReducedRowEchelonForm = function () {
+    for (var col = 0; col < this.width && col < this.height; col++) {
+      var bestRow = null;
+      var bestRowVal = 0;
+      for (var row = col; row < this.height; row++) {
+        if (Math.abs(this.mtx[row][col]) > bestRowVal) {
+          bestRow = row;
+          bestRowVal = Math.abs(this.mtx[row][col]);
+        }
+      }
+
+      //All zeros in this column :(
+      if (bestRow == null) {
+        for (var row = 0; row < this.height; row++) {
+          this.mtx[row][col] = 0;
+        }
+        continue;
+      }
+
+      //Swap rows
+      var tmp = this.mtx[col];
+      this.mtx[col] = this.mtx[bestRow];
+      this.mtx[bestRow] = tmp;
+
+      //Normalize
+      for (var row = 0; row < this.height; row++) {
+        if (row == col) {
+          //Normalize reference row last, for numeric stability
+          continue;
+        }
+        var k = this.mtx[row][col] / this.mtx[col][col];
+        for (var i = col; i < this.width; i++) {
+          this.mtx[row][i] -= k * this.mtx[col][i];
+        }
+      }
+
+      //Normalize reference row now
+      var k = this.mtx[col][col];
+      for (var i = col; i < this.width; i++) {
+        this.mtx[col][i] /= k;
+      }
+
+      //Normalize this column for numeric stability
+      for (var row = 0; row < this.height; row++) {
+        this.mtx[row][col] = row == col ? 1 : 0;
+      }
+    }
+    return this;
+  };
+  Matrix.prototype.toString = function () {
+    var s = [];
+    for (var i = 0; i < this.mtx.length; i++) {
+      s.push(this.mtx[i].join(','));
+    }
+    return s.join('\n');
+  };
+
+  /**
+   * Contour axis
+   * Just add an extra axis with `contourAxis: true` and it will display labels for 'value' at the intersection with the contour curves
+   */
+
+  var contourAxisGetCoordinate = function contourAxisGetCoordinate(axis, pixels) {
+    var x, y;
+    var xAxis = axis.contourSeries.xAxis;
+    var yAxis = axis.contourSeries.yAxis;
+    if (axis.isXAxis) {
+      x = xAxis.toValue(pixels, true);
+      y = yAxis.toValue(!axis.opposite !== !axis.chart.inverted ? 0 : yAxis.len, true);
+    } else {
+      x = xAxis.toValue(!axis.opposite !== !axis.chart.inverted ? xAxis.len : 0, true);
+      y = yAxis.toValue(pixels, true);
+    }
+    return {
+      x: x,
+      y: y
+    };
+  };
+  var contourAxisTickPositioner = function contourAxisTickPositioner() {
+    var axis = this;
+    var contourSeries = axis.contourSeries;
+    if (!contourSeries) {
+      contourSeries = find(axis.chart.series, function (serie) {
+        if (axis.options.serie) {
+          return serie.id === axis.options.serie || serie.options && serie.options.id === axis.options.serie;
+        } else {
+          return serie.type === 'contour';
+        }
+      });
+      if (!contourSeries) {
+        H.error(17, false);
+        return [];
+      }
+      axis.contourSeries = contourSeries;
+      each(contourSeries.axisTypes || [], function (AXIS) {
+        wrap(contourSeries[AXIS], 'setTickPositions', function (proceed) {
+          proceed.apply(this, [].slice.call(arguments, 1));
+          axis.forceRedraw = true;
+          axis.setScale();
+        });
+      });
+    }
+    var valueTicks = contourSeries.colorAxis.tickPositions;
+    if (!valueTicks || valueTicks.length === 0) return [];
+    var x1, v1;
+    var ret = [];
+    var labels = {};
+    for (var i = 0; i <= axis.len; i++) {
+      var x2 = axis.toValue(i, true);
+      var v2 = contourSeries.dataFunction(contourAxisGetCoordinate(axis, i)).value;
+      if (i > 0 && v1 !== v2) {
+        for (var tickIndex in valueTicks) {
+          var tickValue = valueTicks[tickIndex];
+          if (tickValue >= Math.min(v1, v2) && tickValue <= Math.max(v1, v2)) {
+            var q = (tickValue - v1) / (v2 - v1);
+            var pos = q * (x2 - x1) + x1;
+            ret.push(pos);
+            labels[pos] = tickValue;
+          }
+        }
+      }
+      x1 = x2;
+      v1 = v2;
+    }
+    axis._contourAxisLabels = labels;
+    return ret;
+  };
+  wrap(H.Axis.prototype, 'setOptions', function (proceed, userOptions) {
+    if (userOptions.contourAxis) {
+      userOptions = merge({
+        tickWidth: 1,
+        tickColor: 'black',
+        title: {
+          text: null
+        }
+      }, userOptions, {
+        min: 0,
+        max: 1,
+        startOnTick: false,
+        endOnTick: false,
+        tickPositioner: contourAxisTickPositioner
+      });
+    }
+    return proceed.call(this, userOptions);
+  });
+  wrap(H.Axis.prototype, 'init', function (proceed, chart, options) {
+    proceed.apply(this, [].slice.call(arguments, 1));
+    if (this.options.tickPositioner === contourAxisTickPositioner) {
+      var oldFormatter = this.labelFormatter;
+      this.labelFormatter = function () {
+        this.value = this.axis._contourAxisLabels[this.value];
+        return oldFormatter.call(this);
+      };
+    }
+  });
+}
+
+export { addContour as default };
+//# sourceMappingURL=highcharts-contour.js.map