comments

Author: kurkle

src/controllers/controller.radar.js

@@ -150,7 +150,7 @@ module.exports = DatasetController.extend({
 			point._model = {
 				x,
 				y,
-				r: pointPosition.r,
+				r: pointPosition.r, // `r` refers to radial axis, value is in radians
 				skip: isNaN(x) || isNaN(y),
 				// Appearance
 				radius: options.radius,

src/elements/element.line.js

@@ -38,15 +38,27 @@ function lineTo(ctx, previous, target) {
 }
 
 function getLineMethod(line) {
-	return line.steppedLine ? _steppedLineTo
-		: !line.tension ? lineTo
-		: _bezierCurveTo;
+	if (line.steppedLine) {
+		return _steppedLineTo;
+	}
+
+	if (line.tension) {
+		return _bezierCurveTo;
+	}
+
+	return lineTo;
 }
 
 function getInterpolationMethod(line) {
-	return line.steppedLine ? steppedInterpolation
-		: !line.tension ? pointInLine
-		: bezierInterpolation;
+	if (line.steppedLine) {
+		return steppedInterpolation;
+	}
+
+	if (line.tension) {
+		return bezierInterpolation;
+	}
+
+	return pointInLine;
 }
 
 function pathSegment(ctx, line, segment, options) {
@@ -104,11 +116,11 @@ function fastPath(ctx, points, line, options) {
 	let {move = true, startIndex = 0, reverse = false} = options;
 	let count = 0;
 	let avgX = 0;
-	let i, index, point, truncX, prevX, minY, maxY, lastY;
+	let i, prevX, minY, maxY, lastY;
 
 	for (i = 0; i < ilen; ++i) {
-		index = (startIndex + i) % ilen;
-		point = points[reverse ? ilen - index - 1 : index]._view;
+		const index = (startIndex + i) % ilen;
+		const point = points[reverse ? ilen - index - 1 : index]._view;
 
 		// If point is skipped, we either move to next (not skipped) point
 		// or line to it if spanGaps is true. `move` can already be true.
@@ -117,8 +129,8 @@ function fastPath(ctx, points, line, options) {
 			continue;
 		}
 
-		let {x, y} = point;
-		truncX = x | 0; // truncated x-coordinate
+		const {x, y} = point;
+		const truncX = x | 0; // truncated x-coordinate
 
 		if (move) {
 			ctx.moveTo(x, y);
@@ -210,6 +222,18 @@ function getSegment(segment, points, bounds) {
 	return {start, end, loop};
 }
 
+/**
+ * Returns the sub-segment(s) of a line segment that fall in the given bounds
+ * @param {object} segment
+ * @param {number} segment.start - start index of the segment, referring the points array
+ * @param {number} segment.end - end index of the segment, referring the points array
+ * @param {boolean} segment.loop - indicates that the segment is a loop
+ * @param {Point[]} points - the points that this segment refers to
+ * @param {object} bounds
+ * @param {string} bounds.axis - the axis we are bounding. `x`, `y` or `r`.
+ * @param {number} bounds.start - start value on the axis
+ * @param {number} bounds.end - end value on the axis
+ **/
 export function boundSegment(segment, points, bounds) {
 	if (!bounds) {
 		return [segment];
@@ -252,6 +276,14 @@ export function boundSegment(segment, points, bounds) {
 	return result;
 }
 
+/**
+ * Returns the segments of then line that are inside given bounds
+ * @param {Line} line
+ * @param {object} bounds
+ * @param {string} bounds.axis - the axis we are bounding. `x`, `y` or `r`.
+ * @param {number} bounds.start - start value on the axis
+ * @param {number} bounds.end - end value on the axis
+ */
 export function boundSegments(line, bounds) {
 	const result = [];
 
@@ -278,6 +310,11 @@ function findStart(points, count, loop) {
 	return start % count;
 }
 
+/**
+ * Compute the continuous segments that define the whole line
+ * There can be skipped points within a segment, if spanGaps is true.
+ * @param {Line} line
+ */
 function computeSegments(line) {
 	const points = line.points;
 	const spanGaps = line._view.spanGaps;
@@ -339,19 +376,34 @@ class Line extends Element {
 		return this._segments || (this._segments = computeSegments(this));
 	}
 
+	/**
+	 * First non-skipped point on this line
+	 * @returns {Point|undefined}
+	 */
 	first() {
 		const segments = this.segments;
 		const points = this.points;
 		return segments.length && points[segments[0].start]._view;
 	}
 
+	/**
+	 * Last non-skipped point on this line
+	 * @returns {Point|undefined}
+	 */
 	last() {
 		const segments = this.segments;
 		const points = this.points;
 		const count = segments.length;
 		return count && points[segments[count - 1].end]._view;
 	}
 
+	/**
+	 * Interpolate a point in this line at the same value on `axis` as
+	 * the reference `point` provided
+	 * @param {Point} point - the reference point
+	 * @param {string} axis - the axis to match on
+	 * @returns {Point|undefined}
+	 */
 	interpolate(point, axis) {
 		const me = this;
 		const vm = me._view;
@@ -364,7 +416,7 @@ class Line extends Element {
 		}
 
 		const result = [];
-		const method = getInterpolationMethod(vm);
+		const _interpolate = getInterpolationMethod(vm);
 		let i, ilen;
 		for (i = 0, ilen = segments.length; i < ilen; ++i) {
 			const {start, end} = segments[i];
@@ -375,13 +427,19 @@ class Line extends Element {
 				continue;
 			}
 			const t = Math.abs((value - p1[axis]) / (p2[axis] - p1[axis]));
-			let interpolated = method(p1, p2, t, vm.steppedLine);
+			let interpolated = _interpolate(p1, p2, t, vm.steppedLine);
 			interpolated[axis] = point[axis];
 			result.push(interpolated);
 		}
 		return result.lenght === 1 ? result[0] : result;
 	}
 
+	/**
+	 * Append a segment of this line to current path.
+	 * @param {CanvasRenderingContext2D} ctx
+	 * @param {object} segment
+	 * @param {object} options
+	 */
 	pathSegment(ctx, segment, options) {
 		return pathSegment(ctx, this, segment, options);
 	}