811 lines
29 KiB
JavaScript
811 lines
29 KiB
JavaScript
/* *
|
|
* (c) 2016 Highsoft AS
|
|
* Author: Øystein Moseng
|
|
*
|
|
* License: www.highcharts.com/license
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
import H from '../parts/Globals.js';
|
|
import '../parts/Utilities.js';
|
|
|
|
var min = Math.min,
|
|
max = Math.max,
|
|
abs = Math.abs,
|
|
pick = H.pick;
|
|
|
|
/**
|
|
* Get index of last obstacle before xMin. Employs a type of binary search, and
|
|
* thus requires that obstacles are sorted by xMin value.
|
|
*
|
|
* @private
|
|
* @function findLastObstacleBefore
|
|
*
|
|
* @param {Array<object>} obstacles
|
|
* Array of obstacles to search in.
|
|
*
|
|
* @param {number} xMin
|
|
* The xMin threshold.
|
|
*
|
|
* @param {number} startIx
|
|
* Starting index to search from. Must be within array range.
|
|
*
|
|
* @return {number}
|
|
* The index of the last obstacle element before xMin.
|
|
*/
|
|
function findLastObstacleBefore(obstacles, xMin, startIx) {
|
|
var left = startIx || 0, // left limit
|
|
right = obstacles.length - 1, // right limit
|
|
min = xMin - 0.0000001, // Make sure we include all obstacles at xMin
|
|
cursor,
|
|
cmp;
|
|
while (left <= right) {
|
|
cursor = (right + left) >> 1;
|
|
cmp = min - obstacles[cursor].xMin;
|
|
if (cmp > 0) {
|
|
left = cursor + 1;
|
|
} else if (cmp < 0) {
|
|
right = cursor - 1;
|
|
} else {
|
|
return cursor;
|
|
}
|
|
}
|
|
return left > 0 ? left - 1 : 0;
|
|
}
|
|
|
|
/**
|
|
* Test if a point lays within an obstacle.
|
|
*
|
|
* @private
|
|
* @function pointWithinObstacle
|
|
*
|
|
* @param {object} obstacle
|
|
* Obstacle to test.
|
|
*
|
|
* @param {Highcharts.Point} point
|
|
* Point with x/y props.
|
|
*
|
|
* @return {boolean}
|
|
* Whether point is within the obstacle or not.
|
|
*/
|
|
function pointWithinObstacle(obstacle, point) {
|
|
return (
|
|
point.x <= obstacle.xMax &&
|
|
point.x >= obstacle.xMin &&
|
|
point.y <= obstacle.yMax &&
|
|
point.y >= obstacle.yMin
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Find the index of an obstacle that wraps around a point.
|
|
* Returns -1 if not found.
|
|
*
|
|
* @private
|
|
* @function findObstacleFromPoint
|
|
*
|
|
* @param {Array<object>} obstacles
|
|
* Obstacles to test.
|
|
*
|
|
* @param {Highcharts.Point} point
|
|
* Point with x/y props.
|
|
*
|
|
* @return {number}
|
|
* Ix of the obstacle in the array, or -1 if not found.
|
|
*/
|
|
function findObstacleFromPoint(obstacles, point) {
|
|
var i = findLastObstacleBefore(obstacles, point.x + 1) + 1;
|
|
while (i--) {
|
|
if (obstacles[i].xMax >= point.x &&
|
|
// optimization using lazy evaluation
|
|
pointWithinObstacle(obstacles[i], point)) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/**
|
|
* Get SVG path array from array of line segments.
|
|
*
|
|
* @private
|
|
* @function pathFromSegments
|
|
*
|
|
* @param {Array<object>} segments
|
|
* The segments to build the path from.
|
|
*
|
|
* @return {Highcharts.SVGPathArray}
|
|
* SVG path array as accepted by the SVG Renderer.
|
|
*/
|
|
function pathFromSegments(segments) {
|
|
var path = [];
|
|
if (segments.length) {
|
|
path.push('M', segments[0].start.x, segments[0].start.y);
|
|
for (var i = 0; i < segments.length; ++i) {
|
|
path.push('L', segments[i].end.x, segments[i].end.y);
|
|
}
|
|
}
|
|
return path;
|
|
}
|
|
|
|
/**
|
|
* Limits obstacle max/mins in all directions to bounds. Modifies input
|
|
* obstacle.
|
|
*
|
|
* @private
|
|
* @function limitObstacleToBounds
|
|
*
|
|
* @param {object} obstacle
|
|
* Obstacle to limit.
|
|
*
|
|
* @param {object} bounds
|
|
* Bounds to use as limit.
|
|
*/
|
|
function limitObstacleToBounds(obstacle, bounds) {
|
|
obstacle.yMin = max(obstacle.yMin, bounds.yMin);
|
|
obstacle.yMax = min(obstacle.yMax, bounds.yMax);
|
|
obstacle.xMin = max(obstacle.xMin, bounds.xMin);
|
|
obstacle.xMax = min(obstacle.xMax, bounds.xMax);
|
|
}
|
|
|
|
|
|
|
|
// Define the available pathfinding algorithms.
|
|
// Algorithms take up to 3 arguments: starting point, ending point, and an
|
|
// options object.
|
|
var algorithms = {
|
|
|
|
/**
|
|
* Get an SVG path from a starting coordinate to an ending coordinate.
|
|
* Draws a straight line.
|
|
*
|
|
* @function Highcharts.Pathfinder.algorithms.straight
|
|
*
|
|
* @param {object} start
|
|
* Starting coordinate, object with x/y props.
|
|
*
|
|
* @param {object} end
|
|
* Ending coordinate, object with x/y props.
|
|
*
|
|
* @return {object}
|
|
* An object with the SVG path in Array form as accepted by the SVG
|
|
* renderer, as well as an array of new obstacles making up this
|
|
* path.
|
|
*/
|
|
straight: function (start, end) {
|
|
return {
|
|
path: ['M', start.x, start.y, 'L', end.x, end.y],
|
|
obstacles: [{ start: start, end: end }]
|
|
};
|
|
},
|
|
|
|
/**
|
|
* Find a path from a starting coordinate to an ending coordinate, using
|
|
* right angles only, and taking only starting/ending obstacle into
|
|
* consideration.
|
|
*
|
|
* @function Highcharts.Pathfinder.algorithms.simpleConnect
|
|
*
|
|
* @param {object} start
|
|
* Starting coordinate, object with x/y props.
|
|
*
|
|
* @param {object} end
|
|
* Ending coordinate, object with x/y props.
|
|
*
|
|
* @param {object} options
|
|
* Options for the algorithm:
|
|
* - chartObstacles: Array of chart obstacles to avoid
|
|
* - startDirectionX: Optional. True if starting in the X direction.
|
|
* If not provided, the algorithm starts in the direction that is
|
|
* the furthest between start/end.
|
|
*
|
|
* @return {object}
|
|
* An object with the SVG path in Array form as accepted by the SVG
|
|
* renderer, as well as an array of new obstacles making up this
|
|
* path.
|
|
*/
|
|
simpleConnect: H.extend(function (start, end, options) {
|
|
var segments = [],
|
|
endSegment,
|
|
dir = pick(
|
|
options.startDirectionX,
|
|
abs(end.x - start.x) > abs(end.y - start.y)
|
|
) ? 'x' : 'y',
|
|
chartObstacles = options.chartObstacles,
|
|
startObstacleIx = findObstacleFromPoint(chartObstacles, start),
|
|
endObstacleIx = findObstacleFromPoint(chartObstacles, end),
|
|
startObstacle,
|
|
endObstacle,
|
|
prevWaypoint,
|
|
waypoint,
|
|
waypoint2,
|
|
useMax,
|
|
endPoint;
|
|
|
|
// Return a clone of a point with a property set from a target object,
|
|
// optionally with an offset
|
|
function copyFromPoint(from, fromKey, to, toKey, offset) {
|
|
var point = {
|
|
x: from.x,
|
|
y: from.y
|
|
};
|
|
point[fromKey] = to[toKey || fromKey] + (offset || 0);
|
|
return point;
|
|
}
|
|
|
|
// Return waypoint outside obstacle
|
|
function getMeOut(obstacle, point, direction) {
|
|
var useMax = abs(point[direction] - obstacle[direction + 'Min']) >
|
|
abs(point[direction] - obstacle[direction + 'Max']);
|
|
return copyFromPoint(
|
|
point,
|
|
direction,
|
|
obstacle,
|
|
direction + (useMax ? 'Max' : 'Min'),
|
|
useMax ? 1 : -1
|
|
);
|
|
}
|
|
|
|
// Pull out end point
|
|
if (endObstacleIx > -1) {
|
|
endObstacle = chartObstacles[endObstacleIx];
|
|
waypoint = getMeOut(endObstacle, end, dir);
|
|
endSegment = {
|
|
start: waypoint,
|
|
end: end
|
|
};
|
|
endPoint = waypoint;
|
|
} else {
|
|
endPoint = end;
|
|
}
|
|
|
|
// If an obstacle envelops the start point, add a segment to get out,
|
|
// and around it.
|
|
if (startObstacleIx > -1) {
|
|
startObstacle = chartObstacles[startObstacleIx];
|
|
waypoint = getMeOut(startObstacle, start, dir);
|
|
segments.push({
|
|
start: start,
|
|
end: waypoint
|
|
});
|
|
|
|
// If we are going back again, switch direction to get around start
|
|
// obstacle.
|
|
if (
|
|
waypoint[dir] > start[dir] === // Going towards max from start
|
|
waypoint[dir] > endPoint[dir] // Going towards min to end
|
|
) {
|
|
dir = dir === 'y' ? 'x' : 'y';
|
|
useMax = start[dir] < end[dir];
|
|
segments.push({
|
|
start: waypoint,
|
|
end: copyFromPoint(
|
|
waypoint,
|
|
dir,
|
|
startObstacle,
|
|
dir + (useMax ? 'Max' : 'Min'),
|
|
useMax ? 1 : -1
|
|
)
|
|
});
|
|
|
|
// Switch direction again
|
|
dir = dir === 'y' ? 'x' : 'y';
|
|
}
|
|
}
|
|
|
|
// We are around the start obstacle. Go towards the end in one
|
|
// direction.
|
|
prevWaypoint = segments.length ?
|
|
segments[segments.length - 1].end :
|
|
start;
|
|
waypoint = copyFromPoint(prevWaypoint, dir, endPoint);
|
|
segments.push({
|
|
start: prevWaypoint,
|
|
end: waypoint
|
|
});
|
|
|
|
// Final run to end point in the other direction
|
|
dir = dir === 'y' ? 'x' : 'y';
|
|
waypoint2 = copyFromPoint(waypoint, dir, endPoint);
|
|
segments.push({
|
|
start: waypoint,
|
|
end: waypoint2
|
|
});
|
|
|
|
// Finally add the endSegment
|
|
segments.push(endSegment);
|
|
|
|
return {
|
|
path: pathFromSegments(segments),
|
|
obstacles: segments
|
|
};
|
|
}, {
|
|
requiresObstacles: true
|
|
}),
|
|
|
|
/**
|
|
* Find a path from a starting coordinate to an ending coordinate, taking
|
|
* obstacles into consideration. Might not always find the optimal path,
|
|
* but is fast, and usually good enough.
|
|
*
|
|
* @function Highcharts.Pathfinder.algorithms.fastAvoid
|
|
*
|
|
* @param {object} start
|
|
* Starting coordinate, object with x/y props.
|
|
*
|
|
* @param {object} end
|
|
* Ending coordinate, object with x/y props.
|
|
*
|
|
* @param {object} options
|
|
* Options for the algorithm.
|
|
* - chartObstacles: Array of chart obstacles to avoid
|
|
* - lineObstacles: Array of line obstacles to jump over
|
|
* - obstacleMetrics: Object with metrics of chartObstacles cached
|
|
* - hardBounds: Hard boundaries to not cross
|
|
* - obstacleOptions: Options for the obstacles, including margin
|
|
* - startDirectionX: Optional. True if starting in the X direction.
|
|
* If not provided, the algorithm starts in the
|
|
* direction that is the furthest between
|
|
* start/end.
|
|
*
|
|
* @return {object}
|
|
* An object with the SVG path in Array form as accepted by the SVG
|
|
* renderer, as well as an array of new obstacles making up this
|
|
* path.
|
|
*/
|
|
fastAvoid: H.extend(function (start, end, options) {
|
|
/*
|
|
Algorithm rules/description
|
|
- Find initial direction
|
|
- Determine soft/hard max for each direction.
|
|
- Move along initial direction until obstacle.
|
|
- Change direction.
|
|
- If hitting obstacle, first try to change length of previous line
|
|
before changing direction again.
|
|
|
|
Soft min/max x = start/destination x +/- widest obstacle + margin
|
|
Soft min/max y = start/destination y +/- tallest obstacle + margin
|
|
|
|
@todo:
|
|
- Make retrospective, try changing prev segment to reduce
|
|
corners
|
|
- Fix logic for breaking out of end-points - not always picking
|
|
the best direction currently
|
|
- When going around the end obstacle we should not always go the
|
|
shortest route, rather pick the one closer to the end point
|
|
*/
|
|
var dirIsX = pick(
|
|
options.startDirectionX,
|
|
abs(end.x - start.x) > abs(end.y - start.y)
|
|
),
|
|
dir = dirIsX ? 'x' : 'y',
|
|
segments,
|
|
useMax,
|
|
extractedEndPoint,
|
|
endSegments = [],
|
|
forceObstacleBreak = false, // Used in clearPathTo to keep track of
|
|
// when to force break through an obstacle.
|
|
|
|
// Boundaries to stay within. If beyond soft boundary, prefer to
|
|
// change direction ASAP. If at hard max, always change immediately.
|
|
metrics = options.obstacleMetrics,
|
|
softMinX = min(start.x, end.x) - metrics.maxWidth - 10,
|
|
softMaxX = max(start.x, end.x) + metrics.maxWidth + 10,
|
|
softMinY = min(start.y, end.y) - metrics.maxHeight - 10,
|
|
softMaxY = max(start.y, end.y) + metrics.maxHeight + 10,
|
|
|
|
// Obstacles
|
|
chartObstacles = options.chartObstacles,
|
|
startObstacleIx = findLastObstacleBefore(chartObstacles, softMinX),
|
|
endObstacleIx = findLastObstacleBefore(chartObstacles, softMaxX);
|
|
|
|
// How far can you go between two points before hitting an obstacle?
|
|
// Does not work for diagonal lines (because it doesn't have to).
|
|
function pivotPoint(fromPoint, toPoint, directionIsX) {
|
|
var firstPoint,
|
|
lastPoint,
|
|
highestPoint,
|
|
lowestPoint,
|
|
i,
|
|
searchDirection = fromPoint.x < toPoint.x ? 1 : -1;
|
|
|
|
if (fromPoint.x < toPoint.x) {
|
|
firstPoint = fromPoint;
|
|
lastPoint = toPoint;
|
|
} else {
|
|
firstPoint = toPoint;
|
|
lastPoint = fromPoint;
|
|
}
|
|
|
|
if (fromPoint.y < toPoint.y) {
|
|
lowestPoint = fromPoint;
|
|
highestPoint = toPoint;
|
|
} else {
|
|
lowestPoint = toPoint;
|
|
highestPoint = fromPoint;
|
|
}
|
|
|
|
// Go through obstacle range in reverse if toPoint is before
|
|
// fromPoint in the X-dimension.
|
|
i = searchDirection < 0 ?
|
|
// Searching backwards, start at last obstacle before last point
|
|
min(findLastObstacleBefore(chartObstacles, lastPoint.x),
|
|
chartObstacles.length - 1) :
|
|
// Forwards. Since we're not sorted by xMax, we have to look
|
|
// at all obstacles.
|
|
0;
|
|
|
|
// Go through obstacles in this X range
|
|
while (chartObstacles[i] && (
|
|
searchDirection > 0 && chartObstacles[i].xMin <= lastPoint.x ||
|
|
searchDirection < 0 && chartObstacles[i].xMax >= firstPoint.x
|
|
)) {
|
|
// If this obstacle is between from and to points in a straight
|
|
// line, pivot at the intersection.
|
|
if (
|
|
chartObstacles[i].xMin <= lastPoint.x &&
|
|
chartObstacles[i].xMax >= firstPoint.x &&
|
|
chartObstacles[i].yMin <= highestPoint.y &&
|
|
chartObstacles[i].yMax >= lowestPoint.y
|
|
) {
|
|
if (directionIsX) {
|
|
return {
|
|
y: fromPoint.y,
|
|
x: fromPoint.x < toPoint.x ?
|
|
chartObstacles[i].xMin - 1 :
|
|
chartObstacles[i].xMax + 1,
|
|
obstacle: chartObstacles[i]
|
|
};
|
|
}
|
|
// else ...
|
|
return {
|
|
x: fromPoint.x,
|
|
y: fromPoint.y < toPoint.y ?
|
|
chartObstacles[i].yMin - 1 :
|
|
chartObstacles[i].yMax + 1,
|
|
obstacle: chartObstacles[i]
|
|
};
|
|
}
|
|
|
|
i += searchDirection;
|
|
}
|
|
|
|
return toPoint;
|
|
}
|
|
|
|
/**
|
|
* Decide in which direction to dodge or get out of an obstacle.
|
|
* Considers desired direction, which way is shortest, soft and hard
|
|
* bounds.
|
|
*
|
|
* (? Returns a string, either xMin, xMax, yMin or yMax.)
|
|
*
|
|
* @private
|
|
* @function
|
|
*
|
|
* @param {object} obstacle
|
|
* Obstacle to dodge/escape.
|
|
*
|
|
* @param {object} fromPoint
|
|
* Point with x/y props that's dodging/escaping.
|
|
*
|
|
* @param {object} toPoint
|
|
* Goal point.
|
|
*
|
|
* @param {boolean} dirIsX
|
|
* Dodge in X dimension.
|
|
*
|
|
* @param {object} bounds
|
|
* Hard and soft boundaries.
|
|
*
|
|
* @return {boolean}
|
|
* Use max or not.
|
|
*/
|
|
function getDodgeDirection(
|
|
obstacle,
|
|
fromPoint,
|
|
toPoint,
|
|
dirIsX,
|
|
bounds
|
|
) {
|
|
var softBounds = bounds.soft,
|
|
hardBounds = bounds.hard,
|
|
dir = dirIsX ? 'x' : 'y',
|
|
toPointMax = { x: fromPoint.x, y: fromPoint.y },
|
|
toPointMin = { x: fromPoint.x, y: fromPoint.y },
|
|
minPivot,
|
|
maxPivot,
|
|
maxOutOfSoftBounds = obstacle[dir + 'Max'] >=
|
|
softBounds[dir + 'Max'],
|
|
minOutOfSoftBounds = obstacle[dir + 'Min'] <=
|
|
softBounds[dir + 'Min'],
|
|
maxOutOfHardBounds = obstacle[dir + 'Max'] >=
|
|
hardBounds[dir + 'Max'],
|
|
minOutOfHardBounds = obstacle[dir + 'Min'] <=
|
|
hardBounds[dir + 'Min'],
|
|
// Find out if we should prefer one direction over the other if
|
|
// we can choose freely
|
|
minDistance = abs(obstacle[dir + 'Min'] - fromPoint[dir]),
|
|
maxDistance = abs(obstacle[dir + 'Max'] - fromPoint[dir]),
|
|
// If it's a small difference, pick the one leading towards dest
|
|
// point. Otherwise pick the shortest distance
|
|
useMax = abs(minDistance - maxDistance) < 10 ?
|
|
fromPoint[dir] < toPoint[dir] :
|
|
maxDistance < minDistance;
|
|
|
|
// Check if we hit any obstacles trying to go around in either
|
|
// direction.
|
|
toPointMin[dir] = obstacle[dir + 'Min'];
|
|
toPointMax[dir] = obstacle[dir + 'Max'];
|
|
minPivot = pivotPoint(fromPoint, toPointMin, dirIsX)[dir] !==
|
|
toPointMin[dir];
|
|
maxPivot = pivotPoint(fromPoint, toPointMax, dirIsX)[dir] !==
|
|
toPointMax[dir];
|
|
useMax = minPivot ?
|
|
(maxPivot ? useMax : true) :
|
|
(maxPivot ? false : useMax);
|
|
|
|
// useMax now contains our preferred choice, bounds not taken into
|
|
// account. If both or neither direction is out of bounds we want to
|
|
// use this.
|
|
|
|
// Deal with soft bounds
|
|
useMax = minOutOfSoftBounds ?
|
|
(maxOutOfSoftBounds ? useMax : true) : // Out on min
|
|
(maxOutOfSoftBounds ? false : useMax); // Not out on min
|
|
|
|
// Deal with hard bounds
|
|
useMax = minOutOfHardBounds ?
|
|
(maxOutOfHardBounds ? useMax : true) : // Out on min
|
|
(maxOutOfHardBounds ? false : useMax); // Not out on min
|
|
|
|
return useMax;
|
|
}
|
|
|
|
// Find a clear path between point
|
|
function clearPathTo(fromPoint, toPoint, dirIsX) {
|
|
// Don't waste time if we've hit goal
|
|
if (fromPoint.x === toPoint.x && fromPoint.y === toPoint.y) {
|
|
return [];
|
|
}
|
|
|
|
var dir = dirIsX ? 'x' : 'y',
|
|
pivot,
|
|
segments,
|
|
waypoint,
|
|
waypointUseMax,
|
|
envelopingObstacle,
|
|
secondEnvelopingObstacle,
|
|
envelopWaypoint,
|
|
obstacleMargin = options.obstacleOptions.margin,
|
|
bounds = {
|
|
soft: {
|
|
xMin: softMinX,
|
|
xMax: softMaxX,
|
|
yMin: softMinY,
|
|
yMax: softMaxY
|
|
},
|
|
hard: options.hardBounds
|
|
};
|
|
|
|
// If fromPoint is inside an obstacle we have a problem. Break out
|
|
// by just going to the outside of this obstacle. We prefer to go to
|
|
// the nearest edge in the chosen direction.
|
|
envelopingObstacle =
|
|
findObstacleFromPoint(chartObstacles, fromPoint);
|
|
if (envelopingObstacle > -1) {
|
|
envelopingObstacle = chartObstacles[envelopingObstacle];
|
|
waypointUseMax = getDodgeDirection(
|
|
envelopingObstacle, fromPoint, toPoint, dirIsX, bounds
|
|
);
|
|
|
|
// Cut obstacle to hard bounds to make sure we stay within
|
|
limitObstacleToBounds(envelopingObstacle, options.hardBounds);
|
|
|
|
envelopWaypoint = dirIsX ? {
|
|
y: fromPoint.y,
|
|
x: envelopingObstacle[waypointUseMax ? 'xMax' : 'xMin'] +
|
|
(waypointUseMax ? 1 : -1)
|
|
} : {
|
|
x: fromPoint.x,
|
|
y: envelopingObstacle[waypointUseMax ? 'yMax' : 'yMin'] +
|
|
(waypointUseMax ? 1 : -1)
|
|
};
|
|
|
|
// If we crashed into another obstacle doing this, we put the
|
|
// waypoint between them instead
|
|
secondEnvelopingObstacle = findObstacleFromPoint(
|
|
chartObstacles, envelopWaypoint);
|
|
if (secondEnvelopingObstacle > -1) {
|
|
secondEnvelopingObstacle = chartObstacles[
|
|
secondEnvelopingObstacle
|
|
];
|
|
|
|
// Cut obstacle to hard bounds
|
|
limitObstacleToBounds(
|
|
secondEnvelopingObstacle,
|
|
options.hardBounds
|
|
);
|
|
|
|
// Modify waypoint to lay between obstacles
|
|
envelopWaypoint[dir] = waypointUseMax ? max(
|
|
envelopingObstacle[dir + 'Max'] - obstacleMargin + 1,
|
|
(
|
|
secondEnvelopingObstacle[dir + 'Min'] +
|
|
envelopingObstacle[dir + 'Max']
|
|
) / 2
|
|
) :
|
|
min(
|
|
envelopingObstacle[dir + 'Min'] + obstacleMargin - 1,
|
|
(
|
|
secondEnvelopingObstacle[dir + 'Max'] +
|
|
envelopingObstacle[dir + 'Min']
|
|
) / 2
|
|
);
|
|
|
|
// We are not going anywhere. If this happens for the first
|
|
// time, do nothing. Otherwise, try to go to the extreme of
|
|
// the obstacle pair in the current direction.
|
|
if (fromPoint.x === envelopWaypoint.x &&
|
|
fromPoint.y === envelopWaypoint.y) {
|
|
if (forceObstacleBreak) {
|
|
envelopWaypoint[dir] = waypointUseMax ?
|
|
max(
|
|
envelopingObstacle[dir + 'Max'],
|
|
secondEnvelopingObstacle[dir + 'Max']
|
|
) + 1 :
|
|
min(
|
|
envelopingObstacle[dir + 'Min'],
|
|
secondEnvelopingObstacle[dir + 'Min']
|
|
) - 1;
|
|
}
|
|
// Toggle on if off, and the opposite
|
|
forceObstacleBreak = !forceObstacleBreak;
|
|
} else {
|
|
// This point is not identical to previous.
|
|
// Clear break trigger.
|
|
forceObstacleBreak = false;
|
|
}
|
|
}
|
|
|
|
segments = [{
|
|
start: fromPoint,
|
|
end: envelopWaypoint
|
|
}];
|
|
|
|
} else { // If not enveloping, use standard pivot calculation
|
|
|
|
pivot = pivotPoint(fromPoint, {
|
|
x: dirIsX ? toPoint.x : fromPoint.x,
|
|
y: dirIsX ? fromPoint.y : toPoint.y
|
|
}, dirIsX);
|
|
|
|
segments = [{
|
|
start: fromPoint,
|
|
end: {
|
|
x: pivot.x,
|
|
y: pivot.y
|
|
}
|
|
}];
|
|
|
|
// Pivot before goal, use a waypoint to dodge obstacle
|
|
if (pivot[dirIsX ? 'x' : 'y'] !== toPoint[dirIsX ? 'x' : 'y']) {
|
|
// Find direction of waypoint
|
|
waypointUseMax = getDodgeDirection(
|
|
pivot.obstacle, pivot, toPoint, !dirIsX, bounds
|
|
);
|
|
|
|
// Cut waypoint to hard bounds
|
|
limitObstacleToBounds(pivot.obstacle, options.hardBounds);
|
|
|
|
waypoint = {
|
|
x: dirIsX ?
|
|
pivot.x :
|
|
pivot.obstacle[waypointUseMax ? 'xMax' : 'xMin'] +
|
|
(waypointUseMax ? 1 : -1),
|
|
y: dirIsX ?
|
|
pivot.obstacle[waypointUseMax ? 'yMax' : 'yMin'] +
|
|
(waypointUseMax ? 1 : -1) :
|
|
pivot.y
|
|
};
|
|
|
|
// We're changing direction here, store that to make sure we
|
|
// also change direction when adding the last segment array
|
|
// after handling waypoint.
|
|
dirIsX = !dirIsX;
|
|
|
|
segments = segments.concat(clearPathTo({
|
|
x: pivot.x,
|
|
y: pivot.y
|
|
}, waypoint, dirIsX));
|
|
}
|
|
}
|
|
|
|
// Get segments for the other direction too
|
|
// Recursion is our friend
|
|
segments = segments.concat(clearPathTo(
|
|
segments[segments.length - 1].end, toPoint, !dirIsX
|
|
));
|
|
|
|
return segments;
|
|
}
|
|
|
|
// Extract point to outside of obstacle in whichever direction is
|
|
// closest. Returns new point outside obstacle.
|
|
function extractFromObstacle(obstacle, point, goalPoint) {
|
|
var dirIsX = min(obstacle.xMax - point.x, point.x - obstacle.xMin) <
|
|
min(obstacle.yMax - point.y, point.y - obstacle.yMin),
|
|
bounds = {
|
|
soft: options.hardBounds,
|
|
hard: options.hardBounds
|
|
},
|
|
useMax = getDodgeDirection(
|
|
obstacle, point, goalPoint, dirIsX, bounds
|
|
);
|
|
|
|
return dirIsX ? {
|
|
y: point.y,
|
|
x: obstacle[useMax ? 'xMax' : 'xMin'] + (useMax ? 1 : -1)
|
|
} : {
|
|
x: point.x,
|
|
y: obstacle[useMax ? 'yMax' : 'yMin'] + (useMax ? 1 : -1)
|
|
};
|
|
}
|
|
|
|
// Cut the obstacle array to soft bounds for optimization in large
|
|
// datasets.
|
|
chartObstacles =
|
|
chartObstacles.slice(startObstacleIx, endObstacleIx + 1);
|
|
|
|
// If an obstacle envelops the end point, move it out of there and add
|
|
// a little segment to where it was.
|
|
if ((endObstacleIx = findObstacleFromPoint(chartObstacles, end)) > -1) {
|
|
extractedEndPoint = extractFromObstacle(
|
|
chartObstacles[endObstacleIx],
|
|
end,
|
|
start
|
|
);
|
|
endSegments.push({
|
|
end: end,
|
|
start: extractedEndPoint
|
|
});
|
|
end = extractedEndPoint;
|
|
}
|
|
// If it's still inside one or more obstacles, get out of there by
|
|
// force-moving towards the start point.
|
|
while (
|
|
(endObstacleIx = findObstacleFromPoint(chartObstacles, end)) > -1
|
|
) {
|
|
useMax = end[dir] - start[dir] < 0;
|
|
extractedEndPoint = {
|
|
x: end.x,
|
|
y: end.y
|
|
};
|
|
extractedEndPoint[dir] = chartObstacles[endObstacleIx][
|
|
useMax ? dir + 'Max' : dir + 'Min'
|
|
] + (useMax ? 1 : -1);
|
|
endSegments.push({
|
|
end: end,
|
|
start: extractedEndPoint
|
|
});
|
|
end = extractedEndPoint;
|
|
}
|
|
|
|
// Find the path
|
|
segments = clearPathTo(start, end, dirIsX);
|
|
|
|
// Add the end-point segments
|
|
segments = segments.concat(endSegments.reverse());
|
|
|
|
return {
|
|
path: pathFromSegments(segments),
|
|
obstacles: segments
|
|
};
|
|
}, {
|
|
requiresObstacles: true
|
|
})
|
|
};
|
|
|
|
export default algorithms;
|