Contour line labels #1815
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,195 @@ | ||
| /** | ||
| * Copyright 2012-2017, Plotly, Inc. | ||
| * All rights reserved. | ||
| * | ||
| * This source code is licensed under the MIT license found in the | ||
| * LICENSE file in the root directory of this source tree. | ||
| */ | ||
|
|
||
| 'use strict'; | ||
|
|
||
| var mod = require('./mod'); | ||
|
|
||
| /* | ||
| * look for intersection of two line segments | ||
| * (1->2 and 3->4) - returns array [x,y] if they do, null if not | ||
| */ | ||
| exports.segmentsIntersect = segmentsIntersect; | ||
| function segmentsIntersect(x1, y1, x2, y2, x3, y3, x4, y4) { | ||
| var a = x2 - x1, | ||
| b = x3 - x1, | ||
| c = x4 - x3, | ||
| d = y2 - y1, | ||
| e = y3 - y1, | ||
| f = y4 - y3, | ||
| det = a * f - c * d; | ||
| // parallel lines? intersection is undefined | ||
| // ignore the case where they are colinear | ||
| if(det === 0) return null; | ||
| var t = (b * f - c * e) / det, | ||
| u = (b * d - a * e) / det; | ||
|
There was a problem hiding this comment. If I were really going to nitpick, I'd suggest comparing bounding boxes first and here multiplying through by |
||
| // segments do not intersect? | ||
| if(u < 0 || u > 1 || t < 0 || t > 1) return null; | ||
|
|
||
| return {x: x1 + a * t, y: y1 + d * t}; | ||
| } | ||
|
|
||
| /* | ||
| * find the minimum distance between two line segments (1->2 and 3->4) | ||
| */ | ||
| exports.segmentDistance = function segmentDistance(x1, y1, x2, y2, x3, y3, x4, y4) { | ||
| if(segmentsIntersect(x1, y1, x2, y2, x3, y3, x4, y4)) return 0; | ||
|
|
||
| // the two segments and their lengths squared | ||
| var x12 = x2 - x1; | ||
| var y12 = y2 - y1; | ||
| var x34 = x4 - x3; | ||
| var y34 = y4 - y3; | ||
| var l2_12 = x12 * x12 + y12 * y12; | ||
| var l2_34 = x34 * x34 + y34 * y34; | ||
|
|
||
| // calculate distance squared, then take the sqrt at the very end | ||
| var dist2 = Math.min( | ||
| perpDistance2(x12, y12, l2_12, x3 - x1, y3 - y1), | ||
| perpDistance2(x12, y12, l2_12, x4 - x1, y4 - y1), | ||
| perpDistance2(x34, y34, l2_34, x1 - x3, y1 - y3), | ||
| perpDistance2(x34, y34, l2_34, x2 - x3, y2 - y3) | ||
| ); | ||
|
|
||
| return Math.sqrt(dist2); | ||
| }; | ||
|
|
||
| /* | ||
| * distance squared from segment ab to point c | ||
| * [xab, yab] is the vector b-a | ||
| * [xac, yac] is the vector c-a | ||
| * l2_ab is the length squared of (b-a), just to simplify calculation | ||
| */ | ||
| function perpDistance2(xab, yab, l2_ab, xac, yac) { | ||
| var fc_ab = (xac * xab + yac * yab); | ||
| if(fc_ab < 0) { | ||
| // point c is closer to point a | ||
| return xac * xac + yac * yac; | ||
| } | ||
| else if(fc_ab > l2_ab) { | ||
| // point c is closer to point b | ||
| var xbc = xac - xab; | ||
| var ybc = yac - yab; | ||
| return xbc * xbc + ybc * ybc; | ||
| } | ||
| else { | ||
| // perpendicular distance is the shortest | ||
| var crossProduct = xac * yab - yac * xab; | ||
| return crossProduct * crossProduct / l2_ab; | ||
| } | ||
| } | ||
|
|
||
| // a very short-term cache for getTextLocation, just because | ||
| // we're often looping over the same locations multiple times | ||
| // invalidated as soon as we look at a different path | ||
| var locationCache, workingPath, workingTextWidth; | ||
|
|
||
| // turn a path and position along it into x, y, and angle for the given text | ||
| exports.getTextLocation = function getTextLocation(path, totalPathLen, positionOnPath, textWidth) { | ||
| if(path !== workingPath || textWidth !== workingTextWidth) { | ||
| locationCache = {}; | ||
| workingPath = path; | ||
| workingTextWidth = textWidth; | ||
| } | ||
| if(locationCache[positionOnPath]) { | ||
| return locationCache[positionOnPath]; | ||
| } | ||
|
|
||
| // for the angle, use points on the path separated by the text width | ||
| // even though due to curvature, the text will cover a bit more than that | ||
| var p0 = path.getPointAtLength(mod(positionOnPath - textWidth / 2, totalPathLen)); | ||
| var p1 = path.getPointAtLength(mod(positionOnPath + textWidth / 2, totalPathLen)); | ||
| // note: atan handles 1/0 nicely | ||
| var theta = Math.atan((p1.y - p0.y) / (p1.x - p0.x)); | ||
| // center the text at 2/3 of the center position plus 1/3 the p0/p1 midpoint | ||
| // that's the average position of this segment, assuming it's roughly quadratic | ||
| var pCenter = path.getPointAtLength(mod(positionOnPath, totalPathLen)); | ||
| var x = (pCenter.x * 4 + p0.x + p1.x) / 6; | ||
| var y = (pCenter.y * 4 + p0.y + p1.y) / 6; | ||
|
|
||
| var out = {x: x, y: y, theta: theta}; | ||
| locationCache[positionOnPath] = out; | ||
| return out; | ||
| }; | ||
|
|
||
| exports.clearLocationCache = function() { | ||
| workingPath = null; | ||
| }; | ||
|
|
||
| /* | ||
| * Find the segment of `path` that's within the visible area | ||
| * given by `bounds` {left, right, top, bottom}, to within a | ||
| * precision of `buffer` px | ||
| * | ||
| * returns: undefined if nothing is visible, else object: | ||
| * { | ||
| * min: position where the path first enters bounds, or 0 if it | ||
| * starts within bounds | ||
| * max: position where the path last exits bounds, or the path length | ||
| * if it finishes within bounds | ||
| * len: max - min, ie the length of visible path | ||
| * total: the total path length - just included so the caller doesn't | ||
| * need to call path.getTotalLength() again | ||
| * isClosed: true iff the start and end points of the path are both visible | ||
| * and are at the same point | ||
| * } | ||
| * | ||
| * Works by starting from either end and repeatedly finding the distance from | ||
| * that point to the plot area, and if it's outside the plot, moving along the | ||
| * path by that distance (because the plot must be at least that far away on | ||
| * the path). Note that if a path enters, exits, and re-enters the plot, we | ||
| * will not capture this behavior. | ||
| */ | ||
| exports.getVisibleSegment = function getVisibleSegment(path, bounds, buffer) { | ||
|
There was a problem hiding this comment. Oh man, I've implemented something similar to this before. It's such a pain! |
||
| var left = bounds.left; | ||
| var right = bounds.right; | ||
| var top = bounds.top; | ||
| var bottom = bounds.bottom; | ||
|
|
||
| var pMin = 0; | ||
| var pTotal = path.getTotalLength(); | ||
| var pMax = pTotal; | ||
|
|
||
| var pt0, ptTotal; | ||
|
|
||
| function getDistToPlot(len) { | ||
| var pt = path.getPointAtLength(len); | ||
|
|
||
| // hold on to the start and end points for `closed` | ||
| if(len === 0) pt0 = pt; | ||
| else if(len === pTotal) ptTotal = pt; | ||
|
|
||
| var dx = (pt.x < left) ? left - pt.x : (pt.x > right ? pt.x - right : 0); | ||
| var dy = (pt.y < top) ? top - pt.y : (pt.y > bottom ? pt.y - bottom : 0); | ||
| return Math.sqrt(dx * dx + dy * dy); | ||
| } | ||
|
|
||
| var distToPlot = getDistToPlot(pMin); | ||
| while(distToPlot) { | ||
| pMin += distToPlot + buffer; | ||
| if(pMin > pMax) return; | ||
| distToPlot = getDistToPlot(pMin); | ||
| } | ||
|
|
||
| distToPlot = getDistToPlot(pMax); | ||
| while(distToPlot) { | ||
| pMax -= distToPlot + buffer; | ||
| if(pMin > pMax) return; | ||
| distToPlot = getDistToPlot(pMax); | ||
| } | ||
|
|
||
| return { | ||
| min: pMin, | ||
| max: pMax, | ||
| len: pMax - pMin, | ||
| total: pTotal, | ||
| isClosed: pMin === 0 && pMax === pTotal && | ||
| Math.abs(pt0.x - ptTotal.x) < 0.1 && | ||
| Math.abs(pt0.y - ptTotal.y) < 0.1 | ||
| }; | ||
| }; | ||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Not part of this PR and I'm sure no meaningful performance hit, but is
reducenecessary here? Seems likewould be more concise and readable and would bail out early when it can.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Unless that equates to an
allcondition where you actually need to check all. Not 100% sure. The^is a bit confusing.