/**
* @license Highcharts JS v6.0.1 (2017-10-05)
*
* Variable Pie module for Highcharts
*
* (c) 2010-2017 Grzegorz Blachliński
*
* License: www.highcharts.com/license
*/
'use strict';
(function(factory) {
if (typeof module === 'object' && module.exports) {
module.exports = factory;
} else {
factory(Highcharts);
}
}(function(Highcharts) {
(function(H) {
/**
*
* Variable Pie module for Highcharts
*
* (c) 2010-2017 Grzegorz Blachliński
*
* License: www.highcharts.com/license
*/
/* eslint max-len: ["warn", 80, 4] */
var pick = H.pick,
each = H.each,
grep = H.grep,
arrayMin = H.arrayMin,
arrayMax = H.arrayMax,
seriesType = H.seriesType,
pieProto = H.seriesTypes.pie.prototype;
/**
* The variablepie series type.
*
* @constructor seriesTypes.variablepie
* @augments seriesTypes.pie
*/
seriesType('variablepie', 'pie',
/**
* A variable pie series is a two dimensional series type, where each point
* renders an Y and Z value. Each point is drawn as a pie slice where the
* size (arc) of the slice relates to the Y value and the radius of pie
* slice relates to the Z value. Requires `highcharts-more.js`.
*
* @extends {plotOptions.pie}
* @product highcharts
* @sample {highcharts} highcharts/demo/variable-radius-pie/
* Variable-radius pie chart
* @since 6.0.0
* @optionparent plotOptions.variablepie
*/
{
/**
* The minimum size of the points' radius related to chart's `plotArea`.
* If a number is set, it applies in pixels.
*
* @sample {highcharts}
* highcharts/variable-radius-pie/min-max-point-size/
* Example of minPointSize and maxPointSize
* @sample {highcharts}
* highcharts/variable-radius-pie/min-point-size-100/
* minPointSize set to 100
* @type {String|Number}
* @since 6.0.0
* @product highcharts
*/
minPointSize: '10%',
/**
* The maximum size of the points' radius related to chart's `plotArea`.
* If a number is set, it applies in pixels.
*
* @sample {highcharts}
* highcharts/variable-radius-pie/min-max-point-size/
* Example of minPointSize and maxPointSize
* @type {String|Number}
* @since 6.0.0
* @product highcharts
*/
maxPointSize: '100%',
/**
* The minimum possible z value for the point's radius calculation.
* If the point's Z value is smaller than zMin, the slice will be drawn
* according to the zMin value.
*
* @sample {highcharts}
* highcharts/variable-radius-pie/zmin-5/
* zMin set to 5, smaller z values are treated as 5
* @sample {highcharts}
* highcharts/variable-radius-pie/zmin-zmax/
* Series limited by both zMin and zMax
* @type {Number}
* @since 6.0.0
* @product highcharts
*/
zMin: undefined,
/**
* The maximum possible z value for the point's radius calculation. If
* the point's Z value is bigger than zMax, the slice will be drawn
* according to the zMax value
*
* @sample {highcharts}
* highcharts/variable-radius-pie/zmin-zmax/
* Series limited by both zMin and zMax
* @type {Number}
* @since 6.0.0
* @product highcharts
*/
zMax: undefined,
/**
* Whether the pie slice's value should be represented by the area
* or the radius of the slice. Can be either `area` or `radius`. The
* default, `area`, corresponds best to the human perception of the size
* of each pie slice.
*
* @sample {highcharts}
* highcharts/variable-radius-pie/sizeby/
* Difference between area and radius sizeBy
* @type {String}
* @validvalue ["area", "radius"]
* @since 6.0.0
* @product highcharts
*/
sizeBy: 'area',
tooltip: {
pointFormat: '\u25CF {series.name}
Value: {point.y}
Size: {point.z}
' // eslint-disable-line max-len
}
}, {
pointArrayMap: ['y', 'z'],
parallelArrays: ['x', 'y', 'z'],
/*
* It is needed to null series.center on chart redraw. Probably good
* idea will be to add this option in directly in pie series.
*/
redraw: function() {
this.center = null;
pieProto.redraw.call(this, arguments);
},
/*
* For arrayMin and arrayMax calculations array shouldn't have
* null/undefined/string values.
* In this case it is needed to check if points Z value is a Number.
*/
zValEval: function(zVal) {
if (typeof zVal === 'number' && !isNaN(zVal)) {
return true;
}
return null;
},
/*
* Before standard translate method for pie chart it is needed to
* calculate min/max radius of each pie slice based on its Z value.
*/
calculateExtremes: function() {
var series = this,
chart = series.chart,
plotWidth = chart.plotWidth,
plotHeight = chart.plotHeight,
seriesOptions = series.options,
slicingRoom = 2 * (seriesOptions.slicedOffset || 0),
zMin,
zMax,
zData = series.zData,
smallestSize = Math.min(plotWidth, plotHeight) - slicingRoom,
extremes = {}, // Min and max size of pie slice.
// In pie charts size of a pie is changed to make space for
// dataLabels, then series.center is changing.
positions = series.center || series.getCenter();
each(['minPointSize', 'maxPointSize'], function(prop) {
var length = seriesOptions[prop],
isPercent = /%$/.test(length);
length = parseInt(length, 10);
extremes[prop] = isPercent ?
smallestSize * length / 100 :
length * 2; // Because it should be radius, not diameter.
});
series.minPxSize = positions[3] + extremes.minPointSize;
series.maxPxSize = Math.max(
Math.min(positions[2], extremes.maxPointSize),
positions[3] + extremes.minPointSize
);
if (zData.length) {
zMin = pick(
seriesOptions.zMin,
arrayMin(grep(zData, series.zValEval))
);
zMax = pick(
seriesOptions.zMax,
arrayMax(grep(zData, series.zValEval))
);
this.getRadii(zMin, zMax, series.minPxSize, series.maxPxSize);
}
},
/*
* Finding radius of series points based on their Z value and min/max Z
* value for all series
* zMin - min threshold for Z value. If point's Z value is smaller that
* zMin, point will have the smallest possible radius.
* zMax - max threshold for Z value. If point's Z value is bigger that
* zMax, point will have the biggest possible radius.
* minSize - minimal pixel size possible for radius
* maxSize - minimal pixel size possible for radius
*/
getRadii: function(zMin, zMax, minSize, maxSize) {
var i = 0,
pos,
zData = this.zData,
len = zData.length,
radii = [],
options = this.options,
sizeByArea = options.sizeBy !== 'radius',
zRange = zMax - zMin,
value,
radius;
// Calculate radius for all pie slice's based on their Z values
for (i; i < len; i++) {
// if zData[i] is null/undefined/string we need to take zMin for
// smallest radius.
value = this.zValEval(zData[i]) ? zData[i] : zMin;
if (value <= zMin) {
radius = minSize / 2;
} else if (value >= zMax) {
radius = maxSize / 2;
} else {
// Relative size, a number between 0 and 1
pos = zRange > 0 ? (value - zMin) / zRange : 0.5;
if (sizeByArea) {
pos = Math.sqrt(pos);
}
radius = Math.ceil(minSize + pos * (maxSize - minSize)) / 2;
}
radii.push(radius);
}
this.radii = radii;
},
/**
* Extend tranlate by updating radius for each pie slice instead of
* using one global radius.
*/
translate: function(positions) {
this.generatePoints();
var series = this,
cumulative = 0,
precision = 1000, // issue #172
options = series.options,
slicedOffset = options.slicedOffset,
connectorOffset = slicedOffset + (options.borderWidth || 0),
finalConnectorOffset,
start,
end,
angle,
startAngle = options.startAngle || 0,
startAngleRad = Math.PI / 180 * (startAngle - 90),
endAngleRad = Math.PI / 180 * (pick(
options.endAngle,
startAngle + 360) - 90),
circ = endAngleRad - startAngleRad, // 2 * Math.PI,
points = series.points,
// the x component of the radius vector for a given point
radiusX,
radiusY,
labelDistance = options.dataLabels.distance,
ignoreHiddenPoint = options.ignoreHiddenPoint,
i,
len = points.length,
point,
pointRadii,
pointRadiusX,
pointRadiusY;
series.startAngleRad = startAngleRad;
series.endAngleRad = endAngleRad;
// Use calculateExtremes to get series.radii array.
series.calculateExtremes();
// Get positions - either an integer or a percentage string must be
// given. If positions are passed as a parameter, we're in a
// recursive loop for adjusting space for data labels.
if (!positions) {
series.center = positions = series.getCenter();
}
// Utility for getting the x value from a given y, used for
// anticollision logic in data labels. Added point for using
// specific points' label distance.
series.getX = function(y, left, point) {
var radii = point.series.radii[point.index];
angle = Math.asin(
Math.min(
(y - positions[1]) /
(radii + point.labelDistance),
1
)
);
return positions[0] +
(left ? -1 : 1) *
(Math.cos(angle) * (radii +
point.labelDistance));
};
// Calculate the geometry for each point
for (i = 0; i < len; i++) {
point = points[i];
pointRadii = series.radii[i];
// Used for distance calculation for specific point.
point.labelDistance = pick(
point.options.dataLabels &&
point.options.dataLabels.distance,
labelDistance
);
// Saved for later dataLabels distance calculation.
series.maxLabelDistance = Math.max(
series.maxLabelDistance || 0,
point.labelDistance
);
// set start and end angle
start = startAngleRad + (cumulative * circ);
if (!ignoreHiddenPoint || point.visible) {
cumulative += point.percentage / 100;
}
end = startAngleRad + (cumulative * circ);
// set the shape
point.shapeType = 'arc';
point.shapeArgs = {
x: positions[0],
y: positions[1],
r: pointRadii,
innerR: positions[3] / 2,
start: Math.round(start * precision) / precision,
end: Math.round(end * precision) / precision
};
// The angle must stay within -90 and 270 (#2645)
angle = (end + start) / 2;
if (angle > 1.5 * Math.PI) {
angle -= 2 * Math.PI;
} else if (angle < -Math.PI / 2) {
angle += 2 * Math.PI;
}
// Center for the sliced out slice
point.slicedTranslation = {
translateX: Math.round(Math.cos(angle) * slicedOffset),
translateY: Math.round(Math.sin(angle) * slicedOffset)
};
// set the anchor point for tooltips
radiusX = Math.cos(angle) * positions[2] / 2;
radiusY = Math.sin(angle) * positions[2] / 2;
pointRadiusX = Math.cos(angle) * pointRadii;
pointRadiusY = Math.sin(angle) * pointRadii;
point.tooltipPos = [
positions[0] + radiusX * 0.7,
positions[1] + radiusY * 0.7
];
point.half = angle < -Math.PI / 2 || angle > Math.PI / 2 ?
1 :
0;
point.angle = angle;
// Set the anchor point for data labels. Use point.labelDistance
// instead of labelDistance // #1174
// finalConnectorOffset - not override connectorOffset value.
finalConnectorOffset = Math.min(
connectorOffset,
point.labelDistance / 5
); // #1678
point.labelPos = [
positions[0] + pointRadiusX +
// first break of connector
Math.cos(angle) * point.labelDistance,
positions[1] + pointRadiusY +
Math.sin(angle) * point.labelDistance, // a/a
positions[0] + pointRadiusX +
// second break, right outside pie
Math.cos(angle) * finalConnectorOffset,
positions[1] + pointRadiusY +
Math.sin(angle) * finalConnectorOffset, // a/a
positions[0] + pointRadiusX, // landing point for connector
positions[1] + pointRadiusY, // a/a
point.labelDistance < 0 ? // alignment
'center' :
point.half ? 'right' : 'left', // alignment
angle // center angle
];
}
}
}
);
/**
* A `variablepie` series. If the [type](#series.variablepie.type) option is not
* specified, it is inherited from [chart.type](#chart.type).
*
* For options that apply to multiple series, it is recommended to add
* them to the [plotOptions.series](#plotOptions.series) options structure.
* To apply to all series of this specific type, apply it to [plotOptions.
* variablepie](#plotOptions.variablepie).
*
* @type {Object}
* @extends series,plotOptions.variablepie
* @excluding dataParser,dataURL,stack,xAxis,yAxis
* @product highcharts
* @apioption series.variablepie
*/
/**
* An array of data points for the series. For the `variablepie` series type,
* points can be given in the following ways:
*
* 1. An array of arrays with 2 values. In this case, the numerical values
* will be interpreted as `y, z` options. Example:
*
* ```js
* data: [
* [40, 75],
* [50, 50],
* [60, 40]
* ]
* ```
*
* 2. An array of objects with named values. The objects are point
* configuration objects as seen below. If the total number of data
* points exceeds the series'
* [turboThreshold](#series.variablepie.turboThreshold), this option is not
* available.
*
* ```js
* data: [{
* y: 1,
* z: 4,
* name: "Point2",
* color: "#00FF00"
* }, {
* y: 7,
* z: 10,
* name: "Point1",
* color: "#FF00FF"
* }]
* ```
*
* @type {Array}
* @extends series.pie.data
* @excluding marker,x
* @sample {highcharts} highcharts/chart/reflow-true/
* Numerical values
* @sample {highcharts} highcharts/series/data-array-of-arrays/
* Arrays of numeric x and y
* @sample {highcharts} highcharts/series/data-array-of-arrays-datetime/
* Arrays of datetime x and y
* @sample {highcharts} highcharts/series/data-array-of-name-value/
* Arrays of point.name and y
* @sample {highcharts} highcharts/series/data-array-of-objects/
* Config objects
* @product highcharts
* @apioption series.variablepie.data
*/
}(Highcharts));
}));