Carga
Carga
This commit is contained in:
@@ -0,0 +1,81 @@
|
||||
/* *
|
||||
*
|
||||
* (c) 2010-2021 Grzegorz Blachlinski, Sebastian Bochan
|
||||
*
|
||||
* License: www.highcharts.com/license
|
||||
*
|
||||
* !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
|
||||
*
|
||||
* */
|
||||
'use strict';
|
||||
import H from '../../Core/Globals.js';
|
||||
var noop = H.noop;
|
||||
import VerletIntegration from '../Networkgraph/VerletIntegration.js';
|
||||
/* *
|
||||
*
|
||||
* Functions
|
||||
*
|
||||
* */
|
||||
/**
|
||||
* @private
|
||||
*/
|
||||
function barycenter() {
|
||||
var layout = this, gravitationalConstant = layout.options.gravitationalConstant, box = layout.box, nodes = layout.nodes;
|
||||
var centerX, centerY;
|
||||
for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
|
||||
var node = nodes_1[_i];
|
||||
if (layout.options.splitSeries && !node.isParentNode) {
|
||||
centerX = node.series.parentNode.plotX;
|
||||
centerY = node.series.parentNode.plotY;
|
||||
}
|
||||
else {
|
||||
centerX = box.width / 2;
|
||||
centerY = box.height / 2;
|
||||
}
|
||||
if (!node.fixedPosition) {
|
||||
node.plotX -=
|
||||
(node.plotX - centerX) *
|
||||
gravitationalConstant /
|
||||
(node.mass * Math.sqrt(nodes.length));
|
||||
node.plotY -=
|
||||
(node.plotY - centerY) *
|
||||
gravitationalConstant /
|
||||
(node.mass * Math.sqrt(nodes.length));
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @private
|
||||
*/
|
||||
function repulsive(node, force, distanceXY, repNode) {
|
||||
var factor = (force * this.diffTemperature / node.mass /
|
||||
node.degree), x = distanceXY.x * factor, y = distanceXY.y * factor;
|
||||
if (!node.fixedPosition) {
|
||||
node.plotX += x;
|
||||
node.plotY += y;
|
||||
}
|
||||
if (!repNode.fixedPosition) {
|
||||
repNode.plotX -= x;
|
||||
repNode.plotY -= y;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @private
|
||||
*/
|
||||
function repulsiveForceFunction(d, k, node, repNode) {
|
||||
return Math.min(d, (node.marker.radius +
|
||||
repNode.marker.radius) / 2);
|
||||
}
|
||||
/* *
|
||||
*
|
||||
* Default Export
|
||||
*
|
||||
* */
|
||||
var PackedBubbleIntegration = {
|
||||
barycenter: barycenter,
|
||||
getK: noop,
|
||||
integrate: VerletIntegration.integrate,
|
||||
repulsive: repulsive,
|
||||
repulsiveForceFunction: repulsiveForceFunction
|
||||
};
|
||||
export default PackedBubbleIntegration;
|
||||
@@ -0,0 +1,207 @@
|
||||
/* *
|
||||
*
|
||||
* (c) 2010-2021 Grzegorz Blachlinski, Sebastian Bochan
|
||||
*
|
||||
* License: www.highcharts.com/license
|
||||
*
|
||||
* !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
|
||||
*
|
||||
* */
|
||||
'use strict';
|
||||
var __extends = (this && this.__extends) || (function () {
|
||||
var extendStatics = function (d, b) {
|
||||
extendStatics = Object.setPrototypeOf ||
|
||||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
||||
return extendStatics(d, b);
|
||||
};
|
||||
return function (d, b) {
|
||||
if (typeof b !== "function" && b !== null)
|
||||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
||||
extendStatics(d, b);
|
||||
function __() { this.constructor = d; }
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
};
|
||||
})();
|
||||
import GraphLayout from '../GraphLayoutComposition.js';
|
||||
import PackedBubbleIntegration from './PackedBubbleIntegration.js';
|
||||
import ReingoldFruchtermanLayout from '../Networkgraph/ReingoldFruchtermanLayout.js';
|
||||
import U from '../../Core/Utilities.js';
|
||||
var addEvent = U.addEvent, pick = U.pick;
|
||||
/* *
|
||||
*
|
||||
* Constants
|
||||
*
|
||||
* */
|
||||
var composedClasses = [];
|
||||
/* *
|
||||
*
|
||||
* Functions
|
||||
*
|
||||
* */
|
||||
/**
|
||||
* @private
|
||||
*/
|
||||
function chartGetSelectedParentNodes() {
|
||||
var allSeries = this.series, selectedParentsNodes = [];
|
||||
allSeries.forEach(function (series) {
|
||||
if (series.parentNode && series.parentNode.selected) {
|
||||
selectedParentsNodes.push(series.parentNode);
|
||||
}
|
||||
});
|
||||
return selectedParentsNodes;
|
||||
}
|
||||
/**
|
||||
* Remove accumulated data points to redistribute all of them again
|
||||
* (i.e after hiding series by legend)
|
||||
* @private
|
||||
*/
|
||||
function onChartBeforeRedraw() {
|
||||
if (this.allDataPoints) {
|
||||
delete this.allDataPoints;
|
||||
}
|
||||
}
|
||||
/* *
|
||||
*
|
||||
* Class
|
||||
*
|
||||
* */
|
||||
var PackedBubbleLayout = /** @class */ (function (_super) {
|
||||
__extends(PackedBubbleLayout, _super);
|
||||
function PackedBubbleLayout() {
|
||||
/* *
|
||||
*
|
||||
* Static Functions
|
||||
*
|
||||
* */
|
||||
var _this = _super !== null && _super.apply(this, arguments) || this;
|
||||
_this.index = NaN;
|
||||
_this.nodes = [];
|
||||
_this.options = void 0;
|
||||
_this.series = [];
|
||||
return _this;
|
||||
}
|
||||
PackedBubbleLayout.compose = function (ChartClass) {
|
||||
ReingoldFruchtermanLayout.compose(ChartClass);
|
||||
GraphLayout.integrations.packedbubble = PackedBubbleIntegration;
|
||||
GraphLayout.layouts.packedbubble = PackedBubbleLayout;
|
||||
if (composedClasses.indexOf(ChartClass) === -1) {
|
||||
composedClasses.push(ChartClass);
|
||||
addEvent(ChartClass, 'beforeRedraw', onChartBeforeRedraw);
|
||||
var chartProto = ChartClass.prototype;
|
||||
chartProto.getSelectedParentNodes = chartGetSelectedParentNodes;
|
||||
}
|
||||
};
|
||||
/* *
|
||||
*
|
||||
* Functions
|
||||
*
|
||||
* */
|
||||
PackedBubbleLayout.prototype.beforeStep = function () {
|
||||
if (this.options.marker) {
|
||||
this.series.forEach(function (series) {
|
||||
if (series) {
|
||||
series.calculateParentRadius();
|
||||
}
|
||||
});
|
||||
}
|
||||
};
|
||||
// #14439, new stable check.
|
||||
PackedBubbleLayout.prototype.isStable = function () {
|
||||
var tempDiff = Math.abs(this.prevSystemTemperature -
|
||||
this.systemTemperature);
|
||||
var upScaledTemperature = 10 * this.systemTemperature /
|
||||
Math.sqrt(this.nodes.length);
|
||||
return Math.abs(upScaledTemperature) < 1 &&
|
||||
tempDiff < 0.00001 ||
|
||||
this.temperature <= 0;
|
||||
};
|
||||
PackedBubbleLayout.prototype.setCircularPositions = function () {
|
||||
var layout = this, box = layout.box, nodes = layout.nodes, nodesLength = nodes.length + 1, angle = 2 * Math.PI / nodesLength, radius = layout.options.initialPositionRadius;
|
||||
var centerX, centerY, index = 0;
|
||||
for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
|
||||
var node = nodes_1[_i];
|
||||
if (layout.options.splitSeries &&
|
||||
!node.isParentNode) {
|
||||
centerX = node.series.parentNode.plotX;
|
||||
centerY = node.series.parentNode.plotY;
|
||||
}
|
||||
else {
|
||||
centerX = box.width / 2;
|
||||
centerY = box.height / 2;
|
||||
}
|
||||
node.plotX = node.prevX = pick(node.plotX, centerX +
|
||||
radius * Math.cos(node.index || index * angle));
|
||||
node.plotY = node.prevY = pick(node.plotY, centerY +
|
||||
radius * Math.sin(node.index || index * angle));
|
||||
node.dispX = 0;
|
||||
node.dispY = 0;
|
||||
index++;
|
||||
}
|
||||
};
|
||||
PackedBubbleLayout.prototype.repulsiveForces = function () {
|
||||
var layout = this, bubblePadding = layout.options.bubblePadding;
|
||||
var force, distanceR, distanceXY;
|
||||
layout.nodes.forEach(function (node) {
|
||||
node.degree = node.mass;
|
||||
node.neighbours = 0;
|
||||
layout.nodes.forEach(function (repNode) {
|
||||
force = 0;
|
||||
if (
|
||||
// Node cannot repulse itself:
|
||||
node !== repNode &&
|
||||
// Only close nodes affect each other:
|
||||
// Not dragged:
|
||||
!node.fixedPosition &&
|
||||
(layout.options.seriesInteraction ||
|
||||
node.series === repNode.series)) {
|
||||
distanceXY = layout.getDistXY(node, repNode);
|
||||
distanceR = (layout.vectorLength(distanceXY) -
|
||||
(node.marker.radius +
|
||||
repNode.marker.radius +
|
||||
bubblePadding));
|
||||
// TODO padding configurable
|
||||
if (distanceR < 0) {
|
||||
node.degree += 0.01;
|
||||
node.neighbours++;
|
||||
force = layout.repulsiveForce(-distanceR / Math.sqrt(node.neighbours), layout.k, node, repNode);
|
||||
}
|
||||
layout.force('repulsive', node, force * repNode.mass, distanceXY, repNode, distanceR);
|
||||
}
|
||||
});
|
||||
});
|
||||
};
|
||||
PackedBubbleLayout.prototype.applyLimitBox = function (node, box) {
|
||||
var layout = this, factor = 0.01;
|
||||
var distanceXY, distanceR;
|
||||
// parentNodeLimit should be used together
|
||||
// with seriesInteraction: false
|
||||
if (layout.options.splitSeries &&
|
||||
!node.isParentNode &&
|
||||
layout.options.parentNodeLimit) {
|
||||
distanceXY = layout.getDistXY(node, node.series.parentNode);
|
||||
distanceR = (node.series.parentNodeRadius -
|
||||
node.marker.radius -
|
||||
layout.vectorLength(distanceXY));
|
||||
if (distanceR < 0 &&
|
||||
distanceR > -2 * node.marker.radius) {
|
||||
node.plotX -= distanceXY.x * factor;
|
||||
node.plotY -= distanceXY.y * factor;
|
||||
}
|
||||
}
|
||||
_super.prototype.applyLimitBox.call(this, node, box);
|
||||
};
|
||||
return PackedBubbleLayout;
|
||||
}(ReingoldFruchtermanLayout));
|
||||
/* *
|
||||
*
|
||||
* Registry
|
||||
*
|
||||
* */
|
||||
GraphLayout.layouts.packedbubble = PackedBubbleLayout;
|
||||
/* *
|
||||
*
|
||||
* Default Export
|
||||
*
|
||||
* */
|
||||
export default PackedBubbleLayout;
|
||||
@@ -0,0 +1,100 @@
|
||||
/* *
|
||||
*
|
||||
* (c) 2010-2021 Grzegorz Blachlinski, Sebastian Bochan
|
||||
*
|
||||
* License: www.highcharts.com/license
|
||||
*
|
||||
* !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
|
||||
*
|
||||
* */
|
||||
'use strict';
|
||||
var __extends = (this && this.__extends) || (function () {
|
||||
var extendStatics = function (d, b) {
|
||||
extendStatics = Object.setPrototypeOf ||
|
||||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
||||
return extendStatics(d, b);
|
||||
};
|
||||
return function (d, b) {
|
||||
if (typeof b !== "function" && b !== null)
|
||||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
||||
extendStatics(d, b);
|
||||
function __() { this.constructor = d; }
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
};
|
||||
})();
|
||||
import Chart from '../../Core/Chart/Chart.js';
|
||||
import Point from '../../Core/Series/Point.js';
|
||||
import SeriesRegistry from '../../Core/Series/SeriesRegistry.js';
|
||||
var BubblePoint = SeriesRegistry.seriesTypes.bubble.prototype.pointClass;
|
||||
/* *
|
||||
*
|
||||
* Class
|
||||
*
|
||||
* */
|
||||
var PackedBubblePoint = /** @class */ (function (_super) {
|
||||
__extends(PackedBubblePoint, _super);
|
||||
function PackedBubblePoint() {
|
||||
/* *
|
||||
*
|
||||
* Properties
|
||||
*
|
||||
* */
|
||||
var _this = _super !== null && _super.apply(this, arguments) || this;
|
||||
_this.degree = NaN;
|
||||
_this.mass = NaN;
|
||||
_this.radius = NaN;
|
||||
_this.options = void 0;
|
||||
_this.series = void 0;
|
||||
_this.value = null;
|
||||
return _this;
|
||||
/* eslint-enable valid-jsdoc */
|
||||
}
|
||||
/* *
|
||||
*
|
||||
* Functions
|
||||
*
|
||||
* */
|
||||
/* eslint-disable valid-jsdoc */
|
||||
/**
|
||||
* Destroy point.
|
||||
* Then remove point from the layout.
|
||||
* @private
|
||||
*/
|
||||
PackedBubblePoint.prototype.destroy = function () {
|
||||
if (this.series.layout) {
|
||||
this.series.layout.removeElementFromCollection(this, this.series.layout.nodes);
|
||||
}
|
||||
return Point.prototype.destroy.apply(this, arguments);
|
||||
};
|
||||
PackedBubblePoint.prototype.firePointEvent = function () {
|
||||
var point = this, series = this.series, seriesOptions = series.options;
|
||||
if (this.isParentNode && seriesOptions.parentNode) {
|
||||
var temp = seriesOptions.allowPointSelect;
|
||||
seriesOptions.allowPointSelect = (seriesOptions.parentNode.allowPointSelect);
|
||||
Point.prototype.firePointEvent.apply(this, arguments);
|
||||
seriesOptions.allowPointSelect = temp;
|
||||
}
|
||||
else {
|
||||
Point.prototype.firePointEvent.apply(this, arguments);
|
||||
}
|
||||
};
|
||||
PackedBubblePoint.prototype.select = function () {
|
||||
var point = this, series = this.series, chart = series.chart;
|
||||
if (point.isParentNode) {
|
||||
chart.getSelectedPoints = chart.getSelectedParentNodes;
|
||||
Point.prototype.select.apply(this, arguments);
|
||||
chart.getSelectedPoints = Chart.prototype.getSelectedPoints;
|
||||
}
|
||||
else {
|
||||
Point.prototype.select.apply(this, arguments);
|
||||
}
|
||||
};
|
||||
return PackedBubblePoint;
|
||||
}(BubblePoint));
|
||||
/* *
|
||||
*
|
||||
* Default Export
|
||||
*
|
||||
* */
|
||||
export default PackedBubblePoint;
|
||||
@@ -0,0 +1,913 @@
|
||||
/* *
|
||||
*
|
||||
* (c) 2010-2021 Grzegorz Blachlinski, Sebastian Bochan
|
||||
*
|
||||
* License: www.highcharts.com/license
|
||||
*
|
||||
* !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
|
||||
*
|
||||
* */
|
||||
'use strict';
|
||||
var __extends = (this && this.__extends) || (function () {
|
||||
var extendStatics = function (d, b) {
|
||||
extendStatics = Object.setPrototypeOf ||
|
||||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
|
||||
return extendStatics(d, b);
|
||||
};
|
||||
return function (d, b) {
|
||||
if (typeof b !== "function" && b !== null)
|
||||
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
||||
extendStatics(d, b);
|
||||
function __() { this.constructor = d; }
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
};
|
||||
})();
|
||||
import Color from '../../Core/Color/Color.js';
|
||||
var color = Color.parse;
|
||||
import DragNodesComposition from '../DragNodesComposition.js';
|
||||
import GraphLayout from '../GraphLayoutComposition.js';
|
||||
import H from '../../Core/Globals.js';
|
||||
var noop = H.noop;
|
||||
import PackedBubblePoint from './PackedBubblePoint.js';
|
||||
import PackedBubbleSeriesDefaults from './PackedBubbleSeriesDefaults.js';
|
||||
import PackedBubbleLayout from './PackedBubbleLayout.js';
|
||||
import SeriesRegistry from '../../Core/Series/SeriesRegistry.js';
|
||||
var seriesProto = SeriesRegistry.series.prototype, BubbleSeries = SeriesRegistry.seriesTypes.bubble;
|
||||
import U from '../../Core/Utilities.js';
|
||||
var addEvent = U.addEvent, clamp = U.clamp, defined = U.defined, extend = U.extend, fireEvent = U.fireEvent, isArray = U.isArray, isNumber = U.isNumber, merge = U.merge, pick = U.pick;
|
||||
/* *
|
||||
*
|
||||
* Class
|
||||
*
|
||||
* */
|
||||
/**
|
||||
* @private
|
||||
* @class
|
||||
* @name Highcharts.seriesTypes.packedbubble
|
||||
*
|
||||
* @extends Highcharts.Series
|
||||
*/
|
||||
var PackedBubbleSeries = /** @class */ (function (_super) {
|
||||
__extends(PackedBubbleSeries, _super);
|
||||
function PackedBubbleSeries() {
|
||||
/* *
|
||||
*
|
||||
* Static Properties
|
||||
*
|
||||
* */
|
||||
var _this = _super !== null && _super.apply(this, arguments) || this;
|
||||
/* *
|
||||
*
|
||||
* Properties
|
||||
*
|
||||
* */
|
||||
_this.chart = void 0;
|
||||
_this.data = void 0;
|
||||
_this.layout = void 0;
|
||||
_this.options = void 0;
|
||||
_this.parentNodeMass = 0;
|
||||
_this.points = void 0;
|
||||
_this.xData = void 0;
|
||||
return _this;
|
||||
/* eslint-enable valid-jsdoc */
|
||||
}
|
||||
/* *
|
||||
*
|
||||
* Static Functions
|
||||
*
|
||||
* */
|
||||
PackedBubbleSeries.compose = function (AxisClass, ChartClass, LegendClass, SeriesClass) {
|
||||
BubbleSeries.compose(AxisClass, ChartClass, LegendClass, SeriesClass);
|
||||
PackedBubbleLayout.compose(ChartClass);
|
||||
};
|
||||
/* *
|
||||
*
|
||||
* Functions
|
||||
*
|
||||
* */
|
||||
/* eslint-disable valid-jsdoc */
|
||||
/**
|
||||
* Create a single array of all points from all series
|
||||
* @private
|
||||
*/
|
||||
PackedBubbleSeries.prototype.accumulateAllPoints = function () {
|
||||
var chart = this.chart, allDataPoints = [];
|
||||
var yData;
|
||||
for (var _i = 0, _a = chart.series; _i < _a.length; _i++) {
|
||||
var series = _a[_i];
|
||||
if (series.is('packedbubble') && // #13574
|
||||
series.visible ||
|
||||
!chart.options.chart.ignoreHiddenSeries) {
|
||||
yData = series.yData || [];
|
||||
// add data to array only if series is visible
|
||||
for (var j = 0; j < yData.length; j++) {
|
||||
allDataPoints.push([
|
||||
null, null,
|
||||
yData[j],
|
||||
series.index,
|
||||
j,
|
||||
{
|
||||
id: j,
|
||||
marker: {
|
||||
radius: 0
|
||||
}
|
||||
}
|
||||
]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return allDataPoints;
|
||||
};
|
||||
/**
|
||||
* Adding the basic layout to series points.
|
||||
* @private
|
||||
*/
|
||||
PackedBubbleSeries.prototype.addLayout = function () {
|
||||
var layoutOptions = this.options.layoutAlgorithm =
|
||||
this.options.layoutAlgorithm || {}, layoutType = layoutOptions.type || 'packedbubble', chartOptions = this.chart.options.chart;
|
||||
var graphLayoutsStorage = this.chart.graphLayoutsStorage, graphLayoutsLookup = this.chart.graphLayoutsLookup, layout;
|
||||
if (!graphLayoutsStorage) {
|
||||
this.chart.graphLayoutsStorage = graphLayoutsStorage = {};
|
||||
this.chart.graphLayoutsLookup = graphLayoutsLookup = [];
|
||||
}
|
||||
layout = graphLayoutsStorage[layoutType];
|
||||
if (!layout) {
|
||||
layoutOptions.enableSimulation =
|
||||
!defined(chartOptions.forExport) ?
|
||||
layoutOptions.enableSimulation :
|
||||
!chartOptions.forExport;
|
||||
graphLayoutsStorage[layoutType] = layout =
|
||||
new GraphLayout.layouts[layoutType]();
|
||||
layout.init(layoutOptions);
|
||||
graphLayoutsLookup.splice(layout.index, 0, layout);
|
||||
}
|
||||
this.layout = layout;
|
||||
this.points.forEach(function (node) {
|
||||
node.mass = 2;
|
||||
node.degree = 1;
|
||||
node.collisionNmb = 1;
|
||||
});
|
||||
layout.setArea(0, 0, this.chart.plotWidth, this.chart.plotHeight);
|
||||
layout.addElementsToCollection([this], layout.series);
|
||||
layout.addElementsToCollection(this.points, layout.nodes);
|
||||
};
|
||||
/**
|
||||
* Function responsible for adding series layout, used for parent nodes.
|
||||
* @private
|
||||
*/
|
||||
PackedBubbleSeries.prototype.addSeriesLayout = function () {
|
||||
var layoutOptions = this.options.layoutAlgorithm =
|
||||
this.options.layoutAlgorithm || {}, layoutType = (layoutOptions.type || 'packedbubble'), graphLayoutsStorage = this.chart.graphLayoutsStorage, graphLayoutsLookup = this.chart.graphLayoutsLookup, parentNodeOptions = merge(layoutOptions, layoutOptions.parentNodeOptions, {
|
||||
enableSimulation: this.layout.options.enableSimulation
|
||||
});
|
||||
var seriesLayout = graphLayoutsStorage[layoutType + '-series'];
|
||||
if (!seriesLayout) {
|
||||
graphLayoutsStorage[layoutType + '-series'] = seriesLayout =
|
||||
new GraphLayout.layouts[layoutType]();
|
||||
seriesLayout.init(parentNodeOptions);
|
||||
graphLayoutsLookup.splice(seriesLayout.index, 0, seriesLayout);
|
||||
}
|
||||
this.parentNodeLayout = seriesLayout;
|
||||
this.createParentNodes();
|
||||
};
|
||||
/**
|
||||
* The function responsible for calculating the parent node radius
|
||||
* based on the total surface of iniside-bubbles and the group BBox
|
||||
* @private
|
||||
*/
|
||||
PackedBubbleSeries.prototype.calculateParentRadius = function () {
|
||||
var bBox = this.seriesBox(), parentPadding = 20, minParentRadius = 20;
|
||||
this.parentNodeRadius = clamp(Math.sqrt(2 * this.parentNodeMass / Math.PI) + parentPadding, minParentRadius, bBox ?
|
||||
Math.max(Math.sqrt(Math.pow(bBox.width, 2) +
|
||||
Math.pow(bBox.height, 2)) / 2 + parentPadding, minParentRadius) :
|
||||
Math.sqrt(2 * this.parentNodeMass / Math.PI) + parentPadding);
|
||||
if (this.parentNode) {
|
||||
this.parentNode.marker.radius =
|
||||
this.parentNode.radius = this.parentNodeRadius;
|
||||
}
|
||||
};
|
||||
/**
|
||||
* Calculate min and max bubble value for radius calculation.
|
||||
* @private
|
||||
*/
|
||||
PackedBubbleSeries.prototype.calculateZExtremes = function () {
|
||||
var chart = this.chart, allSeries = chart.series;
|
||||
var zMin = this.options.zMin, zMax = this.options.zMax, valMin = Infinity, valMax = -Infinity;
|
||||
if (zMin && zMax) {
|
||||
return [zMin, zMax];
|
||||
}
|
||||
// it is needed to deal with null
|
||||
// and undefined values
|
||||
allSeries.forEach(function (series) {
|
||||
series.yData.forEach(function (y) {
|
||||
if (defined(y)) {
|
||||
if (y > valMax) {
|
||||
valMax = y;
|
||||
}
|
||||
if (y < valMin) {
|
||||
valMin = y;
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
zMin = pick(zMin, valMin);
|
||||
zMax = pick(zMax, valMax);
|
||||
return [zMin, zMax];
|
||||
};
|
||||
/**
|
||||
* Check if two bubbles overlaps.
|
||||
* @private
|
||||
*/
|
||||
PackedBubbleSeries.prototype.checkOverlap = function (bubble1, bubble2) {
|
||||
var diffX = bubble1[0] - bubble2[0], // diff of X center values
|
||||
diffY = bubble1[1] - bubble2[1], // diff of Y center values
|
||||
sumRad = bubble1[2] + bubble2[2]; // sum of bubble radius
|
||||
return (Math.sqrt(diffX * diffX + diffY * diffY) -
|
||||
Math.abs(sumRad)) < -0.001;
|
||||
};
|
||||
/**
|
||||
* Creating parent nodes for split series, in which all the bubbles
|
||||
* are rendered.
|
||||
* @private
|
||||
*/
|
||||
PackedBubbleSeries.prototype.createParentNodes = function () {
|
||||
var _this = this;
|
||||
var PackedBubblePoint = this.pointClass, chart = this.chart, parentNodeLayout = this.parentNodeLayout, layoutOptions = this.layout.options;
|
||||
var nodeAdded, parentNode = this.parentNode, parentMarkerOptions = {
|
||||
radius: this.parentNodeRadius,
|
||||
lineColor: this.color,
|
||||
fillColor: color(this.color).brighten(0.4).get()
|
||||
};
|
||||
if (layoutOptions.parentNodeOptions) {
|
||||
parentMarkerOptions = merge(layoutOptions.parentNodeOptions.marker || {}, parentMarkerOptions);
|
||||
}
|
||||
this.parentNodeMass = 0;
|
||||
this.points.forEach(function (p) {
|
||||
_this.parentNodeMass +=
|
||||
Math.PI * Math.pow(p.marker.radius, 2);
|
||||
});
|
||||
this.calculateParentRadius();
|
||||
parentNodeLayout.nodes.forEach(function (node) {
|
||||
if (node.seriesIndex === _this.index) {
|
||||
nodeAdded = true;
|
||||
}
|
||||
});
|
||||
parentNodeLayout.setArea(0, 0, chart.plotWidth, chart.plotHeight);
|
||||
if (!nodeAdded) {
|
||||
if (!parentNode) {
|
||||
parentNode = (new PackedBubblePoint()).init(this, {
|
||||
mass: this.parentNodeRadius / 2,
|
||||
marker: parentMarkerOptions,
|
||||
dataLabels: {
|
||||
inside: false
|
||||
},
|
||||
states: {
|
||||
normal: {
|
||||
marker: parentMarkerOptions
|
||||
},
|
||||
hover: {
|
||||
marker: parentMarkerOptions
|
||||
}
|
||||
},
|
||||
dataLabelOnNull: true,
|
||||
degree: this.parentNodeRadius,
|
||||
isParentNode: true,
|
||||
seriesIndex: this.index
|
||||
});
|
||||
}
|
||||
if (this.parentNode) {
|
||||
parentNode.plotX = this.parentNode.plotX;
|
||||
parentNode.plotY = this.parentNode.plotY;
|
||||
}
|
||||
this.parentNode = parentNode;
|
||||
parentNodeLayout.addElementsToCollection([this], parentNodeLayout.series);
|
||||
parentNodeLayout.addElementsToCollection([parentNode], parentNodeLayout.nodes);
|
||||
}
|
||||
};
|
||||
/**
|
||||
* Function responsible for adding all the layouts to the chart.
|
||||
* @private
|
||||
*/
|
||||
PackedBubbleSeries.prototype.deferLayout = function () {
|
||||
// TODO split layouts to independent methods
|
||||
var layoutOptions = this.options.layoutAlgorithm;
|
||||
if (!this.visible) {
|
||||
return;
|
||||
}
|
||||
// layout is using nodes for position calculation
|
||||
this.addLayout();
|
||||
if (layoutOptions.splitSeries) {
|
||||
this.addSeriesLayout();
|
||||
}
|
||||
};
|
||||
PackedBubbleSeries.prototype.destroy = function () {
|
||||
var _this = this;
|
||||
// Remove the series from all layouts series collections #11469
|
||||
if (this.chart.graphLayoutsLookup) {
|
||||
this.chart.graphLayoutsLookup.forEach(function (layout) {
|
||||
layout.removeElementFromCollection(_this, layout.series);
|
||||
}, this);
|
||||
}
|
||||
if (this.parentNode &&
|
||||
this.parentNodeLayout) {
|
||||
this.parentNodeLayout.removeElementFromCollection(this.parentNode, this.parentNodeLayout.nodes);
|
||||
if (this.parentNode.dataLabel) {
|
||||
this.parentNode.dataLabel =
|
||||
this.parentNode.dataLabel.destroy();
|
||||
}
|
||||
}
|
||||
seriesProto.destroy.apply(this, arguments);
|
||||
};
|
||||
/**
|
||||
* Packedbubble has two separate collecions of nodes if split, render
|
||||
* dataLabels for both sets:
|
||||
* @private
|
||||
*/
|
||||
PackedBubbleSeries.prototype.drawDataLabels = function () {
|
||||
var textPath = this.options.dataLabels.textPath, points = this.points;
|
||||
// Render node labels:
|
||||
seriesProto.drawDataLabels.apply(this, arguments);
|
||||
// Render parentNode labels:
|
||||
if (this.parentNode) {
|
||||
this.parentNode.formatPrefix = 'parentNode';
|
||||
this.points = [this.parentNode];
|
||||
this.options.dataLabels.textPath =
|
||||
this.options.dataLabels.parentNodeTextPath;
|
||||
seriesProto.drawDataLabels.apply(this, arguments);
|
||||
// Restore nodes
|
||||
this.points = points;
|
||||
this.options.dataLabels.textPath = textPath;
|
||||
}
|
||||
};
|
||||
/**
|
||||
* Create Background/Parent Nodes for split series.
|
||||
* @private
|
||||
*/
|
||||
PackedBubbleSeries.prototype.drawGraph = function () {
|
||||
// if the series is not using layout, don't add parent nodes
|
||||
if (!this.layout || !this.layout.options.splitSeries) {
|
||||
return;
|
||||
}
|
||||
var chart = this.chart, nodeMarker = this.layout.options.parentNodeOptions.marker, parentOptions = {
|
||||
fill: (nodeMarker.fillColor ||
|
||||
color(this.color).brighten(0.4).get()),
|
||||
opacity: nodeMarker.fillOpacity,
|
||||
stroke: nodeMarker.lineColor || this.color,
|
||||
'stroke-width': pick(nodeMarker.lineWidth, this.options.lineWidth)
|
||||
};
|
||||
var parentAttribs = {};
|
||||
// create the group for parent Nodes if doesn't exist
|
||||
if (!this.parentNodesGroup) {
|
||||
this.parentNodesGroup = this.plotGroup('parentNodesGroup', 'parentNode', this.visible ? 'inherit' : 'hidden', 0.1, chart.seriesGroup);
|
||||
this.group.attr({
|
||||
zIndex: 2
|
||||
});
|
||||
}
|
||||
this.calculateParentRadius();
|
||||
parentAttribs = merge({
|
||||
x: this.parentNode.plotX -
|
||||
this.parentNodeRadius,
|
||||
y: this.parentNode.plotY -
|
||||
this.parentNodeRadius,
|
||||
width: this.parentNodeRadius * 2,
|
||||
height: this.parentNodeRadius * 2
|
||||
}, parentOptions);
|
||||
if (!this.parentNode.graphic) {
|
||||
this.graph = this.parentNode.graphic =
|
||||
chart.renderer.symbol(parentOptions.symbol)
|
||||
.add(this.parentNodesGroup);
|
||||
}
|
||||
this.parentNode.graphic.attr(parentAttribs);
|
||||
};
|
||||
PackedBubbleSeries.prototype.drawTracker = function () {
|
||||
var parentNode = this.parentNode;
|
||||
// chart = series.chart,
|
||||
// pointer = chart.pointer,
|
||||
// onMouseOver = function (e: PointerEvent): void {
|
||||
// const point = pointer.getPointFromEvent(e);
|
||||
// // undefined on graph in scatterchart
|
||||
// if (typeof point !== 'undefined') {
|
||||
// pointer.isDirectTouch = true;
|
||||
// point.onMouseOver(e);
|
||||
// }
|
||||
// };
|
||||
var dataLabels;
|
||||
_super.prototype.drawTracker.call(this);
|
||||
// Add reference to the point
|
||||
if (parentNode) {
|
||||
dataLabels = (isArray(parentNode.dataLabels) ?
|
||||
parentNode.dataLabels :
|
||||
(parentNode.dataLabel ? [parentNode.dataLabel] : []));
|
||||
if (parentNode.graphic) {
|
||||
parentNode.graphic.element.point = parentNode;
|
||||
}
|
||||
dataLabels.forEach(function (dataLabel) {
|
||||
if (dataLabel.div) {
|
||||
dataLabel.div.point = parentNode;
|
||||
}
|
||||
else {
|
||||
dataLabel.element.point = parentNode;
|
||||
}
|
||||
});
|
||||
}
|
||||
};
|
||||
/**
|
||||
* Calculate radius of bubbles in series.
|
||||
* @private
|
||||
*/
|
||||
PackedBubbleSeries.prototype.getPointRadius = function () {
|
||||
var _this = this;
|
||||
var chart = this.chart, plotWidth = chart.plotWidth, plotHeight = chart.plotHeight, seriesOptions = this.options, useSimulation = seriesOptions.useSimulation, smallestSize = Math.min(plotWidth, plotHeight), extremes = {}, radii = [], allDataPoints = chart.allDataPoints || [], allDataPointsLength = allDataPoints.length;
|
||||
var minSize, maxSize, value, radius;
|
||||
['minSize', 'maxSize'].forEach(function (prop) {
|
||||
var length = parseInt(seriesOptions[prop], 10), isPercent = /%$/.test(seriesOptions[prop]);
|
||||
extremes[prop] = isPercent ?
|
||||
smallestSize * length / 100 :
|
||||
length * Math.sqrt(allDataPointsLength);
|
||||
});
|
||||
chart.minRadius = minSize = extremes.minSize /
|
||||
Math.sqrt(allDataPointsLength);
|
||||
chart.maxRadius = maxSize = extremes.maxSize /
|
||||
Math.sqrt(allDataPointsLength);
|
||||
var zExtremes = useSimulation ?
|
||||
this.calculateZExtremes() :
|
||||
[minSize, maxSize];
|
||||
allDataPoints.forEach(function (point, i) {
|
||||
value = useSimulation ?
|
||||
clamp(point[2], zExtremes[0], zExtremes[1]) :
|
||||
point[2];
|
||||
radius = _this.getRadius(zExtremes[0], zExtremes[1], minSize, maxSize, value);
|
||||
if (radius === 0) {
|
||||
radius = null;
|
||||
}
|
||||
allDataPoints[i][2] = radius;
|
||||
radii.push(radius);
|
||||
});
|
||||
this.radii = radii;
|
||||
};
|
||||
PackedBubbleSeries.prototype.init = function () {
|
||||
seriesProto.init.apply(this, arguments);
|
||||
/* eslint-disable no-invalid-this */
|
||||
// When one series is modified, the others need to be recomputed
|
||||
this.eventsToUnbind.push(addEvent(this, 'updatedData', function () {
|
||||
var _this = this;
|
||||
this.chart.series.forEach(function (s) {
|
||||
if (s.type === _this.type) {
|
||||
s.isDirty = true;
|
||||
}
|
||||
}, this);
|
||||
}));
|
||||
/* eslint-enable no-invalid-this */
|
||||
return this;
|
||||
};
|
||||
/**
|
||||
* Mouse up action, finalizing drag&drop.
|
||||
* @private
|
||||
* @param {Highcharts.Point} point The point that event occured.
|
||||
*/
|
||||
PackedBubbleSeries.prototype.onMouseUp = function (dnPoint) {
|
||||
var point = dnPoint;
|
||||
if (point.fixedPosition && !point.removed) {
|
||||
var layout_1 = this.layout, parentNodeLayout = this.parentNodeLayout;
|
||||
var distanceXY_1, distanceR_1;
|
||||
if (parentNodeLayout && layout_1.options.dragBetweenSeries) {
|
||||
parentNodeLayout.nodes.forEach(function (node) {
|
||||
if (point && point.marker &&
|
||||
node !== point.series.parentNode) {
|
||||
distanceXY_1 = layout_1.getDistXY(point, node);
|
||||
distanceR_1 = (layout_1.vectorLength(distanceXY_1) -
|
||||
node.marker.radius -
|
||||
point.marker.radius);
|
||||
if (distanceR_1 < 0) {
|
||||
node.series.addPoint(merge(point.options, {
|
||||
plotX: point.plotX,
|
||||
plotY: point.plotY
|
||||
}), false);
|
||||
layout_1.removeElementFromCollection(point, layout_1.nodes);
|
||||
point.remove();
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
DragNodesComposition.onMouseUp.apply(this, arguments);
|
||||
}
|
||||
};
|
||||
/**
|
||||
* This is the main function responsible
|
||||
* for positioning all of the bubbles
|
||||
* allDataPoints - bubble array, in format [pixel x value,
|
||||
* pixel y value, radius,
|
||||
* related series index, related point index]
|
||||
* @private
|
||||
* @param {Array<Highcharts.PackedBubbleData>} allDataPoints All points from all series
|
||||
* @return {Array<Highcharts.PackedBubbleData>} Positions of all bubbles
|
||||
*/
|
||||
PackedBubbleSeries.prototype.placeBubbles = function (allDataPoints) {
|
||||
var checkOverlap = this.checkOverlap, positionBubble = this.positionBubble, bubblePos = [];
|
||||
var stage = 1, j = 0, k = 0, calculatedBubble, arr = [], i;
|
||||
// sort all points
|
||||
var sortedArr = allDataPoints.sort(function (a, b) {
|
||||
return b[2] - a[2];
|
||||
});
|
||||
if (sortedArr.length) {
|
||||
// create first bubble in the middle of the chart
|
||||
bubblePos.push([
|
||||
[
|
||||
0,
|
||||
0,
|
||||
sortedArr[0][2],
|
||||
sortedArr[0][3],
|
||||
sortedArr[0][4]
|
||||
] // point index
|
||||
]); // 0 level bubble
|
||||
if (sortedArr.length > 1) {
|
||||
bubblePos.push([
|
||||
[
|
||||
0,
|
||||
(0 - sortedArr[1][2] -
|
||||
sortedArr[0][2]),
|
||||
// move bubble above first one
|
||||
sortedArr[1][2],
|
||||
sortedArr[1][3],
|
||||
sortedArr[1][4]
|
||||
]
|
||||
]); // 1 level 1st bubble
|
||||
// first two already positioned so starting from 2
|
||||
for (i = 2; i < sortedArr.length; i++) {
|
||||
sortedArr[i][2] = sortedArr[i][2] || 1;
|
||||
// in case if radius is calculated as 0.
|
||||
calculatedBubble = positionBubble(bubblePos[stage][j], bubblePos[stage - 1][k], sortedArr[i]); // calculate initial bubble position
|
||||
if (checkOverlap(calculatedBubble, bubblePos[stage][0])) {
|
||||
/* if new bubble is overlapping with first bubble
|
||||
* in current level (stage)
|
||||
*/
|
||||
bubblePos.push([]);
|
||||
k = 0;
|
||||
/* reset index of bubble, used for
|
||||
* positioning the bubbles around it,
|
||||
* we are starting from first bubble in next
|
||||
* stage because we are changing level to higher
|
||||
*/
|
||||
bubblePos[stage + 1].push(positionBubble(bubblePos[stage][j], bubblePos[stage][0], sortedArr[i]));
|
||||
// (last bubble, 1. from curr stage, new bubble)
|
||||
stage++; // the new level is created, above current
|
||||
j = 0; // set the index of bubble in curr level to 0
|
||||
}
|
||||
else if (stage > 1 &&
|
||||
bubblePos[stage - 1][k + 1] &&
|
||||
checkOverlap(calculatedBubble, bubblePos[stage - 1][k + 1])) {
|
||||
/* if new bubble is overlapping with one of the prev
|
||||
* stage bubbles, it means that - bubble, used for
|
||||
* positioning the bubbles around it has changed
|
||||
* so we need to recalculate it
|
||||
*/
|
||||
k++;
|
||||
bubblePos[stage].push(positionBubble(bubblePos[stage][j], bubblePos[stage - 1][k], sortedArr[i]));
|
||||
// (last bubble, prev stage bubble, new bubble)
|
||||
j++;
|
||||
}
|
||||
else { // simply add calculated bubble
|
||||
j++;
|
||||
bubblePos[stage].push(calculatedBubble);
|
||||
}
|
||||
}
|
||||
}
|
||||
this.chart.stages = bubblePos;
|
||||
// it may not be necessary but adding it just in case -
|
||||
// it is containing all of the bubble levels
|
||||
this.chart.rawPositions =
|
||||
[]
|
||||
.concat.apply([], bubblePos);
|
||||
// bubble positions merged into one array
|
||||
this.resizeRadius();
|
||||
arr = this.chart.rawPositions;
|
||||
}
|
||||
return arr;
|
||||
};
|
||||
/**
|
||||
* Function that checks for a parentMarker and sets the correct opacity.
|
||||
* @private
|
||||
* @param {Highcharts.Pack} point
|
||||
* Candidate point for opacity correction.
|
||||
* @param {string} [state]
|
||||
* The point state, can be either `hover`, `select` or 'normal'. If
|
||||
* undefined, normal state is assumed.
|
||||
*
|
||||
* @return {Highcharts.SVGAttributes}
|
||||
* The presentational attributes to be set on the point.
|
||||
*/
|
||||
PackedBubbleSeries.prototype.pointAttribs = function (point, state) {
|
||||
var options = this.options, hasParentMarker = point && point.isParentNode;
|
||||
var markerOptions = options.marker;
|
||||
if (hasParentMarker &&
|
||||
options.layoutAlgorithm &&
|
||||
options.layoutAlgorithm.parentNodeOptions) {
|
||||
markerOptions = options.layoutAlgorithm.parentNodeOptions.marker;
|
||||
}
|
||||
var fillOpacity = markerOptions.fillOpacity, attr = seriesProto.pointAttribs.call(this, point, state);
|
||||
if (fillOpacity !== 1) {
|
||||
attr['fill-opacity'] = fillOpacity;
|
||||
}
|
||||
return attr;
|
||||
};
|
||||
/**
|
||||
* Function that is adding one bubble based on positions and sizes of
|
||||
* two other bubbles, lastBubble is the last added bubble, newOrigin is
|
||||
* the bubble for positioning new bubbles. nextBubble is the curently
|
||||
* added bubble for which we are calculating positions
|
||||
* @private
|
||||
* @param {Array<number>} lastBubble The closest last bubble
|
||||
* @param {Array<number>} newOrigin New bubble
|
||||
* @param {Array<number>} nextBubble The closest next bubble
|
||||
* @return {Array<number>} Bubble with correct positions
|
||||
*/
|
||||
PackedBubbleSeries.prototype.positionBubble = function (lastBubble, newOrigin, nextBubble) {
|
||||
var sqrt = Math.sqrt, asin = Math.asin, acos = Math.acos, pow = Math.pow, abs = Math.abs, distance = sqrt(// dist between lastBubble and newOrigin
|
||||
pow((lastBubble[0] - newOrigin[0]), 2) +
|
||||
pow((lastBubble[1] - newOrigin[1]), 2)), alfa = acos(
|
||||
// from cosinus theorem: alfa is an angle used for
|
||||
// calculating correct position
|
||||
(pow(distance, 2) +
|
||||
pow(nextBubble[2] + newOrigin[2], 2) -
|
||||
pow(nextBubble[2] + lastBubble[2], 2)) / (2 * (nextBubble[2] + newOrigin[2]) * distance)), beta = asin(// from sinus theorem.
|
||||
abs(lastBubble[0] - newOrigin[0]) /
|
||||
distance),
|
||||
// providing helping variables, related to angle between
|
||||
// lastBubble and newOrigin
|
||||
gamma = (lastBubble[1] - newOrigin[1]) < 0 ? 0 : Math.PI,
|
||||
// if new origin y is smaller than last bubble y value
|
||||
// (2 and 3 quarter),
|
||||
// add Math.PI to final angle
|
||||
delta = (lastBubble[0] - newOrigin[0]) *
|
||||
(lastBubble[1] - newOrigin[1]) < 0 ?
|
||||
1 : -1, // (1st and 3rd quarter)
|
||||
finalAngle = gamma + alfa + beta * delta, cosA = Math.cos(finalAngle), sinA = Math.sin(finalAngle), posX = newOrigin[0] + (newOrigin[2] + nextBubble[2]) * sinA,
|
||||
// center of new origin + (radius1 + radius2) * sinus A
|
||||
posY = newOrigin[1] - (newOrigin[2] + nextBubble[2]) * cosA;
|
||||
return [
|
||||
posX,
|
||||
posY,
|
||||
nextBubble[2],
|
||||
nextBubble[3],
|
||||
nextBubble[4]
|
||||
]; // the same as described before
|
||||
};
|
||||
PackedBubbleSeries.prototype.render = function () {
|
||||
var dataLabels = [];
|
||||
seriesProto.render.apply(this, arguments);
|
||||
// #10823 - dataLabels should stay visible
|
||||
// when enabled allowOverlap.
|
||||
if (!this.options.dataLabels.allowOverlap) {
|
||||
this.data.forEach(function (point) {
|
||||
if (isArray(point.dataLabels)) {
|
||||
point.dataLabels.forEach(function (dataLabel) {
|
||||
dataLabels.push(dataLabel);
|
||||
});
|
||||
}
|
||||
});
|
||||
// Only hide overlapping dataLabels for layouts that
|
||||
// use simulation. Spiral packedbubble don't need
|
||||
// additional dataLabel hiding on every simulation step
|
||||
if (this.options.useSimulation) {
|
||||
this.chart.hideOverlappingLabels(dataLabels);
|
||||
}
|
||||
}
|
||||
};
|
||||
/**
|
||||
* The function responsible for resizing the bubble radius.
|
||||
* In shortcut: it is taking the initially
|
||||
* calculated positions of bubbles. Then it is calculating the min max
|
||||
* of both dimensions, creating something in shape of bBox.
|
||||
* The comparison of bBox and the size of plotArea
|
||||
* (later it may be also the size set by customer) is giving the
|
||||
* value how to recalculate the radius so it will match the size
|
||||
* @private
|
||||
*/
|
||||
PackedBubbleSeries.prototype.resizeRadius = function () {
|
||||
var chart = this.chart, positions = chart.rawPositions, min = Math.min, max = Math.max, plotLeft = chart.plotLeft, plotTop = chart.plotTop, chartHeight = chart.plotHeight, chartWidth = chart.plotWidth;
|
||||
var minX, maxX, minY, maxY, radius;
|
||||
minX = minY = Number.POSITIVE_INFINITY; // set initial values
|
||||
maxX = maxY = Number.NEGATIVE_INFINITY;
|
||||
for (var _i = 0, positions_1 = positions; _i < positions_1.length; _i++) {
|
||||
var position = positions_1[_i];
|
||||
radius = position[2];
|
||||
minX = min(minX, position[0] - radius);
|
||||
// (x center-radius) is the min x value used by specific bubble
|
||||
maxX = max(maxX, position[0] + radius);
|
||||
minY = min(minY, position[1] - radius);
|
||||
maxY = max(maxY, position[1] + radius);
|
||||
}
|
||||
var bBox = [maxX - minX, maxY - minY], spaceRatio = [
|
||||
(chartWidth - plotLeft) / bBox[0],
|
||||
(chartHeight - plotTop) / bBox[1]
|
||||
], smallerDimension = min.apply([], spaceRatio);
|
||||
if (Math.abs(smallerDimension - 1) > 1e-10) {
|
||||
// if bBox is considered not the same width as possible size
|
||||
for (var _a = 0, positions_2 = positions; _a < positions_2.length; _a++) {
|
||||
var position = positions_2[_a];
|
||||
position[2] *= smallerDimension;
|
||||
}
|
||||
this.placeBubbles(positions);
|
||||
}
|
||||
else {
|
||||
/** if no radius recalculation is needed, we need to position
|
||||
* the whole bubbles in center of chart plotarea
|
||||
* for this, we are adding two parameters,
|
||||
* diffY and diffX, that are related to differences
|
||||
* between the initial center and the bounding box
|
||||
*/
|
||||
chart.diffY = chartHeight / 2 +
|
||||
plotTop - minY - (maxY - minY) / 2;
|
||||
chart.diffX = chartWidth / 2 +
|
||||
plotLeft - minX - (maxX - minX) / 2;
|
||||
}
|
||||
};
|
||||
/**
|
||||
* The function responsible for calculating series bubble' s bBox.
|
||||
* Needed because of exporting failure when useSimulation
|
||||
* is set to false
|
||||
* @private
|
||||
*/
|
||||
PackedBubbleSeries.prototype.seriesBox = function () {
|
||||
var chart = this.chart, data = this.data, max = Math.max, min = Math.min,
|
||||
// bBox = [xMin, xMax, yMin, yMax]
|
||||
bBox = [
|
||||
chart.plotLeft,
|
||||
chart.plotLeft + chart.plotWidth,
|
||||
chart.plotTop,
|
||||
chart.plotTop + chart.plotHeight
|
||||
];
|
||||
var radius;
|
||||
data.forEach(function (p) {
|
||||
if (defined(p.plotX) &&
|
||||
defined(p.plotY) &&
|
||||
p.marker.radius) {
|
||||
radius = p.marker.radius;
|
||||
bBox[0] = min(bBox[0], p.plotX - radius);
|
||||
bBox[1] = max(bBox[1], p.plotX + radius);
|
||||
bBox[2] = min(bBox[2], p.plotY - radius);
|
||||
bBox[3] = max(bBox[3], p.plotY + radius);
|
||||
}
|
||||
});
|
||||
return isNumber(bBox.width / bBox.height) ?
|
||||
bBox :
|
||||
null;
|
||||
};
|
||||
/**
|
||||
* Needed because of z-indexing issue if point is added in series.group
|
||||
* @private
|
||||
*/
|
||||
PackedBubbleSeries.prototype.setVisible = function () {
|
||||
var series = this;
|
||||
seriesProto.setVisible.apply(series, arguments);
|
||||
if (series.parentNodeLayout && series.graph) {
|
||||
if (series.visible) {
|
||||
series.graph.show();
|
||||
if (series.parentNode.dataLabel) {
|
||||
series.parentNode.dataLabel.show();
|
||||
}
|
||||
}
|
||||
else {
|
||||
series.graph.hide();
|
||||
series.parentNodeLayout
|
||||
.removeElementFromCollection(series.parentNode, series.parentNodeLayout.nodes);
|
||||
if (series.parentNode.dataLabel) {
|
||||
series.parentNode.dataLabel.hide();
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (series.layout) {
|
||||
if (series.visible) {
|
||||
series.layout.addElementsToCollection(series.points, series.layout.nodes);
|
||||
}
|
||||
else {
|
||||
series.points.forEach(function (node) {
|
||||
series.layout.removeElementFromCollection(node, series.layout.nodes);
|
||||
});
|
||||
}
|
||||
}
|
||||
};
|
||||
/**
|
||||
* Extend the base translate method to handle bubble size,
|
||||
* and correct positioning them.
|
||||
* @private
|
||||
*/
|
||||
PackedBubbleSeries.prototype.translate = function () {
|
||||
var chart = this.chart, data = this.data, index = this.index, useSimulation = this.options.useSimulation;
|
||||
var point, radius, positions;
|
||||
this.processedXData = this.xData;
|
||||
this.generatePoints();
|
||||
// merged data is an array with all of the data from all series
|
||||
if (!defined(chart.allDataPoints)) {
|
||||
chart.allDataPoints = this.accumulateAllPoints();
|
||||
// calculate radius for all added data
|
||||
this.getPointRadius();
|
||||
}
|
||||
// after getting initial radius, calculate bubble positions
|
||||
if (useSimulation) {
|
||||
positions = chart.allDataPoints;
|
||||
}
|
||||
else {
|
||||
positions = this.placeBubbles(chart.allDataPoints);
|
||||
this.options.draggable = false;
|
||||
}
|
||||
// Set the shape and arguments to be picked up in drawPoints
|
||||
for (var _i = 0, positions_3 = positions; _i < positions_3.length; _i++) {
|
||||
var position = positions_3[_i];
|
||||
if (position[3] === index) {
|
||||
// update the series points with the val from positions
|
||||
// array
|
||||
point = data[position[4]];
|
||||
radius = pick(position[2], void 0);
|
||||
if (!useSimulation) {
|
||||
point.plotX = (position[0] - chart.plotLeft +
|
||||
chart.diffX);
|
||||
point.plotY = (position[1] - chart.plotTop +
|
||||
chart.diffY);
|
||||
}
|
||||
if (isNumber(radius)) {
|
||||
point.marker = extend(point.marker, {
|
||||
radius: radius,
|
||||
width: 2 * radius,
|
||||
height: 2 * radius
|
||||
});
|
||||
point.radius = radius;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (useSimulation) {
|
||||
this.deferLayout();
|
||||
}
|
||||
fireEvent(this, 'afterTranslate');
|
||||
};
|
||||
PackedBubbleSeries.defaultOptions = merge(BubbleSeries.defaultOptions, PackedBubbleSeriesDefaults);
|
||||
return PackedBubbleSeries;
|
||||
}(BubbleSeries));
|
||||
extend(PackedBubbleSeries.prototype, {
|
||||
pointClass: PackedBubblePoint,
|
||||
axisTypes: [],
|
||||
directTouch: true,
|
||||
forces: ['barycenter', 'repulsive'],
|
||||
hasDraggableNodes: true,
|
||||
isCartesian: false,
|
||||
noSharedTooltip: true,
|
||||
pointArrayMap: ['value'],
|
||||
pointValKey: 'value',
|
||||
requireSorting: false,
|
||||
trackerGroups: ['group', 'dataLabelsGroup', 'parentNodesGroup'],
|
||||
alignDataLabel: seriesProto.alignDataLabel,
|
||||
indexateNodes: noop,
|
||||
onMouseDown: DragNodesComposition.onMouseDown,
|
||||
onMouseMove: DragNodesComposition.onMouseMove,
|
||||
redrawHalo: DragNodesComposition.redrawHalo,
|
||||
searchPoint: noop // solving #12287
|
||||
});
|
||||
SeriesRegistry.registerSeriesType('packedbubble', PackedBubbleSeries);
|
||||
/* *
|
||||
*
|
||||
* Default Export
|
||||
*
|
||||
* */
|
||||
export default PackedBubbleSeries;
|
||||
/* *
|
||||
*
|
||||
* API Declarations
|
||||
*
|
||||
* */
|
||||
/**
|
||||
* Formatter callback function.
|
||||
*
|
||||
* @callback Highcharts.SeriesPackedBubbleDataLabelsFormatterCallbackFunction
|
||||
*
|
||||
* @param {Highcharts.SeriesPackedBubbleDataLabelsFormatterContextObject} this
|
||||
* Data label context to format
|
||||
*
|
||||
* @return {string}
|
||||
* Formatted data label text
|
||||
*/
|
||||
/**
|
||||
* Context for the formatter function.
|
||||
*
|
||||
* @interface Highcharts.SeriesPackedBubbleDataLabelsFormatterContextObject
|
||||
* @extends Highcharts.PointLabelObject
|
||||
* @since 7.0.0
|
||||
*/ /**
|
||||
* The color of the node.
|
||||
* @name Highcharts.SeriesPackedBubbleDataLabelsFormatterContextObject#color
|
||||
* @type {Highcharts.ColorString}
|
||||
* @since 7.0.0
|
||||
*/ /**
|
||||
* The point (node) object. The node name, if defined, is available through
|
||||
* `this.point.name`. Arrays: `this.point.linksFrom` and `this.point.linksTo`
|
||||
* contains all nodes connected to this point.
|
||||
* @name Highcharts.SeriesPackedBubbleDataLabelsFormatterContextObject#point
|
||||
* @type {Highcharts.Point}
|
||||
* @since 7.0.0
|
||||
*/ /**
|
||||
* The ID of the node.
|
||||
* @name Highcharts.SeriesPackedBubbleDataLabelsFormatterContextObject#key
|
||||
* @type {string}
|
||||
* @since 7.0.0
|
||||
*/
|
||||
''; // detach doclets above
|
||||
@@ -0,0 +1,394 @@
|
||||
/* *
|
||||
*
|
||||
* Imports
|
||||
*
|
||||
* */
|
||||
import U from '../../Core/Utilities.js';
|
||||
var isNumber = U.isNumber;
|
||||
/* *
|
||||
*
|
||||
* Constants
|
||||
*
|
||||
* */
|
||||
/**
|
||||
* A packed bubble series is a two dimensional series type, where each point
|
||||
* renders a value in X, Y position. Each point is drawn as a bubble
|
||||
* where the bubbles don't overlap with each other and the radius
|
||||
* of the bubble relates to the value.
|
||||
*
|
||||
* @sample highcharts/demo/packed-bubble/
|
||||
* Packed bubble chart
|
||||
* @sample highcharts/demo/packed-bubble-split/
|
||||
* Split packed bubble chart
|
||||
*
|
||||
* @extends plotOptions.bubble
|
||||
* @excluding connectEnds, connectNulls, cropThreshold, dragDrop, jitter,
|
||||
* keys, pointPlacement, sizeByAbsoluteValue, step, xAxis,
|
||||
* yAxis, zMax, zMin, dataSorting, boostThreshold,
|
||||
* boostBlending
|
||||
* @product highcharts
|
||||
* @since 7.0.0
|
||||
* @requires highcharts-more
|
||||
* @optionparent plotOptions.packedbubble
|
||||
*/
|
||||
var PackedBubbleSeriesDefaults = {
|
||||
/**
|
||||
* Minimum bubble size. Bubbles will automatically size between the
|
||||
* `minSize` and `maxSize` to reflect the value of each bubble.
|
||||
* Can be either pixels (when no unit is given), or a percentage of
|
||||
* the smallest one of the plot width and height, divided by the square
|
||||
* root of total number of points.
|
||||
*
|
||||
* @sample highcharts/plotoptions/bubble-size/
|
||||
* Bubble size
|
||||
*
|
||||
* @type {number|string}
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
minSize: '10%',
|
||||
/**
|
||||
* Maximum bubble size. Bubbles will automatically size between the
|
||||
* `minSize` and `maxSize` to reflect the value of each bubble.
|
||||
* Can be either pixels (when no unit is given), or a percentage of
|
||||
* the smallest one of the plot width and height, divided by the square
|
||||
* root of total number of points.
|
||||
*
|
||||
* @sample highcharts/plotoptions/bubble-size/
|
||||
* Bubble size
|
||||
*
|
||||
* @type {number|string}
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
maxSize: '50%',
|
||||
sizeBy: 'area',
|
||||
zoneAxis: 'y',
|
||||
crisp: false,
|
||||
tooltip: {
|
||||
pointFormat: 'Value: {point.value}'
|
||||
},
|
||||
/**
|
||||
* Flag to determine if nodes are draggable or not. Available for
|
||||
* graph with useSimulation set to true only.
|
||||
*
|
||||
* @since 7.1.0
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
draggable: true,
|
||||
/**
|
||||
* An option is giving a possibility to choose between using simulation
|
||||
* for calculating bubble positions. These reflects in both animation
|
||||
* and final position of bubbles. Simulation is also adding options to
|
||||
* the series graph based on used layout. In case of big data sets, with
|
||||
* any performance issues, it is possible to disable animation and pack
|
||||
* bubble in a simple circular way.
|
||||
*
|
||||
* @sample highcharts/series-packedbubble/spiral/
|
||||
* useSimulation set to false
|
||||
*
|
||||
* @since 7.1.0
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
useSimulation: true,
|
||||
/**
|
||||
* Series options for parent nodes.
|
||||
*
|
||||
* @since 8.1.1
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
parentNode: {
|
||||
/**
|
||||
* Allow this series' parent nodes to be selected
|
||||
* by clicking on the graph.
|
||||
*
|
||||
* @since 8.1.1
|
||||
*/
|
||||
allowPointSelect: false
|
||||
},
|
||||
/**
|
||||
/**
|
||||
*
|
||||
* @declare Highcharts.SeriesPackedBubbleDataLabelsOptionsObject
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
dataLabels: {
|
||||
/**
|
||||
* The
|
||||
* [format string](https://www.highcharts.com/docs/chart-concepts/labels-and-string-formatting)
|
||||
* specifying what to show for _node_ in the networkgraph. In v7.0
|
||||
* defaults to `{key}`, since v7.1 defaults to `undefined` and
|
||||
* `formatter` is used instead.
|
||||
*
|
||||
* @type {string}
|
||||
* @since 7.0.0
|
||||
* @apioption plotOptions.packedbubble.dataLabels.format
|
||||
*/
|
||||
// eslint-disable-next-line valid-jsdoc
|
||||
/**
|
||||
* Callback JavaScript function to format the data label for a node.
|
||||
* Note that if a `format` is defined, the format takes precedence
|
||||
* and the formatter is ignored.
|
||||
*
|
||||
* @type {Highcharts.SeriesPackedBubbleDataLabelsFormatterCallbackFunction}
|
||||
* @since 7.0.0
|
||||
*/
|
||||
formatter: function () {
|
||||
var numberFormatter = this.series.chart.numberFormatter;
|
||||
var value = this.point.value;
|
||||
return isNumber(value) ? numberFormatter(value, -1) : '';
|
||||
},
|
||||
/**
|
||||
* @type {string}
|
||||
* @since 7.1.0
|
||||
* @apioption plotOptions.packedbubble.dataLabels.parentNodeFormat
|
||||
*/
|
||||
// eslint-disable-next-line valid-jsdoc
|
||||
/**
|
||||
* @type {Highcharts.SeriesPackedBubbleDataLabelsFormatterCallbackFunction}
|
||||
* @since 7.1.0
|
||||
*/
|
||||
parentNodeFormatter: function () {
|
||||
return this.name;
|
||||
},
|
||||
/**
|
||||
* @sample {highcharts} highcharts/series-packedbubble/packed-dashboard
|
||||
* Dashboard with dataLabels on parentNodes
|
||||
*
|
||||
* @declare Highcharts.SeriesPackedBubbleDataLabelsTextPathOptionsObject
|
||||
* @since 7.1.0
|
||||
*/
|
||||
parentNodeTextPath: {
|
||||
/**
|
||||
* Presentation attributes for the text path.
|
||||
*
|
||||
* @type {Highcharts.SVGAttributes}
|
||||
* @since 7.1.0
|
||||
* @apioption plotOptions.packedbubble.dataLabels.attributes
|
||||
*/
|
||||
/**
|
||||
* Enable or disable `textPath` option for link's or marker's
|
||||
* data labels.
|
||||
*
|
||||
* @since 7.1.0
|
||||
*/
|
||||
enabled: true
|
||||
},
|
||||
/**
|
||||
* Options for a _node_ label text which should follow marker's
|
||||
* shape.
|
||||
*
|
||||
* **Note:** Only SVG-based renderer supports this option.
|
||||
*
|
||||
* @extends plotOptions.series.dataLabels.textPath
|
||||
* @apioption plotOptions.packedbubble.dataLabels.textPath
|
||||
*/
|
||||
padding: 0,
|
||||
style: {
|
||||
transition: 'opacity 2000ms'
|
||||
}
|
||||
},
|
||||
/**
|
||||
* Options for layout algorithm when simulation is enabled. Inside there
|
||||
* are options to change the speed, padding, initial bubbles positions
|
||||
* and more.
|
||||
*
|
||||
* @extends plotOptions.networkgraph.layoutAlgorithm
|
||||
* @excluding approximation, attractiveForce, repulsiveForce, theta
|
||||
* @since 7.1.0
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
layoutAlgorithm: {
|
||||
/**
|
||||
* Initial layout algorithm for positioning nodes. Can be one of
|
||||
* the built-in options ("circle", "random") or a function where
|
||||
* positions should be set on each node (`this.nodes`) as
|
||||
* `node.plotX` and `node.plotY`.
|
||||
*
|
||||
* @sample highcharts/series-networkgraph/initial-positions/
|
||||
* Initial positions with callback
|
||||
*
|
||||
* @type {"circle"|"random"|Function}
|
||||
*/
|
||||
initialPositions: 'circle',
|
||||
/**
|
||||
* @sample highcharts/series-packedbubble/initial-radius/
|
||||
* Initial radius set to 200
|
||||
*
|
||||
* @extends plotOptions.networkgraph.layoutAlgorithm.initialPositionRadius
|
||||
* @excluding states
|
||||
*/
|
||||
initialPositionRadius: 20,
|
||||
/**
|
||||
* The distance between two bubbles, when the algorithm starts to
|
||||
* treat two bubbles as overlapping. The `bubblePadding` is also the
|
||||
* expected distance between all the bubbles on simulation end.
|
||||
*/
|
||||
bubblePadding: 5,
|
||||
/**
|
||||
* Whether bubbles should interact with their parentNode to keep
|
||||
* them inside.
|
||||
*/
|
||||
parentNodeLimit: false,
|
||||
/**
|
||||
* Whether series should interact with each other or not. When
|
||||
* `parentNodeLimit` is set to true, thi option should be set to
|
||||
* false to avoid sticking points in wrong series parentNode.
|
||||
*/
|
||||
seriesInteraction: true,
|
||||
/**
|
||||
* In case of split series, this option allows user to drag and
|
||||
* drop points between series, for changing point related series.
|
||||
*
|
||||
* @sample highcharts/series-packedbubble/packed-dashboard/
|
||||
* Example of drag'n drop bubbles for bubble kanban
|
||||
*/
|
||||
dragBetweenSeries: false,
|
||||
/**
|
||||
* Layout algorithm options for parent nodes.
|
||||
*
|
||||
* @extends plotOptions.networkgraph.layoutAlgorithm
|
||||
* @excluding approximation, attractiveForce, enableSimulation,
|
||||
* repulsiveForce, theta
|
||||
*/
|
||||
parentNodeOptions: {
|
||||
maxIterations: 400,
|
||||
gravitationalConstant: 0.03,
|
||||
maxSpeed: 50,
|
||||
initialPositionRadius: 100,
|
||||
seriesInteraction: true,
|
||||
/**
|
||||
* Styling options for parentNodes markers. Similar to
|
||||
* line.marker options.
|
||||
*
|
||||
* @sample highcharts/series-packedbubble/parentnode-style/
|
||||
* Bubble size
|
||||
*
|
||||
* @extends plotOptions.series.marker
|
||||
* @excluding states
|
||||
*/
|
||||
marker: {
|
||||
fillColor: null,
|
||||
fillOpacity: 1,
|
||||
lineWidth: null,
|
||||
lineColor: null,
|
||||
symbol: 'circle'
|
||||
}
|
||||
},
|
||||
enableSimulation: true,
|
||||
/**
|
||||
* Type of the algorithm used when positioning bubbles.
|
||||
* @ignore-option
|
||||
*/
|
||||
type: 'packedbubble',
|
||||
/**
|
||||
* Integration type. Integration determines how forces are applied
|
||||
* on particles. The `packedbubble` integration is based on
|
||||
* the networkgraph `verlet` integration, where the new position
|
||||
* is based on a previous position without velocity:
|
||||
* `newPosition += previousPosition - newPosition`.
|
||||
*
|
||||
* @sample highcharts/series-networkgraph/forces/
|
||||
*
|
||||
* @ignore-option
|
||||
*/
|
||||
integration: 'packedbubble',
|
||||
maxIterations: 1000,
|
||||
/**
|
||||
* Whether to split series into individual groups or to mix all
|
||||
* series together.
|
||||
*
|
||||
* @since 7.1.0
|
||||
* @default false
|
||||
*/
|
||||
splitSeries: false,
|
||||
/**
|
||||
* Max speed that node can get in one iteration. In terms of
|
||||
* simulation, it's a maximum translation (in pixels) that a node
|
||||
* can move (in both, x and y, dimensions). While `friction` is
|
||||
* applied on all nodes, max speed is applied only for nodes that
|
||||
* move very fast, for example small or disconnected ones.
|
||||
*
|
||||
* @see [layoutAlgorithm.integration](#series.networkgraph.layoutAlgorithm.integration)
|
||||
*
|
||||
* @see [layoutAlgorithm.friction](#series.networkgraph.layoutAlgorithm.friction)
|
||||
*/
|
||||
maxSpeed: 5,
|
||||
gravitationalConstant: 0.01,
|
||||
friction: -0.981
|
||||
}
|
||||
};
|
||||
/* *
|
||||
*
|
||||
* Default Export
|
||||
*
|
||||
* */
|
||||
export default PackedBubbleSeriesDefaults;
|
||||
/* *
|
||||
*
|
||||
* API Options
|
||||
*
|
||||
* */
|
||||
/**
|
||||
* A `packedbubble` series. If the [type](#series.packedbubble.type) option is
|
||||
* not specified, it is inherited from [chart.type](#chart.type).
|
||||
*
|
||||
* @type {Object}
|
||||
* @extends series,plotOptions.packedbubble
|
||||
* @excluding cropThreshold, dataParser, dataSorting, dataURL, dragDrop, stack,
|
||||
* boostThreshold, boostBlending
|
||||
* @product highcharts
|
||||
* @requires highcharts-more
|
||||
* @apioption series.packedbubble
|
||||
*/
|
||||
/**
|
||||
* An array of data points for the series. For the `packedbubble` series type,
|
||||
* points can be given in the following ways:
|
||||
*
|
||||
* 1. An array of `values`.
|
||||
*
|
||||
* ```js
|
||||
* data: [5, 1, 20]
|
||||
* ```
|
||||
*
|
||||
* 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.packedbubble.turboThreshold),
|
||||
* this option is not available.
|
||||
*
|
||||
* ```js
|
||||
* data: [{
|
||||
* value: 1,
|
||||
* name: "Point2",
|
||||
* color: "#00FF00"
|
||||
* }, {
|
||||
* value: 5,
|
||||
* name: "Point1",
|
||||
* color: "#FF00FF"
|
||||
* }]
|
||||
* ```
|
||||
*
|
||||
* @type {Array<Object|Array>}
|
||||
* @extends series.line.data
|
||||
* @excluding marker, x, y
|
||||
* @sample {highcharts} highcharts/series/data-array-of-objects/
|
||||
* Config objects
|
||||
* @product highcharts
|
||||
* @apioption series.packedbubble.data
|
||||
*/
|
||||
/**
|
||||
* @type {Highcharts.SeriesPackedBubbleDataLabelsOptionsObject|Array<Highcharts.SeriesPackedBubbleDataLabelsOptionsObject>}
|
||||
* @product highcharts
|
||||
* @apioption series.packedbubble.data.dataLabels
|
||||
*/
|
||||
/**
|
||||
* @excluding enabled,enabledThreshold,height,radius,width
|
||||
* @product highcharts
|
||||
* @apioption series.packedbubble.marker
|
||||
*/
|
||||
''; // adds doclets above to transpiled file
|
||||
Reference in New Issue
Block a user