Carga
Carga
This commit is contained in:
818
static/lib/Highcharts-10.2.1/es-modules/Gantt/Pathfinder.js
Normal file
818
static/lib/Highcharts-10.2.1/es-modules/Gantt/Pathfinder.js
Normal file
@@ -0,0 +1,818 @@
|
||||
/* *
|
||||
*
|
||||
* (c) 2016 Highsoft AS
|
||||
* Authors: Øystein Moseng, Lars A. V. Cabrera
|
||||
*
|
||||
* License: www.highcharts.com/license
|
||||
*
|
||||
* !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
|
||||
*
|
||||
* */
|
||||
'use strict';
|
||||
import Connection from './Connection.js';
|
||||
import Chart from '../Core/Chart/Chart.js';
|
||||
import H from '../Core/Globals.js';
|
||||
/**
|
||||
* The default pathfinder algorithm to use for a chart. It is possible to define
|
||||
* your own algorithms by adding them to the
|
||||
* `Highcharts.Pathfinder.prototype.algorithms`
|
||||
* object before the chart has been created.
|
||||
*
|
||||
* The default algorithms are as follows:
|
||||
*
|
||||
* `straight`: Draws a straight line between the connecting
|
||||
* points. Does not avoid other points when drawing.
|
||||
*
|
||||
* `simpleConnect`: Finds a path between the points using right angles
|
||||
* only. Takes only starting/ending points into
|
||||
* account, and will not avoid other points.
|
||||
*
|
||||
* `fastAvoid`: Finds a path between the points using right angles
|
||||
* only. Will attempt to avoid other points, but its
|
||||
* focus is performance over accuracy. Works well with
|
||||
* less dense datasets.
|
||||
*
|
||||
* @typedef {"fastAvoid"|"simpleConnect"|"straight"|string} Highcharts.PathfinderTypeValue
|
||||
*/
|
||||
''; // detach doclets above
|
||||
import D from '../Core/DefaultOptions.js';
|
||||
var defaultOptions = D.defaultOptions;
|
||||
import Point from '../Core/Series/Point.js';
|
||||
import U from '../Core/Utilities.js';
|
||||
var addEvent = U.addEvent, defined = U.defined, error = U.error, extend = U.extend, merge = U.merge, objectEach = U.objectEach, pick = U.pick, splat = U.splat;
|
||||
import pathfinderAlgorithms from './PathfinderAlgorithms.js';
|
||||
import '../Extensions/ArrowSymbols.js';
|
||||
var deg2rad = H.deg2rad, max = Math.max, min = Math.min;
|
||||
/*
|
||||
@todo:
|
||||
- Document how to write your own algorithms
|
||||
- Consider adding a Point.pathTo method that wraps creating a connection
|
||||
and rendering it
|
||||
*/
|
||||
// Set default Pathfinder options
|
||||
extend(defaultOptions, {
|
||||
/**
|
||||
* The Pathfinder module allows you to define connections between any two
|
||||
* points, represented as lines - optionally with markers for the start
|
||||
* and/or end points. Multiple algorithms are available for calculating how
|
||||
* the connecting lines are drawn.
|
||||
*
|
||||
* Connector functionality requires Highcharts Gantt to be loaded. In Gantt
|
||||
* charts, the connectors are used to draw dependencies between tasks.
|
||||
*
|
||||
* @see [dependency](series.gantt.data.dependency)
|
||||
*
|
||||
* @sample gantt/pathfinder/demo
|
||||
* Pathfinder connections
|
||||
*
|
||||
* @declare Highcharts.ConnectorsOptions
|
||||
* @product gantt
|
||||
* @optionparent connectors
|
||||
*/
|
||||
connectors: {
|
||||
/**
|
||||
* Enable connectors for this chart. Requires Highcharts Gantt.
|
||||
*
|
||||
* @type {boolean}
|
||||
* @default true
|
||||
* @since 6.2.0
|
||||
* @apioption connectors.enabled
|
||||
*/
|
||||
/**
|
||||
* Set the default dash style for this chart's connecting lines.
|
||||
*
|
||||
* @type {string}
|
||||
* @default solid
|
||||
* @since 6.2.0
|
||||
* @apioption connectors.dashStyle
|
||||
*/
|
||||
/**
|
||||
* Set the default color for this chart's Pathfinder connecting lines.
|
||||
* Defaults to the color of the point being connected.
|
||||
*
|
||||
* @type {Highcharts.ColorString}
|
||||
* @since 6.2.0
|
||||
* @apioption connectors.lineColor
|
||||
*/
|
||||
/**
|
||||
* Set the default pathfinder margin to use, in pixels. Some Pathfinder
|
||||
* algorithms attempt to avoid obstacles, such as other points in the
|
||||
* chart. These algorithms use this margin to determine how close lines
|
||||
* can be to an obstacle. The default is to compute this automatically
|
||||
* from the size of the obstacles in the chart.
|
||||
*
|
||||
* To draw connecting lines close to existing points, set this to a low
|
||||
* number. For more space around existing points, set this number
|
||||
* higher.
|
||||
*
|
||||
* @sample gantt/pathfinder/algorithm-margin
|
||||
* Small algorithmMargin
|
||||
*
|
||||
* @type {number}
|
||||
* @since 6.2.0
|
||||
* @apioption connectors.algorithmMargin
|
||||
*/
|
||||
/**
|
||||
* Set the default pathfinder algorithm to use for this chart. It is
|
||||
* possible to define your own algorithms by adding them to the
|
||||
* Highcharts.Pathfinder.prototype.algorithms object before the chart
|
||||
* has been created.
|
||||
*
|
||||
* The default algorithms are as follows:
|
||||
*
|
||||
* `straight`: Draws a straight line between the connecting
|
||||
* points. Does not avoid other points when drawing.
|
||||
*
|
||||
* `simpleConnect`: Finds a path between the points using right angles
|
||||
* only. Takes only starting/ending points into
|
||||
* account, and will not avoid other points.
|
||||
*
|
||||
* `fastAvoid`: Finds a path between the points using right angles
|
||||
* only. Will attempt to avoid other points, but its
|
||||
* focus is performance over accuracy. Works well with
|
||||
* less dense datasets.
|
||||
*
|
||||
* Default value: `straight` is used as default for most series types,
|
||||
* while `simpleConnect` is used as default for Gantt series, to show
|
||||
* dependencies between points.
|
||||
*
|
||||
* @sample gantt/pathfinder/demo
|
||||
* Different types used
|
||||
*
|
||||
* @type {Highcharts.PathfinderTypeValue}
|
||||
* @default undefined
|
||||
* @since 6.2.0
|
||||
*/
|
||||
type: 'straight',
|
||||
/**
|
||||
* Set the default pixel width for this chart's Pathfinder connecting
|
||||
* lines.
|
||||
*
|
||||
* @since 6.2.0
|
||||
*/
|
||||
lineWidth: 1,
|
||||
/**
|
||||
* Marker options for this chart's Pathfinder connectors. Note that
|
||||
* this option is overridden by the `startMarker` and `endMarker`
|
||||
* options.
|
||||
*
|
||||
* @declare Highcharts.ConnectorsMarkerOptions
|
||||
* @since 6.2.0
|
||||
*/
|
||||
marker: {
|
||||
/**
|
||||
* Set the radius of the connector markers. The default is
|
||||
* automatically computed based on the algorithmMargin setting.
|
||||
*
|
||||
* Setting marker.width and marker.height will override this
|
||||
* setting.
|
||||
*
|
||||
* @type {number}
|
||||
* @since 6.2.0
|
||||
* @apioption connectors.marker.radius
|
||||
*/
|
||||
/**
|
||||
* Set the width of the connector markers. If not supplied, this
|
||||
* is inferred from the marker radius.
|
||||
*
|
||||
* @type {number}
|
||||
* @since 6.2.0
|
||||
* @apioption connectors.marker.width
|
||||
*/
|
||||
/**
|
||||
* Set the height of the connector markers. If not supplied, this
|
||||
* is inferred from the marker radius.
|
||||
*
|
||||
* @type {number}
|
||||
* @since 6.2.0
|
||||
* @apioption connectors.marker.height
|
||||
*/
|
||||
/**
|
||||
* Set the color of the connector markers. By default this is the
|
||||
* same as the connector color.
|
||||
*
|
||||
* @type {Highcharts.ColorString|Highcharts.GradientColorObject|Highcharts.PatternObject}
|
||||
* @since 6.2.0
|
||||
* @apioption connectors.marker.color
|
||||
*/
|
||||
/**
|
||||
* Set the line/border color of the connector markers. By default
|
||||
* this is the same as the marker color.
|
||||
*
|
||||
* @type {Highcharts.ColorString}
|
||||
* @since 6.2.0
|
||||
* @apioption connectors.marker.lineColor
|
||||
*/
|
||||
/**
|
||||
* Enable markers for the connectors.
|
||||
*/
|
||||
enabled: false,
|
||||
/**
|
||||
* Horizontal alignment of the markers relative to the points.
|
||||
*
|
||||
* @type {Highcharts.AlignValue}
|
||||
*/
|
||||
align: 'center',
|
||||
/**
|
||||
* Vertical alignment of the markers relative to the points.
|
||||
*
|
||||
* @type {Highcharts.VerticalAlignValue}
|
||||
*/
|
||||
verticalAlign: 'middle',
|
||||
/**
|
||||
* Whether or not to draw the markers inside the points.
|
||||
*/
|
||||
inside: false,
|
||||
/**
|
||||
* Set the line/border width of the pathfinder markers.
|
||||
*/
|
||||
lineWidth: 1
|
||||
},
|
||||
/**
|
||||
* Marker options specific to the start markers for this chart's
|
||||
* Pathfinder connectors. Overrides the generic marker options.
|
||||
*
|
||||
* @declare Highcharts.ConnectorsStartMarkerOptions
|
||||
* @extends connectors.marker
|
||||
* @since 6.2.0
|
||||
*/
|
||||
startMarker: {
|
||||
/**
|
||||
* Set the symbol of the connector start markers.
|
||||
*/
|
||||
symbol: 'diamond'
|
||||
},
|
||||
/**
|
||||
* Marker options specific to the end markers for this chart's
|
||||
* Pathfinder connectors. Overrides the generic marker options.
|
||||
*
|
||||
* @declare Highcharts.ConnectorsEndMarkerOptions
|
||||
* @extends connectors.marker
|
||||
* @since 6.2.0
|
||||
*/
|
||||
endMarker: {
|
||||
/**
|
||||
* Set the symbol of the connector end markers.
|
||||
*/
|
||||
symbol: 'arrow-filled'
|
||||
}
|
||||
}
|
||||
});
|
||||
/**
|
||||
* Override Pathfinder connector options for a series. Requires Highcharts Gantt
|
||||
* to be loaded.
|
||||
*
|
||||
* @declare Highcharts.SeriesConnectorsOptionsObject
|
||||
* @extends connectors
|
||||
* @since 6.2.0
|
||||
* @excluding enabled, algorithmMargin
|
||||
* @product gantt
|
||||
* @apioption plotOptions.series.connectors
|
||||
*/
|
||||
/**
|
||||
* Connect to a point. This option can be either a string, referring to the ID
|
||||
* of another point, or an object, or an array of either. If the option is an
|
||||
* array, each element defines a connection.
|
||||
*
|
||||
* @sample gantt/pathfinder/demo
|
||||
* Different connection types
|
||||
*
|
||||
* @declare Highcharts.XrangePointConnectorsOptionsObject
|
||||
* @type {string|Array<string|*>|*}
|
||||
* @extends plotOptions.series.connectors
|
||||
* @since 6.2.0
|
||||
* @excluding enabled
|
||||
* @product gantt
|
||||
* @requires highcharts-gantt
|
||||
* @apioption series.xrange.data.connect
|
||||
*/
|
||||
/**
|
||||
* The ID of the point to connect to.
|
||||
*
|
||||
* @type {string}
|
||||
* @since 6.2.0
|
||||
* @product gantt
|
||||
* @apioption series.xrange.data.connect.to
|
||||
*/
|
||||
/**
|
||||
* Get point bounding box using plotX/plotY and shapeArgs. If using
|
||||
* graphic.getBBox() directly, the bbox will be affected by animation.
|
||||
*
|
||||
* @private
|
||||
* @function
|
||||
*
|
||||
* @param {Highcharts.Point} point
|
||||
* The point to get BB of.
|
||||
*
|
||||
* @return {Highcharts.Dictionary<number>|null}
|
||||
* Result xMax, xMin, yMax, yMin.
|
||||
*/
|
||||
function getPointBB(point) {
|
||||
var shapeArgs = point.shapeArgs, bb;
|
||||
// Prefer using shapeArgs (columns)
|
||||
if (shapeArgs) {
|
||||
return {
|
||||
xMin: shapeArgs.x || 0,
|
||||
xMax: (shapeArgs.x || 0) + (shapeArgs.width || 0),
|
||||
yMin: shapeArgs.y || 0,
|
||||
yMax: (shapeArgs.y || 0) + (shapeArgs.height || 0)
|
||||
};
|
||||
}
|
||||
// Otherwise use plotX/plotY and bb
|
||||
bb = point.graphic && point.graphic.getBBox();
|
||||
return bb ? {
|
||||
xMin: point.plotX - bb.width / 2,
|
||||
xMax: point.plotX + bb.width / 2,
|
||||
yMin: point.plotY - bb.height / 2,
|
||||
yMax: point.plotY + bb.height / 2
|
||||
} : null;
|
||||
}
|
||||
/**
|
||||
* Calculate margin to place around obstacles for the pathfinder in pixels.
|
||||
* Returns a minimum of 1 pixel margin.
|
||||
*
|
||||
* @private
|
||||
* @function
|
||||
*
|
||||
* @param {Array<object>} obstacles
|
||||
* Obstacles to calculate margin from.
|
||||
*
|
||||
* @return {number}
|
||||
* The calculated margin in pixels. At least 1.
|
||||
*/
|
||||
function calculateObstacleMargin(obstacles) {
|
||||
var len = obstacles.length, i = 0, j, obstacleDistance, distances = [],
|
||||
// Compute smallest distance between two rectangles
|
||||
distance = function (a, b, bbMargin) {
|
||||
// Count the distance even if we are slightly off
|
||||
var margin = pick(bbMargin, 10), yOverlap = a.yMax + margin > b.yMin - margin &&
|
||||
a.yMin - margin < b.yMax + margin, xOverlap = a.xMax + margin > b.xMin - margin &&
|
||||
a.xMin - margin < b.xMax + margin, xDistance = yOverlap ? (a.xMin > b.xMax ? a.xMin - b.xMax : b.xMin - a.xMax) : Infinity, yDistance = xOverlap ? (a.yMin > b.yMax ? a.yMin - b.yMax : b.yMin - a.yMax) : Infinity;
|
||||
// If the rectangles collide, try recomputing with smaller margin.
|
||||
// If they collide anyway, discard the obstacle.
|
||||
if (xOverlap && yOverlap) {
|
||||
return (margin ?
|
||||
distance(a, b, Math.floor(margin / 2)) :
|
||||
Infinity);
|
||||
}
|
||||
return min(xDistance, yDistance);
|
||||
};
|
||||
// Go over all obstacles and compare them to the others.
|
||||
for (; i < len; ++i) {
|
||||
// Compare to all obstacles ahead. We will already have compared this
|
||||
// obstacle to the ones before.
|
||||
for (j = i + 1; j < len; ++j) {
|
||||
obstacleDistance = distance(obstacles[i], obstacles[j]);
|
||||
// TODO: Magic number 80
|
||||
if (obstacleDistance < 80) { // Ignore large distances
|
||||
distances.push(obstacleDistance);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Ensure we always have at least one value, even in very spaceous charts
|
||||
distances.push(80);
|
||||
return max(Math.floor(distances.sort(function (a, b) {
|
||||
return (a - b);
|
||||
})[
|
||||
// Discard first 10% of the relevant distances, and then grab
|
||||
// the smallest one.
|
||||
Math.floor(distances.length / 10)] / 2 - 1 // Divide the distance by 2 and subtract 1.
|
||||
), 1 // 1 is the minimum margin
|
||||
);
|
||||
}
|
||||
/* eslint-disable no-invalid-this, valid-jsdoc */
|
||||
/**
|
||||
* The Pathfinder class.
|
||||
*
|
||||
* @private
|
||||
* @class
|
||||
* @name Highcharts.Pathfinder
|
||||
*
|
||||
* @param {Highcharts.Chart} chart
|
||||
* The chart to operate on.
|
||||
*/
|
||||
var Pathfinder = /** @class */ (function () {
|
||||
function Pathfinder(chart) {
|
||||
/* *
|
||||
*
|
||||
* Properties
|
||||
*
|
||||
* */
|
||||
this.chart = void 0;
|
||||
this.chartObstacles = void 0;
|
||||
this.chartObstacleMetrics = void 0;
|
||||
this.connections = void 0;
|
||||
this.group = void 0;
|
||||
this.lineObstacles = void 0;
|
||||
this.init(chart);
|
||||
}
|
||||
/**
|
||||
* @name Highcharts.Pathfinder#algorithms
|
||||
* @type {Highcharts.Dictionary<Function>}
|
||||
*/
|
||||
/**
|
||||
* Initialize the Pathfinder object.
|
||||
*
|
||||
* @function Highcharts.Pathfinder#init
|
||||
*
|
||||
* @param {Highcharts.Chart} chart
|
||||
* The chart context.
|
||||
*/
|
||||
Pathfinder.prototype.init = function (chart) {
|
||||
// Initialize pathfinder with chart context
|
||||
this.chart = chart;
|
||||
// Init connection reference list
|
||||
this.connections = [];
|
||||
// Recalculate paths/obstacles on chart redraw
|
||||
addEvent(chart, 'redraw', function () {
|
||||
this.pathfinder.update();
|
||||
});
|
||||
};
|
||||
/**
|
||||
* Update Pathfinder connections from scratch.
|
||||
*
|
||||
* @function Highcharts.Pathfinder#update
|
||||
*
|
||||
* @param {boolean} [deferRender]
|
||||
* Whether or not to defer rendering of connections until
|
||||
* series.afterAnimate event has fired. Used on first render.
|
||||
*/
|
||||
Pathfinder.prototype.update = function (deferRender) {
|
||||
var chart = this.chart, pathfinder = this, oldConnections = pathfinder.connections;
|
||||
// Rebuild pathfinder connections from options
|
||||
pathfinder.connections = [];
|
||||
chart.series.forEach(function (series) {
|
||||
if (series.visible && !series.options.isInternal) {
|
||||
series.points.forEach(function (point) {
|
||||
var ganttPointOptions = point.options;
|
||||
// For Gantt series the connect could be
|
||||
// defined as a dependency
|
||||
if (ganttPointOptions && ganttPointOptions.dependency) {
|
||||
ganttPointOptions.connect = ganttPointOptions
|
||||
.dependency;
|
||||
}
|
||||
var to, connects = (point.options &&
|
||||
point.options.connect &&
|
||||
splat(point.options.connect));
|
||||
if (point.visible && point.isInside !== false && connects) {
|
||||
connects.forEach(function (connect) {
|
||||
to = chart.get(typeof connect === 'string' ?
|
||||
connect : connect.to);
|
||||
if (to instanceof Point &&
|
||||
to.series.visible &&
|
||||
to.visible &&
|
||||
to.isInside !== false) {
|
||||
// Add new connection
|
||||
pathfinder.connections.push(new Connection(point, // from
|
||||
to, typeof connect === 'string' ?
|
||||
{} :
|
||||
connect));
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
});
|
||||
// Clear connections that should not be updated, and move old info over
|
||||
// to new connections.
|
||||
for (var j = 0, k = void 0, found = void 0, lenOld = oldConnections.length, lenNew = pathfinder.connections.length; j < lenOld; ++j) {
|
||||
found = false;
|
||||
for (k = 0; k < lenNew; ++k) {
|
||||
if (oldConnections[j].fromPoint ===
|
||||
pathfinder.connections[k].fromPoint &&
|
||||
oldConnections[j].toPoint ===
|
||||
pathfinder.connections[k].toPoint) {
|
||||
pathfinder.connections[k].graphics =
|
||||
oldConnections[j].graphics;
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!found) {
|
||||
oldConnections[j].destroy();
|
||||
}
|
||||
}
|
||||
// Clear obstacles to force recalculation. This must be done on every
|
||||
// redraw in case positions have changed. Recalculation is handled in
|
||||
// Connection.getPath on demand.
|
||||
delete this.chartObstacles;
|
||||
delete this.lineObstacles;
|
||||
// Draw the pending connections
|
||||
pathfinder.renderConnections(deferRender);
|
||||
};
|
||||
/**
|
||||
* Draw the chart's connecting paths.
|
||||
*
|
||||
* @function Highcharts.Pathfinder#renderConnections
|
||||
*
|
||||
* @param {boolean} [deferRender]
|
||||
* Whether or not to defer render until series animation is finished.
|
||||
* Used on first render.
|
||||
*/
|
||||
Pathfinder.prototype.renderConnections = function (deferRender) {
|
||||
if (deferRender) {
|
||||
// Render after series are done animating
|
||||
this.chart.series.forEach(function (series) {
|
||||
var render = function () {
|
||||
// Find pathfinder connections belonging to this series
|
||||
// that haven't rendered, and render them now.
|
||||
var pathfinder = series.chart.pathfinder, conns = pathfinder && pathfinder.connections || [];
|
||||
conns.forEach(function (connection) {
|
||||
if (connection.fromPoint &&
|
||||
connection.fromPoint.series === series) {
|
||||
connection.render();
|
||||
}
|
||||
});
|
||||
if (series.pathfinderRemoveRenderEvent) {
|
||||
series.pathfinderRemoveRenderEvent();
|
||||
delete series.pathfinderRemoveRenderEvent;
|
||||
}
|
||||
};
|
||||
if (series.options.animation === false) {
|
||||
render();
|
||||
}
|
||||
else {
|
||||
series.pathfinderRemoveRenderEvent = addEvent(series, 'afterAnimate', render);
|
||||
}
|
||||
});
|
||||
}
|
||||
else {
|
||||
// Go through connections and render them
|
||||
this.connections.forEach(function (connection) {
|
||||
connection.render();
|
||||
});
|
||||
}
|
||||
};
|
||||
/**
|
||||
* Get obstacles for the points in the chart. Does not include connecting
|
||||
* lines from Pathfinder. Applies algorithmMargin to the obstacles.
|
||||
*
|
||||
* @function Highcharts.Pathfinder#getChartObstacles
|
||||
*
|
||||
* @param {Object} options
|
||||
* Options for the calculation. Currenlty only
|
||||
* options.algorithmMargin.
|
||||
*
|
||||
* @return {Array<object>}
|
||||
* An array of calculated obstacles. Each obstacle is defined as an
|
||||
* object with xMin, xMax, yMin and yMax properties.
|
||||
*/
|
||||
Pathfinder.prototype.getChartObstacles = function (options) {
|
||||
var obstacles = [], series = this.chart.series, margin = pick(options.algorithmMargin, 0), calculatedMargin;
|
||||
for (var i = 0, sLen = series.length; i < sLen; ++i) {
|
||||
if (series[i].visible && !series[i].options.isInternal) {
|
||||
for (var j = 0, pLen = series[i].points.length, bb = void 0, point = void 0; j < pLen; ++j) {
|
||||
point = series[i].points[j];
|
||||
if (point.visible) {
|
||||
bb = getPointBB(point);
|
||||
if (bb) {
|
||||
obstacles.push({
|
||||
xMin: bb.xMin - margin,
|
||||
xMax: bb.xMax + margin,
|
||||
yMin: bb.yMin - margin,
|
||||
yMax: bb.yMax + margin
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// Sort obstacles by xMin for optimization
|
||||
obstacles = obstacles.sort(function (a, b) {
|
||||
return a.xMin - b.xMin;
|
||||
});
|
||||
// Add auto-calculated margin if the option is not defined
|
||||
if (!defined(options.algorithmMargin)) {
|
||||
calculatedMargin =
|
||||
options.algorithmMargin =
|
||||
calculateObstacleMargin(obstacles);
|
||||
obstacles.forEach(function (obstacle) {
|
||||
obstacle.xMin -= calculatedMargin;
|
||||
obstacle.xMax += calculatedMargin;
|
||||
obstacle.yMin -= calculatedMargin;
|
||||
obstacle.yMax += calculatedMargin;
|
||||
});
|
||||
}
|
||||
return obstacles;
|
||||
};
|
||||
/**
|
||||
* Utility function to get metrics for obstacles:
|
||||
* - Widest obstacle width
|
||||
* - Tallest obstacle height
|
||||
*
|
||||
* @function Highcharts.Pathfinder#getObstacleMetrics
|
||||
*
|
||||
* @param {Array<object>} obstacles
|
||||
* An array of obstacles to inspect.
|
||||
*
|
||||
* @return {Object}
|
||||
* The calculated metrics, as an object with maxHeight and maxWidth
|
||||
* properties.
|
||||
*/
|
||||
Pathfinder.prototype.getObstacleMetrics = function (obstacles) {
|
||||
var maxWidth = 0, maxHeight = 0, width, height, i = obstacles.length;
|
||||
while (i--) {
|
||||
width = obstacles[i].xMax - obstacles[i].xMin;
|
||||
height = obstacles[i].yMax - obstacles[i].yMin;
|
||||
if (maxWidth < width) {
|
||||
maxWidth = width;
|
||||
}
|
||||
if (maxHeight < height) {
|
||||
maxHeight = height;
|
||||
}
|
||||
}
|
||||
return {
|
||||
maxHeight: maxHeight,
|
||||
maxWidth: maxWidth
|
||||
};
|
||||
};
|
||||
/**
|
||||
* Utility to get which direction to start the pathfinding algorithm
|
||||
* (X vs Y), calculated from a set of marker options.
|
||||
*
|
||||
* @function Highcharts.Pathfinder#getAlgorithmStartDirection
|
||||
*
|
||||
* @param {Highcharts.ConnectorsMarkerOptions} markerOptions
|
||||
* Marker options to calculate from.
|
||||
*
|
||||
* @return {boolean}
|
||||
* Returns true for X, false for Y, and undefined for autocalculate.
|
||||
*/
|
||||
Pathfinder.prototype.getAlgorithmStartDirection = function (markerOptions) {
|
||||
var xCenter = markerOptions.align !== 'left' &&
|
||||
markerOptions.align !== 'right', yCenter = markerOptions.verticalAlign !== 'top' &&
|
||||
markerOptions.verticalAlign !== 'bottom', undef;
|
||||
return xCenter ?
|
||||
(yCenter ? undef : false) : // x is centered
|
||||
(yCenter ? true : undef); // x is off-center
|
||||
};
|
||||
return Pathfinder;
|
||||
}());
|
||||
Pathfinder.prototype.algorithms = pathfinderAlgorithms;
|
||||
// Add to Highcharts namespace
|
||||
H.Pathfinder = Pathfinder;
|
||||
// Add pathfinding capabilities to Points
|
||||
extend(Point.prototype, /** @lends Point.prototype */ {
|
||||
/**
|
||||
* Get coordinates of anchor point for pathfinder connection.
|
||||
*
|
||||
* @private
|
||||
* @function Highcharts.Point#getPathfinderAnchorPoint
|
||||
*
|
||||
* @param {Highcharts.ConnectorsMarkerOptions} markerOptions
|
||||
* Connection options for position on point.
|
||||
*
|
||||
* @return {Highcharts.PositionObject}
|
||||
* An object with x/y properties for the position. Coordinates are
|
||||
* in plot values, not relative to point.
|
||||
*/
|
||||
getPathfinderAnchorPoint: function (markerOptions) {
|
||||
var bb = getPointBB(this), x, y;
|
||||
switch (markerOptions.align) { // eslint-disable-line default-case
|
||||
case 'right':
|
||||
x = 'xMax';
|
||||
break;
|
||||
case 'left':
|
||||
x = 'xMin';
|
||||
}
|
||||
switch (markerOptions.verticalAlign) { // eslint-disable-line default-case
|
||||
case 'top':
|
||||
y = 'yMin';
|
||||
break;
|
||||
case 'bottom':
|
||||
y = 'yMax';
|
||||
}
|
||||
return {
|
||||
x: x ? bb[x] : (bb.xMin + bb.xMax) / 2,
|
||||
y: y ? bb[y] : (bb.yMin + bb.yMax) / 2
|
||||
};
|
||||
},
|
||||
/**
|
||||
* Utility to get the angle from one point to another.
|
||||
*
|
||||
* @private
|
||||
* @function Highcharts.Point#getRadiansToVector
|
||||
*
|
||||
* @param {Highcharts.PositionObject} v1
|
||||
* The first vector, as an object with x/y properties.
|
||||
*
|
||||
* @param {Highcharts.PositionObject} v2
|
||||
* The second vector, as an object with x/y properties.
|
||||
*
|
||||
* @return {number}
|
||||
* The angle in degrees
|
||||
*/
|
||||
getRadiansToVector: function (v1, v2) {
|
||||
var box;
|
||||
if (!defined(v2)) {
|
||||
box = getPointBB(this);
|
||||
if (box) {
|
||||
v2 = {
|
||||
x: (box.xMin + box.xMax) / 2,
|
||||
y: (box.yMin + box.yMax) / 2
|
||||
};
|
||||
}
|
||||
}
|
||||
return Math.atan2(v2.y - v1.y, v1.x - v2.x);
|
||||
},
|
||||
/**
|
||||
* Utility to get the position of the marker, based on the path angle and
|
||||
* the marker's radius.
|
||||
*
|
||||
* @private
|
||||
* @function Highcharts.Point#getMarkerVector
|
||||
*
|
||||
* @param {number} radians
|
||||
* The angle in radians from the point center to another vector.
|
||||
*
|
||||
* @param {number} markerRadius
|
||||
* The radius of the marker, to calculate the additional distance to
|
||||
* the center of the marker.
|
||||
*
|
||||
* @param {Object} anchor
|
||||
* The anchor point of the path and marker as an object with x/y
|
||||
* properties.
|
||||
*
|
||||
* @return {Object}
|
||||
* The marker vector as an object with x/y properties.
|
||||
*/
|
||||
getMarkerVector: function (radians, markerRadius, anchor) {
|
||||
var twoPI = Math.PI * 2.0, theta = radians, bb = getPointBB(this), rectWidth = bb.xMax - bb.xMin, rectHeight = bb.yMax - bb.yMin, rAtan = Math.atan2(rectHeight, rectWidth), tanTheta = 1, leftOrRightRegion = false, rectHalfWidth = rectWidth / 2.0, rectHalfHeight = rectHeight / 2.0, rectHorizontalCenter = bb.xMin + rectHalfWidth, rectVerticalCenter = bb.yMin + rectHalfHeight, edgePoint = {
|
||||
x: rectHorizontalCenter,
|
||||
y: rectVerticalCenter
|
||||
}, xFactor = 1, yFactor = 1;
|
||||
while (theta < -Math.PI) {
|
||||
theta += twoPI;
|
||||
}
|
||||
while (theta > Math.PI) {
|
||||
theta -= twoPI;
|
||||
}
|
||||
tanTheta = Math.tan(theta);
|
||||
if ((theta > -rAtan) && (theta <= rAtan)) {
|
||||
// Right side
|
||||
yFactor = -1;
|
||||
leftOrRightRegion = true;
|
||||
}
|
||||
else if (theta > rAtan && theta <= (Math.PI - rAtan)) {
|
||||
// Top side
|
||||
yFactor = -1;
|
||||
}
|
||||
else if (theta > (Math.PI - rAtan) || theta <= -(Math.PI - rAtan)) {
|
||||
// Left side
|
||||
xFactor = -1;
|
||||
leftOrRightRegion = true;
|
||||
}
|
||||
else {
|
||||
// Bottom side
|
||||
xFactor = -1;
|
||||
}
|
||||
// Correct the edgePoint according to the placement of the marker
|
||||
if (leftOrRightRegion) {
|
||||
edgePoint.x += xFactor * (rectHalfWidth);
|
||||
edgePoint.y += yFactor * (rectHalfWidth) * tanTheta;
|
||||
}
|
||||
else {
|
||||
edgePoint.x += xFactor * (rectHeight / (2.0 * tanTheta));
|
||||
edgePoint.y += yFactor * (rectHalfHeight);
|
||||
}
|
||||
if (anchor.x !== rectHorizontalCenter) {
|
||||
edgePoint.x = anchor.x;
|
||||
}
|
||||
if (anchor.y !== rectVerticalCenter) {
|
||||
edgePoint.y = anchor.y;
|
||||
}
|
||||
return {
|
||||
x: edgePoint.x + (markerRadius * Math.cos(theta)),
|
||||
y: edgePoint.y - (markerRadius * Math.sin(theta))
|
||||
};
|
||||
}
|
||||
});
|
||||
/**
|
||||
* Warn if using legacy options. Copy the options over. Note that this will
|
||||
* still break if using the legacy options in chart.update, addSeries etc.
|
||||
* @private
|
||||
*/
|
||||
function warnLegacy(chart) {
|
||||
if (chart.options.pathfinder ||
|
||||
chart.series.reduce(function (acc, series) {
|
||||
if (series.options) {
|
||||
merge(true, (series.options.connectors = series.options.connectors ||
|
||||
{}), series.options.pathfinder);
|
||||
}
|
||||
return acc || series.options && series.options.pathfinder;
|
||||
}, false)) {
|
||||
merge(true, (chart.options.connectors = chart.options.connectors || {}), chart.options.pathfinder);
|
||||
error('WARNING: Pathfinder options have been renamed. ' +
|
||||
'Use "chart.connectors" or "series.connectors" instead.');
|
||||
}
|
||||
}
|
||||
// Initialize Pathfinder for charts
|
||||
Chart.prototype.callbacks.push(function (chart) {
|
||||
var options = chart.options;
|
||||
if (options.connectors.enabled !== false) {
|
||||
warnLegacy(chart);
|
||||
this.pathfinder = new Pathfinder(this);
|
||||
this.pathfinder.update(true); // First draw, defer render
|
||||
}
|
||||
});
|
||||
export default Pathfinder;
|
||||
Reference in New Issue
Block a user